source: trunk/libtransmission/handshake.c @ 8433

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

(trunk) #7: DHT support. This is a work in progress... no gui/rpc support yet

  • Property svn:keywords set to Date Rev Author Id
File size: 37.3 KB
Line 
1/*
2 * This file Copyright (C) 2007-2009 Charles Kerr <charles@transmissionbt.com>
3 *
4 * This file is licensed by the GPL version 2.  Works owned by the
5 * Transmission project are granted a special exemption to clause 2(b)
6 * so that the bulk of its code can remain under the MIT license.
7 * This exemption does not extend to derived works not owned by
8 * the Transmission project.
9 *
10 * $Id: handshake.c 8433 2009-05-19 18:38:26Z charles $
11 */
12
13#include <assert.h>
14#include <errno.h>
15#include <inttypes.h>
16#include <limits.h> /* UCHAR_MAX */
17#include <string.h>
18#include <stdio.h>
19
20#include <event.h>
21
22#include "transmission.h"
23#include "session.h"
24#include "bencode.h"
25#include "clients.h"
26#include "crypto.h"
27#include "handshake.h"
28#include "peer-io.h"
29#include "peer-mgr.h"
30#include "torrent.h"
31#include "tr-dht.h"
32#include "trevent.h"
33#include "utils.h"
34
35/* enable LibTransmission extension protocol */
36#define ENABLE_LTEP * /
37/* fast extensions */
38#define ENABLE_FAST * /
39/* DHT */
40#define ENABLE_DHT * /
41
42/***
43****
44***/
45
46#define HANDSHAKE_NAME "\023BitTorrent protocol"
47
48enum
49{
50    /* BitTorrent Handshake Constants */
51    HANDSHAKE_NAME_LEN             = 20,
52    HANDSHAKE_FLAGS_LEN            = 8,
53    HANDSHAKE_SIZE                 = 68,
54    PEER_ID_LEN                    = 20,
55    INCOMING_HANDSHAKE_LEN         = 48,
56
57    /* Encryption Constants */
58    PadA_MAXLEN                    = 512,
59    PadB_MAXLEN                    = 512,
60    PadC_MAXLEN                    = 512,
61    PadD_MAXLEN                    = 512,
62    VC_LENGTH                      = 8,
63    KEY_LEN                        = 96,
64    CRYPTO_PROVIDE_PLAINTEXT       = 1,
65    CRYPTO_PROVIDE_CRYPTO          = 2,
66
67    /* how long to wait before giving up on a handshake */
68    HANDSHAKE_TIMEOUT_MSEC         = 60 * 1000
69};
70
71
72#ifdef ENABLE_LTEP
73 #define HANDSHAKE_HAS_LTEP( bits ) ( ( ( bits )[5] & 0x10 ) ? 1 : 0 )
74 #define HANDSHAKE_SET_LTEP( bits ) ( ( bits )[5] |= 0x10 )
75#else
76 #define HANDSHAKE_HAS_LTEP( bits ) ( 0 )
77 #define HANDSHAKE_SET_LTEP( bits ) ( (void)0 )
78#endif
79
80#ifdef ENABLE_FAST
81 #define HANDSHAKE_HAS_FASTEXT( bits ) ( ( ( bits )[7] & 0x04 ) ? 1 : 0 )
82 #define HANDSHAKE_SET_FASTEXT( bits ) ( ( bits )[7] |= 0x04 )
83#else
84 #define HANDSHAKE_HAS_FASTEXT( bits ) ( 0 )
85 #define HANDSHAKE_SET_FASTEXT( bits ) ( (void)0 )
86#endif
87
88#ifdef ENABLE_DHT
89 #define HANDSHAKE_HAS_DHT( bits ) ( ( ( bits )[7] & 0x01 ) ? 1 : 0 )
90 #define HANDSHAKE_SET_DHT( bits ) ( ( bits )[7] |= 0x01 )
91#else
92 #define HANDSHAKE_HAS_DHT( bits ) ( 0 )
93 #define HANDSHAKE_SET_DHT( bits ) ( (void)0 )
94#endif
95
96/* http://www.azureuswiki.com/index.php/Extension_negotiation_protocol
97   these macros are to be used if both extended messaging and the
98   azureus protocol is supported, they indicate which protocol is preferred */
99#define HANDSHAKE_GET_EXTPREF( reserved )      ( ( reserved )[5] & 0x03 )
100#define HANDSHAKE_SET_EXTPREF( reserved, val ) ( ( reserved )[5] |= 0x03 &\
101                                                                    ( val ) )
102
103struct tr_handshake
104{
105    tr_bool               havePeerID;
106    tr_bool               haveSentBitTorrentHandshake;
107    tr_peerIo *           io;
108    tr_crypto *           crypto;
109    tr_session *          session;
110    uint8_t               myPublicKey[KEY_LEN];
111    uint8_t               mySecret[KEY_LEN];
112    uint8_t               state;
113    tr_encryption_mode    encryptionMode;
114    uint16_t              pad_c_len;
115    uint16_t              pad_d_len;
116    uint16_t              ia_len;
117    uint32_t              crypto_select;
118    uint32_t              crypto_provide;
119    uint8_t               myReq1[SHA_DIGEST_LENGTH];
120    uint8_t               peer_id[PEER_ID_LEN];
121    handshakeDoneCB       doneCB;
122    void *                doneUserData;
123    tr_timer *            timeout;
124};
125
126/**
127***
128**/
129
130enum
131{
132    /* incoming */
133    AWAITING_HANDSHAKE,
134    AWAITING_PEER_ID,
135    AWAITING_YA,
136    AWAITING_PAD_A,
137    AWAITING_CRYPTO_PROVIDE,
138    AWAITING_PAD_C,
139    AWAITING_IA,
140    AWAITING_PAYLOAD_STREAM,
141
142    /* outgoing */
143    AWAITING_YB,
144    AWAITING_VC,
145    AWAITING_CRYPTO_SELECT,
146    AWAITING_PAD_D,
147};
148
149/**
150***
151**/
152
153#define dbgmsg( handshake, ... ) \
154    do { \
155        if( tr_deepLoggingIsActive( ) ) \
156            tr_deepLog( __FILE__, __LINE__, tr_peerIoGetAddrStr( handshake->io ), __VA_ARGS__ ); \
157    } while( 0 )
158
159static const char*
160getStateName( short state )
161{
162    const char * str = "f00!";
163
164    switch( state )
165    {
166        case AWAITING_HANDSHAKE:
167            str = "awaiting handshake"; break;
168
169        case AWAITING_PEER_ID:
170            str = "awaiting peer id"; break;
171
172        case AWAITING_YA:
173            str = "awaiting ya"; break;
174
175        case AWAITING_PAD_A:
176            str = "awaiting pad a"; break;
177
178        case AWAITING_CRYPTO_PROVIDE:
179            str = "awaiting crypto_provide"; break;
180
181        case AWAITING_PAD_C:
182            str = "awaiting pad c"; break;
183
184        case AWAITING_IA:
185            str = "awaiting ia"; break;
186
187        case AWAITING_YB:
188            str = "awaiting yb"; break;
189
190        case AWAITING_VC:
191            str = "awaiting vc"; break;
192
193        case AWAITING_CRYPTO_SELECT:
194            str = "awaiting crypto select"; break;
195
196        case AWAITING_PAD_D:
197            str = "awaiting pad d"; break;
198    }
199    return str;
200}
201
202static void
203setState( tr_handshake * handshake,
204          short          state )
205{
206    dbgmsg( handshake, "setting to state [%s]", getStateName( state ) );
207    handshake->state = state;
208}
209
210static void
211setReadState( tr_handshake * handshake,
212              int            state )
213{
214    setState( handshake, state );
215}
216
217static uint8_t *
218buildHandshakeMessage( tr_handshake * handshake,
219                       int *          setme_len )
220{
221    uint8_t          * buf = tr_new0( uint8_t, HANDSHAKE_SIZE );
222    uint8_t          * walk = buf;
223    const uint8_t    * torrentHash = tr_cryptoGetTorrentHash( handshake->crypto );
224    const tr_torrent * tor = tr_torrentFindFromHash( handshake->session, torrentHash );
225    const uint8_t    * peer_id = tor && tor->peer_id ? tor->peer_id : tr_getPeerId( );
226
227    memcpy( walk, HANDSHAKE_NAME, HANDSHAKE_NAME_LEN );
228    walk += HANDSHAKE_NAME_LEN;
229    memset( walk, 0, HANDSHAKE_FLAGS_LEN );
230    HANDSHAKE_SET_LTEP( walk );
231    HANDSHAKE_SET_FASTEXT( walk );
232
233    /* Note that this doesn't depend on whether the torrent is private.  We
234       don't accept DHT peers for a private torrent, but we participate in
235       the DHT regardless. */
236    if(tr_dhtEnabled(handshake->session))
237        HANDSHAKE_SET_DHT( walk );
238
239    walk += HANDSHAKE_FLAGS_LEN;
240    memcpy( walk, torrentHash, SHA_DIGEST_LENGTH );
241    walk += SHA_DIGEST_LENGTH;
242    memcpy( walk, peer_id, PEER_ID_LEN );
243    walk += PEER_ID_LEN;
244
245    assert( strlen( ( const char* )peer_id ) == PEER_ID_LEN );
246    assert( walk - buf == HANDSHAKE_SIZE );
247    *setme_len = walk - buf;
248    return buf;
249}
250
251static int tr_handshakeDone( tr_handshake * handshake,
252                             tr_bool        isConnected );
253
254enum
255{
256    HANDSHAKE_OK,
257    HANDSHAKE_ENCRYPTION_WRONG,
258    HANDSHAKE_BAD_TORRENT,
259    HANDSHAKE_PEER_IS_SELF,
260};
261
262static int
263parseHandshake( tr_handshake *    handshake,
264                struct evbuffer * inbuf )
265{
266    uint8_t name[HANDSHAKE_NAME_LEN];
267    uint8_t reserved[HANDSHAKE_FLAGS_LEN];
268    uint8_t hash[SHA_DIGEST_LENGTH];
269    const tr_torrent * tor;
270    const uint8_t * peer_id;
271
272    dbgmsg( handshake, "payload: need %d, got %zu",
273            (int)HANDSHAKE_SIZE, EVBUFFER_LENGTH( inbuf ) );
274
275    if( EVBUFFER_LENGTH( inbuf ) < HANDSHAKE_SIZE )
276        return READ_LATER;
277
278    /* confirm the protocol */
279    tr_peerIoReadBytes( handshake->io, inbuf, name, HANDSHAKE_NAME_LEN );
280    if( memcmp( name, HANDSHAKE_NAME, HANDSHAKE_NAME_LEN ) )
281        return HANDSHAKE_ENCRYPTION_WRONG;
282
283    /* read the reserved bytes */
284    tr_peerIoReadBytes( handshake->io, inbuf, reserved, HANDSHAKE_FLAGS_LEN );
285
286    /* torrent hash */
287    tr_peerIoReadBytes( handshake->io, inbuf, hash, sizeof( hash ) );
288    assert( tr_peerIoHasTorrentHash( handshake->io ) );
289    if( !tr_torrentExists( handshake->session, hash )
290      || memcmp( hash, tr_peerIoGetTorrentHash( handshake->io ),
291                 SHA_DIGEST_LENGTH ) )
292    {
293        dbgmsg( handshake, "peer returned the wrong hash. wtf?" );
294        return HANDSHAKE_BAD_TORRENT;
295    }
296
297    /* peer_id */
298    tr_peerIoReadBytes( handshake->io, inbuf, handshake->peer_id,
299                       sizeof( handshake->peer_id ) );
300    tr_peerIoSetPeersId( handshake->io, handshake->peer_id );
301
302    /* peer id */
303    handshake->havePeerID = TRUE;
304    dbgmsg( handshake, "peer-id is [%*.*s]", PEER_ID_LEN, PEER_ID_LEN,
305            handshake->peer_id );
306
307    tor = tr_torrentFindFromHash( handshake->session, hash );
308    peer_id = tor && tor->peer_id ? tor->peer_id : tr_getPeerId( );
309    if( !memcmp( handshake->peer_id, peer_id, PEER_ID_LEN ) )
310    {
311        dbgmsg( handshake, "streuth!  we've connected to ourselves." );
312        return HANDSHAKE_PEER_IS_SELF;
313    }
314
315    /**
316    *** Extensions
317    **/
318
319    tr_peerIoEnableLTEP( handshake->io, HANDSHAKE_HAS_LTEP( reserved ) );
320
321    tr_peerIoEnableFEXT( handshake->io, HANDSHAKE_HAS_FASTEXT( reserved ) );
322
323    /* This doesn't depend on whether the torrent is private. */
324    if( tor->session->isDHTEnabled )
325        tr_peerIoEnableDHT( handshake->io, HANDSHAKE_HAS_DHT( reserved ) );
326
327    return HANDSHAKE_OK;
328}
329
330/***
331****
332****  OUTGOING CONNECTIONS
333****
334***/
335
336/* 1 A->B: Diffie Hellman Ya, PadA */
337static void
338sendYa( tr_handshake * handshake )
339{
340    int               len;
341    const uint8_t *   public_key;
342    struct evbuffer * outbuf = tr_getBuffer( );
343    uint8_t           pad_a[PadA_MAXLEN];
344
345    /* add our public key (Ya) */
346    public_key = tr_cryptoGetMyPublicKey( handshake->crypto, &len );
347    assert( len == KEY_LEN );
348    assert( public_key );
349    evbuffer_add( outbuf, public_key, len );
350
351    /* add some bullshit padding */
352    len = tr_cryptoRandInt( PadA_MAXLEN );
353    tr_cryptoRandBuf( pad_a, len );
354    evbuffer_add( outbuf, pad_a, len );
355
356    /* send it */
357    setReadState( handshake, AWAITING_YB );
358    tr_peerIoWriteBuf( handshake->io, outbuf, FALSE );
359
360    /* cleanup */
361    tr_releaseBuffer( outbuf );
362}
363
364static uint32_t
365getCryptoProvide( const tr_handshake * handshake )
366{
367    uint32_t provide = 0;
368
369    switch( handshake->encryptionMode )
370    {
371        case TR_ENCRYPTION_REQUIRED:
372        case TR_ENCRYPTION_PREFERRED:
373            provide |= CRYPTO_PROVIDE_CRYPTO;
374            break;
375
376        case TR_CLEAR_PREFERRED:
377            provide |= CRYPTO_PROVIDE_CRYPTO | CRYPTO_PROVIDE_PLAINTEXT;
378            break;
379    }
380
381    return provide;
382}
383
384static uint32_t
385getCryptoSelect( const tr_handshake * handshake,
386                 uint32_t             crypto_provide )
387{
388    uint32_t choices[4];
389    int      i, nChoices = 0;
390
391    switch( handshake->encryptionMode )
392    {
393        case TR_ENCRYPTION_REQUIRED:
394            choices[nChoices++] = CRYPTO_PROVIDE_CRYPTO;
395            break;
396
397        case TR_ENCRYPTION_PREFERRED:
398            choices[nChoices++] = CRYPTO_PROVIDE_CRYPTO;
399            choices[nChoices++] = CRYPTO_PROVIDE_PLAINTEXT;
400            break;
401
402        case TR_CLEAR_PREFERRED:
403            choices[nChoices++] = CRYPTO_PROVIDE_PLAINTEXT;
404            choices[nChoices++] = CRYPTO_PROVIDE_CRYPTO;
405            break;
406    }
407
408    for( i = 0; i < nChoices; ++i )
409        if( crypto_provide & choices[i] )
410            return choices[i];
411
412    return 0;
413}
414
415static int
416readYb( tr_handshake *    handshake,
417        struct evbuffer * inbuf )
418{
419    int               isEncrypted;
420    const uint8_t *   secret;
421    uint8_t           yb[KEY_LEN];
422    struct evbuffer * outbuf;
423    size_t            needlen = HANDSHAKE_NAME_LEN;
424
425    if( EVBUFFER_LENGTH( inbuf ) < needlen )
426        return READ_LATER;
427
428    isEncrypted = memcmp( EVBUFFER_DATA( inbuf ), HANDSHAKE_NAME, HANDSHAKE_NAME_LEN );
429    if( isEncrypted )
430    {
431        needlen = KEY_LEN;
432        if( EVBUFFER_LENGTH( inbuf ) < needlen )
433            return READ_LATER;
434    }
435
436    dbgmsg( handshake, "got a %s handshake",
437           ( isEncrypted ? "encrypted" : "plaintext" ) );
438
439    tr_peerIoSetEncryption( handshake->io, isEncrypted ? PEER_ENCRYPTION_RC4
440                                                       : PEER_ENCRYPTION_NONE );
441    if( !isEncrypted )
442    {
443        setState( handshake, AWAITING_HANDSHAKE );
444        return READ_NOW;
445    }
446
447    /* compute the secret */
448    evbuffer_remove( inbuf, yb, KEY_LEN );
449    secret = tr_cryptoComputeSecret( handshake->crypto, yb );
450    memcpy( handshake->mySecret, secret, KEY_LEN );
451
452    /* now send these: HASH('req1', S), HASH('req2', SKEY) xor HASH('req3', S),
453     * ENCRYPT(VC, crypto_provide, len(PadC), PadC, len(IA)), ENCRYPT(IA) */
454    outbuf = tr_getBuffer( );
455
456    /* HASH('req1', S) */
457    {
458        uint8_t req1[SHA_DIGEST_LENGTH];
459        tr_sha1( req1, "req1", 4, secret, KEY_LEN, NULL );
460        evbuffer_add( outbuf, req1, SHA_DIGEST_LENGTH );
461    }
462
463    /* HASH('req2', SKEY) xor HASH('req3', S) */
464    {
465        int     i;
466        uint8_t req2[SHA_DIGEST_LENGTH];
467        uint8_t req3[SHA_DIGEST_LENGTH];
468        uint8_t buf[SHA_DIGEST_LENGTH];
469        tr_sha1( req2, "req2", 4,
470                 tr_cryptoGetTorrentHash( handshake->crypto ),
471                 SHA_DIGEST_LENGTH, NULL );
472        tr_sha1( req3, "req3", 4, secret, KEY_LEN, NULL );
473        for( i = 0; i < SHA_DIGEST_LENGTH; ++i )
474            buf[i] = req2[i] ^ req3[i];
475        evbuffer_add( outbuf, buf, SHA_DIGEST_LENGTH );
476    }
477
478    /* ENCRYPT(VC, crypto_provide, len(PadC), PadC
479     * PadC is reserved for future extensions to the handshake...
480     * standard practice at this time is for it to be zero-length */
481    {
482        uint8_t vc[VC_LENGTH] = { 0, 0, 0, 0, 0, 0, 0, 0 };
483
484        tr_peerIoWriteBuf( handshake->io, outbuf, FALSE );
485        tr_cryptoEncryptInit( handshake->crypto );
486        tr_peerIoSetEncryption( handshake->io, PEER_ENCRYPTION_RC4 );
487
488        tr_peerIoWriteBytes( handshake->io, outbuf, vc, VC_LENGTH );
489        tr_peerIoWriteUint32( handshake->io, outbuf,
490                             getCryptoProvide( handshake ) );
491        tr_peerIoWriteUint16( handshake->io, outbuf, 0 );
492    }
493
494    /* ENCRYPT len(IA)), ENCRYPT(IA) */
495    {
496        int       msglen;
497        uint8_t * msg = buildHandshakeMessage( handshake, &msglen );
498
499        tr_peerIoWriteUint16( handshake->io, outbuf, msglen );
500        tr_peerIoWriteBytes( handshake->io, outbuf, msg, msglen );
501
502        handshake->haveSentBitTorrentHandshake = 1;
503        tr_free( msg );
504    }
505
506    /* send it */
507    tr_cryptoDecryptInit( handshake->crypto );
508    setReadState( handshake, AWAITING_VC );
509    tr_peerIoWriteBuf( handshake->io, outbuf, FALSE );
510
511    /* cleanup */
512    tr_releaseBuffer( outbuf );
513    return READ_LATER;
514}
515
516static int
517readVC( tr_handshake *    handshake,
518        struct evbuffer * inbuf )
519{
520    const uint8_t key[VC_LENGTH] = { 0, 0, 0, 0, 0, 0, 0, 0 };
521    const int     key_len = VC_LENGTH;
522    uint8_t       tmp[VC_LENGTH];
523
524    /* note: this works w/o having to `unwind' the buffer if
525     * we read too much, but it is pretty brute-force.
526     * it would be nice to make this cleaner. */
527    for( ; ; )
528    {
529        if( EVBUFFER_LENGTH( inbuf ) < VC_LENGTH )
530        {
531            dbgmsg( handshake, "not enough bytes... returning read_more" );
532            return READ_LATER;
533        }
534
535        memcpy( tmp, EVBUFFER_DATA( inbuf ), key_len );
536        tr_cryptoDecryptInit( handshake->crypto );
537        tr_cryptoDecrypt( handshake->crypto, key_len, tmp, tmp );
538        if( !memcmp( tmp, key, key_len ) )
539            break;
540
541        evbuffer_drain( inbuf, 1 );
542    }
543
544    dbgmsg( handshake, "got it!" );
545    evbuffer_drain( inbuf, key_len );
546    setState( handshake, AWAITING_CRYPTO_SELECT );
547    return READ_NOW;
548}
549
550static int
551readCryptoSelect( tr_handshake *    handshake,
552                  struct evbuffer * inbuf )
553{
554    uint32_t     crypto_select;
555    uint16_t     pad_d_len;
556    const size_t needlen = sizeof( uint32_t ) + sizeof( uint16_t );
557
558    if( EVBUFFER_LENGTH( inbuf ) < needlen )
559        return READ_LATER;
560
561    tr_peerIoReadUint32( handshake->io, inbuf, &crypto_select );
562    handshake->crypto_select = crypto_select;
563    dbgmsg( handshake, "crypto select is %d", (int)crypto_select );
564    if( !( crypto_select & getCryptoProvide( handshake ) ) )
565    {
566        dbgmsg( handshake,
567                "peer selected an encryption option we didn't provide" );
568        return tr_handshakeDone( handshake, FALSE );
569    }
570
571    tr_peerIoReadUint16( handshake->io, inbuf, &pad_d_len );
572    dbgmsg( handshake, "pad_d_len is %d", (int)pad_d_len );
573
574    if( pad_d_len > 512 )
575    {
576        dbgmsg( handshake, "encryption handshake: pad_d_len is too long" );
577        return tr_handshakeDone( handshake, FALSE );
578    }
579
580    handshake->pad_d_len = pad_d_len;
581
582    setState( handshake, AWAITING_PAD_D );
583    return READ_NOW;
584}
585
586static int
587readPadD( tr_handshake *    handshake,
588          struct evbuffer * inbuf )
589{
590    const size_t needlen = handshake->pad_d_len;
591    uint8_t *    tmp;
592
593    dbgmsg( handshake, "pad d: need %zu, got %zu",
594            needlen, EVBUFFER_LENGTH( inbuf ) );
595    if( EVBUFFER_LENGTH( inbuf ) < needlen )
596        return READ_LATER;
597
598    tmp = tr_new( uint8_t, needlen );
599    tr_peerIoReadBytes( handshake->io, inbuf, tmp, needlen );
600    tr_free( tmp );
601
602    tr_peerIoSetEncryption( handshake->io,
603                            handshake->crypto_select );
604
605    setState( handshake, AWAITING_HANDSHAKE );
606    return READ_NOW;
607}
608
609/***
610****
611****  INCOMING CONNECTIONS
612****
613***/
614
615static int
616readHandshake( tr_handshake *    handshake,
617               struct evbuffer * inbuf )
618{
619    uint8_t   pstrlen;
620    uint8_t * pstr;
621    uint8_t   reserved[HANDSHAKE_FLAGS_LEN];
622    uint8_t   hash[SHA_DIGEST_LENGTH];
623
624    dbgmsg( handshake, "payload: need %d, got %zu",
625            (int)INCOMING_HANDSHAKE_LEN, EVBUFFER_LENGTH( inbuf ) );
626
627    if( EVBUFFER_LENGTH( inbuf ) < INCOMING_HANDSHAKE_LEN )
628        return READ_LATER;
629
630    pstrlen = EVBUFFER_DATA( inbuf )[0]; /* peek, don't read.  We may be
631                                          handing inbuf to AWAITING_YA */
632
633    if( pstrlen == 19 ) /* unencrypted */
634    {
635        tr_peerIoSetEncryption( handshake->io, PEER_ENCRYPTION_NONE );
636
637        if( handshake->encryptionMode == TR_ENCRYPTION_REQUIRED )
638        {
639            dbgmsg( handshake,
640                    "peer is unencrypted, and we're disallowing that" );
641            return tr_handshakeDone( handshake, FALSE );
642        }
643    }
644    else /* encrypted or corrupt */
645    {
646        tr_peerIoSetEncryption( handshake->io, PEER_ENCRYPTION_RC4 );
647
648        if( tr_peerIoIsIncoming( handshake->io ) )
649        {
650            dbgmsg( handshake,
651                    "I think peer is sending us an encrypted handshake..." );
652            setState( handshake, AWAITING_YA );
653            return READ_NOW;
654        }
655        tr_cryptoDecrypt( handshake->crypto, 1, &pstrlen, &pstrlen );
656
657        if( pstrlen != 19 )
658        {
659            dbgmsg( handshake,
660                    "I think peer has sent us a corrupt handshake..." );
661            return tr_handshakeDone( handshake, FALSE );
662        }
663    }
664
665    evbuffer_drain( inbuf, 1 );
666
667    /* pstr (BitTorrent) */
668    pstr = tr_new( uint8_t, pstrlen + 1 );
669    tr_peerIoReadBytes( handshake->io, inbuf, pstr, pstrlen );
670    pstr[pstrlen] = '\0';
671    if( strcmp( (char*)pstr, "BitTorrent protocol" ) )
672    {
673        tr_free( pstr );
674        return tr_handshakeDone( handshake, FALSE );
675    }
676    tr_free( pstr );
677
678    /* reserved bytes */
679    tr_peerIoReadBytes( handshake->io, inbuf, reserved, sizeof( reserved ) );
680
681    /**
682    *** Extensions
683    **/
684
685    tr_peerIoEnableLTEP( handshake->io, HANDSHAKE_HAS_LTEP( reserved ) );
686
687    tr_peerIoEnableFEXT( handshake->io, HANDSHAKE_HAS_FASTEXT( reserved ) );
688
689    /* torrent hash */
690    tr_peerIoReadBytes( handshake->io, inbuf, hash, sizeof( hash ) );
691    if( tr_peerIoIsIncoming( handshake->io ) )
692    {
693        if( !tr_torrentExists( handshake->session, hash ) )
694        {
695            dbgmsg( handshake, "peer is trying to connect to us for a torrent we don't have." );
696            return tr_handshakeDone( handshake, FALSE );
697        }
698        else
699        {
700            assert( !tr_peerIoHasTorrentHash( handshake->io ) );
701            tr_peerIoSetTorrentHash( handshake->io, hash );
702        }
703    }
704    else /* outgoing */
705    {
706        assert( tr_peerIoHasTorrentHash( handshake->io ) );
707        if( memcmp( hash, tr_peerIoGetTorrentHash( handshake->io ),
708                    SHA_DIGEST_LENGTH ) )
709        {
710            dbgmsg( handshake, "peer returned the wrong hash. wtf?" );
711            return tr_handshakeDone( handshake, FALSE );
712        }
713    }
714
715    /**
716    ***  If it's an incoming message, we need to send a response handshake
717    **/
718
719    if( !handshake->haveSentBitTorrentHandshake )
720    {
721        int       msgSize;
722        uint8_t * msg = buildHandshakeMessage( handshake, &msgSize );
723        tr_peerIoWrite( handshake->io, msg, msgSize, FALSE );
724        tr_free( msg );
725        handshake->haveSentBitTorrentHandshake = 1;
726    }
727
728    setReadState( handshake, AWAITING_PEER_ID );
729    return READ_NOW;
730}
731
732static int
733readPeerId( tr_handshake    * handshake,
734            struct evbuffer * inbuf )
735{
736    int  peerIsGood;
737    char client[128];
738    tr_torrent * tor;
739    const uint8_t * peer_id;
740
741    if( EVBUFFER_LENGTH( inbuf ) < PEER_ID_LEN )
742        return READ_LATER;
743
744    /* peer id */
745    tr_peerIoReadBytes( handshake->io, inbuf, handshake->peer_id, PEER_ID_LEN );
746    tr_peerIoSetPeersId( handshake->io, handshake->peer_id );
747    handshake->havePeerID = TRUE;
748    tr_clientForId( client, sizeof( client ), handshake->peer_id );
749    dbgmsg( handshake, "peer-id is [%s] ... isIncoming is %d", client,
750            tr_peerIoIsIncoming( handshake->io ) );
751
752    /* if we've somehow connected to ourselves, don't keep the connection */
753    tor = tr_torrentFindFromHash( handshake->session, tr_peerIoGetTorrentHash( handshake->io ) );
754    peer_id = tor && tor->peer_id ? tor->peer_id : tr_getPeerId( );
755    peerIsGood = memcmp( handshake->peer_id, peer_id, PEER_ID_LEN ) != 0;
756    dbgmsg( handshake, "isPeerGood == %d", peerIsGood );
757    return tr_handshakeDone( handshake, peerIsGood );
758}
759
760static int
761readYa( tr_handshake *    handshake,
762        struct evbuffer * inbuf )
763{
764    uint8_t        ya[KEY_LEN];
765    uint8_t *      walk, outbuf[KEY_LEN + PadB_MAXLEN];
766    const uint8_t *myKey, *secret;
767    int            len;
768
769    dbgmsg( handshake, "in readYa... need %d, have %zu",
770            (int)KEY_LEN, EVBUFFER_LENGTH( inbuf ) );
771    if( EVBUFFER_LENGTH( inbuf ) < KEY_LEN )
772        return READ_LATER;
773
774    /* read the incoming peer's public key */
775    evbuffer_remove( inbuf, ya, KEY_LEN );
776    secret = tr_cryptoComputeSecret( handshake->crypto, ya );
777    memcpy( handshake->mySecret, secret, KEY_LEN );
778    tr_sha1( handshake->myReq1, "req1", 4, secret, KEY_LEN, NULL );
779
780    dbgmsg( handshake, "sending B->A: Diffie Hellman Yb, PadB" );
781    /* send our public key to the peer */
782    walk = outbuf;
783    myKey = tr_cryptoGetMyPublicKey( handshake->crypto, &len );
784    memcpy( walk, myKey, len );
785    walk += len;
786    len = tr_cryptoRandInt( PadB_MAXLEN );
787    tr_cryptoRandBuf( walk, len );
788    walk += len;
789
790    setReadState( handshake, AWAITING_PAD_A );
791    tr_peerIoWrite( handshake->io, outbuf, walk - outbuf, FALSE );
792    return READ_NOW;
793}
794
795static int
796readPadA( tr_handshake *    handshake,
797          struct evbuffer * inbuf )
798{
799    uint8_t * pch;
800
801    dbgmsg( handshake, "looking to get past pad a... & resync on hash('req',S) ... have %zu bytes",
802            EVBUFFER_LENGTH( inbuf ) );
803    /**
804    *** Resynchronizing on HASH('req1',S)
805    **/
806
807    pch = memchr( EVBUFFER_DATA( inbuf ),
808                 handshake->myReq1[0],
809                 EVBUFFER_LENGTH( inbuf ) );
810    if( pch == NULL )
811    {
812        dbgmsg( handshake, "no luck so far.. draining %zu bytes",
813                EVBUFFER_LENGTH( inbuf ) );
814        evbuffer_drain( inbuf, EVBUFFER_LENGTH( inbuf ) );
815        return READ_LATER;
816    }
817    dbgmsg( handshake, "looking for hash('req',S) ... draining %d bytes",
818           (int)( pch - EVBUFFER_DATA( inbuf ) ) );
819    evbuffer_drain( inbuf, pch - EVBUFFER_DATA( inbuf ) );
820    if( EVBUFFER_LENGTH( inbuf ) < SHA_DIGEST_LENGTH )
821        return READ_LATER;
822    if( memcmp( EVBUFFER_DATA( inbuf ), handshake->myReq1,
823                SHA_DIGEST_LENGTH ) )
824    {
825        dbgmsg( handshake, "draining one more byte" );
826        evbuffer_drain( inbuf, 1 );
827        return READ_NOW;
828    }
829
830    dbgmsg( handshake,
831            "found it... looking setting to awaiting_crypto_provide" );
832    setState( handshake, AWAITING_CRYPTO_PROVIDE );
833    return READ_NOW;
834}
835
836static int
837readCryptoProvide( tr_handshake *    handshake,
838                   struct evbuffer * inbuf )
839{
840    /* HASH('req2', SKEY) xor HASH('req3', S), ENCRYPT(VC, crypto_provide,
841      len(PadC)) */
842
843    int          i;
844    uint8_t      vc_in[VC_LENGTH];
845    uint8_t      req2[SHA_DIGEST_LENGTH];
846    uint8_t      req3[SHA_DIGEST_LENGTH];
847    uint8_t      obfuscatedTorrentHash[SHA_DIGEST_LENGTH];
848    uint16_t     padc_len = 0;
849    uint32_t     crypto_provide = 0;
850    const size_t needlen = SHA_DIGEST_LENGTH /* HASH('req1',s) */
851                           + SHA_DIGEST_LENGTH /* HASH('req2', SKEY) xor
852                                                 HASH('req3', S) */
853                           + VC_LENGTH
854                           + sizeof( crypto_provide )
855                           + sizeof( padc_len );
856    tr_torrent * tor = NULL;
857
858    if( EVBUFFER_LENGTH( inbuf ) < needlen )
859        return READ_LATER;
860
861    /* TODO: confirm they sent HASH('req1',S) here? */
862    evbuffer_drain( inbuf, SHA_DIGEST_LENGTH );
863
864    /* This next piece is HASH('req2', SKEY) xor HASH('req3', S) ...
865     * we can get the first half of that (the obufscatedTorrentHash)
866     * by building the latter and xor'ing it with what the peer sent us */
867    dbgmsg( handshake, "reading obfuscated torrent hash..." );
868    evbuffer_remove( inbuf, req2, SHA_DIGEST_LENGTH );
869    tr_sha1( req3, "req3", 4, handshake->mySecret, KEY_LEN, NULL );
870    for( i = 0; i < SHA_DIGEST_LENGTH; ++i )
871        obfuscatedTorrentHash[i] = req2[i] ^ req3[i];
872    if(( tor = tr_torrentFindFromObfuscatedHash( handshake->session, obfuscatedTorrentHash )))
873    {
874        const tr_bool clientIsSeed = tr_torrentIsSeed( tor );
875        const tr_bool peerIsSeed = tr_peerMgrPeerIsSeed( tor, tr_peerIoGetAddress( handshake->io, NULL ) );
876        dbgmsg( handshake, "got INCOMING connection's encrypted handshake for torrent [%s]",
877                tor->info.name );
878        tr_peerIoSetTorrentHash( handshake->io, tor->info.hash );
879
880        if( clientIsSeed && peerIsSeed )
881        {
882            dbgmsg( handshake, "another seed tried to reconnect to us!" );
883            return tr_handshakeDone( handshake, FALSE );
884        }
885    }
886    else
887    {
888        dbgmsg( handshake, "can't find that torrent..." );
889        return tr_handshakeDone( handshake, FALSE );
890    }
891
892    /* next part: ENCRYPT(VC, crypto_provide, len(PadC), */
893
894    tr_cryptoDecryptInit( handshake->crypto );
895
896    tr_peerIoReadBytes( handshake->io, inbuf, vc_in, VC_LENGTH );
897
898    tr_peerIoReadUint32( handshake->io, inbuf, &crypto_provide );
899    handshake->crypto_provide = crypto_provide;
900    dbgmsg( handshake, "crypto_provide is %d", (int)crypto_provide );
901
902    tr_peerIoReadUint16( handshake->io, inbuf, &padc_len );
903    dbgmsg( handshake, "padc is %d", (int)padc_len );
904    handshake->pad_c_len = padc_len;
905    setState( handshake, AWAITING_PAD_C );
906    return READ_NOW;
907}
908
909static int
910readPadC( tr_handshake *    handshake,
911          struct evbuffer * inbuf )
912{
913    uint16_t     ia_len;
914    const size_t needlen = handshake->pad_c_len + sizeof( uint16_t );
915
916    if( EVBUFFER_LENGTH( inbuf ) < needlen )
917        return READ_LATER;
918
919    evbuffer_drain( inbuf, handshake->pad_c_len );
920
921    tr_peerIoReadUint16( handshake->io, inbuf, &ia_len );
922    dbgmsg( handshake, "ia_len is %d", (int)ia_len );
923    handshake->ia_len = ia_len;
924    setState( handshake, AWAITING_IA );
925    return READ_NOW;
926}
927
928static int
929readIA( tr_handshake *    handshake,
930        struct evbuffer * inbuf )
931{
932    const size_t      needlen = handshake->ia_len;
933    struct evbuffer * outbuf;
934    uint32_t          crypto_select;
935
936    dbgmsg( handshake, "reading IA... have %zu, need %zu",
937            EVBUFFER_LENGTH( inbuf ), needlen );
938    if( EVBUFFER_LENGTH( inbuf ) < needlen )
939        return READ_LATER;
940
941    /**
942    ***  B->A: ENCRYPT(VC, crypto_select, len(padD), padD), ENCRYPT2(Payload Stream)
943    **/
944
945    tr_cryptoEncryptInit( handshake->crypto );
946    outbuf = tr_getBuffer( );
947
948    dbgmsg( handshake, "sending vc" );
949    /* send VC */
950    {
951        uint8_t vc[VC_LENGTH];
952        memset( vc, 0, VC_LENGTH );
953        tr_peerIoWriteBytes( handshake->io, outbuf, vc, VC_LENGTH );
954    }
955
956    /* send crypto_select */
957    crypto_select = getCryptoSelect( handshake, handshake->crypto_provide );
958    if( crypto_select )
959    {
960        dbgmsg( handshake, "selecting crypto mode '%d'", (int)crypto_select );
961        tr_peerIoWriteUint32( handshake->io, outbuf, crypto_select );
962    }
963    else
964    {
965        dbgmsg( handshake, "peer didn't offer an encryption mode we like." );
966        tr_releaseBuffer( outbuf );
967        return tr_handshakeDone( handshake, FALSE );
968    }
969
970    dbgmsg( handshake, "sending pad d" );
971    /* ENCRYPT(VC, crypto_provide, len(PadD), PadD
972     * PadD is reserved for future extensions to the handshake...
973     * standard practice at this time is for it to be zero-length */
974    {
975        const int len = 0;
976        tr_peerIoWriteUint16( handshake->io, outbuf, len );
977    }
978
979    /* maybe de-encrypt our connection */
980    if( crypto_select == CRYPTO_PROVIDE_PLAINTEXT )
981    {
982        tr_peerIoWriteBuf( handshake->io, outbuf, FALSE );
983        tr_peerIoSetEncryption( handshake->io, PEER_ENCRYPTION_NONE );
984    }
985
986    dbgmsg( handshake, "sending handshake" );
987    /* send our handshake */
988    {
989        int       msgSize;
990        uint8_t * msg = buildHandshakeMessage( handshake, &msgSize );
991        tr_peerIoWriteBytes( handshake->io, outbuf, msg, msgSize );
992        handshake->haveSentBitTorrentHandshake = 1;
993        tr_free( msg );
994    }
995
996    /* send it out */
997    tr_peerIoWriteBuf( handshake->io, outbuf, FALSE );
998    tr_releaseBuffer( outbuf );
999
1000    /* now await the handshake */
1001    setState( handshake, AWAITING_PAYLOAD_STREAM );
1002    return READ_NOW;
1003}
1004
1005static int
1006readPayloadStream( tr_handshake    * handshake,
1007                   struct evbuffer * inbuf )
1008{
1009    int i;
1010    const size_t      needlen = HANDSHAKE_SIZE;
1011
1012    dbgmsg( handshake, "reading payload stream... have %zu, need %zu",
1013            EVBUFFER_LENGTH( inbuf ), needlen );
1014    if( EVBUFFER_LENGTH( inbuf ) < needlen )
1015        return READ_LATER;
1016
1017    /* parse the handshake ... */
1018    i = parseHandshake( handshake, inbuf );
1019    dbgmsg( handshake, "parseHandshake returned %d", i );
1020    if( i != HANDSHAKE_OK )
1021        return tr_handshakeDone( handshake, FALSE );
1022
1023    /* we've completed the BT handshake... pass the work on to peer-msgs */
1024    return tr_handshakeDone( handshake, TRUE );
1025}
1026
1027/***
1028****
1029****
1030****
1031***/
1032
1033static ReadState
1034canRead( struct tr_peerIo * io, void * arg, size_t * piece )
1035{
1036    tr_handshake    * handshake = arg;
1037    struct evbuffer * inbuf = tr_peerIoGetReadBuffer( io );
1038    ReadState         ret;
1039    tr_bool           readyForMore = TRUE;
1040
1041    /* no piece data in handshake */
1042    *piece = 0;
1043
1044    dbgmsg( handshake, "handling canRead; state is [%s]",
1045           getStateName( handshake->state ) );
1046
1047    while( readyForMore )
1048    {
1049        switch( handshake->state )
1050        {
1051            case AWAITING_HANDSHAKE:
1052                ret = readHandshake    ( handshake, inbuf ); break;
1053
1054            case AWAITING_PEER_ID:
1055                ret = readPeerId       ( handshake, inbuf ); break;
1056
1057            case AWAITING_YA:
1058                ret = readYa           ( handshake, inbuf ); break;
1059
1060            case AWAITING_PAD_A:
1061                ret = readPadA         ( handshake, inbuf ); break;
1062
1063            case AWAITING_CRYPTO_PROVIDE:
1064                ret = readCryptoProvide( handshake, inbuf ); break;
1065
1066            case AWAITING_PAD_C:
1067                ret = readPadC         ( handshake, inbuf ); break;
1068
1069            case AWAITING_IA:
1070                ret = readIA           ( handshake, inbuf ); break;
1071
1072            case AWAITING_PAYLOAD_STREAM:
1073                ret = readPayloadStream( handshake, inbuf ); break;
1074
1075            case AWAITING_YB:
1076                ret = readYb           ( handshake, inbuf ); break;
1077
1078            case AWAITING_VC:
1079                ret = readVC           ( handshake, inbuf ); break;
1080
1081            case AWAITING_CRYPTO_SELECT:
1082                ret = readCryptoSelect ( handshake, inbuf ); break;
1083
1084            case AWAITING_PAD_D:
1085                ret = readPadD         ( handshake, inbuf ); break;
1086
1087            default:
1088                assert( 0 );
1089        }
1090
1091        if( ret != READ_NOW )
1092            readyForMore = FALSE;
1093        else if( handshake->state == AWAITING_PAD_C )
1094            readyForMore = EVBUFFER_LENGTH( inbuf ) >= handshake->pad_c_len;
1095        else if( handshake->state == AWAITING_PAD_D )
1096            readyForMore = EVBUFFER_LENGTH( inbuf ) >= handshake->pad_d_len;
1097        else if( handshake->state == AWAITING_IA )
1098            readyForMore = EVBUFFER_LENGTH( inbuf ) >= handshake->ia_len;
1099    }
1100
1101    return ret;
1102}
1103
1104static int
1105fireDoneFunc( tr_handshake * handshake,
1106              tr_bool        isConnected )
1107{
1108    const uint8_t * peer_id = isConnected && handshake->havePeerID
1109                              ? handshake->peer_id
1110                              : NULL;
1111    const int       success = ( *handshake->doneCB )( handshake,
1112                                                      handshake->io,
1113                                                      isConnected,
1114                                                      peer_id,
1115                                                      handshake->
1116                                                      doneUserData );
1117
1118    return success;
1119}
1120
1121static void
1122tr_handshakeFree( tr_handshake * handshake )
1123{
1124    if( handshake->io )
1125        tr_peerIoUnref( handshake->io ); /* balanced by the ref in tr_handshakeNew */
1126
1127    tr_timerFree( &handshake->timeout );
1128
1129    tr_free( handshake );
1130}
1131
1132static int
1133tr_handshakeDone( tr_handshake * handshake,
1134                  tr_bool        isOK )
1135{
1136    tr_bool success;
1137
1138    dbgmsg( handshake, "handshakeDone: %s", isOK ? "connected" : "aborting" );
1139    tr_peerIoSetIOFuncs( handshake->io, NULL, NULL, NULL, NULL );
1140
1141    success = fireDoneFunc( handshake, isOK );
1142
1143    tr_handshakeFree( handshake );   
1144
1145    return success ? READ_LATER : READ_ERR;
1146}
1147
1148void
1149tr_handshakeAbort( tr_handshake * handshake )
1150{
1151    tr_handshakeDone( handshake, FALSE );
1152}
1153
1154static void
1155gotError( tr_peerIo  * io UNUSED,
1156          short        what,
1157          void       * arg )
1158{
1159    tr_handshake * handshake = (tr_handshake *) arg;
1160
1161    /* if the error happened while we were sending a public key, we might
1162     * have encountered a peer that doesn't do encryption... reconnect and
1163     * try a plaintext handshake */
1164    if( ( ( handshake->state == AWAITING_YB )
1165        || ( handshake->state == AWAITING_VC ) )
1166      && ( handshake->encryptionMode != TR_ENCRYPTION_REQUIRED )
1167      && ( !tr_peerIoReconnect( handshake->io ) ) )
1168    {
1169        int       msgSize;
1170        uint8_t * msg;
1171        dbgmsg( handshake, "handshake failed, trying plaintext..." );
1172        msg = buildHandshakeMessage( handshake, &msgSize );
1173        handshake->haveSentBitTorrentHandshake = 1;
1174        setReadState( handshake, AWAITING_HANDSHAKE );
1175        tr_peerIoWrite( handshake->io, msg, msgSize, FALSE );
1176        tr_free( msg );
1177    }
1178    else
1179    {
1180        dbgmsg( handshake, "libevent got an error what==%d, errno=%d (%s)",
1181               (int)what, errno, tr_strerror( errno ) );
1182        tr_handshakeDone( handshake, FALSE );
1183    }
1184}
1185
1186/**
1187***
1188**/
1189
1190static int
1191handshakeTimeout( void * handshake )
1192{
1193    tr_handshakeAbort( handshake );
1194    return FALSE;
1195}
1196
1197tr_handshake*
1198tr_handshakeNew( tr_peerIo *        io,
1199                 tr_encryption_mode encryptionMode,
1200                 handshakeDoneCB    doneCB,
1201                 void *             doneUserData )
1202{
1203    tr_handshake * handshake;
1204
1205    handshake = tr_new0( tr_handshake, 1 );
1206    handshake->io = io;
1207    handshake->crypto = tr_peerIoGetCrypto( io );
1208    handshake->encryptionMode = encryptionMode;
1209    handshake->doneCB = doneCB;
1210    handshake->doneUserData = doneUserData;
1211    handshake->session = tr_peerIoGetSession( io );
1212    handshake->timeout = tr_timerNew( handshake->session, handshakeTimeout, handshake, HANDSHAKE_TIMEOUT_MSEC );
1213
1214    tr_peerIoRef( io ); /* balanced by the unref in tr_handshakeFree */
1215    tr_peerIoSetIOFuncs( handshake->io, canRead, NULL, gotError, handshake );
1216    tr_peerIoSetEncryption( io, PEER_ENCRYPTION_NONE );
1217
1218    if( tr_peerIoIsIncoming( handshake->io ) )
1219        setReadState( handshake, AWAITING_HANDSHAKE );
1220    else if( encryptionMode != TR_CLEAR_PREFERRED )
1221        sendYa( handshake );
1222    else
1223    {
1224        int       msgSize;
1225        uint8_t * msg = buildHandshakeMessage( handshake, &msgSize );
1226        handshake->haveSentBitTorrentHandshake = 1;
1227        setReadState( handshake, AWAITING_HANDSHAKE );
1228        tr_peerIoWrite( handshake->io, msg, msgSize, FALSE );
1229        tr_free( msg );
1230    }
1231
1232    return handshake;
1233}
1234
1235struct tr_peerIo*
1236tr_handshakeGetIO( tr_handshake * handshake )
1237{
1238    assert( handshake );
1239    assert( handshake->io );
1240
1241    return handshake->io;
1242}
1243
1244struct tr_peerIo*
1245tr_handshakeStealIO( tr_handshake * handshake )
1246{
1247    struct tr_peerIo * io;
1248
1249    assert( handshake );
1250    assert( handshake->io );
1251
1252    io = handshake->io;
1253    handshake->io = NULL;
1254    return io;
1255}
1256
1257const tr_address *
1258tr_handshakeGetAddr( const struct tr_handshake * handshake,
1259                     tr_port                   * port )
1260{
1261    assert( handshake );
1262    assert( handshake->io );
1263
1264    return tr_peerIoGetAddress( handshake->io, port );
1265}
1266
Note: See TracBrowser for help on using the repository browser.