source: trunk/libtransmission/handshake.c @ 7152

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

(libT) I wonder if this will have any affect on the bug reported by Wizardling.

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