Forensisches Wasserzeichen mit Beacon Apps

Einleitung

Brightcove ist eine Partnerschaft mit NAGRA eingegangen, um Forensic Watermarking mit Beacon-Apps zum Schutz von Premium-Content vor Piraterie und unerlaubter Contentfreigabe anzubieten. Mit dieser Funktion sind die Kunden in der Lage, die Quelle eines Inhaltslecks zu identifizieren und entsprechende Maßnahmen zu ergreifen.

Das folgende Diagramm gibt einen Überblick:

• Inhaltliche Vorbereitung
  • Das forensische Wasserzeichen ist ein unsichtbares Wasserzeichen, das während der Transkodierung mit dem SDK von Nagra in das Video eingebettet wird
  • Bei der Aufnahme werden 2 VOD-Wiedergaben erstellt, eine mit Wasserzeichen A und eine mit Wasserzeichen B; beide Wiedergaben sind Teil desselben Titels in Video Cloud
• Lieferung
  • Bei der Wiedergabe der Inhalte wird das Forensic Watermark-Token dem Player zur Verfügung gestellt und dann in die URL aufgenommen, die für die Anforderung von Inhalten aus dem CDN verwendet wird
  • Das CDN interpretiert das Token und liefert das Video mit der richtigen Reihenfolge der A/B-Segmente an den Betrachter

Voraussetzungen

Die folgenden Anforderungen sind erforderlich, um diese Funktion zu unterstützen:

• Beacon-Anwendungen müssen die OIDC-Authentifizierung verwenden
• Nur für VOD-Assets verfügbar
• MP4-Wiedergaben werden nicht für Videos mit Wasserzeichen erstellt

Einrichtung

Die folgende Einrichtung ist erforderlich, um die forensische Wasserzeichenlösung von Brightcove zu unterstützen:

1. Kundenkonto Video Cloud:
   • Vergewissern Sie sich, dass das Konto des Kunden für die dynamische Zustellung aktiviert ist.
   • Eröffnen Sie ein Support-Ticket , um das Konto des Kunden für Forensic Watermarking zu aktivieren; dies ist ein kostenpflichtiges Add-on zu Video Cloud.
2. Der Kunde erhält seinen Lizenzschlüssel von NAGRA.
3. Der Kunde generiert ein öffentlich-privates Schlüsselpaar, das vom Forensic Watermarking Token (WMT) verwendet und vom CDN entschlüsselt wird. Beispiele finden Sie im folgenden Abschnitt.
4. Der Kunde verwendet das von NAGRA bereitgestellte Skript, um ein Forensic Watermarking Token (WMT) zu erzeugen.
5. Fordern Sie vom Kunden den Namen des Claims an, der das Watermarking Token (WMT) an die Anwendungen weitergeben wird. Teilen Sie diesen Anspruch dem Beacon-Team mit, damit es ihn im Beacon Master CMS konfigurieren kann.

Generieren Sie ein öffentlich-privates Schlüsselpaar

Es gibt viele Möglichkeiten, das öffentlich-private Schlüsselpaar zu generieren. Hier sind einige Beispiele:

Beispiel für ein Bash-Skript:

Beispielskript zum Generieren des Schlüsselpaars:

#!/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"

Führen Sie das Skript aus:

$ 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");

Unterstützte Funktionen und Einschränkungen

Eine Liste der unterstützten Funktionen und Einschränkungen bei der Verwendung von Forensic Watermarking finden Sie in der Übersicht: Dokument zum forensischen Wasserzeichen.