import time
import hashlib
from urllib.parse import urlparse
import jwt

def sign_request(private_key, api_key, request_url, request_body=None):
    # Extrair caminho com consulta
    parsed_url = urlparse(request_url)
    url = parsed_url.path
    if parsed_url.query:
        url += '?' + parsed_url.query
    
    # Hash do corpo
    body = request_body if request_body else '{}'
    body_hash = hashlib.sha256(body.encode('utf-8')).hexdigest()
    
    # Criar JWT
    now = int(time.time())
    payload = {
        'uri': url,
        'iat': now,
        'exp': now + 55,
        'sub': api_key,
        'bodyHash': body_hash
    }
    
    headers = {
        'typ': 'JWT',
        'alg': 'RS256'
    }
    
    signed_jwt = jwt.encode(
        payload=payload,
        key=private_key,
        algorithm='RS256',
        headers=headers
    )
    
    return f"Bearer {signed_jwt}"

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.security.Keys;
import java.net.URI;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.security.KeyFactory;
import java.security.MessageDigest;
import java.security.PrivateKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.time.Instant;
import java.util.Base64;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

public String signRequest(String privateKeyPem, String apiKey, String requestUrl, String requestBody) throws Exception {
    // Analisar URL
    URL url = new URL(requestUrl);
    String path = url.getPath();
    String query = url.getQuery();
    String uriPath = query != null ? path + "?" + query : path;
    
    // Hash do corpo
    String body = requestBody != null ? requestBody : "{}";
    MessageDigest digest = MessageDigest.getInstance("SHA-256");
    byte[] hash = digest.digest(body.getBytes(StandardCharsets.UTF_8));
    String bodyHash = bytesToHex(hash);
    
    // Hora atual
    long now = Instant.now().getEpochSecond();
    
    // Cabeçalho JWT
    Map<String, Object> header = new HashMap<>();
    header.put("typ", "JWT");
    header.put("alg", "RS256");
    
    // Payload JWT
    Map<String, Object> claims = new HashMap<>();
    claims.put("uri", uriPath);
    claims.put("iat", now);
    claims.put("exp", now + 55);
    claims.put("sub", apiKey);
    claims.put("bodyHash", bodyHash);
    
    // Converter PEM para PrivateKey
    PrivateKey privateKey = loadPrivateKey(privateKeyPem);
    
    // Assinar JWT
    String signedJwt = Jwts.builder()
        .setHeader(header)
        .setClaims(claims)
        .signWith(privateKey, SignatureAlgorithm.RS256)
        .compact();
    
    return "Bearer " + signedJwt;
}

private static String bytesToHex(byte[] hash) {
    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();
}

private static PrivateKey loadPrivateKey(String privateKeyPem) throws Exception {
    // Remover cabeçalhos e converter para binário
    String privateKeyContent = privateKeyPem
        .replace("-----BEGIN PRIVATE KEY-----", "")
        .replace("-----END PRIVATE KEY-----", "")
        .replaceAll("\\s", "");
    
    byte[] encoded = Base64.getDecoder().decode(privateKeyContent);
    
    // Criar chave privada
    KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(encoded);
    return keyFactory.generatePrivate(keySpec);
}

<?php
use \Firebase\JWT\JWT;

function signRequest($privateKey, $apiKey, $requestUrl, $requestBody = null) {
    // Analisar URL
    $urlParts = parse_url($requestUrl);
    $path = $urlParts['path'] ?? '';
    $query = isset($urlParts['query']) ? '?' . $urlParts['query'] : '';
    $url = $path . $query;
    
    // Hash do corpo
    $body = $requestBody ?? '{}';
    $bodyHash = hash('sha256', $body);
    
    // Hora atual
    $now = time();
    
    // Cabeçalhos JWT
    $header = [
        'typ' => 'JWT',
        'alg' => 'RS256'
    ];
    
    // Payload JWT
    $payload = [
        'uri' => $url,
        'iat' => $now,
        'exp' => $now + 55,
        'sub' => $apiKey,
        'bodyHash' => $bodyHash
    ];
    
    // Assinar JWT
    $signedJwt = JWT::encode($payload, $privateKey, 'RS256', null, $header);
    
    return 'Bearer ' . $signedJwt;
}
?>