Udostępnij przez

Bezpieczny serwer usuwania dla środowiska testowego PlayReady

Przegląd

Serwer bezpiecznego usuwania PlayReady udostępnia testowy punkt końcowy do weryfikowania funkcji bezpiecznego usuwania w implementacjach PlayReady. Bezpieczne usuwanie gwarantuje, że chroniona zawartość i skojarzone licencje mogą zostać bezpiecznie usunięte z urządzeń klienckich, jeśli jest to wymagane, zachowując wymagania dotyczące ochrony zawartości i zgodności.

Punkt końcowy usługi

Serwer testowy Bezpiecznego usuwania jest dostępny pod adresem:

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

Protokół Secure Delete

Omówienie protokołu

Funkcja Secure Delete umożliwia dostawcom zawartości zdalne wyzwalanie bezpiecznego usuwania zawartości i licencji:

  1. Dostawca zawartości określa, że wymagane jest usunięcie
  2. Serwer generuje polecenie bezpiecznego usuwania
  3. Polecenie jest dostarczane do urządzenia klienckiego
  4. Klient weryfikuje i wykonuje bezpieczne usuwanie
  5. Uzupełnianie usuwania raportów klienta na serwerze

Przepływ komunikatów

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

Konfiguracja serwera

Zasady bezpiecznego usuwania

Konfigurowanie wymagań dotyczących bezpiecznego usuwania w licencjach:

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

Zasady usuwania

Definiowanie różnych scenariuszy usuwania:

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

Punkty końcowe interfejsu API

Żądanie bezpiecznego usunięcia

Punkt końcowy:POST /pr/svc/securedelete.asmx/RequestDelete

Format żądania:

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
}

Format odpowiedzi:

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

Stan usuwania zapytania

Punkt końcowy:GET /pr/svc/securedelete.asmx/QueryStatus

Format żądania:

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

Format odpowiedzi:

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

Uzupełnianie usuwania raportu

Punkt końcowy:POST /pr/svc/securedelete.asmx/ReportCompletion

Format żądania:

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

[Secure Delete Completion Report - Binary Format]

Scenariusze testowania

Podstawowe testowanie bezpiecznego usuwania

Przetestuj standardowy bezpieczny przepływ usuwania:

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

Testowanie usuwania oparte na zasadach

Przetestuj różne zasady usuwania:

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

Testowanie usuwania wsadowego

Przetestuj wiele operacji usuwania zawartości:

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

Integracja klienta

Implementacja języka JavaScript

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

Implementacja języka C#

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

Zakresy usuwania

usuwanie License-Only

Usuń tylko licencję, zachowując zawartość:

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

Usuwanie tylko do zawartości

Usuń pliki zawartości przy zachowaniu licencji:

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

Całkowite usunięcie

Usuń zarówno licencję, jak i zawartość:

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

Zagadnienia dotyczące zabezpieczeń

Uwierzytelnianie poleceń

Polecenia bezpiecznego usuwania muszą być uwierzytelnione:

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

Wymagania dotyczące weryfikacji

Upewnij się, że bezpieczne usuwanie zostało prawidłowo wykonane:

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

Funkcje zaawansowane

Usuwanie warunkowe

Konfigurowanie wyzwalaczy usuwania warunkowego:

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

Możliwość wycofywania

Obsługa wycofywania usuwania (jeśli to możliwe):

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

Monitorowanie i raportowanie

Analiza usuwania

Śledzenie operacji bezpiecznego usuwania:

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

Raportowanie zgodności

Generowanie raportów zgodności na potrzeby inspekcji:

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
}

Najlepsze praktyki

Wytyczne dotyczące implementacji

  1. Weryfikacja: zawsze weryfikuj ukończenie usuwania
  2. Rejestrowanie: obsługa szczegółowych dzienników usuwania
  3. Zabezpieczenia: użyj silnego uwierzytelniania do usuwania poleceń
  4. Odzyskiwanie: Implementowanie odpowiednich strategii tworzenia kopii zapasowych
  5. Testowanie: Scenariusze dokładnie testowego usuwania

Optymalizacja wydajności

  1. Operacje wsadowe: usuwanie powiązane z grupą
  2. Przetwarzanie asynchroniczne: użyj usuwania asynchronicznego dla dużych operacji
  3. Zarządzanie zasobami: monitorowanie zasobów systemowych podczas usuwania
  4. Planowanie: Planowanie usuwania w okresach niskiego użycia

Obsługa błędów

Typowe scenariusze błędów

  • Błędy uwierzytelniania: nieprawidłowe lub wygasłe poświadczenia
  • Nie znaleziono zawartości: określona zawartość nie istnieje
  • Konflikty usuwania: zawartość aktualnie używana
  • Błędy systemowe: Problemy z magazynem lub siecią
  • Naruszenia zasad: usuwanie niedozwolone przez zasady

Odzyskiwanie błędu

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

Pomoc techniczna i rozwiązywanie problemów

W przypadku problemów z funkcją bezpiecznego usuwania:

  1. Sprawdzanie, czy bezpieczne usuwanie jest włączone w licencji
  2. Sprawdzanie zakresu usuwania i konfiguracji zasad
  3. Weryfikowanie uwierzytelniania poleceń
  4. Monitorowanie postępu i stanu usuwania
  5. Przejrzyj dzienniki błędów pod kątem konkretnych problemów

Typowe kroki rozwiązywania problemów:

  • Testowanie przy użyciu uproszczonych scenariuszy usuwania
  • Weryfikowanie łączności sieciowej z serwerem
  • Sprawdzanie uprawnień urządzenia do usuwania zawartości
  • Weryfikowanie podpisów kryptograficznych
  • Przeglądanie konfliktów zasad

Aby uzyskać dodatkową pomoc techniczną, zapoznaj się z główną dokumentacją serwerów testowych PlayReady .

  • Last updated on