source: branches/1.4x/libtransmission/handshake.c @ 7341

Last change on this file since 7341 was 7341, checked in by charles, 12 years ago

(1.4x libT) fix minor r7267 oops that could keep us from disconnecting if we made a peer connection to ourself

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