Node.js Signing And Verification

const crypto = require('node:crypto');

function fail(message) { throw new Error(message); }
function timestamp(value) {
  const text = String(value);
  if (!/^[1-9][0-9]{0,18}$/.test(text) || BigInt(text) > 9223372036854775807n) fail('invalid Timestamp: use Unix seconds');
  return text;
}
function base64(text, label) {
  if (typeof text !== 'string' || !text || text.length % 4 || !/^[A-Za-z0-9+/]*={0,2}$/.test(text)) fail(`${label}: invalid Base64`);
  const bytes = Buffer.from(text, 'base64');
  if (bytes.toString('base64') !== text) fail(`${label}: non-canonical Base64`);
  return bytes;
}
function key(input, privateKey) {
  if (typeof input !== 'string' || input.length > 16384) fail('key: missing or too large');
  let text = input.replace(/\\r\\n/g, '\n').replace(/\\n/g, '\n').trim();
  const labels = privateKey ? ['PRIVATE KEY', 'RSA PRIVATE KEY'] : ['PUBLIC KEY', 'RSA PUBLIC KEY'];
  if (text.startsWith('-----BEGIN')) {
    const match = /^-----BEGIN ([A-Z ]+)-----\s*([A-Za-z0-9+/=\s]+)\s*-----END \1-----$/.exec(text);
    if (!match || !labels.includes(match[1])) fail('key: expected one unencrypted RSA PEM block of the correct kind');
    text = match[2];
  }
  const der = base64(text.replace(/\s/g, ''), 'key');
  for (const type of privateKey ? ['pkcs8', 'pkcs1'] : ['spki', 'pkcs1']) {
    try {
      const result = privateKey ? crypto.createPrivateKey({ key: der, format: 'der', type })
        : crypto.createPublicKey({ key: der, format: 'der', type });
      if (result.asymmetricKeyType !== 'rsa') fail('key: not RSA');
      // createPublicKey can otherwise derive a public key from private-key input.
      if (!privateKey && !result.export({ format: 'der', type }).equals(der)) continue;
      return result;
    } catch { /* Try the other documented DER container. */ }
  }
  fail(`key: invalid/truncated or non-RSA ${privateKey ? 'private' : 'public'} key`);
}
function checked(operation, body, action) {
  try { return action(); }
  catch (error) {
    console.error(`[payment-${operation}] FAILED body_bytes=${Buffer.isBuffer(body) ? body.length : 0} error=${JSON.stringify(error.message)}`);
    throw error;
  }
}
function hash(body) {
  if (!Buffer.isBuffer(body)) fail('body: expected raw Buffer, not a parsed JSON object');
  return crypto.createHash('sha512').update(body).digest('hex');
}

// null means no request body. Buffer.alloc(0) means a present, empty body.
function signRequest(path, body, ts, merchantPrivateKey) {
  return checked('sign', body, () => {
    if (typeof path !== 'string' || !path.startsWith('/')) fail('path: expected API path');
    const origin = path + (body === null ? '' : hash(body)) + timestamp(ts);
    return crypto.sign('sha512', Buffer.from(origin, 'utf8'), {
      key: key(merchantPrivateKey, true), padding: crypto.constants.RSA_PKCS1_PADDING,
    }).toString('base64');
  });
}

// Callbacks: exact HTTP body + header Timestamp/Signature, with the PLATFORM public key.
// Signed API envelopes: pass the exact serialized data bytes, not the whole envelope.
function verifyPlatform(body, ts, signature, platformPublicKey) {
  return checked('verify', body, () => {
    const origin = hash(body) + timestamp(ts); // NO path or URL.
    const publicKey = key(platformPublicKey, false);
    const sig = base64(signature, 'Signature');
    const expected = Math.ceil(publicKey.asymmetricKeyDetails.modulusLength / 8);
    if (sig.length !== expected) fail(`Signature length: got ${sig.length}, expected ${expected} bytes`);
    if (!crypto.verify('sha512', Buffer.from(origin, 'utf8'), {
      key: publicKey, padding: crypto.constants.RSA_PKCS1_PADDING,
    }, sig)) fail('RSA SHA512 verification failed: check platform key, raw bytes, timestamp and formula');
  });
}
module.exports = { signRequest, verifyPlatform };

const { signRequest } = require('./sign.cjs');

// Node.js 18+. Serialize once before calling; rawBody is Buffer or null.
async function send(baseUrl, path, merchantCode, rawBody, merchantPrivateKey) {
  if (!baseUrl.startsWith('https://')) throw new Error('HTTPS is required');
  const timestamp = String(Math.floor(Date.now() / 1000));
  const signature = signRequest(path, rawBody, timestamp, merchantPrivateKey);
  const response = await fetch(baseUrl + path, {
    method: rawBody === null ? 'GET' : 'POST',
    body: rawBody,
    headers: { 'Content-Type': 'application/json', 'Merchant-Code': merchantCode,
      Timestamp: timestamp, Signature: signature },
    redirect: 'error', signal: AbortSignal.timeout(60000),
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}; reconcile before retrying`);
  const chunks = [];
  let size = 0;
  for await (const chunk of response.body) {
    size += chunk.length;
    if (size > 8 * 1024 * 1024) throw new Error('Response exceeds 8 MiB');
    chunks.push(chunk);
  }
  return Buffer.concat(chunks); // Preserve raw response for envelope verification.
}
module.exports = { send };

const { signRequest, verifyPlatform } = require('./sign.cjs');
const { send } = require('./http.cjs');
const body = Buffer.from(JSON.stringify(payload), 'utf8');
const responseBytes = await send(baseUrl, '/v1/merchant/pay', merchantCode, body, merchantPrivateKey);
// GET: await send(baseUrl, '/v1/merchant/account', merchantCode, null, merchantPrivateKey);
// Verify the signed response data before using it. Do not treat HTTP 200 as payment success.

// Express: register this raw-body route BEFORE any express.json() middleware.
app.post('/callback', express.raw({ type: 'application/json', limit: '1mb' }), async (req, res, next) => {
  try {
    verifyPlatform(req.body, req.get('Timestamp'), req.get('Signature'), configuredPlatformPublicKey);
  } catch { return res.status(401).send('invalid signature'); }
  try {
    const event = JSON.parse(req.body.toString('utf8'));
    await validateAndApplyIdempotently(event); // Your durable business transaction.
    res.status(200).send('SUCCESS');
  } catch (error) { next(error); }
});