Changes in uspace/lib/crypto/crypto.c [1b20da0:a35b458] in mainline

File:

• uspace/lib/crypto/crypto.c (modified) (14 diffs)

uspace/lib/crypto/crypto.c

@@ -101 +101 @@
         uint32_t f, g, temp;
         uint32_t w[HASH_MD5 / 4];
-        
+
         memcpy(w, h, (HASH_MD5 / 4) * sizeof(uint32_t));
-        
+
         for (size_t k = 0; k < 64; k++) {
                 if (k < 16) {
@@ -118 +118 @@
                         g = 7 * k % 16;
                 }
-                
+
                 temp = w[3];
                 w[3] = w[2];
@@ -127 +127 @@
                 w[0] = temp;
         }
-        
+
         for (uint8_t k = 0; k < HASH_MD5 / 4; k++)
                 h[k] += w[k];
@@ -142 +142 @@
         uint32_t f, cf, temp;
         uint32_t w[HASH_SHA1 / 4];
-        
+
         for (size_t k = 16; k < 80; k++) {
                 sched_arr[k] = rotl_uint32(
@@ -151 +151 @@
                     1);
         }
-        
+
         memcpy(w, h, (HASH_SHA1 / 4) * sizeof(uint32_t));
-        
+
         for (size_t k = 0; k < 80; k++) {
                 if (k < 20) {
@@ -168 +168 @@
                         cf = 0xca62c1d6;
                 }
-                
+
                 temp = rotl_uint32(w[0], 5) + f + w[4] + cf + sched_arr[k];
-                
+
                 w[4] = w[3];
                 w[3] = w[2];
@@ -177 +177 @@
                 w[0] = temp;
         }
-        
+
         for (uint8_t k = 0; k < HASH_SHA1 / 4; k++)
                 h[k] += w[k];
@@ -199 +199 @@
         if (!input)
                 return EINVAL;
-        
+
         if (!output)
                 return ENOMEM;
-        
+
         hash_fnc_t hash_func = (hash_sel == HASH_MD5) ? md5_proc : sha1_proc;
-        
+
         /* Prepare scheduled input. */
         uint8_t work_input[input_size + 1];
         memcpy(work_input, input, input_size);
         work_input[input_size] = 0x80;
-        
+
         // FIXME: double?
         size_t blocks = ceil_uint32((((double) input_size + 1) / 4 + 2) / 16);
@@ -222 +222 @@
                 }
         }
-        
+
         uint64_t bits_size = (uint64_t) (input_size * 8);
         if (hash_sel == HASH_MD5)
                 bits_size = uint64_t_byteorder_swap(bits_size);
-        
+
         work_arr[(blocks - 1) * 16 + 14] = bits_size >> 32;
         work_arr[(blocks - 1) * 16 + 15] = bits_size & 0xffffffff;
-        
+
         /* Hash computation. */
         uint32_t h[hash_sel / 4];
@@ -237 +237 @@
                 for (size_t k = 0; k < 16; k++)
                         sched_arr[k] = work_arr[i * 16 + k];
-                
+
                 hash_func(h, sched_arr);
         }
-        
+
         /* Copy hash parts into final result. */
         for (size_t i = 0; i < hash_sel / 4; i++) {
                 if (hash_sel == HASH_SHA1)
                         h[i] = uint32_t_byteorder_swap(h[i]);
-                
+
                 memcpy(output + i * sizeof(uint32_t), &h[i], sizeof(uint32_t));
         }
-        
+
         return EOK;
 }
@@ -271 +271 @@
         if ((!key) || (!msg))
                 return EINVAL;
-        
+
         if (!hash)
                 return ENOMEM;
-        
+
         uint8_t work_key[HMAC_BLOCK_LENGTH];
         uint8_t o_key_pad[HMAC_BLOCK_LENGTH];
@@ -280 +280 @@
         uint8_t temp_hash[hash_sel];
         memset(work_key, 0, HMAC_BLOCK_LENGTH);
-        
+
         if(key_size > HMAC_BLOCK_LENGTH)
                 create_hash(key, key_size, work_key, hash_sel);
         else
                 memcpy(work_key, key, key_size);
-        
+
         for (size_t i = 0; i < HMAC_BLOCK_LENGTH; i++) {
                 o_key_pad[i] = work_key[i] ^ 0x5c;
                 i_key_pad[i] = work_key[i] ^ 0x36;
         }
-        
+
         uint8_t temp_work[HMAC_BLOCK_LENGTH + max(msg_size, hash_sel)];
         memcpy(temp_work, i_key_pad, HMAC_BLOCK_LENGTH);
         memcpy(temp_work + HMAC_BLOCK_LENGTH, msg, msg_size);
-        
+
         create_hash(temp_work, HMAC_BLOCK_LENGTH + msg_size, temp_hash,
             hash_sel);
-        
+
         memcpy(temp_work, o_key_pad, HMAC_BLOCK_LENGTH);
         memcpy(temp_work + HMAC_BLOCK_LENGTH, temp_hash, hash_sel);
-        
+
         create_hash(temp_work, HMAC_BLOCK_LENGTH + hash_sel, hash, hash_sel);
-        
+
         return EOK;
 }
@@ -327 +327 @@
         if ((!pass) || (!salt))
                 return EINVAL;
-        
+
         if (!hash)
                 return ENOMEM;
-        
+
         uint8_t work_salt[salt_size + 4];
         memcpy(work_salt, salt, salt_size);
@@ -337 +337 @@
         uint8_t xor_hmac[HASH_SHA1];
         uint8_t temp_hash[HASH_SHA1 * 2];
-        
+
         for (size_t i = 0; i < 2; i++) {
                 uint32_t be_i = host2uint32_t_be(i + 1);
-                
+
                 memcpy(work_salt + salt_size, &be_i, 4);
                 hmac(pass, pass_size, work_salt, salt_size + 4,
                     work_hmac, HASH_SHA1);
                 memcpy(xor_hmac, work_hmac, HASH_SHA1);
-                
+
                 for (size_t k = 1; k < 4096; k++) {
                         memcpy(temp_hmac, work_hmac, HASH_SHA1);
                         hmac(pass, pass_size, temp_hmac, HASH_SHA1,
                             work_hmac, HASH_SHA1);
-                        
+
                         for (size_t t = 0; t < HASH_SHA1; t++)
                                 xor_hmac[t] ^= work_hmac[t];
                 }
-                
+
                 memcpy(temp_hash + i * HASH_SHA1, xor_hmac, HASH_SHA1);
         }
-        
+
         memcpy(hash, temp_hash, PBKDF2_KEY_LENGTH);
-        
+
         return EOK;
 }