| author | Xiaoliang Wang <xiaoliang.wang@amlogic.com> | 2019-04-24 09:35:55 (GMT) |
|---|---|---|
| committer | Xiaoliang Wang <xiaoliang.wang@amlogic.com> | 2019-04-24 09:35:55 (GMT) |
| commit | 5c2411b16fd12de624a7559a514361f6f98e0d97 (patch) | |
| tree | 5a0d052792bb9e013dee2e216c6b84863e6ea88a | |
| parent | 16adde75b5fe82f511185964c0de5bd6b0f74bb5 (diff) | |
| download | tdk-p-tv-atom.zip tdk-p-tv-atom.tar.gz tdk-p-tv-atom.tar.bz2 | |
Revert "tdk: change for patch build sync fail[1/1]"
This reverts commit 16adde75b5fe82f511185964c0de5bd6b0f74bb5.
Reason for revert: <INSERT REASONING HERE>
Change-Id: I90e68953e19ae80ad030c66ebe7580fa496197e7
81 files changed, 0 insertions, 3824 deletions
diff --git a/secureos/axg/bl32.img b/secureos/axg/bl32.img index 2626b36..2626b36 100644..100755 --- a/secureos/axg/bl32.img +++ b/secureos/axg/bl32.img diff --git a/secureos/g12a/bl32.img b/secureos/g12a/bl32.img index e4b6982..e4b6982 100644..100755 --- a/secureos/g12a/bl32.img +++ b/secureos/g12a/bl32.img diff --git a/secureos/gx/bl32.img b/secureos/gx/bl32.img index 453ee35..453ee35 100644..100755 --- a/secureos/gx/bl32.img +++ b/secureos/gx/bl32.img diff --git a/secureos/txlx/bl32.img b/secureos/txlx/bl32.img index 5b46ddd..5b46ddd 100644..100755 --- a/secureos/txlx/bl32.img +++ b/secureos/txlx/bl32.img diff --git a/ta_export/host_include/ngwm_defs.h b/ta_export/host_include/ngwm_defs.h index cd2bee6..cd2bee6 100644..100755 --- a/ta_export/host_include/ngwm_defs.h +++ b/ta_export/host_include/ngwm_defs.h diff --git a/ta_export/host_include/nv_wmk.h b/ta_export/host_include/nv_wmk.h index eda512e..eda512e 100644..100755 --- a/ta_export/host_include/nv_wmk.h +++ b/ta_export/host_include/nv_wmk.h diff --git a/ta_export/host_include/tee_ngwm_api.h b/ta_export/host_include/tee_ngwm_api.h index 6b2d73c..6b2d73c 100644..100755 --- a/ta_export/host_include/tee_ngwm_api.h +++ b/ta_export/host_include/tee_ngwm_api.h diff --git a/ta_export/host_include/tee_vxwm_api.h b/ta_export/host_include/tee_vxwm_api.h index 5dc2555..5dc2555 100644..100755 --- a/ta_export/host_include/tee_vxwm_api.h +++ b/ta_export/host_include/tee_vxwm_api.h diff --git a/ta_export/include/ngwm_defs.h b/ta_export/include/ngwm_defs.h index cd2bee6..cd2bee6 100644..100755 --- a/ta_export/include/ngwm_defs.h +++ b/ta_export/include/ngwm_defs.h diff --git a/ta_export/include/nv_wmk.h b/ta_export/include/nv_wmk.h index eda512e..eda512e 100644..100755 --- a/ta_export/include/nv_wmk.h +++ b/ta_export/include/nv_wmk.h diff --git a/ta_export/include/tee_ngwm_api.h b/ta_export/include/tee_ngwm_api.h index 6b2d73c..6b2d73c 100644..100755 --- a/ta_export/include/tee_ngwm_api.h +++ b/ta_export/include/tee_ngwm_api.h diff --git a/ta_export/include/tee_vxwm_api.h b/ta_export/include/tee_vxwm_api.h index 5dc2555..5dc2555 100644..100755 --- a/ta_export/include/tee_vxwm_api.h +++ b/ta_export/include/tee_vxwm_api.h diff --git a/ta_export/lib/libmpa.a b/ta_export/lib/libmpa.a index 3b3880e..3b3880e 100644..100755 --- a/ta_export/lib/libmpa.a +++ b/ta_export/lib/libmpa.a diff --git a/ta_export/lib/libnvwmk.a b/ta_export/lib/libnvwmk.a index c0a51a2..c0a51a2 100644..100755 --- a/ta_export/lib/libnvwmk.a +++ b/ta_export/lib/libnvwmk.a diff --git a/ta_export/lib/libpng.a b/ta_export/lib/libpng.a index ae7c447..ae7c447 100644..100755 --- a/ta_export/lib/libpng.a +++ b/ta_export/lib/libpng.a diff --git a/ta_export/lib/libutee.a b/ta_export/lib/libutee.a index e0ae182..e0ae182 100644..100755 --- a/ta_export/lib/libutee.a +++ b/ta_export/lib/libutee.a diff --git a/ta_export/lib/libutils.a b/ta_export/lib/libutils.a index b559659..b559659 100644..100755 --- a/ta_export/lib/libutils.a +++ b/ta_export/lib/libutils.a diff --git a/ta_export/lib/libzlib.a b/ta_export/lib/libzlib.a index fb639a0..fb639a0 100644..100755 --- a/ta_export/lib/libzlib.a +++ b/ta_export/lib/libzlib.a diff --git a/ta_export/scripts/Crypto/Cipher/AES.pyc b/ta_export/scripts/Crypto/Cipher/AES.pyc deleted file mode 100755 index 389ada3..0000000 --- a/ta_export/scripts/Crypto/Cipher/AES.pyc +++ b/dev/null @@ -1,62 +0,0 @@ -
-~/Sc - - - -AES `(Advanced Encryption Standard)`__ is a symmetric block cipher standardized -by NIST_ . It has a fixed data block size of 16 bytes. -Its keys can be 128, 192, or 256 bits long. - -AES is very fast and secure, and it is the de facto standard for symmetric -encryption. - -As an example, encryption can be done as follows: - - >>> from Crypto.Cipher import AES - >>> from Crypto import Random - >>> - >>> key = b'Sixteen byte key' - >>> iv = Random.new().read(AES.block_size) - >>> cipher = AES.new(key, AES.MODE_CFB, iv) - >>> msg = iv + cipher.encrypt(b'Attack at dawn') - -.. __: http://en.wikipedia.org/wiki/Advanced_Encryption_Standard -.. _NIST: http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf - -:undocumented: __revision__, __package__ -s - - See also `new()` at the module level.N( - - - :Parameters: - key : byte string - The secret key to use in the symmetric cipher. - It must be 16 (*AES-128*), 24 (*AES-192*), or 32 (*AES-256*) bytes long. - :Keywords: - mode : a *MODE_** constant - The chaining mode to use for encryption or decryption. - Default is `MODE_ECB`. - IV : byte string - The initialization vector to use for encryption or decryption. - - It is ignored for `MODE_ECB` and `MODE_CTR`. - - For `MODE_OPENPGP`, IV must be `block_size` bytes long for encryption - and `block_size` +2 bytes for decryption (in the latter case, it is - actually the *encrypted* IV which was prefixed to the ciphertext). - It is mandatory. - - For all other modes, it must be `block_size` bytes longs. - counter : callable - (*Only* `MODE_CTR`). A stateful function that returns the next - *counter block*, which is a byte string of `block_size` bytes. - For better performance, use `Crypto.Util.Counter`. - segment_size : integer - (*Only* `MODE_CFB`).The number of bits the plaintext and ciphertext - are segmented in. - It must be a multiple of 8. If 0 or not specified, it will be assumed to be 8. - - :Return: an `AESCipher` object - ( - diff --git a/ta_export/scripts/Crypto/Cipher/ARC2.pyc b/ta_export/scripts/Crypto/Cipher/ARC2.pyc deleted file mode 100755 index c0d022b..0000000 --- a/ta_export/scripts/Crypto/Cipher/ARC2.pyc +++ b/dev/null @@ -1,77 +0,0 @@ -
-~/Sc - - - -RC2_ (Rivest's Cipher version 2) is a symmetric block cipher designed -by Ron Rivest in 1987. The cipher started as a proprietary design, -that was reverse engineered and anonymously posted on Usenet in 1996. -For this reason, the algorithm was first called *Alleged* RC2 (ARC2), -since the company that owned RC2 (RSA Data Inc.) did not confirm whether -the details leaked into public domain were really correct. - -The company eventually published its full specification in RFC2268_. - -RC2 has a fixed data block size of 8 bytes. Length of its keys can vary from -8 to 128 bits. One particular property of RC2 is that the actual -cryptographic strength of the key (*effective key length*) can be reduced -via a parameter. - -Even though RC2 is not cryptographically broken, it has not been analyzed as -thoroughly as AES, which is also faster than RC2. - -New designs should not use RC2. - -As an example, encryption can be done as follows: - - >>> from Crypto.Cipher import ARC2 - >>> from Crypto import Random - >>> - >>> key = b'Sixteen byte key' - >>> iv = Random.new().read(ARC2.block_size) - >>> cipher = ARC2.new(key, ARC2.MODE_CFB, iv) - >>> msg = iv + cipher.encrypt(b'Attack at dawn') - -.. _RC2: http://en.wikipedia.org/wiki/RC2 -.. _RFC2268: http://tools.ietf.org/html/rfc2268 - -:undocumented: __revision__, __package__ -s - - See also `new()` at the module level.N( - - - :Parameters: - key : byte string - The secret key to use in the symmetric cipher. - Its length can vary from 1 to 128 bytes. - :Keywords: - mode : a *MODE_** constant - The chaining mode to use for encryption or decryption. - Default is `MODE_ECB`. - IV : byte string - The initialization vector to use for encryption or decryption. - - It is ignored for `MODE_ECB` and `MODE_CTR`. - - For `MODE_OPENPGP`, IV must be `block_size` bytes long for encryption - and `block_size` +2 bytes for decryption (in the latter case, it is - actually the *encrypted* IV which was prefixed to the ciphertext). - It is mandatory. - - For all other modes, it must be `block_size` bytes longs. - counter : callable - (*Only* `MODE_CTR`). A stateful function that returns the next - *counter block*, which is a byte string of `block_size` bytes. - For better performance, use `Crypto.Util.Counter`. - segment_size : integer - (*Only* `MODE_CFB`).The number of bits the plaintext and ciphertext - are segmented in. - It must be a multiple of 8. If 0 or not specified, it will be assumed to be 8. - effective_keylen : integer - Maximum cryptographic strength of the key, in bits. - It can vary from 0 to 1024. The default value is 1024. - - :Return: an `RC2Cipher` object - ( - diff --git a/ta_export/scripts/Crypto/Cipher/ARC4.pyc b/ta_export/scripts/Crypto/Cipher/ARC4.pyc deleted file mode 100755 index 202f103..0000000 --- a/ta_export/scripts/Crypto/Cipher/ARC4.pyc +++ b/dev/null @@ -1,73 +0,0 @@ -
-Bd\Rc - - -ARC4_ (Alleged RC4) is an implementation of RC4 (Rivest's Cipher version 4), -a symmetric stream cipher designed by Ron Rivest in 1987. - -The cipher started as a proprietary design, that was reverse engineered and -anonymously posted on Usenet in 1994. The company that owns RC4 (RSA Data -Inc.) never confirmed the correctness of the leaked algorithm. - -Unlike RC2, the company has never published the full specification of RC4, -of whom it still holds the trademark. - -ARC4 keys can vary in length from 40 to 2048 bits. - -One problem of ARC4 is that it does not take a nonce or an IV. If it is required -to encrypt multiple messages with the same long-term key, a distinct -independent nonce must be created for each message, and a short-term key must -be derived from the combination of the long-term key and the nonce. -Due to the weak key scheduling algorithm of RC2, the combination must be carried -out with a complex function (e.g. a cryptographic hash) and not by simply -concatenating key and nonce. - -New designs should not use ARC4. A good alternative is AES -(`Crypto.Cipher.AES`) in any of the modes that turn it into a stream cipher (OFB, CFB, or CTR). - -As an example, encryption can be done as follows: - - >>> from Crypto.Cipher import ARC4 - >>> from Crypto.Hash import SHA - >>> from Crypto import Random - >>> - >>> key = b'Very long and confidential key' - >>> nonce = Random.new().read(16) - >>> tempkey = SHA.new(key+nonce).digest() - >>> cipher = ARC4.new(tempkey) - >>> msg = nonce + cipher.encrypt(b'Open the pod bay doors, HAL') - -.. _ARC4: http://en.wikipedia.org/wiki/RC4 - -:undocumented: __revision__, __package__ -s - - - See also `new()` at the module level.N( - - - :Parameters: - plaintext : byte string - The piece of data to encrypt. It can be of any size. - :Return: the encrypted data (byte string, as long as the - plaintext). - ( - - :Parameters: - ciphertext : byte string - The piece of data to decrypt. It can be of any size. - :Return: the decrypted data (byte string, as long as the - ciphertext). - ( - - - - - :Parameters: - key : byte string - The secret key to use in the symmetric cipher. - It can have any length, with a minimum of 40 bytes. - Its cryptograpic strength is always capped to 2048 bits (256 bytes). - - :Return: an `ARC4Cipher` object - ( diff --git a/ta_export/scripts/Crypto/Cipher/Blowfish.pyc b/ta_export/scripts/Crypto/Cipher/Blowfish.pyc deleted file mode 100755 index 3405051..0000000 --- a/ta_export/scripts/Crypto/Cipher/Blowfish.pyc +++ b/dev/null @@ -1,68 +0,0 @@ -
-~/Sc - - - -Blowfish_ is a symmetric block cipher designed by Bruce Schneier. - -It has a fixed data block size of 8 bytes and its keys can vary in length -from 32 to 448 bits (4 to 56 bytes). - -Blowfish is deemed secure and it is fast. However, its keys should be chosen -to be big enough to withstand a brute force attack (e.g. at least 16 bytes). - -As an example, encryption can be done as follows: - - >>> from Crypto.Cipher import Blowfish - >>> from Crypto import Random - >>> from struct import pack - >>> - >>> bs = Blowfish.block_size - >>> key = b'An arbitrarily long key' - >>> iv = Random.new().read(bs) - >>> cipher = Blowfish.new(key, Blowfish.MODE_CBC, iv) - >>> plaintext = b'docendo discimus ' - >>> plen = bs - divmod(len(plaintext),bs)[1] - >>> padding = [plen]*plen - >>> padding = pack('b'*plen, *padding) - >>> msg = iv + cipher.encrypt(plaintext + padding) - -.. _Blowfish: http://www.schneier.com/blowfish.html - -:undocumented: __revision__, __package__ -s - - See also `new()` at the module level.N( - - - :Parameters: - key : byte string - The secret key to use in the symmetric cipher. - Its length can vary from 4 to 56 bytes. - :Keywords: - mode : a *MODE_** constant - The chaining mode to use for encryption or decryption. - Default is `MODE_ECB`. - IV : byte string - The initialization vector to use for encryption or decryption. - - It is ignored for `MODE_ECB` and `MODE_CTR`. - - For `MODE_OPENPGP`, IV must be `block_size` bytes long for encryption - and `block_size` +2 bytes for decryption (in the latter case, it is - actually the *encrypted* IV which was prefixed to the ciphertext). - It is mandatory. - - For all other modes, it must be `block_size` bytes longs. - counter : callable - (*Only* `MODE_CTR`). A stateful function that returns the next - *counter block*, which is a byte string of `block_size` bytes. - For better performance, use `Crypto.Util.Counter`. - segment_size : integer - (*Only* `MODE_CFB`).The number of bits the plaintext and ciphertext - are segmented in. - It must be a multiple of 8. If 0 or not specified, it will be assumed to be 8. - - :Return: a `BlowfishCipher` object - ( - diff --git a/ta_export/scripts/Crypto/Cipher/CAST.pyc b/ta_export/scripts/Crypto/Cipher/CAST.pyc deleted file mode 100755 index 43587d2..0000000 --- a/ta_export/scripts/Crypto/Cipher/CAST.pyc +++ b/dev/null @@ -1,71 +0,0 @@ -
-~/Sc - - - -CAST-128_ (or CAST5) is a symmetric block cipher specified in RFC2144_. - -It has a fixed data block size of 8 bytes. Its key can vary in length -from 40 to 128 bits. - -CAST is deemed to be cryptographically secure, but its usage is not widespread. -Keys of sufficient length should be used to prevent brute force attacks -(128 bits are recommended). - -As an example, encryption can be done as follows: - - >>> from Crypto.Cipher import CAST - >>> from Crypto import Random - >>> - >>> key = b'Sixteen byte key' - >>> iv = Random.new().read(CAST.block_size) - >>> cipher = CAST.new(key, CAST.MODE_OPENPGP, iv) - >>> plaintext = b'sona si latine loqueris ' - >>> msg = cipher.encrypt(plaintext) - >>> - ... - >>> eiv = msg[:CAST.block_size+2] - >>> ciphertext = msg[CAST.block_size+2:] - >>> cipher = CAST.new(key, CAST.MODE_OPENPGP, eiv) - >>> print cipher.decrypt(ciphertext) - -.. _CAST-128: http://en.wikipedia.org/wiki/CAST-128 -.. _RFC2144: http://tools.ietf.org/html/rfc2144 - -:undocumented: __revision__, __package__ -s - - See also `new()` at the module level.N( - - - :Parameters: - key : byte string - The secret key to use in the symmetric cipher. - Its length may vary from 5 to 16 bytes. - :Keywords: - mode : a *MODE_** constant - The chaining mode to use for encryption or decryption. - Default is `MODE_ECB`. - IV : byte string - The initialization vector to use for encryption or decryption. - - It is ignored for `MODE_ECB` and `MODE_CTR`. - - For `MODE_OPENPGP`, IV must be `block_size` bytes long for encryption - and `block_size` +2 bytes for decryption (in the latter case, it is - actually the *encrypted* IV which was prefixed to the ciphertext). - It is mandatory. - - For all other modes, it must be `block_size` bytes longs. - counter : callable - (*Only* `MODE_CTR`). A stateful function that returns the next - *counter block*, which is a byte string of `block_size` bytes. - For better performance, use `Crypto.Util.Counter`. - segment_size : integer - (*Only* `MODE_CFB`).The number of bits the plaintext and ciphertext - are segmented in. - It must be a multiple of 8. If 0 or not specified, it will be assumed to be 8. - - :Return: an `CAST128Cipher` object - ( - diff --git a/ta_export/scripts/Crypto/Cipher/DES.pyc b/ta_export/scripts/Crypto/Cipher/DES.pyc deleted file mode 100755 index fb8202f..0000000 --- a/ta_export/scripts/Crypto/Cipher/DES.pyc +++ b/dev/null @@ -1,66 +0,0 @@ -
-~/Sc - - - -DES `(Data Encryption Standard)`__ is a symmetric block cipher standardized -by NIST_ . It has a fixed data block size of 8 bytes. -Its keys are 64 bits long, even though 8 bits were used for integrity (now they -are ignored) and do not contribute to securty. - -DES is cryptographically secure, but its key length is too short by nowadays -standards and it could be brute forced with some effort. - -DES should not be used for new designs. Use `AES`. - -As an example, encryption can be done as follows: - - >>> from Crypto.Cipher import DES3 - >>> from Crypto import Random - >>> - >>> key = b'Sixteen byte key' - >>> iv = Random.new().read(DES3.block_size) - >>> cipher = DES3.new(key, DES3.MODE_OFB, iv) - >>> plaintext = b'sona si latine loqueris ' - >>> msg = iv + cipher.encrypt(plaintext) - -.. __: http://en.wikipedia.org/wiki/Data_Encryption_Standard -.. _NIST: http://csrc.nist.gov/publications/fips/fips46-3/fips46-3.pdf - -:undocumented: __revision__, __package__ -s - - See also `new()` at the module level.N( - - - :Parameters: - key : byte string - The secret key to use in the symmetric cipher. - It must be 8 byte long. The parity bits will be ignored. - :Keywords: - mode : a *MODE_** constant - The chaining mode to use for encryption or decryption. - Default is `MODE_ECB`. - IV : byte string - The initialization vector to use for encryption or decryption. - - It is ignored for `MODE_ECB` and `MODE_CTR`. - - For `MODE_OPENPGP`, IV must be `block_size` bytes long for encryption - and `block_size` +2 bytes for decryption (in the latter case, it is - actually the *encrypted* IV which was prefixed to the ciphertext). - It is mandatory. - - For all other modes, it must be `block_size` bytes longs. - counter : callable - (*Only* `MODE_CTR`). A stateful function that returns the next - *counter block*, which is a byte string of `block_size` bytes. - For better performance, use `Crypto.Util.Counter`. - segment_size : integer - (*Only* `MODE_CFB`).The number of bits the plaintext and ciphertext - are segmented in. - It must be a multiple of 8. If 0 or not specified, it will be assumed to be 8. - - :Return: an `DESCipher` object - ( - diff --git a/ta_export/scripts/Crypto/Cipher/DES3.pyc b/ta_export/scripts/Crypto/Cipher/DES3.pyc deleted file mode 100755 index f2839d4..0000000 --- a/ta_export/scripts/Crypto/Cipher/DES3.pyc +++ b/dev/null @@ -1,82 +0,0 @@ -
-~/Sc - - - -`Triple DES`__ (or TDES or TDEA or 3DES) is a symmetric block cipher standardized by NIST_. -It has a fixed data block size of 8 bytes. Its keys are 128 (*Option 1*) or 192 -bits (*Option 2*) long. -However, 1 out of 8 bits is used for redundancy and do not contribute to -security. The effective key length is respectively 112 or 168 bits. - -TDES consists of the concatenation of 3 simple `DES` ciphers. - -The plaintext is first DES encrypted with *K1*, then decrypted with *K2*, -and finally encrypted again with *K3*. The ciphertext is decrypted in the reverse manner. - -The 192 bit key is a bundle of three 64 bit independent subkeys: *K1*, *K2*, and *K3*. - -The 128 bit key is split into *K1* and *K2*, whereas *K1=K3*. - -It is important that all subkeys are different, otherwise TDES would degrade to -single `DES`. - -TDES is cryptographically secure, even though it is neither as secure nor as fast -as `AES`. - -As an example, encryption can be done as follows: - - >>> from Crypto.Cipher import DES - >>> from Crypto import Random - >>> from Crypto.Util import Counter - >>> - >>> key = b'-8B key-' - >>> nonce = Random.new().read(DES.block_size/2) - >>> ctr = Counter.new(DES.block_size*8/2, prefix=nonce) - >>> cipher = DES.new(key, DES.MODE_CTR, counter=ctr) - >>> plaintext = b'We are no longer the knights who say ni!' - >>> msg = nonce + cipher.encrypt(plaintext) - -.. __: http://en.wikipedia.org/wiki/Triple_DES -.. _NIST: http://csrc.nist.gov/publications/nistpubs/800-67/SP800-67.pdf - -:undocumented: __revision__, __package__ -s - - - See also `new()` at the module level.N( - - - :Parameters: - key : byte string - The secret key to use in the symmetric cipher. - It must be 16 or 24 bytes long. The parity bits will be ignored. - :Keywords: - mode : a *MODE_** constant - The chaining mode to use for encryption or decryption. - Default is `MODE_ECB`. - IV : byte string - The initialization vector to use for encryption or decryption. - - It is ignored for `MODE_ECB` and `MODE_CTR`. - - For `MODE_OPENPGP`, IV must be `block_size` bytes long for encryption - and `block_size` +2 bytes for decryption (in the latter case, it is - actually the *encrypted* IV which was prefixed to the ciphertext). - It is mandatory. - - For all other modes, it must be `block_size` bytes longs. - counter : callable - (*Only* `MODE_CTR`). A stateful function that returns the next - *counter block*, which is a byte string of `block_size` bytes. - For better performance, use `Crypto.Util.Counter`. - segment_size : integer - (*Only* `MODE_CFB`).The number of bits the plaintext and ciphertext - are segmented in. - It must be a multiple of 8. If 0 or not specified, it will be assumed to be 8. - - :Attention: it is important that all 8 byte subkeys are different, - otherwise TDES would degrade to single `DES`. - :Return: an `DES3Cipher` object - ( - diff --git a/ta_export/scripts/Crypto/Cipher/PKCS1_OAEP.pyc b/ta_export/scripts/Crypto/Cipher/PKCS1_OAEP.pyc deleted file mode 100755 index 257dc49..0000000 --- a/ta_export/scripts/Crypto/Cipher/PKCS1_OAEP.pyc +++ b/dev/null @@ -1,124 +0,0 @@ -
-Bd\Rc - - - - -See RFC3447__ or the `original RSA Labs specification`__ . - -This scheme is more properly called ``RSAES-OAEP``. - -As an example, a sender may encrypt a message in this way: - - >>> from Crypto.Cipher import PKCS1_OAEP - >>> from Crypto.PublicKey import RSA - >>> - >>> message = 'To be encrypted' - >>> key = RSA.importKey(open('pubkey.der').read()) - >>> cipher = PKCS1_OAEP.new(key) - >>> ciphertext = cipher.encrypt(message) - -At the receiver side, decryption can be done using the private part of -the RSA key: - - >>> key = RSA.importKey(open('privkey.der').read()) - >>> cipher = PKCS1_OAP.new(key) - >>> message = cipher.decrypt(ciphertext) - -:undocumented: __revision__, __package__ - -.. __: http://www.ietf.org/rfc/rfc3447.txt -.. __: http://www.rsa.com/rsalabs/node.asp?id=2125. -i( - - :Parameters: - key : an RSA key object - If a private half is given, both encryption and decryption are possible. - If a public half is given, only encryption is possible. - hashAlgo : hash object - The hash function to use. This can be a module under `Crypto.Hash` - or an existing hash object created from any of such modules. If not specified, - `Crypto.Hash.SHA` (that is, SHA-1) is used. - mgfunc : callable - A mask generation function that accepts two parameters: a string to - use as seed, and the lenth of the mask to generate, in bytes. - If not specified, the standard MGF1 is used (a safe choice). - label : string - A label to apply to this particular encryption. If not specified, - an empty string is used. Specifying a label does not improve - security. - - :attention: Modify the mask generation function only if you know what you are doing. - Sender and receiver must use the same one. - c - - - - - - - This function is named ``RSAES-OAEP-ENCRYPT``, and is specified in - section 7.1.1 of RFC3447. - - :Parameters: - message : string - The message to encrypt, also known as plaintext. It can be of - variable length, but not longer than the RSA modulus (in bytes) - minus 2, minus twice the hash output size. - - :Return: A string, the ciphertext in which the message is encrypted. - It is as long as the RSA modulus (in bytes). - :Raise ValueError: - If the RSA key length is not sufficiently long to deal with the given - message. - i - - - - - - - - - - This function is named ``RSAES-OAEP-DECRYPT``, and is specified in - section 7.1.2 of RFC3447. - - :Parameters: - ct : string - The ciphertext that contains the message to recover. - - :Return: A string, the original message. - :Raise ValueError: - If the ciphertext length is incorrect, or if the decryption does not - succeed. - :Raise TypeError: - If the RSA key has no private half. - i - - - ( - - - :Parameters: - key : RSA key object - The key to use to encrypt or decrypt the message. This is a `Crypto.PublicKey.RSA` object. - Decryption is only possible if *key* is a private RSA key. - hashAlgo : hash object - The hash function to use. This can be a module under `Crypto.Hash` - or an existing hash object created from any of such modules. If not specified, - `Crypto.Hash.SHA` (that is, SHA-1) is used. - mgfunc : callable - A mask generation function that accepts two parameters: a string to - use as seed, and the lenth of the mask to generate, in bytes. - If not specified, the standard MGF1 is used (a safe choice). - label : string - A label to apply to this particular encryption. If not specified, - an empty string is used. Specifying a label does not improve - security. - - :attention: Modify the mask generation function only if you know what you are doing. - Sender and receiver must use the same one. - ( - -
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Cipher/PKCS1_v1_5.pyc b/ta_export/scripts/Crypto/Cipher/PKCS1_v1_5.pyc deleted file mode 100755 index 6c44ea2..0000000 --- a/ta_export/scripts/Crypto/Cipher/PKCS1_v1_5.pyc +++ b/dev/null @@ -1,143 +0,0 @@ -
-Bd\Rc - - -See RFC3447__ or the `original RSA Labs specification`__ . - -This scheme is more properly called ``RSAES-PKCS1-v1_5``. - -**If you are designing a new protocol, consider using the more robust PKCS#1 OAEP.** - -As an example, a sender may encrypt a message in this way: - - >>> from Crypto.Cipher import PKCS1_v1_5 - >>> from Crypto.PublicKey import RSA - >>> from Crypto.Hash import SHA - >>> - >>> message = 'To be encrypted' - >>> h = SHA.new(message) - >>> - >>> key = RSA.importKey(open('pubkey.der').read()) - >>> cipher = PKCS1_v1_5.new(key) - >>> ciphertext = cipher.encrypt(message+h.digest()) - -At the receiver side, decryption can be done using the private part of -the RSA key: - - >>> From Crypto.Hash import SHA - >>> from Crypto import Random - >>> - >>> key = RSA.importKey(open('privkey.der').read()) - >>> - >>> dsize = SHA.digest_size - >>> sentinel = Random.new().read(15+dsize) # Let's assume that average data length is 15 - >>> - >>> cipher = PKCS1_v1_5.new(key) - >>> message = cipher.decrypt(ciphertext, sentinel) - >>> - >>> digest = SHA.new(message[:-dsize]).digest() - >>> if digest==message[-dsize:]: # Note how we DO NOT look for the sentinel - >>> print "Encryption was correct." - >>> else: - >>> print "Encryption was not correct." - -:undocumented: __revision__, __package__ - -.. __: http://www.ietf.org/rfc/rfc3447.txt -.. __: http://www.rsa.com/rsalabs/node.asp?id=2125. -s - - :Parameters: - key : an RSA key object - If a private half is given, both encryption and decryption are possible. - If a public half is given, only encryption is possible. - N( - - - - - - This function is named ``RSAES-PKCS1-V1_5-ENCRYPT``, and is specified in - section 7.2.1 of RFC3447. - For a complete example see `Crypto.Cipher.PKCS1_v1_5`. - - :Parameters: - message : byte string - The message to encrypt, also known as plaintext. It can be of - variable length, but not longer than the RSA modulus (in bytes) minus 11. - - :Return: A byte string, the ciphertext in which the message is encrypted. - It is as long as the RSA modulus (in bytes). - :Raise ValueError: - If the RSA key length is not sufficiently long to deal with the given - message. - - i - - - - - - - - - This function is named ``RSAES-PKCS1-V1_5-DECRYPT``, and is specified in - section 7.2.2 of RFC3447. - For a complete example see `Crypto.Cipher.PKCS1_v1_5`. - - :Parameters: - ct : byte string - The ciphertext that contains the message to recover. - sentinel : any type - The object to return to indicate that an error was detected during decryption. - - :Return: A byte string. It is either the original message or the ``sentinel`` (in case of an error). - :Raise ValueError: - If the ciphertext length is incorrect - :Raise TypeError: - If the RSA key has no private half. - - :attention: - You should **never** let the party who submitted the ciphertext know that - this function returned the ``sentinel`` value. - Armed with such knowledge (for a fair amount of carefully crafted but invalid ciphertexts), - an attacker is able to recontruct the plaintext of any other encryption that were carried out - with the same RSA public key (see `Bleichenbacher's`__ attack). - - In general, it should not be possible for the other party to distinguish - whether processing at the server side failed because the value returned - was a ``sentinel`` as opposed to a random, invalid message. - - In fact, the second option is not that unlikely: encryption done according to PKCS#1 v1.5 - embeds no good integrity check. There is roughly one chance - in 2^16 for a random ciphertext to be returned as a valid message - (although random looking). - - It is therefore advisabled to: - - 1. Select as ``sentinel`` a value that resembles a plausable random, invalid message. - 2. Not report back an error as soon as you detect a ``sentinel`` value. - Put differently, you should not explicitly check if the returned value is the ``sentinel`` or not. - 3. Cover all possible errors with a single, generic error indicator. - 4. Embed into the definition of ``message`` (at the protocol level) a digest (e.g. ``SHA-1``). - It is recommended for it to be the rightmost part ``message``. - 5. Where possible, monitor the number of errors due to ciphertexts originating from the same party, - and slow down the rate of the requests from such party (or even blacklist it altogether). - - **If you are designing a new protocol, consider using the more robust PKCS#1 OAEP.** - - .. __: http://www.bell-labs.com/user/bleichen/papers/pkcs.ps - - i - - - .c - - - :Parameters: - key : RSA key object - The key to use to encrypt or decrypt the message. This is a `Crypto.PublicKey.RSA` object. - Decryption is only possible if *key* is a private RSA key. - - ( -
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Cipher/XOR.pyc b/ta_export/scripts/Crypto/Cipher/XOR.pyc deleted file mode 100755 index 73fa7cb..0000000 --- a/ta_export/scripts/Crypto/Cipher/XOR.pyc +++ b/dev/null @@ -1,41 +0,0 @@ -
-/Oc - - -XOR is one the simplest stream ciphers. Encryption and decryption are -performed by XOR-ing data with a keystream made by contatenating -the key. - -Do not use it for real applications! - -:undocumented: __revision__, __package__ -s - - See also `new()` at the module level.N( - - - :Parameters: - plaintext : byte string - The piece of data to encrypt. It can be of any size. - :Return: the encrypted data (byte string, as long as the - plaintext). - ( - - :Parameters: - ciphertext : byte string - The piece of data to decrypt. It can be of any size. - :Return: the decrypted data (byte string, as long as the - ciphertext). - ( - - - - - :Parameters: - key : byte string - The secret key to use in the symmetric cipher. - Its length may vary from 1 to 32 bytes. - - :Return: an `XORCipher` object - ( -i diff --git a/ta_export/scripts/Crypto/Cipher/__init__.pyc b/ta_export/scripts/Crypto/Cipher/__init__.pyc deleted file mode 100755 index aca9645..0000000 --- a/ta_export/scripts/Crypto/Cipher/__init__.pyc +++ b/dev/null @@ -1,60 +0,0 @@ -
-/Oc - - - - -Encryption algorithms transform plaintext in some way that -is dependent on a key or key pair, producing ciphertext. - -Symmetric algorithms --------------------- - -Encryption can easily be reversed, if (and, hopefully, only if) -one knows the same key. -In other words, sender and receiver share the same key. - -The symmetric encryption modules here all support the interface described in PEP -272, "API for Block Encryption Algorithms". - -If you don't know which algorithm to choose, use AES because it's -standard and has undergone a fair bit of examination. - -======================== ======= ======================== -Module name Type Description -======================== ======= ======================== -`Crypto.Cipher.AES` Block Advanced Encryption Standard -`Crypto.Cipher.ARC2` Block Alleged RC2 -`Crypto.Cipher.ARC4` Stream Alleged RC4 -`Crypto.Cipher.Blowfish` Block Blowfish -`Crypto.Cipher.CAST` Block CAST -`Crypto.Cipher.DES` Block The Data Encryption Standard. - Very commonly used in the past, - but today its 56-bit keys are too small. -`Crypto.Cipher.DES3` Block Triple DES. -`Crypto.Cipher.XOR` Stream The simple XOR cipher. -======================== ======= ======================== - - -Asymmetric algorithms ---------------------- - -For asymmetric algorithms, the key to be used for decryption is totally -different and cannot be derived in a feasible way from the key used -for encryption. Put differently, sender and receiver each own one half -of a key pair. The encryption key is often called ``public`` whereas -the decryption key is called ``private``. - -========================== ======================= -Module name Description -========================== ======================= -`Crypto.Cipher.PKCS1_v1_5` PKCS#1 v1.5 encryption, based on RSA key pairs -`Crypto.Cipher.PKCS1_OAEP` PKCS#1 OAEP encryption, based on RSA key pairs -========================== ======================= - -:undocumented: __revision__, __package__, _AES, _ARC2, _ARC4, _Blowfish - _CAST, _DES, _DES3, _XOR -t - - - diff --git a/ta_export/scripts/Crypto/Cipher/blockalgo.pyc b/ta_export/scripts/Crypto/Cipher/blockalgo.pyc deleted file mode 100755 index 2fd0190..0000000 --- a/ta_export/scripts/Crypto/Cipher/blockalgo.pyc +++ b/dev/null @@ -1,87 +0,0 @@ -
-Bd\Rc - - - - - - - - - - - - - - The cipher object is stateful; encryption of a long block - of data can be broken up in two or more calls to `encrypt()`. - That is, the statement: - - >>> c.encrypt(a) + c.encrypt(b) - - is always equivalent to: - - >>> c.encrypt(a+b) - - That also means that you cannot reuse an object for encrypting - or decrypting other data with the same key. - - This function does not perform any padding. - - - For `MODE_ECB`, `MODE_CBC`, and `MODE_OFB`, *plaintext* length - (in bytes) must be a multiple of *block_size*. - - - For `MODE_CFB`, *plaintext* length (in bytes) must be a multiple - of *segment_size*/8. - - - For `MODE_CTR`, *plaintext* can be of any length. - - - For `MODE_OPENPGP`, *plaintext* must be a multiple of *block_size*, - unless it is the last chunk of the message. - - :Parameters: - plaintext : byte string - The piece of data to encrypt. - :Return: - the encrypted data, as a byte string. It is as long as - *plaintext* with one exception: when encrypting the first message - chunk with `MODE_OPENPGP`, the encypted IV is prepended to the - returned ciphertext. - i - - The cipher object is stateful; decryption of a long block - of data can be broken up in two or more calls to `decrypt()`. - That is, the statement: - - >>> c.decrypt(a) + c.decrypt(b) - - is always equivalent to: - - >>> c.decrypt(a+b) - - That also means that you cannot reuse an object for encrypting - or decrypting other data with the same key. - - This function does not perform any padding. - - - For `MODE_ECB`, `MODE_CBC`, and `MODE_OFB`, *ciphertext* length - (in bytes) must be a multiple of *block_size*. - - - For `MODE_CFB`, *ciphertext* length (in bytes) must be a multiple - of *segment_size*/8. - - - For `MODE_CTR`, *ciphertext* can be of any length. - - - For `MODE_OPENPGP`, *plaintext* must be a multiple of *block_size*, - unless it is the last chunk of the message. - - :Parameters: - ciphertext : byte string - The piece of data to decrypt. - :Return: the decrypted data (byte string, as long as *ciphertext*). - i - - - - -
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Hash/HMAC.pyc b/ta_export/scripts/Crypto/Hash/HMAC.pyc deleted file mode 100755 index 02c2048..0000000 --- a/ta_export/scripts/Crypto/Hash/HMAC.pyc +++ b/dev/null @@ -1,111 +0,0 @@ -
-/Oc - - - - - -HMAC is a MAC defined in RFC2104_ and FIPS-198_ and constructed using -a cryptograpic hash algorithm. -It is usually named *HMAC-X*, where *X* is the hash algorithm; for -instance *HMAC-SHA1* or *HMAC-MD5*. - -The strength of an HMAC depends on: - - - the strength of the hash algorithm - - the length and entropy of the secret key - -An example of possible usage is the following: - - >>> from Crypto.Hash import HMAC - >>> - >>> secret = b'Swordfish' - >>> h = HMAC.new(secret) - >>> h.update(b'Hello') - >>> print h.hexdigest() - -.. _RFC2104: http://www.ietf.org/rfc/rfc2104.txt -.. _FIPS-198: http://csrc.nist.gov/publications/fips/fips198/fips-198a.pdf -s - - - - - :Parameters: - key : byte string - secret key for the MAC object. - It must be long enough to match the expected security level of the - MAC. However, there is no benefit in using keys longer than the - `digest_size` of the underlying hash algorithm. - msg : byte string - The very first chunk of the message to authenticate. - It is equivalent to an early call to `update()`. Optional. - :Parameter digestmod: - The hash algorithm the HMAC is based on. - Default is `Crypto.Hash.MD5`. - :Type digestmod: - A hash module or object instantiated from `Crypto.Hash` - iNi@ - - c - - Repeated calls are equivalent to a single call with the concatenation - of all the arguments. In other words: - - >>> m.update(a); m.update(b) - - is equivalent to: - - >>> m.update(a+b) - - :Parameters: - msg : byte string - The next chunk of the message being authenticated - N( - - The copy will have the same internal state as the original MAC - object. - This can be used to efficiently compute the MAC of strings that - share a common initial substring. - - :Returns: An `HMAC` object - t - - c - been authenticated so far. - - This method does not change the state of the MAC object. - You can continue updating the object after calling this function. - - :Return: A byte string of `digest_size` bytes. It may contain non-ASCII - characters, including null bytes. - ( -c - authenticated so far. - - This method does not change the state of the MAC object. - - :Return: A string of 2* `digest_size` bytes. It contains only - hexadecimal ASCII digits. - R - - - - :Parameters: - key : byte string - key for the MAC object. - It must be long enough to match the expected security level of the - MAC. However, there is no benefit in using keys longer than the - `digest_size` of the underlying hash algorithm. - msg : byte string - The very first chunk of the message to authenticate. - It is equivalent to an early call to `HMAC.update()`. - Optional. - :Parameter digestmod: - The hash to use to implement the HMAC. Default is `Crypto.Hash.MD5`. - :Type digestmod: - A hash module or instantiated object from `Crypto.Hash` - :Returns: An `HMAC` object - ( - -v
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Hash/MD2.pyc b/ta_export/scripts/Crypto/Hash/MD2.pyc deleted file mode 100755 index 2d5b3e6..0000000 --- a/ta_export/scripts/Crypto/Hash/MD2.pyc +++ b/dev/null @@ -1,40 +0,0 @@ -
-Bd\Rc - - - - - -MD2 is specified in RFC1319_ and it produces the 128 bit digest of a message. - - >>> from Crypto.Hash import MD2 - >>> - >>> h = MD2.new() - >>> h.update(b'Hello') - >>> print h.hexdigest() - -MD2 stand for Message Digest version 2, and it was invented by Rivest in 1989. - -This algorithm is both slow and insecure. Do not use it for new designs. - -.. _RFC1319: http://tools.ietf.org/html/rfc1319 -s - - :undocumented: block_size - s - - - - - - c - - :Parameters: - data : byte string - The very first chunk of the message to hash. - It is equivalent to an early call to `MD2Hash.update()`. - Optional. - - :Return: An `MD2Hash` object - ( -
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Hash/MD4.pyc b/ta_export/scripts/Crypto/Hash/MD4.pyc deleted file mode 100755 index 610da47..0000000 --- a/ta_export/scripts/Crypto/Hash/MD4.pyc +++ b/dev/null @@ -1,40 +0,0 @@ -
-Bd\Rc - - - - - -MD4 is specified in RFC1320_ and produces the 128 bit digest of a message. - - >>> from Crypto.Hash import MD4 - >>> - >>> h = MD4.new() - >>> h.update(b'Hello') - >>> print h.hexdigest() - -MD4 stand for Message Digest version 4, and it was invented by Rivest in 1990. - -This algorithm is insecure. Do not use it for new designs. - -.. _RFC1320: http://tools.ietf.org/html/rfc1320 -s - - :undocumented: block_size - s - - - - - - c - - :Parameters: - data : byte string - The very first chunk of the message to hash. - It is equivalent to an early call to `MD4Hash.update()`. - Optional. - - :Return: A `MD4Hash` object - ( -
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Hash/MD5.pyc b/ta_export/scripts/Crypto/Hash/MD5.pyc deleted file mode 100755 index b3d3252..0000000 --- a/ta_export/scripts/Crypto/Hash/MD5.pyc +++ b/dev/null @@ -1,42 +0,0 @@ -
-Bd\Rc - - - - - - -MD5 is specified in RFC1321_ and produces the 128 bit digest of a message. - - >>> from Crypto.Hash import MD5 - >>> - >>> h = MD5.new() - >>> h.update(b'Hello') - >>> print h.hexdigest() - -MD5 stand for Message Digest version 5, and it was invented by Rivest in 1991. - -This algorithm is insecure. Do not use it for new designs. - -.. _RFC1321: http://tools.ietf.org/html/rfc1321 -s - - :undocumented: block_size - s - - - - - - c - - :Parameters: - data : byte string - The very first chunk of the message to hash. - It is equivalent to an early call to `MD5Hash.update()`. - Optional. - - :Return: A `MD5Hash` object - ( -
-
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Hash/RIPEMD.pyc b/ta_export/scripts/Crypto/Hash/RIPEMD.pyc deleted file mode 100755 index d4ed39b..0000000 --- a/ta_export/scripts/Crypto/Hash/RIPEMD.pyc +++ b/dev/null @@ -1,43 +0,0 @@ -
-Bd\Rc - - - - - -RIPEMD-160_ produces the 160 bit digest of a message. - - >>> from Crypto.Hash import RIPEMD - >>> - >>> h = RIPEMD.new() - >>> h.update(b'Hello') - >>> print h.hexdigest() - -RIPEMD-160 stands for RACE Integrity Primitives Evaluation Message Digest -with a 160 bit digest. It was invented by Dobbertin, Bosselaers, and Preneel. - -This algorithm is considered secure, although it has not been scrutinized as -extensively as SHA-1. Moreover, it provides an informal security level of just -80bits. - -.. _RIPEMD-160: http://homes.esat.kuleuven.be/~bosselae/ripemd160.html -s - - :undocumented: block_size - s - - - - - c - - :Parameters: - data : byte string - The very first chunk of the message to hash. - It is equivalent to an early call to `RIPEMD160Hash.update()`. - Optional. - - :Return: A `RIPEMD160Hash` object - ( - -
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Hash/SHA.pyc b/ta_export/scripts/Crypto/Hash/SHA.pyc deleted file mode 100755 index b0ede7f..0000000 --- a/ta_export/scripts/Crypto/Hash/SHA.pyc +++ b/dev/null @@ -1,41 +0,0 @@ -
-Bd\Rc - - - - - - -SHA-1_ produces the 160 bit digest of a message. - - >>> from Crypto.Hash import SHA - >>> - >>> h = SHA.new() - >>> h.update(b'Hello') - >>> print h.hexdigest() - -*SHA* stands for Secure Hash Algorithm. - -This algorithm is not considered secure. Do not use it for new designs. - -.. _SHA-1: http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf -s - - :undocumented: block_size - s - - - - - c - - :Parameters: - data : byte string - The very first chunk of the message to hash. - It is equivalent to an early call to `SHA1Hash.update()`. - Optional. - - :Return: A `SHA1Hash` object - ( -
-
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Hash/SHA224.pyc b/ta_export/scripts/Crypto/Hash/SHA224.pyc deleted file mode 100755 index 0dc36f2..0000000 --- a/ta_export/scripts/Crypto/Hash/SHA224.pyc +++ b/dev/null @@ -1,39 +0,0 @@ -
-Bd\Rc - - - - -SHA-224 belongs to the SHA-2_ family of cryptographic hashes. -It produces the 224 bit digest of a message. - - >>> from Crypto.Hash import SHA224 - >>> - >>> h = SHA224.new() - >>> h.update(b'Hello') - >>> print h.hexdigest() - -*SHA* stands for Secure Hash Algorithm. - -.. _SHA-2: http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf -s - - - :undocumented: block_size - s - - - - - c - - :Parameters: - data : byte string - The very first chunk of the message to hash. - It is equivalent to an early call to `SHA224Hash.update()`. - Optional. - - :Return: A `SHA224Hash` object - ( -
-
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Hash/SHA256.pyc b/ta_export/scripts/Crypto/Hash/SHA256.pyc deleted file mode 100755 index f3978cc..0000000 --- a/ta_export/scripts/Crypto/Hash/SHA256.pyc +++ b/dev/null @@ -1,39 +0,0 @@ -
-Bd\Rc - - - - -SHA-256 belongs to the SHA-2_ family of cryptographic hashes. -It produces the 256 bit digest of a message. - - >>> from Crypto.Hash import SHA256 - >>> - >>> h = SHA256.new() - >>> h.update(b'Hello') - >>> print h.hexdigest() - -*SHA* stands for Secure Hash Algorithm. - -.. _SHA-2: http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf -s - - - :undocumented: block_size - s - - - - - c - - :Parameters: - data : byte string - The very first chunk of the message to hash. - It is equivalent to an early call to `SHA256Hash.update()`. - Optional. - - :Return: A `SHA256Hash` object - ( -
-
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Hash/SHA384.pyc b/ta_export/scripts/Crypto/Hash/SHA384.pyc deleted file mode 100755 index 9571ddb..0000000 --- a/ta_export/scripts/Crypto/Hash/SHA384.pyc +++ b/dev/null @@ -1,39 +0,0 @@ -
-Bd\Rc - - - - -SHA-384 belongs to the SHA-2_ family of cryptographic hashes. -It produces the 384 bit digest of a message. - - >>> from Crypto.Hash import SHA384 - >>> - >>> h = SHA384.new() - >>> h.update(b'Hello') - >>> print h.hexdigest() - -*SHA* stands for Secure Hash Algorithm. - -.. _SHA-2: http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf -s - - - :undocumented: block_size - s - - - - - c - - :Parameters: - data : byte string - The very first chunk of the message to hash. - It is equivalent to an early call to `SHA384Hash.update()`. - Optional. - - :Return: A `SHA384Hash` object - ( -
-
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Hash/SHA512.pyc b/ta_export/scripts/Crypto/Hash/SHA512.pyc deleted file mode 100755 index cd923b4..0000000 --- a/ta_export/scripts/Crypto/Hash/SHA512.pyc +++ b/dev/null @@ -1,39 +0,0 @@ -
-Bd\Rc - - - - -SHA-512 belongs to the SHA-2_ family of cryptographic hashes. -It produces the 512 bit digest of a message. - - >>> from Crypto.Hash import SHA512 - >>> - >>> h = SHA512.new() - >>> h.update(b'Hello') - >>> print h.hexdigest() - -*SHA* stands for Secure Hash Algorithm. - -.. _SHA-2: http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf -s - - - :undocumented: block_size - s - - - - - c - - :Parameters: - data : byte string - The very first chunk of the message to hash. - It is equivalent to an early call to `SHA512Hash.update()`. - Optional. - - :Return: A `SHA512Hash` object - ( -
-
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Hash/__init__.pyc b/ta_export/scripts/Crypto/Hash/__init__.pyc deleted file mode 100755 index 8bec03e..0000000 --- a/ta_export/scripts/Crypto/Hash/__init__.pyc +++ b/dev/null @@ -1,34 +0,0 @@ -
-Bd\Rc - - - - -Hash functions take arbitrary binary strings as input, and produce a random-like output -of fixed size that is dependent on the input; it should be practically infeasible -to derive the original input data given only the hash function's -output. In other words, the hash function is *one-way*. - -It should also not be practically feasible to find a second piece of data -(a *second pre-image*) whose hash is the same as the original message -(*weak collision resistance*). - -Finally, it should not be feasible to find two arbitrary messages with the -same hash (*strong collision resistance*). - -The output of the hash function is called the *digest* of the input message. -In general, the security of a hash function is related to the length of the -digest. If the digest is *n* bits long, its security level is roughly comparable -to the the one offered by an *n/2* bit encryption algorithm. - -Hash functions can be used simply as a integrity check, or, in -association with a public-key algorithm, can be used to implement -digital signatures. - -The hashing modules here all support the interface described in `PEP -247`_ , "API for Cryptographic Hash Functions". - -.. _`PEP 247` : http://www.python.org/dev/peps/pep-0247/ - -:undocumented: _MD2, _MD4, _RIPEMD160, _SHA224, _SHA256, _SHA384, _SHA512 -t diff --git a/ta_export/scripts/Crypto/Hash/hashalgo.pyc b/ta_export/scripts/Crypto/Hash/hashalgo.pyc deleted file mode 100755 index 282b1b5..0000000 --- a/ta_export/scripts/Crypto/Hash/hashalgo.pyc +++ b/dev/null @@ -1,67 +0,0 @@ -
-Bd\Rc - - - :undocumented: block_size - c - - :Parameters: - hashFactory : callable - An object that will generate the actual hash implementation. - *hashFactory* must have a *new()* method, or must be directly - callable. - data : byte string - The very first chunk of the message to hash. - It is equivalent to an early call to `update()`. - t - - - Repeated calls are equivalent to a single call with the concatenation - of all the arguments. In other words: - - >>> m.update(a); m.update(b) - - is equivalent to: - - >>> m.update(a+b) - - :Parameters: - data : byte string - The next chunk of the message being hashed. - ( - - This method does not change the state of the hash object. - You can continue updating the object after calling this function. - - :Return: A byte string of `digest_size` bytes. It may contain non-ASCII - characters, including null bytes. - ( - - - This method does not change the state of the hash object. - - :Return: A string of 2* `digest_size` characters. It contains only - hexadecimal ASCII digits. - ( - - The copy will have the same internal state as the original hash - object. - This can be used to efficiently compute the digests of strings that - share a common initial substring. - - :Return: A hash object of the same type - ( -c - - Unlike the `copy` method, the internal state of the object is empty. - - :Parameters: - data : byte string - The next chunk of the message being hashed. - - :Return: A hash object of the same type - N( - - - - N( diff --git a/ta_export/scripts/Crypto/Protocol/AllOrNothing.pyc b/ta_export/scripts/Crypto/Protocol/AllOrNothing.pyc deleted file mode 100755 index e41a31f..0000000 --- a/ta_export/scripts/Crypto/Protocol/AllOrNothing.pyc +++ b/dev/null @@ -1,95 +0,0 @@ -
-/Oc - - - - -An all-or-nothing package transformation is one in which some text is -transformed into message blocks, such that all blocks must be obtained before -the reverse transformation can be applied. Thus, if any blocks are corrupted -or lost, the original message cannot be reproduced. - -An all-or-nothing package transformation is not encryption, although a block -cipher algorithm is used. The encryption key is randomly generated and is -extractable from the message blocks. - -This class implements the All-Or-Nothing package transformation algorithm -described in: - -Ronald L. Rivest. "All-Or-Nothing Encryption and The Package Transform" -http://theory.lcs.mit.edu/~rivest/fusion.pdf - -s - - - - Methods for subclassing: - - _inventkey(key_size): - Returns a randomly generated key. Subclasses can use this to - implement better random key generating algorithms. The default - algorithm is probably not very cryptographically secure. - - c - - ciphermodule is a module implementing the cipher algorithm to - use. It must provide the PEP272 interface. - - Note that the encryption key is randomly generated - automatically when needed. Optional arguments mode and IV are - passed directly through to the ciphermodule.new() method; they - are the feedback mode and initialization vector to use. All - three arguments must be the same for the object used to create - the digest, and to undigest'ify the message blocks. - i - - - - - - - Perform the All-or-Nothing package transform on the given - string. Output is a list of message blocks describing the - transformed text, where each block is a string of bit length equal - to the ciphermodule's block_size. - t - - -
-
c - - - - - - Perform the reverse package transformation on a list of message - blocks. Note that the ciphermodule used for both transformations - must be the same. blocks is a list of strings of bit length - equal to the ciphermodule's block_size. - i - - - - - R 6 t - -Where: - --cipher module - -c module - Cipher module to use. Default: %(ciphermodule)s - - --aslong - -l - Print the encoded message blocks as long integers instead of base64 - encoded strings - - --help - -h - Print this help message -t - -i -==========s - - -
(
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Protocol/Chaffing.pyc b/ta_export/scripts/Crypto/Protocol/Chaffing.pyc deleted file mode 100755 index bd8f20e..0000000 --- a/ta_export/scripts/Crypto/Protocol/Chaffing.pyc +++ b/dev/null @@ -1,109 +0,0 @@ -
-/Oc - - - - - - -Winnowing and chaffing is a technique for enhancing privacy without requiring -strong encryption. In short, the technique takes a set of authenticated -message blocks (the wheat) and adds a number of chaff blocks which have -randomly chosen data and MAC fields. This means that to an adversary, the -chaff blocks look as valid as the wheat blocks, and so the authentication -would have to be performed on every block. By tailoring the number of chaff -blocks added to the message, the sender can make breaking the message -computationally infeasible. There are many other interesting properties of -the winnow/chaff technique. - -For example, say Alice is sending a message to Bob. She packetizes the -message and performs an all-or-nothing transformation on the packets. Then -she authenticates each packet with a message authentication code (MAC). The -MAC is a hash of the data packet, and there is a secret key which she must -share with Bob (key distribution is an exercise left to the reader). She then -adds a serial number to each packet, and sends the packets to Bob. - -Bob receives the packets, and using the shared secret authentication key, -authenticates the MACs for each packet. Those packets that have bad MACs are -simply discarded. The remainder are sorted by serial number, and passed -through the reverse all-or-nothing transform. The transform means that an -eavesdropper (say Eve) must acquire all the packets before any of the data can -be read. If even one packet is missing, the data is useless. - -There's one twist: by adding chaff packets, Alice and Bob can make Eve's job -much harder, since Eve now has to break the shared secret key, or try every -combination of wheat and chaff packet to read any of the message. The cool -thing is that Bob doesn't need to add any additional code; the chaff packets -are already filtered out because their MACs don't match (in all likelihood -- -since the data and MACs for the chaff packets are randomly chosen it is -possible, but very unlikely that a chaff MAC will match the chaff data). And -Alice need not even be the party adding the chaff! She could be completely -unaware that a third party, say Charles, is adding chaff packets to her -messages as they are transmitted. - -For more information on winnowing and chaffing see this paper: - -Ronald L. Rivest, "Chaffing and Winnowing: Confidentiality without Encryption" -http://theory.lcs.mit.edu/~rivest/chaffing.txt - -s - - Methods for subclasses: - - _randnum(size): - Returns a randomly generated number with a byte-length equal - to size. Subclasses can use this to implement better random - data and MAC generating algorithms. The default algorithm is - probably not very cryptographically secure. It is most - important that the chaff data does not contain any patterns - that can be used to discern it from wheat data without running - the MAC. - - g - - factor is the number of message blocks to add chaff to, - expressed as a percentage between 0.0 and 1.0. blocksper is - the number of chaff blocks to include for each block being - chaffed. Thus the defaults add one chaff block to every - message block. By changing the defaults, you can adjust how - computationally difficult it could be for an adversary to - brute-force crack the message. The difficulty is expressed - as: - - pow(blocksper, int(factor * number-of-blocks)) - - For ease of implementation, when factor < 1.0, only the first - int(factor*number-of-blocks) message blocks are chaffed. - g - - - - : [(int, string, string)] - - Add chaff to message blocks. blocks is a list of 3-tuples of the - form (serial-number, data, MAC). - - Chaff is created by choosing a random number of the same - byte-length as data, and another random number of the same - byte-length as MAC. The message block's serial number is - placed on the chaff block and all the packet's chaff blocks - are randomly interspersed with the single wheat block. This - method then returns a list of 3-tuples of the same form. - Chaffed blocks will contain multiple instances of 3-tuples - with the same serial number, but the only way to figure out - which blocks are wheat and which are chaff is to perform the - MAC hash and compare values. - i - -they are endowed by their Creator with certain unalienable Rights, that among -these are Life, Liberty, and the pursuit of Happiness. That to secure these -rights, Governments are instituted among Men, deriving their just powers from -the consent of the governed. That whenever any Form of Government becomes -destructive of these ends, it is the Right of the People to alter or to -abolish it, and to institute new Government, laying its foundation on such -principles and organizing its powers in such form, as to them shall seem most -likely to effect their Safety and Happiness. -s -==========s - - diff --git a/ta_export/scripts/Crypto/Protocol/KDF.pyc b/ta_export/scripts/Crypto/Protocol/KDF.pyc deleted file mode 100755 index 59b96c9..0000000 --- a/ta_export/scripts/Crypto/Protocol/KDF.pyc +++ b/dev/null @@ -1,69 +0,0 @@ -
-Bd\Rc - - - - -A key derivation function derives one or more secondary secret keys from -one primary secret (a master key or a pass phrase). - -This is typically done to insulate the secondary keys from each other, -to avoid that leakage of a secondary key compromises the security of the -master key, or to thwart attacks on pass phrases (e.g. via rainbow tables). - -:undocumented: __revision__ -s - - This function performs key derivation according an old version of - the PKCS#5 standard (v1.5). - - This algorithm is called ``PBKDF1``. Even though it is still described - in the latest version of the PKCS#5 standard (version 2, or RFC2898), - newer applications should use the more secure and versatile `PBKDF2` instead. - - :Parameters: - password : string - The secret password or pass phrase to generate the key from. - salt : byte string - An 8 byte string to use for better protection from dictionary attacks. - This value does not need to be kept secret, but it should be randomly - chosen for each derivation. - dkLen : integer - The length of the desired key. Default is 16 bytes, suitable for instance for `Crypto.Cipher.AES`. - count : integer - The number of iterations to carry out. It's recommended to use at least 1000. - hashAlgo : module - The hash algorithm to use, as a module or an object from the `Crypto.Hash` package. - The digest length must be no shorter than ``dkLen``. - The default algorithm is `SHA1`. - - :Return: A byte string of length `dkLen` that can be used as key. - s: - - - - - This performs key derivation according to the PKCS#5 standard (v2.0), - by means of the ``PBKDF2`` algorithm. - - :Parameters: - password : string - The secret password or pass phrase to generate the key from. - salt : string - A string to use for better protection from dictionary attacks. - This value does not need to be kept secret, but it should be randomly - chosen for each derivation. It is recommended to be at least 8 bytes long. - dkLen : integer - The cumulative length of the desired keys. Default is 16 bytes, suitable for instance for `Crypto.Cipher.AES`. - count : integer - The number of iterations to carry out. It's recommended to use at least 1000. - prf : callable - A pseudorandom function. It must be a function that returns a pseudorandom string - from two parameters: a secret and a salt. If not specified, HMAC-SHA1 is used. - - :Return: A byte string of length `dkLen` that can be used as key material. - If you wanted multiple keys, just break up this string into segments of the desired length. -c - -( -)
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Protocol/__init__.pyc b/ta_export/scripts/Crypto/Protocol/__init__.pyc deleted file mode 100755 index 561feba..0000000 --- a/ta_export/scripts/Crypto/Protocol/__init__.pyc +++ b/dev/null @@ -1,19 +0,0 @@ -
-/Oc - -Implements various cryptographic protocols. (Don't expect to find -network protocols here.) - -Crypto.Protocol.AllOrNothing - Transforms a message into a set of message blocks, such that the blocks - can be recombined to get the message back. - -Crypto.Protocol.Chaffing - Takes a set of authenticated message blocks (the wheat) and adds a number - of randomly generated blocks (the chaff). - -Crypto.Protocol.KDF - A collection of standard key derivation functions. - -:undocumented: __revision__ -t diff --git a/ta_export/scripts/Crypto/PublicKey/DSA.pyc b/ta_export/scripts/Crypto/PublicKey/DSA.pyc deleted file mode 100755 index 8eb626a..0000000 --- a/ta_export/scripts/Crypto/PublicKey/DSA.pyc +++ b/dev/null @@ -1,183 +0,0 @@ -
-Bd\Rc - - - - -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.Random import random - >>> from Crypto.PublicKey import DSA - >>> from Crypto.Hash import SHA - >>> - >>> message = "Hello" - >>> key = DSA.generate(1024) - >>> h = SHA.new(message).digest() - >>> k = random.StrongRandom().randint(1,key.q-1) - >>> sig = key.sign(h,k) - >>> ... - >>> if key.verify(h,sig): - >>> 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 -s - - - - :undocumented: __getstate__, __setstate__, __repr__, __getattr__ - t - - :Parameter M: The piece of data to sign with DSA. It may - not be longer in bit size than the sub-group order (*q*). - :Type M: byte string or long - - :Parameter K: A secret number, chosen randomly in the closed - range *[1,q-1]*. - :Type K: long (recommended) or byte string (not recommended) - - :attention: selection of *K* is crucial for security. Generating a - random number larger than *q* and taking the modulus by *q* is - **not** secure, since smaller values will occur more frequently. - Generating a random number systematically smaller than *q-1* - (e.g. *floor((q-1)/8)* random bytes) is also **not** secure. In general, - it shall not be possible for an attacker to know the value of `any - bit of K`__. - - :attention: The number *K* shall not be reused for any other - operation and shall be discarded immediately. - - :attention: M must be a digest cryptographic hash, otherwise - an attacker may mount an existential forgery attack. - - :Return: A tuple with 2 longs. - - .. __: http://www.di.ens.fr/~pnguyen/pub_NgSh00.htm - ( - - :Parameter M: The expected message. - :Type M: byte string or long - - :Parameter signature: The DSA signature to verify. - :Type signature: A tuple with 2 longs as return by `sign` - - :Return: True if the signature is correct, False otherwise. - ( - - - - -c - A DSA key factory. - - This class is only internally used to implement the methods of the - `Crypto.PublicKey.DSA` module. - c - - :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
- - - - - :Parameters: - bits : int - Key length, or size (in bits) of the DSA modulus - *p*. - It must be a multiple of 64, in the closed - interval [512,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. - - :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: A DSA key object (`_DSAobj`). - - :Raise ValueError: - When **bits** is too little, too big, or not a multiple of 64. - i - - - - The modulus *p* must be a prime. - - The following equations must apply: - - - p-1 = 0 mod q - - g^x = y mod p - - 0 < x < q - - 1 < g < p - - :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. - - :Return: A DSA key object (`_DSAobj`). - ( - -
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/PublicKey/ElGamal.pyc b/ta_export/scripts/Crypto/PublicKey/ElGamal.pyc deleted file mode 100755 index 2a2ccb9..0000000 --- a/ta_export/scripts/Crypto/PublicKey/ElGamal.pyc +++ b/dev/null @@ -1,214 +0,0 @@ -
-Bd\Rc - - - -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.Random import random - >>> from Crypto.PublicKey import ElGamal - >>> from Crypto.Util.number import GCD - >>> from Crypto.Hash import SHA - >>> - >>> message = "Hello" - >>> key = ElGamal.generate(1024, Random.new().read) - >>> h = SHA.new(message).digest() - >>> while 1: - >>> k = random.StrongRandom().randint(1,key.p-1) - >>> if GCD(k,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 -s - - - - - - 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. - 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. - - :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 (`ElGamalobj`). - s -i -i -s -(
- - 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. - - :Return: An ElGamal key object (`ElGamalobj`). - i - - - - - :undocumented: __getstate__, __setstate__, __repr__, __getattr__ - R - - :Parameter plaintext: The piece of data to encrypt with ElGamal. - It must be numerically smaller than the module (*p*). - :Type plaintext: byte string or long - - :Parameter K: A secret number, chosen randomly in the closed - range *[1,p-2]*. - :Type K: long (recommended) or byte string (not recommended) - - :Return: A tuple with two items. Each item is of the same type as the - plaintext (string or long). - - :attention: selection of *K* is crucial for security. Generating a - random number larger than *p-1* and taking the modulus by *p-1* is - **not** secure, since smaller values will occur more frequently. - Generating a random number systematically smaller than *p-1* - (e.g. *floor((p-1)/8)* random bytes) is also **not** secure. - In general, it shall not be possible for an attacker to know - the value of any bit of K. - - :attention: The number *K* shall not be reused for any other - operation and shall be discarded immediately. - ( - - :Parameter ciphertext: The piece of data to decrypt with ElGamal. - :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. - ( - -c - - :Parameter M: The piece of data to sign with ElGamal. It may - not be longer in bit size than *p-1*. - :Type M: byte string or long - - :Parameter K: A secret number, chosen randomly in the closed - range *[1,p-2]* and such that *gcd(k,p-1)=1*. - :Type K: long (recommended) or byte string (not recommended) - - :attention: selection of *K* is crucial for security. Generating a - random number larger than *p-1* and taking the modulus by *p-1* is - **not** secure, since smaller values will occur more frequently. - Generating a random number systematically smaller than *p-1* - (e.g. *floor((p-1)/8)* random bytes) is also **not** secure. - In general, it shall not be possible for an attacker to know - the value of any bit of K. - - :attention: The number *K* shall not be reused for any other - operation and shall be discarded immediately. - - :attention: M must be be a cryptographic hash, otherwise an - attacker may mount an existential forgery attack. - - :Return: A tuple with 2 longs. - ( - - :Parameter M: The expected message. - :Type M: byte string or long - - :Parameter signature: The ElGamal signature to verify. - :Type signature: A tuple with 2 longs as return by `sign` - - :Return: True if the signature is correct, False otherwise. - ( - - N( - J !
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/PublicKey/RSA.pyc b/ta_export/scripts/Crypto/PublicKey/RSA.pyc deleted file mode 100755 index efb8df5..0000000 --- a/ta_export/scripts/Crypto/PublicKey/RSA.pyc +++ b/dev/null @@ -1,336 +0,0 @@ -
-~/Sc - - - - - -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 - - - - :undocumented: __getstate__, __setstate__, __repr__, __getattr__ - t - - - :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. - ( - - 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. - ( - - - 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. - ( - - :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. - ( - - - - - - - - - - - - - - - - - :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 - - -N( -s - -i0 - - - - - & 0 ?N( - - c - 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 - - :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
- - - - :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 - - - 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`). - ( - - - - - - - - - - - - - :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 - - - - -
- diff --git a/ta_export/scripts/Crypto/PublicKey/_DSA.pyc b/ta_export/scripts/Crypto/PublicKey/_DSA.pyc deleted file mode 100755 index 2b14e04..0000000 --- a/ta_export/scripts/Crypto/PublicKey/_DSA.pyc +++ b/dev/null @@ -1,27 +0,0 @@ -
-Bd\Rc - - - - - -c - - - - - - - Generate a DSA key of length 'bits', using 'randfunc' to get - random data and 'progress_func', if present, to display - the progress of the key generation. - i -i -s -s -i - - -
,
R - - 8
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/PublicKey/_RSA.pyc b/ta_export/scripts/Crypto/PublicKey/_RSA.pyc deleted file mode 100755 index 1d79aab..0000000 --- a/ta_export/scripts/Crypto/PublicKey/_RSA.pyc +++ b/dev/null @@ -1,15 +0,0 @@ -
-/Oc - - - Generate an RSA key of length 'bits', public exponent 'e'(which must be - odd), using 'randfunc' to get random data and 'progress_func', - if present, to display the progress of the key generation. - s -l -s -s - '
*"R - Return the maximum number of bits that can be handled by this key. - i - diff --git a/ta_export/scripts/Crypto/PublicKey/__init__.pyc b/ta_export/scripts/Crypto/PublicKey/__init__.pyc deleted file mode 100755 index 8dead4d..0000000 --- a/ta_export/scripts/Crypto/PublicKey/__init__.pyc +++ b/dev/null @@ -1,18 +0,0 @@ -
-Bd\Rc - -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. - -======================== ============================================= -Module Description -======================== ============================================= -Crypto.PublicKey.DSA Digital Signature Algorithm (Signature only) -Crypto.PublicKey.ElGamal (Signing and encryption) -Crypto.PublicKey.RSA (Signing, encryption, and blinding) -======================== ============================================= - -:undocumented: _DSA, _RSA, _fastmath, _slowmath, pubkey -t diff --git a/ta_export/scripts/Crypto/PublicKey/_slowmath.pyc b/ta_export/scripts/Crypto/PublicKey/_slowmath.pyc deleted file mode 100755 index 4480269..0000000 --- a/ta_export/scripts/Crypto/PublicKey/_slowmath.pyc +++ b/dev/null @@ -1,21 +0,0 @@ -
-/Oc - - - - c - - - - - - - - - - - - - - - diff --git a/ta_export/scripts/Crypto/PublicKey/pubkey.pyc b/ta_export/scripts/Crypto/PublicKey/pubkey.pyc deleted file mode 100755 index 447163a..0000000 --- a/ta_export/scripts/Crypto/PublicKey/pubkey.pyc +++ b/dev/null @@ -1,112 +0,0 @@ -
-/Oc - - - - :undocumented: __getstate__, __setstate__, __eq__, __ne__, validate - c - converted to standard Python long integers before being - written out. It will then be reconverted as necessary on - restoration.( - - - - -number representation being used, whether that is Python long -integers, MPZ objects, or whatever.N( - - :Parameter plaintext: The piece of data to encrypt. - :Type plaintext: byte string or long - - :Parameter K: A random parameter required by some algorithms - :Type K: byte string or long - - :Return: A tuple with two items. Each item is of the same type as the - plaintext (string or long). - i - - - - - :Parameter ciphertext: The piece of data to decrypt. - :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. - i -c - - :Parameter M: The piece of data to encrypt. - :Type M: byte string or long - - :Parameter K: A random parameter required by some algorithms - :Type K: byte string or long - - :Return: A tuple with two items. - s( - - :Parameter M: The expected message. - :Type M: byte string or long - - :Parameter signature: The signature to verify. - :Type signature: tuple with two items, as return by `sign` - - :Return: True if the signature is correct, False otherwise. - ( - - :Parameter M: The message to blind. - :Type M: byte string or long - - :Parameter B: Blinding factor. - :Type B: byte string or long - - :Return: A byte string if M was so. A long otherwise. - i -c - - :Parameter M: The encoded message to unblind. - :Type M: byte string or long - - :Parameter B: Blinding factor. - :Type B: byte string or long - i -c - - This property concerns the *algorithm*, not the key itself. - It may happen that this particular key object hasn't got - the private information required to generate a signature. - - :Return: boolean - i - - This property concerns the *algorithm*, not the key itself. - It may happen that this particular key object hasn't got - the private information required to decrypt data. - - :Return: boolean - i - - This property concerns the *algorithm*, not the key itself. - It may happen that this particular key object hasn't got - the private information required carry out blinding. - - :Return: boolean - i - - :Return: int - i - - :Return: bool - i - - :Return: A new `pubkey` object. - ( - Compare us to other for equality. - ( - - Compare us to other for inequality. - ( - - - ( -
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Random/Fortuna/FortunaAccumulator.pyc b/ta_export/scripts/Crypto/Random/Fortuna/FortunaAccumulator.pyc deleted file mode 100755 index 7fc1b6c..0000000 --- a/ta_export/scripts/Crypto/Random/Fortuna/FortunaAccumulator.pyc +++ b/dev/null @@ -1,28 +0,0 @@ -
-Bd\Rc - - - - - This object acts like a hash object, with the following differences: - - - It keeps a count (the .length attribute) of the number of bytes that - have been added to the pool - - It supports a .reset() method for in-place reinitialization - - The method to add bytes to the pool is .append(), not .update(). - c - - - - According to _Practical Cryptography_, chapter 10.5.2 "Pools": - - "Pool P_i is included if 2**i is a divisor of r. Thus P_0 is used - every reseed, P_1 every other reseed, P_2 every fourth reseed, etc." - i - - - - - - - !
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Random/Fortuna/FortunaGenerator.pyc b/ta_export/scripts/Crypto/Random/Fortuna/FortunaGenerator.pyc deleted file mode 100755 index 815bebc..0000000 --- a/ta_export/scripts/Crypto/Random/Fortuna/FortunaGenerator.pyc +++ b/dev/null @@ -1,28 +0,0 @@ -
-Bd\Rc - - - - - - - - This is used internally by the Fortuna PRNG to generate arbitrary amounts - of pseudorandom data from a smaller amount of seed data. - - The output is generated by running AES-256 in counter mode and re-keying - after every mebibyte (2**16 blocks) of output. - i - - - - -c - -c - - - - -
( -
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Random/Fortuna/SHAd256.pyc b/ta_export/scripts/Crypto/Random/Fortuna/SHAd256.pyc deleted file mode 100755 index 954c924..0000000 --- a/ta_export/scripts/Crypto/Random/Fortuna/SHAd256.pyc +++ b/dev/null @@ -1,22 +0,0 @@ -
-/Oc - - - - - -This module should comply with PEP 247. -s - - - Returns SHA-256(SHA-256(data)). - c - - - - - - -c - -*
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Random/Fortuna/__init__.pyc b/ta_export/scripts/Crypto/Random/Fortuna/__init__.pyc deleted file mode 100755 index d9fa7fd..0000000 --- a/ta_export/scripts/Crypto/Random/Fortuna/__init__.pyc +++ b/dev/null @@ -1,2 +0,0 @@ -
-/Oc diff --git a/ta_export/scripts/Crypto/Random/OSRNG/__init__.pyc b/ta_export/scripts/Crypto/Random/OSRNG/__init__.pyc deleted file mode 100755 index 478a9fc..0000000 --- a/ta_export/scripts/Crypto/Random/OSRNG/__init__.pyc +++ b/dev/null @@ -1,4 +0,0 @@ -
-/Oc -supplied by various operating systems.s - diff --git a/ta_export/scripts/Crypto/Random/OSRNG/fallback.pyc b/ta_export/scripts/Crypto/Random/OSRNG/fallback.pyc deleted file mode 100755 index 04dc683..0000000 --- a/ta_export/scripts/Crypto/Random/OSRNG/fallback.pyc +++ b/dev/null @@ -1,4 +0,0 @@ -
-/Oc - - diff --git a/ta_export/scripts/Crypto/Random/OSRNG/nt.pyc b/ta_export/scripts/Crypto/Random/OSRNG/nt.pyc deleted file mode 100755 index acb819a..0000000 --- a/ta_export/scripts/Crypto/Random/OSRNG/nt.pyc +++ b/dev/null @@ -1,21 +0,0 @@ -
-Bd\Rc - - - The CryptGenRandom mechanism in some versions of Windows allows an - attacker to learn 128 KiB of past and future output. As a workaround, - this function reads 128 KiB of 'random' data from Windows and discards - it. - - For more information about the weaknesses in CryptGenRandom, see - _Cryptanalysis of the Random Number Generator of the Windows Operating - System_, by Leo Dorrendorf and Zvi Gutterman and Benny Pinkas - http://eprint.iacr.org/2007/419 - s - - - -( - - - diff --git a/ta_export/scripts/Crypto/Random/OSRNG/posix.pyc b/ta_export/scripts/Crypto/Random/OSRNG/posix.pyc deleted file mode 100755 index 70c2488..0000000 --- a/ta_export/scripts/Crypto/Random/OSRNG/posix.pyc +++ b/dev/null @@ -1,8 +0,0 @@ -
-/Oc - - - c - - - diff --git a/ta_export/scripts/Crypto/Random/OSRNG/rng_base.pyc b/ta_export/scripts/Crypto/Random/OSRNG/rng_base.pyc deleted file mode 100755 index 6bcf994..0000000 --- a/ta_export/scripts/Crypto/Random/OSRNG/rng_base.pyc +++ b/dev/null @@ -1,9 +0,0 @@ -
-/Oc - - - - - - - diff --git a/ta_export/scripts/Crypto/Random/_UserFriendlyRNG.pyc b/ta_export/scripts/Crypto/Random/_UserFriendlyRNG.pyc deleted file mode 100755 index a9af526..0000000 --- a/ta_export/scripts/Crypto/Random/_UserFriendlyRNG.pyc +++ b/dev/null @@ -1,22 +0,0 @@ -
-Bd\Rc - - - -c - - -t - the operating system. - N( -c - - - - -c -( - - c - K -
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Random/__init__.pyc b/ta_export/scripts/Crypto/Random/__init__.pyc deleted file mode 100755 index a9474dd..0000000 --- a/ta_export/scripts/Crypto/Random/__init__.pyc +++ b/dev/null @@ -1,2 +0,0 @@ -
-/Oc diff --git a/ta_export/scripts/Crypto/Random/random.pyc b/ta_export/scripts/Crypto/Random/random.pyc deleted file mode 100755 index 387afa9..0000000 --- a/ta_export/scripts/Crypto/Random/random.pyc +++ b/dev/null @@ -1,24 +0,0 @@ -
-Bd\Rc - - - - - - - - - - - Return a randomly-selected element from range(start, stop, step).i - - - - If the seqence is empty, raises IndexError. - i - - - - - " -( diff --git a/ta_export/scripts/Crypto/Signature/PKCS1_PSS.pyc b/ta_export/scripts/Crypto/Signature/PKCS1_PSS.pyc deleted file mode 100755 index bcd2237..0000000 --- a/ta_export/scripts/Crypto/Signature/PKCS1_PSS.pyc +++ b/dev/null @@ -1,182 +0,0 @@ -
-Bd\Rc - - - - - - -See RFC3447__ or the `original RSA Labs specification`__. - -This scheme is more properly called ``RSASSA-PSS``. - -For example, a sender may authenticate a message using SHA-1 and PSS like -this: - - >>> from Crypto.Signature import PKCS1_PSS - >>> from Crypto.Hash import SHA - >>> from Crypto.PublicKey import RSA - >>> from Crypto import Random - >>> - >>> message = 'To be signed' - >>> key = RSA.importKey(open('privkey.der').read()) - >>> h = SHA.new() - >>> h.update(message) - >>> signer = PKCS1_PSS.new(key) - >>> signature = PKCS1_PSS.sign(key) - -At the receiver side, verification can be done like using the public part of -the RSA key: - - >>> key = RSA.importKey(open('pubkey.der').read()) - >>> h = SHA.new() - >>> h.update(message) - >>> verifier = PKCS1_PSS.new(key) - >>> if verifier.verify(h, signature): - >>> print "The signature is authentic." - >>> else: - >>> print "The signature is not authentic." - -:undocumented: __revision__, __package__ - -.. __: http://www.ietf.org/rfc/rfc3447.txt -.. __: http://www.rsa.com/rsalabs/node.asp?id=2125 -i( - - - :Parameters: - key : an RSA key object - If a private half is given, both signature and verification are possible. - If a public half is given, only verification is possible. - mgfunc : callable - A mask generation function that accepts two parameters: a string to - use as seed, and the lenth of the mask to generate, in bytes. - saltLen : int - Length of the salt, in bytes. - N( - - - - This function is named ``RSASSA-PSS-SIGN``, and is specified in - section 8.1.1 of RFC3447. - - :Parameters: - mhash : hash object - The hash that was carried out over the message. This is an object - belonging to the `Crypto.Hash` module. - - :Return: The PSS signature encoded as a string. - :Raise ValueError: - If the RSA key length is not sufficiently long to deal with the given - hash algorithm. - :Raise TypeError: - If the RSA key has no private half. - - :attention: Modify the salt length and the mask generation function only - if you know what you are doing. - The receiver must use the same parameters too. - c - - - - - - - - This function checks if the party holding the private half of the given - RSA key has really signed the message. - - This function is called ``RSASSA-PSS-VERIFY``, and is specified in section - 8.1.2 of RFC3447. - - :Parameters: - mhash : hash object - The hash that was carried out over the message. This is an object - belonging to the `Crypto.Hash` module. - S : string - The signature that needs to be validated. - - :Return: True if verification is correct. False otherwise. - c - - - - - - - - Implement the ``EMSA-PSS-ENCODE`` function, as defined - in PKCS#1 v2.1 (RFC3447, 9.1.1). - - The original ``EMSA-PSS-ENCODE`` actually accepts the message ``M`` as input, - and hash it internally. Here, we expect that the message has already - been hashed instead. - - :Parameters: - mhash : hash object - The hash object that holds the digest of the message being signed. - emBits : int - Maximum length of the final encoding, in bits. - randFunc : callable - An RNG function that accepts as only parameter an int, and returns - a string of random bytes, to be used as salt. - mgf : callable - A mask generation function that accepts two parameters: a string to - use as seed, and the lenth of the mask to generate, in bytes. - sLen : int - Length of the salt, in bytes. - - :Return: An ``emLen`` byte long string that encodes the hash - (with ``emLen = \ceil(emBits/8)``). - - :Raise ValueError: - When digest or salt length are too big. - i - - - - - Implement the ``EMSA-PSS-VERIFY`` function, as defined - in PKCS#1 v2.1 (RFC3447, 9.1.2). - - ``EMSA-PSS-VERIFY`` actually accepts the message ``M`` as input, - and hash it internally. Here, we expect that the message has already - been hashed instead. - - :Parameters: - mhash : hash object - The hash object that holds the digest of the message to be verified. - em : string - The signature to verify, therefore proving that the sender really signed - the message that was received. - emBits : int - Length of the final encoding (em), in bits. - mgf : callable - A mask generation function that accepts two parameters: a string to - use as seed, and the lenth of the mask to generate, in bytes. - sLen : int - Length of the salt, in bytes. - - :Return: 0 if the encoding is consistent, 1 if it is inconsistent. - - :Raise ValueError: - When digest or salt length are too big. - i - - can be used to perform PKCS#1 PSS signature or verification. - - :Parameters: - key : RSA key object - The key to use to sign or verify the message. This is a `Crypto.PublicKey.RSA` object. - Signing is only possible if *key* is a private RSA key. - mgfunc : callable - A mask generation function that accepts two parameters: a string to - use as seed, and the lenth of the mask to generate, in bytes. - If not specified, the standard MGF1 is used. - saltLen : int - Length of the salt, in bytes. If not specified, it matches the output - size of the hash function. - - ( - -&
} ; D
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Signature/PKCS1_v1_5.pyc b/ta_export/scripts/Crypto/Signature/PKCS1_v1_5.pyc deleted file mode 100755 index f69af65..0000000 --- a/ta_export/scripts/Crypto/Signature/PKCS1_v1_5.pyc +++ b/dev/null @@ -1,125 +0,0 @@ -
-Bd\Rc - - -RSA digital signature protocol according to PKCS#1 v1.5 - -See RFC3447__ or the `original RSA Labs specification`__. - -This scheme is more properly called ``RSASSA-PKCS1-v1_5``. - -For example, a sender may authenticate a message using SHA-1 like -this: - - >>> from Crypto.Signature import PKCS1_v1_5 - >>> from Crypto.Hash import SHA - >>> from Crypto.PublicKey import RSA - >>> - >>> message = 'To be signed' - >>> key = RSA.importKey(open('privkey.der').read()) - >>> h = SHA.new(message) - >>> signer = PKCS1_v1_5.new(key) - >>> signature = signer.sign(h) - -At the receiver side, verification can be done using the public part of -the RSA key: - - >>> key = RSA.importKey(open('pubkey.der').read()) - >>> h = SHA.new(message) - >>> verifier = PKCS1_v1_5.new(key) - >>> if verifier.verify(h, signature): - >>> print "The signature is authentic." - >>> else: - >>> print "The signature is not authentic." - -:undocumented: __revision__, __package__ - -.. __: http://www.ietf.org/rfc/rfc3447.txt -.. __: http://www.rsa.com/rsalabs/node.asp?id=2125 -s - - :Parameters: - key : an RSA key object - If a private half is given, both signature and verification are possible. - If a public half is given, only verification is possible. - N( - - - This function is named ``RSASSA-PKCS1-V1_5-SIGN``, and is specified in - section 8.2.1 of RFC3447. - - :Parameters: - mhash : hash object - The hash that was carried out over the message. This is an object - belonging to the `Crypto.Hash` module. - - :Return: The signature encoded as a string. - :Raise ValueError: - If the RSA key length is not sufficiently long to deal with the given - hash algorithm. - :Raise TypeError: - If the RSA key has no private half. - i - - - - This function checks if the party holding the private half of the key - really signed the message. - - This function is named ``RSASSA-PKCS1-V1_5-VERIFY``, and is specified in - section 8.2.2 of RFC3447. - - :Parameters: - mhash : hash object - The hash that was carried out over the message. This is an object - belonging to the `Crypto.Hash` module. - S : string - The signature that needs to be validated. - - :Return: True if verification is correct. False otherwise. - i - - - - - c - Implement the ``EMSA-PKCS1-V1_5-ENCODE`` function, as defined - in PKCS#1 v2.1 (RFC3447, 9.2). - - ``EMSA-PKCS1-V1_5-ENCODE`` actually accepts the message ``M`` as input, - and hash it internally. Here, we expect that the message has already - been hashed instead. - - :Parameters: - hash : hash object - The hash object that holds the digest of the message being signed. - emLen : int - The length the final encoding must have, in bytes. - - :attention: the early standard (RFC2313) stated that ``DigestInfo`` - had to be BER-encoded. This means that old signatures - might have length tags in indefinite form, which - is not supported in DER. Such encoding cannot be - reproduced by this function. - - :attention: the same standard defined ``DigestAlgorithm`` to be - of ``AlgorithmIdentifier`` type, where the PARAMETERS - item is optional. Encodings for ``MD2/4/5`` without - ``PARAMETERS`` cannot be reproduced by this function. - - :Return: An ``emLen`` byte long string that encodes the hash. - i - - - - - can be used to perform PKCS#1 v1.5 signature or verification. - - :Parameters: - key : RSA key object - The key to use to sign or verify the message. This is a `Crypto.PublicKey.RSA` object. - Signing is only possible if *key* is a private RSA key. - - ( -( -_ >
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Signature/__init__.pyc b/ta_export/scripts/Crypto/Signature/__init__.pyc deleted file mode 100755 index 6235def..0000000 --- a/ta_export/scripts/Crypto/Signature/__init__.pyc +++ b/dev/null @@ -1,8 +0,0 @@ -
-/Oc - -A collection of standardized protocols to carry out digital signatures. - -:undocumented: __revision__, __package__ -t - diff --git a/ta_export/scripts/Crypto/Util/Counter.pyc b/ta_export/scripts/Crypto/Util/Counter.pyc deleted file mode 100755 index c22b052..0000000 --- a/ta_export/scripts/Crypto/Util/Counter.pyc +++ b/dev/null @@ -1,72 +0,0 @@ -
-Bd\Rc - - - -CTR is a chaining mode for symmetric block encryption or decryption. -Messages are divideded into blocks, and the cipher operation takes -place on each block using the secret key and a unique *counter block*. - -The most straightforward way to fulfil the uniqueness property is -to start with an initial, random *counter block* value, and increment it as -the next block is processed. - -The block ciphers from `Crypto.Cipher` (when configured in *MODE_CTR* mode) -invoke a callable object (the *counter* parameter) to get the next *counter block*. -Unfortunately, the Python calling protocol leads to major performance degradations. - -The counter functions instantiated by this module will be invoked directly -by the ciphers in `Crypto.Cipher`. The fact that the Python layer is bypassed -lead to more efficient (and faster) execution of CTR cipher modes. - -An example of usage is the following: - - >>> from Crypto.Cipher import AES - >>> from Crypto.Util import Counter - >>> - >>> pt = b' - >>> ctr = Counter.new(128) - >>> cipher = AES.new(b' - >>> ct = cipher.encrypt(pt) - -:undocumented: __package__ -iNi - - - - - - Each call to the function returns the next counter block. - Each counter block is made up by three parts:: - - prefix || counter value || postfix - - The counter value is incremented by one at each call. - - :Parameters: - nbits : integer - Length of the desired counter, in bits. It must be a multiple of 8. - prefix : byte string - The constant prefix of the counter block. By default, no prefix is - used. - suffix : byte string - The constant postfix of the counter block. By default, no suffix is - used. - initial_value : integer - The initial value of the counter. Default value is 1. - little_endian : boolean - If True, the counter number will be encoded in little endian format. - If False (default), in big endian format. - allow_wraparound : boolean - If True, the function will raise an *OverflowError* exception as soon - as the counter wraps around. If False (default), the counter will - simply restart from zero. - disable_shortcut : boolean - If True, do not make ciphers from `Crypto.Cipher` bypass the Python - layer when invoking the counter block function. - If False (default), bypass the Python layer. - :Returns: - The counter block function. - i - - *5
\ No newline at end of file diff --git a/ta_export/scripts/Crypto/Util/RFC1751.pyc b/ta_export/scripts/Crypto/Util/RFC1751.pyc deleted file mode 100755 index cd90407..0000000 --- a/ta_export/scripts/Crypto/Util/RFC1751.pyc +++ b/dev/null @@ -1,44 +0,0 @@ -
-/Oc - -d d d
ddddddddddddddd d d d d d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwdxdydzd{d|d}d~dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd -d d d
ddddddddddddddd d d d d d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwdxdydzd{d|d}d~dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd -d d d
ddddddddddddddd d d d d d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwdxdydzd{d|d}d~dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd -d d d
ddddddddddddddd d d d d d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwdxdydzd{d|d}d~dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd -d d d
ddddddddddddddd d d d d d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwdxdydzd{d|d}d~dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd -d d d
ddddddddddddddd d d d d d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwdxdydzd{d|d}d~dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd -d d d
ddddddddddddddd d d d d d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwdxdydzd{d|d}d~dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd -d d d
ddddddddddddddd d d d d d!d"d#d$d%d&d'g - - - - - numeric value.c - - Transform an arbitrary key into a string containing English words. - The key length must be a multiple of 8. - R - - - - - - - - - - - - - - - - - Transform a string into a corresponding key. - The string must contain words separated by whitespace; the number - of words must be a multiple of 6. - R - -$ "% % - --* # diff --git a/ta_export/scripts/Crypto/Util/__init__.pyc b/ta_export/scripts/Crypto/Util/__init__.pyc deleted file mode 100755 index caf1f80..0000000 --- a/ta_export/scripts/Crypto/Util/__init__.pyc +++ b/dev/null @@ -1,13 +0,0 @@ -
-Bd\Rc - -Contains useful modules that don't belong into any of the -other Crypto.* subpackages. - -Crypto.Util.number Number-theoretic functions (primality testing, etc.) -Crypto.Util.randpool Random number generation -Crypto.Util.RFC1751 Converts between 128-bit keys and human-readable - strings of words. -Crypto.Util.asn1 Minimal support for ASN.1 DER encoding - -t diff --git a/ta_export/scripts/Crypto/Util/_number_new.pyc b/ta_export/scripts/Crypto/Util/_number_new.pyc deleted file mode 100755 index 35f3f28..0000000 --- a/ta_export/scripts/Crypto/Util/_number_new.pyc +++ b/dev/null @@ -1,31 +0,0 @@ -
-/Oc - - - - - - - This is done by right-shifting n by b bits and incrementing the result by 1 - if any '1' bits were shifted out. - s& - - c - - - - If no such integer exists, this function raises ValueError. - s - - - -c - - If no such integer exists, this function raises ValueError. - - Both operands must be integers. - - If the second operand is zero, this function will raise ZeroDivisionError - unless allow_divzero is true (default: False). - s& - diff --git a/ta_export/scripts/Crypto/Util/asn1.pyc b/ta_export/scripts/Crypto/Util/asn1.pyc deleted file mode 100755 index 7943705..0000000 --- a/ta_export/scripts/Crypto/Util/asn1.pyc +++ b/dev/null @@ -1,97 +0,0 @@ -
-Bd\Rc - - - - - - - Instantiate this class ONLY when you have to decode a DER element. - i0 - - - The ASN.1 type is either specified as the ASN.1 string (e.g. - 'SEQUENCE'), directly with its numerical tag or with no tag - at all (None).i - bytes) in a format suitable for a DER length tag (L). - i - - a DER length tag (L), return a tuple with the payload size, - and the index of the first byte of the such payload (V). - - Raises a ValueError exception if the DER length is invalid. - Raises an IndexError exception if the DER element is too short. - i - - - - object with it. - - @param derEle A complete DER element. It must start with a DER T - tag. - @param noLeftOvers Indicate whether it is acceptable to complete the - parsing of the DER element and find that not all - bytes in derEle have been used. - @return Index of the first unused byte in the given DER element. - - Raises a ValueError exception in case of parsing errors. - Raises an IndexError exception if the DER element is too short. - i - - - - Limitation: only non-negative values are supported. - R - - object with it. - - @param derEle A complete INTEGER DER element. It must start with a DER - INTEGER tag. - @param noLeftOvers Indicate whether it is acceptable to complete the - parsing of the DER element and find that not all - bytes in derEle have been used. - @return Index of the first unused byte in the given DER element. - - Raises a ValueError exception if the DER element is not a - valid non-negative INTEGER. - Raises an IndexError exception if the DER element is too short. - R - - - - - This object behave like a dynamic Python sequence. - Sub-elements that are INTEGERs, look like Python integers. - Any other sub-element is a binary string encoded as the complete DER - sub-element (TLV). - c - initially.R - the non-negative integers and longs added to this object. - - Limitation: Raises a ValueError exception if it some elements - in the sequence are neither Python integers nor complete DER INTEGERs. - R - - - - object with it. - - @param derEle A complete SEQUENCE DER element. It must start with a DER - SEQUENCE tag. - @param noLeftOvers Indicate whether it is acceptable to complete the - parsing of the DER element and find that not all - bytes in derEle have been used. - @return Index of the first unused byte in the given DER element. - - DER INTEGERs are decoded into Python integers. Any other DER - element is not decoded. Its validity is not checked. - - Raises a ValueError exception if the DER element is not a - valid DER SEQUENCE. - Raises an IndexError exception if the DER element is too short. - R - - - - -S'g diff --git a/ta_export/scripts/Crypto/Util/number.pyc b/ta_export/scripts/Crypto/Util/number.pyc deleted file mode 100755 index fc7bd85..0000000 --- a/ta_export/scripts/Crypto/Util/number.pyc +++ b/dev/null @@ -1,228 +0,0 @@ -
-/Oc - - - - Returns the size of the number N in bits. - i - Return a random number with at most N bits. - - If randfunc is omitted, then Random.new().read is used. - - This function is for internal use only and may be renamed or removed in - the future. - i - - c - Return a random number n so that a <= n < b. - - If randfunc is omitted, then Random.new().read is used. - - This function is for internal use only and may be renamed or removed in - the future. - i - - Return a random number with exactly N-bits, i.e. a random number - between 2**(N-1) and (2**N)-1. - - If randfunc is omitted, then Random.new().read is used. - - This function is for internal use only and may be renamed or removed in - the future. - i - -c - Return the GCD of x and y. - i - - Return the inverse of u mod v. - l - Return a random N-bit prime number. - - If randfunc is omitted, then Random.new().read is used. - i - - - - - - Tests if n is prime. - Returns 0 when n is definitly composite. - Returns 1 when n is probably prime. - Returns 2 when n is definitly prime. - - If randfunc is omitted, then Random.new().read is used. - - This function is for internal use only and may be renamed or removed in - the future. - i - - - -
i - - - - - Return a random strong N-bit prime number. - In this context p is a strong prime if p-1 and p+1 have at - least one large prime factor. - N should be a multiple of 128 and > 512. - - If e is provided the returned prime p-1 will be coprime to e - and thus suitable for RSA where e is the public exponent. - - The optional false_positive_prob is the statistical probability - that true is returned even though it is not (pseudo-prime). - It defaults to 1e-6 (less than 1:1000000). - Note that the real probability of a false-positive is far less. This is - just the mathematically provable limit. - - randfunc should take a single int parameter and return that - many random bytes as a string. - If randfunc is omitted, then Random.new().read is used. - i - - - -' - - - -
- & -c - Return true if N is prime. - - The optional false_positive_prob is the statistical probability - that true is returned even though it is not (pseudo-prime). - It defaults to 1e-6 (less than 1:1000000). - Note that the real probability of a false-positive is far less. This is - just the mathematically provable limit. - - If randfunc is omitted, then Random.new().read is used. - i - - -
,c - Convert a long integer to a byte string. - - If optional blocksize is given and greater than zero, pad the front of the - byte string with binary zeros so that the length is a multiple of - blocksize. - t - %c - Convert a byte string to a long integer. - - This is (essentially) the inverse of long_to_bytes(). - l -
*c - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - 0z
diff --git a/ta_export/scripts/Crypto/Util/py21compat.pyc b/ta_export/scripts/Crypto/Util/py21compat.pyc deleted file mode 100755 index 687f1e1..0000000 --- a/ta_export/scripts/Crypto/Util/py21compat.pyc +++ b/dev/null @@ -1,16 +0,0 @@ -
-Bd\Rc - - - - - - - -Currently, this just defines: - - True and False - - object - - isinstance -s - - diff --git a/ta_export/scripts/Crypto/Util/py3compat.pyc b/ta_export/scripts/Crypto/Util/py3compat.pyc deleted file mode 100755 index 410d667..0000000 --- a/ta_export/scripts/Crypto/Util/py3compat.pyc +++ b/dev/null @@ -1,44 +0,0 @@ -
-Bd\Rc - - - -In Python 2.x, strings (of type ''str'') contain binary data, including encoded -Unicode text (e.g. UTF-8). The separate type ''unicode'' holds Unicode text. -Unicode literals are specified via the u'...' prefix. Indexing or slicing -either type always produces a string of the same type as the original. -Data read from a file is always of '''str'' type. - -In Python 3.x, strings (type ''str'') may only contain Unicode text. The u'...' -prefix and the ''unicode'' type are now redundant. A new type (called -''bytes'') has to be used for binary data (including any particular -''encoding'' of a string). The b'...' prefix allows one to specify a binary -literal. Indexing or slicing a string produces another string. Slicing a byte -string produces another byte string, but the indexing operation produces an -integer. Data read from a file is of '''str'' type if the file was opened in -text mode, or of ''bytes'' type otherwise. - -Since PyCrypto aims at supporting both Python 2.x and 3.x, the following helper -functions are used to keep the rest of the library as independent as possible -from the actual Python version. - -In general, the code should always deal with binary strings, and use integers -instead of 1-byte character strings. - -b(s) - Take a text string literal (with no prefix or with u'...' prefix) and - make a byte string. -bchr(c) - Take an integer and make a 1-character byte string. -bord(c) - Take the result of indexing on a byte string and make an integer. -tobytes(s) - Take a text string, a byte string, or a sequence of character taken from - a byte string and make a byte string. -s - - - - - - diff --git a/ta_export/scripts/Crypto/Util/randpool.pyc b/ta_export/scripts/Crypto/Util/randpool.pyc deleted file mode 100755 index 06b71f2..0000000 --- a/ta_export/scripts/Crypto/Util/randpool.pyc +++ b/dev/null @@ -1,14 +0,0 @@ -
-/Oc - - - - - See http://www.pycrypto.org/randpool-broken - i - - - - - - diff --git a/ta_export/scripts/Crypto/Util/winrandom.pyc b/ta_export/scripts/Crypto/Util/winrandom.pyc deleted file mode 100755 index 73a9260..0000000 --- a/ta_export/scripts/Crypto/Util/winrandom.pyc +++ b/dev/null @@ -1,2 +0,0 @@ -
-/Oc diff --git a/ta_export/scripts/Crypto/__init__.pyc b/ta_export/scripts/Crypto/__init__.pyc deleted file mode 100755 index 3f777d7..0000000 --- a/ta_export/scripts/Crypto/__init__.pyc +++ b/dev/null @@ -1,23 +0,0 @@ -
-Bd\Rc - -A collection of cryptographic modules implementing various algorithms -and protocols. - -Subpackages: - -Crypto.Cipher - Secret-key (AES, DES, ARC4) and public-key encryption (RSA PKCS#1) algorithms -Crypto.Hash - Hashing algorithms (MD5, SHA, HMAC) -Crypto.Protocol - Cryptographic protocols (Chaffing, all-or-nothing transform, key derivation - functions). This package does not contain any network protocols. -Crypto.PublicKey - Public-key encryption and signature algorithms (RSA, DSA) -Crypto.Signature - Public-key signature algorithms (RSA PKCS#1) -Crypto.Util - Various useful modules and functions (long-to-string conversion, random number - generation, number theoretic functions) -t diff --git a/ta_export/scripts/Crypto/pct_warnings.pyc b/ta_export/scripts/Crypto/pct_warnings.pyc deleted file mode 100755 index 28e011e..0000000 --- a/ta_export/scripts/Crypto/pct_warnings.pyc +++ b/dev/null @@ -1,5 +0,0 @@ -
-Bd\Rc - - - |