ApsaraVideo Live：Implementasi autentikasi berbasis token

Pembuatan token di sisi server (disarankan)

ApsaraVideo Live menyediakan contoh kode pembuatan token untuk berbagai bahasa, termasuk Go, Java, dan Python. Untuk detailnya, kunjungi repositori GitHub.

Pembuatan token di sisi client (hanya untuk pengembangan dan pengujian)

Selama fase pengembangan dan pengujian, jika implementasi pembuatan token di sisi server Anda belum tersedia, Anda dapat menggunakan kode contoh di APIExample untuk menghasilkan token sementara. Kode contohnya sebagai berikut:

Android: Android/ARTCExample/KeyCenter/src/main/java/com/aliyun/artc/api/keycenter/ARTCTokenHelper.java

iOS: iOS/ARTCExample/Common/ARTCTokenHelper.swift

Bergabung ke channel dengan token

Android: Android/ARTCExample/QuickStart/src/main/java/com/aliyun/artc/api/quickstart/TokenGenerate/TokenGenerateActivity.java
iOS: iOS/ARTCExample/QuickStart/TokenGenerate/TokenGenerateVC.swift

Prosedur

1. Client meminta token dari server aplikasi Anda. Server aplikasi menghasilkan token sesuai aturan yang telah ditentukan dan mengembalikannya ke client.

2. Client menggunakan token yang diterima, bersama informasi lain yang diperlukan seperti appId, channelId, dan userId, untuk mengirim permintaan bergabung ke channel yang ditentukan.

3. Server ARTC memverifikasi token tersebut dan mengizinkan client masuk ke channel jika verifikasi berhasil.

Metode pembuatan token

Tabel berikut menjelaskan bidang-bidang yang digunakan dalam pembuatan token.

Prosedur pembuatan token:

Contoh kode:

// 1. Gabungkan bidang-bidang berikut: AppID+AppKey+ChannelID+UserID+Nonce+Timestamp
// 2. Gunakan fungsi sha256 pada string yang digabungkan untuk menghasilkan token.
token = sha256(AppID+AppKey+ChannelID+UserID+Nonce+Timestamp)
// Contoh:
AppID = "abc",AppKey="abckey",ChannelID="abcChannel",UserID="abcUser",Nonce="",Timestamp=1699423634
token = sha256("abcabckeyabcChannelabcUser1699423634") = "3c9ee8d9f8734f0b7560ed8022a0590659113955819724fc9345ab8eedf84f31"

Metode parameter tunggal (disarankan)

SDK ARTC menyediakan API yang disederhanakan dengan parameter tunggal untuk bergabung ke channel. Metode ini direkomendasikan karena berfungsi seperti syntactic sugar, dirancang untuk mencegah kegagalan bergabung akibat ketidaksesuaian antara parameter yang dihasilkan di server Anda dan yang dikirim oleh client.

Untuk menggunakan metode ini, gabungkan parameter Token, AppID, ChannelID, Nonce, UserID, dan Timestamp ke dalam objek JSON. Kemudian, encode string JSON tersebut dengan Base64 untuk menghasilkan string autentikasi baru (Base64 token).

package com.example;

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;
import java.util.Calendar;
import org.json.JSONObject;

public class App {

    public static String createBase64Token(String appid, String appkey, String channelid, String userid) {
        // Hitung stempel waktu kedaluwarsa (24 jam dari sekarang)
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.HOUR_OF_DAY, 24);
        long timestamp = calendar.getTimeInMillis() / 1000;

        // Gabungkan string
        String stringBuilder = appid + appkey + channelid + userid + timestamp;

        // Hitung hash SHA-256
        String token = sha256(stringBuilder);

        // Buat objek JSON
        JSONObject base64tokenJson = new JSONObject();
        base64tokenJson.put("appid", appid);
        base64tokenJson.put("channelid", channelid);
        base64tokenJson.put("userid", userid);
        base64tokenJson.put("nonce", "");
        base64tokenJson.put("timestamp", timestamp);
        base64tokenJson.put("token", token);

        // Ubah objek JSON menjadi string dan encode dalam Base64
        String jsonStr = base64tokenJson.toString();
        String base64token = Base64.getEncoder().encodeToString(jsonStr.getBytes(StandardCharsets.UTF_8));
        return base64token;
    }

    private static String sha256(String input) {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] hash = digest.digest(input.getBytes(StandardCharsets.UTF_8));
            StringBuilder hexString = new StringBuilder();
            for (byte b : hash) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1)
                    hexString.append('0');
                hexString.append(hex);
            }
            return hexString.toString();
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        String appid = "your_appid";
        String appkey = "your_appkey";
        String channel_id = "your_channel_id";
        String user_id = "your_user_id";

        String base64token = createBase64Token(appid, appkey, channel_id, user_id);
        System.out.println("Base64 Token: " + base64token);
    }
}

package main

import (
	"crypto/sha256"
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"time"
)

func createBase64Token(appid, appkey, channelID, userID string) (string, error) {
	// Hitung stempel waktu kedaluwarsa (24 jam dari sekarang)
	timestamp := time.Now().Add(24 * time.Hour).Unix()

	// Gabungkan string
	stringBuilder := appid + appkey + channelID + userID + fmt.Sprintf("%d", timestamp)

	// Hitung hash SHA-256
	hasher := sha256.New()
	hasher.Write([]byte(stringBuilder))
	token := hasher.Sum(nil)

	// Konversi hash ke string heksadesimal menggunakan encoding/hex
	tokenHex := hex.EncodeToString(token)

	// Buat objek JSON
	tokenJSON := map[string]interface{}{
		"appid":     appid,
		"channelid": channelID,
		"userid":    userID,
		"nonce":     "",
		"timestamp": timestamp,
		"token":     tokenHex,
	}

	// Ubah objek JSON menjadi byte dan encode dalam Base64
	jsonBytes, err := json.Marshal(tokenJSON)
	if err != nil {
		return "", err
	}
	base64Token := base64.StdEncoding.EncodeToString(jsonBytes)

	return base64Token, nil
}

func main() {
	appid := "your_appid"
	appkey := "your_appkey"
	channelID := "your_channel_id"
	userID := "your_user_id"

	token, err := createBase64Token(appid, appkey, channelID, userID)
	if err != nil {
		fmt.Println("Error creating token:", err)
		return
	}
	fmt.Println("Base64 Token:", token)
}

#!/usr/bin/env python
# -*- coding: UTF-8 -*-

import hashlib
import datetime
import time
import base64
import json

def create_base64_token(app_id, app_key, channel_id, user_id):
    expire = datetime.datetime.now() + datetime.timedelta(days=1)
    timestamp = int(time.mktime(expire.timetuple()))
    h = hashlib.sha256()
    h.update(str(app_id).encode('utf-8'))
    h.update(str(app_key).encode('utf-8'))
    h.update(str(channel_id).encode('utf-8'))
    h.update(str(user_id).encode('utf-8'))
    h.update(str(timestamp).encode('utf-8'))
    token = h.hexdigest()

    jsonToken = {'appid':app_id,
                 'channelid':channel_id,
                 'userid':user_id,
                 'nonce':'',
                 'timestamp':timestamp,
                 'token':token
                }
    base64Token = base64.b64encode(json.dumps(jsonToken).encode())

    return base64Token

def main():
    app_id = 'your_appid'
    app_key = 'your_appkey'
    channel_id = 'your_channel_id'
    user_id = 'your_user_id'

    base64Token = create_base64_token(app_id, app_key, channel_id, user_id)
    
    print(base64Token)

if __name__ == '__main__':
    main()

'use strict'
const crypto = require('crypto')
function create_base64_token(appid, appkey, channelid, userid) {
    let timestamp = Math.floor(Date.now() / 1000 + 24 * 60 * 60)

    let string_builder = appid + appkey + channelid + userid + timestamp.toString()
    let token = crypto.createHash('sha256').update(string_builder).digest('hex')
    let base64tokenJson = {
        appid:appid,
        channelid:channelid,
        userid:userid,
        nonce:'',
        timestamp:timestamp,
        token:token
    }
    let base64token = Buffer.from(JSON.stringify(base64tokenJson), 'utf-8').toString('base64')
    return base64token
}

let appid = "your_appid";
let appkey = "your_appkey";
let channel_id = "your_channel_id";
let user_id = "your_user_id";

let base64token = create_base64_token(appid, appkey, channel_id, user_id)
console.log(base64token)

use chrono::{Duration, Utc};
use sha2::{Sha256, Digest};
use serde_json::json;
use base64::encode;

fn create_base64_token(appid: &str, appkey: &str, channel_id: &str, user_id: &str) -> String {
    // Hitung stempel waktu kedaluwarsa (24 jam dari sekarang)
    let timestamp = (Utc::now() + Duration::hours(24)).timestamp();

    // Gabungkan string
    let string_builder = format!("{}{}{}{}{}", appid, appkey, channel_id, user_id, timestamp);

    // Hitung hash SHA-256
    let mut hasher = Sha256::new();
    hasher.update(string_builder);
    let token = hasher.finalize();
    let token_hex = format!("{:x}", token);

    // Buat objek JSON
    let token_json = json!({
        "appid": appid,
        "channelid": channel_id,
        "userid": user_id,
        "nonce": "",
        "timestamp": timestamp,
        "token": token_hex
    });

    // Ubah objek JSON menjadi string dan encode dalam Base64
    let base64_token = encode(token_json.to_string());

    base64_token
}

fn main() {
    let appid = "your_appid";
    let appkey = "your_appkey";
    let channel_id = "your_channel_id";
    let user_id = "your_user_id";

    let token = create_base64_token(appid, appkey, channel_id, user_id);
    println!("Base64 Token: {}", token);
}

Sisi client: Panggil joinChannel

Client menerima Base64 token dari server dan memanggil API joinChannel untuk bergabung ke channel:

• Android:

  // Anda dapat mengirim null untuk channelId dan userId karena nilainya sudah termasuk dalam Base64 token. Jika Anda tetap memberikan nilai, nilainya harus sesuai dengan yang digunakan saat menghasilkan token. Fitur ini dapat digunakan untuk memverifikasi konsistensi parameter antara server dan client.
  // base64Token adalah token yang telah di-encode Base64.
  // username adalah identitas yang dapat Anda kirimkan untuk troubleshooting.
  mAliRtcEngine.joinChannel(base64Token, null, null, "username");

• iOS:

  // Anda dapat mengirim nil untuk channelId dan userId karena nilainya sudah termasuk dalam Base64 token. Jika Anda tetap memberikan nilai, nilainya harus sesuai dengan yang digunakan saat menghasilkan token. Fitur ini dapat digunakan untuk memverifikasi konsistensi parameter antara server dan client.
  // base64Token adalah token yang telah di-encode Base64.
  // username adalah identitas yang dapat Anda kirimkan untuk troubleshooting.
  [self.engine joinChannel:base64Token channelId:nil userId:nil name:@"username" onResultWithUserId:nil];

Metode multi-parameter

SDK ARTC juga menyediakan API untuk bergabung ke channel dengan beberapa parameter. Metode ini menggunakan struktur data AliRtcAuthInfo untuk menyimpan token dan informasi pengguna.

• Android:

  // Kirim token dan informasi pengguna.
  AliRtcAuthInfo authInfo = new AliRtcAuthInfo();
  authInfo.appId = appId;
  authInfo.channelId = channelId;
  authInfo.userId = userId;
  authInfo.timestamp = timestamp;
  authInfo.nonce = nonce;
  authInfo.token = token;
  // Bergabung ke channel.
  mAliRtcEngine.joinChannel(authInfo, "");

• iOS:

  // Kirim token dan informasi pengguna.
  let authInfo = AliRtcAuthInfo()
  authInfo.appId = appId
  authInfo.channelId = channelId
  authInfo.nonce = nonce
  authInfo.userId = userId
  authInfo.timestamp = timestamp
  authInfo.token = authToken
  // Bergabung ke channel.
  self.rtcEngine?.joinChannel(authInfo, name: nil)