blob: 9da7c6bbee60980b38613cf13fa93e90d847599c (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
Reference
=========
This is the class and function reference. For more usage information
see the :ref:`usage` page.
Functions
---------
.. autofunction:: rsa.encrypt
.. autofunction:: rsa.decrypt
.. autofunction:: rsa.sign
.. autofunction:: rsa.verify
.. autofunction:: rsa.find_signature_hash
.. autofunction:: rsa.newkeys(keysize)
Classes
-------
.. note::
Storing public and private keys via the `pickle` module is possible.
However, it is insecure to load a key from an untrusted source.
The pickle module is not secure against erroneous or maliciously
constructed data. Never unpickle data received from an untrusted
or unauthenticated source.
.. autoclass:: rsa.PublicKey
:members:
:inherited-members:
.. autoclass:: rsa.PrivateKey
:members:
:inherited-members:
Exceptions
----------
.. autoclass:: rsa.pkcs1.CryptoError(Exception)
.. autoclass:: rsa.pkcs1.DecryptionError(CryptoError)
.. autoclass:: rsa.pkcs1.VerificationError(CryptoError)
.. index:: VARBLOCK (file format)
The VARBLOCK file format
++++++++++++++++++++++++
.. warning::
The VARBLOCK format is NOT recommended for general use, has been deprecated since
Python-RSA 3.4, and was removed in version 4.0. It's vulnerable to a
number of attacks. See :ref:`bigfiles` for more information.
The VARBLOCK file format allows us to encrypt files that are larger
than the RSA key. The format is as follows; || denotes byte string
concatenation::
VARBLOCK := VERSION || BLOCK || BLOCK || ...
VERSION := 1
BLOCK := LENGTH || DATA
LENGTH := varint-encoded length of the following data, in bytes
DATA := the data to store in the block
The varint-format was taken from Google's Protobuf_, and allows us to
efficiently encode an arbitrarily long integer.
.. _Protobuf:
https://code.google.com/apis/protocolbuffers/docs/encoding.html#varints
Module: rsa.core
----------------
At the core of the RSA encryption method lie these functions. They
both operate on (arbitrarily long) integers only. They probably aren't
of much use to you, but I wanted to document them anyway as they are
the core of the entire library.
.. autofunction:: rsa.core.encrypt_int
.. autofunction:: rsa.core.decrypt_int
|
