JWT Authentication

package main

import (
	"fmt"
	"time"

	"github.com/golang-jwt/jwt"
)

func GenerateJWTToken1(portOneKey, portOneSecret string) string {
	cur := time.Now()
	expirationTime := cur.Add(100 * time.Second)

	// Create the JWT claims, which includes the username and expiry time
	claims := jwt.StandardClaims{
		// In JWT, the expiry time is expressed as unix milliseconds
		Issuer:    "PORTONE",
		Subject:   portOneKey,
		IssuedAt:  cur.Unix(),
		ExpiresAt: expirationTime.Unix(),
	}

	// Declare the token with the algorithm used for signing, and the claims
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	// Create the JWT string
	tokenString, _ := token.SignedString([]byte(portOneSecret))
	return tokenString

}

func main() {
	portOneKey := "PORTONE_KEY"
	portOneSecret := "PORTONE_SECRET"
	token := GenerateJWTToken(portOneKey, portOneSecret)
	fmt.Printf("The JWT Token is: %v\n", token)
}

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/4.0.0/crypto-js.min.js"></script>

<script>
    function base64url(source) {
        return CryptoJS.enc.Base64.stringify(source).replace(/=+$/, '').replace(/\+/g, '-').replace(/\//g, '_');
    }

    function main() {
        let portOneKey = "PORTONE_KEY";
        let portOneSecret = "PORTONE_SECRET";
        const jwtToken = jwtTokenGenerator(portOneKey, portOneSecret);
        console.log(`The JWT Token is: ${jwtToken}\n`);
    }

    function jwtTokenGenerator(portOneKey, portOneSecret) {
        const header = {
            alg: "HS256",
            typ: "JWT"
        };
        const stringifiedHeader = CryptoJS.enc.Utf8.parse(JSON.stringify(header));
        const encodedHeader = base64url(stringifiedHeader);
        const timeNow = parseInt(new Date().getTime()/1000);

        const data = {
            sub: portOneKey,
            iss: "PORTONE",
            iat: timeNow,
            exp: timeNow+100,
        };

        const stringifiedData = CryptoJS.enc.Utf8.parse(JSON.stringify(data));
        const encodedData = base64url(stringifiedData);

        const token = `${encodedHeader}.${encodedData}`;
        const signature = CryptoJS.HmacSHA256(token, portOneSecret);
        const encodedSignature = base64url(signature);

        const jwtToken = `${token}.${encodedSignature}`;
        return jwtToken;
    }
    main()
</script>

<?php
function base64url($source) {
    // Encode in classical base64
    $encodedSource = base64_encode($source);

    // Remove padding equal characters
    $encodedSource = rtrim($encodedSource, '=');

    // Replace characters according to base64url specifications
    $encodedSource = str_replace(['+', '/'], ['-', '_'], $encodedSource);

    return $encodedSource;
}

function generateJWTToken() {
    $key = "PORTONE_KEY";
    $secret_key = "PORTONE_SECRET";

    $header = [
        'alg' => 'HS256',
        'typ' => 'JWT'
    ];
    $stringifiedHeader = json_encode($header);
    $encodedHeader = base64url($stringifiedHeader);

    $timeNow = time();

    $data = [
        'iss' => 'PORTONE',
        'sub' => $key,
        'iat' => $timeNow,
        'exp' => $timeNow + 100
    ];
    $stringifiedData = json_encode($data);
    $encodedData = base64url($stringifiedData);

    $token = $encodedHeader . "." . $encodedData;
    $signature = base64url(hash_hmac('sha256', $token, $secret_key, true));

    $signedToken = $token . "." . $signature;

    return $signedToken;
}

function main() {
    $jwtToken = generateJWTToken();
    echo "JWT Token: " . $jwtToken;
}

main()
?>

import CryptoJS from 'crypto-js';

function base64url(source) {
    // Encode in classical base64
    let encodedSource = CryptoJS.enc.Base64.stringify(source)

    // Remove padding equal characters
    encodedSource = encodedSource.replace(/=+$/, '')

    // Replace characters according to base64url specifications
    encodedSource = encodedSource.replace(/\+/g, '-')
    encodedSource = encodedSource.replace(/\//g, '_')

    return encodedSource
}

function getJWTToken(portOnekey,portOneSecret){
    const header = {
        "alg": "HS256",
        "typ": "JWT"
    };

    const stringifiedHeader = CryptoJS.enc.Utf8.parse(JSON.stringify(header));
    const encodedHeader = base64url(stringifiedHeader);

    const timeNow = parseInt(new Date().getTime() / 1000);

    const data = {
        "sub": portOnekey,
        "iss": "PORTONE",
        "iat": timeNow,
        "exp": timeNow + 100,
    };

    const stringifiedData = CryptoJS.enc.Utf8.parse(JSON.stringify(data));
    const encodedData = base64url(stringifiedData);

    const token = encodedHeader + "." + encodedData;

    let signature = CryptoJS.HmacSHA256(token, portOneSecret);
    signature = base64url(signature);

    return token + "." + signature;
}
let portOneKey = "PORTONE_KEY";
let portOneSecret = "PORTONE_SECRET";
let token = getJWTToken(portOneKey, portOneSecret );
console.log(`The JWT Token is: ${token}\n`);

using System;
using System.Text;
using System.Security.Cryptography;
using Newtonsoft.Json;

public class Base64Url
{
    public static string Encode(byte[] source)
    {
        // Encode in classical base64
        string encodedSource = Convert.ToBase64String(source);

        // Remove padding equal characters
        encodedSource = encodedSource.TrimEnd('=');

        // Replace characters according to base64url specifications
        encodedSource = encodedSource.Replace('+', '-');
        encodedSource = encodedSource.Replace('/', '_');

        return encodedSource;
    }
}

public class JWTGenerator
{
    public static string GetJWTToken(string portOnekey, string portOneSecret)
    {
        var header = new
        {
            alg = "HS256",
            typ = "JWT"
        };

        var stringifiedHeader = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(header));
        var encodedHeader = Base64Url.Encode(stringifiedHeader);

        var timeNow = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds;

        var data = new
        {
            sub = portOnekey,
            iss = "PORTONE",
            iat = timeNow,
            exp = timeNow + 100,
        };

        var stringifiedData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(data));
        var encodedData = Base64Url.Encode(stringifiedData);

        var token = encodedHeader + "." + encodedData;

        var secret = Encoding.UTF8.GetBytes(portOneSecret);

        using (var hmac = new HMACSHA256(secret))
        {
            var signatureBytes = hmac.ComputeHash(Encoding.UTF8.GetBytes(token));
            var signature = Base64Url.Encode(signatureBytes);

            var signedToken = token + "." + signature;
            return signedToken;
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        string key = "PORTONE_KEY";
        string secret = "PORTONE_SECRET";
        string jwtToken = JWTGenerator.GetJWTToken(key, secret);
        Console.WriteLine("JWT Token:",+ jwtToken);
    }
}

import java.nio.charset.StandardCharsets;
import java.util.Base64;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

public class JWTGenerator {

    public static String base64url(byte[] source) {
        // Encode in classical base64
        String encodedSource = Base64.getEncoder().encodeToString(source);

        // Remove padding equal characters
        encodedSource = encodedSource.replaceAll("=+$", "");

        // Replace characters according to base64url specifications
        encodedSource = encodedSource.replace("+", "-");
        encodedSource = encodedSource.replace("/", "_");

        return encodedSource;
    }

    public static String generateJWTToken() {
        String key = "PORTONE_KEY";
        String secretKey = "PORTONE_SECRET";

        // Header
        String header = "{\"alg\":\"HS256\",\"typ\":\"JWT\"}";
        byte[] stringifiedHeader = header.getBytes(StandardCharsets.UTF_8);
        String encodedHeader = base64url(stringifiedHeader);

        // Payload
        long timeNow = System.currentTimeMillis() / 1000;

        String payload = "{\"iss\":\"PORTONE\",\"sub\":\"" + key + "\",\"iat\":" + timeNow + ",\"exp\":" + (timeNow + 1000000) + "}";
        byte[] stringifiedPayload = payload.getBytes(StandardCharsets.UTF_8);
        String encodedData = base64url(stringifiedPayload);

        // Token
        String token = encodedHeader + "." + encodedData;

        // Signature
        try {
            Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
            SecretKeySpec secret_key = new SecretKeySpec(secretKey.getBytes(StandardCharsets.UTF_8), "HmacSHA256");
            sha256_HMAC.init(secret_key);

            byte[] signatureBytes = sha256_HMAC.doFinal(token.getBytes(StandardCharsets.UTF_8));
            String signature = base64url(signatureBytes);

            // Signed Token
            return token + "." + signature;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static void main(String[] args) {
        String jwtToken = generateJWTToken();
        System.out.println("JWT Token: " + jwtToken);
    }
}

import base64
import json
import hashlib
import hmac
import time

def base64url(source):
    # Remove padding equal characters
    encoded_source = base64.b64encode(source).decode().rstrip("=")

    # Replace characters according to base64url specifications
    encoded_source = encoded_source.replace("+", "-").replace("/", "_")

    return encoded_source

def generate_jwt_token():
    key = "PORTONE_KEY"
    secret_key = "PORTONE_SECRET"

    # Header
    header = {
        'alg': 'HS256',
        'typ': 'JWT'
    }
    stringified_header = json.dumps(header)
    encoded_header = base64url(stringified_header.encode())

    # Payload
    time_now = int(time.time())
    data = {
        'iss': 'PORTONE',
        'sub': key,
        'iat': time_now,
        'exp': time_now + 100
    }
    stringified_data = json.dumps(data)
    encoded_data = base64url(stringified_data.encode())

    # Token
    token = f"{encoded_header}.{encoded_data}"

    # Signature
    signature = base64url(hmac.new(secret_key.encode(), token.encode(), hashlib.sha256).digest())

    # Signed Token
    signed_token = f"{token}.{signature}"

    return signed_token

def main():
    jwt_token = generate_jwt_token()
    print("JWT Token:", jwt_token)

if __name__ == "__main__":
    main()