cas-typescript-sdk 1.0.16 → 1.0.17

package/README.md

@@ -1,6 +1,8 @@
 # cas-typescript-sdk
 
-Ever wanted all of your most useful cryptograpihc operations in one module and not have to surf documentation for various packages? 
+[![image](https://img.shields.io/badge/Discord-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/7bXXCQj45q)
+
+Ever wanted all of your most useful cryptographic 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).
 

package/index.d.ts

@@ -29,12 +29,14 @@ 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 sha512RsaDigitalSignature(rsaKeySize: number, dataToSign: Array<number>): RsaDigitalSignatureResult
 export function sha512RsaVerifyDigitalSignature(publicKey: string, dataToVerify: Array<number>, signature: Array<number>): boolean
-export function sha256RsaDigitalSignature(rsaKeySize: number, dataToSign: Array<number>): CasrsaDigitalSignatureResult
+export function sha256RsaDigitalSignature(rsaKeySize: number, dataToSign: Array<number>): RsaDigitalSignatureResult
 export function sha256RsaVerifyDigitalSignature(publicKey: string, dataToVerify: Array<number>, signature: Array<number>): boolean
-export function sha512Ed25519DigitalSignature(dataToSign: Array<number>): Casshaed25519DalekDigitalSignatureResult
+export function sha512Ed25519DigitalSignature(dataToSign: Array<number>): Shaed25519DalekDigitalSignatureResult
 export function sha512Ed25519DigitalSignatureVerify(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean
+export function sha256Ed25519DigitalSignature(dataToSign: Array<number>): Shaed25519DalekDigitalSignatureResult
+export function sha256Ed25519DigitalSignatureVerify(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean
 export type x25519SecretPublicKeyResult = X25519SecretPublicKeyResult
 export class X25519SecretPublicKeyResult {
   publicKey: Array<number>
@@ -52,15 +54,15 @@ export class RsaKeyPairResult {
   publicKey: string
   constructor(privateKey: string, publicKey: string)
 }
-export type CASRSADigitalSignatureResult = CasrsaDigitalSignatureResult
-export class CasrsaDigitalSignatureResult {
+export type RSADigitalSignatureResult = RsaDigitalSignatureResult
+export class RsaDigitalSignatureResult {
   publicKey: string
   privateKey: string
   signature: Array<number>
   constructor(publicKey: string, privateKey: string, signature: Array<number>)
 }
-export type CASSHAED25519DalekDigitalSignatureResult = Casshaed25519DalekDigitalSignatureResult
-export class Casshaed25519DalekDigitalSignatureResult {
+export type SHAED25519DalekDigitalSignatureResult = Shaed25519DalekDigitalSignatureResult
+export class Shaed25519DalekDigitalSignatureResult {
   publicKey: Array<number>
   signature: Array<number>
   constructor(publicKey: Array<number>, signature: Array<number>)

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

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

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

@@ -3,6 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DigitalSignatureSHA512Wrapper = void 0;
 const index_1 = require("../../index");
 class DigitalSignatureSHA512Wrapper {
+    createED25519(dataToSign) {
+        if (dataToSign?.length === 0) {
+            throw new Error("Must provide allocated data to sign");
+        }
+        return (0, index_1.sha512Ed25519DigitalSignature)(dataToSign);
+    }
+    verifyED25519(publicKey, dataToVerify, signature) {
+        if (!publicKey) {
+            throw new Error("You must provide a public key for verify with ED25519");
+        }
+        if (dataToVerify?.length === 0) {
+            throw new Error("Must provide allocated data to verify");
+        }
+        if (signature?.length === 0) {
+            throw new Error("Must provide allocated signature to verify");
+        }
+        return (0, index_1.sha512Ed25519DigitalSignatureVerify)(publicKey, dataToVerify, signature);
+    }
     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.");

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

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

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

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

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

@@ -3,6 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DigitalSignatureSHA256Wrapper = void 0;
 const index_1 = require("../../index");
 class DigitalSignatureSHA256Wrapper {
+    createED25519(dataToSign) {
+        if (dataToSign?.length === 0) {
+            throw new Error("Must provide allocated data to sign");
+        }
+        return (0, index_1.sha256Ed25519DigitalSignature)(dataToSign);
+    }
+    verifyED25519(publicKey, dataToVerify, signature) {
+        if (!publicKey) {
+            throw new Error("You must provide a public key for verify with ED25519");
+        }
+        if (dataToVerify?.length === 0) {
+            throw new Error("Must provide allocated data to verify");
+        }
+        if (signature?.length === 0) {
+            throw new Error("Must provide allocated signature to verify");
+        }
+        return (0, index_1.sha256Ed25519DigitalSignatureVerify)(publicKey, dataToVerify, signature);
+    }
     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.");

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

@@ -1,4 +1,5 @@
-export declare enum DigitalSignatureType {
-    SHA512 = 1,
-    SHA256 = 2
-}
+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 };

package/lib/digital-signature/index.js

@@ -1,8 +1,11 @@
 "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 = {}));
+exports.DigitalSignatureType = exports.DigitalSignatureSHA512Wrapper = exports.DigitalSignatureSHA256Wrapper = exports.DigitalSignatureFactory = void 0;
+const digital_signature_factory_1 = require("./digital-signature-factory");
+Object.defineProperty(exports, "DigitalSignatureType", { enumerable: true, get: function () { return digital_signature_factory_1.DigitalSignatureType; } });
+const digital_signature_factory_2 = require("./digital-signature-factory");
+Object.defineProperty(exports, "DigitalSignatureFactory", { enumerable: true, get: function () { return digital_signature_factory_2.DigitalSignatureFactory; } });
+const digital_signaturte_sha_256_1 = require("./digital-signaturte-sha-256");
+Object.defineProperty(exports, "DigitalSignatureSHA256Wrapper", { enumerable: true, get: function () { return digital_signaturte_sha_256_1.DigitalSignatureSHA256Wrapper; } });
+const digital_siganture_sha_512_1 = require("./digital-siganture-sha-512");
+Object.defineProperty(exports, "DigitalSignatureSHA512Wrapper", { enumerable: true, get: function () { return digital_siganture_sha_512_1.DigitalSignatureSHA512Wrapper; } });

package/lib/index.d.ts

@@ -4,4 +4,5 @@ import { X25519Wrapper } from "./key_exchange/index";
 import { AESWrapper } from "./symmetric/index";
 import { RsaKeyPairResult, RSAWrapper } from "./asymmetric/index";
 import { AesRsaHybridEncryptResult, AESRSAHybridInitializer, HybridEncryptionWrapper } from "./hybrid/index";
-export { AesRsaHybridEncryptResult, AESRSAHybridInitializer, AESWrapper, Argon2Wrapper, BCryptWrapper, HasherFactory, HasherType, HybridEncryptionWrapper, PasswordHasherFactory, PasswordHasherType, RsaKeyPairResult, RSAWrapper, ScryptWrapper, SHAWrapper, X25519Wrapper, };
+import { DigitalSignatureFactory, DigitalSignatureSHA256Wrapper, DigitalSignatureSHA512Wrapper, DigitalSignatureType } from "./digital-signature";
+export { AesRsaHybridEncryptResult, AESRSAHybridInitializer, AESWrapper, Argon2Wrapper, BCryptWrapper, HasherFactory, HasherType, HybridEncryptionWrapper, PasswordHasherFactory, PasswordHasherType, RsaKeyPairResult, RSAWrapper, ScryptWrapper, SHAWrapper, X25519Wrapper, DigitalSignatureFactory, DigitalSignatureSHA256Wrapper, DigitalSignatureSHA512Wrapper, DigitalSignatureType, };

package/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
 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.BCryptWrapper = exports.Argon2Wrapper = exports.AESWrapper = exports.AESRSAHybridInitializer = exports.AesRsaHybridEncryptResult = void 0;
+exports.DigitalSignatureType = exports.DigitalSignatureSHA512Wrapper = exports.DigitalSignatureSHA256Wrapper = exports.DigitalSignatureFactory = exports.X25519Wrapper = exports.SHAWrapper = exports.ScryptWrapper = exports.RSAWrapper = exports.RsaKeyPairResult = exports.PasswordHasherType = exports.PasswordHasherFactory = exports.HybridEncryptionWrapper = exports.HasherType = exports.HasherFactory = exports.BCryptWrapper = 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; } });
@@ -22,3 +22,8 @@ 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; } });

package/package.json

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

package/src/digital_signature/cas_digital_signature_rsa.rs

@@ -1,27 +1,27 @@
 use napi_derive::napi;
 
 #[napi(constructor)]
-pub struct CASRSADigitalSignatureResult {
+pub struct RSADigitalSignatureResult {
     pub public_key: String,
     pub private_key: String,
     pub signature: Vec<u8>,
 }
 
 #[napi(constructor)]
-pub struct CASSHAED25519DalekDigitalSignatureResult {
+pub struct SHAED25519DalekDigitalSignatureResult {
     pub public_key: Vec<u8>,
     pub signature: Vec<u8>
 }
 
-pub trait CASRSADigitalSignature {
+pub trait RSADigitalSignature {
     fn digital_signature_rsa(
         rsa_key_size: u32,
         data_to_sign: Vec<u8>,
-    ) -> CASRSADigitalSignatureResult;
+    ) -> RSADigitalSignatureResult;
     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;
+pub trait ED25519DigitalSignature {
+    fn digital_signature_ed25519(data_to_sign: Vec<u8>) -> SHAED25519DalekDigitalSignatureResult;
     fn digital_signature_ed25519_verify(public_key: Vec<u8>, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool;
 }

package/src/digital_signature/sha_256_ed25519.rs

@@ -0,0 +1,69 @@
+use ed25519_dalek::{Keypair, Signature, Signer, Verifier};
+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();
+    }
+}
+
+#[napi]
+pub fn sha_256_ed25519_digital_signature(data_to_sign: Vec<u8>) -> SHAED25519DalekDigitalSignatureResult {
+    return SHA256ED25519DigitalSignature::digital_signature_ed25519(data_to_sign);
+}
+
+#[napi]
+pub fn sha_256_ed25519_digital_signature_verify(public_key: Vec<u8>, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool {
+    return SHA256ED25519DigitalSignature::digital_signature_ed25519_verify(public_key, data_to_verify, signature)
+}
+
+#[test]
+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 is_verified: bool = SHA256ED25519DigitalSignature::digital_signature_ed25519_verify(signature_result.public_key, data_to_sign, signature_result.signature);
+    assert_eq!(is_verified, true);
+}
+
+#[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 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);
+}

package/src/digital_signature/sha_256_rsa.rs

@@ -8,15 +8,15 @@ use rsa::{
 use sha3::{Digest, Sha3_256};
 
 
-use super::cas_digital_signature_rsa::{CASRSADigitalSignatureResult, CASRSADigitalSignature};
+use super::cas_digital_signature_rsa::{RSADigitalSignatureResult, RSADigitalSignature};
 
 pub struct SHA256RSADigitalSignature;
 
-impl CASRSADigitalSignature for SHA256RSADigitalSignature {
+impl RSADigitalSignature for SHA256RSADigitalSignature {
     fn digital_signature_rsa(
         rsa_key_size: u32,
         data_to_sign: Vec<u8>,
-    ) -> CASRSADigitalSignatureResult {
+    ) -> RSADigitalSignatureResult {
         let mut hasher = Sha3_256::new();
         hasher.update(data_to_sign);
         let sha_hasher_result = hasher.finalize();
@@ -27,7 +27,7 @@ impl CASRSADigitalSignature for SHA256RSADigitalSignature {
         let mut signed_data = private_key
             .sign(Pkcs1v15Sign::new_unprefixed(), &sha_hasher_result)
             .unwrap();
-        let result = CASRSADigitalSignatureResult {
+        let result = RSADigitalSignatureResult {
             private_key: private_key
                 .to_pkcs8_pem(rsa::pkcs8::LineEnding::LF)
                 .unwrap()
@@ -63,7 +63,7 @@ impl CASRSADigitalSignature for SHA256RSADigitalSignature {
 pub fn sha_256_rsa_digital_signature(
     rsa_key_size: u32,
     data_to_sign: Vec<u8>,
-) -> CASRSADigitalSignatureResult {
+) -> RSADigitalSignatureResult {
     return SHA256RSADigitalSignature::digital_signature_rsa(rsa_key_size, data_to_sign);
 }
 
@@ -80,7 +80,7 @@ pub fn sha_256_rsa_verify_digital_signature(
 fn sha_256_rsa_digital_signature_test() {
     let key_size: u32 = 1024;
     let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASRSADigitalSignatureResult = SHA256RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone());
+    let signature_result: RSADigitalSignatureResult = SHA256RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone());
     let is_verified: bool = SHA256RSADigitalSignature::verify_rsa(signature_result.public_key, data_to_sign, signature_result.signature);
     assert_eq!(is_verified, true);
 }
@@ -89,7 +89,7 @@ fn sha_256_rsa_digital_signature_test() {
 fn sha_256_rsa_digital_signature_fail_test() {
     let key_size: u32 = 1024;
     let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASRSADigitalSignatureResult = SHA256RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone());
+    let signature_result: RSADigitalSignatureResult = SHA256RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone());
     let new_data = b"NOtTheOriginalData".to_vec();
     let is_verified: bool = SHA256RSADigitalSignature::verify_rsa(signature_result.public_key, new_data, signature_result.signature);
     assert_eq!(is_verified, false);

package/src/digital_signature/sha_512_ed25519.rs

@@ -3,15 +3,15 @@ use napi_derive::napi;
 use sha3::{Digest, Sha3_512};
 
 use super::cas_digital_signature_rsa::{
-    CASED25519DigitalSignature, CASSHAED25519DalekDigitalSignatureResult,
+    ED25519DigitalSignature, SHAED25519DalekDigitalSignatureResult,
 };
 
 pub struct SHA512ED25519DigitalSignature;
 
-impl CASED25519DigitalSignature for SHA512ED25519DigitalSignature {
+impl ED25519DigitalSignature for SHA512ED25519DigitalSignature {
     fn digital_signature_ed25519(
         data_to_sign: Vec<u8>,
-    ) -> CASSHAED25519DalekDigitalSignatureResult {
+    ) -> SHAED25519DalekDigitalSignatureResult {
         let mut hasher = Sha3_512::new();
         hasher.update(data_to_sign);
         let sha_hasher_result = hasher.finalize();
@@ -21,7 +21,7 @@ impl CASED25519DigitalSignature for SHA512ED25519DigitalSignature {
         let signature = keypair.sign(&sha_hasher_result);
         let signature_bytes = signature.to_bytes();
         let public_keypair_bytes = keypair.public.to_bytes();
-        let result = CASSHAED25519DalekDigitalSignatureResult {
+        let result = SHAED25519DalekDigitalSignatureResult {
             public_key: public_keypair_bytes.to_vec(),
             signature: signature_bytes.to_vec(),
         };
@@ -46,7 +46,7 @@ impl CASED25519DigitalSignature for SHA512ED25519DigitalSignature {
 }
 
 #[napi]
-pub fn sha_512_ed25519_digital_signature(data_to_sign: Vec<u8>) -> CASSHAED25519DalekDigitalSignatureResult {
+pub fn sha_512_ed25519_digital_signature(data_to_sign: Vec<u8>) -> SHAED25519DalekDigitalSignatureResult {
     return SHA512ED25519DigitalSignature::digital_signature_ed25519(data_to_sign);
 }
 
@@ -59,7 +59,7 @@ pub fn sha_512_ed25519_digital_signature_verify(public_key: Vec<u8>, data_to_ver
 fn sha_512_ed25519_test() {
     let key_size: u32 = 1024;
     let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASSHAED25519DalekDigitalSignatureResult = SHA512ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone());
+    let signature_result: SHAED25519DalekDigitalSignatureResult = SHA512ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone());
     let is_verified: bool = SHA512ED25519DigitalSignature::digital_signature_ed25519_verify(signature_result.public_key, data_to_sign, signature_result.signature);
     assert_eq!(is_verified, true);
 }
@@ -68,7 +68,7 @@ fn sha_512_ed25519_test() {
 fn sha_512_ed25519_test_fail() {
     let key_size: u32 = 1024;
     let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASSHAED25519DalekDigitalSignatureResult = SHA512ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone());
+    let signature_result: SHAED25519DalekDigitalSignatureResult = SHA512ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone());
     let not_original_data = b"NOtTHoseBytes".to_vec();
     let is_verified: bool = SHA512ED25519DigitalSignature::digital_signature_ed25519_verify(signature_result.public_key, not_original_data, signature_result.signature);
     assert_eq!(is_verified, false);

package/src/digital_signature/sha_512_rsa.rs

@@ -6,14 +6,14 @@ use rsa::{
     Pkcs1v15Sign, RsaPrivateKey, RsaPublicKey,
 };
 use sha3::{Digest, Sha3_512};
-use super::cas_digital_signature_rsa::{CASRSADigitalSignatureResult, CASRSADigitalSignature};
+use super::cas_digital_signature_rsa::{RSADigitalSignatureResult, RSADigitalSignature};
 pub struct SHA512RSADigitalSignature;
 
-impl CASRSADigitalSignature for SHA512RSADigitalSignature {
+impl RSADigitalSignature for SHA512RSADigitalSignature {
     fn digital_signature_rsa(
         rsa_key_size: u32,
         data_to_sign: Vec<u8>,
-    ) -> CASRSADigitalSignatureResult {
+    ) -> RSADigitalSignatureResult {
         let mut hasher = Sha3_512::new();
         hasher.update(data_to_sign);
         let sha_hasher_result = hasher.finalize();
@@ -24,7 +24,7 @@ impl CASRSADigitalSignature for SHA512RSADigitalSignature {
         let mut signed_data = private_key
             .sign(Pkcs1v15Sign::new_unprefixed(), &sha_hasher_result)
             .unwrap();
-        let result = CASRSADigitalSignatureResult {
+        let result = RSADigitalSignatureResult {
             private_key: private_key
                 .to_pkcs8_pem(rsa::pkcs8::LineEnding::LF)
                 .unwrap()
@@ -60,7 +60,7 @@ impl CASRSADigitalSignature for SHA512RSADigitalSignature {
 pub fn sha_512_rsa_digital_signature(
     rsa_key_size: u32,
     data_to_sign: Vec<u8>,
-) -> CASRSADigitalSignatureResult {
+) -> RSADigitalSignatureResult {
     return SHA512RSADigitalSignature::digital_signature_rsa(rsa_key_size, data_to_sign);
 }
 
@@ -77,7 +77,7 @@ pub fn sha_512_rsa_verify_digital_signature(
 fn sha_512_rsa_digital_signature_test() {
     let key_size: u32 = 1024;
     let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASRSADigitalSignatureResult = SHA512RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone());
+    let signature_result: RSADigitalSignatureResult = SHA512RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone());
     let is_verified: bool = SHA512RSADigitalSignature::verify_rsa(signature_result.public_key, data_to_sign, signature_result.signature);
     assert_eq!(is_verified, true);
 }
@@ -86,7 +86,7 @@ fn sha_512_rsa_digital_signature_test() {
 fn sha_512_rsa_digital_signature_fail_test() {
     let key_size: u32 = 1024;
     let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASRSADigitalSignatureResult = SHA512RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone());
+    let signature_result: RSADigitalSignatureResult = SHA512RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone());
     let new_data = b"NOtTheOriginalData".to_vec();
     let is_verified: bool = SHA512RSADigitalSignature::verify_rsa(signature_result.public_key, new_data, signature_result.signature);
     assert_eq!(is_verified, false);

package/src/lib.rs

@@ -31,4 +31,5 @@ mod digital_signature {
     pub mod sha_512_rsa;
     pub mod sha_256_rsa;
     pub mod sha_512_ed25519;
+    pub mod sha_256_ed25519;
 }

package/src-ts/digital-signature/digital-siganture-sha-512.ts

@@ -1,9 +1,29 @@
-import { CasrsaDigitalSignatureResult, sha512RsaDigitalSignature, sha512RsaVerifyDigitalSignature } from "../../index";
+import { RsaDigitalSignatureResult, SHAED25519DalekDigitalSignatureResult, sha512Ed25519DigitalSignature, sha512Ed25519DigitalSignatureVerify, sha512RsaDigitalSignature, sha512RsaVerifyDigitalSignature } from "../../index";
 import { IDigitalSignature } from "./digital-signature-base";
 
 export class DigitalSignatureSHA512Wrapper implements IDigitalSignature {
 
-    createRsa(rsa_key_size: number, data_to_sign: number[]): CasrsaDigitalSignatureResult {
+    createED25519(dataToSign: number[]): SHAED25519DalekDigitalSignatureResult {
+        if (dataToSign?.length === 0) {
+            throw new Error("Must provide allocated data to sign");
+        }
+        return sha512Ed25519DigitalSignature(dataToSign);
+    }
+    
+    verifyED25519(publicKey: number[], dataToVerify: number[], signature: number[]): boolean {
+        if (!publicKey) {
+            throw new Error("You must provide a public key for verify with ED25519");
+        }
+        if (dataToVerify?.length === 0) {
+            throw new Error("Must provide allocated data to verify");
+        }
+        if (signature?.length === 0) {
+            throw new Error("Must provide allocated signature to verify");
+        }
+        return sha512Ed25519DigitalSignatureVerify(publicKey, dataToVerify, signature);
+    }
+
+    createRsa(rsa_key_size: number, data_to_sign: number[]): RsaDigitalSignatureResult {
         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.");
         }

package/src-ts/digital-signature/digital-signature-base.ts

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

package/src-ts/digital-signature/digital-signaturte-sha-256.ts

@@ -1,9 +1,29 @@
-import { CasrsaDigitalSignatureResult, sha256RsaDigitalSignature, sha256RsaVerifyDigitalSignature } from "../../index";
+import { RsaDigitalSignatureResult, SHAED25519DalekDigitalSignatureResult, Shaed25519DalekDigitalSignatureResult, sha256Ed25519DigitalSignature, sha256Ed25519DigitalSignatureVerify, sha256RsaDigitalSignature, sha256RsaVerifyDigitalSignature, sha512Ed25519DigitalSignature } from "../../index";
 import { IDigitalSignature } from "./digital-signature-base";
 
 export class DigitalSignatureSHA256Wrapper implements IDigitalSignature {
+    
+    createED25519(dataToSign: number[]): Shaed25519DalekDigitalSignatureResult {
+        if (dataToSign?.length === 0) {
+            throw new Error("Must provide allocated data to sign");
+        }
+        return sha256Ed25519DigitalSignature(dataToSign);
+    }
+
+    verifyED25519(publicKey: number[], dataToVerify: number[], signature: number[]): boolean {
+        if (!publicKey) {
+            throw new Error("You must provide a public key for verify with ED25519");
+        }
+        if (dataToVerify?.length === 0) {
+            throw new Error("Must provide allocated data to verify");
+        }
+        if (signature?.length === 0) {
+            throw new Error("Must provide allocated signature to verify");
+        }
+        return sha256Ed25519DigitalSignatureVerify(publicKey, dataToVerify, signature);
+    }
 
-    createRsa(rsa_key_size: number, data_to_sign: number[]): CasrsaDigitalSignatureResult {
+    createRsa(rsa_key_size: number, data_to_sign: number[]): RsaDigitalSignatureResult {
         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.");
         }

package/src-ts/digital-signature/index.ts

@@ -1,4 +1,11 @@
-export enum DigitalSignatureType {
-    SHA512 = 1,
-    SHA256 = 2
-}
+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
+};

package/src-ts/index.ts

@@ -14,6 +14,12 @@ import {
   AESRSAHybridInitializer,
   HybridEncryptionWrapper,
 } from "./hybrid/index";
+import {
+  DigitalSignatureFactory,
+  DigitalSignatureSHA256Wrapper,
+  DigitalSignatureSHA512Wrapper,
+  DigitalSignatureType,
+} from "./digital-signature";
 
 export {
   AesRsaHybridEncryptResult,
@@ -31,4 +37,8 @@ export {
   ScryptWrapper,
   SHAWrapper,
   X25519Wrapper,
+  DigitalSignatureFactory,
+  DigitalSignatureSHA256Wrapper,
+  DigitalSignatureSHA512Wrapper,
+  DigitalSignatureType,
 };

package/test-ts/digital-signature.test.spec.ts

@@ -1,6 +1,6 @@
 import { assert } from "chai";
 import { DigitalSignatureFactory, DigitalSignatureType } from "../src-ts/digital-signature/digital-signature-factory";
-import { CASRSADigitalSignatureResult } from "../index";
+import { RSADigitalSignatureResult } from "../index";
 
 describe("Digital Signature", () => {
     it("SHA 512 RSA pass", () => {
@@ -8,7 +8,7 @@ describe("Digital Signature", () => {
         const tohashed: string = "This is my array to encrypt";
         const encoder = new TextEncoder();
         const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-        const dsResult: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(2048, tohashBytes);
+        const dsResult: RSADigitalSignatureResult = shaDsWrapper.createRsa(2048, tohashBytes);
         const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, tohashBytes, dsResult.signature);
         assert.equal(verify, true);
     });
@@ -20,7 +20,7 @@ describe("Digital Signature", () => {
         const encoder = new TextEncoder();
         const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
         const badBytes: Array<number> = Array.from(encoder.encode(notOriginal));
-        const dsResult: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(4096, tohashBytes);
+        const dsResult: RSADigitalSignatureResult = shaDsWrapper.createRsa(4096, tohashBytes);
         const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, badBytes, dsResult.signature);
         assert.equal(verify, false);
     });
@@ -30,7 +30,7 @@ describe("Digital Signature", () => {
         const tohashed: string = "This is my array to encrypt";
         const encoder = new TextEncoder();
         const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-        const dsResult: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(2048, tohashBytes);
+        const dsResult: RSADigitalSignatureResult = shaDsWrapper.createRsa(2048, tohashBytes);
         const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, tohashBytes, dsResult.signature);
         assert.equal(verify, true);
     });
@@ -42,8 +42,52 @@ describe("Digital Signature", () => {
         const encoder = new TextEncoder();
         const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
         const badBytes: Array<number> = Array.from(encoder.encode(notOriginal));
-        const dsResult: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(4096, tohashBytes);
+        const dsResult: RSADigitalSignatureResult = shaDsWrapper.createRsa(4096, tohashBytes);
         const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, badBytes, dsResult.signature);
         assert.equal(verify, false);
     });
+
+    it("SHA 512 ED25519 pass", () => {
+        const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA512)
+        const toHash: string = "This is my array to encrypt";
+        const encoder = new TextEncoder();
+        const toHashBytes: Array<number> = Array.from(encoder.encode(toHash));
+        const dsResult = shaDsWrapper.createED25519(toHashBytes);
+        const verify = shaDsWrapper.verifyED25519(dsResult.publicKey, toHashBytes, dsResult.signature);
+        assert.equal(verify, true);
+    });
+
+    it("SHA 512 ED25519 fails", () => {
+        const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA512)
+        const toHash: string = "This is my array to encrypt";
+        const notOriginal: string = "This is not a fun time";
+        const encoder = new TextEncoder();
+        const toHashBytes: Array<number> = Array.from(encoder.encode(toHash));
+        const badBytes: Array<number> = Array.from(encoder.encode(notOriginal));
+        const dsResult = shaDsWrapper.createED25519(toHashBytes);
+        const verify = shaDsWrapper.verifyED25519(dsResult.publicKey, badBytes, dsResult.signature);
+        assert.equal(verify, false);
+    });
+
+    it("SHA 256 ED25519 pass", () => {
+        const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA256)
+        const toHash: string = "This is my array to encrypt";
+        const encoder = new TextEncoder();
+        const toHashBytes: Array<number> = Array.from(encoder.encode(toHash));
+        const dsResult = shaDsWrapper.createED25519(toHashBytes);
+        const verify = shaDsWrapper.verifyED25519(dsResult.publicKey, toHashBytes, dsResult.signature);
+        assert.equal(verify, true);
+    });
+
+    it("SHA 256 ED25519 fails", () => {
+        const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA256)
+        const toHash: string = "This is my array to encrypt";
+        const notOriginal: string = "This is not a fun time";
+        const encoder = new TextEncoder();
+        const toHashBytes: Array<number> = Array.from(encoder.encode(toHash));
+        const badBytes: Array<number> = Array.from(encoder.encode(notOriginal));
+        const dsResult = shaDsWrapper.createED25519(toHashBytes);
+        const verify = shaDsWrapper.verifyED25519(dsResult.publicKey, badBytes, dsResult.signature);
+        assert.equal(verify, false);
+    });
 });

package/src-ts/global.d.ts

@@ -1,2 +0,0 @@
-declare var pathToWindowsDll: string;
-declare var pathToLinuxSO: string;