Updated DB_Helper by adding firebase methods.
This commit is contained in:
parent
485cc3bbba
commit
c82121d036
1810 changed files with 537281 additions and 1 deletions
717
venv/Lib/site-packages/Crypto/PublicKey/DSA.py
Normal file
717
venv/Lib/site-packages/Crypto/PublicKey/DSA.py
Normal file
|
|
@ -0,0 +1,717 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# PublicKey/DSA.py : DSA signature primitive
|
||||
#
|
||||
# Written in 2008 by Dwayne C. Litzenberger <dlitz@dlitz.net>
|
||||
#
|
||||
# ===================================================================
|
||||
# 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.
|
||||
# ===================================================================
|
||||
|
||||
"""DSA public-key signature algorithm.
|
||||
|
||||
DSA_ is a widespread public-key signature algorithm. Its security is
|
||||
based on the discrete logarithm problem (DLP_). Given a cyclic
|
||||
group, a generator *g*, and an element *h*, it is hard
|
||||
to find an integer *x* such that *g^x = h*. The problem is believed
|
||||
to be difficult, and it has been proved such (and therefore secure) for
|
||||
more than 30 years.
|
||||
|
||||
The group is actually a sub-group over the integers modulo *p*, with *p* prime.
|
||||
The sub-group order is *q*, which is prime too; it always holds that *(p-1)* is a multiple of *q*.
|
||||
The cryptographic strength is linked to the magnitude of *p* and *q*.
|
||||
The signer holds a value *x* (*0<x<q-1*) as private key, and its public
|
||||
key (*y* where *y=g^x mod p*) is distributed.
|
||||
|
||||
In 2012, a sufficient size is deemed to be 2048 bits for *p* and 256 bits for *q*.
|
||||
For more information, see the most recent ECRYPT_ report.
|
||||
|
||||
DSA is reasonably secure for new designs.
|
||||
|
||||
The algorithm can only be used for authentication (digital signature).
|
||||
DSA cannot be used for confidentiality (encryption).
|
||||
|
||||
The values *(p,q,g)* are called *domain parameters*;
|
||||
they are not sensitive but must be shared by both parties (the signer and the verifier).
|
||||
Different signers can share the same domain parameters with no security
|
||||
concerns.
|
||||
|
||||
The DSA signature is twice as big as the size of *q* (64 bytes if *q* is 256 bit
|
||||
long).
|
||||
|
||||
This module provides facilities for generating new DSA keys and for constructing
|
||||
them from known components. DSA keys allows you to perform basic signing and
|
||||
verification.
|
||||
|
||||
>>> from Crypto.PublicKey import DSA
|
||||
>>> from Crypto.Signature.DSS
|
||||
>>> from Crypto.Hash import SHA256
|
||||
>>>
|
||||
>>> message = b"Hello"
|
||||
>>> key = DSA.generate(2048)
|
||||
>>> f = open("public_key.pem", "w")
|
||||
>>> f.write(key.publickey().exportKey(key))
|
||||
>>> hash_obj = SHA256.new(message)
|
||||
>>> signer = DSS.new(key, 'fips-186-3')
|
||||
>>> signature = key.sign(hash_obj)
|
||||
>>> ...
|
||||
>>> f = open("public_key.pem", "r")
|
||||
>>> hash_obj = SHA256.new(message)
|
||||
>>> pub_key = DSA.import_key(f.read())
|
||||
>>> if pub_key.verify(hash_obj, signature):
|
||||
>>> print "OK"
|
||||
>>> else:
|
||||
>>> print "Incorrect signature"
|
||||
|
||||
.. _DSA: http://en.wikipedia.org/wiki/Digital_Signature_Algorithm
|
||||
.. _DLP: http://www.cosic.esat.kuleuven.be/publications/talk-78.pdf
|
||||
.. _ECRYPT: http://www.ecrypt.eu.org/documents/D.SPA.17.pdf
|
||||
"""
|
||||
|
||||
__all__ = ['generate', 'construct', 'DSAImplementation',
|
||||
'DsaKey', 'import_key' ]
|
||||
|
||||
import binascii
|
||||
import struct
|
||||
import itertools
|
||||
|
||||
from Crypto.Util.py3compat import *
|
||||
|
||||
from Crypto import Random
|
||||
from Crypto.IO import PKCS8, PEM
|
||||
from Crypto.Hash import SHA256
|
||||
from Crypto.Util.asn1 import (
|
||||
DerObject, DerSequence,
|
||||
DerInteger, DerObjectId,
|
||||
DerBitString,
|
||||
)
|
||||
|
||||
from Crypto.Math.Numbers import Integer
|
||||
from Crypto.Math.Primality import (test_probable_prime, COMPOSITE,
|
||||
PROBABLY_PRIME)
|
||||
|
||||
from Crypto.PublicKey import (_expand_subject_public_key_info,
|
||||
_create_subject_public_key_info,
|
||||
_extract_subject_public_key_info)
|
||||
|
||||
# ; The following ASN.1 types are relevant for DSA
|
||||
#
|
||||
# SubjectPublicKeyInfo ::= SEQUENCE {
|
||||
# algorithm AlgorithmIdentifier,
|
||||
# subjectPublicKey BIT STRING
|
||||
# }
|
||||
#
|
||||
# id-dsa ID ::= { iso(1) member-body(2) us(840) x9-57(10040) x9cm(4) 1 }
|
||||
#
|
||||
# ; See RFC3279
|
||||
# Dss-Parms ::= SEQUENCE {
|
||||
# p INTEGER,
|
||||
# q INTEGER,
|
||||
# g INTEGER
|
||||
# }
|
||||
#
|
||||
# DSAPublicKey ::= INTEGER
|
||||
#
|
||||
# DSSPrivatKey_OpenSSL ::= SEQUENCE
|
||||
# version INTEGER,
|
||||
# p INTEGER,
|
||||
# q INTEGER,
|
||||
# g INTEGER,
|
||||
# y INTEGER,
|
||||
# x INTEGER
|
||||
# }
|
||||
#
|
||||
|
||||
class DsaKey(object):
|
||||
"""Class defining an actual DSA key.
|
||||
|
||||
:undocumented: __getstate__, __setstate__, __repr__, __getattr__,
|
||||
__init__, __eq__, __ne__, sign, verify, encrypt, decrypt,
|
||||
blind, unblind, size
|
||||
"""
|
||||
#: Dictionary of DSA parameters.
|
||||
#:
|
||||
#: A public key will only have the following entries:
|
||||
#:
|
||||
#: - **y**, the public key.
|
||||
#: - **g**, the generator.
|
||||
#: - **p**, the modulus.
|
||||
#: - **q**, the order of the sub-group.
|
||||
#:
|
||||
#: A private key will also have:
|
||||
#:
|
||||
#: - **x**, the private key.
|
||||
_keydata = ['y', 'g', 'p', 'q', 'x']
|
||||
|
||||
def __init__(self, key_dict):
|
||||
input_set = set(key_dict.keys())
|
||||
public_set = set(('y' , 'g', 'p', 'q'))
|
||||
if not public_set.issubset(input_set):
|
||||
raise ValueError("Some DSA components are missing = %s" %
|
||||
str(public_set - input_set))
|
||||
extra_set = input_set - public_set
|
||||
if extra_set and extra_set != set(('x',)):
|
||||
raise ValueError("Unknown DSA components = %s" %
|
||||
str(extra_set - set(('x',))))
|
||||
self._key = dict(key_dict)
|
||||
|
||||
def _sign(self, m, k):
|
||||
if not self.has_private():
|
||||
raise TypeError("DSA public key cannot be used for signing")
|
||||
if not (1 < k < self.q):
|
||||
raise ValueError("k is not between 2 and q-1")
|
||||
|
||||
x, q, p, g = [self._key[comp] for comp in ['x', 'q', 'p', 'g']]
|
||||
|
||||
blind_factor = Integer.random_range(min_inclusive=1,
|
||||
max_exclusive=q)
|
||||
inv_blind_k = (blind_factor * k).inverse(q)
|
||||
blind_x = x * blind_factor
|
||||
|
||||
r = pow(g, k, p) % q # r = (g**k mod p) mod q
|
||||
s = (inv_blind_k * (blind_factor * m + blind_x * r)) % q
|
||||
return list(map(int, (r, s)))
|
||||
|
||||
def _verify(self, m, sig):
|
||||
r, s = sig
|
||||
y, q, p, g = [self._key[comp] for comp in ['y', 'q', 'p', 'g']]
|
||||
if not (0 < r < q) or not (0 < s < q):
|
||||
return False
|
||||
w = Integer(s).inverse(q)
|
||||
u1 = (w * m) % q
|
||||
u2 = (w * r) % q
|
||||
v = (pow(g, u1, p) * pow(y, u2, p) % p) % q
|
||||
return v == r
|
||||
|
||||
def has_private(self):
|
||||
return 'x' in self._key
|
||||
|
||||
def can_encrypt(self):
|
||||
return False
|
||||
|
||||
def can_sign(self):
|
||||
return True
|
||||
|
||||
def publickey(self):
|
||||
public_components = dict((k, self._key[k]) for k in ('y', 'g', 'p', 'q'))
|
||||
return DsaKey(public_components)
|
||||
|
||||
def __eq__(self, other):
|
||||
if bool(self.has_private()) != bool(other.has_private()):
|
||||
return False
|
||||
|
||||
result = True
|
||||
for comp in self._keydata:
|
||||
result = result and (getattr(self._key, comp, None) ==
|
||||
getattr(other._key, comp, None))
|
||||
return result
|
||||
|
||||
def __ne__(self, other):
|
||||
return not self.__eq__(other)
|
||||
|
||||
def __getstate__(self):
|
||||
# DSA key is not pickable
|
||||
from pickle import PicklingError
|
||||
raise PicklingError
|
||||
|
||||
def domain(self):
|
||||
"""The DSA domain parameters: *p*, *q* and *g*. """
|
||||
|
||||
return list(map(int, [self._key[comp] for comp in ('p', 'q', 'g')]))
|
||||
|
||||
def __repr__(self):
|
||||
attrs = []
|
||||
for k in self._keydata:
|
||||
if k == 'p':
|
||||
attrs.append("p(%d)" % (self.size()+1,))
|
||||
elif hasattr(self, k):
|
||||
attrs.append(k)
|
||||
if self.has_private():
|
||||
attrs.append("private")
|
||||
# PY3K: This is meant to be text, do not change to bytes (data)
|
||||
return "<%s @0x%x %s>" % (self.__class__.__name__, id(self), ",".join(attrs))
|
||||
|
||||
def __getattr__(self, item):
|
||||
try:
|
||||
return int(self._key[item])
|
||||
except KeyError:
|
||||
raise AttributeError(item)
|
||||
|
||||
def exportKey(self, format='PEM', pkcs8=None, passphrase=None,
|
||||
protection=None, randfunc=None):
|
||||
"""Export this DSA key.
|
||||
|
||||
:Parameters:
|
||||
format : string
|
||||
The format to use for wrapping the key:
|
||||
|
||||
- *'DER'*. Binary encoding.
|
||||
- *'PEM'*. Textual encoding, done according to `RFC1421`_/
|
||||
`RFC1423`_ (default).
|
||||
- *'OpenSSH'*. Textual encoding, one line of text, see `RFC4253`_.
|
||||
Only suitable for public keys, not private keys.
|
||||
|
||||
passphrase : string
|
||||
For private keys only. The pass phrase to use for deriving
|
||||
the encryption key.
|
||||
|
||||
pkcs8 : boolean
|
||||
For private keys only. If ``True`` (default), the key is arranged
|
||||
according to `PKCS#8`_ and if `False`, according to the custom
|
||||
OpenSSL/OpenSSH encoding.
|
||||
|
||||
protection : string
|
||||
The encryption scheme to use for protecting the private key.
|
||||
It is only meaningful when a pass phrase is present too.
|
||||
|
||||
If ``pkcs8`` takes value ``True``, ``protection`` is the PKCS#8
|
||||
algorithm to use for deriving the secret and encrypting
|
||||
the private DSA key.
|
||||
For a complete list of algorithms, see `Crypto.IO.PKCS8`.
|
||||
The default is *PBKDF2WithHMAC-SHA1AndDES-EDE3-CBC*.
|
||||
|
||||
If ``pkcs8`` is ``False``, the obsolete PEM encryption scheme is
|
||||
used. It is based on MD5 for key derivation, and Triple DES for
|
||||
encryption. Parameter ``protection`` is ignored.
|
||||
|
||||
The combination ``format='DER'`` and ``pkcs8=False`` is not allowed
|
||||
if a passphrase is present.
|
||||
|
||||
randfunc : callable
|
||||
A function that returns random bytes.
|
||||
By default it is `Crypto.Random.get_random_bytes`.
|
||||
|
||||
:Return: A byte string with the encoded public or private half
|
||||
of the key.
|
||||
:Raise ValueError:
|
||||
When the format is unknown or when you try to encrypt a private
|
||||
key with *DER* format and OpenSSL/OpenSSH.
|
||||
:attention:
|
||||
If you don't provide a pass phrase, the private key will be
|
||||
exported in the clear!
|
||||
|
||||
.. _RFC1421: http://www.ietf.org/rfc/rfc1421.txt
|
||||
.. _RFC1423: http://www.ietf.org/rfc/rfc1423.txt
|
||||
.. _RFC4253: http://www.ietf.org/rfc/rfc4253.txt
|
||||
.. _`PKCS#8`: http://www.ietf.org/rfc/rfc5208.txt
|
||||
"""
|
||||
|
||||
if passphrase is not None:
|
||||
passphrase = tobytes(passphrase)
|
||||
|
||||
if randfunc is None:
|
||||
randfunc = Random.get_random_bytes
|
||||
|
||||
if format == 'OpenSSH':
|
||||
tup1 = [self._key[x].to_bytes() for x in ('p', 'q', 'g', 'y')]
|
||||
|
||||
def func(x):
|
||||
if (bord(x[0]) & 0x80):
|
||||
return bchr(0) + x
|
||||
else:
|
||||
return x
|
||||
|
||||
tup2 = list(map(func, tup1))
|
||||
keyparts = [b('ssh-dss')] + tup2
|
||||
keystring = b('').join(
|
||||
[struct.pack(">I", len(kp)) + kp for kp in keyparts]
|
||||
)
|
||||
return b('ssh-dss ') + binascii.b2a_base64(keystring)[:-1]
|
||||
|
||||
# DER format is always used, even in case of PEM, which simply
|
||||
# encodes it into BASE64.
|
||||
params = DerSequence([self.p, self.q, self.g])
|
||||
if self.has_private():
|
||||
if pkcs8 is None:
|
||||
pkcs8 = True
|
||||
if pkcs8:
|
||||
if not protection:
|
||||
protection = 'PBKDF2WithHMAC-SHA1AndDES-EDE3-CBC'
|
||||
private_key = DerInteger(self.x).encode()
|
||||
binary_key = PKCS8.wrap(
|
||||
private_key, oid, passphrase,
|
||||
protection, key_params=params,
|
||||
randfunc=randfunc
|
||||
)
|
||||
if passphrase:
|
||||
key_type = 'ENCRYPTED PRIVATE'
|
||||
else:
|
||||
key_type = 'PRIVATE'
|
||||
passphrase = None
|
||||
else:
|
||||
if format != 'PEM' and passphrase:
|
||||
raise ValueError("DSA private key cannot be encrypted")
|
||||
ints = [0, self.p, self.q, self.g, self.y, self.x]
|
||||
binary_key = DerSequence(ints).encode()
|
||||
key_type = "DSA PRIVATE"
|
||||
else:
|
||||
if pkcs8:
|
||||
raise ValueError("PKCS#8 is only meaningful for private keys")
|
||||
|
||||
binary_key = _create_subject_public_key_info(oid,
|
||||
DerInteger(self.y), params)
|
||||
key_type = "DSA PUBLIC"
|
||||
|
||||
if format == 'DER':
|
||||
return binary_key
|
||||
if format == 'PEM':
|
||||
pem_str = PEM.encode(
|
||||
binary_key, key_type + " KEY",
|
||||
passphrase, randfunc
|
||||
)
|
||||
return tobytes(pem_str)
|
||||
raise ValueError("Unknown key format '%s'. Cannot export the DSA key." % format)
|
||||
|
||||
# Methods defined in PyCrypto that we don't support anymore
|
||||
|
||||
def sign(self, M, K):
|
||||
raise NotImplementedError("Use module Crypto.Signature.DSS instead")
|
||||
|
||||
def verify(self, M, signature):
|
||||
raise NotImplementedError("Use module Crypto.Signature.DSS instead")
|
||||
|
||||
def encrypt(self, plaintext, K):
|
||||
raise NotImplementedError
|
||||
|
||||
def decrypt(self, ciphertext):
|
||||
raise NotImplementedError
|
||||
|
||||
def blind(self, M, B):
|
||||
raise NotImplementedError
|
||||
|
||||
def unblind(self, M, B):
|
||||
raise NotImplementedError
|
||||
|
||||
def size():
|
||||
raise NotImplementedError
|
||||
|
||||
|
||||
def _generate_domain(L, randfunc):
|
||||
"""Generate a new set of DSA domain parameters"""
|
||||
|
||||
N = { 1024:160, 2048:224, 3072:256 }.get(L)
|
||||
if N is None:
|
||||
raise ValueError("Invalid modulus length (%d)" % L)
|
||||
|
||||
outlen = SHA256.digest_size * 8
|
||||
n = (L + outlen - 1) // outlen - 1 # ceil(L/outlen) -1
|
||||
b_ = L - 1 - (n * outlen)
|
||||
|
||||
# Generate q (A.1.1.2)
|
||||
q = Integer(4)
|
||||
upper_bit = 1 << (N - 1)
|
||||
while test_probable_prime(q, randfunc) != PROBABLY_PRIME:
|
||||
seed = randfunc(64)
|
||||
U = Integer.from_bytes(SHA256.new(seed).digest()) & (upper_bit - 1)
|
||||
q = U | upper_bit | 1
|
||||
|
||||
assert(q.size_in_bits() == N)
|
||||
|
||||
# Generate p (A.1.1.2)
|
||||
offset = 1
|
||||
upper_bit = 1 << (L - 1)
|
||||
while True:
|
||||
V = [ SHA256.new(seed + Integer(offset + j).to_bytes()).digest()
|
||||
for j in range(n + 1) ]
|
||||
V = [ Integer.from_bytes(v) for v in V ]
|
||||
W = sum([V[i] * (1 << (i * outlen)) for i in range(n)],
|
||||
(V[n] & (1 << b_ - 1)) * (1 << (n * outlen)))
|
||||
|
||||
X = Integer(W + upper_bit) # 2^{L-1} < X < 2^{L}
|
||||
assert(X.size_in_bits() == L)
|
||||
|
||||
c = X % (q * 2)
|
||||
p = X - (c - 1) # 2q divides (p-1)
|
||||
if p.size_in_bits() == L and \
|
||||
test_probable_prime(p, randfunc) == PROBABLY_PRIME:
|
||||
break
|
||||
offset += n + 1
|
||||
|
||||
# Generate g (A.2.3, index=1)
|
||||
e = (p - 1) // q
|
||||
for count in itertools.count(1):
|
||||
U = seed + b("ggen") + bchr(1) + Integer(count).to_bytes()
|
||||
W = Integer.from_bytes(SHA256.new(U).digest())
|
||||
g = pow(W, e, p)
|
||||
if g != 1:
|
||||
break
|
||||
|
||||
return (p, q, g, seed)
|
||||
|
||||
|
||||
def generate(bits, randfunc=None, domain=None):
|
||||
"""Generate a new DSA key pair.
|
||||
|
||||
The algorithm follows Appendix A.1/A.2 and B.1 of `FIPS 186-4`_,
|
||||
respectively for domain generation and key pair generation.
|
||||
|
||||
:Parameters:
|
||||
bits : integer
|
||||
Key length, or size (in bits) of the DSA modulus *p*.
|
||||
It must be 1024, 2048 or 3072.
|
||||
|
||||
randfunc : callable
|
||||
Random number generation function; it accepts a single integer N
|
||||
and return a string of random data N bytes long.
|
||||
If not specified, the default from ``Crypto.Random`` is used.
|
||||
|
||||
domain : list
|
||||
The DSA domain parameters *p*, *q* and *g* as a list of 3
|
||||
integers. Size of *p* and *q* must comply to `FIPS 186-4`_.
|
||||
If not specified, the parameters are created anew.
|
||||
|
||||
:Return: A DSA key object (`DsaKey`).
|
||||
|
||||
:Raise ValueError:
|
||||
When **bits** is too little, too big, or not a multiple of 64.
|
||||
|
||||
.. _FIPS 186-4: http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf
|
||||
"""
|
||||
|
||||
if randfunc is None:
|
||||
randfunc = Random.get_random_bytes
|
||||
|
||||
if domain:
|
||||
p, q, g = list(map(Integer, domain))
|
||||
|
||||
## Perform consistency check on domain parameters
|
||||
# P and Q must be prime
|
||||
fmt_error = test_probable_prime(p) == COMPOSITE
|
||||
fmt_error = test_probable_prime(q) == COMPOSITE
|
||||
# Verify Lagrange's theorem for sub-group
|
||||
fmt_error |= ((p - 1) % q) != 0
|
||||
fmt_error |= g <= 1 or g >= p
|
||||
fmt_error |= pow(g, q, p) != 1
|
||||
if fmt_error:
|
||||
raise ValueError("Invalid DSA domain parameters")
|
||||
else:
|
||||
p, q, g, _ = _generate_domain(bits, randfunc)
|
||||
|
||||
L = p.size_in_bits()
|
||||
N = q.size_in_bits()
|
||||
|
||||
if L != bits:
|
||||
raise ValueError("Mismatch between size of modulus (%d)"
|
||||
" and 'bits' parameter (%d)" % (L, bits))
|
||||
|
||||
if (L, N) not in [(1024, 160), (2048, 224),
|
||||
(2048, 256), (3072, 256)]:
|
||||
raise ValueError("Lengths of p and q (%d, %d) are not compatible"
|
||||
"to FIPS 186-3" % (L, N))
|
||||
|
||||
if not 1 < g < p:
|
||||
raise ValueError("Incorrent DSA generator")
|
||||
|
||||
# B.1.1
|
||||
c = Integer.random(exact_bits=N + 64)
|
||||
x = c % (q - 1) + 1 # 1 <= x <= q-1
|
||||
y = pow(g, x, p)
|
||||
|
||||
key_dict = { 'y':y, 'g':g, 'p':p, 'q':q, 'x':x }
|
||||
return DsaKey(key_dict)
|
||||
|
||||
|
||||
def construct(tup, consistency_check=True):
|
||||
"""Construct a DSA key from a tuple of valid DSA components.
|
||||
|
||||
:Parameters:
|
||||
tup : tuple
|
||||
A tuple of long integers, with 4 or 5 items
|
||||
in the following order:
|
||||
|
||||
1. Public key (*y*).
|
||||
2. Sub-group generator (*g*).
|
||||
3. Modulus, finite field order (*p*).
|
||||
4. Sub-group order (*q*).
|
||||
5. Private key (*x*). Optional.
|
||||
consistency_check : boolean
|
||||
If *True*, the library will verify that the provided components
|
||||
fulfil the main DSA properties.
|
||||
|
||||
:Raise PublicKey.ValueError:
|
||||
When the key being imported fails the most basic DSA validity checks.
|
||||
:Return: A DSA key object (`DsaKey`).
|
||||
"""
|
||||
|
||||
key_dict = dict(list(zip(('y', 'g', 'p', 'q', 'x'), list(map(Integer, tup)))))
|
||||
key = DsaKey(key_dict)
|
||||
|
||||
fmt_error = False
|
||||
if consistency_check:
|
||||
# P and Q must be prime
|
||||
fmt_error = test_probable_prime(key.p) == COMPOSITE
|
||||
fmt_error = test_probable_prime(key.q) == COMPOSITE
|
||||
# Verify Lagrange's theorem for sub-group
|
||||
fmt_error |= ((key.p - 1) % key.q) != 0
|
||||
fmt_error |= key.g <= 1 or key.g >= key.p
|
||||
fmt_error |= pow(key.g, key.q, key.p) != 1
|
||||
# Public key
|
||||
fmt_error |= key.y <= 0 or key.y >= key.p
|
||||
if hasattr(key, 'x'):
|
||||
fmt_error |= key.x <= 0 or key.x >= key.q
|
||||
fmt_error |= pow(key.g, key.x, key.p) != key.y
|
||||
|
||||
if fmt_error:
|
||||
raise ValueError("Invalid DSA key components")
|
||||
|
||||
return key
|
||||
|
||||
|
||||
# Dss-Parms ::= SEQUENCE {
|
||||
# p OCTET STRING,
|
||||
# q OCTET STRING,
|
||||
# g OCTET STRING
|
||||
# }
|
||||
# DSAPublicKey ::= INTEGER -- public key, y
|
||||
|
||||
def _import_openssl_private(encoded, passphrase, params):
|
||||
if params:
|
||||
raise ValueError("DSA private key already comes with parameters")
|
||||
der = DerSequence().decode(encoded, nr_elements=6, only_ints_expected=True)
|
||||
if der[0] != 0:
|
||||
raise ValueError("No version found")
|
||||
tup = [der[comp] for comp in (4, 3, 1, 2, 5)]
|
||||
return construct(tup)
|
||||
|
||||
|
||||
def _import_subjectPublicKeyInfo(encoded, passphrase, params):
|
||||
|
||||
algoid, encoded_key, emb_params = _expand_subject_public_key_info(encoded)
|
||||
if algoid != oid:
|
||||
raise ValueError("No DSA subjectPublicKeyInfo")
|
||||
if params and emb_params:
|
||||
raise ValueError("Too many DSA parameters")
|
||||
|
||||
y = DerInteger().decode(encoded_key).value
|
||||
p, q, g = list(DerSequence().decode(params or emb_params))
|
||||
tup = (y, g, p, q)
|
||||
return construct(tup)
|
||||
|
||||
|
||||
def _import_x509_cert(encoded, passphrase, params):
|
||||
|
||||
sp_info = _extract_subject_public_key_info(encoded)
|
||||
return _import_subjectPublicKeyInfo(sp_info, None, params)
|
||||
|
||||
|
||||
def _import_pkcs8(encoded, passphrase, params):
|
||||
if params:
|
||||
raise ValueError("PKCS#8 already includes parameters")
|
||||
k = PKCS8.unwrap(encoded, passphrase)
|
||||
if k[0] != oid:
|
||||
raise ValueError("No PKCS#8 encoded DSA key")
|
||||
x = DerInteger().decode(k[1]).value
|
||||
p, q, g = list(DerSequence().decode(k[2]))
|
||||
tup = (pow(g, x, p), g, p, q, x)
|
||||
return construct(tup)
|
||||
|
||||
|
||||
def _import_key_der(key_data, passphrase, params):
|
||||
"""Import a DSA key (public or private half), encoded in DER form."""
|
||||
|
||||
decodings = (_import_openssl_private,
|
||||
_import_subjectPublicKeyInfo,
|
||||
_import_x509_cert,
|
||||
_import_pkcs8)
|
||||
|
||||
for decoding in decodings:
|
||||
try:
|
||||
return decoding(key_data, passphrase, params)
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
raise ValueError("DSA key format is not supported")
|
||||
|
||||
|
||||
def import_key(extern_key, passphrase=None):
|
||||
"""Import a DSA key (public or private).
|
||||
|
||||
:Parameters:
|
||||
extern_key : (byte) string
|
||||
The DSA key to import.
|
||||
|
||||
An DSA *public* key can be in any of the following formats:
|
||||
|
||||
- X.509 certificate (binary or PEM format)
|
||||
- X.509 ``subjectPublicKeyInfo`` (binary or PEM)
|
||||
- OpenSSH (one line of text, see `RFC4253`_)
|
||||
|
||||
A DSA *private* key can be in any of the following formats:
|
||||
|
||||
- `PKCS#8`_ ``PrivateKeyInfo`` or ``EncryptedPrivateKeyInfo``
|
||||
DER SEQUENCE (binary or PEM encoding)
|
||||
- OpenSSL/OpenSSH (binary or PEM)
|
||||
|
||||
For details about the PEM encoding, see `RFC1421`_/`RFC1423`_.
|
||||
|
||||
The private key may be encrypted by means of a certain pass phrase
|
||||
either at the PEM level or at the PKCS#8 level.
|
||||
|
||||
passphrase : string
|
||||
In case of an encrypted private key, this is the pass phrase
|
||||
from which the decryption key is derived.
|
||||
|
||||
:Return: A DSA key object (`DsaKey`).
|
||||
:Raise ValueError:
|
||||
When the given key cannot be parsed (possibly because
|
||||
the pass phrase is wrong).
|
||||
|
||||
.. _RFC1421: http://www.ietf.org/rfc/rfc1421.txt
|
||||
.. _RFC1423: http://www.ietf.org/rfc/rfc1423.txt
|
||||
.. _RFC4253: http://www.ietf.org/rfc/rfc4253.txt
|
||||
.. _PKCS#8: http://www.ietf.org/rfc/rfc5208.txt
|
||||
"""
|
||||
|
||||
extern_key = tobytes(extern_key)
|
||||
if passphrase is not None:
|
||||
passphrase = tobytes(passphrase)
|
||||
|
||||
if extern_key.startswith(b('-----')):
|
||||
# This is probably a PEM encoded key
|
||||
(der, marker, enc_flag) = PEM.decode(tostr(extern_key), passphrase)
|
||||
if enc_flag:
|
||||
passphrase = None
|
||||
return _import_key_der(der, passphrase, None)
|
||||
|
||||
if extern_key.startswith(b('ssh-dss ')):
|
||||
# This is probably a public OpenSSH key
|
||||
keystring = binascii.a2b_base64(extern_key.split(b(' '))[1])
|
||||
keyparts = []
|
||||
while len(keystring) > 4:
|
||||
length = struct.unpack(">I", keystring[:4])[0]
|
||||
keyparts.append(keystring[4:4 + length])
|
||||
keystring = keystring[4 + length:]
|
||||
if keyparts[0] == b("ssh-dss"):
|
||||
tup = [Integer.from_bytes(keyparts[x]) for x in (4, 3, 1, 2)]
|
||||
return construct(tup)
|
||||
|
||||
if bord(extern_key[0]) == 0x30:
|
||||
# This is probably a DER encoded key
|
||||
return _import_key_der(extern_key, passphrase, None)
|
||||
|
||||
raise ValueError("DSA key format is not supported")
|
||||
|
||||
|
||||
# Backward compatibility
|
||||
importKey = import_key
|
||||
|
||||
#: `Object ID`_ for a DSA key.
|
||||
#:
|
||||
#: id-dsa ID ::= { iso(1) member-body(2) us(840) x9-57(10040) x9cm(4) 1 }
|
||||
#:
|
||||
#: .. _`Object ID`: http://www.alvestrand.no/objectid/1.2.840.10040.4.1.html
|
||||
oid = "1.2.840.10040.4.1"
|
||||
835
venv/Lib/site-packages/Crypto/PublicKey/ECC.py
Normal file
835
venv/Lib/site-packages/Crypto/PublicKey/ECC.py
Normal file
|
|
@ -0,0 +1,835 @@
|
|||
# ===================================================================
|
||||
#
|
||||
# Copyright (c) 2015, Legrandin <helderijs@gmail.com>
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in
|
||||
# the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
# POSSIBILITY OF SUCH DAMAGE.
|
||||
# ===================================================================
|
||||
|
||||
"""Elliptic Curve Cryptography (ECC) algorithms.
|
||||
|
||||
ECC_ is a modern and efficient type of public key cryptography.
|
||||
Its security is based on the difficulty to solve discrete logarithms
|
||||
on the field defined by specific equations involving points on a curve.
|
||||
|
||||
ECC can be used to perform signing/verification and asymmetric
|
||||
encryption/decryption.
|
||||
|
||||
The main benefit of ECC is that the size of a key is significantly smaller
|
||||
than with other, more traditional algorithms like RSA or DSA.
|
||||
|
||||
For instance, consider the security level equivalent to AES128: an RSA
|
||||
key of similar strength must have a modulus of 3072 bits (therefore the total size
|
||||
is 768 bytes, comprising modulus and private exponent).
|
||||
An ECC private needs as little as 256 bits (32 bytes).
|
||||
|
||||
This module provides mechanisms for generating new ECC keys, exporting them
|
||||
using widely supported formats like PEM or DER and importing them back.
|
||||
|
||||
**This module currently supports only ECC keys defined over the standard
|
||||
NIST P-256 curve** (see `FIPS 186-4`_, Section D.1.2.3). More curves will be
|
||||
added in the future.
|
||||
|
||||
The following example demonstrates how to generate a new key, export it,
|
||||
and subsequentely reload it back into the application:
|
||||
|
||||
>>> from Crypto.PublicKey import ECC
|
||||
>>>
|
||||
>>> key = ECC.generate(curve='P-256')
|
||||
>>> f = open('myprivatekey.pem','wt')
|
||||
>>> f.write(key.export_key('PEM'))
|
||||
>>> f.close()
|
||||
...
|
||||
>>> f = open('myprivatekey.pem','rt')
|
||||
>>> key = RSA.import_key(f.read())
|
||||
|
||||
The ECC key can be used to perform or verify ECDSA signatures, see
|
||||
`Crypto.Signature.DSS`.
|
||||
|
||||
.. _ECC: http://andrea.corbellini.name/2015/05/17/elliptic-curve-cryptography-a-gentle-introduction/
|
||||
.. _`FIPS 186-4`: http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf
|
||||
|
||||
:undocumented: __package__
|
||||
"""
|
||||
|
||||
|
||||
import struct
|
||||
import binascii
|
||||
|
||||
from Crypto.Util.py3compat import bord, tobytes, b, tostr, bchr
|
||||
|
||||
from Crypto.Math.Numbers import Integer
|
||||
from Crypto.Random import get_random_bytes
|
||||
from Crypto.Util.asn1 import (DerObjectId, DerOctetString, DerSequence,
|
||||
DerBitString)
|
||||
|
||||
from Crypto.IO import PKCS8, PEM
|
||||
from Crypto.PublicKey import (_expand_subject_public_key_info,
|
||||
_create_subject_public_key_info,
|
||||
_extract_subject_public_key_info)
|
||||
|
||||
|
||||
class _Curve(object):
|
||||
pass
|
||||
|
||||
_curve = _Curve()
|
||||
_curve.p = Integer(0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff)
|
||||
_curve.b = Integer(0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b)
|
||||
_curve.order = Integer(0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551)
|
||||
_curve.Gx = Integer(0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296)
|
||||
_curve.Gy = Integer(0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5)
|
||||
_curve.names = ("P-256", "prime256v1", "secp256r1")
|
||||
_curve.oid = "1.2.840.10045.3.1.7"
|
||||
|
||||
|
||||
class EccPoint(object):
|
||||
"""A class to abstract a point over an Elliptic Curve.
|
||||
|
||||
:undocumented: __init__, __eq__, __neg__, __iadd__, __add__, __mul__
|
||||
"""
|
||||
|
||||
def __init__(self, x, y):
|
||||
self._x = Integer(x)
|
||||
self._y = Integer(y)
|
||||
|
||||
# Buffers
|
||||
self._common = Integer(0)
|
||||
self._tmp1 = Integer(0)
|
||||
self._x3 = Integer(0)
|
||||
self._y3 = Integer(0)
|
||||
|
||||
def set(self, point):
|
||||
self._x = Integer(point._x)
|
||||
self._y = Integer(point._y)
|
||||
return self
|
||||
|
||||
def __eq__(self, point):
|
||||
return self._x == point._x and self._y == point._y
|
||||
|
||||
def __neg__(self):
|
||||
if self.is_point_at_infinity():
|
||||
return self.point_at_infinity()
|
||||
return EccPoint(self._x, _curve.p - self._y)
|
||||
|
||||
def copy(self):
|
||||
return EccPoint(self._x, self._y)
|
||||
|
||||
def is_point_at_infinity(self):
|
||||
return not (self._x or self._y)
|
||||
|
||||
@staticmethod
|
||||
def point_at_infinity():
|
||||
return EccPoint(0, 0)
|
||||
|
||||
@property
|
||||
def x(self):
|
||||
"""The X-coordinate of the ECC point"""
|
||||
if self.is_point_at_infinity():
|
||||
raise ValueError("Point at infinity")
|
||||
return self._x
|
||||
|
||||
@property
|
||||
def y(self):
|
||||
"""The Y-coordinate of the ECC point"""
|
||||
if self.is_point_at_infinity():
|
||||
raise ValueError("Point at infinity")
|
||||
return self._y
|
||||
|
||||
def double(self):
|
||||
"""Double this point"""
|
||||
|
||||
if not self._y:
|
||||
return self.point_at_infinity()
|
||||
|
||||
common = self._common
|
||||
tmp1 = self._tmp1
|
||||
x3 = self._x3
|
||||
y3 = self._y3
|
||||
|
||||
# common = (pow(self._x, 2, _curve.p) * 3 - 3) * (self._y << 1).inverse(_curve.p) % _curve.p
|
||||
common.set(self._x)
|
||||
common.inplace_pow(2, _curve.p)
|
||||
common *= 3
|
||||
common -= 3
|
||||
tmp1.set(self._y)
|
||||
tmp1 <<= 1
|
||||
tmp1.inplace_inverse(_curve.p)
|
||||
common *= tmp1
|
||||
common %= _curve.p
|
||||
|
||||
# x3 = (pow(common, 2, _curve.p) - 2 * self._x) % _curve.p
|
||||
x3.set(common)
|
||||
x3.inplace_pow(2, _curve.p)
|
||||
x3 -= self._x
|
||||
x3 -= self._x
|
||||
while x3.is_negative():
|
||||
x3 += _curve.p
|
||||
|
||||
# y3 = ((self._x - x3) * common - self._y) % _curve.p
|
||||
y3.set(self._x)
|
||||
y3 -= x3
|
||||
y3 *= common
|
||||
y3 -= self._y
|
||||
y3 %= _curve.p
|
||||
|
||||
self._x.set(x3)
|
||||
self._y.set(y3)
|
||||
return self
|
||||
|
||||
def __iadd__(self, point):
|
||||
"""Add a second point to this one"""
|
||||
|
||||
if self.is_point_at_infinity():
|
||||
return self.set(point)
|
||||
|
||||
if point.is_point_at_infinity():
|
||||
return self
|
||||
|
||||
if self == point:
|
||||
return self.double()
|
||||
|
||||
if self._x == point._x:
|
||||
return self.set(self.point_at_infinity())
|
||||
|
||||
common = self._common
|
||||
tmp1 = self._tmp1
|
||||
x3 = self._x3
|
||||
y3 = self._y3
|
||||
|
||||
# common = (point._y - self._y) * (point._x - self._x).inverse(_curve.p) % _curve.p
|
||||
common.set(point._y)
|
||||
common -= self._y
|
||||
tmp1.set(point._x)
|
||||
tmp1 -= self._x
|
||||
tmp1.inplace_inverse(_curve.p)
|
||||
common *= tmp1
|
||||
common %= _curve.p
|
||||
|
||||
# x3 = (pow(common, 2, _curve.p) - self._x - point._x) % _curve.p
|
||||
x3.set(common)
|
||||
x3.inplace_pow(2, _curve.p)
|
||||
x3 -= self._x
|
||||
x3 -= point._x
|
||||
while x3.is_negative():
|
||||
x3 += _curve.p
|
||||
|
||||
# y3 = ((self._x - x3) * common - self._y) % _curve.p
|
||||
y3.set(self._x)
|
||||
y3 -= x3
|
||||
y3 *= common
|
||||
y3 -= self._y
|
||||
y3 %= _curve.p
|
||||
|
||||
self._x.set(x3)
|
||||
self._y.set(y3)
|
||||
return self
|
||||
|
||||
def __add__(self, point):
|
||||
"""Return a new point, the addition of this one and another"""
|
||||
|
||||
result = self.copy()
|
||||
result += point
|
||||
return result
|
||||
|
||||
def __mul__(self, scalar):
|
||||
"""Return a new point, the scalar product of this one"""
|
||||
|
||||
if scalar < 0:
|
||||
raise ValueError("Scalar multiplication only defined for non-negative integers")
|
||||
|
||||
# Trivial results
|
||||
if scalar == 0 or self.is_point_at_infinity():
|
||||
return self.point_at_infinity()
|
||||
elif scalar == 1:
|
||||
return self.copy()
|
||||
|
||||
# Scalar randomization
|
||||
scalar_blind = Integer.random(exact_bits=64) * _curve.order + scalar
|
||||
|
||||
# Montgomery key ladder
|
||||
r = [self.point_at_infinity().copy(), self.copy()]
|
||||
bit_size = int(scalar_blind.size_in_bits())
|
||||
scalar_int = int(scalar_blind)
|
||||
for i in range(bit_size, -1, -1):
|
||||
di = scalar_int >> i & 1
|
||||
r[di ^ 1] += r[di]
|
||||
r[di].double()
|
||||
|
||||
return r[0]
|
||||
|
||||
|
||||
_curve.G = EccPoint(_curve.Gx, _curve.Gy)
|
||||
|
||||
|
||||
class EccKey(object):
|
||||
"""A private or public key over an Elliptic Curve.
|
||||
|
||||
:undocumented: __eq__, __repr__, __init__
|
||||
"""
|
||||
|
||||
def __init__(self, **kwargs):
|
||||
"""Create a new ECC key
|
||||
|
||||
Do not instantiate this object directly.
|
||||
|
||||
Keywords:
|
||||
curve : string
|
||||
It must be *"P-256"*, *"prime256v1"* or *"secp256r1"*.
|
||||
d : integer
|
||||
Only for a private key. It must be in the range ``[1..order-1]``.
|
||||
point : EccPoint
|
||||
Mandatory for a public key. If provided for a private key,
|
||||
the implementation will NOT check whether it matches ``d``.
|
||||
"""
|
||||
|
||||
kwargs_ = dict(kwargs)
|
||||
self.curve = kwargs_.pop("curve", None)
|
||||
self._d = kwargs_.pop("d", None)
|
||||
self._point = kwargs_.pop("point", None)
|
||||
if kwargs_:
|
||||
raise TypeError("Unknown parameters: " + str(kwargs_))
|
||||
|
||||
if self.curve not in _curve.names:
|
||||
raise ValueError("Unsupported curve (%s)", self.curve)
|
||||
|
||||
if self._d is None:
|
||||
if self._point is None:
|
||||
raise ValueError("Either private or public ECC component must be specified")
|
||||
else:
|
||||
self._d = Integer(self._d)
|
||||
if not 1 <= self._d < _curve.order:
|
||||
raise ValueError("Invalid ECC private component")
|
||||
|
||||
def __eq__(self, other):
|
||||
if other.has_private() != self.has_private():
|
||||
return False
|
||||
|
||||
return (other.pointQ.x == self.pointQ.x) and (other.pointQ.y == self.pointQ.y)
|
||||
|
||||
def __repr__(self):
|
||||
if self.has_private():
|
||||
extra = ", d=%d" % int(self._d)
|
||||
else:
|
||||
extra = ""
|
||||
return "EccKey(curve='P-256', x=%d, y=%d%s)" %\
|
||||
(self.pointQ.x, self.pointQ.y, extra)
|
||||
|
||||
def has_private(self):
|
||||
"""True if this key can be used for making signatures or decrypting"""
|
||||
return self._d is not None
|
||||
|
||||
def _sign(self, z, k):
|
||||
assert 0 < k < _curve.order
|
||||
|
||||
blind = Integer.random_range(min_inclusive=1,
|
||||
max_exclusive=_curve.order)
|
||||
|
||||
blind_d = self._d * blind
|
||||
inv_blind_k = (blind * k).inverse(_curve.order)
|
||||
|
||||
r = (_curve.G * k).x % _curve.order
|
||||
s = inv_blind_k * (blind * z + blind_d * r) % _curve.order
|
||||
return (r, s)
|
||||
|
||||
def _verify(self, z, rs):
|
||||
sinv = rs[1].inverse(_curve.order)
|
||||
point1 = _curve.G * ((sinv * z) % _curve.order)
|
||||
point2 = self.pointQ * ((sinv * rs[0]) % _curve.order)
|
||||
return (point1 + point2).x == rs[0]
|
||||
|
||||
@property
|
||||
def d(self):
|
||||
"""An integer (scalar), representating the private component"""
|
||||
if not self.has_private():
|
||||
raise ValueError("This is not a private ECC key")
|
||||
return self._d
|
||||
|
||||
@property
|
||||
def pointQ(self):
|
||||
"""An `EccPoint`, representating the public component"""
|
||||
if self._point is None:
|
||||
self._point = _curve.G * self._d
|
||||
return self._point
|
||||
|
||||
def public_key(self):
|
||||
"""Create a new `EccKey`, by retaining only the public components"""
|
||||
return EccKey(curve="P-256", point=self.pointQ)
|
||||
|
||||
def _export_subjectPublicKeyInfo(self):
|
||||
|
||||
# Uncompressed form
|
||||
order_bytes = _curve.order.size_in_bytes()
|
||||
public_key = (bchr(4) +
|
||||
self.pointQ.x.to_bytes(order_bytes) +
|
||||
self.pointQ.y.to_bytes(order_bytes))
|
||||
|
||||
unrestricted_oid = "1.2.840.10045.2.1"
|
||||
return _create_subject_public_key_info(unrestricted_oid,
|
||||
public_key,
|
||||
DerObjectId(_curve.oid))
|
||||
|
||||
def _export_private_der(self, include_ec_params=True):
|
||||
|
||||
assert self.has_private()
|
||||
|
||||
# ECPrivateKey ::= SEQUENCE {
|
||||
# version INTEGER { ecPrivkeyVer1(1) } (ecPrivkeyVer1),
|
||||
# privateKey OCTET STRING,
|
||||
# parameters [0] ECParameters {{ NamedCurve }} OPTIONAL,
|
||||
# publicKey [1] BIT STRING OPTIONAL
|
||||
# }
|
||||
|
||||
# Public key - uncompressed form
|
||||
order_bytes = _curve.order.size_in_bytes()
|
||||
public_key = (bchr(4) +
|
||||
self.pointQ.x.to_bytes(order_bytes) +
|
||||
self.pointQ.y.to_bytes(order_bytes))
|
||||
|
||||
seq = [1,
|
||||
DerOctetString(self.d.to_bytes(order_bytes)),
|
||||
DerObjectId(_curve.oid, explicit=0),
|
||||
DerBitString(public_key, explicit=1)]
|
||||
|
||||
if not include_ec_params:
|
||||
del seq[2]
|
||||
|
||||
return DerSequence(seq).encode()
|
||||
|
||||
def _export_pkcs8(self, **kwargs):
|
||||
if kwargs.get('passphrase', None) is not None and 'protection' not in kwargs:
|
||||
raise ValueError("At least the 'protection' parameter should be present")
|
||||
unrestricted_oid = "1.2.840.10045.2.1"
|
||||
private_key = self._export_private_der(include_ec_params=False)
|
||||
result = PKCS8.wrap(private_key,
|
||||
unrestricted_oid,
|
||||
key_params=DerObjectId(_curve.oid),
|
||||
**kwargs)
|
||||
return result
|
||||
|
||||
def _export_public_pem(self):
|
||||
encoded_der = self._export_subjectPublicKeyInfo()
|
||||
return PEM.encode(encoded_der, "PUBLIC KEY")
|
||||
|
||||
def _export_private_pem(self, passphrase, **kwargs):
|
||||
encoded_der = self._export_private_der()
|
||||
return PEM.encode(encoded_der, "EC PRIVATE KEY", passphrase, **kwargs)
|
||||
|
||||
def _export_private_clear_pkcs8_in_clear_pem(self):
|
||||
encoded_der = self._export_pkcs8()
|
||||
return PEM.encode(encoded_der, "PRIVATE KEY")
|
||||
|
||||
def _export_private_encrypted_pkcs8_in_clear_pem(self, passphrase, **kwargs):
|
||||
assert passphrase
|
||||
if 'protection' not in kwargs:
|
||||
raise ValueError("At least the 'protection' parameter should be present")
|
||||
encoded_der = self._export_pkcs8(passphrase=passphrase, **kwargs)
|
||||
return PEM.encode(encoded_der, "ENCRYPTED PRIVATE KEY")
|
||||
|
||||
def _export_openssh(self):
|
||||
assert not self.has_private()
|
||||
|
||||
desc = "ecdsa-sha2-nistp256"
|
||||
|
||||
# Uncompressed form
|
||||
order_bytes = _curve.order.size_in_bytes()
|
||||
public_key = (bchr(4) +
|
||||
self.pointQ.x.to_bytes(order_bytes) +
|
||||
self.pointQ.y.to_bytes(order_bytes))
|
||||
|
||||
comps = (tobytes(desc), b("nistp256"), public_key)
|
||||
blob = b("").join([ struct.pack(">I", len(x)) + x for x in comps])
|
||||
return desc + " " + tostr(binascii.b2a_base64(blob))
|
||||
|
||||
def export_key(self, **kwargs):
|
||||
"""Export this ECC key.
|
||||
|
||||
:Keywords:
|
||||
|
||||
format : string
|
||||
The format to use for wrapping the key:
|
||||
|
||||
- *'DER'*. The key will be encoded in an ASN.1 DER_ structure (binary).
|
||||
- *'PEM'*. The key will be encoded in a PEM_ envelope (ASCII).
|
||||
- *'OpenSSH'*. The key will be encoded in the OpenSSH_ format
|
||||
(ASCII, public keys only).
|
||||
|
||||
passphrase : byte string or string
|
||||
The passphrase to use for protecting the private key.
|
||||
*If not provided, the private key will remain in clear form!*
|
||||
|
||||
use_pkcs8 : boolean
|
||||
In case of a private key, whether the PKCS#8_ representation
|
||||
should be (internally) used. By default it will.
|
||||
|
||||
Not using PKCS#8 when exporting a private key in
|
||||
password-protected PEM_ form means that the much weaker and
|
||||
unflexible `PEM encryption`_ mechanism will be used.
|
||||
PKCS#8 is therefore always recommended.
|
||||
|
||||
protection : string
|
||||
In case of a private key being exported with password-protection
|
||||
and PKCS#8 (both ``DER`` and ``PEM`` formats), this parameter MUST be
|
||||
present and be a valid algorithm supported by `Crypto.IO.PKCS8`.
|
||||
It is recommended to use ``PBKDF2WithHMAC-SHA1AndAES128-CBC``.
|
||||
|
||||
:Note:
|
||||
In case of a private key being exported with password-protection
|
||||
and PKCS#8_ (both ``DER`` and ``PEM`` formats), all additional parameters
|
||||
will be passed to `Crypto.IO.PKCS8`.
|
||||
|
||||
.. _DER: http://www.ietf.org/rfc/rfc5915.txt
|
||||
.. _PEM: http://www.ietf.org/rfc/rfc1421.txt
|
||||
.. _`PEM encryption`: http://www.ietf.org/rfc/rfc1423.txt
|
||||
.. _`PKCS#8`: http://www.ietf.org/rfc/rfc5208.txt
|
||||
.. _OpenSSH: http://www.openssh.com/txt/rfc5656.txt
|
||||
|
||||
:Return: A multi-line string (for PEM and OpenSSH) or bytes (for DER) with the encoded key.
|
||||
"""
|
||||
|
||||
args = kwargs.copy()
|
||||
ext_format = args.pop("format")
|
||||
if ext_format not in ("PEM", "DER", "OpenSSH"):
|
||||
raise ValueError("Unknown format '%s'" % ext_format)
|
||||
|
||||
if self.has_private():
|
||||
passphrase = args.pop("passphrase", None)
|
||||
if isinstance(passphrase, str):
|
||||
passphrase = tobytes(passphrase)
|
||||
if not passphrase:
|
||||
raise ValueError("Empty passphrase")
|
||||
use_pkcs8 = args.pop("use_pkcs8", True)
|
||||
if ext_format == "PEM":
|
||||
if use_pkcs8:
|
||||
if passphrase:
|
||||
return self._export_private_encrypted_pkcs8_in_clear_pem(passphrase, **args)
|
||||
else:
|
||||
return self._export_private_clear_pkcs8_in_clear_pem()
|
||||
else:
|
||||
return self._export_private_pem(passphrase, **args)
|
||||
elif ext_format == "DER":
|
||||
# DER
|
||||
if passphrase and not use_pkcs8:
|
||||
raise ValueError("Private keys can only be encrpyted with DER using PKCS#8")
|
||||
if use_pkcs8:
|
||||
return self._export_pkcs8(passphrase=passphrase, **args)
|
||||
else:
|
||||
return self._export_private_der()
|
||||
else:
|
||||
raise ValueError("Private keys cannot be exported in OpenSSH format")
|
||||
else: # Public key
|
||||
if args:
|
||||
raise ValueError("Unexpected parameters: '%s'" % args)
|
||||
if ext_format == "PEM":
|
||||
return self._export_public_pem()
|
||||
elif ext_format == "DER":
|
||||
return self._export_subjectPublicKeyInfo()
|
||||
else:
|
||||
return self._export_openssh()
|
||||
|
||||
|
||||
def generate(**kwargs):
|
||||
"""Generate a new private key on the given curve.
|
||||
|
||||
:Keywords:
|
||||
curve : string
|
||||
Mandatory. It must be "P-256", "prime256v1" or "secp256r1".
|
||||
randfunc : callable
|
||||
Optional. The RNG to read randomness from.
|
||||
If ``None``, the system source is used.
|
||||
"""
|
||||
|
||||
curve = kwargs.pop("curve")
|
||||
randfunc = kwargs.pop("randfunc", get_random_bytes)
|
||||
if kwargs:
|
||||
raise TypeError("Unknown parameters: " + str(kwargs))
|
||||
|
||||
d = Integer.random_range(min_inclusive=1,
|
||||
max_exclusive=_curve.order,
|
||||
randfunc=randfunc)
|
||||
|
||||
return EccKey(curve=curve, d=d)
|
||||
|
||||
|
||||
def construct(**kwargs):
|
||||
"""Build a new ECC key (private or public) starting
|
||||
from some base components.
|
||||
|
||||
:Keywords:
|
||||
curve : string
|
||||
Mandatory. It must be "P-256", "prime256v1" or "secp256r1".
|
||||
d : integer
|
||||
Only for a private key. It must be in the range ``[1..order-1]``.
|
||||
point_x : integer
|
||||
Mandatory for a public key. X coordinate (affine) of the ECC point.
|
||||
point_y : integer
|
||||
Mandatory for a public key. Y coordinate (affine) of the ECC point.
|
||||
"""
|
||||
|
||||
point_x = kwargs.pop("point_x", None)
|
||||
point_y = kwargs.pop("point_y", None)
|
||||
|
||||
if "point" in kwargs:
|
||||
raise TypeError("Unknown keyword: point")
|
||||
|
||||
if None not in (point_x, point_y):
|
||||
kwargs["point"] = EccPoint(point_x, point_y)
|
||||
|
||||
# Validate that the point is on the P-256 curve
|
||||
eq1 = pow(Integer(point_y), 2, _curve.p)
|
||||
x = Integer(point_x)
|
||||
eq2 = pow(x, 3, _curve.p)
|
||||
x *= -3
|
||||
eq2 += x
|
||||
eq2 += _curve.b
|
||||
eq2 %= _curve.p
|
||||
|
||||
if eq1 != eq2:
|
||||
raise ValueError("The point is not on the curve")
|
||||
|
||||
# Validate that the private key matches the public one
|
||||
d = kwargs.get("d", None)
|
||||
if d is not None and "point" in kwargs:
|
||||
pub_key = _curve.G * d
|
||||
if pub_key.x != point_x or pub_key.y != point_y:
|
||||
raise ValueError("Private and public ECC keys do not match")
|
||||
|
||||
return EccKey(**kwargs)
|
||||
|
||||
|
||||
def _import_public_der(curve_name, publickey):
|
||||
|
||||
# We only support P-256 named curves for now
|
||||
if curve_name != _curve.oid:
|
||||
raise ValueError("Unsupport curve")
|
||||
|
||||
# ECPoint ::= OCTET STRING
|
||||
|
||||
# We support only uncompressed points
|
||||
order_bytes = _curve.order.size_in_bytes()
|
||||
if len(publickey) != (1 + 2 * order_bytes) or bord(publickey[0]) != 4:
|
||||
raise ValueError("Only uncompressed points are supported")
|
||||
|
||||
point_x = Integer.from_bytes(publickey[1:order_bytes+1])
|
||||
point_y = Integer.from_bytes(publickey[order_bytes+1:])
|
||||
return construct(curve="P-256", point_x=point_x, point_y=point_y)
|
||||
|
||||
|
||||
def _import_subjectPublicKeyInfo(encoded, *kwargs):
|
||||
oid, encoded_key, params = _expand_subject_public_key_info(encoded)
|
||||
|
||||
# We accept id-ecPublicKey, id-ecDH, id-ecMQV without making any
|
||||
# distiction for now.
|
||||
unrestricted_oid = "1.2.840.10045.2.1"
|
||||
ecdh_oid = "1.3.132.1.12"
|
||||
ecmqv_oid = "1.3.132.1.13"
|
||||
|
||||
if oid not in (unrestricted_oid, ecdh_oid, ecmqv_oid) or not params:
|
||||
raise ValueError("Invalid ECC OID")
|
||||
|
||||
# ECParameters ::= CHOICE {
|
||||
# namedCurve OBJECT IDENTIFIER
|
||||
# -- implicitCurve NULL
|
||||
# -- specifiedCurve SpecifiedECDomain
|
||||
# }
|
||||
curve_name = DerObjectId().decode(params).value
|
||||
|
||||
return _import_public_der(curve_name, encoded_key)
|
||||
|
||||
|
||||
def _import_private_der(encoded, passphrase, curve_name=None):
|
||||
|
||||
# ECPrivateKey ::= SEQUENCE {
|
||||
# version INTEGER { ecPrivkeyVer1(1) } (ecPrivkeyVer1),
|
||||
# privateKey OCTET STRING,
|
||||
# parameters [0] ECParameters {{ NamedCurve }} OPTIONAL,
|
||||
# publicKey [1] BIT STRING OPTIONAL
|
||||
# }
|
||||
|
||||
private_key = DerSequence().decode(encoded, nr_elements=(3, 4))
|
||||
if private_key[0] != 1:
|
||||
raise ValueError("Incorrect ECC private key version")
|
||||
|
||||
scalar_bytes = DerOctetString().decode(private_key[1]).payload
|
||||
order_bytes = _curve.order.size_in_bytes()
|
||||
if len(scalar_bytes) != order_bytes:
|
||||
raise ValueError("Private key is too small")
|
||||
d = Integer.from_bytes(scalar_bytes)
|
||||
|
||||
try:
|
||||
curve_name = DerObjectId(explicit=0).decode(private_key[2]).value
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
if curve_name != _curve.oid:
|
||||
raise ValueError("Unsupport curve")
|
||||
|
||||
# Decode public key (if any, it must be P-256)
|
||||
if len(private_key) == 4:
|
||||
public_key_enc = DerBitString(explicit=1).decode(private_key[3]).value
|
||||
public_key = _import_public_der(curve_name, public_key_enc)
|
||||
point_x = public_key.pointQ.x
|
||||
point_y = public_key.pointQ.y
|
||||
else:
|
||||
point_x = point_y = None
|
||||
|
||||
return construct(curve="P-256", d=d, point_x=point_x, point_y=point_y)
|
||||
|
||||
|
||||
def _import_pkcs8(encoded, passphrase):
|
||||
|
||||
# From RFC5915, Section 1:
|
||||
#
|
||||
# Distributing an EC private key with PKCS#8 [RFC5208] involves including:
|
||||
# a) id-ecPublicKey, id-ecDH, or id-ecMQV (from [RFC5480]) with the
|
||||
# namedCurve as the parameters in the privateKeyAlgorithm field; and
|
||||
# b) ECPrivateKey in the PrivateKey field, which is an OCTET STRING.
|
||||
|
||||
algo_oid, private_key, params = PKCS8.unwrap(encoded, passphrase)
|
||||
|
||||
# We accept id-ecPublicKey, id-ecDH, id-ecMQV without making any
|
||||
# distiction for now.
|
||||
unrestricted_oid = "1.2.840.10045.2.1"
|
||||
ecdh_oid = "1.3.132.1.12"
|
||||
ecmqv_oid = "1.3.132.1.13"
|
||||
|
||||
if algo_oid not in (unrestricted_oid, ecdh_oid, ecmqv_oid):
|
||||
raise ValueError("No PKCS#8 encoded ECC key")
|
||||
|
||||
curve_name = DerObjectId().decode(params).value
|
||||
|
||||
return _import_private_der(private_key, passphrase, curve_name)
|
||||
|
||||
|
||||
def _import_x509_cert(encoded, *kwargs):
|
||||
|
||||
sp_info = _extract_subject_public_key_info(encoded)
|
||||
return _import_subjectPublicKeyInfo(sp_info)
|
||||
|
||||
|
||||
def _import_der(encoded, passphrase):
|
||||
|
||||
decodings = (
|
||||
_import_subjectPublicKeyInfo,
|
||||
_import_x509_cert,
|
||||
_import_private_der,
|
||||
_import_pkcs8,
|
||||
)
|
||||
|
||||
for decoding in decodings:
|
||||
try:
|
||||
return decoding(encoded, passphrase)
|
||||
except (ValueError, TypeError, IndexError):
|
||||
pass
|
||||
|
||||
raise ValueError("Not an ECC DER key")
|
||||
|
||||
|
||||
def _import_openssh(encoded):
|
||||
keystring = binascii.a2b_base64(encoded.split(b(' '))[1])
|
||||
|
||||
keyparts = []
|
||||
while len(keystring) > 4:
|
||||
l = struct.unpack(">I", keystring[:4])[0]
|
||||
keyparts.append(keystring[4:4 + l])
|
||||
keystring = keystring[4 + l:]
|
||||
|
||||
if keyparts[1] != b("nistp256"):
|
||||
raise ValueError("Unsupported ECC curve")
|
||||
|
||||
return _import_public_der(_curve.oid, keyparts[2])
|
||||
|
||||
|
||||
def import_key(encoded, passphrase=None):
|
||||
"""Import an ECC key (public or private).
|
||||
|
||||
:Parameters:
|
||||
encoded : bytes or a (multi-line) string
|
||||
The ECC key to import.
|
||||
|
||||
An ECC public key can be:
|
||||
|
||||
- An X.509 certificate, binary (DER) or ASCII (PEM)
|
||||
- An X.509 ``subjectPublicKeyInfo``, binary (DER) or ASCII (PEM)
|
||||
- An OpenSSH line (e.g. the content of ``~/.ssh/id_ecdsa``, ASCII)
|
||||
|
||||
An ECC private key can be:
|
||||
|
||||
- In binary format (DER, see section 3 of `RFC5915`_ or `PKCS#8`_)
|
||||
- In ASCII format (PEM or OpenSSH)
|
||||
|
||||
Private keys can be in the clear or password-protected.
|
||||
|
||||
For details about the PEM encoding, see `RFC1421`_/`RFC1423`_.
|
||||
|
||||
:Keywords:
|
||||
passphrase : byte string
|
||||
The passphrase to use for decrypting a private key.
|
||||
Encryption may be applied protected at the PEM level or at the PKCS#8 level.
|
||||
This parameter is ignored if the key in input is not encrypted.
|
||||
|
||||
:Return: An ECC key object (`EccKey`)
|
||||
|
||||
:Raise ValueError:
|
||||
When the given key cannot be parsed (possibly because
|
||||
the pass phrase is wrong).
|
||||
|
||||
.. _RFC1421: http://www.ietf.org/rfc/rfc1421.txt
|
||||
.. _RFC1423: http://www.ietf.org/rfc/rfc1423.txt
|
||||
.. _RFC5915: http://www.ietf.org/rfc/rfc5915.txt
|
||||
.. _`PKCS#8`: http://www.ietf.org/rfc/rfc5208.txt
|
||||
"""
|
||||
|
||||
encoded = tobytes(encoded)
|
||||
if passphrase is not None:
|
||||
passphrase = tobytes(passphrase)
|
||||
|
||||
# PEM
|
||||
if encoded.startswith(b('-----')):
|
||||
der_encoded, marker, enc_flag = PEM.decode(tostr(encoded), passphrase)
|
||||
if enc_flag:
|
||||
passphrase = None
|
||||
return _import_der(der_encoded, passphrase)
|
||||
|
||||
# OpenSSH
|
||||
if encoded.startswith(b('ecdsa-sha2-')):
|
||||
return _import_openssh(encoded)
|
||||
|
||||
# DER
|
||||
if bord(encoded[0]) == 0x30:
|
||||
return _import_der(encoded, passphrase)
|
||||
|
||||
raise ValueError("ECC key format is not supported")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
import time
|
||||
d = 0xc51e4753afdec1e6b6c6a5b992f43f8dd0c7a8933072708b6522468b2ffb06fd
|
||||
|
||||
point = generate(curve="P-256").pointQ
|
||||
start = time.time()
|
||||
count = 30
|
||||
for x in range(count):
|
||||
_ = point * d
|
||||
print((time.time() - start) / count * 1000, "ms")
|
||||
345
venv/Lib/site-packages/Crypto/PublicKey/ElGamal.py
Normal file
345
venv/Lib/site-packages/Crypto/PublicKey/ElGamal.py
Normal file
|
|
@ -0,0 +1,345 @@
|
|||
#
|
||||
# ElGamal.py : ElGamal encryption/decryption and signatures
|
||||
#
|
||||
# Part of the Python Cryptography Toolkit
|
||||
#
|
||||
# Originally written by: A.M. Kuchling
|
||||
#
|
||||
# ===================================================================
|
||||
# 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.
|
||||
# ===================================================================
|
||||
|
||||
"""ElGamal public-key algorithm (randomized encryption and signature).
|
||||
|
||||
Signature algorithm
|
||||
-------------------
|
||||
The security of the ElGamal signature scheme is based (like DSA) on the discrete
|
||||
logarithm problem (DLP_). Given a cyclic group, a generator *g*,
|
||||
and an element *h*, it is hard to find an integer *x* such that *g^x = h*.
|
||||
|
||||
The group is the largest multiplicative sub-group of the integers modulo *p*,
|
||||
with *p* prime.
|
||||
The signer holds a value *x* (*0<x<p-1*) as private key, and its public
|
||||
key (*y* where *y=g^x mod p*) is distributed.
|
||||
|
||||
The ElGamal signature is twice as big as *p*.
|
||||
|
||||
Encryption algorithm
|
||||
--------------------
|
||||
The security of the ElGamal encryption scheme is based on the computational
|
||||
Diffie-Hellman problem (CDH_). Given a cyclic group, a generator *g*,
|
||||
and two integers *a* and *b*, it is difficult to find
|
||||
the element *g^{ab}* when only *g^a* and *g^b* are known, and not *a* and *b*.
|
||||
|
||||
As before, the group is the largest multiplicative sub-group of the integers
|
||||
modulo *p*, with *p* prime.
|
||||
The receiver holds a value *a* (*0<a<p-1*) as private key, and its public key
|
||||
(*b* where *b*=g^a*) is given to the sender.
|
||||
|
||||
The ElGamal ciphertext is twice as big as *p*.
|
||||
|
||||
Domain parameters
|
||||
-----------------
|
||||
For both signature and encryption schemes, the values *(p,g)* are called
|
||||
*domain parameters*.
|
||||
They are not sensitive but must be distributed to all parties (senders and
|
||||
receivers).
|
||||
Different signers can share the same domain parameters, as can
|
||||
different recipients of encrypted messages.
|
||||
|
||||
Security
|
||||
--------
|
||||
Both DLP and CDH problem are believed to be difficult, and they have been proved
|
||||
such (and therefore secure) for more than 30 years.
|
||||
|
||||
The cryptographic strength is linked to the magnitude of *p*.
|
||||
In 2012, a sufficient size for *p* is deemed to be 2048 bits.
|
||||
For more information, see the most recent ECRYPT_ report.
|
||||
|
||||
Even though ElGamal algorithms are in theory reasonably secure for new designs,
|
||||
in practice there are no real good reasons for using them.
|
||||
The signature is four times larger than the equivalent DSA, and the ciphertext
|
||||
is two times larger than the equivalent RSA.
|
||||
|
||||
Functionality
|
||||
-------------
|
||||
This module provides facilities for generating new ElGamal keys and for constructing
|
||||
them from known components. ElGamal keys allows you to perform basic signing,
|
||||
verification, encryption, and decryption.
|
||||
|
||||
>>> from Crypto import Random
|
||||
>>> from Crypto.PublicKey import ElGamal
|
||||
>>> from Crypto.Hash import SHA
|
||||
>>> from Crypto.Math import Numbers
|
||||
>>>
|
||||
>>> message = "Hello"
|
||||
>>> key = ElGamal.generate(1024, Random.new().read)
|
||||
>>> h = SHA.new(message).digest()
|
||||
>>> while 1:
|
||||
>>> k = Numbers.random_range(min_inclusive=1, min_exclusive=key.p-1)
|
||||
>>> if k.gcd(key.p-1)==1: break
|
||||
>>> sig = key.sign(h,k)
|
||||
>>> ...
|
||||
>>> if key.verify(h,sig):
|
||||
>>> print "OK"
|
||||
>>> else:
|
||||
>>> print "Incorrect signature"
|
||||
|
||||
.. _DLP: http://www.cosic.esat.kuleuven.be/publications/talk-78.pdf
|
||||
.. _CDH: http://en.wikipedia.org/wiki/Computational_Diffie%E2%80%93Hellman_assumption
|
||||
.. _ECRYPT: http://www.ecrypt.eu.org/documents/D.SPA.17.pdf
|
||||
"""
|
||||
|
||||
__all__ = ['generate', 'construct', 'ElGamalKey']
|
||||
|
||||
from Crypto import Random
|
||||
from Crypto.Math.Primality import ( generate_probable_safe_prime,
|
||||
test_probable_prime, COMPOSITE )
|
||||
from Crypto.Math.Numbers import Integer
|
||||
|
||||
# Generate an ElGamal key with N bits
|
||||
def generate(bits, randfunc):
|
||||
"""Randomly generate a fresh, new ElGamal key.
|
||||
|
||||
The key will be safe for use for both encryption and signature
|
||||
(although it should be used for **only one** purpose).
|
||||
|
||||
:Parameters:
|
||||
bits : int
|
||||
Key length, or size (in bits) of the modulus *p*.
|
||||
Recommended value is 2048.
|
||||
randfunc : callable
|
||||
Random number generation function; it should accept
|
||||
a single integer N and return a string of random data
|
||||
N bytes long.
|
||||
|
||||
:attention: You should always use a cryptographically secure random number generator,
|
||||
such as the one defined in the ``Crypto.Random`` module; **don't** just use the
|
||||
current time and the ``random`` module.
|
||||
|
||||
:Return: An ElGamal key object (`ElGamalKey`).
|
||||
"""
|
||||
obj=ElGamalKey()
|
||||
# Generate a safe prime p
|
||||
# See Algorithm 4.86 in Handbook of Applied Cryptography
|
||||
|
||||
obj.p = generate_probable_safe_prime(exact_bits=bits, randfunc=randfunc)
|
||||
q = (obj.p - 1) >> 1
|
||||
|
||||
# Generate generator g
|
||||
# See Algorithm 4.80 in Handbook of Applied Cryptography
|
||||
# Note that the order of the group is n=p-1=2q, where q is prime
|
||||
while 1:
|
||||
# We must avoid g=2 because of Bleichenbacher's attack described
|
||||
# in "Generating ElGamal signatures without knowning the secret key",
|
||||
# 1996
|
||||
#
|
||||
obj.g = Integer.random_range(min_inclusive=3,
|
||||
max_exclusive=obj.p,
|
||||
randfunc=randfunc)
|
||||
safe = 1
|
||||
if pow(obj.g, 2, obj.p)==1:
|
||||
safe=0
|
||||
if safe and pow(obj.g, q, obj.p)==1:
|
||||
safe=0
|
||||
# Discard g if it divides p-1 because of the attack described
|
||||
# in Note 11.67 (iii) in HAC
|
||||
if safe and (obj.p-1) % obj.g == 0:
|
||||
safe=0
|
||||
# g^{-1} must not divide p-1 because of Khadir's attack
|
||||
# described in "Conditions of the generator for forging ElGamal
|
||||
# signature", 2011
|
||||
ginv = obj.g.inverse(obj.p)
|
||||
if safe and (obj.p-1) % ginv == 0:
|
||||
safe=0
|
||||
if safe:
|
||||
break
|
||||
# Generate private key x
|
||||
obj.x = Integer.random_range(min_inclusive=2,
|
||||
max_exclusive=obj.p-1,
|
||||
randfunc=randfunc)
|
||||
# Generate public key y
|
||||
obj.y = pow(obj.g, obj.x, obj.p)
|
||||
return obj
|
||||
|
||||
def construct(tup):
|
||||
"""Construct an ElGamal key from a tuple of valid ElGamal components.
|
||||
|
||||
The modulus *p* must be a prime.
|
||||
|
||||
The following conditions must apply:
|
||||
|
||||
- 1 < g < p-1
|
||||
- g^{p-1} = 1 mod p
|
||||
- 1 < x < p-1
|
||||
- g^x = y mod p
|
||||
|
||||
:Parameters:
|
||||
tup : tuple
|
||||
A tuple of long integers, with 3 or 4 items
|
||||
in the following order:
|
||||
|
||||
1. Modulus (*p*).
|
||||
2. Generator (*g*).
|
||||
3. Public key (*y*).
|
||||
4. Private key (*x*). Optional.
|
||||
|
||||
:Raise PublicKey.ValueError:
|
||||
When the key being imported fails the most basic ElGamal validity checks.
|
||||
:Return: An ElGamal key object (`ElGamalKey`).
|
||||
"""
|
||||
|
||||
obj=ElGamalKey()
|
||||
if len(tup) not in [3,4]:
|
||||
raise ValueError('argument for construct() wrong length')
|
||||
for i in range(len(tup)):
|
||||
field = obj._keydata[i]
|
||||
setattr(obj, field, Integer(tup[i]))
|
||||
|
||||
fmt_error = test_probable_prime(obj.p) == COMPOSITE
|
||||
fmt_error |= obj.g<=1 or obj.g>=obj.p
|
||||
fmt_error |= pow(obj.g, obj.p-1, obj.p)!=1
|
||||
fmt_error |= obj.y<1 or obj.y>=obj.p
|
||||
if len(tup)==4:
|
||||
fmt_error |= obj.x<=1 or obj.x>=obj.p
|
||||
fmt_error |= pow(obj.g, obj.x, obj.p)!=obj.y
|
||||
|
||||
if fmt_error:
|
||||
raise ValueError("Invalid ElGamal key components")
|
||||
|
||||
return obj
|
||||
|
||||
class ElGamalKey(object):
|
||||
"""Class defining an ElGamal key.
|
||||
|
||||
:undocumented: __getstate__, __setstate__, __repr__, __getattr__
|
||||
"""
|
||||
|
||||
#: Dictionary of ElGamal parameters.
|
||||
#:
|
||||
#: A public key will only have the following entries:
|
||||
#:
|
||||
#: - **y**, the public key.
|
||||
#: - **g**, the generator.
|
||||
#: - **p**, the modulus.
|
||||
#:
|
||||
#: A private key will also have:
|
||||
#:
|
||||
#: - **x**, the private key.
|
||||
_keydata=['p', 'g', 'y', 'x']
|
||||
|
||||
def __init__(self, randfunc=None):
|
||||
if randfunc is None:
|
||||
randfunc = Random.new().read
|
||||
self._randfunc = randfunc
|
||||
|
||||
def _encrypt(self, M, K):
|
||||
a=pow(self.g, K, self.p)
|
||||
b=( pow(self.y, K, self.p)*M ) % self.p
|
||||
return list(map(int, ( a,b )))
|
||||
|
||||
def _decrypt(self, M):
|
||||
if (not hasattr(self, 'x')):
|
||||
raise TypeError('Private key not available in this object')
|
||||
r = Integer.random_range(min_inclusive=2,
|
||||
max_exclusive=self.p-1,
|
||||
randfunc=self._randfunc)
|
||||
a_blind = (pow(self.g, r, self.p) * M[0]) % self.p
|
||||
ax=pow(a_blind, self.x, self.p)
|
||||
plaintext_blind = (ax.inverse(self.p) * M[1] ) % self.p
|
||||
plaintext = (plaintext_blind * pow(self.y, r, self.p)) % self.p
|
||||
return int(plaintext)
|
||||
|
||||
def _sign(self, M, K):
|
||||
if (not hasattr(self, 'x')):
|
||||
raise TypeError('Private key not available in this object')
|
||||
p1=self.p-1
|
||||
K = Integer(K)
|
||||
if (K.gcd(p1)!=1):
|
||||
raise ValueError('Bad K value: GCD(K,p-1)!=1')
|
||||
a=pow(self.g, K, self.p)
|
||||
t=(Integer(M)-self.x*a) % p1
|
||||
while t<0: t=t+p1
|
||||
b=(t*K.inverse(p1)) % p1
|
||||
return list(map(int, (a, b)))
|
||||
|
||||
def _verify(self, M, sig):
|
||||
sig = list(map(Integer, sig))
|
||||
if sig[0]<1 or sig[0]>self.p-1:
|
||||
return 0
|
||||
v1=pow(self.y, sig[0], self.p)
|
||||
v1=(v1*pow(sig[0], sig[1], self.p)) % self.p
|
||||
v2=pow(self.g, M, self.p)
|
||||
if v1==v2:
|
||||
return 1
|
||||
return 0
|
||||
|
||||
def has_private(self):
|
||||
if hasattr(self, 'x'):
|
||||
return 1
|
||||
else:
|
||||
return 0
|
||||
|
||||
def can_encrypt(self):
|
||||
return True
|
||||
|
||||
def can_sign(self):
|
||||
return True
|
||||
|
||||
def publickey(self):
|
||||
return construct((self.p, self.g, self.y))
|
||||
|
||||
def __eq__(self, other):
|
||||
if bool(self.has_private()) != bool(other.has_private()):
|
||||
return False
|
||||
|
||||
result = True
|
||||
for comp in self._keydata:
|
||||
result = result and (getattr(self.key, comp, None) ==
|
||||
getattr(other.key, comp, None))
|
||||
return result
|
||||
|
||||
def __ne__(self, other):
|
||||
return not self.__eq__(other)
|
||||
|
||||
def __getstate__(self):
|
||||
# ElGamal key is not pickable
|
||||
from pickle import PicklingError
|
||||
raise PicklingError
|
||||
|
||||
# Methods defined in PyCrypto that we don't support anymore
|
||||
|
||||
def sign(self, M, K):
|
||||
raise NotImplementedError
|
||||
|
||||
def verify(self, M, signature):
|
||||
raise NotImplementedError
|
||||
|
||||
def encrypt(self, plaintext, K):
|
||||
raise NotImplementedError
|
||||
|
||||
def decrypt(self, ciphertext):
|
||||
raise NotImplementedError
|
||||
|
||||
def blind(self, M, B):
|
||||
raise NotImplementedError
|
||||
|
||||
def unblind(self, M, B):
|
||||
raise NotImplementedError
|
||||
|
||||
def size():
|
||||
raise NotImplementedError
|
||||
767
venv/Lib/site-packages/Crypto/PublicKey/RSA.py
Normal file
767
venv/Lib/site-packages/Crypto/PublicKey/RSA.py
Normal file
|
|
@ -0,0 +1,767 @@
|
|||
# ===================================================================
|
||||
#
|
||||
# Copyright (c) 2016, Legrandin <helderijs@gmail.com>
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in
|
||||
# the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
# POSSIBILITY OF SUCH DAMAGE.
|
||||
# ===================================================================
|
||||
|
||||
"""RSA public-key cryptography algorithm (signature and encryption).
|
||||
|
||||
RSA_ is the most widespread and used public key algorithm. Its security is
|
||||
based on the difficulty of factoring large integers. The algorithm has
|
||||
withstood attacks for 30 years, and it is therefore considered reasonably
|
||||
secure for new designs.
|
||||
|
||||
The algorithm can be used for both confidentiality (encryption) and
|
||||
authentication (digital signature). It is worth noting that signing and
|
||||
decryption are significantly slower than verification and encryption.
|
||||
The cryptograhic strength is primarily linked to the length of the modulus *n*.
|
||||
In 2012, a sufficient length is deemed to be 2048 bits. For more information,
|
||||
see the most recent ECRYPT_ report.
|
||||
|
||||
Both RSA ciphertext and RSA signature are as big as the modulus *n* (256
|
||||
bytes if *n* is 2048 bit long).
|
||||
|
||||
This module provides facilities for generating fresh, new RSA keys,
|
||||
constructing them from known components, exporting them, and importing them.
|
||||
|
||||
>>> from Crypto.PublicKey import RSA
|
||||
>>>
|
||||
>>> key = RSA.generate(2048)
|
||||
>>> f = open('mykey.pem','w')
|
||||
>>> f.write(key.exportKey('PEM'))
|
||||
>>> f.close()
|
||||
...
|
||||
>>> f = open('mykey.pem','r')
|
||||
>>> key = RSA.import_key(f.read())
|
||||
|
||||
Even though you may choose to directly use the methods of an RSA key object
|
||||
to perform the primitive cryptographic operations (e.g. `RsaKey._encrypt`),
|
||||
it is recommended to use one of the standardized schemes instead (like
|
||||
`Crypto.Cipher.PKCS1_v1_5` or `Crypto.Signature.PKCS1_v1_5`).
|
||||
|
||||
.. _RSA: http://en.wikipedia.org/wiki/RSA_%28algorithm%29
|
||||
.. _ECRYPT: http://www.ecrypt.eu.org/documents/D.SPA.17.pdf
|
||||
|
||||
:sort: generate,construct,import_key
|
||||
"""
|
||||
|
||||
__all__ = ['generate', 'construct', 'import_key',
|
||||
'RsaKey', 'oid']
|
||||
|
||||
import binascii
|
||||
import struct
|
||||
|
||||
from Crypto import Random
|
||||
from Crypto.IO import PKCS8, PEM
|
||||
from Crypto.Util.py3compat import tobytes, bord, bchr, b, tostr
|
||||
from Crypto.Util.asn1 import DerSequence
|
||||
|
||||
from Crypto.Math.Numbers import Integer
|
||||
from Crypto.Math.Primality import (test_probable_prime,
|
||||
generate_probable_prime, COMPOSITE)
|
||||
|
||||
from Crypto.PublicKey import (_expand_subject_public_key_info,
|
||||
_create_subject_public_key_info,
|
||||
_extract_subject_public_key_info)
|
||||
|
||||
|
||||
class RsaKey(object):
|
||||
"""Class defining an actual RSA key.
|
||||
|
||||
:undocumented: __init__, __repr__, __getstate__, __eq__, __ne__, __str__,
|
||||
sign, verify, encrypt, decrypt, blind, unblind, size
|
||||
"""
|
||||
|
||||
def __init__(self, **kwargs):
|
||||
"""Build an RSA key.
|
||||
|
||||
:Keywords:
|
||||
n : integer
|
||||
The modulus.
|
||||
e : integer
|
||||
The public exponent.
|
||||
d : integer
|
||||
The private exponent. Only required for private keys.
|
||||
p : integer
|
||||
The first factor of the modulus. Only required for private keys.
|
||||
q : integer
|
||||
The second factor of the modulus. Only required for private keys.
|
||||
u : integer
|
||||
The CRT coefficient (inverse of p modulo q). Only required for
|
||||
privta keys.
|
||||
"""
|
||||
|
||||
input_set = set(kwargs.keys())
|
||||
public_set = set(('n', 'e'))
|
||||
private_set = public_set | set(('p', 'q', 'd', 'u'))
|
||||
if input_set not in (private_set, public_set):
|
||||
raise ValueError("Some RSA components are missing")
|
||||
for component, value in list(kwargs.items()):
|
||||
setattr(self, "_" + component, value)
|
||||
|
||||
@property
|
||||
def n(self):
|
||||
"""Modulus"""
|
||||
return int(self._n)
|
||||
|
||||
@property
|
||||
def e(self):
|
||||
"""Public exponent"""
|
||||
return int(self._e)
|
||||
|
||||
@property
|
||||
def d(self):
|
||||
"""Private exponent"""
|
||||
if not self.has_private():
|
||||
raise AttributeError("No private exponent available for public keys")
|
||||
return int(self._d)
|
||||
|
||||
@property
|
||||
def p(self):
|
||||
"""First factor of the modulus"""
|
||||
if not self.has_private():
|
||||
raise AttributeError("No CRT component 'p' available for public keys")
|
||||
return int(self._p)
|
||||
|
||||
@property
|
||||
def q(self):
|
||||
"""Second factor of the modulus"""
|
||||
if not self.has_private():
|
||||
raise AttributeError("No CRT component 'q' available for public keys")
|
||||
return int(self._q)
|
||||
|
||||
@property
|
||||
def u(self):
|
||||
"""Chinese remainder component (inverse of *p* modulo *q*)"""
|
||||
if not self.has_private():
|
||||
raise AttributeError("No CRT component 'u' available for public keys")
|
||||
return int(self._u)
|
||||
|
||||
def size_in_bits(self):
|
||||
"""Size of the RSA modulus in bits"""
|
||||
return self._n.size_in_bits()
|
||||
|
||||
def size_in_bytes(self):
|
||||
"""The minimal amount of bytes that can hold the RSA modulus"""
|
||||
return (self._n.size_in_bits() - 1) // 8 + 1
|
||||
|
||||
def _encrypt(self, plaintext):
|
||||
if not 0 < plaintext < self._n:
|
||||
raise ValueError("Plaintext too large")
|
||||
return int(pow(Integer(plaintext), self._e, self._n))
|
||||
|
||||
def _decrypt(self, ciphertext):
|
||||
if not 0 < ciphertext < self._n:
|
||||
raise ValueError("Ciphertext too large")
|
||||
if not self.has_private():
|
||||
raise TypeError("This is not a private key")
|
||||
|
||||
# Blinded RSA decryption (to prevent timing attacks):
|
||||
# Step 1: Generate random secret blinding factor r,
|
||||
# such that 0 < r < n-1
|
||||
r = Integer.random_range(min_inclusive=1, max_exclusive=self._n)
|
||||
# Step 2: Compute c' = c * r**e mod n
|
||||
cp = Integer(ciphertext) * pow(r, self._e, self._n) % self._n
|
||||
# Step 3: Compute m' = c'**d mod n (ordinary RSA decryption)
|
||||
m1 = pow(cp, self._d % (self._p - 1), self._p)
|
||||
m2 = pow(cp, self._d % (self._q - 1), self._q)
|
||||
h = m2 - m1
|
||||
while h < 0:
|
||||
h += self._q
|
||||
h = (h * self._u) % self._q
|
||||
mp = h * self._p + m1
|
||||
# Step 4: Compute m = m**(r-1) mod n
|
||||
result = (r.inverse(self._n) * mp) % self._n
|
||||
# Verify no faults occured
|
||||
if ciphertext != pow(result, self._e, self._n):
|
||||
raise ValueError("Fault detected in RSA decryption")
|
||||
return result
|
||||
|
||||
def has_private(self):
|
||||
return hasattr(self, "_d")
|
||||
|
||||
def can_encrypt(self):
|
||||
return True
|
||||
|
||||
def can_sign(self):
|
||||
return True
|
||||
|
||||
def publickey(self):
|
||||
return RsaKey(n=self._n, e=self._e)
|
||||
|
||||
def __eq__(self, other):
|
||||
if self.has_private() != other.has_private():
|
||||
return False
|
||||
if self.n != other.n or self.e != other.e:
|
||||
return False
|
||||
if not self.has_private():
|
||||
return True
|
||||
return (self.d == other.d and
|
||||
self.q == other.q and
|
||||
self.p == other.p and
|
||||
self.u == other.u)
|
||||
|
||||
def __ne__(self, other):
|
||||
return not (self == other)
|
||||
|
||||
def __getstate__(self):
|
||||
# RSA key is not pickable
|
||||
from pickle import PicklingError
|
||||
raise PicklingError
|
||||
|
||||
def __repr__(self):
|
||||
if self.has_private():
|
||||
extra = ", d=%d, p=%d, q=%d, u=%d" % (int(self._d), int(self._p),
|
||||
int(self._q), int(self._u))
|
||||
else:
|
||||
extra = ""
|
||||
return "RsaKey(n=%d, e=%d%s)" % (int(self._n), int(self._e), extra)
|
||||
|
||||
def __str__(self):
|
||||
if self.has_private():
|
||||
key_type = "Private"
|
||||
else:
|
||||
key_type = "Public"
|
||||
return "%s RSA key at 0x%X" % (key_type, id(self))
|
||||
|
||||
def exportKey(self, format='PEM', passphrase=None, pkcs=1,
|
||||
protection=None, randfunc=None):
|
||||
"""Export this RSA key.
|
||||
|
||||
:Parameters:
|
||||
format : string
|
||||
The format to use for wrapping the key:
|
||||
|
||||
- *'DER'*. Binary encoding.
|
||||
- *'PEM'*. Textual encoding, done according to `RFC1421`_/`RFC1423`_.
|
||||
- *'OpenSSH'*. Textual encoding, done according to OpenSSH specification.
|
||||
Only suitable for public keys (not private keys).
|
||||
|
||||
passphrase : string
|
||||
For private keys only. The pass phrase used for deriving the encryption
|
||||
key.
|
||||
|
||||
pkcs : integer
|
||||
For *DER* and *PEM* format only.
|
||||
The PKCS standard to follow for assembling the components of the key.
|
||||
You have two choices:
|
||||
|
||||
- **1** (default): the public key is embedded into
|
||||
an X.509 ``SubjectPublicKeyInfo`` DER SEQUENCE.
|
||||
The private key is embedded into a `PKCS#1`_
|
||||
``RSAPrivateKey`` DER SEQUENCE.
|
||||
- **8**: the private key is embedded into a `PKCS#8`_
|
||||
``PrivateKeyInfo`` DER SEQUENCE. This value cannot be used
|
||||
for public keys.
|
||||
|
||||
protection : string
|
||||
The encryption scheme to use for protecting the private key.
|
||||
|
||||
If ``None`` (default), the behavior depends on ``format``:
|
||||
|
||||
- For *DER*, the *PBKDF2WithHMAC-SHA1AndDES-EDE3-CBC*
|
||||
scheme is used. The following operations are performed:
|
||||
|
||||
1. A 16 byte Triple DES key is derived from the passphrase
|
||||
using `Crypto.Protocol.KDF.PBKDF2` with 8 bytes salt,
|
||||
and 1 000 iterations of `Crypto.Hash.HMAC`.
|
||||
2. The private key is encrypted using CBC.
|
||||
3. The encrypted key is encoded according to PKCS#8.
|
||||
|
||||
- For *PEM*, the obsolete PEM encryption scheme is used.
|
||||
It is based on MD5 for key derivation, and Triple DES for encryption.
|
||||
|
||||
Specifying a value for ``protection`` is only meaningful for PKCS#8
|
||||
(that is, ``pkcs=8``) and only if a pass phrase is present too.
|
||||
|
||||
The supported schemes for PKCS#8 are listed in the
|
||||
`Crypto.IO.PKCS8` module (see ``wrap_algo`` parameter).
|
||||
|
||||
randfunc : callable
|
||||
A function that provides random bytes. Only used for PEM encoding.
|
||||
The default is `Crypto.Random.get_random_bytes`.
|
||||
|
||||
:Return: A byte string with the encoded public or private half
|
||||
of the key.
|
||||
:Raise ValueError:
|
||||
When the format is unknown or when you try to encrypt a private
|
||||
key with *DER* format and PKCS#1.
|
||||
:attention:
|
||||
If you don't provide a pass phrase, the private key will be
|
||||
exported in the clear!
|
||||
|
||||
.. _RFC1421: http://www.ietf.org/rfc/rfc1421.txt
|
||||
.. _RFC1423: http://www.ietf.org/rfc/rfc1423.txt
|
||||
.. _`PKCS#1`: http://www.ietf.org/rfc/rfc3447.txt
|
||||
.. _`PKCS#8`: http://www.ietf.org/rfc/rfc5208.txt
|
||||
"""
|
||||
|
||||
if passphrase is not None:
|
||||
passphrase = tobytes(passphrase)
|
||||
|
||||
if randfunc is None:
|
||||
randfunc = Random.get_random_bytes
|
||||
|
||||
if format == 'OpenSSH':
|
||||
e_bytes, n_bytes = [x.to_bytes() for x in (self._e, self._n)]
|
||||
if bord(e_bytes[0]) & 0x80:
|
||||
e_bytes = bchr(0) + e_bytes
|
||||
if bord(n_bytes[0]) & 0x80:
|
||||
n_bytes = bchr(0) + n_bytes
|
||||
keyparts = [b('ssh-rsa'), e_bytes, n_bytes]
|
||||
keystring = b('').join([struct.pack(">I", len(kp)) + kp for kp in keyparts])
|
||||
return b('ssh-rsa ') + binascii.b2a_base64(keystring)[:-1]
|
||||
|
||||
# DER format is always used, even in case of PEM, which simply
|
||||
# encodes it into BASE64.
|
||||
if self.has_private():
|
||||
binary_key = DerSequence([0,
|
||||
self.n,
|
||||
self.e,
|
||||
self.d,
|
||||
self.p,
|
||||
self.q,
|
||||
self.d % (self.p-1),
|
||||
self.d % (self.q-1),
|
||||
Integer(self.q).inverse(self.p)
|
||||
]).encode()
|
||||
if pkcs == 1:
|
||||
key_type = 'RSA PRIVATE KEY'
|
||||
if format == 'DER' and passphrase:
|
||||
raise ValueError("PKCS#1 private key cannot be encrypted")
|
||||
else: # PKCS#8
|
||||
if format == 'PEM' and protection is None:
|
||||
key_type = 'PRIVATE KEY'
|
||||
binary_key = PKCS8.wrap(binary_key, oid, None)
|
||||
else:
|
||||
key_type = 'ENCRYPTED PRIVATE KEY'
|
||||
if not protection:
|
||||
protection = 'PBKDF2WithHMAC-SHA1AndDES-EDE3-CBC'
|
||||
binary_key = PKCS8.wrap(binary_key, oid,
|
||||
passphrase, protection)
|
||||
passphrase = None
|
||||
else:
|
||||
key_type = "RSA PUBLIC KEY"
|
||||
binary_key = _create_subject_public_key_info(oid,
|
||||
DerSequence([self.n,
|
||||
self.e])
|
||||
)
|
||||
|
||||
if format == 'DER':
|
||||
return binary_key
|
||||
if format == 'PEM':
|
||||
pem_str = PEM.encode(binary_key, key_type, passphrase, randfunc)
|
||||
return tobytes(pem_str)
|
||||
|
||||
raise ValueError("Unknown key format '%s'. Cannot export the RSA key." % format)
|
||||
|
||||
# Methods defined in PyCrypto that we don't support anymore
|
||||
def sign(self, M, K):
|
||||
raise NotImplementedError("Use module Crypto.Signature.pkcs1_15 instead")
|
||||
|
||||
def verify(self, M, signature):
|
||||
raise NotImplementedError("Use module Crypto.Signature.pkcs1_15 instead")
|
||||
|
||||
def encrypt(self, plaintext, K):
|
||||
raise NotImplementedError("Use module Crypto.Cipher.PKCS1_OAEP instead")
|
||||
|
||||
def decrypt(self, ciphertext):
|
||||
raise NotImplementedError("Use module Crypto.Cipher.PKCS1_OAEP instead")
|
||||
|
||||
def blind(self, M, B):
|
||||
raise NotImplementedError
|
||||
|
||||
def unblind(self, M, B):
|
||||
raise NotImplementedError
|
||||
|
||||
def size():
|
||||
raise NotImplementedError
|
||||
|
||||
|
||||
def generate(bits, randfunc=None, e=65537):
|
||||
"""Create a new RSA key.
|
||||
|
||||
The algorithm closely follows NIST `FIPS 186-4`_ in its
|
||||
sections B.3.1 and B.3.3. The modulus is the product of
|
||||
two non-strong probable primes.
|
||||
Each prime passes a suitable number of Miller-Rabin tests
|
||||
with random bases and a single Lucas test.
|
||||
|
||||
:Parameters:
|
||||
bits : integer
|
||||
Key length, or size (in bits) of the RSA modulus.
|
||||
It must be at least 1024.
|
||||
The FIPS standard only defines 1024, 2048 and 3072.
|
||||
randfunc : callable
|
||||
Function that returns random bytes.
|
||||
The default is `Crypto.Random.get_random_bytes`.
|
||||
e : integer
|
||||
Public RSA exponent. It must be an odd positive integer.
|
||||
It is typically a small number with very few ones in its
|
||||
binary representation.
|
||||
The FIPS standard requires the public exponent to be
|
||||
at least 65537 (the default).
|
||||
|
||||
:Return: An RSA key object (`RsaKey`).
|
||||
|
||||
.. _FIPS 186-4: http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf
|
||||
"""
|
||||
|
||||
if bits < 1024:
|
||||
raise ValueError("RSA modulus length must be >= 1024")
|
||||
if e % 2 == 0 or e < 3:
|
||||
raise ValueError("RSA public exponent must be a positive, odd integer larger than 2.")
|
||||
|
||||
if randfunc is None:
|
||||
randfunc = Random.get_random_bytes
|
||||
|
||||
d = n = Integer(1)
|
||||
e = Integer(e)
|
||||
|
||||
while n.size_in_bits() != bits and d < (1 << (bits // 2)):
|
||||
# Generate the prime factors of n: p and q.
|
||||
# By construciton, their product is always
|
||||
# 2^{bits-1} < p*q < 2^bits.
|
||||
size_q = bits // 2
|
||||
size_p = bits - size_q
|
||||
|
||||
min_p = min_q = (Integer(1) << (2 * size_q - 1)).sqrt()
|
||||
if size_q != size_p:
|
||||
min_p = (Integer(1) << (2 * size_p - 1)).sqrt()
|
||||
|
||||
def filter_p(candidate):
|
||||
return candidate > min_p and (candidate - 1).gcd(e) == 1
|
||||
|
||||
p = generate_probable_prime(exact_bits=size_p,
|
||||
randfunc=randfunc,
|
||||
prime_filter=filter_p)
|
||||
|
||||
min_distance = Integer(1) << (bits // 2 - 100)
|
||||
|
||||
def filter_q(candidate):
|
||||
return (candidate > min_q and
|
||||
(candidate - 1).gcd(e) == 1 and
|
||||
abs(candidate - p) > min_distance)
|
||||
|
||||
q = generate_probable_prime(exact_bits=size_q,
|
||||
randfunc=randfunc,
|
||||
prime_filter=filter_q)
|
||||
|
||||
n = p * q
|
||||
lcm = (p - 1).lcm(q - 1)
|
||||
d = e.inverse(lcm)
|
||||
|
||||
if p > q:
|
||||
p, q = q, p
|
||||
|
||||
u = p.inverse(q)
|
||||
|
||||
return RsaKey(n=n, e=e, d=d, p=p, q=q, u=u)
|
||||
|
||||
|
||||
def construct(rsa_components, consistency_check=True):
|
||||
"""Construct an RSA key from a tuple of valid RSA components.
|
||||
|
||||
The modulus **n** must be the product of two primes.
|
||||
The public exponent **e** must be odd and larger than 1.
|
||||
|
||||
In case of a private key, the following equations must apply:
|
||||
|
||||
- e != 1
|
||||
- p*q = n
|
||||
- e*d = 1 mod lcm[(p-1)(q-1)]
|
||||
- p*u = 1 mod q
|
||||
|
||||
:Parameters:
|
||||
rsa_components : tuple
|
||||
A tuple of long integers, with at least 2 and no
|
||||
more than 6 items. The items come in the following order:
|
||||
|
||||
1. RSA modulus (*n*).
|
||||
2. Public exponent (*e*).
|
||||
3. Private exponent (*d*).
|
||||
Only required if the key is private.
|
||||
4. First factor of *n* (*p*).
|
||||
Optional, but factor q must also be present.
|
||||
5. Second factor of *n* (*q*). Optional.
|
||||
6. CRT coefficient, *(1/p) mod q* (*u*). Optional.
|
||||
consistency_check : boolean
|
||||
If *True*, the library will verify that the provided components
|
||||
fulfil the main RSA properties.
|
||||
|
||||
:Raise ValueError:
|
||||
When the key being imported fails the most basic RSA validity checks.
|
||||
:Return: An RSA key object (`RsaKey`).
|
||||
"""
|
||||
|
||||
class InputComps(object):
|
||||
pass
|
||||
|
||||
input_comps = InputComps()
|
||||
for (comp, value) in zip(('n', 'e', 'd', 'p', 'q', 'u'), rsa_components):
|
||||
setattr(input_comps, comp, Integer(value))
|
||||
|
||||
n = input_comps.n
|
||||
e = input_comps.e
|
||||
if not hasattr(input_comps, 'd'):
|
||||
key = RsaKey(n=n, e=e)
|
||||
else:
|
||||
d = input_comps.d
|
||||
if hasattr(input_comps, 'q'):
|
||||
p = input_comps.p
|
||||
q = input_comps.q
|
||||
else:
|
||||
# Compute factors p and q from the private exponent d.
|
||||
# We assume that n has no more than two factors.
|
||||
# See 8.2.2(i) in Handbook of Applied Cryptography.
|
||||
ktot = d * e - 1
|
||||
# The quantity d*e-1 is a multiple of phi(n), even,
|
||||
# and can be represented as t*2^s.
|
||||
t = ktot
|
||||
while t % 2 == 0:
|
||||
t //= 2
|
||||
# Cycle through all multiplicative inverses in Zn.
|
||||
# The algorithm is non-deterministic, but there is a 50% chance
|
||||
# any candidate a leads to successful factoring.
|
||||
# See "Digitalized Signatures and Public Key Functions as Intractable
|
||||
# as Factorization", M. Rabin, 1979
|
||||
spotted = False
|
||||
a = Integer(2)
|
||||
while not spotted and a < 100:
|
||||
k = Integer(t)
|
||||
# Cycle through all values a^{t*2^i}=a^k
|
||||
while k < ktot:
|
||||
cand = pow(a, k, n)
|
||||
# Check if a^k is a non-trivial root of unity (mod n)
|
||||
if cand != 1 and cand != (n - 1) and pow(cand, 2, n) == 1:
|
||||
# We have found a number such that (cand-1)(cand+1)=0 (mod n).
|
||||
# Either of the terms divides n.
|
||||
p = Integer(n).gcd(cand + 1)
|
||||
spotted = True
|
||||
break
|
||||
k *= 2
|
||||
# This value was not any good... let's try another!
|
||||
a += 2
|
||||
if not spotted:
|
||||
raise ValueError("Unable to compute factors p and q from exponent d.")
|
||||
# Found !
|
||||
assert ((n % p) == 0)
|
||||
q = n // p
|
||||
|
||||
if hasattr(input_comps, 'u'):
|
||||
u = input_comps.u
|
||||
else:
|
||||
u = p.inverse(q)
|
||||
|
||||
# Build key object
|
||||
key = RsaKey(n=n, e=e, d=d, p=p, q=q, u=u)
|
||||
|
||||
# Very consistency of the key
|
||||
fmt_error = False
|
||||
if consistency_check:
|
||||
# Modulus and public exponent must be coprime
|
||||
fmt_error = e <= 1 or e >= n
|
||||
fmt_error |= Integer(n).gcd(e) != 1
|
||||
|
||||
# For RSA, modulus must be odd
|
||||
fmt_error |= not n & 1
|
||||
|
||||
if not fmt_error and key.has_private():
|
||||
# Modulus and private exponent must be coprime
|
||||
fmt_error = d <= 1 or d >= n
|
||||
fmt_error |= Integer(n).gcd(d) != 1
|
||||
# Modulus must be product of 2 primes
|
||||
fmt_error |= (p * q != n)
|
||||
fmt_error |= test_probable_prime(p) == COMPOSITE
|
||||
fmt_error |= test_probable_prime(q) == COMPOSITE
|
||||
# See Carmichael theorem
|
||||
phi = (p - 1) * (q - 1)
|
||||
lcm = phi // (p - 1).gcd(q - 1)
|
||||
fmt_error |= (e * d % int(lcm)) != 1
|
||||
if hasattr(key, 'u'):
|
||||
# CRT coefficient
|
||||
fmt_error |= u <= 1 or u >= q
|
||||
fmt_error |= (p * u % q) != 1
|
||||
else:
|
||||
fmt_error = True
|
||||
|
||||
if fmt_error:
|
||||
raise ValueError("Invalid RSA key components")
|
||||
|
||||
return key
|
||||
|
||||
|
||||
def _import_pkcs1_private(encoded, *kwargs):
|
||||
# RSAPrivateKey ::= SEQUENCE {
|
||||
# version Version,
|
||||
# modulus INTEGER, -- n
|
||||
# publicExponent INTEGER, -- e
|
||||
# privateExponent INTEGER, -- d
|
||||
# prime1 INTEGER, -- p
|
||||
# prime2 INTEGER, -- q
|
||||
# exponent1 INTEGER, -- d mod (p-1)
|
||||
# exponent2 INTEGER, -- d mod (q-1)
|
||||
# coefficient INTEGER -- (inverse of q) mod p
|
||||
# }
|
||||
#
|
||||
# Version ::= INTEGER
|
||||
der = DerSequence().decode(encoded, nr_elements=9, only_ints_expected=True)
|
||||
if der[0] != 0:
|
||||
raise ValueError("No PKCS#1 encoding of an RSA private key")
|
||||
return construct(der[1:6] + [Integer(der[4]).inverse(der[5])])
|
||||
|
||||
|
||||
def _import_pkcs1_public(encoded, *kwargs):
|
||||
# RSAPublicKey ::= SEQUENCE {
|
||||
# modulus INTEGER, -- n
|
||||
# publicExponent INTEGER -- e
|
||||
# }
|
||||
der = DerSequence().decode(encoded, nr_elements=2, only_ints_expected=True)
|
||||
return construct(der)
|
||||
|
||||
|
||||
def _import_subjectPublicKeyInfo(encoded, *kwargs):
|
||||
|
||||
algoid, encoded_key, params = _expand_subject_public_key_info(encoded)
|
||||
if algoid != oid or params is not None:
|
||||
raise ValueError("No RSA subjectPublicKeyInfo")
|
||||
return _import_pkcs1_public(encoded_key)
|
||||
|
||||
|
||||
def _import_x509_cert(encoded, *kwargs):
|
||||
|
||||
sp_info = _extract_subject_public_key_info(encoded)
|
||||
return _import_subjectPublicKeyInfo(sp_info)
|
||||
|
||||
|
||||
def _import_pkcs8(encoded, passphrase):
|
||||
k = PKCS8.unwrap(encoded, passphrase)
|
||||
if k[0] != oid:
|
||||
raise ValueError("No PKCS#8 encoded RSA key")
|
||||
return _import_keyDER(k[1], passphrase)
|
||||
|
||||
|
||||
def _import_keyDER(extern_key, passphrase):
|
||||
"""Import an RSA key (public or private half), encoded in DER form."""
|
||||
|
||||
decodings = (_import_pkcs1_private,
|
||||
_import_pkcs1_public,
|
||||
_import_subjectPublicKeyInfo,
|
||||
_import_x509_cert,
|
||||
_import_pkcs8)
|
||||
|
||||
for decoding in decodings:
|
||||
try:
|
||||
return decoding(extern_key, passphrase)
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
raise ValueError("RSA key format is not supported")
|
||||
|
||||
|
||||
def import_key(extern_key, passphrase=None):
|
||||
"""Import an RSA key (public or private half), encoded in standard
|
||||
form.
|
||||
|
||||
:Parameter extern_key:
|
||||
The RSA key to import, encoded as a byte string.
|
||||
|
||||
An RSA public key can be in any of the following formats:
|
||||
|
||||
- X.509 certificate (binary or PEM format)
|
||||
- X.509 ``subjectPublicKeyInfo`` DER SEQUENCE (binary or PEM
|
||||
encoding)
|
||||
- `PKCS#1`_ ``RSAPublicKey`` DER SEQUENCE (binary or PEM encoding)
|
||||
- OpenSSH (textual public key only)
|
||||
|
||||
An RSA private key can be in any of the following formats:
|
||||
|
||||
- PKCS#1 ``RSAPrivateKey`` DER SEQUENCE (binary or PEM encoding)
|
||||
- `PKCS#8`_ ``PrivateKeyInfo`` or ``EncryptedPrivateKeyInfo``
|
||||
DER SEQUENCE (binary or PEM encoding)
|
||||
- OpenSSH (textual public key only)
|
||||
|
||||
For details about the PEM encoding, see `RFC1421`_/`RFC1423`_.
|
||||
|
||||
The private key may be encrypted by means of a certain pass phrase
|
||||
either at the PEM level or at the PKCS#8 level.
|
||||
:Type extern_key: string
|
||||
|
||||
:Parameter passphrase:
|
||||
In case of an encrypted private key, this is the pass phrase from
|
||||
which the decryption key is derived.
|
||||
:Type passphrase: string
|
||||
|
||||
:Return: An RSA key object (`RsaKey`).
|
||||
|
||||
:Raise ValueError/IndexError/TypeError:
|
||||
When the given key cannot be parsed (possibly because the pass
|
||||
phrase is wrong).
|
||||
|
||||
.. _RFC1421: http://www.ietf.org/rfc/rfc1421.txt
|
||||
.. _RFC1423: http://www.ietf.org/rfc/rfc1423.txt
|
||||
.. _`PKCS#1`: http://www.ietf.org/rfc/rfc3447.txt
|
||||
.. _`PKCS#8`: http://www.ietf.org/rfc/rfc5208.txt
|
||||
"""
|
||||
extern_key = tobytes(extern_key)
|
||||
if passphrase is not None:
|
||||
passphrase = tobytes(passphrase)
|
||||
|
||||
if extern_key.startswith(b('-----')):
|
||||
# This is probably a PEM encoded key.
|
||||
(der, marker, enc_flag) = PEM.decode(tostr(extern_key), passphrase)
|
||||
if enc_flag:
|
||||
passphrase = None
|
||||
return _import_keyDER(der, passphrase)
|
||||
|
||||
if extern_key.startswith(b('ssh-rsa ')):
|
||||
# This is probably an OpenSSH key
|
||||
keystring = binascii.a2b_base64(extern_key.split(b(' '))[1])
|
||||
keyparts = []
|
||||
while len(keystring) > 4:
|
||||
l = struct.unpack(">I", keystring[:4])[0]
|
||||
keyparts.append(keystring[4:4 + l])
|
||||
keystring = keystring[4 + l:]
|
||||
e = Integer.from_bytes(keyparts[1])
|
||||
n = Integer.from_bytes(keyparts[2])
|
||||
return construct([n, e])
|
||||
|
||||
if bord(extern_key[0]) == 0x30:
|
||||
# This is probably a DER encoded key
|
||||
return _import_keyDER(extern_key, passphrase)
|
||||
|
||||
raise ValueError("RSA key format is not supported")
|
||||
|
||||
# Backward compatibility
|
||||
importKey = import_key
|
||||
|
||||
#: `Object ID`_ for the RSA encryption algorithm. This OID often indicates
|
||||
#: a generic RSA key, even when such key will be actually used for digital
|
||||
#: signatures.
|
||||
#:
|
||||
#: .. _`Object ID`: http://www.alvestrand.no/objectid/1.2.840.113549.1.1.1.html
|
||||
oid = "1.2.840.113549.1.1.1"
|
||||
103
venv/Lib/site-packages/Crypto/PublicKey/__init__.py
Normal file
103
venv/Lib/site-packages/Crypto/PublicKey/__init__.py
Normal file
|
|
@ -0,0 +1,103 @@
|
|||
# -*- 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.
|
||||
# ===================================================================
|
||||
|
||||
"""Public-key encryption and signature algorithms.
|
||||
|
||||
Public-key encryption uses two different keys, one for encryption and
|
||||
one for decryption. The encryption key can be made public, and the
|
||||
decryption key is kept private. Many public-key algorithms can also
|
||||
be used to sign messages, and some can *only* be used for signatures.
|
||||
"""
|
||||
|
||||
from Crypto.Util.asn1 import (DerSequence, DerInteger, DerBitString,
|
||||
DerObjectId, DerNull)
|
||||
|
||||
|
||||
def _expand_subject_public_key_info(encoded):
|
||||
"""Parse a SubjectPublicKeyInfo structure.
|
||||
|
||||
It returns a triple with:
|
||||
* OID (string)
|
||||
* encoded public key (bytes)
|
||||
* Algorithm parameters (bytes or None)
|
||||
"""
|
||||
|
||||
#
|
||||
# SubjectPublicKeyInfo ::= SEQUENCE {
|
||||
# algorithm AlgorithmIdentifier,
|
||||
# subjectPublicKey BIT STRING
|
||||
# }
|
||||
#
|
||||
# AlgorithmIdentifier ::= SEQUENCE {
|
||||
# algorithm OBJECT IDENTIFIER,
|
||||
# parameters ANY DEFINED BY algorithm OPTIONAL
|
||||
# }
|
||||
#
|
||||
|
||||
spki = DerSequence().decode(encoded, nr_elements=2)
|
||||
algo = DerSequence().decode(spki[0], nr_elements=(1,2))
|
||||
algo_oid = DerObjectId().decode(algo[0])
|
||||
spk = DerBitString().decode(spki[1]).value
|
||||
|
||||
if len(algo) == 1:
|
||||
algo_params = None
|
||||
else:
|
||||
try:
|
||||
DerNull().decode(algo[1])
|
||||
algo_params = None
|
||||
except:
|
||||
algo_params = algo[1]
|
||||
|
||||
return algo_oid.value, spk, algo_params
|
||||
|
||||
|
||||
def _create_subject_public_key_info(algo_oid, secret_key, params=None):
|
||||
|
||||
if params is None:
|
||||
params = DerNull()
|
||||
|
||||
spki = DerSequence([
|
||||
DerSequence([
|
||||
DerObjectId(algo_oid),
|
||||
params]),
|
||||
DerBitString(secret_key)
|
||||
])
|
||||
return spki.encode()
|
||||
|
||||
|
||||
def _extract_subject_public_key_info(x509_certificate):
|
||||
"""Extract subjectPublicKeyInfo from a DER X.509 certificate."""
|
||||
|
||||
certificate = DerSequence().decode(x509_certificate, nr_elements=3)
|
||||
tbs_certificate = DerSequence().decode(certificate[0],
|
||||
nr_elements=list(range(6, 11)))
|
||||
|
||||
index = 5
|
||||
try:
|
||||
tbs_certificate[0] + 1
|
||||
# Version not present
|
||||
version = 1
|
||||
except TypeError:
|
||||
version = DerInteger(explicit=0).decode(tbs_certificate[0]).value
|
||||
if version not in (2, 3):
|
||||
raise ValueError("Incorrect X.509 certificate version")
|
||||
index = 6
|
||||
|
||||
return tbs_certificate[index]
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Loading…
Add table
Add a link
Reference in a new issue