Compartir a través de

Servidor de eliminación segura para el entorno de prueba de PlayReady

Información general

PlayReady Secure Delete Server proporciona un punto de conexión de prueba para validar la funcionalidad de eliminación segura en implementaciones de PlayReady. La eliminación segura garantiza que el contenido protegido y las licencias asociadas se puedan quitar de forma segura de los dispositivos cliente cuando sea necesario, manteniendo los requisitos de cumplimiento y protección de contenido.

Punto de conexión del servicio

El servidor de prueba De eliminación segura está disponible en:

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

Protocolo de eliminación segura

Información general sobre el protocolo

La eliminación segura permite a los proveedores de contenido desencadenar de forma remota la eliminación segura del contenido y las licencias:

  1. El proveedor de contenido determina que se requiere eliminación
  2. El servidor genera un comando de eliminación segura
  3. El comando se entrega al dispositivo cliente
  4. El cliente valida y ejecuta la eliminación segura
  5. Finalización de la eliminación de informes de cliente en el servidor

Flujo de mensajes

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

Configuración del servidor

Directiva de eliminación segura

Configure los requisitos de eliminación segura en las licencias:

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

Directivas de eliminación

Defina varios escenarios de eliminación:

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

Puntos de conexión de API

Solicitud de eliminación segura

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

Formato de solicitud:

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 respuesta:

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

Estado de eliminación de consultas

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

Formato de solicitud:

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

Formato de respuesta:

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

Finalización de eliminación de informes

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

Formato de solicitud:

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

[Secure Delete Completion Report - Binary Format]

Escenarios de prueba

Pruebas básicas de eliminación segura

Prueba del flujo de eliminación segura estándar:

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

Pruebas de eliminación basadas en directivas

Pruebe diferentes directivas de eliminación:

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

Pruebas de eliminación por lotes

Pruebe la eliminación de contenido múltiple:

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

Integración de clientes

Implementación de 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');

Implementación 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;
    }
}

Ámbitos de eliminación

Eliminación de License-Only

Quite solo la licencia y mantenga el contenido:

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

Eliminación solo de contenido

Quite los archivos de contenido al conservar la licencia:

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

Eliminación completa

Quite tanto la licencia como el contenido:

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

Consideraciones de seguridad

Autenticación de comandos

Los comandos de eliminación segura deben autenticarse:

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

Requisitos de comprobación

Asegúrese de que la eliminación segura se ejecuta correctamente:

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

Características avanzadas

Eliminación condicional

Configurar desencadenadores de eliminación 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"
  }
}

Funcionalidad de reversión

Compatibilidad con la reversión de eliminación (siempre que sea posible):

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

Supervisión e informes

Análisis de eliminación

Realizar un seguimiento de las operaciones de eliminación 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
  }
}

Informes de cumplimiento

Generación de informes de cumplimiento para la auditoría:

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
}

Procedimientos recomendados

Directrices de implementación

  1. Comprobación: comprobar siempre la finalización de la eliminación
  2. Registro: mantenimiento de registros de eliminación detallados
  3. Seguridad: uso de la autenticación segura para los comandos de eliminación
  4. Recuperación: Implementación de estrategias de copia de seguridad adecuadas
  5. Pruebas: escenarios de eliminación de pruebas exhaustivas

Optimización del rendimiento

  1. Operaciones por lotes: eliminaciones relacionadas con el grupo
  2. Procesamiento asincrónico: uso de la eliminación asincrónica para operaciones grandes
  3. Administración de recursos: Supervisión de los recursos del sistema durante la eliminación
  4. Programación: programar eliminaciones durante períodos de uso bajo

Tratamiento de errores

Escenarios de error comunes

  • Errores de autenticación: credenciales no válidas o expiradas
  • Contenido no encontrado: el contenido especificado no existe
  • Conflictos de eliminación: contenido actualmente en uso
  • Errores del sistema: problemas de almacenamiento o de red
  • Infracciones de directiva: eliminación no permitida por la directiva

Recuperación de errores

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

Soporte técnico y solución de problemas

Para problemas con la funcionalidad de eliminación segura:

  1. Comprobación de que la eliminación segura está habilitada en la licencia
  2. Comprobación del ámbito de eliminación y la configuración de directivas
  3. Validación de la autenticación de comandos
  4. Supervisión del progreso y el estado de eliminación
  5. Revisión de los registros de errores para problemas específicos

Pasos comunes de solución de problemas:

  • Prueba con escenarios de eliminación simplificada
  • Comprobación de la conectividad de red con el servidor
  • Comprobación de los permisos de dispositivo para la eliminación de contenido
  • Validación de firmas criptográficas
  • Revisión de conflictos de directivas

Para obtener soporte adicional, consulte la documentación principal de los servidores de prueba de PlayReady .

  • Last updated on