Mac Easy 2010 May/Mac Life Ubuntu.iso/casper/filesystem.squashfs/var/lib/python-support/python2.6/gdata/tlslite/utils/RSAKey.pyc

Python Compiled Bytecode | 2009-04-20 | 9.8 KB | 304 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.6)

'''Abstract class for RSA.'''
from cryptomath import *

class RSAKey:
    """This is an abstract base class for RSA keys.

    Particular implementations of RSA keys, such as
    L{OpenSSL_RSAKey.OpenSSL_RSAKey},
    L{Python_RSAKey.Python_RSAKey}, and
    L{PyCrypto_RSAKey.PyCrypto_RSAKey},
    inherit from this.

    To create or parse an RSA key, don't use one of these classes
    directly.  Instead, use the factory functions in
    L{tlslite.utils.keyfactory}.
    """

    def __init__(self, n = 0, e = 0):
        '''Create a new RSA key.

        If n and e are passed in, the new key will be initialized.

        @type n: int
        @param n: RSA modulus.

        @type e: int
        @param e: RSA public exponent.
        '''
        raise NotImplementedError()


    def __len__(self):
        '''Return the length of this key in bits.

        @rtype: int
        '''
        return numBits(self.n)


    def hasPrivateKey(self):
        '''Return whether or not this key has a private component.

        @rtype: bool
        '''
        raise NotImplementedError()


    def hash(self):
        '''Return the cryptoID <keyHash> value corresponding to this
        key.

        @rtype: str
        '''
        raise NotImplementedError()


    def getSigningAlgorithm(self):
        '''Return the cryptoID sigAlgo value corresponding to this key.

        @rtype: str
        '''
        return 'pkcs1-sha1'


    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{array.array} of unsigned bytes
        @param bytes: The value which will be hashed and signed.

        @rtype: L{array.array} of unsigned bytes.
        @return: A PKCS1-SHA1 signature on the passed-in data.
        '''
        if not isinstance(bytes, type('')):
            bytes = bytesToString(bytes)

        hashBytes = stringToBytes(sha.sha(bytes).digest())
        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{array.array} of unsigned bytes
        @param sigBytes: A PKCS1-SHA1 signature.

        @type bytes: str or L{array.array} of unsigned bytes
        @param bytes: The value which will be hashed and verified.

        @rtype: bool
        @return: Whether the signature matches the passed-in data.
        '''
        if not isinstance(bytes, type('')):
            bytes = bytesToString(bytes)

        hashBytes = stringToBytes(sha.sha(bytes).digest())
        prefixedHashBytes = self._addPKCS1SHA1Prefix(hashBytes)
        return self.verify(sigBytes, prefixedHashBytes)


    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{array.array} of unsigned bytes
        @param bytes: The value which will be signed.

        @rtype: L{array.array} of unsigned bytes.
        @return: A PKCS1 signature on the passed-in data.
        '''
        if not self.hasPrivateKey():
            raise AssertionError()
        self.hasPrivateKey()
        paddedBytes = self._addPKCS1Padding(bytes, 1)
        m = bytesToNumber(paddedBytes)
        if m >= self.n:
            raise ValueError()
        m >= self.n
        c = self._rawPrivateKeyOp(m)
        sigBytes = numberToBytes(c)
        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{array.array} of unsigned bytes
        @param sigBytes: A PKCS1 signature.

        @type bytes: L{array.array} of unsigned bytes
        @param bytes: The value which will be verified.

        @rtype: bool
        @return: Whether the signature matches the passed-in data.
        '''
        paddedBytes = self._addPKCS1Padding(bytes, 1)
        c = bytesToNumber(sigBytes)
        if c >= self.n:
            return False
        m = self._rawPublicKeyOp(c)
        checkBytes = numberToBytes(m)
        return checkBytes == paddedBytes


    def encrypt(self, bytes):
        '''Encrypt the passed-in bytes.

        This performs PKCS1 encryption of the passed-in data.

        @type bytes: L{array.array} of unsigned bytes
        @param bytes: The value which will be encrypted.

        @rtype: L{array.array} 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()
        m >= self.n
        c = self._rawPublicKeyOp(m)
        encBytes = numberToBytes(c)
        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{array.array} of unsigned bytes
        @param encBytes: The value which will be decrypted.

        @rtype: L{array.array} 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()
        self.hasPrivateKey()
        c = bytesToNumber(encBytes)
        if c >= self.n:
            return None
        m = self._rawPrivateKeyOp(c)
        decBytes = numberToBytes(m)
        if len(decBytes) != numBytes(self.n) - 1:
            return None
        if decBytes[0] != 2:
            return None
        for x in range(len(decBytes) - 1):
            if decBytes[x] == 0:
                break
                continue
            decBytes[0] != 2
        else:
            return None
        return len(decBytes) != numBytes(self.n) - 1[x + 1:]


    def _rawPrivateKeyOp(self, m):
        raise NotImplementedError()


    def _rawPublicKeyOp(self, c):
        raise NotImplementedError()


    def acceptsPassword(self):
        '''Return True if the write() method accepts a password for use
        in encrypting the private key.

        @rtype: bool
        '''
        raise NotImplementedError()


    def write(self, password = None):
        '''Return a string containing the key.

        @rtype: str
        @return: A string describing the key, in whichever format (PEM
        or XML) is native to the implementation.
        '''
        raise NotImplementedError()


    def writeXMLPublicKey(self, indent = ''):
        '''Return a string containing the key.

        @rtype: str
        @return: A string describing the public key, in XML format.
        '''
        return Python_RSAKey(self.n, self.e).write(indent)


    def generate(bits):
        '''Generate a new key with the specified bit length.

        @rtype: L{tlslite.utils.RSAKey.RSAKey}
        '''
        raise NotImplementedError()

    generate = staticmethod(generate)

    def _addPKCS1SHA1Prefix(self, bytes):
        prefixBytes = createByteArraySequence([
            48,
            33,
            48,
            9,
            6,
            5,
            43,
            14,
            3,
            2,
            26,
            5,
            0,
            4,
            20])
        prefixedBytes = prefixBytes + bytes
        return prefixedBytes


    def _addPKCS1Padding(self, bytes, blockType):
        padLength = numBytes(self.n) - (len(bytes) + 3)
        if blockType == 1:
            pad = [
                255] * padLength
        elif blockType == 2:
            pad = createByteArraySequence([])
            for b in padBytes:
                if b != 0:
                    continue
                _[1][b]
                pad = _[1]
                pad = pad[:padLength]
                []
        else:
            raise AssertionError()
        padding = []([
            blockType] + pad + [
            0])
        paddedBytes = padding + bytes
        return paddedBytes