source: trunk/libtransmission/handshake.c @ 12918

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

(trunk libT) more heap pruning: use composition rather than aggregation for the tr_crypto object owned by tr_peerIo.

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