Partager via

Secure Stop Server for PlayReady Test Environment

Aperçu

PlayReady Secure Stop Server fournit un point de terminaison de test pour la validation des fonctionnalités d’arrêt sécurisé dans les implémentations PlayReady. L’arrêt sécurisé garantit que les données de suivi de la consommation multimédia sont transmises de manière sécurisée des clients aux fournisseurs de contenu, ce qui permet une surveillance précise de l’utilisation et des rapports de conformité.

Point de terminaison de service

Le serveur de test Secure Stop est disponible à l’adresse suivante :

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

Protocole d’arrêt sécurisé

Vue d’ensemble du protocole

L’arrêt sécurisé permet aux clients de signaler en toute sécurité les informations de fin de session :

  1. Le client commence la session de lecture
  2. La licence spécifie les exigences en matière d’arrêt sécurisé
  3. Le client génère des données d’arrêt sécurisées pendant la lecture
  4. À la fin de la session, le client envoie un rapport d’arrêt sécurisé au serveur
  5. Le serveur valide et accuse réception

Flux de messages

Client                    License Server           Secure Stop Server
  |                            |                           |
  |-- License Request -------->|                           |
  |<-- License Response -------|                           |
  |    (with SecureStop URL)   |                           |
  |                            |                           |
  |    [Playback Session]      |                           |
  |                            |                           |
  |-- Secure Stop Report ------|-------------------------->|
  |<-- Acknowledgment ---------|---------------------------|

Configuration du serveur

Exigences en matière d’arrêt sécurisé

Configurez l’arrêt sécurisé dans les réponses de licence :

{
  "licenseType": "persistent",
  "keyId": "key-id-guid",
  "secureStop": {
    "required": true,
    "serverUrl": "https://playready.directtaps.net/pr/svc/securestop.asmx",
    "reportingFrequency": "session-end",
    "customData": {
      "sessionId": "unique-session-identifier",
      "contentId": "content-identifier"
    }
  }
}

Configuration de la réponse au serveur

Le serveur prend en charge différents modes de réponse pour les tests :

{
  "responseMode": "success|failure|timeout|partial",
  "acknowledgmentDelay": 0,
  "customData": {
    "testScenario": "normal-operation"
  }
}

Points de terminaison d’API

Envoyer un rapport d’arrêt sécurisé

Point de terminaison :POST /pr/svc/securestop.asmx/SubmitReport

Format de la demande :

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

[Secure Stop Report Data - Binary Format]

Format de réponse :

HTTP/1.1 200 OK
Content-Type: application/octet-stream

[Secure Stop Acknowledgment - Binary Format]

État du rapport de requête

Point de terminaison :GET /pr/svc/securestop.asmx/QueryStatus

Format de la demande :

GET /pr/svc/securestop.asmx/QueryStatus?sessionId=SESSION_ID HTTP/1.1
Host: playready.directtaps.net

Format de réponse :

{
  "sessionId": "session-identifier",
  "status": "pending|received|processed|error",
  "timestamp": "2024-01-15T10:30:00Z",
  "reportSize": 1024,
  "processingTime": 50
}

Scénarios de test

Test d’arrêt sécurisé de base

Testez le flux d’arrêt sécurisé normal :

async function testBasicSecureStop() {
    // 1. Acquire license with secure stop requirement
    const license = await acquireLicense({
        keyId: 'test-key-id',
        secureStopRequired: true,
        secureStopUrl: 'https://playready.directtaps.net/pr/svc/securestop.asmx'
    });
    
    // 2. Simulate playback session
    const session = await startPlaybackSession(license);
    
    // 3. End session and generate secure stop report
    const secureStopReport = await endSessionWithSecureStop(session);
    
    // 4. Submit secure stop report
    const response = await submitSecureStopReport(secureStopReport);
    
    return response.acknowledged;
}

Test de gestion des erreurs

Scénarios d’erreur de test :

async function testSecureStopErrorHandling() {
    const testCases = [
        {
            name: 'Invalid Report Format',
            data: generateInvalidReport(),
            expectedError: 'INVALID_FORMAT'
        },
        {
            name: 'Expired Session',
            data: generateExpiredSessionReport(),
            expectedError: 'SESSION_EXPIRED'
        },
        {
            name: 'Duplicate Report',
            data: generateDuplicateReport(),
            expectedError: 'DUPLICATE_REPORT'
        }
    ];
    
    const results = [];
    for (const testCase of testCases) {
        try {
            await submitSecureStopReport(testCase.data);
            results.push({ test: testCase.name, result: 'UNEXPECTED_SUCCESS' });
        } catch (error) {
            results.push({ 
                test: testCase.name, 
                result: error.code === testCase.expectedError ? 'PASS' : 'FAIL' 
            });
        }
    }
    
    return results;
}

Tests de performances

Testez les performances d’arrêt sécurisées :

async function testSecureStopPerformance() {
    const concurrentReports = 10;
    const reports = [];
    
    // Generate multiple secure stop reports
    for (let i = 0; i < concurrentReports; i++) {
        reports.push(generateSecureStopReport(`session-${i}`));
    }
    
    // Submit reports concurrently
    const startTime = Date.now();
    const promises = reports.map(report => submitSecureStopReport(report));
    const results = await Promise.allSettled(promises);
    const endTime = Date.now();
    
    return {
        totalTime: endTime - startTime,
        averageTime: (endTime - startTime) / concurrentReports,
        successCount: results.filter(r => r.status === 'fulfilled').length,
        errorCount: results.filter(r => r.status === 'rejected').length
    };
}

Intégration du client

Implémentation JavaScript

class SecureStopClient {
    constructor(serverUrl) {
        this.serverUrl = serverUrl;
    }
    
    async submitReport(secureStopData) {
        const response = await fetch(`${this.serverUrl}/SubmitReport`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/octet-stream'
            },
            body: secureStopData
        });
        
        if (!response.ok) {
            throw new Error(`Secure stop submission failed: ${response.status}`);
        }
        
        return await response.arrayBuffer();
    }
    
    async queryStatus(sessionId) {
        const response = await fetch(`${this.serverUrl}/QueryStatus?sessionId=${sessionId}`);
        
        if (!response.ok) {
            throw new Error(`Status query failed: ${response.status}`);
        }
        
        return await response.json();
    }
}

// Usage
const secureStopClient = new SecureStopClient('https://playready.directtaps.net/pr/svc/securestop.asmx');

Implémentation C#

public class SecureStopClient
{
    private readonly HttpClient httpClient;
    private readonly string serverUrl;
    
    public SecureStopClient(string serverUrl)
    {
        this.serverUrl = serverUrl;
        this.httpClient = new HttpClient();
    }
    
    public async Task<byte[]> SubmitReportAsync(byte[] secureStopData)
    {
        var content = new ByteArrayContent(secureStopData);
        content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
        
        var response = await httpClient.PostAsync($"{serverUrl}/SubmitReport", content);
        response.EnsureSuccessStatusCode();
        
        return await response.Content.ReadAsByteArrayAsync();
    }
    
    public async Task<SecureStopStatus> QueryStatusAsync(string sessionId)
    {
        var response = await httpClient.GetAsync($"{serverUrl}/QueryStatus?sessionId={sessionId}");
        response.EnsureSuccessStatusCode();
        
        var json = await response.Content.ReadAsStringAsync();
        return JsonConvert.DeserializeObject<SecureStopStatus>(json);
    }
}

Format des données

Structure de rapport d’arrêt sécurisé

Le rapport d’arrêt sécurisé contient les éléments suivants :

  • Identificateur de session : ID de session unique
  • Identificateur de contenu : contenu consommé
  • Données d’utilisation : durée de lecture, qualité, etc.
  • Informations sur l’appareil : détails de l’appareil client
  • Informations d’horodatage : heures de début/de fin de session
  • Signature numérique : preuve de chiffrement d’authenticité

Validation du rapport

Le serveur valide les rapports pour :

  • Intégrité du format : structure binaire correcte
  • Signature numérique : authenticité de chiffrement
  • Validité de session : paramètres de session valides
  • Précision de l’horodatage : valeurs de temps raisonnables
  • Détection dupliquée : prévention des soumissions en double

Fonctionnalités avancées

Prise en charge des données personnalisées

Incluez des données personnalisées dans des rapports d’arrêt sécurisé :

{
  "customData": {
    "contentProvider": "test-provider",
    "userAgent": "PlayReady-Client/4.0",
    "playbackQuality": "HD",
    "geolocation": "US-WEST"
  }
}

Création de rapports par lots

Envoyez plusieurs rapports d’arrêt sécurisés dans une seule requête :

async function submitBatchReports(reports) {
    const batchData = {
        reports: reports,
        batchId: generateBatchId(),
        timestamp: new Date().toISOString()
    };
    
    const response = await fetch(`${serverUrl}/SubmitBatch`, {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify(batchData)
    });
    
    return await response.json();
}

Supervision et analytique

Analyse des rapports

Le serveur de test fournit des points de terminaison d’analyse :

GET /pr/svc/securestop.asmx/Analytics?period=24h

La réponse inclut :

  • Nombre total de rapports reçus
  • Temps de traitement moyen
  • Taux d’erreur par type
  • Distribution géographique
  • Statistiques de version du client

Surveillance de la santé

Surveiller l’intégrité du serveur :

async function checkSecureStopServerHealth() {
    const response = await fetch('https://playready.directtaps.net/pr/svc/securestop.asmx/Health');
    return await response.json();
}

Meilleures pratiques

Mise en œuvre chez le client

  1. Livraison fiable : Implémenter la logique de nouvelle tentative pour les soumissions ayant échoué
  2. Prise en charge hors connexion : rapports de file d’attente lorsque le réseau n’est pas disponible
  3. Validation des données : valider les données de rapport avant la soumission
  4. Gestion des erreurs : Gérer correctement les erreurs du serveur
  5. Confidentialité : Protéger les données sensibles dans les rapports

Recommandations de test

  1. Scénarios complets : Tester des conditions normales et d’erreur
  2. Test des performances : Valider dans des conditions de charge
  3. Conditions réseau : Tester avec différents scénarios réseau
  4. Intégrité des données : vérifier la précision des données du rapport
  5. Test de sécurité : Valider les composants de chiffrement

Support et résolution des problèmes

Pour les problèmes liés à la fonctionnalité d’arrêt sécurisé :

  1. Vérifier que l’arrêt sécurisé est activé dans la licence
  2. Vérifier le format et la structure du rapport
  3. Valider la connectivité réseau au serveur
  4. Passer en revue la réponse du serveur pour obtenir les détails de l’erreur
  5. Tester avec des scénarios simplifiés en premier

Problèmes courants :

  • Erreurs de format de rapport : format ou structure binaire non valide
  • Validation de signature : problèmes de signature de chiffrement
  • Délais d’expiration du réseau : problèmes de connectivité du serveur
  • Expiration de session : rapports envoyés trop tard

Pour obtenir une prise en charge supplémentaire, reportez-vous à la documentation principale des serveurs de test PlayReady .

  • Last updated on