551 lines
24 KiB
Plaintext
551 lines
24 KiB
Plaintext
/**
|
|
* HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented as a
|
|
* separate module.
|
|
* @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/https.js)
|
|
*/
|
|
declare module "https" {
|
|
import { Duplex } from "node:stream";
|
|
import * as tls from "node:tls";
|
|
import * as http from "node:http";
|
|
import { URL } from "node:url";
|
|
type ServerOptions<
|
|
Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
|
|
Response extends typeof http.ServerResponse = typeof http.ServerResponse,
|
|
> = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions<Request, Response>;
|
|
type RequestOptions =
|
|
& http.RequestOptions
|
|
& tls.SecureContextOptions
|
|
& {
|
|
checkServerIdentity?: typeof tls.checkServerIdentity | undefined;
|
|
rejectUnauthorized?: boolean | undefined; // Defaults to true
|
|
servername?: string | undefined; // SNI TLS Extension
|
|
};
|
|
interface AgentOptions extends http.AgentOptions, tls.ConnectionOptions {
|
|
rejectUnauthorized?: boolean | undefined;
|
|
maxCachedSessions?: number | undefined;
|
|
}
|
|
/**
|
|
* An `Agent` object for HTTPS similar to `http.Agent`. See {@link request} for more information.
|
|
* @since v0.4.5
|
|
*/
|
|
class Agent extends http.Agent {
|
|
constructor(options?: AgentOptions);
|
|
options: AgentOptions;
|
|
}
|
|
interface Server<
|
|
Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
|
|
Response extends typeof http.ServerResponse = typeof http.ServerResponse,
|
|
> extends http.Server<Request, Response> {}
|
|
/**
|
|
* See `http.Server` for more information.
|
|
* @since v0.3.4
|
|
*/
|
|
class Server<
|
|
Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
|
|
Response extends typeof http.ServerResponse = typeof http.ServerResponse,
|
|
> extends tls.Server {
|
|
constructor(requestListener?: http.RequestListener<Request, Response>);
|
|
constructor(
|
|
options: ServerOptions<Request, Response>,
|
|
requestListener?: http.RequestListener<Request, Response>,
|
|
);
|
|
/**
|
|
* Closes all connections connected to this server.
|
|
* @since v18.2.0
|
|
*/
|
|
closeAllConnections(): void;
|
|
/**
|
|
* Closes all connections connected to this server which are not sending a request or waiting for a response.
|
|
* @since v18.2.0
|
|
*/
|
|
closeIdleConnections(): void;
|
|
addListener(event: string, listener: (...args: any[]) => void): this;
|
|
addListener(event: "keylog", listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
|
|
addListener(
|
|
event: "newSession",
|
|
listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
|
|
): this;
|
|
addListener(
|
|
event: "OCSPRequest",
|
|
listener: (
|
|
certificate: Buffer,
|
|
issuer: Buffer,
|
|
callback: (err: Error | null, resp: Buffer) => void,
|
|
) => void,
|
|
): this;
|
|
addListener(
|
|
event: "resumeSession",
|
|
listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
|
|
): this;
|
|
addListener(event: "secureConnection", listener: (tlsSocket: tls.TLSSocket) => void): this;
|
|
addListener(event: "tlsClientError", listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
|
|
addListener(event: "close", listener: () => void): this;
|
|
addListener(event: "connection", listener: (socket: Duplex) => void): this;
|
|
addListener(event: "error", listener: (err: Error) => void): this;
|
|
addListener(event: "listening", listener: () => void): this;
|
|
addListener(event: "checkContinue", listener: http.RequestListener<Request, Response>): this;
|
|
addListener(event: "checkExpectation", listener: http.RequestListener<Request, Response>): this;
|
|
addListener(event: "clientError", listener: (err: Error, socket: Duplex) => void): this;
|
|
addListener(
|
|
event: "connect",
|
|
listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
|
|
): this;
|
|
addListener(event: "request", listener: http.RequestListener<Request, Response>): this;
|
|
addListener(
|
|
event: "upgrade",
|
|
listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
|
|
): this;
|
|
emit(event: string, ...args: any[]): boolean;
|
|
emit(event: "keylog", line: Buffer, tlsSocket: tls.TLSSocket): boolean;
|
|
emit(
|
|
event: "newSession",
|
|
sessionId: Buffer,
|
|
sessionData: Buffer,
|
|
callback: (err: Error, resp: Buffer) => void,
|
|
): boolean;
|
|
emit(
|
|
event: "OCSPRequest",
|
|
certificate: Buffer,
|
|
issuer: Buffer,
|
|
callback: (err: Error | null, resp: Buffer) => void,
|
|
): boolean;
|
|
emit(event: "resumeSession", sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void): boolean;
|
|
emit(event: "secureConnection", tlsSocket: tls.TLSSocket): boolean;
|
|
emit(event: "tlsClientError", err: Error, tlsSocket: tls.TLSSocket): boolean;
|
|
emit(event: "close"): boolean;
|
|
emit(event: "connection", socket: Duplex): boolean;
|
|
emit(event: "error", err: Error): boolean;
|
|
emit(event: "listening"): boolean;
|
|
emit(
|
|
event: "checkContinue",
|
|
req: InstanceType<Request>,
|
|
res: InstanceType<Response> & {
|
|
req: InstanceType<Request>;
|
|
},
|
|
): boolean;
|
|
emit(
|
|
event: "checkExpectation",
|
|
req: InstanceType<Request>,
|
|
res: InstanceType<Response> & {
|
|
req: InstanceType<Request>;
|
|
},
|
|
): boolean;
|
|
emit(event: "clientError", err: Error, socket: Duplex): boolean;
|
|
emit(event: "connect", req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
|
|
emit(
|
|
event: "request",
|
|
req: InstanceType<Request>,
|
|
res: InstanceType<Response> & {
|
|
req: InstanceType<Request>;
|
|
},
|
|
): boolean;
|
|
emit(event: "upgrade", req: InstanceType<Request>, socket: Duplex, head: Buffer): boolean;
|
|
on(event: string, listener: (...args: any[]) => void): this;
|
|
on(event: "keylog", listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
|
|
on(
|
|
event: "newSession",
|
|
listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
|
|
): this;
|
|
on(
|
|
event: "OCSPRequest",
|
|
listener: (
|
|
certificate: Buffer,
|
|
issuer: Buffer,
|
|
callback: (err: Error | null, resp: Buffer) => void,
|
|
) => void,
|
|
): this;
|
|
on(
|
|
event: "resumeSession",
|
|
listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
|
|
): this;
|
|
on(event: "secureConnection", listener: (tlsSocket: tls.TLSSocket) => void): this;
|
|
on(event: "tlsClientError", listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
|
|
on(event: "close", listener: () => void): this;
|
|
on(event: "connection", listener: (socket: Duplex) => void): this;
|
|
on(event: "error", listener: (err: Error) => void): this;
|
|
on(event: "listening", listener: () => void): this;
|
|
on(event: "checkContinue", listener: http.RequestListener<Request, Response>): this;
|
|
on(event: "checkExpectation", listener: http.RequestListener<Request, Response>): this;
|
|
on(event: "clientError", listener: (err: Error, socket: Duplex) => void): this;
|
|
on(event: "connect", listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
|
|
on(event: "request", listener: http.RequestListener<Request, Response>): this;
|
|
on(event: "upgrade", listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
|
|
once(event: string, listener: (...args: any[]) => void): this;
|
|
once(event: "keylog", listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
|
|
once(
|
|
event: "newSession",
|
|
listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
|
|
): this;
|
|
once(
|
|
event: "OCSPRequest",
|
|
listener: (
|
|
certificate: Buffer,
|
|
issuer: Buffer,
|
|
callback: (err: Error | null, resp: Buffer) => void,
|
|
) => void,
|
|
): this;
|
|
once(
|
|
event: "resumeSession",
|
|
listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
|
|
): this;
|
|
once(event: "secureConnection", listener: (tlsSocket: tls.TLSSocket) => void): this;
|
|
once(event: "tlsClientError", listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
|
|
once(event: "close", listener: () => void): this;
|
|
once(event: "connection", listener: (socket: Duplex) => void): this;
|
|
once(event: "error", listener: (err: Error) => void): this;
|
|
once(event: "listening", listener: () => void): this;
|
|
once(event: "checkContinue", listener: http.RequestListener<Request, Response>): this;
|
|
once(event: "checkExpectation", listener: http.RequestListener<Request, Response>): this;
|
|
once(event: "clientError", listener: (err: Error, socket: Duplex) => void): this;
|
|
once(event: "connect", listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
|
|
once(event: "request", listener: http.RequestListener<Request, Response>): this;
|
|
once(event: "upgrade", listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void): this;
|
|
prependListener(event: string, listener: (...args: any[]) => void): this;
|
|
prependListener(event: "keylog", listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
|
|
prependListener(
|
|
event: "newSession",
|
|
listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
|
|
): this;
|
|
prependListener(
|
|
event: "OCSPRequest",
|
|
listener: (
|
|
certificate: Buffer,
|
|
issuer: Buffer,
|
|
callback: (err: Error | null, resp: Buffer) => void,
|
|
) => void,
|
|
): this;
|
|
prependListener(
|
|
event: "resumeSession",
|
|
listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
|
|
): this;
|
|
prependListener(event: "secureConnection", listener: (tlsSocket: tls.TLSSocket) => void): this;
|
|
prependListener(event: "tlsClientError", listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
|
|
prependListener(event: "close", listener: () => void): this;
|
|
prependListener(event: "connection", listener: (socket: Duplex) => void): this;
|
|
prependListener(event: "error", listener: (err: Error) => void): this;
|
|
prependListener(event: "listening", listener: () => void): this;
|
|
prependListener(event: "checkContinue", listener: http.RequestListener<Request, Response>): this;
|
|
prependListener(event: "checkExpectation", listener: http.RequestListener<Request, Response>): this;
|
|
prependListener(event: "clientError", listener: (err: Error, socket: Duplex) => void): this;
|
|
prependListener(
|
|
event: "connect",
|
|
listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
|
|
): this;
|
|
prependListener(event: "request", listener: http.RequestListener<Request, Response>): this;
|
|
prependListener(
|
|
event: "upgrade",
|
|
listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
|
|
): this;
|
|
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
|
|
prependOnceListener(event: "keylog", listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
|
|
prependOnceListener(
|
|
event: "newSession",
|
|
listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void,
|
|
): this;
|
|
prependOnceListener(
|
|
event: "OCSPRequest",
|
|
listener: (
|
|
certificate: Buffer,
|
|
issuer: Buffer,
|
|
callback: (err: Error | null, resp: Buffer) => void,
|
|
) => void,
|
|
): this;
|
|
prependOnceListener(
|
|
event: "resumeSession",
|
|
listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void,
|
|
): this;
|
|
prependOnceListener(event: "secureConnection", listener: (tlsSocket: tls.TLSSocket) => void): this;
|
|
prependOnceListener(event: "tlsClientError", listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
|
|
prependOnceListener(event: "close", listener: () => void): this;
|
|
prependOnceListener(event: "connection", listener: (socket: Duplex) => void): this;
|
|
prependOnceListener(event: "error", listener: (err: Error) => void): this;
|
|
prependOnceListener(event: "listening", listener: () => void): this;
|
|
prependOnceListener(event: "checkContinue", listener: http.RequestListener<Request, Response>): this;
|
|
prependOnceListener(event: "checkExpectation", listener: http.RequestListener<Request, Response>): this;
|
|
prependOnceListener(event: "clientError", listener: (err: Error, socket: Duplex) => void): this;
|
|
prependOnceListener(
|
|
event: "connect",
|
|
listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
|
|
): this;
|
|
prependOnceListener(event: "request", listener: http.RequestListener<Request, Response>): this;
|
|
prependOnceListener(
|
|
event: "upgrade",
|
|
listener: (req: InstanceType<Request>, socket: Duplex, head: Buffer) => void,
|
|
): this;
|
|
}
|
|
/**
|
|
* ```js
|
|
* // curl -k https://localhost:8000/
|
|
* const https = require('node:https');
|
|
* const fs = require('node:fs');
|
|
*
|
|
* const options = {
|
|
* key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
|
|
* cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),
|
|
* };
|
|
*
|
|
* https.createServer(options, (req, res) => {
|
|
* res.writeHead(200);
|
|
* res.end('hello world\n');
|
|
* }).listen(8000);
|
|
* ```
|
|
*
|
|
* Or
|
|
*
|
|
* ```js
|
|
* const https = require('node:https');
|
|
* const fs = require('node:fs');
|
|
*
|
|
* const options = {
|
|
* pfx: fs.readFileSync('test/fixtures/test_cert.pfx'),
|
|
* passphrase: 'sample',
|
|
* };
|
|
*
|
|
* https.createServer(options, (req, res) => {
|
|
* res.writeHead(200);
|
|
* res.end('hello world\n');
|
|
* }).listen(8000);
|
|
* ```
|
|
* @since v0.3.4
|
|
* @param options Accepts `options` from `createServer`, `createSecureContext` and `createServer`.
|
|
* @param requestListener A listener to be added to the `'request'` event.
|
|
*/
|
|
function createServer<
|
|
Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
|
|
Response extends typeof http.ServerResponse = typeof http.ServerResponse,
|
|
>(requestListener?: http.RequestListener<Request, Response>): Server<Request, Response>;
|
|
function createServer<
|
|
Request extends typeof http.IncomingMessage = typeof http.IncomingMessage,
|
|
Response extends typeof http.ServerResponse = typeof http.ServerResponse,
|
|
>(
|
|
options: ServerOptions<Request, Response>,
|
|
requestListener?: http.RequestListener<Request, Response>,
|
|
): Server<Request, Response>;
|
|
/**
|
|
* Makes a request to a secure web server.
|
|
*
|
|
* The following additional `options` from `tls.connect()` are also accepted:`ca`, `cert`, `ciphers`, `clientCertEngine`, `crl`, `dhparam`, `ecdhCurve`,`honorCipherOrder`, `key`, `passphrase`,
|
|
* `pfx`, `rejectUnauthorized`,`secureOptions`, `secureProtocol`, `servername`, `sessionIdContext`,`highWaterMark`.
|
|
*
|
|
* `options` can be an object, a string, or a `URL` object. If `options` is a
|
|
* string, it is automatically parsed with `new URL()`. If it is a `URL` object, it will be automatically converted to an ordinary `options` object.
|
|
*
|
|
* `https.request()` returns an instance of the `http.ClientRequest` class. The `ClientRequest` instance is a writable stream. If one needs to
|
|
* upload a file with a POST request, then write to the `ClientRequest` object.
|
|
*
|
|
* ```js
|
|
* const https = require('node:https');
|
|
*
|
|
* const options = {
|
|
* hostname: 'encrypted.google.com',
|
|
* port: 443,
|
|
* path: '/',
|
|
* method: 'GET',
|
|
* };
|
|
*
|
|
* const req = https.request(options, (res) => {
|
|
* console.log('statusCode:', res.statusCode);
|
|
* console.log('headers:', res.headers);
|
|
*
|
|
* res.on('data', (d) => {
|
|
* process.stdout.write(d);
|
|
* });
|
|
* });
|
|
*
|
|
* req.on('error', (e) => {
|
|
* console.error(e);
|
|
* });
|
|
* req.end();
|
|
* ```
|
|
*
|
|
* Example using options from `tls.connect()`:
|
|
*
|
|
* ```js
|
|
* const options = {
|
|
* hostname: 'encrypted.google.com',
|
|
* port: 443,
|
|
* path: '/',
|
|
* method: 'GET',
|
|
* key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
|
|
* cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),
|
|
* };
|
|
* options.agent = new https.Agent(options);
|
|
*
|
|
* const req = https.request(options, (res) => {
|
|
* // ...
|
|
* });
|
|
* ```
|
|
*
|
|
* Alternatively, opt out of connection pooling by not using an `Agent`.
|
|
*
|
|
* ```js
|
|
* const options = {
|
|
* hostname: 'encrypted.google.com',
|
|
* port: 443,
|
|
* path: '/',
|
|
* method: 'GET',
|
|
* key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
|
|
* cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),
|
|
* agent: false,
|
|
* };
|
|
*
|
|
* const req = https.request(options, (res) => {
|
|
* // ...
|
|
* });
|
|
* ```
|
|
*
|
|
* Example using a `URL` as `options`:
|
|
*
|
|
* ```js
|
|
* const options = new URL('https://abc:xyz@example.com');
|
|
*
|
|
* const req = https.request(options, (res) => {
|
|
* // ...
|
|
* });
|
|
* ```
|
|
*
|
|
* Example pinning on certificate fingerprint, or the public key (similar to`pin-sha256`):
|
|
*
|
|
* ```js
|
|
* const tls = require('node:tls');
|
|
* const https = require('node:https');
|
|
* const crypto = require('node:crypto');
|
|
*
|
|
* function sha256(s) {
|
|
* return crypto.createHash('sha256').update(s).digest('base64');
|
|
* }
|
|
* const options = {
|
|
* hostname: 'github.com',
|
|
* port: 443,
|
|
* path: '/',
|
|
* method: 'GET',
|
|
* checkServerIdentity: function(host, cert) {
|
|
* // Make sure the certificate is issued to the host we are connected to
|
|
* const err = tls.checkServerIdentity(host, cert);
|
|
* if (err) {
|
|
* return err;
|
|
* }
|
|
*
|
|
* // Pin the public key, similar to HPKP pin-sha256 pinning
|
|
* const pubkey256 = 'pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=';
|
|
* if (sha256(cert.pubkey) !== pubkey256) {
|
|
* const msg = 'Certificate verification error: ' +
|
|
* `The public key of '${cert.subject.CN}' ` +
|
|
* 'does not match our pinned fingerprint';
|
|
* return new Error(msg);
|
|
* }
|
|
*
|
|
* // Pin the exact certificate, rather than the pub key
|
|
* const cert256 = '25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:' +
|
|
* 'D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16';
|
|
* if (cert.fingerprint256 !== cert256) {
|
|
* const msg = 'Certificate verification error: ' +
|
|
* `The certificate of '${cert.subject.CN}' ` +
|
|
* 'does not match our pinned fingerprint';
|
|
* return new Error(msg);
|
|
* }
|
|
*
|
|
* // This loop is informational only.
|
|
* // Print the certificate and public key fingerprints of all certs in the
|
|
* // chain. Its common to pin the public key of the issuer on the public
|
|
* // internet, while pinning the public key of the service in sensitive
|
|
* // environments.
|
|
* do {
|
|
* console.log('Subject Common Name:', cert.subject.CN);
|
|
* console.log(' Certificate SHA256 fingerprint:', cert.fingerprint256);
|
|
*
|
|
* hash = crypto.createHash('sha256');
|
|
* console.log(' Public key ping-sha256:', sha256(cert.pubkey));
|
|
*
|
|
* lastprint256 = cert.fingerprint256;
|
|
* cert = cert.issuerCertificate;
|
|
* } while (cert.fingerprint256 !== lastprint256);
|
|
*
|
|
* },
|
|
* };
|
|
*
|
|
* options.agent = new https.Agent(options);
|
|
* const req = https.request(options, (res) => {
|
|
* console.log('All OK. Server matched our pinned cert or public key');
|
|
* console.log('statusCode:', res.statusCode);
|
|
* // Print the HPKP values
|
|
* console.log('headers:', res.headers['public-key-pins']);
|
|
*
|
|
* res.on('data', (d) => {});
|
|
* });
|
|
*
|
|
* req.on('error', (e) => {
|
|
* console.error(e.message);
|
|
* });
|
|
* req.end();
|
|
* ```
|
|
*
|
|
* Outputs for example:
|
|
*
|
|
* ```text
|
|
* Subject Common Name: github.com
|
|
* Certificate SHA256 fingerprint: 25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16
|
|
* Public key ping-sha256: pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=
|
|
* Subject Common Name: DigiCert SHA2 Extended Validation Server CA
|
|
* Certificate SHA256 fingerprint: 40:3E:06:2A:26:53:05:91:13:28:5B:AF:80:A0:D4:AE:42:2C:84:8C:9F:78:FA:D0:1F:C9:4B:C5:B8:7F:EF:1A
|
|
* Public key ping-sha256: RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=
|
|
* Subject Common Name: DigiCert High Assurance EV Root CA
|
|
* Certificate SHA256 fingerprint: 74:31:E5:F4:C3:C1:CE:46:90:77:4F:0B:61:E0:54:40:88:3B:A9:A0:1E:D0:0B:A6:AB:D7:80:6E:D3:B1:18:CF
|
|
* Public key ping-sha256: WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=
|
|
* All OK. Server matched our pinned cert or public key
|
|
* statusCode: 200
|
|
* headers: max-age=0; pin-sha256="WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18="; pin-sha256="RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=";
|
|
* pin-sha256="k2v657xBsOVe1PQRwOsHsw3bsGT2VzIqz5K+59sNQws="; pin-sha256="K87oWBWM9UZfyddvDfoxL+8lpNyoUB2ptGtn0fv6G2Q="; pin-sha256="IQBnNBEiFuhj+8x6X8XLgh01V9Ic5/V3IRQLNFFc7v4=";
|
|
* pin-sha256="iie1VXtL7HzAMF+/PVPR9xzT80kQxdZeJ+zduCB3uj0="; pin-sha256="LvRiGEjRqfzurezaWuj8Wie2gyHMrW5Q06LspMnox7A="; includeSubDomains
|
|
* ```
|
|
* @since v0.3.6
|
|
* @param options Accepts all `options` from `request`, with some differences in default values:
|
|
*/
|
|
function request(
|
|
options: RequestOptions | string | URL,
|
|
callback?: (res: http.IncomingMessage) => void,
|
|
): http.ClientRequest;
|
|
function request(
|
|
url: string | URL,
|
|
options: RequestOptions,
|
|
callback?: (res: http.IncomingMessage) => void,
|
|
): http.ClientRequest;
|
|
/**
|
|
* Like `http.get()` but for HTTPS.
|
|
*
|
|
* `options` can be an object, a string, or a `URL` object. If `options` is a
|
|
* string, it is automatically parsed with `new URL()`. If it is a `URL` object, it will be automatically converted to an ordinary `options` object.
|
|
*
|
|
* ```js
|
|
* const https = require('node:https');
|
|
*
|
|
* https.get('https://encrypted.google.com/', (res) => {
|
|
* console.log('statusCode:', res.statusCode);
|
|
* console.log('headers:', res.headers);
|
|
*
|
|
* res.on('data', (d) => {
|
|
* process.stdout.write(d);
|
|
* });
|
|
*
|
|
* }).on('error', (e) => {
|
|
* console.error(e);
|
|
* });
|
|
* ```
|
|
* @since v0.3.6
|
|
* @param options Accepts the same `options` as {@link request}, with the `method` always set to `GET`.
|
|
*/
|
|
function get(
|
|
options: RequestOptions | string | URL,
|
|
callback?: (res: http.IncomingMessage) => void,
|
|
): http.ClientRequest;
|
|
function get(
|
|
url: string | URL,
|
|
options: RequestOptions,
|
|
callback?: (res: http.IncomingMessage) => void,
|
|
): http.ClientRequest;
|
|
let globalAgent: Agent;
|
|
}
|
|
declare module "node:https" {
|
|
export * from "https";
|
|
}
|