sigflint 0.0.0 → 1.0.0

package/package.json

@@ -1,19 +1,83 @@
 {
   "name": "sigflint",
-  "version": "0.0.0",
-  "description": "Placeholder that reserves the name. sigflint 1.0.0, an AWS Signature Version 4 signing library, follows.",
+  "version": "1.0.0",
+  "description": "Fast, dependency-free AWS Signature Version 4 signing for every AWS service: headers, presigned URLs, SigV4a, chunked uploads and event streams. Node.js, Bun, Deno, Cloudflare Workers and browsers.",
+  "keywords": [
+    "aws",
+    "s3",
+    "sigv4",
+    "sigv4a",
+    "presigned-url",
+    "signature",
+    "signing",
+    "authorization",
+    "bun",
+    "deno",
+    "cloudflare-workers"
+  ],
   "license": "MIT",
   "author": "bompus",
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "main": "./dist/node.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "workerd": "./src/web.js",
+      "worker": "./src/web.js",
+      "browser": "./src/web.js",
+      "bun": "./dist/bun.js",
+      "node": "./dist/node.js",
+      "default": "./src/node.js"
+    },
+    "./web": {
+      "types": "./types/web.d.ts",
+      "default": "./src/web.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "dist",
+    "types",
+    "index.d.ts",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "esbuild src/node.js src/bun.js --bundle --format=esm --platform=node --target=es2022 --outdir=dist --log-level=warning",
+    "pretest": "npm run build",
+    "test": "node --test \"test/*.test.js\"",
+    "pretest:bun": "npm run build",
+    "test:bun": "bun test test/",
+    "types": "tsc && tsc -p test/types",
+    "conformance": "node conformance/build.mjs && node conformance/build-more.mjs",
+    "prepack": "tsc && npm run build",
+    "lint": "npx --yes oxlint@1.85.0 --deny-warnings src test conformance index.d.ts",
+    "format": "npx --yes oxfmt@0.70.0 .",
+    "check:style": "npm run lint && npx --yes oxfmt@0.70.0 --check .",
+    "check": "npm test && npm run types && npm run check:package && npm run check:style",
+    "check:benchmarked": "node bench/check-benchmarked.mjs",
+    "check:package": "tsc && npm run build && publint && attw --pack . --profile esm-only"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
+    "@types/node": "^26.6.5",
+    "esbuild": "^0.28.2",
+    "publint": "^0.3.25",
+    "typescript": "^7.0.2"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/bompus/sigflint.git"
   },
-  "homepage": "https://github.com/bompus/sigflint#readme",
   "bugs": {
     "url": "https://github.com/bompus/sigflint/issues"
   },
-  "files": [
-    "README.md",
-    "LICENSE"
-  ]
+  "homepage": "https://github.com/bompus/sigflint#readme"
 }

package/src/base.js

@@ -0,0 +1,341 @@
+// AWS Signature Version 4, header based, for S3 and every other service (request.service, default 's3'). No imports: the hash and HMAC primitives come from the
+// runtime entry. Presigned URLs, SigV4a and streamed bodies live in their own modules so a consumer only bundles what it imports.
+// The canonical request follows the specification:
+// - path:  S3 percent-decodes ('+' is a space) and encodes every byte but A-Z a-z 0-9 - . _ ~ and '/'; every other service normalises the path
+//          (empty segments dropped, '.' and '..' resolved) and encodes it a second time.
+// - query: split on '&', decode each name and value, encode every byte but A-Z a-z 0-9 - . _ ~, sort by name then value, valueless names get "name=".
+// - headers: lowercase names, trimmed values with runs of spaces and tabs collapsed, sorted by name.
+// The request (including its URL) is never modified.
+
+export const emptyBodyHash = 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855';
+
+/** The scheme of a signature: its algorithm name and how the credential scope is written. SigV4a (v4a.js) has its own. */
+export const symmetric = { algorithm: 'AWS4-HMAC-SHA256', scope: (date, region, service) => `${date}/${region}/${service}/aws4_request` };
+
+const reSafePath = /^[A-Za-z0-9\-._~/]*$/;
+const reSafeQuery = /^[A-Za-z0-9\-._~=&]*$/;
+const reSpaces = /[ \t]+/g;
+const reDirty = /\t|  /;
+
+// ASCII code -> what it is written as in a canonical path / query. url.pathname and url.search are always ASCII (the URL parser percent-encodes everything else).
+// Built on first use, so importing this module costs nothing.
+let pathTable;
+let queryTable;
+function tables() {
+  if (pathTable !== undefined) return;
+  pathTable = new Array(256);
+  queryTable = new Array(256);
+  for (let b = 0; b < 256; b++) {
+    const c = String.fromCharCode(b);
+    const unreserved = /[A-Za-z0-9\-._~]/.test(c);
+    const escaped = (b < 16 ? '%0' : '%') + b.toString(16).toUpperCase();
+    pathTable[b] = unreserved || c === '/' ? c : escaped;
+    queryTable[b] = unreserved ? c : escaped;
+  }
+}
+
+function hexValue(code) {
+  if (code >= 48 && code <= 57) return code - 48; // 0-9
+  if (code >= 65 && code <= 70) return code - 55; // A-F
+  if (code >= 97 && code <= 102) return code - 87; // a-f
+  return -1;
+}
+
+// Decodes %XX escapes to bytes (a '%' that does not start an escape is the byte 0x25) and encodes each byte with the table; '+' is a space.
+// Runs of characters that are already canonical are copied as one piece.
+function canonicalEncode(string, table) {
+  let out = '';
+  let start = 0;
+  for (let i = 0; i < string.length; i++) {
+    const code = string.charCodeAt(i);
+    const same = table[code];
+    if (same.length === 1 && code !== 43) continue;
+    out += string.slice(start, i);
+    start = i + 1;
+    if (code === 37) {
+      const hi = hexValue(string.charCodeAt(i + 1));
+      const lo = hexValue(string.charCodeAt(i + 2));
+      if (hi >= 0 && lo >= 0) {
+        out += table[(hi << 4) | lo];
+        i += 2;
+        start = i + 1;
+      } else {
+        out += '%25';
+      }
+    } else {
+      out += code === 43 ? '%20' : same;
+    }
+  }
+  return start === 0 ? string : out + string.slice(start);
+}
+
+function canonicalPathGeneral(pathname) {
+  const parts = pathname.split('/');
+  const kept = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part === '' || part === '.') continue;
+    if (part === '..') kept.pop();
+    else kept.push(part);
+  }
+  const path = (pathname.startsWith('/') ? '/' : '') + kept.join('/') + (pathname.endsWith('/') && kept.length > 0 ? '/' : '');
+  if (reSafePath.test(path)) return path === '' ? '/' : path;
+  tables();
+  let out = '';
+  for (let i = 0; i < path.length; i++) out += queryTable[path.charCodeAt(i)] === path[i] || path[i] === '/' ? path[i] : queryTable[path.charCodeAt(i)];
+  return out;
+}
+
+function canonicalPathS3(pathname) {
+  if (reSafePath.test(pathname)) return pathname === '' ? '/' : pathname;
+  tables();
+  return canonicalEncode(pathname, pathTable);
+}
+
+/** The canonical path for a service. */
+export const canonicalPath = (service, pathname) => (service === 's3' ? canonicalPathS3(pathname) : canonicalPathGeneral(pathname));
+
+function comparePairs(a, b) {
+  return a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0;
+}
+
+/** search is url.search, which is '' or starts with '?' */
+export function canonicalQuery(search) {
+  if (search.length < 2) return '';
+  const query = search.slice(1);
+  const simple = reSafeQuery.test(query);
+  if (simple) {
+    // Plain characters, one '=' per parameter, in order: the canonical query is the query (a name without a value gets a '='). Anything else, including two
+    // parameters with the same name and value, is left to the general code below.
+    let out = '';
+    let previousName = '';
+    let previousValue = '';
+    let start = 0;
+    for (;;) {
+      let end = query.indexOf('&', start);
+      if (end === -1) end = query.length;
+      let eq = query.indexOf('=', start);
+      if (eq === -1 || eq > end) eq = end;
+      const name = query.slice(start, eq);
+      const value = query.slice(eq + 1, end);
+      if (end === start || eq === start || value.includes('=') || (start > 0 && (name < previousName || (name === previousName && value <= previousValue)))) break;
+      out += (start === 0 ? '' : '&') + name + '=' + value;
+      if (end === query.length) return out;
+      previousName = name;
+      previousValue = value;
+      start = end + 1;
+    }
+  }
+  tables();
+  const pairs = [];
+  for (const part of query.split('&')) {
+    if (part === '') continue;
+    const eq = part.indexOf('=');
+    const rawName = eq === -1 ? part : part.slice(0, eq);
+    const rawValue = eq === -1 ? '' : part.slice(eq + 1);
+    // a '=' inside a value must be encoded, so the plain-characters shortcut applies only to values without one
+    pairs.push(simple && !rawValue.includes('=') ? [rawName, rawValue] : [canonicalEncode(rawName, queryTable), canonicalEncode(rawValue, queryTable)]);
+  }
+  if (pairs.length > 1) pairs.sort(comparePairs);
+  let out = '';
+  for (let i = 0; i < pairs.length; i++) out += (i === 0 ? '' : '&') + pairs[i][0] + '=' + pairs[i][1];
+  return out;
+}
+
+/** inserts into the name-ordered lists, replacing an entry with the same name */
+export function insert(names, values, name, value) {
+  let i = names.length;
+  while (i > 0 && names[i - 1] > name) i--;
+  if (i > 0 && names[i - 1] === name) {
+    values[i - 1] = value;
+    return;
+  }
+  for (let j = names.length; j > i; j--) {
+    names[j] = names[j - 1];
+    values[j] = values[j - 1];
+  }
+  names[i] = name;
+  values[i] = value;
+}
+
+/**
+ * Refuses a signHeaders entry that cannot be signed as given: x-amz-date and authorization are set by the signer, `__proto__` cannot be a property of the
+ * returned headers, and a line break in a value would start another canonical header line. Returns the lowercase name.
+ */
+export function signHeaderName(name, value) {
+  const lowerName = name.toLowerCase();
+  if (lowerName === 'x-amz-date' || lowerName === 'authorization' || lowerName === '__proto__') throw new TypeError(`signHeaders cannot contain ${lowerName}`);
+  if (/[\r\n]/.test(value)) throw new TypeError(`signHeaders ${lowerName} has a line break in its value`);
+  return lowerName;
+}
+
+/** A header value as it is signed: trimmed, runs of spaces and tabs collapsed. */
+export const headerValue = (value) => {
+  const trimmed = String(value).trim();
+  return reDirty.test(trimmed) ? trimmed.replace(reSpaces, ' ') : trimmed;
+};
+
+// 20130524T000000Z, recomputed only when the second changes
+let lastSecond = NaN;
+let lastDatetime = '';
+export function amzDatetime(now) {
+  const second = Math.floor(now / 1000);
+  if (second !== lastSecond) {
+    const iso = new Date(second * 1000).toISOString(); // 2013-05-24T00:00:00.000Z
+    lastDatetime = iso.slice(0, 4) + iso.slice(5, 7) + iso.slice(8, 10) + 'T' + iso.slice(11, 13) + iso.slice(14, 16) + iso.slice(17, 19) + 'Z';
+    lastSecond = second;
+  }
+  return lastDatetime;
+}
+
+/**
+ * @typedef {Object} SignRequest
+ * @property {string} method - GET, HEAD, PUT, POST, DELETE
+ * @property {URL} url
+ * @property {string} [service] - default 's3'
+ * @property {string} [region] - for example us-west-2
+ * @property {string} [body] - hashed into x-amz-content-sha256; an empty or missing body is the hash of an empty string
+ * @property {boolean} [unsignedPayload] - send UNSIGNED-PAYLOAD as x-amz-content-sha256 instead of hashing the body
+ * @property {Record<string, string>} [signHeaders] - extra headers to sign and return; names are lowercased in the result
+ * @property {number} [now] - signing time in milliseconds since the epoch; defaults to the current time
+ * @property {number} [expires] - presigned URLs: lifetime in seconds, default 3600
+ * @property {string} [regionSet] - SigV4a: the regions the signature is valid for, 'us-east-1,us-west-2' or '*'
+ */
+
+/**
+ * @typedef {Object} Credentials
+ * @property {string} accessKeyId
+ * @property {string} secretAccessKey
+ * @property {string} [sessionToken] - temporary credentials: signed and returned as x-amz-security-token
+ */
+
+/** @typedef {Record<string, string>} AuthHeaders */
+
+/**
+ * @typedef {Object} Primitives
+ * @property {(data: string | Uint8Array) => string} hexHash - SHA-256 as lowercase hex
+ * @property {(key: string | Uint8Array, data: string) => Uint8Array} hmac - HMAC-SHA-256 as bytes
+ * @property {(key: Uint8Array, data: string) => string} hmacHex - HMAC-SHA-256 as lowercase hex
+ * @property {ReturnType<typeof createKeys>} getSigningKey - the entry's one signing-key cache, shared by every symmetric signer
+ */
+
+/** The payload hash for x-amz-content-sha256. The hash function may return a promise, which is then the result. */
+export function payloadHashOf(request, hexHash) {
+  const body = request.body ?? '';
+  return request.unsignedPayload ? 'UNSIGNED-PAYLOAD' : body.length === 0 ? emptyBodyHash : hexHash(body);
+}
+
+/** Everything up to the hashing: the headers to return, the canonical request and the credential scope. */
+export function prepare(request, credentials, payloadHash, scheme = symmetric) {
+  const { method, url, signHeaders } = request;
+  const region = request.region ?? '';
+  const service = request.service ?? 's3';
+  // S3 always sends x-amz-content-sha256; other services only when the payload is unsigned
+  const withHash = service === 's3' || request.unsignedPayload === true;
+  const sessionToken = credentials.sessionToken;
+  const datetime = amzDatetime(request.now ?? Date.now());
+  const date = datetime.slice(0, 8);
+
+  const headers = withHash ? { 'x-amz-date': datetime, 'x-amz-content-sha256': payloadHash } : { 'x-amz-date': datetime }; // as returned
+
+  const extraNames = signHeaders === undefined ? [] : Object.keys(signHeaders);
+  let canonicalHeaders;
+  let signedHeaders;
+  if (extraNames.length === 0 && !sessionToken) {
+    // the usual request: only the headers that are always signed, already in sorted order
+    canonicalHeaders = withHash ? `host:${url.host}\nx-amz-content-sha256:${payloadHash}\nx-amz-date:${datetime}\n` : `host:${url.host}\nx-amz-date:${datetime}\n`;
+    signedHeaders = withHash ? 'host;x-amz-content-sha256;x-amz-date' : 'host;x-amz-date';
+  } else {
+    // the extra headers (and the session token) in name order, then merged with the ones that are always signed;
+    // a header named like one of those, or like an earlier extra, replaces it
+    const names = [];
+    const values = [];
+    if (sessionToken) {
+      headers['x-amz-security-token'] = sessionToken;
+      insert(names, values, 'x-amz-security-token', sessionToken.trim());
+    }
+    for (const name of extraNames) {
+      const value = /** @type {Record<string, string>} */ (signHeaders)[name];
+      const lowerName = signHeaderName(name, value);
+      headers[lowerName] = value;
+      insert(names, values, lowerName, headerValue(value));
+    }
+    const baseNames = withHash ? ['host', 'x-amz-content-sha256', 'x-amz-date'] : ['host', 'x-amz-date'];
+    const baseValues = withHash ? [url.host, payloadHash, datetime] : [url.host, datetime];
+    const nBase = baseNames.length;
+    canonicalHeaders = '';
+    signedHeaders = '';
+    let i = 0;
+    let j = 0;
+    while (i < names.length || j < nBase) {
+      let name;
+      let value;
+      if (j === nBase || (i < names.length && names[i] <= baseNames[j])) {
+        name = names[i];
+        value = values[i++];
+        if (j < nBase && name === baseNames[j]) j++;
+      } else {
+        name = baseNames[j];
+        value = baseValues[j++];
+      }
+      if (name === 'x-amz-content-sha256') payloadHash = value; // a caller-supplied one replaces the computed one
+      canonicalHeaders += `${name}:${value}\n`;
+      signedHeaders += signedHeaders === '' ? name : ';' + name;
+    }
+  }
+
+  const canonicalRequest = `${method}\n${canonicalPath(service, url.pathname)}\n${canonicalQuery(url.search)}\n${canonicalHeaders}\n${signedHeaders}\n${payloadHash}`;
+  return { headers, canonicalRequest, datetime, date, region, service, credentialScope: scheme.scope(date, region, service), signedHeaders, algorithm: scheme.algorithm };
+}
+
+export const stringToSign = (prepared, canonicalRequestHash) => `${prepared.algorithm}\n${prepared.datetime}\n${prepared.credentialScope}\n${canonicalRequestHash}`;
+
+/** Adds the authorization header to the headers to return. */
+export function authorize(prepared, accessKeyId, signature) {
+  prepared.headers.authorization = `${prepared.algorithm} Credential=${accessKeyId}/${prepared.credentialScope}, SignedHeaders=${prepared.signedHeaders}, Signature=${signature}`;
+  return prepared.headers;
+}
+
+export function createKeys(hmac) {
+  const signingKeys = new Map();
+  const maxSigningKeys = 1000;
+
+  // the key used last is checked first, which skips building the lookup string on repeated calls
+  let lastSecret;
+  let lastDate;
+  let lastRegion;
+  let lastService;
+  let lastKey;
+
+  return function getSigningKey(secretAccessKey, date, region, service) {
+    if (secretAccessKey === lastSecret && date === lastDate && region === lastRegion && service === lastService) return lastKey;
+    const cacheKey = `${date}\n${region}\n${service}\n${secretAccessKey}`; // a region or service cannot contain a line break, so two scopes never share a key
+    let signingKey = signingKeys.get(cacheKey);
+    if (signingKey === undefined) {
+      signingKey = hmac(hmac(hmac(hmac('AWS4' + secretAccessKey, date), region), service), 'aws4_request');
+      if (signingKeys.size >= maxSigningKeys) signingKeys.delete(signingKeys.keys().next().value);
+      signingKeys.set(cacheKey, signingKey);
+    }
+    lastSecret = secretAccessKey;
+    lastDate = date;
+    lastRegion = region;
+    lastService = service;
+    lastKey = signingKey;
+    return signingKey;
+  };
+}
+
+/**
+ * @param {Primitives} primitives
+ * @returns {(request: SignRequest, credentials: Credentials) => AuthHeaders}
+ */
+export function createSigner({ hexHash, hmacHex, getSigningKey }) {
+  return function getAuthHeaders(request, credentials) {
+    const prepared = prepare(request, credentials, payloadHashOf(request, hexHash));
+    return authorize(
+      prepared,
+      credentials.accessKeyId,
+      hmacHex(getSigningKey(credentials.secretAccessKey, prepared.date, prepared.region, prepared.service), stringToSign(prepared, hexHash(prepared.canonicalRequest))),
+    );
+  };
+}

package/src/bun.js

@@ -0,0 +1,37 @@
+// Bun: its own SHA-256 and HMAC, which are faster than node:crypto there.
+import crypto from 'node:crypto';
+import { createSigner, createKeys } from './base.js';
+import { createPresigner } from './presign.js';
+import { createSignerV4a, createPresignerV4a } from './v4a.js';
+import { ecdsa } from './ecdsa-node.js';
+import { createChunkSigner } from './chunks.js';
+import { createEventSigner } from './events.js';
+
+const bun = /** @type {any} */ (globalThis).Bun;
+
+// the HMAC state for the signing key in use is built once and cloned for each signature
+let baseKey;
+let base;
+
+const hmac = (key, data) => crypto.createHmac('sha256', key).update(data).digest();
+const getSigningKey = /* @__PURE__ */ createKeys(hmac);
+const hexHash = (data) => bun.SHA256.hash(data, 'hex');
+const primitives = {
+  hexHash,
+  hmac,
+  hmacHex: (key, data) => {
+    if (key !== baseKey) {
+      baseKey = key;
+      base = new bun.CryptoHasher('sha256', key);
+    }
+    return base.copy().update(data).digest('hex');
+  },
+  getSigningKey,
+};
+
+export const getAuthHeaders = /* @__PURE__ */ createSigner(primitives);
+export const presign = /* @__PURE__ */ createPresigner(primitives);
+export const getAuthHeadersV4a = /* @__PURE__ */ createSignerV4a({ hexHash, hmac, ecdsa });
+export const presignV4a = /* @__PURE__ */ createPresignerV4a({ hexHash, hmac, ecdsa });
+export const chunkSigner = /* @__PURE__ */ createChunkSigner(primitives);
+export const eventSigner = /* @__PURE__ */ createEventSigner(primitives);

package/src/chunks.js

@@ -0,0 +1,82 @@
+// aws-chunked uploads (x-amz-content-sha256: STREAMING-AWS4-HMAC-SHA256-PAYLOAD[-TRAILER]): every chunk is signed with the previous signature, starting from the
+// one in the request's authorization header. The pure helpers are shared by the synchronous entries (createChunkSigner) and the WebCrypto one.
+import { emptyBodyHash as emptyHash } from './base.js';
+
+export const utf8 = /* @__PURE__ */ new TextEncoder();
+
+/** The seed signature, timestamp and scope of a signed request, from the headers getAuthHeaders returned. */
+export function seedOf(authHeaders) {
+  const auth = authHeaders.authorization;
+  if (typeof auth !== 'string' || !auth.startsWith('AWS4-HMAC-SHA256 '))
+    throw new TypeError('authHeaders must be the headers getAuthHeaders returned (a SigV4a signature cannot start a chunk or event stream)');
+  const scope = auth.slice(auth.indexOf('Credential=') + 11, auth.indexOf(',')).split('/'); // access key, date, region, service, aws4_request
+  return {
+    signature: auth.slice(auth.lastIndexOf('Signature=') + 10),
+    datetime: authHeaders['x-amz-date'],
+    date: scope[1],
+    region: scope[2],
+    service: scope[3],
+    scope: scope.slice(1).join('/'),
+  };
+}
+
+export const chunkStringToSign = (datetime, scope, previous, payloadHash) => `AWS4-HMAC-SHA256-PAYLOAD\n${datetime}\n${scope}\n${previous}\n${emptyHash}\n${payloadHash}`;
+export const trailerStringToSign = (datetime, scope, previous, trailerHash) => `AWS4-HMAC-SHA256-TRAILER\n${datetime}\n${scope}\n${previous}\n${trailerHash}`;
+
+/** Trailing headers in canonical form: lowercase names in name order, each line ending in a newline. */
+export function canonicalTrailers(trailers) {
+  return Object.keys(trailers)
+    .map((name) => [name.toLowerCase(), String(trailers[name]).trim()])
+    .sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
+    .map(([name, value]) => `${name}:${value}\n`)
+    .join('');
+}
+
+/** The bytes of one chunk on the wire: size in hex, signature, the data. */
+export function frameChunk(signature, data) {
+  const head = utf8.encode(`${data.length.toString(16)};chunk-signature=${signature}\r\n`);
+  const out = new Uint8Array(head.length + data.length + 2);
+  out.set(head);
+  out.set(data, head.length);
+  out[out.length - 2] = 13;
+  out[out.length - 1] = 10;
+  return out;
+}
+
+/** The last chunk (no data), with the signed trailing headers when there are any. */
+export function frameEnd(signature, trailers, trailerSignature) {
+  return utf8.encode(
+    trailers === undefined
+      ? `0;chunk-signature=${signature}\r\n\r\n`
+      : `0;chunk-signature=${signature}\r\n${trailers.replace(/\n/g, '\r\n')}x-amz-trailer-signature:${trailerSignature}\r\n\r\n`,
+  );
+}
+
+/**
+ * @typedef {Object} ChunkSigner
+ * @property {(data: Uint8Array) => Uint8Array} chunk - the bytes to send for one chunk of the body
+ * @property {(trailers?: Record<string, string>) => Uint8Array} end - the last chunk, with the signed trailing headers when there are any
+ */
+
+/**
+ * @param {import('./base.js').Primitives} primitives
+ * @returns {(authHeaders: import('./base.js').AuthHeaders, credentials: import('./base.js').Credentials) => ChunkSigner}
+ */
+export function createChunkSigner({ hexHash, hmacHex, getSigningKey }) {
+  return function chunkSigner(authHeaders, credentials) {
+    const seed = seedOf(authHeaders);
+    const key = getSigningKey(credentials.secretAccessKey, seed.date, seed.region, seed.service);
+    let previous = seed.signature;
+    const sign = (data) => (previous = hmacHex(key, chunkStringToSign(seed.datetime, seed.scope, previous, hexHash(data))));
+    return {
+      chunk: (data) => (data.length === 0 ? data : frameChunk(sign(data), data)), // a zero-length chunk would end the upload; it is not sent
+      end(trailers) {
+        const signature = sign(new Uint8Array(0));
+        if (trailers === undefined) return frameEnd(signature);
+        const text = canonicalTrailers(trailers);
+        const trailerSignature = hmacHex(key, trailerStringToSign(seed.datetime, seed.scope, signature, hexHash(text)));
+        return frameEnd(signature, text, trailerSignature);
+      },
+    };
+  };
+}

package/src/ecdsa-node.js

@@ -0,0 +1,14 @@
+// SigV4a's ECDSA P-256 for the entries that have node:crypto (Node, Deno, Bun). The key is rebuilt from the derived scalar; ECDH supplies the public point that a JWK needs.
+import crypto from 'node:crypto';
+
+const b64url = (bytes) => Buffer.from(bytes).toString('base64url');
+
+export const ecdsa = {
+  key(d) {
+    const ecdh = crypto.createECDH('prime256v1');
+    ecdh.setPrivateKey(d);
+    const point = ecdh.getPublicKey();
+    return crypto.createPrivateKey({ key: { kty: 'EC', crv: 'P-256', d: b64url(d), x: b64url(point.subarray(1, 33)), y: b64url(point.subarray(33)) }, format: 'jwk' });
+  },
+  sign: (key, text) => crypto.sign('sha256', text, { key, dsaEncoding: 'der' }).toString('hex'),
+};

package/src/events.js

@@ -0,0 +1,85 @@
+// Event streams (Transcribe, Lex, Bedrock, Kinesis, ...): each message is wrapped in an outer message that carries a :date and a :chunk-signature header.
+import { amzDatetime } from './base.js';
+import { seedOf, utf8 } from './chunks.js';
+
+let crcTable;
+function crc32(bytes, start, end) {
+  if (crcTable === undefined) {
+    crcTable = new Int32Array(256);
+    for (let n = 0; n < 256; n++) {
+      let c = n;
+      for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+      crcTable[n] = c;
+    }
+  }
+  let crc = -1;
+  for (let i = start; i < end; i++) crc = crcTable[(crc ^ bytes[i]) & 255] ^ (crc >>> 8);
+  return ~crc >>> 0;
+}
+
+/** The :date header of an event: name, type 8 (timestamp), milliseconds since the epoch as 8 bytes. */
+export function dateHeader(ms) {
+  const out = new Uint8Array(15);
+  out[0] = 5;
+  out.set(utf8.encode(':date'), 1);
+  out[6] = 8;
+  new DataView(out.buffer).setBigInt64(7, BigInt(Math.floor(ms)));
+  return out;
+}
+
+/** The signed event: prelude, the :date and :chunk-signature headers, the inner message as payload, checksums. */
+export function frameEvent(dateBytes, signatureHex, inner) {
+  const headersLength = dateBytes.length + 52;
+  const out = new Uint8Array(16 + headersLength + inner.length);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, out.length);
+  view.setUint32(4, headersLength);
+  view.setUint32(8, crc32(out, 0, 8));
+  out.set(dateBytes, 12);
+  let at = 12 + dateBytes.length;
+  out[at++] = 16;
+  out.set(utf8.encode(':chunk-signature'), at);
+  at += 16;
+  out[at++] = 6;
+  view.setUint16(at, 32);
+  at += 2;
+  for (let i = 0; i < 32; i++) out[at + i] = parseInt(signatureHex.slice(2 * i, 2 * i + 2), 16);
+  at += 32;
+  out.set(inner, at);
+  view.setUint32(out.length - 4, crc32(out, 0, out.length - 4));
+  return out;
+}
+
+export const eventStringToSign = (datetime, scope, previous, headersHash, payloadHash) =>
+  `AWS4-HMAC-SHA256-PAYLOAD\n${datetime}\n${scope}\n${previous}\n${headersHash}\n${payloadHash}`;
+export const eventScope = (ms, region, service) => {
+  const datetime = amzDatetime(ms);
+  return { datetime, scope: `${datetime.slice(0, 8)}/${region}/${service}/aws4_request`, date: datetime.slice(0, 8) };
+};
+
+/**
+ * @typedef {Object} EventSigner
+ * @property {(message: Uint8Array, now?: number) => Uint8Array} sign - the signed event to send for one encoded message
+ */
+
+/**
+ * @param {import('./base.js').Primitives} primitives
+ * @returns {(authHeaders: import('./base.js').AuthHeaders, credentials: import('./base.js').Credentials) => EventSigner}
+ */
+export function createEventSigner({ hexHash, hmacHex, getSigningKey }) {
+  return function eventSigner(authHeaders, credentials) {
+    const seed = seedOf(authHeaders);
+    let previous = seed.signature;
+    return {
+      sign(message, now = Date.now()) {
+        const { datetime, scope, date } = eventScope(now, seed.region, seed.service);
+        const header = dateHeader(now);
+        previous = hmacHex(
+          getSigningKey(credentials.secretAccessKey, date, seed.region, seed.service),
+          eventStringToSign(datetime, scope, previous, hexHash(header), hexHash(message)),
+        );
+        return frameEvent(header, previous, message);
+      },
+    };
+  };
+}