Authenticated Playback for Live Streaming with Signed JWT Tokens

<?php

/*

Please note that in order to use JWT in PHP, you need to install the "firebase/php-jwt" library via Composer. 
You can do that with the following command:
composer require firebase/php-jwt

*/

require_once('vendor/autoload.php');
use FirebaseJWTJWT;

function generateSignedToken($signingKeyId, $privateKey, $uri, $exp = 3600, $nbf = null)
{
    $payload = [
        'uri' => $uri
    ];
    if ($exp > 0) {
        $payload['exp'] = time() + $exp;
    }
    if ($nbf !== null) {
        $payload['nbf'] = $nbf;
    }

    $headers = [
        'alg' => 'RS256',
        'typ' => 'JWT',
        'kid' => $signingKeyId
    ];

    $token = JWT::encode($payload, $privateKey, 'RS256', null, $headers);
    return $token;
}

// you can get signing key data from the response of https://api-cdn.qencode.com/v1/signing_keys endpoint
$signingKey = [
  'id' => 'your_signing_key_id',
  'private_key' => 'your_signing_key_private_key'
];

// generate token for Live stream playback
$streamPlaybackId = 'your_stream_playback_id';

$token = generateSignedToken($signingKey['id'], $signingKey['private_key'], $streamPlaybackId);
echo $token;
?>

const jwt = require('jsonwebtoken');

function generateSignedToken(signingKeyId, privateKey, uri, exp = 3600, nbf = null) {
    let payload = {
        uri: uri,
    };

    if (exp > 0) {
        payload.exp = Math.floor(Date.now() / 1000) + exp;
    }

    if (nbf !== null) {
        payload.nbf = nbf;
    }

    let headers = {
        alg: 'RS256',
        typ: 'JWT',
        kid: signingKeyId,
    };

    let token = jwt.sign(payload, privateKey, { algorithm: 'RS256', header: headers });
    return token;
}

// you can get signing key data from the response of https://api-cdn.qencode.com/v1/signing_keys endpoint
let signingKey = {
  id: 'your_signing_key_id',
  privateKey: 'your_signing_key_private_key',
};

// generate token for Live stream playback
let streamPlaybackId = 'your_stream_playback_id';

let token = generateSignedToken(signingKey.id, signingKey.privateKey, streamPlaybackId);
console.log(token);

using System;
using System.Collections.Generic;
using Microsoft.IdentityModel.Tokens;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;

class Program
{
    static void Main()
    {
        string signingKeyId = "your_signing_key_id";
        string privateKey = "your_signing_key_private_key"; // You might need to convert this to a SecurityKey
        string uri = "your_stream_playback_id";
        int exp = 3600;
        int? nbf = null;

        var token = GenerateSignedToken(signingKeyId, privateKey, uri, exp, nbf);
        Console.WriteLine(token);
    }

    static string GenerateSignedToken(string signingKeyId, string privateKey, string uri, int exp, int? nbf)
    {
        var claims = new List<Claim>
        {
            new Claim("uri", uri)
        };

        if (exp > 0)
        {
            var expTime = DateTime.UtcNow.AddSeconds(exp);
            claims.Add(new Claim(JwtRegisteredClaimNames.Exp, new DateTimeOffset(expTime).ToUnixTimeSeconds().ToString()));
        }

        if (nbf != null)
        {
            claims.Add(new Claim(JwtRegisteredClaimNames.Nbf, nbf.ToString()));
        }

        var securityKey = new SymmetricSecurityKey(System.Text.Encoding.UTF8.GetBytes(privateKey)); // might need to be adjusted based on your key
        var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256Signature);

        var header = new JwtHeader(credentials);
        header.Add("kid", signingKeyId);

        var payload = new JwtPayload(claims);
        var secToken = new JwtSecurityToken(header, payload);

        var handler = new JwtSecurityTokenHandler();

        return handler.WriteToken(secToken);
    }
}

import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;
import java.nio.charset.StandardCharsets;
import java.util.Date;

public class Main {
    public static void main(String[] args) {
        String signingKeyId = "your_signing_key_id";
        String privateKeyStr = "your_signing_key_private_key"; // You might need to convert this to a Key
        String uri = "your_stream_playback_id";
        long exp = 3600;
        Long nbf = null;

        String token = generateSignedToken(signingKeyId, privateKeyStr, uri, exp, nbf);
        System.out.println(token);
    }

    private static String generateSignedToken(String signingKeyId, String privateKeyStr, String uri, long exp, Long nbf) {
        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);

        byte[] privateKeyBytes = privateKeyStr.getBytes(StandardCharsets.UTF_8);
        Key signingKey = Keys.hmacShaKeyFor(privateKeyBytes);

        JwtBuilder builder = Jwts.builder()
                .setId(signingKeyId)
                .claim("uri", uri)
                .signWith(signingKey, SignatureAlgorithm.HS256);

        if (exp > 0) {
            long expMillis = nowMillis + exp * 1000;
            Date expDate = new Date(expMillis);
            builder.setExpiration(expDate);
        }

        if (nbf != null) {
            long nbfMillis = nbf * 1000;
            Date nbfDate = new Date(nbfMillis);
            builder.setNotBefore(nbfDate);
        }

        return builder.compact();
    }
}

require 'jwt'
require 'time'

def generate_signed_token(signing_key_id, private_key, uri, exp=3600, nbf=nil)
    payload = {
        'uri' => uri
    }
    if exp > 0
        payload['exp'] = Time.now.to_i + exp
    end
    if !nbf.nil?
        payload['nbf'] = nbf
    end

    headers = {
        'alg' => 'RS256',
        'typ' => 'JWT',
        'kid' => signing_key_id
    }

    token = JWT.encode payload, private_key, 'RS256', headers
    return token
end

# you can get signing key data from the response of https://api-cdn.qencode.com/v1/signing_keys endpoint
signing_key = {
    'id' => 'your_signing_key_id',
    'private_key' => 'your_signing_key_private_key'
}

# generate token for Live stream playback
stream_playback_id = 'your_stream_playback_id'

token = generate_signed_token(signing_key['id'], signing_key['private_key'], stream_playback_id)
puts token