torture_pki: store test case attributes in struct instead of multiple arrays

Signed-off-by: Ben Toews <mastahyeti@gmail.com>
Reviewed-by: Jakub Jelen <jjelen@redhat.com>

tests/unittests/torture_pki.c

@@ -47,44 +47,26 @@ static void torture_pki_signature(void **state)
     ssh_signature_free(sig);
 }
 
-/* Maps to enum ssh_keytypes_e */
-const char *key_types[] = {
-    "", /* UNKNOWN */
-    "ssh-dss",
-    "ssh-rsa",
-    "",/* RSA1 */
-    "ecdsa-sha2-nistp521",
-    "ssh-ed25519",
+struct key_attrs {
+    int sign;
+    int verify;
+    const char *type_c;
+    int size_arg;
+    int sig_length;
+    const char *sig_type_c;
 };
 
-/* Maps to enum ssh_keytypes_e */
-const int key_sizes[] = {
-    0, /* UNKNOWN */
-    1024,
-    2048,
-    0, /* RSA1 */
-    521,
-    0,
-};
-
-/* Maps to enum ssh_keytypes_e */
-const int sig_lengths[]  = {
-    0, /* UNKNOWN */
-    20,
-    20,
-    0, /* RSA1 */
-    64,
-    33,
-};
-
-/* Maps to enum ssh_keytypes_e */
-const char *signature_types[] = {
-    "", /* UNKNOWN */
-    "ssh-dss",
-    "ssh-rsa",
-    "",/* RSA1 */
-    "ecdsa-sha2-nistp521",
-    "ssh-ed25519",
+struct key_attrs key_attrs_list[] = {
+    {0, 0, "", 0, 0, ""},                                          /* UNKNOWN */
+#ifdef HAVE_DSA
+    {1, 1, "ssh-dss", 1024, 20, "ssh-dss" },                       /* DSS */
+#else
+    {0, 0, "", 0, 0, ""},                                          /* DSS */
+#endif
+    {1, 1, "ssh-rsa", 2048, 20, "ssh-rsa"},                        /* RSA */
+    {0, 0, "", 0, 0, ""},                                          /* RSA1 */
+    {1, 1, "ecdsa-sha2-nistp521", 521, 64, "ecdsa-sha2-nistp521"}, /* ECDSA */
+    {1, 1, "ssh-ed25519", 0, 33, "ssh-ed25519"},                   /* ED25519 */
 };
 
 /* Maps to enum ssh_digest_e */
@@ -112,37 +94,33 @@ static void torture_pki_verify_mismatch(void **state)
     ssh_signature sign = NULL, import_sig = NULL, new_sig = NULL;
     ssh_string blob;
     ssh_session session = ssh_new();
-    enum ssh_keytypes_e key_type, sig_type, first_key;
+    enum ssh_keytypes_e key_type, sig_type;
     enum ssh_digest_e hash;
     int hash_length;
+    struct key_attrs skey_attrs, vkey_attrs;
 
     (void) state;
 
     ssh_options_set(session, SSH_OPTIONS_LOG_VERBOSITY, &verbosity);
 
-#ifdef HAVE_DSA
-    first_key = SSH_KEYTYPE_DSS;
-#else
-    first_key = SSH_KEYTYPE_RSA;
-#endif /* HAVE_DSA */
-
-    for (sig_type = first_key;
+    for (sig_type = SSH_KEYTYPE_DSS;
          sig_type <= SSH_KEYTYPE_ED25519;
          sig_type++) {
-        if (sig_type == SSH_KEYTYPE_RSA1) {
+        skey_attrs = key_attrs_list[sig_type];
+        if (!skey_attrs.sign) {
             continue;
         }
-        rc = ssh_pki_generate(sig_type, key_sizes[sig_type], &key);
+        rc = ssh_pki_generate(sig_type, skey_attrs.size_arg, &key);
         assert_true(rc == SSH_OK);
         assert_non_null(key);
         assert_int_equal(key->type, sig_type);
-        assert_string_equal(key->type_c, key_types[sig_type]);
+        assert_string_equal(key->type_c, skey_attrs.type_c);
 
         for (hash = SSH_DIGEST_AUTO;
              hash <= SSH_DIGEST_SHA512;
              hash++) {
             hash_length = ((hash == SSH_DIGEST_AUTO) ?
-                              sig_lengths[sig_type] : hash_lengths[hash]);
+                              skey_attrs.sig_length : hash_lengths[hash]);
 
             SSH_LOG(SSH_LOG_TRACE, "Creating signature %d with hash %d",
                     sig_type, hash);
@@ -153,7 +131,7 @@ static void torture_pki_verify_mismatch(void **state)
             assert_int_equal(sign->type, key->type);
             if (hash == SSH_DIGEST_AUTO) {
                 assert_string_equal(sign->type_c, key->type_c);
-                assert_string_equal(sign->type_c, signature_types[sig_type]);
+                assert_string_equal(sign->type_c, skey_attrs.sig_type_c);
             } else {
                 assert_string_equal(sign->type_c, hash_signatures[hash]);
             }
@@ -172,7 +150,7 @@ static void torture_pki_verify_mismatch(void **state)
             assert_int_equal(import_sig->type, key->type);
             if (hash == SSH_DIGEST_AUTO) {
                 assert_string_equal(import_sig->type_c, key->type_c);
-                assert_string_equal(import_sig->type_c, signature_types[sig_type]);
+                assert_string_equal(import_sig->type_c, skey_attrs.sig_type_c);
             } else {
                 assert_string_equal(import_sig->type_c, hash_signatures[hash]);
             }
@@ -185,16 +163,17 @@ static void torture_pki_verify_mismatch(void **state)
                                       hash_length);
             assert_true(rc == SSH_OK);
 
-            for (key_type = first_key;
+            for (key_type = SSH_KEYTYPE_DSS;
                  key_type <= SSH_KEYTYPE_ED25519;
                  key_type++) {
-                if (key_type == SSH_KEYTYPE_RSA1) {
+                vkey_attrs = key_attrs_list[key_type];
+                if (!vkey_attrs.verify) {
                     continue;
                 }
                 SSH_LOG(SSH_LOG_TRACE, "Trying key %d with signature %d",
                         key_type, sig_type);
 
-                rc = ssh_pki_generate(key_type, key_sizes[key_type], &verify_key);
+                rc = ssh_pki_generate(key_type, vkey_attrs.size_arg, &verify_key);
                 assert_true(rc == SSH_OK);
                 assert_non_null(verify_key);
 
@@ -229,7 +208,7 @@ static void torture_pki_verify_mismatch(void **state)
                         assert_string_equal(new_sig->type_c, hash_signatures[new_sig->hash_type]);
                     } else {
                         assert_string_equal(new_sig->type_c, key->type_c);
-                        assert_string_equal(new_sig->type_c, signature_types[sig_type]);
+                        assert_string_equal(new_sig->type_c, skey_attrs.sig_type_c);
                     }
                     /* The verification should not work */
                     rc = pki_signature_verify(session,