switch to using function calls to determine the size of signatures and key export buffers

John Bland · John Bland · commit eb9d1da3c947 · 2022-08-02T15:54:19.000-04:00
ecc_key_size is a new convenience function that returns the size of the ecc key, it is used in shared_secret to determine the size of the secret buffer

sizeof_ecc_x963 is a new convenience function that returns the size the exported ecc key will be, just calls wc_ecc_export_x963 with NULL and returns the length it gets back

RsaPrivateDerSize is a new convenience function that returns the size the exported private key will be, just calls wc_RsaKeyToDer with NULL

RsaPublicDerSize is a new convenience function that returns the size the exported public key will be, just calls wc_RsaKeyToPublicDer with NULL
diff --git a/addon/wolfcrypt/ecc.cpp b/addon/wolfcrypt/ecc.cpp
@@ -34,6 +34,14 @@ Napi::Number sizeof_ecc_point(const Napi::CallbackInfo& info)
   return Napi::Number::New( env, sizeof( ecc_point ) );
 }
 
+Napi::Number ecc_key_size(const Napi::CallbackInfo& info)
+{
+  Napi::Env env = info.Env();
+  ecc_key* ecc = (ecc_key*)( info[0].As<Napi::Uint8Array>().Data() );
+
+  return Napi::Number::New( env, ecc->dp->size );
+}
+
 Napi::Number bind_wc_ecc_init(const Napi::CallbackInfo& info)
 {
   int ret;
@@ -60,6 +68,17 @@ Napi::Number bind_wc_ecc_make_key(const Napi::CallbackInfo& info)
   return Napi::Number::New( env, ret );
 }
 
+Napi::Number sizeof_ecc_x963(const Napi::CallbackInfo& info)
+{
+  Napi::Env env = info.Env();
+  ecc_key* ecc = (ecc_key*)( info[0].As<Napi::Uint8Array>().Data() );
+  unsigned int out_len;
+
+  wc_ecc_export_x963( ecc, NULL, &out_len );
+
+  return Napi::Number::New( env, out_len );
+}
+
 Napi::Number bind_wc_ecc_export_x963(const Napi::CallbackInfo& info)
 {
   Napi::Env env = info.Env();
diff --git a/addon/wolfcrypt/h/ecc.h b/addon/wolfcrypt/h/ecc.h
@@ -25,8 +25,10 @@
 
 Napi::Number sizeof_ecc_key(const Napi::CallbackInfo& info);
 Napi::Number sizeof_ecc_point(const Napi::CallbackInfo& info);
+Napi::Number ecc_key_size(const Napi::CallbackInfo& info);
 Napi::Number bind_wc_ecc_init(const Napi::CallbackInfo& info);
 Napi::Number bind_wc_ecc_make_key(const Napi::CallbackInfo& info);
+Napi::Number sizeof_ecc_x963(const Napi::CallbackInfo& info);
 Napi::Number bind_wc_ecc_export_x963(const Napi::CallbackInfo& info);
 Napi::Number bind_wc_ecc_import_x963(const Napi::CallbackInfo& info);
 Napi::Number bind_wc_ecc_set_curve(const Napi::CallbackInfo& info);
diff --git a/addon/wolfcrypt/h/rsa.h b/addon/wolfcrypt/h/rsa.h
@@ -28,7 +28,9 @@ Napi::Number sizeof_RsaKey(const Napi::CallbackInfo& info);
 Napi::Number bind_wc_RsaEncryptSize(const Napi::CallbackInfo& info);
 Napi::Number bind_wc_InitRsaKey(const Napi::CallbackInfo& info);
 Napi::Number bind_wc_MakeRsaKey(const Napi::CallbackInfo& info);
+Napi::Number RsaPrivateDerSize(const Napi::CallbackInfo& info);
 Napi::Number bind_wc_RsaKeyToDer(const Napi::CallbackInfo& info);
+Napi::Number RsaPublicDerSize(const Napi::CallbackInfo& info);
 Napi::Number bind_wc_RsaKeyToPublicDer(const Napi::CallbackInfo& info);
 Napi::Number bind_wc_RsaPrivateKeyDecode(const Napi::CallbackInfo& info);
 Napi::Number bind_wc_RsaPublicKeyDecode(const Napi::CallbackInfo& info);
diff --git a/addon/wolfcrypt/main.cpp b/addon/wolfcrypt/main.cpp
@@ -49,7 +49,9 @@ Napi::Object Init(Napi::Env env, Napi::Object exports)
   exports.Set(Napi::String::New(env, "wc_RsaEncryptSize"), Napi::Function::New(env, bind_wc_RsaEncryptSize));
   exports.Set(Napi::String::New(env, "wc_InitRsaKey"), Napi::Function::New(env, bind_wc_InitRsaKey));
   exports.Set(Napi::String::New(env, "wc_MakeRsaKey"), Napi::Function::New(env, bind_wc_MakeRsaKey));
+  exports.Set(Napi::String::New(env, "RsaPrivateDerSize"), Napi::Function::New(env, RsaPrivateDerSize));
   exports.Set(Napi::String::New(env, "wc_RsaKeyToDer"), Napi::Function::New(env, bind_wc_RsaKeyToDer));
+  exports.Set(Napi::String::New(env, "RsaPublicDerSize"), Napi::Function::New(env, RsaPublicDerSize));
   exports.Set(Napi::String::New(env, "wc_RsaKeyToPublicDer"), Napi::Function::New(env, bind_wc_RsaKeyToPublicDer));
   exports.Set(Napi::String::New(env, "wc_RsaPrivateKeyDecode"), Napi::Function::New(env, bind_wc_RsaPrivateKeyDecode));
   exports.Set(Napi::String::New(env, "wc_RsaPublicKeyDecode"), Napi::Function::New(env, bind_wc_RsaPublicKeyDecode));
@@ -98,8 +100,10 @@ Napi::Object Init(Napi::Env env, Napi::Object exports)
 
   exports.Set(Napi::String::New(env, "sizeof_ecc_key"), Napi::Function::New(env, sizeof_ecc_key));
   exports.Set(Napi::String::New(env, "sizeof_ecc_point"), Napi::Function::New(env, sizeof_ecc_point));
+  exports.Set(Napi::String::New(env, "ecc_key_size"), Napi::Function::New(env, ecc_key_size));
   exports.Set(Napi::String::New(env, "wc_ecc_init"), Napi::Function::New(env, bind_wc_ecc_init));
   exports.Set(Napi::String::New(env, "wc_ecc_make_key"), Napi::Function::New(env, bind_wc_ecc_make_key));
+  exports.Set(Napi::String::New(env, "sizeof_ecc_x963"), Napi::Function::New(env, sizeof_ecc_x963));
   exports.Set(Napi::String::New(env, "wc_ecc_export_x963"), Napi::Function::New(env, bind_wc_ecc_export_x963));
   exports.Set(Napi::String::New(env, "wc_ecc_import_x963"), Napi::Function::New(env, bind_wc_ecc_import_x963));
   exports.Set(Napi::String::New(env, "wc_ecc_set_curve"), Napi::Function::New(env, bind_wc_ecc_set_curve));
diff --git a/addon/wolfcrypt/rsa.cpp b/addon/wolfcrypt/rsa.cpp
@@ -64,6 +64,17 @@ Napi::Number bind_wc_MakeRsaKey(const Napi::CallbackInfo& info)
   return Napi::Number::New( env, ret );
 }
 
+Napi::Number RsaPrivateDerSize(const Napi::CallbackInfo& info)
+{
+  int ret;
+  Napi::Env env = info.Env();
+  RsaKey* rsa = (RsaKey*)( info[0].As<Napi::Uint8Array>().Data() );
+
+  ret = wc_RsaKeyToDer( rsa, NULL, 0 );
+
+  return Napi::Number::New( env, ret );
+}
+
 Napi::Number bind_wc_RsaKeyToDer(const Napi::CallbackInfo& info)
 {
   int ret;
@@ -77,6 +88,17 @@ Napi::Number bind_wc_RsaKeyToDer(const Napi::CallbackInfo& info)
   return Napi::Number::New( env, ret );
 }
 
+Napi::Number RsaPublicDerSize(const Napi::CallbackInfo& info)
+{
+  int ret;
+  Napi::Env env = info.Env();
+  RsaKey* rsa = (RsaKey*)( info[0].As<Napi::Uint8Array>().Data() );
+
+  ret = wc_RsaKeyToPublicDer( rsa, NULL, 0 );
+
+  return Napi::Number::New( env, ret );
+}
+
 Napi::Number bind_wc_RsaKeyToPublicDer(const Napi::CallbackInfo& info)
 {
   int ret;
diff --git a/interfaces/ecc.js b/interfaces/ecc.js
@@ -25,7 +25,6 @@ class WolfSSLEcc
   constructor()
   {
     this.ecc = Buffer.alloc( wolfcrypt.sizeof_ecc_key() )
-    this.size = -1
 
     let ret = wolfcrypt.wc_ecc_init( this.ecc )
 
@@ -48,8 +47,6 @@ class WolfSSLEcc
     {
       throw `Failed to wc_ecc_make_key ${ ret }`
     }
-
-    this.size = size
   }
 
   export_x963()
@@ -59,8 +56,8 @@ class WolfSSLEcc
       throw 'Ecc not allocated'
     }
 
-    // TODO is there a way to know this ahead of time to make sure our asnBuf is big enough
-    let asnBuf = Buffer.alloc( 2048 )
+    // passing null will return the size
+    let asnBuf = Buffer.alloc( wolfcrypt.sizeof_ecc_x963( this.ecc ) )
 
     let ret = wolfcrypt.wc_ecc_export_x963( this.ecc, asnBuf, asnBuf.length )
 
@@ -116,11 +113,18 @@ class WolfSSLEcc
       throw 'Ecc not allocated'
     }
 
-    let secret = Buffer.alloc( this.size )
+    const keySize = wolfcrypt.ecc_key_size( this.ecc )
+
+    if ( keySize <= 0 )
+    {
+      throw `Failed to ecc_key_size ${ keySize }`
+    }
+
+    let secret = Buffer.alloc( keySize )
 
-    let ret = wolfcrypt.wc_ecc_shared_secret( this.ecc, pubEcc.ecc, secret, this.size )
+    let ret = wolfcrypt.wc_ecc_shared_secret( this.ecc, pubEcc.ecc, secret, keySize )
 
-    if ( ret != this.size )
+    if ( ret != keySize )
     {
       throw `Failed to wc_ecc_shared_secret ${ ret }`
     }
diff --git a/interfaces/rsa.js b/interfaces/rsa.js
@@ -25,14 +25,11 @@ class WolfSSLRsa
   constructor()
   {
     this.rsa = Buffer.alloc( wolfcrypt.sizeof_RsaKey() )
-    this.size = -1
     wolfcrypt.wc_InitRsaKey( this.rsa )
   }
 
   MakeRsaKey( size, e )
   {
-    this.size = size
-
     let ret = wolfcrypt.wc_MakeRsaKey( this.rsa, size, e )
 
     if ( ret != 0 )
@@ -43,15 +40,14 @@ class WolfSSLRsa
 
   KeyToDer()
   {
-    if ( this.size == -1 || this.rsa == null )
+    if ( this.rsa == null )
     {
       throw 'Invalid rsa key'
     }
 
-    // TODO is there a way to know this ahead of time or shrink afterwards?
-    let derBuf = Buffer.alloc( this.size )
+    let derBuf = Buffer.alloc( wolfcrypt.RsaPrivateDerSize( this.rsa ) )
 
-    let ret = wolfcrypt.wc_RsaKeyToDer( this.rsa, derBuf, this.size )
+    let ret = wolfcrypt.wc_RsaKeyToDer( this.rsa, derBuf, derBuf.length )
 
     if ( ret <= 0 )
     {
@@ -63,13 +59,12 @@ class WolfSSLRsa
 
   KeyToPublicDer()
   {
-    if ( this.size == -1 || this.rsa == null )
+    if ( this.rsa == null )
     {
       throw 'Invalid rsa key'
     }
 
-    // TODO is there a way to know this ahead of time or shrink afterwards?
-    let derBuf = Buffer.alloc( this.size )
+    let derBuf = Buffer.alloc( wolfcrypt.RsaPublicDerSize( this.rsa ) )
 
     let ret = wolfcrypt.wc_RsaKeyToPublicDer( this.rsa, derBuf, derBuf.length )
 
@@ -81,7 +76,7 @@ class WolfSSLRsa
     return derBuf
   }
 
-  PrivateKeyDecode( derBuf, size )
+  PrivateKeyDecode( derBuf )
   {
     if ( this.rsa == null )
     {
@@ -99,25 +94,26 @@ class WolfSSLRsa
     {
       throw `Failed to wc_RsaPrivateKeyDecode ${ ret }`
     }
-
-    this.size = size
   }
 
-  PublicKeyDecode( derBuf, size )
+  PublicKeyDecode( derBuf )
   {
     if ( this.rsa == null )
     {
       throw 'Invalid rsa key'
     }
 
+    if ( !Buffer.isBuffer( derBuf ) )
+    {
+      throw 'Public key der must be Buffer'
+    }
+
     let ret = wolfcrypt.wc_RsaPublicKeyDecode( derBuf, this.rsa, derBuf.length )
 
     if ( ret != 0 )
     {
       throw `Failed to wc_RsaPublicKeyDecode ${ ret }`
     }
-
-    this.size = size
   }
 
   PublicEncrypt( data )
@@ -184,7 +180,7 @@ class WolfSSLRsa
       data = Buffer.from( data )
     }
 
-    let sig = Buffer.alloc( this.size / 8 )
+    let sig = Buffer.alloc( wolfcrypt.wc_RsaEncryptSize( this.rsa ) )
 
     let ret = wolfcrypt.wc_RsaSSL_Sign( data, data.length, sig, sig.length, this.rsa )
 
diff --git a/tests/rsa.js b/tests/rsa.js
@@ -46,7 +46,7 @@ const rsa_tests =
   {
     let rsa = new WolfSSLRsa()
 
-    rsa.PrivateKeyDecode( Buffer.from( privateDerHex, 'hex' ), 2048 )
+    rsa.PrivateKeyDecode( Buffer.from( privateDerHex, 'hex' ) )
 
     const derHex = rsa.KeyToPublicDer().toString( 'hex' )
 
@@ -59,7 +59,7 @@ const rsa_tests =
   {
     let rsa = new WolfSSLRsa()
 
-    rsa.PrivateKeyDecode( Buffer.from( privateDerHex, 'hex' ), 2048 )
+    rsa.PrivateKeyDecode( Buffer.from( privateDerHex, 'hex' ) )
 
     const sigHex = rsa.SSL_Sign( message ).toString( 'hex' )
 
@@ -79,7 +79,7 @@ const rsa_tests =
   {
     let rsa = new WolfSSLRsa()
 
-    rsa.PublicKeyDecode( Buffer.from( publicDerHex, 'hex' ), 2048 )
+    rsa.PublicKeyDecode( Buffer.from( publicDerHex, 'hex' ) )
 
     if ( rsa.SSL_Verify( Buffer.from( rsaSigHex, 'hex' ), message ) )
     {
@@ -97,7 +97,7 @@ const rsa_tests =
   {
     let rsa = new WolfSSLRsa()
 
-    rsa.PrivateKeyDecode( Buffer.from( privateDerHex, 'hex' ), 2048 )
+    rsa.PrivateKeyDecode( Buffer.from( privateDerHex, 'hex' ) )
 
     const ciphertext = rsa.PublicEncrypt( message )
     const plaintext = rsa.PrivateDecrypt( ciphertext ).toString()
@@ -118,7 +118,7 @@ const rsa_tests =
   {
     let rsa = new WolfSSLRsa()
 
-    rsa.PrivateKeyDecode( Buffer.from( privateDerHex, 'hex' ), 2048 )
+    rsa.PrivateKeyDecode( Buffer.from( privateDerHex, 'hex' ) )
 
     const sig = rsa.SSL_Sign( message )
 

Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,6 @@ class WolfSSLEcc`
`25`	`25`	`constructor()`
`26`	`26`	`{`
`27`	`27`	`this.ecc = Buffer.alloc( wolfcrypt.sizeof_ecc_key() )`
`28`		`- this.size = -1`
`29`	`28`
`30`	`29`	`let ret = wolfcrypt.wc_ecc_init( this.ecc )`
`31`	`30`
`@@ -48,8 +47,6 @@ class WolfSSLEcc`
`48`	`47`	`{`
`49`	`48`	throw `Failed to wc_ecc_make_key ${ ret }`
`50`	`49`	`}`
`51`		`-`
`52`		`- this.size = size`
`53`	`50`	`}`
`54`	`51`
`55`	`52`	`export_x963()`
`@@ -59,8 +56,8 @@ class WolfSSLEcc`
`59`	`56`	`throw 'Ecc not allocated'`
`60`	`57`	`}`
`61`	`58`
`62`		`- // TODO is there a way to know this ahead of time to make sure our asnBuf is big enough`
`63`		`- let asnBuf = Buffer.alloc( 2048 )`
	`59`	`+ // passing null will return the size`
	`60`	`+ let asnBuf = Buffer.alloc( wolfcrypt.sizeof_ecc_x963( this.ecc ) )`
`64`	`61`
`65`	`62`	`let ret = wolfcrypt.wc_ecc_export_x963( this.ecc, asnBuf, asnBuf.length )`
`66`	`63`
`@@ -116,11 +113,18 @@ class WolfSSLEcc`
`116`	`113`	`throw 'Ecc not allocated'`
`117`	`114`	`}`
`118`	`115`
`119`		`- let secret = Buffer.alloc( this.size )`
	`116`	`+ const keySize = wolfcrypt.ecc_key_size( this.ecc )`
	`117`	`+`
	`118`	`+ if ( keySize <= 0 )`
	`119`	`+ {`
	`120`	+ throw `Failed to ecc_key_size ${ keySize }`
	`121`	`+ }`
	`122`	`+`
	`123`	`+ let secret = Buffer.alloc( keySize )`
`120`	`124`
`121`		`- let ret = wolfcrypt.wc_ecc_shared_secret( this.ecc, pubEcc.ecc, secret, this.size )`
	`125`	`+ let ret = wolfcrypt.wc_ecc_shared_secret( this.ecc, pubEcc.ecc, secret, keySize )`
`122`	`126`
`123`		`- if ( ret != this.size )`
	`127`	`+ if ( ret != keySize )`
`124`	`128`	`{`
`125`	`129`	throw `Failed to wc_ecc_shared_secret ${ ret }`
`126`	`130`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,14 +25,11 @@ class WolfSSLRsa`
`25`	`25`	`constructor()`
`26`	`26`	`{`
`27`	`27`	`this.rsa = Buffer.alloc( wolfcrypt.sizeof_RsaKey() )`
`28`		`- this.size = -1`
`29`	`28`	`wolfcrypt.wc_InitRsaKey( this.rsa )`
`30`	`29`	`}`
`31`	`30`
`32`	`31`	`MakeRsaKey( size, e )`
`33`	`32`	`{`
`34`		`- this.size = size`
`35`		`-`
`36`	`33`	`let ret = wolfcrypt.wc_MakeRsaKey( this.rsa, size, e )`
`37`	`34`
`38`	`35`	`if ( ret != 0 )`
`@@ -43,15 +40,14 @@ class WolfSSLRsa`
`43`	`40`
`44`	`41`	`KeyToDer()`
`45`	`42`	`{`
`46`		`- if ( this.size == -1 \|\| this.rsa == null )`
	`43`	`+ if ( this.rsa == null )`
`47`	`44`	`{`
`48`	`45`	`throw 'Invalid rsa key'`
`49`	`46`	`}`
`50`	`47`
`51`		`- // TODO is there a way to know this ahead of time or shrink afterwards?`
`52`		`- let derBuf = Buffer.alloc( this.size )`
	`48`	`+ let derBuf = Buffer.alloc( wolfcrypt.RsaPrivateDerSize( this.rsa ) )`
`53`	`49`
`54`		`- let ret = wolfcrypt.wc_RsaKeyToDer( this.rsa, derBuf, this.size )`
	`50`	`+ let ret = wolfcrypt.wc_RsaKeyToDer( this.rsa, derBuf, derBuf.length )`
`55`	`51`
`56`	`52`	`if ( ret <= 0 )`
`57`	`53`	`{`
`@@ -63,13 +59,12 @@ class WolfSSLRsa`
`63`	`59`
`64`	`60`	`KeyToPublicDer()`
`65`	`61`	`{`
`66`		`- if ( this.size == -1 \|\| this.rsa == null )`
	`62`	`+ if ( this.rsa == null )`
`67`	`63`	`{`
`68`	`64`	`throw 'Invalid rsa key'`
`69`	`65`	`}`
`70`	`66`
`71`		`- // TODO is there a way to know this ahead of time or shrink afterwards?`
`72`		`- let derBuf = Buffer.alloc( this.size )`
	`67`	`+ let derBuf = Buffer.alloc( wolfcrypt.RsaPublicDerSize( this.rsa ) )`
`73`	`68`
`74`	`69`	`let ret = wolfcrypt.wc_RsaKeyToPublicDer( this.rsa, derBuf, derBuf.length )`
`75`	`70`
`@@ -81,7 +76,7 @@ class WolfSSLRsa`
`81`	`76`	`return derBuf`
`82`	`77`	`}`
`83`	`78`
`84`		`- PrivateKeyDecode( derBuf, size )`
	`79`	`+ PrivateKeyDecode( derBuf )`
`85`	`80`	`{`
`86`	`81`	`if ( this.rsa == null )`
`87`	`82`	`{`
`@@ -99,25 +94,26 @@ class WolfSSLRsa`
`99`	`94`	`{`
`100`	`95`	throw `Failed to wc_RsaPrivateKeyDecode ${ ret }`
`101`	`96`	`}`
`102`		`-`
`103`		`- this.size = size`
`104`	`97`	`}`
`105`	`98`
`106`		`- PublicKeyDecode( derBuf, size )`
	`99`	`+ PublicKeyDecode( derBuf )`
`107`	`100`	`{`
`108`	`101`	`if ( this.rsa == null )`
`109`	`102`	`{`
`110`	`103`	`throw 'Invalid rsa key'`
`111`	`104`	`}`
`112`	`105`
	`106`	`+ if ( !Buffer.isBuffer( derBuf ) )`
	`107`	`+ {`
	`108`	`+ throw 'Public key der must be Buffer'`
	`109`	`+ }`
	`110`	`+`
`113`	`111`	`let ret = wolfcrypt.wc_RsaPublicKeyDecode( derBuf, this.rsa, derBuf.length )`
`114`	`112`
`115`	`113`	`if ( ret != 0 )`
`116`	`114`	`{`
`117`	`115`	throw `Failed to wc_RsaPublicKeyDecode ${ ret }`
`118`	`116`	`}`
`119`		`-`
`120`		`- this.size = size`
`121`	`117`	`}`
`122`	`118`
`123`	`119`	`PublicEncrypt( data )`
`@@ -184,7 +180,7 @@ class WolfSSLRsa`
`184`	`180`	`data = Buffer.from( data )`
`185`	`181`	`}`
`186`	`182`
`187`		`- let sig = Buffer.alloc( this.size / 8 )`
	`183`	`+ let sig = Buffer.alloc( wolfcrypt.wc_RsaEncryptSize( this.rsa ) )`
`188`	`184`
`189`	`185`	`let ret = wolfcrypt.wc_RsaSSL_Sign( data, data.length, sig, sig.length, this.rsa )`
`190`	`186`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ const rsa_tests =`
`46`	`46`	`{`
`47`	`47`	`let rsa = new WolfSSLRsa()`
`48`	`48`
`49`		`- rsa.PrivateKeyDecode( Buffer.from( privateDerHex, 'hex' ), 2048 )`
	`49`	`+ rsa.PrivateKeyDecode( Buffer.from( privateDerHex, 'hex' ) )`
`50`	`50`
`51`	`51`	`const derHex = rsa.KeyToPublicDer().toString( 'hex' )`
`52`	`52`
`@@ -59,7 +59,7 @@ const rsa_tests =`
`59`	`59`	`{`
`60`	`60`	`let rsa = new WolfSSLRsa()`
`61`	`61`
`62`		`- rsa.PrivateKeyDecode( Buffer.from( privateDerHex, 'hex' ), 2048 )`
	`62`	`+ rsa.PrivateKeyDecode( Buffer.from( privateDerHex, 'hex' ) )`
`63`	`63`
`64`	`64`	`const sigHex = rsa.SSL_Sign( message ).toString( 'hex' )`
`65`	`65`
`@@ -79,7 +79,7 @@ const rsa_tests =`
`79`	`79`	`{`
`80`	`80`	`let rsa = new WolfSSLRsa()`
`81`	`81`
`82`		`- rsa.PublicKeyDecode( Buffer.from( publicDerHex, 'hex' ), 2048 )`
	`82`	`+ rsa.PublicKeyDecode( Buffer.from( publicDerHex, 'hex' ) )`
`83`	`83`
`84`	`84`	`if ( rsa.SSL_Verify( Buffer.from( rsaSigHex, 'hex' ), message ) )`
`85`	`85`	`{`
`@@ -97,7 +97,7 @@ const rsa_tests =`
`97`	`97`	`{`
`98`	`98`	`let rsa = new WolfSSLRsa()`
`99`	`99`
`100`		`- rsa.PrivateKeyDecode( Buffer.from( privateDerHex, 'hex' ), 2048 )`
	`100`	`+ rsa.PrivateKeyDecode( Buffer.from( privateDerHex, 'hex' ) )`
`101`	`101`
`102`	`102`	`const ciphertext = rsa.PublicEncrypt( message )`
`103`	`103`	`const plaintext = rsa.PrivateDecrypt( ciphertext ).toString()`
`@@ -118,7 +118,7 @@ const rsa_tests =`
`118`	`118`	`{`
`119`	`119`	`let rsa = new WolfSSLRsa()`
`120`	`120`
`121`		`- rsa.PrivateKeyDecode( Buffer.from( privateDerHex, 'hex' ), 2048 )`
	`121`	`+ rsa.PrivateKeyDecode( Buffer.from( privateDerHex, 'hex' ) )`
`122`	`122`
`123`	`123`	`const sig = rsa.SSL_Sign( message )`
`124`	`124`