From 361463a2ff10bd3e536e34ee816b397c23dca6f7 Mon Sep 17 00:00:00 2001 From: Florian Dold Date: Sat, 22 Sep 2018 17:18:25 +0200 Subject: wasm --- src/crypto/cryptoWorker.ts | 76 +++++++++++++++++++++++++++++++++++++++++++++ src/crypto/emscInterface.ts | 72 +++++++++++++++++++++++++++++++++++++++++- 2 files changed, 147 insertions(+), 1 deletion(-) (limited to 'src/crypto') 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"]), }; @@ -1357,6 +1371,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. */ @@ -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. -- cgit v1.2.3