Verify that the imported keys match

Signed-off-by: Steffen Jaeckel <[email protected]>

tests/common.h

@@ -6,6 +6,21 @@
 #include <tomcrypt.h>
 
 extern prng_state yarrow_prng;
+#if defined(LTC_MDSA)
+extern const unsigned char ltc_dsa_private_test_key[];
+extern const unsigned long ltc_dsa_private_test_key_sz;
+int dsa_key_cmp(const int should_type, const dsa_key *should, const dsa_key *is);
+#endif
+#if defined(LTC_MRSA)
+extern const unsigned char ltc_rsa_private_test_key[];
+extern const unsigned long ltc_rsa_private_test_key_sz;
+int rsa_key_cmp(const int should_type, const rsa_key *should, const rsa_key *is);
+#endif
+#if defined(LTC_MECC)
+extern const unsigned char ltc_ecc_long_pri_test_key[];
+extern const unsigned long ltc_ecc_long_pri_test_key_sz;
+int ecc_key_cmp(const int should_type, const ecc_key *should, const ecc_key *is);
+#endif
 
 #ifdef LTC_VERBOSE
 #define DO(x) do { fprintf(stderr, "%s:\n", #x); run_cmd((x), __LINE__, __FILE__, #x, NULL); } while (0)

tests/dsa_test.c

@@ -5,7 +5,7 @@
 #if defined(LTC_MDSA)
 
 /* This is the private key from test_dsa.key */
-static const unsigned char openssl_priv_dsa[] = {
+const unsigned char ltc_dsa_private_test_key[] = {
   0x30, 0x82, 0x01, 0xbb, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xc5,
   0x0a, 0x37, 0x51, 0x5c, 0xab, 0xd6, 0x18, 0xd5, 0xa2, 0x70, 0xbd, 0x4a,
   0x6f, 0x6b, 0x4a, 0xf9, 0xe1, 0x39, 0x95, 0x0f, 0x2b, 0x99, 0x38, 0x7d,
@@ -45,6 +45,7 @@ static const unsigned char openssl_priv_dsa[] = {
   0xfb, 0x28, 0xbe, 0x91, 0xf5, 0x06, 0x5f, 0xe8, 0xc9, 0x35, 0xb3, 0xf5,
   0xd8, 0x1f, 0xc5
 };
+const unsigned long ltc_dsa_private_test_key_sz = sizeof(ltc_dsa_private_test_key);
 
 /* private key - raw hexadecimal numbers */
 static const char *hex_g = "3B92E4FF5929150B08995A7BF2AD1440556FA047FF9099B344B3D4FC451505AE6722439CBA3710A5894737ECCCF5AEADA8B47A35CB9D935CEDE6B07E9694C4A60C7DD6708A094F814A0EC213FBEB16BFEAA4F456FF723005DE8A443FBEC6852655D62D1D1EDB15DAA445833C1797980B8D87F3490D90BDA9AB676E87687223DC";
@@ -123,6 +124,20 @@ static unsigned char dsaparam_der[] = {
  };
 
 
+int dsa_key_cmp(const int should_type, const dsa_key *should, const dsa_key *is)
+{
+   if (should_type != is->type)                               return CRYPT_ERROR;
+   if (should_type == PK_PRIVATE) {
+      if (mp_cmp(should->x, is->x) != LTC_MP_EQ)              return CRYPT_ERROR;
+   }
+   if (mp_cmp(should->y, is->y) != LTC_MP_EQ)                 return CRYPT_ERROR;
+   if (mp_cmp(should->g, is->g) != LTC_MP_EQ)                 return CRYPT_ERROR;
+   if (mp_cmp(should->p, is->p) != LTC_MP_EQ)                 return CRYPT_ERROR;
+   if (mp_cmp(should->q, is->q) != LTC_MP_EQ)                 return CRYPT_ERROR;
+   if (should->qord != is->qord)                              return CRYPT_ERROR;
+   return CRYPT_OK;
+}
+
 static int s_dsa_compat_test(void)
 {
   dsa_key key;
@@ -132,11 +147,11 @@ static int s_dsa_compat_test(void)
   unsigned long key_lens[5];
   int stat;
 
-  DO(dsa_import(openssl_priv_dsa, sizeof(openssl_priv_dsa), &key));
+  DO(dsa_import(ltc_dsa_private_test_key, sizeof(ltc_dsa_private_test_key), &key));
 
   x = sizeof(tmp);
   DO(dsa_export(tmp, &x, PK_PRIVATE | PK_STD, &key));
-  DO(do_compare_testvector(tmp, x, openssl_priv_dsa, sizeof(openssl_priv_dsa),
+  DO(do_compare_testvector(tmp, x, ltc_dsa_private_test_key, sizeof(ltc_dsa_private_test_key),
                          "DSA private export failed from dsa_import(priv_key)\n", __LINE__));
 
   x = sizeof(tmp);
@@ -172,7 +187,7 @@ static int s_dsa_compat_test(void)
                  &key));
   len = sizeof(buf);
   DO(dsa_export(buf, &len, PK_PRIVATE | PK_STD, &key));
-  DO(do_compare_testvector(buf, len, openssl_priv_dsa, sizeof(openssl_priv_dsa),
+  DO(do_compare_testvector(buf, len, ltc_dsa_private_test_key, sizeof(ltc_dsa_private_test_key),
                          "DSA private export failed from dsa_set_pqg() & dsa_set_key()\n", __LINE__));
   dsa_free(&key);
 
@@ -219,7 +234,7 @@ static int s_dsa_compat_test(void)
                  &key));
   len = sizeof(buf);
   DO(dsa_export(buf, &len, PK_PRIVATE | PK_STD, &key));
-  DO(do_compare_testvector(buf, len, openssl_priv_dsa, sizeof(openssl_priv_dsa),
+  DO(do_compare_testvector(buf, len, ltc_dsa_private_test_key, sizeof(ltc_dsa_private_test_key),
                          "DSA private export failed from dsa_set_pqg_dsaparam()\n", __LINE__));
   dsa_free(&key);
 

tests/ecc_test.c

@@ -4,6 +4,28 @@
 
 #if defined(LTC_MECC)
 
+const unsigned char ltc_ecc_long_pri_test_key[] = { /* private + long public, explicit curve params */
+   0x30, 0x82, 0x01, 0x13, 0x02, 0x01, 0x01, 0x04, 0x20, 0x0c, 0xf1, 0xad, 0x2f, 0x03, 0xf7, 0x91,
+   0x1b, 0xba, 0x03, 0xcf, 0x23, 0x37, 0xc8, 0xf2, 0xf7, 0x36, 0xce, 0x65, 0xf1, 0x84, 0x2d, 0x7d,
+   0x9f, 0x5f, 0x9e, 0x21, 0xd9, 0x5e, 0x49, 0xbd, 0x23, 0xa0, 0x81, 0xa5, 0x30, 0x81, 0xa2, 0x02,
+   0x01, 0x01, 0x30, 0x2c, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x01, 0x01, 0x02, 0x21, 0x00,
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2f,
+   0x30, 0x06, 0x04, 0x01, 0x00, 0x04, 0x01, 0x07, 0x04, 0x41, 0x04, 0x79, 0xbe, 0x66, 0x7e, 0xf9,
+   0xdc, 0xbb, 0xac, 0x55, 0xa0, 0x62, 0x95, 0xce, 0x87, 0x0b, 0x07, 0x02, 0x9b, 0xfc, 0xdb, 0x2d,
+   0xce, 0x28, 0xd9, 0x59, 0xf2, 0x81, 0x5b, 0x16, 0xf8, 0x17, 0x98, 0x48, 0x3a, 0xda, 0x77, 0x26,
+   0xa3, 0xc4, 0x65, 0x5d, 0xa4, 0xfb, 0xfc, 0x0e, 0x11, 0x08, 0xa8, 0xfd, 0x17, 0xb4, 0x48, 0xa6,
+   0x85, 0x54, 0x19, 0x9c, 0x47, 0xd0, 0x8f, 0xfb, 0x10, 0xd4, 0xb8, 0x02, 0x21, 0x00, 0xff, 0xff,
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xba, 0xae,
+   0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b, 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x41, 0x02, 0x01,
+   0x01, 0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0x2a, 0xf9, 0x0b, 0xda, 0xbe, 0x71, 0x66, 0x9e, 0xd1,
+   0xcf, 0x12, 0xd0, 0x24, 0xaf, 0xba, 0xb6, 0x7f, 0xfb, 0x96, 0x27, 0x3e, 0x2f, 0xbd, 0x1e, 0xd5,
+   0xf9, 0x8d, 0x6c, 0x73, 0x9d, 0xc5, 0x16, 0x91, 0xbd, 0xb2, 0xb9, 0x1b, 0x40, 0x10, 0x5a, 0xb7,
+   0x6c, 0x6e, 0x32, 0x5b, 0xf7, 0x63, 0x62, 0x94, 0x24, 0x24, 0xdb, 0xec, 0x3f, 0x8b, 0xe5, 0x6e,
+   0x4b, 0x64, 0x37, 0x31, 0x24, 0x79, 0x4d
+};
+const unsigned long ltc_ecc_long_pri_test_key_sz = sizeof(ltc_ecc_long_pri_test_key);
+
 static unsigned int sizes[] = {
 #ifdef LTC_ECC_SECP112R1
 14,
@@ -506,7 +528,7 @@ static int s_ecc_old_api(void)
    return CRYPT_OK;
 }
 
-static int s_ecc_key_cmp(const int should_type, const ecc_key *should, const ecc_key *is)
+int ecc_key_cmp(const int should_type, const ecc_key *should, const ecc_key *is)
 {
    if (should_type != is->type)                               return CRYPT_ERROR;
    if (should_type == PK_PRIVATE) {
@@ -613,7 +635,7 @@ static int s_ecc_new_api(void)
          for (j = 0; j < 2*(1+(int)privkey.dp.cofactor); j++) {
             stat = ecc_recover_key(buf, len, data16, 16, j, LTC_ECCSIG_ANSIX962, &reckey);
             if (stat != CRYPT_OK) continue; /* last two will almost always fail, only possible if x<(prime mod order) */
-            stat = s_ecc_key_cmp(PK_PUBLIC, &pubkey, &reckey);
+            stat = ecc_key_cmp(PK_PUBLIC, &pubkey, &reckey);
             if (stat == CRYPT_OK) found++;
          }
          if (found != 1) return CRYPT_FAIL_TESTVECTOR; /* unique match */
@@ -676,39 +698,20 @@ static int s_ecc_import_export(void) {
         # password protected - PBES1
         openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in long_pri.der -v1 PBE-MD2-DES     -out long_pri_pkcs8_pbe_md2_des.der
         openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in long_pri.der -v1 PBE-MD2-RC2-64  -out long_pri_pkcs8_pbe_md2_rc2_64.der
-        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in long_pri.der -v1 PBE-MD5-DES     -out long_pri_pkcs8_pbe_md5_des.der
-        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in long_pri.der -v1 PBE-SHA1-RC2-64 -out long_pri_pkcs8_pbe_sha1_rc2_64.der
-        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in long_pri.der -v1 PBE-MD5-RC2-64  -out long_pri_pkcs8_pbe_md5_rc2_64.der
-        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in long_pri.der -v1 PBE-SHA1-DES    -out long_pri_pkcs8_pbe_sha1_des.der
+        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v1 PBE-MD5-DES     -out long_pri_pkcs8_pbe_md5_des.der
+        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v1 PBE-SHA1-RC2-64 -out long_pri_pkcs8_pbe_sha1_rc2_64.der
+        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v1 PBE-MD5-RC2-64  -out long_pri_pkcs8_pbe_md5_rc2_64.der
+        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v1 PBE-SHA1-DES    -out long_pri_pkcs8_pbe_sha1_des.der
         # password protected - PBES2
-        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in long_pri.der -v2 rc2  -out long_pri_pkcs8_pbkdf2_rc2_cbc.der
-        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in long_pri.der -v2 des  -out long_pri_pkcs8_pbkdf2_des_cbc.der
-        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in long_pri.der -v2 des3 -out long_pri_pkcs8_pbkdf2_des_ede3_cbc.der
-        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in long_pri.der -v2 des3 -v2prf hmacWithSHA224 -out long_pri_pkcs8_pbkdf2_sha224_des_ede3_cbc.der
-        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in long_pri.der -v2 des3 -v2prf hmacWithSHA256 -out long_pri_pkcs8_pbkdf2_sha256_des_ede3_cbc.der
-        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in long_pri.der -v2 des3 -v2prf hmacWithSHA384 -out long_pri_pkcs8_pbkdf2_sha384_des_ede3_cbc.der
-        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in long_pri.der -v2 des3 -v2prf hmacWithSHA512 -out long_pri_pkcs8_pbkdf2_sha512_des_ede3_cbc.der
+        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v2 rc2  -out long_pri_pkcs8_pbkdf2_rc2_cbc.der
+        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v2 des  -out long_pri_pkcs8_pbkdf2_des_cbc.der
+        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v2 des3 -out long_pri_pkcs8_pbkdf2_des_ede3_cbc.der
+        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v2 des3 -v2prf hmacWithSHA224 -out long_pri_pkcs8_pbkdf2_sha224_des_ede3_cbc.der
+        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v2 des3 -v2prf hmacWithSHA256 -out long_pri_pkcs8_pbkdf2_sha256_des_ede3_cbc.der
+        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v2 des3 -v2prf hmacWithSHA384 -out long_pri_pkcs8_pbkdf2_sha384_des_ede3_cbc.der
+        openssl pkcs8 -topk8 -inform DER -outform DER -passout pass:secret -in ltc_ecc_long_pri_test_key.der -v2 des3 -v2prf hmacWithSHA512 -out long_pri_pkcs8_pbkdf2_sha512_des_ede3_cbc.der
     */
-   static const unsigned char long_pri[] = { /* private + long public, explicit curve params */
-      0x30, 0x82, 0x01, 0x13, 0x02, 0x01, 0x01, 0x04, 0x20, 0x0c, 0xf1, 0xad, 0x2f, 0x03, 0xf7, 0x91,
-      0x1b, 0xba, 0x03, 0xcf, 0x23, 0x37, 0xc8, 0xf2, 0xf7, 0x36, 0xce, 0x65, 0xf1, 0x84, 0x2d, 0x7d,
-      0x9f, 0x5f, 0x9e, 0x21, 0xd9, 0x5e, 0x49, 0xbd, 0x23, 0xa0, 0x81, 0xa5, 0x30, 0x81, 0xa2, 0x02,
-      0x01, 0x01, 0x30, 0x2c, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x01, 0x01, 0x02, 0x21, 0x00,
-      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2f,
-      0x30, 0x06, 0x04, 0x01, 0x00, 0x04, 0x01, 0x07, 0x04, 0x41, 0x04, 0x79, 0xbe, 0x66, 0x7e, 0xf9,
-      0xdc, 0xbb, 0xac, 0x55, 0xa0, 0x62, 0x95, 0xce, 0x87, 0x0b, 0x07, 0x02, 0x9b, 0xfc, 0xdb, 0x2d,
-      0xce, 0x28, 0xd9, 0x59, 0xf2, 0x81, 0x5b, 0x16, 0xf8, 0x17, 0x98, 0x48, 0x3a, 0xda, 0x77, 0x26,
-      0xa3, 0xc4, 0x65, 0x5d, 0xa4, 0xfb, 0xfc, 0x0e, 0x11, 0x08, 0xa8, 0xfd, 0x17, 0xb4, 0x48, 0xa6,
-      0x85, 0x54, 0x19, 0x9c, 0x47, 0xd0, 0x8f, 0xfb, 0x10, 0xd4, 0xb8, 0x02, 0x21, 0x00, 0xff, 0xff,
-      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xba, 0xae,
-      0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b, 0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x41, 0x02, 0x01,
-      0x01, 0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0x2a, 0xf9, 0x0b, 0xda, 0xbe, 0x71, 0x66, 0x9e, 0xd1,
-      0xcf, 0x12, 0xd0, 0x24, 0xaf, 0xba, 0xb6, 0x7f, 0xfb, 0x96, 0x27, 0x3e, 0x2f, 0xbd, 0x1e, 0xd5,
-      0xf9, 0x8d, 0x6c, 0x73, 0x9d, 0xc5, 0x16, 0x91, 0xbd, 0xb2, 0xb9, 0x1b, 0x40, 0x10, 0x5a, 0xb7,
-      0x6c, 0x6e, 0x32, 0x5b, 0xf7, 0x63, 0x62, 0x94, 0x24, 0x24, 0xdb, 0xec, 0x3f, 0x8b, 0xe5, 0x6e,
-      0x4b, 0x64, 0x37, 0x31, 0x24, 0x79, 0x4d
-   };
+   /* static const unsigned char ltc_ecc_long_pri_test_key[] defined globally */
    static const unsigned char long_pri_pkcs8[] = { /* private + long public, explicit curve params, PKCS8 */
       0x30, 0x82, 0x01, 0x23, 0x02, 0x01, 0x00, 0x30, 0x81, 0xae, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce,
       0x3d, 0x02, 0x01, 0x30, 0x81, 0xa2, 0x02, 0x01, 0x01, 0x30, 0x2c, 0x06, 0x07, 0x2a, 0x86, 0x48,
@@ -1338,144 +1341,144 @@ static int s_ecc_import_export(void) {
    /* import - raw keys */
    DO(ecc_set_curve(cu, &key));
    DO(ecc_set_key(raw_pri, sizeof(raw_pri),  PK_PRIVATE, &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
    DO(ecc_set_curve(cu, &key));
    DO(ecc_set_key(raw_pub, sizeof(raw_pub),  PK_PUBLIC,  &key));
-   DO(s_ecc_key_cmp(PK_PUBLIC, &pub, &key));
+   DO(ecc_key_cmp(PK_PUBLIC, &pub, &key));
    ecc_free(&key);
    DO(ecc_set_curve(cu, &key));
    DO(ecc_set_key(raw_pubc, sizeof(raw_pubc), PK_PUBLIC,  &key));
-   DO(s_ecc_key_cmp(PK_PUBLIC, &pub, &key));
+   DO(ecc_key_cmp(PK_PUBLIC, &pub, &key));
    ecc_free(&key);
 
    /* import - openssl compatible DER format */
-   DO(ecc_import_openssl(long_pri, sizeof(long_pri),   &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_import_openssl(ltc_ecc_long_pri_test_key, sizeof(ltc_ecc_long_pri_test_key),   &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
    DO(ecc_import_openssl(long_pric, sizeof(long_pric),  &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
    DO(ecc_import_openssl(long_pub, sizeof(long_pub),   &key));
-   DO(s_ecc_key_cmp(PK_PUBLIC, &pub, &key));
+   DO(ecc_key_cmp(PK_PUBLIC, &pub, &key));
    ecc_free(&key);
    DO(ecc_import_openssl(long_pubc, sizeof(long_pubc),  &key));
-   DO(s_ecc_key_cmp(PK_PUBLIC, &pub, &key));
+   DO(ecc_key_cmp(PK_PUBLIC, &pub, &key));
    ecc_free(&key);
    DO(ecc_import_openssl(short_pri, sizeof(short_pri),  &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
    DO(ecc_import_openssl(short_pric, sizeof(short_pric), &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
    DO(ecc_import_openssl(short_pub, sizeof(short_pub),  &key));
-   DO(s_ecc_key_cmp(PK_PUBLIC, &pub, &key));
+   DO(ecc_key_cmp(PK_PUBLIC, &pub, &key));
    ecc_free(&key);
    DO(ecc_import_openssl(short_pubc, sizeof(short_pubc), &key));
-   DO(s_ecc_key_cmp(PK_PUBLIC, &pub, &key));
+   DO(ecc_key_cmp(PK_PUBLIC, &pub, &key));
    ecc_free(&key);
 
    /* import - private PKCS8 format - no password */
    DO(ecc_import_pkcs8(long_pri_pkcs8, sizeof(long_pri_pkcs8),   NULL, &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
    DO(ecc_import_pkcs8(long_pric_pkcs8, sizeof(long_pric_pkcs8),  NULL, &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
    DO(ecc_import_pkcs8(short_pri_pkcs8, sizeof(short_pri_pkcs8),  NULL, &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
    DO(ecc_import_pkcs8(short_pric_pkcs8, sizeof(short_pric_pkcs8), NULL, &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
 
    /* import - private PKCS8 format - password protected (PBES1 algorithms) */
 #ifdef LTC_MD2
    DO(ecc_import_pkcs8(long_pri_pkcs8_pbe_md2_des, sizeof(long_pri_pkcs8_pbe_md2_des), &pw_ctx, &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
 #endif
 #ifdef LTC_MD5
    DO(ecc_import_pkcs8(long_pri_pkcs8_pbe_md5_des, sizeof(long_pri_pkcs8_pbe_md5_des), &pw_ctx, &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
 #endif
 #ifdef LTC_SHA1
    DO(ecc_import_pkcs8(long_pri_pkcs8_pbe_sha1_des, sizeof(long_pri_pkcs8_pbe_sha1_des), &pw_ctx, &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
 #endif
 #if defined(LTC_RC2) && defined(LTC_MD2)
    DO(ecc_import_pkcs8(long_pri_pkcs8_pbe_md2_rc2_64, sizeof(long_pri_pkcs8_pbe_md2_rc2_64), &pw_ctx, &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
 #endif
 #if defined(LTC_RC2) && defined(LTC_MD5)
    DO(ecc_import_pkcs8(long_pri_pkcs8_pbe_md5_rc2_64, sizeof(long_pri_pkcs8_pbe_md5_rc2_64), &pw_ctx, &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
 #endif
 #if defined(LTC_RC2) && defined(LTC_SHA1)
    DO(ecc_import_pkcs8(long_pri_pkcs8_pbe_sha1_rc2_64, sizeof(long_pri_pkcs8_pbe_sha1_rc2_64), &pw_ctx, &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
 #endif
 
    /* import - private PKCS8 format - password protected (PBES2 algorithms) */
 #if defined(LTC_RC2)
    DO(ecc_import_pkcs8(long_pri_pkcs8_pbkdf2_rc2_cbc, sizeof(long_pri_pkcs8_pbkdf2_rc2_cbc), &pw_ctx, &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
 #endif
 #if defined(LTC_DES)
    DO(ecc_import_pkcs8(long_pri_pkcs8_pbkdf2_des_cbc, sizeof(long_pri_pkcs8_pbkdf2_des_cbc), &pw_ctx, &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
 #endif
 #if defined(LTC_DES)
    DO(ecc_import_pkcs8(long_pri_pkcs8_pbkdf2_des_ede3_cbc, sizeof(long_pri_pkcs8_pbkdf2_des_ede3_cbc), &pw_ctx, &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
 #endif
 #if defined(LTC_SHA224) && defined(LTC_DES)
    DO(ecc_import_pkcs8(long_pri_pkcs8_pbkdf2_sha224_des_ede3_cbc, sizeof(long_pri_pkcs8_pbkdf2_sha224_des_ede3_cbc), &pw_ctx, &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
 #endif
 #if defined(LTC_SHA256) && defined(LTC_DES)
    DO(ecc_import_pkcs8(long_pri_pkcs8_pbkdf2_sha256_des_ede3_cbc, sizeof(long_pri_pkcs8_pbkdf2_sha256_des_ede3_cbc), &pw_ctx, &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
 #endif
 #if defined(LTC_SHA384) && defined(LTC_DES)
    DO(ecc_import_pkcs8(long_pri_pkcs8_pbkdf2_sha384_des_ede3_cbc, sizeof(long_pri_pkcs8_pbkdf2_sha384_des_ede3_cbc), &pw_ctx, &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
 #endif
 #if defined(LTC_SHA512) && defined(LTC_DES)
    DO(ecc_import_pkcs8(long_pri_pkcs8_pbkdf2_sha512_des_ede3_cbc, sizeof(long_pri_pkcs8_pbkdf2_sha512_des_ede3_cbc), &pw_ctx, &key));
-   DO(s_ecc_key_cmp(PK_PRIVATE, &pri, &key));
+   DO(ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
 #endif
 
    /* import - X.509 EC certificates */
    DO(ecc_import_x509(x509_cert_long,   sizeof(x509_cert_long),   &key));
-   DO(s_ecc_key_cmp(PK_PUBLIC, &pub, &key));
+   DO(ecc_key_cmp(PK_PUBLIC, &pub, &key));
    ecc_free(&key);
    DO(ecc_import_x509(x509_cert_longc,  sizeof(x509_cert_longc),  &key));
-   DO(s_ecc_key_cmp(PK_PUBLIC, &pub, &key));
+   DO(ecc_key_cmp(PK_PUBLIC, &pub, &key));
    ecc_free(&key);
    DO(ecc_import_x509(x509_cert_short,  sizeof(x509_cert_short),  &key));
-   DO(s_ecc_key_cmp(PK_PUBLIC, &pub, &key));
+   DO(ecc_key_cmp(PK_PUBLIC, &pub, &key));
    ecc_free(&key);
    DO(ecc_import_x509(x509_cert_shortc, sizeof(x509_cert_shortc), &key));
-   DO(s_ecc_key_cmp(PK_PUBLIC, &pub, &key));
+   DO(ecc_key_cmp(PK_PUBLIC, &pub, &key));
    ecc_free(&key);
 
    /* export - openssl compatible DER format */
    outlen = sizeof(out);
    DO(ecc_export_openssl(out, &outlen, PK_PRIVATE, &pri));
-   if (compare_testvector(out, outlen, long_pri, sizeof(long_pri),   "e-long_pri",   0)) return CRYPT_ERROR;
+   if (compare_testvector(out, outlen, ltc_ecc_long_pri_test_key, sizeof(ltc_ecc_long_pri_test_key),   "e-ltc_ecc_long_pri_test_key",   0)) return CRYPT_ERROR;
    outlen = sizeof(out);
    DO(ecc_export_openssl(out, &outlen, PK_PRIVATE|PK_COMPRESSED, &pri));
    if (compare_testvector(out, outlen, long_pric, sizeof(long_pric),  "e-long_pric",  0)) return CRYPT_ERROR;
@@ -1554,13 +1557,13 @@ static int s_ecc_test_recovery(void)
    DO(ecc_set_curve(dp, &reckey));
    stat = ecc_recover_key(eth_sig, sizeof(eth_sig)-1, eth_hash, sizeof(eth_hash), 0, LTC_ECCSIG_RFC7518, &reckey);
    if (stat != CRYPT_OK) return CRYPT_FAIL_TESTVECTOR;
-   DO(s_ecc_key_cmp(PK_PUBLIC, &pubkey, &reckey));
+   DO(ecc_key_cmp(PK_PUBLIC, &pubkey, &reckey));
    ecc_free(&reckey);
 
    DO(ecc_set_curve(dp, &reckey));
    stat = ecc_recover_key(eth_sig, sizeof(eth_sig), eth_hash, sizeof(eth_hash), -1, LTC_ECCSIG_ETH27, &reckey);
    if (stat != CRYPT_OK) return CRYPT_FAIL_TESTVECTOR;
-   DO(s_ecc_key_cmp(PK_PUBLIC, &pubkey, &reckey));
+   DO(ecc_key_cmp(PK_PUBLIC, &pubkey, &reckey));
    ecc_free(&reckey);
 
    ecc_free(&pubkey);
@@ -1605,7 +1608,7 @@ static int s_ecc_test_recovery(void)
       DO(ecc_set_curve(dp, &reckey));
       stat = ecc_recover_key(buf, len, data16, 16, recid, LTC_ECCSIG_RFC7518, &reckey);
       if (stat != CRYPT_OK) return CRYPT_FAIL_TESTVECTOR;
-      DO(s_ecc_key_cmp(PK_PUBLIC, &pubkey, &reckey));
+      DO(ecc_key_cmp(PK_PUBLIC, &pubkey, &reckey));
 
       /* cleanup */
       ecc_free(&reckey);

tests/pem_test.c

@@ -12,21 +12,66 @@ static int password_get(void **p, unsigned long *l, void *u)
    return 0;
 }
 
+#if defined(LTC_MDSA)
+static dsa_key s_dsa_key_should;
+#endif
+#if defined(LTC_MRSA)
+static rsa_key s_rsa_key_should;
+#endif
+#if defined(LTC_MECC)
+static ecc_key s_ecc_key_should;
+#endif
+
 static int s_pem_decode_filehandle(const void *in, unsigned long inlen, void *key)
 {
    password_ctx pw_ctx;
+   ltc_pka_key *key_ = key;
+   int err;
    pw_ctx.callback = password_get;
-   return pem_decode(in, inlen, key, &pw_ctx);
+   if ((err = pem_decode(in, inlen, key_, &pw_ctx)) != CRYPT_OK) {
+      return err;
+   }
+   switch (key_->id) {
+      case LTC_PKA_DSA:
+#if defined(LTC_MDSA)
+         return dsa_key_cmp(PK_PRIVATE, &s_dsa_key_should, &key_->u.dsa);
+#endif
+         break;
+      case LTC_PKA_RSA:
+#if defined(LTC_MRSA)
+         return rsa_key_cmp(PK_PRIVATE, &s_rsa_key_should, &key_->u.rsa);
+#endif
+         break;
+      case LTC_PKA_EC:
+#if defined(LTC_MECC)
+         return ecc_key_cmp(PK_PRIVATE, &s_ecc_key_should, &key_->u.ecc);
+#endif
+         break;
+      case LTC_PKA_CURVE25519:
+         return CRYPT_OK;
+      default:
+         return CRYPT_INVALID_ARG;
+   }
+   return CRYPT_INVALID_ARG;
 }
 
 static void s_pem_free_key(ltc_pka_key *key)
 {
    switch (key->id) {
+      case LTC_PKA_DSA:
+#if defined(LTC_MDSA)
+         dsa_free(&key->u.dsa);
+#endif
+         break;
       case LTC_PKA_RSA:
+#if defined(LTC_MRSA)
          rsa_free(&key->u.rsa);
+#endif
          break;
       case LTC_PKA_EC:
+#if defined(LTC_MECC)
          ecc_free(&key->u.ecc);
+#endif
          break;
       default:
          break;
@@ -39,9 +84,30 @@ int pem_test(void)
 
    if (ltc_mp.name == NULL) return CRYPT_NOP;
 
+#if defined(LTC_MDSA)
+   DO(dsa_import(ltc_dsa_private_test_key, ltc_dsa_private_test_key_sz, &s_dsa_key_should));
+#endif
+#if defined(LTC_MRSA)
+   DO(rsa_import(ltc_rsa_private_test_key, ltc_rsa_private_test_key_sz, &s_rsa_key_should));
+#endif
+#if defined(LTC_MECC)
+   DO(ecc_import_openssl(ltc_ecc_long_pri_test_key, ltc_ecc_long_pri_test_key_sz, &s_ecc_key_should));
+#endif
+
+
    DO(test_process_dir("tests/pem", &key, s_pem_decode_filehandle, (dir_cleanup_cb)s_pem_free_key, "pem_test"));
    DO(test_process_dir("tests/pem-ecc-pkcs8", &key, s_pem_decode_filehandle, (dir_cleanup_cb)s_pem_free_key, "pem_test+ecc"));
 
+#if defined(LTC_MDSA)
+   dsa_free(&s_dsa_key_should);
+#endif
+#if defined(LTC_MRSA)
+   rsa_free(&s_rsa_key_should);
+#endif
+#if defined(LTC_MECC)
+   ecc_free(&s_ecc_key_should);
+#endif
+
    return 0;
 }
 

tests/rsa_test.c

@@ -11,7 +11,7 @@
 #endif
 
 /* These are test keys [see file test.key] that I use to test my import/export against */
-static const unsigned char openssl_private_rsa[] = {
+const unsigned char ltc_rsa_private_test_key[] = {
    0x30, 0x82, 0x02, 0x5e, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xcf, 0x9a, 0xde, 0x64, 0x8a,
    0xda, 0xc8, 0x33, 0x20, 0xa9, 0xd7, 0x83, 0x31, 0x19, 0x54, 0xb2, 0x9a, 0x85, 0xa7, 0xa1, 0xb7,
    0x75, 0x33, 0xb6, 0xa9, 0xac, 0x84, 0x24, 0xb3, 0xde, 0xdb, 0x7d, 0x85, 0x2d, 0x96, 0x65, 0xe5,
@@ -52,6 +52,8 @@ static const unsigned char openssl_private_rsa[] = {
    0x78, 0x18, 0x5a, 0x79, 0x3d, 0x2e, 0x8e, 0x7e, 0x86, 0x0a, 0xe6, 0xa8, 0x33, 0xc1, 0x04, 0x17,
    0x4a, 0x9f,  };
 
+const unsigned long ltc_rsa_private_test_key_sz = sizeof(ltc_rsa_private_test_key);
+
 static const char x509_public_rsa[] =
     "MIICdTCCAd4CCQCYjCwz0l9JpjANBgkqhkiG9w0BAQsFADB+MQswCQYDVQQGEwJD\
      WjEPMA0GA1UECAwGTW9yYXZhMQ0wCwYDVQQHDARCcm5vMRAwDgYDVQQKDAdMVEMg\
@@ -184,7 +186,7 @@ static int rsa_compat_test(void)
    unsigned long len, key_lens[8];
 
    /* try reading the key */
-   DO(rsa_import(openssl_private_rsa, sizeof(openssl_private_rsa), &key));
+   DO(rsa_import(ltc_rsa_private_test_key, sizeof(ltc_rsa_private_test_key), &key));
    DO(rsa_import(openssl_public_rsa, sizeof(openssl_public_rsa), &pubkey));
 
    /* sign-verify a message with PKCS #1 v1.5 no ASN.1 */
@@ -205,7 +207,7 @@ static int rsa_compat_test(void)
    /* now try to export private/public and compare */
    len = sizeof(buf);
    DO(rsa_export(buf, &len, PK_PRIVATE, &key));
-   DO(do_compare_testvector(buf, len, openssl_private_rsa, sizeof(openssl_private_rsa), "RSA private export (from OpenSSL)", 0));
+   DO(do_compare_testvector(buf, len, ltc_rsa_private_test_key, sizeof(ltc_rsa_private_test_key), "RSA private export (from OpenSSL)", 0));
 
    len = sizeof(buf);
    DO(rsa_export(buf, &len, PK_PUBLIC, &key));
@@ -230,7 +232,7 @@ static int rsa_compat_test(void)
    DO(rsa_import_pkcs8(pkcs8_private_rsa, sizeof(pkcs8_private_rsa), NULL, &key));
    len = sizeof(buf);
    DO(rsa_export(buf, &len, PK_PRIVATE, &key));
-   DO(do_compare_testvector(buf, len, openssl_private_rsa, sizeof(openssl_private_rsa), "RSA private export (from PKCS#8)", 0));
+   DO(do_compare_testvector(buf, len, ltc_rsa_private_test_key, sizeof(ltc_rsa_private_test_key), "RSA private export (from PKCS#8)", 0));
    rsa_free(&key);
 
    /* convert raw hexadecimal numbers to binary */
@@ -244,7 +246,7 @@ static int rsa_compat_test(void)
    DO(rsa_set_crt_params(key_parts[pk_dP], key_lens[pk_dP], key_parts[pk_dQ], key_lens[pk_dQ], key_parts[pk_qP], key_lens[pk_qP], &key));
    len = sizeof(buf);
    DO(rsa_export(buf, &len, PK_PRIVATE, &key));
-   DO(do_compare_testvector(buf, len, openssl_private_rsa, sizeof(openssl_private_rsa), "RSA private export (from hex)", 0));
+   DO(do_compare_testvector(buf, len, ltc_rsa_private_test_key, sizeof(ltc_rsa_private_test_key), "RSA private export (from hex)", 0));
    rsa_free(&key);
 
    /* try import public key from converted raw hexadecimal numbers */
@@ -264,7 +266,7 @@ static int rsa_compat_test(void)
    return 0;
 }
 
-static int s_rsa_key_cmp(const int should_type, const rsa_key *should, const rsa_key *is)
+int rsa_key_cmp(const int should_type, const rsa_key *should, const rsa_key *is)
 {
    if(should_type != is->type)
       return CRYPT_ERROR;
@@ -348,21 +350,21 @@ static int s_rsa_issue_301(int prng_idx)
    DO(rsa_export(buf, &len, PK_PRIVATE, &key));
    DO(rsa_import(buf, len, &key_in));
 
-   DO(s_rsa_key_cmp(PK_PRIVATE, &key, &key_in));
+   DO(rsa_key_cmp(PK_PRIVATE, &key, &key_in));
    rsa_free(&key_in);
 
    len = sizeof(buf);
    DO(rsa_export(buf, &len, PK_PUBLIC, &key));
    DO(rsa_import(buf, len, &key_in));
 
-   DO(s_rsa_key_cmp(PK_PUBLIC, &key, &key_in));
+   DO(rsa_key_cmp(PK_PUBLIC, &key, &key_in));
    rsa_free(&key_in);
 
    len = sizeof(buf);
    DO(rsa_export(buf, &len, PK_PUBLIC | PK_STD, &key));
    DO(rsa_import(buf, len, &key_in));
 
-   DO(s_rsa_key_cmp(PK_PUBLIC, &key, &key_in));
+   DO(rsa_key_cmp(PK_PUBLIC, &key, &key_in));
    rsa_free(&key_in);
 
    rsa_free(&key);