Logo for jsDocs.io

selfsigned

  • Version 5.2.0
  • Published
  • 62.5 kB
  • 2 dependencies
  • MIT license

Install

npm i selfsigned
yarn add selfsigned
pnpm add selfsigned

Overview

Generate self signed certificates private and public keys

Index

Functions

Interfaces

Enums

Functions

function generate

generate: (
    attrs?: CertificateField[],
    opts?: SelfsignedOptions
) => Promise<GenerateResult>;

  • Generate a certificate (async only)

    Parameter attrs

    Certificate attributes

    Parameter opts

    Generation options

    Returns

    Promise that resolves with certificate data

    Example 1

    // Self-signed certificate
    const pems = await generate();
    

    const pems = await generate([{ name: 'commonName', value: 'example.com' }]);
    

    const pems = await generate(null, {
      keySize: 2048,
      algorithm: 'sha256'
    });
    

    // CA-signed certificate
    const pems = await generate([{ name: 'commonName', value: 'localhost' }], {
      algorithm: 'sha256',
      ca: {
        key: fs.readFileSync('/path/to/ca.key', 'utf8'),
        cert: fs.readFileSync('/path/to/ca.crt', 'utf8')
      }
    });

Interfaces

interface CertificateField

interface CertificateField extends CertificateFieldOptions {}

    property extensions

    extensions?: any[] | undefined;

      property value

      value?: any[] | string | undefined;

        property valueConstructed

        valueConstructed?: boolean | undefined;

          property valueTagClass

          valueTagClass?: ASN1Class | undefined;

            interface CertificateFieldOptions

            interface CertificateFieldOptions {}

              property name

              name?: string | undefined;

                property shortName

                shortName?: string | undefined;

                  property type

                  type?: string | undefined;

                    interface GenerateResult

                    interface GenerateResult {}

                      property cert

                      cert: string;

                        property clientcert

                        clientcert?: string;

                          property clientpkcs7

                          clientpkcs7?: string;

                            property clientprivate

                            clientprivate?: string;

                              property clientpublic

                              clientpublic?: string;

                                property fingerprint

                                fingerprint: string;

                                  property pkcs7

                                  pkcs7?: string;

                                    property private

                                    private: string;

                                      property public

                                      public: string;

                                        interface SelfsignedOptions

                                        interface SelfsignedOptions {}

                                          property algorithm

                                          algorithm?: string;

                                          • The signature algorithm: sha256, sha384, sha512 or sha1 "sha1"

                                          property ca

                                          ca?: {
                                              /** CA private key in PEM format */
                                              key: string;
                                              /** CA certificate in PEM format */
                                              cert: string;
                                          };

                                          • CA certificate and key for signing (if not provided, generates self-signed)

                                          property clientCertificate

                                          clientCertificate?: boolean;

                                          • generate client cert signed by the original key false

                                          property clientCertificateCN

                                          clientCertificateCN?: string;

                                          • client certificate's common name "John Doe jdoe123"

                                          property clientCertificateKeySize

                                          clientCertificateKeySize?: number;

                                          • the size for the client private key in bits 2048

                                          property extensions

                                          extensions?: any[];

                                          • additional extensions for the certificate

                                          property keyPair

                                          keyPair?: {
                                              privateKey: string;
                                              publicKey: string;
                                          };

                                          • existing key pair to use instead of generating new keys

                                          property keySize

                                          keySize?: number;

                                          • the size for the private key in bits 2048

                                          property notAfterDate

                                          notAfterDate?: Date;

                                          • The date after which the certificate should not be valid

                                            notBeforeDate + 365 days

                                          property notBeforeDate

                                          notBeforeDate?: Date;

                                          • The date before which the certificate should not be valid

                                            now

                                          property passphrase

                                          passphrase?: string;

                                          • Passphrase to encrypt the private key (PKCS#8 encrypted format) When provided, the private key will be encrypted using AES-256-CBC

                                          property pkcs7

                                          pkcs7?: boolean;

                                          • include PKCS#7 as part of the output false

                                          Enums

                                          enum ASN1Class

                                          enum ASN1Class {
                                              UNIVERSAL = 0x00,
                                              APPLICATION = 0x40,
                                              CONTEXT_SPECIFIC = 0x80,
                                              PRIVATE = 0xc0,
                                          }

                                            member APPLICATION

                                            APPLICATION = 0x40

                                              member CONTEXT_SPECIFIC

                                              CONTEXT_SPECIFIC = 0x80

                                                member PRIVATE

                                                PRIVATE = 0xc0

                                                  member UNIVERSAL

                                                  UNIVERSAL = 0x00

                                                    Package Files (1)

                                                    Dependencies (2)

                                                    Dev Dependencies (2)

                                                    Peer Dependencies (0)

                                                    No peer dependencies.

                                                    Badge

                                                    To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                    You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/selfsigned.

                                                    • Markdown
                                                      [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/selfsigned)
                                                    • HTML
                                                      <a href="https://www.jsdocs.io/package/selfsigned"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>