cas-typescript-sdk 1.0.23 → 1.0.25

package/Cargo.toml

@@ -8,27 +8,10 @@ path = "src/lib.rs"
 crate-type = ["cdylib"]
 
 [dependencies]
-aes-gcm = "0.10.3"
-argon2 = "0.5.2"
-bcrypt = "0.15.0"
-blake2 = "0.10.6"
 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"]}
-rand_07 = { package = "rand", version = "0.7.0" }
-ascon-aead = "0.4.2"
-rayon = "1.10.0"
-
-[profile.dev.package.num-bigint-dig]
-opt-level = 3
-
-[dependencies.ed25519-dalek]
-version = "1"
+csbindgen = "1.9.1"
+cas-lib = "0.1.6"
 
 [build-dependencies]
-napi-build = "1"
+napi-build = "1"

package/README.md

@@ -12,7 +12,7 @@ The official NPM page can be found [here](https://www.npmjs.com/package/cas-type
 
 
 ## Consuming Library Documentation
-This Node.js NPM module is dependent on our Rust layer [here](./src) that contains methods to run industry-standard cryptographic operations sequentially, on threads, and the thread pool.
+This Node.js NPM module is dependent on our Rust layer [cas-lib](https://github.com/Cryptographic-API-Services/cas-lib). that contains methods to run industry-standard cryptographic operations sequentially, on threads, and the thread pool.
 
 We utilize some smart people's existing work and we believe their documentation should be reviewed when possible.
 - [Spin Research](https://github.com/SpinResearch)

package/index.d.ts

@@ -19,7 +19,7 @@ export function sha512(dataToHash: Array<number>): Array<number>
 export function sha512Verify(dataToHash: Array<number>, dataToVerify: Array<number>): boolean
 export function sha256(dataToHash: Array<number>): Array<number>
 export function sha256Verify(dataToHash: Array<number>, dataToVerify: Array<number>): boolean
-export function x25519GenerateSecretAndPublicKey(): X25519SecretPublicKeyResult
+export function x25519GenerateSecretAndPublicKey(): CASx25519SecretPublicKeyResult
 export function x25519DiffieHellman(mySecretKey: Array<number>, usersPublicKey: Array<number>): Array<number>
 export function aesNonce(): Array<number>
 export function aes128Key(): Array<number>
@@ -28,52 +28,53 @@ 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 aes256KeyFromX25519SharedSecret(sharedSecret: Array<number>): AesKeyFromX25519SharedSecret
-export function aes128KeyFromX25519SharedSecret(sharedSecret: Array<number>): AesKeyFromX25519SharedSecret
-export function generateRsaKeys(keySize: number): RsaKeyPairResult
+export function aes256KeyFromX25519SharedSecret(sharedSecret: Array<number>): CASAesKeyFromX25519SharedSecret
+export function aes128KeyFromX25519SharedSecret(sharedSecret: Array<number>): CASAesKeyFromX25519SharedSecret
+export function generateRsaKeys(keySize: number): CasrsaKeyPairResult
 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 function sha512RsaDigitalSignature(rsaKeySize: number, dataToSign: Array<number>): RsaDigitalSignatureResult
+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>): RsaDigitalSignatureResult
+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>): Shaed25519DalekDigitalSignatureResult
+export function sha512Ed25519DigitalSignature(dataToSign: Array<number>): CASSHAED25519DalekDigitalSignatureResult
 export function sha512Ed25519DigitalSignatureVerify(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean
-export function sha256Ed25519DigitalSignature(dataToSign: Array<number>): Shaed25519DalekDigitalSignatureResult
+export function sha256Ed25519DigitalSignature(dataToSign: Array<number>): CASSHAED25519DalekDigitalSignatureResult
 export function sha256Ed25519DigitalSignatureVerify(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean
 export function ascon128KeyGenerate(): Array<number>
 export function ascon128NonceGenerate(): Array<number>
 export function ascon128Encrypt(key: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>
 export function ascon128Decrypt(key: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>
-export type x25519SecretPublicKeyResult = X25519SecretPublicKeyResult
-export class X25519SecretPublicKeyResult {
+export type CASx25519SecretPublicKeyResult = CaSx25519SecretPublicKeyResult
+export class CaSx25519SecretPublicKeyResult {
   publicKey: Array<number>
   secretKey: Array<number>
   constructor(publicKey: Array<number>, secretKey: Array<number>)
 }
-export class AesKeyFromX25519SharedSecret {
+export type CASAesKeyFromX25519SharedSecret = CasAesKeyFromX25519SharedSecret
+export class CasAesKeyFromX25519SharedSecret {
   aesKey: Array<number>
   aesNonce: Array<number>
   constructor(aesKey: Array<number>, aesNonce: Array<number>)
 }
-export type RSAKeyPairResult = RsaKeyPairResult
-export class RsaKeyPairResult {
+export type CASRSAKeyPairResult = CasrsaKeyPairResult
+export class CasrsaKeyPairResult {
   privateKey: string
   publicKey: string
   constructor(privateKey: string, publicKey: string)
 }
-export type RSADigitalSignatureResult = RsaDigitalSignatureResult
-export class RsaDigitalSignatureResult {
+export type CASSHAED25519DalekDigitalSignatureResult = Casshaed25519DalekDigitalSignatureResult
+export class Casshaed25519DalekDigitalSignatureResult {
+  publicKey: Array<number>
+  signature: Array<number>
+  constructor(publicKey: Array<number>, signature: Array<number>)
+}
+export type CASRSADigitalSignatureResult = CasrsaDigitalSignatureResult
+export class CasrsaDigitalSignatureResult {
   publicKey: string
   privateKey: string
   signature: Array<number>
   constructor(publicKey: string, privateKey: string, signature: Array<number>)
 }
-export type SHAED25519DalekDigitalSignatureResult = Shaed25519DalekDigitalSignatureResult
-export class Shaed25519DalekDigitalSignatureResult {
-  publicKey: Array<number>
-  signature: Array<number>
-  constructor(publicKey: Array<number>, signature: Array<number>)
-}

package/lib/asymmetric/RSAWrapper.d.ts

@@ -1,11 +1,11 @@
-import { RsaKeyPairResult } from "../../index";
+import { CASRSAKeyPairResult } from "../../index";
 export declare class RSAWrapper {
     /**
      * Generates an RSA key pair based of parameter sent in 1024, 2048, and 4096 are supported.
      * @param keySize
-     * @returns RsaKeyPairResult
+     * @returns CASRSAKeyPairResult
      */
-    generateKeys(keySize: number): RsaKeyPairResult;
+    generateKeys(keySize: number): CASRSAKeyPairResult;
     /**
      * Encrypts a plaintext byte array with a RSA public key
      * @param publicKey

package/lib/asymmetric/RSAWrapper.js

@@ -6,7 +6,7 @@ class RSAWrapper {
     /**
      * Generates an RSA key pair based of parameter sent in 1024, 2048, and 4096 are supported.
      * @param keySize
-     * @returns RsaKeyPairResult
+     * @returns CASRSAKeyPairResult
      */
     generateKeys(keySize) {
         if (keySize !== 1024 && keySize !== 2048 && keySize !== 4096) {

package/lib/asymmetric/index.d.ts

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

package/lib/asymmetric/index.js

@@ -1,7 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RsaKeyPairResult = exports.RSAWrapper = void 0;
+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/digital-signature/digital-siganture-sha-512.d.ts

@@ -1,12 +1,12 @@
-import { RsaDigitalSignatureResult, SHAED25519DalekDigitalSignatureResult } from "../../index";
+import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult } from "../../index";
 import { IDigitalSignature } from "./digital-signature-base";
 export declare class DigitalSignatureSHA512Wrapper implements IDigitalSignature {
     /**
      * Creates an ED25519 siganture from an array of bytes with SHA3-512.
      * @param dataToSign
-     * @returns SHAED25519DalekDigitalSignatureResult
+     * @returns CASSHAED25519DalekDigitalSignatureResult
      */
-    createED25519(dataToSign: number[]): SHAED25519DalekDigitalSignatureResult;
+    createED25519(dataToSign: number[]): CASSHAED25519DalekDigitalSignatureResult;
     /**
      * Verifies an ED25519 signature with the public key generated from running createED25519() with SHA3-512
      * @param publicKey
@@ -19,9 +19,9 @@ export declare class DigitalSignatureSHA512Wrapper implements IDigitalSignature
      * Generates and RSA digital signature with SHA3-512
      * @param rsa_key_size
      * @param data_to_sign
-     * @returns RsaDigitalSignatureResult
+     * @returns CASRSADigitalSignatureResult
      */
-    createRsa(rsa_key_size: number, data_to_sign: number[]): RsaDigitalSignatureResult;
+    createRsa(rsa_key_size: number, data_to_sign: number[]): CASRSADigitalSignatureResult;
     /**
      * Verifies a digital signature created with the RSA public key.
      * @param public_key

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

@@ -6,7 +6,7 @@ class DigitalSignatureSHA512Wrapper {
     /**
      * Creates an ED25519 siganture from an array of bytes with SHA3-512.
      * @param dataToSign
-     * @returns SHAED25519DalekDigitalSignatureResult
+     * @returns CASSHAED25519DalekDigitalSignatureResult
      */
     createED25519(dataToSign) {
         if (dataToSign?.length === 0) {
@@ -37,7 +37,7 @@ class DigitalSignatureSHA512Wrapper {
      * Generates and RSA digital signature with SHA3-512
      * @param rsa_key_size
      * @param data_to_sign
-     * @returns RsaDigitalSignatureResult
+     * @returns CASRSADigitalSignatureResult
      */
     createRsa(rsa_key_size, data_to_sign) {
         if (rsa_key_size !== 1024 && rsa_key_size !== 2048 && rsa_key_size !== 4096) {

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

@@ -1,7 +1,7 @@
-import { RSADigitalSignatureResult, SHAED25519DalekDigitalSignatureResult } from "../../index";
+import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult } from "../../index";
 export interface IDigitalSignature {
-    createRsa(rsa_key_size: number, data_to_sign: Array<number>): RSADigitalSignatureResult;
+    createRsa(rsa_key_size: number, data_to_sign: Array<number>): CASRSADigitalSignatureResult;
     verifyRSa(public_key: string, data_to_verify: Array<number>, signature: Array<number>): boolean;
-    createED25519(dataToSign: Array<number>): SHAED25519DalekDigitalSignatureResult;
+    createED25519(dataToSign: Array<number>): CASSHAED25519DalekDigitalSignatureResult;
     verifyED25519(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean;
 }

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

@@ -1,4 +1,4 @@
-import { RsaDigitalSignatureResult, Shaed25519DalekDigitalSignatureResult } from "../../index";
+import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult } from "../../index";
 import { IDigitalSignature } from "./digital-signature-base";
 export declare class DigitalSignatureSHA256Wrapper implements IDigitalSignature {
     /**
@@ -6,7 +6,7 @@ export declare class DigitalSignatureSHA256Wrapper implements IDigitalSignature
      * @param dataToSign
      * @returns SHAED25519DalekDigitalSignatureResult
      */
-    createED25519(dataToSign: number[]): Shaed25519DalekDigitalSignatureResult;
+    createED25519(dataToSign: number[]): CASSHAED25519DalekDigitalSignatureResult;
     /**
      * Verifies an ED25519 signature with the public key generated from running createED25519() with SHA3-512
      * @param publicKey
@@ -21,7 +21,7 @@ export declare class DigitalSignatureSHA256Wrapper implements IDigitalSignature
      * @param data_to_sign
      * @returns RsaDigitalSignatureResult
      */
-    createRsa(rsa_key_size: number, data_to_sign: number[]): RsaDigitalSignatureResult;
+    createRsa(rsa_key_size: number, data_to_sign: number[]): CASRSADigitalSignatureResult;
     /**
      * Verifies a digital signature created with the RSA public key.
      * @param public_key

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

@@ -2,4 +2,5 @@ import { DigitalSignatureType } from "./digital-signature-factory";
 import { DigitalSignatureFactory } from "./digital-signature-factory";
 import { DigitalSignatureSHA256Wrapper } from "./digital-signaturte-sha-256";
 import { DigitalSignatureSHA512Wrapper } from "./digital-siganture-sha-512";
-export { DigitalSignatureFactory, DigitalSignatureSHA256Wrapper, DigitalSignatureSHA512Wrapper, DigitalSignatureType };
+import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult } from "../../index";
+export { DigitalSignatureFactory, DigitalSignatureSHA256Wrapper, DigitalSignatureSHA512Wrapper, DigitalSignatureType, CASSHAED25519DalekDigitalSignatureResult, CASRSADigitalSignatureResult };

package/lib/hybrid/types/aes-rsa-hybrid-initializer.d.ts

@@ -1,9 +1,9 @@
-import { RsaKeyPairResult } from "../../..";
+import { CASRSAKeyPairResult } from "../../..";
 export declare class AESRSAHybridInitializer {
     aesType: number;
     aesKey: Array<number>;
     aesNonce: Array<number>;
-    rsaKeyPair: RsaKeyPairResult;
+    rsaKeyPair: CASRSAKeyPairResult;
     /**
      * Constructs an initalizer to use with Hybrid Encryption wrapper. Generates your RSA key pair, AES nonce, and AES key based on the parameters passed in.
      * @param aesType

package/lib/index.d.ts

@@ -1,9 +1,8 @@
-import { Argon2Wrapper, BCryptWrapper, PasswordHasherFactory, PasswordHasherType, ScryptWrapper } from "./password-hashers/index";
-import { HasherFactory, HasherType, SHAWrapper } from "./hashers/index";
-import { X25519Wrapper } from "./key_exchange/index";
-import { AESWrapper } from "./symmetric/index";
-import { RsaKeyPairResult, RSAWrapper } from "./asymmetric/index";
-import { AesRsaHybridEncryptResult, AESRSAHybridInitializer, HybridEncryptionWrapper } from "./hybrid/index";
-import { DigitalSignatureFactory, DigitalSignatureSHA256Wrapper, DigitalSignatureSHA512Wrapper, DigitalSignatureType } from "./digital-signature";
-import { AsconWrapper } from "./sponges/index";
-export { AesRsaHybridEncryptResult, AESRSAHybridInitializer, AESWrapper, Argon2Wrapper, AsconWrapper, BCryptWrapper, DigitalSignatureFactory, DigitalSignatureSHA256Wrapper, DigitalSignatureSHA512Wrapper, DigitalSignatureType, HasherFactory, HasherType, HybridEncryptionWrapper, PasswordHasherFactory, PasswordHasherType, RsaKeyPairResult, RSAWrapper, ScryptWrapper, SHAWrapper, X25519Wrapper, };
+export * from "./password-hashers/index";
+export * from "./hashers/index";
+export * from "./key_exchange/index";
+export * from "./symmetric/index";
+export * from "./asymmetric/index";
+export * from "./hybrid/index";
+export * from "./digital-signature";
+export * from "./sponges/index";

package/lib/index.js

@@ -1,31 +1,24 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.X25519Wrapper = exports.SHAWrapper = exports.ScryptWrapper = exports.RSAWrapper = exports.RsaKeyPairResult = exports.PasswordHasherType = exports.PasswordHasherFactory = exports.HybridEncryptionWrapper = exports.HasherType = exports.HasherFactory = exports.DigitalSignatureType = exports.DigitalSignatureSHA512Wrapper = exports.DigitalSignatureSHA256Wrapper = exports.DigitalSignatureFactory = exports.BCryptWrapper = exports.AsconWrapper = exports.Argon2Wrapper = exports.AESWrapper = exports.AESRSAHybridInitializer = exports.AesRsaHybridEncryptResult = 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; } });
-Object.defineProperty(exports, "PasswordHasherFactory", { enumerable: true, get: function () { return index_1.PasswordHasherFactory; } });
-Object.defineProperty(exports, "PasswordHasherType", { enumerable: true, get: function () { return index_1.PasswordHasherType; } });
-Object.defineProperty(exports, "ScryptWrapper", { enumerable: true, get: function () { return index_1.ScryptWrapper; } });
-const index_2 = require("./hashers/index");
-Object.defineProperty(exports, "HasherFactory", { enumerable: true, get: function () { return index_2.HasherFactory; } });
-Object.defineProperty(exports, "HasherType", { enumerable: true, get: function () { return index_2.HasherType; } });
-Object.defineProperty(exports, "SHAWrapper", { enumerable: true, get: function () { return index_2.SHAWrapper; } });
-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 index_5 = require("./asymmetric/index");
-Object.defineProperty(exports, "RsaKeyPairResult", { enumerable: true, get: function () { return index_5.RsaKeyPairResult; } });
-Object.defineProperty(exports, "RSAWrapper", { enumerable: true, get: function () { return index_5.RSAWrapper; } });
-const index_6 = require("./hybrid/index");
-Object.defineProperty(exports, "AesRsaHybridEncryptResult", { enumerable: true, get: function () { return index_6.AesRsaHybridEncryptResult; } });
-Object.defineProperty(exports, "AESRSAHybridInitializer", { enumerable: true, get: function () { return index_6.AESRSAHybridInitializer; } });
-Object.defineProperty(exports, "HybridEncryptionWrapper", { enumerable: true, get: function () { return index_6.HybridEncryptionWrapper; } });
-const digital_signature_1 = require("./digital-signature");
-Object.defineProperty(exports, "DigitalSignatureFactory", { enumerable: true, get: function () { return digital_signature_1.DigitalSignatureFactory; } });
-Object.defineProperty(exports, "DigitalSignatureSHA256Wrapper", { enumerable: true, get: function () { return digital_signature_1.DigitalSignatureSHA256Wrapper; } });
-Object.defineProperty(exports, "DigitalSignatureSHA512Wrapper", { enumerable: true, get: function () { return digital_signature_1.DigitalSignatureSHA512Wrapper; } });
-Object.defineProperty(exports, "DigitalSignatureType", { enumerable: true, get: function () { return digital_signature_1.DigitalSignatureType; } });
-const index_7 = require("./sponges/index");
-Object.defineProperty(exports, "AsconWrapper", { enumerable: true, get: function () { return index_7.AsconWrapper; } });
+__exportStar(require("./password-hashers/index"), exports);
+__exportStar(require("./hashers/index"), exports);
+__exportStar(require("./key_exchange/index"), exports);
+__exportStar(require("./symmetric/index"), exports);
+__exportStar(require("./asymmetric/index"), exports);
+__exportStar(require("./hybrid/index"), exports);
+__exportStar(require("./digital-signature"), exports);
+__exportStar(require("./sponges/index"), exports);

package/lib/key_exchange/index.d.ts

@@ -1,2 +1,3 @@
+import { CASx25519SecretPublicKeyResult } from "../../index";
 import { X25519Wrapper } from "./x25519";
-export { X25519Wrapper };
+export { X25519Wrapper, CASx25519SecretPublicKeyResult };

package/lib/key_exchange/x25519.d.ts

@@ -1,11 +1,11 @@
-import { X25519SecretPublicKeyResult } from "../../index";
+import { CASx25519SecretPublicKeyResult } from "../../index";
 export declare class X25519Wrapper {
     /**
      * Generates and secret and public key to be used to create a shared secret with Diffie Hellman.
      * User should share their public key with the other user and take the other user's public key and they can generate a Shared Secret.
      * @returns X25519SecretPublicKeyResult
      */
-    generateSecretAndPublicKey(): X25519SecretPublicKeyResult;
+    generateSecretAndPublicKey(): CASx25519SecretPublicKeyResult;
     /**
      * User takes their secret key and the other user's public key to generate a shared secret.
      * Can be used to derive an AES key over insecure channel.

package/lib/symmetric/aes-wrapper.d.ts

@@ -1,4 +1,4 @@
-import { AesKeyFromX25519SharedSecret } from "../../index";
+import { CASAesKeyFromX25519SharedSecret } from "../../index";
 export declare class AESWrapper {
     /**
      * @description Generates a 128 bit AES key
@@ -52,11 +52,11 @@ export declare class AESWrapper {
      * @param shared_secret
      * @returns
      */
-    aes256KeyNonceX25519DiffieHellman(shared_secret: Array<number>): AesKeyFromX25519SharedSecret;
+    aes256KeyNonceX25519DiffieHellman(shared_secret: Array<number>): CASAesKeyFromX25519SharedSecret;
     /**
      * Derives an AES-128 key from a X25519 Diffie Hellman shared secret.
      * @param shared_secret
      * @returns
      */
-    aes128KeyNonceX25519DiffieHellman(shared_secret: Array<number>): AesKeyFromX25519SharedSecret;
+    aes128KeyNonceX25519DiffieHellman(shared_secret: Array<number>): CASAesKeyFromX25519SharedSecret;
 }

package/lib/symmetric/index.d.ts

@@ -1,2 +1,3 @@
+import { CASAesKeyFromX25519SharedSecret } from "../../index";
 import { AESWrapper } from "./aes-wrapper";
-export { AESWrapper };
+export { AESWrapper, CASAesKeyFromX25519SharedSecret };

package/package.json

@@ -1,7 +1,7 @@
 
 {
   "name": "cas-typescript-sdk",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/asymmetric/cas_rsa.rs

@@ -1,70 +1,24 @@
+use cas_lib::asymmetric::{cas_asymmetric_encryption::CASRSAEncryption, cas_rsa::CASRSA, types::RSAKeyPairResult};
 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
-    }
+#[napi(constructor)]
+pub struct CASRSAKeyPairResult {
+    pub private_key: String,
+    pub public_key: String,
+}
 
-    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;
+impl From<RSAKeyPairResult> for CASRSAKeyPairResult {
+    fn from(result: RSAKeyPairResult) -> Self {
+        CASRSAKeyPairResult {
+            private_key: result.private_key,
+            public_key: result.public_key,
         }
     }
 }
 
 #[napi]
-pub fn generate_rsa_keys(key_size: u32) -> RSAKeyPairResult {
-    return CASRSA::generate_rsa_keys(key_size);
+pub fn generate_rsa_keys(key_size: u32) -> CASRSAKeyPairResult {
+    return CASRSA::generate_rsa_keys(key_size as usize).into();
 }
 
 #[napi]

package/src/digital_signature/sha_256_ed25519.rs

@@ -1,47 +1,11 @@
-use ed25519_dalek::{Keypair, Signature, Signer, Verifier};
+use cas_lib::digital_signature::{cas_digital_signature_rsa::ED25519DigitalSignature, sha_256_ed25519::SHA256ED25519DigitalSignature};
 use napi_derive::napi;
-use sha3::{Digest, Sha3_256};
 
-use super::cas_digital_signature_rsa::{
-    ED25519DigitalSignature, SHAED25519DalekDigitalSignatureResult,
-};
-
-pub struct SHA256ED25519DigitalSignature;
-
-impl ED25519DigitalSignature for SHA256ED25519DigitalSignature {
-    fn digital_signature_ed25519(data_to_sign: Vec<u8>) -> SHAED25519DalekDigitalSignatureResult {
-        let mut hasher = Sha3_256::new();
-        hasher.update(data_to_sign);
-        let sha_hasher_result = hasher.finalize();
-        let mut csprng = rand_07::rngs::OsRng {};
-        let keypair = ed25519_dalek::Keypair::generate(&mut csprng);
-
-        let signature = keypair.sign(&sha_hasher_result);
-        let signature_bytes = signature.to_bytes();
-        let public_keypair_bytes = keypair.public.to_bytes();
-        let result = SHAED25519DalekDigitalSignatureResult {
-            public_key: public_keypair_bytes.to_vec(),
-            signature: signature_bytes.to_vec(),
-        };
-        result
-    }
-
-    fn digital_signature_ed25519_verify(public_key: Vec<u8>, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool {
-        let mut hasher = Sha3_256::new();
-        hasher.update(data_to_verify);
-        let sha_hasher_result = hasher.finalize();
-
-        let public_key_parsed = ed25519_dalek::PublicKey::from_bytes(&public_key).unwrap();
-        let signature_parsed = Signature::from_bytes(&signature).unwrap();
-        return public_key_parsed
-            .verify(&sha_hasher_result, &signature_parsed)
-            .is_ok();
-    }
-}
+use super::types::CASSHAED25519DalekDigitalSignatureResult;
 
 #[napi]
-pub fn sha_256_ed25519_digital_signature(data_to_sign: Vec<u8>) -> SHAED25519DalekDigitalSignatureResult {
-    return SHA256ED25519DigitalSignature::digital_signature_ed25519(data_to_sign);
+pub fn sha_256_ed25519_digital_signature(data_to_sign: Vec<u8>) -> CASSHAED25519DalekDigitalSignatureResult {
+    return <SHA256ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(data_to_sign).into();
 }
 
 #[napi]
@@ -53,7 +17,7 @@ pub fn sha_256_ed25519_digital_signature_verify(public_key: Vec<u8>, data_to_ver
 fn sha_256_ed25519_test() {
     let key_size: u32 = 1024;
     let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: SHAED25519DalekDigitalSignatureResult = SHA256ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone());
+    let signature_result: CASSHAED25519DalekDigitalSignatureResult = SHA256ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone()).into();
     let is_verified: bool = SHA256ED25519DigitalSignature::digital_signature_ed25519_verify(signature_result.public_key, data_to_sign, signature_result.signature);
     assert_eq!(is_verified, true);
 }
@@ -62,7 +26,7 @@ fn sha_256_ed25519_test() {
 fn sha_512_ed25519_test_fail() {
     let key_size: u32 = 1024;
     let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: SHAED25519DalekDigitalSignatureResult = SHA256ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone());
+    let signature_result: CASSHAED25519DalekDigitalSignatureResult = SHA256ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone()).into();
     let not_original_data = b"NOtTHoseBytes".to_vec();
     let is_verified: bool = SHA256ED25519DigitalSignature::digital_signature_ed25519_verify(signature_result.public_key, not_original_data, signature_result.signature);
     assert_eq!(is_verified, false);