123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.// Copyright Joyent, Inc. and Node.js contributors. All rights reserved. MIT license.
import { kHandle, kKeyObject } from "./constants.ts";import {  ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE,  ERR_INVALID_ARG_TYPE,  ERR_INVALID_ARG_VALUE,} from "../errors.ts";import { notImplemented } from "../../_utils.ts";import type {  KeyFormat,  KeyType,  PrivateKeyInput,  PublicKeyInput,} from "./types.ts";import { Buffer } from "../../buffer.ts";import { isAnyArrayBuffer, isArrayBufferView } from "../util/types.ts";import { hideStackFrames } from "../errors.ts";import {  isCryptoKey as isCryptoKey_,  isKeyObject as isKeyObject_,  kKeyType,} from "./_keys.ts";
const getArrayBufferOrView = hideStackFrames(  (    buffer,    name,    encoding,  ):    | ArrayBuffer    | SharedArrayBuffer    | Buffer    | DataView    | BigInt64Array    | BigUint64Array    | Float32Array    | Float64Array    | Int8Array    | Int16Array    | Int32Array    | Uint8Array    | Uint8ClampedArray    | Uint16Array    | Uint32Array => {    if (isAnyArrayBuffer(buffer)) {      return buffer;    }    if (typeof buffer === "string") {      if (encoding === "buffer") {        encoding = "utf8";      }      return Buffer.from(buffer, encoding);    }    if (!isArrayBufferView(buffer)) {      throw new ERR_INVALID_ARG_TYPE(        name,        [          "string",          "ArrayBuffer",          "Buffer",          "TypedArray",          "DataView",        ],        buffer,      );    }    return buffer;  },);
export interface AsymmetricKeyDetails {  /**   * Key size in bits (RSA, DSA).   */  modulusLength?: number | undefined;  /**   * Public exponent (RSA).   */  publicExponent?: bigint | undefined;  /**   * Name of the message digest (RSA-PSS).   */  hashAlgorithm?: string | undefined;  /**   * Name of the message digest used by MGF1 (RSA-PSS).   */  mgf1HashAlgorithm?: string | undefined;  /**   * Minimal salt length in bytes (RSA-PSS).   */  saltLength?: number | undefined;  /**   * Size of q in bits (DSA).   */  divisorLength?: number | undefined;  /**   * Name of the curve (EC).   */  namedCurve?: string | undefined;}
export type KeyObjectType = "secret" | "public" | "private";
export interface KeyExportOptions<T extends KeyFormat> {  type: "pkcs1" | "spki" | "pkcs8" | "sec1";  format: T;  cipher?: string | undefined;  passphrase?: string | Buffer | undefined;}
export interface JwkKeyExportOptions {  format: "jwk";}
export function isKeyObject(obj: unknown): obj is KeyObject {  return isKeyObject_(obj);}
export function isCryptoKey(  obj: unknown,): obj is { type: string; [kKeyObject]: KeyObject } {  return isCryptoKey_(obj);}
export class KeyObject {  [kKeyType]: KeyObjectType;  [kHandle]: unknown;
  constructor(type: KeyObjectType, handle: unknown) {    if (type !== "secret" && type !== "public" && type !== "private") {      throw new ERR_INVALID_ARG_VALUE("type", type);    }
    if (typeof handle !== "object") {      throw new ERR_INVALID_ARG_TYPE("handle", "object", handle);    }
    this[kKeyType] = type;
    Object.defineProperty(this, kHandle, {      value: handle,      enumerable: false,      configurable: false,      writable: false,    });  }
  get type(): KeyObjectType {    return this[kKeyType];  }
  get asymmetricKeyDetails(): AsymmetricKeyDetails | undefined {    notImplemented("crypto.KeyObject.prototype.asymmetricKeyDetails");
    return undefined;  }
  get asymmetricKeyType(): KeyType | undefined {    notImplemented("crypto.KeyObject.prototype.asymmetricKeyType");
    return undefined;  }
  get symmetricKeySize(): number | undefined {    notImplemented("crypto.KeyObject.prototype.symmetricKeySize");
    return undefined;  }
  static from(key: CryptoKey): KeyObject {    if (!isCryptoKey(key)) {      throw new ERR_INVALID_ARG_TYPE("key", "CryptoKey", key);    }
    notImplemented("crypto.KeyObject.prototype.from");  }
  equals(otherKeyObject: KeyObject): boolean {    if (!isKeyObject(otherKeyObject)) {      throw new ERR_INVALID_ARG_TYPE(        "otherKeyObject",        "KeyObject",        otherKeyObject,      );    }
    notImplemented("crypto.KeyObject.prototype.equals");  }
  export(options: KeyExportOptions<"pem">): string | Buffer;  export(options?: KeyExportOptions<"der">): Buffer;  export(options?: JwkKeyExportOptions): JsonWebKey;  export(_options?: unknown): string | Buffer | JsonWebKey {    notImplemented("crypto.KeyObject.prototype.asymmetricKeyType");  }}
export interface JsonWebKeyInput {  key: JsonWebKey;  format: "jwk";}
export function createPrivateKey(  _key: PrivateKeyInput | string | Buffer | JsonWebKeyInput,): KeyObject {  notImplemented("crypto.createPrivateKey");}
export function createPublicKey(  _key: PublicKeyInput | string | Buffer | KeyObject | JsonWebKeyInput,): KeyObject {  notImplemented("crypto.createPublicKey");}
function getKeyTypes(allowKeyObject: boolean, bufferOnly = false) {  const types = [    "ArrayBuffer",    "Buffer",    "TypedArray",    "DataView",    "string", // Only if bufferOnly == false    "KeyObject", // Only if allowKeyObject == true && bufferOnly == false    "CryptoKey", // Only if allowKeyObject == true && bufferOnly == false  ];  if (bufferOnly) {    return types.slice(0, 4);  } else if (!allowKeyObject) {    return types.slice(0, 5);  }  return types;}
export function prepareSecretKey(  key: string | ArrayBuffer | KeyObject,  encoding: string | undefined,  bufferOnly = false,) {  if (!bufferOnly) {    if (isKeyObject(key)) {      if (key.type !== "secret") {        throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE(key.type, "secret");      }      return key[kHandle];    } else if (isCryptoKey(key)) {      if (key.type !== "secret") {        throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE(key.type, "secret");      }      return key[kKeyObject][kHandle];    }  }  if (    typeof key !== "string" &&    !isArrayBufferView(key) &&    !isAnyArrayBuffer(key)  ) {    throw new ERR_INVALID_ARG_TYPE(      "key",      getKeyTypes(!bufferOnly, bufferOnly),      key,    );  }
  return getArrayBufferOrView(key, "key", encoding);}
export function createSecretKey(key: ArrayBufferView): KeyObject;export function createSecretKey(  key: string,  encoding: string,): KeyObject;export function createSecretKey(  _key: string | ArrayBufferView,  _encoding?: string,): KeyObject {  notImplemented("crypto.createSecretKey");}
export default {  createPrivateKey,  createPublicKey,  createSecretKey,  isKeyObject,  isCryptoKey,  KeyObject,  prepareSecretKey,};