@sebastienrousseau/crypto-lib 0.0.2 → 0.0.7

package/dist/protocols/opaque/envelope.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCleartextCredentials = createCleartextCredentials;
+exports.serializeCleartextCredentials = serializeCleartextCredentials;
+exports.randomizePassword = randomizePassword;
+exports.maskingKeyFor = maskingKeyFor;
+exports.envelopeKeys = envelopeKeys;
+exports.store = store;
+exports.recover = recover;
+const errors_1 = require("../../errors");
+const utils_1 = require("../../utils");
+const suite_1 = require("./suite");
+function identityOr(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    const bytes = (0, suite_1.toBytes)(value);
+    if (bytes.length < 1 || bytes.length > 0xffff) {
+        throw new errors_1.CryptoError("OPAQUE identities must be 1 to 65535 bytes", suite_1.OpaqueErrorCode.INVALID_INPUT);
+    }
+    return bytes;
+}
+function createCleartextCredentials(serverPublicKey, clientPublicKey, ids) {
+    return {
+        serverPublicKey,
+        serverIdentity: identityOr(ids.serverIdentity, serverPublicKey),
+        clientIdentity: identityOr(ids.clientIdentity, clientPublicKey),
+    };
+}
+function serializeCleartextCredentials(cc) {
+    return (0, suite_1.concat)(cc.serverPublicKey, (0, suite_1.i2osp)(cc.serverIdentity.length, 2), cc.serverIdentity, (0, suite_1.i2osp)(cc.clientIdentity.length, 2), cc.clientIdentity);
+}
+function randomizePassword(s, ksf, oprfOutput) {
+    const stretched = ksf.stretch(oprfOutput);
+    return (0, suite_1.kdfExtract)(s, new Uint8Array(0), (0, suite_1.concat)(oprfOutput, stretched));
+}
+function maskingKeyFor(s, randomizedPassword) {
+    return (0, suite_1.kdfExpand)(s, randomizedPassword, (0, suite_1.utf8)("MaskingKey"), s.Nh);
+}
+function envelopeKeys(s, randomizedPassword, nonce) {
+    const derive = (label, length) => (0, suite_1.kdfExpand)(s, randomizedPassword, (0, suite_1.concat)(nonce, (0, suite_1.utf8)(label)), length);
+    return {
+        authKey: derive("AuthKey", s.Nh),
+        exportKey: derive("ExportKey", s.Nh),
+        keyPair: (0, suite_1.deriveDiffieHellmanKeyPair)(s, derive("PrivateKey", suite_1.Nseed)),
+    };
+}
+function authTag(s, authKey, nonce, cc) {
+    return (0, suite_1.mac)(s, authKey, (0, suite_1.concat)(nonce, serializeCleartextCredentials(cc)));
+}
+function store(s, randomizedPassword, serverPublicKey, ids, nonce) {
+    const { authKey, exportKey, keyPair } = envelopeKeys(s, randomizedPassword, nonce);
+    const cc = createCleartextCredentials(serverPublicKey, keyPair.publicKey, ids);
+    const envelope = {
+        nonce: nonce.slice(),
+        authTag: authTag(s, authKey, nonce, cc),
+    };
+    return {
+        envelope,
+        clientPublicKey: keyPair.publicKey,
+        maskingKey: maskingKeyFor(s, randomizedPassword),
+        exportKey,
+    };
+}
+function recover(s, randomizedPassword, serverPublicKey, envelope, ids) {
+    const { authKey, exportKey, keyPair } = envelopeKeys(s, randomizedPassword, envelope.nonce);
+    const cc = createCleartextCredentials(serverPublicKey, keyPair.publicKey, ids);
+    const expected = authTag(s, authKey, envelope.nonce, cc);
+    if (!(0, utils_1.timingSafeEqual)(envelope.authTag, expected)) {
+        throw new errors_1.CryptoError("OPAQUE envelope recovery failed: wrong password or invalid response", suite_1.OpaqueErrorCode.ENVELOPE_RECOVERY);
+    }
+    return {
+        clientPrivateKey: keyPair.privateKey,
+        cleartextCredentials: cc,
+        exportKey,
+    };
+}
+//# sourceMappingURL=envelope.js.map

package/dist/protocols/opaque/ksf.d.ts

@@ -0,0 +1,15 @@
+export interface Ksf {
+    readonly name: string;
+    stretch(msg: Uint8Array): Uint8Array;
+}
+export interface ScryptKsfParams {
+    N: number;
+    r: number;
+    p: number;
+    dkLen: number;
+}
+export declare const RFC9807_SCRYPT_PARAMS: Readonly<ScryptKsfParams>;
+export declare function scryptKsf(params?: Partial<ScryptKsfParams>): Ksf;
+export declare const identityKsf: Ksf;
+export declare const DEFAULT_KSF: Ksf;
+//# sourceMappingURL=ksf.d.ts.map

package/dist/protocols/opaque/ksf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ksf.d.ts","sourceRoot":"","sources":["../../../src/protocols/opaque/ksf.ts"],"names":[],"mappings":"AAyBA,MAAM,WAAW,GAAG;IAElB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,OAAO,CAAC,GAAG,EAAE,UAAU,GAAG,UAAU,CAAC;CACtC;AAGD,MAAM,WAAW,eAAe;IAE9B,CAAC,EAAE,MAAM,CAAC;IAEV,CAAC,EAAE,MAAM,CAAC;IAEV,CAAC,EAAE,MAAM,CAAC;IAEV,KAAK,EAAE,MAAM,CAAC;CACf;AAGD,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,eAAe,CAK1D,CAAC;AASH,wBAAgB,SAAS,CAAC,MAAM,GAAE,OAAO,CAAC,eAAe,CAAM,GAAG,GAAG,CAQpE;AAQD,eAAO,MAAM,WAAW,EAAE,GAGxB,CAAC;AAGH,eAAO,MAAM,WAAW,EAAE,GAAiB,CAAC"}

package/dist/protocols/opaque/ksf.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_KSF = exports.identityKsf = exports.RFC9807_SCRYPT_PARAMS = void 0;
+exports.scryptKsf = scryptKsf;
+const scrypt_js_1 = require("@noble/hashes/scrypt.js");
+const cost_limits_1 = require("../../modern/cost-limits");
+exports.RFC9807_SCRYPT_PARAMS = Object.freeze({
+    N: 32768,
+    r: 8,
+    p: 1,
+    dkLen: 32,
+});
+function scryptKsf(params = {}) {
+    const { N, r, p, dkLen } = { ...exports.RFC9807_SCRYPT_PARAMS, ...params };
+    (0, cost_limits_1.checkScryptCosts)(N, r, p);
+    const salt = new Uint8Array(16);
+    return Object.freeze({
+        name: `scrypt(N=${N},r=${r},p=${p},dkLen=${dkLen})`,
+        stretch: (msg) => (0, scrypt_js_1.scrypt)(msg, salt, { N, r, p, dkLen }),
+    });
+}
+exports.identityKsf = Object.freeze({
+    name: "Identity",
+    stretch: (msg) => msg.slice(),
+});
+exports.DEFAULT_KSF = scryptKsf();
+//# sourceMappingURL=ksf.js.map

package/dist/protocols/opaque/messages.d.ts

@@ -0,0 +1,61 @@
+import type { Suite, SuiteId } from "./suite";
+export interface RegistrationRequest {
+    blindedMessage: Uint8Array;
+}
+export interface RegistrationResponse {
+    evaluatedMessage: Uint8Array;
+    serverPublicKey: Uint8Array;
+}
+export interface Envelope {
+    nonce: Uint8Array;
+    authTag: Uint8Array;
+}
+export interface RegistrationRecord {
+    clientPublicKey: Uint8Array;
+    maskingKey: Uint8Array;
+    envelope: Envelope;
+}
+export interface CredentialRequest {
+    blindedMessage: Uint8Array;
+}
+export interface CredentialResponse {
+    evaluatedMessage: Uint8Array;
+    maskingNonce: Uint8Array;
+    maskedResponse: Uint8Array;
+}
+export interface AuthRequest {
+    clientNonce: Uint8Array;
+    clientPublicKeyshare: Uint8Array;
+}
+export interface KE1 {
+    credentialRequest: CredentialRequest;
+    authRequest: AuthRequest;
+}
+export interface AuthResponse {
+    serverNonce: Uint8Array;
+    serverPublicKeyshare: Uint8Array;
+    serverMac: Uint8Array;
+}
+export interface KE2 {
+    credentialResponse: CredentialResponse;
+    authResponse: AuthResponse;
+}
+export interface KE3 {
+    clientMac: Uint8Array;
+}
+export declare function maskedResponseLength(s: Suite): number;
+export declare function serializeEnvelope(e: Envelope): Uint8Array;
+export declare function serializeCredentialResponse(r: CredentialResponse): Uint8Array<ArrayBufferLike> & Uint8Array<ArrayBuffer>;
+export declare function serializeRegistrationRequest(m: RegistrationRequest): Uint8Array<ArrayBuffer>;
+export declare function deserializeRegistrationRequest(bytes: Uint8Array, suite?: SuiteId): RegistrationRequest;
+export declare function serializeRegistrationResponse(m: RegistrationResponse): Uint8Array<ArrayBufferLike> & Uint8Array<ArrayBuffer>;
+export declare function deserializeRegistrationResponse(bytes: Uint8Array, suite?: SuiteId): RegistrationResponse;
+export declare function serializeRegistrationRecord(m: RegistrationRecord): Uint8Array<ArrayBufferLike> & Uint8Array<ArrayBuffer>;
+export declare function deserializeRegistrationRecord(bytes: Uint8Array, suite?: SuiteId): RegistrationRecord;
+export declare function serializeKE1(m: KE1): Uint8Array;
+export declare function deserializeKE1(bytes: Uint8Array, suite?: SuiteId): KE1;
+export declare function serializeKE2(m: KE2): Uint8Array;
+export declare function deserializeKE2(bytes: Uint8Array, suite?: SuiteId): KE2;
+export declare function serializeKE3(m: KE3): Uint8Array;
+export declare function deserializeKE3(bytes: Uint8Array, suite?: SuiteId): KE3;
+//# sourceMappingURL=messages.d.ts.map

package/dist/protocols/opaque/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/protocols/opaque/messages.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAG9C,MAAM,WAAW,mBAAmB;IAElC,cAAc,EAAE,UAAU,CAAC;CAC5B;AAGD,MAAM,WAAW,oBAAoB;IAEnC,gBAAgB,EAAE,UAAU,CAAC;IAE7B,eAAe,EAAE,UAAU,CAAC;CAC7B;AAGD,MAAM,WAAW,QAAQ;IAEvB,KAAK,EAAE,UAAU,CAAC;IAElB,OAAO,EAAE,UAAU,CAAC;CACrB;AAQD,MAAM,WAAW,kBAAkB;IAEjC,eAAe,EAAE,UAAU,CAAC;IAE5B,UAAU,EAAE,UAAU,CAAC;IAEvB,QAAQ,EAAE,QAAQ,CAAC;CACpB;AAGD,MAAM,WAAW,iBAAiB;IAEhC,cAAc,EAAE,UAAU,CAAC;CAC5B;AAGD,MAAM,WAAW,kBAAkB;IAEjC,gBAAgB,EAAE,UAAU,CAAC;IAE7B,YAAY,EAAE,UAAU,CAAC;IAEzB,cAAc,EAAE,UAAU,CAAC;CAC5B;AAGD,MAAM,WAAW,WAAW;IAE1B,WAAW,EAAE,UAAU,CAAC;IAExB,oBAAoB,EAAE,UAAU,CAAC;CAClC;AAGD,MAAM,WAAW,GAAG;IAElB,iBAAiB,EAAE,iBAAiB,CAAC;IAErC,WAAW,EAAE,WAAW,CAAC;CAC1B;AAGD,MAAM,WAAW,YAAY;IAE3B,WAAW,EAAE,UAAU,CAAC;IAExB,oBAAoB,EAAE,UAAU,CAAC;IAEjC,SAAS,EAAE,UAAU,CAAC;CACvB;AAGD,MAAM,WAAW,GAAG;IAElB,kBAAkB,EAAE,kBAAkB,CAAC;IAEvC,YAAY,EAAE,YAAY,CAAC;CAC5B;AAGD,MAAM,WAAW,GAAG;IAElB,SAAS,EAAE,UAAU,CAAC;CACvB;AAgBD,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAErD;AAGD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,QAAQ,GAAG,UAAU,CAEzD;AAGD,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,kBAAkB,yDAEhE;AAGD,wBAAgB,4BAA4B,CAAC,CAAC,EAAE,mBAAmB,2BAElE;AAGD,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,UAAU,EACjB,KAAK,GAAE,OAAuB,GAC7B,mBAAmB,CAOrB;AAGD,wBAAgB,6BAA6B,CAAC,CAAC,EAAE,oBAAoB,yDAEpE;AAMD,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,UAAU,EACjB,KAAK,GAAE,OAAuB,GAC7B,oBAAoB,CAStB;AAGD,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,kBAAkB,yDAEhE;AAMD,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,UAAU,EACjB,KAAK,GAAE,OAAuB,GAC7B,kBAAkB,CASpB;AAGD,wBAAgB,YAAY,CAAC,CAAC,EAAE,GAAG,GAAG,UAAU,CAM/C;AAGD,wBAAgB,cAAc,CAC5B,KAAK,EAAE,UAAU,EACjB,KAAK,GAAE,OAAuB,GAC7B,GAAG,CAWL;AAGD,wBAAgB,YAAY,CAAC,CAAC,EAAE,GAAG,GAAG,UAAU,CAQ/C;AAGD,wBAAgB,cAAc,CAC5B,KAAK,EAAE,UAAU,EACjB,KAAK,GAAE,OAAuB,GAC7B,GAAG,CAiBL;AAGD,wBAAgB,YAAY,CAAC,CAAC,EAAE,GAAG,GAAG,UAAU,CAE/C;AAGD,wBAAgB,cAAc,CAC5B,KAAK,EAAE,UAAU,EACjB,KAAK,GAAE,OAAuB,GAC7B,GAAG,CAGL"}

package/dist/protocols/opaque/messages.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maskedResponseLength = maskedResponseLength;
+exports.serializeEnvelope = serializeEnvelope;
+exports.serializeCredentialResponse = serializeCredentialResponse;
+exports.serializeRegistrationRequest = serializeRegistrationRequest;
+exports.deserializeRegistrationRequest = deserializeRegistrationRequest;
+exports.serializeRegistrationResponse = serializeRegistrationResponse;
+exports.deserializeRegistrationResponse = deserializeRegistrationResponse;
+exports.serializeRegistrationRecord = serializeRegistrationRecord;
+exports.deserializeRegistrationRecord = deserializeRegistrationRecord;
+exports.serializeKE1 = serializeKE1;
+exports.deserializeKE1 = deserializeKE1;
+exports.serializeKE2 = serializeKE2;
+exports.deserializeKE2 = deserializeKE2;
+exports.serializeKE3 = serializeKE3;
+exports.deserializeKE3 = deserializeKE3;
+const errors_1 = require("../../errors");
+const suite_1 = require("./suite");
+function split(bytes, lengths, label) {
+    const total = lengths.reduce((a, b) => a + b, 0);
+    if (!(bytes instanceof Uint8Array) || bytes.length !== total) {
+        throw new errors_1.CryptoError(`Invalid ${label}: expected ${total} bytes`, suite_1.OpaqueErrorCode.DESERIALIZE);
+    }
+    let offset = 0;
+    return lengths.map((len) => bytes.slice(offset, (offset += len)));
+}
+function maskedResponseLength(s) {
+    return s.Npk + suite_1.Nn + s.Nh;
+}
+function serializeEnvelope(e) {
+    return (0, suite_1.concat)(e.nonce, e.authTag);
+}
+function serializeCredentialResponse(r) {
+    return (0, suite_1.concat)(r.evaluatedMessage, r.maskingNonce, r.maskedResponse);
+}
+function serializeRegistrationRequest(m) {
+    return m.blindedMessage.slice();
+}
+function deserializeRegistrationRequest(bytes, suite = "P256-SHA256") {
+    const [blindedMessage] = split(bytes, [(0, suite_1.getSuite)(suite).Noe], "RegistrationRequest");
+    return { blindedMessage };
+}
+function serializeRegistrationResponse(m) {
+    return (0, suite_1.concat)(m.evaluatedMessage, m.serverPublicKey);
+}
+function deserializeRegistrationResponse(bytes, suite = "P256-SHA256") {
+    const s = (0, suite_1.getSuite)(suite);
+    const [evaluatedMessage, serverPublicKey] = split(bytes, [s.Noe, s.Npk], "RegistrationResponse");
+    (0, suite_1.decodeElement)(s, serverPublicKey, "server public key");
+    return { evaluatedMessage, serverPublicKey };
+}
+function serializeRegistrationRecord(m) {
+    return (0, suite_1.concat)(m.clientPublicKey, m.maskingKey, serializeEnvelope(m.envelope));
+}
+function deserializeRegistrationRecord(bytes, suite = "P256-SHA256") {
+    const s = (0, suite_1.getSuite)(suite);
+    const [clientPublicKey, maskingKey, nonce, authTag] = split(bytes, [s.Npk, s.Nh, suite_1.Nn, s.Nh], "RegistrationRecord");
+    (0, suite_1.decodeElement)(s, clientPublicKey, "client public key");
+    return { clientPublicKey, maskingKey, envelope: { nonce, authTag } };
+}
+function serializeKE1(m) {
+    return (0, suite_1.concat)(m.credentialRequest.blindedMessage, m.authRequest.clientNonce, m.authRequest.clientPublicKeyshare);
+}
+function deserializeKE1(bytes, suite = "P256-SHA256") {
+    const s = (0, suite_1.getSuite)(suite);
+    const [blindedMessage, clientNonce, clientPublicKeyshare] = split(bytes, [s.Noe, suite_1.Nn, s.Npk], "KE1");
+    return {
+        credentialRequest: { blindedMessage },
+        authRequest: { clientNonce, clientPublicKeyshare },
+    };
+}
+function serializeKE2(m) {
+    const a = m.authResponse;
+    return (0, suite_1.concat)(serializeCredentialResponse(m.credentialResponse), a.serverNonce, a.serverPublicKeyshare, a.serverMac);
+}
+function deserializeKE2(bytes, suite = "P256-SHA256") {
+    const s = (0, suite_1.getSuite)(suite);
+    const lengths = [s.Noe, suite_1.Nn, maskedResponseLength(s), suite_1.Nn, s.Npk, s.Nh];
+    const [evaluatedMessage, maskingNonce, maskedResponse, ...auth] = split(bytes, lengths, "KE2");
+    const [serverNonce, serverPublicKeyshare, serverMac] = auth;
+    return {
+        credentialResponse: { evaluatedMessage, maskingNonce, maskedResponse },
+        authResponse: { serverNonce, serverPublicKeyshare, serverMac },
+    };
+}
+function serializeKE3(m) {
+    return m.clientMac.slice();
+}
+function deserializeKE3(bytes, suite = "P256-SHA256") {
+    const [clientMac] = split(bytes, [(0, suite_1.getSuite)(suite).Nh], "KE3");
+    return { clientMac };
+}
+//# sourceMappingURL=messages.js.map

package/dist/protocols/opaque/server.d.ts

@@ -0,0 +1,33 @@
+import type { DerivedKeys, ServerLoginState } from "./ake";
+import type { OpaqueConfig } from "./config";
+import type { Identities } from "./envelope";
+import type { KE1, KE2, KE3, RegistrationRecord, RegistrationRequest, RegistrationResponse } from "./messages";
+export interface ServerSetup {
+    serverPrivateKey: Uint8Array;
+    serverPublicKey: Uint8Array;
+    oprfSeed: Uint8Array;
+}
+export interface GenerateKE2Input extends ServerSetup, Identities {
+    record: RegistrationRecord;
+    credentialIdentifier: Uint8Array | string;
+    ke1: KE1;
+}
+export interface KE2Randomness {
+    maskingNonce?: Uint8Array;
+    serverNonce?: Uint8Array;
+    serverKeyshareSeed?: Uint8Array;
+}
+export declare function createServerSetup(config?: OpaqueConfig): ServerSetup;
+export declare function createFakeRecord(config?: OpaqueConfig): RegistrationRecord;
+export declare function createRegistrationResponse(request: RegistrationRequest, serverPublicKey: Uint8Array, credentialIdentifier: Uint8Array | string, oprfSeed: Uint8Array, config?: OpaqueConfig): RegistrationResponse;
+export declare function generateKE2With(input: GenerateKE2Input, config: OpaqueConfig, r: KE2Randomness): {
+    ke2: KE2;
+    state: ServerLoginState;
+    keys: DerivedKeys;
+};
+export declare function generateKE2(input: GenerateKE2Input, config?: OpaqueConfig): {
+    ke2: KE2;
+    state: ServerLoginState;
+};
+export declare function serverFinish(state: ServerLoginState, ke3: KE3): Uint8Array;
+//# sourceMappingURL=server.d.ts.map

package/dist/protocols/opaque/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/protocols/opaque/server.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAE3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAG7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAS7C,OAAO,KAAK,EACV,GAAG,EACH,GAAG,EACH,GAAG,EACH,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAIpB,MAAM,WAAW,WAAW;IAE1B,gBAAgB,EAAE,UAAU,CAAC;IAE7B,eAAe,EAAE,UAAU,CAAC;IAE5B,QAAQ,EAAE,UAAU,CAAC;CACtB;AAGD,MAAM,WAAW,gBAAiB,SAAQ,WAAW,EAAE,UAAU;IAE/D,MAAM,EAAE,kBAAkB,CAAC;IAE3B,oBAAoB,EAAE,UAAU,GAAG,MAAM,CAAC;IAE1C,GAAG,EAAE,GAAG,CAAC;CACV;AAGD,MAAM,WAAW,aAAa;IAC5B,YAAY,CAAC,EAAE,UAAU,CAAC;IAC1B,WAAW,CAAC,EAAE,UAAU,CAAC;IACzB,kBAAkB,CAAC,EAAE,UAAU,CAAC;CACjC;AASD,wBAAgB,iBAAiB,CAAC,MAAM,GAAE,YAAiB,GAAG,WAAW,CAQxE;AAYD,wBAAgB,gBAAgB,CAC9B,MAAM,GAAE,YAAiB,GACxB,kBAAkB,CAQpB;AAaD,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,mBAAmB,EAC5B,eAAe,EAAE,UAAU,EAC3B,oBAAoB,EAAE,UAAU,GAAG,MAAM,EACzC,QAAQ,EAAE,UAAU,EACpB,MAAM,GAAE,YAAiB,GACxB,oBAAoB,CAetB;AAGD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,gBAAgB,EACvB,MAAM,EAAE,YAAY,EACpB,CAAC,EAAE,aAAa,GACf;IAAE,GAAG,EAAE,GAAG,CAAC;IAAC,KAAK,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,WAAW,CAAA;CAAE,CA+B1D;AAYD,wBAAgB,WAAW,CACzB,KAAK,EAAE,gBAAgB,EACvB,MAAM,GAAE,YAAiB,GACxB;IAAE,GAAG,EAAE,GAAG,CAAC;IAAC,KAAK,EAAE,gBAAgB,CAAA;CAAE,CAGvC;AAaD,wBAAgB,YAAY,CAAC,KAAK,EAAE,gBAAgB,EAAE,GAAG,EAAE,GAAG,GAAG,UAAU,CAE1E"}

package/dist/protocols/opaque/server.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServerSetup = createServerSetup;
+exports.createFakeRecord = createFakeRecord;
+exports.createRegistrationResponse = createRegistrationResponse;
+exports.generateKE2With = generateKE2With;
+exports.generateKE2 = generateKE2;
+exports.serverFinish = serverFinish;
+const utils_js_1 = require("@noble/hashes/utils.js");
+const ake_1 = require("./ake");
+const config_1 = require("./config");
+const credentials_1 = require("./credentials");
+const envelope_1 = require("./envelope");
+const messages_1 = require("./messages");
+const suite_1 = require("./suite");
+function createServerSetup(config = {}) {
+    const { s } = (0, config_1.resolveConfig)(config);
+    const kp = (0, suite_1.deriveDiffieHellmanKeyPair)(s, (0, utils_js_1.randomBytes)(suite_1.Nseed));
+    return {
+        serverPrivateKey: kp.privateKey,
+        serverPublicKey: kp.publicKey,
+        oprfSeed: (0, utils_js_1.randomBytes)(s.Nh),
+    };
+}
+function createFakeRecord(config = {}) {
+    const { s } = (0, config_1.resolveConfig)(config);
+    return {
+        clientPublicKey: (0, suite_1.deriveDiffieHellmanKeyPair)(s, (0, utils_js_1.randomBytes)(suite_1.Nseed))
+            .publicKey,
+        maskingKey: (0, utils_js_1.randomBytes)(s.Nh),
+        envelope: { nonce: new Uint8Array(suite_1.Nn), authTag: new Uint8Array(s.Nh) },
+    };
+}
+function createRegistrationResponse(request, serverPublicKey, credentialIdentifier, oprfSeed, config = {}) {
+    const { s } = (0, config_1.resolveConfig)(config);
+    const req = (0, messages_1.deserializeRegistrationRequest)((0, messages_1.serializeRegistrationRequest)(request), s.id);
+    return {
+        evaluatedMessage: (0, credentials_1.evaluateOprf)(s, oprfSeed, credentialIdentifier, req.blindedMessage),
+        serverPublicKey: serverPublicKey.slice(),
+    };
+}
+function generateKE2With(input, config, r) {
+    const { s, context } = (0, config_1.resolveConfig)(config);
+    const ke1 = (0, messages_1.deserializeKE1)((0, messages_1.serializeKE1)(input.ke1), s.id);
+    const record = (0, messages_1.deserializeRegistrationRecord)((0, messages_1.serializeRegistrationRecord)(input.record), s.id);
+    const credentialResponse = (0, credentials_1.createCredentialResponse)(s, {
+        request: ke1.credentialRequest,
+        serverPublicKey: input.serverPublicKey,
+        record,
+        credentialIdentifier: input.credentialIdentifier,
+        oprfSeed: input.oprfSeed,
+        maskingNonce: r.maskingNonce ?? (0, utils_js_1.randomBytes)(suite_1.Nn),
+    });
+    const auth = (0, ake_1.authServerRespond)(s, {
+        context,
+        cleartextCredentials: (0, envelope_1.createCleartextCredentials)(input.serverPublicKey, record.clientPublicKey, input),
+        serverPrivateKey: input.serverPrivateKey,
+        clientPublicKey: record.clientPublicKey,
+        ke1,
+        credentialResponse,
+        serverNonce: r.serverNonce ?? (0, utils_js_1.randomBytes)(suite_1.Nn),
+        serverKeyshareSeed: r.serverKeyshareSeed ?? (0, utils_js_1.randomBytes)(suite_1.Nseed),
+    });
+    const ke2 = { credentialResponse, authResponse: auth.authResponse };
+    return { ke2, state: auth.state, keys: auth.keys };
+}
+function generateKE2(input, config = {}) {
+    const { ke2, state } = generateKE2With(input, config, {});
+    return { ke2, state };
+}
+function serverFinish(state, ke3) {
+    return (0, ake_1.authServerFinalize)(state, ke3);
+}
+//# sourceMappingURL=server.js.map

package/dist/protocols/opaque/suite.d.ts

@@ -0,0 +1,58 @@
+import { p256_oprf } from "@noble/curves/nist.js";
+import { concatBytes } from "@noble/hashes/utils.js";
+import type { CHash } from "@noble/hashes/utils.js";
+export type SuiteId = "P256-SHA256" | "ristretto255-SHA512";
+export declare const OpaqueErrorCode: {
+    readonly ENVELOPE_RECOVERY: "OPAQUE_ENVELOPE_RECOVERY";
+    readonly SERVER_AUTHENTICATION: "OPAQUE_SERVER_AUTHENTICATION";
+    readonly CLIENT_AUTHENTICATION: "OPAQUE_CLIENT_AUTHENTICATION";
+    readonly DESERIALIZE: "OPAQUE_DESERIALIZE";
+    readonly INVALID_INPUT: "OPAQUE_INVALID_INPUT";
+};
+export declare const Nn = 32;
+export declare const Nseed = 32;
+interface Element {
+    multiply(scalar: bigint): Element;
+    equals(other: Element): boolean;
+    toBytes(): Uint8Array;
+}
+interface Group {
+    fromBytes(bytes: Uint8Array): Element;
+    readonly ZERO: Element;
+    readonly Fn: {
+        fromBytes(bytes: Uint8Array): bigint;
+    };
+}
+type Oprf = typeof p256_oprf.oprf;
+export interface Suite {
+    readonly id: SuiteId;
+    readonly Nh: number;
+    readonly Npk: number;
+    readonly Noe: number;
+    readonly Nok: number;
+    readonly hash: CHash;
+    readonly oprf: Oprf;
+    readonly group: Group;
+    readonly hashToGroup: (msg: Uint8Array, opts: {
+        DST: Uint8Array;
+    }) => Element;
+    readonly blindDst: Uint8Array;
+}
+export declare function utf8(s: string): Uint8Array;
+export declare function toBytes(value: Uint8Array | string): Uint8Array;
+export declare function i2osp(n: number, len: 1 | 2): Uint8Array;
+export declare const concat: typeof concatBytes;
+export declare function xor(a: Uint8Array, b: Uint8Array): Uint8Array;
+export declare function getSuite(id: SuiteId): Suite;
+export declare function kdfExtract(s: Suite, salt: Uint8Array, ikm: Uint8Array): Uint8Array<ArrayBufferLike> & Uint8Array<ArrayBuffer>;
+export declare function kdfExpand(s: Suite, prk: Uint8Array, info: Uint8Array, length: number): Uint8Array;
+export declare function mac(s: Suite, key: Uint8Array, msg: Uint8Array): Uint8Array;
+export declare function decodeElement(s: Suite, bytes: Uint8Array, label: string): Element;
+export declare function deriveDiffieHellmanKeyPair(s: Suite, seed: Uint8Array): {
+    privateKey: import("@noble/curves/abstract/oprf").ScalarBytes & Uint8Array<ArrayBuffer>;
+    publicKey: import("@noble/curves/abstract/oprf").PointBytes & Uint8Array<ArrayBuffer>;
+};
+export declare function diffieHellman(s: Suite, privateKey: Uint8Array, publicKey: Uint8Array): Uint8Array;
+export declare function blindWith(s: Suite, input: Uint8Array, blind: Uint8Array): Uint8Array;
+export {};
+//# sourceMappingURL=suite.d.ts.map

package/dist/protocols/opaque/suite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suite.d.ts","sourceRoot":"","sources":["../../../src/protocols/opaque/suite.ts"],"names":[],"mappings":"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"}

package/dist/protocols/opaque/suite.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concat = exports.Nseed = exports.Nn = exports.OpaqueErrorCode = void 0;
+exports.utf8 = utf8;
+exports.toBytes = toBytes;
+exports.i2osp = i2osp;
+exports.xor = xor;
+exports.getSuite = getSuite;
+exports.kdfExtract = kdfExtract;
+exports.kdfExpand = kdfExpand;
+exports.mac = mac;
+exports.decodeElement = decodeElement;
+exports.deriveDiffieHellmanKeyPair = deriveDiffieHellmanKeyPair;
+exports.diffieHellman = diffieHellman;
+exports.blindWith = blindWith;
+const nist_js_1 = require("@noble/curves/nist.js");
+const ed25519_js_1 = require("@noble/curves/ed25519.js");
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const hkdf_js_1 = require("@noble/hashes/hkdf.js");
+const hmac_js_1 = require("@noble/hashes/hmac.js");
+const utils_js_1 = require("@noble/hashes/utils.js");
+const errors_1 = require("../../errors");
+exports.OpaqueErrorCode = {
+    ENVELOPE_RECOVERY: "OPAQUE_ENVELOPE_RECOVERY",
+    SERVER_AUTHENTICATION: "OPAQUE_SERVER_AUTHENTICATION",
+    CLIENT_AUTHENTICATION: "OPAQUE_CLIENT_AUTHENTICATION",
+    DESERIALIZE: "OPAQUE_DESERIALIZE",
+    INVALID_INPUT: "OPAQUE_INVALID_INPUT",
+};
+exports.Nn = 32;
+exports.Nseed = 32;
+function utf8(s) {
+    return new TextEncoder().encode(s);
+}
+function toBytes(value) {
+    return typeof value === "string" ? utf8(value) : value;
+}
+function i2osp(n, len) {
+    return len === 1 ? Uint8Array.of(n) : Uint8Array.of(n >> 8, n & 0xff);
+}
+exports.concat = utils_js_1.concatBytes;
+function xor(a, b) {
+    return a.map((x, i) => x ^ b[i]);
+}
+const SUITES = {
+    "P256-SHA256": {
+        id: "P256-SHA256",
+        Nh: 32,
+        Npk: 33,
+        Noe: 33,
+        Nok: 32,
+        hash: sha2_js_1.sha256,
+        oprf: nist_js_1.p256_oprf.oprf,
+        group: nist_js_1.p256.Point,
+        hashToGroup: nist_js_1.p256_hasher.hashToCurve,
+        blindDst: utf8("HashToGroup-OPRFV1-\x00-P256-SHA256"),
+    },
+    "ristretto255-SHA512": {
+        id: "ristretto255-SHA512",
+        Nh: 64,
+        Npk: 32,
+        Noe: 32,
+        Nok: 32,
+        hash: sha2_js_1.sha512,
+        oprf: ed25519_js_1.ristretto255_oprf.oprf,
+        group: ed25519_js_1.ristretto255.Point,
+        hashToGroup: ed25519_js_1.ristretto255_hasher.hashToCurve,
+        blindDst: utf8("HashToGroup-OPRFV1-\x00-ristretto255-SHA512"),
+    },
+};
+function getSuite(id) {
+    const suite = Object.hasOwn(SUITES, id) ? SUITES[id] : undefined;
+    if (suite === undefined) {
+        throw new errors_1.CryptoError(`Unsupported OPAQUE suite: ${String(id)}`, exports.OpaqueErrorCode.INVALID_INPUT);
+    }
+    return suite;
+}
+function kdfExtract(s, salt, ikm) {
+    return (0, hkdf_js_1.extract)(s.hash, ikm, salt);
+}
+function kdfExpand(s, prk, info, length) {
+    return (0, hkdf_js_1.expand)(s.hash, prk, info, length);
+}
+function mac(s, key, msg) {
+    return (0, hmac_js_1.hmac)(s.hash, key, msg);
+}
+function decodeElement(s, bytes, label) {
+    let element;
+    try {
+        element = s.group.fromBytes(bytes);
+    }
+    catch {
+        throw new errors_1.CryptoError(`Invalid ${label}`, exports.OpaqueErrorCode.DESERIALIZE);
+    }
+    if (element.equals(s.group.ZERO)) {
+        throw new errors_1.CryptoError(`Invalid ${label}: identity element`, exports.OpaqueErrorCode.DESERIALIZE);
+    }
+    return element;
+}
+function deriveDiffieHellmanKeyPair(s, seed) {
+    const kp = s.oprf.deriveKeyPair(seed, utf8("OPAQUE-DeriveDiffieHellmanKeyPair"));
+    return { privateKey: kp.secretKey, publicKey: kp.publicKey };
+}
+function diffieHellman(s, privateKey, publicKey) {
+    return decodeElement(s, publicKey, "public key")
+        .multiply(s.group.Fn.fromBytes(privateKey))
+        .toBytes();
+}
+function blindWith(s, input, blind) {
+    return s
+        .hashToGroup(input, { DST: s.blindDst })
+        .multiply(s.group.Fn.fromBytes(blind))
+        .toBytes();
+}
+//# sourceMappingURL=suite.js.map

package/dist/protocols/pake.d.ts

@@ -0,0 +1,14 @@
+export { OpaqueErrorCode } from "./opaque/suite";
+export type { SuiteId } from "./opaque/suite";
+export { RFC9807_SCRYPT_PARAMS, scryptKsf } from "./opaque/ksf";
+export type { Ksf, ScryptKsfParams } from "./opaque/ksf";
+export type { OpaqueConfig } from "./opaque/config";
+export type { Identities } from "./opaque/envelope";
+export type { ServerLoginState } from "./opaque/ake";
+export { deserializeKE1, deserializeKE2, deserializeKE3, deserializeRegistrationRecord, deserializeRegistrationRequest, deserializeRegistrationResponse, serializeKE1, serializeKE2, serializeKE3, serializeRegistrationRecord, serializeRegistrationRequest, serializeRegistrationResponse, } from "./opaque/messages";
+export type { AuthRequest, AuthResponse, CredentialRequest, CredentialResponse, Envelope, KE1, KE2, KE3, RegistrationRecord, RegistrationRequest, RegistrationResponse, } from "./opaque/messages";
+export { createRegistrationRequest, finalizeRegistrationRequest, generateKE1, generateKE3, } from "./opaque/client";
+export type { ClientLoginState } from "./opaque/client";
+export { createFakeRecord, createRegistrationResponse, createServerSetup, generateKE2, serverFinish, } from "./opaque/server";
+export type { GenerateKE2Input, ServerSetup } from "./opaque/server";
+//# sourceMappingURL=pake.d.ts.map

package/dist/protocols/pake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pake.d.ts","sourceRoot":"","sources":["../../src/protocols/pake.ts"],"names":[],"mappings":"AA+EA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,YAAY,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,qBAAqB,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAChE,YAAY,EAAE,GAAG,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACzD,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,YAAY,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EACL,cAAc,EACd,cAAc,EACd,cAAc,EACd,6BAA6B,EAC7B,8BAA8B,EAC9B,+BAA+B,EAC/B,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,2BAA2B,EAC3B,4BAA4B,EAC5B,6BAA6B,GAC9B,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,WAAW,EACX,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,QAAQ,EACR,GAAG,EACH,GAAG,EACH,GAAG,EACH,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,yBAAyB,EACzB,2BAA2B,EAC3B,WAAW,EACX,WAAW,GACZ,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EACL,gBAAgB,EAChB,0BAA0B,EAC1B,iBAAiB,EACjB,WAAW,EACX,YAAY,GACb,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/protocols/pake.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serverFinish = exports.generateKE2 = exports.createServerSetup = exports.createRegistrationResponse = exports.createFakeRecord = exports.generateKE3 = exports.generateKE1 = exports.finalizeRegistrationRequest = exports.createRegistrationRequest = exports.serializeRegistrationResponse = exports.serializeRegistrationRequest = exports.serializeRegistrationRecord = exports.serializeKE3 = exports.serializeKE2 = exports.serializeKE1 = exports.deserializeRegistrationResponse = exports.deserializeRegistrationRequest = exports.deserializeRegistrationRecord = exports.deserializeKE3 = exports.deserializeKE2 = exports.deserializeKE1 = exports.scryptKsf = exports.RFC9807_SCRYPT_PARAMS = exports.OpaqueErrorCode = void 0;
+var suite_1 = require("./opaque/suite");
+Object.defineProperty(exports, "OpaqueErrorCode", { enumerable: true, get: function () { return suite_1.OpaqueErrorCode; } });
+var ksf_1 = require("./opaque/ksf");
+Object.defineProperty(exports, "RFC9807_SCRYPT_PARAMS", { enumerable: true, get: function () { return ksf_1.RFC9807_SCRYPT_PARAMS; } });
+Object.defineProperty(exports, "scryptKsf", { enumerable: true, get: function () { return ksf_1.scryptKsf; } });
+var messages_1 = require("./opaque/messages");
+Object.defineProperty(exports, "deserializeKE1", { enumerable: true, get: function () { return messages_1.deserializeKE1; } });
+Object.defineProperty(exports, "deserializeKE2", { enumerable: true, get: function () { return messages_1.deserializeKE2; } });
+Object.defineProperty(exports, "deserializeKE3", { enumerable: true, get: function () { return messages_1.deserializeKE3; } });
+Object.defineProperty(exports, "deserializeRegistrationRecord", { enumerable: true, get: function () { return messages_1.deserializeRegistrationRecord; } });
+Object.defineProperty(exports, "deserializeRegistrationRequest", { enumerable: true, get: function () { return messages_1.deserializeRegistrationRequest; } });
+Object.defineProperty(exports, "deserializeRegistrationResponse", { enumerable: true, get: function () { return messages_1.deserializeRegistrationResponse; } });
+Object.defineProperty(exports, "serializeKE1", { enumerable: true, get: function () { return messages_1.serializeKE1; } });
+Object.defineProperty(exports, "serializeKE2", { enumerable: true, get: function () { return messages_1.serializeKE2; } });
+Object.defineProperty(exports, "serializeKE3", { enumerable: true, get: function () { return messages_1.serializeKE3; } });
+Object.defineProperty(exports, "serializeRegistrationRecord", { enumerable: true, get: function () { return messages_1.serializeRegistrationRecord; } });
+Object.defineProperty(exports, "serializeRegistrationRequest", { enumerable: true, get: function () { return messages_1.serializeRegistrationRequest; } });
+Object.defineProperty(exports, "serializeRegistrationResponse", { enumerable: true, get: function () { return messages_1.serializeRegistrationResponse; } });
+var client_1 = require("./opaque/client");
+Object.defineProperty(exports, "createRegistrationRequest", { enumerable: true, get: function () { return client_1.createRegistrationRequest; } });
+Object.defineProperty(exports, "finalizeRegistrationRequest", { enumerable: true, get: function () { return client_1.finalizeRegistrationRequest; } });
+Object.defineProperty(exports, "generateKE1", { enumerable: true, get: function () { return client_1.generateKE1; } });
+Object.defineProperty(exports, "generateKE3", { enumerable: true, get: function () { return client_1.generateKE3; } });
+var server_1 = require("./opaque/server");
+Object.defineProperty(exports, "createFakeRecord", { enumerable: true, get: function () { return server_1.createFakeRecord; } });
+Object.defineProperty(exports, "createRegistrationResponse", { enumerable: true, get: function () { return server_1.createRegistrationResponse; } });
+Object.defineProperty(exports, "createServerSetup", { enumerable: true, get: function () { return server_1.createServerSetup; } });
+Object.defineProperty(exports, "generateKE2", { enumerable: true, get: function () { return server_1.generateKE2; } });
+Object.defineProperty(exports, "serverFinish", { enumerable: true, get: function () { return server_1.serverFinish; } });
+//# sourceMappingURL=pake.js.map