import type { CreateCredentialResult, GetCredentialResult } from "electron-webauthn";
import { PASSKEY_CREATE_CHANNEL, PASSKEY_GET_CHANNEL } from "./GuestProtocol.ts";
export type PasskeyCeremonyResult =
| Extract<CreateCredentialResult, { success: true }>
| Extract<GetCredentialResult, { success: true }>
| { readonly success: false; readonly error: string };
type PasskeyChannel = typeof PASSKEY_CREATE_CHANNEL | typeof PASSKEY_GET_CHANNEL;
// Credential Management Level 1 added `mediation` to creation requests.
type CreationOptions = CredentialCreationOptions & {
readonly mediation?: CredentialMediationRequirement;
};
type InvokePasskeyCeremony = (channel: PasskeyChannel, publicKey: unknown) => Promise<unknown>;
const NOT_ALLOWED_MESSAGE =
"The operation either timed out or was not allowed. See: https://www.w3.org/TR/webauthn-2/#sctn-privacy-considerations-client.";
const DOM_EXCEPTION_NAMES = new Set([
"AbortError",
"InvalidStateError",
"NotAllowedError",
"NotSupportedError",
"SecurityError",
]);
const fromBase64Url = (value: string) => {
const base64 = value.replaceAll("-", "+").replaceAll("_", "/");
const binary = atob(base64.padEnd(base64.length + ((4 - (base64.length % 4)) % 4), "="));
return Uint8Array.from(binary, (character) => character.charCodeAt(0)).buffer;
};
const toBase64Url = (buffer: ArrayBuffer) =>
btoa(String.fromCharCode(...new Uint8Array(buffer)))
.replaceAll("+", "-")
.replaceAll("/", "_")
.replace(/=+$/u, "");
const ceremonyError = (name: string) =>
name === "TypeError"
? new TypeError("The passkey request options are invalid.")
: new DOMException(
NOT_ALLOWED_MESSAGE,
DOM_EXCEPTION_NAMES.has(name) ? name : "NotAllowedError",
);
// Chromium drops unknown members; discard uncloneable values instead of failing the ceremony.
const toCloneable = (value: unknown): unknown => {
if (value instanceof ArrayBuffer) return value.slice(0);
if (ArrayBuffer.isView(value)) {
return new Uint8Array(value.buffer, value.byteOffset, value.byteLength).slice();
}
if (Array.isArray(value)) return value.map(toCloneable);
if (typeof value === "object" && value !== null) {
return Object.fromEntries(
Object.entries(value).flatMap(([key, member]) =>
typeof member === "function" || member === undefined ? [] : [[key, toCloneable(member)]],
),
);
}
return value;
};
// Shadow native getters: they reject objects Chromium did not create, even with the correct prototype.
const withValues = <T extends object>(target: T, values: Record<string, unknown>) => {
for (const [key, value] of Object.entries(values)) {
Object.defineProperty(target, key, { value, enumerable: true, configurable: true });
}
return target;
};
const prfOutputs = (prf: {
readonly enabled?: boolean;
readonly results?: { readonly first?: string; readonly second?: string };
}): AuthenticationExtensionsPRFOutputs => {
const first = prf.results?.first;
const second = prf.results?.second;
return {
...(prf.enabled === undefined ? {} : { enabled: prf.enabled }),
...(first === undefined
? {}
: {
results: {
first: fromBase64Url(first),
...(second === undefined ? {} : { second: fromBase64Url(second) }),
},
}),
};
};
const extensionResultsJson = (results: AuthenticationExtensionsClientOutputs) =>
JSON.parse(
JSON.stringify(results, (_key, value: unknown) =>
value instanceof ArrayBuffer ? toBase64Url(value) : value,
),
) as unknown;
const makeCredential = (input: {
readonly id: string;
readonly authenticatorAttachment: AuthenticatorAttachment | null;
readonly response: AuthenticatorResponse;
readonly responseJson: Record<string, unknown>;
readonly extensionResults: AuthenticationExtensionsClientOutputs;
}) =>
withValues(Object.create(PublicKeyCredential.prototype) as PublicKeyCredential, {
id: input.id,
rawId: fromBase64Url(input.id),
type: "public-key",
authenticatorAttachment: input.authenticatorAttachment,
response: input.response,
getClientExtensionResults: () => input.extensionResults,
toJSON: () => ({
id: input.id,
rawId: input.id,
type: "public-key",
...(input.authenticatorAttachment === null
? {}
: { authenticatorAttachment: input.authenticatorAttachment }),
response: input.responseJson,
clientExtensionResults: extensionResultsJson(input.extensionResults),
}),
});
const credentialFromCreateResult = (
data: Extract<CreateCredentialResult, { success: true }>["data"],
) => {
const transports = [...data.transports];
const publicKey = data.publicKey.length > 0 ? data.publicKey : null;
const extensionResults: AuthenticationExtensionsClientOutputs = {
...(data.extensions.credProps ? { credProps: { ...data.extensions.credProps } } : {}),
...(data.extensions.prf ? { prf: prfOutputs(data.extensions.prf) } : {}),
...(data.extensions.largeBlob ? { largeBlob: { ...data.extensions.largeBlob } } : {}),
};
return makeCredential({
id: data.credentialId,
// The native layer cannot tell a synced passkey from a security key.
authenticatorAttachment: null,
response: withValues(
Object.create(AuthenticatorAttestationResponse.prototype) as AuthenticatorAttestationResponse,
{
clientDataJSON: fromBase64Url(data.clientDataJSON),
attestationObject: fromBase64Url(data.attestationObject),
getTransports: () => [...transports],
getAuthenticatorData: () => fromBase64Url(data.authData),
getPublicKey: () => (publicKey === null ? null : fromBase64Url(publicKey)),
getPublicKeyAlgorithm: () => data.publicKeyAlgorithm,
},
),
responseJson: {
clientDataJSON: data.clientDataJSON,
attestationObject: data.attestationObject,
authenticatorData: data.authData,
transports,
...(publicKey === null ? {} : { publicKey }),
publicKeyAlgorithm: data.publicKeyAlgorithm,
},
extensionResults,
});
};
const credentialFromGetResult = (data: Extract<GetCredentialResult, { success: true }>["data"]) => {
const userHandle = data.userHandle.length > 0 ? data.userHandle : null;
const { prf, largeBlob } = data.extensions ?? {};
const extensionResults: AuthenticationExtensionsClientOutputs = {
...(prf ? { prf: prfOutputs(prf) } : {}),
...(largeBlob
? {
largeBlob: {
...(largeBlob.blob === undefined ? {} : { blob: fromBase64Url(largeBlob.blob) }),
...(largeBlob.written === undefined ? {} : { written: largeBlob.written }),
},
}
: {}),
};
return makeCredential({
id: data.credentialId,
authenticatorAttachment: null,
response: withValues(
Object.create(AuthenticatorAssertionResponse.prototype) as AuthenticatorAssertionResponse,
{
clientDataJSON: fromBase64Url(data.clientDataJSON),
authenticatorData: fromBase64Url(data.authenticatorData),
signature: fromBase64Url(data.signature),
userHandle: userHandle === null ? null : fromBase64Url(userHandle),
},
),
responseJson: {
clientDataJSON: data.clientDataJSON,
authenticatorData: data.authenticatorData,
signature: data.signature,
...(userHandle === null ? {} : { userHandle }),
},
extensionResults,
});
};
const abortReason = (signal: AbortSignal) =>
signal.reason ?? new DOMException("The operation was aborted.", "AbortError");
/** Keep conditional requests native so autofill and upgrades cannot open a modal sheet unprompted. */
export function installPasskeyBridge(invoke: InvokePasskeyCeremony) {
if (typeof CredentialsContainer === "undefined" || typeof PublicKeyCredential === "undefined") {
return;
}
const run = async (
channel: PasskeyChannel,
publicKey: unknown,
signal: AbortSignal | undefined,
): Promise<PublicKeyCredential> => {
if (signal?.aborted) throw abortReason(signal);
const ceremony = invoke(channel, toCloneable(publicKey)).then(
(value) => {
const result = value as PasskeyCeremonyResult;
if (!result.success) throw ceremonyError(result.error);
return "attestationObject" in result.data
? credentialFromCreateResult(result.data)
: credentialFromGetResult(result.data);
},
(error: unknown) => {
throw error instanceof DOMException || error instanceof TypeError
? error
: ceremonyError("NotAllowedError");
},
);
if (!signal) return ceremony;
return new Promise((resolve, reject) => {
const onAbort = () => reject(abortReason(signal));
signal.addEventListener("abort", onAbort, { once: true });
ceremony.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
});
};
const container = CredentialsContainer.prototype;
const nativeCreate = container.create;
const nativeGet = container.get;
const define = (target: object, key: string, value: unknown) =>
Object.defineProperty(target, key, { value, configurable: true, writable: true });
define(
container,
"create",
function create(this: CredentialsContainer, options?: CreationOptions) {
return options?.publicKey && options.mediation !== "conditional"
? run(PASSKEY_CREATE_CHANNEL, options.publicKey, options.signal)
: Reflect.apply(nativeCreate, this, [options]);
},
);
define(
container,
"get",
function get(this: CredentialsContainer, options?: CredentialRequestOptions) {
return options?.publicKey && options.mediation !== "conditional"
? run(PASSKEY_GET_CHANNEL, options.publicKey, options.signal)
: Reflect.apply(nativeGet, this, [options]);
},
);
define(PublicKeyCredential, "isUserVerifyingPlatformAuthenticatorAvailable", async () => true);
define(PublicKeyCredential, "isConditionalMediationAvailable", async () => false);
const nativeCapabilities = PublicKeyCredential.getClientCapabilities;
if (typeof nativeCapabilities === "function") {
define(PublicKeyCredential, "getClientCapabilities", async () => ({
...(await Reflect.apply(nativeCapabilities, PublicKeyCredential, [])),
conditionalCreate: false,
conditionalGet: false,
hybridTransport: true,
passkeyPlatformAuthenticator: true,
userVerifyingPlatformAuthenticator: true,
}));
}
}