视频加密

func (s *CIService) CreateJob(ctx context.Context, opt *CreateJobsOptions) (*CreateJobsResult, *Response, error)

// 将 examplebucket-1250000000 和 COS_REGION 修改为真实的信息 
bu, _ := url.Parse("https://examplebucket-1250000000.cos.COS_REGION.myqcloud.com")
cu, _ := url.Parse("https://examplebucket-1250000000.ci.COS_REGION.myqcloud.com")
b := &cos.BaseURL{BucketURL: bu, CIURL: cu}
c := cos.NewClient(b, &http.Client{
        Transport: &cos.AuthorizationTransport{
            SecretID:  os.Getenv("SECRETID"),
            SecretKey: os.Getenv("SECRETKEY"),
        },
})

createJobOpt := &cos.CreateJobsOptions{
    Tag: "Transcode",
    Input: &cos.JobInput{
        Object: "input/test.mp4",
    },
    Operation: &cos.MediaProcessJobOperation{
        Output: &cos.JobOutput{
            Region: "ap-chongqing",
            Object: "output/test",
            Bucket: "test-1234567890",
        },
        Transcode: &cos.Transcode{
            Container: &cos.Container{
                Format: "hls",
            },
            Video: &cos.Video{
                Codec: "H.264",
            },
            Audio: &cos.Audio{
                Codec: "AAC",
            },
            TimeInterval: &cos.TimeInterval{
                Start:    "10",
                Duration: "",
            },
            TransConfig: &cos.TransConfig{
                HlsEncrypt: &cos.HlsEncrypt{
                    IsHlsEncrypt: true,
                },
            },
        },
        UserData: "hello world",
    },
}
createJobRes, _, err := c.CI.CreateJob(context.Background(), createJobOpt)
log_status(err)
fmt.Printf("%+v\\n", createJobRes.JobsDetail)

type URLToken struct {
    SessionToken string `url:"x-cos-security-token,omitempty" header:"-"`
}

type JwtTokens struct {
    // base info
    Type     string `json:"Type"`
    AppId    string `json:"AppId"`
    BucketId string `json:"BucketId"`
    Object   string `json:"Object"`
    Issuer   string `json:"Issuer"`
    // time info
    IssuedTimeStamp int64 `json:"IssuedTimeStamp"`
    ExpireTimeStamp int64 `json:"ExpireTimeStamp"`
    // other info
    Random int64 `json:"Random"`
    // times info
    UsageLimit int `json:"UsageLimit"`
    // secret info
    ProtectSchema     string `json:"ProtectSchema"`
    PublicKey         string `json:"PublicKey"`
    ProtectContentKey int    `json:"ProtectContentKey"`
}


func (token JwtTokens) Valid() error {
    return nil
}


// 生成jwt
func GenerateToken(appId string, bucketId string, objectKey string, secret []byte) (string, error) {
    t := time.Now()
    now := t.Unix()
    payLoad := JwtTokens{
        // 固定为 CosCiToken， 必填参数
        Type: "CosCiToken",
        // app id，必填参数
        AppId: appId,
        // 播放文件所在的BucketId， 必填参数
        BucketId: bucketId,
        // 播放文件名
        Object: url.QueryEscape(objectKey),
        // 固定为client，必填参数
        Issuer: "client",
        // token颁发时间戳，必填参数
        IssuedTimeStamp: now,
        // token过期时间戳，非必填参数，默认1天过期
        ExpireTimeStamp: t.Add(time.Hour * 24 * 6).Unix(),
        // token使用次数限制，非必填参数，默认限制100次
        UsageLimit: 20,
        // 保护模式，填写为 rsa1024 ，则表示使用 RSA 非对称加密的方式保护，公私钥对长度为 1024 bit
        ProtectSchema: "rsa1024",
        // 公钥。1024 bit 的 RSA 公钥，需使用 Base64 进行编码
        PublicKey: "xxx",
        // 是否加密解密密钥（播放时解密ts视频流的密钥），1表示对解密密钥加密，0表示不对解密密钥加密。
        ProtectContentKey: 0,
    }
    //使用指定的签名方法创建签名对象
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, payLoad)


    //使用指定的secret签名并获得完成的编码后的字符串token
    return token.SignedString(secret)
}
// COS环境
func GetCOSDomainVideoEncryptionURL(tak string, tsk string, token *URLToken, bucketId string, region string, objectKey string, jwtToken string) string {
    u, _ := url.Parse("https://" + bucketId + ".cos." + region + ".myqcloud.com")
    b := &cos.BaseURL{BucketURL: u}
    c := cos.NewClient(b, &http.Client{
        Transport: &cos.AuthorizationTransport{
            SecretID:     tak,
            SecretKey:    tsk,
            SessionToken: token.SessionToken,
        },
    })
    ctx := context.Background()


    // 获取预签名
    presignedURL, err := c.Object.GetPresignedURL3(ctx, http.MethodGet, objectKey, time.Hour, token)
    if err != nil {
        fmt.Printf("Error: %v\\n", err)
        return ""
    }


    resultUrl := presignedURL.String() + "&ci-process=pm3u8&expires=43200&&tokenType=JwtToken&token=" + jwtToken
    return resultUrl
}

// CDN域名
func GetCDNDomainVideoEncryptionURL(cdn string, objectKey string, jwtToken string) string {
    url := cdn + "/" + objectKey
    resultUrl := url + "?ci-process=pm3u8&signType=no&expires=43200&&tokenType=JwtToken&token=" + jwtToken
    return resultUrl
}

func main() {
    // 替换成您的密钥
    tak := os.Getenv("COS_SECRETID")
    tsk := os.Getenv("COS_SECRETKEY")
    token := &URLToken{
        SessionToken: "",
    }
    // 替换成您的桶名称
    appId := "1250000000"
    // 替换成您的桶名称
    bucketId := "test-1250000000"
    // 替换成您桶所在的region
    region := "ap-chongqing"
    // 替换成您需要播放的视频名称
    objectKey := "live/a.m3u8"


    // 替换为自己cdn域名
    cdn := "http://abc.cdn.com"

    // 替换为自己播放密钥，控制台可以查询
    var playkey = []byte("aaaaaaaaaaa")
    // 生成token
    jwtToken, _ := GenerateToken(appId, bucketId, objectKey, playkey)
    playUrl = GetCOSDomainVideoEncryptionURL(tak, tsk, token, bucketId, region, objectKey, jwtToken)
    fmt.Println(playUrl)
    playUrl = GetCDNDomainVideoEncryptionURL(cdn, objectKey, jwtToken)
    fmt.Println(playUrl)
}