projects/guix·blob python-team · refs

1004 lines · 37.5 KiB

1;;; GNU Guix --- Functional package management for GNU
2;;; Copyright © 2015 Paul van der Walt <[email protected]>
3;;; Copyright © 2015, 2017, 2018, 2019 Ricardo Wurmus <[email protected]>
4;;; Copyright © 2016 Nikita <[email protected]>
5;;; Copyright © 2017 rsiddharth <[email protected]>
6;;; Copyright © 2017, 2019, 2023 Tobias Geerinckx-Rice <[email protected]>
7;;; Copyright © 2020 Giacomo Leidi <[email protected]>
8;;; Copyright © 2025 Maxim Cournoyer <[email protected]>
9;;; Copyright © 2026 Konstantin Suntsov <[email protected]>
10;;;
11;;; This file is part of GNU Guix.
12;;;
13;;; GNU Guix is free software; you can redistribute it and/or modify it
14;;; under the terms of the GNU General Public License as published by
15;;; the Free Software Foundation; either version 3 of the License, or (at
16;;; your option) any later version.
17;;;
18;;; GNU Guix is distributed in the hope that it will be useful, but
19;;; WITHOUT ANY WARRANTY; without even the implied warranty of
20;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21;;; GNU General Public License for more details.
22;;;
23;;; You should have received a copy of the GNU General Public License
24;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
25
26(define-module (gnu packages haskell-crypto)
27 #:use-module (gnu packages)
28 #:use-module (gnu packages compression)
29 #:use-module (gnu packages haskell)
30 #:use-module (gnu packages haskell-check)
31 #:use-module (gnu packages haskell-xyz)
32 #:use-module (gnu packages pkg-config)
33 #:use-module (gnu packages tls)
34 #:use-module (guix build-system haskell)
35 #:use-module (guix download)
36 #:use-module (guix gexp)
37 #:use-module ((guix licenses) #:prefix license:)
38 #:use-module (guix packages)
39 #:use-module (guix utils))
40
41(define-public ghc-asn1-types
42 (package
43 (name "ghc-asn1-types")
44 (version "0.3.4")
45 (source (origin
46 (method url-fetch)
47 (uri (hackage-uri "asn1-types" version))
48 (sha256
49 (base32
50 "1a119qxhxhr0yn37r26dkydm6g5kykdkx98ghb59i4ipa6i95vkq"))))
51 (build-system haskell-build-system)
52 (properties '((upstream-name . "asn1-types")))
53 (inputs
54 (list ghc-memory ghc-hourglass))
55 (home-page "https://github.com/vincenthz/hs-asn1-types")
56 (synopsis "ASN.1 types for Haskell")
57 (description
58 "The package provides the standard types for dealing with the ASN.1
59format.")
60 (license license:bsd-3)))
61
62(define-public ghc-asn1-encoding
63 (package
64 (name "ghc-asn1-encoding")
65 (version "0.9.6")
66 (source
67 (origin
68 (method url-fetch)
69 (uri (hackage-uri "asn1-encoding" version))
70 (sha256
71 (base32 "02nsr30h5yic1mk7znf0q4z3n560ip017n60hg7ya25rsfmxxy6r"))))
72 (build-system haskell-build-system)
73 (properties '((upstream-name . "asn1-encoding")))
74 (inputs (list ghc-hourglass ghc-asn1-types))
75 (native-inputs (list ghc-tasty ghc-tasty-quickcheck))
76 (arguments
77 `(#:cabal-revision ("2"
78 "16503ryhq15f2rfdav2qnkq11dg2r3vk3f9v64q9dmxf8dh8zv97")))
79 (home-page "https://github.com/vincenthz/hs-asn1")
80 (synopsis "ASN1 data reader and writer in RAW, BER and DER forms")
81 (description
82 "This package provides a reader and writer for ASN1 data in raw form with
83supports for high level forms of ASN1 (BER, and DER).")
84 (license license:bsd-3)))
85
86(define-public ghc-asn1-parse
87 (package
88 (name "ghc-asn1-parse")
89 (version "0.9.5")
90 (source (origin
91 (method url-fetch)
92 (uri (hackage-uri "asn1-parse" version))
93 (sha256
94 (base32
95 "17pk8y3nwv9b9i5j15qlmwi7fmq9ab2z4kfpjk2rvcrh9lsf27wg"))))
96 (build-system haskell-build-system)
97 (properties '((upstream-name . "asn1-parse")))
98 (inputs
99 (list ghc-asn1-types ghc-asn1-encoding))
100 (home-page "https://github.com/vincenthz/hs-asn1")
101 (synopsis "Simple monadic parser for ASN1 stream types")
102 (description
103 "This package provides a simple monadic parser for ASN1 stream types,
104when ASN1 pattern matching is not convenient.")
105 (license license:bsd-3)))
106
107(define-public ghc-crypto-api
108 (package
109 (name "ghc-crypto-api")
110 (version "0.13.3")
111 (source
112 (origin
113 (method url-fetch)
114 (uri (hackage-uri "crypto-api" version))
115 (sha256
116 (base32 "19bsmkqkpnvh01b77pmyarx00fic15j4hvg4pzscrj4prskrx2i9"))))
117 (build-system haskell-build-system)
118 (properties '((upstream-name . "crypto-api")))
119 (inputs (list ghc-cereal ghc-tagged ghc-entropy))
120 (arguments
121 `(#:cabal-revision ("1"
122 "1z6n1sa5pn3iqvqjrd8hv4bc2pxzsrhm5sh0l8z7g9lbqp6w0wp5")))
123 (home-page "https://github.com/TomMD/crypto-api")
124 (synopsis "Provides generic interface for cryptographic operations
125for Haskell")
126 (description
127 "This Haskell package provides a generic interface for
128cryptographic operations (hashes, ciphers, randomness).
129
130Maintainers of hash and cipher implementations are encouraged to add instances
131for the classes defined in @code{Crypto.Classes}. @code{Crypto} users are
132similarly encouraged to use the interfaces defined in the @code{Classes} module.
133
134Any concepts or functions of general use to more than one cryptographic
135algorithm (ex: padding) is within scope of this package.")
136 (license license:bsd-3)))
137
138(define-public ghc-crypto-api-tests
139 (package
140 (name "ghc-crypto-api-tests")
141 (version "0.3")
142 (source
143 (origin
144 (method url-fetch)
145 (uri (hackage-uri "crypto-api-tests" version))
146 (sha256
147 (base32
148 "0w3j43jdrlj28jryp18hc6q84nkl2yf4vs1hhgrsk7gb9kfyqjpl"))))
149 (build-system haskell-build-system)
150 (properties '((upstream-name . "crypto-api-tests")))
151 (inputs (list ghc-test-framework-quickcheck2
152 ghc-crypto-api
153 ghc-cereal
154 ghc-test-framework
155 ghc-test-framework-hunit
156 ghc-hunit
157 ghc-quickcheck))
158 (home-page "https://github.com/TomMD/crypto-api-tests")
159 (synopsis "Test framework and KATs for cryptographic operations for Haskell")
160 (description "This Haskell package provides a test framework for hash and
161cipher operations using the crypto-api interface. Known answer tests (KATs)
162for common cryptographic algorithms are included.")
163 (license license:bsd-3)))
164
165(define-public ghc-cryptohash
166 (package
167 (name "ghc-cryptohash")
168 (version "0.11.9")
169 (source
170 (origin
171 (method url-fetch)
172 (uri (hackage-uri "cryptohash" version))
173 (sha256
174 (base32
175 "1yr2iyb779znj79j3fq4ky8l1y8a600a2x1fx9p5pmpwq5zq93y2"))))
176 (build-system haskell-build-system)
177 (properties '((upstream-name . "cryptohash")))
178 (inputs
179 (list ghc-byteable
180 ghc-cryptonite
181 ghc-memory
182 ghc-hunit
183 ghc-quickcheck
184 ghc-tasty
185 ghc-tasty-quickcheck
186 ghc-tasty-hunit))
187 (home-page "https://github.com/vincenthz/hs-cryptohash")
188 (synopsis "Collection of cryptographic hashes in Haskell")
189 (description
190 "A collection of crypto hashes, with a practical incremental and one-pass,
191pure APIs, with performance close to the fastest implementations available in
192other languages. The implementations are made in C with a haskell FFI wrapper
193that hides the C implementation.")
194 (license license:bsd-3)))
195
196(define-public ghc-cryptohash-md5
197 (package
198 (name "ghc-cryptohash-md5")
199 (version "0.11.101.0")
200 (source
201 (origin
202 (method url-fetch)
203 (uri (hackage-uri "cryptohash-md5" version))
204 (sha256
205 (base32 "018g13hkmq5782i24b4518hcd926fl6x6fh5hd7b9wlxwc5dn21v"))))
206 (build-system haskell-build-system)
207 (properties '((upstream-name . "cryptohash-md5")))
208 (native-inputs (list ghc-base16-bytestring ghc-puremd5 ghc-tasty
209 ghc-tasty-quickcheck ghc-tasty-hunit))
210 (arguments
211 `(#:cabal-revision ("6"
212 "0m7f9mgw4w9vcch37ja9zgbn0knq8rjppqr9x2ylkcdxfdnmhhif")))
213 (home-page "https://github.com/haskell-hvr/cryptohash-md5")
214 (synopsis "MD5 implementation for Haskell")
215 (description "This Haskell package provides implementation of MD5.")
216 (license license:bsd-3)))
217
218(define-public ghc-cryptohash-sha1
219 (package
220 (name "ghc-cryptohash-sha1")
221 (version "0.11.101.0")
222 (source
223 (origin
224 (method url-fetch)
225 (uri (hackage-uri "cryptohash-sha1" version))
226 (sha256
227 (base32 "0h9jl9v38gj0vnscqx7xdklk634p05fa6z2pcvknisq2mnbjq154"))))
228 (build-system haskell-build-system)
229 (properties '((upstream-name . "cryptohash-sha1")))
230 (native-inputs (list ghc-base16-bytestring ghc-sha ghc-tasty
231 ghc-tasty-quickcheck ghc-tasty-hunit))
232 (arguments
233 `(#:cabal-revision ("6"
234 "1cxdw2y10z4v0mz91wki7f233jziipx85j4qy5msig4nv3djkprb")))
235 (home-page "https://github.com/haskell-hvr/cryptohash-sha1")
236 (synopsis "SHA-1 implementation for Haskell")
237 (description
238 "This Haskell package provides an incremental and one-pass,
239pure API to the @uref{https://en.wikipedia.org/wiki/SHA-1, SHA-1 hash algorithm},
240including @uref{https://en.wikipedia.org/wiki/HMAC, HMAC support}, with
241performance close to the fastest implementations available in other languages.
242
243The implementation is made in C with a haskell FFI wrapper that hides
244the C implementation.")
245 (license license:bsd-3)))
246
247(define-public ghc-cryptohash-sha256
248 (package
249 (name "ghc-cryptohash-sha256")
250 (version "0.11.102.1")
251 (source
252 (origin
253 (method url-fetch)
254 (uri (hackage-uri "cryptohash-sha256" version))
255 (sha256
256 (base32 "1xkb7iqplbw4fy1122p79xf1zcb7k44rl0wmfj1q06l7cdqxr9vk"))))
257 (build-system haskell-build-system)
258 (properties '((upstream-name . "cryptohash-sha256")))
259 (native-inputs (list ghc-base16-bytestring ghc-sha ghc-tasty
260 ghc-tasty-quickcheck ghc-tasty-hunit))
261 (arguments
262 `(#:cabal-revision ("6"
263 "01s12sl5mxvraj5fj3cs0pkb03pm8xpjz13y09dpl7i6rv6f578f")))
264 (home-page "https://github.com/haskell-hvr/cryptohash-sha256")
265 (synopsis "SHA-256 implementation for Haskell")
266 (description
267 "This Haskell package provides an incremental and
268one-pass, pure API to the @uref{https://en.wikipedia.org/wiki/SHA-2,
269SHA-256 cryptographic hash algorithm}, with performance close to the
270fastest implementations available in other languages.
271
272The implementation is made in C with a haskell FFI wrapper that hides
273the C implementation.")
274 (license license:bsd-3)))
275
276(define-public ghc-cryptonite
277 (package
278 (name "ghc-cryptonite")
279 (version "0.30")
280 (source
281 (origin
282 (method url-fetch)
283 (uri (hackage-uri "cryptonite" version))
284 (sha256
285 (base32 "07bb97iszhnrfddh5ql6p3dqd0c13xycjw5n2kljw7d0ia59q2an"))))
286 (build-system haskell-build-system)
287 (properties '((upstream-name . "cryptonite")))
288 (inputs (list ghc-memory ghc-basement))
289 (native-inputs (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit
290 ghc-tasty-kat))
291 (home-page "https://github.com/haskell-crypto/cryptonite")
292 (synopsis "Cryptography primitives")
293 (description
294 "This package is a repository of cryptographic primitives for Haskell.
295It supports a wide range of symmetric ciphers, cryptographic hash functions,
296public key algorithms, key derivation numbers, cryptographic random number
297generators, and more.")
298 (license license:bsd-3)))
299
300(define-public ghc-curve25519
301 (package
302 (name "ghc-curve25519")
303 (version "0.2.8.1")
304 (source
305 (origin
306 (method url-fetch)
307 (uri (hackage-uri "curve25519" version))
308 (sha256
309 (base32 "0p2rxad477cxbpxryvp78v8nrrf5gm35106jbqrj5cjgksappkdj"))))
310 (build-system haskell-build-system)
311 (native-inputs
312 (list ghc-hunit
313 ghc-quickcheck
314 ghc-tagged
315 ghc-test-framework
316 ghc-test-framework-hunit
317 ghc-test-framework-quickcheck2))
318 (inputs
319 (list ghc-crypto-api))
320 (properties '((upstream-name . "curve25519")))
321 (home-page "https://github.com/acw/curve25519")
322 (synopsis "Fast implementations of the curve25519 elliptic curve primitives")
323 (description
324 "This module provides Haskell bindings and extensions to the curve25519-donna
325codebase. It's a pretty straightforward implementation of the basic
326cryptographic routines you'd want from a project that uses curve25519: key
327generation, and key agreement. For further functionality, you'll want to look
328elsewhere.")
329 (license license:bsd-3)))
330
331(define-public ghc-digest
332 (package
333 (name "ghc-digest")
334 (version "0.0.2.1")
335 (source
336 (origin
337 (method url-fetch)
338 (uri (hackage-uri "digest" version))
339 (sha256
340 (base32 "163418p50bqdxn8ajzj6x3455xbch9jq1w6psbkdz5qzw017py6b"))))
341 (build-system haskell-build-system)
342 (properties '((upstream-name . "digest")))
343 (arguments
344 `(#:extra-directories ("zlib")))
345 (inputs (list zlib))
346 (native-inputs (list pkg-config))
347 (home-page "http://hackage.haskell.org/package/digest")
348 (synopsis "Various cryptographic hashes for bytestrings")
349 (description
350 "This package provides efficient cryptographic hash implementations for
351strict and lazy bytestrings. For now, CRC32 and Adler32 are supported; they
352are implemented as FFI bindings to efficient code from zlib.")
353 (license license:bsd-3)))
354
355(define-public ghc-entropy
356 (package
357 (name "ghc-entropy")
358 (version "0.4.1.11")
359 (source
360 (origin
361 (method url-fetch)
362 (uri (hackage-uri "entropy" version))
363 (sha256
364 (base32 "1slj5n783k2amsx2hqs5qwvcw4rgfhdhgmiyg7cii0wg4w0mmpgm"))))
365 (build-system haskell-build-system)
366 (properties '((upstream-name . "entropy")))
367 (home-page "https://github.com/TomMD/entropy")
368 (synopsis "Provides platform independent entropy source for Haskell")
369 (description "This Haskell package provides a platform independent method
370to obtain cryptographically strong entropy.")
371 (license license:bsd-3)))
372
373(define-public ghc-pem
374 (package
375 (name "ghc-pem")
376 (version "0.2.4")
377 (source (origin
378 (method url-fetch)
379 (uri (hackage-uri "pem" version))
380 (sha256
381 (base32
382 "1m7qjsxrd8m88cvkqmr8kscril500j2a9y0iynvksjyjkhdlq33p"))))
383 (build-system haskell-build-system)
384 (properties '((upstream-name . "pem")))
385 (inputs
386 (list ghc-basement ghc-memory))
387 (native-inputs
388 (list ghc-test-framework ghc-test-framework-quickcheck2
389 ghc-test-framework-hunit ghc-hunit ghc-quickcheck))
390 (home-page "https://github.com/vincenthz/hs-pem")
391 (synopsis "Privacy Enhanced Mail (PEM) format reader and writer")
392 (description
393 "This library provides readers and writers for the @dfn{Privacy Enhanced
394Mail} (PEM) format.")
395 (license license:bsd-3)))
396
397(define-public ghc-puremd5
398 (package
399 (name "ghc-puremd5")
400 (version "2.1.4")
401 (source
402 (origin
403 (method url-fetch)
404 (uri (hackage-uri "pureMD5" version))
405 (sha256
406 (base32
407 "0qwkvxwi9wh6knn69rg2hvc8ngmv1if77kmpcnp0xqr0l30fwavq"))))
408 (build-system haskell-build-system)
409 (properties '((upstream-name . "pureMD5")))
410 (inputs (list ghc-cereal ghc-crypto-api ghc-tagged))
411 (native-inputs (list ghc-crypto-api-tests ghc-quickcheck
412 ghc-test-framework ghc-test-framework-quickcheck2
413 ghc-pretty-hex))
414 (home-page "https://github.com/TomMD/pureMD5")
415 (synopsis "Haskell implementation of the MD5 hash algorithm")
416 (description "This package provides a Haskell-only implementation of
417the MD5 digest (hash) algorithm. This now supports the @code{crypto-api} class
418interface.")
419 (license license:bsd-3)))
420
421(define-public ghc-rsa
422 (package
423 (name "ghc-rsa")
424 (version "2.4.1")
425 (source
426 (origin
427 (method url-fetch)
428 (uri (hackage-uri "RSA" version))
429 (sha256
430 (base32 "0hchsqrxpfw7mqrqwscfy8ig1w2di6w3nxpzi873w0gibv2diibj"))))
431 (build-system haskell-build-system)
432 (properties '((upstream-name . "RSA")))
433 (inputs (list ghc-crypto-api ghc-crypto-pubkey-types ghc-sha))
434 (native-inputs (list ghc-quickcheck ghc-tagged ghc-test-framework
435 ghc-test-framework-quickcheck2))
436 (arguments
437 `(#:cabal-revision ("2"
438 "090yzm99fmh7c6z4m9hbkasqhc3xlw104g2b6wnk77n1abd13ryj")))
439 (home-page "http://hackage.haskell.org/package/RSA")
440 (synopsis
441 "Implementation of RSA, using the padding schemes of PKCS#1 v2.1.")
442 (description
443 "This library implements the RSA encryption and signature algorithms for
444arbitrarily-sized @code{ByteStrings}. While the implementations work, they are
445not necessarily the fastest ones on the planet. Particularly key generation.
446The algorithms included are based of RFC 3447, or the Public-Key Cryptography
447Standard for RSA, version 2.1 (a.k.a, PKCS#1 v2.1).")
448 (license license:bsd-3)))
449
450(define-public ghc-sha
451 (package
452 (name "ghc-sha")
453 (version "1.6.4.4")
454 (source (origin
455 (method url-fetch)
456 (uri (hackage-uri "SHA" version))
457 (sha256
458 (base32
459 "0i4b2wjisivdy72synal711ywhx05mfqfba5n65rk8qidggm1nbb"))))
460 (build-system haskell-build-system)
461 (properties '((upstream-name . "SHA")))
462 (native-inputs
463 (list ghc-quickcheck ghc-test-framework
464 ghc-test-framework-quickcheck2))
465 (home-page "https://hackage.haskell.org/package/SHA")
466 (synopsis "SHA suite of message digest functions")
467 (description
468 "This library implements the SHA suite of message digest functions,
469according to NIST FIPS 180-2 (with the SHA-224 addendum), as well as the
470SHA-based HMAC routines. The functions have been tested against most of the
471NIST and RFC test vectors for the various functions. While some attention has
472been paid to performance, these do not presently reach the speed of well-tuned
473libraries, like OpenSSL.")
474 (license license:bsd-3)))
475
476(define-public ghc-x509
477 (package
478 (name "ghc-x509")
479 (version "1.7.7")
480 (source (origin
481 (method url-fetch)
482 (uri (hackage-uri "x509" version))
483 (sha256
484 (base32
485 "1zk8lll1hmzl5xvrd16dhyz25151y59xhsqp2mm1wgymwl7r5ijr"))))
486 (build-system haskell-build-system)
487 (properties '((upstream-name . "x509")))
488 (inputs (list ghc-memory
489 ghc-hourglass
490 ghc-pem
491 ghc-asn1-types
492 ghc-asn1-encoding
493 ghc-asn1-parse
494 ghc-cryptonite))
495 (native-inputs (list ghc-tasty ghc-tasty-quickcheck))
496 (home-page "http://github.com/vincenthz/hs-certificate")
497 (synopsis "X509 reader and writer")
498 (description
499 "This library provides functions to read and write X509 certificates.")
500 (license license:bsd-3)))
501
502(define-public ghc-x509-store
503 (package
504 (name "ghc-x509-store")
505 (version "1.6.9")
506 (source (origin
507 (method url-fetch)
508 (uri (hackage-uri "x509-store" version))
509 (sha256
510 (base32
511 "1nn8ql7vkp4qgf2msm600sr6ranpsajbhq0sc4c0l6pk1i9174n5"))))
512 (build-system haskell-build-system)
513 (properties '((upstream-name . "x509-store")))
514 (inputs (list ghc-pem ghc-asn1-types ghc-asn1-encoding ghc-cryptonite
515 ghc-x509))
516 (native-inputs (list ghc-tasty ghc-tasty-hunit))
517 (home-page "http://github.com/vincenthz/hs-certificate")
518 (synopsis "X.509 collection accessing and storing methods")
519 (description
520 "This package provides functions for accessing and storing X.509
521collections, certificates, revocation lists, and exception lists.")
522 (license license:bsd-3)))
523
524(define-public ghc-x509-validation
525 (package
526 (name "ghc-x509-validation")
527 (version "1.6.12")
528 (source (origin
529 (method url-fetch)
530 (uri (hackage-uri "x509-validation" version))
531 (sha256
532 (base32
533 "1j7is28ljz4yxwxz5ax3x7ykgwkr38dx46bw7vgj4arkk7hl93hd"))))
534 (build-system haskell-build-system)
535 (properties '((upstream-name . "x509-validation")))
536 (inputs (list ghc-memory
537 ghc-hourglass
538 ghc-data-default-class
539 ghc-pem
540 ghc-asn1-types
541 ghc-asn1-encoding
542 ghc-x509
543 ghc-x509-store
544 ghc-cryptonite))
545 (native-inputs (list ghc-tasty ghc-tasty-hunit))
546 (home-page "http://github.com/vincenthz/hs-certificate")
547 (synopsis "X.509 certificate and revocation list validation")
548 (description
549 "This package provides functions for X.509 certificate and revocation
550list validation.")
551 (license license:bsd-3)))
552
553(define-public ghc-x509-system
554 (package
555 (name "ghc-x509-system")
556 (version "1.6.7")
557 (source (origin
558 (method url-fetch)
559 (uri (hackage-uri "x509-system" version))
560 (sha256
561 (base32
562 "049bdaxrih49nkhkyl2342qnbx2f0q99z8rld648bz1kkgyizz38"))))
563 (build-system haskell-build-system)
564 (properties '((upstream-name . "x509-system")))
565 (inputs (list ghc-pem ghc-x509 ghc-x509-store))
566 (home-page "http://github.com/vincenthz/hs-certificate")
567 (synopsis "Handle system X.509 accessors and storage")
568 (description
569 "This package provides a library to handle system accessors and storage
570for X.509 certificates.")
571 (license license:bsd-3)))
572
573(define-public ghc-crypto-cipher-types
574 (package
575 (name "ghc-crypto-cipher-types")
576 (version "0.0.9")
577 (source
578 (origin
579 (method url-fetch)
580 (uri (hackage-uri "crypto-cipher-types" version))
581 (sha256
582 (base32
583 "03qa1i1kj07pfrxsi7fiaqnnd0vi94jd4jfswbmnm4gp1nvzcwr0"))))
584 (build-system haskell-build-system)
585 (properties '((upstream-name . "crypto-cipher-types")))
586 (inputs (list ghc-byteable ghc-securemem))
587 (home-page "https://github.com/vincenthz/hs-crypto-cipher")
588 (synopsis "Generic cryptography cipher types for Haskell")
589 (description "This Haskell package provides basic typeclasses and types
590for symmetric ciphers.")
591 (license license:bsd-3)))
592
593(define-public ghc-cipher-aes
594 (package
595 (name "ghc-cipher-aes")
596 (version "0.2.11")
597 (source
598 (origin
599 (method url-fetch)
600 (uri (hackage-uri "cipher-aes" version))
601 (sha256
602 (base32
603 "05ahz6kjq0fl1w66gpiqy0vndli5yx1pbsbw9ni3viwqas4p3cfk"))))
604 (build-system haskell-build-system)
605 (properties '((upstream-name . "cipher-aes")))
606 (inputs (list ghc-byteable ghc-securemem ghc-crypto-cipher-types))
607 (native-inputs (list ghc-quickcheck ghc-test-framework
608 ghc-test-framework-quickcheck2
609 ghc-crypto-cipher-tests))
610 (home-page "https://github.com/vincenthz/hs-cipher-aes")
611 (synopsis "AES cipher implementation with advanced mode of operations for
612Haskell")
613 (description "This Haskell package provides AES cipher implementation.
614
615The modes of operations available are ECB (Electronic code book), CBC (Cipher
616block chaining), CTR (Counter), XTS (XEX with ciphertext stealing),
617GCM (Galois Counter Mode).
618
619The AES implementation uses AES-NI when available (on x86 and x86-64
620architecture), but fallback gracefully to a software C implementation.
621
622The software implementation uses S-Boxes, which might suffer for cache timing
623issues. However do notes that most other known software implementations,
624including very popular one (openssl, gnutls) also uses similar
625implementation. If it matters for your case, you should make sure you have
626AES-NI available, or you'll need to use a different implementation.")
627 (license license:bsd-3)))
628
629(define-public ghc-crypto-pubkey-types
630 (package
631 (name "ghc-crypto-pubkey-types")
632 (version "0.4.3")
633 (source
634 (origin
635 (method url-fetch)
636 (uri (hackage-uri "crypto-pubkey-types" version))
637 (sha256
638 (base32 "0q0wlzjmpx536h1zcdzrpxjkvqw8abj8z0ci38138kpch4igbnby"))))
639 (build-system haskell-build-system)
640 (properties '((upstream-name . "crypto-pubkey-types")))
641 (inputs (list ghc-asn1-types ghc-asn1-encoding))
642 (home-page "http://github.com/vincenthz/hs-crypto-pubkey-types")
643 (synopsis "Generic cryptography Public keys algorithm types")
644 (description "Generic cryptography public keys algorithm types.")
645 (license license:bsd-3)))
646
647(define-public ghc-crypton
648 (package
649 (name "ghc-crypton")
650 (version "1.0.4")
651 (source
652 (origin
653 (method url-fetch)
654 (uri (hackage-uri "crypton" version))
655 (sha256
656 (base32 "06h1qjvqd8gmiyzvh31sc061vcgns101l0774c44a8k44015925l"))))
657 (build-system haskell-build-system)
658 (properties '((upstream-name . "crypton")))
659 (inputs (list ghc-memory ghc-basement))
660 (native-inputs (list ghc-tasty ghc-tasty-quickcheck ghc-tasty-hunit
661 ghc-tasty-kat))
662 (home-page "https://github.com/kazu-yamamoto/crypton")
663 (synopsis "Cryptography Primitives sink")
664 (description
665 "This package provides a repository of cryptographic primitives.
666
667@itemize @bullet
668@item Symmetric ciphers: AES, DES, 3DES, CAST5, Blowfish, Twofish, Camellia,
669 RC4, Salsa, XSalsa, ChaCha.
670@item Hash: SHA1, SHA2, SHA3, SHAKE, MD2, MD4, MD5, Keccak, Skein, Ripemd,
671 Tiger, Whirlpool, Blake2.
672@item MAC: HMAC, KMAC, Poly1305
673@item Asymmetric crypto: DSA, RSA, DH, ECDH, ECDSA, ECC, Curve25519, Curve448,
674 Ed25519, Ed448
675@item Key Derivation Function: PBKDF2, Scrypt, HKDF, Argon2, BCrypt,
676 BCryptPBKDF
677@item Cryptographic Random generation: System Entropy, Deterministic Random
678 Generator
679@item Data related: Anti-Forensic Information Splitter (AFIS)
680@end itemize")
681 (license license:bsd-3)))
682
683(define-public ghc-crypton-x509
684 (package
685 (name "ghc-crypton-x509")
686 (version "1.7.7")
687 (source
688 (origin
689 (method url-fetch)
690 (uri (hackage-uri "crypton-x509" version))
691 (sha256
692 (base32 "10pkva9wvm6ih48bprxlnyhnn3nr6xq9dhkrk4hfxpsaij6f9v7g"))))
693 (build-system haskell-build-system)
694 (properties '((upstream-name . "crypton-x509")))
695 (inputs (list ghc-memory
696 ghc-hourglass
697 ghc-pem
698 ghc-asn1-types
699 ghc-asn1-encoding
700 ghc-asn1-parse
701 ghc-crypton))
702 (native-inputs (list ghc-tasty ghc-tasty-quickcheck))
703 (home-page "https://github.com/kazu-yamamoto/crypton-certificate")
704 (synopsis "X509 reader and writer")
705 (description "This package provides generic X509 support for Haskell.")
706 (license license:bsd-3)))
707
708(define-public ghc-crypton-x509-store
709 (package
710 (name "ghc-crypton-x509-store")
711 (version "1.6.11")
712 (source
713 (origin
714 (method url-fetch)
715 (uri (hackage-uri "crypton-x509-store" version))
716 (sha256
717 (base32 "07vq7f883cm5krqz2kc0qkh9ks54jknrwdqvfqsk91s12b693a83"))))
718 (build-system haskell-build-system)
719 (properties '((upstream-name . "crypton-x509-store")))
720 (inputs (list ghc-pem ghc-asn1-types ghc-asn1-encoding ghc-crypton
721 ghc-crypton-x509))
722 (native-inputs (list ghc-tasty ghc-tasty-hunit))
723 (home-page "https://github.com/kazu-yamamoto/crypton-certificate")
724 (synopsis "X.509 collection accessing and storing methods")
725 (description
726 "This package provides methods for accessing and storing X.509
727collections of certificates, certificate revocation lists, and exception
728lists.")
729 (license license:bsd-3)))
730
731(define-public ghc-crypton-x509-system
732 (package
733 (name "ghc-crypton-x509-system")
734 (version "1.6.7")
735 (source
736 (origin
737 (method url-fetch)
738 (uri (hackage-uri "crypton-x509-system" version))
739 (sha256
740 (base32 "1jilnr9715njlx1hqvg5lrsrwk12r04maypmh18di0sybwg2cdm4"))))
741 (build-system haskell-build-system)
742 (properties '((upstream-name . "crypton-x509-system")))
743 (inputs (list ghc-pem ghc-crypton-x509 ghc-crypton-x509-store))
744 (home-page "https://github.com/kazu-yamamoto/crypton-certificate")
745 (synopsis "Handle per-operating-system X.509 accessors and storage")
746 (description
747 "This package provides tools for operating system dependent X.509 stores,
748storage methods, and accessors.")
749 (license license:bsd-3)))
750
751(define-public ghc-crypton-x509-validation
752 (package
753 (name "ghc-crypton-x509-validation")
754 (version "1.6.14")
755 (source
756 (origin
757 (method url-fetch)
758 (uri (hackage-uri "crypton-x509-validation" version))
759 (sha256
760 (base32 "07b09kgrd3m5ahxpj458r5ycd30bz8ldwjwf19mdcnfv4x0kj3pd"))))
761 (build-system haskell-build-system)
762 (properties '((upstream-name . "crypton-x509-validation")))
763 (inputs (list ghc-memory
764 ghc-hourglass
765 ghc-data-default
766 ghc-pem
767 ghc-asn1-types
768 ghc-asn1-encoding
769 ghc-crypton-x509
770 ghc-crypton-x509-store
771 ghc-crypton
772 ghc-iproute))
773 (native-inputs (list ghc-tasty ghc-tasty-hunit))
774 (home-page "https://github.com/kazu-yamamoto/crypton-certificate")
775 (synopsis "X.509 Certificate and CRL validation")
776 (description "This package provides Haskell tools for X.509 certificate
777and @dfn{Certificates revocation list} (CRL) validation.")
778 (license license:bsd-3)))
779
780(define-public ghc-crypton-socks
781 (package
782 (name "ghc-crypton-socks")
783 (version "0.6.2")
784 (source
785 (origin
786 (method url-fetch)
787 (uri (hackage-uri "crypton-socks" version))
788 (sha256
789 (base32 "0fwzlvndyxjwhxambxdjzzm63yvb6jzsg53dkv3i6x17biz0hdm8"))))
790 (build-system haskell-build-system)
791 (properties '((upstream-name . "crypton-socks")))
792 (inputs (list ghc-cereal ghc-network ghc-network-bsd))
793 (home-page "http://github.com/mpilgrem/crypton-socks")
794 (synopsis "SOCKS Protocol Version 5")
795 (description
796 "This package provides a library implementing SOCKS Protocol Version 5.")
797 (license license:bsd-3)))
798
799(define-public ghc-crypto-token
800 (package
801 (name "ghc-crypto-token")
802 (version "0.1.2")
803 (source
804 (origin
805 (method url-fetch)
806 (uri (hackage-uri "crypto-token" version))
807 (sha256
808 (base32 "18xphlvn6wzyi6lqrvm5vic97pkcbiph1938p5l1mb22rj5215zm"))))
809 (build-system haskell-build-system)
810 (properties '((upstream-name . "crypto-token")))
811 (inputs (list ghc-crypton ghc-memory ghc-network-byte-order))
812 (native-inputs (list ghc-hspec hspec-discover))
813 (home-page "http://hackage.haskell.org/package/crypto-token")
814 (synopsis "crypto tokens")
815 (description "Encrypted tokens/tickets to keep state in the client side.")
816 (license license:bsd-3)))
817
818(define-public ghc-ed25519
819 (package
820 (name "ghc-ed25519")
821 (version "0.0.5.0")
822 (source
823 (origin
824 (method url-fetch)
825 (uri (hackage-uri "ed25519" version))
826 (sha256
827 (base32 "0v8msqvgzimhs7p5ri25hrb1ni2wvisl5rmdxy89fc59py79b9fq"))))
828 (build-system haskell-build-system)
829 (properties '((upstream-name . "ed25519")))
830 (native-inputs (list ghc-quickcheck ghc-doctest))
831 (arguments
832 `(#:cabal-revision ("9"
833 "0y5vfdcys18waa5k5zxiq9n8jq0l05j76riml23i0gxmwgdhsmgi")
834 ;; the tests don't work with current versions of the test frameworks
835 #:tests? #f))
836 (home-page "https://github.com/thoughtpolice/hs-ed25519/")
837 (synopsis "Ed25519 cryptographic signatures")
838 (description
839 "This package provides a simple, fast, self-contained
840copy of the Ed25519 public-key signature system with a clean interface.
841It also includes support for detached signatures, and thorough
842documentation on the design and implementation, including usage
843guidelines.")
844 (license license:expat)))
845
846(define-public ghc-tls
847 (package
848 (name "ghc-tls")
849 (version "2.1.8")
850 (source (origin
851 (method url-fetch)
852 (uri (hackage-uri "tls" version))
853 (sha256
854 (base32
855 "1csdy3426lva1a5f7gh9qm96vzfraqj91jbxlm79wbf1jsdzfhsq"))))
856 (build-system haskell-build-system)
857 (properties '((upstream-name . "tls")))
858 (inputs (list ghc-asn1-types
859 ghc-asn1-encoding
860 ghc-base16-bytestring
861 ghc-cereal
862 ghc-crypton
863 ghc-crypton-x509
864 ghc-crypton-x509-store
865 ghc-crypton-x509-validation
866 ghc-data-default
867 ghc-memory
868 ghc-network
869 ghc-serialise
870 ghc-transformers
871 ghc-unix-time
872 ghc-zlib))
873 (native-inputs (list ghc-quickcheck
874 ghc-asn1-types
875 ghc-async
876 ghc-crypton
877 ghc-crypton-x509
878 ghc-crypton-x509-validation
879 ghc-hourglass
880 ghc-hspec
881 ghc-serialise
882 hspec-discover))
883 (home-page "http://github.com/haskell-tls/hs-tls")
884 (synopsis "TLS/SSL protocol native implementation (Server and Client)")
885 (description
886 "Native Haskell TLS and SSL protocol implementation for server and client.
887This provides a high-level implementation of a sensitive security protocol,
888eliminating a common set of security issues through the use of the advanced
889type system, high level constructions and common Haskell features. Currently
890implement the SSL3.0, TLS1.0, TLS1.1 and TLS1.2 protocol, and support RSA and
891Ephemeral (Elliptic curve and regular) Diffie Hellman key exchanges, and many
892extensions.")
893 (license license:bsd-3)))
894
895(define-public ghc-hsopenssl
896 (package
897 (name "ghc-hsopenssl")
898 (version "0.11.7.11")
899 (source
900 (origin
901 (method url-fetch)
902 (uri (hackage-uri "HsOpenSSL" version))
903 (sha256
904 (base32 "1fnlz44s5cvg3q7mc4cfyydhlkmpb1zlwvpsbrahhnmgl9llrgkq"))))
905 (build-system haskell-build-system)
906 (properties '((upstream-name . "HsOpenSSL")))
907 (arguments
908 (list #:extra-directories (list "openssl")
909 #:configure-flags
910 #~(list "--ghc-options=-optc=-Wno-incompatible-pointer-types")))
911 (inputs (list ghc-network openssl))
912 (home-page "https://github.com/haskell-cryptography/HsOpenSSL")
913 (synopsis "Partial OpenSSL binding for Haskell")
914 (description
915 "HsOpenSSL is an OpenSSL binding for Haskell. It can
916generate RSA and DSA keys, read and write PEM files, generate message
917digests, sign and verify messages, encrypt and decrypt messages. It has
918also some capabilities of creating SSL clients and servers. This
919package is in production use by a number of Haskell based systems and
920stable. You may also be interested in the tls package,
921@uref{http://hackage.haskell.org/package/tls}, which is a pure Haskell
922implementation of SSL.")
923 (license license:public-domain)))
924
925(define-public ghc-hsopenssl-x509-system
926 (package
927 (name "ghc-hsopenssl-x509-system")
928 (version "0.1.0.4")
929 (source
930 (origin
931 (method url-fetch)
932 (uri (hackage-uri "HsOpenSSL-x509-system" version))
933 (sha256
934 (base32 "15mp70bqg1lzp971bzp6wym3bwzvxb76hzbgckygbfa722xyymhr"))))
935 (build-system haskell-build-system)
936 (inputs
937 (list ghc-hsopenssl))
938 (properties '((upstream-name . "HsOpenSSL-x509-system")))
939 (home-page "https://github.com/redneb/HsOpenSSL-x509-system")
940 (synopsis "Use the system's native CA certificate store with HsOpenSSL")
941 (description
942 "This package provides a cross-platform library that tries to find
943a (reasonable) CA certificate bundle that can be used with HsOpenSSL to verify
944the certificates of remote peers. It is for HsOpenSSL what x509-system is for
945the tls package, and borrows some ideas from x509-system.")
946 (license license:bsd-3)))
947
948(define-public ghc-openssl-streams
949 (package
950 (name "ghc-openssl-streams")
951 (version "1.2.3.0")
952 (source
953 (origin
954 (method url-fetch)
955 (uri (hackage-uri "openssl-streams" version))
956 (sha256
957 (base32 "10pnnpzgb5xr811kc9qdk7h2cgn6hk2yiyhnzz8f8p0fjzc0pwjm"))
958 (patches
959 (search-patches
960 "ghc-openssl-streams-regenerate-test-certificate.patch"))))
961 (build-system haskell-build-system)
962 (properties '((upstream-name . "openssl-streams")))
963 (inputs (list ghc-hsopenssl ghc-io-streams ghc-network))
964 (native-inputs (list ghc-hunit ghc-test-framework ghc-test-framework-hunit))
965 (arguments
966 `(#:cabal-revision ("3"
967 "1vizl9yajkbd59rrnfb38xwq7hfj36avbv6vwqnkhbvz3qaj3dwg")))
968 (home-page "https://hackage.haskell.org/package/openssl-streams")
969 (synopsis "OpenSSL network support for io-streams")
970 (description "This library contains io-streams routines for secure
971networking using OpenSSL (by way of HsOpenSSL).")
972 (license license:bsd-3)))
973
974(define-public ghc-cryptonite-conduit
975 (package
976 (name "ghc-cryptonite-conduit")
977 (version "0.2.2")
978 (source
979 (origin
980 (method url-fetch)
981 (uri (hackage-uri "cryptonite-conduit" version))
982 (sha256
983 (base32
984 "1bldcmda4xh52mw1wfrjljv8crhw3al7v7kv1j0vidvr7ymnjpbh"))))
985 (build-system haskell-build-system)
986 (properties '((upstream-name . "cryptonite-conduit")))
987 (inputs
988 (list ghc-conduit
989 ghc-conduit-extra
990 ghc-cryptonite
991 ghc-exceptions
992 ghc-memory
993 ghc-resourcet))
994 (native-inputs
995 (list ghc-conduit-combinators ghc-tasty ghc-tasty-hunit
996 ghc-tasty-quickcheck))
997 (arguments
998 `(#:cabal-revision
999 ("1" "1hh2nzfz4qpxgivfilgk4ll416lph8b2fdkzpzrmqfjglivydfmz")))
1000 (home-page "https://github.com/haskell-crypto/cryptonite-conduit")
1001 (synopsis "Cryptonite bridge for conduit")
1002 (description "This package provides conduit interfaces for some of
1003cryptonite's implementations of cryptographic primitives.")
1004 (license license:bsd-3)))