source: trunk/libtransmission/handshake.c @ 7154

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

(libT) yet another stab at getting bandwidth management under control. this version may suck less than previous attempts. It also breaks the mac build until someone adds iobuf.[ch] to xcode...

  • Property svn:keywords set to Date Rev Author Id
File size: 35.7 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 7154 2008-11-25 21:35:17Z 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    unsigned int          havePeerID                  : 1;
93    unsigned int          haveSentBitTorrentHandshake : 1;
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(
210        handshake->crypto );
211    const uint8_t * peerId = 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, peerId, PEER_ID_LEN );
223    walk += PEER_ID_LEN;
224
225    assert( strlen( ( const char* )peerId ) == 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
250    dbgmsg( handshake, "payload: need %d, got %d", (int)HANDSHAKE_SIZE,
251           (int)EVBUFFER_LENGTH( inbuf ) );
252
253    if( EVBUFFER_LENGTH( inbuf ) < HANDSHAKE_SIZE )
254        return READ_LATER;
255
256    /* confirm the protocol */
257    tr_peerIoReadBytes( handshake->io, inbuf, name, HANDSHAKE_NAME_LEN );
258    if( memcmp( name, HANDSHAKE_NAME, HANDSHAKE_NAME_LEN ) )
259        return HANDSHAKE_ENCRYPTION_WRONG;
260
261    /* read the reserved bytes */
262    tr_peerIoReadBytes( handshake->io, inbuf, reserved, HANDSHAKE_FLAGS_LEN );
263
264    /* torrent hash */
265    tr_peerIoReadBytes( handshake->io, inbuf, hash, sizeof( hash ) );
266    assert( tr_peerIoHasTorrentHash( handshake->io ) );
267    if( !tr_torrentExists( handshake->handle, hash )
268      || memcmp( hash, tr_peerIoGetTorrentHash( handshake->io ),
269                 SHA_DIGEST_LENGTH ) )
270    {
271        dbgmsg( handshake, "peer returned the wrong hash. wtf?" );
272        return HANDSHAKE_BAD_TORRENT;
273    }
274
275    /* peer_id */
276    tr_peerIoReadBytes( handshake->io, inbuf, handshake->peer_id,
277                       sizeof( handshake->peer_id ) );
278    tr_peerIoSetPeersId( handshake->io, handshake->peer_id );
279
280    /* peer id */
281    handshake->havePeerID = TRUE;
282    dbgmsg( handshake, "peer-id is [%*.*s]", PEER_ID_LEN, PEER_ID_LEN,
283            handshake->peer_id );
284    if( !memcmp( handshake->peer_id, tr_getPeerId( ), PEER_ID_LEN ) )
285    {
286        dbgmsg( handshake, "streuth!  we've connected to ourselves." );
287        return HANDSHAKE_PEER_IS_SELF;
288    }
289
290    /**
291    *** Extensions
292    **/
293
294    if( HANDSHAKE_HAS_LTEP( reserved ) )
295    {
296        tr_peerIoEnableLTEP( handshake->io, 1 );
297        dbgmsg( handshake, "using ltep" );
298    }
299
300    if( HANDSHAKE_HAS_FASTEXT( reserved ) )
301    {
302        tr_peerIoEnableFEXT( handshake->io, 1 );
303        dbgmsg( handshake, "using fext" );
304    }
305
306    return HANDSHAKE_OK;
307}
308
309/***
310****
311****  OUTGOING CONNECTIONS
312****
313***/
314
315/* 1 A->B: Diffie Hellman Ya, PadA */
316static void
317sendYa( tr_handshake * handshake )
318{
319    int               len;
320    const uint8_t *   public_key;
321    struct evbuffer * outbuf = evbuffer_new( );
322    uint8_t           pad_a[PadA_MAXLEN];
323
324    /* add our public key (Ya) */
325    public_key = tr_cryptoGetMyPublicKey( handshake->crypto, &len );
326    assert( len == KEY_LEN );
327    assert( public_key );
328    evbuffer_add( outbuf, public_key, len );
329
330    /* add some bullshit padding */
331    len = tr_cryptoRandInt( PadA_MAXLEN );
332    tr_cryptoRandBuf( pad_a, len );
333    evbuffer_add( outbuf, pad_a, len );
334
335    /* send it */
336    setReadState( handshake, AWAITING_YB );
337    tr_peerIoWriteBuf( handshake->io, outbuf, FALSE );
338
339    /* cleanup */
340    evbuffer_free( outbuf );
341}
342
343static uint32_t
344getCryptoProvide( const tr_handshake * handshake )
345{
346    uint32_t provide = 0;
347
348    switch( handshake->encryptionMode )
349    {
350        case TR_ENCRYPTION_REQUIRED:
351        case TR_ENCRYPTION_PREFERRED:
352            provide |= CRYPTO_PROVIDE_CRYPTO;
353            break;
354
355        case TR_CLEAR_PREFERRED:
356            provide |= CRYPTO_PROVIDE_CRYPTO | CRYPTO_PROVIDE_PLAINTEXT;
357            break;
358    }
359
360    return provide;
361}
362
363static uint32_t
364getCryptoSelect( const tr_handshake * handshake,
365                 uint32_t             crypto_provide )
366{
367    uint32_t choices[4];
368    int      i, nChoices = 0;
369
370    switch( handshake->encryptionMode )
371    {
372        case TR_ENCRYPTION_REQUIRED:
373            choices[nChoices++] = CRYPTO_PROVIDE_CRYPTO;
374            break;
375
376        case TR_ENCRYPTION_PREFERRED:
377            choices[nChoices++] = CRYPTO_PROVIDE_CRYPTO;
378            choices[nChoices++] = CRYPTO_PROVIDE_PLAINTEXT;
379            break;
380
381        case TR_CLEAR_PREFERRED:
382            choices[nChoices++] = CRYPTO_PROVIDE_PLAINTEXT;
383            choices[nChoices++] = CRYPTO_PROVIDE_CRYPTO;
384            break;
385    }
386
387    for( i = 0; i < nChoices; ++i )
388        if( crypto_provide & choices[i] )
389            return choices[i];
390
391    return 0;
392}
393
394static int
395readYb( tr_handshake *    handshake,
396        struct evbuffer * inbuf )
397{
398    int               isEncrypted;
399    const uint8_t *   secret;
400    uint8_t           yb[KEY_LEN];
401    struct evbuffer * outbuf;
402    size_t            needlen = HANDSHAKE_NAME_LEN;
403
404    if( EVBUFFER_LENGTH( inbuf ) < needlen )
405        return READ_LATER;
406
407    isEncrypted = memcmp( EVBUFFER_DATA(
408                              inbuf ), HANDSHAKE_NAME, HANDSHAKE_NAME_LEN );
409    if( isEncrypted )
410    {
411        needlen = KEY_LEN;
412        if( EVBUFFER_LENGTH( inbuf ) < needlen )
413            return READ_LATER;
414    }
415
416    dbgmsg( handshake, "got a %s handshake",
417           ( isEncrypted ? "encrypted" : "plaintext" ) );
418
419    tr_peerIoSetEncryption(
420        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    /* compute the secret */
429    evbuffer_remove( inbuf, yb, KEY_LEN );
430    secret = tr_cryptoComputeSecret( handshake->crypto, yb );
431    memcpy( handshake->mySecret, secret, KEY_LEN );
432
433    /* now send these: HASH('req1', S), HASH('req2', SKEY) xor HASH('req3', S),
434     * ENCRYPT(VC, crypto_provide, len(PadC), PadC, len(IA)), ENCRYPT(IA) */
435    outbuf = evbuffer_new( );
436
437    /* HASH('req1', S) */
438    {
439        uint8_t req1[SHA_DIGEST_LENGTH];
440        tr_sha1( req1, "req1", 4, secret, KEY_LEN, NULL );
441        evbuffer_add( outbuf, req1, SHA_DIGEST_LENGTH );
442    }
443
444    /* HASH('req2', SKEY) xor HASH('req3', S) */
445    {
446        int     i;
447        uint8_t req2[SHA_DIGEST_LENGTH];
448        uint8_t req3[SHA_DIGEST_LENGTH];
449        uint8_t buf[SHA_DIGEST_LENGTH];
450        tr_sha1( req2, "req2", 4,
451                 tr_cryptoGetTorrentHash(
452                     handshake->crypto ), SHA_DIGEST_LENGTH, NULL );
453        tr_sha1( req3, "req3", 4, secret, KEY_LEN, NULL );
454        for( i = 0; i < SHA_DIGEST_LENGTH; ++i )
455            buf[i] = req2[i] ^ req3[i];
456        evbuffer_add( outbuf, buf, SHA_DIGEST_LENGTH );
457    }
458
459    /* ENCRYPT(VC, crypto_provide, len(PadC), PadC
460     * PadC is reserved for future extensions to the handshake...
461     * standard practice at this time is for it to be zero-length */
462    {
463        uint8_t vc[VC_LENGTH] = { 0, 0, 0, 0, 0, 0, 0, 0 };
464
465        tr_cryptoEncryptInit( handshake->crypto );
466        tr_peerIoSetEncryption( handshake->io, PEER_ENCRYPTION_RC4 );
467
468        tr_peerIoWriteBytes( handshake->io, outbuf, vc, VC_LENGTH );
469        tr_peerIoWriteUint32( handshake->io, outbuf,
470                             getCryptoProvide( handshake ) );
471        tr_peerIoWriteUint16( handshake->io, outbuf, 0 );
472    }
473
474    /* ENCRYPT len(IA)), ENCRYPT(IA) */
475    {
476        int       msglen;
477        uint8_t * msg = buildHandshakeMessage( handshake, &msglen );
478
479        tr_peerIoWriteUint16( handshake->io, outbuf, msglen );
480        tr_peerIoWriteBytes( handshake->io, outbuf, msg, msglen );
481
482        handshake->haveSentBitTorrentHandshake = 1;
483        tr_free( msg );
484    }
485
486    /* send it */
487    tr_cryptoDecryptInit( handshake->crypto );
488    setReadState( handshake, AWAITING_VC );
489    tr_peerIoWriteBuf( handshake->io, outbuf, FALSE );
490
491    /* cleanup */
492    evbuffer_free( outbuf );
493    return READ_LATER;
494}
495
496static int
497readVC( tr_handshake *    handshake,
498        struct evbuffer * inbuf )
499{
500    const uint8_t key[VC_LENGTH] = { 0, 0, 0, 0, 0, 0, 0, 0 };
501    const int     key_len = VC_LENGTH;
502    uint8_t       tmp[VC_LENGTH];
503
504    /* note: this works w/o having to `unwind' the buffer if
505     * we read too much, but it is pretty brute-force.
506     * it would be nice to make this cleaner. */
507    for( ; ; )
508    {
509        if( EVBUFFER_LENGTH( inbuf ) < VC_LENGTH )
510        {
511            dbgmsg( handshake, "not enough bytes... returning read_more" );
512            return READ_LATER;
513        }
514
515        memcpy( tmp, EVBUFFER_DATA( inbuf ), key_len );
516        tr_cryptoDecryptInit( handshake->crypto );
517        tr_cryptoDecrypt( handshake->crypto, key_len, tmp, tmp );
518        if( !memcmp( tmp, key, key_len ) )
519            break;
520
521        evbuffer_drain( inbuf, 1 );
522    }
523
524    dbgmsg( handshake, "got it!" );
525    evbuffer_drain( inbuf, key_len );
526    setState( handshake, AWAITING_CRYPTO_SELECT );
527    return READ_NOW;
528}
529
530static int
531readCryptoSelect( tr_handshake *    handshake,
532                  struct evbuffer * inbuf )
533{
534    uint32_t     crypto_select;
535    uint16_t     pad_d_len;
536    const size_t needlen = sizeof( uint32_t ) + sizeof( uint16_t );
537
538    if( EVBUFFER_LENGTH( inbuf ) < needlen )
539        return READ_LATER;
540
541    tr_peerIoReadUint32( handshake->io, inbuf, &crypto_select );
542    handshake->crypto_select = crypto_select;
543    dbgmsg( handshake, "crypto select is %d", (int)crypto_select );
544    if( !( crypto_select & getCryptoProvide( handshake ) ) )
545    {
546        dbgmsg( handshake,
547                "peer selected an encryption option we didn't provide" );
548        return tr_handshakeDone( handshake, FALSE );
549    }
550
551    tr_peerIoReadUint16( handshake->io, inbuf, &pad_d_len );
552    dbgmsg( handshake, "pad_d_len is %d", (int)pad_d_len );
553
554    if( pad_d_len > 512 )
555    {
556        dbgmsg( handshake, "encryption handshake: pad_d_len is too long" );
557        return tr_handshakeDone( handshake, FALSE );
558    }
559
560    handshake->pad_d_len = pad_d_len;
561
562    setState( handshake, AWAITING_PAD_D );
563    return READ_NOW;
564}
565
566static int
567readPadD( tr_handshake *    handshake,
568          struct evbuffer * inbuf )
569{
570    const size_t needlen = handshake->pad_d_len;
571    uint8_t *    tmp;
572
573    dbgmsg( handshake, "pad d: need %d, got %d", (int)needlen,
574           (int)EVBUFFER_LENGTH(
575               inbuf ) );
576    if( EVBUFFER_LENGTH( inbuf ) < needlen )
577        return READ_LATER;
578
579    tmp = tr_new( uint8_t, needlen );
580    tr_peerIoReadBytes( handshake->io, inbuf, tmp, needlen );
581    tr_free( tmp );
582
583    tr_peerIoSetEncryption( handshake->io,
584                            handshake->crypto_select );
585
586    setState( handshake, AWAITING_HANDSHAKE );
587    return READ_NOW;
588}
589
590/***
591****
592****  INCOMING CONNECTIONS
593****
594***/
595
596static int
597readHandshake( tr_handshake *    handshake,
598               struct evbuffer * inbuf )
599{
600    uint8_t   pstrlen;
601    uint8_t * pstr;
602    uint8_t   reserved[HANDSHAKE_FLAGS_LEN];
603    uint8_t   hash[SHA_DIGEST_LENGTH];
604
605    dbgmsg( handshake, "payload: need %d, got %d",
606           (int)INCOMING_HANDSHAKE_LEN, (int)EVBUFFER_LENGTH(
607               inbuf ) );
608
609    if( EVBUFFER_LENGTH( inbuf ) < INCOMING_HANDSHAKE_LEN )
610        return READ_LATER;
611
612    pstrlen = EVBUFFER_DATA( inbuf )[0]; /* peek, don't read.  We may be
613                                          handing inbuf to AWAITING_YA */
614
615    if( pstrlen == 19 ) /* unencrypted */
616    {
617        tr_peerIoSetEncryption( handshake->io, PEER_ENCRYPTION_NONE );
618
619        if( handshake->encryptionMode == TR_ENCRYPTION_REQUIRED )
620        {
621            dbgmsg( handshake,
622                    "peer is unencrypted, and we're disallowing that" );
623            return tr_handshakeDone( handshake, FALSE );
624        }
625    }
626    else /* encrypted or corrupt */
627    {
628        tr_peerIoSetEncryption( handshake->io, PEER_ENCRYPTION_RC4 );
629
630        if( tr_peerIoIsIncoming( handshake->io ) )
631        {
632            dbgmsg( handshake,
633                    "I think peer is sending us an encrypted handshake..." );
634            setState( handshake, AWAITING_YA );
635            return READ_NOW;
636        }
637        tr_cryptoDecrypt( handshake->crypto, 1, &pstrlen, &pstrlen );
638
639        if( pstrlen != 19 )
640        {
641            dbgmsg( handshake,
642                    "I think peer has sent us a corrupt handshake..." );
643            return tr_handshakeDone( handshake, FALSE );
644        }
645    }
646
647    evbuffer_drain( inbuf, 1 );
648
649    /* pstr (BitTorrent) */
650    pstr = tr_new( uint8_t, pstrlen + 1 );
651    tr_peerIoReadBytes( handshake->io, inbuf, pstr, pstrlen );
652    pstr[pstrlen] = '\0';
653    if( strcmp( (char*)pstr, "BitTorrent protocol" ) )
654    {
655        tr_free( pstr );
656        return tr_handshakeDone( handshake, FALSE );
657    }
658    tr_free( pstr );
659
660    /* reserved bytes */
661    tr_peerIoReadBytes( handshake->io, inbuf, reserved, sizeof( reserved ) );
662
663    /**
664    *** Extension negotiation
665    **/
666
667    if( HANDSHAKE_HAS_LTEP( reserved ) )
668    {
669        tr_peerIoEnableLTEP( handshake->io, 1 );
670        dbgmsg( handshake, "using ltep" );
671    }
672    if( HANDSHAKE_HAS_FASTEXT( reserved ) )
673    {
674        tr_peerIoEnableFEXT( handshake->io, 1 );
675        dbgmsg( handshake, "using fext" );
676    }
677
678    /* torrent hash */
679    tr_peerIoReadBytes( handshake->io, inbuf, hash, sizeof( hash ) );
680    if( tr_peerIoIsIncoming( handshake->io ) )
681    {
682        if( !tr_torrentExists( handshake->handle, hash ) )
683        {
684            dbgmsg(
685                handshake,
686                "peer is trying to connect to us for a torrent we don't have." );
687            return tr_handshakeDone( handshake, FALSE );
688        }
689        else
690        {
691            assert( !tr_peerIoHasTorrentHash( handshake->io ) );
692            tr_peerIoSetTorrentHash( handshake->io, hash );
693        }
694    }
695    else /* outgoing */
696    {
697        assert( tr_peerIoHasTorrentHash( handshake->io ) );
698        if( memcmp( hash, tr_peerIoGetTorrentHash( handshake->io ),
699                    SHA_DIGEST_LENGTH ) )
700        {
701            dbgmsg( handshake, "peer returned the wrong hash. wtf?" );
702            return tr_handshakeDone( handshake, FALSE );
703        }
704    }
705
706    /**
707    ***  If this is an incoming message, then we need to send a response
708    ***handshake
709    **/
710
711    if( !handshake->haveSentBitTorrentHandshake )
712    {
713        int       msgSize;
714        uint8_t * msg = buildHandshakeMessage( handshake, &msgSize );
715        tr_peerIoWrite( handshake->io, msg, msgSize, FALSE );
716        tr_free( msg );
717        handshake->haveSentBitTorrentHandshake = 1;
718    }
719
720    setReadState( handshake, AWAITING_PEER_ID );
721    return READ_NOW;
722}
723
724static int
725readPeerId( tr_handshake *    handshake,
726            struct evbuffer * inbuf )
727{
728    int  peerIsGood;
729    char client[128];
730
731    if( EVBUFFER_LENGTH( inbuf ) < PEER_ID_LEN )
732        return READ_LATER;
733
734    /* peer id */
735    tr_peerIoReadBytes( handshake->io, inbuf, handshake->peer_id,
736                        PEER_ID_LEN );
737    tr_peerIoSetPeersId( handshake->io, handshake->peer_id );
738    handshake->havePeerID = TRUE;
739    tr_clientForId( client, sizeof( client ), handshake->peer_id );
740    dbgmsg( handshake, "peer-id is [%s] ... isIncoming is %d", client,
741           tr_peerIoIsIncoming(
742               handshake->io ) );
743
744    /* if we've somehow connected to ourselves, don't keep the connection */
745    peerIsGood =
746        memcmp( handshake->peer_id, tr_getPeerId( ), PEER_ID_LEN ) ? 1 : 0;
747    dbgmsg( handshake, "isPeerGood == %d", peerIsGood );
748    return tr_handshakeDone( handshake, peerIsGood );
749}
750
751static int
752readYa( tr_handshake *    handshake,
753        struct evbuffer * inbuf )
754{
755    uint8_t        ya[KEY_LEN];
756    uint8_t *      walk, outbuf[KEY_LEN + PadB_MAXLEN];
757    const uint8_t *myKey, *secret;
758    int            len;
759
760    dbgmsg( handshake, "in readYa... need %d, have %d", (int)KEY_LEN,
761           (int)EVBUFFER_LENGTH(
762               inbuf ) );
763    if( EVBUFFER_LENGTH( inbuf ) < KEY_LEN )
764        return READ_LATER;
765
766    /* read the incoming peer's public key */
767    evbuffer_remove( inbuf, ya, KEY_LEN );
768    secret = tr_cryptoComputeSecret( handshake->crypto, ya );
769    memcpy( handshake->mySecret, secret, KEY_LEN );
770    tr_sha1( handshake->myReq1, "req1", 4, secret, KEY_LEN, NULL );
771
772    dbgmsg( handshake, "sending B->A: Diffie Hellman Yb, PadB" );
773    /* send our public key to the peer */
774    walk = outbuf;
775    myKey = tr_cryptoGetMyPublicKey( handshake->crypto, &len );
776    memcpy( walk, myKey, len );
777    walk += len;
778    len = tr_cryptoRandInt( PadB_MAXLEN );
779    tr_cryptoRandBuf( walk, len );
780    walk += len;
781
782    setReadState( handshake, AWAITING_PAD_A );
783    tr_peerIoWrite( handshake->io, outbuf, walk - outbuf, FALSE );
784    return READ_NOW;
785}
786
787static int
788readPadA( tr_handshake *    handshake,
789          struct evbuffer * inbuf )
790{
791    uint8_t * pch;
792
793    dbgmsg(
794         handshake,
795        "looking to get past pad a... & resync on hash('req',S) ... have %d bytes",
796        (int)EVBUFFER_LENGTH( inbuf ) );
797    /**
798    *** Resynchronizing on HASH('req1',S)
799    **/
800
801    pch = memchr( EVBUFFER_DATA( inbuf ),
802                 handshake->myReq1[0],
803                 EVBUFFER_LENGTH( inbuf ) );
804    if( pch == NULL )
805    {
806        dbgmsg( handshake, "no luck so far.. draining %d bytes",
807               (int)EVBUFFER_LENGTH(
808                   inbuf ) );
809        evbuffer_drain( inbuf, EVBUFFER_LENGTH( inbuf ) );
810        return READ_LATER;
811    }
812    dbgmsg( handshake, "looking for hash('req',S) ... draining %d bytes",
813           (int)( pch - EVBUFFER_DATA( inbuf ) ) );
814    evbuffer_drain( inbuf, pch - EVBUFFER_DATA( inbuf ) );
815    if( EVBUFFER_LENGTH( inbuf ) < SHA_DIGEST_LENGTH )
816        return READ_LATER;
817    if( memcmp( EVBUFFER_DATA( inbuf ), handshake->myReq1,
818                SHA_DIGEST_LENGTH ) )
819    {
820        dbgmsg( handshake, "draining one more byte" );
821        evbuffer_drain( inbuf, 1 );
822        return READ_NOW;
823    }
824
825    dbgmsg( handshake,
826            "found it... looking setting to awaiting_crypto_provide" );
827    setState( handshake, AWAITING_CRYPTO_PROVIDE );
828    return READ_NOW;
829}
830
831static int
832readCryptoProvide( tr_handshake *    handshake,
833                   struct evbuffer * inbuf )
834{
835    /* HASH('req2', SKEY) xor HASH('req3', S), ENCRYPT(VC, crypto_provide,
836      len(PadC)) */
837
838    int          i;
839    uint8_t      vc_in[VC_LENGTH];
840    uint8_t      req2[SHA_DIGEST_LENGTH];
841    uint8_t      req3[SHA_DIGEST_LENGTH];
842    uint8_t      obfuscatedTorrentHash[SHA_DIGEST_LENGTH];
843    uint16_t     padc_len = 0;
844    uint32_t     crypto_provide = 0;
845    const size_t needlen = SHA_DIGEST_LENGTH /* HASH('req1',s) */
846                           + SHA_DIGEST_LENGTH /* HASH('req2', SKEY) xor
847                                                 HASH('req3', S) */
848                           + VC_LENGTH
849                           + sizeof( crypto_provide )
850                           + sizeof( padc_len );
851    tr_torrent * tor = NULL;
852
853    if( EVBUFFER_LENGTH( inbuf ) < needlen )
854        return READ_LATER;
855
856    /* TODO: confirm they sent HASH('req1',S) here? */
857    evbuffer_drain( inbuf, SHA_DIGEST_LENGTH );
858
859    /* This next piece is HASH('req2', SKEY) xor HASH('req3', S) ...
860     * we can get the first half of that (the obufscatedTorrentHash)
861     * by building the latter and xor'ing it with what the peer sent us */
862    dbgmsg( handshake, "reading obfuscated torrent hash..." );
863    evbuffer_remove( inbuf, req2, SHA_DIGEST_LENGTH );
864    tr_sha1( req3, "req3", 4, handshake->mySecret, KEY_LEN, NULL );
865    for( i = 0; i < SHA_DIGEST_LENGTH; ++i )
866        obfuscatedTorrentHash[i] = req2[i] ^ req3[i];
867    if( ( tor =
868             tr_torrentFindFromObfuscatedHash( handshake->handle,
869                                               obfuscatedTorrentHash ) ) )
870    {
871        dbgmsg(
872            handshake,
873            "got INCOMING connection's encrypted handshake for torrent [%s]",
874            tor->info.name );
875        tr_peerIoSetTorrentHash( handshake->io, tor->info.hash );
876        if( !tr_torrentAllowsPex( tor )
877          && tr_peerMgrPeerIsSeed( handshake->handle->peerMgr,
878                                  tor->info.hash,
879                                  tr_peerIoGetAddress( handshake->io, NULL ) ) )
880        {
881            dbgmsg( handshake, "a peer has tried to reconnect to us!" );
882            return tr_handshakeDone( handshake, FALSE );
883        }
884    }
885    else
886    {
887        dbgmsg( handshake, "can't find that torrent..." );
888        return tr_handshakeDone( handshake, FALSE );
889    }
890
891    /* next part: ENCRYPT(VC, crypto_provide, len(PadC), */
892
893    tr_cryptoDecryptInit( handshake->crypto );
894
895    tr_peerIoReadBytes( handshake->io, inbuf, vc_in, VC_LENGTH );
896
897    tr_peerIoReadUint32( handshake->io, inbuf, &crypto_provide );
898    handshake->crypto_provide = crypto_provide;
899    dbgmsg( handshake, "crypto_provide is %d", (int)crypto_provide );
900
901    tr_peerIoReadUint16( handshake->io, inbuf, &padc_len );
902    dbgmsg( handshake, "padc is %d", (int)padc_len );
903    handshake->pad_c_len = padc_len;
904    setState( handshake, AWAITING_PAD_C );
905    return READ_NOW;
906}
907
908static int
909readPadC( tr_handshake *    handshake,
910          struct evbuffer * inbuf )
911{
912    uint16_t     ia_len;
913    const size_t needlen = handshake->pad_c_len + sizeof( uint16_t );
914
915    if( EVBUFFER_LENGTH( inbuf ) < needlen )
916        return READ_LATER;
917
918    evbuffer_drain( inbuf, handshake->pad_c_len );
919
920    tr_peerIoReadUint16( handshake->io, inbuf, &ia_len );
921    dbgmsg( handshake, "ia_len is %d", (int)ia_len );
922    handshake->ia_len = ia_len;
923    setState( handshake, AWAITING_IA );
924    return READ_NOW;
925}
926
927static int
928readIA( tr_handshake *    handshake,
929        struct evbuffer * inbuf )
930{
931    const size_t      needlen = handshake->ia_len;
932    struct evbuffer * outbuf;
933    uint32_t          crypto_select;
934
935    dbgmsg( handshake, "reading IA... have %d, need %d",
936            (int)EVBUFFER_LENGTH(
937                inbuf ), (int)needlen );
938    if( EVBUFFER_LENGTH( inbuf ) < needlen )
939        return READ_LATER;
940
941    /**
942    ***  B->A: ENCRYPT(VC, crypto_select, len(padD), padD), ENCRYPT2(Payload
943    ***Stream)
944    **/
945
946    tr_cryptoEncryptInit( handshake->crypto );
947    outbuf = evbuffer_new( );
948
949    dbgmsg( handshake, "sending vc" );
950    /* send VC */
951    {
952        uint8_t vc[VC_LENGTH];
953        memset( vc, 0, VC_LENGTH );
954        tr_peerIoWriteBytes( handshake->io, outbuf, vc, VC_LENGTH );
955    }
956
957    /* send crypto_select */
958    crypto_select = getCryptoSelect( handshake, handshake->crypto_provide );
959    if( crypto_select )
960    {
961        dbgmsg( handshake, "selecting crypto mode '%d'", (int)crypto_select );
962        tr_peerIoWriteUint32( handshake->io, outbuf, crypto_select );
963    }
964    else
965    {
966        dbgmsg( handshake, "peer didn't offer an encryption mode we like." );
967        evbuffer_free( outbuf );
968        return tr_handshakeDone( handshake, FALSE );
969    }
970
971    dbgmsg( handshake, "sending pad d" );
972    /* ENCRYPT(VC, crypto_provide, len(PadC), PadC
973     * PadD is reserved for future extensions to the handshake...
974     * standard practice at this time is for it to be zero-length */
975    {
976        const int len = 0;
977        tr_peerIoWriteUint16( handshake->io, outbuf, len );
978    }
979
980    /* maybe de-encrypt our connection */
981    if( crypto_select == CRYPTO_PROVIDE_PLAINTEXT )
982        tr_peerIoSetEncryption( handshake->io, PEER_ENCRYPTION_NONE );
983
984    dbgmsg( handshake, "sending handshake" );
985    /* send our handshake */
986    {
987        int       msgSize;
988        uint8_t * msg = buildHandshakeMessage( handshake, &msgSize );
989        tr_peerIoWriteBytes( handshake->io, outbuf, msg, msgSize );
990        handshake->haveSentBitTorrentHandshake = 1;
991        tr_free( msg );
992    }
993
994    /* send it out */
995    tr_peerIoWriteBuf( handshake->io, outbuf, FALSE );
996    evbuffer_free( outbuf );
997
998    /* now await the handshake */
999    setState( handshake, AWAITING_PAYLOAD_STREAM );
1000    return READ_NOW;
1001}
1002
1003static int
1004readPayloadStream( tr_handshake    * handshake,
1005                   struct evbuffer * inbuf )
1006{
1007    int i;
1008    const size_t      needlen = HANDSHAKE_SIZE;
1009
1010    dbgmsg( handshake, "reading payload stream... have %d, need %d",
1011            (int)EVBUFFER_LENGTH( inbuf ), (int)needlen );
1012    if( EVBUFFER_LENGTH( inbuf ) < needlen )
1013        return READ_LATER;
1014
1015    /* parse the handshake ... */
1016    i = parseHandshake( handshake, inbuf );
1017    dbgmsg( handshake, "parseHandshake returned %d", i );
1018    if( i != HANDSHAKE_OK )
1019        return tr_handshakeDone( handshake, FALSE );
1020
1021    /* we've completed the BT handshake... pass the work on to peer-msgs */
1022    return tr_handshakeDone( handshake, TRUE );
1023}
1024
1025/***
1026****
1027****
1028****
1029***/
1030
1031static ReadState
1032canRead( struct tr_iobuf * iobuf, void * arg, size_t * piece )
1033{
1034    tr_handshake *    handshake = arg;
1035    struct evbuffer * inbuf = tr_iobuf_input( iobuf );
1036    ReadState         ret;
1037    int               readyForMore = TRUE;
1038
1039    /* no piece data in handshake */
1040    *piece = 0;
1041
1042    dbgmsg( handshake, "handling canRead; state is [%s]",
1043           getStateName( handshake->state ) );
1044
1045    while( readyForMore )
1046    {
1047        switch( handshake->state )
1048        {
1049            case AWAITING_HANDSHAKE:
1050                ret = readHandshake    ( handshake, inbuf ); break;
1051
1052            case AWAITING_PEER_ID:
1053                ret = readPeerId       ( handshake, inbuf ); break;
1054
1055            case AWAITING_YA:
1056                ret = readYa           ( handshake, inbuf ); break;
1057
1058            case AWAITING_PAD_A:
1059                ret = readPadA         ( handshake, inbuf ); break;
1060
1061            case AWAITING_CRYPTO_PROVIDE:
1062                ret = readCryptoProvide( handshake, inbuf ); break;
1063
1064            case AWAITING_PAD_C:
1065                ret = readPadC         ( handshake, inbuf ); break;
1066
1067            case AWAITING_IA:
1068                ret = readIA           ( handshake, inbuf ); break;
1069
1070            case AWAITING_PAYLOAD_STREAM:
1071                ret = readPayloadStream( handshake, inbuf ); break;
1072
1073            case AWAITING_YB:
1074                ret = readYb           ( handshake, inbuf ); break;
1075
1076            case AWAITING_VC:
1077                ret = readVC           ( handshake, inbuf ); break;
1078
1079            case AWAITING_CRYPTO_SELECT:
1080                ret = readCryptoSelect ( handshake, inbuf ); break;
1081
1082            case AWAITING_PAD_D:
1083                ret = readPadD         ( handshake, inbuf ); break;
1084
1085            default:
1086                assert( 0 );
1087        }
1088
1089        if( ret != READ_NOW )
1090            readyForMore = FALSE;
1091        else if( handshake->state == AWAITING_PAD_C )
1092            readyForMore = EVBUFFER_LENGTH( inbuf ) >= handshake->pad_c_len;
1093        else if( handshake->state == AWAITING_PAD_D )
1094            readyForMore = EVBUFFER_LENGTH( inbuf ) >= handshake->pad_d_len;
1095        else if( handshake->state == AWAITING_IA )
1096            readyForMore = EVBUFFER_LENGTH( inbuf ) >= handshake->ia_len;
1097    }
1098
1099    return ret;
1100}
1101
1102static int
1103fireDoneFunc( tr_handshake * handshake,
1104              int            isConnected )
1105{
1106    const uint8_t * peer_id = isConnected && handshake->havePeerID
1107                              ? handshake->peer_id
1108                              : NULL;
1109    const int       success = ( *handshake->doneCB )( handshake,
1110                                                      handshake->io,
1111                                                      isConnected,
1112                                                      peer_id,
1113                                                      handshake->
1114                                                      doneUserData );
1115
1116    return success;
1117}
1118
1119static int
1120tr_handshakeDone( tr_handshake * handshake,
1121                  int            isOK )
1122{
1123    int success;
1124
1125    dbgmsg( handshake, "handshakeDone: %s", isOK ? "connected" : "aborting" );
1126    tr_peerIoSetIOFuncs( handshake->io, NULL, NULL, NULL, NULL );
1127
1128    success = fireDoneFunc( handshake, isOK );
1129
1130    tr_free( handshake );
1131
1132    return success ? READ_LATER : READ_ERR;
1133}
1134
1135void
1136tr_handshakeAbort( tr_handshake * handshake )
1137{
1138    tr_handshakeDone( handshake, FALSE );
1139}
1140
1141static void
1142gotError( struct tr_iobuf  * iobuf UNUSED,
1143          short              what,
1144          void             * arg )
1145{
1146    tr_handshake * handshake = (tr_handshake *) arg;
1147
1148    /* if the error happened while we were sending a public key, we might
1149     * have encountered a peer that doesn't do encryption... reconnect and
1150     * try a plaintext handshake */
1151    if( ( ( handshake->state == AWAITING_YB )
1152        || ( handshake->state == AWAITING_VC ) )
1153      && ( handshake->encryptionMode != TR_ENCRYPTION_REQUIRED )
1154      && ( !tr_peerIoReconnect( handshake->io ) ) )
1155    {
1156        int       msgSize;
1157        uint8_t * msg;
1158        dbgmsg( handshake, "handshake failed, trying plaintext..." );
1159        msg = buildHandshakeMessage( handshake, &msgSize );
1160        handshake->haveSentBitTorrentHandshake = 1;
1161        setReadState( handshake, AWAITING_HANDSHAKE );
1162        tr_peerIoWrite( handshake->io, msg, msgSize, FALSE );
1163        tr_free( msg );
1164    }
1165    else
1166    {
1167        dbgmsg( handshake, "libevent got an error what==%d, errno=%d (%s)",
1168               (int)what, errno, tr_strerror( errno ) );
1169        tr_handshakeDone( handshake, FALSE );
1170    }
1171}
1172
1173/**
1174***
1175**/
1176
1177tr_handshake*
1178tr_handshakeNew( tr_peerIo *        io,
1179                 tr_encryption_mode encryptionMode,
1180                 handshakeDoneCB    doneCB,
1181                 void *             doneUserData )
1182{
1183    tr_handshake * handshake;
1184
1185    handshake = tr_new0( tr_handshake, 1 );
1186    handshake->io = io;
1187    handshake->crypto = tr_peerIoGetCrypto( io );
1188    handshake->encryptionMode = encryptionMode;
1189    handshake->doneCB = doneCB;
1190    handshake->doneUserData = doneUserData;
1191    handshake->handle = tr_peerIoGetSession( io );
1192    tr_peerIoSetTimeoutSecs( io, 15 );
1193
1194    tr_peerIoSetIOFuncs( handshake->io, canRead, NULL, gotError, handshake );
1195
1196    if( tr_peerIoIsIncoming( handshake->io ) )
1197        setReadState( handshake, AWAITING_HANDSHAKE );
1198    else if( encryptionMode != TR_CLEAR_PREFERRED )
1199        sendYa( handshake );
1200    else
1201    {
1202        int       msgSize;
1203        uint8_t * msg = buildHandshakeMessage( handshake, &msgSize );
1204        handshake->haveSentBitTorrentHandshake = 1;
1205        setReadState( handshake, AWAITING_HANDSHAKE );
1206        tr_peerIoWrite( handshake->io, msg, msgSize, FALSE );
1207        tr_free( msg );
1208    }
1209
1210    return handshake;
1211}
1212
1213struct tr_peerIo*
1214tr_handshakeGetIO( tr_handshake * handshake )
1215{
1216    assert( handshake );
1217    assert( handshake->io );
1218
1219    return handshake->io;
1220}
1221
1222const struct in_addr *
1223tr_handshakeGetAddr( const struct tr_handshake * handshake,
1224                                                 uint16_t * port )
1225{
1226    assert( handshake );
1227    assert( handshake->io );
1228
1229    return tr_peerIoGetAddress( handshake->io, port );
1230}
1231
Note: See TracBrowser for help on using the repository browser.