treplace TLSLite dependency with minimal RSA implementation - electrum - Electrum Bitcoin wallet
(HTM) git clone https://git.parazyd.org/electrum
(DIR) Log
(DIR) Files
(DIR) Refs
(DIR) Submodules
---
(DIR) commit e8d30129eae10b5efeaa9e95a900576e41dd2bf1
(DIR) parent 2ba07377daafa337225b4814656b7a9613fd6540
(HTM) Author: ThomasV <thomasv@gitorious>
Date: Tue, 4 Aug 2015 18:16:06 +0200
replace TLSLite dependency with minimal RSA implementation
Diffstat:
M RELEASE-NOTES | 1 +
M lib/asn1tinydecoder.py | 47 +++++++++++++++++++++++++++++++
M lib/dnssec.py | 16 ++++++++--------
M lib/paymentrequest.py | 29 +++++++++++++++++------------
A lib/pem.py | 164 +++++++++++++++++++++++++++++++
A lib/rsakey.py | 517 +++++++++++++++++++++++++++++++
M lib/x509.py | 90 +++++++++----------------------
M setup.py | 1 -
8 files changed, 780 insertions(+), 85 deletions(-)
---
(DIR) diff --git a/RELEASE-NOTES b/RELEASE-NOTES
t@@ -1,6 +1,7 @@
# Release 2.4.1
* Use ssl.PROTOCOL_TLSv1
* Fix DNSSEC issues with ECDSA signatures
+ * Replace TLSLite dependency with minimal RSA implementation
# Release 2.4
* Payment to DNS names storing a Bitcoin addresses (OpenAlias) is
(DIR) diff --git a/lib/asn1tinydecoder.py b/lib/asn1tinydecoder.py
t@@ -121,3 +121,50 @@ def asn1_read_length(der,ix):
####################### END ASN1 DECODER ############################
+def decode_OID(s):
+ s = map(ord, s)
+ r = []
+ r.append(s[0] / 40)
+ r.append(s[0] % 40)
+ k = 0
+ for i in s[1:]:
+ if i < 128:
+ r.append(i + 128*k)
+ k = 0
+ else:
+ k = (i - 128) + 128*k
+ return '.'.join(map(str, r))
+
+def encode_OID(oid):
+ x = map(int, oid.split('.'))
+ s = chr(x[0]*40 + x[1])
+ for i in x[2:]:
+ ss = chr(i % 128)
+ while i > 128:
+ i = i / 128
+ ss = chr(128 + i % 128) + ss
+ s += ss
+ return s
+
+def asn1_get_children(der, i):
+ nodes = []
+ ii = asn1_node_first_child(der,i)
+ nodes.append(ii)
+ while ii[2]<i[2]:
+ ii = asn1_node_next(der,ii)
+ nodes.append(ii)
+ return nodes
+
+def asn1_get_sequence(s):
+ return map(lambda j: asn1_get_value(s, j), asn1_get_children(s, asn1_node_root(s)))
+
+def asn1_get_dict(der, i):
+ p = {}
+ for ii in asn1_get_children(der, i):
+ for iii in asn1_get_children(der, ii):
+ iiii = asn1_node_first_child(der, iii)
+ oid = decode_OID(asn1_get_value_of_type(der, iiii, 'OBJECT IDENTIFIER'))
+ iiii = asn1_node_next(der, iiii)
+ value = asn1_get_value(der, iiii)
+ p[oid] = value
+ return p
(DIR) diff --git a/lib/dnssec.py b/lib/dnssec.py
t@@ -57,16 +57,16 @@ from dns.exception import DNSException
"""
Pure-Python version of dns.dnssec._validate_rsig
-Uses tlslite instead of PyCrypto
"""
+
+import ecdsa
+import rsakey
+
+
def python_validate_rrsig(rrset, rrsig, keys, origin=None, now=None):
from dns.dnssec import ValidationFailure, ECDSAP256SHA256, ECDSAP384SHA384
from dns.dnssec import _find_candidate_keys, _make_hash, _is_ecdsa, _is_rsa, _to_rdata, _make_algorithm_id
- import ecdsa
- from tlslite.utils.keyfactory import _createPublicRSAKey
- from tlslite.utils.cryptomath import bytesToNumber
-
if isinstance(origin, (str, unicode)):
origin = dns.name.from_text(origin, dns.name.root)
t@@ -101,9 +101,9 @@ def python_validate_rrsig(rrset, rrsig, keys, origin=None, now=None):
keyptr = keyptr[2:]
rsa_e = keyptr[0:bytes]
rsa_n = keyptr[bytes:]
- n = bytesToNumber(bytearray(rsa_n))
- e = bytesToNumber(bytearray(rsa_e))
- pubkey = _createPublicRSAKey(n, e)
+ n = ecdsa.util.string_to_number(rsa_n)
+ e = ecdsa.util.string_to_number(rsa_e)
+ pubkey = rsakey.RSAKey(n, e)
sig = rrsig.signature
elif _is_ecdsa(rrsig.algorithm):
(DIR) diff --git a/lib/paymentrequest.py b/lib/paymentrequest.py
t@@ -25,6 +25,7 @@ import threading
import time
import traceback
import urlparse
+import json
import requests
try:
t@@ -34,9 +35,11 @@ except ImportError:
import bitcoin
import util
+from util import print_error
import transaction
import x509
-from util import print_error
+import rsakey
+
REQUEST_HEADERS = {'Accept': 'application/bitcoin-paymentrequest', 'User-Agent': 'Electrum'}
ACK_HEADERS = {'Content-Type':'application/bitcoin-payment','Accept':'application/bitcoin-paymentack','User-Agent':'Electrum'}
t@@ -52,7 +55,6 @@ PR_UNKNOWN = 2 # sent but not propagated
PR_PAID = 3 # send and propagated
PR_ERROR = 4 # could not parse
-import json
def get_payment_request(url):
t@@ -163,7 +165,9 @@ class PaymentRequest:
prev_x = x509_chain[i-1]
algo, sig, data = prev_x.get_signature()
sig = bytearray(sig)
- pubkey = x.publicKey
+
+ pubkey = rsakey.RSAKey(x.modulus, x.exponent)
+
if algo == x509.ALGO_RSA_SHA1:
verify = pubkey.hashAndVerify(sig, data)
elif algo == x509.ALGO_RSA_SHA256:
t@@ -183,7 +187,8 @@ class PaymentRequest:
self.error = "Certificate not Signed by Provided CA Certificate Chain"
return False
# verify the BIP70 signature
- pubkey0 = x509_chain[0].publicKey
+ x = x509_chain[0]
+ pubkey0 = rsakey.RSAKey(x.modulus, x.exponent)
sig = paymntreq.signature
paymntreq.signature = ''
s = paymntreq.SerializeToString()
t@@ -324,20 +329,22 @@ def sign_request_with_alias(pr, alias, alias_privkey):
pr.signature = ec_key.sign_message(message, compressed, address)
+
def sign_request_with_x509(pr, key_path, cert_path):
- import tlslite
+ import pem
with open(key_path, 'r') as f:
- rsakey = tlslite.utils.python_rsakey.Python_RSAKey.parsePEM(f.read())
+ params = pem.parse_private_key(f.read())
+ privkey = rsakey.RSAKey(*params)
with open(cert_path, 'r') as f:
- chain = tlslite.X509CertChain()
- chain.parsePemList(f.read())
+ s = f.read()
+ bList = pem.dePemList(s, "CERTIFICATE")
certificates = pb2.X509Certificates()
- certificates.certificate.extend(map(lambda x: str(x.bytes), chain.x509List))
+ certificates.certificate.extend(map(str, bList))
pr.pki_type = 'x509+sha256'
pr.pki_data = certificates.SerializeToString()
msgBytes = bytearray(pr.SerializeToString())
hashBytes = bytearray(hashlib.sha256(msgBytes).digest())
- sig = rsakey.sign(x509.PREFIX_RSA_SHA256 + hashBytes)
+ sig = privkey.sign(x509.PREFIX_RSA_SHA256 + hashBytes)
pr.signature = bytes(sig)
t@@ -362,8 +369,6 @@ def make_request(config, req):
-
-
class InvoiceStore(object):
def __init__(self, config):
(DIR) diff --git a/lib/pem.py b/lib/pem.py
t@@ -0,0 +1,164 @@
+# This module uses code from TLSLlite
+# TLSLite Author: Trevor Perrin)
+
+
+import binascii
+
+from asn1tinydecoder import *
+
+
+def a2b_base64(s):
+ try:
+ b = bytearray(binascii.a2b_base64(s))
+ except Exception as e:
+ raise SyntaxError("base64 error: %s" % e)
+ return b
+
+def b2a_base64(b):
+ return binascii.b2a_base64(b)
+
+
+def dePem(s, name):
+ """Decode a PEM string into a bytearray of its payload.
+
+ The input must contain an appropriate PEM prefix and postfix
+ based on the input name string, e.g. for name="CERTIFICATE":
+
+ -----BEGIN CERTIFICATE-----
+ MIIBXDCCAUSgAwIBAgIBADANBgkqhkiG9w0BAQUFADAPMQ0wCwYDVQQDEwRUQUNL
+ ...
+ KoZIhvcNAQEFBQADAwA5kw==
+ -----END CERTIFICATE-----
+
+ The first such PEM block in the input will be found, and its
+ payload will be base64 decoded and returned.
+ """
+ prefix = "-----BEGIN %s-----" % name
+ postfix = "-----END %s-----" % name
+ start = s.find(prefix)
+ if start == -1:
+ raise SyntaxError("Missing PEM prefix")
+ end = s.find(postfix, start+len(prefix))
+ if end == -1:
+ raise SyntaxError("Missing PEM postfix")
+ s = s[start+len("-----BEGIN %s-----" % name) : end]
+ retBytes = a2b_base64(s) # May raise SyntaxError
+ return retBytes
+
+def dePemList(s, name):
+ """Decode a sequence of PEM blocks into a list of bytearrays.
+
+ The input must contain any number of PEM blocks, each with the appropriate
+ PEM prefix and postfix based on the input name string, e.g. for
+ name="TACK BREAK SIG". Arbitrary text can appear between and before and
+ after the PEM blocks. For example:
+
+ " Created by TACK.py 0.9.3 Created at 2012-02-01T00:30:10Z -----BEGIN TACK
+ BREAK SIG-----
+ ATKhrz5C6JHJW8BF5fLVrnQss6JnWVyEaC0p89LNhKPswvcC9/s6+vWLd9snYTUv
+ YMEBdw69PUP8JB4AdqA3K6Ap0Fgd9SSTOECeAKOUAym8zcYaXUwpk0+WuPYa7Zmm
+ SkbOlK4ywqt+amhWbg9txSGUwFO5tWUHT3QrnRlE/e3PeNFXLx5Bckg= -----END TACK
+ BREAK SIG----- Created by TACK.py 0.9.3 Created at 2012-02-01T00:30:11Z
+ -----BEGIN TACK BREAK SIG-----
+ ATKhrz5C6JHJW8BF5fLVrnQss6JnWVyEaC0p89LNhKPswvcC9/s6+vWLd9snYTUv
+ YMEBdw69PUP8JB4AdqA3K6BVCWfcjN36lx6JwxmZQncS6sww7DecFO/qjSePCxwM
+ +kdDqX/9/183nmjx6bf0ewhPXkA0nVXsDYZaydN8rJU1GaMlnjcIYxY= -----END TACK
+ BREAK SIG----- "
+
+ All such PEM blocks will be found, decoded, and return in an ordered list
+ of bytearrays, which may have zero elements if not PEM blocks are found.
+ """
+ bList = []
+ prefix = "-----BEGIN %s-----" % name
+ postfix = "-----END %s-----" % name
+ while 1:
+ start = s.find(prefix)
+ if start == -1:
+ return bList
+ end = s.find(postfix, start+len(prefix))
+ if end == -1:
+ raise SyntaxError("Missing PEM postfix")
+ s2 = s[start+len(prefix) : end]
+ retBytes = a2b_base64(s2) # May raise SyntaxError
+ bList.append(retBytes)
+ s = s[end+len(postfix) : ]
+
+def pem(b, name):
+ """Encode a payload bytearray into a PEM string.
+
+ The input will be base64 encoded, then wrapped in a PEM prefix/postfix
+ based on the name string, e.g. for name="CERTIFICATE":
+
+ -----BEGIN CERTIFICATE-----
+ MIIBXDCCAUSgAwIBAgIBADANBgkqhkiG9w0BAQUFADAPMQ0wCwYDVQQDEwRUQUNL
+ ...
+ KoZIhvcNAQEFBQADAwA5kw==
+ -----END CERTIFICATE-----
+ """
+ s1 = b2a_base64(b)[:-1] # remove terminating \n
+ s2 = ""
+ while s1:
+ s2 += s1[:64] + "\n"
+ s1 = s1[64:]
+ s = ("-----BEGIN %s-----\n" % name) + s2 + \
+ ("-----END %s-----\n" % name)
+ return s
+
+def pemSniff(inStr, name):
+ searchStr = "-----BEGIN %s-----" % name
+ return searchStr in inStr
+
+
+def parse_private_key(s):
+ """Parse a string containing a PEM-encoded <privateKey>."""
+ if pemSniff(s, "PRIVATE KEY"):
+ bytes = dePem(s, "PRIVATE KEY")
+ return _parsePKCS8(bytes)
+ elif pemSniff(s, "RSA PRIVATE KEY"):
+ bytes = dePem(s, "RSA PRIVATE KEY")
+ return _parseSSLeay(bytes)
+ else:
+ raise SyntaxError("Not a PEM private key file")
+
+
+def _parsePKCS8(bytes):
+ s = str(bytes)
+ root = asn1_node_root(s)
+ version_node = asn1_node_first_child(s, root)
+ version = bytestr_to_int(asn1_get_value_of_type(s, version_node, 'INTEGER'))
+ if version != 0:
+ raise SyntaxError("Unrecognized PKCS8 version")
+ rsaOID_node = asn1_node_next(s, version_node)
+ ii = asn1_node_first_child(s, rsaOID_node)
+ rsaOID = decode_OID(asn1_get_value_of_type(s, ii, 'OBJECT IDENTIFIER'))
+ if rsaOID != '1.2.840.113549.1.1.1':
+ raise SyntaxError("Unrecognized AlgorithmIdentifier")
+ privkey_node = asn1_node_next(s, rsaOID_node)
+ value = asn1_get_value_of_type(s, privkey_node, 'OCTET STRING')
+ return _parseASN1PrivateKey(value)
+
+
+def _parseSSLeay(bytes):
+ return _parseASN1PrivateKey(str(bytes))
+
+
+def bytesToNumber(s):
+ return int(binascii.hexlify(s), 16)
+
+
+def _parseASN1PrivateKey(s):
+ root = asn1_node_root(s)
+ version_node = asn1_node_first_child(s, root)
+ version = bytestr_to_int(asn1_get_value_of_type(s, version_node, 'INTEGER'))
+ if version != 0:
+ raise SyntaxError("Unrecognized RSAPrivateKey version")
+ n = asn1_node_next(s, version_node)
+ e = asn1_node_next(s, n)
+ d = asn1_node_next(s, e)
+ p = asn1_node_next(s, d)
+ q = asn1_node_next(s, p)
+ dP = asn1_node_next(s, q)
+ dQ = asn1_node_next(s, dP)
+ qInv = asn1_node_next(s, dQ)
+ return map(lambda x: bytesToNumber(asn1_get_value_of_type(s, x, 'INTEGER')), [n, e, d, p, q, dP, dQ, qInv])
+
(DIR) diff --git a/lib/rsakey.py b/lib/rsakey.py
t@@ -0,0 +1,517 @@
+# This module uses functions from TLSLite (public domain)
+#
+# TLSLite Authors:
+# Trevor Perrin
+# Martin von Loewis - python 3 port
+# Yngve Pettersen (ported by Paul Sokolovsky) - TLS 1.2
+#
+
+"""Pure-Python RSA implementation."""
+
+
+from __future__ import print_function
+import os
+import math
+import base64
+import binascii
+
+from pem import *
+
+
+# **************************************************************************
+# PRNG Functions
+# **************************************************************************
+
+# Check that os.urandom works
+import zlib
+length = len(zlib.compress(os.urandom(1000)))
+assert(length > 900)
+
+def getRandomBytes(howMany):
+ b = bytearray(os.urandom(howMany))
+ assert(len(b) == howMany)
+ return b
+
+prngName = "os.urandom"
+
+
+# **************************************************************************
+# Converter Functions
+# **************************************************************************
+
+def bytesToNumber(b):
+ total = 0
+ multiplier = 1
+ for count in range(len(b)-1, -1, -1):
+ byte = b[count]
+ total += multiplier * byte
+ multiplier *= 256
+ return total
+
+def numberToByteArray(n, howManyBytes=None):
+ """Convert an integer into a bytearray, zero-pad to howManyBytes.
+
+ The returned bytearray may be smaller than howManyBytes, but will
+ not be larger. The returned bytearray will contain a big-endian
+ encoding of the input integer (n).
+ """
+ if howManyBytes == None:
+ howManyBytes = numBytes(n)
+ b = bytearray(howManyBytes)
+ for count in range(howManyBytes-1, -1, -1):
+ b[count] = int(n % 256)
+ n >>= 8
+ return b
+
+def mpiToNumber(mpi): #mpi is an openssl-format bignum string
+ if (ord(mpi[4]) & 0x80) !=0: #Make sure this is a positive number
+ raise AssertionError()
+ b = bytearray(mpi[4:])
+ return bytesToNumber(b)
+
+def numberToMPI(n):
+ b = numberToByteArray(n)
+ ext = 0
+ #If the high-order bit is going to be set,
+ #add an extra byte of zeros
+ if (numBits(n) & 0x7)==0:
+ ext = 1
+ length = numBytes(n) + ext
+ b = bytearray(4+ext) + b
+ b[0] = (length >> 24) & 0xFF
+ b[1] = (length >> 16) & 0xFF
+ b[2] = (length >> 8) & 0xFF
+ b[3] = length & 0xFF
+ return bytes(b)
+
+
+# **************************************************************************
+# Misc. Utility Functions
+# **************************************************************************
+
+def numBits(n):
+ if n==0:
+ return 0
+ s = "%x" % n
+ return ((len(s)-1)*4) + \
+ {'0':0, '1':1, '2':2, '3':2,
+ '4':3, '5':3, '6':3, '7':3,
+ '8':4, '9':4, 'a':4, 'b':4,
+ 'c':4, 'd':4, 'e':4, 'f':4,
+ }[s[0]]
+ return int(math.floor(math.log(n, 2))+1)
+
+def numBytes(n):
+ if n==0:
+ return 0
+ bits = numBits(n)
+ return int(math.ceil(bits / 8.0))
+
+# **************************************************************************
+# Big Number Math
+# **************************************************************************
+
+def getRandomNumber(low, high):
+ if low >= high:
+ raise AssertionError()
+ howManyBits = numBits(high)
+ howManyBytes = numBytes(high)
+ lastBits = howManyBits % 8
+ while 1:
+ bytes = getRandomBytes(howManyBytes)
+ if lastBits:
+ bytes[0] = bytes[0] % (1 << lastBits)
+ n = bytesToNumber(bytes)
+ if n >= low and n < high:
+ return n
+
+def gcd(a,b):
+ a, b = max(a,b), min(a,b)
+ while b:
+ a, b = b, a % b
+ return a
+
+def lcm(a, b):
+ return (a * b) // gcd(a, b)
+
+#Returns inverse of a mod b, zero if none
+#Uses Extended Euclidean Algorithm
+def invMod(a, b):
+ c, d = a, b
+ uc, ud = 1, 0
+ while c != 0:
+ q = d // c
+ c, d = d-(q*c), c
+ uc, ud = ud - (q * uc), uc
+ if d == 1:
+ return ud % b
+ return 0
+
+
+def powMod(base, power, modulus):
+ if power < 0:
+ result = pow(base, power*-1, modulus)
+ result = invMod(result, modulus)
+ return result
+ else:
+ return pow(base, power, modulus)
+
+#Pre-calculate a sieve of the ~100 primes < 1000:
+def makeSieve(n):
+ sieve = list(range(n))
+ for count in range(2, int(math.sqrt(n))+1):
+ if sieve[count] == 0:
+ continue
+ x = sieve[count] * 2
+ while x < len(sieve):
+ sieve[x] = 0
+ x += sieve[count]
+ sieve = [x for x in sieve[2:] if x]
+ return sieve
+
+sieve = makeSieve(1000)
+
+def isPrime(n, iterations=5, display=False):
+ #Trial division with sieve
+ for x in sieve:
+ if x >= n: return True
+ if n % x == 0: return False
+ #Passed trial division, proceed to Rabin-Miller
+ #Rabin-Miller implemented per Ferguson & Schneier
+ #Compute s, t for Rabin-Miller
+ if display: print("*", end=' ')
+ s, t = n-1, 0
+ while s % 2 == 0:
+ s, t = s//2, t+1
+ #Repeat Rabin-Miller x times
+ a = 2 #Use 2 as a base for first iteration speedup, per HAC
+ for count in range(iterations):
+ v = powMod(a, s, n)
+ if v==1:
+ continue
+ i = 0
+ while v != n-1:
+ if i == t-1:
+ return False
+ else:
+ v, i = powMod(v, 2, n), i+1
+ a = getRandomNumber(2, n)
+ return True
+
+def getRandomPrime(bits, display=False):
+ if bits < 10:
+ raise AssertionError()
+ #The 1.5 ensures the 2 MSBs are set
+ #Thus, when used for p,q in RSA, n will have its MSB set
+ #
+ #Since 30 is lcm(2,3,5), we'll set our test numbers to
+ #29 % 30 and keep them there
+ low = ((2 ** (bits-1)) * 3) // 2
+ high = 2 ** bits - 30
+ p = getRandomNumber(low, high)
+ p += 29 - (p % 30)
+ while 1:
+ if display: print(".", end=' ')
+ p += 30
+ if p >= high:
+ p = getRandomNumber(low, high)
+ p += 29 - (p % 30)
+ if isPrime(p, display=display):
+ return p
+
+#Unused at the moment...
+def getRandomSafePrime(bits, display=False):
+ if bits < 10:
+ raise AssertionError()
+ #The 1.5 ensures the 2 MSBs are set
+ #Thus, when used for p,q in RSA, n will have its MSB set
+ #
+ #Since 30 is lcm(2,3,5), we'll set our test numbers to
+ #29 % 30 and keep them there
+ low = (2 ** (bits-2)) * 3//2
+ high = (2 ** (bits-1)) - 30
+ q = getRandomNumber(low, high)
+ q += 29 - (q % 30)
+ while 1:
+ if display: print(".", end=' ')
+ q += 30
+ if (q >= high):
+ q = getRandomNumber(low, high)
+ q += 29 - (q % 30)
+ #Ideas from Tom Wu's SRP code
+ #Do trial division on p and q before Rabin-Miller
+ if isPrime(q, 0, display=display):
+ p = (2 * q) + 1
+ if isPrime(p, display=display):
+ if isPrime(q, display=display):
+ return p
+
+
+class RSAKey(object):
+
+ def __init__(self, n=0, e=0, d=0, p=0, q=0, dP=0, dQ=0, qInv=0):
+ if (n and not e) or (e and not n):
+ raise AssertionError()
+ self.n = n
+ self.e = e
+ self.d = d
+ self.p = p
+ self.q = q
+ self.dP = dP
+ self.dQ = dQ
+ self.qInv = qInv
+ self.blinder = 0
+ self.unblinder = 0
+
+ def __len__(self):
+ """Return the length of this key in bits.
+
+ @rtype: int
+ """
+ return numBits(self.n)
+
+ def hasPrivateKey(self):
+ return self.d != 0
+
+ def hashAndSign(self, bytes):
+ """Hash and sign the passed-in bytes.
+
+ This requires the key to have a private component. It performs
+ a PKCS1-SHA1 signature on the passed-in data.
+
+ @type bytes: str or L{bytearray} of unsigned bytes
+ @param bytes: The value which will be hashed and signed.
+
+ @rtype: L{bytearray} of unsigned bytes.
+ @return: A PKCS1-SHA1 signature on the passed-in data.
+ """
+ hashBytes = SHA1(bytearray(bytes))
+ prefixedHashBytes = self._addPKCS1SHA1Prefix(hashBytes)
+ sigBytes = self.sign(prefixedHashBytes)
+ return sigBytes
+
+ def hashAndVerify(self, sigBytes, bytes):
+ """Hash and verify the passed-in bytes with the signature.
+
+ This verifies a PKCS1-SHA1 signature on the passed-in data.
+
+ @type sigBytes: L{bytearray} of unsigned bytes
+ @param sigBytes: A PKCS1-SHA1 signature.
+
+ @type bytes: str or L{bytearray} of unsigned bytes
+ @param bytes: The value which will be hashed and verified.
+
+ @rtype: bool
+ @return: Whether the signature matches the passed-in data.
+ """
+ hashBytes = SHA1(bytearray(bytes))
+
+ # Try it with/without the embedded NULL
+ prefixedHashBytes1 = self._addPKCS1SHA1Prefix(hashBytes, False)
+ prefixedHashBytes2 = self._addPKCS1SHA1Prefix(hashBytes, True)
+ result1 = self.verify(sigBytes, prefixedHashBytes1)
+ result2 = self.verify(sigBytes, prefixedHashBytes2)
+ return (result1 or result2)
+
+ def sign(self, bytes):
+ """Sign the passed-in bytes.
+
+ This requires the key to have a private component. It performs
+ a PKCS1 signature on the passed-in data.
+
+ @type bytes: L{bytearray} of unsigned bytes
+ @param bytes: The value which will be signed.
+
+ @rtype: L{bytearray} of unsigned bytes.
+ @return: A PKCS1 signature on the passed-in data.
+ """
+ if not self.hasPrivateKey():
+ raise AssertionError()
+ paddedBytes = self._addPKCS1Padding(bytes, 1)
+ m = bytesToNumber(paddedBytes)
+ if m >= self.n:
+ raise ValueError()
+ c = self._rawPrivateKeyOp(m)
+ sigBytes = numberToByteArray(c, numBytes(self.n))
+ return sigBytes
+
+ def verify(self, sigBytes, bytes):
+ """Verify the passed-in bytes with the signature.
+
+ This verifies a PKCS1 signature on the passed-in data.
+
+ @type sigBytes: L{bytearray} of unsigned bytes
+ @param sigBytes: A PKCS1 signature.
+
+ @type bytes: L{bytearray} of unsigned bytes
+ @param bytes: The value which will be verified.
+
+ @rtype: bool
+ @return: Whether the signature matches the passed-in data.
+ """
+ if len(sigBytes) != numBytes(self.n):
+ return False
+ paddedBytes = self._addPKCS1Padding(bytes, 1)
+ c = bytesToNumber(sigBytes)
+ if c >= self.n:
+ return False
+ m = self._rawPublicKeyOp(c)
+ checkBytes = numberToByteArray(m, numBytes(self.n))
+ return checkBytes == paddedBytes
+
+ def encrypt(self, bytes):
+ """Encrypt the passed-in bytes.
+
+ This performs PKCS1 encryption of the passed-in data.
+
+ @type bytes: L{bytearray} of unsigned bytes
+ @param bytes: The value which will be encrypted.
+
+ @rtype: L{bytearray} of unsigned bytes.
+ @return: A PKCS1 encryption of the passed-in data.
+ """
+ paddedBytes = self._addPKCS1Padding(bytes, 2)
+ m = bytesToNumber(paddedBytes)
+ if m >= self.n:
+ raise ValueError()
+ c = self._rawPublicKeyOp(m)
+ encBytes = numberToByteArray(c, numBytes(self.n))
+ return encBytes
+
+ def decrypt(self, encBytes):
+ """Decrypt the passed-in bytes.
+
+ This requires the key to have a private component. It performs
+ PKCS1 decryption of the passed-in data.
+
+ @type encBytes: L{bytearray} of unsigned bytes
+ @param encBytes: The value which will be decrypted.
+
+ @rtype: L{bytearray} of unsigned bytes or None.
+ @return: A PKCS1 decryption of the passed-in data or None if
+ the data is not properly formatted.
+ """
+ if not self.hasPrivateKey():
+ raise AssertionError()
+ if len(encBytes) != numBytes(self.n):
+ return None
+ c = bytesToNumber(encBytes)
+ if c >= self.n:
+ return None
+ m = self._rawPrivateKeyOp(c)
+ decBytes = numberToByteArray(m, numBytes(self.n))
+ #Check first two bytes
+ if decBytes[0] != 0 or decBytes[1] != 2:
+ return None
+ #Scan through for zero separator
+ for x in range(1, len(decBytes)-1):
+ if decBytes[x]== 0:
+ break
+ else:
+ return None
+ return decBytes[x+1:] #Return everything after the separator
+
+
+
+
+ # **************************************************************************
+ # Helper Functions for RSA Keys
+ # **************************************************************************
+
+ def _addPKCS1SHA1Prefix(self, bytes, withNULL=True):
+ # There is a long history of confusion over whether the SHA1
+ # algorithmIdentifier should be encoded with a NULL parameter or
+ # with the parameter omitted. While the original intention was
+ # apparently to omit it, many toolkits went the other way. TLS 1.2
+ # specifies the NULL should be included, and this behavior is also
+ # mandated in recent versions of PKCS #1, and is what tlslite has
+ # always implemented. Anyways, verification code should probably
+ # accept both. However, nothing uses this code yet, so this is
+ # all fairly moot.
+ if not withNULL:
+ prefixBytes = bytearray(\
+ [0x30,0x1f,0x30,0x07,0x06,0x05,0x2b,0x0e,0x03,0x02,0x1a,0x04,0x14])
+ else:
+ prefixBytes = bytearray(\
+ [0x30,0x21,0x30,0x09,0x06,0x05,0x2b,0x0e,0x03,0x02,0x1a,0x05,0x00,0x04,0x14])
+ prefixedBytes = prefixBytes + bytes
+ return prefixedBytes
+
+ def _addPKCS1Padding(self, bytes, blockType):
+ padLength = (numBytes(self.n) - (len(bytes)+3))
+ if blockType == 1: #Signature padding
+ pad = [0xFF] * padLength
+ elif blockType == 2: #Encryption padding
+ pad = bytearray(0)
+ while len(pad) < padLength:
+ padBytes = getRandomBytes(padLength * 2)
+ pad = [b for b in padBytes if b != 0]
+ pad = pad[:padLength]
+ else:
+ raise AssertionError()
+
+ padding = bytearray([0,blockType] + pad + [0])
+ paddedBytes = padding + bytes
+ return paddedBytes
+
+
+
+
+ def _rawPrivateKeyOp(self, m):
+ #Create blinding values, on the first pass:
+ if not self.blinder:
+ self.unblinder = getRandomNumber(2, self.n)
+ self.blinder = powMod(invMod(self.unblinder, self.n), self.e,
+ self.n)
+
+ #Blind the input
+ m = (m * self.blinder) % self.n
+
+ #Perform the RSA operation
+ c = self._rawPrivateKeyOpHelper(m)
+
+ #Unblind the output
+ c = (c * self.unblinder) % self.n
+
+ #Update blinding values
+ self.blinder = (self.blinder * self.blinder) % self.n
+ self.unblinder = (self.unblinder * self.unblinder) % self.n
+
+ #Return the output
+ return c
+
+
+ def _rawPrivateKeyOpHelper(self, m):
+ #Non-CRT version
+ #c = powMod(m, self.d, self.n)
+
+ #CRT version (~3x faster)
+ s1 = powMod(m, self.dP, self.p)
+ s2 = powMod(m, self.dQ, self.q)
+ h = ((s1 - s2) * self.qInv) % self.p
+ c = s2 + self.q * h
+ return c
+
+ def _rawPublicKeyOp(self, c):
+ m = powMod(c, self.e, self.n)
+ return m
+
+ def acceptsPassword(self):
+ return False
+
+ def generate(bits):
+ key = Python_RSAKey()
+ p = getRandomPrime(bits//2, False)
+ q = getRandomPrime(bits//2, False)
+ t = lcm(p-1, q-1)
+ key.n = p * q
+ key.e = 65537
+ key.d = invMod(key.e, t)
+ key.p = p
+ key.q = q
+ key.dP = key.d % (p-1)
+ key.dQ = key.d % (q-1)
+ key.qInv = invMod(q, p)
+ return key
+ generate = staticmethod(generate)
+
(DIR) diff --git a/lib/x509.py b/lib/x509.py
t@@ -20,17 +20,12 @@
from datetime import datetime
import sys
-import tlslite
import util
from util import profiler, print_error
-from asn1tinydecoder import asn1_node_root, asn1_get_all, asn1_get_value, \
- asn1_get_value_of_type, asn1_node_next, asn1_node_first_child, \
- asn1_read_length, asn1_node_is_child_of, \
- bytestr_to_int, bitstr_to_bytestr
-
-# workaround https://github.com/trevp/tlslite/issues/15
-tlslite.utils.cryptomath.pycryptoLoaded = False
+from asn1tinydecoder import *
+import ecdsa
+import hashlib
# algo OIDs
t@@ -50,61 +45,13 @@ class CertificateError(Exception):
pass
-def decode_OID(s):
- s = map(ord, s)
- r = []
- r.append(s[0] / 40)
- r.append(s[0] % 40)
- k = 0
- for i in s[1:]:
- if i < 128:
- r.append(i + 128*k)
- k = 0
- else:
- k = (i - 128) + 128*k
- return '.'.join(map(str, r))
-
-def encode_OID(oid):
- x = map(int, oid.split('.'))
- s = chr(x[0]*40 + x[1])
- for i in x[2:]:
- ss = chr(i % 128)
- while i > 128:
- i = i / 128
- ss = chr(128 + i % 128) + ss
- s += ss
- return s
-
-def asn1_get_children(der, i):
- nodes = []
- ii = asn1_node_first_child(der,i)
- nodes.append(ii)
- while ii[2]<i[2]:
- ii = asn1_node_next(der,ii)
- nodes.append(ii)
- return nodes
-
-def asn1_get_sequence(s):
- return map(lambda j: asn1_get_value(s, j), asn1_get_children(s, asn1_node_root(s)))
-
-def asn1_get_dict(der, i):
- p = {}
- for ii in asn1_get_children(der, i):
- for iii in asn1_get_children(der, ii):
- iiii = asn1_node_first_child(der, iii)
- oid = decode_OID(asn1_get_value_of_type(der, iiii, 'OBJECT IDENTIFIER'))
- iiii = asn1_node_next(der, iiii)
- value = asn1_get_value(der, iiii)
- p[oid] = value
- return p
-class X509(tlslite.X509):
+class X509(object):
def parseBinary(self, b):
- # call tlslite method first
- tlslite.X509.parseBinary(self, b)
+ self.bytes = bytearray(b)
der = str(b)
root = asn1_node_root(der)
t@@ -139,8 +86,25 @@ class X509(tlslite.X509):
# subject
subject = asn1_node_next(der, validity)
self.subject = asn1_get_dict(der, subject)
+
subject_pki = asn1_node_next(der, subject)
+ public_key_algo = asn1_node_first_child(der, subject_pki)
+ ii = asn1_node_first_child(der, public_key_algo)
+ self.public_key_algo = decode_OID(asn1_get_value_of_type(der, ii, 'OBJECT IDENTIFIER'))
+
+ # pubkey modulus and exponent
+ subject_public_key = asn1_node_next(der, public_key_algo)
+ spk = asn1_get_value_of_type(der, subject_public_key, 'BIT STRING')
+ spk = bitstr_to_bytestr(spk)
+ r = asn1_node_root(spk)
+ modulus = asn1_node_first_child(spk, r)
+ exponent = asn1_node_next(spk, modulus)
+ rsa_n = asn1_get_value_of_type(spk, modulus, 'INTEGER')
+ rsa_e = asn1_get_value_of_type(spk, exponent, 'INTEGER')
+ self.modulus = ecdsa.util.string_to_number(rsa_n)
+ self.exponent = ecdsa.util.string_to_number(rsa_e)
+
# extensions
self.CA = False
self.AKI = None
t@@ -198,10 +162,8 @@ class X509(tlslite.X509):
if not_after <= now:
raise CertificateError('Certificate has expired.')
-
-
-class X509CertChain(tlslite.X509CertChain):
- pass
+ def getFingerprint(self):
+ return hashlib.sha1(self.bytes).digest()
t@@ -209,11 +171,12 @@ class X509CertChain(tlslite.X509CertChain):
@profiler
def load_certificates(ca_path):
+ import pem
ca_list = {}
ca_keyID = {}
with open(ca_path, 'r') as f:
s = f.read()
- bList = tlslite.utils.pem.dePemList(s, "CERTIFICATE")
+ bList = pem.dePemList(s, "CERTIFICATE")
for b in bList:
x = X509()
try:
t@@ -238,7 +201,6 @@ def int_to_bytestr(i):
return s
def create_csr(commonName, challenge, k):
- import ecdsa, hashlib
from bitcoin import point_to_ser
private_key = ecdsa.SigningKey.from_string(k, curve = ecdsa.SECP256k1)
public_key = private_key.get_verifying_key()
(DIR) diff --git a/setup.py b/setup.py
t@@ -35,7 +35,6 @@ setup(
'requests',
'qrcode',
'protobuf',
- 'tlslite',
'dnspython',
],
package_dir={