生成令牌

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

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

您在创建令牌字符串时使用已签名值。您可以通过组合令牌的参数（例如已签名值的对称密钥基于哈希的消息身份验证代码 [HMAC]）来创建令牌字符串。

媒体 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	要授予访问权限的路径片段（最多 5 个）的列表。这些片段可以用英文逗号 (,) 或感叹号 (!) 分隔，但不能同时使用这两者。 PathGlobs 支持使用星号 (*) 和问号 (?) 在路径中使用通配符。与 pathMatchTemplate 的模式匹配语法不同，单个星号 (*) 字符可跨任意数量的路径片段。 不允许使用英文分号 (;) 表示路径参数，因为这会在匹配时造成歧义。 因此，请确保您的网址不包含以下特殊字符：,!*?;	PathGlobs=PATHS
URLPrefix	可在网址中安全使用的 base64 编码网址，包括协议 http:// 或 https://（最多到您选择的点）。 例如，`https://example.com/foo/bar.ts` 的一些有效网址前缀值是 `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	HMAC 值的可在 web 环境中安全使用的 base64 编码版本。	不适用

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 都不匹配。

对于网址路径，正则表达式必须以星号 (*) 或正斜杠 (/) 开头。

由于 * 和 /* 与所有网址路径匹配，因此我们不建议在已签名令牌中使用这两者。为实现最大程度的保护，请确保您的正则表达式与您打算授予访问权限的内容相符。

可选令牌字段

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

下表介绍了可选参数的参数名称、所有别名和详细信息：

字段名称 / 别名	参数	有符号值
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，但预期的标头值不会从已签名值重复。这样，您就可以对特定请求标头键值对进行签名，而无需在令牌中重复值。