feat(ext/node): embed std/node into the snapshot (#17724)

This commit moves "deno_std/node" in "ext/node" crate. The code is
transpiled and snapshotted during the build process.

During the first pass a minimal amount of work was done to create the
snapshot, a lot of code in "ext/node" depends on presence of "Deno"
global. This code will be gradually fixed in the follow up PRs to migrate
it to import relevant APIs from "internal:" modules.

Currently the code from snapshot is not used in any way, and all
Node/npm compatibility still uses code from 
"https://deno.land/std/node" (or from the location specified by 
"DENO_NODE_COMPAT_URL"). This will also be handled in a follow 
up PRs.

---------

Co-authored-by: crowlkats <crowlkats@toaxl.com>
Co-authored-by: Divy Srivastava <dj.srivastava23@gmail.com>
Co-authored-by: Yoshiya Hinosawa <stibium121@gmail.com>

1 files changed, 306 insertions, 0 deletions

diff --git a/ext/node/polyfills/internal/crypto/diffiehellman.ts b/ext/node/polyfills/internal/crypto/diffiehellman.ts
new file mode 100644
index 000000000..eb903ccb3
--- /dev/null
+++ b/ext/node/polyfills/internal/crypto/diffiehellman.ts
@@ -0,0 +1,306 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Copyright Joyent, Inc. and Node.js contributors. All rights reserved. MIT license.
+
+import { notImplemented } from "internal:deno_node/polyfills/_utils.ts";
+import {
+  isAnyArrayBuffer,
+  isArrayBufferView,
+} from "internal:deno_node/polyfills/internal/util/types.ts";
+import { ERR_INVALID_ARG_TYPE } from "internal:deno_node/polyfills/internal/errors.ts";
+import {
+  validateInt32,
+  validateString,
+} from "internal:deno_node/polyfills/internal/validators.mjs";
+import { Buffer } from "internal:deno_node/polyfills/buffer.ts";
+import {
+  getDefaultEncoding,
+  toBuf,
+} from "internal:deno_node/polyfills/internal/crypto/util.ts";
+import type {
+  BinaryLike,
+  BinaryToTextEncoding,
+  ECDHKeyFormat,
+} from "internal:deno_node/polyfills/internal/crypto/types.ts";
+import { KeyObject } from "internal:deno_node/polyfills/internal/crypto/keys.ts";
+import type { BufferEncoding } from "internal:deno_node/polyfills/_global.d.ts";
+
+const DH_GENERATOR = 2;
+
+export class DiffieHellman {
+  verifyError!: number;
+
+  constructor(
+    sizeOrKey: unknown,
+    keyEncoding?: unknown,
+    generator?: unknown,
+    genEncoding?: unknown,
+  ) {
+    if (
+      typeof sizeOrKey !== "number" &&
+      typeof sizeOrKey !== "string" &&
+      !isArrayBufferView(sizeOrKey) &&
+      !isAnyArrayBuffer(sizeOrKey)
+    ) {
+      throw new ERR_INVALID_ARG_TYPE(
+        "sizeOrKey",
+        ["number", "string", "ArrayBuffer", "Buffer", "TypedArray", "DataView"],
+        sizeOrKey,
+      );
+    }
+
+    if (typeof sizeOrKey === "number") {
+      validateInt32(sizeOrKey, "sizeOrKey");
+    }
+
+    if (
+      keyEncoding &&
+      !Buffer.isEncoding(keyEncoding as BinaryToTextEncoding) &&
+      keyEncoding !== "buffer"
+    ) {
+      genEncoding = generator;
+      generator = keyEncoding;
+      keyEncoding = false;
+    }
+
+    const encoding = getDefaultEncoding();
+    keyEncoding = keyEncoding || encoding;
+    genEncoding = genEncoding || encoding;
+
+    if (typeof sizeOrKey !== "number") {
+      sizeOrKey = toBuf(sizeOrKey as string, keyEncoding as string);
+    }
+
+    if (!generator) {
+      generator = DH_GENERATOR;
+    } else if (typeof generator === "number") {
+      validateInt32(generator, "generator");
+    } else if (typeof generator === "string") {
+      generator = toBuf(generator, genEncoding as string);
+    } else if (!isArrayBufferView(generator) && !isAnyArrayBuffer(generator)) {
+      throw new ERR_INVALID_ARG_TYPE(
+        "generator",
+        ["number", "string", "ArrayBuffer", "Buffer", "TypedArray", "DataView"],
+        generator,
+      );
+    }
+
+    notImplemented("crypto.DiffieHellman");
+  }
+
+  computeSecret(otherPublicKey: ArrayBufferView): Buffer;
+  computeSecret(
+    otherPublicKey: string,
+    inputEncoding: BinaryToTextEncoding,
+  ): Buffer;
+  computeSecret(
+    otherPublicKey: ArrayBufferView,
+    outputEncoding: BinaryToTextEncoding,
+  ): string;
+  computeSecret(
+    otherPublicKey: string,
+    inputEncoding: BinaryToTextEncoding,
+    outputEncoding: BinaryToTextEncoding,
+  ): string;
+  computeSecret(
+    _otherPublicKey: ArrayBufferView | string,
+    _inputEncoding?: BinaryToTextEncoding,
+    _outputEncoding?: BinaryToTextEncoding,
+  ): Buffer | string {
+    notImplemented("crypto.DiffieHellman.prototype.computeSecret");
+  }
+
+  generateKeys(): Buffer;
+  generateKeys(encoding: BinaryToTextEncoding): string;
+  generateKeys(_encoding?: BinaryToTextEncoding): Buffer | string {
+    notImplemented("crypto.DiffieHellman.prototype.generateKeys");
+  }
+
+  getGenerator(): Buffer;
+  getGenerator(encoding: BinaryToTextEncoding): string;
+  getGenerator(_encoding?: BinaryToTextEncoding): Buffer | string {
+    notImplemented("crypto.DiffieHellman.prototype.getGenerator");
+  }
+
+  getPrime(): Buffer;
+  getPrime(encoding: BinaryToTextEncoding): string;
+  getPrime(_encoding?: BinaryToTextEncoding): Buffer | string {
+    notImplemented("crypto.DiffieHellman.prototype.getPrime");
+  }
+
+  getPrivateKey(): Buffer;
+  getPrivateKey(encoding: BinaryToTextEncoding): string;
+  getPrivateKey(_encoding?: BinaryToTextEncoding): Buffer | string {
+    notImplemented("crypto.DiffieHellman.prototype.getPrivateKey");
+  }
+
+  getPublicKey(): Buffer;
+  getPublicKey(encoding: BinaryToTextEncoding): string;
+  getPublicKey(_encoding?: BinaryToTextEncoding): Buffer | string {
+    notImplemented("crypto.DiffieHellman.prototype.getPublicKey");
+  }
+
+  setPrivateKey(privateKey: ArrayBufferView): void;
+  setPrivateKey(privateKey: string, encoding: BufferEncoding): void;
+  setPrivateKey(
+    _privateKey: ArrayBufferView | string,
+    _encoding?: BufferEncoding,
+  ) {
+    notImplemented("crypto.DiffieHellman.prototype.setPrivateKey");
+  }
+
+  setPublicKey(publicKey: ArrayBufferView): void;
+  setPublicKey(publicKey: string, encoding: BufferEncoding): void;
+  setPublicKey(
+    _publicKey: ArrayBufferView | string,
+    _encoding?: BufferEncoding,
+  ) {
+    notImplemented("crypto.DiffieHellman.prototype.setPublicKey");
+  }
+}
+
+export class DiffieHellmanGroup {
+  verifyError!: number;
+
+  constructor(_name: string) {
+    notImplemented("crypto.DiffieHellmanGroup");
+  }
+
+  computeSecret(otherPublicKey: ArrayBufferView): Buffer;
+  computeSecret(
+    otherPublicKey: string,
+    inputEncoding: BinaryToTextEncoding,
+  ): Buffer;
+  computeSecret(
+    otherPublicKey: ArrayBufferView,
+    outputEncoding: BinaryToTextEncoding,
+  ): string;
+  computeSecret(
+    otherPublicKey: string,
+    inputEncoding: BinaryToTextEncoding,
+    outputEncoding: BinaryToTextEncoding,
+  ): string;
+  computeSecret(
+    _otherPublicKey: ArrayBufferView | string,
+    _inputEncoding?: BinaryToTextEncoding,
+    _outputEncoding?: BinaryToTextEncoding,
+  ): Buffer | string {
+    notImplemented("crypto.DiffieHellman.prototype.computeSecret");
+  }
+
+  generateKeys(): Buffer;
+  generateKeys(encoding: BinaryToTextEncoding): string;
+  generateKeys(_encoding?: BinaryToTextEncoding): Buffer | string {
+    notImplemented("crypto.DiffieHellman.prototype.generateKeys");
+  }
+
+  getGenerator(): Buffer;
+  getGenerator(encoding: BinaryToTextEncoding): string;
+  getGenerator(_encoding?: BinaryToTextEncoding): Buffer | string {
+    notImplemented("crypto.DiffieHellman.prototype.getGenerator");
+  }
+
+  getPrime(): Buffer;
+  getPrime(encoding: BinaryToTextEncoding): string;
+  getPrime(_encoding?: BinaryToTextEncoding): Buffer | string {
+    notImplemented("crypto.DiffieHellman.prototype.getPrime");
+  }
+
+  getPrivateKey(): Buffer;
+  getPrivateKey(encoding: BinaryToTextEncoding): string;
+  getPrivateKey(_encoding?: BinaryToTextEncoding): Buffer | string {
+    notImplemented("crypto.DiffieHellman.prototype.getPrivateKey");
+  }
+
+  getPublicKey(): Buffer;
+  getPublicKey(encoding: BinaryToTextEncoding): string;
+  getPublicKey(_encoding?: BinaryToTextEncoding): Buffer | string {
+    notImplemented("crypto.DiffieHellman.prototype.getPublicKey");
+  }
+}
+
+export class ECDH {
+  constructor(curve: string) {
+    validateString(curve, "curve");
+
+    notImplemented("crypto.ECDH");
+  }
+
+  static convertKey(
+    _key: BinaryLike,
+    _curve: string,
+    _inputEncoding?: BinaryToTextEncoding,
+    _outputEncoding?: "latin1" | "hex" | "base64" | "base64url",
+    _format?: "uncompressed" | "compressed" | "hybrid",
+  ): Buffer | string {
+    notImplemented("crypto.ECDH.prototype.convertKey");
+  }
+
+  computeSecret(otherPublicKey: ArrayBufferView): Buffer;
+  computeSecret(
+    otherPublicKey: string,
+    inputEncoding: BinaryToTextEncoding,
+  ): Buffer;
+  computeSecret(
+    otherPublicKey: ArrayBufferView,
+    outputEncoding: BinaryToTextEncoding,
+  ): string;
+  computeSecret(
+    otherPublicKey: string,
+    inputEncoding: BinaryToTextEncoding,
+    outputEncoding: BinaryToTextEncoding,
+  ): string;
+  computeSecret(
+    _otherPublicKey: ArrayBufferView | string,
+    _inputEncoding?: BinaryToTextEncoding,
+    _outputEncoding?: BinaryToTextEncoding,
+  ): Buffer | string {
+    notImplemented("crypto.ECDH.prototype.computeSecret");
+  }
+
+  generateKeys(): Buffer;
+  generateKeys(encoding: BinaryToTextEncoding, format?: ECDHKeyFormat): string;
+  generateKeys(
+    _encoding?: BinaryToTextEncoding,
+    _format?: ECDHKeyFormat,
+  ): Buffer | string {
+    notImplemented("crypto.ECDH.prototype.generateKeys");
+  }
+
+  getPrivateKey(): Buffer;
+  getPrivateKey(encoding: BinaryToTextEncoding): string;
+  getPrivateKey(_encoding?: BinaryToTextEncoding): Buffer | string {
+    notImplemented("crypto.ECDH.prototype.getPrivateKey");
+  }
+
+  getPublicKey(): Buffer;
+  getPublicKey(encoding: BinaryToTextEncoding, format?: ECDHKeyFormat): string;
+  getPublicKey(
+    _encoding?: BinaryToTextEncoding,
+    _format?: ECDHKeyFormat,
+  ): Buffer | string {
+    notImplemented("crypto.ECDH.prototype.getPublicKey");
+  }
+
+  setPrivateKey(privateKey: ArrayBufferView): void;
+  setPrivateKey(privateKey: string, encoding: BinaryToTextEncoding): void;
+  setPrivateKey(
+    _privateKey: ArrayBufferView | string,
+    _encoding?: BinaryToTextEncoding,
+  ): Buffer | string {
+    notImplemented("crypto.ECDH.prototype.setPrivateKey");
+  }
+}
+
+export function diffieHellman(_options: {
+  privateKey: KeyObject;
+  publicKey: KeyObject;
+}): Buffer {
+  notImplemented("crypto.diffieHellman");
+}
+
+export default {
+  DiffieHellman,
+  DiffieHellmanGroup,
+  ECDH,
+  diffieHellman,
+};