Merge branch 'py3'

Author: warner

.gitignore

@@ -1,8 +1,48 @@
-/.coverage
-/coverage-html/
-/t/
-/build/
-/ecdsa/_version.py
-/MANIFEST
-/dist/
-*.pyc
+*.py[cod]
+ecdsa/_version.py
+MANIFEST
+
+# C extensions
+*.so
+*.dylib
+
+# Packages
+*.egg
+*.egg-info
+dist
+build
+eggs
+parts
+bin
+var
+sdist
+develop-eggs
+.installed.cfg
+lib
+lib64
+__pycache__
+
+# Installer logs
+pip-log.txt
+
+# Other logs
+*.log
+
+# Unit test / coverage reports
+.coverage
+coverage-html
+.tox
+nosetests.xml
+t/
+
+# Translations
+*.mo
+
+# Mr Developer
+.mr.developer.cfg
+.project
+.pydevproject
+
+# Backup files
+*.swp
+*~

.travis.yml

@@ -3,6 +3,8 @@ python:
   - "2.5"
   - "2.6"
   - "2.7"
+  - "3.2"
+  - "3.3"
 install: true
 script:
   - python setup.py test

ecdsa/__init__.py

@@ -1,6 +1,7 @@
-
-from keys import SigningKey, VerifyingKey, BadSignatureError, BadDigestError
-from curves import NIST192p, NIST224p, NIST256p, NIST384p, NIST521p
+__all__ = ["curves", "der", "ecdsa", "ellipticcurve", "keys", "numbertheory",
+           "test_pyecdsa", "util", "six"]
+from .keys import SigningKey, VerifyingKey, BadSignatureError, BadDigestError
+from .curves import NIST192p, NIST224p, NIST256p, NIST384p, NIST521p
 
 _hush_pyflakes = [SigningKey, VerifyingKey, BadSignatureError, BadDigestError,
                   NIST192p, NIST224p, NIST256p, NIST384p, NIST521p]

ecdsa/curves.py

@@ -1,4 +1,6 @@
-import der, ecdsa
+from __future__ import division
+
+from . import der, ecdsa
 
 class UnknownCurveError(Exception):
     pass

ecdsa/der.py

@@ -1,39 +1,43 @@
+from __future__ import division
+
 import binascii
 import base64
+from .six import int2byte, b, PY3, integer_types, text_type
 
 class UnexpectedDER(Exception):
     pass
 
 def encode_constructed(tag, value):
-    return chr(0xa0+tag) + encode_length(len(value)) + value
+    return int2byte(0xa0+tag) + encode_length(len(value)) + value
 def encode_integer(r):
     assert r >= 0 # can't support negative numbers yet
-    h = "%x" % r
-    if len(h)%2:
-        h = "0" + h
+    h = ("%x" % r).encode()
+    if len(h) % 2:
+        h = b("0") + h
     s = binascii.unhexlify(h)
-    if ord(s[0]) <= 0x7f:
-        return "\x02" + chr(len(s)) + s
+    num = s[0] if isinstance(s[0], integer_types) else ord(s[0])
+    if num <= 0x7f:
+        return b("\x02") + int2byte(len(s)) + s
     else:
         # DER integers are two's complement, so if the first byte is
         # 0x80-0xff then we need an extra 0x00 byte to prevent it from
         # looking negative.
-        return "\x02" + chr(len(s)+1) + "\x00" + s
+        return b("\x02") + int2byte(len(s)+1) + b("\x00") + s
 
 def encode_bitstring(s):
-    return "\x03" + encode_length(len(s)) + s
+    return b("\x03") + encode_length(len(s)) + s
 def encode_octet_string(s):
-    return "\x04" + encode_length(len(s)) + s
+    return b("\x04") + encode_length(len(s)) + s
 def encode_oid(first, second, *pieces):
     assert first <= 2
     assert second <= 39
-    encoded_pieces = [chr(40*first+second)] + [encode_number(p)
-                                               for p in pieces]
-    body = "".join(encoded_pieces)
-    return "\x06" + encode_length(len(body)) + body
+    encoded_pieces = [int2byte(40*first+second)] + [encode_number(p)
+                                                    for p in pieces]
+    body = b('').join(encoded_pieces)
+    return b('\x06') + encode_length(len(body)) + body
 def encode_sequence(*encoded_pieces):
     total_len = sum([len(p) for p in encoded_pieces])
-    return "\x30" + encode_length(total_len) + "".join(encoded_pieces)
+    return b('\x30') + encode_length(total_len) + b('').join(encoded_pieces)
 def encode_number(n):
     b128_digits = []
     while n:
@@ -42,10 +46,10 @@ def encode_number(n):
     if not b128_digits:
         b128_digits.append(0)
     b128_digits[-1] &= 0x7f
-    return "".join([chr(d) for d in b128_digits])
+    return b('').join([int2byte(d) for d in b128_digits])
 
 def remove_constructed(string):
-    s0 = ord(string[0])
+    s0 = string[0] if isinstance(string[0], integer_types) else ord(string[0])
     if (s0 & 0xe0) != 0xa0:
         raise UnexpectedDER("wanted constructed tag (0xa0-0xbf), got 0x%02x"
                             % s0)
@@ -56,26 +60,26 @@ def remove_constructed(string):
     return tag, body, rest
 
 def remove_sequence(string):
-    if not string.startswith("\x30"):
-        raise UnexpectedDER("wanted sequence (0x30), got 0x%02x" %
-                            ord(string[0]))
+    if not string.startswith(b("\x30")):
+        n = string[0] if isinstance(string[0], integer_types) else ord(string[0])
+        raise UnexpectedDER("wanted sequence (0x30), got 0x%02x" % n)
     length, lengthlength = read_length(string[1:])
     endseq = 1+lengthlength+length
     return string[1+lengthlength:endseq], string[endseq:]
 
 def remove_octet_string(string):
-    if not string.startswith("\x04"):
-        raise UnexpectedDER("wanted octetstring (0x04), got 0x%02x" %
-                            ord(string[0]))
+    if not string.startswith(b("\x04")):
+        n = string[0] if isinstance(string[0], integer_types) else ord(string[0])
+        raise UnexpectedDER("wanted octetstring (0x04), got 0x%02x" % n)
     length, llen = read_length(string[1:])
     body = string[1+llen:1+llen+length]
     rest = string[1+llen+length:]
     return body, rest
 
 def remove_object(string):
-    if not string.startswith("\x06"):
-        raise UnexpectedDER("wanted object (0x06), got 0x%02x" %
-                            ord(string[0]))
+    if not string.startswith(b("\x06")):
+        n = string[0] if isinstance(string[0], integer_types) else ord(string[0])
+        raise UnexpectedDER("wanted object (0x06), got 0x%02x" % n)
     length, lengthlength = read_length(string[1:])
     body = string[1+lengthlength:1+lengthlength+length]
     rest = string[1+lengthlength+length:]
@@ -92,13 +96,14 @@ def remove_object(string):
     return tuple(numbers), rest
 
 def remove_integer(string):
-    if not string.startswith("\x02"):
-        raise UnexpectedDER("wanted integer (0x02), got 0x%02x" %
-                            ord(string[0]))
+    if not string.startswith(b("\x02")):
+        n = string[0] if isinstance(string[0], integer_types) else ord(string[0])
+        raise UnexpectedDER("wanted integer (0x02), got 0x%02x" % n)
     length, llen = read_length(string[1:])
     numberbytes = string[1+llen:1+llen+length]
     rest = string[1+llen+length:]
-    assert ord(numberbytes[0]) < 0x80 # can't support negative numbers yet
+    nbytes = numberbytes[0] if isinstance(numberbytes[0], integer_types) else ord(numberbytes[0])
+    assert nbytes < 0x80 # can't support negative numbers yet
     return int(binascii.hexlify(numberbytes), 16), rest
 
 def read_number(string):
@@ -109,7 +114,7 @@ def read_number(string):
         if llen > len(string):
             raise UnexpectedDER("ran out of length bytes")
         number = number << 7
-        d = ord(string[llen])
+        d = string[llen] if isinstance(string[llen], integer_types) else ord(string[llen])
         number += (d & 0x7f)
         llen += 1
         if not d & 0x80:
@@ -119,29 +124,30 @@ def read_number(string):
 def encode_length(l):
     assert l >= 0
     if l < 0x80:
-        return chr(l)
-    s = "%x" % l
+        return int2byte(l)
+    s = ("%x" % l).encode()
     if len(s)%2:
-        s = "0"+s
+        s = b("0")+s
     s = binascii.unhexlify(s)
     llen = len(s)
-    return chr(0x80|llen) + s
+    return int2byte(0x80|llen) + s
 
 def read_length(string):
-    if not (ord(string[0]) & 0x80):
+    num = string[0] if isinstance(string[0], integer_types) else ord(string[0])
+    if not (num & 0x80):
         # short form
-        return (ord(string[0]) & 0x7f), 1
+        return (num & 0x7f), 1
     # else long-form: b0&0x7f is number of additional base256 length bytes,
     # big-endian
-    llen = ord(string[0]) & 0x7f
+    llen = num & 0x7f
     if llen > len(string)-1:
         raise UnexpectedDER("ran out of length bytes")
     return int(binascii.hexlify(string[1:1+llen]), 16), 1+llen
 
 def remove_bitstring(string):
-    if not string.startswith("\x03"):
-        raise UnexpectedDER("wanted bitstring (0x03), got 0x%02x" %
-                            ord(string[0]))
+    num = string[0] if isinstance(string[0], integer_types) else ord(string[0])
+    if not string.startswith(b("\x03")):
+        raise UnexpectedDER("wanted bitstring (0x03), got 0x%02x" % num)
     length, llen = read_length(string[1:])
     body = string[1+llen:1+llen+length]
     rest = string[1+llen+length:]
@@ -177,14 +183,17 @@ def remove_bitstring(string):
 #  iso(1) identified-organization(3) certicom(132) curve(0) 34 }
 
 def unpem(pem):
-    d = "".join([l.strip() for l in pem.split("\n")
-                 if l and not l.startswith("-----")])
+    if isinstance(pem, text_type):
+        pem = pem.encode()
+
+    d = b("").join([l.strip() for l in pem.split(b("\n"))
+                    if l and not l.startswith(b("-----"))])
     return base64.b64decode(d)
 def topem(der, name):
     b64 = base64.b64encode(der)
-    lines = ["-----BEGIN %s-----\n" % name]
-    lines.extend([b64[start:start+64]+"\n"
+    lines = [("-----BEGIN %s-----\n" % name).encode()]
+    lines.extend([b64[start:start+64]+b("\n")
                   for start in range(0, len(b64), 64)])
-    lines.append("-----END %s-----\n" % name)
-    return "".join(lines)
+    lines.append(("-----END %s-----\n" % name).encode())
+    return b("").join(lines)