source: trunk/libtransmission/crypto.c @ 9973

Last change on this file since 9973 was 9973, checked in by charles, 13 years ago

(trunk libT) #2775 "Saving some memory/storage" -- committed for 1.80

  • Property svn:keywords set to Date Rev Author Id
File size: 10.2 KB
Line 
1/* * This file Copyright (C) 2007-2010 Mnemosyne LLC
2 *
3 * This file is licensed by the GPL version 2.  Works owned by the
4 * Transmission project are granted a special exemption to clause 2(b)
5 * so that the bulk of its code can remain under the MIT license.
6 * This exemption does not extend to derived works not owned by
7 * the Transmission project.
8 *
9 * $Id: crypto.c 9973 2010-01-20 18:48:52Z charles $
10 */
11
12#include <stdlib.h> /* for abs() */
13#include <limits.h> /* for INT_MAX */
14#include <sys/types.h> /* for event.h, as well as netinet/in.h on some platforms
15                         */
16#include <assert.h>
17#include <inttypes.h> /* uint8_t */
18#include <string.h> /* memcpy */
19#include <stdarg.h>
20
21#include <openssl/bn.h>
22#include <openssl/dh.h>
23#include <openssl/err.h>
24#include <openssl/rc4.h>
25#include <openssl/sha.h>
26#include <openssl/rand.h>
27
28#include <event.h>
29
30#include "crypto.h"
31#include "utils.h"
32
33#define MY_NAME "tr_crypto"
34
35/**
36***
37**/
38
39void
40tr_sha1( uint8_t *    setme,
41         const void * content1,
42         int          content1_len,
43         ... )
44{
45    va_list vl;
46    SHA_CTX sha;
47
48    SHA1_Init( &sha );
49    SHA1_Update( &sha, content1, content1_len );
50
51    va_start( vl, content1_len );
52    for( ; ; )
53    {
54        const void * content = (const void*) va_arg( vl, const void* );
55        const int    content_len = content ? (int) va_arg( vl, int ) : -1;
56        if( content == NULL || content_len < 1 )
57            break;
58        SHA1_Update( &sha, content, content_len );
59    }
60    va_end( vl );
61    SHA1_Final( setme, &sha );
62}
63
64/**
65***
66**/
67
68#define KEY_LEN 96
69
70#define PRIME_LEN 96
71
72#define DH_PRIVKEY_LEN_MIN 16
73#define DH_PRIVKEY_LEN 20
74
75static const uint8_t dh_P[PRIME_LEN] =
76{
77    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x0F, 0xDA, 0xA2,
78    0x21, 0x68, 0xC2, 0x34, 0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1,
79    0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74, 0x02, 0x0B, 0xBE, 0xA6,
80    0x3B, 0x13, 0x9B, 0x22, 0x51, 0x4A, 0x08, 0x79, 0x8E, 0x34, 0x04, 0xDD,
81    0xEF, 0x95, 0x19, 0xB3, 0xCD, 0x3A, 0x43, 0x1B, 0x30, 0x2B, 0x0A, 0x6D,
82    0xF2, 0x5F, 0x14, 0x37, 0x4F, 0xE1, 0x35, 0x6D, 0x6D, 0x51, 0xC2, 0x45,
83    0xE4, 0x85, 0xB5, 0x76, 0x62, 0x5E, 0x7E, 0xC6, 0xF4, 0x4C, 0x42, 0xE9,
84    0xA6, 0x3A, 0x36, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x05, 0x63,
85};
86
87static const uint8_t dh_G[] = { 2 };
88
89/** @brief Holds state information for encrypted peer communications */
90struct tr_crypto
91{
92    RC4_KEY         dec_key;
93    RC4_KEY         enc_key;
94    uint8_t         torrentHash[SHA_DIGEST_LENGTH];
95    tr_bool         isIncoming;
96    tr_bool         torrentHashIsSet;
97    tr_bool         mySecretIsSet;
98    uint8_t         myPublicKey[KEY_LEN];
99    uint8_t         mySecret[KEY_LEN];
100    DH *            dh;
101};
102
103/**
104***
105**/
106
107#define logErrorFromSSL( ... ) \
108    do { \
109        if( tr_msgLoggingIsActive( TR_MSG_ERR ) ) { \
110            char buf[512]; \
111            ERR_error_string_n( ERR_get_error( ), buf, sizeof( buf ) ); \
112            tr_msg( __FILE__, __LINE__, TR_MSG_ERR, MY_NAME, "%s", buf ); \
113        } \
114    } while( 0 )
115
116static void
117ensureKeyExists( tr_crypto * crypto)
118{
119    if( crypto->dh == NULL )
120    {
121        int len, offset;
122        DH * dh = DH_new( );
123
124        dh->p = BN_bin2bn( dh_P, sizeof( dh_P ), NULL );
125        if( dh->p == NULL )
126            logErrorFromSSL( );
127
128        dh->g = BN_bin2bn( dh_G, sizeof( dh_G ), NULL );
129        if( dh->g == NULL )
130            logErrorFromSSL( );
131
132        /* private DH value: strong random BN of DH_PRIVKEY_LEN*8 bits */
133        dh->priv_key = BN_new( );
134        do {
135            if( BN_rand( dh->priv_key, DH_PRIVKEY_LEN * 8, -1, 0 ) != 1 )
136                logErrorFromSSL( );
137        } while ( BN_num_bits( dh->priv_key ) < DH_PRIVKEY_LEN_MIN * 8 );
138
139        if( !DH_generate_key( dh ) )
140            logErrorFromSSL( );
141
142        /* DH can generate key sizes that are smaller than the size of
143           P with exponentially decreasing probability, in which case
144           the msb's of myPublicKey need to be zeroed appropriately. */
145        len = BN_num_bytes( dh->pub_key );
146        offset = KEY_LEN - len;
147        assert( len <= KEY_LEN );
148        memset( crypto->myPublicKey, 0, offset );
149        BN_bn2bin( dh->pub_key, crypto->myPublicKey + offset );
150
151        crypto->dh = dh;
152    }
153}
154
155tr_crypto *
156tr_cryptoNew( const uint8_t * torrentHash,
157              int             isIncoming )
158{
159    tr_crypto * crypto;
160
161    crypto = tr_new0( tr_crypto, 1 );
162    crypto->isIncoming = isIncoming ? 1 : 0;
163    tr_cryptoSetTorrentHash( crypto, torrentHash );
164    crypto->dh = NULL;
165
166    return crypto;
167}
168
169void
170tr_cryptoFree( tr_crypto * crypto )
171{
172    if( crypto->dh != NULL )
173        DH_free( crypto->dh );
174    tr_free( crypto );
175}
176
177/**
178***
179**/
180
181const uint8_t*
182tr_cryptoComputeSecret( tr_crypto *     crypto,
183                        const uint8_t * peerPublicKey )
184{
185    int      len;
186    uint8_t  secret[KEY_LEN];
187    BIGNUM * bn = BN_bin2bn( peerPublicKey, KEY_LEN, NULL );
188    DH *     dh;
189
190    ensureKeyExists( crypto );
191    dh = crypto->dh;
192
193    assert( DH_size( dh ) == KEY_LEN );
194
195    len = DH_compute_key( secret, bn, dh );
196    if( len == -1 )
197        logErrorFromSSL( );
198    else {
199        int offset;
200        assert( len <= KEY_LEN );
201        offset = KEY_LEN - len;
202        memset( crypto->mySecret, 0, offset );
203        memcpy( crypto->mySecret + offset, secret, len );
204        crypto->mySecretIsSet = 1;
205    }
206
207    BN_free( bn );
208    return crypto->mySecret;
209}
210
211const uint8_t*
212tr_cryptoGetMyPublicKey( const tr_crypto * crypto,
213                         int *             setme_len )
214{
215    ensureKeyExists( (tr_crypto *) crypto );
216    *setme_len = KEY_LEN;
217    return crypto->myPublicKey;
218}
219
220/**
221***
222**/
223
224static void
225initRC4( tr_crypto *  crypto,
226         RC4_KEY *    setme,
227         const char * key )
228{
229    SHA_CTX sha;
230    uint8_t buf[SHA_DIGEST_LENGTH];
231
232    assert( crypto->torrentHashIsSet );
233    assert( crypto->mySecretIsSet );
234
235    if( SHA1_Init( &sha )
236        && SHA1_Update( &sha, key, 4 )
237        && SHA1_Update( &sha, crypto->mySecret, KEY_LEN )
238        && SHA1_Update( &sha, crypto->torrentHash, SHA_DIGEST_LENGTH )
239        && SHA1_Final( buf, &sha ) )
240    {
241        RC4_set_key( setme, SHA_DIGEST_LENGTH, buf );
242    }
243    else
244    {
245        logErrorFromSSL( );
246    }
247}
248
249void
250tr_cryptoDecryptInit( tr_crypto * crypto )
251{
252    unsigned char discard[1024];
253    const char *  txt = crypto->isIncoming ? "keyA" : "keyB";
254
255    initRC4( crypto, &crypto->dec_key, txt );
256    RC4( &crypto->dec_key, sizeof( discard ), discard, discard );
257}
258
259void
260tr_cryptoDecrypt( tr_crypto *  crypto,
261                  size_t       buf_len,
262                  const void * buf_in,
263                  void *       buf_out )
264{
265    RC4( &crypto->dec_key, buf_len,
266         (const unsigned char*)buf_in,
267         (unsigned char*)buf_out );
268}
269
270void
271tr_cryptoEncryptInit( tr_crypto * crypto )
272{
273    unsigned char discard[1024];
274    const char *  txt = crypto->isIncoming ? "keyB" : "keyA";
275
276    initRC4( crypto, &crypto->enc_key, txt );
277    RC4( &crypto->enc_key, sizeof( discard ), discard, discard );
278}
279
280void
281tr_cryptoEncrypt( tr_crypto *  crypto,
282                  size_t       buf_len,
283                  const void * buf_in,
284                  void *       buf_out )
285{
286    RC4( &crypto->enc_key, buf_len,
287         (const unsigned char*)buf_in,
288         (unsigned char*)buf_out );
289}
290
291/**
292***
293**/
294
295void
296tr_cryptoSetTorrentHash( tr_crypto *     crypto,
297                         const uint8_t * hash )
298{
299    crypto->torrentHashIsSet = hash ? 1 : 0;
300
301    if( hash )
302        memcpy( crypto->torrentHash, hash, SHA_DIGEST_LENGTH );
303    else
304        memset( crypto->torrentHash, 0, SHA_DIGEST_LENGTH );
305}
306
307const uint8_t*
308tr_cryptoGetTorrentHash( const tr_crypto * crypto )
309{
310    assert( crypto );
311    assert( crypto->torrentHashIsSet );
312
313    return crypto->torrentHash;
314}
315
316int
317tr_cryptoHasTorrentHash( const tr_crypto * crypto )
318{
319    assert( crypto );
320
321    return crypto->torrentHashIsSet ? 1 : 0;
322}
323
324int
325tr_cryptoRandInt( int upperBound )
326{
327    int noise;
328    int val;
329
330    assert( upperBound > 0 );
331
332    if( RAND_pseudo_bytes ( (unsigned char *) &noise, sizeof noise ) >= 0 )
333    {
334        val = abs( noise ) % upperBound;
335    }
336    else /* fall back to a weaker implementation... */
337    {
338        val = tr_cryptoWeakRandInt( upperBound );
339    }
340
341    return val;
342}
343
344int
345tr_cryptoWeakRandInt( int upperBound )
346{
347    static tr_bool init = FALSE;
348
349    assert( upperBound > 0 );
350
351    if( !init )
352    {
353        srand( tr_date( ) );
354        init = TRUE;
355    }
356
357    return rand( ) % upperBound;
358}
359
360void
361tr_cryptoRandBuf( void * buf, size_t len )
362{
363    if( RAND_pseudo_bytes ( (unsigned char*)buf, len ) != 1 )
364        logErrorFromSSL( );
365}
366
367/***
368****
369***/
370
371char*
372tr_ssha1( const void * plaintext )
373{
374    static const char * salter = "0123456789"
375                                 "abcdefghijklmnopqrstuvwxyz"
376                                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
377                                 "./";
378    const size_t salter_len = 64;
379    const size_t saltval_len = 8;
380
381    size_t i;
382    char salt[saltval_len];
383    uint8_t sha[SHA_DIGEST_LENGTH];
384    char buf[2*SHA_DIGEST_LENGTH + saltval_len + 2];
385
386    for( i=0; i<saltval_len; ++i )
387        salt[i] = salter[ tr_cryptoRandInt( salter_len ) ];
388
389    tr_sha1( sha, plaintext, strlen( plaintext ), salt, saltval_len, NULL );
390    tr_sha1_to_hex( &buf[1], sha );
391    memcpy( &buf[1+2*SHA_DIGEST_LENGTH], &salt, saltval_len );
392    buf[1+2*SHA_DIGEST_LENGTH + saltval_len] = '\0';
393    buf[0] = '{'; /* signal that this is a hash. this makes saving/restoring
394                     easier */
395
396    return tr_strdup( &buf );
397}
398
399tr_bool
400tr_ssha1_matches( const char * source, const char * pass )
401{
402    char * salt;
403    size_t saltlen;
404    char * hashed;
405    uint8_t buf[SHA_DIGEST_LENGTH];
406    tr_bool result;
407
408    /* extract the salt */
409    saltlen = strlen( source ) - 2*SHA_DIGEST_LENGTH-1;
410    salt = tr_malloc( saltlen );
411    memcpy( salt, source + 2*SHA_DIGEST_LENGTH+1, saltlen );
412
413    /* hash pass + salt */
414    hashed = tr_malloc( 2*SHA_DIGEST_LENGTH + saltlen + 2 );
415    tr_sha1( buf, pass, strlen( pass ), salt, saltlen, NULL );
416    tr_sha1_to_hex( &hashed[1], buf );
417    memcpy( hashed + 1+2*SHA_DIGEST_LENGTH, salt, saltlen );
418    hashed[1+2*SHA_DIGEST_LENGTH + saltlen] = '\0';
419    hashed[0] = '{';
420
421    result = strcmp( source, hashed ) == 0 ? TRUE : FALSE;
422
423    tr_free( hashed );
424    tr_free( salt );
425
426    return result;
427}
Note: See TracBrowser for help on using the repository browser.