gotr/potr/crypt.py

@@ -22,8 +22,8 @@ import logging
 import struct
 
 
-from potr.compatcrypto import SHA256, SHA1, HMAC, SHA1HMAC, SHA256HMAC, \
-        SHA256HMAC160, Counter, AESCTR, RNG, PK, generateDefaultKey
+from potr.compatcrypto import SHA256, SHA1, SHA1HMAC, SHA256HMAC, \
+        SHA256HMAC160, Counter, AESCTR, PK, random
 from potr.utils import bytes_to_long, long_to_bytes, pack_mpi, read_mpi
 from potr import proto
 
@@ -36,32 +36,31 @@ STATE_AWAITING_SIG = 4
 STATE_V1_SETUP = 5
 
 
-DH1536_MODULUS = 2410312426921032588552076022197566074856950548502459942654116941958108831682612228890093858261341614673227141477904012196503648957050582631942730706805009223062734745341073406696246014589361659774041027169249453200378729434170325843778659198143763193776859869524088940195577346119843545301547043747207749969763750084308926339295559968882457872412993810129130294592999947926365264059284647209730384947211681434464714438488520940127459844288859336526896320919633919
-DH1536_MODULUS_2 = DH1536_MODULUS-2
-DH1536_GENERATOR = 2
-SM_ORDER = (DH1536_MODULUS - 1) // 2
+DH_MODULUS = 2410312426921032588552076022197566074856950548502459942654116941958108831682612228890093858261341614673227141477904012196503648957050582631942730706805009223062734745341073406696246014589361659774041027169249453200378729434170325843778659198143763193776859869524088940195577346119843545301547043747207749969763750084308926339295559968882457872412993810129130294592999947926365264059284647209730384947211681434464714438488520940127459844288859336526896320919633919
+DH_MODULUS_2 = DH_MODULUS-2
+DH_GENERATOR = 2
+DH_BITS = 1536
+DH_MAX = 2**DH_BITS
+SM_ORDER = (DH_MODULUS - 1) // 2
 
 def check_group(n):
-    return 2 <= n <= DH1536_MODULUS_2
+    return 2 <= n <= DH_MODULUS_2
 def check_exp(n):
     return 1 <= n < SM_ORDER
 
 class DH(object):
-    __slots__ = ['priv', 'pub']
     @classmethod
     def set_params(cls, prime, gen):
         cls.prime = prime
         cls.gen = gen
 
     def __init__(self):
-        self.priv = bytes_to_long(RNG.read(40))
+        self.priv = random.randrange(2, 2**320)
         self.pub = pow(self.gen, self.priv, self.prime)
 
-DH.set_params(DH1536_MODULUS, DH1536_GENERATOR)
+DH.set_params(DH_MODULUS, DH_GENERATOR)
 
 class DHSession(object):
-    __slots__ = ['sendenc', 'sendmac', 'rcvenc', 'rcvmac', 'sendctr', 'rcvctr',
-            'sendmacused', 'rcvmacused']
     def __init__(self, sendenc, sendmac, rcvenc, rcvmac):
         self.sendenc = sendenc
         self.sendmac = sendmac
@@ -79,7 +78,7 @@ class DHSession(object):
 
     @classmethod
     def create(cls, dh, y):
-        s = pow(y, dh.priv, DH1536_MODULUS)
+        s = pow(y, dh.priv, DH_MODULUS)
         sb = pack_mpi(s)
 
         if dh.pub > y:
@@ -96,9 +95,6 @@ class DHSession(object):
         return cls(sendenc, sendmac, rcvenc, rcvmac)
 
 class CryptEngine(object):
-    __slots__ = ['ctx', 'ake', 'sessionId', 'sessionIdHalf', 'theirKeyid',
-            'theirY', 'theirOldY', 'ourOldDHKey', 'ourDHKey', 'ourKeyid',
-            'sessionkeys', 'theirPubkey', 'savedMacKeys', 'smp']
     def __init__(self, ctx):
         self.ctx = ctx
         self.ake = None
@@ -118,6 +114,7 @@ class CryptEngine(object):
         self.savedMacKeys = []
 
         self.smp = None
+        self.extraKey = None
 
     def revealMacs(self, ours=True):
         if ours:
@@ -174,7 +171,7 @@ class CryptEngine(object):
         if msg.mac != SHA1HMAC(sesskey.rcvmac, msg.getMacedData()):
             logger.error('HMACs don\'t match')
             raise InvalidParameterError
-        sesskey.rcvmacused = 1
+        sesskey.rcvmacused = True
 
         newCtrPrefix = bytes_to_long(msg.ctr)
         if newCtrPrefix <= sesskey.rcvctr.prefix:
@@ -223,11 +220,14 @@ class CryptEngine(object):
             self.smp = SMPHandler(self)
         self.smp.abort(appdata=appdata)
 
-    def createDataMessage(self, message, flags=0, tlvs=[]):
+    def createDataMessage(self, message, flags=0, tlvs=None):
         # check MSGSTATE
         if self.theirKeyid == 0:
             raise InvalidParameterError
 
+        if tlvs is None:
+            tlvs = []
+
         sess = self.sessionkeys[1][0]
         sess.sendctr.inc()
 
@@ -303,13 +303,16 @@ class CryptEngine(object):
         self.ourKeyid = ake.ourKeyid
         self.theirY = ake.gy
         self.theirOldY = None
+        self.extraKey = ake.extraKey
 
         if self.ourKeyid != ake.ourKeyid + 1 or self.ourOldDHKey != ake.dh.pub:
-            # XXX is this really ok?
             self.ourDHKey = ake.dh
             self.sessionkeys[0][0] = DHSession.create(self.ourDHKey, self.theirY)
             self.rotateDHKeys()
 
+        # we don't need the AKE anymore, free the reference
+        self.ake = None
+
         self.ctx._wentEncrypted()
         logger.info('went encrypted with {0}'.format(self.theirPubkey))
 
@@ -317,10 +320,6 @@ class CryptEngine(object):
         self.smp = None
 
 class AuthKeyExchange(object):
-    __slots__ = ['privkey', 'state', 'r', 'encgx', 'hashgx', 'ourKeyid',
-            'theirPubkey', 'theirKeyid', 'enc_c', 'enc_cp', 'mac_m1',
-            'mac_m1p', 'mac_m2', 'mac_m2p', 'sessionId', 'dh', 'onSuccess',
-            'gy', 'lastmsg', 'sessionIdHalf']
     def __init__(self, privkey, onSuccess):
         self.privkey = privkey
         self.state = STATE_NONE
@@ -341,9 +340,11 @@ class AuthKeyExchange(object):
         self.dh = DH()
         self.onSuccess = onSuccess
         self.gy = None
+        self.extraKey = None
+        self.lastmsg = None
 
     def startAKE(self):
-        self.r = RNG.read(16)
+        self.r = long_to_bytes(random.getrandbits(128))
 
         gxmpi = pack_mpi(self.dh.pub)
 
@@ -444,15 +445,17 @@ class AuthKeyExchange(object):
         self.state = STATE_NONE
 
     def createAuthKeys(self):
-        s = pow(self.gy, self.dh.priv, DH1536_MODULUS)
+        s = pow(self.gy, self.dh.priv, DH_MODULUS)
         sbyte = pack_mpi(s)
-        self.sessionId = SHA256(b'\0' + sbyte)[:8]
-        enc = SHA256(b'\1' + sbyte)
-        self.enc_c, self.enc_cp = enc[:16], enc[16:]
-        self.mac_m1 = SHA256(b'\2' + sbyte)
-        self.mac_m2 = SHA256(b'\3' + sbyte)
-        self.mac_m1p = SHA256(b'\4' + sbyte)
-        self.mac_m2p = SHA256(b'\5' + sbyte)
+        self.sessionId = SHA256(b'\x00' + sbyte)[:8]
+        enc = SHA256(b'\x01' + sbyte)
+        self.enc_c = enc[:16]
+        self.enc_cp = enc[16:]
+        self.mac_m1 = SHA256(b'\x02' + sbyte)
+        self.mac_m2 = SHA256(b'\x03' + sbyte)
+        self.mac_m1p = SHA256(b'\x04' + sbyte)
+        self.mac_m2p = SHA256(b'\x05' + sbyte)
+        self.extraKey = SHA256(b'\xff' + sbyte)
 
     def calculatePubkeyAuth(self, key, mackey):
         pubkey = self.privkey.serializePublicKey()
@@ -490,14 +493,15 @@ SMPPROG_FAILED = -1
 SMPPROG_SUCCEEDED = 1
 
 class SMPHandler:
-    __slots__ = ['crypto', 'questionReceived', 'prog', 'state', 'g1', 'g3o',
-            'x2', 'x3', 'g2', 'g3', 'pab', 'qab', 'secret', 'p', 'q']
-
     def __init__(self, crypto):
         self.crypto = crypto
         self.state = 1
-        self.g1 = DH1536_GENERATOR
+        self.g1 = DH_GENERATOR
+        self.g2 = None
+        self.g3 = None
         self.g3o = None
+        self.x2 = None
+        self.x3 = None
         self.prog = SMPPROG_OK
         self.pab = None
         self.qab = None
@@ -539,11 +543,11 @@ class SMPHandler:
 
             self.g3o = msg[3]
 
-            self.x2 = bytes_to_long(RNG.read(192))
-            self.x3 = bytes_to_long(RNG.read(192))
+            self.x2 = random.randrange(2, DH_MAX)
+            self.x3 = random.randrange(2, DH_MAX)
 
-            self.g2 = pow(msg[0], self.x2, DH1536_MODULUS)
-            self.g3 = pow(msg[3], self.x3, DH1536_MODULUS)
+            self.g2 = pow(msg[0], self.x2, DH_MODULUS)
+            self.g3 = pow(msg[3], self.x3, DH_MODULUS)
 
             self.prog = SMPPROG_OK
             self.state = 0
@@ -568,29 +572,29 @@ class SMPHandler:
                 return
 
             self.g3o = msg[3]
-            self.g2 = pow(msg[0], self.x2, DH1536_MODULUS)
-            self.g3 = pow(msg[3], self.x3, DH1536_MODULUS)
+            self.g2 = pow(msg[0], self.x2, DH_MODULUS)
+            self.g3 = pow(msg[3], self.x3, DH_MODULUS)
 
             if not self.check_equal_coords(msg[6:11], 5):
                 logger.error('invalid SMP2TLV received')
                 self.abort(appdata=appdata)
                 return
 
-            r = bytes_to_long(RNG.read(192))
-            self.p = pow(self.g3, r, DH1536_MODULUS)
+            r = random.randrange(2, DH_MAX)
+            self.p = pow(self.g3, r, DH_MODULUS)
             msg = [self.p]
-            qa1 = pow(self.g1, r, DH1536_MODULUS)
-            qa2 = pow(self.g2, self.secret, DH1536_MODULUS)
-            self.q = qa1*qa2 % DH1536_MODULUS
+            qa1 = pow(self.g1, r, DH_MODULUS)
+            qa2 = pow(self.g2, self.secret, DH_MODULUS)
+            self.q = qa1*qa2 % DH_MODULUS
             msg.append(self.q)
             msg += self.proof_equal_coords(r, 6)
 
             inv = invMod(mp)
-            self.pab = self.p * inv % DH1536_MODULUS
+            self.pab = self.p * inv % DH_MODULUS
             inv = invMod(mq)
-            self.qab = self.q * inv % DH1536_MODULUS
+            self.qab = self.q * inv % DH_MODULUS
 
-            msg.append(pow(self.qab, self.x3, DH1536_MODULUS))
+            msg.append(pow(self.qab, self.x3, DH_MODULUS))
             msg += self.proof_equal_logs(7)
 
             self.state = 4
@@ -613,9 +617,9 @@ class SMPHandler:
                 return
 
             inv = invMod(self.p)
-            self.pab = msg[0] * inv % DH1536_MODULUS
+            self.pab = msg[0] * inv % DH_MODULUS
             inv = invMod(self.q)
-            self.qab = msg[1] * inv % DH1536_MODULUS
+            self.qab = msg[1] * inv % DH_MODULUS
 
             if not self.check_equal_logs(msg[5:8], 7):
                 logger.error('invalid SMP3TLV received')
@@ -623,10 +627,10 @@ class SMPHandler:
                 return
 
             md = msg[5]
-            msg = [pow(self.qab, self.x3, DH1536_MODULUS)]
+            msg = [pow(self.qab, self.x3, DH_MODULUS)]
             msg += self.proof_equal_logs(8)
 
-            rab = pow(md, self.x3, DH1536_MODULUS)
+            rab = pow(md, self.x3, DH_MODULUS)
             self.prog = SMPPROG_SUCCEEDED if self.pab == rab else SMPPROG_FAILED
 
             if self.prog != SMPPROG_SUCCEEDED:
@@ -654,7 +658,7 @@ class SMPHandler:
                 self.abort(appdata=appdata)
                 return
 
-            rab = pow(msg[0], self.x3, DH1536_MODULUS)
+            rab = pow(msg[0], self.x3, DH_MODULUS)
 
             self.prog = SMPPROG_SUCCEEDED if self.pab == rab else SMPPROG_FAILED
 
@@ -679,12 +683,12 @@ class SMPHandler:
 
             self.secret = bytes_to_long(combSecret)
 
-            self.x2 = bytes_to_long(RNG.read(192))
-            self.x3 = bytes_to_long(RNG.read(192))
+            self.x2 = random.randrange(2, DH_MAX)
+            self.x3 = random.randrange(2, DH_MAX)
 
-            msg = [pow(self.g1, self.x2, DH1536_MODULUS)]
+            msg = [pow(self.g1, self.x2, DH_MODULUS)]
             msg += proof_known_log(self.g1, self.x2, 1)
-            msg.append(pow(self.g1, self.x3, DH1536_MODULUS))
+            msg.append(pow(self.g1, self.x3, DH_MODULUS))
             msg += proof_known_log(self.g1, self.x3, 2)
 
             self.prog = SMPPROG_OK
@@ -700,19 +704,19 @@ class SMPHandler:
 
             self.secret = bytes_to_long(combSecret)
 
-            msg = [pow(self.g1, self.x2, DH1536_MODULUS)]
+            msg = [pow(self.g1, self.x2, DH_MODULUS)]
             msg += proof_known_log(self.g1, self.x2, 3)
-            msg.append(pow(self.g1, self.x3, DH1536_MODULUS))
+            msg.append(pow(self.g1, self.x3, DH_MODULUS))
             msg += proof_known_log(self.g1, self.x3, 4)
 
-            r = bytes_to_long(RNG.read(192))
+            r = random.randrange(2, DH_MAX)
 
-            self.p = pow(self.g3, r, DH1536_MODULUS)
+            self.p = pow(self.g3, r, DH_MODULUS)
             msg.append(self.p)
 
-            qb1 = pow(self.g1, r, DH1536_MODULUS)
-            qb2 = pow(self.g2, self.secret, DH1536_MODULUS)
-            self.q = qb1 * qb2 % DH1536_MODULUS
+            qb1 = pow(self.g1, r, DH_MODULUS)
+            qb2 = pow(self.g2, self.secret, DH_MODULUS)
+            self.q = qb1 * qb2 % DH_MODULUS
             msg.append(self.q)
 
             msg += self.proof_equal_coords(r, 5)
@@ -721,11 +725,11 @@ class SMPHandler:
             self.sendTLV(proto.SMP2TLV(msg), appdata=appdata)
 
     def proof_equal_coords(self, r, v):
-        r1 = bytes_to_long(RNG.read(192))
-        r2 = bytes_to_long(RNG.read(192))
-        temp2 = pow(self.g1, r1, DH1536_MODULUS) \
-                * pow(self.g2, r2, DH1536_MODULUS) % DH1536_MODULUS
-        temp1 = pow(self.g3, r1, DH1536_MODULUS)
+        r1 = random.randrange(2, DH_MAX)
+        r2 = random.randrange(2, DH_MAX)
+        temp2 = pow(self.g1, r1, DH_MODULUS) \
+                * pow(self.g2, r2, DH_MODULUS) % DH_MODULUS
+        temp1 = pow(self.g3, r1, DH_MODULUS)
 
         cb = SHA256(struct.pack(b'B', v) + pack_mpi(temp1) + pack_mpi(temp2))
         c = bytes_to_long(cb)
@@ -739,21 +743,21 @@ class SMPHandler:
 
     def check_equal_coords(self, coords, v):
         (p, q, c, d1, d2) = coords
-        temp1 = pow(self.g3, d1, DH1536_MODULUS) * pow(p, c, DH1536_MODULUS) \
-                % DH1536_MODULUS
+        temp1 = pow(self.g3, d1, DH_MODULUS) * pow(p, c, DH_MODULUS) \
+                % DH_MODULUS
 
-        temp2 = pow(self.g1, d1, DH1536_MODULUS) \
-                * pow(self.g2, d2, DH1536_MODULUS) \
-                * pow(q, c, DH1536_MODULUS) % DH1536_MODULUS
+        temp2 = pow(self.g1, d1, DH_MODULUS) \
+                * pow(self.g2, d2, DH_MODULUS) \
+                * pow(q, c, DH_MODULUS) % DH_MODULUS
 
         cprime = SHA256(struct.pack(b'B', v) + pack_mpi(temp1) + pack_mpi(temp2))
 
-        return long_to_bytes(c) == cprime
+        return long_to_bytes(c, 32) == cprime
 
     def proof_equal_logs(self, v):
-        r = bytes_to_long(RNG.read(192))
-        temp1 = pow(self.g1, r, DH1536_MODULUS)
-        temp2 = pow(self.qab, r, DH1536_MODULUS)
+        r = random.randrange(2, DH_MAX)
+        temp1 = pow(self.g1, r, DH_MODULUS)
+        temp2 = pow(self.qab, r, DH_MODULUS)
 
         cb = SHA256(struct.pack(b'B', v) + pack_mpi(temp1) + pack_mpi(temp2))
         c = bytes_to_long(cb)
@@ -763,29 +767,29 @@ class SMPHandler:
 
     def check_equal_logs(self, logs, v):
         (r, c, d) = logs
-        temp1 = pow(self.g1, d, DH1536_MODULUS) \
-                * pow(self.g3o, c, DH1536_MODULUS) % DH1536_MODULUS
+        temp1 = pow(self.g1, d, DH_MODULUS) \
+                * pow(self.g3o, c, DH_MODULUS) % DH_MODULUS
 
-        temp2 = pow(self.qab, d, DH1536_MODULUS) \
-                * pow(r, c, DH1536_MODULUS) % DH1536_MODULUS
+        temp2 = pow(self.qab, d, DH_MODULUS) \
+                * pow(r, c, DH_MODULUS) % DH_MODULUS
 
         cprime = SHA256(struct.pack(b'B', v) + pack_mpi(temp1) + pack_mpi(temp2))
-        return long_to_bytes(c) == cprime
+        return long_to_bytes(c, 32) == cprime
 
 def proof_known_log(g, x, v):
-    r = bytes_to_long(RNG.read(192))
-    c = bytes_to_long(SHA256(struct.pack(b'B', v) + pack_mpi(pow(g, r, DH1536_MODULUS))))
+    r = random.randrange(2, DH_MAX)
+    c = bytes_to_long(SHA256(struct.pack(b'B', v) + pack_mpi(pow(g, r, DH_MODULUS))))
     temp = x * c % SM_ORDER
     return c, (r-temp) % SM_ORDER
 
 def check_known_log(c, d, g, x, v):
-    gd = pow(g, d, DH1536_MODULUS)
-    xc = pow(x, c, DH1536_MODULUS)
-    gdxc = gd * xc % DH1536_MODULUS
-    return SHA256(struct.pack(b'B', v) + pack_mpi(gdxc)) == long_to_bytes(c)
+    gd = pow(g, d, DH_MODULUS)
+    xc = pow(x, c, DH_MODULUS)
+    gdxc = gd * xc % DH_MODULUS
+    return SHA256(struct.pack(b'B', v) + pack_mpi(gdxc)) == long_to_bytes(c, 32)
 
 def invMod(n):
-    return pow(n, DH1536_MODULUS_2, DH1536_MODULUS)
+    return pow(n, DH_MODULUS_2, DH_MODULUS)
 
 class InvalidParameterError(RuntimeError):
     pass

gotr/potr/proto.py

@@ -19,14 +19,16 @@
 from __future__ import unicode_literals
 
 import base64
-import logging
 import struct
 from potr.utils import pack_mpi, read_mpi, pack_data, read_data, unpack
 
 OTRTAG = b'?OTR'
 MESSAGE_TAG_BASE = b' \t  \t\t\t\t \t \t \t  '
-MESSAGE_TAG_V1 = b' \t \t  \t '
-MESSAGE_TAG_V2 = b'  \t\t  \t '
+MESSAGE_TAGS = {
+        1:b' \t \t  \t ',
+        2:b'  \t\t  \t ',
+        3:b'  \t\t  \t\t',
+    }
 
 MSGTYPE_NOTOTR = 0
 MSGTYPE_TAGGEDPLAINTEXT = 1
@@ -62,6 +64,8 @@ def registermessage(cls):
 def registertlv(cls):
     if not hasattr(cls, 'parsePayload'):
         raise TypeError('registered tlv types need parsePayload()')
+    if cls.typ is None:
+        raise TypeError('registered tlv type needs type ID')
     tlvClasses[cls.typ] = cls
     return cls
 
@@ -84,16 +88,6 @@ class OTRMessage(object):
     __slots__ = ['payload']
     version = 0x0002
     msgtype = 0
-    def __init__(self, payload):
-        self.payload = payload
-
-    def getPayload(self):
-        return self.payload
-
-    def __bytes__(self):
-        data = struct.pack(b'!HB', self.version, self.msgtype) \
-                + self.getPayload()
-        return b'?OTR:' + base64.b64encode(data) + b'.'
 
     def __eq__(self, other):
         if not isinstance(other, self.__class__):
@@ -110,6 +104,7 @@ class OTRMessage(object):
 class Error(OTRMessage):
     __slots__ = ['error']
     def __init__(self, error):
+        super(Error, self).__init__()
         self.error = error
 
     def __repr__(self):
@@ -119,56 +114,58 @@ class Error(OTRMessage):
         return b'?OTR Error:' + self.error
 
 class Query(OTRMessage):
-    __slots__ = ['v1', 'v2']
-    def __init__(self, v1, v2):
-        self.v1 = v1
-        self.v2 = v2
+    __slots__ = ['versions']
+    def __init__(self, versions=set()):
+        super(Query, self).__init__()
+        self.versions = versions
 
     @classmethod
     def parse(cls, data):
-        v2 = False
-        v1 = False
-        if len(data) > 0 and data[0:1] == b'?':
-            data = data[1:]
-            v1 = True
-
-        if len(data) > 0 and data[0:1] == b'v':
-            for c in data[1:]:
-                if c == b'2'[0]:
-                    v2 = True
-        return cls(v1, v2)
+        if not isinstance(data, bytes):
+            raise TypeError('can only parse bytes')
+        udata = data.decode('ascii', errors='replace')
+
+        versions = set()
+        if len(udata) > 0 and udata[0] == '?':
+            udata = udata[1:]
+            versions.add(1)
+
+        if len(udata) > 0 and udata[0] == 'v':
+            versions.update(( int(c) for c in udata if c.isdigit() ))
+        return cls(versions)
 
     def __repr__(self):
-        return '<proto.Query(v1=%r,v2=%r)>'%(self.v1,self.v2)
+        return '<proto.Query(versions=%r)>' % (self.versions)
 
     def __bytes__(self):
         d = b'?OTR'
-        if self.v1:
+        if 1 in self.versions:
             d += b'?'
         d += b'v'
-        if self.v2:
-            d += b'2'
+
+        # in python3 there is only int->unicode conversion
+        # so I convert to unicode and encode it to a byte string
+        versions = [ '%d' % v for v in self.versions if v != 1 ]
+        d += ''.join(versions).encode('ascii')
+
         d += b'?'
         return d
 
 class TaggedPlaintext(Query):
     __slots__ = ['msg']
-    def __init__(self, msg, v1, v2):
+    def __init__(self, msg, versions):
+        super(TaggedPlaintext, self).__init__(versions)
         self.msg = msg
-        self.v1 = v1
-        self.v2 = v2
 
     def __bytes__(self):
         data = self.msg + MESSAGE_TAG_BASE
-        if self.v1:
-            data += MESSAGE_TAG_V1
-        if self.v2:
-            data += MESSAGE_TAG_V2
+        for v in self.versions:
+            data += MESSAGE_TAGS[v]
         return data
 
     def __repr__(self):
-        return '<proto.TaggedPlaintext(v1={v1!r},v2={v2!r},msg={msg!r})>' \
-                .format(v1=self.v1, v2=self.v2, msg=self.msg)
+        return '<proto.TaggedPlaintext(versions={versions!r},msg={msg!r})>' \
+                .format(versions=self.versions, msg=self.msg)
 
     @classmethod
     def parse(cls, data):
@@ -177,21 +174,18 @@ class TaggedPlaintext(Query):
             raise TypeError(
                     'this is not a tagged plaintext ({0!r:.20})'.format(data))
 
-        v1 = False
-        v2 = False
-
         tags = [ data[i:i+8] for i in range(tagPos, len(data), 8) ]
-        for tag in tags:
-            if not tag.isspace():
-                break
-            v1 |= tag == MESSAGE_TAG_V1
-            v2 |= tag == MESSAGE_TAG_V2
+        versions = set([ version for version, tag in MESSAGE_TAGS.items() if tag
+            in tags ])
 
-        return TaggedPlaintext(data[:tagPos], v1, v2)
+        return TaggedPlaintext(data[:tagPos], versions)
 
 class GenericOTRMessage(OTRMessage):
     __slots__ = ['data']
+    fields  = []
+
     def __init__(self, *args):
+        super(GenericOTRMessage, self).__init__()
         if len(args) != len(self.fields):
             raise TypeError('%s needs %d arguments, got %d' %
                     (self.__class__.__name__, len(self.fields), len(args)))
@@ -213,6 +207,11 @@ class GenericOTRMessage(OTRMessage):
             self.__getattr__(attr) # existence check
             self.data[attr] = val
 
+    def __bytes__(self):
+        data = struct.pack(b'!HB', self.version, self.msgtype) \
+                + self.getPayload()
+        return b'?OTR:' + base64.b64encode(data) + b'.'
+
     def __repr__(self):
         name = self.__class__.__name__
         data = ''
@@ -224,11 +223,10 @@ class GenericOTRMessage(OTRMessage):
     def parsePayload(cls, data):
         data = base64.b64decode(data)
         args = []
-        for k, ftype in cls.fields:
+        for _, ftype in cls.fields:
             if ftype == 'data':
                 value, data = read_data(data)
             elif isinstance(ftype, bytes):
-                size = int(struct.calcsize(ftype))
                 value, data = unpack(ftype, data)
             elif isinstance(ftype, int):
                 value, data = data[:ftype], data[ftype:]
@@ -251,26 +249,24 @@ class GenericOTRMessage(OTRMessage):
 
 class AKEMessage(GenericOTRMessage):
     __slots__ = []
-    pass
 
 @registermessage
 class DHCommit(AKEMessage):
     __slots__ = []
     msgtype = 0x02
-    fields = [('encgx','data'), ('hashgx','data'), ]
-
+    fields = [('encgx', 'data'), ('hashgx', 'data'), ]
 
 @registermessage
 class DHKey(AKEMessage):
     __slots__ = []
     msgtype = 0x0a
-    fields = [('gy','data'), ]
+    fields = [('gy', 'data'), ]
 
 @registermessage
 class RevealSig(AKEMessage):
     __slots__ = []
     msgtype = 0x11
-    fields = [('rkey','data'), ('encsig','data'), ('mac',20),]
+    fields = [('rkey', 'data'), ('encsig', 'data'), ('mac', 20),]
 
     def getMacedData(self):
         p = self.encsig
@@ -280,7 +276,7 @@ class RevealSig(AKEMessage):
 class Signature(AKEMessage):
     __slots__ = []
     msgtype = 0x12
-    fields = [('encsig','data'), ('mac',20)]
+    fields = [('encsig', 'data'), ('mac', 20)]
 
     def getMacedData(self):
         p = self.encsig
@@ -290,8 +286,9 @@ class Signature(AKEMessage):
 class DataMessage(GenericOTRMessage):
     __slots__ = []
     msgtype = 0x03
-    fields = [('flags',b'!B'), ('skeyid',b'!I'), ('rkeyid',b'!I'), ('dhy','data'),
-            ('ctr',8), ('encmsg','data'), ('mac',20), ('oldmacs','data'), ]
+    fields = [('flags', b'!B'), ('skeyid', b'!I'), ('rkeyid', b'!I'),
+            ('dhy', 'data'), ('ctr', 8), ('encmsg', 'data'), ('mac', 20),
+            ('oldmacs', 'data'), ]
 
     def getMacedData(self):
         return struct.pack(b'!HB', self.version, self.msgtype) + \
@@ -300,6 +297,10 @@ class DataMessage(GenericOTRMessage):
 @bytesAndStrings
 class TLV(object):
     __slots__ = []
+    typ = None
+
+    def getPayload(self):
+        raise NotImplementedError
 
     def __repr__(self):
         val = self.getPayload()
@@ -330,11 +331,28 @@ class TLV(object):
     def __neq__(self, other):
         return not self.__eq__(other)
 
+@registertlv
+class PaddingTLV(TLV):
+    typ = 0
+
+    __slots__ = ['padding']
+
+    def __init__(self, padding):
+        super(PaddingTLV, self).__init__()
+        self.padding = padding
+
+    def getPayload(self):
+        return self.padding
+
+    @classmethod
+    def parsePayload(cls, data):
+        return cls(data)
+
 @registertlv
 class DisconnectTLV(TLV):
     typ = 1
     def __init__(self):
-        pass
+        super(DisconnectTLV, self).__init__()
 
     def getPayload(self):
         return b''
@@ -348,8 +366,14 @@ class DisconnectTLV(TLV):
 
 class SMPTLV(TLV):
     __slots__ = ['mpis']
-
-    def __init__(self, mpis=[]):
+    dlen = None
+
+    def __init__(self, mpis=None):
+        super(SMPTLV, self).__init__()
+        if mpis is None:
+            mpis = []
+        if self.dlen is None:
+            raise TypeError('no amount of mpis specified in dlen')
         if len(mpis) != self.dlen:
             raise TypeError('expected {0} mpis, got {1}'
                     .format(self.dlen, len(mpis)))
@@ -366,7 +390,7 @@ class SMPTLV(TLV):
         mpis = []
         if cls.dlen > 0:
             count, data = unpack(b'!I', data)
-            for i in range(count):
+            for _ in range(count):
                 n, data = read_mpi(data)
                 mpis.append(n)
         if len(data) > 0:
@@ -419,3 +443,23 @@ class SMPABORTTLV(SMPTLV):
 
     def getPayload(self):
         return b''
+
+@registertlv
+class ExtraKeyTLV(TLV):
+    typ = 8
+
+    __slots__ = ['appid', 'appdata']
+
+    def __init__(self, appid, appdata):
+        super(ExtraKeyTLV, self).__init__()
+        self.appid = appid
+        self.appdata = appdata
+        if appdata is None:
+            self.appdata = b''
+
+    def getPayload(self):
+        return self.appid + self.appdata
+
+    @classmethod
+    def parsePayload(cls, data):
+        return cls(data[:4], data[4:])

gotr/potr/utils.py

@@ -43,11 +43,12 @@ def bytes_to_long(b):
         s += byte_to_long(b[i:i+1]) << 8*(l-i-1)
     return s
 
-def long_to_bytes(l):
+def long_to_bytes(l, n=0):
     b = b''
-    while l != 0:
+    while l != 0 or n > 0:
         b = long_to_byte(l & 0xff) + b
         l >>= 8
+        n -= 1
     return b
 
 def byte_to_long(b):

gui_for_me/__init__.py

+from gui_for_me import GuiForMe

gui_for_me/gui_for_me.py

+# -*- coding: utf-8 -*-
+
+import gtk
+
+from common import gajim
+from plugins import GajimPlugin
+from plugins.helpers import log_calls
+
+
+class GuiForMe(GajimPlugin):
+
+    @log_calls('GuiForMePlugin')
+    def init(self):
+        self.config_dialog = None  # GuiForMePluginConfigDialog(self)
+        self.gui_extension_points = {
+            'chat_control_base': (self.connect_with_chat_control,
+                                  self.disconnect_from_chat_control),
+            'chat_control_base_update_toolbar': (self.update_button_state,
+                                                None)}
+        self.controls = []
+
+    @log_calls('GuiForMePlugin')
+    def connect_with_chat_control(self, chat_control):
+        if chat_control.widget_name != 'groupchat_control':
+            return
+
+        self.chat_control = chat_control
+        control = Base(self, self.chat_control)
+        self.controls.append(control)
+
+
+    @log_calls('GuiForMePlugin')
+    def disconnect_from_chat_control(self, chat_control):
+        for control in self.controls:
+            control.disconnect_from_chat_control()
+        self.controls = []
+
+    @log_calls('GuiForMePlugin')
+    def update_button_state(self, chat_control):
+        for base in self.controls:
+            if base.chat_control != chat_control:
+                continue
+            base.button.set_sensitive(chat_control.contact.show != 'offline' \
+            and gajim.connections[chat_control.account].connected > 0)
+
+
+class Base(object):
+    def __init__(self, plugin, chat_control):
+        self.chat_control = chat_control
+        self.plugin = plugin
+        self.textview = self.chat_control.conv_textview
+        self.change_cursor = False
+
+        self.create_buttons()
+
+    def create_buttons(self):
+        # create /me button
+        actions_hbox = self.chat_control.xml.get_object('actions_hbox')
+        self.button = gtk.Button(label=None, stock=None, use_underline=True)
+        self.button.set_property('relief', gtk.RELIEF_NONE)
+        self.button.set_property('can-focus', False)
+        img = gtk.Image()
+        img_path = self.plugin.local_file_path('gui_for_me.png')
+        pixbuf = gtk.gdk.pixbuf_new_from_file(img_path)
+        iconset = gtk.IconSet(pixbuf=pixbuf)
+        factory = gtk.IconFactory()
+        factory.add('gui_for_me', iconset)
+        factory.add_default()
+        img.set_from_stock('gui_for_me', gtk.ICON_SIZE_MENU)
+        self.button.set_image(img)
+        self.button.set_tooltip_text(_('Insert /me to conversation input box,'
+            ' at cursor position'))
+        send_button = self.chat_control.xml.get_object('send_button')
+        send_button_pos = actions_hbox.child_get_property(send_button,
+            'position')
+        actions_hbox.add_with_properties(self.button, 'position',
+            send_button_pos - 1, 'expand', False)
+        id_ = self.button.connect('clicked', self.on_me_button_clicked)
+        self.chat_control.handlers[id_] = self.button
+        self.button.show()
+
+    def on_me_button_clicked(self, widget):
+        """
+        Insert /me to conversation input box, at cursor position
+        """
+        message_buffer = self.chat_control.msg_textview.get_buffer()
+        message_buffer.insert_at_cursor('/me ')
+        self.chat_control.msg_textview.grab_focus()
+
+    def disconnect_from_chat_control(self):
+        actions_hbox = self.chat_control.xml.get_object('actions_hbox')
+        actions_hbox.remove(self.button)

gui_for_me/manifest.ini

+[info]
+name: GUI For Me
+short_name: gui_for_me
+version: 0.2
+description: Gui for the '/me' command.
+authors: BomberMan
+ copper
+ Denis Fomin <fominde@gmail.com>
+homepage: http://trac-plugins.gajim.org/wiki/GUIForMePlugin
+max_gajim_version: 0.16.9

hamster/hamster.py

@@ -3,10 +3,11 @@
 import dbus
 import datetime as dt
 import gobject
+import os
+
 from common import gajim
 from common import ged
 from common import dbus_support
-
 from plugins import GajimPlugin
 from plugins.helpers import log_calls, log
 from common.pep import ACTIVITIES
@@ -24,11 +25,11 @@ class HamsterIntegrationPlugin(GajimPlugin):
 
     @log_calls('HamsterIntegrationPlugin')
     def init(self):
-        self.description = _('Integration with project hamster\n'
-        'see https://trac.gajim.org/ticket/6993\n'
-        'and http://projecthamster.wordpress.com/about/')
         self.config_dialog = None
         self.events_handlers = {}
+        if os.name == 'nt':
+            self.available_text = _('Plugin can\'t be run under Windows.')
+            self.activatable = False
 
     @log_calls('HamsterIntegrationPlugin')
     def activate(self):

hamster/manifest.ini

 [info]
 name: Hamster integration
 short_name: hamster_integration
-version: 0.1.1
-description: Integration with project hamster
- see https://trac.gajim.org/ticket/6993
- and http://projecthamster.wordpress.com/about/
+version: 0.1.3
+description: Integration with project hamster<br/>
+ see see <a href="https://trac.gajim.org/ticket/6993">ticket #6993</a>
+ and <a href="http://projecthamster.wordpress.com/about/">hamster project</a>
 authors: Denis Fomin <fominde@gmail.com>
 homepage: http://trac-plugins.gajim.org/wiki/
+max_gajim_version: 0.16.9

httpupload/__init__.py

+# simple redirect
+from httpupload import HttpuploadPlugin

httpupload/manifest.ini

+[info]
+name: HttpUpload
+short_name: httpupload
+version: 0.4.0
+description: This plugin is designed to send a file to a contact or muc by using httpupload.<br/>
+ Your server must support <a href="http://xmpp.org/extensions/xep-0363.html">XEP-0363: HTTP Upload</a>.<br/>
+ Conversations supported this.<br/>
+ If the receiving side supports <a href="http://xmpp.org/extensions/xep-0071.html">XEP-0071: XHTML-IM</a>
+ and maintains the scheme data: URI, a thumbnail image is send along the link to the full size image.
+ If the receiving side doesn't support this, only a text message containing the link to the image is send.
+authors: Thilo Molitor <thilo@eightysoft.de>
+ Anders Sandblad <runeson@gmail.com>
+ Philipp Hörist <philipp@hoerist.com>
+homepage: https://trac-plugins.gajim.org/wiki/HttpUploadPlugin
+min_gajim_version: 0.16.5
+max_gajim_version: 0.16.9

image/image.py

@@ -16,11 +16,6 @@ NS_XHTML_IM = 'http://jabber.org/protocol/xhtml-im'             # XEP-0071
 class ImagePlugin(GajimPlugin):
     @log_calls('ImagePlugin')
     def init(self):
-        self.description = _('This plugin is designed to send '
-            'a small(0 - 40 kb) graphic image to your contact.\n'
-            'Client on the other side must support XEP-0071: XHTML-IM'
-            ' and maintain the scheme data: URI.\n'
-            'Psi+ and Jabbim supported this.')
         self.config_dialog = None  # ImagePluginConfigDialog(self)
         self.controls = []
         self.gui_extension_points = {
@@ -136,8 +131,8 @@ class Base(object):
             msg = 'HTML image'
             extension = os.path.splitext(os.path.split(path_to_file)[1])[1] \
                 .lower()[1:]
-            xhtml = ' <img alt="img" src="data:image/%s;base64,%s"/>' % (
-                extension, img)
+            xhtml = '<body><br/> <img alt="img" src="data:image/%s;base64,%s"/> \
+                    </body>' % (extension, img)
             self.chat_control.send_message(message=msg, xhtml=xhtml)
             self.chat_control.msg_textview.grab_focus()
 

image/manifest.ini

 [info]
 name: Image
 short_name: image
-version: 0.5
-description: This plugin is designed to send a small(0 - 40 kb) graphic image to your contact.
- Client on the other side must support XEP-0071: XHTML-IM and maintain the scheme data: URI.
+version: 0.5.1
+description: This plugin is designed to send a small(0 - 40 kb) graphic image to your contact.<br/>
+ Client on the other side must support <a href="http://xmpp.org/extensions/xep-0071.html">XEP-0071: XHTML-IM</a> and maintain the scheme data: URI.<br/>
  Psi+ and Jabbim supported this.
 authors: Denis Fomin <fominde@gmail.com>
 homepage: http://trac-plugins.gajim.org/wiki/ImagePlugin
+max_gajim_version: 0.16.9