lin
2025-08-14 dae8bad597b6607a449b32bf76c523423f7720ed
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