cas-typescript-sdk 1.0.10 → 1.0.11

package/Cargo.toml

@@ -16,6 +16,7 @@ napi = "2"
 napi-derive = "2"
 rand = "0.8.5"
 rand_chacha = "0.3.1"
+rsa = "0.9.6"
 scrypt = "0.11.0"
 sha3 = "0.10.8"
 x25519-dalek = {version = "2.0.0", features = ["static_secrets"] }

package/README.md

@@ -1,5 +1,7 @@
 # eas-typescript-sdk
 
+Ever wanted all of your most useful cryptograpihc operations in one module and not have to surf documentation for various packages? 
+CAS is here to provide a unified development experience as an abstract layer to the RustCrypto and Dalek-Cryptography suite of algorithms.
 The official NPM page can be found [here](https://www.npmjs.com/package/cas-typescript-sdk).
 
 ## Consuming Library Documentation

package/index.d.ts

@@ -22,9 +22,20 @@ export function aes128Encrypt(aesKey: Array<number>, nonce: Array<number>, plain
 export function aes128Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>
 export function aes256Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>
 export function aes256Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>
+export function generateRsaKeys(keySize: number): RsaKeyPairResult
+export function encryptPlaintextRsa(publicKey: string, plaintext: Array<number>): Array<number>
+export function decryptCiphertextRsa(privateKey: string, ciphertext: Array<number>): Array<number>
+export function signRsa(privateKey: string, hash: Array<number>): Array<number>
+export function verifyRsa(publicKey: string, hash: Array<number>, signature: Array<number>): boolean
 export type x25519SecretPublicKeyResult = X25519SecretPublicKeyResult
 export class X25519SecretPublicKeyResult {
   publicKey: Array<number>
   secretKey: Array<number>
   constructor(publicKey: Array<number>, secretKey: Array<number>)
 }
+export type RSAKeyPairResult = RsaKeyPairResult
+export class RsaKeyPairResult {
+  privateKey: string
+  publicKey: string
+  constructor(privateKey: string, publicKey: string)
+}

package/lib/asymmetric/RSAWrapper.d.ts

@@ -0,0 +1,8 @@
+import { RsaKeyPairResult } from "../../index";
+export declare class RSAWrapper {
+    generateKeys(keySize: number): RsaKeyPairResult;
+    encrypt(publicKey: string, plaintext: Array<number>): Array<number>;
+    decrypt(privateKey: string, ciphertext: Array<number>): Array<number>;
+    sign(privateKey: string, hash: Array<number>): Array<number>;
+    verify(publicKey: string, hash: Array<number>, signature: Array<number>): boolean;
+}

package/lib/asymmetric/RSAWrapper.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RSAWrapper = void 0;
+const index_1 = require("../../index");
+class RSAWrapper {
+    generateKeys(keySize) {
+        if (keySize !== 1024 && keySize !== 2048 && keySize !== 4096) {
+            throw new Error("You must provide an appropriate key size to generate RSA keys");
+        }
+        return (0, index_1.generateRsaKeys)(keySize);
+    }
+    encrypt(publicKey, plaintext) {
+        if (!publicKey) {
+            throw new Error("You must provide a public key to encrypt with RSA");
+        }
+        if (!plaintext || plaintext.length === 0) {
+            throw new Error("You must provide an array of plaintext bytes to encrypt with RSA");
+        }
+        return (0, index_1.encryptPlaintextRsa)(publicKey, plaintext);
+    }
+    decrypt(privateKey, ciphertext) {
+        if (!privateKey) {
+            throw new Error("You must provide a private key to encrypt with RSA");
+        }
+        if (!ciphertext || ciphertext.length === 0) {
+            throw new Error("You must provide an array of ciphertext bytes to encrypt with RSA");
+        }
+        return (0, index_1.decryptCiphertextRsa)(privateKey, ciphertext);
+    }
+    sign(privateKey, hash) {
+        if (!privateKey) {
+            throw new Error("You must provide a private key to sign with RSA");
+        }
+        if (!hash || hash.length === 0) {
+            throw new Error("You must provide an allocated hash to sign with RSA");
+        }
+        return (0, index_1.signRsa)(privateKey, hash);
+    }
+    verify(publicKey, hash, signature) {
+        if (!publicKey) {
+            throw new Error("You must provide a public key to verify with RSA");
+        }
+        if (!hash || hash.length === 0) {
+            throw new Error("You must provide an allocated hash to verify with RSA");
+        }
+        if (!signature || signature.length === 0) {
+            throw new Error("You must provide and allocated signature to verify with RSA");
+        }
+        return (0, index_1.verifyRsa)(publicKey, hash, signature);
+    }
+}
+exports.RSAWrapper = RSAWrapper;

package/lib/asymmetric/index.d.ts

@@ -0,0 +1,3 @@
+import { RSAWrapper } from "./RSAWrapper";
+import { RsaKeyPairResult } from "../../index";
+export { RSAWrapper, RsaKeyPairResult };

package/lib/asymmetric/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RsaKeyPairResult = exports.RSAWrapper = void 0;
+const RSAWrapper_1 = require("./RSAWrapper");
+Object.defineProperty(exports, "RSAWrapper", { enumerable: true, get: function () { return RSAWrapper_1.RSAWrapper; } });
+const index_1 = require("../../index");
+Object.defineProperty(exports, "RsaKeyPairResult", { enumerable: true, get: function () { return index_1.RsaKeyPairResult; } });

package/lib/index.d.ts

@@ -2,4 +2,5 @@ import { Argon2Wrapper, BCryptWrapper, PasswordHasherFactory, PasswordHasherType
 import { HasherFactory, HasherType, SHAWrapper } from "./hashers/index";
 import { X25519Wrapper } from "./key_exchange/index";
 import { AESWrapper } from "./symmetric/index";
-export { Argon2Wrapper, BCryptWrapper, HasherFactory, HasherType, PasswordHasherFactory, PasswordHasherType, ScryptWrapper, SHAWrapper, X25519Wrapper, AESWrapper };
+import { RSAWrapper, RsaKeyPairResult } from "./asymmetric";
+export { Argon2Wrapper, BCryptWrapper, HasherFactory, HasherType, PasswordHasherFactory, PasswordHasherType, ScryptWrapper, SHAWrapper, X25519Wrapper, AESWrapper, RSAWrapper, RsaKeyPairResult };

package/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AESWrapper = exports.X25519Wrapper = exports.SHAWrapper = exports.ScryptWrapper = exports.PasswordHasherType = exports.PasswordHasherFactory = exports.HasherType = exports.HasherFactory = exports.BCryptWrapper = exports.Argon2Wrapper = void 0;
+exports.RsaKeyPairResult = exports.RSAWrapper = exports.AESWrapper = exports.X25519Wrapper = exports.SHAWrapper = exports.ScryptWrapper = exports.PasswordHasherType = exports.PasswordHasherFactory = exports.HasherType = exports.HasherFactory = exports.BCryptWrapper = exports.Argon2Wrapper = void 0;
 const index_1 = require("./password-hashers/index");
 Object.defineProperty(exports, "Argon2Wrapper", { enumerable: true, get: function () { return index_1.Argon2Wrapper; } });
 Object.defineProperty(exports, "BCryptWrapper", { enumerable: true, get: function () { return index_1.BCryptWrapper; } });
@@ -15,3 +15,6 @@ const index_3 = require("./key_exchange/index");
 Object.defineProperty(exports, "X25519Wrapper", { enumerable: true, get: function () { return index_3.X25519Wrapper; } });
 const index_4 = require("./symmetric/index");
 Object.defineProperty(exports, "AESWrapper", { enumerable: true, get: function () { return index_4.AESWrapper; } });
+const asymmetric_1 = require("./asymmetric");
+Object.defineProperty(exports, "RSAWrapper", { enumerable: true, get: function () { return asymmetric_1.RSAWrapper; } });
+Object.defineProperty(exports, "RsaKeyPairResult", { enumerable: true, get: function () { return asymmetric_1.RsaKeyPairResult; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cas-typescript-sdk",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/asymmetric/cas_asymmetric_encryption.rs

@@ -0,0 +1,15 @@
+use napi_derive::napi;
+
+#[napi(constructor)]
+pub struct RSAKeyPairResult {
+    pub private_key: String,
+    pub public_key: String
+}
+
+pub trait CASRSAEncryption {
+    fn generate_rsa_keys(key_size: u32) -> RSAKeyPairResult;
+    fn encrypt_plaintext(public_key: String, plaintext: Vec<u8>) -> Vec<u8>;
+    fn decrypt_ciphertext(private_key: String, ciphertext: Vec<u8>) -> Vec<u8>;
+    fn sign(private_key: String, hash: Vec<u8>) -> Vec<u8>;
+    fn verify(public_key: String, hash: Vec<u8>, signed_text: Vec<u8>) -> bool;
+}

package/src/asymmetric/cas_rsa.rs

@@ -0,0 +1,80 @@
+use napi_derive::napi;
+use rand::rngs::OsRng;
+use rsa::{
+    pkcs1::{DecodeRsaPublicKey, EncodeRsaPublicKey}, pkcs8::{DecodePrivateKey, EncodePrivateKey}, Pkcs1v15Encrypt, Pkcs1v15Sign, RsaPrivateKey, RsaPublicKey
+};
+
+use super::cas_asymmetric_encryption::{CASRSAEncryption, RSAKeyPairResult};
+pub struct CASRSA;
+
+impl CASRSAEncryption for CASRSA {
+    fn generate_rsa_keys(key_size: u32) -> RSAKeyPairResult {
+        let mut rng: OsRng = OsRng;
+        let private_key: RsaPrivateKey = RsaPrivateKey::new(&mut rng, key_size as usize).expect("failed to generate a key");
+        let public_key: RsaPublicKey = private_key.to_public_key();
+        let result = RSAKeyPairResult {
+            public_key: public_key.to_pkcs1_pem(rsa::pkcs1::LineEnding::LF).unwrap().to_string(),
+            private_key: private_key.to_pkcs8_pem(rsa::pkcs8::LineEnding::LF).unwrap().to_string()
+        };
+        result
+    }
+
+    fn encrypt_plaintext(public_key: String, plaintext: Vec<u8>) -> Vec<u8> {
+        let public_key = RsaPublicKey::from_pkcs1_pem(&public_key).unwrap();
+        let mut rng = rand::thread_rng();
+        let ciphertext = public_key.encrypt(&mut rng, Pkcs1v15Encrypt, &plaintext).unwrap();
+        ciphertext
+    }
+
+    fn decrypt_ciphertext(private_key: String, ciphertext: Vec<u8>) -> Vec<u8> {
+        let private_key = RsaPrivateKey::from_pkcs8_pem(&private_key).unwrap();
+        let plaintext = private_key.decrypt(Pkcs1v15Encrypt, &ciphertext).unwrap();
+        plaintext
+    }
+
+    fn sign(private_key: String, hash: Vec<u8>) -> Vec<u8> {
+        let private_key = RsaPrivateKey::from_pkcs8_pem(&private_key).unwrap();
+        let mut signed_data = private_key.sign(Pkcs1v15Sign::new_unprefixed(), &hash).unwrap();
+        signed_data
+    }
+
+    fn verify(public_key: String, hash: Vec<u8>, signature: Vec<u8>) -> bool {
+        let public_key = RsaPublicKey::from_pkcs1_pem(&public_key).unwrap();
+        let verified = public_key.verify(
+            Pkcs1v15Sign::new_unprefixed(),
+            &hash,
+            &signature,
+        );
+        if verified.is_err() == false {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+
+
+#[napi]
+pub fn generate_rsa_keys(key_size: u32) -> RSAKeyPairResult {
+    return CASRSA::generate_rsa_keys(key_size);
+}
+
+#[napi]
+pub fn encrypt_plaintext_rsa(public_key: String, plaintext: Vec<u8>) -> Vec<u8> {
+    return CASRSA::encrypt_plaintext(public_key, plaintext);
+}
+
+#[napi]
+pub fn decrypt_ciphertext_rsa(private_key: String, ciphertext: Vec<u8>) -> Vec<u8> {
+    return CASRSA::decrypt_ciphertext(private_key, ciphertext);
+}
+
+#[napi]
+pub fn sign_rsa(private_key: String, hash: Vec<u8>) -> Vec<u8> {
+    return CASRSA::sign(private_key, hash);
+}
+
+#[napi]
+pub fn verify_rsa(public_key: String, hash: Vec<u8>, signature: Vec<u8>) -> bool {
+    return CASRSA::verify(public_key, hash, signature);
+}

package/src/lib.rs

@@ -19,4 +19,9 @@ mod key_exchange {
 mod symmetric {
     pub mod aes;
     pub mod cas_symmetric_encryption;
+}
+
+mod asymmetric {
+    pub mod cas_asymmetric_encryption;
+    pub mod cas_rsa;
 }

package/src-ts/asymmetric/RSAWrapper.ts

@@ -0,0 +1,53 @@
+import { decryptCiphertextRsa, encryptPlaintextRsa, generateRsaKeys, RsaKeyPairResult, signRsa, verifyRsa } from "../../index";
+
+export class RSAWrapper {
+  public generateKeys(keySize: number): RsaKeyPairResult {
+    if (keySize !== 1024 && keySize !== 2048 && keySize !== 4096) {
+        throw new Error("You must provide an appropriate key size to generate RSA keys");
+    }
+    return generateRsaKeys(keySize);
+  }
+
+  public encrypt(publicKey: string, plaintext: Array<number>): Array<number> {
+    if (!publicKey) {
+      throw new Error("You must provide a public key to encrypt with RSA");
+    }
+    if (!plaintext || plaintext.length === 0) {
+      throw new Error("You must provide an array of plaintext bytes to encrypt with RSA");
+    }
+    return encryptPlaintextRsa(publicKey, plaintext);
+  }
+
+  public decrypt(privateKey: string, ciphertext: Array<number>): Array<number> {
+    if (!privateKey) {
+      throw new Error("You must provide a private key to encrypt with RSA");
+    }
+    if (!ciphertext || ciphertext.length === 0) {
+      throw new Error("You must provide an array of ciphertext bytes to encrypt with RSA");
+    }
+    return decryptCiphertextRsa(privateKey, ciphertext);
+  }
+
+  public sign(privateKey: string, hash: Array<number>): Array<number> {
+    if (!privateKey) {
+      throw new Error("You must provide a private key to sign with RSA");
+    }
+    if (!hash || hash.length === 0) {
+      throw new Error("You must provide an allocated hash to sign with RSA");
+    }
+    return signRsa(privateKey, hash);
+  }
+
+  public verify(publicKey: string, hash: Array<number>, signature: Array<number>): boolean {
+    if (!publicKey) {
+      throw new Error("You must provide a public key to verify with RSA");
+    }
+    if (!hash || hash.length === 0) {
+      throw new Error("You must provide an allocated hash to verify with RSA");
+    }
+    if (!signature || signature.length === 0) {
+      throw new Error("You must provide and allocated signature to verify with RSA");
+    }
+    return verifyRsa(publicKey, hash, signature);
+  }
+}

package/src-ts/asymmetric/index.ts

@@ -0,0 +1,4 @@
+import { RSAWrapper } from "./RSAWrapper";
+import { RsaKeyPairResult } from "../../index";
+
+export { RSAWrapper, RsaKeyPairResult };

package/src-ts/index.ts

@@ -8,6 +8,7 @@ import {
 import { HasherFactory, HasherType, SHAWrapper } from "./hashers/index";
 import { X25519Wrapper } from "./key_exchange/index";
 import { AESWrapper } from "./symmetric/index";
+import { RSAWrapper, RsaKeyPairResult } from "./asymmetric";
 
 export {
   Argon2Wrapper,
@@ -19,5 +20,7 @@ export {
   ScryptWrapper,
   SHAWrapper,
   X25519Wrapper,
-  AESWrapper
+  AESWrapper,
+  RSAWrapper,
+  RsaKeyPairResult
 };

package/test-ts/asymmetric.test.spec.ts

@@ -0,0 +1,28 @@
+import { assert } from "chai";
+import { RSAWrapper, RsaKeyPairResult } from "..";
+import { areEqual } from "./helpers/array";
+
+describe("Asymmetric Tests", () => {
+    it("RSA 4096 encrypt and decrypt equals", () => {
+      const rsaWrapper: RSAWrapper = new RSAWrapper();
+      const keys: RsaKeyPairResult = rsaWrapper.generateKeys(4096);
+      const tohashed: string = "This is my array to encrypt";
+      const encoder = new TextEncoder();
+      const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
+      const ciphertext = rsaWrapper.encrypt(keys.publicKey, tohashBytes);
+      const plaintext = rsaWrapper.decrypt(keys.privateKey, ciphertext);
+      let result = areEqual(tohashBytes, plaintext);
+      assert.isTrue(result);
+    });
+
+    it("RSA 2048 Sign and Verify", () => {
+      const rsaWrapper = new RSAWrapper();
+      const keys: RsaKeyPairResult = rsaWrapper.generateKeys(2048);
+      const tohashed: string = "This is my encrypt";
+      const encoder = new TextEncoder();
+      const toSignBytes: Array<number> = Array.from(encoder.encode(tohashed));
+      const signature: Array<number> = rsaWrapper.sign(keys.privateKey, toSignBytes);
+      const verified = rsaWrapper.verify(keys.publicKey, toSignBytes, signature);
+      assert.isTrue(verified);
+    });
+});