@vercel/cli-auth 0.3.12 → 0.3.14-snapshot-dd15927e8ded

package/tpm.ts

@@ -0,0 +1,221 @@
+// Seals a secret with an RSA key that lives in this PC's TPM, through CNG's
+// Platform Crypto Provider (called with koffi, so there's no native code to
+// build). The TPM keeps the private key and only hands out what it unseals:
+// what we save is the key's name, which is useless on any other PC.
+
+import { type Koffi, loadKoffi } from './koffi';
+
+export type Handle = number | bigint;
+
+// String constants from `ncrypt.h` and `bcrypt.h`.
+const PLATFORM_CRYPTO_PROVIDER = 'Microsoft Platform Crypto Provider';
+const NCRYPT_RSA_ALGORITHM = 'RSA';
+const NCRYPT_LENGTH_PROPERTY = 'Length';
+const NCRYPT_KEY_USAGE_PROPERTY = 'Key Usage';
+const BCRYPT_SHA256_ALGORITHM = 'SHA256';
+const RSA_KEY_BITS = 2048;
+// `ncrypt.h`: the key may only decrypt.
+const NCRYPT_ALLOW_DECRYPT_FLAG = 0x1;
+// `ncrypt.h`: RSA-OAEP, with a `BCRYPT_OAEP_PADDING_INFO`.
+const NCRYPT_PAD_OAEP_FLAG = 0x4;
+// `ncrypt.h`: fail instead of showing UI, since the CLI may not be
+// interactive.
+const NCRYPT_SILENT_FLAG = 0x40;
+// `winerror.h` NTE_BAD_KEYSET: there's no key with that name.
+const NTE_BAD_KEYSET = 0x80090016;
+
+let api: ReturnType<typeof loadApi> | undefined;
+
+function loadApi(koffi: Koffi) {
+  const ncrypt = koffi.load('ncrypt.dll');
+  koffi.struct('BCRYPT_OAEP_PADDING_INFO', {
+    pszAlgId: 'str16',
+    pbLabel: 'void *',
+    cbLabel: 'uint32_t',
+  });
+  return {
+    NCryptOpenStorageProvider: ncrypt.func(
+      'int32_t __stdcall NCryptOpenStorageProvider(_Out_ uintptr_t *phProvider, const char16_t *pszProviderName, uint32_t dwFlags)'
+    ),
+    NCryptCreatePersistedKey: ncrypt.func(
+      'int32_t __stdcall NCryptCreatePersistedKey(uintptr_t hProvider, _Out_ uintptr_t *phKey, const char16_t *pszAlgId, const char16_t *pszKeyName, uint32_t dwLegacyKeySpec, uint32_t dwFlags)'
+    ),
+    NCryptSetProperty: ncrypt.func(
+      'int32_t __stdcall NCryptSetProperty(uintptr_t hObject, const char16_t *pszProperty, const uint8_t *pbInput, uint32_t cbInput, uint32_t dwFlags)'
+    ),
+    NCryptFinalizeKey: ncrypt.func(
+      'int32_t __stdcall NCryptFinalizeKey(uintptr_t hKey, uint32_t dwFlags)'
+    ),
+    NCryptOpenKey: ncrypt.func(
+      'int32_t __stdcall NCryptOpenKey(uintptr_t hProvider, _Out_ uintptr_t *phKey, const char16_t *pszKeyName, uint32_t dwLegacyKeySpec, uint32_t dwFlags)'
+    ),
+    NCryptEncrypt: ncrypt.func(
+      'int32_t __stdcall NCryptEncrypt(uintptr_t hKey, const uint8_t *pbInput, uint32_t cbInput, const BCRYPT_OAEP_PADDING_INFO *pPaddingInfo, _Out_ uint8_t *pbOutput, uint32_t cbOutput, _Out_ uint32_t *pcbResult, uint32_t dwFlags)'
+    ),
+    NCryptDecrypt: ncrypt.func(
+      'int32_t __stdcall NCryptDecrypt(uintptr_t hKey, const uint8_t *pbInput, uint32_t cbInput, const BCRYPT_OAEP_PADDING_INFO *pPaddingInfo, _Out_ uint8_t *pbOutput, uint32_t cbOutput, _Out_ uint32_t *pcbResult, uint32_t dwFlags)'
+    ),
+    NCryptDeleteKey: ncrypt.func(
+      'int32_t __stdcall NCryptDeleteKey(uintptr_t hKey, uint32_t dwFlags)'
+    ),
+    NCryptFreeObject: ncrypt.func(
+      'int32_t __stdcall NCryptFreeObject(uintptr_t hObject)'
+    ),
+  };
+}
+
+type Api = ReturnType<typeof loadApi>;
+
+class TpmError extends Error {
+  constructor(
+    what: string,
+    readonly status: number
+  ) {
+    super(`${what} failed with 0x${(status >>> 0).toString(16)}.`);
+  }
+}
+
+function check(what: string, status: number): void {
+  if (status !== 0) {
+    throw new TpmError(what, status);
+  }
+}
+
+function withProvider<T>(fn: (a: Api, provider: Handle) => T): T {
+  const a = (api ??= loadApi(loadKoffi()));
+  const provider: [Handle] = [0];
+  check(
+    'NCryptOpenStorageProvider',
+    a.NCryptOpenStorageProvider(provider, PLATFORM_CRYPTO_PROVIDER, 0)
+  );
+  try {
+    return fn(a, provider[0]);
+  } finally {
+    a.NCryptFreeObject(provider[0]);
+  }
+}
+
+function openKey(a: Api, provider: Handle, name: string): Handle {
+  const key: [Handle] = [0];
+  check(
+    'NCryptOpenKey',
+    a.NCryptOpenKey(provider, key, name, 0, NCRYPT_SILENT_FLAG)
+  );
+  return key[0];
+}
+
+/**
+ * Create an RSA key named `name` in this PC's TPM, which may only decrypt,
+ * and seal `secret` with it. Returns the sealed secret.
+ */
+export function createTpmKey(name: string, secret: Buffer): Buffer {
+  return withProvider((a, provider) => {
+    const handle: [Handle] = [0];
+    check(
+      'NCryptCreatePersistedKey',
+      a.NCryptCreatePersistedKey(
+        provider,
+        handle,
+        NCRYPT_RSA_ALGORITHM,
+        name,
+        0,
+        0
+      )
+    );
+    const key = handle[0];
+    let finalized = false;
+    try {
+      setDword(a, key, NCRYPT_LENGTH_PROPERTY, RSA_KEY_BITS);
+      setDword(a, key, NCRYPT_KEY_USAGE_PROPERTY, NCRYPT_ALLOW_DECRYPT_FLAG);
+      check('NCryptFinalizeKey', a.NCryptFinalizeKey(key, NCRYPT_SILENT_FLAG));
+      finalized = true;
+      const sealed = oaep(a, 'NCryptEncrypt', key, secret);
+      a.NCryptFreeObject(key);
+      return sealed;
+    } catch (error) {
+      if (finalized) {
+        // Also frees the handle.
+        a.NCryptDeleteKey(key, NCRYPT_SILENT_FLAG);
+      } else {
+        a.NCryptFreeObject(key);
+      }
+      throw error;
+    }
+  });
+}
+
+/**
+ * Unseal what `createTpmKey` sealed, with the key named `name` in this PC's
+ * TPM. The TPM's private key never leaves it.
+ */
+export function unsealWithTpmKey(name: string, sealed: Buffer): Buffer {
+  return withProvider((a, provider) => {
+    const key = openKey(a, provider, name);
+    try {
+      return oaep(a, 'NCryptDecrypt', key, sealed);
+    } finally {
+      a.NCryptFreeObject(key);
+    }
+  });
+}
+
+function setDword(a: Api, key: Handle, property: string, value: number) {
+  const bytes = Buffer.alloc(4);
+  bytes.writeUInt32LE(value);
+  check(
+    `NCryptSetProperty(${property})`,
+    a.NCryptSetProperty(key, property, bytes, bytes.length, 0)
+  );
+}
+
+// Encrypt or decrypt with RSA-OAEP and SHA-256.
+function oaep(
+  a: Api,
+  what: 'NCryptEncrypt' | 'NCryptDecrypt',
+  key: Handle,
+  input: Buffer
+): Buffer {
+  const output = Buffer.alloc(RSA_KEY_BITS / 8);
+  const size: [number] = [0];
+  check(
+    what,
+    a[what](
+      key,
+      input,
+      input.length,
+      { pszAlgId: BCRYPT_SHA256_ALGORITHM, pbLabel: null, cbLabel: 0 },
+      output,
+      output.length,
+      size,
+      // Only decrypting uses the private key, which may want UI.
+      what === 'NCryptDecrypt'
+        ? NCRYPT_PAD_OAEP_FLAG | NCRYPT_SILENT_FLAG
+        : NCRYPT_PAD_OAEP_FLAG
+    )
+  );
+  const result = Buffer.from(new Uint8Array(output.subarray(0, size[0])));
+  // Don't leave an unsealed secret behind.
+  output.fill(0);
+  return result;
+}
+
+/** Delete the key named `name` from this PC's TPM, if it's there. */
+export function deleteTpmKey(name: string): void {
+  withProvider((a, provider) => {
+    let key: Handle;
+    try {
+      key = openKey(a, provider, name);
+    } catch (error) {
+      if (error instanceof TpmError && error.status >>> 0 === NTE_BAD_KEYSET) {
+        return;
+      }
+      throw error;
+    }
+    // Frees the handle when it succeeds.
+    const status = a.NCryptDeleteKey(key, NCRYPT_SILENT_FLAG);
+    if (status !== 0) {
+      a.NCryptFreeObject(key);
+    }
+    check('NCryptDeleteKey', status);
+  });
+}