生成令牌

本指南介绍了如何生成令牌，以及 字段。

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

您在创建令牌字符串时将使用带符号的值。您可以通过组合令牌的参数（例如已签名值的对称密钥基于哈希的消息身份验证代码 [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

如需向媒体 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 值的可在网页上安全使用的 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 都不匹配。

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

由于 * 和 /* 会匹配所有网址路径，因此我们不建议 使用其中任意一种签名。为了最大限度提供保护， 确保您的 glob 与您打算授予访问权限的内容相匹配。

可选令牌字段

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

下表介绍了参数名称、所有别名以及 可选参数：

字段名称/别名	参数	有符号值
Starts st	自 Unix 纪元 (1970-01-01T00:00:00Z) 以来的整数秒数	Starts=START_TIME
IPRanges	一个最多包含 5 个 CIDR 格式的 IPv4 和 IPv6 地址列表， 此网址是有效的网络安全 base64 格式。例如，如需指定 IP 地址范围“192.6.13.13/32,193.5.64.135/32”，您可以指定 IPRanges=MTkyLjYuMTMuMTMvMzIsMTkzLjUuNjQuMTM1LzMy。 当客户端 或连接网络路径 应用前端不同于交付路径。 媒体 CDN 使用 HTTP 403 拒绝客户端 与不属于 签名请求。 以下情况可能会导致 Media CDN 使用 HTTP 403 代码拒绝客户端： 双栈（IPv4、IPv6）环境 连接迁移（Wi-Fi 到移动网络，移动网络到 Wi-Fi） 使用运营商网关 NAT（CGNAT 或 CGN）的移动网络 多路径 TCP (MPTCP) 所有这些因素都会导致特定客户 非确定性 IP 地址。如果 但在您授予访问权限后，客户端 IP 地址会发生变化， 然后，客户端尝试将视频片段下载到其播放 它们会从 HTTP 403 接收 媒体 CDN。	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， 但预期的标头值不会与带符号的值重复。这样， 您可以签署特定的请求标头键值对，而无需复制 标记中。