1342

pending completion

Build # 1342

Build Type

Pull #418

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/tomato42/tlslite-ng/commit/<a class=hub.com/tomato42/tlslite-ng/commit/30d2c4a6cd1e0c8d6311a960ff123a4062fbae41">30d2c4a6c<a href="https://github.com/tomato42/tlslite-ng/commit/30d2c4a6cd1e0c8d6311a960ff123a4062fbae41">">Merge </a><a class="double-link" href="https://github.com/tomato42/tlslite-ng/commit/<a class="double-link" href="https://github.com/tomato42/tlslite-ng/commit/9e70455db3c997254ba87992302ec8937f713ea3">9e70455db</a>">9e70455db</a><a href="https://github.com/tomato42/tlslite-ng/commit/30d2c4a6cd1e0c8d6311a960ff123a4062fbae41"> into a8287baf6">a8287baf6</a>

Pull Request Pull Request #418: DSA cipher definitions

Run Details

3584 of 4835 branches covered (74.13%)

Branch coverage included in aggregate %.

232 of 232 new or added lines in 6 files covered. (100.0%)

10631 of 11992 relevant lines covered (88.65%)

28.95 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

70.21

/tlslite/utils/keyfactory.py

# Author: Trevor Perrin
# See the LICENSE file for legal information regarding use of this file.

"""Factory functions for asymmetric cryptography."""

from .compat import *

from .rsakey import RSAKey
from .python_rsakey import Python_RSAKey
from .python_ecdsakey import Python_ECDSAKey
from .python_dsakey import Python_DSAKey
from tlslite.utils import cryptomath

if cryptomath.m2cryptoLoaded:
    from .openssl_rsakey import OpenSSL_RSAKey

if cryptomath.pycryptoLoaded:
    from .pycrypto_rsakey import PyCrypto_RSAKey

# **************************************************************************
# Factory Functions for RSA Keys
# **************************************************************************

def generateRSAKey(bits, implementations=["openssl", "python"]):
    """Generate an RSA key with the specified bit length.

    :type bits: int
    :param bits: Desired bit length of the new key's modulus.

    :rtype: ~tlslite.utils.rsakey.RSAKey
    :returns: A new RSA private key.
    """
    for implementation in implementations:
        if implementation == "openssl" and cryptomath.m2cryptoLoaded:
            return OpenSSL_RSAKey.generate(bits)
        elif implementation == "python":
            return Python_RSAKey.generate(bits)
    raise ValueError("No acceptable implementations")

#Parse as an OpenSSL or Python key
def parsePEMKey(s, private=False, public=False, passwordCallback=None,
                implementations=["openssl", "python"]):
    """Parse a PEM-format key.

    The PEM format is used by OpenSSL and other tools.  The
    format is typically used to store both the public and private
    components of a key.  For example::

       -----BEGIN RSA PRIVATE KEY-----
        MIICXQIBAAKBgQDYscuoMzsGmW0pAYsmyHltxB2TdwHS0dImfjCMfaSDkfLdZY5+
        dOWORVns9etWnr194mSGA1F0Pls/VJW8+cX9+3vtJV8zSdANPYUoQf0TP7VlJxkH
        dSRkUbEoz5bAAs/+970uos7n7iXQIni+3erUTdYEk2iWnMBjTljfgbK/dQIDAQAB
        AoGAJHoJZk75aKr7DSQNYIHuruOMdv5ZeDuJvKERWxTrVJqE32/xBKh42/IgqRrc
        esBN9ZregRCd7YtxoL+EVUNWaJNVx2mNmezEznrc9zhcYUrgeaVdFO2yBF1889zO
        gCOVwrO8uDgeyj6IKa25H6c1N13ih/o7ZzEgWbGG+ylU1yECQQDv4ZSJ4EjSh/Fl
        aHdz3wbBa/HKGTjC8iRy476Cyg2Fm8MZUe9Yy3udOrb5ZnS2MTpIXt5AF3h2TfYV
        VoFXIorjAkEA50FcJmzT8sNMrPaV8vn+9W2Lu4U7C+K/O2g1iXMaZms5PC5zV5aV
        CKXZWUX1fq2RaOzlbQrpgiolhXpeh8FjxwJBAOFHzSQfSsTNfttp3KUpU0LbiVvv
        i+spVSnA0O4rq79KpVNmK44Mq67hsW1P11QzrzTAQ6GVaUBRv0YS061td1kCQHnP
        wtN2tboFR6lABkJDjxoGRvlSt4SOPr7zKGgrWjeiuTZLHXSAnCY+/hr5L9Q3ZwXG
        6x6iBdgLjVIe4BZQNtcCQQDXGv/gWinCNTN3MPWfTW/RGzuMYVmyBFais0/VrgdH
        h1dLpztmpQqfyH/zrBXQ9qL/zR4ojS6XYneO/U18WpEe
        -----END RSA PRIVATE KEY-----

    To generate a key like this with OpenSSL, run::

        openssl genrsa 2048 > key.pem

    This format also supports password-encrypted private keys.  TLS
    Lite can only handle password-encrypted private keys when OpenSSL
    and M2Crypto are installed.  In this case, passwordCallback will be
    invoked to query the user for the password.

    :type s: str
    :param s: A string containing a PEM-encoded public or private key.

    :type private: bool
    :param private: If True, a :py:class:`SyntaxError` will be raised if the
        private key component is not present.

    :type public: bool
    :param public: If True, the private key component (if present) will
        be discarded, so this function will always return a public key.

    :type passwordCallback: callable
    :param passwordCallback: This function will be called, with no
        arguments, if the PEM-encoded private key is password-encrypted.
        The callback should return the password string.  If the password is
        incorrect, SyntaxError will be raised.  If no callback is passed
        and the key is password-encrypted, a prompt will be displayed at
        the console.

    :rtype: ~tlslite.utils.rsakey.RSAKey
    :returns: An RSA key.

    :raises SyntaxError: If the key is not properly formatted.
    """
    # as old versions of openssl can't handle RSA-PSS or ECDSA keys, first
    # try to detect what kind of key it is (we ignore errors as the python
    # code can't handle encrypted key files while m2crypto/openssl can)
    key_type = "rsa"
    try:
        key = Python_RSAKey.parsePEM(s)
        key_type = key.key_type
        del key
    except Exception:
        pass

    for implementation in implementations:
        if implementation == "openssl" and cryptomath.m2cryptoLoaded \
                and key_type == "rsa":
            key = OpenSSL_RSAKey.parse(s, passwordCallback)
            break
        elif implementation == "python":
            key = Python_RSAKey.parsePEM(s)
            break
    else:
        raise ValueError("No acceptable implementations")

    return _parseKeyHelper(key, private, public)


def _parseKeyHelper(key, private, public):
    if private:
        if not key.hasPrivateKey():
            raise SyntaxError("Not a private key!")

    if public:
        return _createPublicKey(key)

    if private:
        if hasattr(key, "d"):
            return _createPrivateKey(key)
        else:
            return key

    return key

def parseAsPublicKey(s):
    """Parse a PEM-formatted public key.

    :type s: str
    :param s: A string containing a PEM-encoded public or private key.

    :rtype: ~tlslite.utils.rsakey.RSAKey
    :returns: An RSA public key.

    :raises SyntaxError: If the key is not properly formatted.
    """
    return parsePEMKey(s, public=True)

def parsePrivateKey(s):
    """Parse a PEM-formatted private key.

    :type s: str
    :param s: A string containing a PEM-encoded private key.

    :rtype: ~tlslite.utils.rsakey.RSAKey
    :returns: An RSA private key.

    :raises SyntaxError: If the key is not properly formatted.
    """
    return parsePEMKey(s, private=True)

def _createPublicKey(key):
    """
    Create a new public key.  Discard any private component,
    and return the most efficient key possible.
    """
    if not isinstance(key, RSAKey):
        raise AssertionError()
    return _createPublicRSAKey(key.n, key.e, key.key_type)

def _createPrivateKey(key):
    """
    Create a new private key.  Return the most efficient key possible.
    """
    if not isinstance(key, RSAKey):
        raise AssertionError()
    if not key.hasPrivateKey():
        raise AssertionError()
    return _createPrivateRSAKey(key.n, key.e, key.d, key.p, key.q, key.dP,
                                key.dQ, key.qInv, key.key_type)

# n, e, d, etc. are the names used in mathematical proofs for the variables
# so using so short names makes it actually more readable
# pylint: disable=invalid-name
def _createPublicRSAKey(n, e, key_type,
                        implementations=("openssl", "pycrypto", "python")):
    for implementation in implementations:
        if implementation == "openssl" and cryptomath.m2cryptoLoaded:
            return OpenSSL_RSAKey(n, e, key_type=key_type)
        elif implementation == "pycrypto" and cryptomath.pycryptoLoaded:
            return PyCrypto_RSAKey(n, e, key_type=key_type)
        elif implementation == "python":
            return Python_RSAKey(n, e, key_type=key_type)
    raise ValueError("No acceptable implementations")

def _createPrivateRSAKey(n, e, d, p, q, dP, dQ, qInv, key_type,
                         implementations=("pycrypto", "python")):
    for implementation in implementations:
        if implementation == "pycrypto" and cryptomath.pycryptoLoaded:
            return PyCrypto_RSAKey(n, e, d, p, q, dP, dQ, qInv,
                                   key_type=key_type)
        elif implementation == "python":
            return Python_RSAKey(n, e, d, p, q, dP, dQ, qInv,
                                 key_type=key_type)
    raise ValueError("No acceptable implementations")
# pylint: enable=invalid-name


def _create_public_ecdsa_key(point_x, point_y, curve_name,
                             implementations=("python",)):
    """
    Convert public key parameters into concrete implementation of verifier.

    The public key in ECDSA is a point on elliptic curve, so it consists of
    two integers that identify the point and the name of the curve on which
    it needs to lie on.

    :type point_x: int
    :param point_x: the 'x' coordinate of the point
    :type point_y: int
    :param point_y: the 'y' coordinate of the point
    :type curve_name: str
    :param curve_name: well known name of the curve (e.g. 'NIST256p' or
        'SECP256k1')
    :type implementations: iterable of str
    :param implementations: list of implementations that can be used as the
        concrete implementation of the verifying key (only 'python' is
        supported currently)
    """
    for impl in implementations:
        if impl == "python":
            return Python_ECDSAKey(point_x, point_y, curve_name)
    raise ValueError("No acceptable implementation")

def _create_public_dsa_key(p, q, g, y,
                           implementations=("python",)):
    """
    Convert public key parameters into concrete implementation of verifier.

    The public key in DSA consists of four integers.

    :type p: int
    :param p: domain parameter, prime num defining Gaolis Field
    :type q: int
    :param q: domain parameter, prime factor of p-1
    :type g: int
    :param g: domain parameter, generator of q-order cyclic group GP(p)
    :type y: int
    :param y: public key
    :type implementations: iterable of str
    :param implementations: list of implementations that can be used as the
        concrete implementation of the verifying key (only 'python' is
        supported currently)
    """
    for impl in implementations:
        if impl == "python":
            return Python_DSAKey(p=p, q=q, g=g, y=y)
    raise ValueError("No acceptable implementation")

1	# Author: Trevor Perrin
2	# See the LICENSE file for legal information regarding use of this file.
3
4	"""Factory functions for asymmetric cryptography."""	34✔
5
6	from .compat import *	34✔
7
8	from .rsakey import RSAKey	34✔
9	from .python_rsakey import Python_RSAKey	34✔
10	from .python_ecdsakey import Python_ECDSAKey	34✔
11	from .python_dsakey import Python_DSAKey	34✔
12	from tlslite.utils import cryptomath	34✔
13
14	if cryptomath.m2cryptoLoaded:	34✔
15	from .openssl_rsakey import OpenSSL_RSAKey	10✔
16
17	if cryptomath.pycryptoLoaded:	34✔
18	from .pycrypto_rsakey import PyCrypto_RSAKey	8✔
19
20	# **************************************************************************
21	# Factory Functions for RSA Keys
22	# **************************************************************************
23
24	def generateRSAKey(bits, implementations=["openssl", "python"]):	34✔
25	"""Generate an RSA key with the specified bit length.
26
27	:type bits: int
28	:param bits: Desired bit length of the new key's modulus.
29
30	:rtype: ~tlslite.utils.rsakey.RSAKey
31	:returns: A new RSA private key.
32	"""
33	for implementation in implementations:	×
34	if implementation == "openssl" and cryptomath.m2cryptoLoaded:	×
35	return OpenSSL_RSAKey.generate(bits)	×
36	elif implementation == "python":	×
37	return Python_RSAKey.generate(bits)	×
38	raise ValueError("No acceptable implementations")	×
39
40	#Parse as an OpenSSL or Python key
41	def parsePEMKey(s, private=False, public=False, passwordCallback=None,	34✔
42	implementations=["openssl", "python"]):
43	"""Parse a PEM-format key.
44
45	The PEM format is used by OpenSSL and other tools. The
46	format is typically used to store both the public and private
47	components of a key. For example::
48
49	-----BEGIN RSA PRIVATE KEY-----
50	MIICXQIBAAKBgQDYscuoMzsGmW0pAYsmyHltxB2TdwHS0dImfjCMfaSDkfLdZY5+
51	dOWORVns9etWnr194mSGA1F0Pls/VJW8+cX9+3vtJV8zSdANPYUoQf0TP7VlJxkH
52	dSRkUbEoz5bAAs/+970uos7n7iXQIni+3erUTdYEk2iWnMBjTljfgbK/dQIDAQAB
53	AoGAJHoJZk75aKr7DSQNYIHuruOMdv5ZeDuJvKERWxTrVJqE32/xBKh42/IgqRrc
54	esBN9ZregRCd7YtxoL+EVUNWaJNVx2mNmezEznrc9zhcYUrgeaVdFO2yBF1889zO
55	gCOVwrO8uDgeyj6IKa25H6c1N13ih/o7ZzEgWbGG+ylU1yECQQDv4ZSJ4EjSh/Fl
56	aHdz3wbBa/HKGTjC8iRy476Cyg2Fm8MZUe9Yy3udOrb5ZnS2MTpIXt5AF3h2TfYV
57	VoFXIorjAkEA50FcJmzT8sNMrPaV8vn+9W2Lu4U7C+K/O2g1iXMaZms5PC5zV5aV
58	CKXZWUX1fq2RaOzlbQrpgiolhXpeh8FjxwJBAOFHzSQfSsTNfttp3KUpU0LbiVvv
59	i+spVSnA0O4rq79KpVNmK44Mq67hsW1P11QzrzTAQ6GVaUBRv0YS061td1kCQHnP
60	wtN2tboFR6lABkJDjxoGRvlSt4SOPr7zKGgrWjeiuTZLHXSAnCY+/hr5L9Q3ZwXG
61	6x6iBdgLjVIe4BZQNtcCQQDXGv/gWinCNTN3MPWfTW/RGzuMYVmyBFais0/VrgdH
62	h1dLpztmpQqfyH/zrBXQ9qL/zR4ojS6XYneO/U18WpEe
63	-----END RSA PRIVATE KEY-----
64
65	To generate a key like this with OpenSSL, run::
66
67	openssl genrsa 2048 > key.pem
68
69	This format also supports password-encrypted private keys. TLS
70	Lite can only handle password-encrypted private keys when OpenSSL
71	and M2Crypto are installed. In this case, passwordCallback will be
72	invoked to query the user for the password.
73
74	:type s: str
75	:param s: A string containing a PEM-encoded public or private key.
76
77	:type private: bool
78	:param private: If True, a :py:class:`SyntaxError` will be raised if the
79	private key component is not present.
80
81	:type public: bool
82	:param public: If True, the private key component (if present) will
83	be discarded, so this function will always return a public key.
84
85	:type passwordCallback: callable
86	:param passwordCallback: This function will be called, with no
87	arguments, if the PEM-encoded private key is password-encrypted.
88	The callback should return the password string. If the password is
89	incorrect, SyntaxError will be raised. If no callback is passed
90	and the key is password-encrypted, a prompt will be displayed at
91	the console.
92
93	:rtype: ~tlslite.utils.rsakey.RSAKey
94	:returns: An RSA key.
95
96	:raises SyntaxError: If the key is not properly formatted.
97	"""
98	# as old versions of openssl can't handle RSA-PSS or ECDSA keys, first
99	# try to detect what kind of key it is (we ignore errors as the python
100	# code can't handle encrypted key files while m2crypto/openssl can)
101	key_type = "rsa"	34✔
102	try:	34✔
103	key = Python_RSAKey.parsePEM(s)	34✔
104	key_type = key.key_type	34✔
105	del key	34✔
106	except Exception:	×
107	pass	×
108
109	for implementation in implementations:	34✔
110	if implementation == "openssl" and cryptomath.m2cryptoLoaded \	34✔
111	and key_type == "rsa":
112	key = OpenSSL_RSAKey.parse(s, passwordCallback)	10✔
113	break	10✔
114	elif implementation == "python":	34✔
115	key = Python_RSAKey.parsePEM(s)	34✔
116	break	34✔
117	else:
118	raise ValueError("No acceptable implementations")	34✔
119
120	return _parseKeyHelper(key, private, public)	34✔
121
122
123	def _parseKeyHelper(key, private, public):	34✔
124	if private:	34!
125	if not key.hasPrivateKey():	34!
126	raise SyntaxError("Not a private key!")	×
127
128	if public:	34!
129	return _createPublicKey(key)	×
130
131	if private:	34!
132	if hasattr(key, "d"):	34✔
133	return _createPrivateKey(key)	34✔
134	else:
135	return key	34✔
136
137	return key	×
138
139	def parseAsPublicKey(s):	34✔
140	"""Parse a PEM-formatted public key.
141
142	:type s: str
143	:param s: A string containing a PEM-encoded public or private key.
144
145	:rtype: ~tlslite.utils.rsakey.RSAKey
146	:returns: An RSA public key.
147
148	:raises SyntaxError: If the key is not properly formatted.
149	"""
150	return parsePEMKey(s, public=True)	×
151
152	def parsePrivateKey(s):	34✔
153	"""Parse a PEM-formatted private key.
154
155	:type s: str
156	:param s: A string containing a PEM-encoded private key.
157
158	:rtype: ~tlslite.utils.rsakey.RSAKey
159	:returns: An RSA private key.
160
161	:raises SyntaxError: If the key is not properly formatted.
162	"""
163	return parsePEMKey(s, private=True)	×
164
165	def _createPublicKey(key):	34✔
166	"""
167	Create a new public key. Discard any private component,
168	and return the most efficient key possible.
169	"""
170	if not isinstance(key, RSAKey):	×
171	raise AssertionError()	×
172	return _createPublicRSAKey(key.n, key.e, key.key_type)	×
173
174	def _createPrivateKey(key):	34✔
175	"""
176	Create a new private key. Return the most efficient key possible.
177	"""
178	if not isinstance(key, RSAKey):	34!
179	raise AssertionError()	×
180	if not key.hasPrivateKey():	34!
181	raise AssertionError()	×
182	return _createPrivateRSAKey(key.n, key.e, key.d, key.p, key.q, key.dP,	34✔
183	key.dQ, key.qInv, key.key_type)
184
185	# n, e, d, etc. are the names used in mathematical proofs for the variables
186	# so using so short names makes it actually more readable
187	# pylint: disable=invalid-name
188	def _createPublicRSAKey(n, e, key_type,	34✔
189	implementations=("openssl", "pycrypto", "python")):
190	for implementation in implementations:	34!
191	if implementation == "openssl" and cryptomath.m2cryptoLoaded:	34✔
192	return OpenSSL_RSAKey(n, e, key_type=key_type)	10✔
193	elif implementation == "pycrypto" and cryptomath.pycryptoLoaded:	24✔
194	return PyCrypto_RSAKey(n, e, key_type=key_type)	4✔
195	elif implementation == "python":	24✔
196	return Python_RSAKey(n, e, key_type=key_type)	20✔
197	raise ValueError("No acceptable implementations")	×
198
199	def _createPrivateRSAKey(n, e, d, p, q, dP, dQ, qInv, key_type,	34✔
200	implementations=("pycrypto", "python")):
201	for implementation in implementations:	34!
202	if implementation == "pycrypto" and cryptomath.pycryptoLoaded:	34✔
203	return PyCrypto_RSAKey(n, e, d, p, q, dP, dQ, qInv,	8✔
204	key_type=key_type)
205	elif implementation == "python":	26✔
206	return Python_RSAKey(n, e, d, p, q, dP, dQ, qInv,	26✔
207	key_type=key_type)
208	raise ValueError("No acceptable implementations")	×
209	# pylint: enable=invalid-name
210
211
212	def _create_public_ecdsa_key(point_x, point_y, curve_name,	34✔
213	implementations=("python",)):
214	"""
215	Convert public key parameters into concrete implementation of verifier.
216
217	The public key in ECDSA is a point on elliptic curve, so it consists of
218	two integers that identify the point and the name of the curve on which
219	it needs to lie on.
220
221	:type point_x: int
222	:param point_x: the 'x' coordinate of the point
223	:type point_y: int
224	:param point_y: the 'y' coordinate of the point
225	:type curve_name: str
226	:param curve_name: well known name of the curve (e.g. 'NIST256p' or
227	'SECP256k1')
228	:type implementations: iterable of str
229	:param implementations: list of implementations that can be used as the
230	concrete implementation of the verifying key (only 'python' is
231	supported currently)
232	"""
233	for impl in implementations:	34!
234	if impl == "python":	34!
235	return Python_ECDSAKey(point_x, point_y, curve_name)	34✔
236	raise ValueError("No acceptable implementation")	×
237
238	def _create_public_dsa_key(p, q, g, y,	34✔
239	implementations=("python",)):
240	"""
241	Convert public key parameters into concrete implementation of verifier.
242
243	The public key in DSA consists of four integers.
244
245	:type p: int
246	:param p: domain parameter, prime num defining Gaolis Field
247	:type q: int
248	:param q: domain parameter, prime factor of p-1
249	:type g: int
250	:param g: domain parameter, generator of q-order cyclic group GP(p)
251	:type y: int
252	:param y: public key
253	:type implementations: iterable of str
254	:param implementations: list of implementations that can be used as the
255	concrete implementation of the verifying key (only 'python' is
256	supported currently)
257	"""
258	for impl in implementations:	34!
259	if impl == "python":	34!
260	return Python_DSAKey(p=p, q=q, g=g, y=y)	34✔
261	raise ValueError("No acceptable implementation")	×

tomato42 / tlslite-ng / 1342

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous