Signaturen generieren

In dieser Anleitung wird erklärt, wie Sie eine Signatur erstellen und welche Felder für Signaturen erforderlich und optional sind.

Um eine Signatur zu erstellen, verfassen Sie eine zu signierende Zeichenfolge, die wir als signierten Wert beschrieben. Der signierte Wert enthält Parameter, die die zu schützenden Inhalte, die Ablaufzeit des signierten Werts usw. beschreiben.

Sie verwenden den signierten Wert beim Erstellen eines Signaturstrings. Zum Erstellen eines Signaturstrings erstellen Sie die Parameter für die Signatur, z. B. eine Signatur mit dem asymmetrischen Schlüssel für Ed25519 des signierten Werts.

Media CDN nutzt die abschließende Signatur, um Ihre Inhalte.

Unterstützte Signaturformate

Media CDN unterstützt die folgenden Formate für signierte Anfragen.

Format	Verhalten	Beispiel
Suchparameter (genaue URL)	Genaue URL zum Gewähren des Zugriffs auf eine bestimmte URL.	Exakt: https://media.example.com/content/manifest.m3u8? Expires=EXPIRATION &KeyName=KEY_NAME &Signature=SIGNATURE
Suchparameter (URL-Präfix)	Durch die Angabe eines URLPrefix können Sie ein Präfix signieren und dieselben Abfrageparameter an mehrere URLs innerhalb Ihres Players oder Ihrer Manifestgenerierung anhängen.	Zu unterschreiben: URLPrefix=PREFIX &Expires=EXPIRATION &KeyName=KEY_NAME &Signature=SIGNATURE Ersetzen Sie PREFIX durch das Präfix, für das Sie Zugriff gewähren möchten, einschließlich Schema, Host und teilweisem Pfad.
Pfadkomponente	Präfix: Ermöglicht den Zugriff auf alle URLs, deren Präfix vor dem Präfix Komponente „"/edge-cache-token=[...]"“. Dadurch können relative Manifest-URLs automatisch den Parameter signierte URL beim Abrufen von Unterressourcen.	https://media.example.com/video/edge-cache-token=Expires=EXPIRATION &KeyName=KEY_NAME &Signature=SIGNATURE/manifest_12382131.m3u8
Signiertes Cookie	Präfix: Das Cookie ermöglicht den Zugriff auf jede URL mit dem angegebenen Präfix. im vorzeichenbehafteten Wert URLPrefix.	Edge-Caching-Cookie: URLPrefix=PREFIX: Expires=EXPIRATION: KeyName=KEY_NAME: Signature=SIGNATURE

Signatur erstellen

Hinweis: Die Host- und Pfadkomponenten der URL (oder des URL-Präfixes) werden zum Validieren von Signaturen verwendet. Wenn Sie eine URL für eine dieser programmatischen APIs angeben, lassen Sie den Port weg. Geben Sie also für einen Pfad wie https://example.com:443/path den Pfad als https://example.com/path an.

1. Erstellen Sie einen signierten Wert, indem Sie einen String verketten, der den Parameter erforderliche Signaturfelder und optionale Signaturfelder.

   Falls angegeben, muss URLPrefix an erster Stelle stehen, gefolgt von Expires, KeyName und dann allen optionalen Parametern.

   Trennen Sie die Felder und Parameter folgendermaßen voneinander:

   • Verwenden Sie für Cookies das Zeichen „:“ :.
   • Verwenden Sie für Suchparameter und Pfadkomponenten ein Et-Zeichen (&) & Zeichen.

2. Signieren Sie den signierten Wert mit einer Ed25519-Signatur.

3. Hängen Sie am Ende des Strings ein Feldtrennzeichen (entweder : oder &) gefolgt von Signature= und der Ed25519-Signatur an.

Signierte URL erstellen

Die folgenden Codebeispiele zeigen, wie Sie eine signierte URL programmatisch erstellen können.

Go

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Media CDN zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import (
	"crypto/ed25519"
	"encoding/base64"
	"fmt"
	"io"
	"strings"
	"time"
)

// signURL prints the signed URL string for the specified URL and configuration.
func signURL(w io.Writer, url, keyName string, privateKey []byte, expires time.Time) error {
	// url := "http://example.com"
	// keyName := "your_key_name"
	// privateKey := "[]byte{34, 31, ...}"
	// expires := time.Unix(1558131350, 0)

	sep := '?'
	if strings.ContainsRune(url, '?') {
		sep = '&'
	}
	toSign := fmt.Sprintf("%s%cExpires=%d&KeyName=%s", url, sep, expires.Unix(), keyName)
	sig := ed25519.Sign(privateKey, []byte(toSign))

	fmt.Fprintf(w, "%s&Signature=%s", toSign, base64.RawURLEncoding.EncodeToString(sig))

	return nil
}

Python

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Media CDN zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import base64
import datetime

import cryptography.hazmat.primitives.asymmetric.ed25519 as ed25519


from six.moves import urllib

def sign_url(
    url: str, key_name: str, base64_key: str, expiration_time: datetime.datetime
) -> str:
    """Gets the Signed URL string for the specified URL and configuration.

    Args:
        url: URL to sign as a string.
        key_name: name of the signing key as a string.
        base64_key: signing key as a base64 encoded byte string.
        expiration_time: expiration time as a UTC datetime object.

    Returns:
        Returns the Signed URL appended with the query parameters based on the
        specified configuration.
    """
    stripped_url = url.strip()
    parsed_url = urllib.parse.urlsplit(stripped_url)
    query_params = urllib.parse.parse_qs(parsed_url.query, keep_blank_values=True)
    epoch = datetime.datetime.utcfromtimestamp(0)
    expiration_timestamp = int((expiration_time - epoch).total_seconds())
    decoded_key = base64.urlsafe_b64decode(base64_key)

    url_pattern = "{url}{separator}Expires={expires}&KeyName={key_name}"

    url_to_sign = url_pattern.format(
        url=stripped_url,
        separator="&" if query_params else "?",
        expires=expiration_timestamp,
        key_name=key_name,
    )

    digest = ed25519.Ed25519PrivateKey.from_private_bytes(decoded_key).sign(
        url_to_sign.encode("utf-8")
    )
    signature = base64.urlsafe_b64encode(digest).decode("utf-8")
    signed_url = "{url}&Signature={signature}".format(
        url=url_to_sign, signature=signature
    )

    return signed_url

Präfix für signierte URL erstellen

Die folgenden Codebeispiele zeigen, wie ein Präfix für signierte URLs programmatisch erstellt wird.

Go

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Media CDN zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import (
	"crypto/ed25519"
	"encoding/base64"
	"fmt"
	"io"
	"strings"
	"time"
)

// signURLPrefix prints the signed URL string for the specified URL prefix and configuration.
func signURLPrefix(w io.Writer, urlPrefix, keyName string, privateKey []byte, expires time.Time) error {
	// urlPrefix := "https://examples.com"
	// keyName := "your_key_name"
	// privateKey := "[]byte{34, 31, ...}"
	// expires := time.Unix(1558131350, 0)

	sep := '?'
	if strings.ContainsRune(urlPrefix, '?') {
		sep = '&'
	}

	toSign := fmt.Sprintf(
		"URLPrefix=%s&Expires=%d&KeyName=%s",
		base64.RawURLEncoding.EncodeToString([]byte(urlPrefix)),
		expires.Unix(),
		keyName,
	)
	sig := ed25519.Sign(privateKey, []byte(toSign))

	fmt.Fprintf(
		w,
		"%s%c%s&Signature=%s",
		urlPrefix,
		sep,
		toSign,
		base64.RawURLEncoding.EncodeToString(sig),
	)

	return nil
}

Python

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Media CDN zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import base64
import datetime

import cryptography.hazmat.primitives.asymmetric.ed25519 as ed25519


from six.moves import urllib

def sign_url_prefix(
    url: str,
    url_prefix: str,
    key_name: str,
    base64_key: str,
    expiration_time: datetime.datetime,
) -> str:
    """Gets the Signed URL string for the specified URL prefix and configuration.

    Args:
        url: URL of request.
        url_prefix: URL prefix to sign as a string.
        key_name: name of the signing key as a string.
        base64_key: signing key as a base64 encoded string.
        expiration_time: expiration time as a UTC datetime object.

    Returns:
        Returns the Signed URL appended with the query parameters based on the
        specified URL prefix and configuration.
    """
    stripped_url = url.strip()
    parsed_url = urllib.parse.urlsplit(stripped_url)
    query_params = urllib.parse.parse_qs(parsed_url.query, keep_blank_values=True)
    encoded_url_prefix = base64.urlsafe_b64encode(
        url_prefix.strip().encode("utf-8")
    ).decode("utf-8")
    epoch = datetime.datetime.utcfromtimestamp(0)
    expiration_timestamp = int((expiration_time - epoch).total_seconds())
    decoded_key = base64.urlsafe_b64decode(base64_key)

    policy_pattern = (
        "URLPrefix={encoded_url_prefix}&Expires={expires}&KeyName={key_name}"
    )
    policy = policy_pattern.format(
        encoded_url_prefix=encoded_url_prefix,
        expires=expiration_timestamp,
        key_name=key_name,
    )

    digest = ed25519.Ed25519PrivateKey.from_private_bytes(decoded_key).sign(
        policy.encode("utf-8")
    )
    signature = base64.urlsafe_b64encode(digest).decode("utf-8")
    signed_url = "{url}{separator}{policy}&Signature={signature}".format(
        url=stripped_url,
        separator="&" if query_params else "?",
        policy=policy,
        signature=signature,
    )
    return signed_url

Cookie für signierte URLs erstellen

Die folgenden Codebeispiele zeigen, wie Sie eine signierte URL programmatisch erstellen können Cookie.

Go

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Media CDN zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import (
	"crypto/ed25519"
	"encoding/base64"
	"fmt"
	"io"
	"time"
)

// signCookie prints the signed cookie value for the specified URL prefix and configuration.
func signCookie(w io.Writer, urlPrefix, keyName string, privateKey []byte, expires time.Time) error {
	// urlPrefix := "http://example.com"
	// keyName := "your_key_name"
	// privateKey := "[]byte{34, 31, ...}"
	// expires := time.Unix(1558131350, 0)

	toSign := fmt.Sprintf(
		"URLPrefix=%s:Expires=%d:KeyName=%s",
		base64.RawURLEncoding.EncodeToString([]byte(urlPrefix)),
		expires.Unix(),
		keyName,
	)
	sig := ed25519.Sign(privateKey, []byte(toSign))

	fmt.Fprintf(
		w,
		"Edge-Cache-Cookie=%s:Signature=%s",
		toSign,
		base64.RawURLEncoding.EncodeToString(sig),
	)

	return nil
}

Python

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Media CDN zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import base64
import datetime

import cryptography.hazmat.primitives.asymmetric.ed25519 as ed25519


from six.moves import urllib

def sign_cookie(
    url_prefix: str, key_name: str, base64_key: str, expiration_time: datetime.datetime
) -> str:
    """Gets the Signed cookie value for the specified URL prefix and configuration.

    Args:
        url_prefix: URL prefix to sign as a string.
        key_name: name of the signing key as a string.
        base64_key: signing key as a base64 encoded string.
        expiration_time: expiration time as a UTC datetime object.

    Returns:
        Returns the Edge-Cache-Cookie value based on the specified configuration.
    """
    encoded_url_prefix = base64.urlsafe_b64encode(
        url_prefix.strip().encode("utf-8")
    ).decode("utf-8")
    epoch = datetime.datetime.utcfromtimestamp(0)
    expiration_timestamp = int((expiration_time - epoch).total_seconds())
    decoded_key = base64.urlsafe_b64decode(base64_key)

    policy_pattern = (
        "URLPrefix={encoded_url_prefix}:Expires={expires}:KeyName={key_name}"
    )
    policy = policy_pattern.format(
        encoded_url_prefix=encoded_url_prefix,
        expires=expiration_timestamp,
        key_name=key_name,
    )

    digest = ed25519.Ed25519PrivateKey.from_private_bytes(decoded_key).sign(
        policy.encode("utf-8")
    )
    signature = base64.urlsafe_b64encode(digest).decode("utf-8")

    signed_policy = "Edge-Cache-Cookie={policy}:Signature={signature}".format(
        policy=policy, signature=signature
    )
    return signed_policy

Signierte Pfadkomponente erstellen

Die folgenden Codebeispiele zeigen, wie Sie einen signierten Pfad programmatisch erstellen Komponente.

Python

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Media CDN zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import base64
import datetime
import hashlib
import hmac

import cryptography.hazmat.primitives.asymmetric.ed25519 as ed25519


def base64_encoder(value: bytes) -> str:
    """
    Returns a base64-encoded string compatible with Media CDN.

    Media CDN uses URL-safe base64 encoding and strips off the padding at the
    end.
    """
    encoded_bytes = base64.urlsafe_b64encode(value)
    encoded_str = encoded_bytes.decode("utf-8")
    return encoded_str.rstrip("=")


def sign_path_component(
    url_prefix: str,
    filename: str,
    key_name: str,
    base64_key: str,
    expiration_time: datetime.datetime,
) -> str:
    """Gets the Signed URL string for the specified URL prefix and configuration.

    Args:
        url_prefix: URL Prefix to sign as a string.
        filename: The filename of the sample request
        key_name: The name of the signing key as a string.
        base64_key: The signing key as a base64 encoded string.
        expiration_time: Expiration time as a UTC datetime object with timezone.

    Returns:
        Returns the Signed URL appended with the query parameters based on the
        specified URL prefix and configuration.
    """

    expiration_duration = expiration_time.astimezone(
        tz=datetime.timezone.utc
    ) - datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)
    decoded_key = base64.urlsafe_b64decode(base64_key)

    policy_pattern = "{url_prefix}edge-cache-token=Expires={expires}&KeyName={key_name}"
    policy = policy_pattern.format(
        url_prefix=url_prefix,
        expires=int(expiration_duration.total_seconds()),
        key_name=key_name,
    )

    digest = ed25519.Ed25519PrivateKey.from_private_bytes(decoded_key).sign(
        policy.encode("utf-8")
    )
    signature = base64_encoder(digest)

    signed_url = "{policy}&Signature={signature}/{filename}".format(
        policy=policy, signature=signature, filename=filename
    )

    return signed_url

Pflichtfelder für Signaturen

Die folgenden Felder sind für jede Signatur erforderlich:

• Expires
• KeyName
• Signature

Wenn Suchparameter vorhanden sind, müssen sie als letzte Parameter in der URL gruppiert werden. Wenn nicht anders angegeben, wird bei Parameternamen und ihren Werten die Groß-/Kleinschreibung beachtet.

In der folgenden Tabelle werden die einzelnen Parameter erläutert:

Feldname	Signaturparameter	Signierter Wert
Expires	Ganzzahlsekunden, die seit der Unix-Epoche verstrichen sind (1970-01-01T00:00:00Z)	Expires=EXPIRATION_TIME, danach ist die Signatur nicht mehr gültig.
KeyName	Der Name der EdgeCacheKeyset, mit der diese Anfrage signiert wurde. KeyName bezieht sich auf das gesamte Keyset und nicht auf einzelne Schlüssel im Schlüsselsatz selbst.	KeyName=EDGE_CACHE_KEYSET
Signature	Eine Base64-codierte Version der Signatur.	Nicht zutreffend

Optionale Signaturfelder

Wenn Suchparameter vorhanden sind, müssen sie als letzte Parameter in der URL. Wenn nicht anders angegeben, wird bei Parameternamen und ihren Werten die Groß-/Kleinschreibung beachtet.

In der folgenden Tabelle werden die Namen und Details der einzelnen Parameter für optionale Signaturparameter:

Feldname	Signaturparameter	Signierter Wert
HeaderName	Ein benanntes Feldname für den Anfrageheader, der im Feld Muss bei der Signatur in Kleinbuchstaben geschrieben werden, da bei Header-Feldnamen die Groß- und Kleinschreibung beachtet wird. Media CDN setzt die Überschrift in Kleinbuchstaben, bevor die Signatur validiert wird.	HeaderName=HEADER_NAME
HeaderValue	Ein benannter Wert für ein Anfrageheader-Feld, der in der Anfrage vorhanden sein muss. In der Regel ist dies eine Nutzer-ID oder eine andere intransparente Kennung. Anfragen mit HeaderValue, aber ohne HeaderName werden abgelehnt.	HeaderValue=HEADER_VALUE
IPRanges	Eine Liste mit bis zu fünf IPv4- und IPv6-Adressen im CIDR-Format für für die diese URL im websicheren Base64-Format gültig ist. Geben Sie beispielsweise IPRanges=MTkyLjYuMTMuMTMvMzIsMTkzLjUuNjQuMTM1LzMy an, um die IP-Bereiche "192.6.13.13/32,193.5.64.135/32" anzugeben. Die Aufnahme von IPRanges in die Signaturen ist möglicherweise nicht sinnvoll, wenn Kunden von WAN-Migrationen bedroht sind oder wenn der Netzwerkpfad zu Ihrem Anwendungs-Frontend ein anderer ist als der Bereitstellungspfad. Media CDN lehnt Kunden mit einem HTTP 403 ab wenn sie eine Verbindung mit einer IP-Adresse herstellen, die nicht Teil des unterzeichnete Anfrage. Die folgenden Fälle können zu Media CDN führen Kunden mit dem Code HTTP 403 ablehnen: Dual-Stack-Umgebungen (IPv4, IPv6) Verbindungsmigration (WLAN zu Mobilfunk und Mobilfunk zu WLAN) Mobilfunknetze, die Carrier Gateway NAT (CGNAT oder CGN) verwenden Multipath-TCP (MPTCP) All diese Faktoren können dazu beitragen, dass ein bestimmter Client während einer Videowiedergabesitzung eine nicht-deterministische IP-Adresse hat. Wenn der Parameter Client-IP-Adresse ändert sich, nachdem Sie Zugriff gewährt haben, und Client versucht, ein Videosegment in die Wiedergabe herunterzuladen. erhält er eine HTTP 403 von Media CDN.	IPRanges=BASE_64_IP_RANGES
URLPrefix	Das Base64-URL-Präfix (URL-sicher), für das Zugriff gewährt werden soll. Durch die Angabe eines URLPrefix können Sie ein Präfix signieren und dieselben Abfrageparameter an mehrere URLs innerhalb Ihres Players oder Ihrer Manifestgenerierung anhängen. Bei Verwendung des signierten Cookies ist die URLPrefix erforderlich Format.	URLPrefix=BASE_64_URL_PREFIX