source: trunk/libtransmission/handshake.c @ 6986

Last change on this file since 6986 was 6986, checked in by charles, 13 years ago

#1389 test #2

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