Changeset 5ebff60 for lib/arc.c


Ignore:
Timestamp:
2015-02-20T22:50:54Z (9 years ago)
Author:
dequis <dx@…>
Branches:
master
Children:
0b9daac, 3d45471, 7733b8c
Parents:
af359b4
git-author:
Indent <please@…> (19-02-15 05:47:20)
git-committer:
dequis <dx@…> (20-02-15 22:50:54)
Message:

Reindent everything to K&R style with tabs

Used uncrustify, with the configuration file in ./doc/uncrustify.cfg

Commit author set to "Indent <please@…>" so that it's easier to
skip while doing git blame.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • lib/arc.c

    raf359b4 r5ebff60  
    2222\***************************************************************************/
    2323
    24 /* 
     24/*
    2525   This file implements ArcFour-encryption, which will mainly be used to
    2626   save IM passwords safely in the new XML-format. Possibly other uses will
    … …  
    2929   way to crack BitlBee passwords now is to use a sniffer to get your hands
    3030   on the user's password.
    31    
     31
    3232   If you see that something's wrong in this implementation (I asked a
    3333   couple of people to look at it already, but who knows), please tell me.
    34    
     34
    3535   The reason I picked ArcFour is because it's pretty simple but effective,
    3636   so it will work without adding several KBs or an extra library dependency.
    37    
     37
    3838   (ArcFour is an RC4-compatible cipher. See for details:
    3939   http://www.mozilla.org/projects/security/pki/nss/draft-kaukonen-cipher-arcfour-03.txt)
    … …  
    5757#define ARC_CYCLES 1024
    5858
    59 struct arc_state *arc_keymaker( unsigned char *key, int kl, int cycles )
     59struct arc_state *arc_keymaker(unsigned char *key, int kl, int cycles)
    6060{
    6161        struct arc_state *st;
    6262        int i, j, tmp;
    6363        unsigned char S2[256];
    64        
    65         st = g_malloc( sizeof( struct arc_state ) );
     64
     65        st = g_malloc(sizeof(struct arc_state));
    6666        st->i = st->j = 0;
    67         if( kl <= 0 )
    68                 kl = strlen( (char*) key );
    69        
    70         for( i = 0; i < 256; i ++ )
    71         {
     67        if (kl <= 0) {
     68                kl = strlen((char *) key);
     69        }
     70
     71        for (i = 0; i < 256; i++) {
    7272                st->S[i] = i;
    73                 S2[i] = key[i%kl];
    74         }
    75        
    76         for( i = j = 0; i < 256; i ++ )
    77         {
    78                 j = ( j + st->S[i] + S2[i] ) & 0xff;
     73                S2[i] = key[i % kl];
     74        }
     75
     76        for (i = j = 0; i < 256; i++) {
     77                j = (j + st->S[i] + S2[i]) & 0xff;
    7978                tmp = st->S[i];
    8079                st->S[i] = st->S[j];
    8180                st->S[j] = tmp;
    8281        }
    83        
    84         memset( S2, 0, 256 );
     82
     83        memset(S2, 0, 256);
    8584        i = j = 0;
    86        
    87         for( i = 0; i < cycles; i ++ )
    88                 arc_getbyte( st );
    89        
     85
     86        for (i = 0; i < cycles; i++) {
     87                arc_getbyte(st);
     88        }
     89
    9090        return st;
    9191}
    … …  
    9696   xor it with your cleartext. To decrypt, just give it the same key again
    9797   and start xorring.
    98    
     98
    9999   The function above initializes the byte generator, the next function can
    100100   be used to get bytes from the generator (and shuffle things a bit).
    101101*/
    102102
    103 unsigned char arc_getbyte( struct arc_state *st )
     103unsigned char arc_getbyte(struct arc_state *st)
    104104{
    105105        unsigned char tmp;
    106        
     106
    107107        /* Unfortunately the st-> stuff doesn't really improve readability here... */
    108         st->i ++;
     108        st->i++;
    109109        st->j += st->S[st->i];
    110110        tmp = st->S[st->i];
    … …  
    112112        st->S[st->j] = tmp;
    113113        tmp = (st->S[st->i] + st->S[st->j]) & 0xff;
    114        
     114
    115115        return st->S[tmp];
    116116}
    … …  
    122122   structures. These 6 bytes are also saved in the results, because of
    123123   course we'll need them in arc_decode().
    124    
     124
    125125   Because the length of the resulting string is unknown to the caller,
    126126   it should pass a char**. Since the encode/decode functions allocate
    … …  
    129129   memory. And of course, don't forget to free() the result when you
    130130   don't need it anymore.
    131    
     131
    132132   Both functions return the number of bytes in the result string.
    133    
     133
    134134   Note that if you use the pad_to argument, you will need zero-termi-
    135135   nation to find back the original string length after decryption. So
    … …  
    137137*/
    138138
    139 int arc_encode( char *clear, int clear_len, unsigned char **crypt, char *password, int pad_to )
     139int arc_encode(char *clear, int clear_len, unsigned char **crypt, char *password, int pad_to)
    140140{
    141141        struct arc_state *st;
    … …  
    143143        char *padded = NULL;
    144144        int key_len, i, padded_len;
    145        
    146         key_len = strlen( password ) + ARC_IV_LEN;
    147         if( clear_len <= 0 )
    148                 clear_len = strlen( clear );
    149        
     145
     146        key_len = strlen(password) + ARC_IV_LEN;
     147        if (clear_len <= 0) {
     148                clear_len = strlen(clear);
     149        }
     150
    150151        /* Pad the string to the closest multiple of pad_to. This makes it
    151152           impossible to see the exact length of the password. */
    152         if( pad_to > 0 && ( clear_len % pad_to ) > 0 )
    153         {
    154                 padded_len = clear_len + pad_to - ( clear_len % pad_to );
    155                 padded = g_malloc( padded_len );
    156                 memcpy( padded, clear, clear_len );
    157                
     153        if (pad_to > 0 && (clear_len % pad_to) > 0) {
     154                padded_len = clear_len + pad_to - (clear_len % pad_to);
     155                padded = g_malloc(padded_len);
     156                memcpy(padded, clear, clear_len);
     157
    158158                /* First a \0 and then random data, so we don't have to do
    159159                   anything special when decrypting. */
    160160                padded[clear_len] = 0;
    161                 random_bytes( (unsigned char*) padded + clear_len + 1, padded_len - clear_len - 1 );
    162                
     161                random_bytes((unsigned char *) padded + clear_len + 1, padded_len - clear_len - 1);
     162
    163163                clear = padded;
    164164                clear_len = padded_len;
    165165        }
    166        
     166
    167167        /* Prepare buffers and the key + IV */
    168         *crypt = g_malloc( clear_len + ARC_IV_LEN );
    169         key = g_malloc( key_len );
    170         strcpy( (char*) key, password );
    171        
     168        *crypt = g_malloc(clear_len + ARC_IV_LEN);
     169        key = g_malloc(key_len);
     170        strcpy((char *) key, password);
     171
    172172        /* Add the salt. Save it for later (when decrypting) and, of course,
    173173           add it to the encryption key. */
    174         random_bytes( crypt[0], ARC_IV_LEN );
    175         memcpy( key + key_len - ARC_IV_LEN, crypt[0], ARC_IV_LEN );
    176        
     174        random_bytes(crypt[0], ARC_IV_LEN);
     175        memcpy(key + key_len - ARC_IV_LEN, crypt[0], ARC_IV_LEN);
     176
    177177        /* Generate the initial S[] from the IVed key. */
    178         st = arc_keymaker( key, key_len, ARC_CYCLES );
    179         g_free( key );
    180        
    181         for( i = 0; i < clear_len; i ++ )
    182                 crypt[0][i+ARC_IV_LEN] = clear[i] ^ arc_getbyte( st );
    183        
    184         g_free( st );
    185         g_free( padded );
    186        
     178        st = arc_keymaker(key, key_len, ARC_CYCLES);
     179        g_free(key);
     180
     181        for (i = 0; i < clear_len; i++) {
     182                crypt[0][i + ARC_IV_LEN] = clear[i] ^ arc_getbyte(st);
     183        }
     184
     185        g_free(st);
     186        g_free(padded);
     187
    187188        return clear_len + ARC_IV_LEN;
    188189}
    189190
    190 int arc_decode( unsigned char *crypt, int crypt_len, char **clear, const char *password )
     191int arc_decode(unsigned char *crypt, int crypt_len, char **clear, const char *password)
    191192{
    192193        struct arc_state *st;
    193194        unsigned char *key;
    194195        int key_len, clear_len, i;
    195        
    196         key_len = strlen( password ) + ARC_IV_LEN;
     196
     197        key_len = strlen(password) + ARC_IV_LEN;
    197198        clear_len = crypt_len - ARC_IV_LEN;
    198        
    199         if( clear_len < 0 )
    200         {
    201                 *clear = g_strdup( "" );
     199
     200        if (clear_len < 0) {
     201                *clear = g_strdup("");
    202202                return -1;
    203203        }
    204        
     204
    205205        /* Prepare buffers and the key + IV */
    206         *clear = g_malloc( clear_len + 1 );
    207         key = g_malloc( key_len );
    208         strcpy( (char*) key, password );
    209         for( i = 0; i < ARC_IV_LEN; i ++ )
    210                 key[key_len-ARC_IV_LEN+i] = crypt[i];
    211        
     206        *clear = g_malloc(clear_len + 1);
     207        key = g_malloc(key_len);
     208        strcpy((char *) key, password);
     209        for (i = 0; i < ARC_IV_LEN; i++) {
     210                key[key_len - ARC_IV_LEN + i] = crypt[i];
     211        }
     212
    212213        /* Generate the initial S[] from the IVed key. */
    213         st = arc_keymaker( key, key_len, ARC_CYCLES );
    214         g_free( key );
    215        
    216         for( i = 0; i < clear_len; i ++ )
    217                 clear[0][i] = crypt[i+ARC_IV_LEN] ^ arc_getbyte( st );
     214        st = arc_keymaker(key, key_len, ARC_CYCLES);
     215        g_free(key);
     216
     217        for (i = 0; i < clear_len; i++) {
     218                clear[0][i] = crypt[i + ARC_IV_LEN] ^ arc_getbyte(st);
     219        }
    218220        clear[0][i] = 0; /* Nice to have for plaintexts. */
    219        
    220         g_free( st );
    221        
     221
     222        g_free(st);
     223
    222224        return clear_len;
    223225}
Note: See TracChangeset for help on using the changeset viewer.