source: branches/1.5x/libtransmission/crypto.c @ 7863

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

(1.5x libT) crash in tr_cryptoComputeSecret()

  • Property svn:keywords set to Date Rev Author Id
File size: 7.7 KB
RevLine 
[7863]1/* * This file Copyright (C) 2007-2009 Charles Kerr <charles@transmissionbt.com>
[2936]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)
[6795]5 * so that the bulk of its code can remain under the MIT license.
[2936]6 * This exemption does not extend to derived works not owned by
7 * the Transmission project.
8 *
[2938]9 * $Id: crypto.c 7863 2009-02-10 15:57:31Z charles $
[2936]10 */
11
[6517]12#include <stdlib.h> /* for abs() */
[6518]13#include <limits.h> /* for INT_MAX */
[6795]14#include <sys/types.h> /* for event.h, as well as netinet/in.h on some platforms
15                         */
[3775]16#include <assert.h>
[2936]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>
[7863]23#include <openssl/err.h>
[2936]24#include <openssl/rc4.h>
25#include <openssl/sha.h>
[6517]26#include <openssl/rand.h>
[2936]27
28#include <event.h>
[3554]29
[2938]30#include "crypto.h"
[2936]31#include "utils.h"
32
[7863]33#define MY_NAME "tr_crypto"
34
[2936]35/**
36***
37**/
38
39void
[6795]40tr_sha1( uint8_t *    setme,
[2936]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 );
[6795]52    for( ; ; )
53    {
[2936]54        const void * content = (const void*) va_arg( vl, const void* );
[6795]55        const int    content_len = content ? (int) va_arg( vl, int ) : -1;
56        if( content == NULL || content_len < 1 )
[2936]57            break;
58        SHA1_Update( &sha, content, content_len );
59    }
[6480]60    va_end( vl );
[2936]61    SHA1_Final( setme, &sha );
62}
63
64/**
65***
66**/
67
68#define KEY_LEN 96
69
70#define PRIME_LEN 96
71
72static const uint8_t dh_P[PRIME_LEN] =
73{
74    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x0F, 0xDA, 0xA2,
75    0x21, 0x68, 0xC2, 0x34, 0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1,
76    0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74, 0x02, 0x0B, 0xBE, 0xA6,
77    0x3B, 0x13, 0x9B, 0x22, 0x51, 0x4A, 0x08, 0x79, 0x8E, 0x34, 0x04, 0xDD,
78    0xEF, 0x95, 0x19, 0xB3, 0xCD, 0x3A, 0x43, 0x1B, 0x30, 0x2B, 0x0A, 0x6D,
79    0xF2, 0x5F, 0x14, 0x37, 0x4F, 0xE1, 0x35, 0x6D, 0x6D, 0x51, 0xC2, 0x45,
80    0xE4, 0x85, 0xB5, 0x76, 0x62, 0x5E, 0x7E, 0xC6, 0xF4, 0x4C, 0x42, 0xE9,
81    0xA6, 0x3A, 0x36, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x05, 0x63,
82};
83
84static const uint8_t dh_G[] = { 2 };
85
[2938]86struct tr_crypto
[2936]87{
[6795]88    RC4_KEY         dec_key;
89    RC4_KEY         enc_key;
90    uint8_t         torrentHash[SHA_DIGEST_LENGTH];
[7664]91    tr_bool         isIncoming;
92    tr_bool         torrentHashIsSet;
93    tr_bool         mySecretIsSet;
[6795]94    uint8_t         myPublicKey[KEY_LEN];
95    uint8_t         mySecret[KEY_LEN];
[2936]96};
97
[3405]98/**
99***
100**/
101
[7863]102#define logErrorFromSSL( ... ) \
103    do { \
104        if( tr_msgLoggingIsActive( TR_MSG_ERR ) ) { \
105            char buf[512]; \
106            ERR_error_string_n( ERR_get_error( ), buf, sizeof( buf ) ); \
107            tr_msg( __FILE__, __LINE__, TR_MSG_ERR, MY_NAME, "%s", buf ); \
108        } \
109    } while( 0 )
110
[3405]111static DH*
112getSharedDH( void )
[3360]113{
[3405]114    static DH * dh = NULL;
115
116    if( dh == NULL )
[3360]117    {
[3405]118        dh = DH_new( );
[7863]119
[6795]120        dh->p = BN_bin2bn( dh_P, sizeof( dh_P ), NULL );
[7863]121        if( dh->p == NULL )
122            logErrorFromSSL( );
123
[6795]124        dh->g = BN_bin2bn( dh_G, sizeof( dh_G ), NULL );
[7863]125        if( dh->g == NULL )
126            logErrorFromSSL( );
127
128        if( !DH_generate_key( dh ) )
129            logErrorFromSSL( );
[3405]130    }
[3360]131
[3405]132    return dh;
[3360]133}
134
[6795]135tr_crypto *
[2938]136tr_cryptoNew( const uint8_t * torrentHash,
137              int             isIncoming )
[2936]138{
[6795]139    int         len, offset;
[2938]140    tr_crypto * crypto;
[6795]141    DH *        dh = getSharedDH( );
[2936]142
[2938]143    crypto = tr_new0( tr_crypto, 1 );
144    crypto->isIncoming = isIncoming ? 1 : 0;
145    tr_cryptoSetTorrentHash( crypto, torrentHash );
[3405]146
147    /* DH can generate key sizes that are smaller than the size of
148       P with exponentially decreasing probability, in which case
149       the msb's of myPublicKey need to be zeroed appropriately. */
150    len = DH_size( dh );
151    offset = KEY_LEN - len;
152    assert( len <= KEY_LEN );
153    memset( crypto->myPublicKey, 0, offset );
154    BN_bn2bin( dh->pub_key, crypto->myPublicKey + offset );
155
[2938]156    return crypto;
[2936]157}
158
159void
[2938]160tr_cryptoFree( tr_crypto * crypto )
[2936]161{
[2938]162    tr_free( crypto );
[2936]163}
164
165/**
166***
167**/
168
169const uint8_t*
[6795]170tr_cryptoComputeSecret( tr_crypto *     crypto,
171                        const uint8_t * peerPublicKey )
[2936]172{
[7863]173    int      len;
[6795]174    uint8_t  secret[KEY_LEN];
[2936]175    BIGNUM * bn = BN_bin2bn( peerPublicKey, KEY_LEN, NULL );
[6795]176    DH *     dh = getSharedDH( );
[2936]177
[6795]178    assert( DH_size( dh ) == KEY_LEN );
179
[3405]180    len = DH_compute_key( secret, bn, dh );
[7863]181    if( len == -1 )
182        logErrorFromSSL( );
183    else {
184        int offset;
185        assert( len <= KEY_LEN );
186        offset = KEY_LEN - len;
187        memset( crypto->mySecret, 0, offset );
188        memcpy( crypto->mySecret + offset, secret, len );
189        crypto->mySecretIsSet = 1;
190    }
[6795]191
[2936]192    BN_free( bn );
[2938]193    return crypto->mySecret;
[2936]194}
195
196const uint8_t*
[6795]197tr_cryptoGetMyPublicKey( const tr_crypto * crypto,
198                         int *             setme_len )
[2936]199{
200    *setme_len = KEY_LEN;
[2938]201    return crypto->myPublicKey;
[2936]202}
203
204/**
205***
206**/
207
208static void
[6795]209initRC4( tr_crypto *  crypto,
210         RC4_KEY *    setme,
211         const char * key )
[2936]212{
213    SHA_CTX sha;
214    uint8_t buf[SHA_DIGEST_LENGTH];
215
[2938]216    assert( crypto->torrentHashIsSet );
217    assert( crypto->mySecretIsSet );
[2936]218
[7863]219    if( SHA1_Init( &sha )
220        && SHA1_Update( &sha, key, 4 )
221        && SHA1_Update( &sha, crypto->mySecret, KEY_LEN )
222        && SHA1_Update( &sha, crypto->torrentHash, SHA_DIGEST_LENGTH )
223        && SHA1_Final( buf, &sha ) )
224    {
225        RC4_set_key( setme, SHA_DIGEST_LENGTH, buf );
226    }
227    else
228    {
229        logErrorFromSSL( );
230    }
[2936]231}
232
233void
[2938]234tr_cryptoDecryptInit( tr_crypto * crypto )
[2936]235{
236    unsigned char discard[1024];
[6795]237    const char *  txt = crypto->isIncoming ? "keyA" : "keyB";
238
[2938]239    initRC4( crypto, &crypto->dec_key, txt );
[6795]240    RC4( &crypto->dec_key, sizeof( discard ), discard, discard );
[2936]241}
242
243void
[6795]244tr_cryptoDecrypt( tr_crypto *  crypto,
[2938]245                  size_t       buf_len,
246                  const void * buf_in,
[6795]247                  void *       buf_out )
[2936]248{
[2938]249    RC4( &crypto->dec_key, buf_len,
[2936]250         (const unsigned char*)buf_in,
251         (unsigned char*)buf_out );
252}
253
254void
[2938]255tr_cryptoEncryptInit( tr_crypto * crypto )
[2936]256{
257    unsigned char discard[1024];
[6795]258    const char *  txt = crypto->isIncoming ? "keyB" : "keyA";
259
[2938]260    initRC4( crypto, &crypto->enc_key, txt );
[6795]261    RC4( &crypto->enc_key, sizeof( discard ), discard, discard );
[2936]262}
263
264void
[6795]265tr_cryptoEncrypt( tr_crypto *  crypto,
[2938]266                  size_t       buf_len,
267                  const void * buf_in,
[6795]268                  void *       buf_out )
[2936]269{
[2938]270    RC4( &crypto->enc_key, buf_len,
[2936]271         (const unsigned char*)buf_in,
272         (unsigned char*)buf_out );
273}
274
275/**
276***
277**/
278
279void
[6795]280tr_cryptoSetTorrentHash( tr_crypto *     crypto,
[2938]281                         const uint8_t * hash )
[2936]282{
[2938]283    crypto->torrentHashIsSet = hash ? 1 : 0;
[2936]284
[6425]285    if( hash )
[2938]286        memcpy( crypto->torrentHash, hash, SHA_DIGEST_LENGTH );
[2936]287    else
[2938]288        memset( crypto->torrentHash, 0, SHA_DIGEST_LENGTH );
[2936]289}
290
291const uint8_t*
[2938]292tr_cryptoGetTorrentHash( const tr_crypto * crypto )
[2936]293{
[6425]294    assert( crypto );
[2938]295    assert( crypto->torrentHashIsSet );
[2936]296
[2938]297    return crypto->torrentHash;
[2936]298}
[2985]299
300int
301tr_cryptoHasTorrentHash( const tr_crypto * crypto )
302{
[6425]303    assert( crypto );
[2985]304
305    return crypto->torrentHashIsSet ? 1 : 0;
306}
[6517]307
[6652]308int
309tr_cryptoRandInt( int sup )
[6517]310{
311    int r;
312
[6795]313    RAND_pseudo_bytes ( (unsigned char *) &r, sizeof r );
[6517]314
[6795]315    return (int) ( sup * ( abs( r ) / ( INT_MAX + 1.0 ) ) );
[6517]316}
317
[6652]318int
319tr_cryptoWeakRandInt( int sup )
320{
321    static int init = 0;
[6795]322
[6652]323    assert( sup > 0 );
324
325    if( !init )
326    {
327        srand( tr_date( ) );
328        init = 1;
329    }
330
[6795]331    return rand( ) % sup;
[6652]332}
333
[6795]334void
335tr_cryptoRandBuf( unsigned char *buf,
336                  size_t         len )
[6517]337{
[7863]338    if( RAND_pseudo_bytes ( buf, len ) != 1 )
339        logErrorFromSSL( );
[6517]340}
341
Note: See TracBrowser for help on using the repository browser.