Signing & Endorsed Requests

import { createSign } from 'node:crypto';
import canonicalize from 'canonicalize'; // npm install canonicalize

function signIntent(intent, privateKey) {
  const canonical = canonicalize(intent);
  const signer = createSign('SHA256');
  signer.update(canonical);
  const signature = signer.sign({ key: privateKey, dsaEncoding: 'der' });
  return signature.toString('base64');
}

import base64
import jcs  # pip install jcs
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import ec

def sign_intent(intent, private_key):
    canonical = jcs.canonicalize(intent)
    signature = private_key.sign(canonical, ec.ECDSA(hashes.SHA256()))
    return base64.b64encode(signature).decode('ascii')

import (
    "crypto/ecdsa"
    "crypto/rand"
    "crypto/sha256"
    "encoding/base64"
    "encoding/json"

    "github.com/cyberphone/json-canonicalization/go/src/webpki.org/jsoncanonicalizer"
)

func signIntent(intent any, priv *ecdsa.PrivateKey) (string, error) {
    raw, err := json.Marshal(intent)
    if err != nil {
        return "", err
    }
    canonical, err := jsoncanonicalizer.Transform(raw)
    if err != nil {
        return "", err
    }
    hash := sha256.Sum256(canonical)
    sig, err := ecdsa.SignASN1(rand.Reader, priv, hash[:])
    if err != nil {
        return "", err
    }
    return base64.StdEncoding.EncodeToString(sig), nil
}

import canonicalize from 'canonicalize';

async function signIntent(intent, privateKey) {
  const canonical = canonicalize(intent);
  const data = new TextEncoder().encode(canonical);
  // WebCrypto returns raw r||s (IEEE P1363); Dakota expects ASN.1 DER.
  const rawSig = new Uint8Array(
    await crypto.subtle.sign(
      { name: 'ECDSA', hash: 'SHA-256' },
      privateKey,
      data,
    ),
  );
  const der = rawEcdsaSignatureToDer(rawSig);
  let binary = '';
  for (const b of der) binary += String.fromCharCode(b);
  return btoa(binary);
}

// Convert a WebCrypto ECDSA P-256 signature (64 bytes, r || s) to
// ASN.1 DER: SEQUENCE { INTEGER r, INTEGER s }.
function rawEcdsaSignatureToDer(raw) {
  const r = trimLeadingZeros(raw.slice(0, 32));
  const s = trimLeadingZeros(raw.slice(32, 64));
  const rDer = encodeInteger(r);
  const sDer = encodeInteger(s);
  const seqLen = rDer.length + sDer.length;
  const out = new Uint8Array(2 + seqLen);
  out[0] = 0x30; // SEQUENCE
  out[1] = seqLen;
  out.set(rDer, 2);
  out.set(sDer, 2 + rDer.length);
  return out;
}

function trimLeadingZeros(bytes) {
  let i = 0;
  while (i < bytes.length - 1 && bytes[i] === 0) i++;
  return bytes.slice(i);
}

function encodeInteger(bytes) {
  const needsPad = (bytes[0] & 0x80) !== 0;
  const body = needsPad ? new Uint8Array([0, ...bytes]) : bytes;
  return new Uint8Array([0x02, body.length, ...body]);
}