Changeset 3101 for branches/encryption/libtransmission/handshake.c

Timestamp:

Sep 20, 2007, 4:11:09 AM (15 years ago)

Author:

charles

Message:

• add a public API call for setting encryption preferences
• fix upload bug that caused us to send the same block out more than once
• fix handshake bug that caused us to shun uTorrent and vice versa
• fix minor memory leaks (valgrind).
• move extension handshakes into peer-msgs

File:

• branches/encryption/libtransmission/handshake.c (modified) (33 diffs)

branches/encryption/libtransmission/handshake.c

@@ -44 +44 @@
 #define HANDSHAKE_SIZE          68
 
+/***
+****
+***/
+
+enum
+{
+    HANDSHAKE_EXTPREF_LTEP_FORCE   = 0x0,
+    HANDSHAKE_EXTPREF_LTEP_PREFER  = 0x1,
+    HANDSHAKE_EXTPREF_AZMP_PREFER  = 0x2,
+    HANDSHAKE_EXTPREF_AZMP_FORCE   = 0x3
+};
+
+
 #ifdef ENABLE_LTEP
-#define HANDSHAKE_HAS_EXTMSGS( bits ) ( (bits)[5] & 0x10 )
-#define HANDSHAKE_SET_EXTMSGS( bits ) ( (bits)[5] |= 0x10 )
+#define HANDSHAKE_HAS_EXTMSGS( bits ) ( ( (bits)[5] & 0x10 ) ? 1 : 0 )
+#define HANDSHAKE_SET_EXTMSGS( bits ) ( ( (bits)[5] |= 0x10 ) ? 1 : 0 )
 #else
 #define HANDSHAKE_HAS_EXTMSGS( bits ) ( 0 )
@@ -53 +66 @@
 
 #ifdef ENABLE_AZMP
-#define HANDSHAKE_HAS_AZPROTO( bits ) ( (bits)[0] & 0x80 )
-#define HANDSHAKE_SET_AZPROTO( bits ) ( (bits)[0] |= 0x80 )
+#define HANDSHAKE_HAS_AZPROTO( bits ) ( ( (bits)[0] & 0x80 ) ? 1 : 0 )
+#define HANDSHAKE_SET_AZPROTO( bits ) ( ( (bits)[0] |= 0x80 ) ? 1 : 0 )
 #else
 #define HANDSHAKE_HAS_AZPROTO( bits ) ( 0 )
@@ -70 +83 @@
 #define HANDSHAKE_EXTPREF_AZMP_FORCE   ( 0x3 )
 
+enum
+{
+    PadA_MAXLEN = 512,
+    PadB_MAXLEN = 512,
+    PadC_MAXLEN = 512,
+    PadD_MAXLEN = 512
+};
+
 extern const char* getPeerId( void ) ;
 
@@ -77 +98 @@
 struct tr_handshake
 {
-    unsigned int peerSupportsEncryption : 1;
-    unsigned int havePeerID             : 1;
+    unsigned int peerSupportsEncryption       : 1;
+    unsigned int havePeerID                   : 1;
+    unsigned int haveSentBitTorrentHandshake  : 1;
+    unsigned int shunUnencryptedPeers         : 1;
     tr_peerIo * io;
     tr_crypto * crypto;
@@ -85 +108 @@
     uint8_t mySecret[96];
     uint8_t state;
-    uint8_t encryptionPreference;
     uint16_t pad_c_len;
     uint16_t pad_d_len;
@@ -96 +118 @@
 };
 
-static void
-fireDoneCB( tr_handshake * handshake, int isConnected );
-
 /**
 ***
 **/
 
-enum /*ccc*/
+enum
 {
     /* incoming */
@@ -123 +142 @@
 ***
 **/
+
+static void
+myDebug( const char * file, int line, const tr_handshake * handshake, const char * fmt, ... )
+{
+    va_list args;
+    const char * addr = tr_peerIoGetAddrStr( handshake->io );
+    struct evbuffer * buf = evbuffer_new( );
+    evbuffer_add_printf( buf, "[%s:%d] %s (%p) ", file, line, addr, handshake );
+    va_start( args, fmt );
+    evbuffer_add_vprintf( buf, fmt, args );
+    va_end( args );
+
+    fprintf( stderr, "%s\n", EVBUFFER_DATA(buf) );
+
+    evbuffer_free( buf );
+}
+
+#define dbgmsg(handshake, fmt...) myDebug(__FILE__, __LINE__, handshake, ##fmt )
 
 static const char* getStateName( short state )
@@ -141 +178 @@
         case AWAITING_CRYPTO_SELECT:  str = "awaiting crypto select"; break;
         case AWAITING_PAD_D:          str = "awaiting pad d"; break;
-        //case SENDING_PLAINTEXT_HANDSHAKE: str = "sending plaintext handshake"; break;
+        //case SENDING_NONE: str = "sending plaintext handshake"; break;
     }
     return str;
@@ -149 +186 @@
 setState( tr_handshake * handshake, short state )
 {
-    fprintf( stderr, "handshake %p: setting to state [%s]\n", handshake, getStateName(state) );
+    dbgmsg( handshake, "setting to state [%s]", getStateName(state) );
     handshake->state = state;
 }
@@ -160 +197 @@
 }
 
+static uint8_t *
+buildHandshakeMessage( tr_handshake * handshake,
+                       int            extensionPreference,
+                       int          * setme_len )
+{
+    uint8_t * buf = tr_new0( uint8_t, HANDSHAKE_SIZE );
+    uint8_t * walk = buf;
+    const uint8_t * torrentHash = tr_cryptoGetTorrentHash( handshake->crypto );
+
+    memcpy( walk, HANDSHAKE_NAME, HANDSHAKE_NAME_LEN );
+    walk += HANDSHAKE_NAME_LEN;
+    memset( walk, 0, HANDSHAKE_FLAGS_LEN );
+    switch( extensionPreference )
+    {
+        case HANDSHAKE_EXTPREF_LTEP_FORCE:
+            HANDSHAKE_SET_EXTMSGS( walk );
+            HANDSHAKE_SET_EXTPREF( walk, extensionPreference );
+            break;
+
+        case HANDSHAKE_EXTPREF_LTEP_PREFER:
+            HANDSHAKE_SET_EXTMSGS( walk );
+            HANDSHAKE_SET_AZPROTO( walk );
+            HANDSHAKE_SET_EXTPREF( walk, extensionPreference );
+            break;
+
+        case HANDSHAKE_EXTPREF_AZMP_PREFER:
+            HANDSHAKE_SET_EXTMSGS( walk );
+            HANDSHAKE_SET_AZPROTO( walk );
+            HANDSHAKE_SET_EXTPREF( walk, extensionPreference );
+            break;
+
+        case HANDSHAKE_EXTPREF_AZMP_FORCE:
+            HANDSHAKE_SET_AZPROTO( walk );
+            HANDSHAKE_SET_EXTPREF( walk, extensionPreference );
+            break;
+    }
+
+    walk += HANDSHAKE_FLAGS_LEN;
+    memcpy( walk, torrentHash, SHA_DIGEST_LENGTH );
+    walk += SHA_DIGEST_LENGTH;
+    memcpy( walk, getPeerId(), TR_ID_LEN );
+    walk += TR_ID_LEN;
+
+    assert( walk-buf == HANDSHAKE_SIZE );
+    *setme_len = walk - buf;
+    return buf;
+}
+
+/***
+****
+****  OUTGOING CONNECTIONS
+****
+***/
+
+/* 1 A->B: Diffie Hellman Ya, PadA */
 static void
-sendPublicKey( tr_handshake * handshake )
+sendYa( tr_handshake * handshake )
 {
     int i;
@@ -167 +259 @@
     const uint8_t * public_key;
     struct evbuffer * outbuf = evbuffer_new( );
-    uint8_t pad[512];
+    uint8_t pad_a[PadA_MAXLEN];
 
     /* add our public key (Ya) */
@@ -176 +268 @@
 
     /* add some bullshit padding */
-    len = tr_rand( 512 );
+    len = tr_rand( PadA_MAXLEN );
     for( i=0; i<len; ++i )
-        pad[i] = tr_rand( UCHAR_MAX );
-    evbuffer_add( outbuf, pad, len );
+        pad_a[i] = tr_rand( UCHAR_MAX );
+    evbuffer_add( outbuf, pad_a, len );
 
     /* send it */
     setReadState( handshake, AWAITING_YB );
-    //setState( handshake, SENDING_YA );
     tr_peerIoWriteBuf( handshake->io, outbuf );
 
@@ -189 +280 @@
     evbuffer_free( outbuf );
 }
-
-static void
-buildHandshakeMessage( tr_handshake * handshake, uint8_t * buf )
-{
-    uint8_t *walk = buf;
-    const uint8_t * torrentHash = tr_cryptoGetTorrentHash( handshake->crypto );
-
-    memcpy( walk, HANDSHAKE_NAME, HANDSHAKE_NAME_LEN );
-    walk += HANDSHAKE_NAME_LEN;
-    memset( walk, 0, HANDSHAKE_FLAGS_LEN );
-    HANDSHAKE_SET_EXTMSGS( walk );
-    HANDSHAKE_SET_AZPROTO( walk );
-    HANDSHAKE_SET_EXTPREF( walk, HANDSHAKE_EXTPREF_LTEP_PREFER );
-    walk += HANDSHAKE_FLAGS_LEN;
-    memcpy( walk, torrentHash, SHA_DIGEST_LENGTH );
-    walk += SHA_DIGEST_LENGTH;
-    memcpy( walk, getPeerId(), TR_ID_LEN );
-    walk += TR_ID_LEN;
-    assert( walk-buf == HANDSHAKE_SIZE );
-}
-
-static void
-sendPlaintextHandshake( tr_handshake * handshake )
-{
-    uint8_t buf[HANDSHAKE_SIZE];
-    buildHandshakeMessage( handshake, buf );
-
-    setReadState( handshake, AWAITING_HANDSHAKE );
-    tr_peerIoWrite( handshake->io, buf, HANDSHAKE_SIZE );
-}
-
-static void
-sendHandshake( tr_handshake * handshake )
-{
-    if( ( handshake->encryptionPreference == HANDSHAKE_ENCRYPTION_PREFERRED ) ||
-        ( handshake->encryptionPreference == HANDSHAKE_ENCRYPTION_REQUIRED ) )
-    {
-        sendPublicKey( handshake );
-    }
-    else
-    {
-        sendPlaintextHandshake( handshake );
-    }
-}
-
-static void
-sendLtepHandshake( tr_handshake * handshake )
-{
-    benc_val_t val, *m;
-    char * buf;
-    int len;
-    const char * v = TR_NAME " " USERAGENT_PREFIX;
-    const int port = tr_getPublicPort( handshake->handle );
-    struct evbuffer * outbuf = evbuffer_new( );
-    uint32_t msglen;
-    const uint8_t tr_msgid = 20; /* ltep extension id */
-    const uint8_t ltep_msgid = 0; /* handshake id */
-
-    tr_bencInit( &val, TYPE_DICT );
-    tr_bencDictReserve( &val, 3 );
-    m  = tr_bencDictAdd( &val, "m" );
-    tr_bencInit( m, TYPE_DICT );
-    tr_bencDictReserve( m, 1 );
-    tr_bencInitInt( tr_bencDictAdd( m, "ut_pex" ), 1 );
-    if( port > 0 )
-        tr_bencInitInt( tr_bencDictAdd( &val, "p" ), port );
-    tr_bencInitStr( tr_bencDictAdd( &val, "v" ), v, 0, 1 );
-
-    fprintf( stderr, "handshake %p: sending ltep handshake...\n", handshake );
-    buf = tr_bencSaveMalloc( &val,  &len );
-    tr_bencPrint( &val );
-
-    msglen = sizeof(tr_msgid) + sizeof(ltep_msgid) + len;
-    tr_peerIoWriteUint32( handshake->io, outbuf, msglen );
-    tr_peerIoWriteBytes ( handshake->io, outbuf, &tr_msgid, 1 );
-    tr_peerIoWriteBytes ( handshake->io, outbuf, &ltep_msgid, 1 );
-    tr_peerIoWriteBytes ( handshake->io, outbuf, buf, len );
-    
-    tr_peerIoWriteBuf( handshake->io, outbuf );
-    fireDoneCB( handshake, TRUE );
-  
-    /* cleanup */ 
-    tr_bencFree( &val );
-    tr_free( buf ); 
-    evbuffer_free( outbuf );
-}
-
-
-/**
-***
-**/
-
-static int
-readYa( tr_handshake * handshake, struct evbuffer  * inbuf )
-{
-    uint8_t ya[KEY_LEN];
-    uint8_t *walk, outbuf[KEY_LEN + 512];
-    const uint8_t *myKey, *secret;
-    int len;
-
-    if( EVBUFFER_LENGTH( inbuf ) < KEY_LEN )
-        return READ_MORE;
-
-    /* read the incoming peer's public key */
-    evbuffer_remove( inbuf, ya, KEY_LEN );
-    secret = tr_cryptoComputeSecret( handshake->crypto, ya );
-    memcpy( handshake->mySecret, secret, KEY_LEN );
-    tr_sha1( handshake->myReq1, "req1", 4, secret, KEY_LEN, NULL );
-
-    /* send our public key to the peer */
-    walk = outbuf;
-    myKey = tr_cryptoGetMyPublicKey( handshake->crypto, &len );
-    memcpy( walk, myKey, len );
-    len = tr_rand( 512 );
-    while( len-- )
-        *walk++ = tr_rand( UCHAR_MAX );
-
-    setReadState( handshake, AWAITING_PAD_A );
-    tr_peerIoWrite( handshake->io, outbuf, walk-outbuf );
-
-    return READ_DONE;
-}
-
-static int
-readPadA( tr_handshake * handshake, struct evbuffer * inbuf )
-{
-    uint8_t * pch;
-
-    /**
-    *** Resynchronizing on HASH('req1',S)
-    **/
-
-    pch = memchr( EVBUFFER_DATA(inbuf),
-                  handshake->myReq1[0],
-                  EVBUFFER_LENGTH(inbuf) );
-    if( pch == NULL ) {
-        evbuffer_drain( inbuf, EVBUFFER_LENGTH(inbuf) );
-        return READ_MORE;
-    }
-    evbuffer_drain( inbuf, pch-EVBUFFER_DATA(inbuf) );
-    if( EVBUFFER_LENGTH(inbuf) < SHA_DIGEST_LENGTH )
-        return READ_MORE;
-    if( memcmp( EVBUFFER_DATA(inbuf), handshake->myReq1, SHA_DIGEST_LENGTH ) ) {
-        evbuffer_drain( inbuf, 1 );
-        return READ_AGAIN;
-    }
-
-    setState( handshake, AWAITING_CRYPTO_PROVIDE );
-    return READ_AGAIN;
-}
-
-static int
-readCryptoProvide( tr_handshake * handshake, struct evbuffer * inbuf )
-{
-    /* HASH('req2', SKEY) xor HASH('req3', S), ENCRYPT(VC, crypto_provide, len(PadC)) */
-
-    int i;
-    uint8_t vc_in[VC_LENGTH];
-    uint8_t req2[SHA_DIGEST_LENGTH];
-    uint8_t req3[SHA_DIGEST_LENGTH];
-    uint8_t obfuscatedTorrentHash[SHA_DIGEST_LENGTH];
-    uint16_t padc_len = 0;
-    uint32_t crypto_provide = 0;
-    const size_t needlen = SHA_DIGEST_LENGTH + VC_LENGTH + sizeof(crypto_provide) + sizeof(padc_len);
-    tr_torrent * tor = NULL;
-
-    if( EVBUFFER_LENGTH(inbuf) < needlen )
-        return READ_MORE;
-
-    /* TODO: confirm they sent HASH('req1',S) here? */
-    evbuffer_drain( inbuf, SHA_DIGEST_LENGTH );
-
-    /* This next piece is HASH('req2', SKEY) xor HASH('req3', S) ...
-     * we can get the first half of that (the obufscatedTorrentHash)
-     * by building the latter and xor'ing it with what the peer sent us */
-    fprintf( stderr, "reading obfuscated torrent hash...\n" );
-    evbuffer_remove( inbuf, req2, SHA_DIGEST_LENGTH );
-    tr_sha1( req3, "req3", 4, handshake->mySecret, KEY_LEN, NULL );
-    for( i=0; i<SHA_DIGEST_LENGTH; ++i )
-        obfuscatedTorrentHash[i] = req2[i] ^ req3[i];
-    tor = tr_torrentFindFromObfuscatedHash( handshake->handle, obfuscatedTorrentHash );
-    assert( tor != NULL );
-    fprintf( stderr, "found the torrent; it's [%s]\n", tor->info.name );
-    tr_peerIoSetTorrentHash( handshake->io, tor->info.hash );
-
-    /* next part: ENCRYPT(VC, crypto_provide, len(PadC), */
-
-    tr_cryptoDecryptInit( handshake->crypto );
-
-    tr_peerIoReadBytes( handshake->io, inbuf, vc_in, VC_LENGTH );
-
-    tr_peerIoReadUint32( handshake->io, inbuf, &crypto_provide );
-    fprintf( stderr, "crypto_provide is %d\n", (int)crypto_provide );
-
-    tr_peerIoReadUint16( handshake->io, inbuf, &padc_len );
-    fprintf( stderr, "padc is %d\n", (int)padc_len );
-    handshake->pad_c_len = padc_len;
-    setState( handshake, AWAITING_PAD_C );
-    return READ_AGAIN;
-}
-
-static int
-readPadC( tr_handshake * handshake, struct evbuffer * inbuf )
-{
-    uint16_t ia_len;
-    const size_t needlen = handshake->pad_c_len + sizeof(uint16_t);
-
-    if( EVBUFFER_LENGTH(inbuf) < needlen )
-        return READ_MORE;
-
-    evbuffer_drain( inbuf, needlen );
-
-    tr_peerIoReadUint16( handshake->io, inbuf, &ia_len );
-    fprintf( stderr, "ia_len is %d\n", (int)ia_len );
-    handshake->ia_len = ia_len;
-    setState( handshake, AWAITING_IA );
-    return READ_AGAIN;
-}
-
-static int
-readIA( tr_handshake * handshake, struct evbuffer * inbuf )
-{
-    const size_t needlen = handshake->ia_len;
-    uint8_t * ia;
-
-    if( EVBUFFER_LENGTH(inbuf) < needlen )
-        return READ_MORE;
-
-    ia = tr_new( uint8_t, handshake->ia_len );
-    tr_peerIoReadBytes( handshake->io, inbuf, ia, handshake->ia_len );
-    fprintf( stderr, "got their payload ia: [%*.*s]\n", (int)needlen, (int)needlen, ia );
-
-    handshake->state = -1;
-    assert( 0 && "asdf" );
-}
-
-/**
-***
-**/
 
 static int
@@ -440 +292 @@
     if( EVBUFFER_LENGTH(inbuf) < needlen )
         return READ_MORE;
-fprintf( stderr, "%*.*s\n", HANDSHAKE_NAME_LEN, HANDSHAKE_NAME_LEN, EVBUFFER_DATA(inbuf) );
 
     isEncrypted = memcmp( EVBUFFER_DATA(inbuf), HANDSHAKE_NAME, HANDSHAKE_NAME_LEN );
@@ -449 +300 @@
     }
 
-    fprintf( stderr, "got a %s handshake\n", (isEncrypted ? "encrypted" : "plaintext") );
+    dbgmsg( handshake, "got a %s handshake", (isEncrypted ? "encrypted" : "plaintext") );
+
     handshake->peerSupportsEncryption = isEncrypted;
-    tr_peerIoSetEncryption( handshake->io, isEncrypted
-        ? PEER_ENCRYPTION_RC4
-        : PEER_ENCRYPTION_PLAINTEXT );
+    tr_peerIoSetEncryption( handshake->io, isEncrypted ? PEER_ENCRYPTION_RC4
+                                                       : PEER_ENCRYPTION_NONE );
     if( !isEncrypted ) {
         setState( handshake, AWAITING_HANDSHAKE );
@@ -503 +354 @@
         /* crypto_provide */
         crypto_provide = 0;
-        if( handshake->encryptionPreference != HANDSHAKE_PLAINTEXT_REQUIRED )
-            crypto_provide |= (1<<0);
-        if( handshake->encryptionPreference != HANDSHAKE_ENCRYPTION_REQUIRED )
+        crypto_provide |= (1<<0); /* encryption */
+        if( !handshake->shunUnencryptedPeers ) /* plaintext */
             crypto_provide |= (1<<1);
         assert( 1<=crypto_provide && crypto_provide<=3 );
@@ -528 +378 @@
     {
         uint16_t i;
-        uint8_t msg[HANDSHAKE_SIZE];
-        buildHandshakeMessage( handshake, msg );
-
-        i = htons( HANDSHAKE_SIZE );
+        int msgSize;
+        uint8_t * msg = buildHandshakeMessage( handshake, HANDSHAKE_EXTPREF_LTEP_PREFER, &msgSize );
+
+        i = htons( msgSize );
         tr_cryptoEncrypt( handshake->crypto, sizeof(uint16_t), &i, &i );
         evbuffer_add( outbuf, &i, sizeof(uint16_t) );
 
-        tr_cryptoEncrypt( handshake->crypto, HANDSHAKE_SIZE, msg, msg );
+        tr_cryptoEncrypt( handshake->crypto, msgSize, msg, msg );
         evbuffer_add( outbuf, msg, HANDSHAKE_SIZE );
+        handshake->haveSentBitTorrentHandshake = 1;
+
+        tr_free( msg );
     }
 
@@ -562 +415 @@
     {
         if( EVBUFFER_LENGTH(inbuf) < VC_LENGTH ) {
-            fprintf( stderr, "not enough bytes... returning read_more\n" );
+            dbgmsg( handshake, "not enough bytes... returning read_more" );
             return READ_MORE;
         }
@@ -575 +428 @@
     }
 
-    fprintf( stderr, "got it!\n" );
+    dbgmsg( handshake, "got it!" );
     evbuffer_drain( inbuf, key_len );
     setState( handshake, AWAITING_CRYPTO_SELECT );
@@ -594 +447 @@
     assert( crypto_select==1 || crypto_select==2 );
     handshake->crypto_select = crypto_select;
-    fprintf( stderr, "crypto select is %d\n", crypto_select );
+    dbgmsg( handshake, "crypto select is %d", (int)crypto_select );
 
     tr_peerIoReadUint16( handshake->io, inbuf, &pad_d_len );
-    fprintf( stderr, "pad_d_len is %d\n", (int)pad_d_len );
+    dbgmsg( handshake, "pad_d_len is %d", (int)pad_d_len );
     assert( pad_d_len <= 512 );
     handshake->pad_d_len = pad_d_len;
@@ -611 +464 @@
     uint8_t * tmp;
 
-fprintf( stderr, "pad d: need %d, got %d\n", (int)needlen, (int)EVBUFFER_LENGTH(inbuf) );
+    dbgmsg( handshake, "pad d: need %d, got %d", (int)needlen, (int)EVBUFFER_LENGTH(inbuf) );
     if( EVBUFFER_LENGTH(inbuf) < needlen )
         return READ_MORE;
@@ -626 +479 @@
 }
 
+/***
+****
+****  INCOMING CONNECTIONS
+****
+***/
+
 static void
-gotError( struct bufferevent * evbuf UNUSED, short what UNUSED, void * arg );
-
-/*ccc*/
+tr_handshakeDone( tr_handshake * handshake, int isConnected );
+
 static int
 readHandshake( tr_handshake * handshake, struct evbuffer * inbuf )
 {
     int i;
-    int ltep = 0;
-    int azmp = 0;
-    int isEncrypted;
+    uint8_t ltep = 0;
+    uint8_t azmp = 0;
     uint8_t pstrlen;
     uint8_t * pstr;
     uint8_t reserved[8];
     uint8_t hash[SHA_DIGEST_LENGTH];
-    int bytesRead = 0;
-
-fprintf( stderr, "handshake payload: need %d, got %d\n", (int)HANDSHAKE_SIZE, (int)EVBUFFER_LENGTH(inbuf) );
+
+    dbgmsg( handshake, "payload: need %d, got %d\n", (int)HANDSHAKE_SIZE, (int)EVBUFFER_LENGTH(inbuf) );
 
     if( EVBUFFER_LENGTH(inbuf) < HANDSHAKE_SIZE )
         return READ_MORE;
 
-    /* pstrlen */
-    pstrlen = EVBUFFER_DATA(inbuf)[0];
-    fprintf( stderr, "pstrlen 1 is %d [%c]\n", (int)pstrlen, pstrlen );
-    fprintf( stderr, "the buf is [%c][%c][%c][%c]",
-        EVBUFFER_DATA(inbuf)[0], 
-        EVBUFFER_DATA(inbuf)[1], 
-        EVBUFFER_DATA(inbuf)[2], 
-        EVBUFFER_DATA(inbuf)[3] );
-    isEncrypted = pstrlen != 19;
-    handshake->peerSupportsEncryption = isEncrypted;
-    tr_peerIoSetEncryption( handshake->io, isEncrypted
-        ? PEER_ENCRYPTION_RC4
-        : PEER_ENCRYPTION_PLAINTEXT );
-    if( isEncrypted ) {
-        fprintf( stderr, "I guess it's encrypted...\n" );
-        if( tr_peerIoIsIncoming( handshake->io ) ) {
+for( i=0; i<(int)EVBUFFER_LENGTH(inbuf); ++i )
+fprintf( stderr, "[%c]", EVBUFFER_DATA(inbuf)[i] );
+fprintf( stderr, "\n" );
+
+    pstrlen = EVBUFFER_DATA(inbuf)[0]; /* peek, don't read.  We may be
+                                          handing inbuf to AWAITING_YA */
+
+    if( pstrlen == 19 ) /* unencrypted */
+    {
+        tr_peerIoSetEncryption( handshake->io, PEER_ENCRYPTION_NONE );
+    }
+    else /* encrypted or corrupt */
+    {
+        tr_peerIoSetEncryption( handshake->io, PEER_ENCRYPTION_RC4 );
+
+        if( tr_peerIoIsIncoming( handshake->io ) )
+        {
+            dbgmsg( handshake, "I think peer is sending us an encrypted handshake..." );
             setState( handshake, AWAITING_YA );
             return READ_AGAIN;
         }
         tr_cryptoDecrypt( handshake->crypto, 1, &pstrlen, &pstrlen );
-    }
-    bytesRead++;
+
+        if( pstrlen != 19 )
+        {
+            dbgmsg( handshake, "I think peer has sent us a corrupt handshake..." );
+            tr_handshakeDone( handshake, FALSE );
+            return READ_DONE;
+        }
+    }
+
     evbuffer_drain( inbuf, 1 );
-    fprintf( stderr, "pstrlen is %d [%c]\n", (int)pstrlen, pstrlen );
-    assert( pstrlen == 19 );
 
     /* pstr (BitTorrent) */
@@ -678 +541 @@
     tr_peerIoReadBytes( handshake->io, inbuf, pstr, pstrlen );
     pstr[pstrlen] = '\0';
-    fprintf( stderr, "pstrlen is [%s]\n", pstr );
-    bytesRead += pstrlen;
-    fprintf( stderr, "%*.*s", pstrlen, pstrlen, (char*)pstr );
     if( strcmp( (char*)pstr, "BitTorrent protocol" ) ) {
         tr_free( pstr );
-        gotError( NULL, 0, handshake );
+        tr_handshakeDone( handshake, FALSE );
         return READ_DONE;
     }
@@ -690 +550 @@
     /* reserved bytes */
     tr_peerIoReadBytes( handshake->io, inbuf, reserved, sizeof(reserved) );
-    bytesRead += sizeof(reserved);
 
     /* torrent hash */
     tr_peerIoReadBytes( handshake->io, inbuf, hash, sizeof(hash) );
-    bytesRead += sizeof(hash);
     if( tr_peerIoIsIncoming( handshake->io ) )
     {
-        assert( !tr_peerIoHasTorrentHash( handshake->io ) );
-        tr_peerIoSetTorrentHash( handshake->io, hash );
-    }
-    else
-    {
+        if( !tr_torrentExists( handshake->handle, hash ) )
+        {
+            dbgmsg( handshake, "peer is trying to connect to us for a torrent we don't have." );
+            tr_handshakeDone( handshake, FALSE );
+            return READ_DONE;
+        }
+        else
+        {
+            assert( !tr_peerIoHasTorrentHash( handshake->io ) );
+            tr_peerIoSetTorrentHash( handshake->io, hash );
+        }
+    }
+    else /* outgoing */
+    {
+        assert( tr_torrentExists( handshake->handle, hash ) );
         assert( tr_peerIoHasTorrentHash( handshake->io ) );
-        assert( !memcmp( hash, tr_peerIoGetTorrentHash(handshake->io), SHA_DIGEST_LENGTH ) );
+        if( memcmp( hash, tr_peerIoGetTorrentHash(handshake->io), SHA_DIGEST_LENGTH ) )
+        {
+            dbgmsg( handshake, "peer returned the wrong hash. wtf?" );
+            tr_handshakeDone( handshake, FALSE );
+            return READ_DONE;
+        }
     }
 
@@ -709 +582 @@
     tr_peerIoReadBytes( handshake->io, inbuf, handshake->peer_id, sizeof(handshake->peer_id) );
     tr_peerIoSetPeersId( handshake->io, handshake->peer_id );
-    bytesRead += sizeof(handshake->peer_id);
     handshake->havePeerID = TRUE;
 
-    assert( bytesRead == HANDSHAKE_SIZE );
-
     /**
-    ***
+    *** Extension negotiation
     **/
 
-    ltep = HANDSHAKE_HAS_EXTMSGS( reserved ) ? 1 : 0;
-    azmp = HANDSHAKE_HAS_AZPROTO( reserved ) ? 1 : 0;
+    ltep = HANDSHAKE_HAS_EXTMSGS( reserved );
+    azmp = HANDSHAKE_HAS_AZPROTO( reserved );
     if( ltep && azmp ) {
         switch( HANDSHAKE_GET_EXTPREF( reserved ) ) {
@@ -733 +603 @@
     }
     assert( !ltep || !azmp );
-         if( ltep ) { i = LT_EXTENSIONS_LTEP; fprintf(stderr,"using ltep\n" ); }
-    else if( azmp ) { i = LT_EXTENSIONS_AZMP; fprintf(stderr,"using azmp\n" ); }
-    else            { i = LT_EXTENSIONS_NONE; fprintf(stderr,"using no extensions\n" ); }
+         if( ltep ) { i = LT_EXTENSIONS_LTEP; dbgmsg(handshake,"using ltep" ); }
+    else if( azmp ) { i = LT_EXTENSIONS_AZMP; dbgmsg(handshake,"using azmp" ); }
+    else            { i = LT_EXTENSIONS_NONE; dbgmsg(handshake,"using no extensions" ); }
     tr_peerIoSetExtension( handshake->io, i );
 
 
-    if( i == LT_EXTENSIONS_LTEP )
-    {
-        sendLtepHandshake( handshake );
-        return READ_DONE;
-    }
-    else if( !tr_peerIoIsIncoming( handshake->io ) && ( i != LT_EXTENSIONS_AZMP ) )
-    {
-        fireDoneCB( handshake, TRUE );
-        return READ_DONE;
-    }
-
-
-    fprintf( stderr, " UNHANDLED -- azmp " );
-    return 0;
-}
-
-/**
-***
-**/
+    /**
+    ***  If this is an incoming message, then we need to send a response handshake
+    **/
+
+    if( !handshake->haveSentBitTorrentHandshake )
+    {
+        const int ext = ltep ? HANDSHAKE_EXTPREF_LTEP_FORCE
+                             : HANDSHAKE_EXTPREF_AZMP_FORCE;
+        int msgSize;
+        uint8_t * msg = buildHandshakeMessage( handshake, ext, &msgSize );
+        tr_peerIoWrite( handshake->io, msg, msgSize );
+        tr_free( msg );
+        handshake->haveSentBitTorrentHandshake = 1;
+    }
+
+    /* we've completed the BT handshake... pass the work on to peer-msgs */
+    tr_handshakeDone( handshake, TRUE );
+    return READ_DONE;
+}
+
+static int
+readYa( tr_handshake * handshake, struct evbuffer  * inbuf )
+{
+    uint8_t ya[KEY_LEN];
+    uint8_t *walk, outbuf[KEY_LEN + PadB_MAXLEN];
+    const uint8_t *myKey, *secret;
+    int len;
+
+    if( EVBUFFER_LENGTH( inbuf ) < KEY_LEN )
+        return READ_MORE;
+
+    /* read the incoming peer's public key */
+    evbuffer_remove( inbuf, ya, KEY_LEN );
+    secret = tr_cryptoComputeSecret( handshake->crypto, ya );
+    memcpy( handshake->mySecret, secret, KEY_LEN );
+    tr_sha1( handshake->myReq1, "req1", 4, secret, KEY_LEN, NULL );
+
+    /* send our public key to the peer */
+    walk = outbuf;
+    myKey = tr_cryptoGetMyPublicKey( handshake->crypto, &len );
+    memcpy( walk, myKey, len );
+    len = tr_rand( PadB_MAXLEN );
+    while( len-- )
+        *walk++ = tr_rand( UCHAR_MAX );
+
+    setReadState( handshake, AWAITING_PAD_A );
+    tr_peerIoWrite( handshake->io, outbuf, walk-outbuf );
+
+    return READ_DONE;
+}
+
+static int
+readPadA( tr_handshake * handshake, struct evbuffer * inbuf )
+{
+    uint8_t * pch;
+
+    /**
+    *** Resynchronizing on HASH('req1',S)
+    **/
+
+    pch = memchr( EVBUFFER_DATA(inbuf),
+                  handshake->myReq1[0],
+                  EVBUFFER_LENGTH(inbuf) );
+    if( pch == NULL ) {
+        evbuffer_drain( inbuf, EVBUFFER_LENGTH(inbuf) );
+        return READ_MORE;
+    }
+    evbuffer_drain( inbuf, pch-EVBUFFER_DATA(inbuf) );
+    if( EVBUFFER_LENGTH(inbuf) < SHA_DIGEST_LENGTH )
+        return READ_MORE;
+    if( memcmp( EVBUFFER_DATA(inbuf), handshake->myReq1, SHA_DIGEST_LENGTH ) ) {
+        evbuffer_drain( inbuf, 1 );
+        return READ_AGAIN;
+    }
+
+    setState( handshake, AWAITING_CRYPTO_PROVIDE );
+    return READ_AGAIN;
+}
+
+static int
+readCryptoProvide( tr_handshake * handshake, struct evbuffer * inbuf )
+{
+    /* HASH('req2', SKEY) xor HASH('req3', S), ENCRYPT(VC, crypto_provide, len(PadC)) */
+
+    int i;
+    uint8_t vc_in[VC_LENGTH];
+    uint8_t req2[SHA_DIGEST_LENGTH];
+    uint8_t req3[SHA_DIGEST_LENGTH];
+    uint8_t obfuscatedTorrentHash[SHA_DIGEST_LENGTH];
+    uint16_t padc_len = 0;
+    uint32_t crypto_provide = 0;
+    const size_t needlen = SHA_DIGEST_LENGTH + VC_LENGTH + sizeof(crypto_provide) + sizeof(padc_len);
+    tr_torrent * tor = NULL;
+
+    if( EVBUFFER_LENGTH(inbuf) < needlen )
+        return READ_MORE;
+
+    /* TODO: confirm they sent HASH('req1',S) here? */
+    evbuffer_drain( inbuf, SHA_DIGEST_LENGTH );
+
+    /* This next piece is HASH('req2', SKEY) xor HASH('req3', S) ...
+     * we can get the first half of that (the obufscatedTorrentHash)
+     * by building the latter and xor'ing it with what the peer sent us */
+    dbgmsg( handshake, "reading obfuscated torrent hash...\n" );
+    evbuffer_remove( inbuf, req2, SHA_DIGEST_LENGTH );
+    tr_sha1( req3, "req3", 4, handshake->mySecret, KEY_LEN, NULL );
+    for( i=0; i<SHA_DIGEST_LENGTH; ++i )
+        obfuscatedTorrentHash[i] = req2[i] ^ req3[i];
+    tor = tr_torrentFindFromObfuscatedHash( handshake->handle, obfuscatedTorrentHash );
+    assert( tor != NULL );
+    dbgmsg( handshake, "found the torrent; it's [%s]\n", tor->info.name );
+    tr_peerIoSetTorrentHash( handshake->io, tor->info.hash );
+
+    /* next part: ENCRYPT(VC, crypto_provide, len(PadC), */
+
+    tr_cryptoDecryptInit( handshake->crypto );
+
+    tr_peerIoReadBytes( handshake->io, inbuf, vc_in, VC_LENGTH );
+
+    tr_peerIoReadUint32( handshake->io, inbuf, &crypto_provide );
+    dbgmsg( handshake, "crypto_provide is %d\n", (int)crypto_provide );
+
+    tr_peerIoReadUint16( handshake->io, inbuf, &padc_len );
+    dbgmsg( handshake, "padc is %d\n", (int)padc_len );
+    handshake->pad_c_len = padc_len;
+    setState( handshake, AWAITING_PAD_C );
+    return READ_AGAIN;
+}
+
+static int
+readPadC( tr_handshake * handshake, struct evbuffer * inbuf )
+{
+    uint16_t ia_len;
+    const size_t needlen = handshake->pad_c_len + sizeof(uint16_t);
+
+    if( EVBUFFER_LENGTH(inbuf) < needlen )
+        return READ_MORE;
+
+    evbuffer_drain( inbuf, needlen );
+
+    tr_peerIoReadUint16( handshake->io, inbuf, &ia_len );
+    dbgmsg( handshake, "ia_len is %d", (int)ia_len );
+    handshake->ia_len = ia_len;
+    setState( handshake, AWAITING_IA );
+    return READ_AGAIN;
+}
+
+static int
+readIA( tr_handshake * handshake, struct evbuffer * inbuf )
+{
+    const size_t needlen = handshake->ia_len;
+
+    if( EVBUFFER_LENGTH(inbuf) < needlen )
+        return READ_MORE;
+
+    return readHandshake( handshake, inbuf );
+}
+
+/***
+****
+****
+****
+***/
 
 static ReadState
@@ -765 +779 @@
     struct evbuffer * inbuf = EVBUFFER_INPUT ( evin );
     ReadState ret;
-    fprintf( stderr, "handshake %p handling canRead; state is [%s]\n", handshake, getStateName(handshake->state) );
+    dbgmsg( handshake, "handling canRead; state is [%s]\n", getStateName(handshake->state) );
 
     switch( handshake->state )
@@ -788 +802 @@
 
 static void
-tr_handshakeFree( tr_handshake * handshake )
-{
-    tr_free( handshake );
-}
-
-static void
-fireDoneCB( tr_handshake * handshake, int isConnected )
+fireDoneFunc( tr_handshake * handshake, int isConnected )
 {
     const uint8_t * peer_id = isConnected && handshake->havePeerID
@@ -805 +813 @@
                           handshake->peerSupportsEncryption,
                           handshake->doneUserData );
-    tr_handshakeFree( handshake );
+}
+
+void
+tr_handshakeDone( tr_handshake * handshake, int isOK )
+{
+    dbgmsg( handshake, "handshakeDone: %s", isOK ? "connected" : "aborting" );
+    tr_peerIoSetIOFuncs( handshake->io, NULL, NULL, NULL, NULL );
+    fireDoneFunc( handshake, isOK );
+    tr_free( handshake );
+}
+
+void
+tr_handshakeAbort( tr_handshake * handshake )
+{
+    tr_handshakeDone( handshake, FALSE );
 }
 
@@ -817 +839 @@
      * try a plaintext handshake */
     if(    ( ( handshake->state == AWAITING_YB ) || ( handshake->state == AWAITING_VC ) )
-        && ( handshake->encryptionPreference != HANDSHAKE_ENCRYPTION_REQUIRED )
+        && ( !handshake->shunUnencryptedPeers )
         && ( !tr_peerIoReconnect( handshake->io ) ) )
     {
-fprintf( stderr, "handshake %p trying again in plaintext...\n", handshake );
-        handshake->encryptionPreference = HANDSHAKE_PLAINTEXT_REQUIRED;
-        sendPlaintextHandshake( handshake );
+        int msgSize; 
+        uint8_t * msg = buildHandshakeMessage( handshake, HANDSHAKE_EXTPREF_LTEP_PREFER, &msgSize );
+        setReadState( handshake, AWAITING_HANDSHAKE );
+        tr_peerIoWrite( handshake->io, msg, msgSize );
+        tr_free( msg );
     }
     else
     {
-        tr_peerIoSetIOFuncs( handshake->io, NULL, NULL, NULL, NULL );
-        fireDoneCB( handshake, FALSE );
+        tr_handshakeDone( handshake, FALSE );
     }
 }
@@ -836 +859 @@
 
 tr_handshake*
-tr_handshakeNew( tr_peerIo        * io,
-                 int                encryptionPreference,
-                 handshakeDoneCB    doneCB,
-                 void             * doneUserData )
+tr_handshakeNew( tr_peerIo           * io,
+                 tr_encryption_mode    encryption_mode,
+                 handshakeDoneCB       doneCB,
+                 void                * doneUserData )
 {
     tr_handshake * handshake;
 
-//w00t
+// w00t
 //static int count = 0;
 //if( count++ ) return NULL;
@@ -850 +873 @@
     handshake->io = io;
     handshake->crypto = tr_peerIoGetCrypto( io );
-    handshake->encryptionPreference = encryptionPreference;
+    handshake->shunUnencryptedPeers = encryption_mode==TR_ENCRYPTION_REQUIRED;
     handshake->doneCB = doneCB;
     handshake->doneUserData = doneUserData;
@@ -858 +881 @@
     tr_peerIoSetIOFuncs( io, canRead, NULL, gotError, handshake );
 
-fprintf( stderr, "handshake %p: new handshake for io %p\n", handshake, io );
+dbgmsg( handshake, "new handshake for io %p", io );
 
     if( tr_peerIoIsIncoming( io ) )
-    {
         setReadState( handshake, AWAITING_HANDSHAKE );
-    }
     else
-    {
-        sendHandshake( handshake );
-    }
+        sendYa( handshake );
 
     return handshake;
 }
-
-void
-tr_handshakeAbort( tr_handshake * handshake )
-{
-    tr_peerIoFree( handshake->io );
-    tr_handshakeFree( handshake );
-}