Servidor de exclusão segura para ambiente de teste PlayReady

Visão geral

O PlayReady Secure Delete Server fornece um ponto de extremidade de teste para validar a funcionalidade de exclusão segura em implementações PlayReady. A Exclusão Segura garante que o conteúdo protegido e as licenças associadas possam ser removidos com segurança dos dispositivos clientes quando necessário, mantendo a proteção de conteúdo e os requisitos de conformidade.

Endereço de Serviço

O servidor de teste Secure Delete está disponível em:

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

Protocolo de exclusão segura

Visão geral do protocolo

A Exclusão Segura permite que os provedores de conteúdo acionem remotamente a exclusão segura de conteúdo e licenças:

1. O provedor de conteúdo determina que a exclusão é necessária
2. O servidor gera o comando de exclusão segura
3. O comando é entregue ao dispositivo cliente
4. O cliente valida e executa a exclusão segura
5. O cliente relata a conclusão da exclusão para o servidor

Fluxo de mensagens

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

Configuração do servidor

Política de exclusão segura

Configure os requisitos de exclusão segura nas licenças:

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

Políticas de exclusão

Defina vários cenários de exclusão:

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

Pontos de extremidade da API

Solicitar exclusão segura

Ponto final:POST /pr/svc/securedelete.asmx/RequestDelete

Formato do pedido:

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
}

Formato de resposta:

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

Status de exclusão de consulta

Ponto final:GET /pr/svc/securedelete.asmx/QueryStatus

Formato do pedido:

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

Formato de resposta:

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

Relatório de Conclusão de Exclusão

Ponto final:POST /pr/svc/securedelete.asmx/ReportCompletion

Formato do pedido:

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

[Secure Delete Completion Report - Binary Format]

Cenários de teste

Teste básico de exclusão segura

Teste o fluxo de exclusão segura padrão:

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

Teste de exclusão baseado em políticas

Teste diferentes políticas de exclusão:

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

Teste de exclusão de lote

Teste a exclusão de vários conteúdos:

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

Integração do Cliente

Implementação 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');

Implementação em 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;
    }
}

Escopos de exclusão

License-Only Eliminação

Remova apenas a licença, mantendo o conteúdo:

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

Exclusão somente de conteúdo

Remova arquivos de conteúdo, preservando a licença:

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

Eliminação completa

Remova a licença e o conteúdo:

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

Considerações de segurança

Autenticação de comando

Os comandos de exclusão segura devem ser autenticados:

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

Requisitos de verificação

Certifique-se de que a exclusão segura seja executada corretamente:

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

Funcionalidades avançadas

Exclusão condicional

Configure gatilhos de exclusão condicional:

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

Capacidade de reversão

Suporte para reversão de exclusão (quando possível):

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

Monitorização e relatórios

Análise de exclusão

Rastreie operações de exclusão segura:

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

Relatórios de conformidade

Gerar relatórios de conformidade para auditoria:

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
}

Melhores práticas

Diretrizes de implementação

1. Verificação: sempre verifique a conclusão da exclusão
2. Logging: Mantenha logs de exclusão detalhados
3. Segurança: use autenticação forte para excluir comandos
4. Recuperação: implemente estratégias de backup apropriadas
5. Testando: teste completamente os cenários de exclusão

Otimização do Desempenho

1. Operações em lote: exclusões relacionadas ao grupo
2. Processamento assíncrono: use a exclusão assíncrona para operações grandes
3. Gerenciamento de recursos: monitore os recursos do sistema durante a exclusão
4. Agendamento: Agendar exclusões durante períodos de baixo uso

Tratamento de erros

Cenários de erro comuns

• Falhas de autenticação: credenciais inválidas ou expiradas
• Conteúdo não encontrado: o conteúdo especificado não existe
• Conflitos de exclusão: conteúdo atualmente em uso
• Erros do sistema: problemas de armazenamento ou rede
• Violações da política: Exclusão não permitida pela política

Recuperação de erros

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

Documentação relacionada

• Serviço do Servidor de Teste PlayReady - Visão geral do serviço principal
• Servidor Secure Stop - Funcionalidade segura relacionada
• Versioned Servers - Informações sobre a versão do servidor
• PlayReady Test Servers - Documentação completa do servidor

Suporte e solução de problemas

Para problemas com a funcionalidade de exclusão segura:

1. Verifique se a exclusão segura está habilitada na licença
2. Verificar o escopo de exclusão e a configuração da política
3. Validar autenticação de comando
4. Monitorar o progresso e o status da exclusão
5. Revise os logs de erros para problemas específicos

Etapas comuns de solução de problemas:

• Teste com cenários de exclusão simplificados
• Verificar a conectividade de rede com o servidor
• Verificar as permissões do dispositivo para exclusão de conteúdo
• Validar assinaturas criptográficas
• Rever conflitos de política

Para obter suporte adicional, consulte a documentação principal dos Servidores de Teste PlayReady .