Freigeben über

Sicherer Löschserver für PlayReady-Testumgebung

Überblick

Der PlayReady Secure Delete Server stellt einen Testendpunkt für die Überprüfung der Funktion für sicheres Löschen in PlayReady-Implementierungen bereit. Durch sicheres Löschen wird sichergestellt, dass geschützte Inhalte und zugehörige Lizenzen bei Bedarf sicher von Clientgeräten entfernt werden können, wobei der Schutz von Inhalten und die Complianceanforderungen beibehalten werden.

Dienstendpunkt

Der Testserver für sicheres Löschen ist verfügbar unter:

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

Protokoll für sicheres Löschen

Protokollübersicht

Secure Delete ermöglicht Inhaltsanbietern das Remote-Auslösen der sicheren Löschung von Inhalten und Lizenzen:

  1. Inhaltsanbieter bestimmt, dass das Löschen erforderlich ist.
  2. Server generiert Befehl zum sicheren Löschen
  3. Der Befehl wird an das Clientgerät übermittelt.
  4. Client überprüft und führt sichere Löschung aus.
  5. Abschluss des Löschvorgangs für Clientberichte auf dem Server

Nachrichtenfluss

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

Serverkonfiguration

Richtlinie für sicheres Löschen

Konfigurieren von Anforderungen für sicheres Löschen in Lizenzen:

{
  "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"
    }
  }
}

Löschrichtlinien

Definieren verschiedener Löschszenarien:

{
  "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-Endpunkte

Sicheres Löschen anfordern

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

Anforderungsformat:

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
}

Antwortformat:

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

Abfragelöschstatus

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

Anforderungsformat:

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

Antwortformat:

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

Abschluss des Berichtslöschvorgangs

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

Anforderungsformat:

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

[Secure Delete Completion Report - Binary Format]

Testszenarien

Grundlegende Tests für sicheres Löschen

Testen sie standardmäßigen sicheren Löschfluss:

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';
}

Richtlinienbasierte Löschtests

Testen verschiedener Löschrichtlinien:

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;
}

Batchlöschtests

Testen sie mehrere Inhaltslöschvorgänge:

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
    };
}

Clientintegration

JavaScript-Implementierung

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#-Implementierung

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;
    }
}

Löschbereiche

License-Only Löschen

Entfernen Sie nur die Lizenz, und behalten Sie Inhalte bei:

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

Nur Inhaltslöschung

Entfernen von Inhaltsdateien beim Beibehalten der Lizenz:

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

Löschvorgang abgeschlossen

Lizenz und Inhalt entfernen:

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

Sicherheitsüberlegungen

Befehlsauthentifizierung

Befehle zum sicheren Löschen müssen authentifiziert werden:

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

Überprüfungsanforderungen

Stellen Sie sicher, dass der sichere Löschvorgang ordnungsgemäß ausgeführt wird:

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

Erweiterte Funktionen

Bedingte Löschung

Konfigurieren von bedingte Löschungstriggern:

{
  "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"
  }
}

Rollbackfunktion

Unterstützung für den Löschrollback (sofern möglich):

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

Überwachung und Berichterstellung

Löschanalyse

Nachverfolgen sicherer Löschvorgänge:

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
  }
}

Complianceberichterstattung

Generieren von Complianceberichten für die Überwachung:

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
}

Bewährte Methoden

Implementierungsrichtlinien

  1. Überprüfung: Löschvorgang immer überprüfen
  2. Protokollierung: Verwalten detaillierter Löschprotokolle
  3. Sicherheit: Verwenden einer starken Authentifizierung für Löschbefehle
  4. Wiederherstellung: Implementieren geeigneter Sicherungsstrategien
  5. Tests: Gründliches Testen von Löschszenarien

Leistungsoptimierung

  1. Batchvorgänge: Gruppieren verwandter Löschungen
  2. Asynchrone Verarbeitung: Verwenden des asynchronen Löschens für große Vorgänge
  3. Ressourcenverwaltung: Überwachen von Systemressourcen während des Löschens
  4. Terminplanung: Planen von Löschungen während geringer Nutzungszeiträume

Fehlerbehandlung

Häufige Fehlerszenarien

  • Authentifizierungsfehler: Ungültige oder abgelaufene Anmeldeinformationen
  • Inhalt nicht gefunden: Der angegebene Inhalt ist nicht vorhanden.
  • Löschkonflikte: Aktuell verwendeter Inhalt
  • Systemfehler: Speicher- oder Netzwerkprobleme
  • Richtlinienverstöße: Löschung durch Richtlinie nicht zulässig

Fehlerwiederherstellung

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}`);
    }
}

Support und Problembehandlung

Für Probleme mit sicherer Löschfunktionalität:

  1. Überprüfen, ob die sichere Löschung in der Lizenz aktiviert ist
  2. Überprüfen des Löschbereichs und der Richtlinienkonfiguration
  3. Überprüfen der Befehlsauthentifizierung
  4. Überwachen des Löschfortschritts und des Status
  5. Überprüfen von Fehlerprotokollen für bestimmte Probleme

Häufige Schritte zur Problembehandlung:

  • Testen mit vereinfachten Löschszenarien
  • Überprüfen der Netzwerkkonnektivität mit dem Server
  • Überprüfen von Geräteberechtigungen für das Löschen von Inhalten
  • Überprüfen kryptografischer Signaturen
  • Überprüfen von Richtlinienkonflikten

Weitere Unterstützung finden Sie in der Hauptdokumentation zu PlayReady-Testservern .

  • Last updated on