Ninety-nine Pitchers of Malt

    dotencr
    TypeScript icon, indicating that this package has built-in type declarations

    1.0.3 • Public • Published

    dotenv-encrypt aka dotencr

    Encrypt and decrypt individual lines inside a .env file. Supports multiple environments. Encryption keys can be read from a text file or from the environment.

    Uses dotenv for reading .env files.

    ✅ TypeScript support ✅

    Library and command line interface

    The library can load and decrypt variables stored in a .env file.

    The CLI (command line interface) can encrypt and decrypt entire .env files. It can also test your encrypted .env file for any issues. The CLI generates output in JSON for easy parsing.

    Installation

    Using npm:

    $ npm i dotencr

    Note: add --save if you are using npm < 5.0.0

    Features

    Transparently decrypt values in your dotenv file

    Inside your .env

    CIPHERED__DEV__EMAIL_API=q6M1bArrP6vCQooz.ZUi7rAgMG+KrOOVJ1qKyYB7W/umPFKZTGZ5UIh5JBBGlRTluS2yr.CcggXA5pndStr4MjczcwDg==

    is loaded into the process.env as

    UNENCRYPTED__DEV__EMAIL_API=EM.74f2f09e-7fde-4de8-afd8-82bd5050cc5c

    Use a single .env file for all of you environments

    CIPHERED__PROD__MONGODB_CONN_URI=kBIT9XGsjJde1k8P.3jutbijodVqQ3s6r8HGIvAJ6VVqxTr3TRVZr/WpUsLsL131stt2iBKPvWymrVmfPuvBBc0zsUEMeJn8X2LICKg==.8b95MRxaLVHWZP90Jl+18Q==
    CIPHERED__TEST__MONGODB_CONN_URI=tm/NnqfiLJrEck+e.hQnpgKjoST/EuGd6T+wEg+LUOSiQh/F18JlQNgVAdT/h/zO+yOsb2W/C9R6p/iV7xgL5ZXQOxWDhfmRUTCVXnw==.3CkkMVRSbUOsHiHW0xgIWg==
    CIPHERED__DEV__MONGODB_CONN_URI=eKUJcDfhjsLSuGiO.5zEuGMbJIr2kJCkxi2h7M/fd9PBIEE18HOrp/6nEZY7stNKm7UvrwBtNJkybpzqh7TuHhzVdi6y3kugd1JO2.e8pu7Q4bX5G7S/fPIOW86Q==
    CIPHERED__LOCAL__MONGODB_CONN_URI=XrWJtbMpeSd/pGkS.nRVgbW9/gtbYGdezQ5WyN3hydn4sHGhXcQJcFja/Dvfn2z9fiEmpq/6x.FjREVjOxemKZKO0iDk+goQ==

    Supports multiple encryption keys, one for each environment

    DOTENV_ENC_KEY__LOCAL=VRd/lYPCt6uV0NgiRSlFmzMKAaGdhWkItWHvkOUIIfQ=
    DOTENV_ENC_KEY__DEV=DA2Yj8nc383NOBLsWBT7LH22ooU5YxdZTyiSYa6d2rY=
    DOTENV_ENC_KEY__TEST=nLseXPYWho9TF1x+lOnC7EkwijvMd0RQMa5IWLhzN2A=
    DOTENV_ENC_KEY__PROD=1J5L9wJrfOnLo/0M62q+az43wDjiLfvXw9UZlV0mMCo=

    Only decrypt the needed environment

    The library only decrypts a variable if the encryption key is provided. For example, in your development environment, don't include the TEST or PROD keys and those will remain encrypted.

    Adding this to your environment

    export DOTENV_ENC_KEY__DEV=DA2Yj8nc383NOBLsWBT7LH22ooU5YxdZTyiSYa6d2rY=

    Only decrypts DEV

    CIPHERED__TEST__SESSION_SECRET=AAAAAAAAAAAAAAAA.6xal+yDKO/4bnAzadSwPXiS14w==.zHzDrwblNDF59kyhGYHS7Q==
    - CIPHERED__DEV__SESSION_SECRET=AAAAAAAAAAAAAAAA.MndptYojylf1fOfwdz56sWiC.R+b7yj0gUGNM2ZhvynKM/A==
    + UNENCRYPTED__DEV__SESSION_SECRET=dev session secret
    CIPHERED__PROD__SESSION_SECRET=AAAAAAAAAAAAAAAA.8fxYOsLT/KGUwNrNXepufxIN4w==.EP1+C5B5V+IuM3j3c/7VdQ==

    Usage tip #1: Using a common key for all environments

    If you have information common to all environments, you can create a specific encryption key just for that information.

    DOTENV_ENC_KEY__ALL=VRd/lYPCt6uV0NgiRSlFmzMKAaGdhWkItWHvkOUIIfQ=
    UNENCRYPTED__ALL__VARIABLE_COMMON_TO_ALL_ENVIRONMENTS=common info for all environments

    Usage tip #2: wildcard

    Writing WILDCARD as the key name, dotenv-encrypt will try all the encryption keys.

    For example, CIPHERED__WILDCARD__MONGODB_CONN_URI, will try all the encryption keys:

    • DOTENV_ENC_KEY__LOCAL
    • DOTENV_ENC_KEY__DEV
    • DOTENV_ENC_KEY__TEST
    • DOTENV_ENC_KEY__PROD
    Example

    Use the CIPHERED__WILDCARD__MONGODB_CONN_URI entry to connect to your various MongoDb servers regardless of the environment you are running in.

    Copy the encrypted value tm/NnqfiLJrEck+e.hQnpgKjoST/EuGd6T+wEg+LUOSiQh/F18JlQNgVAdT/h/zO+yOsb2W/C9R6p/iV7xgL5ZXQOxWDhfmRUTCVXnw==.3CkkMVRSbUOsHiHW0xgIWg== from CIPHERED__TEST__MONGODB_CONN_URI to CIPHERED__WILDCARD__MONGODB_CONN_URI

    CIPHERED__TEST__MONGODB_CONN_URI=tm/NnqfiLJrEck+e.hQnpgKjoST/EuGd6T+wEg+LUOSiQh/F18JlQNgVAdT/h/zO+yOsb2W/C9R6p/iV7xgL5ZXQOxWDhfmRUTCVXnw==.3CkkMVRSbUOsHiHW0xgIWg==
    + CIPHERED__WILDCARD__MONGODB_CONN_URI=tm/NnqfiLJrEck+e.hQnpgKjoST/EuGd6T+wEg+LUOSiQh/F18JlQNgVAdT/h/zO+yOsb2W/C9R6p/iV7xgL5ZXQOxWDhfmRUTCVXnw==.3CkkMVRSbUOsHiHW0xgIWg==

    This will be appear in your process.env as UNENCRYPTED__WILDCARD__MONGODB_CONN_URI

    console.log(process.env["UNENCRYPTED__WILDCARD__MONGODB_CONN_URI"]);
    > mongodb://<mlab_user>:<mlab_password>@<mlab_connection_url_test>

    Easily generate new keys

    Use openssl to generate new encryption keys

    $ openssl rand -base64 32
    FThmNEaGrawthp3ZdiEFfCceds4Hn2ZY6pu6NImyNy8=

    Add the new encryption key to your .bash_profile, dotenv file, or cloud environment.

    export DOTENV_ENC_KEY__NEW_KEY=FThmNEaGrawthp3ZdiEFfCceds4Hn2ZY6pu6NImyNy8=

    Uses AES-256-GCM encryption

    The library uses AES 256 bit encryption in GCM mode. GCM mode generates a value that can be used to verify the data has not been modified. See wikipedia for more information Galois_Counter_Mode.

    The encrypted text is divided into three parts, separated by a period: IV (Initialization Vector), Ciphered Text, Authentication Tag

    CIPHERED__PROD__SECRET_TEXT=wdb1kM/1Wfs4DtFI.dUx0+UTvozWgheWrJPwEQ+sE23YpvDwp6U9P3BIwq8jpf3Nz2uEyUurG74KOqcjTDRuKlg7UKHBgyJSZnBZC.gr+I4brHK7EcCSWdB01EIg==
     
    Initialization Vector (base64 encoding): wdb1kM/1Wfs4DtFI
    Ciphered text (base64 encoding): dUx0+UTvozWgheWrJPwEQ+sE23YpvDwp6U9P3BIwq8jpf3Nz2uEyUurG74KOqcjTDRuKlg7UKHBgyJSZnBZC
    Authentication Tag (base64 encoding): gr+I4brHK7EcCSWdB01EIg==
    • Initialization Vector: is a randomly generated starting value. See wikipedia for more information Initialization_vector.

    • Ciphered Text: is the encrypted value.

    • Authentication Tag: is used to verify the data has not been modified. It's purpose is similar to that of an HMAC.

    Naming conventions

    Encryption keys

    Full text Prefix Separator Encryption key name Equal sign Encryption key (base 64 encoding)
    DOTENV_ENC_KEY__KEY_NAME=VRd/lYPCt6uV0NgiRSlFmzMKAaGdhWkItWHvkOUIIfQ= DOTENV_ENC_KEY __ KEY_NAME = VRd/lYPCt6uV0NgiRSlFmzMKAaGdhWkItWHvkOUIIfQ=
    DOTENV_ENC_KEY__DEV=DA2Yj8nc383NOBLsWBT7LH22ooU5YxdZTyiSYa6d2rY= DOTENV_ENC_KEY __ DEV = DA2Yj8nc383NOBLsWBT7LH22ooU5YxdZTyiSYa6d2rY=
    DOTENV_ENC_KEY__PROD=1J5L9wJrfOnLo/0M62q+az43wDjiLfvXw9UZlV0mMCo= DOTENV_ENC_KEY __ PROD = 1J5L9wJrfOnLo/0M62q+az43wDjiLfvXw9UZlV0mMCo=

    Unencrypted dotenv variables

    Full text Prefix Separator Encryption key name Separator Variable Name Equal sign Value Uses this encryption key (see table above)
    UNENCRYPTED__KEY_NAME__SESSION_SECRET=test session secret UNENCRYPTED __ KEY_NAME __ SESSION_SECRET = misc session secret VRd/lYPCt6uV0NgiRSlFmzMKAaGdhWkItWHvkOUIIfQ=
    UNENCRYPTED__DEV__SESSION_SECRET=dev session secret UNENCRYPTED __ DEV __ SESSION_SECRET = dev session secret DA2Yj8nc383NOBLsWBT7LH22ooU5YxdZTyiSYa6d2rY=
    UNENCRYPTED__PROD__SESSION_SECRET=prod session secret UNENCRYPTED __ PROD __ SESSION_SECRET = prod session secret 1J5L9wJrfOnLo/0M62q+az43wDjiLfvXw9UZlV0mMCo=

    Ciphered dotenv variables

    Full text Prefix Separator Encryption key name Separator Variable Name Equal sign Value Uses this encryption key (see table above)
    CIPHERED__KEY_NAME__SESSION_SECRET=P/qFaEaLinQlpN0J.YA+s/bm/i7ATXTNC6xk1T0QD9Q==.X6LMY5Ihl4jVuelLVan50A== CIPHERED __ KEY_NAME __ SESSION_SECRET = P/qFaEaLinQlpN0J.YA+s/bm/i7ATXTNC6xk1T0QD9Q==.X6LMY5Ihl4jVuelLVan50A== VRd/lYPCt6uV0NgiRSlFmzMKAaGdhWkItWHvkOUIIfQ=
    CIPHERED__DEV__SESSION_SECRET=08W5CnmckwGwGMiK.HbQljYHWzkVdjpntPP6Obk+g.MMyAlD+wJR57xN+MwNRXnQ== CIPHERED __ DEV __ SESSION_SECRET = 08W5CnmckwGwGMiK.HbQljYHWzkVdjpntPP6Obk+g.MMyAlD+wJR57xN+MwNRXnQ== DA2Yj8nc383NOBLsWBT7LH22ooU5YxdZTyiSYa6d2rY=
    CIPHERED__PROD__SESSION_SECRET=u6nMOBh8dsph+ccL.s/LPl2ZEYUqlOm7jruDBv3z3qA==.QbXFaAwm/SzOQk/HEqRbXg== CIPHERED __ PROD __ SESSION_SECRET = u6nMOBh8dsph+ccL.s/LPl2ZEYUqlOm7jruDBv3z3qA==.QbXFaAwm/SzOQk/HEqRbXg== 1J5L9wJrfOnLo/0M62q+az43wDjiLfvXw9UZlV0mMCo=
    CIPHERED__WILDCARD__SESSION_SECRET=u6nMOBh8dsph+ccL.s/LPl2ZEYUqlOm7jruDBv3z3qA==.QbXFaAwm/SzOQk/HEqRbXg== CIPHERED __ try all the encryption keys when decrypting __ SESSION_SECRET = u6nMOBh8dsph+ccL.s/LPl2ZEYUqlOm7jruDBv3z3qA==.QbXFaAwm/SzOQk/HEqRbXg== decryption successful with key 1J5L9wJrfOnLo/0M62q+az43wDjiLfvXw9UZlV0mMCo=

    Why UNENCRYPTED and CIPHERED

    I picked completely different words for the sake of readability. UNENCRYPTED and ENCRYPTED are too easily confused.

    Storing encryption keys

    Encryption keys can be read from the environment or from a file.

    This is an example of how to add encryption keys to your .bash_profile

    export DOTENV_ENC_KEY__LOCAL=VRd/lYPCt6uV0NgiRSlFmzMKAaGdhWkItWHvkOUIIfQ=
    export DOTENV_ENC_KEY__DEV=DA2Yj8nc383NOBLsWBT7LH22ooU5YxdZTyiSYa6d2rY=
    export DOTENV_ENC_KEY__VERY_LONG_NAME=nLseXPYWho9TF1x+lOnC7EkwijvMd0RQMa5IWLhzN2A=

    The encryption keys can also be stored in a dotenv file, .env_encryption_keys, and loaded into your environment using the dotenv library

    DOTENV_ENC_KEY__LOCAL=VRd/lYPCt6uV0NgiRSlFmzMKAaGdhWkItWHvkOUIIfQ=
    DOTENV_ENC_KEY__DEV=DA2Yj8nc383NOBLsWBT7LH22ooU5YxdZTyiSYa6d2rY=
    DOTENV_ENC_KEY__VERY_LONG_NAME=nLseXPYWho9TF1x+lOnC7EkwijvMd0RQMa5IWLhzN2A=

    ❗️❗️ Please evaluate the ease of use vs security when deciding where to store your encryption keys. ❗️❗️

    100% test coverage

    NodeJS usage examples

    TypeScript

    import { decryptProcessEnvironment } from "dotencr";
    import dotenv from "dotenv";
     
    dotenv.config({ path: ".env" });
     
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    const processEnvDecryptionResult = decryptProcessEnvironment();
     
    console.log(process.env["UNENCRYPTED__LOCAL__SESSION_SECRET"]);

    JavaScript

    const decryptProcessEnvironment = require("dotencr").decryptProcessEnvironment;
    const dotenv = require("dotenv");
     
    dotenv.config({ path: ".env" });
     
    const processEnvDecryptionResult = decryptProcessEnvironment();
     
    console.log(process.env["UNENCRYPTED__LOCAL__SESSION_SECRET"]);

    Command line usage examples

    Invoke the application using dotenc on the command line.

    Decrypt a key value pair

    $ dotenc kdec "CIPHERED__DEV__EMAIL_API=q6M1bArrP6vCQooz.ZUi7rAgMG+KrOOVJ1qKyYB7W/umPFKZTGZ5UIh5JBBGlRTluS2yr.CcggXA5pndStr4MjczcwDg=="
    UNENCRYPTED__DEV__EMAIL_API=EM.74f2f09e-7fde-4de8-afd8-82bd5050cc5c

    Encrypt a key value pair

    $ dotenc kenc "UNENCRYPTED__DEV__EMAIL_API=EM.74f2f09e-7fde-4de8-afd8-82bd5050cc5c"
    CIPHERED__DEV__EMAIL_API=NLCiZiNCJTsvLDFc.+G+3LS3vuHwxP1X/4ZTbcui05gTVOJcZXqZa0Qz8kwlmocBGwnjT.cBKY+6Jz/eb+A326+a0oVQ==

    Decrypt a triple: decryption_key_name variable_name value

    dotenc can build key value pair for you by just specifying the:

    • decryption key name: DEV
    • variable name: EMAIL_API
    • value: FhdQgQOC6th8fmti.IBxk8vKOTR4nYHPhDEJVB8ql7EW4rkd/tTxbXREjuMPrsoE0cbxu.JOv1f+AODXEUOUoACmgAQg==
    $ dotenc xdec DEV EMAIL_API "FhdQgQOC6th8fmti.IBxk8vKOTR4nYHPhDEJVB8ql7EW4rkd/tTxbXREjuMPrsoE0cbxu.JOv1f+AODXEUOUoACmgAQg=="
    UNENCRYPTED__DEV__EMAIL_API=EM.74f2f09e-7fde-4de8-afd8-82bd5050cc5c

    Encrypt a triple: decryption_key_name variable_name value

    dotenc can build key value pair for you by just specifying the:

    • decryption key name: DEV
    • variable name: EMAIL_API
    • value: EM.74f2f09e-7fde-4de8-afd8-82bd5050cc5c
    $ $ dotenc xenc DEV EMAIL_API "EM.74f2f09e-7fde-4de8-afd8-82bd5050cc5c"
    CIPHERED__DEV__EMAIL_API=LxhVW3OmYt+dpH/m.1RPR6EHpbeeIYwt/Hukn2fm/BGGp+k+4bRB2/87TZ5fzd8/4VOLE.+c3VL3eBERKmpqsrkTU4pg==

    Test a file to see which variables can and cannot be decrypted

    The results of the test are written to the file dotenv-encrypt_log.json

    $ dotenc test --file .env
    $ cat dotenv-encrypt_log.json

    Encrypt an environment file

    The results of the encryption are written to the file dotenv-encrypt_log.json

    $ dotenc enc --file .env
    $ cat dotenv-encrypt_log.json

    Decrypt an environment file

    The results of the decryption are written to the file dotenv-encrypt_log.json

    $ dotenc dec --file .env
    $ cat dotenv-encrypt_log.json

    Specifying output folders

    The location of the files can be written to distinct folders.

    $ dotenc enc --file ".env" --output "./folder/.env.txt" --jsonOutput "./another_folder/output.json" --backupFolder "./folder_backups/env.bak"
    $ cat dotenv-encrypt_log.json

    Process multiple environment files

    $ dotenc enc --file .env .env_prod .env_test

    The application will search for .env

    $ dotenc enc

    Prevent the application from creating a backup file

    By default, a backup file is created before encrypting or decrypting the environment file.

    $ dotenc enc --no-backup

    Write relative paths to the JSON output file

    By default, the full path is written to the JSON file. For example \full\path\.env

    If useRelativePaths is specified, then the realtive folder path is written to the JSON file. For example path\.env

    $ dotenc enc --useRelativePaths

    Command line usage

    $ dotenc
    Usage: dotenc <enc|kenc|xenc|dec|kdec|xdec|test> [options]
    
    Commands:
      dotenc enc                        Encrypt the variables inside the dotenv file
      dotenc dec                        Decrypt the variables inside the dotenv file
      dotenc kenc <keyvalue>            Encrypt the command line value
      dotenc kdec <keyvalue>            Decrypt the command line value
      dotenc xenc <key> <name> <value>  Encrypt the command line value
      dotenc xdec <key> <name> <value>  Decrypt the command line value
      dotenc test                       Test decrypted dotenv file
    
    Options:
      --version                      Show version number  [boolean]
      --file, -f                     dotenv file  [array] [default: [".env"]]
      --output, -o                   Output folder  [string]
      --jsonOutput, --jo             Write the results to the file in JSON format  [default: "dotenv-encrypt_log.json"]
      --backupFolder, --bf           Create a backup file in the specified folder.  [default: "."]
      --backup, -b                   create a backup file  [boolean] [default: true]
      --useRelativePaths, --relpath  Use relative folder paths  [boolean] [default: false]
      -h, --help                     Show help  [boolean]
    
    Examples:
      dotenc enc -f .env.*                                                                                                                 Encrypt the contents of the variables inside the dotenv file
      dotenc dec -f .env.*                                                                                                                 Decrypt the contents of the variables inside the dotenv file
      dotenc test -f .env.*                                                                                                                Test the contents of the variables inside the dotenv file
      dotenc kdec CIPHERED__DEV__EMAIL_API=q6M1bArrP6vCQooz.ZUi7rAgMG+KrOOVJ1qKyYB7W/umPFKZTGZ5UIh5JBBGlRTluS2yr.CcggXA5pndStr4MjczcwDg==  Decrypt the command line
      dotenc kenc UNENCRYPTED__DEV__EMAIL_API=EM.74f2f09e-7fde-4de8-afd8-82bd5050cc5c                                                      Encrypt the command line
      dotenc xdec DEV EMAIL_API FhdQgQOC6th8fmti.IBxk8vKOTR4nYHPhDEJVB8ql7EW4rkd/tTxbXREjuMPrsoE0cbxu.JOv1f+AODXEUOUoACmgAQg==             Decrypt the command line
      dotenc xenc DEV EMAIL_API EM.74f2f09e-7fde-4de8-afd8-82bd5050cc5c                                                                    Encrypt the command line
    
    copyright Carlos Klapp 2020
    

    Sample JSON output

    {
        "dotenvOutputFileName": "test/results/out/.env.mixed.enc",
        "dotenvSourceFileName": "test/env_test_files/.env.mixed",
        "errors": {
            "cipheredVariableErrors": [
                "The encryption key name is invalid [CIPHERED__WILDCARD__TOO__MANY__TOKENS] or the value is invalid [MCs42CZWs9pbCoN/.m6Yp3bKFWWt4zyBCAzchiYC+.Rpm7TcSbMcAJsNJGZqe/hg==].",
                "[CIPHERED__WILDCARD__TOO__MANY__TOKENS] Got 5 tokens on the left side. Expected between 3 and 3"
            ],
            "encryptionKeyErrors": [
                "The encryption key name [DOTENV_ENC_KEY__WILDCARD] is the reserved word [WILDCARD].",
                "The encryption key name is invalid [DOTENV_ENC_KEY__TOO___MANY] or the value is invalid [4fziNa9iDylQmkz6vJce7oSly1p3uge36ORwJUBt].",
                "Encryption key [DOTENV_ENC_KEY__TOO_SMALL] is too short. Expected a length of 32 bytes (256bits) and received 30 bytes."
            ],
            "errorDecryptingVariables": [
                "Exception: Variable: [CIPHERED__ALL__CIPHER_BAD_CIPHERED_TEXT], Message: [Unsupported state or unable to authenticate data]",
                "Exception: Variable: [CIPHERED__ALL__CIPHER_BAD_IV], Message: [Unsupported state or unable to authenticate data]",
                "Exception: Variable: [CIPHERED__ALL__CIPHER_BAD_TAG], Message: [Unsupported state or unable to authenticate data]",
                "Exception: Variable: [CIPHERED__LOCAL__BAD_CIPHER], Message: [Invalid authentication tag length: 3]",
                "Exception: Variable: [CIPHERED__WILDCARD__BAD_CIPHER], Message: [Invalid authentication tag length: 3]",
                "None of the encryption keys could decrypt [CIPHERED__WILDCARD__BAD_CIPHER]"
            ],
            "errorEncryptingVariables": ["Encryption key not found [DOTENV_ENC_KEY__MISSING_KEY]"],
            "errorValuesDoNotMatch": [
                "Mismatch between [UNENCRYPTED__ALL__MISMATCH_CIPHER_UNENCRYPTED] and [CIPHERED__ALL__MISMATCH_CIPHER_UNENCRYPTED]. [plain text value]!=[ciphered value]"
            ],
            "invalidVariableFormat": [
                "CIPHERED__WILDCARD__TOO__MANY__TOKENS",
                "UNENCRYPTED__WILDCARD__SESSION_SECRET"
            ],
            "plainTextVariableErrors": [
                "The encryption key name [UNENCRYPTED__WILDCARD__SESSION_SECRET] is the reserved word [WILDCARD]."
            ],
            "plainTextVariables": []
        },
        "info": {
            "encryptedVariables": [
                "CIPHERED__ALL__CIPHER_BAD_CIPHERED_TEXT",
                "CIPHERED__ALL__CIPHER_BAD_IV",
                "CIPHERED__ALL__CIPHER_BAD_TAG",
                "CIPHERED__ALL__MISMATCH_CIPHER_UNENCRYPTED",
                "CIPHERED__ALL__MONGODB_CONN_URI",
                "CIPHERED__DEV__MONGODB_CONN_URI",
                "CIPHERED__LOCAL__BAD_CIPHER",
                "CIPHERED__LOCAL__MONGODB_CONN_URI",
                "CIPHERED__LOCAL__SESSION_SECRET",
                "CIPHERED__PROD__MONGODB_CONN_URI",
                "CIPHERED__TEST__MONGODB_CONN_URI",
                "CIPHERED__WILDCARD__BAD_CIPHER",
                "CIPHERED__WILDCARD__MONGODB_CONN_URI",
                "CIPHERED__WILDCARD__SESSION_SECRET"
            ],
            "encryptionKeys": [
                "DOTENV_ENC_KEY__ALL",
                "DOTENV_ENC_KEY__DEV",
                "DOTENV_ENC_KEY__LOCAL",
                "DOTENV_ENC_KEY__PROD",
                "DOTENV_ENC_KEY__TEST"
            ],
            "matchingPlainTextAndCipherValues": [
                "Match between [UNENCRYPTED__LOCAL__SESSION_SECRET] and [CIPHERED__LOCAL__SESSION_SECRET]"
            ],
            "miscellaneous": [],
            "successfullyDecrypted": [
                "CIPHERED__ALL__MISMATCH_CIPHER_UNENCRYPTED",
                "CIPHERED__ALL__MONGODB_CONN_URI",
                "CIPHERED__DEV__MONGODB_CONN_URI",
                "CIPHERED__LOCAL__MONGODB_CONN_URI",
                "CIPHERED__LOCAL__SESSION_SECRET",
                "CIPHERED__PROD__MONGODB_CONN_URI",
                "CIPHERED__TEST__MONGODB_CONN_URI",
                "CIPHERED__WILDCARD__MONGODB_CONN_URI",
                "CIPHERED__WILDCARD__SESSION_SECRET"
            ],
            "successfullyEncrypted": [
                "UNENCRYPTED__ALL__MISMATCH_CIPHER_UNENCRYPTED",
                "UNENCRYPTED__ALL__SESSION_SECRET",
                "UNENCRYPTED__DEV__SESSION_SECRET",
                "UNENCRYPTED__LOCAL__SESSION_SECRET",
                "UNENCRYPTED__PROD__SESSION_SECRET",
                "UNENCRYPTED__TEST__SESSION_SECRET"
            ]
        },
        "warnings": {
            "missingEncryptionKeys": ["DOTENV_ENC_KEY__MISSING_KEY"]
        }
    }

    Why the name

    The original package name dotenv-encrypt. But there were name conflicts with NPM. So I chose dotencr. dotenc was available, but it was too close to the name dotenv.

    I kept the command line name as dotenc since there isn't a name conflict at the moment.

    Install

    npm i dotencr

    DownloadsWeekly Downloads

    6

    Version

    1.0.3

    License

    MIT

    Unpacked Size

    151 kB

    Total Files

    36

    Last publish

    Collaborators

    • carlosk