NaaS — Autenticação e Configuração

import (
    "crypto"
    "crypto/rand"
    "crypto/rsa"
    "crypto/sha256"
    "crypto/x509"
    "encoding/base64"
    "encoding/json"
    "encoding/pem"
    "time"
)

func signEnvelope(privateKeyPEM []byte, correlationID string, payload any) (body []byte, sig string, err error) {
    block, _ := pem.Decode(privateKeyPEM)
    key, err := x509.ParsePKCS1PrivateKey(block.Bytes)
    if err != nil {
        return nil, "", err
    }
    envelope := map[string]any{
        "timestamp": time.Now().UTC().Format(time.RFC3339),
        "payload":   payload,
    }
    if correlationID != "" {
        envelope["correlation_id"] = correlationID
    }
    body, err = json.Marshal(envelope)
    if err != nil {
        return nil, "", err
    }
    hash := sha256.Sum256(body)
    sigBytes, err := rsa.SignPKCS1v15(rand.Reader, key, crypto.SHA256, hash[:])
    if err != nil {
        return nil, "", err
    }
    return body, base64.StdEncoding.EncodeToString(sigBytes), nil
}

import base64, json, time
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import padding

with open("naas_private.pem", "rb") as f:
    private_key = serialization.load_pem_private_key(f.read(), password=None)

def sign_envelope(payload: dict, correlation_id: str = None) -> tuple[bytes, str]:
    envelope = {
        "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
        "payload": payload,
    }
    if correlation_id:
        envelope["correlation_id"] = correlation_id
    body = json.dumps(envelope, separators=(",", ":")).encode()
    sig = private_key.sign(body, padding.PKCS1v15(), hashes.SHA256())
    return body, base64.b64encode(sig).decode()

const crypto = require('crypto');
const fs = require('fs');

const privateKey = fs.readFileSync('naas_private.pem', 'utf8');

function signEnvelope(payload, correlationId = null) {
  const envelope = {
    timestamp: new Date().toISOString().replace(/\.\d{3}Z$/, 'Z'),
    payload,
    ...(correlationId ? { correlation_id: correlationId } : {}),
  };
  const body = Buffer.from(JSON.stringify(envelope));
  const sig = crypto.sign('sha256', body, {
    key: privateKey,
    padding: crypto.constants.RSA_PKCS1_PADDING,
  });
  return { body, signature: sig.toString('base64') };
}

func signGETHeaders(privateKeyPEM []byte, correlationID string) (timestamp, sig string, err error) {
    block, _ := pem.Decode(privateKeyPEM)
    key, err := x509.ParsePKCS1PrivateKey(block.Bytes)
    if err != nil {
        return "", "", err
    }
    timestamp = time.Now().UTC().Format(time.RFC3339)
    canonical := timestamp + "\n" + correlationID
    hash := sha256.Sum256([]byte(canonical))
    sigBytes, err := rsa.SignPKCS1v15(rand.Reader, key, crypto.SHA256, hash[:])
    if err != nil {
        return "", "", err
    }
    return timestamp, base64.StdEncoding.EncodeToString(sigBytes), nil
}

// Uso:
// ts, sig, _ := signGETHeaders(privKeyPEM, correlationID)
// req.Header.Set("X-Timestamp", ts)
// req.Header.Set("X-Correlation-ID", correlationID)
// req.Header.Set("X-Signature", sig)

import base64, time
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding

def sign_get_headers(private_key, correlation_id: str) -> dict:
    timestamp = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
    canonical = f"{timestamp}\n{correlation_id}".encode()
    sig = private_key.sign(canonical, padding.PKCS1v15(), hashes.SHA256())
    return {
        "X-Timestamp": timestamp,
        "X-Correlation-ID": correlation_id,
        "X-Signature": base64.b64encode(sig).decode(),
    }

function signGETHeaders(correlationId) {
  const timestamp = new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
  const canonical = Buffer.from(`${timestamp}\n${correlationId}`);
  const sig = crypto.sign('sha256', canonical, {
    key: privateKey,
    padding: crypto.constants.RSA_PKCS1_PADDING,
  });
  return {
    'X-Timestamp': timestamp,
    'X-Correlation-ID': correlationId,
    'X-Signature': sig.toString('base64'),
  };
}

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
)

func verifyWebhook(body []byte, secret, receivedSig string) bool {
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write(body)
    expected := hex.EncodeToString(mac.Sum(nil))
    return hmac.Equal([]byte(expected), []byte(receivedSig))
}

import hashlib, hmac

def verify_webhook(body: bytes, secret: str, received_sig: str) -> bool:
    expected = hmac.new(secret.encode(), body, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, received_sig)