@opentdf/sdk 0.9.0-beta.91 → 0.9.0-beta.93

package/dist/web/tdf3/src/utils/index.js

@@ -1,4 +1,3 @@
-import * as WebCryptoService from '../crypto/index.js';
 import { SplitKey } from '../models/index.js';
 import { AesGcmCipher } from '../ciphers/aes-gcm-cipher.js';
 import { ConfigurationError } from '../../../src/errors.js';
@@ -237,12 +236,12 @@ export function base64ToBytes(str) {
  *
  * @returns {Object}:
  * {
- *   keyForEncryption: Binary;
- *   keyForManifest: Binary;
+ *   keyForEncryption: KeyInfo;
+ *   keyForManifest: KeyInfo;
  * }
  */
-export async function keyMiddleware() {
-    const cipher = new AesGcmCipher(WebCryptoService);
+export async function keyMiddleware(cryptoService) {
+    const cipher = new AesGcmCipher(cryptoService);
     const encryptionInformation = new SplitKey(cipher);
     if (!encryptionInformation?.generateKey) {
         throw new ConfigurationError('Crypto service not initialised');
@@ -250,4 +249,4 @@ export async function keyMiddleware() {
     const key = await encryptionInformation.generateKey();
     return { keyForEncryption: key, keyForManifest: key };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../tdf3/src/utils/index.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../tdf3/src/utils/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opentdf/sdk",
-  "version": "0.9.0-beta.91",
+  "version": "0.9.0-beta.93",
   "description": "OpenTDF for the Web",
   "homepage": "https://github.com/opentdf/web-sdk",
   "bugs": {
@@ -48,6 +48,13 @@
         "import": "./dist/web/src/encodings/index.js"
       }
     },
+    "./cryptoutils": {
+      "default": {
+        "types": "./dist/types/src/crypto/index.d.ts",
+        "require": "./dist/cjs/src/crypto/index.js",
+        "import": "./dist/web/src/crypto/index.js"
+      }
+    },
     "./platform": {
       "types": "./dist/types/src/platform.d.ts",
       "require": "./dist/cjs/src/platform.js",
@@ -60,7 +67,7 @@
     }
   },
   "scripts": {
-    "build": "npm run clean && tsc && tsc --project tsconfig.commonjs.json && ../scripts/add-module-types.sh",
+    "build": "npm run vendor:jose-jwt-helpers && npm run clean && tsc && tsc --project tsconfig.commonjs.json && ../scripts/add-module-types.sh",
     "build:watch": "tsc --watch",
     "clean": "rm -rf {build,coverage,dist,tests/mocha/dist}",
     "coverage:merge": "for x in mocha wtr; do cp coverage/$x/coverage-final.json coverage/$x.json; done; nyc report --reporter text --reporter lcov -t coverage --lines 75 --statements 75 --branches 70 --functions 65 --check-coverage >coverage/coverage.txt",
@@ -71,6 +78,7 @@
     "lint": "eslint ./src/**/*.ts ./tdf3/**/*.ts ./tests/**/*.ts",
     "prepack": "npm run build",
     "test": "npm run build && npm run test:with-server",
+    "vendor:jose-jwt-helpers": "node scripts/vendor-jose-jwt-helpers.cjs",
     "mock:platform": "npm run build && node dist/web/tests/server.js",
     "test:with-server": "node dist/web/tests/server.js & trap \"node dist/web/tests/stopServer.js\" EXIT; npm run test:mocha && npm run test:wtr && npm run test:browser && npm run coverage:merge",
     "test:browser": "npx webpack --config webpack.test.config.cjs && npx karma start karma.conf.cjs",
@@ -83,8 +91,7 @@
     "@connectrpc/connect": "^2.0.2",
     "@connectrpc/connect-web": "^2.0.2",
     "buffer-crc32": "^1.0.0",
-    "dpop": "^1.4.1",
-    "jose": "^6.0.8",
+    "jose": "6.0.8",
     "json-canonicalize": "^1.0.6",
     "uuid": "~11.1.0"
   },

package/src/access/access-fetch.ts

@@ -1,9 +1,4 @@
-import {
-  KasPublicKeyAlgorithm,
-  KasPublicKeyInfo,
-  noteInvalidPublicKey,
-  OriginAllowList,
-} from '../access.js';
+import { KasPublicKeyAlgorithm, KasPublicKeyInfo, OriginAllowList } from '../access.js';
 import { type AuthProvider } from '../auth/auth.js';
 import {
   ConfigurationError,
@@ -13,7 +8,7 @@ import {
   ServiceError,
   UnauthenticatedError,
 } from '../errors.js';
-import { pemToCryptoPublicKey, validateSecureUrl } from '../utils.js';
+import { validateSecureUrl } from '../utils.js';
 
 export type RewrapRequest = {
   signedRequestToken: string;
@@ -194,7 +189,6 @@ export async function fetchKasPubKey(
     );
   }
   return {
-    key: noteInvalidPublicKey(pkUrlV2, pemToCryptoPublicKey(publicKey)),
     publicKey,
     url: kasEndpoint,
     algorithm: algorithm || 'rsa:2048',

package/src/access/access-rpc.ts

@@ -3,7 +3,6 @@ import {
   isPublicKeyAlgorithm,
   KasPublicKeyAlgorithm,
   KasPublicKeyInfo,
-  noteInvalidPublicKey,
   OriginAllowList,
 } from '../access.js';
 
@@ -22,7 +21,6 @@ import { ListKeyAccessServersResponse } from '../platform/policy/kasregistry/key
 import {
   extractRpcErrorMessage,
   getPlatformUrlFromKasEndpoint,
-  pemToCryptoPublicKey,
   validateSecureUrl,
 } from '../utils.js';
 import { X_REWRAP_ADDITIONAL_CONTEXT } from './constants.js';
@@ -201,7 +199,6 @@ export async function fetchKasPubKey(
       v: '2',
     });
     const result: KasPublicKeyInfo = {
-      key: noteInvalidPublicKey(new URL(platformUrl), pemToCryptoPublicKey(publicKey)),
       publicKey,
       url: kasEndpoint,
       algorithm: algorithm || 'rsa:2048',
@@ -240,10 +237,6 @@ export async function fetchKasBasePubKey(kasEndpoint: string): Promise<KasPublic
     }
 
     const result: KasPublicKeyInfo = {
-      key: noteInvalidPublicKey(
-        new URL(baseKey.kas_uri),
-        pemToCryptoPublicKey(baseKey.public_key.pem)
-      ),
       publicKey: baseKey.public_key.pem,
       url: baseKey.kas_uri,
       algorithm: baseKey.public_key.algorithm,

package/src/access.ts

@@ -1,5 +1,4 @@
 import { type AuthProvider } from './auth/auth.js';
-import { ServiceError } from './errors.js';
 import { RewrapResponse } from './platform/kas/kas_pb.js';
 import { getPlatformUrlFromKasEndpoint, validateSecureUrl } from './utils.js';
 import { base64 } from './encodings/index.js';
@@ -155,24 +154,8 @@ export type KasPublicKeyInfo = {
 
   /** The key value, encoded within a PEM envelope */
   publicKey: string;
-
-  /** A subtle crypto version of the key.
-   * This can be used for wrapping key data for key access objects (with RSA)
-   * or to derive key data (with EC keys). */
-  key: Promise<CryptoKey>;
 };
 
-export async function noteInvalidPublicKey(url: URL, r: Promise<CryptoKey>): Promise<CryptoKey> {
-  try {
-    return await r;
-  } catch (e) {
-    if (e instanceof TypeError) {
-      throw new ServiceError(`invalid public key from [${url}]`, e);
-    }
-    throw e;
-  }
-}
-
 /**
  * Fetches the key access servers for a given platform URL.
  * @param platformUrl The platform URL to fetch key access servers for.

package/src/auth/auth.ts

@@ -1,4 +1,9 @@
-import { type JWTHeaderParameters, type JWTPayload, SignJWT } from 'jose';
+import {
+  type CryptoService,
+  type KeyPair,
+  type PrivateKey,
+} from '../../tdf3/src/crypto/declarations.js';
+import { signJwt, type JwtHeader, type JwtPayload } from '../../tdf3/src/crypto/jwt.js';
 
 export type HttpMethod =
   | 'GET'
@@ -54,22 +59,26 @@ function getTimestampInSeconds() {
 
 /**
  * Generate a JWT (or JWS-ed object)
- * @param toSign the data to sign. Interpreted as JWTPayload but AFAIK this isn't required
- * @param privateKey an RSA key
+ * @param toSign the data to sign. Interpreted as JwtPayload but AFAIK this isn't required
+ * @param privateKey an opaque RSA private key
+ * @param cryptoService the crypto service to use for signing
+ * @param jwtProtectedHeader optional JWT header, defaults to RS256
  * @returns the signed object, with a JWS header. This may be a JWT.
  */
 export async function reqSignature(
   toSign: unknown,
-  privateKey: CryptoKey,
-  jwtProtectedHeader: JWTHeaderParameters = { alg: 'RS256' }
+  privateKey: PrivateKey,
+  cryptoService: CryptoService,
+  jwtProtectedHeader: JwtHeader = { alg: 'RS256' }
 ) {
   const now = getTimestampInSeconds();
   const anHour = 3600;
-  return new SignJWT(toSign as JWTPayload)
-    .setProtectedHeader(jwtProtectedHeader)
-    .setIssuedAt(now - anHour)
-    .setExpirationTime(now + anHour)
-    .sign(privateKey);
+  const payload: JwtPayload = {
+    ...(toSign as JwtPayload),
+    iat: now - anHour,
+    exp: now + anHour,
+  };
+  return signJwt(cryptoService, payload, privateKey, jwtProtectedHeader);
 }
 
 /**
@@ -90,10 +99,10 @@ export type AuthProvider = {
    * using the cached refresh token, and update the auth server config with the
    * current key.
    *
-   * @param signingKey the client signing key pair. Will be bound
+   * @param signingKey the client signing key pair (opaque keys). Will be bound
    * to the OIDC token and require a DPoP header, when set.
    */
-  updateClientPublicKey(signingKey?: CryptoKeyPair): Promise<void>;
+  updateClientPublicKey(signingKey?: KeyPair): Promise<void>;
 
   /**
    * Augment the provided http request with custom auth info to be used by backend services.

package/src/auth/dpop.ts

@@ -0,0 +1,222 @@
+// pulled from https://github.com/panva/dpop/tree/v1.4.1
+// Modified to use CryptoService instead of crypto.subtle
+
+import type {
+  CryptoService,
+  KeyPair,
+  PrivateKey,
+  AsymmetricSigningAlgorithm,
+} from '../../tdf3/src/crypto/declarations.js';
+
+export type JsonObject = { [Key in string]?: JsonValue };
+export type JsonArray = JsonValue[];
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+
+const encoder = new TextEncoder();
+
+function buf(input: string): Uint8Array {
+  return encoder.encode(input);
+}
+
+interface DPoPJwtHeaderParameters {
+  alg: JWSAlgorithm;
+  typ: string;
+  jwk: JsonWebKey;
+}
+
+/**
+ * Minimal JWT sign() implementation using CryptoService.
+ */
+async function jwt(
+  header: DPoPJwtHeaderParameters,
+  claimsSet: Record<string, unknown>,
+  privateKey: PrivateKey,
+  cryptoService: CryptoService
+) {
+  const input = `${b64u(buf(JSON.stringify(header)))}.${b64u(buf(JSON.stringify(claimsSet)))}`;
+  const signature = await cryptoService.sign(
+    buf(input),
+    privateKey,
+    header.alg as AsymmetricSigningAlgorithm
+  );
+  return `${input}.${b64u(signature)}`;
+}
+
+const CHUNK_SIZE = 0x8000;
+function encodeBase64Url(input: Uint8Array | ArrayBuffer) {
+  const bytes = input instanceof ArrayBuffer ? new Uint8Array(input) : input;
+
+  const arr = [];
+  for (let i = 0; i < bytes.byteLength; i += CHUNK_SIZE) {
+    arr.push(
+      String.fromCharCode.apply(null, bytes.subarray(i, i + CHUNK_SIZE) as unknown as number[])
+    );
+  }
+  return btoa(arr.join('')).replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+}
+
+function b64u(input: Uint8Array | ArrayBuffer) {
+  return encodeBase64Url(input);
+}
+
+/**
+ * Generates 32 random bytes and encodes them using base64url.
+ */
+async function randomBytes(cryptoService: CryptoService) {
+  return b64u(await cryptoService.randomBytes(32));
+}
+
+/**
+ * Supported JWS `alg` Algorithm identifiers.
+ *
+ * @example PS256 CryptoKey algorithm
+ * ```ts
+ * interface Ps256Algorithm extends RsaHashedKeyAlgorithm {
+ *   name: 'RSA-PSS'
+ *   hash: { name: 'SHA-256' }
+ * }
+ * ```
+ *
+ * @example CryptoKey algorithm for the `ES256` JWS Algorithm Identifier
+ * ```ts
+ * interface Es256Algorithm extends EcKeyAlgorithm {
+ *   name: 'ECDSA'
+ *   namedCurve: 'P-256'
+ * }
+ * ```
+ *
+ * @example CryptoKey algorithm for the `RS256` JWS Algorithm Identifier
+ * ```ts
+ * interface Rs256Algorithm extends RsaHashedKeyAlgorithm {
+ *   name: 'RSASSA-PKCS1-v1_5'
+ *   hash: { name: 'SHA-256' }
+ * }
+ * ```
+ *
+ * @example CryptoKey algorithm for the `EdDSA` JWS Algorithm Identifier (Experimental)
+ *
+ * Runtime support for this algorithm is very limited, it depends on the [Secure Curves in the Web
+ * Cryptography API](https://wicg.github.io/webcrypto-secure-curves/) proposal which is yet to be
+ * widely adopted. If the proposal changes this implementation will follow up with a minor release.
+ *
+ * ```ts
+ * interface EdDSAAlgorithm extends KeyAlgorithm {
+ *   name: 'Ed25519'
+ * }
+ * ```
+ */
+export type JWSAlgorithm = 'PS256' | 'ES256' | 'ES384' | 'ES512' | 'RS256' | 'EdDSA';
+
+class UnsupportedOperationError extends Error {
+  constructor(message?: string) {
+    super(message ?? 'operation not supported');
+    this.name = this.constructor.name;
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+}
+
+/**
+ * Determines a supported JWS `alg` identifier from PublicKeyInfo algorithm string.
+ */
+function determineJWSAlgorithmFromKeyInfo(algorithm: string): JWSAlgorithm {
+  if (algorithm.startsWith('rsa:')) {
+    return 'RS256';
+  }
+  switch (algorithm) {
+    case 'ec:secp256r1':
+      return 'ES256';
+    case 'ec:secp384r1':
+      return 'ES384';
+    case 'ec:secp521r1':
+      return 'ES512';
+    default:
+      throw new UnsupportedOperationError(`unsupported key algorithm: ${algorithm}`);
+  }
+}
+
+/**
+ * Returns the current unix timestamp in seconds.
+ */
+function epochTime() {
+  return Math.floor(Date.now() / 1000);
+}
+
+/**
+ * Generates a unique DPoP Proof JWT.
+ *
+ * @param keypair Opaque key pair
+ * @param cryptoService CryptoService for cryptographic operations
+ * @param htu The HTTP URI (without query and fragment parts) of the request
+ * @param htm The HTTP method of the request
+ * @param nonce Server-provided nonce.
+ * @param accessToken Associated access token's value.
+ * @param additional Any additional claims.
+ */
+export default async function DPoP(
+  keypair: KeyPair,
+  cryptoService: CryptoService,
+  htu: string,
+  htm: string,
+  nonce?: string,
+  accessToken?: string,
+  additional?: Record<string, JsonValue>
+): Promise<string> {
+  const privateKey = keypair?.privateKey;
+  const publicKey = keypair?.publicKey;
+
+  if (typeof htu !== 'string') {
+    throw new TypeError('"htu" must be a string');
+  }
+
+  if (typeof htm !== 'string') {
+    throw new TypeError('"htm" must be a string');
+  }
+
+  if (nonce !== undefined && typeof nonce !== 'string') {
+    throw new TypeError('"nonce" must be a string or undefined');
+  }
+
+  if (accessToken !== undefined && typeof accessToken !== 'string') {
+    throw new TypeError('"accessToken" must be a string or undefined');
+  }
+
+  if (
+    additional !== undefined &&
+    (typeof additional !== 'object' || additional === null || Array.isArray(additional))
+  ) {
+    throw new TypeError('"additional" must be an object');
+  }
+
+  // Detect algorithm from opaque key metadata
+  const alg = determineJWSAlgorithmFromKeyInfo(publicKey.algorithm);
+
+  // Export public key as JWK for the header
+  const jwk = await cryptoService.exportPublicKeyJwk(publicKey);
+
+  // Compute access token hash if provided
+  let ath: string | undefined;
+  if (accessToken) {
+    const athBytes = await cryptoService.digest('SHA-256', buf(accessToken));
+    ath = b64u(athBytes);
+  }
+
+  return jwt(
+    {
+      alg,
+      typ: 'dpop+jwt',
+      jwk,
+    },
+    {
+      ...additional,
+      iat: epochTime(),
+      jti: await randomBytes(cryptoService),
+      htm,
+      nonce,
+      htu,
+      ath,
+    },
+    privateKey,
+    cryptoService
+  );
+}

package/src/auth/oidc-clientcredentials-provider.ts

@@ -1,32 +1,40 @@
 import { ConfigurationError } from '../errors.js';
 import { AuthProvider, type HttpRequest } from './auth.js';
 import { AccessToken, type ClientSecretCredentials } from './oidc.js';
+import * as defaultCryptoService from '../../tdf3/src/crypto/index.js';
+import { type CryptoService, type KeyPair } from '../../tdf3/src/crypto/declarations.js';
 
 export class OIDCClientCredentialsProvider implements AuthProvider {
   oidcAuth: AccessToken;
 
-  constructor({
-    clientId,
-    clientSecret,
-    oidcOrigin,
-    oidcTokenEndpoint,
-    oidcUserInfoEndpoint,
-  }: Partial<ClientSecretCredentials> & Omit<ClientSecretCredentials, 'exchange'>) {
-    if (!clientId || !clientSecret) {
-      throw new ConfigurationError('clientId & clientSecret required for client credentials flow');
-    }
-
-    this.oidcAuth = new AccessToken({
-      exchange: 'client',
+  constructor(
+    {
       clientId,
       clientSecret,
       oidcOrigin,
       oidcTokenEndpoint,
       oidcUserInfoEndpoint,
-    });
+    }: Partial<ClientSecretCredentials> & Omit<ClientSecretCredentials, 'exchange'>,
+    cryptoService: CryptoService = defaultCryptoService
+  ) {
+    if (!clientId || !clientSecret) {
+      throw new ConfigurationError('clientId & clientSecret required for client credentials flow');
+    }
+
+    this.oidcAuth = new AccessToken(
+      {
+        exchange: 'client',
+        clientId,
+        clientSecret,
+        oidcOrigin,
+        oidcTokenEndpoint,
+        oidcUserInfoEndpoint,
+      },
+      cryptoService
+    );
   }
 
-  async updateClientPublicKey(signingKey: CryptoKeyPair): Promise<void> {
+  async updateClientPublicKey(signingKey: KeyPair): Promise<void> {
     await this.oidcAuth.refreshTokenClaimsWithClientPubkeyIfNeeded(signingKey);
   }
 

package/src/auth/oidc-externaljwt-provider.ts

@@ -1,35 +1,43 @@
 import { ConfigurationError } from '../errors.js';
 import { type AuthProvider, type HttpRequest } from './auth.js';
 import { AccessToken, type ExternalJwtCredentials } from './oidc.js';
+import * as defaultCryptoService from '../../tdf3/src/crypto/index.js';
+import { type CryptoService, type KeyPair } from '../../tdf3/src/crypto/declarations.js';
 
 export class OIDCExternalJwtProvider implements AuthProvider {
   oidcAuth: AccessToken;
   externalJwt?: string;
 
-  constructor({
-    clientId,
-    externalJwt,
-    oidcOrigin,
-    oidcTokenEndpoint,
-    oidcUserInfoEndpoint,
-  }: Partial<ExternalJwtCredentials> & Omit<ExternalJwtCredentials, 'exchange'>) {
-    if (!clientId || !externalJwt) {
-      throw new ConfigurationError('external JWT exchange reequires client id and jwt');
-    }
-
-    this.oidcAuth = new AccessToken({
-      exchange: 'external',
+  constructor(
+    {
       clientId,
       externalJwt,
       oidcOrigin,
       oidcTokenEndpoint,
       oidcUserInfoEndpoint,
-    });
+    }: Partial<ExternalJwtCredentials> & Omit<ExternalJwtCredentials, 'exchange'>,
+    cryptoService: CryptoService = defaultCryptoService
+  ) {
+    if (!clientId || !externalJwt) {
+      throw new ConfigurationError('external JWT exchange reequires client id and jwt');
+    }
+
+    this.oidcAuth = new AccessToken(
+      {
+        exchange: 'external',
+        clientId,
+        externalJwt,
+        oidcOrigin,
+        oidcTokenEndpoint,
+        oidcUserInfoEndpoint,
+      },
+      cryptoService
+    );
 
     this.externalJwt = externalJwt;
   }
 
-  async updateClientPublicKey(signingKey: CryptoKeyPair): Promise<void> {
+  async updateClientPublicKey(signingKey: KeyPair): Promise<void> {
     this.oidcAuth.refreshTokenClaimsWithClientPubkeyIfNeeded(signingKey);
   }
 

package/src/auth/oidc-refreshtoken-provider.ts

@@ -1,6 +1,8 @@
 import { ConfigurationError } from '../errors.js';
 import { type AuthProvider, type HttpRequest } from './auth.js';
 import { AccessToken, type RefreshTokenCredentials } from './oidc.js';
+import * as defaultCryptoService from '../../tdf3/src/crypto/index.js';
+import { type CryptoService, type KeyPair } from '../../tdf3/src/crypto/declarations.js';
 
 /**
  * An AuthProvider that uses an OIDC refresh token to obtain an access token.
@@ -20,29 +22,35 @@ export class OIDCRefreshTokenProvider implements AuthProvider {
   oidcAuth: AccessToken;
   refreshToken?: string;
 
-  constructor({
-    clientId,
-    refreshToken,
-    oidcOrigin,
-    oidcTokenEndpoint,
-    oidcUserInfoEndpoint,
-  }: Partial<RefreshTokenCredentials> & Omit<RefreshTokenCredentials, 'exchange'>) {
-    if (!clientId || !refreshToken) {
-      throw new ConfigurationError('refresh token or client id missing');
-    }
-
-    this.oidcAuth = new AccessToken({
-      exchange: 'refresh',
+  constructor(
+    {
       clientId,
       refreshToken,
       oidcOrigin,
       oidcTokenEndpoint,
       oidcUserInfoEndpoint,
-    });
+    }: Partial<RefreshTokenCredentials> & Omit<RefreshTokenCredentials, 'exchange'>,
+    cryptoService: CryptoService = defaultCryptoService
+  ) {
+    if (!clientId || !refreshToken) {
+      throw new ConfigurationError('refresh token or client id missing');
+    }
+
+    this.oidcAuth = new AccessToken(
+      {
+        exchange: 'refresh',
+        clientId,
+        refreshToken,
+        oidcOrigin,
+        oidcTokenEndpoint,
+        oidcUserInfoEndpoint,
+      },
+      cryptoService
+    );
     this.refreshToken = refreshToken;
   }
 
-  async updateClientPublicKey(signingKey: CryptoKeyPair): Promise<void> {
+  async updateClientPublicKey(signingKey: KeyPair): Promise<void> {
     await this.oidcAuth.refreshTokenClaimsWithClientPubkeyIfNeeded(signingKey);
   }