sailfork / t3code-github / apps/ desktop/ src/ preview/ PasskeyBridge.test.ts

import { assert, describe, it } from "@effect/vitest";
import { afterEach, vi } from "vite-plus/test";

import { PASSKEY_CREATE_CHANNEL, PASSKEY_GET_CHANNEL } from "./GuestProtocol.ts";
import { installPasskeyBridge } from "./PasskeyBridge.ts";

const base64Url = (bytes: ReadonlyArray<number>) => Buffer.from(bytes).toString("base64url");
const bytesOf = (buffer: ArrayBuffer | null) => (buffer ? [...new Uint8Array(buffer)] : null);

const assertionData = {
  credentialId: base64Url([1, 2, 3]),
  clientDataJSON: base64Url([4]),
  authenticatorData: base64Url([5]),
  signature: base64Url([6, 7]),
  userHandle: base64Url([8]),
  extensions: { prf: { results: { first: base64Url([9]) } } },
};

const creationOptions: PublicKeyCredentialCreationOptions = {
  challenge: new Uint8Array([1]),
  rp: { name: "Example" },
  user: { id: new Uint8Array([2]), name: "alice", displayName: "Alice" },
  pubKeyCredParams: [{ type: "public-key", alg: -7 }],
};

const illegalInvocation = (): never => {
  throw new TypeError("Illegal invocation");
};

const install = (respond: (channel: string) => unknown) => {
  const nativeCreate = vi.fn(async () => "native-create");
  const nativeGet = vi.fn(async () => "native-get");
  class FakeCredentialsContainer {
    create() {
      return nativeCreate();
    }
    get() {
      return nativeGet();
    }
  }
  class FakePublicKeyCredential {
    get id() {
      return illegalInvocation();
    }
    get response() {
      return illegalInvocation();
    }
  }
  class FakeAttestationResponse {
    get clientDataJSON() {
      return illegalInvocation();
    }
  }
  class FakeAssertionResponse {
    get signature() {
      return illegalInvocation();
    }
  }
  vi.stubGlobal("CredentialsContainer", FakeCredentialsContainer);
  vi.stubGlobal("PublicKeyCredential", FakePublicKeyCredential);
  vi.stubGlobal("AuthenticatorAttestationResponse", FakeAttestationResponse);
  vi.stubGlobal("AuthenticatorAssertionResponse", FakeAssertionResponse);

  const invoke = vi.fn(async (channel: string, _publicKey: unknown) => respond(channel));
  installPasskeyBridge(invoke);
  return {
    invoke,
    nativeCreate,
    nativeGet,
    credentials: new FakeCredentialsContainer() as unknown as CredentialsContainer,
    FakePublicKeyCredential,
    FakeAttestationResponse,
    FakeAssertionResponse,
  };
};

describe("installPasskeyBridge", () => {
  afterEach(() => {
    vi.unstubAllGlobals();
  });

  it("serves passkey sign-in through the main process with a credential pages can verify", async () => {
    const { invoke, credentials, FakePublicKeyCredential, FakeAssertionResponse } = install(() => ({
      success: true,
      data: assertionData,
    }));
    const challenge = new Uint8Array([0, 1, 2, 3]).subarray(1);

    const credential = (await credentials.get({
      publicKey: {
        challenge,
        rpId: "example.com",
        allowCredentials: [{ type: "public-key", id: new Uint8Array([1, 2, 3]) }],
        extensions: { onHint: () => {} } as AuthenticationExtensionsClientInputs,
      },
    })) as PublicKeyCredential;

    assert.deepStrictEqual(invoke.mock.calls[0], [
      PASSKEY_GET_CHANNEL,
      {
        challenge: new Uint8Array([1, 2, 3]),
        rpId: "example.com",
        allowCredentials: [{ type: "public-key", id: new Uint8Array([1, 2, 3]) }],
        extensions: {},
      },
    ]);
    const response = credential.response as AuthenticatorAssertionResponse;
    assert.instanceOf(credential, FakePublicKeyCredential);
    assert.instanceOf(response, FakeAssertionResponse);
    assert.strictEqual(credential.id, assertionData.credentialId);
    assert.deepStrictEqual(bytesOf(credential.rawId), [1, 2, 3]);
    assert.deepStrictEqual(bytesOf(response.signature), [6, 7]);
    assert.deepStrictEqual(bytesOf(response.userHandle), [8]);
    assert.deepStrictEqual(
      bytesOf(credential.getClientExtensionResults().prf?.results?.first as ArrayBuffer),
      [9],
    );
    assert.deepStrictEqual(credential.toJSON(), {
      id: assertionData.credentialId,
      rawId: assertionData.credentialId,
      type: "public-key",
      response: {
        clientDataJSON: assertionData.clientDataJSON,
        authenticatorData: assertionData.authenticatorData,
        signature: assertionData.signature,
        userHandle: assertionData.userHandle,
      },
      clientExtensionResults: { prf: { results: { first: base64Url([9]) } } },
    });
  });

  it("rejects with the WebAuthn error the ceremony ended with", async () => {
    const { credentials } = install((channel) => ({
      success: false,
      error: channel === PASSKEY_CREATE_CHANNEL ? "InvalidStateError" : "TypeError",
    }));
    const created = await credentials
      .create({ publicKey: creationOptions })
      .catch((error: unknown) => error);
    assert.instanceOf(created, DOMException);
    assert.strictEqual((created as DOMException).name, "InvalidStateError");
    const fetched = await credentials
      .get({ publicKey: { challenge: new Uint8Array([1]) } })
      .catch((error: unknown) => error);
    assert.instanceOf(fetched, TypeError);
  });

  it("rejects as soon as the page aborts, without waiting on the system sheet", async () => {
    const { credentials } = install(() => new Promise(() => {}));
    const controller = new AbortController();

    const pending = credentials
      .get({ publicKey: { challenge: new Uint8Array([1]) }, signal: controller.signal })
      .catch((error: unknown) => error);
    controller.abort();

    const error = await pending;
    assert.instanceOf(error, DOMException);
    assert.strictEqual((error as DOMException).name, "AbortError");
  });
});