curl -X POST "http://127.0.0.1:9801/api/v2/client/mp-speeder/start" -H "accept: */*" -H "Content-Type: application/json"

import jwt
from datetime import datetime, timedelta
from typing import Tuple


class JWTGenerator:
    @classmethod
    def generate_sign(cls, secret_key, device_name: str) -> Tuple[str, int]:
        Generate JWT signature
        now = datetime.utcnow()

        payload = {
            "deviceName": device_name
        }

        token = jwt.encode(
            payload,
            secret_key,
            algorithm="HS256"
        )

        return token

if __name__ == "__main__":
    try:
        # replace with the APP key retrieved from console
        secret_key = "QGZzL0M6L3dpbmRvd3Mvd2luLmluaT9yYXc/aW1wb3J0Jg=="
        # Replace with device name, each device please use a different device_name
        device_name = "test"

        sign = JWTGenerator.generate_sign(secret_key, device_name)
        print(f"Signature: {sign}")
    except Exception as e:
        print(f"Error generating token: {str(e)}")

package main

import (
	"fmt"
	"github.com/golang-jwt/jwt/v4"
)

type JWTGenerator struct{}

// GenerateSign generates JWT signature
func (g *JWTGenerator) GenerateSign(secretKey string, deviceName string) (string, error) {
	// Create payload
	claims := jwt.MapClaims{
		"deviceName": deviceName,
	}

	// Create token
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)

	// Use key signature
	signedToken, err := token.SignedString([]byte(secretKey))
	if err != nil {
		return "", err
	}

	return signedToken, nil
}

func main() {
	// replace with the APP key retrieved from console
	secretKey := "QGZzL0M6L3dpbmRvd3Mvd2luLmluaT9yYXc/aW1wb3J0Jg=="
	// Replace with device name, each device please use a different device_name
	deviceName := "test"

	generator := &JWTGenerator{}
	
	sign, err := generator.GenerateSign(secretKey, deviceName)
	if err != nil {
		fmt.Printf("Error generating token: %v\\n", err)
		return
	}
	
	fmt.Printf("Signature: %s\\n", sign)
}

<dependencies>
    <!-- JWT Library -->
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-api</artifactId>
        <version>0.11.5</version>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-impl</artifactId>
        <version>0.11.5</version>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-jackson</artifactId>
        <version>0.11.5</version>
        <scope>runtime</scope>
    </dependency>
</dependencies>

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.security.Keys;
import javax.crypto.SecretKey;
import java.nio.charset.StandardCharsets;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

public class JWTGenerator {
    
    /**
     * Generate JWT signature
     * @param secretKey Key string
     * @param deviceName Device name
     * @return JWT token
     */
    public static String generateSign(String secretKey, String deviceName) {
        // Convert the key string to SecretKey
        SecretKey key = Keys.hmacShaKeyFor(secretKey.getBytes(StandardCharsets.UTF_8));
        
        // Create payload
        Map<String, Object> claims = new HashMap<>();
        claims.put("deviceName", deviceName);
        
        // Build JWT
        return Jwts.builder()
                .setClaims(claims)
                .signWith(key)
                .compact();
    }
    
    public static void main(String[] args) {
        try {
            // replace with the APP key retrieved from console
            String secretKey = "QGZzL0M6L3dpbmRvd3Mvd2luLmluaT9yYXc/aW1wb3J0Jg==";
            // Replace with device name, each device please use a different device_name
            String deviceName = "test";
            
            String sign = generateSign(secretKey, deviceName);
            System.out.println("Signature: " + sign);
        } catch (Exception e) {
            System.out.println("Error generating token: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

package main

import (
	"crypto/sha256"
	"fmt"
	"golang.org/x/crypto/chacha20"
	"net"
)

// share encryption and decryption
func encryptOrdecrypt(ip net.IP, psk []byte) ([]byte, error) {
	if ip.To4() == nil {
		return nil, fmt.Errorf("invalid ipv4 address")
	}

	key := sha256.Sum256(psk)
	encryptKey := key[:32]
	nonce := make([]byte, 12)
	cipher, err := chacha20.NewUnauthenticatedCipher(encryptKey, nonce)
	if err != nil {
		return nil, err
	}

	// in-place encryption (32bit exact output)
	ciphertext := make([]byte, net.IPv4len)
	cipher.XORKeyStream(ciphertext, ip.To4())
	return ciphertext, nil
}