Melhorar sistema RC4 para bittorrent

[Cheaster]

Hey galera. Estou fazendo um cliente bittorrent em python baseado no ABC.

Então é o seguinte estou tentado encriptar um sistema RC4 de forma a contornar o Traffic Shaping dos ISP's. A ideia é encriptar o mais possivel o tráfego bittorrent para que este não seja identificado pela operadora e seja bloqueado.

Deixo aqui o meu código RC4. Por favor ajudem-me a melhorar e tornar o código mais eficiente. Aceito todo o tipo de truques e dicas.

Ficheiro ARC4.py

"""From TLS Lite: Pure-Python RC4 implementation"""
import array

def bytesToString(bytes):
    return bytes.tostring()

def createByteArrayZeros(howMany):
    return array.array('B', [0] * howMany)

def stringToBytes(s):
    bytes = createByteArrayZeros(0)
    bytes.fromstring(s)
    return bytes

def new(key):
    return RC4(key)

class RC4:
    def __init__(self, key):
        keyBytes = stringToBytes(key)
        S = [i for i in range(256)]
        j = 0
        for i in range(256):
            j = (j + S[i] + keyBytes[i % len(keyBytes)]) % 256
            S[i], S[j] = S[j], S[i]

        self.S = S
        self.i = 0
        self.j = 0

    def encrypt(self, plaintext):
        plaintextBytes = stringToBytes(plaintext)
        S = self.S
        i = self.i
        j = self.j
        for x in range(len(plaintextBytes)):
            i = (i + 1) % 256
            j = (j + S[i]) % 256
            S[i], S[j] = S[j], S[i]
            t = (S[i] + S[j]) % 256
            plaintextBytes[x] ^= S[t]
        self.i = i
        self.j = j
        return bytesToString(plaintextBytes)

    def decrypt(self, ciphertext):
        return self.encrypt(ciphertext)

Ficheiro BTcrypto.py

# Written by John Hoffman
# based on code by Uoti Urpala
# see LICENSE.txt for license information

from __future__ import generators   # for python 2.2
from random import randrange,randint,seed
try:
    from os import urandom
except:
    seed()
    urandom = lambda x: ''.join([chr(randint(0,255)) for i in xrange(x)])
from sha import sha
try:
    True
except:
    True = 1
    False = 0
    
try:
    from Crypto.Cipher import ARC4
    CRYPTO_OK = True
except:
    import ARC4
    CRYPTO_OK = False

KEY_LENGTH = 160
DH_PRIME = 0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A63A36210000000000090563
PAD_MAX = 200 # less than protocol maximum, and later assumed to be < 256
DH_BYTES = 96

def bytetonum(x):
    return long(x.encode('hex'), 16)

def numtobyte(x):
    x = hex(x).lstrip('0x').rstrip('Ll')
    x = '0'*(192 - len(x)) + x
    return x.decode('hex')

class Crypto:
    def __init__(self, initiator, disable_crypto = False):
        self.initiator = initiator
        self.disable_crypto = disable_crypto
#        if not disable_crypto and not CRYPTO_OK:
#            raise NotImplementedError, "attempt to run encryption w/ none installed"
        self.privkey = bytetonum(urandom(KEY_LENGTH/8))
        self.pubkey = numtobyte(pow(2, self.privkey, DH_PRIME))
        self.keylength = DH_BYTES
        self._VC_pattern = None

    def received_key(self, k):
        self.S = numtobyte(pow(bytetonum(k), self.privkey, DH_PRIME))
        self.block3a = sha('req1'+self.S).digest()
        self.block3bkey = sha('req3'+self.S).digest()
        self.block3b = None

    def _gen_block3b(self, SKEY):
        a = sha('req2'+SKEY).digest()
        return ''.join([ chr(ord(a[i])^ord(self.block3bkey[i]))
                         for i in xrange(20) ])

    def test_skey(self, s, SKEY):
        block3b = self._gen_block3b(SKEY)
        if block3b != s:
            return False
        self.block3b = block3b
        if not self.disable_crypto:
            self.set_skey(SKEY)
        return True

    def set_skey(self, SKEY):
        if not self.block3b:
            self.block3b = self._gen_block3b(SKEY)
        crypta = ARC4.new(sha('keyA'+self.S+SKEY).digest())
        cryptb = ARC4.new(sha('keyB'+self.S+SKEY).digest())
        if self.initiator:
            self.encrypt = crypta.encrypt
            self.decrypt = cryptb.decrypt
        else:
            self.encrypt = cryptb.encrypt
            self.decrypt = crypta.decrypt
        self.encrypt('x'*1024)  # discard first 1024 bytes
        self.decrypt('x'*1024)

    def VC_pattern(self):
        if not self._VC_pattern:
            self._VC_pattern = self.decrypt('\x00'*8)
        return self._VC_pattern


    def read(self, s):
        self._read(self.decrypt(s))

    def write(self, s):
        self._write(self.encrypt(s))

    def setrawaccess(self, _read, _write):
        self._read = _read
        self._write = _write

    def padding(self):
        return urandom(randrange(PAD_MAX-16)+16)

Por favor me ajudem-me com o meu programa.

Contacto MSN: geral@bt-revolution.net

Cumps