Update tlslite to 0.4.6.

third_party/tlslite/tlslite/utils/openssl_rsakey.py

+# Author: Trevor Perrin
+# See the LICENSE file for legal information regarding use of this file.
+
 """OpenSSL/M2Crypto RSA implementation."""
 
-from cryptomath import *
+from .cryptomath import *
 
-from rsakey import *
-from python_rsakey import Python_RSAKey
+from .rsakey import *
+from .python_rsakey import Python_RSAKey
 
 #copied from M2Crypto.util.py, so when we load the local copy of m2
 #we can still use it
 def password_callback(v, prompt1='Enter private key passphrase:',
                            prompt2='Verify passphrase:'):
     from getpass import getpass
     while 1:
         try:
             p1=getpass(prompt1)
             if v:
@@ skipping 31 matching lines @@
             elif name == 'n':
                 if not self.rsa:
                     return 0
                 return mpiToNumber(m2.rsa_get_n(self.rsa))
             else:
                 raise AttributeError
 
         def hasPrivateKey(self):
             return self._hasPrivateKey
 
-        def hash(self):
-            return Python_RSAKey(self.n, self.e).hash()
-
         def _rawPrivateKeyOp(self, m):
-            s = numberToString(m)
-            byteLength = numBytes(self.n)
-            if len(s)== byteLength:
-                pass
-            elif len(s) == byteLength-1:
-                s = '\0' + s
-            else:
-                raise AssertionError()
-            c = stringToNumber(m2.rsa_private_encrypt(self.rsa, s,
-                                                      m2.no_padding))
+            b = numberToByteArray(m, numBytes(self.n))
+            s = m2.rsa_private_encrypt(self.rsa, bytes(b), m2.no_padding)
+            c = bytesToNumber(bytearray(s))
             return c
 
         def _rawPublicKeyOp(self, c):
-            s = numberToString(c)
-            byteLength = numBytes(self.n)
-            if len(s)== byteLength:
-                pass
-            elif len(s) == byteLength-1:
-                s = '\0' + s
-            else:
-                raise AssertionError()
-            m = stringToNumber(m2.rsa_public_decrypt(self.rsa, s,
-                                                     m2.no_padding))
+            b = numberToByteArray(c, numBytes(self.n))
+            s = m2.rsa_public_decrypt(self.rsa, bytes(b), m2.no_padding)
+            m = bytesToNumber(bytearray(s))
             return m
 
         def acceptsPassword(self): return True
 
         def write(self, password=None):
             bio = m2.bio_new(m2.bio_s_mem())
             if self._hasPrivateKey:
                 if password:
                     def f(v): return password
                     m2.rsa_write_key(self.rsa, bio, m2.des_ede_cbc(), f)
                 else:
                     def f(): pass
                     m2.rsa_write_key_no_cipher(self.rsa, bio, f)
             else:
                 if password:
                     raise AssertionError()
                 m2.rsa_write_pub_key(self.rsa, bio)
             s = m2.bio_read(bio, m2.bio_ctrl_pending(bio))
             m2.bio_free(bio)
             return s
 
-        def writeXMLPublicKey(self, indent=''):
-            return Python_RSAKey(self.n, self.e).write(indent)
-
         def generate(bits):
             key = OpenSSL_RSAKey()
             def f():pass
             key.rsa = m2.rsa_generate_key(bits, 3, f)
             key._hasPrivateKey = True
             return key
         generate = staticmethod(generate)
 
         def parse(s, passwordCallback=None):
+            # Skip forward to the first PEM header
+            start = s.find("-----BEGIN ")
+            if start == -1:
+                raise SyntaxError()
+            s = s[start:]            
             if s.startswith("-----BEGIN "):
                 if passwordCallback==None:
                     callback = password_callback
                 else:
                     def f(v, prompt1=None, prompt2=None):
                         return passwordCallback()
                     callback = f
                 bio = m2.bio_new(m2.bio_s_mem())
                 try:
                     m2.bio_write(bio, s)
@@ skipping 11 matching lines @@
                         key._hasPrivateKey = False
                     else:
                         raise SyntaxError()
                     return key
                 finally:
                     m2.bio_free(bio)
             else:
                 raise SyntaxError()
 
         parse = staticmethod(parse)