Changeset a35b458 in mainline for uspace/lib/crypto


Ignore:
Timestamp:
2018-03-02T20:10:49Z (7 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1380b7
Parents:
3061bc1
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

Location:
uspace/lib/crypto
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/crypto/aes.c

    r3061bc1 ra35b458  
    213213        uint8_t i = byte >> 4;
    214214        uint8_t j = byte & 0xF;
    215        
     215
    216216        if (!inv)
    217217                return sbox[i][j];
    218        
     218
    219219        return inv_sbox[i][j];
    220220}
    … …  
    229229{
    230230        uint8_t val;
    231        
     231
    232232        for (size_t i = 0; i < ELEMS; i++) {
    233233                for (size_t j = 0; j < ELEMS; j++) {
    … …  
    246246{
    247247        uint8_t temp[ELEMS];
    248        
     248
    249249        for (size_t i = 1; i < ELEMS; i++) {
    250250                memcpy(temp, state[i], i);
    … …  
    262262{
    263263        uint8_t temp[ELEMS];
    264        
     264
    265265        for (size_t i = 1; i < ELEMS; i++) {
    266266                memcpy(temp, state[i], ELEMS - i);
    … …  
    282282        uint8_t result = 0;
    283283        uint8_t f_bith;
    284        
     284
    285285        for (size_t i = 0; i < 8; i++) {
    286286                if (y & 1)
    287287                        result ^= x;
    288                
     288
    289289                f_bith = (x & 0x80);
    290290                x <<= 1;
    291                
     291
    292292                if (f_bith)
    293293                        x ^= AES_IP;
    294                
     294
    295295                y >>= 1;
    296296        }
    297        
     297
    298298        return result;
    299299}
    … …  
    308308        uint8_t orig_state[ELEMS][ELEMS];
    309309        memcpy(orig_state, state, BLOCK_LEN);
    310        
     310
    311311        for (size_t j = 0; j < ELEMS; j++) {
    312312                state[0][j] =
    … …  
    342342        uint8_t orig_state[ELEMS][ELEMS];
    343343        memcpy(orig_state, state, BLOCK_LEN);
    344        
     344
    345345        for (size_t j = 0; j < ELEMS; j++) {
    346346                state[0][j] =
    … …  
    378378        uint8_t shift;
    379379        uint32_t mask = 0xff;
    380        
     380
    381381        for (size_t j = 0; j < ELEMS; j++) {
    382382                for (size_t i = 0; i < ELEMS; i++) {
    … …  
    399399        uint32_t temp = word;
    400400        uint8_t *start = (uint8_t *) &temp;
    401        
     401
    402402        for (size_t i = 0; i < 4; i++)
    403403                *(start + i) = sub_byte(*(start + i), false);
    404        
     404
    405405        return temp;
    406406}
    … …  
    427427{
    428428        uint32_t temp;
    429        
     429
    430430        for (size_t i = 0; i < CIPHER_ELEMS; i++) {
    431431                key_exp[i] =
    … …  
    435435                    (key[4 * i + 3]);
    436436        }
    437        
     437
    438438        for (size_t i = CIPHER_ELEMS; i < ELEMS * (ROUNDS + 1); i++) {
    439439                temp = key_exp[i - 1];
    440                
     440
    441441                if ((i % CIPHER_ELEMS) == 0) {
    442442                        temp = sub_word(rot_word(temp)) ^
    443443                            r_con_array[i / CIPHER_ELEMS - 1];
    444444                }
    445                
     445
    446446                key_exp[i] = key_exp[i - CIPHER_ELEMS] ^ temp;
    447447        }
    … …  
    463463        if ((!key) || (!input))
    464464                return EINVAL;
    465        
     465
    466466        if (!output)
    467467                return ENOMEM;
    468        
     468
    469469        /* Create key expansion. */
    470470        uint32_t key_exp[ELEMS * (ROUNDS + 1)];
    471471        key_expansion(key, key_exp);
    472        
     472
    473473        /* Copy input into state array. */
    474474        uint8_t state[ELEMS][ELEMS];
    … …  
    477477                        state[i][j] = input[i + ELEMS * j];
    478478        }
    479        
     479
    480480        /* Processing loop. */
    481481        add_round_key(state, key_exp);
    482        
     482
    483483        for (size_t k = 1; k <= ROUNDS; k++) {
    484484                sub_bytes(state, false);
    485485                shift_rows(state);
    486                
     486
    487487                if (k < ROUNDS)
    488488                        mix_columns(state);
    489                
     489
    490490                add_round_key(state, key_exp + k * ELEMS);
    491491        }
    492        
     492
    493493        /* Copy state array into output. */
    494494        for (size_t i = 0; i < ELEMS; i++) {
    … …  
    496496                        output[i + j * ELEMS] = state[i][j];
    497497        }
    498        
     498
    499499        return EOK;
    500500}
    … …  
    515515        if ((!key) || (!input))
    516516                return EINVAL;
    517        
     517
    518518        if (!output)
    519519                return ENOMEM;
    520        
     520
    521521        /* Create key expansion. */
    522522        uint32_t key_exp[ELEMS * (ROUNDS + 1)];
    523523        key_expansion(key, key_exp);
    524        
     524
    525525        /* Copy input into state array. */
    526526        uint8_t state[ELEMS][ELEMS];
    … …  
    529529                        state[i][j] = input[i + ELEMS * j];
    530530        }
    531        
     531
    532532        /* Processing loop. */
    533533        add_round_key(state, key_exp + ROUNDS * ELEMS);
    534        
     534
    535535        for (int k = ROUNDS - 1; k >= 0; k--) {
    536536                inv_shift_rows(state);
    537537                sub_bytes(state, true);
    538538                add_round_key(state, key_exp + k * ELEMS);
    539                
     539
    540540                if (k > 0)
    541541                        inv_mix_columns(state);
    542542        }
    543        
     543
    544544        /* Copy state array into output. */
    545545        for (size_t i = 0; i < ELEMS; i++) {
    … …  
    547547                        output[i + j * ELEMS] = state[i][j];
    548548        }
    549        
     549
    550550        return EOK;
    551551}

  • uspace/lib/crypto/crypto.c

    r3061bc1 ra35b458  
    101101        uint32_t f, g, temp;
    102102        uint32_t w[HASH_MD5 / 4];
    103        
     103
    104104        memcpy(w, h, (HASH_MD5 / 4) * sizeof(uint32_t));
    105        
     105
    106106        for (size_t k = 0; k < 64; k++) {
    107107                if (k < 16) {
    … …  
    118118                        g = 7 * k % 16;
    119119                }
    120                
     120
    121121                temp = w[3];
    122122                w[3] = w[2];
    … …  
    127127                w[0] = temp;
    128128        }
    129        
     129
    130130        for (uint8_t k = 0; k < HASH_MD5 / 4; k++)
    131131                h[k] += w[k];
    … …  
    142142        uint32_t f, cf, temp;
    143143        uint32_t w[HASH_SHA1 / 4];
    144        
     144
    145145        for (size_t k = 16; k < 80; k++) {
    146146                sched_arr[k] = rotl_uint32(
    … …  
    151151                    1);
    152152        }
    153        
     153
    154154        memcpy(w, h, (HASH_SHA1 / 4) * sizeof(uint32_t));
    155        
     155
    156156        for (size_t k = 0; k < 80; k++) {
    157157                if (k < 20) {
    … …  
    168168                        cf = 0xca62c1d6;
    169169                }
    170                
     170
    171171                temp = rotl_uint32(w[0], 5) + f + w[4] + cf + sched_arr[k];
    172                
     172
    173173                w[4] = w[3];
    174174                w[3] = w[2];
    … …  
    177177                w[0] = temp;
    178178        }
    179        
     179
    180180        for (uint8_t k = 0; k < HASH_SHA1 / 4; k++)
    181181                h[k] += w[k];
    … …  
    199199        if (!input)
    200200                return EINVAL;
    201        
     201
    202202        if (!output)
    203203                return ENOMEM;
    204        
     204
    205205        hash_fnc_t hash_func = (hash_sel == HASH_MD5) ? md5_proc : sha1_proc;
    206        
     206
    207207        /* Prepare scheduled input. */
    208208        uint8_t work_input[input_size + 1];
    209209        memcpy(work_input, input, input_size);
    210210        work_input[input_size] = 0x80;
    211        
     211
    212212        // FIXME: double?
    213213        size_t blocks = ceil_uint32((((double) input_size + 1) / 4 + 2) / 16);
    … …  
    222222                }
    223223        }
    224        
     224
    225225        uint64_t bits_size = (uint64_t) (input_size * 8);
    226226        if (hash_sel == HASH_MD5)
    227227                bits_size = uint64_t_byteorder_swap(bits_size);
    228        
     228
    229229        work_arr[(blocks - 1) * 16 + 14] = bits_size >> 32;
    230230        work_arr[(blocks - 1) * 16 + 15] = bits_size & 0xffffffff;
    231        
     231
    232232        /* Hash computation. */
    233233        uint32_t h[hash_sel / 4];
    … …  
    237237                for (size_t k = 0; k < 16; k++)
    238238                        sched_arr[k] = work_arr[i * 16 + k];
    239                
     239
    240240                hash_func(h, sched_arr);
    241241        }
    242        
     242
    243243        /* Copy hash parts into final result. */
    244244        for (size_t i = 0; i < hash_sel / 4; i++) {
    245245                if (hash_sel == HASH_SHA1)
    246246                        h[i] = uint32_t_byteorder_swap(h[i]);
    247                
     247
    248248                memcpy(output + i * sizeof(uint32_t), &h[i], sizeof(uint32_t));
    249249        }
    250        
     250
    251251        return EOK;
    252252}
    … …  
    271271        if ((!key) || (!msg))
    272272                return EINVAL;
    273        
     273
    274274        if (!hash)
    275275                return ENOMEM;
    276        
     276
    277277        uint8_t work_key[HMAC_BLOCK_LENGTH];
    278278        uint8_t o_key_pad[HMAC_BLOCK_LENGTH];
    … …  
    280280        uint8_t temp_hash[hash_sel];
    281281        memset(work_key, 0, HMAC_BLOCK_LENGTH);
    282        
     282
    283283        if(key_size > HMAC_BLOCK_LENGTH)
    284284                create_hash(key, key_size, work_key, hash_sel);
    285285        else
    286286                memcpy(work_key, key, key_size);
    287        
     287
    288288        for (size_t i = 0; i < HMAC_BLOCK_LENGTH; i++) {
    289289                o_key_pad[i] = work_key[i] ^ 0x5c;
    290290                i_key_pad[i] = work_key[i] ^ 0x36;
    291291        }
    292        
     292
    293293        uint8_t temp_work[HMAC_BLOCK_LENGTH + max(msg_size, hash_sel)];
    294294        memcpy(temp_work, i_key_pad, HMAC_BLOCK_LENGTH);
    295295        memcpy(temp_work + HMAC_BLOCK_LENGTH, msg, msg_size);
    296        
     296
    297297        create_hash(temp_work, HMAC_BLOCK_LENGTH + msg_size, temp_hash,
    298298            hash_sel);
    299        
     299
    300300        memcpy(temp_work, o_key_pad, HMAC_BLOCK_LENGTH);
    301301        memcpy(temp_work + HMAC_BLOCK_LENGTH, temp_hash, hash_sel);
    302        
     302
    303303        create_hash(temp_work, HMAC_BLOCK_LENGTH + hash_sel, hash, hash_sel);
    304        
     304
    305305        return EOK;
    306306}
    … …  
    327327        if ((!pass) || (!salt))
    328328                return EINVAL;
    329        
     329
    330330        if (!hash)
    331331                return ENOMEM;
    332        
     332
    333333        uint8_t work_salt[salt_size + 4];
    334334        memcpy(work_salt, salt, salt_size);
    … …  
    337337        uint8_t xor_hmac[HASH_SHA1];
    338338        uint8_t temp_hash[HASH_SHA1 * 2];
    339        
     339
    340340        for (size_t i = 0; i < 2; i++) {
    341341                uint32_t be_i = host2uint32_t_be(i + 1);
    342                
     342
    343343                memcpy(work_salt + salt_size, &be_i, 4);
    344344                hmac(pass, pass_size, work_salt, salt_size + 4,
    345345                    work_hmac, HASH_SHA1);
    346346                memcpy(xor_hmac, work_hmac, HASH_SHA1);
    347                
     347
    348348                for (size_t k = 1; k < 4096; k++) {
    349349                        memcpy(temp_hmac, work_hmac, HASH_SHA1);
    350350                        hmac(pass, pass_size, temp_hmac, HASH_SHA1,
    351351                            work_hmac, HASH_SHA1);
    352                        
     352
    353353                        for (size_t t = 0; t < HASH_SHA1; t++)
    354354                                xor_hmac[t] ^= work_hmac[t];
    355355                }
    356                
     356
    357357                memcpy(temp_hash + i * HASH_SHA1, xor_hmac, HASH_SHA1);
    358358        }
    359        
     359
    360360        memcpy(hash, temp_hash, PBKDF2_KEY_LENGTH);
    361        
     361
    362362        return EOK;
    363363}

  • uspace/lib/crypto/rc4.c

    r3061bc1 ra35b458  
    6565        for (size_t i = 0; i < SBOX_SIZE; i++)
    6666                sbox[i] = i;
    67        
     67
    6868        uint8_t j = 0;
    6969        for (size_t i = 0; i < SBOX_SIZE; i++) {
    … …  
    9393        if ((!key) || (!input))
    9494                return EINVAL;
    95        
     95
    9696        if (!output)
    9797                return ENOMEM;
    98        
     98
    9999        /* Initialize sbox. */
    100100        uint8_t sbox[SBOX_SIZE];
    101101        create_sbox(key, key_size, sbox);
    102        
     102
    103103        /* Skip first x bytes. */
    104104        uint8_t i = 0;
    … …  
    109109                swap(i, j, sbox);
    110110        }
    111        
     111
    112112        /* Processing loop. */
    113113        uint8_t val;
    … …  
    119119                output[k] = val ^ input[k];
    120120        }
    121        
     121
    122122        return EOK;
    123123}
Note: See TracChangeset for help on using the changeset viewer.