source: trunk/libtransmission/handshake.c @ 7234

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

(libT) #1549: support fast exensions' "reject" and "have all/none" messages

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