Secure Delete Server for PlayReady Test Environment

Overzicht

De PlayReady Secure Delete Server biedt een testeindpunt voor het valideren van beveiligde verwijderfunctionaliteit in PlayReady-implementaties. Beveiligd verwijderen zorgt ervoor dat beveiligde inhoud en gekoppelde licenties veilig kunnen worden verwijderd van clientapparaten wanneer dat nodig is, waarbij inhoudsbeveiliging en nalevingsvereisten behouden blijven.

Service-eindpunt

De testserver Secure Delete is beschikbaar op:

https://playready.directtaps.net/pr/svc/securedelete.asmx

Secure Delete Protocol

Protocoloverzicht

Met Secure Delete kunnen inhoudsproviders op afstand beveiligde verwijdering van inhoud en licenties activeren:

1. Inhoudsprovider bepaalt dat verwijdering vereist is
2. Server genereert opdracht voor veilig verwijderen
3. Opdracht wordt geleverd aan clientapparaat
4. Client valideert en voert beveiligde verwijdering uit
5. Voltooiing van verwijdering van clientrapporten naar server

Berichtenstroom

Content Provider       Secure Delete Server        Client Device
       |                        |                        |
       |-- Delete Request ----->|                        |
       |<-- Delete Command -----|                        |
       |                        |-- Push Command ------>|
       |                        |<-- Execution Report ---|
       |<-- Completion Report --|                        |

Serverconfiguratie

Beleid voor veilig verwijderen

Configureer de vereisten voor veilig verwijderen in licenties:

{
  "licenseType": "persistent",
  "keyId": "key-id-guid",
  "secureDelete": {
    "enabled": true,
    "serverUrl": "https://playready.directtaps.net/pr/svc/securedelete.asmx",
    "triggerMechanism": "remote|policy|expiration",
    "deletionScope": "license|content|both",
    "customData": {
      "contentId": "content-identifier",
      "policyId": "deletion-policy-id"
    }
  }
}

Verwijderingsbeleid

Verschillende verwijderingsscenario's definiëren:

{
  "deletionPolicies": [
    {
      "policyId": "immediate-delete",
      "trigger": "remote-command",
      "scope": "both",
      "verification": "required"
    },
    {
      "policyId": "expiration-delete",
      "trigger": "license-expiration",
      "scope": "license",
      "gracePeriod": "PT24H"
    },
    {
      "policyId": "compliance-delete",
      "trigger": "compliance-violation",
      "scope": "content",
      "enforcement": "immediate"
    }
  ]
}

API-eindpunten

Veilig verwijderen aanvragen

Eindpunt:POST /pr/svc/securedelete.asmx/RequestDelete

Aanvraagindeling:

POST /pr/svc/securedelete.asmx/RequestDelete HTTP/1.1
Host: playready.directtaps.net
Content-Type: application/json

{
  "contentId": "content-identifier",
  "deviceId": "target-device-id",
  "deletionScope": "license|content|both",
  "reason": "expiration|violation|request",
  "immediateExecution": true
}

Antwoordindeling:

{
  "deleteCommandId": "command-identifier",
  "status": "queued|sent|acknowledged|completed",
  "timestamp": "2024-01-15T10:30:00Z",
  "estimatedCompletion": "2024-01-15T10:35:00Z"
}

Status van query verwijderen

Eindpunt:GET /pr/svc/securedelete.asmx/QueryStatus

Aanvraagindeling:

GET /pr/svc/securedelete.asmx/QueryStatus?commandId=COMMAND_ID HTTP/1.1
Host: playready.directtaps.net

Antwoordindeling:

{
  "commandId": "command-identifier",
  "status": "pending|in-progress|completed|failed",
  "progress": {
    "itemsToDelete": 5,
    "itemsDeleted": 3,
    "percentComplete": 60
  },
  "completionTime": "2024-01-15T10:35:00Z",
  "errorDetails": null
}

Voltooiing van rapport verwijderen

Eindpunt:POST /pr/svc/securedelete.asmx/ReportCompletion

Aanvraagindeling:

POST /pr/svc/securedelete.asmx/ReportCompletion HTTP/1.1
Host: playready.directtaps.net
Content-Type: application/octet-stream

[Secure Delete Completion Report - Binary Format]

Testscenario's

Eenvoudige test voor veilig verwijderen

Test de standaardstroom voor beveiligd verwijderen:

async function testBasicSecureDelete() {
    // 1. Request secure delete for content
    const deleteRequest = {
        contentId: 'test-content-123',
        deviceId: 'test-device-456',
        deletionScope: 'both',
        reason: 'expiration',
        immediateExecution: true
    };
    
    const response = await requestSecureDelete(deleteRequest);
    
    // 2. Monitor deletion progress
    let status;
    do {
        await new Promise(resolve => setTimeout(resolve, 1000)); // Wait 1 second
        status = await queryDeleteStatus(response.deleteCommandId);
    } while (status.status === 'pending' || status.status === 'in-progress');
    
    return status.status === 'completed';
}

Verwijderingstests op basis van beleid

Test verschillende verwijderingsbeleidsregels:

async function testPolicyBasedDeletion() {
    const policies = [
        {
            name: 'Immediate Delete',
            config: { trigger: 'remote-command', scope: 'both' }
        },
        {
            name: 'Expiration Delete',
            config: { trigger: 'license-expiration', scope: 'license' }
        },
        {
            name: 'Selective Delete',
            config: { trigger: 'compliance-violation', scope: 'content' }
        }
    ];
    
    const results = [];
    for (const policy of policies) {
        try {
            const result = await testDeletionPolicy(policy.config);
            results.push({ policy: policy.name, result: 'PASS' });
        } catch (error) {
            results.push({ policy: policy.name, result: 'FAIL', error: error.message });
        }
    }
    
    return results;
}

Testen van batchverwijdering

Meerdere inhoudsverwijdering testen:

async function testBatchDeletion() {
    const contentItems = [
        'content-001',
        'content-002', 
        'content-003',
        'content-004',
        'content-005'
    ];
    
    // Request batch deletion
    const batchRequest = {
        contentIds: contentItems,
        deviceId: 'test-device-789',
        deletionScope: 'both',
        reason: 'batch-cleanup'
    };
    
    const response = await requestBatchDelete(batchRequest);
    
    // Monitor batch progress
    const finalStatus = await monitorBatchProgress(response.batchCommandId);
    
    return {
        totalItems: contentItems.length,
        successfulDeletions: finalStatus.progress.itemsDeleted,
        failedDeletions: finalStatus.progress.itemsToDelete - finalStatus.progress.itemsDeleted,
        completionTime: finalStatus.completionTime
    };
}

Clientintegratie

JavaScript-implementatie

class SecureDeleteClient {
    constructor(serverUrl) {
        this.serverUrl = serverUrl;
    }
    
    async requestDelete(deleteRequest) {
        const response = await fetch(`${this.serverUrl}/RequestDelete`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(deleteRequest)
        });
        
        if (!response.ok) {
            throw new Error(`Delete request failed: ${response.status}`);
        }
        
        return await response.json();
    }
    
    async queryStatus(commandId) {
        const response = await fetch(`${this.serverUrl}/QueryStatus?commandId=${commandId}`);
        
        if (!response.ok) {
            throw new Error(`Status query failed: ${response.status}`);
        }
        
        return await response.json();
    }
    
    async reportCompletion(completionData) {
        const response = await fetch(`${this.serverUrl}/ReportCompletion`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/octet-stream'
            },
            body: completionData
        });
        
        return response.ok;
    }
}

// Usage
const secureDeleteClient = new SecureDeleteClient('https://playready.directtaps.net/pr/svc/securedelete.asmx');

C#-implementatie

public class SecureDeleteClient
{
    private readonly HttpClient httpClient;
    private readonly string serverUrl;
    
    public SecureDeleteClient(string serverUrl)
    {
        this.serverUrl = serverUrl;
        this.httpClient = new HttpClient();
    }
    
    public async Task<DeleteResponse> RequestDeleteAsync(DeleteRequest request)
    {
        var json = JsonConvert.SerializeObject(request);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        var response = await httpClient.PostAsync($"{serverUrl}/RequestDelete", content);
        response.EnsureSuccessStatusCode();
        
        var responseJson = await response.Content.ReadAsStringAsync();
        return JsonConvert.DeserializeObject<DeleteResponse>(responseJson);
    }
    
    public async Task<DeleteStatus> QueryStatusAsync(string commandId)
    {
        var response = await httpClient.GetAsync($"{serverUrl}/QueryStatus?commandId={commandId}");
        response.EnsureSuccessStatusCode();
        
        var json = await response.Content.ReadAsStringAsync();
        return JsonConvert.DeserializeObject<DeleteStatus>(json);
    }
    
    public async Task<bool> ReportCompletionAsync(byte[] completionData)
    {
        var content = new ByteArrayContent(completionData);
        content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
        
        var response = await httpClient.PostAsync($"{serverUrl}/ReportCompletion", content);
        return response.IsSuccessStatusCode;
    }
}

Verwijderingsbereiken

License-Only verwijderen

Alleen de licentie verwijderen, inhoud behouden:

{
  "deletionScope": "license",
  "preserveContent": true,
  "licenseCleanup": {
    "removeFromStore": true,
    "clearCacheReferences": true,
    "revokeBindings": true
  }
}

Alleen inhoud verwijderen

Inhoudsbestanden verwijderen met behoud van licentie:

{
  "deletionScope": "content",
  "preserveLicense": true,
  "contentCleanup": {
    "removeFiles": true,
    "clearTemporaryFiles": true,
    "cleanupMetadata": true
  }
}

Verwijderen voltooien

Verwijder zowel de licentie als de inhoud:

{
  "deletionScope": "both",
  "thoroughCleanup": true,
  "verification": {
    "confirmLicenseRemoval": true,
    "confirmContentRemoval": true,
    "verifyNoResidualData": true
  }
}

Beveiligingsoverwegingen

Opdrachtverificatie

Beveiligde verwijderopdrachten moeten worden geverifieerd:

{
  "commandAuthentication": {
    "signature": "cryptographic-signature",
    "certificateChain": ["cert1", "cert2"],
    "timestamp": "2024-01-15T10:30:00Z",
    "nonce": "random-value"
  }
}

Verificatievereisten

Zorg ervoor dat beveiligde verwijdering correct wordt uitgevoerd:

{
  "verificationRequirements": {
    "cryptographicProof": true,
    "overwriteVerification": true,
    "witnessReporting": true,
    "tamperDetection": true
  }
}

Geavanceerde functies

Voorwaardelijke verwijdering

Triggers voor voorwaardelijke verwijdering configureren:

{
  "conditionalDeletion": {
    "conditions": [
      {
        "type": "time-based",
        "trigger": "2024-12-31T23:59:59Z"
      },
      {
        "type": "usage-based",
        "trigger": "max-plays-exceeded"
      },
      {
        "type": "location-based",
        "trigger": "geographic-restriction"
      }
    ],
    "logicalOperator": "OR"
  }
}

Mogelijkheid voor terugdraaien

Ondersteuning voor terugdraaien van verwijdering (indien mogelijk):

{
  "rollbackSupport": {
    "enabled": true,
    "retentionPeriod": "PT72H",
    "backupLocation": "secure-backup-store",
    "rollbackConditions": ["deletion-error", "false-positive"]
  }
}

Bewaking en Rapportage

Verwijderingsanalyse

Beveiligde verwijderingsbewerkingen bijhouden:

async function getDeletionAnalytics(period) {
    const response = await fetch(`${serverUrl}/Analytics?period=${period}`);
    return await response.json();
}

// Example response
{
  "period": "24h",
  "totalDeletions": 150,
  "successfulDeletions": 145,
  "failedDeletions": 5,
  "averageExecutionTime": "2.3s",
  "deletionReasons": {
    "expiration": 89,
    "violation": 12,
    "request": 49
  }
}

Nalevingsrapportage

Nalevingsrapporten genereren voor controle:

async function generateComplianceReport(startDate, endDate) {
    const params = new URLSearchParams({
        startDate: startDate.toISOString(),
        endDate: endDate.toISOString(),
        format: 'detailed'
    });
    
    const response = await fetch(`${serverUrl}/ComplianceReport?${params}`);
    return await response.blob(); // Returns PDF report
}

Beste praktijken

Implementatierichtlijnen

1. Verificatie: Altijd controleren of de verwijdering is voltooid
2. Logboekregistratie: gedetailleerde verwijderingslogboeken onderhouden
3. Beveiliging: Sterke verificatie gebruiken voor verwijderopdrachten
4. Herstel: geschikte back-upstrategieën implementeren
5. Testen: Scenario's voor het grondig testen van verwijderingen

Prestatieoptimalisatie

1. Batchbewerkingen: gerelateerde verwijderingen groeperen
2. Asynchrone verwerking: asynchrone verwijdering gebruiken voor grote bewerkingen
3. Resourcebeheer: systeemresources bewaken tijdens het verwijderen
4. Planning: Verwijderingen plannen tijdens perioden met weinig gebruik

Foutafhandeling

Veelvoorkomende foutscenario's

• Verificatiefouten: ongeldige of verlopen referenties
• Inhoud niet gevonden: opgegeven inhoud bestaat niet
• Verwijderingsconflicten: inhoud die momenteel wordt gebruikt
• Systeemfouten: problemen met opslag of netwerk
• Beleidsschendingen: verwijdering is niet toegestaan door beleid

Foutherstel

async function handleDeletionError(commandId, error) {
    switch (error.type) {
        case 'AUTHENTICATION_FAILED':
            // Refresh credentials and retry
            await refreshAuthToken();
            return await retryDeletion(commandId);
            
        case 'CONTENT_IN_USE':
            // Wait and retry
            await waitForContentRelease();
            return await retryDeletion(commandId);
            
        case 'SYSTEM_ERROR':
            // Log error and schedule retry
            await logSystemError(error);
            return await scheduleDeletionRetry(commandId);
            
        default:
            throw new Error(`Unhandled deletion error: ${error.message}`);
    }
}

Verwante documentatie

• PlayReady Test Server-service - Overzicht van de hoofdservice
• Secure Stop Server - Gerelateerde beveiligde functionaliteit
• Versiebeheerservers - Serverversiegegevens
• PlayReady-testservers - Volledige serverdocumentatie

Ondersteuning en probleemoplossing

Voor problemen met de functionaliteit voor veilig verwijderen:

1. Controleren of beveiligd verwijderen is ingeschakeld in licentie
2. Verwijderingsbereik en beleidsconfiguratie controleren
3. Verificatie van de opdracht valideren
4. Voortgang en status van verwijdering controleren
5. Foutenlogboeken bekijken voor specifieke problemen

Algemene stappen voor probleemoplossing:

• Testen met vereenvoudigde verwijderingsscenario's
• Netwerkconnectiviteit met server controleren
• Apparaatmachtigingen controleren op het verwijderen van inhoud
• Cryptografische handtekeningen valideren
• Beleidsconflicten controleren

Raadpleeg de belangrijkste documentatie voor PlayReady-testservers voor aanvullende ondersteuning.