toilscript 0.1.16 → 0.1.18

package/std/assembly/crypto.ts

@@ -1,9 +1,147 @@
-import {
-  crypto as crypto_binding
-} from "bindings/dom";
+// Web Crypto for ToilScript — a synchronous SubtleCrypto plus ergonomic
+// helpers, backed by metered host functions (see `bindings/webcrypto.ts` and
+// the toil-backend `crypto` host module).
+//
+// Deviations from the web spec (ToilScript has no Promises): every method is
+// synchronous and returns its value directly. Algorithm parameters are small
+// classes (e.g. `AesGcmParams`) rather than object literals, and key usages are
+// an i32 bitmask. RSA, on-host key generation, and the `jwk` format are not
+// provided (RSA was dropped for an unfixable timing side-channel in the only
+// pure-Rust implementation; keys are imported, never generated on-host).
+
+import { webcrypto } from "bindings/webcrypto";
+import { SubtleCrypto } from "crypto/subtle";
+import { HmacImportParams, HmacParams, ALG_SHA_256, USAGE_SIGN } from "crypto/algorithms";
+import { Encoding } from "encoding";
+
+// Re-export the public surface so guests can import everything from "crypto".
+export { SubtleCrypto } from "./crypto/subtle";
+export { CryptoKey, CryptoKeyPair } from "./crypto/key";
+export {
+  AlgorithmParams,
+  AesGcmParams,
+  AesCbcParams,
+  AesCtrParams,
+  HmacImportParams,
+  HmacParams,
+  Pbkdf2Params,
+  HkdfParams,
+  EcdsaParams,
+  EcKeyImportParams,
+  Ed25519Params,
+  X25519ImportParams,
+  EcdhParams,
+  algId,
+  algName,
+  formatId,
+  curveId,
+  cryptoError,
+  ALG_SHA_1,
+  ALG_SHA_256,
+  ALG_SHA_384,
+  ALG_SHA_512,
+  ALG_AES_GCM,
+  ALG_AES_CBC,
+  ALG_AES_CTR,
+  ALG_AES_KW,
+  ALG_HMAC,
+  ALG_ECDSA,
+  ALG_ED25519,
+  ALG_ECDH,
+  ALG_X25519,
+  ALG_HKDF,
+  ALG_PBKDF2,
+  CURVE_P256,
+  CURVE_P384,
+  USAGE_ENCRYPT,
+  USAGE_DECRYPT,
+  USAGE_SIGN,
+  USAGE_VERIFY,
+  USAGE_DERIVE_KEY,
+  USAGE_DERIVE_BITS,
+  USAGE_WRAP_KEY,
+  USAGE_UNWRAP_KEY,
+} from "./crypto/algorithms";
+
+function utf8Bytes(s: string): Uint8Array {
+  return Uint8Array.wrap(String.UTF8.encode(s));
+}
 
 export namespace crypto {
+  /// The synchronous SubtleCrypto singleton. `@lazy` defers initialization to
+  /// first use so accessing `crypto.subtle` from global scope (without an
+  /// explicit import of "crypto") doesn't hit a cross-module init-order error.
+  // @ts-ignore: decorator
+  @lazy export const subtle: SubtleCrypto = new SubtleCrypto();
+
+  /// Fill `array` with cryptographically strong random bytes.
   export function getRandomValues(array: Uint8Array): void {
-    crypto_binding.getRandomValues(array);
+    webcrypto.fillRandom(array.dataStart, array.byteLength);
+  }
+
+  /// An RFC 4122 version-4 UUID string.
+  export function randomUUID(): string {
+    let b = new Uint8Array(16);
+    webcrypto.randomUuid(b.dataStart);
+    b[6] = (b[6] & 0x0f) | 0x40; // version 4
+    b[8] = (b[8] & 0x3f) | 0x80; // variant 10
+    let h = toHex(b);
+    return (
+      h.substring(0, 8) +
+      "-" +
+      h.substring(8, 12) +
+      "-" +
+      h.substring(12, 16) +
+      "-" +
+      h.substring(16, 20) +
+      "-" +
+      h.substring(20, 32)
+    );
+  }
+
+  // --- Ergonomic digest helpers (thin wrappers over subtle.digest) ----------
+  export function sha1(data: Uint8Array): Uint8Array {
+    return subtle.digest("SHA-1", data);
+  }
+  export function sha256(data: Uint8Array): Uint8Array {
+    return subtle.digest("SHA-256", data);
+  }
+  export function sha384(data: Uint8Array): Uint8Array {
+    return subtle.digest("SHA-384", data);
+  }
+  export function sha512(data: Uint8Array): Uint8Array {
+    return subtle.digest("SHA-512", data);
+  }
+
+  // String-input variants (UTF-8 encode, then hash).
+  export function sha1Text(s: string): Uint8Array {
+    return sha1(utf8Bytes(s));
+  }
+  export function sha256Text(s: string): Uint8Array {
+    return sha256(utf8Bytes(s));
+  }
+  export function sha384Text(s: string): Uint8Array {
+    return sha384(utf8Bytes(s));
+  }
+  export function sha512Text(s: string): Uint8Array {
+    return sha512(utf8Bytes(s));
+  }
+
+  /// One-shot HMAC-SHA-256 over raw key + message bytes.
+  export function hmacSha256(key: Uint8Array, msg: Uint8Array): Uint8Array {
+    let k = subtle.importKey("raw", key, new HmacImportParams(ALG_SHA_256), false, USAGE_SIGN);
+    return subtle.sign(new HmacParams(), k, msg);
+  }
+  export function hmacSha256Text(key: Uint8Array, msg: string): Uint8Array {
+    return hmacSha256(key, utf8Bytes(msg));
+  }
+
+  /// Lowercase hex string of `bytes` (handy for displaying digests).
+  export function toHex(bytes: Uint8Array): string {
+    let hexLen = bytes.length * 2;
+    if (hexLen == 0) return "";
+    let dst = new Uint8Array(hexLen);
+    Encoding.Hex.encode(bytes.dataStart, bytes.length, dst.dataStart);
+    return String.UTF8.decode(dst.buffer);
   }
 }

package/std/assembly/index.d.ts

@@ -2807,10 +2807,93 @@ declare namespace console {
   export function timeEnd(label?: string): void;
 }
 
-/** Browser-like crypto utilities. */
+/** Opaque key handle for the Web Crypto API (per-request on the edge). */
+declare class CryptoKey {
+  readonly handle: u32;
+  readonly type: string;
+  readonly extractable: bool;
+  readonly algorithm: i32;
+  readonly usages: i32;
+  algorithmName(): string;
+  hasUsage(u: i32): bool;
+}
+declare class CryptoKeyPair {
+  readonly publicKey: CryptoKey;
+  readonly privateKey: CryptoKey;
+}
+/** Base class for the algorithm-parameter objects passed to SubtleCrypto. */
+declare abstract class AlgorithmParams {}
+declare class AesGcmParams extends AlgorithmParams {
+  constructor(iv: Uint8Array, additionalData?: Uint8Array, tagLength?: i32);
+}
+declare class AesCbcParams extends AlgorithmParams {
+  constructor(iv: Uint8Array);
+}
+declare class AesCtrParams extends AlgorithmParams {
+  constructor(counter: Uint8Array, length?: i32);
+}
+declare class HmacImportParams extends AlgorithmParams {
+  constructor(hash: i32);
+}
+declare class HmacParams extends AlgorithmParams {}
+declare class Pbkdf2Params extends AlgorithmParams {
+  constructor(hash: i32, salt: Uint8Array, iterations: u32);
+}
+declare class HkdfParams extends AlgorithmParams {
+  constructor(hash: i32, salt: Uint8Array, info?: Uint8Array);
+}
+declare class EcdsaParams extends AlgorithmParams {
+  constructor(hash: i32);
+}
+declare class EcKeyImportParams extends AlgorithmParams {
+  constructor(alg: i32, namedCurve: i32);
+}
+declare class Ed25519Params extends AlgorithmParams {}
+declare class X25519ImportParams extends AlgorithmParams {}
+declare class EcdhParams extends AlgorithmParams {
+  constructor(alg: i32, publicKeyHandle: i32);
+}
+/** Synchronous SubtleCrypto (no Promises). Returns values directly. */
+declare class SubtleCrypto {
+  digest(algorithm: string, data: Uint8Array): Uint8Array;
+  importKey(format: string, keyData: Uint8Array, algorithm: AlgorithmParams, extractable: bool, usages: i32): CryptoKey;
+  exportKey(format: string, key: CryptoKey): Uint8Array;
+  encrypt(algorithm: AlgorithmParams, key: CryptoKey, data: Uint8Array): Uint8Array;
+  decrypt(algorithm: AlgorithmParams, key: CryptoKey, data: Uint8Array): Uint8Array;
+  sign(algorithm: AlgorithmParams, key: CryptoKey, data: Uint8Array): Uint8Array;
+  verify(algorithm: AlgorithmParams, key: CryptoKey, signature: Uint8Array, data: Uint8Array): bool;
+  deriveBits(algorithm: AlgorithmParams, baseKey: CryptoKey, length: i32): Uint8Array;
+  deriveKey(algorithm: AlgorithmParams, baseKey: CryptoKey, lengthBits: i32, derivedKeyAlgorithm: AlgorithmParams, extractable: bool, usages: i32): CryptoKey;
+}
+
+// Algorithm / format / curve / usage ids (the Web Crypto ABI contract).
+declare const ALG_SHA_1: i32, ALG_SHA_256: i32, ALG_SHA_384: i32, ALG_SHA_512: i32;
+declare const ALG_AES_GCM: i32, ALG_AES_CBC: i32, ALG_AES_CTR: i32, ALG_AES_KW: i32;
+declare const ALG_HMAC: i32, ALG_ECDSA: i32, ALG_ED25519: i32, ALG_ECDH: i32, ALG_X25519: i32, ALG_HKDF: i32, ALG_PBKDF2: i32;
+declare const CURVE_P256: i32, CURVE_P384: i32;
+declare const USAGE_ENCRYPT: i32, USAGE_DECRYPT: i32, USAGE_SIGN: i32, USAGE_VERIFY: i32;
+declare const USAGE_DERIVE_KEY: i32, USAGE_DERIVE_BITS: i32, USAGE_WRAP_KEY: i32, USAGE_UNWRAP_KEY: i32;
+
+/** Browser-like Web Crypto (synchronous SubtleCrypto + ergonomic helpers). */
 declare namespace crypto {
+  /** The synchronous SubtleCrypto instance. */
+  export const subtle: SubtleCrypto;
   /** Fills `array` with cryptographically strong random values. */
   export function getRandomValues(array: Uint8Array): void;
+  /** An RFC 4122 version-4 UUID string. */
+  export function randomUUID(): string;
+  export function sha1(data: Uint8Array): Uint8Array;
+  export function sha256(data: Uint8Array): Uint8Array;
+  export function sha384(data: Uint8Array): Uint8Array;
+  export function sha512(data: Uint8Array): Uint8Array;
+  export function sha1Text(s: string): Uint8Array;
+  export function sha256Text(s: string): Uint8Array;
+  export function sha384Text(s: string): Uint8Array;
+  export function sha512Text(s: string): Uint8Array;
+  export function hmacSha256(key: Uint8Array, msg: Uint8Array): Uint8Array;
+  export function hmacSha256Text(key: Uint8Array, msg: string): Uint8Array;
+  /** Lowercase hex string of `bytes`. */
+  export function toHex(bytes: Uint8Array): string;
 }
 
 // Decorators