Marca de agua forense con Beacon Apps

Introducción

Brightcove se ha asociado con NAGRA para proporcionar marcas de agua forenses con aplicaciones Beacon para ayudar a proteger el contenido premium de la piratería y el intercambio de contenido no autorizado. Con esta característica, los clientes podrán identificar la fuente de una fuga de contenido y tomar las medidas adecuadas.

El siguiente diagrama muestra una descripción general:

• preparación de contenido
  • La marca de agua forense es una marca de agua invisible incrustada en el video durante la transcodificación con el SDK de Nagra.
  • La ingestión crea 2 representaciones de VOD, una con marca de agua A y otra con marca de agua B; ambas versiones son parte del mismo título en Video Cloud
• Entrega
  • Al reproducir el contenido, el token de Forensic Watermark se proporciona al reproductor y luego se incluye en la URL utilizada para solicitar contenido de la CDN.
  • La CDN interpreta el token y entrega el video con la secuencia correcta de segmentos A/B al espectador.

Requisitos

Se necesitan los siguientes requisitos para admitir esta función:

• Las aplicaciones Beacon necesitan usar la autenticación OIDC
• Solo disponible para activos VOD
• No se generarán representaciones MP4 para videos con marca de agua

Configuración

Se necesita la siguiente configuración para admitir la solución de marca de agua forense de Brightcove:

1. Cuenta de Video Cloud del cliente:
   • Asegúrese de que la cuenta del cliente esté habilitada para Dynamic Delivery.
   • Abra un ticket de atención al cliente para habilitar la cuenta del cliente para la marca de agua forense; Este es un complemento de pago de Video Cloud.
2. El cliente obtendrá su clave de licencia de NAGRA .
3. El cliente generará un par de claves pública-privada que utilizará el token de marca de agua forense (WMT) y que la CDN descifrará. Para ver ejemplos, consulte la sección a continuación.
4. El cliente utilizará el script proporcionado por NAGRA para generar un token de marca de agua forense (WMT).
5. Solicite al cliente el nombre del reclamo que pasará el token de marca de agua (WMT) a las aplicaciones. Comparta este reclamo con el equipo de Beacon, para que puedan configurarlo en Beacon Master CMS.

Generar un par de claves pública-privada

Hay muchas formas de generar el par de claves pública-privada. Aquí hay unos ejemplos:

Ejemplo de script de bash:

Script de ejemplo para generar el par de claves:

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

Ejecute el 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");

Características y limitaciones admitidas

Para obtener una lista de las funciones y limitaciones admitidas al usar la marca de agua forense, consulte la descripción general: Documento de marca de agua forense.