source: trunk/libtransmission/handshake.c @ 12228

Last change on this file since 12228 was 12228, checked in by jordan, 11 years ago

(trunk libT) still fiddling around with #includes -- this time removing unncecessary libT includes from libT .c files

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