Servidor de Exclusão Segura para o Ambiente de Teste do PlayReady

Visão geral

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

Ponto de extremidade de serviço

O servidor de teste exclusão segura 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 disparem 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 um comando de exclusão segura
3. O comando é entregue ao dispositivo cliente
4. O cliente valida e executa a exclusão segura
5. Conclusão da exclusão de relatórios do cliente 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

Configurar requisitos de exclusão segura em 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 de API

Solicitar exclusão segura

Ponto de extremidade:POST /pr/svc/securedelete.asmx/RequestDelete

Formato da solicitação:

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 de extremidade:GET /pr/svc/securedelete.asmx/QueryStatus

Formato da solicitação:

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
}

Conclusão da exclusão de relatório

Ponto de extremidade:POST /pr/svc/securedelete.asmx/ReportCompletion

Formato da solicitação:

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

Testar 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ítica

Testar políticas de exclusão diferentes:

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 em lote

Testar 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 de Cliente

Implementação do 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 de 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

Exclusão de License-Only

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

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

Exclusão somente conteúdo

Remova arquivos de conteúdo ao preservar a licença:

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

Exclusã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

Verifique se a exclusão segura foi executada corretamente:

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

Recursos avançados

Exclusão condicional

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

Funcionalidade de reversão

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

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

Monitoramento e emissão de relatórios

Análise de Exclusão

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

Práticas recomendadas

Diretrizes de implementação

1. Verificação: sempre verifique a conclusão da exclusão
2. Log: manter logs de exclusão detalhados
3. Segurança: usar autenticação forte para excluir comandos
4. Recuperação: implementar estratégias de backup apropriadas
5. Teste: cenários de exclusão de teste completos

Otimização de desempenho

1. Operações em lote: exclusões relacionadas ao grupo
2. Processamento assíncrono: usar exclusão assíncrona para operações grandes
3. Gerenciamento de Recursos: Monitorar 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 de política: exclusão não permitida pela política

Recuperação de erro

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 de Servidor de Teste do PlayReady – Visão geral do serviço principal
• Servidor de Parada Segura – Funcionalidade segura relacionada
• Servidores com versão – Informações de versão do servidor
• Servidores de Teste do PlayReady – Documentação completa do servidor

Suporte e solução de problemas

Para problemas com a funcionalidade de exclusão segura:

1. Verificar 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. Examinar os logs de erros para problemas específicos

Etapas comuns de solução de problemas:

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

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