python3 update
This commit is contained in:
shim_
@@ -1,163 +0,0 @@
|
||||
# -*- coding: ascii -*-
|
||||
#
|
||||
# Util/PEM.py : Privacy Enhanced Mail utilities
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
"""Set of functions for encapsulating data according to the PEM format.
|
||||
|
||||
PEM (Privacy Enhanced Mail) was an IETF standard for securing emails via a
|
||||
Public Key Infrastructure. It is specified in RFC 1421-1424.
|
||||
|
||||
Even though it has been abandoned, the simple message encapsulation it defined
|
||||
is still widely used today for encoding *binary* cryptographic objects like
|
||||
keys and certificates into text.
|
||||
"""
|
||||
|
||||
__all__ = ['encode', 'decode']
|
||||
|
||||
import sys
|
||||
if sys.version_info[0] == 2 and sys.version_info[1] == 1:
|
||||
from Crypto.Util.py21compat import *
|
||||
from Crypto.Util.py3compat import *
|
||||
|
||||
import re
|
||||
from binascii import hexlify, unhexlify, a2b_base64, b2a_base64
|
||||
|
||||
from Crypto.Hash import MD5
|
||||
from Crypto.Util.Padding import pad, unpad
|
||||
from Crypto.Cipher import DES, DES3, AES
|
||||
from Crypto.Protocol.KDF import PBKDF1
|
||||
from Crypto.Random import get_random_bytes
|
||||
|
||||
|
||||
def encode(data, marker, passphrase=None, randfunc=None):
|
||||
"""Encode a piece of binary data into PEM format.
|
||||
|
||||
:Parameters:
|
||||
data : byte string
|
||||
The piece of binary data to encode.
|
||||
marker : string
|
||||
The marker for the PEM block (e.g. "PUBLIC KEY").
|
||||
Note that there is no official master list for all allowed markers.
|
||||
Still, you can refer to the OpenSSL_ source code.
|
||||
passphrase : byte string
|
||||
If given, the PEM block will be encrypted. The key is derived from
|
||||
the passphrase.
|
||||
randfunc : callable
|
||||
Random number generation function; it accepts an integer N and returns
|
||||
a byte string of random data, N bytes long. If not given, a new one is
|
||||
instantiated.
|
||||
:Returns:
|
||||
The PEM block, as a string.
|
||||
|
||||
.. _OpenSSL: http://cvs.openssl.org/fileview?f=openssl/crypto/pem/pem.h&v=1.66.2.1.4.2
|
||||
"""
|
||||
|
||||
if randfunc is None:
|
||||
randfunc = get_random_bytes
|
||||
|
||||
out = "-----BEGIN %s-----\n" % marker
|
||||
if passphrase:
|
||||
# We only support 3DES for encryption
|
||||
salt = randfunc(8)
|
||||
key = PBKDF1(passphrase, salt, 16, 1, MD5)
|
||||
key += PBKDF1(key + passphrase, salt, 8, 1, MD5)
|
||||
objenc = DES3.new(key, DES3.MODE_CBC, salt)
|
||||
out += "Proc-Type: 4,ENCRYPTED\nDEK-Info: DES-EDE3-CBC,%s\n\n" %\
|
||||
tostr(hexlify(salt).upper())
|
||||
# Encrypt with PKCS#7 padding
|
||||
data = objenc.encrypt(pad(data, objenc.block_size))
|
||||
|
||||
# Each BASE64 line can take up to 64 characters (=48 bytes of data)
|
||||
# b2a_base64 adds a new line character!
|
||||
chunks = [tostr(b2a_base64(data[i:i + 48]))
|
||||
for i in range(0, len(data), 48)]
|
||||
out += "".join(chunks)
|
||||
out += "-----END %s-----" % marker
|
||||
return out
|
||||
|
||||
|
||||
def decode(pem_data, passphrase=None):
|
||||
"""Decode a PEM block into binary.
|
||||
|
||||
:Parameters:
|
||||
pem_data : string
|
||||
The PEM block.
|
||||
passphrase : byte string
|
||||
If given and the PEM block is encrypted,
|
||||
the key will be derived from the passphrase.
|
||||
:Returns:
|
||||
A tuple with the binary data, the marker string, and a boolean to
|
||||
indicate if decryption was performed.
|
||||
:Raises ValueError:
|
||||
If decoding fails, if the PEM file is encrypted and no passphrase has
|
||||
been provided or if the passphrase is incorrect.
|
||||
"""
|
||||
|
||||
# Verify Pre-Encapsulation Boundary
|
||||
r = re.compile("\s*-----BEGIN (.*)-----\n")
|
||||
m = r.match(pem_data)
|
||||
if not m:
|
||||
raise ValueError("Not a valid PEM pre boundary")
|
||||
marker = m.group(1)
|
||||
|
||||
# Verify Post-Encapsulation Boundary
|
||||
r = re.compile("-----END (.*)-----\s*$")
|
||||
m = r.search(pem_data)
|
||||
if not m or m.group(1) != marker:
|
||||
raise ValueError("Not a valid PEM post boundary")
|
||||
|
||||
# Removes spaces and slit on lines
|
||||
lines = pem_data.replace(" ", '').split()
|
||||
|
||||
# Decrypts, if necessary
|
||||
if lines[1].startswith('Proc-Type:4,ENCRYPTED'):
|
||||
if not passphrase:
|
||||
raise ValueError("PEM is encrypted, but no passphrase available")
|
||||
DEK = lines[2].split(':')
|
||||
if len(DEK) != 2 or DEK[0] != 'DEK-Info':
|
||||
raise ValueError("PEM encryption format not supported.")
|
||||
algo, salt = DEK[1].split(',')
|
||||
salt = unhexlify(tobytes(salt))
|
||||
if algo == "DES-CBC":
|
||||
# This is EVP_BytesToKey in OpenSSL
|
||||
key = PBKDF1(passphrase, salt, 8, 1, MD5)
|
||||
objdec = DES.new(key, DES.MODE_CBC, salt)
|
||||
elif algo == "DES-EDE3-CBC":
|
||||
# Note that EVP_BytesToKey is note exactly the same as PBKDF1
|
||||
key = PBKDF1(passphrase, salt, 16, 1, MD5)
|
||||
key += PBKDF1(key + passphrase, salt, 8, 1, MD5)
|
||||
objdec = DES3.new(key, DES3.MODE_CBC, salt)
|
||||
elif algo == "AES-128-CBC":
|
||||
key = PBKDF1(passphrase, salt[:8], 16, 1, MD5)
|
||||
objdec = AES.new(key, AES.MODE_CBC, salt)
|
||||
else:
|
||||
raise ValueError("Unsupport PEM encryption algorithm.")
|
||||
lines = lines[2:]
|
||||
else:
|
||||
objdec = None
|
||||
|
||||
# Decode body
|
||||
data = a2b_base64(b(''.join(lines[1:-1])))
|
||||
enc_flag = False
|
||||
if objdec:
|
||||
data = unpad(objdec.decrypt(data), objdec.block_size)
|
||||
enc_flag = True
|
||||
|
||||
return (data, marker, enc_flag)
|
||||
@@ -1,209 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# PublicKey/PKCS8.py : PKCS#8 functions
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
"""
|
||||
Module for handling private keys wrapped according to `PKCS#8`_.
|
||||
|
||||
PKCS8 is a standard for storing and transferring private key information.
|
||||
The wrapped key can either be clear or encrypted.
|
||||
|
||||
All encryption algorithms are based on passphrase-based key derivation.
|
||||
The following mechanisms are fully supported:
|
||||
|
||||
* *PBKDF2WithHMAC-SHA1AndAES128-CBC*
|
||||
* *PBKDF2WithHMAC-SHA1AndAES192-CBC*
|
||||
* *PBKDF2WithHMAC-SHA1AndAES256-CBC*
|
||||
* *PBKDF2WithHMAC-SHA1AndDES-EDE3-CBC*
|
||||
|
||||
The following mechanisms are only supported for importing keys.
|
||||
They are much weaker than the ones listed above, and they are provided
|
||||
for backward compatibility only:
|
||||
|
||||
* *pbeWithMD5AndRC2-CBC*
|
||||
* *pbeWithMD5AndDES-CBC*
|
||||
* *pbeWithSHA1AndRC2-CBC*
|
||||
* *pbeWithSHA1AndDES-CBC*
|
||||
|
||||
.. _`PKCS#8`: http://www.ietf.org/rfc/rfc5208.txt
|
||||
|
||||
"""
|
||||
|
||||
import sys
|
||||
|
||||
if sys.version_info[0] == 2 and sys.version_info[1] == 1:
|
||||
from Crypto.Util.py21compat import *
|
||||
from Crypto.Util.py3compat import *
|
||||
|
||||
from Crypto.Util.asn1 import *
|
||||
|
||||
from Crypto.IO._PBES import PBES1, PBES2
|
||||
|
||||
__all__ = ['wrap', 'unwrap']
|
||||
|
||||
|
||||
def decode_der(obj_class, binstr):
|
||||
"""Instantiate a DER object class, decode a DER binary string in it, and
|
||||
return the object."""
|
||||
der = obj_class()
|
||||
der.decode(binstr)
|
||||
return der
|
||||
|
||||
|
||||
def wrap(private_key, key_oid, passphrase=None, protection=None,
|
||||
prot_params=None, key_params=None, randfunc=None):
|
||||
"""Wrap a private key into a PKCS#8 blob (clear or encrypted).
|
||||
|
||||
:Parameters:
|
||||
|
||||
private_key : byte string
|
||||
The private key encoded in binary form. The actual encoding is
|
||||
algorithm specific. In most cases, it is DER.
|
||||
|
||||
key_oid : string
|
||||
The object identifier (OID) of the private key to wrap.
|
||||
It is a dotted string, like "``1.2.840.113549.1.1.1``" (for RSA keys).
|
||||
|
||||
passphrase : (binary) string
|
||||
The secret passphrase from which the wrapping key is derived.
|
||||
Set it only if encryption is required.
|
||||
|
||||
protection : string
|
||||
The identifier of the algorithm to use for securely wrapping the key.
|
||||
The default value is '``PBKDF2WithHMAC-SHA1AndDES-EDE3-CBC``'.
|
||||
|
||||
prot_params : dictionary
|
||||
Parameters for the protection algorithm.
|
||||
|
||||
+------------------+-----------------------------------------------+
|
||||
| Key | Description |
|
||||
+==================+===============================================+
|
||||
| iteration_count | The KDF algorithm is repeated several times to|
|
||||
| | slow down brute force attacks on passwords. |
|
||||
| | The default value is 1 000. |
|
||||
+------------------+-----------------------------------------------+
|
||||
| salt_size | Salt is used to thwart dictionary and rainbow |
|
||||
| | attacks on passwords. The default value is 8 |
|
||||
| | bytes. |
|
||||
+------------------+-----------------------------------------------+
|
||||
|
||||
key_params : DER object
|
||||
The algorithm parameters associated to the private key.
|
||||
It is required for algorithms like DSA, but not for others like RSA.
|
||||
|
||||
randfunc : callable
|
||||
Random number generation function; it should accept a single integer
|
||||
N and return a string of random data, N bytes long.
|
||||
If not specified, a new RNG will be instantiated
|
||||
from ``Crypto.Random``.
|
||||
|
||||
:Return:
|
||||
The PKCS#8-wrapped private key (possibly encrypted),
|
||||
as a binary string.
|
||||
"""
|
||||
|
||||
if key_params is None:
|
||||
key_params = DerNull()
|
||||
|
||||
#
|
||||
# PrivateKeyInfo ::= SEQUENCE {
|
||||
# version Version,
|
||||
# privateKeyAlgorithm PrivateKeyAlgorithmIdentifier,
|
||||
# privateKey PrivateKey,
|
||||
# attributes [0] IMPLICIT Attributes OPTIONAL
|
||||
# }
|
||||
#
|
||||
pk_info = newDerSequence(
|
||||
0,
|
||||
newDerSequence(
|
||||
DerObjectId(key_oid),
|
||||
key_params
|
||||
),
|
||||
newDerOctetString(private_key)
|
||||
)
|
||||
pk_info_der = pk_info.encode()
|
||||
|
||||
if not passphrase:
|
||||
return pk_info_der
|
||||
|
||||
# Encryption with PBES2
|
||||
passphrase = tobytes(passphrase)
|
||||
if protection is None:
|
||||
protection = 'PBKDF2WithHMAC-SHA1AndDES-EDE3-CBC'
|
||||
return PBES2.encrypt(pk_info_der, passphrase,
|
||||
protection, prot_params, randfunc)
|
||||
|
||||
|
||||
def unwrap(p8_private_key, passphrase=None):
|
||||
"""Unwrap a private key from a PKCS#8 blob (clear or encrypted).
|
||||
|
||||
:Parameters:
|
||||
p8_private_key : byte string
|
||||
The private key wrapped into a PKCS#8 blob
|
||||
passphrase : (byte) string
|
||||
The passphrase to use to decrypt the blob (if it is encrypted).
|
||||
:Return:
|
||||
A tuple containing:
|
||||
|
||||
#. the algorithm identifier of the wrapped key (OID, dotted string)
|
||||
#. the private key (byte string, DER encoded)
|
||||
#. the associated parameters (byte string, DER encoded) or ``None``
|
||||
|
||||
:Raises ValueError:
|
||||
If decoding fails
|
||||
"""
|
||||
|
||||
if passphrase:
|
||||
passphrase = tobytes(passphrase)
|
||||
found = False
|
||||
for pbes in PBES1, PBES2:
|
||||
try:
|
||||
p8_private_key = pbes.decrypt(p8_private_key, passphrase)
|
||||
except ValueError:
|
||||
pass
|
||||
else:
|
||||
found = True
|
||||
break
|
||||
if not found:
|
||||
raise ValueError("Unsupported PKCS#5 Object ID ")
|
||||
|
||||
pk_info = decode_der(DerSequence, p8_private_key)
|
||||
if len(pk_info) == 2 and not passphrase:
|
||||
raise ValueError("Not a valid clear PKCS#8 structure "
|
||||
"(maybe it is encrypted?)")
|
||||
if not 3 <= len(pk_info) <= 4 or pk_info[0] != 0:
|
||||
raise ValueError("Not a valid PrivateKeyInfo SEQUENCE")
|
||||
|
||||
#
|
||||
# AlgorithmIdentifier ::= SEQUENCE {
|
||||
# algorithm OBJECT IDENTIFIER,
|
||||
# parameters ANY DEFINED BY algorithm OPTIONAL
|
||||
# }
|
||||
#
|
||||
algo_id = decode_der(DerSequence, pk_info[1])
|
||||
if not 1 <= len(algo_id) <= 2:
|
||||
raise ValueError("Not a valid AlgorithmIdentifier SEQUENCE")
|
||||
algo = decode_der(DerObjectId, algo_id[0]).value
|
||||
private_key = decode_der(DerOctetString, pk_info[2]).payload
|
||||
if len(algo_id) == 2 and algo_id[1] != b('\x05\x00'):
|
||||
params = algo_id[1]
|
||||
else:
|
||||
params = None
|
||||
return (algo, private_key, params)
|
||||
@@ -1,348 +0,0 @@
|
||||
#
|
||||
# PublicKey/_PBES.py : Password-Based Encryption functions
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
|
||||
import sys
|
||||
if sys.version_info[0] == 2 and sys.version_info[1] == 1:
|
||||
from Crypto.Util.py21compat import *
|
||||
from Crypto.Util.py3compat import *
|
||||
|
||||
from Crypto import Random
|
||||
from Crypto.Util.asn1 import *
|
||||
|
||||
from Crypto.Util.Padding import pad, unpad
|
||||
from Crypto.Hash import MD5, SHA1
|
||||
from Crypto.Cipher import DES, ARC2, DES3, AES
|
||||
from Crypto.Protocol.KDF import PBKDF1, PBKDF2
|
||||
|
||||
|
||||
# These are the ASN.1 definitions used by the PBES1/2 logic:
|
||||
#
|
||||
# EncryptedPrivateKeyInfo ::= SEQUENCE {
|
||||
# encryptionAlgorithm EncryptionAlgorithmIdentifier,
|
||||
# encryptedData EncryptedData
|
||||
# }
|
||||
#
|
||||
# EncryptionAlgorithmIdentifier ::= AlgorithmIdentifier
|
||||
#
|
||||
# EncryptedData ::= OCTET STRING
|
||||
#
|
||||
# AlgorithmIdentifier ::= SEQUENCE {
|
||||
# algorithm OBJECT IDENTIFIER,
|
||||
# parameters ANY DEFINED BY algorithm OPTIONAL
|
||||
# }
|
||||
#
|
||||
# PBEParameter ::= SEQUENCE {
|
||||
# salt OCTET STRING (SIZE(8)),
|
||||
# iterationCount INTEGER
|
||||
# }
|
||||
#
|
||||
# PBES2-params ::= SEQUENCE {
|
||||
# keyDerivationFunc AlgorithmIdentifier {{PBES2-KDFs}},
|
||||
# encryptionScheme AlgorithmIdentifier {{PBES2-Encs}}
|
||||
# }
|
||||
#
|
||||
# PBKDF2-params ::= SEQUENCE {
|
||||
# salt CHOICE {
|
||||
# specified OCTET STRING,
|
||||
# otherSource AlgorithmIdentifier {{PBKDF2-SaltSources}}
|
||||
# },
|
||||
# iterationCount INTEGER (1..MAX),
|
||||
# keyLength INTEGER (1..MAX) OPTIONAL,
|
||||
# prf AlgorithmIdentifier {{PBKDF2-PRFs}} DEFAULT algid-hmacWithSHA1
|
||||
# }
|
||||
#
|
||||
|
||||
|
||||
def decode_der(obj_class, binstr):
|
||||
"""Instantiate a DER object class, decode a DER binary string in it, and
|
||||
return the object."""
|
||||
der = obj_class()
|
||||
der.decode(binstr)
|
||||
return der
|
||||
|
||||
|
||||
class PBES1(object):
|
||||
"""Deprecated encryption scheme with password-based key derivation
|
||||
(originally defined in PKCS#5 v1.5, but still present in `v2.0`__).
|
||||
|
||||
.. __: http://www.ietf.org/rfc/rfc2898.txt
|
||||
"""
|
||||
|
||||
def decrypt(data, passphrase):
|
||||
"""Decrypt a piece of data using a passphrase and *PBES1*.
|
||||
|
||||
The algorithm to use is automatically detected.
|
||||
|
||||
:Parameters:
|
||||
data : byte string
|
||||
The piece of data to decrypt.
|
||||
passphrase : byte string
|
||||
The passphrase to use for decrypting the data.
|
||||
:Returns:
|
||||
The decrypted data, as a binary string.
|
||||
"""
|
||||
|
||||
encrypted_private_key_info = decode_der(DerSequence, data)
|
||||
encrypted_algorithm = decode_der(
|
||||
DerSequence,
|
||||
encrypted_private_key_info[0]
|
||||
)
|
||||
encrypted_data = decode_der(
|
||||
DerOctetString,
|
||||
encrypted_private_key_info[1]
|
||||
).payload
|
||||
|
||||
pbe_oid = decode_der(DerObjectId, encrypted_algorithm[0]).value
|
||||
cipher_params = {}
|
||||
if pbe_oid == "1.2.840.113549.1.5.3":
|
||||
# PBE_MD5_DES_CBC
|
||||
hashmod = MD5
|
||||
ciphermod = DES
|
||||
elif pbe_oid == "1.2.840.113549.1.5.6":
|
||||
# PBE_MD5_RC2_CBC
|
||||
hashmod = MD5
|
||||
ciphermod = ARC2
|
||||
cipher_params['effective_keylen'] = 64
|
||||
elif pbe_oid == "1.2.840.113549.1.5.10":
|
||||
# PBE_SHA1_DES_CBC
|
||||
hashmod = SHA1
|
||||
ciphermod = DES
|
||||
elif pbe_oid == "1.2.840.113549.1.5.11":
|
||||
# PBE_SHA1_RC2_CBC
|
||||
hashmod = SHA1
|
||||
ciphermod = ARC2
|
||||
cipher_params['effective_keylen'] = 64
|
||||
else:
|
||||
raise ValueError("Unknown OID")
|
||||
|
||||
pbe_params = decode_der(DerSequence, encrypted_algorithm[1])
|
||||
salt = decode_der(DerOctetString, pbe_params[0]).payload
|
||||
iterations = pbe_params[1]
|
||||
|
||||
key_iv = PBKDF1(passphrase, salt, 16, iterations, hashmod)
|
||||
key, iv = key_iv[:8], key_iv[8:]
|
||||
|
||||
cipher = ciphermod.new(key, ciphermod.MODE_CBC, iv, **cipher_params)
|
||||
pt = cipher.decrypt(encrypted_data)
|
||||
return unpad(pt, cipher.block_size)
|
||||
decrypt = staticmethod(decrypt)
|
||||
|
||||
|
||||
class PBES2(object):
|
||||
"""Encryption scheme with password-based key derivation
|
||||
(defined in `PKCS#5 v2.0`__).
|
||||
|
||||
.. __: http://www.ietf.org/rfc/rfc2898.txt."""
|
||||
|
||||
def encrypt(data, passphrase, protection, prot_params=None, randfunc=None):
|
||||
"""Encrypt a piece of data using a passphrase and *PBES2*.
|
||||
|
||||
:Parameters:
|
||||
data : byte string
|
||||
The piece of data to encrypt.
|
||||
passphrase : byte string
|
||||
The passphrase to use for encrypting the data.
|
||||
protection : string
|
||||
The identifier of the encryption algorithm to use.
|
||||
The default value is '``PBKDF2WithHMAC-SHA1AndDES-EDE3-CBC``'.
|
||||
prot_params : dictionary
|
||||
Parameters of the protection algorithm.
|
||||
|
||||
+------------------+-----------------------------------------------+
|
||||
| Key | Description |
|
||||
+==================+===============================================+
|
||||
| iteration_count | The KDF algorithm is repeated several times to|
|
||||
| | slow down brute force attacks on passwords. |
|
||||
| | The default value is 1 000. |
|
||||
+------------------+-----------------------------------------------+
|
||||
| salt_size | Salt is used to thwart dictionary and rainbow |
|
||||
| | attacks on passwords. The default value is 8 |
|
||||
| | bytes. |
|
||||
+------------------+-----------------------------------------------+
|
||||
|
||||
randfunc : callable
|
||||
Random number generation function; it should accept
|
||||
a single integer N and return a string of random data,
|
||||
N bytes long. If not specified, a new RNG will be
|
||||
instantiated from ``Crypto.Random``.
|
||||
|
||||
:Returns:
|
||||
The encrypted data, as a binary string.
|
||||
"""
|
||||
|
||||
if prot_params is None:
|
||||
prot_params = {}
|
||||
|
||||
if randfunc is None:
|
||||
randfunc = Random.new().read
|
||||
|
||||
if protection == 'PBKDF2WithHMAC-SHA1AndDES-EDE3-CBC':
|
||||
key_size = 24
|
||||
module = DES3
|
||||
protection = DES3.MODE_CBC
|
||||
enc_oid = "1.2.840.113549.3.7"
|
||||
elif protection == 'PBKDF2WithHMAC-SHA1AndAES128-CBC':
|
||||
key_size = 16
|
||||
module = AES
|
||||
protection = AES.MODE_CBC
|
||||
enc_oid = "2.16.840.1.101.3.4.1.2"
|
||||
elif protection == 'PBKDF2WithHMAC-SHA1AndAES192-CBC':
|
||||
key_size = 24
|
||||
module = AES
|
||||
protection = AES.MODE_CBC
|
||||
enc_oid = "2.16.840.1.101.3.4.1.22"
|
||||
elif protection == 'PBKDF2WithHMAC-SHA1AndAES256-CBC':
|
||||
key_size = 32
|
||||
module = AES
|
||||
protection = AES.MODE_CBC
|
||||
enc_oid = "2.16.840.1.101.3.4.1.42"
|
||||
else:
|
||||
raise ValueError("Unknown mode")
|
||||
|
||||
# Get random data
|
||||
iv = randfunc(module.block_size)
|
||||
salt = randfunc(prot_params.get("salt_size", 8))
|
||||
|
||||
# Derive key from password
|
||||
count = prot_params.get("iteration_count", 1000)
|
||||
key = PBKDF2(passphrase, salt, key_size, count)
|
||||
key_derivation_func = newDerSequence(
|
||||
DerObjectId("1.2.840.113549.1.5.12"), # PBKDF2
|
||||
newDerSequence(
|
||||
DerOctetString(salt),
|
||||
DerInteger(count)
|
||||
)
|
||||
)
|
||||
|
||||
# Create cipher and use it
|
||||
cipher = module.new(key, protection, iv)
|
||||
encrypted_data = cipher.encrypt(pad(data, cipher.block_size))
|
||||
encryption_scheme = newDerSequence(
|
||||
DerObjectId(enc_oid),
|
||||
DerOctetString(iv)
|
||||
)
|
||||
|
||||
# Result
|
||||
encrypted_private_key_info = newDerSequence(
|
||||
# encryptionAlgorithm
|
||||
newDerSequence(
|
||||
DerObjectId("1.2.840.113549.1.5.13"), # PBES2
|
||||
newDerSequence(
|
||||
key_derivation_func,
|
||||
encryption_scheme
|
||||
),
|
||||
),
|
||||
DerOctetString(encrypted_data)
|
||||
)
|
||||
return encrypted_private_key_info.encode()
|
||||
encrypt = staticmethod(encrypt)
|
||||
|
||||
def decrypt(data, passphrase):
|
||||
"""Decrypt a piece of data using a passphrase and *PBES2*.
|
||||
|
||||
The algorithm to use is automatically detected.
|
||||
|
||||
:Parameters:
|
||||
data : byte string
|
||||
The piece of data to decrypt.
|
||||
passphrase : byte string
|
||||
The passphrase to use for decrypting the data.
|
||||
:Returns:
|
||||
The decrypted data, as a binary string.
|
||||
"""
|
||||
|
||||
encrypted_private_key_info = decode_der(DerSequence, data)
|
||||
encryption_algorithm = decode_der(
|
||||
DerSequence,
|
||||
encrypted_private_key_info[0]
|
||||
)
|
||||
encrypted_data = decode_der(
|
||||
DerOctetString,
|
||||
encrypted_private_key_info[1]
|
||||
).payload
|
||||
|
||||
pbe_oid = decode_der(DerObjectId, encryption_algorithm[0]).value
|
||||
if pbe_oid != "1.2.840.113549.1.5.13":
|
||||
raise ValueError("Not a PBES2 object")
|
||||
|
||||
pbes2_params = decode_der(DerSequence, encryption_algorithm[1])
|
||||
|
||||
### Key Derivation Function selection
|
||||
key_derivation_func = decode_der(DerSequence, pbes2_params[0])
|
||||
key_derivation_oid = decode_der(
|
||||
DerObjectId,
|
||||
key_derivation_func[0]
|
||||
).value
|
||||
|
||||
# For now, we only support PBKDF2
|
||||
if key_derivation_oid != "1.2.840.113549.1.5.12":
|
||||
raise ValueError("Unknown KDF")
|
||||
|
||||
pbkdf2_params = decode_der(DerSequence, key_derivation_func[1])
|
||||
salt = decode_der(DerOctetString, pbkdf2_params[0]).payload
|
||||
iteration_count = pbkdf2_params[1]
|
||||
if len(pbkdf2_params) > 2:
|
||||
pbkdf2_key_length = pbkdf2_params[2]
|
||||
else:
|
||||
pbkdf2_key_length = None
|
||||
if len(pbkdf2_params) > 3:
|
||||
raise ValueError("Unsupported PRF for PBKDF2")
|
||||
|
||||
### Cipher selection
|
||||
encryption_scheme = decode_der(DerSequence, pbes2_params[1])
|
||||
encryption_oid = decode_der(
|
||||
DerObjectId,
|
||||
encryption_scheme[0]
|
||||
).value
|
||||
|
||||
if encryption_oid == "1.2.840.113549.3.7":
|
||||
# DES_EDE3_CBC
|
||||
ciphermod = DES3
|
||||
key_size = 24
|
||||
elif encryption_oid == "2.16.840.1.101.3.4.1.2":
|
||||
# AES128_CBC
|
||||
ciphermod = AES
|
||||
key_size = 16
|
||||
elif encryption_oid == "2.16.840.1.101.3.4.1.22":
|
||||
# AES192_CBC
|
||||
ciphermod = AES
|
||||
key_size = 24
|
||||
elif encryption_oid == "2.16.840.1.101.3.4.1.42":
|
||||
# AES256_CBC
|
||||
ciphermod = AES
|
||||
key_size = 32
|
||||
else:
|
||||
raise ValueError("Unsupported cipher")
|
||||
|
||||
if pbkdf2_key_length and pbkdf2_key_length != key_size:
|
||||
raise ValueError("Mismatch between PBKDF2 parameters"
|
||||
" and selected cipher")
|
||||
|
||||
IV = decode_der(DerOctetString, encryption_scheme[1]).payload
|
||||
|
||||
# Create cipher
|
||||
key = PBKDF2(passphrase, salt, key_size, iteration_count)
|
||||
cipher = ciphermod.new(key, ciphermod.MODE_CBC, IV)
|
||||
|
||||
# Decrypt data
|
||||
pt = cipher.decrypt(encrypted_data)
|
||||
return unpad(pt, cipher.block_size)
|
||||
decrypt = staticmethod(decrypt)
|
||||
@@ -1,32 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
|
||||
"""
|
||||
Modules for reading and writing cryptographic data.
|
||||
|
||||
======================== =============================================
|
||||
Module Description
|
||||
======================== =============================================
|
||||
Crypto.Util.PEM Set of functions for encapsulating data according to the PEM format.
|
||||
Crypto.Util.PKCS8 Set of functions for wrapping/unwrapping private keys.
|
||||
======================== =============================================
|
||||
"""
|
||||
|
||||
__all__ = ['PEM', 'PKCS8']
|
||||
Reference in New Issue
Block a user