生成令牌

本指南介绍了如何生成令牌，以及令牌的必填字段和选填字段。

如需创建令牌，您需要编写一个要签名的字符串，在本指南中，我们将其称为“签名值” 。签名值包含用于描述您要保护的内容、签名值的到期时间等的参数。

您可以在创建令牌字符串时使用签名值。您可以通过编写令牌的参数（例如签名值的对称密钥哈希消息身份验证代码 (HMAC)）来创建令牌字符串。

Media CDN 使用最终编写的令牌来帮助保护您的内容。

创建令牌

1. 通过串联包含 必填令牌字段和所需选填令牌 字段的字符串来创建签名值。使用波浪号 ~ 字符分隔每个字段和任何参数。

2. 使用 Ed25519 签名或 对称密钥 HMAC 对签名值进行签名。

3. 通过串联包含必填令牌字段和选填令牌字段的字符串来编写令牌。使用波浪号 ~ 字符分隔每个字段和任何参数。

   编写令牌时，签名值和令牌字符串中每个参数的值相同，但以下情况除外：

   • FullPath
   • Headers

以下代码示例展示了如何以编程方式创建令牌：

Python

如需向 Media CDN 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅 为本地开发环境设置身份验证。

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_token(
    base64_key: bytes,
    signature_algorithm: str,
    start_time: datetime.datetime = None,
    expiration_time: datetime.datetime = None,
    url_prefix: str = None,
    full_path: str = None,
    path_globs: str = None,
    session_id: str = None,
    data: str = None,
    headers: str = None,
    ip_ranges: str = None,
) -> str:
    """Gets the Signed URL Suffix string for the Media CDN' Short token URL requests.
    One of (`url_prefix`, `full_path`, `path_globs`) must be included in each input.
    Args:
        base64_key: Secret key as a base64 encoded string.
        signature_algorithm: Algorithm can be either `SHA1` or `SHA256` or `Ed25519`.
        start_time: Start time as a UTC datetime object.
        expiration_time: Expiration time as a UTC datetime object. If None, an expiration time 1 hour from now will be used.
        url_prefix: the URL prefix to sign, including protocol.
                    For example: http://example.com/path/ for URLs under /path or http://example.com/path?param=1
        full_path:  A full path to sign, starting with the first '/'.
                    For example: /path/to/content.mp4
        path_globs: a set of ','- or '!'-delimited path glob strings.
                    For example: /tv/*!/film/* to sign paths starting with /tv/ or /film/ in any URL.
        session_id: a unique identifier for the session
        data: data payload to include in the token
        headers: header name and value to include in the signed token in name=value format.  May be specified more than once.
                    For example: [{'name': 'foo', 'value': 'bar'}, {'name': 'baz', 'value': 'qux'}]
        ip_ranges: A list of comma separated ip ranges. Both IPv4 and IPv6 ranges are acceptable.
                    For example: "203.0.113.0/24,2001:db8:4a7f:a732/64"

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

    decoded_key = base64.urlsafe_b64decode(base64_key)
    algo = signature_algorithm.lower()

    # For most fields, the value we put in the token and the value we must sign
    # are the same.  The FullPath and Headers use a different string for the
    # value to be signed compared to the token.  To illustrate this difference,
    # we'll keep the token and the value to be signed separate.
    tokens = []
    to_sign = []

    # check for `full_path` or `path_globs` or `url_prefix`
    if full_path:
        tokens.append("FullPath")
        to_sign.append(f"FullPath={full_path}")
    elif path_globs:
        path_globs = path_globs.strip()
        field = f"PathGlobs={path_globs}"
        tokens.append(field)
        to_sign.append(field)
    elif url_prefix:
        field = "URLPrefix=" + base64_encoder(url_prefix.encode("utf-8"))
        tokens.append(field)
        to_sign.append(field)
    else:
        raise ValueError(
            "User Input Missing: One of `url_prefix`, `full_path` or `path_globs` must be specified"
        )

    # check & parse optional params
    if start_time:
        epoch_duration = start_time.astimezone(
            tz=datetime.timezone.utc
        ) - datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)
        field = f"Starts={int(epoch_duration.total_seconds())}"
        tokens.append(field)
        to_sign.append(field)

    if not expiration_time:
        expiration_time = datetime.datetime.now() + datetime.timedelta(hours=1)
        epoch_duration = expiration_time.astimezone(
            tz=datetime.timezone.utc
        ) - datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)
    else:
        epoch_duration = expiration_time.astimezone(
            tz=datetime.timezone.utc
        ) - datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)
    field = f"Expires={int(epoch_duration.total_seconds())}"
    tokens.append(field)
    to_sign.append(field)

    if session_id:
        field = f"SessionID={session_id}"
        tokens.append(field)
        to_sign.append(field)

    if data:
        field = f"Data={data}"
        tokens.append(field)
        to_sign.append(field)

    if headers:
        header_names = []
        header_pairs = []
        for each in headers:
            header_names.append(each["name"])
            header_pairs.append("%s=%s" % (each["name"], each["value"]))
        tokens.append(f"Headers={','.join(header_names)}")
        to_sign.append(f"Headers={','.join(header_pairs)}")

    if ip_ranges:
        field = f"IPRanges={base64_encoder(ip_ranges.encode('ascii'))}"
        tokens.append(field)
        to_sign.append(field)

    # generating token
    to_sign = "~".join(to_sign)
    to_sign_bytes = to_sign.encode("utf-8")
    if algo == "ed25519":
        digest = ed25519.Ed25519PrivateKey.from_private_bytes(decoded_key).sign(
            to_sign_bytes
        )
        tokens.append("Signature=" + base64_encoder(digest))
    elif algo == "sha256":
        signature = hmac.new(
            decoded_key, to_sign_bytes, digestmod=hashlib.sha256
        ).hexdigest()
        tokens.append("hmac=" + signature)
    elif algo == "sha1":
        signature = hmac.new(
            decoded_key, to_sign_bytes, digestmod=hashlib.sha1
        ).hexdigest()
        tokens.append("hmac=" + signature)
    else:
        raise ValueError(
            "Input Missing Error: `signature_algorithm` can only be one of `sha1`, `sha256` or `ed25519`"
        )
    return "~".join(tokens)

Java

如需向 Media CDN 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅 为本地开发环境设置身份验证。

import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.time.Instant;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;
import java.util.Optional;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters;
import org.bouncycastle.crypto.signers.Ed25519Signer;
import org.bouncycastle.util.encoders.Hex;

public class DualToken {

  public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeyException {
    // TODO(developer): Replace these variables before running the sample.
    // Secret key as a base64 encoded string.
    byte[] base64Key = new byte[]{};
    // Algorithm can be one of these: SHA1, SHA256, or Ed25519.
    String signatureAlgorithm = "ed25519";
    // (Optional) Start time as a UTC datetime object.
    DateTimeFormatter formatter = DateTimeFormatter.ISO_INSTANT;
    Optional<Instant> startTime = Optional.empty();
    // Expiration time as a UTC datetime object.
    // If None, an expiration time that's an hour after the current time is used.
    Instant expiresTime = Instant.from(formatter.parse("2022-09-13T12:00:00Z"));

    // ONE OF (`urlPrefix`, `fullPath`, `pathGlobs`) must be included in each input.
    // The URL prefix and protocol to sign.
    // For example: http://example.com/path/ for URLs under /path or http://example.com/path?param=1
    Optional<String> urlPrefix = Optional.empty();
    // A full path to sign, starting with the first '/'.
    // For example: /path/to/content.mp4
    Optional<String> fullPath = Optional.of("http://10.20.30.40/");
    // A set of path glob strings delimited by ',' or '!'.
    // For example: /tv/*!/film/* to sign paths starting with /tv/ or /film/ in any URL.
    Optional<String> pathGlobs = Optional.empty();

    // (Optional) A unique identifier for the session.
    Optional<String> sessionId = Optional.empty();
    // (Optional) Data payload to include in the token.
    Optional<String> data = Optional.empty();
    // (Optional) Header name and value to include in the signed token in name=value format.
    // May be specified more than once.
    // For example: [{'name': 'foo', 'value': 'bar'}, {'name': 'baz', 'value': 'qux'}]
    Optional<List<Header>> headers = Optional.empty();
    // (Optional) A list of comma-separated IP ranges. Both IPv4 and IPv6 ranges are acceptable.
    // For example: "203.0.113.0/24,2001:db8:4a7f:a732/64"
    Optional<String> ipRanges = Optional.empty();

    DualToken.signToken(
        base64Key,
        signatureAlgorithm,
        startTime,
        expiresTime,
        urlPrefix,
        fullPath,
        pathGlobs,
        sessionId,
        data,
        headers,
        ipRanges);
  }

  // Gets the signed URL suffix string for the Media CDN short token URL requests.
  // Result:
  //     The signed URL appended with the query parameters based on the
  // specified URL prefix and configuration.
  public static void signToken(
      byte[] base64Key, String signatureAlgorithm, Optional<Instant> startTime,
      Instant expirationTime, Optional<String> urlPrefix, Optional<String> fullPath,
      Optional<String> pathGlobs, Optional<String> sessionId, Optional<String> data,
      Optional<List<Header>> headers, Optional<String> ipRanges)
      throws NoSuchAlgorithmException, InvalidKeyException {

    String field = "";
    byte[] decodedKey = Base64.getUrlDecoder().decode(base64Key);

    // For most fields, the value in the token and the value to sign
    // are the same. Compared to the token, the FullPath and Headers
    // use a different string for the value to sign. To illustrate this difference,
    // we'll keep the token and the value to be signed separate.
    List<String> tokens = new ArrayList<>();
    List<String> toSign = new ArrayList<>();

    // Check for `fullPath` or `pathGlobs` or `urlPrefix`.
    if (fullPath.isPresent()) {
      tokens.add("FullPath");
      toSign.add(String.format("FullPath=%s", fullPath.get()));
    } else if (pathGlobs.isPresent()) {
      field = String.format("PathGlobs=%s", pathGlobs.get().trim());
      tokens.add(field);
      toSign.add(field);
    } else if (urlPrefix.isPresent()) {
      field = String.format("URLPrefix=%s",
          base64Encoder(urlPrefix.get().getBytes(StandardCharsets.UTF_8)));
      tokens.add(field);
      toSign.add(field);
    } else {
      throw new IllegalArgumentException(
          "User Input Missing: One of `urlPrefix`, `fullPath` or `pathGlobs` must be specified");
    }

    // Check & parse optional params.
    long epochDuration;
    if (startTime.isPresent()) {
      epochDuration = ChronoUnit.SECONDS.between(Instant.EPOCH, startTime.get());
      field = String.format("Starts=%s", epochDuration);
      tokens.add(field);
      toSign.add(field);
    }

    if (expirationTime == null) {
      expirationTime = Instant.now().plus(1, ChronoUnit.HOURS);
    }
    epochDuration = ChronoUnit.SECONDS.between(Instant.EPOCH, expirationTime);
    field = String.format("Expires=%s", epochDuration);
    tokens.add(field);
    toSign.add(field);

    if (sessionId.isPresent()) {
      field = String.format("SessionID=%s", sessionId.get());
      tokens.add(field);
      toSign.add(field);
    }

    if (data.isPresent()) {
      field = String.format("Data=%s", data.get());
      tokens.add(field);
      toSign.add(field);
    }

    if (headers.isPresent()) {
      List<String> headerNames = new ArrayList<>();
      List<String> headerPairs = new ArrayList<>();

      for (Header entry : headers.get()) {
        headerNames.add(entry.getName());
        headerPairs.add(String.format("%s=%s", entry.getName(), entry.getValue()));
      }
      tokens.add(String.format("Headers=%s", String.join(",", headerNames)));
      toSign.add(String.format("Headers=%s", String.join(",", headerPairs)));
    }

    if (ipRanges.isPresent()) {
      field = String.format("IPRanges=%s",
          base64Encoder(ipRanges.get().getBytes(StandardCharsets.US_ASCII)));
      tokens.add(field);
      toSign.add(field);
    }

    // Generate token.
    String toSignJoined = String.join("~", toSign);
    byte[] toSignBytes = toSignJoined.getBytes(StandardCharsets.UTF_8);
    String algorithm = signatureAlgorithm.toLowerCase();

    if (algorithm.equalsIgnoreCase("ed25519")) {
      Ed25519PrivateKeyParameters privateKey = new Ed25519PrivateKeyParameters(decodedKey, 0);
      Ed25519Signer signer = new Ed25519Signer();
      signer.init(true, privateKey);
      signer.update(toSignBytes, 0, toSignBytes.length);
      byte[] signature = signer.generateSignature();
      tokens.add(String.format("Signature=%s", base64Encoder(signature)));
    } else if (algorithm.equalsIgnoreCase("sha256")) {
      String sha256 = "HmacSHA256";
      Mac mac = Mac.getInstance(sha256);
      SecretKeySpec secretKeySpec = new SecretKeySpec(decodedKey, sha256);
      mac.init(secretKeySpec);
      byte[] signature = mac.doFinal(toSignBytes);
      tokens.add(String.format("hmac=%s", Hex.toHexString(signature)));
    } else if (algorithm.equalsIgnoreCase("sha1")) {
      String sha1 = "HmacSHA1";
      Mac mac = Mac.getInstance(sha1);
      SecretKeySpec secretKeySpec = new SecretKeySpec(decodedKey, sha1);
      mac.init(secretKeySpec);
      byte[] signature = mac.doFinal(toSignBytes);
      tokens.add(String.format("hmac=%s", Hex.toHexString(signature)));
    } else {
      throw new Error(
          "Input Missing Error: `signatureAlgorithm` can only be one of `sha1`, `sha256` or "
              + "`ed25519`");
    }
    // The signed URL appended with the query parameters based on the
    // specified URL prefix and configuration.
    System.out.println(String.join("~", tokens));
  }

  // Returns a base64-encoded string compatible with Media CDN.
  // Media CDN uses URL-safe base64 encoding and strips off the padding at the
  // end.
  public static String base64Encoder(byte[] value) {
    byte[] encodedBytes = Base64.getUrlEncoder().withoutPadding().encode(value);
    return new String(encodedBytes, StandardCharsets.UTF_8);
  }

  public static class Header {

    private String name;
    private String value;

    public Header(String name, String value) {
      this.name = name;
      this.value = value;
    }

    public String getName() {
      return name;
    }

    public void setName(String name) {
      this.name = name;
    }

    public String getValue() {
      return value;
    }

    public void setValue(String value) {
      this.value = value;
    }

    @Override
    public String toString() {
      return "Header{"
          + "name='" + name + '\''
          + ", value='" + value + '\''
          + '}';
    }
  }

}

以下部分介绍了令牌使用的字段。

必填令牌字段

每个令牌都必须包含以下字段：

• Expires
• 以下任一字段：
  • PathGlobs
  • URLPrefix
  • FullPath
• 以下任一字段：
  • Signature
  • hmac

除非另有说明，否则参数名称及其值区分大小写。

下表介绍了每个参数：

字段名称 / 别名	令牌参数	签名值
Expires exp	自 Unix 纪元 (1970-01-01T00:00:00Z) 以来经过的整数秒数	Expires=EXPIRATION_TIME，之后令牌将失效。
PathGlobs paths、acl	最多五个路径段的列表，用于授予访问权限。这些段 可以使用英文逗号 (,) 或感叹号 (!) 分隔，但不能同时使用这两种分隔符。 PathGlobs 支持使用 星号 (*) 和问号 (?) 在路径中使用通配符。单个 星号 (*) 字符可以跨越任意数量的路径段， 这与 pathMatchTemplate 的模式匹配语法不同。 不允许使用路径参数（使用分号 (;) 表示），因为它们会在匹配时造成歧义。 因此，请确保您的网址不包含以下 特殊字符：,!*?;	PathGlobs=PATHS
URLPrefix	可在网络中安全使用的 base64 编码网址，包括协议 http:// 或 https://，最多可包含您选择的字符。 例如，对于 `https://example.com/foo/bar.ts`，一些有效的 网址Prefix 值包括 `https://example.com`、 `https://example.com/foo` 和 `https://example.com/foo/bar`。	URLPrefix=BASE_64_URL_PREFIX
FullPath	无。在令牌中指定 FullPath 时，请勿重复 您在签名值中指定的路径。在令牌中，请添加字段 名称，但不要添加=。	FullPath=FULL_PATH_TO_OBJECT
Signature	可在网络中安全使用的 base64 编码签名版本。	不适用
hmac	可在网络中安全使用的 base64 编码 HMAC 值版本。	不适用

PathGlobs 通配符语法

下表介绍了 PathGlobs 通配符语法。

运算符	Matches	示例
*（星号）	匹配网址路径中的零个或多个字符，包括 正斜线 (/) 字符。	/videos/* 匹配以 /videos/ 开头的任何路径。 /videos/s*/4k/* 匹配 /videos/s/4k/ 和 /videos/s01/4k/main.m3u8。 /manifests/*/4k/* 匹配 /manifests/s01/4k/main.m3u8 和 /manifests/s01/e01/4k/main.m3u8。它不匹配 /manifests/4k/main.m3u8。
?（问号）	匹配网址路径中的单个字符，不包括正斜线 (/) 字符。	/videos/s?main.m3u8 匹配 /videos/s1main.m3u8。它不匹配 /videos/s01main.m3u8 或 /videos/s/main.m3u8。

对于网址路径，Glob 必须以星号 (*) 或正斜线 (/) 开头。

由于 * 和 /* 匹配所有网址路径，因此我们不建议 在签名令牌中使用它们。为了获得最大程度的保护，请确保您的 Glob 与您打算授予访问权限的内容相匹配。

选填令牌字段

除非另有说明，否则参数名称及其值区分大小写。

下表介绍了选填参数的参数名称、任何别名和详细信息：

字段名称 / 别名	参数	签名值
Starts st	自 Unix 纪元 (1970-01-01T00:00:00Z) 以来经过的整数秒数	Starts=START_TIME
IPRanges	最多五个 IPv4 和 IPv6 地址的列表，采用 CIDR 格式， 这些地址可在网络安全 base64 格式的网址中使用。例如，如需指定 IP 范围“192.6.13.13/32,193.5.64.135/32”，您可以指定 IPRanges=MTkyLjYuMTMuMTMvMzIsMTkzLjUuNjQuMTM1LzMy。 当客户端面临 WAN 迁移风险或应用前端的网络路径与传送路径不同时，在令牌中添加 IPRanges 可能没有帮助。当客户端使用不属于签名请求的 IP 地址进行连接时，Media CDN 会拒绝客户端并返回 HTTP 403 代码。 在以下情况下，Media CDN 可能会拒绝客户端并返回 HTTP 403 代码： 双栈（IPv4、IPv6）环境 连接迁移（从 Wi-Fi 到移动网络，以及从移动网络到 Wi-Fi） 使用运营商网关 NAT（CGNAT 或 CGN）的移动网络 多路径 TCP (MPTCP) 所有这些因素都可能导致给定客户端在视频播放会话期间具有 不确定的 IP 地址。如果您在授予访问权限后客户端 IP 地址发生变化，并且客户端尝试将视频段下载到其播放缓冲区中，则会收到来自 Media CDN 的 HTTP 403。	IPRanges=BASE_64_IP_RANGES
SessionID id	任意字符串，可用于日志分析或播放 跟踪。 为避免创建无效令牌，请使用 % 编码或可在网络中安全使用的 base64 编码字符串。以下字符不得用于 SessionID，因为它们会导致令牌无效： “~”、“&”或“ ”（空格）。	SessionID=SESSION_ID_VALUE
Data data、payload	任意字符串，可用于日志分析。 为避免创建无效令牌，请使用 % 编码或可在网络中安全使用的 base64 编码字符串。以下字符不得用于 Data，因为它们会导致令牌无效： “~”、“&”或“ ”（空格）。	data=DATA_VALUE
Headers	以英文逗号分隔的标头字段名称列表。在请求中查找时，标头名称 不区分大小写。签名值中的标头名称区分大小写。如果缺少标头，则该值为空 字符串。如果有多个标头副本，则它们会 以英文逗号连接。	Headers=HEADER_1_NAME=HEADER_1_EXPECTED_VALUE, HEADER_2_NAME=HEADER_2_EXPECTED_VALUE

示例

以下部分展示了生成令牌的示例。

使用 FullPath 的示例

请考虑以下使用 FullPath 字段的示例：

• 请求的项：http://example.com/tv/my-show/s01/e01/playlist.m3u8
• 到期时间：160000000

签名值为：

Expires=160000000~FullPath=/tv/my-show/s01/e01/playlist.m3u8

如需创建令牌，请使用 Ed25519 签名或对称密钥 HMAC 对签名值进行签名。

以下是根据签名值创建的示例令牌：

Ed25519 签名

Expires=160000000~FullPath~Signature=SIGNATURE_OF_SIGNED_VALUE

其中 SIGNATURE_OF_SIGNED_VALUE 是之前创建的 签名值的 ED25519 签名。

对称密钥 HMAC

Expires=160000000~FullPath~hmac=HMAC_OF_SIGNED_VALUE

其中 HMAC_OF_SIGNED_VALUE 是之前创建的签名 值的对称密钥 HMAC。

在前面的示例中，令牌中提供了 FullPath，但该值不会从签名值中指定的路径重复。这样，您就可以对请求的完整路径进行签名，而无需在令牌中重复请求。

使用 URLPrefix 的示例

请考虑以下使用 URLPrefix 字段的示例：

• 请求的项：http://example.com/tv/my-show/s01/e01/playlist.m3u8
• 到期时间：160000000

签名值为：

Expires=160000000~URLPrefix=aHR0cDovL2V4YW1wbGUuY29tL3R2L215LXNob3cvczAxL2UwMS9wbGF5bGlzdC5tM3U4

在前面的示例中，我们将请求项的路径 http://example.com/tv/my-show/s01/e01/playlist.m3u8 替换为可在网络中安全使用的 Base64 格式的项路径 aHR0cDovL2V4YW1wbGUuY29tL3R2L215LXNob3cvczAxL2UwMS9wbGF5bGlzdC5tM3U4。

如需创建令牌，请使用 Ed25519 签名或对称密钥 HMAC 对签名值进行签名。

以下是根据签名值创建的示例令牌：

Ed25519 签名

Expires=160000000~URLPrefix=aHR0cDovL2V4YW1wbGUuY29tL3R2L215LXNob3cvczAxL2UwMS9wbGF5bGlzdC5tM3U4~Signature=SIGNATURE_OF_SIGNED_VALUE

其中 SIGNATURE_OF_SIGNED_VALUE 是之前创建的 签名值的 ED25519 签名。

对称密钥 HMAC

Expires=160000000~URLPrefix=aHR0cDovL2V4YW1wbGUuY29tL3R2L215LXNob3cvczAxL2UwMS9wbGF5bGlzdC5tM3U4~hmac=HMAC_OF_SIGNED_VALUE

其中 HMAC_OF_SIGNED_VALUE 是之前创建的签名 值的对称密钥 HMAC。

使用 Headers 的示例

请考虑以下使用 Headers 字段的示例：

• 请求的项：http://example.com/tv/my-show/s01/e01/playlist.m3u8
• 到期时间：160000000
• PathGlobs 值：*
• 预期请求标头：
  • user-agent: browser
  • accept: text/html

签名值为：

Expires=160000000~PathGlobs=*~Headers=user-agent=browser,accept=text/html

如需创建令牌，请使用 Ed25519 签名或对称密钥 HMAC 对签名值进行签名。

以下是根据签名值创建的示例令牌：

Ed25519 签名

Expires=160000000~PathGlobs=*~Headers=user-agent,accept~Signature=SIGNATURE_OF_SIGNED_VALUE

其中 SIGNATURE_OF_SIGNED_VALUE 是之前创建的 签名值的 ED25519 签名。

对称密钥 HMAC

Expires=160000000~PathGlobs=*~Headers=user-agent,accept~hmac=HMAC_OF_SIGNED_VALUE

其中 HMAC_OF_SIGNED_VALUE 是之前创建的签名 值的对称密钥 HMAC。

在前面的示例中，令牌中提供了 Headers=user-agent,accept，但预期标头值不会从签名值重复。这样，您就可以对特定的请求标头键值对进行签名，而无需在令牌中重复这些值。