projects/guix·blob wip-digests · refs

1732 lines · 63.0 KiB

1;;; GNU Guix --- Functional package management for GNU
2;;; Copyright © 2015 Eric Dvorsak <[email protected]>
3;;; Copyright © 2015, 2016, 2017, 2018, 2019, 2020 Efraim Flashner <[email protected]>
4;;; Copyright © 2015, 2016, 2017, 2019 Leo Famulari <[email protected]>
5;;; Copyright © 2016, 2017, 2020 Marius Bakke <[email protected]>
6;;; Copyright © 2017 Ben Sturmfels <[email protected]>
7;;; Copyright © 2016 Sou Bunnbu <[email protected]>
8;;; Copyright © 2015 Cyril Roelandt <[email protected]>
9;;; Copyright © 2014, 2017 Eric Bavier <[email protected]>
10;;; Copyright © 2015, 2016 David Thompson <[email protected]>
11;;; Copyright © 2016, 2017, 2018, 2019, 2020 Tobias Geerinckx-Rice <[email protected]>
12;;; Copyright © 2016, 2017 Nikita <[email protected]>
13;;; Copyright © 2014, 2015 Mark H Weaver <[email protected]>
14;;; Copyright © 2015, 2016, 2017, 2019 Ricardo Wurmus <[email protected]>
15;;; Copyright © 2016 Danny Milosavljevic <[email protected]>
16;;; Copyright © 2016, 2017, 2020 Arun Isaac <[email protected]>
17;;; Copyright © 2017 Carlo Zancanaro <[email protected]>
18;;; Copyright © 2018 Tomáš Čech <[email protected]>
19;;; Copyright © 2018 Nicolas Goaziou <[email protected]>
20;;; Copyright © 2018 Vagrant Cascadian <[email protected]>
21;;; Copyright © 2018 Nam Nguyen <[email protected]>
22;;; Copyright © 2019 Guillaume Le Vaillant <[email protected]>
23;;; Copyright © 2019 Clément Lassieur <[email protected]>
24;;; Copyright © 2020 Alexandros Theodotou <[email protected]>
25;;; Copyright © 2020 Justus Winter <[email protected]>
26;;; Copyright © 2020 Vinicius Monego <[email protected]>
27;;;
28;;; This file is part of GNU Guix.
29;;;
30;;; GNU Guix is free software; you can redistribute it and/or modify it
31;;; under the terms of the GNU General Public License as published by
32;;; the Free Software Foundation; either version 3 of the License, or (at
33;;; your option) any later version.
34;;;
35;;; GNU Guix is distributed in the hope that it will be useful, but
36;;; WITHOUT ANY WARRANTY; without even the implied warranty of
37;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
38;;; GNU General Public License for more details.
39;;;
40;;; You should have received a copy of the GNU General Public License
41;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
42
43(define-module (gnu packages python-crypto)
44 #:use-module (guix packages)
45 #:use-module (guix download)
46 #:use-module (guix git-download)
47 #:use-module (guix build-system python)
48 #:use-module (gnu packages)
49 #:use-module (gnu packages check)
50 #:use-module (gnu packages crypto)
51 #:use-module (gnu packages kerberos)
52 #:use-module (gnu packages libffi)
53 #:use-module (gnu packages multiprecision)
54 #:use-module (gnu packages password-utils)
55 #:use-module (gnu packages protobuf)
56 #:use-module (gnu packages python)
57 #:use-module (gnu packages python-check)
58 #:use-module (gnu packages python-compression)
59 #:use-module (gnu packages python-web)
60 #:use-module (gnu packages python-xyz)
61 #:use-module (gnu packages swig)
62 #:use-module (gnu packages time)
63 #:use-module (gnu packages tls)
64 #:use-module (gnu packages xml)
65 #:use-module ((guix licenses) #:prefix license:)
66 #:use-module (srfi srfi-1))
67
68(define-public python-potr
69 (package
70 (name "python-potr")
71 (version "1.0.2")
72 (source
73 (origin
74 (method git-fetch)
75 (uri
76 (git-reference
77 (url "https://github.com/python-otr/pure-python-otr")
78 (commit version)))
79 (file-name
80 (git-file-name name version))
81 (sha256
82 (base32 "1hzw6h01fm216nmipyylgz0zybd80w1xsk12m7djycnhqrnrvvv1"))))
83 (build-system python-build-system)
84 (propagated-inputs
85 `(("python-pycrypto" ,python-pycrypto)))
86 (synopsis "Python OTR Implementation")
87 (description "Python OTR is an Off-The-Record Protocol Implementation in
88Python. It does not bind to libotr.")
89 (home-page "https://github.com/python-otr/pure-python-otr")
90 (license license:lgpl3+)))
91
92(define-public python-base58
93 (package
94 (name "python-base58")
95 (version "2.0.1")
96 (source
97 (origin
98 (method url-fetch)
99 (uri (pypi-uri "base58" version))
100 (sha256
101 (base32
102 "0yfaqp76kbdb62hikr5n4jkkfjfmii89grwfy6sw3fmsv5hrap1n"))))
103 (build-system python-build-system)
104 (native-inputs
105 `(("python-pyhamcrest" ,python-pyhamcrest)))
106 (home-page "https://github.com/keis/base58")
107 (synopsis "Base58 and Base58Check implementation")
108 (description "Base58 and Base58Check implementation compatible
109with what is used by the Bitcoin network.")
110 (license license:expat)))
111
112(define-public python-bcrypt
113 (package
114 (name "python-bcrypt")
115 (version "3.1.7")
116 (source
117 (origin
118 (method url-fetch)
119 (uri (pypi-uri "bcrypt" version))
120 (sha256
121 (base32 "0hhywhxx301cxivgxrpslrangbfpccc8y83qbwn1f57cab3nj00b"))))
122 (build-system python-build-system)
123 (native-inputs
124 `(("python-pycparser" ,python-pycparser)
125 ("python-pytest" ,python-pytest)))
126 (propagated-inputs
127 `(("python-cffi" ,python-cffi)
128 ("python-six" ,python-six)))
129 (home-page "https://github.com/pyca/bcrypt/")
130 (synopsis
131 "Modern password hashing library")
132 (description
133 "Bcrypt is a Python module which provides a password hashing method based
134on the Blowfish password hashing algorithm, as described in
135@url{http://static.usenix.org/events/usenix99/provos.html,\"A Future-Adaptable
136Password Scheme\"} by Niels Provos and David Mazieres.")
137 (license license:asl2.0)))
138
139(define-public python2-bcrypt
140 (package-with-python2 python-bcrypt))
141
142(define-public python-passlib
143 (package
144 (name "python-passlib")
145 (version "1.7.4")
146 (source
147 (origin
148 (method url-fetch)
149 (uri (pypi-uri "passlib" version))
150 (sha256
151 (base32 "015y5qaw9qnxr29lg60dml1g5rbqd4586wy5n8m41ib55gvm1zfy"))))
152 (build-system python-build-system)
153 (native-inputs
154 `(("python-nose" ,python-nose)))
155 (propagated-inputs
156 `(("python-py-bcrypt" ,python-py-bcrypt)))
157 (arguments
158 `(#:phases
159 (modify-phases %standard-phases
160 (add-before 'check 'set-PYTHON_EGG_CACHE
161 ;; Some tests require access to "$HOME/.cython".
162 (lambda _ (setenv "PYTHON_EGG_CACHE" "/tmp") #t)))))
163 (home-page "https://bitbucket.org/ecollins/passlib")
164 (synopsis "Comprehensive password hashing framework")
165 (description
166 "Passlib is a password hashing library for Python 2 & 3, which provides
167cross-platform implementations of over 30 password hashing algorithms, as well
168as a framework for managing existing password hashes. It's designed to be
169useful for a wide range of tasks, from verifying a hash found in /etc/shadow,
170to providing full-strength password hashing for multi-user application.")
171 (license license:bsd-3)))
172
173(define-public python2-passlib
174 (package-with-python2 python-passlib))
175
176(define-public python-py-bcrypt
177 (package
178 (name "python-py-bcrypt")
179 (version "0.4")
180 (source
181 (origin
182 (method url-fetch)
183 (uri (pypi-uri "py-bcrypt" version))
184 (sha256
185 (base32
186 "0y6smdggwi5s72v6p1nn53dg6w05hna3d264cq6kas0lap73p8az"))))
187 (build-system python-build-system)
188 (home-page "https://code.google.com/p/py-bcrypt")
189 (synopsis
190 "Bcrypt password hashing and key derivation")
191 (description
192 "A python wrapper of OpenBSD's Blowfish password hashing code. This
193system hashes passwords using a version of Bruce Schneier's Blowfish block
194cipher with modifications designed to raise the cost of off-line password
195cracking and frustrate fast hardware implementation. The computation cost of
196the algorithm is parametrised, so it can be increased as computers get faster.
197The intent is to make a compromise of a password database less likely to
198result in an attacker gaining knowledge of the plaintext passwords (e.g. using
199John the Ripper).")
200 ;; "sha2.c" is under BSD-3;
201 ;; "blowfish.c" and "bcrypt.c" are under BSD-4;
202 ;; the rest is under ISC.
203 (license (list license:isc license:bsd-3 license:bsd-4))))
204
205(define-public python2-py-bcrypt
206 (package-with-python2 python-py-bcrypt))
207
208(define-public python-pyblake2
209 (package
210 (name "python-pyblake2")
211 (version "1.1.2")
212 (source
213 (origin
214 (method url-fetch)
215 (uri (pypi-uri "pyblake2" version))
216 (sha256
217 (base32
218 "0gz9hgznv5zw4qjq43xa56y0yikimx30gffvibxzm0nv5sq7xk2w"))))
219 (build-system python-build-system)
220 (home-page "https://github.com/dchest/pyblake2")
221 (synopsis "BLAKE2 hash function for Python")
222 (description "BLAKE2 is a cryptographic hash function, which offers
223stronger security while being as fast as MD5 or SHA-1, and comes in two
224flavors: @code{BLAKE2b}, optimized for 64-bit platforms and produces digests
225of any size between 1 and 64 bytes, and @code{BLAKE2s}, optimized for 8- to
22632-bit platforms and produces digests of any size between 1 and 32 bytes.
227
228This package provides a Python interface for BLAKE2.")
229 ;; The COPYING file declares it as public domain, with the option to
230 ;; alternatively use and redistribute it under a variety of permissive
231 ;; licenses. cc0 is explicitly mentioned in setup.py and pyblake2module.c.
232 (license (list license:public-domain license:cc0))))
233
234(define-public python-paramiko
235 (package
236 (name "python-paramiko")
237 (version "2.7.2")
238 (source
239 (origin
240 (method url-fetch)
241 (uri (pypi-uri "paramiko" version))
242 (sha256
243 (base32 "0dahwq623jnna7gsr9j0mkwr9k2n1pvkapjryhcx508d5jxg8dkz"))))
244 (build-system python-build-system)
245 (arguments
246 `(;; FIXME: Tests require many unpackaged libraries, see dev-requirements.txt.
247 #:tests? #f))
248 (propagated-inputs
249 `(("python-bcrypt" ,python-bcrypt)
250 ("python-pyasn1" ,python-pyasn1)
251 ("python-pynacl" ,python-pynacl)
252 ("python-cryptography" ,python-cryptography)))
253 (home-page "https://www.paramiko.org/")
254 (synopsis "SSHv2 protocol library")
255 (description "Paramiko is a python implementation of the SSHv2 protocol,
256providing both client and server functionality. While it leverages a Python C
257extension for low level cryptography (PyCrypto), Paramiko itself is a pure
258Python interface around SSH networking concepts.")
259 (license license:lgpl2.1+)))
260
261(define-public python2-paramiko
262 (package-with-python2 python-paramiko))
263
264(define-public python-ecdsa
265 (package
266 (name "python-ecdsa")
267 (version "0.14.1")
268 (source
269 (origin
270 (method url-fetch)
271 (uri (pypi-uri "ecdsa" version))
272 (sha256
273 (base32 "13nx5cbfxc0gnax5zwdmp9xc40qd1llk62mv85jyrvqkbw017ik4"))))
274 (build-system python-build-system)
275 (arguments
276 '(#:phases
277 (modify-phases %standard-phases
278 (replace 'check
279 (lambda _ (invoke "pytest"))))))
280 (propagated-inputs
281 `(("python-six" ,python-six)))
282 (native-inputs
283 `(("openssl" ,openssl)
284 ("python-pytest" ,python-pytest)))
285 (home-page "https://github.com/warner/python-ecdsa")
286 (synopsis "ECDSA cryptographic signature library (pure python)")
287 (description
288 "This is an easy-to-use implementation of ECDSA cryptography (Elliptic
289Curve Digital Signature Algorithm), implemented purely in Python. With this
290library, you can quickly create key pairs (signing key and verifying key), sign
291messages, and verify the signatures. The keys and signatures are very short,
292making them easy to handle and incorporate into other protocols.")
293 (license license:expat)))
294
295(define-public python2-ecdsa
296 (package-with-python2 python-ecdsa))
297
298;;; Pycrypto is abandoned upstream:
299;;;
300;;; https://github.com/dlitz/pycrypto/issues/173
301;;;
302;;; TODO Remove this package from GNU Guix.
303(define-public python-pycrypto
304 (package
305 (name "python-pycrypto")
306 (version "2.6.1")
307 (source
308 (origin
309 (method url-fetch)
310 (uri (pypi-uri "pycrypto" version))
311 (patches (search-patches "python-pycrypto-CVE-2013-7459.patch"
312 "python-pycrypto-time-clock.patch"))
313 (sha256
314 (base32
315 "0g0ayql5b9mkjam8hym6zyg6bv77lbh66rv1fyvgqb17kfc1xkpj"))))
316 (build-system python-build-system)
317 (inputs
318 `(("python" ,python)
319 ("gmp" ,gmp)))
320 (arguments
321 `(#:phases
322 (modify-phases %standard-phases
323 (add-before 'build 'set-build-env
324 ;; pycrypto runs an autoconf configure script behind the scenes
325 (lambda _ (setenv "CONFIG_SHELL" (which "bash")) #t)))))
326 (home-page "https://www.dlitz.net/software/pycrypto/")
327 (synopsis "Cryptographic modules for Python")
328 (description
329 "Pycrypto is a collection of both secure hash functions (such as SHA256
330and RIPEMD160), and various encryption algorithms (AES, DES, RSA, ElGamal,
331etc.). The package is structured to make adding new modules easy.")
332 (license license:public-domain)))
333
334(define-public python2-pycrypto
335 (let ((pycrypto (package-with-python2 python-pycrypto)))
336 (package (inherit pycrypto)
337 (inputs
338 `(("python" ,python-2)
339 ,@(alist-delete
340 "python"
341 (package-inputs pycrypto)))))))
342
343(define-public python-kerberos
344 (package
345 (name "python-kerberos")
346 (version "1.3.0")
347 (source
348 (origin
349 (method url-fetch)
350 (uri (pypi-uri "kerberos" version))
351 (sha256
352 (base32
353 "19663qxmma0i8bfbjc2iwy5hgq0g4pfb75r023v5dps68zfvffgh"))))
354 (build-system python-build-system)
355 (inputs
356 `(("mit-krb5" ,mit-krb5)))
357 (home-page "https://github.com/apple/ccs-pykerberos")
358 (synopsis
359 "Python Kerberos library used by CalendarServer")
360 (description
361 "This Python package is a high-level wrapper for Kerberos (GSSAPI)
362operations. The goal is to avoid having to build a module that wraps the
363entire Kerberos.framework, and instead offer a limited set of functions that
364do what is needed for client/server Kerberos authentication based on
365<http://www.ietf.org/rfc/rfc4559.txt>.")
366 (license license:asl2.0)))
367
368(define-public python-keyring
369 (package
370 (name "python-keyring")
371 (version "21.0.0")
372 (source
373 (origin
374 (method url-fetch)
375 (uri (pypi-uri "keyring" version))
376 (sha256
377 (base32
378 "1k0w3yh3fz0qp0cvkxdiinq9jzbrnc6bd88qpjz34x3cgcr94psz"))
379 (modules '((guix build utils)))
380 (snippet
381 ;; https://github.com/jaraco/keyring/issues/414
382 '(begin (substitute* "tests/test_packaging.py"
383 (("ep, =") "(ep,) =")) #t))))
384 (build-system python-build-system)
385 (arguments
386 `(#:phases
387 (modify-phases %standard-phases
388 (replace 'check
389 (lambda _
390 ;; Not clear why this test fails.
391 (delete-file "tests/test_packaging.py")
392 (substitute* "pytest.ini"
393 (("--black ") ""))
394 (invoke "pytest"))))))
395 (native-inputs
396 `(("python-pytest" ,python-pytest)
397 ("python-pytest-checkdocs" ,python-pytest-checkdocs)
398 ("python-pytest-cov" ,python-pytest-cov)
399 ("python-pytest-flake8" ,python-pytest-flake8)
400 ("python-setuptools-scm" ,python-setuptools-scm)))
401 (propagated-inputs
402 `(("python-importlib-metadata" ,python-importlib-metadata)
403 ("python-secretstorage" ,python-secretstorage)))
404 (home-page "https://github.com/jaraco/keyring")
405 (synopsis "Store and access your passwords safely")
406 (description
407 "The Python keyring lib provides a easy way to access the system keyring
408service from python. It can be used in any application that needs safe
409password storage.")
410 ;; "MIT" and PSF dual license
411 (properties `((python2-variant . ,(delay python2-keyring))))
412 (license license:x11)))
413
414(define-public python2-keyring
415 (let ((keyring (package-with-python2
416 (strip-python2-variant python-keyring))))
417 (package
418 (inherit keyring)
419 (name "python2-keyring")
420 (version "8.7")
421 (source
422 (origin
423 (method url-fetch)
424 (uri (pypi-uri "keyring" version))
425 (sha256
426 (base32
427 "0482rmi2x6p78wl2kz8qzyq21xz1sbbfwnv5x7dggar4vkwxhzfx"))))
428 (arguments
429 `(#:python ,python-2))
430 (native-inputs
431 `(("python2-pytest" ,python2-pytest)
432 ("python2-pytest-runner" ,python2-pytest-runner)
433 ("python2-setuptools-scm" ,python2-setuptools-scm)))
434 (propagated-inputs
435 `(("python2-pycrypto" ,python2-pycrypto))))))
436
437(define-public python-keyrings.alt
438 (package
439 (name "python-keyrings.alt")
440 (version "3.4.0")
441 (source
442 (origin
443 (method url-fetch)
444 (uri (pypi-uri "keyrings.alt" version))
445 (sha256
446 (base32
447 "0gdjdqpq2hf770p6iwi891mil0vbsdhvy88x0v8b2w4y4b28lcli"))
448 (modules '((guix build utils)))
449 (snippet
450 '(begin
451 (delete-file "keyrings/alt/_win_crypto.py")
452 ;; Rely on python-keyring>20:
453 ;; https://github.com/jaraco/keyrings.alt/issues/33
454 (substitute* '("keyrings/alt/tests/test_Gnome.py"
455 "keyrings/alt/tests/test_Google.py"
456 "keyrings/alt/tests/test_Windows.py"
457 "keyrings/alt/tests/test_file.py"
458 "keyrings/alt/tests/test_pyfs.py")
459 (("keyring.tests.test_backend") "keyring.testing.backend")
460 (("keyring.tests.util") "keyring.testing.util"))
461 #t))))
462 (build-system python-build-system)
463 (native-inputs
464 `(("python-keyring" ,python-keyring)
465 ("python-pytest" ,python-pytest)
466 ("python-setuptools-scm" ,python-setuptools-scm)))
467 (home-page "https://github.com/jaraco/keyrings.alt")
468 (synopsis "Alternate keyring implementations")
469 (description "Keyrings in this package may have security risks or other
470implications. These backends were extracted from the main keyring project to
471make them available for those who wish to employ them, but are discouraged for
472general production use. Include this module and use its backends at your own
473risk.")
474 (license license:expat)))
475
476(define-public python-certifi
477 (package
478 (name "python-certifi")
479 (version "2020.11.8")
480 (source (origin
481 (method url-fetch)
482 (uri (pypi-uri "certifi" version))
483 (sha256
484 (base32
485 "1x4w18gm71dbwys5g2mbcnbw27b3dvphj5d56icg5ys45h4yypgh"))))
486 (build-system python-build-system)
487 (arguments '(#:tests? #f)) ;no tests
488 (home-page "https://certifi.io/")
489 (synopsis "Python CA certificate bundle")
490 (description
491 "Certifi is a Python library that contains a CA certificate bundle, which
492is used by the Requests library to verify HTTPS requests.")
493 (license license:asl2.0)))
494
495(define-public python2-certifi
496 (package-with-python2 python-certifi))
497
498(define-public python-cryptography-vectors
499 (package
500 (name "python-cryptography-vectors")
501 (version "3.1.1")
502 (source
503 (origin
504 (method url-fetch)
505 (uri (pypi-uri "cryptography_vectors" version))
506 (sha256
507 (base32
508 "1xp2j79c1y8qj4b97ygx451gzp8l4cp830hnvg3zw8j134bcaaam"))))
509 (build-system python-build-system)
510 (home-page "https://github.com/pyca/cryptography")
511 (synopsis "Test vectors for the cryptography package")
512 (description
513 "This package contains test vectors for the cryptography package.")
514 ;; Distributed under either BSD-3 or ASL2.0
515 (license (list license:bsd-3 license:asl2.0))))
516
517(define-public python2-cryptography-vectors
518 (package-with-python2 python-cryptography-vectors))
519
520(define-public python-cryptography
521 (package
522 (name "python-cryptography")
523 (version "3.1.1")
524 (source
525 (origin
526 (method url-fetch)
527 (uri (pypi-uri "cryptography" version))
528 (sha256
529 (base32
530 "0z81q4d1nangw3r0v5f41mfl4d9r04qnbayl5ll5v5jpcfhwd7wx"))))
531 (build-system python-build-system)
532 (inputs
533 `(("openssl" ,openssl)))
534 (propagated-inputs
535 `(("python-asn1crypto" ,python-asn1crypto)
536 ("python-cffi" ,python-cffi)
537 ("python-six" ,python-six)
538 ("python-idna" ,python-idna)
539 ("python-iso8601" ,python-iso8601)))
540 (native-inputs
541 `(("python-cryptography-vectors" ,python-cryptography-vectors)
542 ("python-hypothesis" ,python-hypothesis)
543 ("python-pretend" ,python-pretend)
544 ("python-pytz" ,python-pytz)
545 ("python-pytest" ,python-pytest)))
546 (home-page "https://github.com/pyca/cryptography")
547 (synopsis "Cryptographic recipes and primitives for Python")
548 (description
549 "cryptography is a package which provides cryptographic recipes and
550primitives to Python developers. It aims to be the “cryptographic standard
551library” for Python. The package includes both high level recipes, and low
552level interfaces to common cryptographic algorithms such as symmetric ciphers,
553message digests and key derivation functions.")
554 ;; Distributed under either BSD-3 or ASL2.0
555 (license (list license:bsd-3 license:asl2.0))
556 (properties `((python2-variant . ,(delay python2-cryptography))))))
557
558(define-public python2-cryptography
559 (let ((crypto (package-with-python2
560 (strip-python2-variant python-cryptography))))
561 (package (inherit crypto)
562 (propagated-inputs
563 `(("python2-ipaddress" ,python2-ipaddress)
564 ("python2-backport-ssl-match-hostname"
565 ,python2-backport-ssl-match-hostname)
566 ("python2-enum34" ,python2-enum34)
567 ,@(package-propagated-inputs crypto))))))
568
569(define-public python-pyopenssl
570 (package
571 (name "python-pyopenssl")
572 (version "19.1.0")
573 (source
574 (origin
575 (method url-fetch)
576 (uri (pypi-uri "pyOpenSSL" version))
577 (sha256
578 (base32
579 "01wmsq6w0frzbr3zps4ga9kmqjidp2h317jwpq1g9ah24r5lj94s"))))
580 (build-system python-build-system)
581 (arguments
582 '(#:phases
583 (modify-phases %standard-phases
584 (delete 'check)
585 (add-after 'install 'check
586 (lambda* (#:key inputs outputs #:allow-other-keys)
587 (add-installed-pythonpath inputs outputs)
588 ;; PyOpenSSL runs tests against a certificate with a fixed
589 ;; expiry time. To ensure successful builds in the future,
590 ;; set the time to roughly the release date.
591 (invoke "faketime" "2019-01-01" "py.test" "-v" "-k"
592 (string-append
593 ;; This test tries to look up certificates from
594 ;; the compiled-in default path in OpenSSL, which
595 ;; does not exist in the build environment.
596 "not test_fallback_default_verify_paths "
597 ;; This test attempts to make a connection to
598 ;; an external web service.
599 "and not test_set_default_verify_paths")))))))
600 (propagated-inputs
601 `(("python-cryptography" ,python-cryptography)
602 ("python-six" ,python-six)))
603 (inputs
604 `(("openssl" ,openssl)))
605 (native-inputs
606 `(("libfaketime" ,libfaketime)
607 ("python-flaky" ,python-flaky)
608 ("python-pretend" ,python-pretend)
609 ("python-pytest" ,python-pytest)))
610 (home-page "https://github.com/pyca/pyopenssl")
611 (synopsis "Python wrapper module around the OpenSSL library")
612 (description
613 "PyOpenSSL is a high-level wrapper around a subset of the OpenSSL
614library.")
615 (license license:asl2.0)))
616
617(define-public python2-pyopenssl
618 (package-with-python2 python-pyopenssl))
619
620(define-public python-ed25519
621 (package
622 (name "python-ed25519")
623 (version "1.4")
624 (source
625 (origin
626 (method url-fetch)
627 (uri (pypi-uri "ed25519" version))
628 (sha256
629 (base32
630 "0ahx1nkxa0xis3cw0h5c4fpgv8mq4znkq7kajly33lc3317bk499"))))
631 (build-system python-build-system)
632 (home-page "https://github.com/warner/python-ed25519")
633 (synopsis "Ed25519 public-key signatures")
634 (description "Ed25519 public-key signatures")
635 (license license:expat)))
636
637(define-public python2-ed25519
638 (package-with-python2 python-ed25519))
639
640(define-public python-axolotl-curve25519
641 (package
642 (name "python-axolotl-curve25519")
643 (version "0.4.1.post2")
644 (source
645 (origin
646 (method url-fetch)
647 (uri (pypi-uri "python-axolotl-curve25519" version))
648 (sha256
649 (base32
650 "18v3rfyv7xi26fb97nw1xc0l6x8wi0i4xj8dlq4gblpbjxiac187"))))
651 (build-system python-build-system)
652 (home-page "https://github.com/tgalal/python-axolotl-curve25519")
653 (synopsis "Python wrapper for curve25519 library")
654 (description "This is a python wrapper for the curve25519 library
655with ed25519 signatures. The C code was pulled from
656libaxolotl-android. At the moment this wrapper is meant for use by
657python-axolotl.")
658 (license (list license:gpl3 ; Most files
659 license:bsd-3)))) ; curve/curve25519-donna.c
660
661(define-public python2-axolotl-curve25519
662 (package-with-python2 python-axolotl-curve25519))
663
664(define-public python-axolotl
665 (package
666 (name "python-axolotl")
667 (version "0.2.3")
668 (source
669 (origin
670 (method url-fetch)
671 (uri (pypi-uri "python-axolotl" version))
672 (sha256
673 (base32
674 "1bwdp24fmriffwx91aigs9k162albb51iskp23nc939z893q23py"))))
675 (build-system python-build-system)
676 (arguments
677 `(#:phases
678 (modify-phases %standard-phases
679 ;; Don't install tests
680 (add-before 'install 'remove-tests
681 (lambda _
682 (for-each delete-file-recursively
683 '("axolotl/tests" "build/lib/axolotl/tests"))
684 #t)))))
685 (propagated-inputs
686 `(("python-axolotl-curve25519" ,python-axolotl-curve25519)
687 ("python-cryptography" ,python-cryptography)
688 ("python-protobuf" ,python-protobuf)))
689 (home-page "https://github.com/tgalal/python-axolotl")
690 (synopsis "Python port of libaxolotl-android")
691 (description "This is a python port of libaxolotl-android. This
692is a ratcheting forward secrecy protocol that works in synchronous and
693asynchronous messaging environments.")
694 (license license:gpl3)))
695
696(define-public python2-axolotl
697 (package-with-python2 python-axolotl))
698
699;; SlowAES isn't compatible with Python 3.
700(define-public python2-slowaes
701 (package
702 (name "python2-slowaes")
703 (version "0.1a1")
704 (source
705 (origin
706 (method url-fetch)
707 (uri (pypi-uri "slowaes" version))
708 (sha256
709 (base32
710 "02dzajm83a7lqgxf6r3hgj64wfmcxz8gs4nvgxpvj5n19kjqlrc3"))))
711 (build-system python-build-system)
712 (arguments `(#:python ,python-2))
713 (home-page "http://code.google.com/p/slowaes/")
714 (synopsis "Implementation of AES in Python")
715 (description "This package contains an implementation of AES in Python.
716This implementation is slow (hence the project name) but still useful when
717faster ones are not available.")
718 (license license:asl2.0)))
719
720(define-public python-pyaes
721 (package
722 (name "python-pyaes")
723 (version "1.6.1")
724 (source
725 (origin
726 (method url-fetch)
727 (uri (pypi-uri "pyaes" version))
728 (sha256
729 (base32
730 "13vdaff15k0jyfcss4b4xvfgm8xyv0nrbyw5n1qc7lrqbi0b3h82"))))
731 (build-system python-build-system)
732 (home-page "https://github.com/ricmoo/pyaes")
733 (synopsis "Implementation of AES in Python")
734 (description "This package contains a pure-Python implementation of the
735AES block cipher algorithm and the common modes of operation (CBC, CFB, CTR,
736ECB and OFB).")
737 (license license:expat)))
738
739(define-public python2-pyaes
740 (package-with-python2 python-pyaes))
741
742(define-public python-asn1crypto
743 (package
744 (name "python-asn1crypto")
745 (version "1.4.0")
746 (source
747 (origin
748 (method git-fetch)
749 (uri (git-reference
750 (url "https://github.com/wbond/asn1crypto")
751 (commit version)))
752 (file-name (git-file-name name version))
753 (sha256
754 (base32
755 "19abibn6jw20mzi1ln4n9jjvpdka8ygm4m439hplyrdfqbvgm01r"))))
756 (build-system python-build-system)
757 (arguments
758 '(#:phases (modify-phases %standard-phases
759 (replace 'check
760 (lambda _
761 (invoke "python" "run.py" "tests"))))))
762 (home-page "https://github.com/wbond/asn1crypto")
763 (synopsis "ASN.1 parser and serializer in Python")
764 (description "asn1crypto is an ASN.1 parser and serializer with definitions
765for private keys, public keys, certificates, CRL, OCSP, CMS, PKCS#3, PKCS#7,
766PKCS#8, PKCS#12, PKCS#5, X.509 and TSP.")
767 (license license:expat)))
768
769(define-public python2-asn1crypto
770 (package-with-python2 python-asn1crypto))
771
772(define-public python-pynacl
773 (package
774 (name "python-pynacl")
775 (version "1.4.0")
776 (source
777 (origin
778 (method url-fetch)
779 (uri (pypi-uri "PyNaCl" version))
780 (modules '((guix build utils)))
781 (snippet
782 '(begin
783 ;; Remove spurious dependency on python-wheel, can be removed
784 ;; for 1.5.
785 (substitute* "setup.py"
786 (("\"wheel\"") ""))
787 ;; Remove bundled libsodium.
788 (delete-file-recursively "src/libsodium")
789 #t))
790 (sha256
791 (base32
792 "01b56hxrbif3hx8l6rwz5kljrgvlbj7shmmd2rjh0hn7974a5sal"))))
793 (build-system python-build-system)
794 (arguments
795 `(#:modules (,@%python-build-system-modules
796 (guix build utils)
797 (ice-9 ftw)
798 (srfi srfi-26))
799 #:phases
800 (modify-phases (@ (guix build python-build-system) %standard-phases)
801 (add-before 'build 'use-system-sodium
802 (lambda _
803 (setenv "SODIUM_INSTALL" "system")
804 #t))
805 (replace 'check
806 (lambda _
807 (let ((build-directory
808 (car (scandir "build" (cut string-prefix? "lib" <>)))))
809 (setenv "PYTHONPATH"
810 (string-append "./build/" build-directory ":"
811 (getenv "PYTHONPATH")))
812 (invoke "pytest" "-vv")))))))
813 (native-inputs
814 `(("python-hypothesis" ,python-hypothesis)
815 ("python-pytest" ,python-pytest)))
816 (propagated-inputs
817 `(("python-cffi" ,python-cffi)
818 ("python-six" ,python-six)
819 ("libsodium" ,libsodium)))
820 (home-page "https://github.com/pyca/pynacl/")
821 (synopsis "Python bindings to libsodium")
822 (description
823 "PyNaCl is a Python binding to libsodium, which is a fork of the
824Networking and Cryptography library. These libraries have a stated goal
825of improving usability, security and speed.")
826 (license license:asl2.0)))
827
828(define-public python2-pynacl
829 (package-with-python2 python-pynacl))
830
831(define-public python2-pgpdump
832 (package
833 (name "python2-pgpdump")
834 (version "1.5")
835 (source
836 (origin
837 (method url-fetch)
838 (uri (pypi-uri "pgpdump" version))
839 (sha256
840 (base32
841 "0s4nh8h7qsdj2yf29bspjs1zvxd4lcd11r6g11dp7fppgf2h0iqw"))))
842 (build-system python-build-system)
843
844 ;; Currently fails to build with Python 3.
845 (arguments `(#:python ,python-2))
846
847 (home-page "https://github.com/toofishes/python-pgpdump")
848 (synopsis "Python library for parsing PGP packets")
849 (description
850 "Python-pgpdump is an OpenPGP packet parser based on
851@uref{http://www.mew.org/~kazu/proj/pgpdump/, pgpdump}. It notably supports:
852
853@itemize
854@item signature packets;
855@item public key packets;
856@item secret key packets;
857@item trust, user ID, and user attribute packets;
858@item ASCII-armor decoding and CRC check.
859@end itemize\n")
860 (license license:bsd-3)))
861
862(define-public python2-roca-detect
863 (package
864 (name "python2-roca-detect")
865 (version "1.0.8")
866 (source
867 (origin
868 (method url-fetch)
869 (uri (pypi-uri "roca-detect" version))
870 (sha256
871 (base32
872 "1di4akyw2lf5r8zfwvyhkilz8jv8g4b66rgaqwfabmjwma6gnw27"))))
873 (build-system python-build-system)
874 (native-inputs
875 ;; TODO: apk_parse_ph4, pyjks
876 `(("python2-dateutil" ,python2-dateutil)
877 ("python2-six" ,python2-six)
878 ("python2-cryptography" ,python2-cryptography)
879 ("python2-future" ,python2-future)
880 ("python2-coloredlogs" ,python2-coloredlogs)
881 ("python2-pgpdump" ,python2-pgpdump)))
882 (arguments
883 `(;; Basic testing routine is quite simple and works with Py3
884 ;; but the rest of the code that processes the different
885 ;; key formats and extracts the modulus for inspection is
886 ;; not yet fully py3 ready.
887 #:python ,python-2))
888 (home-page "https://github.com/crocs-muni/roca")
889 (synopsis "ROCA detection tool")
890 (description
891 "This tool is related to the paper entitled @i{Return of the
892Coppersmith’s Attack: Practical Factorization of Widely Used RSA Moduli}. It
893enables you to test public RSA keys for a presence of the described
894vulnerability. Currently the tool supports the following key formats: X.509
895Certificate (DER encoded, PEM encoded), RSA PEM (encoded private key, public
896key), SSH public key, ASC-encoded OpenPGP key, APK Android application, LDIFF
897file, and more.")
898 (license license:gpl3)))
899
900(define-public python-blurhash
901 (package
902 (name "python-blurhash")
903 (version "1.1.4")
904 (source
905 (origin
906 ;; Tests not included in pypi release and releases not tagged in git repo.
907 (method git-fetch)
908 (uri (git-reference
909 (url "https://github.com/halcy/blurhash-python")
910 (commit "22e081ef1c24da1bb5c5eaa2c1d6649724deaef8")))
911 (file-name (git-file-name name version))
912 (sha256
913 (base32
914 "1qq6mhydlp7q3na4kmaq3871h43wh3pyfyxr4b79bia73wjdylxf"))))
915 (build-system python-build-system)
916 (arguments
917 '(#:phases
918 (modify-phases %standard-phases
919 (replace 'check
920 (lambda _
921 (delete-file "setup.cfg")
922 (invoke "pytest"))))))
923 (native-inputs
924 `(("python-numpy" ,python-numpy)
925 ("python-pillow" ,python-pillow)
926 ("python-pytest" ,python-pytest)))
927 (home-page "https://github.com/halcy/blurhash-python")
928 (synopsis
929 "Pure-Python implementation of the blurhash algorithm")
930 (description
931 "Pure-Python implementation of the blurhash algorithm.")
932 (license license:expat)))
933
934(define-public python-ecpy
935 (package
936 (name "python-ecpy")
937 (version "0.10.0")
938 (source
939 (origin
940 (method url-fetch)
941 (uri (pypi-uri "ECPy" version))
942 (sha256
943 (base32
944 "1gc3i5s93zq6x1nkaxkq1dvmsc12vmrw0hns9f5s1hcb78ni52c8"))))
945 (build-system python-build-system)
946 (propagated-inputs
947 `(("python-future" ,python-future)))
948 (home-page "https://github.com/ubinity/ECPy")
949 (synopsis "Pure Python Elliptic Curve Library")
950 (description "This package provides a Elliptic Curve Library in pure
951Python.")
952 (license license:asl2.0)))
953
954(define-public python2-ecpy
955 (package-with-python2 python-ecpy))
956
957(define-public python-josepy
958 (package
959 (name "python-josepy")
960 (version "1.1.0")
961 (source (origin
962 (method url-fetch)
963 (uri (pypi-uri "josepy" version))
964 (sha256
965 (base32
966 "11khz8malzrv375b27jjkv66z6z6khdx1v5mkkr4vq16gp3n4p7v"))))
967 (build-system python-build-system)
968 (arguments
969 ;; The tests require flake8 >= 3.5, which is not yet packaged.
970 '(#:tests? #f))
971 (propagated-inputs
972 `(("python-cryptography" ,python-cryptography)
973 ("python-pyopenssl" ,python-pyopenssl)
974 ("python-six" ,python-six)))
975;; TODO Enable when we have flake8 >= 3.5.
976; (native-inputs
977; `(("python-coverage" ,python-coverage)
978; ("python-flake8" ,python-flake8)
979; ("python-isort" ,python-isort)
980; ("python-mock" ,python-mock)
981; ("python-pytest" ,python-pytest)
982; ("python-pytest-cov" ,python-pytest-cov)
983; ("python-pytest-cache" ,python-pytest-cache)
984; ("python-pytest-flake8" ,python-pytest-flake8)))
985 (home-page "https://github.com/certbot/josepy")
986 (synopsis "JOSE protocol implementation in Python")
987 (description "This package provides a Python implementation of the JOSE
988protocol (Javascript Object Signing and Encryption).")
989 (license license:asl2.0)))
990
991(define-public python2-josepy
992 (package-with-python2 python-josepy))
993
994(define-public python-pycryptodome
995 (package
996 (name "python-pycryptodome")
997 (version "3.9.9")
998 (source
999 (origin
1000 (method url-fetch)
1001 (uri (pypi-uri "pycryptodome" version))
1002 (sha256
1003 (base32
1004 "1i4m74f88qj9ci8rpyzrbk2slmsdj5ipmwdkq6qk24byalm203li"))))
1005 (build-system python-build-system)
1006 (home-page "https://www.pycryptodome.org")
1007 (synopsis "Low-level cryptographic Python library")
1008 (description
1009 "PyCryptodome is a self-contained Python package of low-level
1010cryptographic primitives. It's not a wrapper to a separate C library like
1011OpenSSL. To the largest possible extent, algorithms are implemented in pure
1012Python. Only the pieces that are extremely critical to performance (e.g.,
1013block ciphers) are implemented as C extensions.
1014
1015You are expected to have a solid understanding of cryptography and security
1016engineering to successfully use these primitives. You must also be able to
1017recognize that some are obsolete (e.g., TDES) or even insecure (RC4).
1018
1019It provides many enhancements over the last release of PyCrypto (2.6.1):
1020
1021@itemize
1022@item Authenticated encryption modes (GCM, CCM, EAX, SIV, OCB)
1023@item Accelerated AES on Intel platforms via AES-NI
1024@item First-class support for PyPy
1025@item Elliptic curves cryptography (NIST P-256 curve only)
1026@item Better and more compact API (nonce and iv attributes for ciphers,
1027automatic generation of random nonces and IVs, simplified CTR cipher mode, and
1028more)
1029@item SHA-3 (including SHAKE XOFs) and BLAKE2 hash algorithms
1030@item Salsa20 and ChaCha20 stream ciphers
1031@item scrypt and HKDF
1032@item Deterministic (EC)DSA
1033@item Password-protected PKCS#8 key containers
1034@item Shamir’s Secret Sharing scheme
1035@item Random numbers get sourced directly from the OS (and not from a CSPRNG
1036in userspace)
1037@item Cleaner RSA and DSA key generation (largely based on FIPS 186-4)
1038@item Major clean-ups and simplification of the code base
1039@end itemize
1040
1041This package provides drop-in compatibility with PyCrypto. It is one of two
1042PyCryptodome variants, the other being python-pycryptodomex.")
1043 (license (list license:bsd-2
1044 license:public-domain)))) ; code inherited from PyCrypto
1045
1046(define-public python2-pycryptodome
1047 (package-with-python2 python-pycryptodome))
1048
1049(define-public python-pycryptodomex
1050 (package (inherit python-pycryptodome)
1051 (name "python-pycryptodomex")
1052 (version (package-version python-pycryptodome))
1053 (source
1054 (origin
1055 (method url-fetch)
1056 (uri (pypi-uri "pycryptodomex" version))
1057 (sha256
1058 (base32 "0lbx4qk3xmwqiidhmkj8qa7bh2lf8bwzg0xjpsh2w5zqjrc7qnvv"))))
1059 (description
1060 "PyCryptodome is a self-contained Python package of low-level
1061cryptographic primitives. It's not a wrapper to a separate C library like
1062OpenSSL. To the largest possible extent, algorithms are implemented in pure
1063Python. Only the pieces that are extremely critical to performance (e.g.,
1064block ciphers) are implemented as C extensions.
1065
1066You are expected to have a solid understanding of cryptography and security
1067engineering to successfully use these primitives. You must also be able to
1068recognize that some are obsolete (e.g., TDES) or even insecure (RC4).
1069
1070It provides many enhancements over the last release of PyCrypto (2.6.1):
1071
1072@itemize
1073@item Authenticated encryption modes (GCM, CCM, EAX, SIV, OCB)
1074@item Accelerated AES on Intel platforms via AES-NI
1075@item First-class support for PyPy
1076@item Elliptic curves cryptography (NIST P-256 curve only)
1077@item Better and more compact API (nonce and iv attributes for ciphers,
1078automatic generation of random nonces and IVs, simplified CTR cipher mode, and
1079more)
1080@item SHA-3 (including SHAKE XOFs) and BLAKE2 hash algorithms
1081@item Salsa20 and ChaCha20 stream ciphers
1082@item scrypt and HKDF
1083@item Deterministic (EC)DSA
1084@item Password-protected PKCS#8 key containers
1085@item Shamir’s Secret Sharing scheme
1086@item Random numbers get sourced directly from the OS (and not from a CSPRNG
1087in userspace)
1088@item Cleaner RSA and DSA key generation (largely based on FIPS 186-4)
1089@item Major clean-ups and simplification of the code base
1090@end itemize
1091
1092PyCryptodomex is the stand-alone version of PyCryptodome that no longer
1093provides drop-in compatibility with PyCrypto.")))
1094
1095(define-public python-m2crypto
1096 (package
1097 (name "python-m2crypto")
1098 (version "0.35.2")
1099 (source
1100 (origin
1101 (method url-fetch)
1102 (uri (pypi-uri "M2Crypto" version))
1103 (sha256
1104 (base32 "09yirf3w77w6f49q6nxhrjm9c3a4y9s30s1k09chqrw8zdgx8sjc"))))
1105 (build-system python-build-system)
1106 (inputs `(("openssl" ,openssl)))
1107 (native-inputs `(("swig" ,swig)))
1108 (home-page "https://gitlab.com/m2crypto/m2crypto")
1109 (synopsis "Python crypto and TLS toolkit")
1110 (description "@code{M2Crypto} is a complete Python wrapper for OpenSSL
1111featuring RSA, DSA, DH, EC, HMACs, message digests, symmetric ciphers
1112(including AES); TLS functionality to implement clients and servers; HTTPS
1113extensions to Python's httplib, urllib, and xmlrpclib; unforgeable HMAC'ing
1114AuthCookies for web session management; FTP/TLS client and server; S/MIME;
1115M2Crypto can also be used to provide TLS for Twisted. Smartcards supported
1116through the Engine interface.")
1117 (properties `((python2-variant . ,(delay python2-m2crypto))))
1118 (license license:expat)))
1119
1120(define-public python2-m2crypto
1121 (let ((m2crypto (package-with-python2
1122 (strip-python2-variant python-m2crypto))))
1123 (package (inherit m2crypto)
1124 (propagated-inputs
1125 `(("python2-typing" ,python2-typing))))))
1126
1127(define-public python-pykeepass
1128 (package
1129 (name "python-pykeepass")
1130 (version "3.2.1")
1131 (source
1132 (origin
1133 (method git-fetch)
1134 ;; Source tarball on PyPI doesn't include tests.
1135 (uri (git-reference
1136 (url "https://github.com/libkeepass/pykeepass")
1137 (commit version)))
1138 (file-name (git-file-name name version))
1139 (sha256
1140 (base32 "1symxf4ahylynihnp9z4z3lh2vy65ipvg8s4hjrnn936hcaaxghk"))))
1141 (build-system python-build-system)
1142 (arguments
1143 `(#:phases
1144 (modify-phases %standard-phases
1145 (add-after 'unpack 'make-kdbx-writable
1146 ;; Tests have to write to the .kdbx files in the test directory.
1147 (lambda _
1148 (with-directory-excursion "tests"
1149 (for-each make-file-writable (find-files "."))
1150 #t)))
1151 (add-before 'build 'patch-requirements
1152 (lambda _
1153 ;; Update requirements from dependency==version
1154 ;; to dependency>=version.
1155 (substitute* "setup.py"
1156 (("==") ">="))
1157 #t)))))
1158 (propagated-inputs
1159 `(("python-argon2-cffi" ,python-argon2-cffi)
1160 ("python-construct" ,python-construct)
1161 ("python-dateutil" ,python-dateutil)
1162 ("python-future" ,python-future)
1163 ("python-lxml" ,python-lxml)
1164 ("python-pycryptodomex" ,python-pycryptodomex)))
1165 (home-page "https://github.com/libkeepass/pykeepass")
1166 (synopsis "Python library to interact with keepass databases")
1167 (description
1168 "This library allows you to write entries to a KeePass database. It
1169supports KDBX3 and KDBX4.")
1170 ;; There are no copyright headers in the source code. The LICENSE file
1171 ;; indicates GPL3.
1172 (license license:gpl3+)))
1173
1174(define-public python-pylibscrypt
1175 (package
1176 (name "python-pylibscrypt")
1177 (version "1.7.1")
1178 (source
1179 (origin
1180 (method url-fetch)
1181 (uri (pypi-uri "pylibscrypt" version))
1182 (sha256
1183 (base32
1184 "1b3rgzl6dbzs08vhv41b6y4n5189wv7lr27acxn104hs45745abs"))))
1185 (build-system python-build-system)
1186 (arguments
1187 `(#:phases
1188 (modify-phases %standard-phases
1189 (add-before 'build 'hard-code-path-to-libscrypt
1190 (lambda* (#:key inputs #:allow-other-keys)
1191 (let ((libscrypt (assoc-ref inputs "libscrypt")))
1192 (substitute* "pylibscrypt/pylibscrypt.py"
1193 (("find_library\\('scrypt'\\)")
1194 (string-append "'" libscrypt "/lib/libscrypt.so'")))
1195 #t))))
1196 ;; The library can use various scrypt implementations and tests all of
1197 ;; them. Since we only provide a single implementation, most tests
1198 ;; fail. Simply skip them.
1199 #:tests? #f))
1200 ;; FIXME: Using "libscrypt" is the second best choice. The best one
1201 ;; requires "hashlib.scrypt", provided by Python 3.6+ built with OpenSSL
1202 ;; 1.1+. Use that as soon as Guix provides it.
1203 (inputs
1204 `(("libscrypt" ,libscrypt)))
1205 (home-page "https://github.com/jvarho/pylibscrypt")
1206 (synopsis "Scrypt for Python")
1207 (description "There are a lot of different scrypt modules for Python, but
1208none of them have everything that I'd like, so here's one more. It uses
1209@code{libscrypt}.")
1210 (license license:isc)))
1211
1212(define-public python-libnacl
1213 (package
1214 (name "python-libnacl")
1215 (version "1.6.1")
1216 (source
1217 (origin
1218 (method url-fetch)
1219 (uri (pypi-uri "libnacl" version))
1220 (sha256
1221 (base32
1222 "0nv7n8nfswkhl614x5mllrkvaslraa0053q11iylb337cy43vb4v"))))
1223 (build-system python-build-system)
1224 (arguments
1225 `(#:phases
1226 (modify-phases %standard-phases
1227 (add-after 'unpack 'locate-libsodium
1228 (lambda* (#:key inputs #:allow-other-keys)
1229 (substitute* "libnacl/__init__.py"
1230 (("(return ctypes.cdll.LoadLibrary\\(')libsodium.so('\\))"
1231 _ pre post)
1232 (let ((libsodium (string-append (assoc-ref inputs "libsodium")
1233 "/lib/libsodium.so")))
1234 (string-append pre libsodium post)))))))))
1235 (native-inputs
1236 `(("python-pyhamcrest" ,python-pyhamcrest)))
1237 (inputs
1238 `(("libsodium" ,libsodium)))
1239 (home-page "https://libnacl.readthedocs.org/")
1240 (synopsis "Python bindings for libsodium based on ctypes")
1241 (description "@code{libnacl} is used to gain direct access to the
1242functions exposed by @code{NaCl} library via @code{libsodium}. It has
1243been constructed to maintain extensive documentation on how to use
1244@code{NaCl} as well as being completely portable.")
1245 (license license:asl2.0)))
1246
1247(define-public python-pyotp
1248 (package
1249 (name "python-pyotp")
1250 (version "2.4.1")
1251 (source
1252 (origin
1253 (method url-fetch)
1254 (uri (pypi-uri "pyotp" version))
1255 (sha256
1256 (base32 "0jsqfmx9i7j8z81r4zazv76xzy1fcq8v9s2r4kvx7ajfndq3z2h3"))))
1257 (build-system python-build-system)
1258 (home-page "https://github.com/pyauth/pyotp")
1259 (synopsis "Python One Time Password Library")
1260 (description
1261 "PyOTP is a Python library for generating and verifying one-time
1262passwords. It can be used to implement two-factor (2FA) or multi-factor
1263(MFA) authentication methods in web applications and in other systems that
1264require users to log in.")
1265 (license license:expat)))
1266
1267(define-public python-scrypt
1268 (package
1269 (name "python-scrypt")
1270 (version "0.8.7")
1271 (source
1272 (origin
1273 (method url-fetch)
1274 (uri (pypi-uri "scrypt" version))
1275 (sha256
1276 (base32
1277 "0hjk71k3mgnl8siikm9lii9im8kv0rb7inkjzx78rnancra48xxr"))))
1278 (build-system python-build-system)
1279 (inputs
1280 `(("openssl" ,openssl)))
1281 (home-page "https://bitbucket.org/mhallin/py-scrypt")
1282 (synopsis "Bindings for the scrypt key derivation function library")
1283 (description "This is a set of Python bindings for the scrypt key
1284derivation function.")
1285 (license license:bsd-2)))
1286
1287(define-public python-service-identity
1288 (package
1289 (name "python-service-identity")
1290 (version "18.1.0")
1291 (source
1292 (origin
1293 (method url-fetch)
1294 (uri (pypi-uri "service_identity" version))
1295 (sha256
1296 (base32
1297 "0b9f5qiqjy8ralzgwjgkhx82h6h8sa7532psmb8mkd65md5aan08"))))
1298 (build-system python-build-system)
1299 (propagated-inputs
1300 `(("python-attrs" ,python-attrs)
1301 ("python-pyasn1" ,python-pyasn1)
1302 ("python-pyasn1-modules" ,python-pyasn1-modules)
1303 ("python-pyopenssl" ,python-pyopenssl)))
1304 (home-page "https://service-identity.readthedocs.io/")
1305 (synopsis "Service identity verification for PyOpenSSL")
1306 (description
1307 "@code{service_identity} aspires to give you all the tools you need
1308for verifying whether a certificate is valid for the intended purposes.
1309In the simplest case, this means host name verification. However,
1310service_identity implements RFC 6125 fully and plans to add other
1311relevant RFCs too.")
1312 (license license:expat)))
1313
1314(define-public python2-service-identity
1315 (package-with-python2 python-service-identity))
1316
1317(define-public python-hkdf
1318 (package
1319 (name "python-hkdf")
1320 (version "0.0.3")
1321 (source
1322 (origin
1323 (method url-fetch)
1324 (uri (pypi-uri "hkdf" version))
1325 (sha256
1326 (base32
1327 "1jhxk5vhxmxxjp3zj526ry521v9inzzl8jqaaf0ma65w6k332ak2"))))
1328 (build-system python-build-system)
1329 (native-inputs
1330 `(("python-nose" ,python-nose)))
1331 (home-page "https://github.com/casebeer/python-hkdf")
1332 (synopsis "HMAC-based Extract-and-Expand Key Derivation Function (HKDF)")
1333 (description "This package provides a Python implementation of the HMAC Key
1334Derivation function (HKDF) defined in RFC 5869.")
1335 (license license:bsd-2)))
1336
1337(define-public python-spake2
1338 (package
1339 (name "python-spake2")
1340 (version "0.8")
1341 (source
1342 (origin
1343 (method url-fetch)
1344 (uri (pypi-uri "spake2" version))
1345 (sha256
1346 (base32
1347 "1x16r7lrbklvfzbacb66qv9iiih6liq1y612dqh2chgf555n2yn1"))))
1348 (build-system python-build-system)
1349 (propagated-inputs
1350 `(("python-hkdf" ,python-hkdf)))
1351 (home-page "https://github.com/warner/python-spake2")
1352 (synopsis "SPAKE2 password-authenticated key exchange in Python")
1353 (description "This package provides a Python implementation of the SPAKE2
1354Password-Authenticated Key Exchange algorithm.")
1355 (license license:expat)))
1356
1357(define-public python-txtorcon
1358 (package
1359 (name "python-txtorcon")
1360 (version "19.0.0")
1361 (source
1362 (origin
1363 (method url-fetch)
1364 (uri (pypi-uri "txtorcon" version))
1365 (sha256
1366 (base32
1367 "0fxzhsc62bhmr730vj9pzallmw56gz6iykvl28a5agrycm0bfc9p"))))
1368 (build-system python-build-system)
1369 (arguments
1370 ;; The tests fail immediately due to a missing file. Reported upstream:
1371 ;; <https://github.com/meejah/txtorcon/issues/330>
1372 `(#:tests? #f))
1373 (propagated-inputs
1374 `(("python-automat" ,python-automat)
1375 ("python-idna" ,python-idna)
1376 ("python-incremental" ,python-incremental)
1377 ("python-service-identity" ,python-service-identity)
1378 ("python-twisted" ,python-twisted)
1379 ("python-zope-interface" ,python-zope-interface)))
1380 (home-page "https://github.com/meejah/txtorcon")
1381 (synopsis "Twisted-based Tor controller client")
1382 (description "This package provides a Twisted-based Tor controller client,
1383with state-tracking and configuration abstractions.")
1384 (license license:expat)))
1385
1386(define-public python-keyutils
1387 (package
1388 (name "python-keyutils")
1389 (version "0.6")
1390 (source
1391 (origin
1392 (method url-fetch)
1393 (uri (pypi-uri "keyutils" version))
1394 (sha256
1395 (base32
1396 "0lipygpzhwzzsq2k5imb1jgkmj8y4khxdwhzadjs3bd56g6bmkx9"))))
1397 (build-system python-build-system)
1398 (native-inputs
1399 `(("python-pytest" ,python-pytest)
1400 ("python-pytest-runner" ,python-pytest-runner)))
1401 (inputs
1402 `(("keyutils" ,keyutils)))
1403 (arguments
1404 '(#:tests? #f))
1405 (home-page "https://github.com/sassoftware/python-keyutils")
1406 (synopsis "Python bindings for keyutils")
1407 (description
1408 "This is a set of python bindings for keyutils, a key management suite
1409that leverages the infrastructure provided by the Linux kernel for safely
1410storing and retrieving sensitive information in your programs.")
1411 (license license:asl2.0)))
1412
1413(define-public python-mcuboot-imgtool
1414 (package
1415 (name "python-mcuboot-imgtool")
1416 (version "1.4.0")
1417 (source
1418 (origin
1419 (method git-fetch)
1420 (uri (git-reference
1421 (url "https://github.com/JuulLabs-OSS/mcuboot")
1422 (commit (string-append "v" version))))
1423 (file-name (git-file-name name version))
1424 (sha256
1425 (base32
1426 "1m1csyvzq4jx81zg635ssy1n7sc0z539z0myh872ll3nwqx7wa0q"))))
1427 (build-system python-build-system)
1428 (arguments
1429 `(#:phases
1430 (modify-phases %standard-phases
1431 (add-after 'unpack 'fix-broken-test
1432 (lambda _
1433 (substitute* "scripts/imgtool/keys/ed25519_test.py"
1434 (("raw_sign") "sign_digest"))
1435 #t))
1436 (add-before 'build 'change-directory
1437 (lambda _
1438 (chdir "scripts")
1439 #t)))))
1440 (propagated-inputs
1441 `(("python-click" ,python-click)
1442 ("python-intelhex" ,python-intelhex)
1443 ("python-cryptography" ,python-cryptography)))
1444 (home-page "https://mcuboot.com")
1445 (synopsis "Tool to securely sign firmware images for booting by MCUboot")
1446 (description "MCUboot is a secure bootloader for 32-bit MCUs. This
1447package provides a tool to securely sign firmware images for booting by
1448MCUboot.")
1449 (license license:expat)))
1450
1451(define-public python-ntlm-auth
1452 (package
1453 (name "python-ntlm-auth")
1454 (version "1.4.0")
1455 (source
1456 (origin
1457 (method url-fetch)
1458 (uri (pypi-uri "ntlm-auth" version))
1459 (sha256
1460 (base32
1461 "16mavidki4ma5ip8srqalr19gz4f5yn3cnmmgps1fmgfr24j63rm"))))
1462 (build-system python-build-system)
1463 (propagated-inputs
1464 `(("python-cryptography" ,python-cryptography)))
1465 (home-page "https://github.com/jborean93/ntlm-auth")
1466 (synopsis
1467 "Calculates NTLM Authentication codes")
1468 (description
1469 "This library handles the low-level details of NTLM authentication for
1470use in authenticating with a service that uses NTLM. It will create and parse
1471the 3 different message types in the order required and produce a base64
1472encoded value that can be attached to the HTTP header.
1473
1474The goal of this library is to offer full NTLM support including signing and
1475sealing of messages as well as supporting MIC for message integrity and the
1476ability to customise and set limits on the messages sent. Please see Features
1477and Backlog for a list of what is and is not currently supported.")
1478 (license license:expat)))
1479
1480(define-public python-secretstorage
1481 (package
1482 (name "python-secretstorage")
1483 (version "3.1.2")
1484 (source
1485 (origin
1486 (method url-fetch)
1487 (uri (pypi-uri "SecretStorage" version))
1488 (sha256
1489 (base32
1490 "1xmzr0j3066s220bss4nkgqbiwb5k4kkp2rkpqlqwjb5kfc8mnhm"))))
1491 (build-system python-build-system)
1492 (arguments
1493 '(#:tests? #f)) ; Tests require a running dbus service.
1494 (propagated-inputs
1495 `(("python-cryptography" ,python-cryptography)
1496 ("python-jeepney" ,python-jeepney)))
1497 (home-page "https://github.com/mitya57/secretstorage")
1498 (synopsis "Python bindings to FreeDesktop.org Secret Service API")
1499 (description
1500 "@code{python-secretstorage} provides a way for securely storing passwords
1501and other secrets. It uses D-Bus Secret Service API that is supported by GNOME
1502Keyring (since version 2.30) and KSecretsService. SecretStorage supports most
1503of the functions provided by Secret Service, including creating and deleting
1504items and collections, editing items, locking and unlocking collections
1505(asynchronous unlocking is also supported).")
1506 (license license:bsd-3)))
1507
1508(define-public python-trustme
1509 (package
1510 (name "python-trustme")
1511 (version "0.6.0")
1512 (source
1513 (origin
1514 (method url-fetch)
1515 (uri (pypi-uri "trustme" version))
1516 (sha256
1517 (base32 "0v3vr5z6apnfmklf07m45kv5kaqvm6hxrkaqywch57bjd2siiywx"))))
1518 (build-system python-build-system)
1519 (arguments
1520 `(#:phases
1521 (modify-phases %standard-phases
1522 (replace 'check
1523 (lambda* (#:key inputs outputs #:allow-other-keys)
1524 (add-installed-pythonpath inputs outputs)
1525 (invoke "pytest" "-vv"))))))
1526 (native-inputs
1527 `(("python-more-itertools" ,python-more-itertools)
1528 ("python-pyopenssl" ,python-pyopenssl)
1529 ("python-pytest" ,python-pytest)
1530 ("python-pytest-cov" ,python-pytest-cov)
1531 ("python-service-identity" ,python-service-identity)
1532 ("python-zipp" ,python-zipp)))
1533 (propagated-inputs
1534 `(("python-cryptography" ,python-cryptography)))
1535 (home-page "https://github.com/python-trio/trustme")
1536 (synopsis "Fake a certificate authority for tests")
1537 (description
1538 "@code{trustme} is a tiny Python package that does one thing: it gives you
1539a fake certificate authority (CA) that you can use to generate fake TLS certs to
1540use in your tests.")
1541 ;; Either license applies.
1542 (license (list license:expat license:asl2.0))))
1543
1544(define-public python-certipy
1545 (package
1546 (name "python-certipy")
1547 (version "0.1.3")
1548 (source
1549 (origin
1550 (method url-fetch)
1551 (uri (pypi-uri "certipy" version))
1552 (sha256
1553 (base32
1554 "0n980gqpzh0fm58h3i4mi2i10wgj606lscm1r5sk60vbf6vh8mv9"))))
1555 (build-system python-build-system)
1556 (propagated-inputs
1557 `(("python-pyopenssl" ,python-pyopenssl)))
1558 (native-inputs
1559 `(("python-pytest" ,python-pytest)))
1560 (home-page "https://github.com/LLNL/certipy")
1561 (synopsis "Utility to create and sign CAs and certificates")
1562 (description
1563 "Certipy was made to simplify the certificate creation process. To that
1564end, certipy exposes methods for creating and managing certificate authorities,
1565certificates, signing and building trust bundles.")
1566 (license license:bsd-3)))
1567
1568(define-public python-jeepney
1569 (package
1570 (name "python-jeepney")
1571 (version "0.4.3")
1572 (source
1573 (origin
1574 (method url-fetch)
1575 (uri (pypi-uri "jeepney" version))
1576 (sha256
1577 (base32 "0vp3p1lqhqk2kd3254q5sxr50znmm2hmysc8a7g0fr1brihvhy9l"))))
1578 (build-system python-build-system)
1579 (native-inputs
1580 `(("python-testpath" ,python-testpath)
1581 ("python-tornado" ,python-tornado)
1582 ("python-pytest" ,python-pytest)))
1583 (home-page "https://gitlab.com/takluyver/jeepney")
1584 (synopsis "Low-level, pure Python DBus protocol wrapper")
1585 (description
1586 "This is a low-level, pure Python DBus protocol client. It has an
1587I/O-free core, and integration modules for different event loops.")
1588 (license license:expat)))
1589
1590(define-public python-argon2-cffi
1591 (package
1592 (name "python-argon2-cffi")
1593 (version "20.1.0")
1594 (source
1595 (origin
1596 (method url-fetch)
1597 (uri (pypi-uri "argon2-cffi" version))
1598 (sha256
1599 (base32
1600 "0zgr4mnnm0p4i99023safb0qb8cgvl202nly1rvylk2b7qnrn0nq"))
1601 (modules '((guix build utils)))
1602 (snippet '(begin (delete-file-recursively "extras") #t))))
1603 (build-system python-build-system)
1604 (arguments
1605 '(#:phases
1606 (modify-phases %standard-phases
1607 (replace 'build
1608 (lambda _
1609 (setenv "ARGON2_CFFI_USE_SYSTEM" "1")
1610 (invoke "python" "setup.py" "build")))
1611 (replace 'check
1612 (lambda* (#:key inputs outputs #:allow-other-keys)
1613 (add-installed-pythonpath inputs outputs)
1614 (invoke "pytest")
1615 (invoke "python" "-m" "argon2" "--help")
1616 ;; see tox.ini
1617 (invoke "python" "-m" "argon2" "-n" "1" "-t" "1" "-m" "8" "-p" "1"))))))
1618 (propagated-inputs
1619 `(("python-cffi" ,python-cffi)
1620 ("python-six" ,python-six)))
1621 (inputs `(("argon2" ,argon2)))
1622 (native-inputs
1623 `(("python-hypothesis" ,python-hypothesis)
1624 ("python-pytest" ,python-pytest)))
1625 (home-page "https://argon2-cffi.readthedocs.io/")
1626 (synopsis "Secure Password Hashes for Python")
1627 (description
1628 "Argon2 is a secure password hashing algorithm. It is designed to have
1629both a configurable runtime as well as memory consumption. This means that you
1630can decide how long it takes to hash a password and how much memory is required.")
1631 (license license:expat)))
1632
1633(define-public python-privy
1634 (package
1635 (name "python-privy")
1636 (version "6.0.0")
1637 (source
1638 (origin
1639 (method git-fetch)
1640 (uri (git-reference
1641 ;; Releases are untagged
1642 (url "https://github.com/ofek/privy")
1643 (commit "2838db3df239797c71bddacc48a4c49a83f35747")))
1644 (file-name (git-file-name name version))
1645 (sha256
1646 (base32
1647 "1m32dh5fqc8cy7jyf1z5fs6zvmdkbq5fi98hr609gbl7s0l0y0i9"))))
1648 (build-system python-build-system)
1649 (arguments
1650 '(#:phases
1651 (modify-phases %standard-phases
1652 (replace 'check
1653 (lambda _
1654 (invoke "python" "-m" "pytest"))))))
1655 (native-inputs
1656 `(("python-pytest" ,python-pytest)))
1657 (propagated-inputs
1658 `(("python-argon2-cffi" ,python-argon2-cffi)
1659 ("python-cryptography" ,python-cryptography)))
1660 (home-page "https://www.dropbox.com/developers")
1661 (synopsis "Library to password-protect your data")
1662 (description
1663 "Privy is a small and fast utility for password-protecting secret
1664data such as API keys, cryptocurrency wallets, or seeds for digital
1665signatures.")
1666 (license (list license:expat license:asl2.0)))) ; dual licensed
1667
1668(define-public python-pgpy
1669 (package
1670 (name "python-pgpy")
1671 (version "0.5.3")
1672 (source
1673 (origin
1674 (method url-fetch)
1675 (uri (pypi-uri "PGPy" version))
1676 (sha256
1677 (base32 "11rrq15gmn6qbahli7czflfcngjl7zyybjlvk732my6axnf2d754"))))
1678 (build-system python-build-system)
1679 (arguments
1680 `(#:phases
1681 (modify-phases %standard-phases
1682 (replace 'check
1683 (lambda* (#:key tests? #:allow-other-keys)
1684 (when tests?
1685 (invoke "pytest")))))))
1686 (native-inputs
1687 `(("python-cryptography" ,python-cryptography)
1688 ("python-pyasn1" ,python-pyasn1)
1689 ("python-pytest" ,python-pytest)
1690 ("python-singledispatch" ,python-singledispatch)
1691 ("python-six" ,python-six)
1692 ("python-wheel" ,python-wheel)))
1693 (home-page "https://github.com/SecurityInnovation/PGPy")
1694 (synopsis "Python implementation of OpenPGP")
1695 (description
1696 "Currently, PGPy can load keys and signatures of all kinds in both ASCII
1697armored and binary formats.
1698
1699It can create and verify RSA, DSA, and ECDSA signatures, at the moment. It
1700can also encrypt and decrypt messages using RSA and ECDH.")
1701 (license license:bsd-3)))
1702
1703(define-public python-sop
1704 (package
1705 (name "python-sop")
1706 (version "0.2.0")
1707 (source
1708 (origin
1709 (method url-fetch)
1710 (uri (pypi-uri "sop" version))
1711 (sha256
1712 (base32
1713 "0gljyjsdn6hdmwlwwb5g5s0c031p6izamvfxp0d39x60af8k5jyf"))))
1714 (build-system python-build-system)
1715 (arguments
1716 '(#:tests? #f)) ; There are no tests, and unittest throws an error trying
1717 ; to find some:
1718 ; TypeError: don't know how to make test from: 0.2.0
1719 (home-page "https://gitlab.com/dkg/python-sop")
1720 (synopsis "Stateless OpenPGP Command-Line Interface")
1721 (description
1722 "The Stateless OpenPGP Command-Line Interface (or sop) is a
1723specification that encourages OpenPGP implementors to provide a common,
1724relatively simple command-line API for purposes of object security.
1725
1726This Python module helps implementers build such a CLI from any implementation
1727accessible to the Python interpreter.
1728
1729It does not provide such an implementation itself -- this is just the
1730scaffolding for the command line, which should make it relatively easy to
1731supply a handful of python functions as methods to a class.")
1732 (license license:expat))) ; MIT license