/** * The `node:tls` module provides an implementation of the Transport Layer Security * (TLS) and Secure Socket Layer (SSL) protocols that is built on top of OpenSSL. * The module can be accessed using: * * ```js * import tls from 'node:tls'; * ``` * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/tls.js) */ declare module "tls" { import { NonSharedBuffer } from "node:buffer"; import { X509Certificate } from "node:crypto"; import * as net from "node:net"; import * as stream from "stream"; const CLIENT_RENEG_LIMIT: number; const CLIENT_RENEG_WINDOW: number; interface Certificate { /** * Country code. */ C: string; /** * Street. */ ST: string; /** * Locality. */ L: string; /** * Organization. */ O: string; /** * Organizational unit. */ OU: string; /** * Common name. */ CN: string; } interface PeerCertificate { /** * `true` if a Certificate Authority (CA), `false` otherwise. * @since v18.13.0 */ ca: boolean; /** * The DER encoded X.509 certificate data. */ raw: NonSharedBuffer; /** * The certificate subject. */ subject: Certificate; /** * The certificate issuer, described in the same terms as the `subject`. */ issuer: Certificate; /** * The date-time the certificate is valid from. */ valid_from: string; /** * The date-time the certificate is valid to. */ valid_to: string; /** * The certificate serial number, as a hex string. */ serialNumber: string; /** * The SHA-1 digest of the DER encoded certificate. * It is returned as a `:` separated hexadecimal string. */ fingerprint: string; /** * The SHA-256 digest of the DER encoded certificate. * It is returned as a `:` separated hexadecimal string. */ fingerprint256: string; /** * The SHA-512 digest of the DER encoded certificate. * It is returned as a `:` separated hexadecimal string. */ fingerprint512: string; /** * The extended key usage, a set of OIDs. */ ext_key_usage?: string[]; /** * A string containing concatenated names for the subject, * an alternative to the `subject` names. */ subjectaltname?: string; /** * An array describing the AuthorityInfoAccess, used with OCSP. */ infoAccess?: NodeJS.Dict; /** * For RSA keys: The RSA bit size. * * For EC keys: The key size in bits. */ bits?: number; /** * The RSA exponent, as a string in hexadecimal number notation. */ exponent?: string; /** * The RSA modulus, as a hexadecimal string. */ modulus?: string; /** * The public key. */ pubkey?: NonSharedBuffer; /** * The ASN.1 name of the OID of the elliptic curve. * Well-known curves are identified by an OID. * While it is unusual, it is possible that the curve * is identified by its mathematical properties, * in which case it will not have an OID. */ asn1Curve?: string; /** * The NIST name for the elliptic curve, if it has one * (not all well-known curves have been assigned names by NIST). */ nistCurve?: string; } interface DetailedPeerCertificate extends PeerCertificate { /** * The issuer certificate object. * For self-signed certificates, this may be a circular reference. */ issuerCertificate: DetailedPeerCertificate; } interface CipherNameAndProtocol { /** * The cipher name. */ name: string; /** * SSL/TLS protocol version. */ version: string; /** * IETF name for the cipher suite. */ standardName: string; } interface EphemeralKeyInfo { /** * The supported types are 'DH' and 'ECDH'. */ type: string; /** * The name property is available only when type is 'ECDH'. */ name?: string | undefined; /** * The size of parameter of an ephemeral key exchange. */ size: number; } interface KeyObject { /** * Private keys in PEM format. */ pem: string | Buffer; /** * Optional passphrase. */ passphrase?: string | undefined; } interface PxfObject { /** * PFX or PKCS12 encoded private key and certificate chain. */ buf: string | Buffer; /** * Optional passphrase. */ passphrase?: string | undefined; } interface TLSSocketOptions extends SecureContextOptions, CommonConnectionOptions { /** * If true the TLS socket will be instantiated in server-mode. * Defaults to false. */ isServer?: boolean | undefined; /** * An optional net.Server instance. */ server?: net.Server | undefined; /** * An optional Buffer instance containing a TLS session. */ session?: Buffer | undefined; /** * If true, specifies that the OCSP status request extension will be * added to the client hello and an 'OCSPResponse' event will be * emitted on the socket before establishing a secure communication */ requestOCSP?: boolean | undefined; } /** * Performs transparent encryption of written data and all required TLS * negotiation. * * Instances of `tls.TLSSocket` implement the duplex `Stream` interface. * * Methods that return TLS connection metadata (e.g.{@link TLSSocket.getPeerCertificate}) will only return data while the * connection is open. * @since v0.11.4 */ class TLSSocket extends net.Socket { /** * Construct a new tls.TLSSocket object from an existing TCP socket. */ constructor(socket: net.Socket | stream.Duplex, options?: TLSSocketOptions); /** * This property is `true` if the peer certificate was signed by one of the CAs * specified when creating the `tls.TLSSocket` instance, otherwise `false`. * @since v0.11.4 */ authorized: boolean; /** * Returns the reason why the peer's certificate was not been verified. This * property is set only when `tlsSocket.authorized === false`. * @since v0.11.4 */ authorizationError: Error; /** * Always returns `true`. This may be used to distinguish TLS sockets from regular`net.Socket` instances. * @since v0.11.4 */ encrypted: true; /** * String containing the selected ALPN protocol. * Before a handshake has completed, this value is always null. * When a handshake is completed but not ALPN protocol was selected, tlsSocket.alpnProtocol equals false. */ alpnProtocol: string | false | null; /** * Returns an object representing the local certificate. The returned object has * some properties corresponding to the fields of the certificate. * * See {@link TLSSocket.getPeerCertificate} for an example of the certificate * structure. * * If there is no local certificate, an empty object will be returned. If the * socket has been destroyed, `null` will be returned. * @since v11.2.0 */ getCertificate(): PeerCertificate | object | null; /** * Returns an object containing information on the negotiated cipher suite. * * For example, a TLSv1.2 protocol with AES256-SHA cipher: * * ```json * { * "name": "AES256-SHA", * "standardName": "TLS_RSA_WITH_AES_256_CBC_SHA", * "version": "SSLv3" * } * ``` * * See [SSL\_CIPHER\_get\_name](https://www.openssl.org/docs/man1.1.1/man3/SSL_CIPHER_get_name.html) for more information. * @since v0.11.4 */ getCipher(): CipherNameAndProtocol; /** * Returns an object representing the type, name, and size of parameter of * an ephemeral key exchange in `perfect forward secrecy` on a client * connection. It returns an empty object when the key exchange is not * ephemeral. As this is only supported on a client socket; `null` is returned * if called on a server socket. The supported types are `'DH'` and `'ECDH'`. The `name` property is available only when type is `'ECDH'`. * * For example: `{ type: 'ECDH', name: 'prime256v1', size: 256 }`. * @since v5.0.0 */ getEphemeralKeyInfo(): EphemeralKeyInfo | object | null; /** * As the `Finished` messages are message digests of the complete handshake * (with a total of 192 bits for TLS 1.0 and more for SSL 3.0), they can * be used for external authentication procedures when the authentication * provided by SSL/TLS is not desired or is not enough. * * Corresponds to the `SSL_get_finished` routine in OpenSSL and may be used * to implement the `tls-unique` channel binding from [RFC 5929](https://tools.ietf.org/html/rfc5929). * @since v9.9.0 * @return The latest `Finished` message that has been sent to the socket as part of a SSL/TLS handshake, or `undefined` if no `Finished` message has been sent yet. */ getFinished(): NonSharedBuffer | undefined; /** * Returns an object representing the peer's certificate. If the peer does not * provide a certificate, an empty object will be returned. If the socket has been * destroyed, `null` will be returned. * * If the full certificate chain was requested, each certificate will include an`issuerCertificate` property containing an object representing its issuer's * certificate. * @since v0.11.4 * @param detailed Include the full certificate chain if `true`, otherwise include just the peer's certificate. * @return A certificate object. */ getPeerCertificate(detailed: true): DetailedPeerCertificate; getPeerCertificate(detailed?: false): PeerCertificate; getPeerCertificate(detailed?: boolean): PeerCertificate | DetailedPeerCertificate; /** * As the `Finished` messages are message digests of the complete handshake * (with a total of 192 bits for TLS 1.0 and more for SSL 3.0), they can * be used for external authentication procedures when the authentication * provided by SSL/TLS is not desired or is not enough. * * Corresponds to the `SSL_get_peer_finished` routine in OpenSSL and may be used * to implement the `tls-unique` channel binding from [RFC 5929](https://tools.ietf.org/html/rfc5929). * @since v9.9.0 * @return The latest `Finished` message that is expected or has actually been received from the socket as part of a SSL/TLS handshake, or `undefined` if there is no `Finished` message so * far. */ getPeerFinished(): NonSharedBuffer | undefined; /** * Returns a string containing the negotiated SSL/TLS protocol version of the * current connection. The value `'unknown'` will be returned for connected * sockets that have not completed the handshaking process. The value `null` will * be returned for server sockets or disconnected client sockets. * * Protocol versions are: * * * `'SSLv3'` * * `'TLSv1'` * * `'TLSv1.1'` * * `'TLSv1.2'` * * `'TLSv1.3'` * * See the OpenSSL [`SSL_get_version`](https://www.openssl.org/docs/man1.1.1/man3/SSL_get_version.html) documentation for more information. * @since v5.7.0 */ getProtocol(): string | null; /** * Returns the TLS session data or `undefined` if no session was * negotiated. On the client, the data can be provided to the `session` option of {@link connect} to resume the connection. On the server, it may be useful * for debugging. * * See `Session Resumption` for more information. * * Note: `getSession()` works only for TLSv1.2 and below. For TLSv1.3, applications * must use the `'session'` event (it also works for TLSv1.2 and below). * @since v0.11.4 */ getSession(): NonSharedBuffer | undefined; /** * See [SSL\_get\_shared\_sigalgs](https://www.openssl.org/docs/man1.1.1/man3/SSL_get_shared_sigalgs.html) for more information. * @since v12.11.0 * @return List of signature algorithms shared between the server and the client in the order of decreasing preference. */ getSharedSigalgs(): string[]; /** * For a client, returns the TLS session ticket if one is available, or`undefined`. For a server, always returns `undefined`. * * It may be useful for debugging. * * See `Session Resumption` for more information. * @since v0.11.4 */ getTLSTicket(): NonSharedBuffer | undefined; /** * See `Session Resumption` for more information. * @since v0.5.6 * @return `true` if the session was reused, `false` otherwise. */ isSessionReused(): boolean; /** * The `tlsSocket.renegotiate()` method initiates a TLS renegotiation process. * Upon completion, the `callback` function will be passed a single argument * that is either an `Error` (if the request failed) or `null`. * * This method can be used to request a peer's certificate after the secure * connection has been established. * * When running as the server, the socket will be destroyed with an error after `handshakeTimeout` timeout. * * For TLSv1.3, renegotiation cannot be initiated, it is not supported by the * protocol. * @since v0.11.8 * @param callback If `renegotiate()` returned `true`, callback is attached once to the `'secure'` event. If `renegotiate()` returned `false`, `callback` will be called in the next tick with * an error, unless the `tlsSocket` has been destroyed, in which case `callback` will not be called at all. * @return `true` if renegotiation was initiated, `false` otherwise. */ renegotiate( options: { rejectUnauthorized?: boolean | undefined; requestCert?: boolean | undefined; }, callback: (err: Error | null) => void, ): undefined | boolean; /** * The `tlsSocket.setKeyCert()` method sets the private key and certificate to use for the socket. * This is mainly useful if you wish to select a server certificate from a TLS server's `ALPNCallback`. * @since v22.5.0, v20.17.0 * @param context An object containing at least `key` and `cert` properties from the {@link createSecureContext()} `options`, * or a TLS context object created with {@link createSecureContext()} itself. */ setKeyCert(context: SecureContextOptions | SecureContext): void; /** * The `tlsSocket.setMaxSendFragment()` method sets the maximum TLS fragment size. * Returns `true` if setting the limit succeeded; `false` otherwise. * * Smaller fragment sizes decrease the buffering latency on the client: larger * fragments are buffered by the TLS layer until the entire fragment is received * and its integrity is verified; large fragments can span multiple roundtrips * and their processing can be delayed due to packet loss or reordering. However, * smaller fragments add extra TLS framing bytes and CPU overhead, which may * decrease overall server throughput. * @since v0.11.11 * @param [size=16384] The maximum TLS fragment size. The maximum value is `16384`. */ setMaxSendFragment(size: number): boolean; /** * Disables TLS renegotiation for this `TLSSocket` instance. Once called, attempts * to renegotiate will trigger an `'error'` event on the `TLSSocket`. * @since v8.4.0 */ disableRenegotiation(): void; /** * When enabled, TLS packet trace information is written to `stderr`. This can be * used to debug TLS connection problems. * * The format of the output is identical to the output of`openssl s_client -trace` or `openssl s_server -trace`. While it is produced by * OpenSSL's `SSL_trace()` function, the format is undocumented, can change * without notice, and should not be relied on. * @since v12.2.0 */ enableTrace(): void; /** * Returns the peer certificate as an `X509Certificate` object. * * If there is no peer certificate, or the socket has been destroyed,`undefined` will be returned. * @since v15.9.0 */ getPeerX509Certificate(): X509Certificate | undefined; /** * Returns the local certificate as an `X509Certificate` object. * * If there is no local certificate, or the socket has been destroyed,`undefined` will be returned. * @since v15.9.0 */ getX509Certificate(): X509Certificate | undefined; /** * Keying material is used for validations to prevent different kind of attacks in * network protocols, for example in the specifications of IEEE 802.1X. * * Example * * ```js * const keyingMaterial = tlsSocket.exportKeyingMaterial( * 128, * 'client finished'); * * /* * Example return value of keyingMaterial: * * * ``` * * See the OpenSSL [`SSL_export_keying_material`](https://www.openssl.org/docs/man1.1.1/man3/SSL_export_keying_material.html) documentation for more * information. * @since v13.10.0, v12.17.0 * @param length number of bytes to retrieve from keying material * @param label an application specific label, typically this will be a value from the [IANA Exporter Label * Registry](https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#exporter-labels). * @param context Optionally provide a context. * @return requested bytes of the keying material */ exportKeyingMaterial(length: number, label: string, context: Buffer): NonSharedBuffer; addListener(event: string, listener: (...args: any[]) => void): this; addListener(event: "OCSPResponse", listener: (response: NonSharedBuffer) => void): this; addListener(event: "secureConnect", listener: () => void): this; addListener(event: "session", listener: (session: NonSharedBuffer) => void): this; addListener(event: "keylog", listener: (line: NonSharedBuffer) => void): this; emit(event: string | symbol, ...args: any[]): boolean; emit(event: "OCSPResponse", response: NonSharedBuffer): boolean; emit(event: "secureConnect"): boolean; emit(event: "session", session: NonSharedBuffer): boolean; emit(event: "keylog", line: NonSharedBuffer): boolean; on(event: string, listener: (...args: any[]) => void): this; on(event: "OCSPResponse", listener: (response: NonSharedBuffer) => void): this; on(event: "secureConnect", listener: () => void): this; on(event: "session", listener: (session: NonSharedBuffer) => void): this; on(event: "keylog", listener: (line: NonSharedBuffer) => void): this; once(event: string, listener: (...args: any[]) => void): this; once(event: "OCSPResponse", listener: (response: NonSharedBuffer) => void): this; once(event: "secureConnect", listener: () => void): this; once(event: "session", listener: (session: NonSharedBuffer) => void): this; once(event: "keylog", listener: (line: NonSharedBuffer) => void): this; prependListener(event: string, listener: (...args: any[]) => void): this; prependListener(event: "OCSPResponse", listener: (response: NonSharedBuffer) => void): this; prependListener(event: "secureConnect", listener: () => void): this; prependListener(event: "session", listener: (session: NonSharedBuffer) => void): this; prependListener(event: "keylog", listener: (line: NonSharedBuffer) => void): this; prependOnceListener(event: string, listener: (...args: any[]) => void): this; prependOnceListener(event: "OCSPResponse", listener: (response: NonSharedBuffer) => void): this; prependOnceListener(event: "secureConnect", listener: () => void): this; prependOnceListener(event: "session", listener: (session: NonSharedBuffer) => void): this; prependOnceListener(event: "keylog", listener: (line: NonSharedBuffer) => void): this; } interface CommonConnectionOptions { /** * An optional TLS context object from tls.createSecureContext() */ secureContext?: SecureContext | undefined; /** * When enabled, TLS packet trace information is written to `stderr`. This can be * used to debug TLS connection problems. * @default false */ enableTrace?: boolean | undefined; /** * If true the server will request a certificate from clients that * connect and attempt to verify that certificate. Defaults to * false. */ requestCert?: boolean | undefined; /** * An array of strings or a Buffer naming possible ALPN protocols. * (Protocols should be ordered by their priority.) */ ALPNProtocols?: readonly string[] | NodeJS.ArrayBufferView | undefined; /** * SNICallback(servername, cb) A function that will be * called if the client supports SNI TLS extension. Two arguments * will be passed when called: servername and cb. SNICallback should * invoke cb(null, ctx), where ctx is a SecureContext instance. * (tls.createSecureContext(...) can be used to get a proper * SecureContext.) If SNICallback wasn't provided the default callback * with high-level API will be used (see below). */ SNICallback?: ((servername: string, cb: (err: Error | null, ctx?: SecureContext) => void) => void) | undefined; /** * If true the server will reject any connection which is not * authorized with the list of supplied CAs. This option only has an * effect if requestCert is true. * @default true */ rejectUnauthorized?: boolean | undefined; } interface TlsOptions extends SecureContextOptions, CommonConnectionOptions, net.ServerOpts { /** * Abort the connection if the SSL/TLS handshake does not finish in the * specified number of milliseconds. A 'tlsClientError' is emitted on * the tls.Server object whenever a handshake times out. Default: * 120000 (120 seconds). */ handshakeTimeout?: number | undefined; /** * The number of seconds after which a TLS session created by the * server will no longer be resumable. See Session Resumption for more * information. Default: 300. */ sessionTimeout?: number | undefined; /** * 48-bytes of cryptographically strong pseudo-random data. */ ticketKeys?: Buffer | undefined; /** * @param socket * @param identity identity parameter sent from the client. * @return pre-shared key that must either be * a buffer or `null` to stop the negotiation process. Returned PSK must be * compatible with the selected cipher's digest. * * When negotiating TLS-PSK (pre-shared keys), this function is called * with the identity provided by the client. * If the return value is `null` the negotiation process will stop and an * "unknown_psk_identity" alert message will be sent to the other party. * If the server wishes to hide the fact that the PSK identity was not known, * the callback must provide some random data as `psk` to make the connection * fail with "decrypt_error" before negotiation is finished. * PSK ciphers are disabled by default, and using TLS-PSK thus * requires explicitly specifying a cipher suite with the `ciphers` option. * More information can be found in the RFC 4279. */ pskCallback?: ((socket: TLSSocket, identity: string) => NodeJS.ArrayBufferView | null) | undefined; /** * hint to send to a client to help * with selecting the identity during TLS-PSK negotiation. Will be ignored * in TLS 1.3. Upon failing to set pskIdentityHint `tlsClientError` will be * emitted with `ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED` code. */ pskIdentityHint?: string | undefined; } interface PSKCallbackNegotation { psk: NodeJS.ArrayBufferView; identity: string; } interface ConnectionOptions extends SecureContextOptions, CommonConnectionOptions { host?: string | undefined; port?: number | undefined; path?: string | undefined; // Creates unix socket connection to path. If this option is specified, `host` and `port` are ignored. socket?: stream.Duplex | undefined; // Establish secure connection on a given socket rather than creating a new socket checkServerIdentity?: typeof checkServerIdentity | undefined; servername?: string | undefined; // SNI TLS Extension session?: Buffer | undefined; minDHSize?: number | undefined; lookup?: net.LookupFunction | undefined; timeout?: number | undefined; /** * When negotiating TLS-PSK (pre-shared keys), this function is called * with optional identity `hint` provided by the server or `null` * in case of TLS 1.3 where `hint` was removed. * It will be necessary to provide a custom `tls.checkServerIdentity()` * for the connection as the default one will try to check hostname/IP * of the server against the certificate but that's not applicable for PSK * because there won't be a certificate present. * More information can be found in the RFC 4279. * * @param hint message sent from the server to help client * decide which identity to use during negotiation. * Always `null` if TLS 1.3 is used. * @returns Return `null` to stop the negotiation process. `psk` must be * compatible with the selected cipher's digest. * `identity` must use UTF-8 encoding. */ pskCallback?: ((hint: string | null) => PSKCallbackNegotation | null) | undefined; } /** * Accepts encrypted connections using TLS or SSL. * @since v0.3.2 */ class Server extends net.Server { constructor(secureConnectionListener?: (socket: TLSSocket) => void); constructor(options: TlsOptions, secureConnectionListener?: (socket: TLSSocket) => void); /** * The `server.addContext()` method adds a secure context that will be used if * the client request's SNI name matches the supplied `hostname` (or wildcard). * * When there are multiple matching contexts, the most recently added one is * used. * @since v0.5.3 * @param hostname A SNI host name or wildcard (e.g. `'*'`) * @param context An object containing any of the possible properties from the {@link createSecureContext} `options` arguments (e.g. `key`, `cert`, `ca`, etc), or a TLS context object created * with {@link createSecureContext} itself. */ addContext(hostname: string, context: SecureContextOptions | SecureContext): void; /** * Returns the session ticket keys. * * See `Session Resumption` for more information. * @since v3.0.0 * @return A 48-byte buffer containing the session ticket keys. */ getTicketKeys(): NonSharedBuffer; /** * The `server.setSecureContext()` method replaces the secure context of an * existing server. Existing connections to the server are not interrupted. * @since v11.0.0 * @param options An object containing any of the possible properties from the {@link createSecureContext} `options` arguments (e.g. `key`, `cert`, `ca`, etc). */ setSecureContext(options: SecureContextOptions): void; /** * Sets the session ticket keys. * * Changes to the ticket keys are effective only for future server connections. * Existing or currently pending server connections will use the previous keys. * * See `Session Resumption` for more information. * @since v3.0.0 * @param keys A 48-byte buffer containing the session ticket keys. */ setTicketKeys(keys: Buffer): void; /** * events.EventEmitter * 1. tlsClientError * 2. newSession * 3. OCSPRequest * 4. resumeSession * 5. secureConnection * 6. keylog */ addListener(event: string, listener: (...args: any[]) => void): this; addListener(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this; addListener( event: "newSession", listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void, ): this; addListener( event: "OCSPRequest", listener: ( certificate: NonSharedBuffer, issuer: NonSharedBuffer, callback: (err: Error | null, resp: Buffer | null) => void, ) => void, ): this; addListener( event: "resumeSession", listener: ( sessionId: NonSharedBuffer, callback: (err: Error | null, sessionData: Buffer | null) => void, ) => void, ): this; addListener(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this; addListener(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: TLSSocket) => void): this; emit(event: string | symbol, ...args: any[]): boolean; emit(event: "tlsClientError", err: Error, tlsSocket: TLSSocket): boolean; emit( event: "newSession", sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void, ): boolean; emit( event: "OCSPRequest", certificate: NonSharedBuffer, issuer: NonSharedBuffer, callback: (err: Error | null, resp: Buffer | null) => void, ): boolean; emit( event: "resumeSession", sessionId: NonSharedBuffer, callback: (err: Error | null, sessionData: Buffer | null) => void, ): boolean; emit(event: "secureConnection", tlsSocket: TLSSocket): boolean; emit(event: "keylog", line: NonSharedBuffer, tlsSocket: TLSSocket): boolean; on(event: string, listener: (...args: any[]) => void): this; on(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this; on( event: "newSession", listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void, ): this; on( event: "OCSPRequest", listener: ( certificate: NonSharedBuffer, issuer: NonSharedBuffer, callback: (err: Error | null, resp: Buffer | null) => void, ) => void, ): this; on( event: "resumeSession", listener: ( sessionId: NonSharedBuffer, callback: (err: Error | null, sessionData: Buffer | null) => void, ) => void, ): this; on(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this; on(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: TLSSocket) => void): this; once(event: string, listener: (...args: any[]) => void): this; once(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this; once( event: "newSession", listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void, ): this; once( event: "OCSPRequest", listener: ( certificate: NonSharedBuffer, issuer: NonSharedBuffer, callback: (err: Error | null, resp: Buffer | null) => void, ) => void, ): this; once( event: "resumeSession", listener: ( sessionId: NonSharedBuffer, callback: (err: Error | null, sessionData: Buffer | null) => void, ) => void, ): this; once(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this; once(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: TLSSocket) => void): this; prependListener(event: string, listener: (...args: any[]) => void): this; prependListener(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this; prependListener( event: "newSession", listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void, ): this; prependListener( event: "OCSPRequest", listener: ( certificate: NonSharedBuffer, issuer: NonSharedBuffer, callback: (err: Error | null, resp: Buffer | null) => void, ) => void, ): this; prependListener( event: "resumeSession", listener: ( sessionId: NonSharedBuffer, callback: (err: Error | null, sessionData: Buffer | null) => void, ) => void, ): this; prependListener(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this; prependListener(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: TLSSocket) => void): this; prependOnceListener(event: string, listener: (...args: any[]) => void): this; prependOnceListener(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this; prependOnceListener( event: "newSession", listener: (sessionId: NonSharedBuffer, sessionData: NonSharedBuffer, callback: () => void) => void, ): this; prependOnceListener( event: "OCSPRequest", listener: ( certificate: NonSharedBuffer, issuer: NonSharedBuffer, callback: (err: Error | null, resp: Buffer | null) => void, ) => void, ): this; prependOnceListener( event: "resumeSession", listener: ( sessionId: NonSharedBuffer, callback: (err: Error | null, sessionData: Buffer | null) => void, ) => void, ): this; prependOnceListener(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this; prependOnceListener(event: "keylog", listener: (line: NonSharedBuffer, tlsSocket: TLSSocket) => void): this; } type SecureVersion = "TLSv1.3" | "TLSv1.2" | "TLSv1.1" | "TLSv1"; interface SecureContextOptions { /** * If set, this will be called when a client opens a connection using the ALPN extension. * One argument will be passed to the callback: an object containing `servername` and `protocols` fields, * respectively containing the server name from the SNI extension (if any) and an array of * ALPN protocol name strings. The callback must return either one of the strings listed in `protocols`, * which will be returned to the client as the selected ALPN protocol, or `undefined`, * to reject the connection with a fatal alert. If a string is returned that does not match one of * the client's ALPN protocols, an error will be thrown. * This option cannot be used with the `ALPNProtocols` option, and setting both options will throw an error. */ ALPNCallback?: ((arg: { servername: string; protocols: string[] }) => string | undefined) | undefined; /** * Treat intermediate (non-self-signed) * certificates in the trust CA certificate list as trusted. * @since v22.9.0, v20.18.0 */ allowPartialTrustChain?: boolean | undefined; /** * Optionally override the trusted CA certificates. Default is to trust * the well-known CAs curated by Mozilla. Mozilla's CAs are completely * replaced when CAs are explicitly specified using this option. */ ca?: string | Buffer | Array | undefined; /** * Cert chains in PEM format. One cert chain should be provided per * private key. Each cert chain should consist of the PEM formatted * certificate for a provided private key, followed by the PEM * formatted intermediate certificates (if any), in order, and not * including the root CA (the root CA must be pre-known to the peer, * see ca). When providing multiple cert chains, they do not have to * be in the same order as their private keys in key. If the * intermediate certificates are not provided, the peer will not be * able to validate the certificate, and the handshake will fail. */ cert?: string | Buffer | Array | undefined; /** * Colon-separated list of supported signature algorithms. The list * can contain digest algorithms (SHA256, MD5 etc.), public key * algorithms (RSA-PSS, ECDSA etc.), combination of both (e.g * 'RSA+SHA384') or TLS v1.3 scheme names (e.g. rsa_pss_pss_sha512). */ sigalgs?: string | undefined; /** * Cipher suite specification, replacing the default. For more * information, see modifying the default cipher suite. Permitted * ciphers can be obtained via tls.getCiphers(). Cipher names must be * uppercased in order for OpenSSL to accept them. */ ciphers?: string | undefined; /** * Name of an OpenSSL engine which can provide the client certificate. * @deprecated */ clientCertEngine?: string | undefined; /** * PEM formatted CRLs (Certificate Revocation Lists). */ crl?: string | Buffer | Array | undefined; /** * `'auto'` or custom Diffie-Hellman parameters, required for non-ECDHE perfect forward secrecy. * If omitted or invalid, the parameters are silently discarded and DHE ciphers will not be available. * ECDHE-based perfect forward secrecy will still be available. */ dhparam?: string | Buffer | undefined; /** * A string describing a named curve or a colon separated list of curve * NIDs or names, for example P-521:P-384:P-256, to use for ECDH key * agreement. Set to auto to select the curve automatically. Use * crypto.getCurves() to obtain a list of available curve names. On * recent releases, openssl ecparam -list_curves will also display the * name and description of each available elliptic curve. Default: * tls.DEFAULT_ECDH_CURVE. */ ecdhCurve?: string | undefined; /** * Attempt to use the server's cipher suite preferences instead of the * client's. When true, causes SSL_OP_CIPHER_SERVER_PREFERENCE to be * set in secureOptions */ honorCipherOrder?: boolean | undefined; /** * Private keys in PEM format. PEM allows the option of private keys * being encrypted. Encrypted keys will be decrypted with * options.passphrase. Multiple keys using different algorithms can be * provided either as an array of unencrypted key strings or buffers, * or an array of objects in the form {pem: [, * passphrase: ]}. The object form can only occur in an array. * object.passphrase is optional. Encrypted keys will be decrypted with * object.passphrase if provided, or options.passphrase if it is not. */ key?: string | Buffer | Array | undefined; /** * Name of an OpenSSL engine to get private key from. Should be used * together with privateKeyIdentifier. * @deprecated */ privateKeyEngine?: string | undefined; /** * Identifier of a private key managed by an OpenSSL engine. Should be * used together with privateKeyEngine. Should not be set together with * key, because both options define a private key in different ways. * @deprecated */ privateKeyIdentifier?: string | undefined; /** * Optionally set the maximum TLS version to allow. One * of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the * `secureProtocol` option, use one or the other. * **Default:** `'TLSv1.3'`, unless changed using CLI options. Using * `--tls-max-v1.2` sets the default to `'TLSv1.2'`. Using `--tls-max-v1.3` sets the default to * `'TLSv1.3'`. If multiple of the options are provided, the highest maximum is used. */ maxVersion?: SecureVersion | undefined; /** * Optionally set the minimum TLS version to allow. One * of `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. Cannot be specified along with the * `secureProtocol` option, use one or the other. It is not recommended to use * less than TLSv1.2, but it may be required for interoperability. * **Default:** `'TLSv1.2'`, unless changed using CLI options. Using * `--tls-v1.0` sets the default to `'TLSv1'`. Using `--tls-v1.1` sets the default to * `'TLSv1.1'`. Using `--tls-min-v1.3` sets the default to * 'TLSv1.3'. If multiple of the options are provided, the lowest minimum is used. */ minVersion?: SecureVersion | undefined; /** * Shared passphrase used for a single private key and/or a PFX. */ passphrase?: string | undefined; /** * PFX or PKCS12 encoded private key and certificate chain. pfx is an * alternative to providing key and cert individually. PFX is usually * encrypted, if it is, passphrase will be used to decrypt it. Multiple * PFX can be provided either as an array of unencrypted PFX buffers, * or an array of objects in the form {buf: [, * passphrase: ]}. The object form can only occur in an array. * object.passphrase is optional. Encrypted PFX will be decrypted with * object.passphrase if provided, or options.passphrase if it is not. */ pfx?: string | Buffer | Array | undefined; /** * Optionally affect the OpenSSL protocol behavior, which is not * usually necessary. This should be used carefully if at all! Value is * a numeric bitmask of the SSL_OP_* options from OpenSSL Options */ secureOptions?: number | undefined; // Value is a numeric bitmask of the `SSL_OP_*` options /** * Legacy mechanism to select the TLS protocol version to use, it does * not support independent control of the minimum and maximum version, * and does not support limiting the protocol to TLSv1.3. Use * minVersion and maxVersion instead. The possible values are listed as * SSL_METHODS, use the function names as strings. For example, use * 'TLSv1_1_method' to force TLS version 1.1, or 'TLS_method' to allow * any TLS protocol version up to TLSv1.3. It is not recommended to use * TLS versions less than 1.2, but it may be required for * interoperability. Default: none, see minVersion. */ secureProtocol?: string | undefined; /** * Opaque identifier used by servers to ensure session state is not * shared between applications. Unused by clients. */ sessionIdContext?: string | undefined; /** * 48-bytes of cryptographically strong pseudo-random data. * See Session Resumption for more information. */ ticketKeys?: Buffer | undefined; /** * The number of seconds after which a TLS session created by the * server will no longer be resumable. See Session Resumption for more * information. Default: 300. */ sessionTimeout?: number | undefined; } interface SecureContext { context: any; } /** * Verifies the certificate `cert` is issued to `hostname`. * * Returns [Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) object, populating it with `reason`, `host`, and `cert` on * failure. On success, returns [undefined](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type). * * This function is intended to be used in combination with the`checkServerIdentity` option that can be passed to {@link connect} and as * such operates on a `certificate object`. For other purposes, consider using `x509.checkHost()` instead. * * This function can be overwritten by providing an alternative function as the `options.checkServerIdentity` option that is passed to `tls.connect()`. The * overwriting function can call `tls.checkServerIdentity()` of course, to augment * the checks done with additional verification. * * This function is only called if the certificate passed all other checks, such as * being issued by trusted CA (`options.ca`). * * Earlier versions of Node.js incorrectly accepted certificates for a given`hostname` if a matching `uniformResourceIdentifier` subject alternative name * was present (see [CVE-2021-44531](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-44531)). Applications that wish to accept`uniformResourceIdentifier` subject alternative names can use * a custom `options.checkServerIdentity` function that implements the desired behavior. * @since v0.8.4 * @param hostname The host name or IP address to verify the certificate against. * @param cert A `certificate object` representing the peer's certificate. */ function checkServerIdentity(hostname: string, cert: PeerCertificate): Error | undefined; /** * Creates a new {@link Server}. The `secureConnectionListener`, if provided, is * automatically set as a listener for the `'secureConnection'` event. * * The `ticketKeys` options is automatically shared between `node:cluster` module * workers. * * The following illustrates a simple echo server: * * ```js * import tls from 'node:tls'; * import fs from 'node:fs'; * * const options = { * key: fs.readFileSync('server-key.pem'), * cert: fs.readFileSync('server-cert.pem'), * * // This is necessary only if using client certificate authentication. * requestCert: true, * * // This is necessary only if the client uses a self-signed certificate. * ca: [ fs.readFileSync('client-cert.pem') ], * }; * * const server = tls.createServer(options, (socket) => { * console.log('server connected', * socket.authorized ? 'authorized' : 'unauthorized'); * socket.write('welcome!\n'); * socket.setEncoding('utf8'); * socket.pipe(socket); * }); * server.listen(8000, () => { * console.log('server bound'); * }); * ``` * * The server can be tested by connecting to it using the example client from {@link connect}. * @since v0.3.2 */ function createServer(secureConnectionListener?: (socket: TLSSocket) => void): Server; function createServer(options: TlsOptions, secureConnectionListener?: (socket: TLSSocket) => void): Server; /** * The `callback` function, if specified, will be added as a listener for the `'secureConnect'` event. * * `tls.connect()` returns a {@link TLSSocket} object. * * Unlike the `https` API, `tls.connect()` does not enable the * SNI (Server Name Indication) extension by default, which may cause some * servers to return an incorrect certificate or reject the connection * altogether. To enable SNI, set the `servername` option in addition * to `host`. * * The following illustrates a client for the echo server example from {@link createServer}: * * ```js * // Assumes an echo server that is listening on port 8000. * import tls from 'node:tls'; * import fs from 'node:fs'; * * const options = { * // Necessary only if the server requires client certificate authentication. * key: fs.readFileSync('client-key.pem'), * cert: fs.readFileSync('client-cert.pem'), * * // Necessary only if the server uses a self-signed certificate. * ca: [ fs.readFileSync('server-cert.pem') ], * * // Necessary only if the server's cert isn't for "localhost". * checkServerIdentity: () => { return null; }, * }; * * const socket = tls.connect(8000, options, () => { * console.log('client connected', * socket.authorized ? 'authorized' : 'unauthorized'); * process.stdin.pipe(socket); * process.stdin.resume(); * }); * socket.setEncoding('utf8'); * socket.on('data', (data) => { * console.log(data); * }); * socket.on('end', () => { * console.log('server ends connection'); * }); * ``` * @since v0.11.3 */ function connect(options: ConnectionOptions, secureConnectListener?: () => void): TLSSocket; function connect( port: number, host?: string, options?: ConnectionOptions, secureConnectListener?: () => void, ): TLSSocket; function connect(port: number, options?: ConnectionOptions, secureConnectListener?: () => void): TLSSocket; /** * `{@link createServer}` sets the default value of the `honorCipherOrder` option * to `true`, other APIs that create secure contexts leave it unset. * * `{@link createServer}` uses a 128 bit truncated SHA1 hash value generated * from `process.argv` as the default value of the `sessionIdContext` option, other * APIs that create secure contexts have no default value. * * The `tls.createSecureContext()` method creates a `SecureContext` object. It is * usable as an argument to several `tls` APIs, such as `server.addContext()`, * but has no public methods. The {@link Server} constructor and the {@link createServer} method do not support the `secureContext` option. * * A key is _required_ for ciphers that use certificates. Either `key` or `pfx` can be used to provide it. * * If the `ca` option is not given, then Node.js will default to using [Mozilla's publicly trusted list of * CAs](https://hg.mozilla.org/mozilla-central/raw-file/tip/security/nss/lib/ckfw/builtins/certdata.txt). * * Custom DHE parameters are discouraged in favor of the new `dhparam: 'auto' `option. When set to `'auto'`, well-known DHE parameters of sufficient strength * will be selected automatically. Otherwise, if necessary, `openssl dhparam` can * be used to create custom parameters. The key length must be greater than or * equal to 1024 bits or else an error will be thrown. Although 1024 bits is * permissible, use 2048 bits or larger for stronger security. * @since v0.11.13 */ function createSecureContext(options?: SecureContextOptions): SecureContext; /** * Returns an array containing the CA certificates from various sources, depending on `type`: * * * `"default"`: return the CA certificates that will be used by the Node.js TLS clients by default. * * When `--use-bundled-ca` is enabled (default), or `--use-openssl-ca` is not enabled, * this would include CA certificates from the bundled Mozilla CA store. * * When `--use-system-ca` is enabled, this would also include certificates from the system's * trusted store. * * When `NODE_EXTRA_CA_CERTS` is used, this would also include certificates loaded from the specified * file. * * `"system"`: return the CA certificates that are loaded from the system's trusted store, according * to rules set by `--use-system-ca`. This can be used to get the certificates from the system * when `--use-system-ca` is not enabled. * * `"bundled"`: return the CA certificates from the bundled Mozilla CA store. This would be the same * as `tls.rootCertificates`. * * `"extra"`: return the CA certificates loaded from `NODE_EXTRA_CA_CERTS`. It's an empty array if * `NODE_EXTRA_CA_CERTS` is not set. * @since v22.15.0 * @param type The type of CA certificates that will be returned. Valid values * are `"default"`, `"system"`, `"bundled"` and `"extra"`. * **Default:** `"default"`. * @returns An array of PEM-encoded certificates. The array may contain duplicates * if the same certificate is repeatedly stored in multiple sources. */ function getCACertificates(type?: "default" | "system" | "bundled" | "extra"): string[]; /** * Returns an array with the names of the supported TLS ciphers. The names are * lower-case for historical reasons, but must be uppercased to be used in * the `ciphers` option of `{@link createSecureContext}`. * * Not all supported ciphers are enabled by default. See * [Modifying the default TLS cipher suite](https://nodejs.org/docs/latest-v24.x/api/tls.html#modifying-the-default-tls-cipher-suite). * * Cipher names that start with `'tls_'` are for TLSv1.3, all the others are for * TLSv1.2 and below. * * ```js * console.log(tls.getCiphers()); // ['aes128-gcm-sha256', 'aes128-sha', ...] * ``` * @since v0.10.2 */ function getCiphers(): string[]; /** * Sets the default CA certificates used by Node.js TLS clients. If the provided * certificates are parsed successfully, they will become the default CA * certificate list returned by {@link getCACertificates} and used * by subsequent TLS connections that don't specify their own CA certificates. * The certificates will be deduplicated before being set as the default. * * This function only affects the current Node.js thread. Previous * sessions cached by the HTTPS agent won't be affected by this change, so * this method should be called before any unwanted cachable TLS connections are * made. * * To use system CA certificates as the default: * * ```js * import tls from 'node:tls'; * tls.setDefaultCACertificates(tls.getCACertificates('system')); * ``` * * This function completely replaces the default CA certificate list. To add additional * certificates to the existing defaults, get the current certificates and append to them: * * ```js * import tls from 'node:tls'; * const currentCerts = tls.getCACertificates('default'); * const additionalCerts = ['-----BEGIN CERTIFICATE-----\n...']; * tls.setDefaultCACertificates([...currentCerts, ...additionalCerts]); * ``` * @since v24.5.0 * @param certs An array of CA certificates in PEM format. */ function setDefaultCACertificates(certs: ReadonlyArray): void; /** * The default curve name to use for ECDH key agreement in a tls server. * The default value is `'auto'`. See `{@link createSecureContext()}` for further * information. * @since v0.11.13 */ let DEFAULT_ECDH_CURVE: string; /** * The default value of the `maxVersion` option of `{@link createSecureContext()}`. * It can be assigned any of the supported TLS protocol versions, * `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. **Default:** `'TLSv1.3'`, unless * changed using CLI options. Using `--tls-max-v1.2` sets the default to `'TLSv1.2'`. Using * `--tls-max-v1.3` sets the default to `'TLSv1.3'`. If multiple of the options * are provided, the highest maximum is used. * @since v11.4.0 */ let DEFAULT_MAX_VERSION: SecureVersion; /** * The default value of the `minVersion` option of `{@link createSecureContext()}`. * It can be assigned any of the supported TLS protocol versions, * `'TLSv1.3'`, `'TLSv1.2'`, `'TLSv1.1'`, or `'TLSv1'`. **Default:** `'TLSv1.2'`, unless * changed using CLI options. Using `--tls-min-v1.0` sets the default to * `'TLSv1'`. Using `--tls-min-v1.1` sets the default to `'TLSv1.1'`. Using * `--tls-min-v1.3` sets the default to `'TLSv1.3'`. If multiple of the options * are provided, the lowest minimum is used. * @since v11.4.0 */ let DEFAULT_MIN_VERSION: SecureVersion; /** * The default value of the `ciphers` option of `{@link createSecureContext()}`. * It can be assigned any of the supported OpenSSL ciphers. * Defaults to the content of `crypto.constants.defaultCoreCipherList`, unless * changed using CLI options using `--tls-default-ciphers`. * @since v19.8.0 */ let DEFAULT_CIPHERS: string; /** * An immutable array of strings representing the root certificates (in PEM format) * from the bundled Mozilla CA store as supplied by the current Node.js version. * * The bundled CA store, as supplied by Node.js, is a snapshot of Mozilla CA store * that is fixed at release time. It is identical on all supported platforms. * @since v12.3.0 */ const rootCertificates: readonly string[]; } declare module "node:tls" { export * from "tls"; }