@multiplatform.one/gpg 7.17.0 → 7.19.0

package/src/signature.ts

@@ -0,0 +1,120 @@
+import { ripemd160, sha1 } from "@noble/hashes/legacy.js";
+import { sha224, sha256, sha384, sha512 } from "@noble/hashes/sha2.js";
+
+// Checks that a pasted detached signature was made over a given message,
+// without verifying it: every OpenPGP signature packet carries the first two
+// bytes of its digest, so recomputing that digest over the message tells a
+// signature for this message from one for another (1 in 65536 slips through).
+// Keycloak's GPG verifier still does the real check.
+
+const BEGIN = "-----BEGIN PGP SIGNATURE-----";
+const END = "-----END PGP SIGNATURE-----";
+
+const hashes: Record<number, (data: Uint8Array) => Uint8Array> = {
+  2: sha1,
+  3: ripemd160,
+  8: sha256,
+  9: sha384,
+  10: sha512,
+  11: sha224,
+};
+
+/** The binary packets inside the first armored PGP SIGNATURE block of `text`. */
+function dearmor(text: string): Uint8Array {
+  const start = text.indexOf(BEGIN);
+  const end = text.indexOf(END, start);
+  if (start < 0 || end < 0) throw new Error("No PGP SIGNATURE block in the paste");
+  const lines = text
+    .slice(start + BEGIN.length, end)
+    .split(/\r?\n/)
+    .map((line) => line.trim());
+  const blank = lines.indexOf("", 1);
+  const hasHeaders = lines.slice(1, blank < 0 ? 0 : blank).some((line) => line.includes(": "));
+  const body = (hasHeaders ? lines.slice(blank) : lines).filter(
+    (line) => line && !/^=[A-Za-z0-9+/]{4}$/.test(line),
+  );
+  const binary = atob(body.join(""));
+  return Uint8Array.from(binary, (c) => c.charCodeAt(0));
+}
+
+/** Signature packet bodies (tag 2), in old or new packet format. */
+function signaturePackets(bytes: Uint8Array): Uint8Array[] {
+  const packets: Uint8Array[] = [];
+  let at = 0;
+  while (at < bytes.length) {
+    const ctb = bytes[at++];
+    if (!(ctb & 0x80)) throw new Error("The PGP SIGNATURE block is not OpenPGP data");
+    let tag: number;
+    let length: number;
+    if (ctb & 0x40) {
+      tag = ctb & 0x3f;
+      const first = bytes[at++];
+      if (first < 192) length = first;
+      else if (first < 224) length = ((first - 192) << 8) + bytes[at++] + 192;
+      else if (first === 255) {
+        length = new DataView(bytes.buffer, bytes.byteOffset + at, 4).getUint32(0);
+        at += 4;
+      } else throw new Error("Partial-length PGP packets are not a detached signature");
+    } else {
+      tag = (ctb >> 2) & 0x0f;
+      const size = [1, 2, 4][ctb & 0x03];
+      if (size === undefined) throw new Error("Indeterminate-length PGP packets are not supported");
+      length = 0;
+      for (let i = 0; i < size; i++) length = length * 256 + bytes[at++];
+    }
+    if (at + length > bytes.length) throw new Error("The PGP SIGNATURE block is truncated");
+    if (tag === 2) packets.push(bytes.subarray(at, at + length));
+    at += length;
+  }
+  return packets;
+}
+
+/** The first two digest bytes of a v4 signature packet recomputed over `message`. */
+function quickCheck(packet: Uint8Array, message: Uint8Array): [expected: number, actual: number] {
+  if (packet[0] !== 4) {
+    throw new Error(
+      `A version ${packet[0]} PGP signature cannot be checked here; sign with a v4 key`,
+    );
+  }
+  const sigType = packet[1];
+  if (sigType !== 0x00 && sigType !== 0x01) {
+    throw new Error(`PGP signature type 0x${sigType.toString(16)} is not a document signature`);
+  }
+  const hash = hashes[packet[3]];
+  if (!hash) throw new Error(`PGP hash algorithm ${packet[3]} is not supported`);
+  const hashedEnd = 6 + ((packet[4] << 8) | packet[5]);
+  const unhashedLength = (packet[hashedEnd] << 8) | packet[hashedEnd + 1];
+  const left16 = hashedEnd + 2 + unhashedLength;
+  if (left16 + 2 > packet.length) throw new Error("The PGP signature packet is truncated");
+
+  const data =
+    sigType === 0x01
+      ? new TextEncoder().encode(
+          new TextDecoder().decode(message).replace(/\r?\n/g, "\n").replace(/\n/g, "\r\n"),
+        )
+      : message;
+  const trailer = new Uint8Array(6);
+  trailer[0] = 0x04;
+  trailer[1] = 0xff;
+  new DataView(trailer.buffer).setUint32(2, hashedEnd);
+  const input = new Uint8Array(data.length + hashedEnd + trailer.length);
+  input.set(data, 0);
+  input.set(packet.subarray(0, hashedEnd), data.length);
+  input.set(trailer, data.length + hashedEnd);
+  const digest = hash(input);
+  return [(packet[left16] << 8) | packet[left16 + 1], (digest[0] << 8) | digest[1]];
+}
+
+/**
+ * True when every signature in the pasted armored PGP SIGNATURE block was made
+ * over `message`'s UTF-8 bytes. Throws on a block it cannot read.
+ */
+export function gpgSignatureCovers(blob: string, message: string): boolean {
+  const packets = signaturePackets(dearmor(blob));
+  if (!packets.length) throw new Error("The PGP SIGNATURE block holds no signature");
+  const bytes = new TextEncoder().encode(message);
+  return packets.every((packet) => {
+    const [expected, actual] = quickCheck(packet, bytes);
+    return expected === actual;
+  });
+}

package/src/signer.ts

@@ -0,0 +1,142 @@
+import { useSyncExternalStore } from "react";
+import { gpgSignatureCovers } from "./signature";
+
+export { gpgSignatureCovers } from "./signature";
+
+// The GPG copy/paste signer as a client, shared by login (GpgProvider) and any
+// other signing an app needs. There is no wallet to talk to: signMessage parks a
+// request, the app shows the terminal command, the user pastes the output back
+// and submit() resolves the pending promise. Only react and @noble/hashes are
+// imported, so the `@multiplatform.one/gpg/signer` subpath stays out of the
+// connectkit graph.
+
+export const GPG_SIGNATURE_BEGIN = "-----BEGIN PGP SIGNATURE-----";
+export const GPG_PUBLIC_KEY_BEGIN = "-----BEGIN PGP PUBLIC KEY BLOCK-----";
+
+/**
+ * The terminal command that signs `message`: a detached armored signature plus
+ * the exported public key, which is the blob the user pastes back. printf %s adds
+ * no newline, so the signed bytes equal `message`. Single quotes are POSIX-escaped
+ * so a message cannot break out of the quoting.
+ */
+export function gpgSignCommand(message: string): string {
+  return `{ printf %s '${message.replace(/'/g, "'\\''")}' | gpg --detach-sign --armor; gpg --armor --export; }`;
+}
+
+/** Trim the pasted terminal output and reject it unless it holds both armored blocks. */
+export function assertGpgSignature(blob: string): string {
+  const trimmed = blob.trim();
+  if (!trimmed.includes(GPG_SIGNATURE_BEGIN) || !trimmed.includes(GPG_PUBLIC_KEY_BEGIN)) {
+    throw new Error(
+      "Paste the FULL output — it must contain both a PGP SIGNATURE and a PUBLIC KEY block.",
+    );
+  }
+  return trimmed;
+}
+
+export interface GpgSignRequest {
+  message: string;
+  command: string;
+}
+
+export interface GpgSigner {
+  readonly family: "gpg";
+  /** A GPG identity is the key fingerprint, which only arrives with the signature. */
+  readonly address: null;
+  readonly capabilities: readonly "signMessage"[];
+  /** The request waiting for pasted output, or null. */
+  readonly pending: GpgSignRequest | null;
+  /**
+   * Ask the user to sign `message` in their terminal. Resolves with the pasted
+   * armored signature followed by the armored public key, the same blob Keycloak's
+   * GPG verifier takes. A second call cancels the first.
+   */
+  signMessage(message: string): Promise<string>;
+  /**
+   * Hand pasted output to `request`, the pending request the paste box showed.
+   * Throws, and keeps the request pending, when `request` is no longer the
+   * pending one, when the paste is incomplete, or when its signature was made
+   * over a different message.
+   */
+  submit(blob: string, request: GpgSignRequest): void;
+  cancel(reason?: Error): void;
+  subscribe(listener: () => void): () => void;
+}
+
+export function createGpgSigner(): GpgSigner {
+  let pending: GpgSignRequest | null = null;
+  let settle: { resolve: (blob: string) => void; reject: (error: Error) => void } | null = null;
+  const listeners = new Set<() => void>();
+  const emit = () => {
+    for (const listener of listeners) listener();
+  };
+
+  const signer: GpgSigner = {
+    family: "gpg",
+    address: null,
+    capabilities: ["signMessage"],
+    get pending() {
+      return pending;
+    },
+    signMessage(message) {
+      settle?.reject(new Error("GPG signing was superseded by a newer request"));
+      return new Promise<string>((resolve, reject) => {
+        settle = { resolve, reject };
+        pending = { message, command: gpgSignCommand(message) };
+        emit();
+      });
+    },
+    submit(blob, request) {
+      if (!settle || !pending) throw new Error("No GPG signature was requested");
+      if (request !== pending) {
+        throw new Error(
+          "That GPG request was superseded; run the current command and paste its output",
+        );
+      }
+      const signature = assertGpgSignature(blob);
+      if (!gpgSignatureCovers(signature, pending.message)) {
+        throw new Error(
+          "That signature is over a different message; run the current command and paste its output",
+        );
+      }
+      const { resolve } = settle;
+      settle = null;
+      pending = null;
+      emit();
+      resolve(signature);
+    },
+    cancel(reason) {
+      if (!settle) return;
+      const { reject } = settle;
+      settle = null;
+      pending = null;
+      emit();
+      reject(reason ?? new Error("GPG signing was cancelled"));
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+  };
+  return signer;
+}
+
+/**
+ * Subscribe a component to a GPG signer so it re-renders when a request is
+ * parked or settled. Omitted, it is the app-wide signer, so the component that
+ * asks for a signature and the one that shows the paste box share one request.
+ */
+export function useGpgSigner(signer: GpgSigner = defaultSigner()): GpgSigner {
+  useSyncExternalStore(
+    signer.subscribe,
+    () => signer.pending,
+    () => signer.pending,
+  );
+  return signer;
+}
+
+let sharedSigner: GpgSigner | null = null;
+function defaultSigner(): GpgSigner {
+  sharedSigner ??= createGpgSigner();
+  return sharedSigner;
+}

package/types/GpgIcon.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+export declare const GpgIcon: React.FC;
+//# sourceMappingURL=GpgIcon.d.ts.map

package/types/GpgIcon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GpgIcon.d.ts","sourceRoot":"","sources":["../src/GpgIcon.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B,eAAO,MAAM,OAAO,EAAE,KAAK,CAAC,EAe3B,CAAC"}

package/types/GpgProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GpgProvider.d.ts","sourceRoot":"","sources":["../src/GpgProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAyC,MAAM,OAAO,CAAC;AAIzE,OAAO,EAAc,SAAS,EAAkB,MAAM,cAAc,CAAC;AAErE,KAAK,KAAK,GAAG,SAAS,GAAG;IACvB,QAAQ,EAAE,SAAS,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,mBAAmB,eAAe,CAAC;AAkBhD,eAAO,MAAM,WAAW,GAAI,mFAOzB,KAAK,4CAqGP,CAAC"}
+{"version":3,"file":"GpgProvider.d.ts","sourceRoot":"","sources":["../src/GpgProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAyC,MAAM,OAAO,CAAC;AAIzE,OAAO,EAAc,SAAS,EAAkB,MAAM,cAAc,CAAC;AAGrE,KAAK,KAAK,GAAG,SAAS,GAAG;IACvB,QAAQ,EAAE,SAAS,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,mBAAmB,eAAe,CAAC;AAkBhD,eAAO,MAAM,WAAW,GAAI,mFAOzB,KAAK,4CAwFP,CAAC"}

package/types/index.d.ts

@@ -1,4 +1,5 @@
 export { useGpg } from "./useGpg";
+export { createGpgSigner, useGpgSigner, gpgSignCommand, assertGpgSignature, gpgSignatureCovers, type GpgSigner, type GpgSignRequest, } from "./signer";
 export { GpgProvider, GPG_NONCE_QUERY_KEY } from "./GpgProvider";
 export { GpgContext, GpgStatusState } from "./GpgContext";
 export type { GpgConfig, GpgContextValue } from "./GpgContext";

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC1D,YAAY,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExE,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EACL,eAAe,EACf,YAAY,EACZ,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,KAAK,SAAS,EACd,KAAK,cAAc,GACpB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC1D,YAAY,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExE,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC"}

package/types/screens.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"screens.d.ts","sourceRoot":"","sources":["../src/screens.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAIL,KAAK,oBAAoB,EACzB,KAAK,SAAS,EACf,MAAM,+BAA+B,CAAC;AAOvC,eAAO,MAAM,SAAS,EAAE,SAOvB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,KAAK,CAAC,EAGtC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,GAAG,oBAAoB,CAUrF,CAAC"}
+{"version":3,"file":"screens.d.ts","sourceRoot":"","sources":["../src/screens.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAIL,KAAK,oBAAoB,EACzB,KAAK,SAAS,EACf,MAAM,+BAA+B,CAAC;AAWvC,eAAO,MAAM,SAAS,EAAE,SAavB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,KAAK,CAAC,EAGtC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,GAAG,oBAAoB,CAUrF,CAAC"}

package/types/signature.d.ts

@@ -0,0 +1,6 @@
+/**
+ * True when every signature in the pasted armored PGP SIGNATURE block was made
+ * over `message`'s UTF-8 bytes. Throws on a block it cannot read.
+ */
+export declare function gpgSignatureCovers(blob: string, message: string): boolean;
+//# sourceMappingURL=signature.d.ts.map

package/types/signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../src/signature.ts"],"names":[],"mappings":"AA2GA;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAQzE"}

package/types/signer.d.ts

@@ -0,0 +1,47 @@
+export { gpgSignatureCovers } from "./signature";
+export declare const GPG_SIGNATURE_BEGIN = "-----BEGIN PGP SIGNATURE-----";
+export declare const GPG_PUBLIC_KEY_BEGIN = "-----BEGIN PGP PUBLIC KEY BLOCK-----";
+/**
+ * The terminal command that signs `message`: a detached armored signature plus
+ * the exported public key, which is the blob the user pastes back. printf %s adds
+ * no newline, so the signed bytes equal `message`. Single quotes are POSIX-escaped
+ * so a message cannot break out of the quoting.
+ */
+export declare function gpgSignCommand(message: string): string;
+/** Trim the pasted terminal output and reject it unless it holds both armored blocks. */
+export declare function assertGpgSignature(blob: string): string;
+export interface GpgSignRequest {
+    message: string;
+    command: string;
+}
+export interface GpgSigner {
+    readonly family: "gpg";
+    /** A GPG identity is the key fingerprint, which only arrives with the signature. */
+    readonly address: null;
+    readonly capabilities: readonly "signMessage"[];
+    /** The request waiting for pasted output, or null. */
+    readonly pending: GpgSignRequest | null;
+    /**
+     * Ask the user to sign `message` in their terminal. Resolves with the pasted
+     * armored signature followed by the armored public key, the same blob Keycloak's
+     * GPG verifier takes. A second call cancels the first.
+     */
+    signMessage(message: string): Promise<string>;
+    /**
+     * Hand pasted output to `request`, the pending request the paste box showed.
+     * Throws, and keeps the request pending, when `request` is no longer the
+     * pending one, when the paste is incomplete, or when its signature was made
+     * over a different message.
+     */
+    submit(blob: string, request: GpgSignRequest): void;
+    cancel(reason?: Error): void;
+    subscribe(listener: () => void): () => void;
+}
+export declare function createGpgSigner(): GpgSigner;
+/**
+ * Subscribe a component to a GPG signer so it re-renders when a request is
+ * parked or settled. Omitted, it is the app-wide signer, so the component that
+ * asks for a signature and the one that shows the paste box share one request.
+ */
+export declare function useGpgSigner(signer?: GpgSigner): GpgSigner;
+//# sourceMappingURL=signer.d.ts.map

package/types/signer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signer.d.ts","sourceRoot":"","sources":["../src/signer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AASjD,eAAO,MAAM,mBAAmB,kCAAkC,CAAC;AACnE,eAAO,MAAM,oBAAoB,yCAAyC,CAAC;AAE3E;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,yFAAyF;AACzF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQvD;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC;IACvB,oFAAoF;IACpF,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,SAAS,aAAa,EAAE,CAAC;IAChD,sDAAsD;IACtD,QAAQ,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAAC;IACxC;;;;OAIG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9C;;;;;OAKG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,IAAI,CAAC;IACpD,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IAC7B,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;CAC7C;AAED,wBAAgB,eAAe,IAAI,SAAS,CAwD3C;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,GAAE,SAA2B,GAAG,SAAS,CAO3E"}