Merge pull request #11 from Cryptographic-API-Services/pre-release

#9 ED25519 Digital SIgnatures for SHA 512 and SHA 256
Cryptographic-API-Services · May 10, 2024 · c2d0658 · c2d0658
2 parents 5ea2ed1 + 3ae5071
commit c2d0658
Show file tree

Hide file tree

Showing 15 changed files with 224 additions and 51 deletions.
diff --git a/index.d.ts b/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>)

diff --git a/index.node b/index.node
diff --git a/src-ts/digital-signature/digital-siganture-sha-512.ts b/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.");
         }

diff --git a/src-ts/digital-signature/digital-signature-base.ts b/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;
 }
diff --git a/src-ts/digital-signature/digital-signaturte-sha-256.ts b/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.");
         }

diff --git a/src-ts/digital-signature/index.ts b/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
+};
diff --git a/src-ts/global.d.ts b/src-ts/global.d.ts
diff --git a/src-ts/index.ts b/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,
 };
diff --git a/src/digital_signature/cas_digital_signature_rsa.rs b/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;
 }
diff --git a/src/digital_signature/sha_256_ed25519.rs b/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);
+}
diff --git a/src/digital_signature/sha_256_rsa.rs b/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);

diff --git a/src/digital_signature/sha_512_ed25519.rs b/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);