Filigrane judiciaire avec Beacon Apps

Introduction

Brightcove s'est associé à NAGRA pour fournir un filigrane judiciaire avec des applications Beacon afin de protéger les contenus de qualité supérieure contre le piratage et le partage de contenu non autorisé. Grâce à cette fonction, les clients pourront identifier la source d'une fuite de contenu et prendre les mesures qui s'imposent.

Le diagramme suivant en donne une vue d'ensemble :

• Préparation du contenu
  • Le Forensic Watermark est un filigrane invisible incorporé dans la vidéo lors du transcodage à l'aide du SDK de Nagra
  • L'ingestion crée 2 rendus VOD, l'un avec le filigrane A et l'autre avec le filigrane B ; les deux rendus font partie du même titre dans le nuage vidéo
• Livraison
  • Lors de la lecture du contenu, le jeton Forensic Watermark est fourni au lecteur, puis inclus dans l'URL utilisée pour demander le contenu au CDN
  • Le CDN interprète le jeton et diffuse la vidéo avec la bonne séquence de segments A/B au spectateur

Exigences

Les exigences suivantes sont nécessaires pour prendre en charge cette fonctionnalité :

• Les applications Beacon doivent utiliser l'authentification OIDC
• Uniquement disponible pour la VOD
• Les rendus MP4 ne seront pas générés pour les vidéos en filigrane

Configuration

La configuration suivante est nécessaire pour prendre en charge la solution Forensic Watermarking de Brightcove :

1. Compte Video Cloud du client :
   • Assurez-vous que le compte du client est activé pour la livraison dynamique.
   • Ouvrez un ticket d'assistance à la clientèle pour activer le compte du client pour le filigranage judiciaire ; il s'agit d'une extension payante de Video Cloud.
2. Le client recevra sa clé de licence de NAGRA.
3. Le client génère une paire de clés publique-privée qui sera utilisée par le jeton de filigrane judiciaire (WMT) et décryptée par le CDN. Pour des exemples, voir la section ci-dessous.
4. Le client utilisera le script fourni par NAGRA pour générer un jeton de filigrane judiciaire (WMT).
5. Le client doit indiquer le nom de la demande qui transmettra le jeton de filigrane (WMT) aux applications. Partagez cette demande avec l'équipe Beacon, afin qu'elle puisse la configurer dans le CMS principal de Beacon.

Générer une paire de clés publique-privée

Il existe de nombreuses façons de générer la paire de clés publique-privée. Voici quelques exemples:

Exemple de script bash :

Exemple de script pour générer la paire de clés :

#!/bin/bash
set -euo pipefail

NAME=${1:-}
test -z "${NAME:-}" && NAME="brightcove-forensic-watermarking-key-$(date +%s)"
mkdir "$NAME"

PRIVATE_PEM="./$NAME/private.pem"
PUBLIC_PEM="./$NAME/public.pem"
PUBLIC_TXT="./$NAME/public_key.txt"

ssh-keygen -t rsa -b 2048 -m PEM -f "$PRIVATE_PEM" -q -N ""
openssl rsa -in "$PRIVATE_PEM" -pubout -outform PEM -out "$PUBLIC_PEM" 2>/dev/null
openssl rsa -in "$PRIVATE_PEM" -pubout -outform DER | base64 > "$PUBLIC_TXT"

rm "$PRIVATE_PEM".pub

echo "Public key to saved in $PUBLIC_TXT"

Exécutez le script :

$ bash keygen.sh

package main
  
  import (
    "crypto/rand"
    "crypto/rsa"
    "crypto/x509"
    "encoding/base64"
    "encoding/pem"
    "flag"
    "fmt"
    "io/ioutil"
    "os"
    "path"
    "strconv"
    "time"
  )
  
  func main() {
    var out string
  
    flag.StringVar(&out, "output-dir", "", "Output directory to write files into")
    flag.Parse()
  
    if out == "" {
      out = "rsa-key_" + strconv.FormatInt(time.Now().Unix(), 10)
    }
  
    if err := os.MkdirAll(out, os.ModePerm); err != nil {
      panic(err.Error())
    }
  
    priv, err := rsa.GenerateKey(rand.Reader, 2048)
    if err != nil {
      panic(err.Error())
    }
  
    privBytes := x509.MarshalPKCS1PrivateKey(priv)
  
    pubBytes, err := x509.MarshalPKIXPublicKey(priv.Public())
    if err != nil {
      panic(err.Error())
    }
  
    privOut, err := os.OpenFile(path.Join(out, "private.pem"), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
    if err != nil {
      panic(err.Error())
    }
  
    if err := pem.Encode(privOut, &pem.Block{Type: "RSA PRIVATE KEY", Bytes: privBytes}); err != nil {
      panic(err.Error())
    }
  
    pubOut, err := os.OpenFile(path.Join(out, "public.pem"), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
    if err != nil {
      panic(err.Error())
    }
  
    if err := pem.Encode(pubOut, &pem.Block{Type: "PUBLIC KEY", Bytes: pubBytes}); err != nil {
      panic(err.Error())
    }
  
    var pubEnc = base64.StdEncoding.EncodeToString(pubBytes)
  
    var pubEncOut = path.Join(out, "public_key.txt")
    if err := ioutil.WriteFile(pubEncOut, []byte(pubEnc+"\n"), 0600); err != nil {
      panic(err.Error())
    }
  
    fmt.Println("Public key saved in " + pubEncOut)
  }
  

var crypto = require("crypto");
  var fs = require("fs");
  
  var now = Math.floor(new Date() / 1000);
  var dir = "rsa-key_" + now;
  fs.mkdirSync(dir);
  
  crypto.generateKeyPair(
    "rsa",
    {modulusLength: 2048},
    (err, publicKey, privateKey) => {
      fs.writeFile(
        dir + "/public.pem",
        publicKey.export({ type: "spki", format: "pem" }),
        err => {}
      );
      fs.writeFile(
        dir + "/public_key.txt",
        publicKey.export({ type: "spki", format: "der" }).toString("base64") +
          "\n",
        err => {}
      );
      fs.writeFile(
        dir + "/private.pem",
        privateKey.export({ type: "pkcs1", format: "pem" }),
        err => {}
      );
    }
  );
  
  console.log("Public key saved in " + dir + "/public_key.txt");

Fonctionnalités et limitations prises en charge

Pour obtenir une liste des fonctions prises en charge et des limitations lors de l'utilisation de Forensic Watermarking, voir la vue d'ensemble: Document de filigrane médico-légal.