/opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey
Edit: /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyc (26795B)
Ñò
Bd\Rc @ sà d Z d Z d d d d d d g Z d d k Z e i d
d j o e i d d j o d d
k Tn d d
k Td d k l Z l Z l
Z
d d k l Z l
Z
l Z d d k l Z d d k l Z l Z l Z d d k Z d d k Z d d k l Z d d k l Z y d d k l Z Wn e j
o
e Z n Xd e i f d „ ƒ YZ d e f d „ ƒ YZ e e d ƒ e ƒ i ƒ g ƒ i ƒ Z e ƒ Z! e! i" Z" e! i# Z# e! i$ Z$ e! i% Z% d S( s† 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(RSA.exportKey('PEM'))
>>> f.close()
...
>>> f = open('mykey.pem','r')
>>> key = RSA.importKey(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. `_RSAobj.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,importKey,error
s $Id$t generatet constructt errort importKeyt RSAImplementationt _RSAobjiÿÿÿÿNi i i ( t *( t getRandomRanget
bytes_to_longt
long_to_bytes( t _RSAt _slowmatht pubkey( t Random( t DerObjectt DerSequencet DerNull( t inverse( t _fastmathc B sû e Z d Z d d d d d d g Z d d „ Z d „ Z d „ Z d
„ Z d „ Z d „ Z
d
„ Z d „ Z d „ Z
d „ Z d d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d d d d „ Z RS( sl Class defining an actual RSA key.
:undocumented: __getstate__, __setstate__, __repr__, __getattr__
t nt et dt pt qt uc C s? | | _ | | _ | d j o t i ƒ i } n | | _ d S( N( t implementationt keyt NoneR
t newt readt _randfunc( t selfR R t randfunc( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyt __init__q s
c C sA | | i j o t | i | ƒ St d | i i | f ƒ ‚ d S( Ns %s object has no %r attribute( t keydatat getattrR t AttributeErrort __class__t __name__( R t attrname( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyt __getattr__x s c C s t i i | | | ƒ S( sÏ Encrypt a piece of data with RSA.
:Parameter plaintext: The piece of data to encrypt with RSA. It may not
be numerically larger than the RSA module (**n**).
:Type plaintext: byte string or long
:Parameter K: A random parameter (*for compatibility only. This
value will be ignored*)
:Type K: byte string or long
:attention: this function performs the plain, primitive RSA encryption
(*textbook*). In real applications, you always need to use proper
cryptographic padding, and you should not directly encrypt data with
this method. Failure to do so may lead to security vulnerabilities.
It is recommended to use modules
`Crypto.Cipher.PKCS1_OAEP` or `Crypto.Cipher.PKCS1_v1_5` instead.
:Return: A tuple with two items. The first item is the ciphertext
of the same type as the plaintext (string or long). The second item
is always None.
( R t encrypt( R t plaintextt K( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyR) € s c C s t i i | | ƒ S( sË Decrypt a piece of data with RSA.
Decryption always takes place with blinding.
:attention: this function performs the plain, primitive RSA decryption
(*textbook*). In real applications, you always need to use proper
cryptographic padding, and you should not directly decrypt data with
this method. Failure to do so may lead to security vulnerabilities.
It is recommended to use modules
`Crypto.Cipher.PKCS1_OAEP` or `Crypto.Cipher.PKCS1_v1_5` instead.
:Parameter ciphertext: The piece of data to decrypt with RSA. It may
not be numerically larger than the RSA module (**n**). If a tuple,
the first item is the actual ciphertext; the second item is ignored.
:Type ciphertext: byte string, long or a 2-item tuple as returned by
`encrypt`
:Return: A byte string if ciphertext was a byte string or a tuple
of byte strings. A long otherwise.
( R t decrypt( R t
ciphertext( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyR, ˜ s c C s t i i | | | ƒ S( s¹ Sign a piece of data with RSA.
Signing always takes place with blinding.
:attention: this function performs the plain, primitive RSA decryption
(*textbook*). In real applications, you always need to use proper
cryptographic padding, and you should not directly sign data with
this method. Failure to do so may lead to security vulnerabilities.
It is recommended to use modules
`Crypto.Signature.PKCS1_PSS` or `Crypto.Signature.PKCS1_v1_5` instead.
:Parameter M: The piece of data to sign with RSA. It may
not be numerically larger than the RSA module (**n**).
:Type M: byte string or long
:Parameter K: A random parameter (*for compatibility only. This
value will be ignored*)
:Type K: byte string or long
:Return: A 2-item tuple. The first item is the actual signature (a
long). The second item is always None.
( R t sign( R t MR+ ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyR. ° s c C s t i i | | | ƒ S( s Verify the validity of an RSA signature.
:attention: this function performs the plain, primitive RSA encryption
(*textbook*). In real applications, you always need to use proper
cryptographic padding, and you should not directly verify data with
this method. Failure to do so may lead to security vulnerabilities.
It is recommended to use modules
`Crypto.Signature.PKCS1_PSS` or `Crypto.Signature.PKCS1_v1_5` instead.
:Parameter M: The expected message.
:Type M: byte string or long
:Parameter signature: The RSA signature to verify. The first item of
the tuple is the actual signature (a long not larger than the modulus
**n**), whereas the second item is always ignored.
:Type signature: A 2-item tuple as return by `sign`
:Return: True if the signature is correct, False otherwise.
( R t verify( R R/ t signature( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyR0 É s c C s | i i | ƒ f S( N( R t _encrypt( R t cR+ ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyR2 ß s c C si | d \ } t d | i i d d | i ƒ} | i i | | ƒ } | i i | ƒ } | i i | | ƒ S( Ni R ( R R R R t _blindt _decryptt _unblind( R R3 R- t rt cpt mp( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyR5 â s
"c C s | i i | | ƒ S( N( R R4 ( R t mR7 ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyR4 ó s c C s | i i | | ƒ S( N( R R6 ( R R: R7 ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyR6 ö s c C s | i i | ƒ f S( N( R t _sign( R R: R+ ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyR; ù s c C s | d \ } | i i | | ƒ S( Ni ( R t _verify( R R: t sigt s( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyR< ü s
c C s
| i i ƒ S( N( R t has_private( R ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyR? s c C s
| i i ƒ S( N( R t size( R ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyR@ s c C s t S( N( t True( R ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyt can_blind s c C s t S( N( RA ( R ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyt can_encrypt s c C s t S( N( RA ( R ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyt can_sign s c C s" | i i | i i | i i f ƒ S( N( R R R R R ( R ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyt publickey s c C sN h } xA | i D]6 } y t | i | ƒ | |
t ,(
R" RJ R@ RH R R? R% R& t idt join( R t attrsRF ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyt __repr__( s
"
t PEMi c C sR | d j o t | ƒ } n | d j oÕ t | i ƒ } t | i ƒ } t | d ƒ d @o t d ƒ | } n t | d ƒ d @o t d ƒ | } n d | | g } d i g } | D]# } | t i d t
| ƒ ƒ | qº ~ ƒ } d t i | ƒ d St
ƒ }
| i ƒ oÍ h d d
6d d 6| } d | i | i | i | i | i | i | i d
| i | i d
t | i | i ƒ g |
(| d j oH |
i ƒ } t
d g ƒ }
|
i t ƒ |
i t d
| ƒ i ƒ ƒ qEnd d } |
i t ƒ t d ƒ }
t
| i | i g ƒ } t d ƒ | i ƒ |
_ |
i |
i ƒ ƒ | d j o |
i ƒ S| d j oÚt d | d ƒ } d } | oî | i d ƒ oÞ d d k } d d k l } d d k l } | i d ƒ } | | | d d
| i i! ƒ } | | | | | d d
| i i! ƒ 7} | i" | | i# i i$ | ƒ } | t d ƒ 7} | t d ƒ t i% | ƒ i& ƒ t d ƒ 7} n |
i ƒ } | o; | i' t
| ƒ | i' } | i( | t | ƒ | ƒ } n g } t) d t
| ƒ d ƒ D]! } | t i | | | d !ƒ qä~ } | t d ƒ i | ƒ 7} | t d | d ƒ 7} | St* d | ƒ S( s$ Export this RSA key.
:Parameter format: The format to use for wrapping the key.
- *'DER'*. Binary encoding, always unencrypted.
- *'PEM'*. Textual encoding, done according to `RFC1421`_/`RFC1423`_.
Unencrypted (default) or encrypted.
- *'OpenSSH'*. Textual encoding, done according to OpenSSH specification.
Only suitable for public keys (not private keys).
:Type format: string
:Parameter passphrase: In case of PEM, the pass phrase to derive the encryption key from.
:Type passphrase: string
:Parameter pkcs: The PKCS standard to follow for assembling the key.
You have two choices:
- with **1**, the public key is embedded into an X.509 `SubjectPublicKeyInfo` DER SEQUENCE.
The private key is embedded into a `PKCS#1`_ `RSAPrivateKey` DER SEQUENCE.
This mode is the default.
- with **8**, the private key is embedded into a `PKCS#8`_ `PrivateKeyInfo` DER SEQUENCE.
This mode is not available for public keys.
PKCS standards are not relevant for the *OpenSSH* format.
:Type pkcs: integer
:Return: A byte string with the encoded public or private half.
:Raise ValueError:
When the format is unknown.
.. _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
t OpenSSHi i€ s ssh-rsat s >Is ssh-rsa iÿÿÿÿs RSA PRIVATEi t PRIVATEi s OCTET STRINGt PUBLICs
BIT STRINGt DERRV s -----BEGIN s
KEY-----
N( t DES3( t PBKDF1i s Proc-Type: 4,ENCRYPTED
s DEK-Info: DES-EDE3-CBC,s
i0 s -----END s KEY-----s3 Unknown key format '%s'. Cannot export the RSA key.(+ R t tobytesR R R t bordt bchrRS t structt packt lent binasciit
b2a_base64R R? R R R R t encodeRJ t algorithmIdentifierR t payloadt bt endswitht Crypto.Hash.MD5t
Crypto.CipherR\ t Crypto.Protocol.KDFR] R t Hasht MD5R t Ciphert MODE_CBCt b2a_hext uppert
block_sizeR) t ranget
ValueError( R t formatt
passphraset pkcst ebt nbt keypartst _[1]t kpt keystringt dert keyTypet derkeyt bitmapt derPKt pemt objenct CryptoR\ R] t saltR t binaryKeyt paddingt _[2]t it chunks( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyt exportKey4 sj $
@
!"
$
& 1 !GN( R& t
__module__t __doc__R" R R! R( R) R, R. R0 R2 R5 R4 R6 R; R< R? R@ RB RC RD RE RG RO RU RŽ ( ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyR ] s0
c B sP e Z d Z d „ Z d „ Z d d d d „ Z d „ Z d „ Z d d „ Z RS( sÒ
An RSA key factory.
This class is only internally used to implement the methods of the `Crypto.PublicKey.RSA` module.
:sort: __init__,generate,construct,importKey
:undocumented: _g*, _i*
c K s± | i d d ƒ } | d j o' t d j o
t | _ q€ t | _ n; | o* t d j o
t | _ q€ t d ƒ ‚ n
t | _ | i i | _ | i d d ƒ | _ d | _ d S( sØ Create a new RSA key factory.
:Keywords:
use_fast_math : bool
Specify which mathematic library to use:
- *None* (default). Use fastest math available.
- *True* . Use fast math.
- *False* . Use slow math.
default_randfunc : callable
Specify how to collect random data:
- *None* (default). Use Random.new().read().
- not *None* . Use the specified function directly.
:Raise RuntimeError:
When **use_fast_math** =True but fast math is not available.
t
use_fast_maths fast math module not availablet default_randfuncN( t getR R RK R t RuntimeErrorR t _default_randfunct _current_randfunc( R t kwargsR‘ ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyR! Ÿ s
c C s? | d j o | S| i d j o t i ƒ i | _ n | i S( N( R R– R
R R ( R R ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyt
_get_randfuncÆ s
i c C sà | d j p | d @d j o t d ƒ ‚ n | d d j p
| d j o t d ƒ ‚ n | i | ƒ } t i | | | | ƒ } | i i | i | i | i | i | i
| i ƒ } t | | ƒ S( s” Randomly generate a fresh, new RSA key.
:Parameters:
bits : int
Key length, or size (in bits) of the RSA modulus.
It must be a multiple of 256, and no smaller than 1024.
randfunc : callable
Random number generation function; it should accept
a single integer N and return a string of random data
N bytes long.
If not specified, a new one will be instantiated
from ``Crypto.Random``.
progress_func : callable
Optional function that will be called with a short string
containing the key parameter currently being generated;
it's useful for interactive applications where a user is
waiting for a key to be generated.
e : int
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 default value 65537 (= ``0b10000000000000001`` ) is a safe
choice: other common values are 5, 7, 17, and 257.
: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.
:attention: Exponent 3 is also widely used, but it requires very special care when padding
the message.
:Return: An RSA key object (`_RSAobj`).
:Raise ValueError:
When **bits** is too little or not a multiple of 256, or when
**e** is not odd or smaller than 2.
i iÿ i s8 RSA modulus length must be a multiple of 256 and >= 1024i i sB RSA public exponent must be a positive, odd integer larger than 2.(
Rv R˜ R
t generate_pyRK RL R R R R R R R ( R t bitsR t
progress_funcR t rft objR ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyR Í s ) 3c C s | i i | Œ } t | | ƒ S( s¸ 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 (p-1)(q-1)
- p*u = 1 mod q
:Parameters:
tup : 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.
5. Second factor of n (q). Optional.
6. CRT coefficient, (1/p) mod q (u). Optional.
:Return: An RSA key object (`_RSAobj`).
( RK RL R ( R t tupR ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyR s c
C sò yÊt ƒ } | i | t ƒ t | ƒ d j oY | i ƒ oL | d d j o; | d 3| i t | d | d ƒ ƒ | d =| i | ƒ St | ƒ d j oÆ | i ƒ o | i | ƒ S| d t j o• t ƒ } | i | d t ƒ | i
d ƒ od t | i d ƒ d j oJ | i | i d t ƒ t | ƒ d j o | i ƒ o | i | ƒ Sq]qan | d d j oW | d t j oB t ƒ } | i | d t ƒ | i
d ƒ o | i
| i ƒ SqÉn Wn t j
o } n Xt d
ƒ ‚ d S( s@ Import an RSA key (public or private half), encoded in DER form.i i i i i i i s
BIT STRINGs OCTET STRINGs RSA key format is not supportedN( R t decodeRA Rc t hasOnlyIntsRJ R R Rg R t isTypeR_ Rh t
_importKeyDERRv ( R t externKeyR€ Rƒ t
privateKeyt
IndexError( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyR¢ s6 1
* c C sŽ t | ƒ } | d
j o t | ƒ } n | i t d ƒ ƒ oM| i t d ƒ t d ƒ ƒ i ƒ } d
} | d i t d ƒ ƒ o¡| d i t d ƒ ƒ } t | ƒ d j p | d t d ƒ j p | o t d
ƒ ‚ n | d i t d ƒ ƒ \ } } t i | ƒ } d d
k
} d d k l } l
}
d d k l } | t d ƒ j o@ | | | d d | i i ƒ } | i | | i i i | ƒ } n† | t d ƒ j of | | | d d | i i ƒ } | | | | | d d | i i ƒ 7} |
i | | i i
i | ƒ } n
t d ƒ ‚ | d } n t i t d ƒ i | d d !ƒ ƒ }
| o. | i |
ƒ }
t |
d ƒ } |
| }
n | i |
ƒ S| i t d ƒ ƒ o· t i | i t d ƒ ƒ d ƒ } g } xX t | ƒ d j oD t i d | d ƒ d } | i | d d | !ƒ | d | } qÍWt | d ƒ } t | d ƒ } | i | | g ƒ St | d ƒ d j o | i | ƒ St d ƒ ‚ d
S( se Import an RSA key (public or private half), encoded in standard form.
:Parameter externKey:
The RSA key to import, encoded as a string.
An RSA public key can be in any of the following formats:
- 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` DER SEQUENCE (binary or PEM encoding)
- OpenSSH (textual public key only)
For details about the PEM encoding, see `RFC1421`_/`RFC1423`_.
In case of PEM encoding, the private key can be encrypted with DES or 3TDES according to a certain ``pass phrase``.
Only OpenSSL-compatible pass phrases are supported.
:Type externKey: string
:Parameter passphrase:
In case of an encrypted PEM key, this is the pass phrase from which the encryption key is derived.
:Type passphrase: string
:Return: An RSA key object (`_RSAobj`).
: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
s -----t RX i s Proc-Type:4,ENCRYPTEDi t :i s DEK-Infos$ PEM encryption format not supported.RQ iÿÿÿÿN( t DESR\ ( R] s DES-CBCi s DES-EDE3-CBCi s# Unsupport PEM encryption algorithm.s ssh-rsa i s >Ii0 s RSA key format is not supported( R^ R t
startswithRi t replacet splitRc Rv Rd t a2b_hexRk Rl R¨ R\ Rm R] Rn Ro R Rp Rq t
a2b_base64RS R, R_ R¢ Ra t unpackRJ R R ( R R£ Rx t linest keyobjt DEKt algoRˆ R‡ R¨ R\ R] R R€ RŠ R R| t lR R ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyR N sX &
$2 " &" %" N(
R& R R R! R˜ R R R R¢ R ( ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyR • s ' 3 0s *†H†÷
(& R t __revision__t __all__t syst version_infot Crypto.Util.py21compatt Crypto.Util.py3compatt Crypto.Util.numberR R R t Crypto.PublicKeyR
R R R‡ R
t Crypto.Util.asn1R R R Rd Ra R R t ImportErrorR R t objectR Ri Rf Rg t _implR R R R ( ( ( sG /opt/alt/python27/lib64/python2.7/site-packages/Crypto/PublicKey/RSA.pyt @ s< (
ÿ 9ÿ