wasm

2 files changed, 147 insertions, 1 deletions

diff --git a/src/crypto/cryptoWorker.ts b/src/crypto/cryptoWorker.ts
index 3e71794b4..11b21190d 100644
--- a/src/crypto/cryptoWorker.ts
+++ b/src/crypto/cryptoWorker.ts
@@ -549,6 +549,76 @@ namespace RpcFunctions {
       time_eddsa_verify += timer.performanceNow() - start;
     }
 
+    /* rsa 2048 */
+
+    let time_rsa_2048_blind = 0;
+    const rsaPriv2048: native.RsaPrivateKey = native.RsaPrivateKey.create(2048);
+    const rsaPub2048 = rsaPriv2048.getPublicKey();
+    const blindingSecret2048 = native.RsaBlindingKeySecret.create();
+    for (let i = 0; i < repetitions; i++) {
+      const start = timer.performanceNow();
+      native.rsaBlind(h, blindingSecret2048, rsaPub2048);
+      time_rsa_2048_blind += timer.performanceNow() - start;
+    }
+
+    const blindedMessage2048 = native.rsaBlind(h, blindingSecret2048, rsaPub2048);
+    if (!blindedMessage2048) {
+      throw Error("should not happen");
+    }
+    const rsaBlindSig2048 = native.rsaSignBlinded(rsaPriv2048, blindedMessage2048);
+
+    let time_rsa_2048_unblind = 0;
+    for (let i = 0; i < repetitions; i++) {
+      const start = timer.performanceNow();
+      native.rsaUnblind(rsaBlindSig2048, blindingSecret2048, rsaPub2048);
+      time_rsa_2048_unblind += timer.performanceNow() - start;
+    }
+
+    const unblindedSig2048 = native.rsaUnblind(rsaBlindSig2048, blindingSecret2048, rsaPub2048);
+
+    let time_rsa_2048_verify = 0;
+    for (let i = 0; i < repetitions; i++) {
+      const start = timer.performanceNow();
+      native.rsaVerify(h, unblindedSig2048, rsaPub2048);
+      time_rsa_2048_verify += timer.performanceNow() - start;
+    }
+
+
+    /* rsa 4096 */
+
+    let time_rsa_4096_blind = 0;
+    const rsaPriv4096: native.RsaPrivateKey = native.RsaPrivateKey.create(4096);
+    const rsaPub4096 = rsaPriv4096.getPublicKey();
+    const blindingSecret4096 = native.RsaBlindingKeySecret.create();
+    for (let i = 0; i < repetitions; i++) {
+      const start = timer.performanceNow();
+      native.rsaBlind(h, blindingSecret4096, rsaPub4096);
+      time_rsa_4096_blind += timer.performanceNow() - start;
+    }
+
+    const blindedMessage4096 = native.rsaBlind(h, blindingSecret4096, rsaPub4096);
+    if (!blindedMessage4096) {
+      throw Error("should not happen");
+    }
+    const rsaBlindSig4096 = native.rsaSignBlinded(rsaPriv4096, blindedMessage4096);
+
+    let time_rsa_4096_unblind = 0;
+    for (let i = 0; i < repetitions; i++) {
+      const start = timer.performanceNow();
+      native.rsaUnblind(rsaBlindSig4096, blindingSecret4096, rsaPub4096);
+      time_rsa_4096_unblind += timer.performanceNow() - start;
+    }
+
+    const unblindedSig4096 = native.rsaUnblind(rsaBlindSig4096, blindingSecret4096, rsaPub4096);
+
+    let time_rsa_4096_verify = 0;
+    for (let i = 0; i < repetitions; i++) {
+      const start = timer.performanceNow();
+      native.rsaVerify(h, unblindedSig4096, rsaPub4096);
+      time_rsa_4096_verify += timer.performanceNow() - start;
+    }
+
+
     return {
       repetitions,
       time: {
@@ -558,6 +628,12 @@ namespace RpcFunctions {
         eddsa_sign: time_eddsa_sign,
         eddsa_verify: time_eddsa_verify,
         ecdsa_create: time_ecdsa_create,
+        rsa_2048_blind: time_rsa_2048_blind,
+        rsa_2048_unblind: time_rsa_2048_unblind,
+        rsa_2048_verify: time_rsa_2048_verify,
+        rsa_4096_blind: time_rsa_4096_blind,
+        rsa_4096_unblind: time_rsa_4096_unblind,
+        rsa_4096_verify: time_rsa_4096_verify,
       }
     };
   }
diff --git a/src/crypto/emscInterface.ts b/src/crypto/emscInterface.ts
index 61289fb75..dcd16e633 100644
--- a/src/crypto/emscInterface.ts
+++ b/src/crypto/emscInterface.ts
@@ -90,7 +90,9 @@ interface EmscFunctions {
   random_block(a1: number, a2: number, a3: number): void;
   rsa_blinding_key_free(a1: number): void;
   rsa_public_key_free(a1: number): void;
+  rsa_private_key_free(a1: number): void;
   rsa_signature_free(a1: number): void;
+  rsa_verify(msgHash: number, sig: number, pubKey: number): number;
   setup_fresh_coin(a1: number, a2: number, a3: number): void;
   string_to_data(a1: number, a2: number, a3: number, a4: number): number;
 }
@@ -115,10 +117,15 @@ interface EmscAllocFunctions {
   rsa_blinding_key_create(a1: number): number;
   rsa_blinding_key_decode(a1: number, a2: number): number;
   rsa_blinding_key_encode(a1: number, a2: number): number;
+  rsa_private_key_create(len: number): number;
+  rsa_private_key_decode(a1: number, a2: number): number;
+  rsa_private_key_encode(a1: number, a2: number): number;
+  rsa_private_key_get_public(privKeyPtr: number): number;
   rsa_public_key_decode(a1: number, a2: number): number;
   rsa_public_key_encode(a1: number, a2: number): number;
-  rsa_signature_encode(a1: number, a2: number): number;
   rsa_signature_decode(a1: number, a2: number): number;
+  rsa_signature_encode(a1: number, a2: number): number;
+  rsa_sign_blinded(keyPtr: number, msgPtr: number, msgLen: number): number;
   rsa_unblind(a1: number, a2: number, a3: number): number;
 }
 
@@ -159,10 +166,15 @@ class EmscEnvironment {
       rsa_blinding_key_create: getEmsc("GNUNET_CRYPTO_rsa_blinding_key_create", "number", ["number"]),
       rsa_blinding_key_decode: getEmsc("GNUNET_CRYPTO_rsa_blinding_key_decode", "number", ["number", "number"]),
       rsa_blinding_key_encode: getEmsc("GNUNET_CRYPTO_rsa_blinding_key_encode", "number", ["number", "number"]),
+      rsa_private_key_create: getEmsc("GNUNET_CRYPTO_rsa_private_key_create", "number", ["number"]),
+      rsa_private_key_decode: getEmsc("GNUNET_CRYPTO_rsa_private_key_decode", "number", ["number", "number"]),
+      rsa_private_key_encode: getEmsc("GNUNET_CRYPTO_rsa_private_key_encode", "number", ["number", "number"]),
+      rsa_private_key_get_public: getEmsc("GNUNET_CRYPTO_rsa_private_key_get_public", "number", ["number"]),
       rsa_public_key_decode: getEmsc("GNUNET_CRYPTO_rsa_public_key_decode", "number", ["number", "number"]),
       rsa_public_key_encode: getEmsc("GNUNET_CRYPTO_rsa_public_key_encode", "number", ["number", "number"]),
       rsa_signature_decode: getEmsc("GNUNET_CRYPTO_rsa_signature_decode", "number", ["number", "number"]),
       rsa_signature_encode: getEmsc("GNUNET_CRYPTO_rsa_signature_encode", "number", ["number", "number"]),
+      rsa_sign_blinded: getEmsc("GNUNET_CRYPTO_rsa_sign_blinded", "number", ["number", "number", "number"]),
       rsa_unblind: getEmsc("GNUNET_CRYPTO_rsa_unblind", "number", ["number", "number", "number"]),
     };
     this.funcs = {
@@ -189,7 +201,9 @@ class EmscEnvironment {
       random_block: getEmsc("GNUNET_CRYPTO_random_block", "void", ["number", "number", "number"]),
       rsa_blinding_key_free: getEmsc("GNUNET_CRYPTO_rsa_blinding_key_free", "void", ["number"]),
       rsa_public_key_free: getEmsc("GNUNET_CRYPTO_rsa_public_key_free", "void", ["number"]),
+      rsa_private_key_free: getEmsc("GNUNET_CRYPTO_rsa_private_key_free", "void", ["number"]),
       rsa_signature_free: getEmsc("GNUNET_CRYPTO_rsa_signature_free", "void", ["number"]),
+      rsa_verify: getEmsc("GNUNET_CRYPTO_rsa_verify", "number", ["number", "number", "number"]),
       setup_fresh_coin: getEmsc("TALER_setup_fresh_coin", "void", ["number", "number", "number"]),
       string_to_data: getEmsc("GNUNET_STRINGS_string_to_data", "number", ["number", "number", "number", "number"]),
     };
@@ -1358,6 +1372,42 @@ export class PaymentSignaturePS extends SignatureStruct {
 
 
 /**
+ * Low-level handle to an RsaPrivateKey.
+ */
+export class RsaPrivateKey extends MallocArenaObject {
+  static fromCrock(s: string): RsaPrivateKey {
+    return fromCrockDecoded(s, this, emsc().allocFuncs.rsa_private_key_decode);
+  }
+
+  static create(bitLen: number, a?: Arena): RsaPrivateKey {
+    const obj = new RsaPrivateKey(a);
+    obj.nativePtr = emsc().allocFuncs.rsa_private_key_create(bitLen);
+    return obj;
+  }
+
+  toCrock() {
+    return this.encode().toCrock();
+  }
+
+
+  getPublicKey(a?: Arena): RsaPublicKey {
+    const obj = new RsaPublicKey(a);
+    obj.nativePtr = emsc().allocFuncs.rsa_private_key_get_public(this.nativePtr);
+    return obj;
+  }
+
+  destroy() {
+    emsc().funcs.rsa_public_key_free(this.nativePtr);
+    this.nativePtr = 0;
+  }
+
+  encode(arena?: Arena): ByteArray {
+    return encode(this, emsc().allocFuncs.rsa_private_key_encode);
+  }
+}
+
+
+/**
  * Low-level handle to an RsaPublicKey.
  */
 export class RsaPublicKey extends MallocArenaObject {
@@ -1470,6 +1520,16 @@ export function eddsaVerify(purposeNum: number,
 }
 
 
+export function rsaVerify(h: HashCode,
+                          sig: RsaSignature,
+                          pub: RsaPublicKey) {
+  const r = emsc().funcs.rsa_verify(h.nativePtr,
+                                    sig.nativePtr,
+                                    pub.nativePtr);
+  return r === GNUNET_OK;
+}
+
+
 /**
  * Unblind a blindly signed value.
  */
@@ -1516,6 +1576,16 @@ export function ecdhEddsa(priv: EcdhePrivateKey,
   return h;
 }
 
+export function rsaSignBlinded(priv: RsaPrivateKey,
+                               msg: ByteArray): RsaSignature {
+  const sig = new RsaSignature();
+  sig.nativePtr = emsc().allocFuncs.rsa_sign_blinded (priv.nativePtr,
+                                                      msg.nativePtr,
+                                                      msg.size());
+  return sig;
+}
+
+
 
 /**
  * Derive a fresh coin from the given seed.  Used during refreshing.