1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-12-25 16:49:18 -05:00
denoland-deno/ext/node/polyfills/internal/crypto/x509.ts
Bartek Iwańczuk d47147fb6a
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>
2023-02-14 17:38:45 +01:00

186 lines
4.3 KiB
TypeScript

// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
// Copyright Joyent, Inc. and Node.js contributors. All rights reserved. MIT license.
import { KeyObject } from "internal:deno_node/polyfills/internal/crypto/keys.ts";
import { Buffer } from "internal:deno_node/polyfills/buffer.ts";
import { ERR_INVALID_ARG_TYPE } from "internal:deno_node/polyfills/internal/errors.ts";
import { isArrayBufferView } from "internal:deno_node/polyfills/internal/util/types.ts";
import { notImplemented } from "internal:deno_node/polyfills/_utils.ts";
import { BinaryLike } from "internal:deno_node/polyfills/internal/crypto/types.ts";
// deno-lint-ignore no-explicit-any
export type PeerCertificate = any;
export interface X509CheckOptions {
/**
* @default 'always'
*/
subject: "always" | "never";
/**
* @default true
*/
wildcards: boolean;
/**
* @default true
*/
partialWildcards: boolean;
/**
* @default false
*/
multiLabelWildcards: boolean;
/**
* @default false
*/
singleLabelSubdomains: boolean;
}
export class X509Certificate {
constructor(buffer: BinaryLike) {
if (typeof buffer === "string") {
buffer = Buffer.from(buffer);
}
if (!isArrayBufferView(buffer)) {
throw new ERR_INVALID_ARG_TYPE(
"buffer",
["string", "Buffer", "TypedArray", "DataView"],
buffer,
);
}
notImplemented("crypto.X509Certificate");
}
get ca(): boolean {
notImplemented("crypto.X509Certificate.prototype.ca");
return false;
}
checkEmail(
_email: string,
_options?: Pick<X509CheckOptions, "subject">,
): string | undefined {
notImplemented("crypto.X509Certificate.prototype.checkEmail");
}
checkHost(_name: string, _options?: X509CheckOptions): string | undefined {
notImplemented("crypto.X509Certificate.prototype.checkHost");
}
checkIP(_ip: string): string | undefined {
notImplemented("crypto.X509Certificate.prototype.checkIP");
}
checkIssued(_otherCert: X509Certificate): boolean {
notImplemented("crypto.X509Certificate.prototype.checkIssued");
}
checkPrivateKey(_privateKey: KeyObject): boolean {
notImplemented("crypto.X509Certificate.prototype.checkPrivateKey");
}
get fingerprint(): string {
notImplemented("crypto.X509Certificate.prototype.fingerprint");
return "";
}
get fingerprint256(): string {
notImplemented("crypto.X509Certificate.prototype.fingerprint256");
return "";
}
get fingerprint512(): string {
notImplemented("crypto.X509Certificate.prototype.fingerprint512");
return "";
}
get infoAccess(): string | undefined {
notImplemented("crypto.X509Certificate.prototype.infoAccess");
return "";
}
get issuer(): string {
notImplemented("crypto.X509Certificate.prototype.issuer");
return "";
}
get issuerCertificate(): X509Certificate | undefined {
notImplemented("crypto.X509Certificate.prototype.issuerCertificate");
return {} as X509Certificate;
}
get keyUsage(): string[] {
notImplemented("crypto.X509Certificate.prototype.keyUsage");
return [];
}
get publicKey(): KeyObject {
notImplemented("crypto.X509Certificate.prototype.publicKey");
return {} as KeyObject;
}
get raw(): Buffer {
notImplemented("crypto.X509Certificate.prototype.raw");
return {} as Buffer;
}
get serialNumber(): string {
notImplemented("crypto.X509Certificate.prototype.serialNumber");
return "";
}
get subject(): string {
notImplemented("crypto.X509Certificate.prototype.subject");
return "";
}
get subjectAltName(): string | undefined {
notImplemented("crypto.X509Certificate.prototype.subjectAltName");
return "";
}
toJSON(): string {
return this.toString();
}
toLegacyObject(): PeerCertificate {
notImplemented("crypto.X509Certificate.prototype.toLegacyObject");
}
toString(): string {
notImplemented("crypto.X509Certificate.prototype.toString");
}
get validFrom(): string {
notImplemented("crypto.X509Certificate.prototype.validFrom");
return "";
}
get validTo(): string {
notImplemented("crypto.X509Certificate.prototype.validTo");
return "";
}
verify(_publicKey: KeyObject): boolean {
notImplemented("crypto.X509Certificate.prototype.verify");
}
}
export default {
X509Certificate,
};