# jesuscrypt

> AES and RSA with node:crypto

Latest version **1.0.0** (published 2023-03-22) · ISC license · 0 weekly downloads

## Install

```sh
npm install jesuscrypt
pnpm add jesuscrypt
yarn add jesuscrypt
bun add jesuscrypt
```

## Health

**Score 15/100 (F)** — status: abandoned.

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 1.0.0 |
| Published | 2023-03-22 |
| First published | 2023-03-22 |
| Weekly downloads | 0 |
| License | ISC |
| TypeScript types | none |
| Module format | CommonJS |
| Dependencies | 2 |
| Unpacked size | 16.8 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| Author | Michele Milani |
| Maintainers | michelemilani |
| Keywords | Crypto, AES, crypt, decrypt, encrypt, encode, decode |

## Links

- npm: https://www.npmjs.com/package/jesuscrypt
- npm.io page: https://npm.io/package/jesuscrypt

## Dependencies (2)

- [node-rsa](https://npm.io/package/node-rsa.md) ^1.1.1
- [node-forge](https://npm.io/package/node-forge.md) ^1.3.1

## Alternatives

- [@gemini-wallet/core](https://npm.io/package/@gemini-wallet/core.md) — 515.6K weekly downloads
- [utility](https://npm.io/package/utility.md) — 416.6K weekly downloads
- [@primno/dpapi](https://npm.io/package/@primno/dpapi.md) — 7.2K weekly downloads
- [pi-readseek](https://npm.io/package/pi-readseek.md) — 3.7K weekly downloads
- [@emilia-protocol/verify](https://npm.io/package/@emilia-protocol/verify.md) — 1.1K weekly downloads

## Recent versions

- 1.0.0 (latest) — 2023-03-22

## README

# JesusCrypt

AES and RSA with node:crypto

This module is in Javascript. It doesn't support Typescript (yet).

## Installation

`npm install --save jesuscrypt`

You can find the following and few more examples in the `./examples` folder.

## AES-256

```js
// Import AES from jesuscript
const { AES } = require('jesuscript');

// Let create a plain text string
let plaintext = [...new Array(10)].map(k=>'test').join('');

/**
 * Init AES
 * 
 * Default params:
{
algorithm='aes-256-cbc', key=crypto.randomBytes(32), iv=crypto.randomBytes(16)
}
*/
let aes = new AES();

/** Encrypt data */
let encrypted = aes.encrypt({
    message: plaintext,
    key: aes.key, // optional. Default is aes.key
    iv: aes.iv // optional. Default is aes.iv
});

/** Decrypt data */
let decrypted = aes.decrypt({
    message: encrypted.message,
    key: aes.key, // optional. Default is aes.key
    iv: encrypted.iv // optional. Default is aes.iv
});

/** Show something in console */
[
    plaintext,
    aes.key.toString('hex'),
    aes.iv.toString('hex'),
    encrypted,
    decrypted
].map(v=>console.log(v));
```

## AES-256 Promises

```js
// Import AES from jesuscript
const { AES } = require('jesuscrypt');

// Let create a plain text string
let plaintext = [...new Array(10)].map(k=>'test').join('');

/**
 * Init AES and convert methods as promises
 * 
 * Default params:
{
algorithm='aes-256-cbc', key=crypto.randomBytes(32), iv=crypto.randomBytes(16)
}
*/
let aes = new AES().promises;

// Show something in console
console.log(plaintext);
console.log(aes.key.toString('hex'));
console.log(aes.iv.toString('hex'));

// Encrypt message
aes.encrypt({
    message: plaintext,
    key: aes.key, // optional. Default is aes.key
    iv: aes.iv // optional. Default is aes.iv
})
.then(encrypted=>{
    // Show something in console
    console.log(encrypted);

    // Decrypt message
    return aes.decrypt({
        message: encrypted.message,
        key: aes.key, // optional. Default is aes.key
        iv: encrypted.iv // optional. Default is aes.iv
    });
})
.then(decrypted=>{
    // Show something in console
    return console.log(decrypted);
})
.catch(console.error);
```

## RSA

```js
// Import RSA
const { RSA } = require('jesuscrypt');

// Get a plain text string
let plaintext = [...new Array(10)].map(k=>'test').join('');

/**
 * Init RSA
 * 
 * default params:
 * { algorithm: 'rsa', length: 4096 }
 */
let rsa = new RSA({
    algorithm: 'rsa',
    length: 2048 // 1024, 2048, 4096
});

// Generate Key pair (with optional passphrase)
let passphrase; // 'any secret passphrase';
rsa.generateKeyPair({ format: 'pem', passphrase })
.then(keyPairAndPassphrase=>{
    // Show key pair and passphrase in console
    console.log(keyPairAndPassphrase);

    // Verify key pair + passphrase
    return rsa.verifyKeyPair(keyPairAndPassphrase)
})
.then(keyPair=>{
    if (keyPair) {
        // Convert plain text utf8 string into Buffer
        let buffer = Buffer.from(plaintext, 'utf-8');

        // Encrypt data
        let encrypted = rsa.encrypt({ publicKey: keyPair.publicKey, buffer, encoding: 'buffer' }); // buffer
        /* As alternative, if plaintext is already in hex or base64:
        ecncrypted = rsa.encrypt({ publicKey: keyPair.publicKey, buffer: plaintext, encoding: 'hex' }); // hex, base64
        */

        // Decrypt data
        let decrypted = rsa.decrypt({ privateKey: keyPair.privateKey, buffer: encrypted, passphrase });
        return decrypted;
    }
    // Throw error for non-valid key pair
    throw Error('Key pair is not valid');
})
// Show decrypted data (Buffer) in utf-8 format string
.then(decrypted=>console.log(decrypted.toString('utf-8')))
// Show error
.catch(console.err);
```

---
_Source: https://npm.io/package/jesuscrypt · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._