Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Signaturen generieren

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

Zum Erstellen einer Signatur erstellen Sie einen String, der signiert werden soll. In dieser Anleitung wird er als signierter Wert bezeichnet. Der signierte Wert enthält Parameter, die den Inhalt beschreiben, den Sie schützen, die Ablaufzeit des signierten Werts usw.

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 verwendet die endgültige Signatur, um Ihre Inhalte zu schützen.

Unterstützte Signierungsformate

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

Format	Verhalten	Beispiel
Abfrageparameter (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`
Abfrageparameter (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 signieren: `URLPrefix=PREFIX &Expires=EXPIRATION &KeyName=KEY_NAME &Signature=SIGNATURE` Ersetzen Sie `PREFIX` durch das Präfix, für das Zugriff gewährt werden soll einschließlich Schema, Host und Teilpfad.
Pfadkomponente	Präfix: Ermöglicht den Zugriff auf jede URL mit einem Präfix vor der `"/edge-cache-token=[...]"` Komponente. So können relative Manifest-URLs die signierte URL-Komponente automatisch übernehmen, wenn Unterressourcen abgerufen werden.	`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 Präfix, das im signierten `URLPrefix` Wert angegeben ist.	Edge-Caching-Cookie: `URLPrefix=PREFIX: Expires=EXPIRATION: KeyName=KEY_NAME: Signature=SIGNATURE`

Signatur erstellen

Erstellen Sie einen signierten Wert, indem Sie einen String verketten, der die erforderlichen Signaturfelder und gewünschten optionalen Signaturfelder enthält.

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

Trennen Sie die einzelnen Felder und Parameter mit Folgendem:
- Verwenden Sie für Cookies einen Doppelpunkt :.
- Verwenden Sie für Abfrageparameter und Pfadkomponenten ein kaufmännisches Und-Zeichen &.
Signieren Sie den signierten Wert mit einer Ed25519-Signatur.
Hängen Sie am Ende des Strings ein Feldtrennzeichen (entweder : oder &) gefolgt von Signature= und der Ed25519-Signatur an.

Signierte URL erstellen

Im folgenden Codebeispiel wird gezeigt, wie Sie programmatisch eine signierte URL erstellen.

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

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

Signiertes URL-Präfix erstellen

In den folgenden Codebeispielen wird gezeigt, wie Sie programmatisch ein signiertes URL-Präfix erstellen.

Go

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

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

In den folgenden Codebeispielen wird gezeigt, wie Sie programmatisch ein signiertes URL- Cookie erstellen.

Go

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

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

In den folgenden Codebeispielen wird gezeigt, wie Sie programmatisch eine signierte Pfadkomponente erstellen.

Python

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

Erforderliche Signaturfelder

Die folgenden Felder sind für jede Signatur erforderlich:

Expires
KeyName
Signature

Wenn Abfrageparameter 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 wird jeder 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 des `EdgeCacheKeyset`, der zum Signieren dieser Anfrage verwendet 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

In der folgenden Tabelle werden Name und Details der einzelnen Parameter für optionale Signaturparameter erläutert:

Feldname	Signaturparameter	Signierter Wert
`HeaderName`	Ein benannter Anfrageheader-Feldname, der in der Anfrage vorhanden sein muss. Muss beim Signieren in Kleinbuchstaben angegeben werden, da bei den Namen der Headerfelder die Groß-/Kleinschreibung beachtet wird. Media CDN wandelt den Header in Kleinbuchstaben um, bevor die Signatur validiert wird.	`HeaderName=HEADER_NAME`
`HeaderValue`	Ein benannter Anfrageheader-Feldwert, der in der Anfrage vorhanden sein muss. Dies ist in der Regel eine Nutzer-ID oder eine andere nicht transparente ID. 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 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 Clients mit dem Code `HTTP 403` ab, wenn sie eine Verbindung mit einer IP-Adresse herstellen, die nicht Teil der signierten Anfrage ist. In den folgenden Fällen kann es vorkommen, dass Media CDN Clients mit dem Code `HTTP 403` ablehnt: Dual-Stack-Umgebungen (IPv4, IPv6) Verbindungsmigration (WLAN zu Mobilfunk und Mobilfunk zu WLAN) Mobilfunknetze, die Carrier-Grade NAT (CGNAT oder CGN) verwenden Multi-Path TCP (MPTCP) All diese Faktoren können dazu beitragen, dass ein bestimmter Client während einer Videowiedergabesitzung eine nicht-deterministische IP-Adresse hat. Wenn sich die IP-Adresse des Clients ändert, nachdem Sie den Zugriff gewährt haben, und der Client dann versucht, ein Videosegment in seinen Wiedergabepuffer herunterzuladen, erhält er von Media CDN den Fehler `HTTP 403`.	`IPRanges=BASE_64_IP_RANGES`
`URLPrefix`	Das Base64-codierte (URL-sichere) URL-Präfix, 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. Der `URLPrefix` ist erforderlich, wenn das Format für signierte Cookies verwendet wird.	`URLPrefix=BASE_64_URL_PREFIX`

Signaturen generieren Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Unterstützte Signierungsformate

Signatur erstellen

Signierte URL erstellen

Go

Python

Signiertes URL-Präfix erstellen

Go

Python

Signiertes URL-Cookie erstellen

Go

Python

Signierte Pfadkomponente erstellen

Python

Erforderliche Signaturfelder

Optionale Signaturfelder

Signaturen generieren