Support Python 3

Author: elliptic-shiho

.gitignore

@@ -1,3 +1,4 @@
 *.pyc
 **/__pycache__/*
 **egg-info*
+**/build/

scryptos/crypto/Ciphertext.py

@@ -1,99 +1,129 @@
 class Ciphertext(object):
-  def __init__(s, parent, v):
-    s.parent = parent
-    s.v = v
-    s.is_homomorphic = hasattr(s.parent, '_homomorphic_type')
-    if s.is_homomorphic:
-      s.homomorphic_type = s.parent._homomorphic_type()
+    def __init__(s, parent, v):
+        s.parent = parent
+        s.v = v
+        s.is_homomorphic = hasattr(s.parent, "_homomorphic_type")
+        if s.is_homomorphic:
+            s.homomorphic_type = s.parent._homomorphic_type()
 
-  def __add__(s, rhs):
-    assert s.is_homomorphic, 'The cryptosystem/cipher does not support homomorphic encryption'
-    assert '+' in s.homomorphic_type, 'Parents does not support addition'
-    if isinstance(rhs, Ciphertext):
-      assert rhs.parent == s.parent, 'Invalid Parents: %s != %s' % (rhs.parent, s.parent)
-      return Ciphertext(s.parent, s.parent.hom('+', s.v, rhs.v))
-    else:
-      return s + s.parent.encrypt(rhs)
+    def __add__(s, rhs):
+        assert (
+            s.is_homomorphic
+        ), "The cryptosystem/cipher does not support homomorphic encryption"
+        assert "+" in s.homomorphic_type, "Parents does not support addition"
+        if isinstance(rhs, Ciphertext):
+            assert rhs.parent == s.parent, "Invalid Parents: %s != %s" % (
+                rhs.parent,
+                s.parent,
+            )
+            return Ciphertext(s.parent, s.parent.hom("+", s.v, rhs.v))
+        else:
+            return s + s.parent.encrypt(rhs)
 
-  def __mul__(s, rhs):
-    assert s.is_homomorphic, 'The cryptosystem/cipher does not support homomorphic encryption'
-    if isinstance(rhs, Ciphertext):
-      assert '*' in s.homomorphic_type, 'Parents does not support multiplication'
-      assert rhs.parent == s.parent, 'Invalid Parents: %s != %s' % (rhs.parent, s.parent)
-      return Ciphertext(s.parent, s.parent.hom('*', s.v, rhs.v))
-    else:
-      if '*' in s.homomorphic_type:
-        return s * s.parent.encrypt(rhs)
-      elif '+' in s.homomorphic_type:
-        bin_repr = map(int, format(rhs, 'b'))
-        t = s.parent.encrypt(0)
-        for x in bin_repr:
-          if x:
-            t += s
-          t += t
-        return t
-      else:
-        raise TypeError('Parents does not support multiplication')
+    def __mul__(s, rhs):
+        assert (
+            s.is_homomorphic
+        ), "The cryptosystem/cipher does not support homomorphic encryption"
+        if isinstance(rhs, Ciphertext):
+            assert "*" in s.homomorphic_type, "Parents does not support multiplication"
+            assert rhs.parent == s.parent, "Invalid Parents: %s != %s" % (
+                rhs.parent,
+                s.parent,
+            )
+            return Ciphertext(s.parent, s.parent.hom("*", s.v, rhs.v))
+        else:
+            if "*" in s.homomorphic_type:
+                return s * s.parent.encrypt(rhs)
+            elif "+" in s.homomorphic_type:
+                bin_repr = map(int, format(rhs, "b"))
+                t = s.parent.encrypt(0)
+                for x in bin_repr:
+                    if x:
+                        t += s
+                    t += t
+                return t
+            else:
+                raise TypeError("Parents does not support multiplication")
 
-  def __sub__(s, rhs):
-    assert s.is_homomorphic, 'The cryptosystem/cipher does not support homomorphic encryption'
-    if isinstance(rhs, Ciphertext):
-      assert rhs.parent == s.parent, 'Invalid Parents: %s != %s' % (rhs.parent, s.parent)
-      if '-' in s.homomorphic_type:
-        return Ciphertext(s.parent, s.parent.hom('-', s.v, rhs.v))
-      return s + -rhs
-    else:
-      return s - s.parent.encrypt(rhs)
+    def __sub__(s, rhs):
+        assert (
+            s.is_homomorphic
+        ), "The cryptosystem/cipher does not support homomorphic encryption"
+        if isinstance(rhs, Ciphertext):
+            assert rhs.parent == s.parent, "Invalid Parents: %s != %s" % (
+                rhs.parent,
+                s.parent,
+            )
+            if "-" in s.homomorphic_type:
+                return Ciphertext(s.parent, s.parent.hom("-", s.v, rhs.v))
+            return s + -rhs
+        else:
+            return s - s.parent.encrypt(rhs)
 
-  def __div__(s, rhs):
-    assert s.is_homomorphic, 'The cryptosystem/cipher does not support homomorphic encryption'
-    assert '/' in s.homomorphic_type, 'Parents does not support division'
-    if isinstance(rhs, Ciphertext):
-      assert rhs.parent == s.parent, 'Invalid Parents: %s != %s' % (rhs.parent, s.parent)
-      return Ciphertext(s.parent, s.parent.hom('/', s.v, rhs.v))
-    else:
-      return s / s.parent.encrypt(rhs)
+    def __div__(s, rhs):
+        assert (
+            s.is_homomorphic
+        ), "The cryptosystem/cipher does not support homomorphic encryption"
+        assert "/" in s.homomorphic_type, "Parents does not support division"
+        if isinstance(rhs, Ciphertext):
+            assert rhs.parent == s.parent, "Invalid Parents: %s != %s" % (
+                rhs.parent,
+                s.parent,
+            )
+            return Ciphertext(s.parent, s.parent.hom("/", s.v, rhs.v))
+        else:
+            return s / s.parent.encrypt(rhs)
 
-  def __neg__(s):
-    assert s.is_homomorphic, 'The cryptosystem/cipher does not support homomorphic encryption'
-    if '*' in s.homomorphic_type:
-      return s * s.parent.encrypt(-1)
-    elif '-' in s.homomorphic_type:
-      return s.parent.encrypt(0) - s
-    else:
-      raise TypeError('Parents does not support negation')
+    def __neg__(s):
+        assert (
+            s.is_homomorphic
+        ), "The cryptosystem/cipher does not support homomorphic encryption"
+        if "*" in s.homomorphic_type:
+            return s * s.parent.encrypt(-1)
+        elif "-" in s.homomorphic_type:
+            return s.parent.encrypt(0) - s
+        else:
+            raise TypeError("Parents does not support negation")
 
-  def __radd__(s, lhs):
-    assert s.is_homomorphic, 'The cryptosystem/cipher does not support homomorphic encryption'
-    assert '+' in s.homomorphic_type, 'Parents does not support addition'
-    return s.parent.encrypt(lhs) + s
+    def __radd__(s, lhs):
+        assert (
+            s.is_homomorphic
+        ), "The cryptosystem/cipher does not support homomorphic encryption"
+        assert "+" in s.homomorphic_type, "Parents does not support addition"
+        return s.parent.encrypt(lhs) + s
 
-  def __rmul__(s, lhs):
-    assert s.is_homomorphic, 'The cryptosystem/cipher does not support homomorphic encryption'
-    if '*' in s.homomorphic_type:
-      return s.parent.encrypt(lhs) * s
-    elif '+' in s.homomorphic_type:
-      return s * lhs
-    else:
-      raise TypeError('Parents does not support multiplication')
+    def __rmul__(s, lhs):
+        assert (
+            s.is_homomorphic
+        ), "The cryptosystem/cipher does not support homomorphic encryption"
+        if "*" in s.homomorphic_type:
+            return s.parent.encrypt(lhs) * s
+        elif "+" in s.homomorphic_type:
+            return s * lhs
+        else:
+            raise TypeError("Parents does not support multiplication")
 
-  def __rsub__(s, lhs):
-    assert s.is_homomorphic, 'The cryptosystem/cipher does not support homomorphic encryption'
-    assert '-' in s.homomorphic_type, 'Parents does not support subtract'
-    return s.parent.encrypt(lhs) - s
+    def __rsub__(s, lhs):
+        assert (
+            s.is_homomorphic
+        ), "The cryptosystem/cipher does not support homomorphic encryption"
+        assert "-" in s.homomorphic_type, "Parents does not support subtract"
+        return s.parent.encrypt(lhs) - s
 
-  def __rdiv__(s, lhs):
-    assert s.is_homomorphic, 'The cryptosystem/cipher does not support homomorphic encryption'
-    assert '/' in s.homomorphic_type, 'Parents does not support division'
-    return s.parent.encrypt(lhs) / s
+    def __rdiv__(s, lhs):
+        assert (
+            s.is_homomorphic
+        ), "The cryptosystem/cipher does not support homomorphic encryption"
+        assert "/" in s.homomorphic_type, "Parents does not support division"
+        return s.parent.encrypt(lhs) / s
 
-  def __eq__(s, rhs):
-    if isinstance(rhs, Ciphertext):
-      return s.v == rhs.v
-    return s.v == rhs
+    def __eq__(s, rhs):
+        if isinstance(rhs, Ciphertext):
+            return s.v == rhs.v
+        return s.v == rhs
 
-  def __str__(s):
-    return 'Ciphertext of %s: %s' % (s.parent, s.v)
+    def __str__(s):
+        return "Ciphertext of %s: %s" % (s.parent, s.v)
 
-  def __repr__(s):
-    return '%s(%r, %r)' % (s.__class__.__name__, s.parent, s.v)
+    def __repr__(s):
+        return "%s(%r, %r)" % (s.__class__.__name__, s.parent, s.v)

scryptos/crypto/RC4.py

@@ -1,65 +1,67 @@
 from scryptos.math.num import *
 from .Ciphertext import Ciphertext
 
+
 class RC4(object):
-  """
-  RSA Public/Private Key Class
-  """
-  def __init__(s, key):
     """
-    Constructor of RC4
-    Args: 
-      key : RC4 Key
+    RSA Public/Private Key Class
     """
-    s.key = key
 
-  def init_ksa(s):
-    import math
-    s.table = list(range(256))
-    j = 0
-    key = s.key * int(math.ceil(256./len(s.key)))
-    for i in range(256):
-      j = (j + s.table[i] + ord(key[i])) % 256
-      s.table[i], s.table[j] = s.table[j], s.table[i]
+    def __init__(s, key):
+        """
+        Constructor of RC4
+        Args:
+          key : RC4 Key
+        """
+        s.key = key
 
-  def prga(s, length):
-    s.init_ksa()
-    i, j = 0, 0
-    rand = ""
-    for _ in range(length):
-      i = (i + 1) % 256
-      j = (j + s.table[i]) % 256
-      s.table[i], s.table[j] = s.table[j], s.table[i]
-      rand += chr(s.table[(s.table[i] + s.table[j]) % 256])
-    return rand
+    def init_ksa(s):
+        import math
 
+        s.table = list(range(256))
+        j = 0
+        key = s.key * int(math.ceil(256.0 / len(s.key)))
+        for i in range(256):
+            j = (j + s.table[i] + ord(key[i])) % 256
+            s.table[i], s.table[j] = s.table[j], s.table[i]
 
-  def encrypt(s, m, raw=False):
-    """
-    RC4 Encryption
-    Args:
-      m   : Plaintext Message (must be string object)
-      raw : Is result wrapped by Ciphertext object?
-    Return: RC4 Ciphertext object or Encrypted String (c_i = m_i XOR PRGA())
-    """
-    c = "".join([chr(ord(x) ^ ord(y)) for x, y in zip(m, s.prga(len(m)))])
-    if raw:
-      return c
-    return Ciphertext(s, c)
+    def prga(s, length):
+        s.init_ksa()
+        i, j = 0, 0
+        rand = ""
+        for _ in range(length):
+            i = (i + 1) % 256
+            j = (j + s.table[i]) % 256
+            s.table[i], s.table[j] = s.table[j], s.table[i]
+            rand += chr(s.table[(s.table[i] + s.table[j]) % 256])
+        return rand
 
-  def decrypt(s, c):
-    """
-    RC4 Decryption
-    Args:
-      c : Ciphertext (must be string object or Ciphertext object)
-    Return: RC4 Decrypted String (same as `encrypt`)
-    """
-    if isinstance(c, Ciphertext):
-      c = c.v
-    return s.encrypt(c, True)
+    def encrypt(s, m, raw=False):
+        """
+        RC4 Encryption
+        Args:
+          m   : Plaintext Message (must be string object)
+          raw : Is result wrapped by Ciphertext object?
+        Return: RC4 Ciphertext object or Encrypted String (c_i = m_i XOR PRGA())
+        """
+        c = "".join([chr(ord(x) ^ ord(y)) for x, y in zip(m, s.prga(len(m)))])
+        if raw:
+            return c
+        return Ciphertext(s, c)
+
+    def decrypt(s, c):
+        """
+        RC4 Decryption
+        Args:
+          c : Ciphertext (must be string object or Ciphertext object)
+        Return: RC4 Decrypted String (same as `encrypt`)
+        """
+        if isinstance(c, Ciphertext):
+            c = c.v
+        return s.encrypt(c, True)
 
-  def __str__(s):
-    return "RC4 Instance: key = %r" % s.key
+    def __str__(s):
+        return "RC4 Instance: key = %r" % s.key
 
-  def __repr__(s):
-    return "RC4(%r)" % s.key
+    def __repr__(s):
+        return "RC4(%r)" % s.key