SPA with HMAC SHA256 and SHA384 now works
authorMichael Rash <mbr@cipherdyne.org>
Sun, 10 Mar 2013 18:26:05 +0000 (14:26 -0400)
committerMichael Rash <mbr@cipherdyne.org>
Sun, 10 Mar 2013 18:26:05 +0000 (14:26 -0400)
This is a fairly significant commit that lays the groundwork for getting
selectable HMAC modes working for both the client and server.  One libfko API
change was required so that the hmac_type is passed into fko_new_with_data().
This allows the server to set the hmac_type via access.conf stanzas.  The
effort in this commit will be extended to allow HMAC MD5, SHA1, and SHA512
also function properly.

client/fwknop.c
lib/fko.h
lib/fko_error.c
lib/fko_funcs.c
lib/fko_hmac.c
server/access.c
server/incoming_spa.c
test/conf/hmac_sha1_access.conf
test/conf/hmac_sha384_access.conf
test/test-fwknop.pl
test/tests/rijndael_hmac.pl

index 90b45eb..133b441 100644 (file)
@@ -432,7 +432,7 @@ main(int argc, char **argv)
          * options, then decode it.
         */
         res = fko_new_with_data(&ctx2, spa_data, NULL,
-            0, enc_mode, hmac_key, hmac_key_len);
+            0, enc_mode, hmac_key, hmac_key_len, options.hmac_type);
         if(res != FKO_SUCCESS)
         {
             errmsg("fko_new_with_data", res);
@@ -970,7 +970,7 @@ get_keys(fko_ctx_t ctx, fko_cli_options_t *options,
 
     if (use_hmac)
     {
-        res = fko_set_hmac_type(ctx, FKO_HMAC_SHA256);
+        res = fko_set_hmac_type(ctx, options->hmac_type);
         if(res != FKO_SUCCESS)
         {
             errmsg("fko_set_hmac_type", res);
index 3617bf0..9ad612e 100644 (file)
--- a/lib/fko.h
+++ b/lib/fko.h
@@ -237,7 +237,7 @@ enum {
 DLL_API int fko_new(fko_ctx_t *ctx);
 DLL_API int fko_new_with_data(fko_ctx_t *ctx, const char * const enc_msg,
     const char * const dec_key, const int dec_key_len, int encryption_mode,
-    const char * const hmac_key, const int hmac_key_len);
+    const char * const hmac_key, const int hmac_key_len, const int hmac_type);
 DLL_API void fko_destroy(fko_ctx_t ctx);
 DLL_API int fko_spa_data_final(fko_ctx_t ctx, const char * const enc_key,
     const int enc_key_len, const char * const hmac_key, const int hmac_key_len);
index aa6858f..cd399e2 100644 (file)
@@ -100,7 +100,7 @@ fko_errstr(const int err_code)
             return("The computed digest did not match the digest in the spa data");
 
         case FKO_ERROR_UNSUPPORTED_HMAC_MODE:
-            return("Unsupported HMAC mode (default: sha256)");
+            return("Unsupported HMAC mode (default: SHA256)");
 
         case FKO_ERROR_UNSUPPORTED_FEATURE:
             return("Unsupported or unimplemented feature or function");
index 8732395..27924a3 100644 (file)
@@ -172,7 +172,7 @@ int
 fko_new_with_data(fko_ctx_t *r_ctx, const char * const enc_msg,
     const char * const dec_key, const int dec_key_len,
     int encryption_mode, const char * const hmac_key,
-    const int hmac_key_len)
+    const int hmac_key_len, const int hmac_type)
 {
     fko_ctx_t   ctx;
     int         res = FKO_SUCCESS; /* Are we optimistic or what? */
@@ -215,6 +215,17 @@ fko_new_with_data(fko_ctx_t *r_ctx, const char * const enc_msg,
     }
     ctx->initval = 0;
 
+    /* HMAC digest type
+    */
+    ctx->initval = FKO_CTX_INITIALIZED;
+    res = fko_set_hmac_type(ctx, hmac_type);
+    if(res != FKO_SUCCESS)
+    {
+        fko_destroy(ctx);
+        return res;
+    }
+    ctx->initval = 0;
+
     /* Check HMAC if the access stanza had an HMAC key
     */
     ctx->initval = FKO_CTX_INITIALIZED;
@@ -357,7 +368,7 @@ fko_key_gen(char * const key_base64, const int key_len,
         const int hmac_type)
 {
     unsigned char key[RIJNDAEL_MAX_KEYSIZE];
-    unsigned char hmac_key[SHA256_BLOCK_LEN];
+    unsigned char hmac_key[SHA512_BLOCK_LEN];
     int klen      = 0;
     int hmac_klen = 0;
 
index 955f4b6..396940b 100644 (file)
@@ -40,6 +40,7 @@ int fko_verify_hmac(fko_ctx_t ctx,
     char    *hmac_digest_from_data = NULL;
     char    *tbuf = NULL;
     int      res = FKO_SUCCESS;
+    int      hmac_b64_digest_len = 0;
 
     /* Must be initialized
     */
@@ -49,17 +50,36 @@ int fko_verify_hmac(fko_ctx_t ctx,
     if (! is_valid_encoded_msg_len(ctx->encrypted_msg_len))
         return(FKO_ERROR_INVALID_DATA);
 
+    if(ctx->hmac_type == FKO_HMAC_MD5)
+        hmac_b64_digest_len = MD5_B64_LEN;
+    else if(ctx->hmac_type == FKO_HMAC_SHA1)
+        hmac_b64_digest_len = SHA1_B64_LEN;
+    else if(ctx->hmac_type == FKO_HMAC_SHA256)
+        hmac_b64_digest_len = SHA256_B64_LEN;
+    else if(ctx->hmac_type == FKO_HMAC_SHA384)
+        hmac_b64_digest_len = SHA384_B64_LEN;
+    else if(ctx->hmac_type == FKO_HMAC_SHA512)
+        hmac_b64_digest_len = SHA512_B64_LEN;
+    else
+        return(FKO_ERROR_UNSUPPORTED_HMAC_MODE);
+
+    if((ctx->encrypted_msg_len - hmac_b64_digest_len)
+            < MIN_SPA_ENCODED_MSG_SIZE)
+        return(FKO_ERROR_INVALID_DATA);
+
     /* Get digest value
     */
     hmac_digest_from_data = strndup((ctx->encrypted_msg
-            + ctx->encrypted_msg_len - SHA256_B64_LEN), SHA256_B64_LEN);
+            + ctx->encrypted_msg_len - hmac_b64_digest_len),
+            hmac_b64_digest_len);
 
     if(hmac_digest_from_data == NULL)
         return(FKO_ERROR_MEMORY_ALLOCATION);
 
     /* Now we chop the HMAC digest off of the encrypted msg
     */
-    tbuf = strndup(ctx->encrypted_msg, ctx->encrypted_msg_len - SHA256_B64_LEN);
+    tbuf = strndup(ctx->encrypted_msg,
+            ctx->encrypted_msg_len - hmac_b64_digest_len);
     if(tbuf == NULL)
     {
         free(hmac_digest_from_data);
@@ -69,7 +89,7 @@ int fko_verify_hmac(fko_ctx_t ctx,
     free(ctx->encrypted_msg);
 
     ctx->encrypted_msg      = tbuf;
-    ctx->encrypted_msg_len -= SHA256_B64_LEN;
+    ctx->encrypted_msg_len -= hmac_b64_digest_len;
 
     /* See if we need to add the "Salted__" string to the front of the
      * encrypted data.
@@ -86,7 +106,7 @@ int fko_verify_hmac(fko_ctx_t ctx,
     /* Calculate the HMAC from the encrypted data and then
      * compare
     */
-    res = fko_set_hmac_type(ctx, FKO_HMAC_SHA256);
+    res = fko_set_hmac_type(ctx, ctx->hmac_type);
     if(res == FKO_SUCCESS)
     {
         res = fko_calculate_hmac(ctx, hmac_key, hmac_key_len);
@@ -94,7 +114,7 @@ int fko_verify_hmac(fko_ctx_t ctx,
         if(res == FKO_SUCCESS)
         {
             if(strncmp(hmac_digest_from_data,
-                    ctx->msg_hmac, SHA256_B64_LEN) != 0)
+                    ctx->msg_hmac, hmac_b64_digest_len) != 0)
             {
                 res = FKO_ERROR_INVALID_DATA;
             }
@@ -158,36 +178,63 @@ fko_get_spa_hmac_type(fko_ctx_t ctx, short *hmac_type)
 int fko_calculate_hmac(fko_ctx_t ctx,
     const char * const hmac_key, const int hmac_key_len)
 {
-    unsigned char hmac[SHA256_DIGEST_STR_LEN] = {0};
+    unsigned char hmac[SHA512_DIGEST_STR_LEN] = {0};
     char *hmac_base64 = NULL;
+    int   hmac_digest_str_len = 0;
+    int   hmac_digest_len = 0;
 
     /* Must be initialized
     */
     if(!CTX_INITIALIZED(ctx))
         return(FKO_ERROR_CTX_NOT_INITIALIZED);
 
-    memset(hmac, 0x00, SHA256_DIGEST_STR_LEN);
+    memset(hmac, 0x00, SHA512_DIGEST_STR_LEN);
 
-    /* Only HMAC-SHA256 is supported for now
-    */
-    if(ctx->hmac_type != FKO_HMAC_SHA256)
-        return(FKO_ERROR_UNSUPPORTED_HMAC_MODE);
+    if(ctx->hmac_type == FKO_HMAC_MD5)
+    {
+        return(FKO_ERROR_CTX_NOT_INITIALIZED);
+    }
+    else if(ctx->hmac_type == FKO_HMAC_SHA1)
+    {
+        return(FKO_ERROR_CTX_NOT_INITIALIZED);
+    }
+    else if(ctx->hmac_type == FKO_HMAC_SHA256)
+    {
+        hmac_sha256(ctx->encrypted_msg,
+            ctx->encrypted_msg_len, hmac, hmac_key, hmac_key_len);
+
+        hmac_digest_len     = SHA256_DIGEST_LEN;
+        hmac_digest_str_len = SHA256_DIGEST_STR_LEN;
+    }
+    else if(ctx->hmac_type == FKO_HMAC_SHA384)
+    {
+        hmac_sha384(ctx->encrypted_msg,
+            ctx->encrypted_msg_len, hmac, hmac_key, hmac_key_len);
 
-    hmac_base64 = calloc(1, MD_HEX_SIZE(SHA256_DIGEST_LEN)+1);
+        hmac_digest_len     = SHA384_DIGEST_LEN;
+        hmac_digest_str_len = SHA384_DIGEST_STR_LEN;
+    }
+    else if(ctx->hmac_type == FKO_HMAC_SHA512)
+    {
+        hmac_sha512(ctx->encrypted_msg,
+            ctx->encrypted_msg_len, hmac, hmac_key, hmac_key_len);
+
+        hmac_digest_len     = SHA512_DIGEST_LEN;
+        hmac_digest_str_len = SHA512_DIGEST_STR_LEN;
+    }
+
+    hmac_base64 = calloc(1, MD_HEX_SIZE(hmac_digest_len)+1);
     if (hmac_base64 == NULL)
         return(FKO_ERROR_MEMORY_ALLOCATION);
 
-    hmac_sha256(ctx->encrypted_msg,
-        ctx->encrypted_msg_len, hmac, hmac_key, hmac_key_len);
-
-    b64_encode(hmac, hmac_base64, SHA256_DIGEST_LEN);
+    b64_encode(hmac, hmac_base64, hmac_digest_len);
     strip_b64_eq(hmac_base64);
 
     if(ctx->msg_hmac != NULL)
         free(ctx->msg_hmac);
 
     ctx->msg_hmac     = strdup(hmac_base64);
-    ctx->msg_hmac_len = strnlen(ctx->msg_hmac, SHA512_DIGEST_STR_LEN);
+    ctx->msg_hmac_len = strnlen(ctx->msg_hmac, hmac_digest_str_len);
 
     free(hmac_base64);
 
index 430cbf7..b84e754 100644 (file)
@@ -838,9 +838,20 @@ set_acc_defaults(fko_srv_options_t *opts)
                 add_acc_string(&(acc->gpg_home_dir), opts->config[CONF_GPG_HOME_DIR]);
         }
 
-        if (acc->encryption_mode == FKO_ENC_MODE_UNKNOWN)
+        if(acc->encryption_mode == FKO_ENC_MODE_UNKNOWN)
             acc->encryption_mode = FKO_DEFAULT_ENC_MODE;
 
+        /* if we're using an HMAC key and the HMAC digest type was not
+         * set for HMAC_DIGEST_TYPE, then assume it's SHA256
+        */
+
+        if(acc->hmac_type == FKO_HMAC_UNKNOWN
+                && acc->hmac_key_len > 0 && acc->hmac_key != NULL)
+        {
+            acc->hmac_type = FKO_DEFAULT_HMAC_MODE;
+        }
+        printf("..........HERE acc->hmac_type: %d\n", acc->hmac_type);
+
         acc = acc->next;
     }
 }
index fa8b304..0679b0c 100644 (file)
@@ -137,7 +137,7 @@ get_raw_digest(char **digest, char *pkt_data)
      * we can get the outer message digest
     */
     res = fko_new_with_data(&ctx, (char *)pkt_data, NULL, 0,
-            FKO_DEFAULT_ENC_MODE, NULL, 0);
+            FKO_DEFAULT_ENC_MODE, NULL, 0, 0);
     if(res != FKO_SUCCESS)
     {
         log_msg(LOG_WARNING, "Error initializing FKO context from SPA data: %s",
@@ -397,7 +397,7 @@ incoming_spa(fko_srv_options_t *opts)
 
             res = fko_new_with_data(&ctx, (char *)spa_pkt->packet_data,
                 acc->key, acc->key_len, acc->encryption_mode, acc->hmac_key,
-                acc->hmac_key_len);
+                acc->hmac_key_len, acc->hmac_type);
         }
         else if(acc->use_gpg && enc_type == FKO_ENCRYPTION_GPG)
         {
@@ -407,7 +407,7 @@ incoming_spa(fko_srv_options_t *opts)
             if(acc->gpg_decrypt_pw != NULL || acc->gpg_allow_no_pw)
             {
                 res = fko_new_with_data(&ctx, (char *)spa_pkt->packet_data, NULL,
-                        0, acc->encryption_mode, NULL, 0);
+                        0, acc->encryption_mode, NULL, 0, 0);
                 if(res != FKO_SUCCESS)
                 {
                     log_msg(LOG_WARNING,
index d453dda..ca55c61 100644 (file)
@@ -1,4 +1,5 @@
 SOURCE: ANY;
 KEY_BASE64:         wzNP62oPPgEc+kXDPQLHPOayQBuNbYUTPP+QrErNDmg=
 HMAC_KEY_BASE64:    Yh+xizBnl6FotC5ec7FanVGClRMlsOAPh2u6eovnerfBVKwaVKzjGoblFMHMc593TNyi0dWn4opLoTIV9q/ttg==
+HMAC_DIGEST_TYPE:   sha1;
 FW_ACCESS_TIMEOUT:  3;
index d453dda..b41baff 100644 (file)
@@ -1,4 +1,5 @@
 SOURCE: ANY;
 KEY_BASE64:         wzNP62oPPgEc+kXDPQLHPOayQBuNbYUTPP+QrErNDmg=
 HMAC_KEY_BASE64:    Yh+xizBnl6FotC5ec7FanVGClRMlsOAPh2u6eovnerfBVKwaVKzjGoblFMHMc593TNyi0dWn4opLoTIV9q/ttg==
+HMAC_DIGEST_TYPE:   sha384;
 FW_ACCESS_TIMEOUT:  3;
index 7002747..08a419c 100755 (executable)
@@ -925,7 +925,7 @@ sub client_send_spa_packet() {
                 $is_hmac_type = 0;
             } elsif (/^\s+HMAC\:\s(\S+)/) {
                 $hmac_digest = $1;
-            } elsif (/^\s+HMAC\sType\:\s\d+\((\S+)\)/) {
+            } elsif (/^\s+HMAC\sType\:\s\d+\s\((\S+)\)/) {
                 $hmac_mode = lc($1);
             }
         }
index 9bfdcaf..f6e7fd1 100644 (file)
         'subcategory' => 'client+server',
         'detail'   => 'complete cycle MD5 (tcp/22 ssh)',
         'function' => \&spa_cycle,
-        'cmdline'  => "$default_client_hmac_args -m md5",
+        'cmdline'  => "$default_client_hmac_args --hmac-digest-type md5",
         'fwknopd_cmdline'  => "LD_LIBRARY_PATH=$lib_dir $valgrind_str " .
-            "$fwknopdCmd $default_server_hmac_conf_args $intf_str",
+            "$fwknopdCmd -c $cf{'def'} -a $cf{'hmac_md5_access'} " .
+            "-d $default_digest_file -p $default_pid_file $intf_str",
         'fw_rule_created' => $NEW_RULE_REQUIRED,
         'fw_rule_removed' => $NEW_RULE_REMOVED,
         'key_file' => $cf{'rc_hmac_b64_key'},
         'subcategory' => 'client+server',
         'detail'   => 'complete cycle SHA1 (tcp/22 ssh)',
         'function' => \&spa_cycle,
-        'cmdline'  => "$default_client_hmac_args -m sha1",
+        'cmdline'  => "$default_client_hmac_args --hmac-digest-type sha1",
         'fwknopd_cmdline'  => "LD_LIBRARY_PATH=$lib_dir $valgrind_str " .
-            "$fwknopdCmd $default_server_hmac_conf_args $intf_str",
+            "$fwknopdCmd -c $cf{'def'} -a $cf{'hmac_sha1_access'} " .
+            "-d $default_digest_file -p $default_pid_file $intf_str",
         'fw_rule_created' => $NEW_RULE_REQUIRED,
         'fw_rule_removed' => $NEW_RULE_REMOVED,
         'key_file' => $cf{'rc_hmac_b64_key'},
         'subcategory' => 'client+server',
         'detail'   => 'complete cycle SHA256 (tcp/22 ssh)',
         'function' => \&spa_cycle,
-        'cmdline'  => "$default_client_hmac_args -m sha256",
+        'cmdline'  => "$default_client_hmac_args --hmac-digest-type sha256",
         'fwknopd_cmdline'  => "LD_LIBRARY_PATH=$lib_dir $valgrind_str " .
             "$fwknopdCmd $default_server_hmac_conf_args $intf_str",
         'fw_rule_created' => $NEW_RULE_REQUIRED,
         'subcategory' => 'client+server',
         'detail'   => 'complete cycle SHA384 (tcp/22 ssh)',
         'function' => \&spa_cycle,
-        'cmdline'  => "$default_client_hmac_args -m sha384",
+        'cmdline'  => "$default_client_hmac_args --hmac-digest-type sha384",
         'fwknopd_cmdline'  => "LD_LIBRARY_PATH=$lib_dir $valgrind_str " .
-            "$fwknopdCmd $default_server_hmac_conf_args $intf_str",
+            "$fwknopdCmd -c $cf{'def'} -a $cf{'hmac_sha384_access'} " .
+            "-d $default_digest_file -p $default_pid_file $intf_str",
         'fw_rule_created' => $NEW_RULE_REQUIRED,
         'fw_rule_removed' => $NEW_RULE_REMOVED,
         'key_file' => $cf{'rc_hmac_b64_key'},
         'subcategory' => 'client+server',
         'detail'   => 'complete cycle SHA512 (tcp/22 ssh)',
         'function' => \&spa_cycle,
-        'cmdline'  => "$default_client_hmac_args -m sha512",
+        'cmdline'  => "$default_client_hmac_args --hmac-digest-type sha512",
         'fwknopd_cmdline'  => "LD_LIBRARY_PATH=$lib_dir $valgrind_str " .
-            "$fwknopdCmd $default_server_hmac_conf_args $intf_str",
+            "$fwknopdCmd -c $cf{'def'} -a $cf{'hmac_sha512_access'} " .
+            "-d $default_digest_file -p $default_pid_file $intf_str",
         'fw_rule_created' => $NEW_RULE_REQUIRED,
         'fw_rule_removed' => $NEW_RULE_REMOVED,
         'key_file' => $cf{'rc_hmac_b64_key'},
         'subcategory' => 'client',
         'detail'   => 'validate digest type arg',
         'function' => \&generic_exec,
-        'cmdline'  => "$default_client_hmac_args -m invaliddigest",
-        'positive_output_matches' => [qr/Invalid\sdigest\stype/i],
+        'cmdline'  => "$default_client_hmac_args --hmac-digest-type invaliddigest",
+        'positive_output_matches' => [qr/Invalid\shmac\sdigest\stype/i],
         'fw_rule_created' => $REQUIRE_NO_NEW_RULE,
         'key_file' => $cf{'rc_hmac_b64_key'},
         'fatal'    => $NO