Add files via upload

qwj · web-flow · commit ee6a710b73bf · 2016-11-03T16:26:49.000+08:00
diff --git a/pproxy/__init__.py b/pproxy/__init__.py
@@ -2,7 +2,7 @@
 from pproxy import proto
 
 __title__ = 'pproxy'
-__version__ = "0.9.9"
+__version__ = "1.0.0"
 __description__ = "Proxy server that can tunnel among remote servers by regex rules."
 __author__ = "Qian Wenjie"
 __license__ = "MIT License"
@@ -140,12 +140,16 @@ def main():
     for option in args.listen:
         print(f'Serving on {option.bind} by {",".join(i.__name__ for i in option.protos)}', '(SSL)' if option.sslclient else '')
         handler = functools.partial(proxy_handler, **vars(args), **vars(option))
-        server = loop.run_until_complete(option.server(handler))
-        servers.append(server)
-    try:
-        loop.run_forever()
-    except KeyboardInterrupt:
-        print('exit')
+        try:
+            server = loop.run_until_complete(option.server(handler))
+            servers.append(server)
+        except Exception as ex:
+            print(f'Start server failed.\n\t==> {ex}')
+    if servers:
+        try:
+            loop.run_forever()
+        except KeyboardInterrupt:
+            print('exit')
     if args.auth_tables:
         with open('.auth_tables', 'wb') as f:
             pickle.dump(args.auth_tables, f, pickle.HIGHEST_PROTOCOL)
diff --git a/pproxy/cipherpy.py b/pproxy/cipherpy.py
@@ -3,7 +3,6 @@
 from pproxy.cipher import BaseCipher
 
 # Pure Python Ciphers
-ROL = lambda a, b: (a<<b)|((a&0xffffffff)>>(32-b))
 
 class Table_Cipher(BaseCipher):
     LIBRARY = False
@@ -55,6 +54,7 @@ def setup(self):
         self.key = hashlib.md5(self.key + self.iv).digest()
         RC4_Cipher.setup(self)
 
+ROL = lambda a, b: a<<b|(a&0xffffffff)>>(32-b)
 class ChaCha20_Cipher(StreamCipher):
     KEY_LENGTH = 32
     IV_LENGTH = 8
@@ -96,10 +96,11 @@ def core(self):
 
 class CFBCipher(StreamCipher):
     def setup(self):
-        self.bit_mode = self.SEGMENT_SIZE % 8 != 0
-        self.stream = self.core_bit() if self.bit_mode else self.core()
+        segment_bit = getattr(self, 'SEGMENT_SIZE', self.IV_LENGTH*8)
+        self.bit_mode = segment_bit % 8 != 0
+        self.stream = self.core_bit(segment_bit) if self.bit_mode else self.core(segment_bit//8)
         self.last = None
-        self.cipher = self.CIPHER(self.key)
+        self.cipher = self.CIPHER.new(self.key)
     def process(self, s, inv=False):
         r = bytearray()
         for i in s:
@@ -119,35 +120,39 @@ def encrypt(self, s):
         return self.process(s, False)
     def decrypt(self, s):
         return self.process(s, True)
-    def core(self):
+    def core(self, segment_byte):
         next_iv = bytearray(self.iv)
-        segment_byte = self.SEGMENT_SIZE // 8
         while 1:
             data = self.cipher.encrypt(next_iv)
             del next_iv[:segment_byte]
             for i in range(segment_byte):
                 next_iv.append((yield data[i]))
-    def core_bit(self):
+    def core_bit(self, segment_bit):
         next_iv = int.from_bytes(self.iv, 'big')
-        mask = (1 << (self.IV_LENGTH*8)) - 1
+        mask = (1 << self.IV_LENGTH*8) - 1
         while 1:
             data = self.cipher.encrypt(next_iv.to_bytes(self.IV_LENGTH, 'big'))
-            next_iv = (next_iv << self.SEGMENT_SIZE) & mask
-            for i in range(self.SEGMENT_SIZE):
-                next_iv |= (yield (data[i//8]>>(7-i%8))&1)<<(self.SEGMENT_SIZE-1-i)
+            next_iv = next_iv<<segment_bit & mask
+            for i in range(segment_bit):
+                next_iv |= (yield (data[i//8]>>(7-i%8))&1)<<(segment_bit-1-i)
+
+class CFB8Cipher(CFBCipher):
+    SEGMENT_SIZE = 8
+
+class CFB1Cipher(CFBCipher):
+    SEGMENT_SIZE = 1
 
 class CTRCipher(StreamCipher):
     def setup(self):
         self.stream = self.core()
-        self.cipher = self.CIPHER(self.key)
+        self.cipher = self.CIPHER.new(self.key)
     def encrypt(self, s):
         return bytes(i^next(self.stream) for i in s)
     decrypt = encrypt
     def core(self):
         next_iv = int.from_bytes(self.iv, 'big')
         while 1:
-            data = self.cipher.encrypt(next_iv.to_bytes(self.IV_LENGTH, 'big'))
-            yield from data
+            yield from self.cipher.encrypt(next_iv.to_bytes(self.IV_LENGTH, 'big'))
             next_iv = 0 if next_iv >= (1<<(self.IV_LENGTH*8))-1 else next_iv+1
 
 class OFBCipher(CTRCipher):
@@ -157,94 +162,53 @@ def core(self):
             data = self.cipher.encrypt(data)
             yield from data
 
-class AES:
+class RAW:
+    CACHE = {}
+    @classmethod
+    def new(cls, key):
+        if key in cls.CACHE:
+            return cls.CACHE[key]
+        ret = cls.CACHE[key] = cls(key)
+        return ret
+
+class AES(RAW):
     g1 = base64.b64decode(b'Y3x3e/Jrb8UwAWcr/terdsqCyX36WUfwrdSir5ykcsC3/ZMmNj/3zDSl5fFx2DEVBMcjwxiWBZoHEoDi6yeydQmDLBobblqgUjvWsynjL4RT0QDtIPyxW2rLvjlKTFjP0O+q+0NNM4VF+QJ/UDyfqFGjQI+SnTj1vLbaIRD/89LNDBPsX5dEF8Snfj1kXRlzYIFP3CIqkIhG7rgU3l4L2+AyOgpJBiRcwtOsYpGV5HnnyDdtjdVOqWxW9Opleq4IunglLhymtMbo3XQfS72LinA+tWZIA/YOYTVXuYbBHZ7h+JgRadmOlJseh+nOVSjfjKGJDb/mQmhBmS0PsFS7Fg==')
     g2 = [((a<<1)&0xff)^0x1b if a&0x80 else a<<1 for a in g1]
     g3 = [a^(((a<<1)&0xff)^0x1b if a&0x80 else a<<1) for a in g1]
     Rcon = base64.b64decode(b'jQECBAgQIECAGzZs2KtNmi9evGPGlzVq1LN9+u/FkTly5NO9YcKfJUqUM2bMgx06dOjL')
     shifts = tuple((j,j&3|((j>>2)+(j&3))*4&12,(j+3)&3|((j>>2)+((j+3)&3))*4&12,(j+2)&3|((j>>2)+((j+2)&3))*4&12,(j+1)&3|((j>>2)+((j+1)&3))*4&12) for j in range(16))
     def __init__(self, key):
-        size = len(key)
+        size, ekey = len(key), bytearray(key)
         nbr = {16:10, 24:12, 32:14}[size]
-        ekey = bytearray(key)
         while len(ekey) < 16*(nbr+1):
             t = ekey[-4:]
             if len(ekey) % size == 0:
                 t = [self.g1[i] for i in t[1:]+t[:1]]
                 t[0] ^= self.Rcon[len(ekey)//size%51]
             if size == 32 and len(ekey) % size == 16:
                 t = [self.g1[i] for i in t]
-            for m in t:
-                ekey.append(ekey[-size] ^ m)
+            ekey.extend(m^ekey[i-size] for i, m in enumerate(t))
         self.ekey = tuple(ekey[i*16:i*16+16] for i in range(nbr+1))
     def encrypt(self, data):
         s = [data[j]^self.ekey[0][j] for j in range(16)]
         for key in self.ekey[1:-1]:
             s = [self.g2[s[a]]^self.g1[s[b]]^self.g1[s[c]]^self.g3[s[d]]^key[j] for j,a,b,c,d in self.shifts]
         return bytes(self.g1[s[self.shifts[j][1]]]^self.ekey[-1][j] for j in range(16))
 
-class AES_256_CFB_Cipher(CFBCipher):
-    KEY_LENGTH = 32
-    IV_LENGTH = 16
-    SEGMENT_SIZE = IV_LENGTH*8
-    CIPHER = AES
-
-class AES_192_CFB_Cipher(AES_256_CFB_Cipher):
-    KEY_LENGTH = 24
-
-class AES_128_CFB_Cipher(AES_256_CFB_Cipher):
-    KEY_LENGTH = 16
-
-class AES_256_CFB8_Cipher(AES_256_CFB_Cipher):
-    SEGMENT_SIZE = 8
-
-class AES_192_CFB8_Cipher(AES_256_CFB8_Cipher):
-    KEY_LENGTH = 24
-
-class AES_128_CFB8_Cipher(AES_256_CFB8_Cipher):
-    KEY_LENGTH = 16
-
-class AES_256_CFB1_Cipher(AES_256_CFB_Cipher):
-    SEGMENT_SIZE = 1
-
-class AES_192_CFB1_Cipher(AES_256_CFB1_Cipher):
-    KEY_LENGTH = 24
-
-class AES_128_CFB1_Cipher(AES_256_CFB1_Cipher):
-    KEY_LENGTH = 16
+for method in (CFBCipher, CFB8Cipher, CFB1Cipher, CTRCipher, OFBCipher):
+    for key in (32, 24, 16):
+        name = f'AES_{key*8}_{method.__name__[:-6]}_Cipher'
+        globals()[name] = type(name, (method,), dict(KEY_LENGTH=key, IV_LENGTH=16, CIPHER=AES))
 
-class AES_256_CTR_Cipher(CTRCipher):
-    KEY_LENGTH = 32
-    IV_LENGTH = 16
-    CIPHER = AES
-
-class AES_192_CTR_Cipher(AES_256_CTR_Cipher):
-    KEY_LENGTH = 24
-
-class AES_128_CTR_Cipher(AES_256_CTR_Cipher):
-    KEY_LENGTH = 16
-
-class AES_256_OFB_Cipher(OFBCipher):
-    KEY_LENGTH = 32
-    IV_LENGTH = 16
-    CIPHER = AES
-
-class AES_192_OFB_Cipher(AES_256_OFB_Cipher):
-    KEY_LENGTH = 24
-
-class AES_128_OFB_Cipher(AES_256_OFB_Cipher):
-    KEY_LENGTH = 16
-
-class Blowfish:
+class Blowfish(RAW):
     P = None
     @staticmethod
     def hex_pi():
         N, n, d = 0, 0, 1
-        while 1:
+        for N in range(1<<20):
             xn, xd = 120*N**2 + 151*N + 47, 512*N**4 + 1024*N**3 + 712*N**2 + 194*N + 15
             n, d = ((16 * n * xd) + (xn * d)) % (d * xd), d * xd
             yield b'%x' % (16 * n // d)
-            N += 1
     def __init__(self, key):
         if not self.P:
             pi = self.hex_pi()
@@ -265,8 +229,42 @@ def encrypt(self, s):
 class BF_CFB_Cipher(CFBCipher):
     KEY_LENGTH = 16
     IV_LENGTH = 8
-    SEGMENT_SIZE = IV_LENGTH*8
     CIPHER = Blowfish
 
+class Camellia(RAW):
+    S1 = base64.b64decode(b'cIIs7LMnwOXkhVc16gyuQSPva5NFGaUh7Q5PTh1lkr2GuK+PfOsfzj4w3F9exQsapuE5ytVHXT3ZAVrWUVZsTYsNmmb7zLAtdBIrIPCxhJnfTMvCNH52BW23qTHRFwTXFFg6Yd4bERwyD5wWUxjyIv5Ez7LDtXqRJAjoqGD8aVCq0KB9oYlil1RbHpXg/2TSEMQASKP3dduKA+baCT/dlIdcgwLNSpAzc2f2851/v+JSm9gmyDfGO4GWb0sTvmMu6XmnjJ9uvI4p9fm2L/20WXiYBmrnRnG61CWrQoiijfpyB7lV+O6sCjZJKmg8OPGkQCjTe7vJQ8EV4630d8eAng==')
+    S2, S3, S4 = bytes(i>>7|(i&0x7f)<<1 for i in S1), bytes(i>>1|(i&1)<<7 for i in S1), S1[::2]+S1[1::2]
+    S = (S1, S4, S3, S2, S4, S3, S2, S1)
+    KS = base64.b64decode(b'AAIICiAiKCpIShETGTM5OxIQQkBKSCMhKykAAgwOJCYoKkRGTE4RExkbMTM1Nz0/EhAaGEZESkgjIS8t')
+    KS = tuple((i%16//4, i%4*32, (64,51,49,36,34)[i>>4]) for i in KS)
+    def R(self, s, t):
+        t = sum(S[((t^s>>64)>>(i*8))&0xff]<<(i*8+32)%64 for i,S in enumerate(self.S))
+        t = t^t>>32<<8&0xffffff00^t>>56^((t>>32<<56|t>>8)^t<<48)&0xffff<<48^(t>>8^t<<16)&0xffff<<32
+        return (t^t>>8&0xff<<24^t>>40^t<<16&0xff<<56^t<<56^(t>>32<<48^t>>16^t<<24)&0xffffff<<32^s)<<64&(1<<128)-1|s>>64
+    def __init__(self, key):
+        q, R = [int.from_bytes(key[:16], 'big'), int.from_bytes(key[16:], 'big'), 0, 0], self.R
+        q[1] = q[1]<<64|q[1]^((1<<64)-1) if len(key)==24 else q[1]
+        q[2] = R(R(R(R(q[0]^q[1],0xa09e667f3bcc908b),0xb67ae8584caa73b2)^q[0],0xc6ef372fe94f82be),0x54ff53a5f1d36f1c)
+        q[3] = R(R(q[2]^q[1],0x10e527fade682d1d),0xb05688c2b3e6c1fd)
+        nr, ks = (22, self.KS[:26]) if len(key)==16 else (29, self.KS[26:])
+        e = [(q[n]<<m>>o|q[n]>>128-m+o)&(1<<64)-1 for n, m, o in ks]
+        self.e = [e[i+i//7]<<64|e[i+i//7+1] if i%7==0 else e[i+i//7+1] for i in range(nr)]
+    def encrypt(self, s):
+        s = int.from_bytes(s, 'big')^self.e[0]
+        for idx, k in enumerate(self.e[1:-1]):
+            s = s^((s&k)>>95&0xfffffffe|(s&k)>>127)<<64^((s&k)<<1&~1<<96^(s&k)>>31^s<<32|k<<32)&0xffffffff<<96 ^ ((s|k)&0xffffffff)<<32^((s|k)<<1^s>>31)&k>>31&0xfffffffe^((s|k)>>31^s>>63)&k>>63&1 if (idx+1)%7==0 else self.R(s, k)
+        return (s>>64^(s&(1<<64)-1)<<64^self.e[-1]).to_bytes(16, 'big')
+
+class Camellia_256_CFB_Cipher(CFBCipher):
+    KEY_LENGTH = 32
+    IV_LENGTH = 16
+    CIPHER = Camellia
+
+class Camellia_192_CFB_Cipher(Camellia_256_CFB_Cipher):
+    KEY_LENGTH = 24
+
+class Camellia_128_CFB_Cipher(Camellia_256_CFB_Cipher):
+    KEY_LENGTH = 16
+
 MAP = {name[:-7].replace('_', '-').lower()+'-py': cls for name, cls in globals().items() if name.endswith('_Cipher')}
 
