cas-typescript-sdk 1.0.15 → 1.0.16

package/.github/workflows/main-pr-linux.yml

@@ -0,0 +1,28 @@
+# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
+
+name: Linux Build / Test
+
+on:
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [20.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    - run: npm ci
+    - run: npm test

package/.github/workflows/main-pr-windows.yml

@@ -0,0 +1,28 @@
+# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
+
+name: Windows Build / Test 
+
+on:
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+
+    runs-on: windows-latest
+
+    strategy:
+      matrix:
+        node-version: [20.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    - run: npm ci
+    - run: npm test

package/.github/workflows/main-publish.yml

@@ -0,0 +1,32 @@
+# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [ "main" ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [20.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}
+        registry-url: 'https://registry.npmjs.org'
+        cache: 'npm'
+    - run: npm ci
+    - run: npm test
+    - run: npm publish
+      env:
+        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/Cargo.toml

@@ -19,7 +19,14 @@ 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"] }
+x25519-dalek = {version = "2.0.0", features = ["static_secrets"]}
+rand_07 = { package = "rand", version = "0.7.0" }
+
+[profile.dev.package.num-bigint-dig]
+opt-level = 3
+
+[dependencies.ed25519-dalek]
+version = "1"
 
 [build-dependencies]
 napi-build = "1"

package/README.md

@@ -4,6 +4,8 @@ Ever wanted all of your most useful cryptograpihc operations in one module and n
 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).
 
+## [Examples](./docs/EXAMPLES.md)
+
 ## Consuming Library Documentation
 **Note: All work is experimental and we understand some benchmarks might not be the most optimal.**
 

package/build.rs

@@ -1,5 +1,5 @@
-extern crate napi_build;
-
-fn main() {
-  napi_build::setup();
-}
+extern crate napi_build;
+
+fn main() {
+    napi_build::setup();
+}

package/docs/EXAMPLES.md

@@ -0,0 +1,39 @@
+### Symmetric
+- AES 256
+```typescript
+const aesWrapper: AESWrapper = new AESWrapper();
+const aesKey = aesWrapper.aes128Key();
+const aesNonce = aesWrapper.aesNonce();
+const toEncrypt: string = "This is my array to encrypt";
+const encoder = new TextEncoder();
+const tohashBytes: Array<number> = Array.from(encoder.encode(toEncrypt));
+const ciphertext = aesWrapper.aes128Encrypt(aesKey, aesNonce, tohashBytes);
+const plaintxt = aesWrapper.aes128Decrypt(aesKey, aesNonce, ciphertext);
+```
+
+
+### Passwords
+- BCrypt
+```typescript
+const hasher: BCryptWrapper = new BCryptWrapper();
+const password: string = "ThisOneBadPassword!@";
+const hashedPassword: string = hasher.hashPassword(password);
+```
+
+- SCrypt
+```typescript
+const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
+      PasswordHasherType.Scrypt,
+    );
+const password: string = "ScryptRocks";
+const hashed: string = hasher.hashPassword(password);
+```
+
+- Argon2
+```typescript
+    const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
+      PasswordHasherType.Argon2,
+    );
+    const password: string = "ScryptRocks";
+    const hashed: string = hasher.hashPassword(password);
+```

package/index.d.ts

@@ -29,6 +29,12 @@ export function encryptPlaintextRsa(publicKey: string, plaintext: 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 function sha512RsaDigitalSignature(rsaKeySize: number, dataToSign: Array<number>): CasrsaDigitalSignatureResult
+export function sha512RsaVerifyDigitalSignature(publicKey: string, dataToVerify: Array<number>, signature: Array<number>): boolean
+export function sha256RsaDigitalSignature(rsaKeySize: number, dataToSign: Array<number>): CasrsaDigitalSignatureResult
+export function sha256RsaVerifyDigitalSignature(publicKey: string, dataToVerify: Array<number>, signature: Array<number>): boolean
+export function sha512Ed25519DigitalSignature(dataToSign: Array<number>): Casshaed25519DalekDigitalSignatureResult
+export function sha512Ed25519DigitalSignatureVerify(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean
 export type x25519SecretPublicKeyResult = X25519SecretPublicKeyResult
 export class X25519SecretPublicKeyResult {
   publicKey: Array<number>
@@ -46,3 +52,16 @@ export class RsaKeyPairResult {
   publicKey: string
   constructor(privateKey: string, publicKey: string)
 }
+export type CASRSADigitalSignatureResult = CasrsaDigitalSignatureResult
+export class CasrsaDigitalSignatureResult {
+  publicKey: string
+  privateKey: string
+  signature: Array<number>
+  constructor(publicKey: string, privateKey: string, signature: Array<number>)
+}
+export type CASSHAED25519DalekDigitalSignatureResult = Casshaed25519DalekDigitalSignatureResult
+export class Casshaed25519DalekDigitalSignatureResult {
+  publicKey: Array<number>
+  signature: Array<number>
+  constructor(publicKey: Array<number>, signature: Array<number>)
+}

package/lib/digital-signature/digital-siganture-sha-512.d.ts

@@ -0,0 +1,6 @@
+import { CasrsaDigitalSignatureResult } from "../../index";
+import { IDigitalSignature } from "./digital-signature-base";
+export declare class DigitalSignatureSHA512Wrapper implements IDigitalSignature {
+    createRsa(rsa_key_size: number, data_to_sign: number[]): CasrsaDigitalSignatureResult;
+    verifyRSa(public_key: string, data_to_verify: number[], signature: number[]): boolean;
+}

package/lib/digital-signature/digital-siganture-sha-512.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DigitalSignatureSHA512Wrapper = void 0;
+const index_1 = require("../../index");
+class DigitalSignatureSHA512Wrapper {
+    createRsa(rsa_key_size, data_to_sign) {
+        if (rsa_key_size !== 1024 && rsa_key_size !== 2048 && rsa_key_size !== 4096) {
+            throw new Error("You need to provide an appropriate RSA key size.");
+        }
+        if (data_to_sign?.length === 0) {
+            throw new Error("Must provide allocated data to sign");
+        }
+        return (0, index_1.sha512RsaDigitalSignature)(rsa_key_size, data_to_sign);
+    }
+    verifyRSa(public_key, data_to_verify, signature) {
+        if (!public_key) {
+            throw new Error("Must provide a public key");
+        }
+        if (data_to_verify?.length === 0) {
+            throw new Error("Must provide an allocated data to verify");
+        }
+        if (signature?.length === 0) {
+            throw new Error("Must provide an allocated signature");
+        }
+        return (0, index_1.sha512RsaVerifyDigitalSignature)(public_key, data_to_verify, signature);
+    }
+}
+exports.DigitalSignatureSHA512Wrapper = DigitalSignatureSHA512Wrapper;

package/lib/digital-signature/digital-signature-base.d.ts

@@ -0,0 +1,5 @@
+import { CASRSADigitalSignatureResult } from "../../index";
+export interface IDigitalSignature {
+    createRsa(rsa_key_size: number, data_to_sign: Array<number>): CASRSADigitalSignatureResult;
+    verifyRSa(public_key: string, data_to_verify: Array<number>, signature: Array<number>): boolean;
+}

package/lib/digital-signature/digital-signature-base.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/digital-signature/digital-signature-factory.d.ts

@@ -0,0 +1,8 @@
+import { DigitalSignatureSHA512Wrapper } from "./digital-siganture-sha-512";
+export declare enum DigitalSignatureType {
+    SHA512 = 1,
+    SHA256 = 2
+}
+export declare class DigitalSignatureFactory {
+    static get(type: DigitalSignatureType): DigitalSignatureSHA512Wrapper;
+}

package/lib/digital-signature/digital-signature-factory.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DigitalSignatureFactory = exports.DigitalSignatureType = void 0;
+const digital_siganture_sha_512_1 = require("./digital-siganture-sha-512");
+const digital_signaturte_sha_256_1 = require("./digital-signaturte-sha-256");
+var DigitalSignatureType;
+(function (DigitalSignatureType) {
+    DigitalSignatureType[DigitalSignatureType["SHA512"] = 1] = "SHA512";
+    DigitalSignatureType[DigitalSignatureType["SHA256"] = 2] = "SHA256";
+})(DigitalSignatureType || (exports.DigitalSignatureType = DigitalSignatureType = {}));
+class DigitalSignatureFactory {
+    static get(type) {
+        let ds = new digital_siganture_sha_512_1.DigitalSignatureSHA512Wrapper();
+        switch (type) {
+            case DigitalSignatureType.SHA256:
+                ds = new digital_signaturte_sha_256_1.DigitalSignatureSHA256Wrapper();
+                break;
+        }
+        return ds;
+    }
+}
+exports.DigitalSignatureFactory = DigitalSignatureFactory;

package/lib/digital-signature/digital-signaturte-sha-256.d.ts

@@ -0,0 +1,6 @@
+import { CasrsaDigitalSignatureResult } from "../../index";
+import { IDigitalSignature } from "./digital-signature-base";
+export declare class DigitalSignatureSHA256Wrapper implements IDigitalSignature {
+    createRsa(rsa_key_size: number, data_to_sign: number[]): CasrsaDigitalSignatureResult;
+    verifyRSa(public_key: string, data_to_verify: number[], signature: number[]): boolean;
+}

package/lib/digital-signature/digital-signaturte-sha-256.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DigitalSignatureSHA256Wrapper = void 0;
+const index_1 = require("../../index");
+class DigitalSignatureSHA256Wrapper {
+    createRsa(rsa_key_size, data_to_sign) {
+        if (rsa_key_size !== 1024 && rsa_key_size !== 2048 && rsa_key_size !== 4096) {
+            throw new Error("You need to provide an appropriate RSA key size.");
+        }
+        if (data_to_sign?.length === 0) {
+            throw new Error("Must provide allocated data to sign");
+        }
+        return (0, index_1.sha256RsaDigitalSignature)(rsa_key_size, data_to_sign);
+    }
+    verifyRSa(public_key, data_to_verify, signature) {
+        if (!public_key) {
+            throw new Error("Must provide a public key");
+        }
+        if (data_to_verify?.length === 0) {
+            throw new Error("Must provide an allocated data to verify");
+        }
+        if (signature?.length === 0) {
+            throw new Error("Must provide an allocated signature");
+        }
+        return (0, index_1.sha256RsaVerifyDigitalSignature)(public_key, data_to_verify, signature);
+    }
+}
+exports.DigitalSignatureSHA256Wrapper = DigitalSignatureSHA256Wrapper;

package/lib/digital-signature/index.d.ts

@@ -0,0 +1,4 @@
+export declare enum DigitalSignatureType {
+    SHA512 = 1,
+    SHA256 = 2
+}

package/lib/digital-signature/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DigitalSignatureType = void 0;
+var DigitalSignatureType;
+(function (DigitalSignatureType) {
+    DigitalSignatureType[DigitalSignatureType["SHA512"] = 1] = "SHA512";
+    DigitalSignatureType[DigitalSignatureType["SHA256"] = 2] = "SHA256";
+})(DigitalSignatureType || (exports.DigitalSignatureType = DigitalSignatureType = {}));

package/package.json

@@ -1,41 +1,41 @@
-{
-  "name": "cas-typescript-sdk",
-  "version": "1.0.15",
-  "description": "",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "scripts": {
-    "test": "cargo test && npm run build && mocha -r ts-node/register ./test-ts/**/*.ts --timeout 20000 --recursive",
-    "node:test": "mocha -r ts-node/register ./test-ts/**/*.ts --timeout 20000 --recursive",
-    "rust:test": "cargo test",
-    "build": "npm run build:rust && npm run build:node",
-    "build:rust": "napi build --release",
-    "build:node": "bash build-node.sh",
-    "prepare": "npm run build"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Cryptographic-API-Services/cas-typescript-sdk"
-  },
-  "keywords": [],
-  "author": "Mike Mulchrone <mikemulchrone987@gmail.com>",
-  "license": "Apache 2.0",
-  "bugs": {
-    "url": "https://github.com/Cryptographic-API-Services/cas-typescript-sdk/issues"
-  },
-  "homepage": "https://github.com/Cryptographic-API-Services/cas-typescript-sdk#readme",
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "devDependencies": {
-    "@napi-rs/cli": "^2.17.0",
-    "@types/chai": "^4.3.11",
-    "@types/mocha": "^10.0.6",
-    "@types/node-fetch": "^2.6.3",
-    "chai": "^4.4.1",
-    "mocha": "^10.2.0",
-    "ts-node": "^10.9.1",
-    "typescript": "^5.0.3"
-  }
-}
+
+{
+  "name": "cas-typescript-sdk",
+  "version": "1.0.16",
+  "description": "",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "test": "cargo test && npm run build && mocha -r ts-node/register ./test-ts/**/*.ts --timeout 20000 --recursive",
+    "node:test": "mocha -r ts-node/register ./test-ts/**/*.ts --timeout 20000 --recursive",
+    "rust:test": "cargo test",
+    "build": "npm run build:rust && rm -rf lib && tsc",
+    "build:rust": "napi build --release",
+    "prepare": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Cryptographic-API-Services/cas-typescript-sdk"
+  },
+  "keywords": [],
+  "author": "Mike Mulchrone <mikemulchrone987@gmail.com>",
+  "license": "Apache 2.0",
+  "bugs": {
+    "url": "https://github.com/Cryptographic-API-Services/cas-typescript-sdk/issues"
+  },
+  "homepage": "https://github.com/Cryptographic-API-Services/cas-typescript-sdk#readme",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^2.17.0",
+    "@types/chai": "^4.3.11",
+    "@types/mocha": "^10.0.6",
+    "@types/node-fetch": "^2.6.3",
+    "chai": "^4.4.1",
+    "mocha": "^10.2.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.3"
+  }
+}

package/src/asymmetric/cas_asymmetric_encryption.rs

@@ -1,15 +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;
-}
+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

@@ -1,80 +1,88 @@
-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);
-}
+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/digital_signature/cas_digital_signature_rsa.rs

@@ -0,0 +1,27 @@
+use napi_derive::napi;
+
+#[napi(constructor)]
+pub struct CASRSADigitalSignatureResult {
+    pub public_key: String,
+    pub private_key: String,
+    pub signature: Vec<u8>,
+}
+
+#[napi(constructor)]
+pub struct CASSHAED25519DalekDigitalSignatureResult {
+    pub public_key: Vec<u8>,
+    pub signature: Vec<u8>
+}
+
+pub trait CASRSADigitalSignature {
+    fn digital_signature_rsa(
+        rsa_key_size: u32,
+        data_to_sign: Vec<u8>,
+    ) -> CASRSADigitalSignatureResult;
+    fn verify_rsa(public_key: String, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool;
+}
+
+pub trait CASED25519DigitalSignature {
+    fn digital_signature_ed25519(data_to_sign: Vec<u8>) -> CASSHAED25519DalekDigitalSignatureResult;
+    fn digital_signature_ed25519_verify(public_key: Vec<u8>, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool;
+}