Update third_party/tlslite to 0.4.8.

third_party/tlslite/tlslite/utils/rsakey.py

 # Author: Trevor Perrin
 # See the LICENSE file for legal information regarding use of this file.
 
 """Abstract class for RSA."""
 
 from .cryptomath import *
 
 
 class RSAKey(object):
     """This is an abstract base class for RSA keys.
@@ skipping 42 matching lines @@
         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)
+        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)
+        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.
 
@@ skipping 118 matching lines @@
         @rtype: L{tlslite.utils.RSAKey.RSAKey}
         """
         raise NotImplementedError()
     generate = staticmethod(generate)
 
 
     # **************************************************************************
     # Helper Functions for RSA Keys
     # **************************************************************************
 
-    def _addPKCS1SHA1Prefix(self, bytes, withNULL=True):
+    @staticmethod
+    def addPKCS1SHA1Prefix(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.
+        # accept both.
         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