~stepankk/pyopenssl/bug-845445

« back to all changes in this revision

Viewing changes to OpenSSL/test/test_crypto.py

Fix exception propagation and some error handling related to the privatekey passphrase callback.

Show diffs side-by-side

added added

removed removed

Lines of Context:
7
7
 
8
8
from unittest import main
9
9
 
10
 
import os, re
 
10
import os, re, sys
11
11
from subprocess import PIPE, Popen
12
12
from datetime import datetime, timedelta
13
13
 
1979
1979
            load_privatekey, FILETYPE_PEM, encryptedPrivateKeyPEM, b("quack"))
1980
1980
 
1981
1981
 
 
1982
    def test_load_privatekey_passphraseWrongType(self):
 
1983
        """
 
1984
        :py:obj:`load_privatekey` raises :py:obj:`ValueError` when it is passed a passphrase
 
1985
        with a private key encoded in a format, that doesn't support
 
1986
        encryption.
 
1987
        """
 
1988
        key = load_privatekey(FILETYPE_PEM, cleartextPrivateKeyPEM)
 
1989
        blob = dump_privatekey(FILETYPE_ASN1, key)
 
1990
        self.assertRaises(ValueError,
 
1991
            load_privatekey, FILETYPE_ASN1, blob, "secret")
 
1992
 
 
1993
 
1982
1994
    def test_load_privatekey_passphrase(self):
1983
1995
        """
1984
1996
        :py:obj:`load_privatekey` can create a :py:obj:`PKey` object from an encrypted PEM
1990
2002
        self.assertTrue(isinstance(key, PKeyType))
1991
2003
 
1992
2004
 
 
2005
    def test_load_privatekey_passphrase_exception(self):
 
2006
        """
 
2007
        If the passphrase callback raises an exception, that exception is raised
 
2008
        by :py:obj:`load_privatekey`.
 
2009
        """
 
2010
        def cb(ignored):
 
2011
            raise ArithmeticError
 
2012
 
 
2013
        self.assertRaises(ArithmeticError,
 
2014
            load_privatekey, FILETYPE_PEM, encryptedPrivateKeyPEM, cb)
 
2015
 
 
2016
 
1993
2017
    def test_load_privatekey_wrongPassphraseCallback(self):
1994
2018
        """
1995
 
        :py:obj:`load_privatekey` raises :py:obj:`OpenSSL.crypto.Error` when it is passed an
1996
 
        encrypted PEM and a passphrase callback which returns an incorrect
1997
 
        passphrase.
 
2019
        :py:obj:`load_privatekey` raises :py:obj:`OpenSSL.crypto.Error` when it
 
2020
        is passed an encrypted PEM and a passphrase callback which returns an
 
2021
        incorrect passphrase.
1998
2022
        """
1999
2023
        called = []
2000
2024
        def cb(*a):
2001
2025
            called.append(None)
2002
 
            return "quack"
 
2026
            return b("quack")
2003
2027
        self.assertRaises(
2004
2028
            Error,
2005
2029
            load_privatekey, FILETYPE_PEM, encryptedPrivateKeyPEM, cb)
2021
2045
        self.assertEqual(called, [False])
2022
2046
 
2023
2047
 
2024
 
    def test_load_privatekey_passphrase_exception(self):
2025
 
        """
2026
 
        An exception raised by the passphrase callback passed to
2027
 
        :py:obj:`load_privatekey` causes :py:obj:`OpenSSL.crypto.Error` to be raised.
2028
 
 
2029
 
        This isn't as nice as just letting the exception pass through.  The
2030
 
        behavior might be changed to that eventually.
2031
 
        """
2032
 
        def broken(ignored):
2033
 
            raise RuntimeError("This is not working.")
 
2048
    def test_load_privatekey_passphrase_wrong_return_type(self):
 
2049
        """
 
2050
        :py:obj:`load_privatekey` raises :py:obj:`ValueError` if the passphrase
 
2051
        callback returns something other than a byte string.
 
2052
        """
2034
2053
        self.assertRaises(
2035
 
            Error,
 
2054
            ValueError,
2036
2055
            load_privatekey,
2037
 
            FILETYPE_PEM, encryptedPrivateKeyPEM, broken)
 
2056
            FILETYPE_PEM, encryptedPrivateKeyPEM, lambda *args: 3)
2038
2057
 
2039
2058
 
2040
2059
    def test_dump_privatekey_wrong_args(self):
2043
2062
        of arguments.
2044
2063
        """
2045
2064
        self.assertRaises(TypeError, dump_privatekey)
 
2065
        # If cipher name is given, password is required.
 
2066
        self.assertRaises(
 
2067
            ValueError, dump_privatekey, FILETYPE_PEM, PKey(), "foo")
2046
2068
 
2047
2069
 
2048
2070
    def test_dump_privatekey_unknown_cipher(self):
2079
2101
        self.assertRaises(ValueError, dump_privatekey, 100, key)
2080
2102
 
2081
2103
 
 
2104
    def test_load_privatekey_passphraseCallbackLength(self):
 
2105
        """
 
2106
        :py:obj:`crypto.load_privatekey` should raise an error when the passphrase
 
2107
        provided by the callback is too long, not silently truncate it.
 
2108
        """
 
2109
        def cb(ignored):
 
2110
            return "a" * 1025
 
2111
 
 
2112
        self.assertRaises(ValueError,
 
2113
            load_privatekey, FILETYPE_PEM, encryptedPrivateKeyPEM, cb)
 
2114
 
 
2115
 
2082
2116
    def test_dump_privatekey_passphrase(self):
2083
2117
        """
2084
2118
        :py:obj:`dump_privatekey` writes an encrypted PEM when given a passphrase.
2093
2127
        self.assertEqual(loadedKey.bits(), key.bits())
2094
2128
 
2095
2129
 
 
2130
    def test_dump_privatekey_passphraseWrongType(self):
 
2131
        """
 
2132
        :py:obj:`dump_privatekey` raises :py:obj:`ValueError` when it is passed a passphrase
 
2133
        with a private key encoded in a format, that doesn't support
 
2134
        encryption.
 
2135
        """
 
2136
        key = load_privatekey(FILETYPE_PEM, cleartextPrivateKeyPEM)
 
2137
        self.assertRaises(ValueError,
 
2138
            dump_privatekey, FILETYPE_ASN1, key, "blowfish", "secret")
 
2139
 
 
2140
 
2096
2141
    def test_dump_certificate(self):
2097
2142
        """
2098
2143
        :py:obj:`dump_certificate` writes PEM, DER, and text.
2171
2216
        self.assertEqual(loadedKey.bits(), key.bits())
2172
2217
 
2173
2218
 
 
2219
    def test_dump_privatekey_passphrase_exception(self):
 
2220
        """
 
2221
        :py:obj:`dump_privatekey` should not overwrite the exception raised
 
2222
        by the passphrase callback.
 
2223
        """
 
2224
        def cb(ignored):
 
2225
            raise ArithmeticError
 
2226
 
 
2227
        key = load_privatekey(FILETYPE_PEM, cleartextPrivateKeyPEM)
 
2228
        self.assertRaises(ArithmeticError,
 
2229
            dump_privatekey, FILETYPE_PEM, key, "blowfish", cb)
 
2230
 
 
2231
 
 
2232
    def test_dump_privatekey_passphraseCallbackLength(self):
 
2233
        """
 
2234
        :py:obj:`crypto.dump_privatekey` should raise an error when the passphrase
 
2235
        provided by the callback is too long, not silently truncate it.
 
2236
        """
 
2237
        def cb(ignored):
 
2238
            return "a" * 1025
 
2239
 
 
2240
        key = load_privatekey(FILETYPE_PEM, cleartextPrivateKeyPEM)
 
2241
        self.assertRaises(ValueError,
 
2242
            dump_privatekey, FILETYPE_PEM, key, "blowfish", cb)
 
2243
 
 
2244
 
2174
2245
    def test_load_pkcs7_data(self):
2175
2246
        """
2176
2247
        :py:obj:`load_pkcs7_data` accepts a PKCS#7 string and returns an instance of