File: PKG-INFO

package info (click to toggle)
python-securesystemslib 0.20.0-1
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, sid
  • size: 1,008 kB
  • sloc: python: 6,362; makefile: 4
file content (427 lines) | stat: -rw-r--r-- 17,093 bytes parent folder | download | duplicates (2)
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
Metadata-Version: 2.1
Name: securesystemslib
Version: 0.20.0
Summary: A library that provides cryptographic and general-purpose routines for Secure Systems Lab projects at NYU
Home-page: https://github.com/secure-systems-lab/securesystemslib
Author: https://www.updateframework.com
Author-email: theupdateframework@googlegroups.com
License: MIT
Project-URL: Source, https://github.com/secure-systems-lab/securesystemslib
Project-URL: Issues, https://github.com/secure-systems-lab/securesystemslib/issues
Description: Secure Systems Library
        ----------------------
        
        .. image:: https://github.com/secure-systems-lab/securesystemslib/workflows/Run%20Securesystemslib%20tests/badge.svg
           :target: https://github.com/secure-systems-lab/securesystemslib/actions?query=workflow%3A%22Run+Securesystemslib+tests%22+branch%3Amaster
        
        .. image:: https://api.dependabot.com/badges/status?host=github&repo=secure-systems-lab/securesystemslib
           :target: https://api.dependabot.com/badges/status?host=github&repo=secure-systems-lab/securesystemslib
        
        
        A library that provides cryptographic and general-purpose functions for Secure
        Systems Lab projects at NYU.  The routines are general enough to be usable by
        other projects.
        
        Overview
        ++++++++
        
        securesystemslib supports public-key and general-purpose cryptography, such as
        `ECDSA
        <https://en.wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm>`_,
        `Ed25519 <http://ed25519.cr.yp.to/>`_, `RSA
        <https://en.wikipedia.org/wiki/RSA_%28cryptosystem%29>`_, SHA256, SHA512, etc.
        Most of the cryptographic operations are performed by the `cryptography
        <https://cryptography.io/en/latest/>`_ and `PyNaCl
        <https://github.com/pyca/pynacl>`_ libraries, but verification of Ed25519
        signatures can be done in pure Python.
        
        The `cryptography` library is used to generate keys and signatures with the
        ECDSA and RSA algorithms, and perform general-purpose cryptography such as
        encrypting keys.  The PyNaCl library is used to generate Ed25519 keys and
        signatures.  PyNaCl is a Python binding to the Networking and Cryptography
        Library.  For key storage, RSA keys may be stored in PEM or JSON format, and
        Ed25519 keys in JSON format.  Generating, importing, and loading cryptographic
        key files can be done with functions available in securesystemslib.
        
        securesystemslib also provides an interface to the `GNU Privacy Guard (GPG)
        <https://gnupg.org/>`_ command line tool, with functions to create RSA and DSA
        signatures using private keys in a local gpg keychain; to export the
        corresponding public keys in a *pythonic* format; and to verify the created
        signatures using the exported keys. The latter does not require the gpg command
        line tool to be installed, instead the `cryptography` library is used.
        
        Installation
        ++++++++++++
        
        ::
        
            $ pip install securesystemslib
        
        
        The default installation only supports Ed25519 keys and signatures (in pure
        Python).  Support for RSA, ECDSA, and E25519 via the `cryptography` and
        `PyNaCl` libraries is available by installing the `crypto` and `pynacl` extras:
        
        ::
        
            $ pip install securesystemslib[crypto]
            $ pip install securesystemslib[pynacl]
        
        Usage
        ++++++++++++
        
        Create RSA Keys
        ~~~~~~~~~~~~~~~
        
        Note:  In the instructions below, lines that start with *>>>* denote commands
        that should be entered by the reader, *#* begins the start of a comment, and
        text without prepended symbols is the output of a command.
        
        ::
        
            >>> from securesystemslib.interface import *
        
            # The following function creates an RSA key pair, where the private key is
            # saved to "rsa_key1" and the public key to "rsa_key1.pub" (both saved to
            # the current working directory).  A full directory path may be specified
            # instead of saving keys to the current working directory.  If specified
            # directories do not exist, they will be created.
            >>> generate_and_write_rsa_keypair(
                    password="password", filepath="rsa_key1", bits=2048)
        
            # If the key length is unspecified, it defaults to 3072 bits. A length of
            # less than 2048 bits raises an exception. A similar function is available
            # to supply a password on the prompt. If an empty password is entered, the
            # private key is saved unencrypted.
            >>> generate_and_write_rsa_keypair_with_prompt("rsa_key2")
            enter password to encrypt private key file '/path/to/rsa_key2'
            (leave empty if key should not be encrypted):
            Confirm:
        
        
        The following four key files should now exist:
        
        1.  rsa_key1
        2.  rsa_key1.pub
        3.  rsa_key2
        4.  rsa_key2.pub
        
        Import RSA Keys
        ~~~~~~~~~~~~~~~
        
        ::
        
            # Continuing from the previous section . . .
        
            # Import an existing public key.
            >>> public_rsa_key1 = import_rsa_publickey_from_file("rsa_key1.pub")
        
            # Import an existing private key.  If your private key is encrypted,
            # which it should be, you either have to pass a 'password' or enter one
            # on the prompt.
            >>> private_rsa_key1 = import_rsa_privatekey_from_file("rsa_key1", password="some passphrase")
            # OR:
            >>> private_rsa_key1 = import_rsa_privatekey_from_file("rsa_key1", prompt=True)
            enter password to decrypt private key file '/path/to/rsa_key1'
            (leave empty if key not encrypted):
        
        **import_rsa_privatekey_from_file()** raises a
        *securesystemslib.exceptions.CryptoError* exception if the key / password is
        invalid:
        
        ::
        
            securesystemslib.exceptions.CryptoError: RSA (public, private) tuple cannot
            be generated from the encrypted PEM string: Bad decrypt. Incorrect password?
        
        Note: The specific message provided by the exception might differ depending on
        which cryptography library is used.
        
        Create and Import Ed25519 Keys
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        
        ::
        
            # Continuing from the previous section . . .
        
            # The same generation and import functions as for rsa keys exist for ed25519
            >>> generate_and_write_ed25519_keypair_with_prompt('ed25519_key')
            enter password to encrypt private key file '/path/to/ed25519_key'
            (leave empty if key should not be encrypted):
            Confirm:
        
            # Import the Ed25519 public key just created . . .
            >>> public_ed25519_key = import_ed25519_publickey_from_file('ed25519_key.pub')
        
            # and its corresponding private key.
            >>> private_ed25519_key = import_ed25519_privatekey_from_file('ed25519_key', prompt=True)
            enter password to decrypt private key file '/path/to/ed25519_key'
            (leave empty if key should not be encrypted):
        
        Create and Import ECDSA Keys
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        
        ::
        
            # The same generation and import functions as for rsa and ed25519 keys
            # exist for ecdsa
            >>> generate_and_write_ecdsa_keypair_with_prompt('ecdsa_key')
            enter password to decrypt private key file '/path/to/ecdsa_key'
            (leave empty if key should not be encrypted):
        
            >>> public_ecdsa_key = import_ecdsa_publickey_from_file('ecdsa_key.pub')
            >>> private_ecdsa_key = import_ecdsa_privatekey_from_file('ecdsa_key', prompt=True)
            enter password to decrypt private key file '/path/to/ecdsa_key'
            (leave empty if key should not be encrypted):
        
        Generate ECDSA, Ed25519, and RSA Signatures
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        
        Note: Users may also access the crypto functions directly to perform
        cryptographic operations.
        
        ::
        
            >>> from securesystemslib.keys import *
        
            >>> data = b'The quick brown fox jumps over the lazy dog'
            >>> ed25519_key = generate_ed25519_key()
            >>> signature = create_signature(ed25519_key, data)
            >>> rsa_key = generate_rsa_key(2048)
            >>> signature = create_signature(rsa_key, data)
            >>> ecdsa_key = generate_ecdsa_key()
            >>> signature = create_signature(ecdsa_key, data)
        
        
        Verify ECDSA, Ed25519, and RSA Signatures
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        
        ::
        
            # Continuing from the previous sections . . .
        
            >>> data = b'The quick brown fox jumps over the lazy dog'
            >>> ed25519_key = generate_ed25519_key()
            >>> signature = create_signature(ed25519_key, data)
            >>> verify_signature(ed25519_key, signature, data)
            True
            >>> verify_signature(ed25519_key, signature, 'bad_data')
            False
            >>> rsa_key = generate_rsa_key()
            >>> signature = create_signature(rsa_key, data)
            >>> verify_signature(rsa_key, signature, data)
            True
            >>> ecdsa_key = generate_ecdsa_key()
            >>> signature = create_signature(ecdsa_key, data)
            >>> verify_signature(ecdsa_key, signature, data)
            True
        
        
        Miscellaneous functions
        ~~~~~~~~~~~~~~~~~~~~~~~
        
        **create_rsa_encrypted_pem()**
        
        ::
        
            # Continuing from the previous sections . . .
        
            >>> rsa_key = generate_rsa_key()
            >>> private = rsa_key['keyval']['private']
            >>> passphrase = 'secret'
            >>> encrypted_pem = create_rsa_encrypted_pem(private, passphrase)
        
        **import_rsakey_from_public_pem()**
        
        ::
        
            >>> rsa_key = generate_rsa_key()
            >>> public = rsa_key['keyval']['public']
            >>> rsa_key2 = import_rsakey_from_public_pem(public)
        
        
        **import_rsakey_from_pem()**
        
        ::
        
            >>> rsa_key = generate_rsa_key()
            >>> public = rsa_key['keyval']['public']
            >>> private = rsa_key['keyval']['private']
            >>> rsa_key2 = import_rsakey_from_pem(public)
            >>> rsa_key3 = import_rsakey_from_pem(private)
        
        
        **extract_pem()**
        
        ::
        
            >>> rsa_key = generate_rsa_key()
            >>> private_pem = extract_pem(rsakey['keyval']['private'], private_pem=True)
            >>> public_pem = extract_pem(rsakey['keyval']['public'], private_pem=False)
        
        
        **encrypt_key()**
        
        ::
        
            >>> ed25519_key = generate_ed25519_key()
            >>> password = 'secret'
            >>> encrypted_key = encrypt_key(ed25519_key, password)
        
        
        **decrypt_key()**
        
        ::
        
            >>> ed25519_key = generate_ed25519_key()
            >>> password = 'secret'
            >>> encrypted_key = encrypt_key(ed25519_key, password)
            >>> decrypted_key = decrypt_key(encrypted_key.encode('utf-8'), password)
            >>> decrypted_key == ed25519_key
            True
        
        
        **create_rsa_encrypted_pem()**
        
        ::
        
          >>> rsa_key = generate_rsa_key()
          >>> private = rsa_key['keyval']['private']
          >>> passphrase = 'secret'
          >>> encrypted_pem = create_rsa_encrypted_pem(private, passphrase)
        
        
        **is_pem_public()**
        
        ::
        
            >>> rsa_key = generate_rsa_key()
            >>> public = rsa_key['keyval']['public']
            >>> private = rsa_key['keyval']['private']
            >>> is_pem_public(public)
            True
            >>> is_pem_public(private)
            False
        
        
        **is_pem_private()**
        
        ::
        
            >>> rsa_key = generate_rsa_key()
            >>> private = rsa_key['keyval']['private']
            >>> public = rsa_key['keyval']['public']
            >>> is_pem_private(private)
            True
            >>> is_pem_private(public)
            False
        
        
        **import_ecdsakey_from_private_pem()**
        
        ::
        
            >>> ecdsa_key = generate_ecdsa_key()
            >>> private_pem = ecdsa_key['keyval']['private']
            >>> ecdsa_key2 = import_ecdsakey_from_private_pem(private_pem)
        
        
        **import_ecdsakey_from_public_pem()**
        
        ::
        
            >>> ecdsa_key = generate_ecdsa_key()
            >>> public = ecdsa_key['keyval']['public']
            >>> ecdsa_key2 = import_ecdsakey_from_public_pem(public)
        
        
        **import_ecdsakey_from_pem()**
        
        ::
        
            >>> ecdsa_key = generate_ecdsa_key()
            >>> private_pem = ecdsa_key['keyval']['private']
            >>> ecdsa_key2 = import_ecdsakey_from_pem(private_pem)
            >>> public_pem = ecdsa_key['keyval']['public']
            >>> ecdsa_key2 = import_ecdsakey_from_pem(public_pem)
        
        
        
        
        GnuPG interface
        ~~~~~~~~~~~~~~~
        
        Signature creation and public key export requires installation of the `gpg` or
        `gpg2` command line tool, which may be downloaded from
        `https://gnupg.org/download <https://gnupg.org/>`_.
        It is also needed to generate the supported RSA or DSA signing keys (see `gpg` man
        pages for detailed instructions). Sample keys are available in a test keyring
        at `tests/gpg_keyrings/rsa`, which may be passed to the signing and export
        functions using the `homedir` argument (if not passed the default keyring is
        used). The GPG client to use can be also specified with the help of environment
        variable `GNUPG`.
        
        ::
        
            >>> import securesystemslib.gpg.functions as gpg
        
            >>> data = b"The quick brown fox jumps over the lazy dog"
        
            >>> signing_key_id = "8465A1E2E0FB2B40ADB2478E18FB3F537E0C8A17"
            >>> keyring = "tests/gpg_keyrings/rsa"
        
            >>> signature = gpg.create_signature(data, signing_key_id, homedir=keyring)
            >>> public_key = gpg.export_pubkey(non_default_signing_key, homedir=keyring)
        
            >>> gpg.verify_signature(signature, public_key, data)
            True
        
        Testing
        ++++++++++++
        
        Testing is done with `tox <https://testrun.org/tox/>`_, which can be installed with pip:
        ::
        
            $ pip install tox
        
        
        Secure Systems Library supports multiple versions of Python.
        For that reason, the project is tested against multiple virtual environments with different Python versions.
        If you run
        ::
        
        $ tox
        
        this will run all tests creating virtual environments for all python versions described in the *tox.ini* file.
        
        If you want to run the tests against specific python version, for example Python 3.7, you will use:
        ::
        
        $ tox -e py37
        
Keywords: cryptography,keys,signatures,rsa,ed25519,ecdsa
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Natural Language :: English
Classifier: Operating System :: POSIX
Classifier: Operating System :: POSIX :: Linux
Classifier: Operating System :: MacOS :: MacOS X
Classifier: Operating System :: Microsoft :: Windows
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Topic :: Security
Classifier: Topic :: Software Development
Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, <4
Description-Content-Type: text/x-rst
Provides-Extra: colors
Provides-Extra: crypto
Provides-Extra: pynacl