source: trunk/libtransmission/handshake.c @ 12223

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

(trunk) copyediting: remove some unneeded #includes, and annotate some needed ones

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