URL 鉴权概述--视频点播-火山引擎

文档中心

视频点播

配置 URL 鉴权

URL 鉴权概述

视频点播提供 Referer 黑白名单、IP 黑白名单、Origin 黑白名单等功能对访客进行过滤。但是在某些情况下，Referer， IP 和 Origin 可以被伪造，容易造成站点资源被恶意盗用。如果您对于站点内容的安全性有很高的要求，可以采用 URL 鉴权。本文为您介绍如何在视频点播控制台开启和配置 URL 鉴权。

URL 鉴权流程

下图展示了视频点播 URL 鉴权的整体流程：

具体步骤说明如下：

生成鉴权 URL：应用服务端使用共享的密钥和鉴权算法，对 URL 进行签名。签名过程通常涉及将 URL 的部分或全部参数与密钥进行加密或摘要。签名后，应用服务端将鉴权参数添加到 URL 中，形成完整的请求 URL。
下发鉴权 URL：应用服务端将带鉴权信息的请求 URL 下发给应用客户端。
发送资源请求：应用客户端使用带鉴权信息的请求 URL 向视频点播 CDN 节点发起资源请求。
校验鉴权参数：CDN 节点使用与应用服务端共享的密钥和鉴权算法对鉴权参数进行校验。校验的过程通常涉及判断鉴权 URL 的有效期，以及将请求参数与鉴权参数一起进行签名，并与请求中的鉴权参数进行比对。
- 如校验通过，CDN 节点将根据请求参数，从缓存中或源服务器获取资源，并将其返回给应用客户端。
- 如校验失败，CDN 节点返回 403 错误，拒绝访问。

在这个流程中，应用客户端负责发起请求，应用服务端负责生成鉴权 URL，CDN 节点负责接收请求并进行鉴权信息的校验。鉴权信息的生成和校验依赖于共享的密钥和鉴权算法，确保了请求的合法性和安全性。通过这种方式，您可以有效地保护 CDN 资源免受未经授权的访问。

适用范围

URL 鉴权适用于点播加速域名和自定义源站加速域名。其中：

点播加速域名的 URL 鉴权支持配置 A 类型。
自定义源站加速域名的 URL 鉴权支持配置 A 类型、B 类型、C 类型、D 类型和 E 类型。

鉴权计算器

在完成 URL 鉴权的配置后，您可以通过鉴权计算器实现以下功能：

生成鉴权 URL 示例。该 URL 示例除了包含签名外，也符合您指定的鉴权类型所定义的 URL 格式。通过发送一个包含该 URL 示例的请求，您可以验证您的 URL 鉴权配置是否符合预期。
验证客户端生成的鉴权 URL 示例是否与鉴权计算器生成的一致。
验证签名的过期时间是否符合预期。

按照以下步骤使用鉴权计算器：

点击鉴权计算器。鉴权计算器会自动获取加速域名的 URL 鉴权配置。如果您没有配置备密钥，鉴权计算器会自动创建一个供参考，您也可以删除该备密钥。如果您删除了备密钥，在生成的鉴权 URL 中，就不会包含备用鉴权 URL。
在原始 URL 处，输入您站点上任意一个文件的 URL。在您未启用 URL 鉴权时，用户使用该 URL 访问该文件。
指定开始时间，用于计算签名的过期时间。默认开始时间为当前时间。
点击生成鉴权，然后查看生成的鉴权 URL 示例以及签名的过期时间。

点播加速域名

操作步骤

按照以下步骤为点播加速域名开启并配置 URL 鉴权：

登录视频点播控制台，进入指定空间。
单击左侧导航栏分发加速 > 域名管理。
根据您的域名类型，在域名列表中找到您需要配置的域名，单击操作列的配置按钮。
在加速域名配置页面，单击访问控制页签。
单击页面下方修改配置按钮。
在 URL 鉴权区域，点播加速域名默认开启 URL 鉴权。根据提示，修改参数配置。配置远程鉴权的参数分为以下模块：
- 生效对象
- 鉴权配置
说明
请先在域名列表关闭点播调度后，再修改 URL 鉴权配置。
完成配置后，单击保存配置按钮。

参数说明

生效对象

表示对哪些文件的请求需要被鉴权。您至少需要添加一个规则，最多可以添加 10 个。
详细的参数信息如下表所示。

参数	说明
类型	A 类型
规则类型	支持以下选项：文件目录：规则应用于特定目录下的所有文件。文件后缀：规则应用于特定后缀名的所有文件。文件全路径：规则应用于特定文件。
是否匹配	可设为匹配或不匹配。
规则内容	根据规则类型，输入规则的内容。长度不能超过 1,024 个字符。不能包含以下字符：连续斜杠（`//`）、空格、美元符号（`$`）、问号（`?`）、Delete（ASCII code 127）。不同规则类型的具体要求如下：如果规则类型是文件后缀，规则内容必须是一个或者多个以分号（`;`）分隔的文件后缀。文件后缀无需以句点（`.`）开头。示例：`png;txt`。如果规则类型是文件目录，规则内容必须是一个或者多个以分号（`;`）分隔的目录路径。目录路径必须以斜杠（`/`）开头和结尾。示例：`/chs/foods/;/us/birds/`。如果规则类型是文件全路径，规则内容必须是一个或者多个以分号（`;`）分隔的文件路径。文件路径必须以斜杠（`/`）开头，可以包含星号（``）用来表示一个或者多个字符。示例：`/chs/foods/localsets;/us/birds/chickadee`。

鉴权配置

参数	说明
主 Key	主密钥。支持自定义签名 key。仅支持可见 ASCII 码，长度为 1-120 个字符。
备 Key	备密钥。支持自定义签名 key。仅支持可见 ASCII 码，长度限制为1-120 个字符。说明对线上业务域名变更 URL 鉴权时，建议在过渡期使用备 Key，避免业务中断。
签名参数名	固定为 auth_key。
签名有效时间	签名的有效时长，单位为秒。该参数与客户端请求中的 `timestamp` 参数搭配使用，用来计算签名的失效时间。签名的失效时间 = `timestamp` + 有效时长。您可指定一个时间单位并输入时间。默认的有效时长是 1,800 秒。您可以指定的最长时间是 10 年，也就是 315,360,000 秒。
时间戳进制	固定为十进制（Unix 时间戳）。
鉴权算法	表示签名计算使用的算法，支持的算法有： MD5：表示 MD5 算法。 SHA256：表示 SHA-256 算法。说明 SHA-256 算法的安全性比 MD5 高，生成的哈希值出现碰撞的几率比 MD5 低，但是加密和解密过程的耗时比 MD5 长。
M3U8 改写	表示在响应 `.m3u8` 文件的请求时，是否对 `.m3u8` 文件中每个分片文件的 URL 添加签名参数。每个分片 URL 的签名是基于改写后分片 URL，使用签名规则计算的。开启该配置后，您还可进行以下配置：分片 URL 原参数：在改写分片 URL 时是否保留 URL 中原有的参数再追加签算参数。默认保留。继承 M3U8 非签名参数：是否将来自该 M3U8 文件请求的非签名参数添加到分片 URL 中。默认关闭。说明对于点播加速域名，m3u8 改写默认开启。对于自定义源站加速域名，m3u8 改写默认关闭。

自定义源站加速域名

按照以下步骤为自定义源站加速域名开启并配置 URL 鉴权：

登录视频点播控制台，进入指定空间。
单击左侧导航栏分发加速设置 > 域名管理。
在加速域名页签下，根据您的域名类型，在域名列表中找到您需要配置的域名，单击操作列的配置按钮。
在加速域名配置页面，单击访问控制页签。
单击页面下方修改配置按钮。
在 URL 鉴权区域，选择不同类型的 URL 鉴权，开启并配置 URL 鉴权功能。具体操作请参见如下文档：

常见问题

时间戳防盗链功能与 URL 鉴权功能均会影响视频播放地址的有效时长，这两者区别是什么？

时间戳防盗链功能决定了通过 GetPlayInfo 接口从视频点播服务获取到的视频播放地址的有效时长。URL 鉴权功能中设置的有效时长决定的则是视频点播 CDN 服务生成的 URL 的有效时长。
若您同时配置了时间戳防盗链和 URL 鉴权，那么会存在以下两种情况：

如果您的视频播放地址是通过 GetPlayInfo 接口获取的，那么实际有效时长则为时间戳防盗链中设置的有效时长 + URL 鉴权中设置的有效时长。
如果您的视频播放地址是自行拼接得到的，那么实际有效时长将只取决于 URL 鉴权中设置的有效时长。

注意

时间戳防盗链功能本质上是在 URL 鉴权的基础上额外增加了过期时间设置。若您关闭了 URL 鉴权功能，那么就算在时间戳防盗链中设置了有效时长，播放地址到期后也不会失效。

签名 Demo

为方便您快速进行签名计算，视频点播提供了多种语言的签名 Demo，演示如何根据给定的密钥和其他参数，生成不同类型的带签名的 URL。

Java

Python

PHP

JavaScript

package main

import (
        "crypto/md5"
        "encoding/hex"
        "fmt"
        "math/rand"
        "regexp"
        "strconv"
        "time"
)

func splitUrl(url string) []string {
        reg := regexp.MustCompile("^(http://|https://)?([^/?]+)(/[^?]*)?(\\?.*)?$")
        return reg.FindStringSubmatch(url)
}

func getMd5(text string) string {
        hashByte := md5.Sum([]byte(text))
        return hex.EncodeToString(hashByte[:])
}

func getRandomString(length int) string {
        b := make([]byte, length)
        rand.Read(b)
        return fmt.Sprintf("%x", b)[:length]
}

func GenTypeAUrl(url string, key string, signName string, uid string, ts int64) string {
        params := splitUrl(url)
        scheme, host, path, args := params[1], params[2], params[3], params[4]
        randstr := getRandomString(10)
        text := fmt.Sprintf("%s-%d-%s-%s-%s", path, ts, randstr, uid, key)
        hash := getMd5(text)
        authArg := fmt.Sprintf("%s=%d-%s-%s-%s", signName, ts, randstr, uid, hash)
        if args == "" {
                return fmt.Sprintf("%s%s%s?%s", scheme, host, path, authArg)
        } else {
                return fmt.Sprintf("%s%s%s%s&%s", scheme, host, path, args, authArg)
        }
}

func GenTypeBUrl(url string, key string, ts int64) string {
        params := splitUrl(url)
        scheme, host, path, args := params[1], params[2], params[3], params[4]
        tsStr := time.Unix(ts, 0).Format("200601021504")
        text := fmt.Sprintf("%s%s%s", key, tsStr, path)
        hash := getMd5(text)
        return fmt.Sprintf("%s%s/%s/%s%s%s", scheme, host, tsStr, hash, path, args)
}

func GenTypeCUrl(url string, key string, ts int64) string {
        params := splitUrl(url)
        scheme, host, path, args := params[1], params[2], params[3], params[4]
        tsStr := strconv.FormatInt(ts, 16)
        text := fmt.Sprintf("%s%s%s", key, path, tsStr)
        hash := getMd5(text)
        return fmt.Sprintf("%s%s/%s/%s%s%s", scheme, host, hash, tsStr, path, args)
}

func GenTypeDUrl(url, key, signName, timeName string, ts int64, base int) string {
        params := splitUrl(url)
        scheme, host, path, args := params[1], params[2], params[3], params[4]
        tsStr := strconv.FormatInt(ts, base)
        text := fmt.Sprintf("%s%s%s", key, path, tsStr)
        hash := getMd5(text)
        authArg := fmt.Sprintf("%s=%s&%s=%s", signName, hash, timeName, tsStr)
        if args == "" {
                return fmt.Sprintf("%s%s%s?%s", scheme, host, path, authArg)
        } else {
                return fmt.Sprintf("%s%s%s%s&%s", scheme, host, path, args, authArg)
        }
}

// GenTypeEUrl Genrate signed url by custom rule(eg.：key+domain+uri+timestamp)
func GenTypeEUrl(url, key, signName, tsName string, ts int64, base int) string {
        params := splitUrl(url)
        scheme, domain, uri, args := params[1], params[2], params[3], params[4]
        tsStr := strconv.FormatInt(ts, base)
        text := fmt.Sprintf("%s%s%s%s", key, domain, uri, tsStr)
        hash := getMd5(text)
        authArg := fmt.Sprintf("%s=%s&%s=%s", signName, hash, tsName, tsStr)
        if args == "" {
                return fmt.Sprintf("%s%s%s?%s", scheme, domain, uri, authArg)
        } else {
                return fmt.Sprintf("%s%s%s%s&%s", scheme, domain, uri, args, authArg)
        }
}

func init() {
        rand.Seed(time.Now().UnixNano())
}

func main() {
        var url = "http://www.test.com/a.txt?a=b&c=d"
        var primaryKey = "primary123456"
        var signName = "auth_key"
        var timeName = "t"
        var uid = "0"
        var ts = time.Now().Unix() + 3600 //默认一小时过期

        typeAUrl := GenTypeAUrl(url, primaryKey, signName, uid, ts)
        typeBUrl := GenTypeBUrl(url, primaryKey, ts)
        typeCUrl := GenTypeCUrl(url, primaryKey, ts)
        typeDUrl := GenTypeDUrl(url, primaryKey, signName, timeName, ts, 10)
        typeEUrl := GenTypeEUrl(url, primaryKey, signName, timeName, ts, 10)

        fmt.Println("OriginUrl: ", url)
        fmt.Println("TypeA: ", typeAUrl)
        fmt.Println("TypeB: ", typeBUrl)
        fmt.Println("TypeC: ", typeCUrl)
        fmt.Println("TypeD: ", typeDUrl)
        fmt.Println("TypeE: ", typeEUrl)
}

import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.SimpleDateFormat;
import java.util.regex.*;
import java.util.*;

public class url_auth {
    private static String getMd5(String text) {
        MessageDigest hash = null;
        try {
            hash = MessageDigest.getInstance("MD5");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        hash.update(StandardCharsets.UTF_8.encode(text));
        return String.format("%032x", new BigInteger(1, hash.digest()));
    }

    private static String getRandomString(int length) {
        int leftLimit = 48; // numeral '0'
        int rightLimit = 122; // letter 'z'
        Random random = new Random();
        String str = random.ints(leftLimit, rightLimit + 1)
          .filter(i -> (i <= 57 || i >= 65) && (i <= 90 || i >= 97))
          .limit(length)
          .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
          .toString();
        return str;
    }

    private static Map<String,String> splitUrl(String url) {
        String pattern = "^(http://|https://)?([^/?]+)(/[^?]*)?(\\?.*)?$";
        Pattern r = Pattern.compile(pattern);
        Matcher m = r.matcher(url);
        Map<String,String> result = new HashMap<>();
        String scheme = "", domain = "", uri = "", args = "";
        if (m.find()) {
            scheme = m.group(1) == null ? "http://" : m.group(1);
            domain = m.group(2) == null ? "" : m.group(2);
            uri = m.group(3) == null ? "/" : m.group(3);
            args = m.group(4) == null ? "" : m.group(4);
        }
        result.put("scheme", scheme);
        result.put("domain", domain);
        result.put("uri", uri);
        result.put("args", args);
        return result;
    }

    private static String genTypeAUrl(String url, String key, String signName, String uid, long ts) {
        Map<String,String> uriInfo = splitUrl(url);
        String scheme = uriInfo.get("scheme"), domain = uriInfo.get("domain"), uri = uriInfo.get("uri"), args = uriInfo.get("args");
        String rand = getRandomString(10);
        String text = String.format("%s-%d-%s-%s-%s", uri, ts, rand, uid, key);
        String hash = getMd5(text);
        String authArg = String.format("%s=%d-%s-%s-%s", signName, ts, rand, uid, hash);
        if (args == "") return String.format("%s%s%s?%s", scheme, domain, uri, authArg);
        else return String.format("%s%s%s%s&%s", scheme, domain, uri, args, authArg);
    }

    private static String genTypeBUrl(String url, String key, long ts) {
        Map<String,String> uriInfo = splitUrl(url);
        String scheme = uriInfo.get("scheme"), domain = uriInfo.get("domain"), uri = uriInfo.get("uri"), args = uriInfo.get("args");
        String tsStr = new SimpleDateFormat("yyyyMMddHHmm").format(ts*1000);
        String text = String.format("%s%s%s", key, tsStr, uri);
        String hash = getMd5(text);
        return String.format("%s%s/%s/%s%s%s", scheme, domain, tsStr, hash, uri, args);
    }

    private static String genTypeCUrl(String url, String key, long ts) {
        Map<String,String> uriInfo = splitUrl(url);
        String scheme = uriInfo.get("scheme"), domain = uriInfo.get("domain"), uri = uriInfo.get("uri"), args = uriInfo.get("args");
        String hexts = Long.toHexString(ts);
        String text = String.format("%s%s%s", key, uri, hexts);
        String hash = getMd5(text);
        return String.format("%s%s/%s/%s%s%s", scheme, domain, hash, hexts, uri, args);
    }

    private static String genTypeDUrl(String url, String key, String signName, String timeName, long ts, int base) {
        Map<String,String> uriInfo = splitUrl(url);
        String scheme = uriInfo.get("scheme"), domain = uriInfo.get("domain"), uri = uriInfo.get("uri"), args = uriInfo.get("args");
        String tsStr = String.format("%d", ts);
        if (base==16)
            tsStr = Long.toHexString(ts);
        String text = String.format("%s%s%s", key, uri, tsStr);
        String hash = getMd5(text);
        String authArg = String.format("%s=%s&%s=%d", signName, hash, timeName, ts);
        if (args == "") return String.format("%s%s%s?%s", scheme, domain, uri, authArg);
        else return String.format("%s%s%s%s&%s", scheme, domain, uri, args, authArg);
    }

    // GenTypeEUrl Genrate signed url by custom rule(eg.：key+domain+uri+timestamp)
    private static String genTypeEUrl(String url, String key, String signName, String timeName, long ts, int base) {
        Map<String,String> uriInfo = splitUrl(url);
        String scheme = uriInfo.get("scheme"), domain = uriInfo.get("domain"), uri = uriInfo.get("uri"), args = uriInfo.get("args");
        String tsStr = String.format("%d", ts);
        if (base==16)
            tsStr = Long.toHexString(ts);
        String text = String.format("%s%s%s%s", key, domain, uri, tsStr);
        String hash = getMd5(text);
        String authArg = String.format("%s=%s&%s=%s", signName, hash, timeName, tsStr);
        if (args == "") return String.format("%s%s%s?%s", scheme, domain, uri, authArg);
        else return String.format("%s%s%s%s&%s", scheme, domain, uri, args, authArg);
    }

    public static void main(String[] args) {
        String url = "http://www.test.com/a.txt?a=b&c=d";
        String primaryKey = "primary123456";
        String signName = "auth_key";
        String tName = "t";
        String uid = "0";
        long ts = System.currentTimeMillis() / 1000 + 3600;//默认一小时过期

        System.out.println("OriginUrl:" + url);
        System.out.println("TypeA:" + genTypeAUrl(url, primaryKey, signName, uid, ts));
        System.out.println("TypeB:" + genTypeBUrl(url, primaryKey, ts));
        System.out.println("TypeC:" + genTypeCUrl(url, primaryKey, ts));
        System.out.println("TypeD:" + genTypeDUrl(url, primaryKey, signName, tName, ts, 10));
        System.out.println("TypeE:" + genTypeEUrl(url, primaryKey, signName, tName, ts, 10));
    }
}

import re
import time
import random
import string
import hashlib

def getMd5(text):
    hash = hashlib.md5()
    hash.update(text.encode("utf8"))
    return hash.hexdigest()

def splitUrl(url):
    p = re.compile("^(http://|https://)?([^/?]+)(/[^?]*)?(\\?.*)?$")
    if not p:
        return None
    m = p.match(url)
    if not m:
        return "", "", "", ""
    scheme, domain, uri, args = m.groups()
    if not scheme: scheme = "http://"
    if not uri: uri = "/"
    if not args: args = ""
    return scheme, domain, uri, args

def getRandomString(n):
    x = ''.join(random.sample(string.ascii_letters + string.digits, n))
    return x

def genTypeAUrl(url, key, signName, uid, ts):
    scheme, domain, uri, args = splitUrl(url)
    rand = getRandomString(10)
    text = "%s-%d-%s-%s-%s" %(uri, ts, rand, uid, key)
    hash = getMd5(text)
    authArg = "%s=%d-%s-%s-%s" %(signName, ts, rand, uid, hash)
    if args:
        return "%s%s%s%s&%s" %(scheme, domain, uri, args, authArg)
    else:
        return "%s%s%s?%s" %(scheme, domain, uri, authArg)

def genTypeBUrl(url, key, ts):
    scheme, domain, uri, args = splitUrl(url)
    ts_str = time.strftime('%Y%m%d%H%M', time.localtime(ts))
    text = "%s%s%s" % (key, ts_str, uri)
    hash = getMd5(text)
    return "%s%s/%s/%s%s%s" %(scheme, domain, ts_str, hash, uri, args)

def genTypeCUrl(url, key, ts):
    scheme, domain, uri, args = splitUrl(url)
    ts = "%x" %(int(ts))
    text = "%s%s%s" %(key, uri, ts)
    hash = getMd5(text)
    return "%s%s/%s/%s%s%s" %(scheme, domain, hash, ts, uri, args)

def genTypeDUrl(url, key, signName, tName, ts, ts_base):
    scheme, domain, uri, args = splitUrl(url)
    ts_str = "%d" %(int(ts))
    if ts_base == 16:
        ts_str = "%x" %(int(time.time()))
    text = "%s%s%s" %(key, uri, ts_str)
    hash = getMd5(text)
    authArg = "%s=%s&%s=%s" %(signName, hash, tName, ts_str)
    if args:
        return "%s%s%s%s&%s" %(scheme, domain, uri, args, authArg)
    else:
        return "%s%s%s?%s" %(scheme, domain, uri, authArg)

def genTypeEUrl(url, key, signName, timeName, ts, ts_base):
    scheme, domain, uri, args = splitUrl(url)
    ts_str = "%d" %(int(ts))
    if ts_base == 16:
        ts_str = "%x" %(int(time.time()))
    text = "%s%s%s%s" %(key, domain, uri, ts_str)
    hash = getMd5(text)
    authArg = "%s=%s&%s=%s" %(signName, hash, timeName, ts_str)
    if args:
        return "%s%s%s%s&%s" %(scheme, domain, uri, args, authArg)
    else:
        return "%s%s%s?%s" %(scheme, domain, uri, authArg)

def test():
    url = 'http://www.test.com/a.txt?a=b&c=d'
    primaryKey = 'primary123456'
    signName = "auth_key"
    timeName = "t"
    uid = "0"
    ts = time.time() + 3600 #默认一小时过期

    print("OriginUrl:{}".format(url))
    print("TypeA:{}".format(genTypeAUrl(url, primaryKey, signName, uid, ts)))
    print("TypeB:{}".format(genTypeBUrl(url, primaryKey, ts)))
    print("TypeC:{}".format(genTypeCUrl(url, primaryKey, ts)))
    print("TypeD:{}".format(genTypeDUrl(url, primaryKey, signName, timeName, ts, 10)))
    print("TypeE:{}".format(genTypeEUrl(url, primaryKey, signName, timeName, ts, 10)))


if __name__ == "__main__":
    test()

<?php
date_default_timezone_set('Asia/Shanghai');

function getRandomString($length = 10) {
    return substr(str_shuffle(str_repeat($x='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
        ceil($length/strlen($x)) )),1,$length);
}

function genTypeAUrl($url, $key, $sign, $uid, $ts) {
    $rand = getRandomString();
    $arr = parse_url($url);
    $text = $arr["path"]."-".$ts."-".$rand."-".$uid."-".$key;
    $hash = md5($text);
    $authArg = "{$sign}={$ts}-{$rand}-{$uid}-{$hash}";
    $result = "{$arr["scheme"]}://{$arr["host"]}{$arr["path"]}";
    if (array_key_exists("query", $arr) ) {
        $result = $result."?{$arr["query"]}&{$authArg}";
    } else {
        $result = $result."?{$authArg}";
    }
    return $result;
}

function genTypeBurl($url, $key, $ts) {
    $arr = parse_url($url);
    $tnow = date('YmdHi', $ts);
    $text = "{$key}{$tnow}{$arr["path"]}";
    $hash = md5($text);
    $result = "{$arr["scheme"]}://{$arr["host"]}/{$tnow}/{$hash}{$arr["path"]}";
    if (array_key_exists("query", $arr) ) {
        $result = $result."?{$arr["query"]}";
    }
    return $result;
}

function genTypeCUrl($url, $key, $ts) {
    $ts = dechex($ts);
    $arr = parse_url($url);
    $text = "{$key}{$arr["path"]}{$ts}";
    $hash = md5($text);
    $result = "{$arr["scheme"]}://{$arr["host"]}/{$hash}/{$ts}{$arr["path"]}";
    if (array_key_exists("query", $arr) ) {
        $result = $result."?{$arr["query"]}";
    }
    return $result;
}

function genTypeDUrl($url, $key, $signName, $timeName, $ts, $ts_base) {
    $arr = parse_url($url);
    $ts_str = "$ts";
    if ($ts_base==16) {
        $ts_str = dechex($ts);
    }
    $text = "{$key}{$arr["path"]}{$ts_str}";
    $hash = md5($text);
    $authArg = "{$signName}={$hash}&{$timeName}={$ts_str}";
    $result = "{$arr["scheme"]}://{$arr["host"]}{$arr["path"]}";
    if (array_key_exists("query", $arr) ) {
        $result = $result."?{$arr["query"]}&{$authArg}";
    } else {
        $result = $result."?{$authArg}";
    }
    return $result;
}

function genTypeEUrl($url, $key, $signName, $timeName, $ts, $ts_base) {
    $arr = parse_url($url);
    $ts_str = "$ts";
    if ($ts_base==16) {
        $ts_str = dechex($ts);
    }
    $text = "{$key}{$arr["host"]}{$arr["path"]}{$ts}";
    $hash = md5($text);
    $authArg = "{$signName}={$hash}&{$timeName}={$ts}";
    $result = "{$arr["scheme"]}://{$arr["host"]}{$arr["path"]}";
    if (array_key_exists("query", $arr) ) {
        $result = $result."?{$arr["query"]}&{$authArg}";
    } else {
        $result = $result."?{$authArg}";
    }
    return $result;
}

function test() {
    $url = "http://www.test.com/a.txt?a=b&c=d";
    $primaryKey = "primary123456";
    $signName = "auth_key";
    $timeName = "t";
    $uid = "0";
    $ts = time() + 3600;//默认一小时过期

    echo("OriginUrl: $url
");
    echo("TypeA:  ".genTypeAUrl($url, $primaryKey, $signName, $uid, $ts)."
");
    echo("TypeB:  ".genTypeBUrl($url, $primaryKey, $ts)."
");
    echo("TypeC:  ".genTypeCUrl($url, $primaryKey, $ts)."
");
    echo("TypeD:  ".genTypeDUrl($url, $primaryKey, $signName, $timeName, $ts, 10)."
");
    echo("TypeE:  ".genTypeEUrl($url, $primaryKey, $signName, $timeName, $ts, 10)."
");
}

test();

?>

import crypto from "crypto";

// 使用正则表达式匹配链接的各个部分
function splitUrl(url) {
  const regexp = /^(http:\/\/|https:\/\/)?([^\/\?]+)(\/[^\?]*)?(\?.*)?$/g;
  return regexp.exec(url);
}

// 计算字符串的 md5 值
function getMd5(str) {
  return crypto.createHash("md5").update(str).digest("hex");
}

// 生成随机字符串
function getRandomString(length) {
  const chars =
    "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
  let result = "";
  for (let i = 0; i < length; i++) {
    result += chars[Math.floor(Math.random() * chars.length)];
  }
  return result;
}

function genTimeString(ts) {
    const date = new Date(ts);
    return `${date.getFullYear()}${date.getMonth()}${date.getDate()}${date.getHours()}${date.getMinutes()}`
}

// 生成鉴权链接
function GenTypeAUrl(url, key, signName, uid, ts) {
  const params = splitUrl(url);
  const [, scheme, host, path, args] = params;
  const randStr = getRandomString(10);
  const text = `${path}-${ts}-${randStr}-${uid}-${key}`;
  const hash = getMd5(text);
  const authArg = `${signName}=${ts}-${randStr}-${uid}-${hash}`;
  if (!args) {
    return `${scheme}${host}${path}?${authArg}`;
  } else {
    return `${scheme}${host}${path}${args}&${authArg}`;
  }
}

function GenTypeBUrl(url, key, ts) {
  const params = splitUrl(url);
  const [, scheme, host, path, args] = params;
  const tsStr = genTimeString(ts*1000);
  const text = `${key}${tsStr}${path}`;
  const hash = getMd5(text);
  return `${scheme}${host}/${tsStr}/${hash}${path}${args}`;
}

function GenTypeCUrl(url, key, ts) {
  const params = splitUrl(url);
  const [, scheme, host, path, args] = params;
  const hexts = Number(ts).toString(16);
  const text = `${key}${path}${hexts}`;
  const hash = getMd5(text);
  return `${scheme}${host}/${hash}/${hexts}${path}${args}`;
}

function GenTypeDUrl(url, key, signName, timeName, ts, base) {
  const params = splitUrl(url);
  const [, scheme, host, path, args] = params;

  let tsStr = Number(ts).toString();;
  if (base===16){
      tsStr = Number(ts).toString(16);
  }
  
  const text = `${key}${path}${tsStr}`;
  const hash = getMd5(text);
  const authArg = `${signName}=${hash}&${timeName}=${ts}`; 
  if (args === ""){
      return `${scheme}${host}${path}?${authArg}`;
  }else {
      return `${scheme}${host}${path}${args}&${authArg}`;
  }
}

function GenTypeEUrl(url, key, signName, timeName, ts, base) {
  const params = splitUrl(url);
  const [, scheme, host, path, args] = params;

  let tsStr = Number(ts).toString();;
  if (base===16){
      tsStr = Number(ts).toString(16);
  }
  
  const text = `${key}${host}${path}${tsStr}`;
  const hash = getMd5(text);
  const authArg = `${signName}=${hash}&${timeName}=${ts}`; 
  if (args === ""){
      return `${scheme}${host}${path}?${authArg}`;
  }else {
      return `${scheme}${host}${path}${args}&${authArg}`;
  }
}

function main() {
  const url = "http://www.test.com/a.txt?a=b&c=d";
  const primaryKey = "primary123456";
  const signName = "auth_key";
  const timeName = "t"
  const uid = "0";
  const ts = Math.floor(Date.now() / 1000) + 3600; // 10 位时间戳
        
  console.log("OriginUrl:", url);
  console.log("TypeA: ", GenTypeAUrl(url, primaryKey, signName, uid, ts));
  console.log("TypeB: ", GenTypeBUrl(url, primaryKey, ts));
  console.log("TypeC: ", GenTypeCUrl(url, primaryKey, ts));
  console.log("TypeD: ", GenTypeDUrl(url, primaryKey, signName, timeName, ts, 10));
  console.log("TypeE: ", GenTypeEUrl(url, primaryKey, signName, timeName, ts, 10));
}

// 执行
main()

最近更新时间：2026.05.13 17:24:56

这个页面对您有帮助吗？

有用

无用

视频点播

URL 鉴权流程 #

适用范围 #

鉴权计算器 #

点播加速域名 #

操作步骤 #

参数说明 #