;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
-;;; Copyright © 2015, 2017, 2018 Ricardo Wurmus <rekado@elephly.net>
-;;; Copyright © 2016 ng0 <ng0@infotropique.org>
+;;; Copyright © 2015, 2017, 2018, 2019 Ricardo Wurmus <rekado@elephly.net>
+;;; Copyright © 2016 Nikita <nikita@n0.is>
;;; Copyright © 2017 rsiddharth <s@ricketyspace.net>
-;;; Copyright © 2017 Tobias Geerinckx-Rice <me@tobias.gr>
+;;; Copyright © 2017, 2019 Tobias Geerinckx-Rice <me@tobias.gr>
+;;; Copyright © 2020 Giacomo Leidi <goodoldpaul@autistici.org>
;;;
;;; This file is part of GNU Guix.
;;;
#:use-module (gnu packages compression)
#:use-module (gnu packages haskell)
#:use-module (gnu packages haskell-check)
+ #:use-module (gnu packages haskell-xyz)
+ #:use-module (gnu packages tls)
#:use-module (guix build-system haskell)
#:use-module (guix download)
#:use-module ((guix licenses) #:prefix license:)
(define-public ghc-asn1-types
(package
(name "ghc-asn1-types")
- (version "0.3.2")
+ (version "0.3.3")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
version ".tar.gz"))
(sha256
(base32
- "05vjchyqiy9n275cygffhn0ma7fz7jx52j0dcdm9qm8h9bziymqc"))))
+ "162lacdl9jr42pdhaj9hxqlba6hjxm6g866anna74q6v3cvw5ssp"))))
(build-system haskell-build-system)
(inputs
`(("ghc-memory" ,ghc-memory)
(define-public ghc-asn1-encoding
(package
(name "ghc-asn1-encoding")
- (version "0.9.5")
+ (version "0.9.6")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
version ".tar.gz"))
(sha256
(base32
- "0adgbamyq0mj1l1hdq4zyyllay714bac1wl0rih3fv1z6vykp1hy"))))
+ "02nsr30h5yic1mk7znf0q4z3n560ip017n60hg7ya25rsfmxxy6r"))))
(build-system haskell-build-system)
(inputs
`(("ghc-hourglass" ,ghc-hourglass)
- ("ghc-asn1-types" ,ghc-asn1-types)
- ("ghc-text" ,ghc-text)
- ("ghc-mtl" ,ghc-mtl)))
+ ("ghc-asn1-types" ,ghc-asn1-types)))
(native-inputs
`(("ghc-tasty" ,ghc-tasty)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
(define-public ghc-asn1-parse
(package
(name "ghc-asn1-parse")
- (version "0.9.4")
+ (version "0.9.5")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
version ".tar.gz"))
(sha256
(base32
- "025prsihk5g6rdv9xlfmj0zpa0wa3qjzj5i4ilzvg7f6f3sji8y6"))))
+ "17pk8y3nwv9b9i5j15qlmwi7fmq9ab2z4kfpjk2rvcrh9lsf27wg"))))
(build-system haskell-build-system)
(inputs
`(("ghc-asn1-types" ,ghc-asn1-types)
(define-public ghc-crypto-api
(package
(name "ghc-crypto-api")
- (version "0.13.2")
+ (version "0.13.3")
(source
(origin
(method url-fetch)
"crypto-api-" version ".tar.gz"))
(sha256
(base32
- "1vc27qcgbg7hf50rkqhlrs58zn1888ilh4b6wrrm07bnm48xacak"))))
+ "19bsmkqkpnvh01b77pmyarx00fic15j4hvg4pzscrj4prskrx2i9"))))
(build-system haskell-build-system)
(inputs `(("ghc-cereal" ,ghc-cereal)
("ghc-tagged" ,ghc-tagged)
(base32
"0w3j43jdrlj28jryp18hc6q84nkl2yf4vs1hhgrsk7gb9kfyqjpl"))))
(build-system haskell-build-system)
+ (outputs '("out" "static" "doc"))
(inputs `(("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
("ghc-crypto-api" ,ghc-crypto-api)
("ghc-cereal" ,ghc-cereal)
"1y8q7s2bn4gdknw1wjikdnar2b5pgz3nv3220lxrlgpsf23x82vi"))))
(build-system haskell-build-system)
(arguments
- `(#:tests? #f)) ; tests require old version of ghc-hunit (0.9)
+ `(#:cabal-revision
+ ("4" "0gzaibjkipijwj9m9l6wrhfk5s3kdvfbhdl7cl1373cjfs41v0m3")
+ #:tests? #f)) ; tests require old version of ghc-hunit (0.9)
(native-inputs `(("ghc-base16-bytestring" ,ghc-base16-bytestring)
("ghc-puremd5" ,ghc-puremd5)
("ghc-tasty" ,ghc-tasty)
"1aqdxdhxhl9jldh951djpwxx8z7gzaqspxl7iwpl84i5ahrsyy9w"))))
(build-system haskell-build-system)
(arguments
- `(#:tests? #f)) ; tests require old version of ghc-hunit (0.9)
+ `(#:cabal-revision
+ ("4" "0qb2wasfc4dpf6f9ahvhlv8njb3p3p9iwblg4032ssi95cg85718")
+ #:tests? #f)) ; tests require old version of ghc-hunit (0.9)
(native-inputs `(("ghc-base16-bytestring" ,ghc-base16-bytestring)
("ghc-sha" ,ghc-sha)
("ghc-tasty" ,ghc-tasty)
including @uref{https://en.wikipedia.org/wiki/HMAC, HMAC support}, with
performance close to the fastest implementations available in other languages.
+The implementation is made in C with a haskell FFI wrapper that hides
+the C implementation.")
+ (license license:bsd-3)))
+
+(define-public ghc-cryptohash-sha256
+ (package
+ (name "ghc-cryptohash-sha256")
+ (version "0.11.101.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "cryptohash-sha256-" version "/"
+ "cryptohash-sha256-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1p85vajcgw9hmq8zsz9krzx0vxh7aggwbg5w9ws8w97avcsn8xaj"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("3" "1arhz4y792kx439s2zv9x291gvvl2zxcfx9sq0nxsjlz7c3hpyp1")
+ #:tests? #f)) ; tests require old version of ghc-hunit (0.9)
+ (inputs
+ `(("ghc-base16-bytestring" ,ghc-base16-bytestring)))
+ (native-inputs
+ `(("ghc-sha" ,ghc-sha)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-hunit" ,ghc-hunit)))
+ (home-page "https://github.com/hvr/cryptohash-sha1")
+ (synopsis "SHA-256 implementation for Haskell")
+ (description "This Haskell package provides an incremental and
+one-pass, pure API to the @uref{https://en.wikipedia.org/wiki/SHA-2,
+SHA-256 cryptographic hash algorithm}, with performance close to the
+fastest implementations available in other languages.
+
The implementation is made in C with a haskell FFI wrapper that hides
the C implementation.")
(license license:bsd-3)))
(define-public ghc-cryptonite
(package
(name "ghc-cryptonite")
- (version "0.20")
+ (version "0.25")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
version ".tar.gz"))
(sha256
(base32
- "0m63np0affci7ba9mrkvw2flzxn0s2mk930xldc4dwijw32gl6r6"))))
+ "131wbbdr5yavs5k1ah9sz6fqx1ffyvaxf66pwjzsfc47mwc1mgl9"))))
(build-system haskell-build-system)
+ ;; FIXME: tests are broken.
+ ;; See https://github.com/haskell-crypto/cryptonite/issues/260
+ (arguments '(#:tests? #f))
+ (outputs '("out" "static" "doc"))
(inputs
- `(("ghc-memory" ,ghc-memory)
+ `(("ghc-basement" ,ghc-basement)
+ ("ghc-memory" ,ghc-memory)
("ghc-byteable" ,ghc-byteable)))
(native-inputs
`(("ghc-tasty" ,ghc-tasty)
(base32
"04gy2zp8yzvv7j9bdfvmfzcz3sqyqa6rwslqcn4vyair2vmif5v4"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:extra-directories ("zlib")))
(inputs
`(("zlib" ,zlib)))
(home-page
(define-public ghc-entropy
(package
(name "ghc-entropy")
- (version "0.3.8")
+ (version "0.4.1.5")
(source
(origin
(method url-fetch)
"entropy-" version "/"
"entropy-" version ".tar.gz"))
(sha256
- (base32
- "1l3lfigqvdlmxkz1wl7zdkmc0i2r5p6z4xzhiw8xdsbsw7aljfkl"))))
+ (base32 "0szf8hi1pi8g0kxnkcymh65gk1b0niyl1nnkckzdqyar87qal0jm"))))
(build-system haskell-build-system)
(home-page "https://github.com/TomMD/entropy")
(synopsis "Provides platform independent entropy source for Haskell")
(define-public ghc-pem
(package
(name "ghc-pem")
- (version "0.2.2")
+ (version "0.2.4")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"pem/pem-" version ".tar.gz"))
(sha256
(base32
- "162sk5sg22w21wqz5qv8kx6ibxp99v5p20g3nknhm1kddk3hha1p"))))
+ "1m7qjsxrd8m88cvkqmr8kscril500j2a9y0iynvksjyjkhdlq33p"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-mtl" ,ghc-mtl)
- ("ghc-base64-bytestring" ,ghc-base64-bytestring)))
+ `(("ghc-basement" ,ghc-basement)
+ ("ghc-memory" ,ghc-memory)))
(native-inputs
`(("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
(define-public ghc-sha
(package
(name "ghc-sha")
- (version "1.6.4.2")
+ (version "1.6.4.4")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"SHA/SHA-" version ".tar.gz"))
(sha256
(base32
- "134ajm87fm4lpsw86m9q8apv20dw4bpk46raa389zr6bcdpifw64"))))
+ "0i4b2wjisivdy72synal711ywhx05mfqfba5n65rk8qidggm1nbb"))))
(build-system haskell-build-system)
(native-inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
(define-public ghc-x509
(package
(name "ghc-x509")
- (version "1.6.4")
+ (version "1.7.5")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
"x509/x509-" version ".tar.gz"))
(sha256
(base32
- "0hixx76wpb4qxida017ka5zr6lrsycahrqyw8z90q9mxvndpy3my"))))
+ "1j67c35g8334jx7x32hh6awhr43dplp0qwal5gnlkmx09axzrc5i"))))
(build-system haskell-build-system)
(inputs
`(("ghc-memory" ,ghc-memory)
- ("ghc-mtl" ,ghc-mtl)
("ghc-hourglass" ,ghc-hourglass)
("ghc-pem" ,ghc-pem)
("ghc-asn1-types" ,ghc-asn1-types)
(define-public ghc-x509-store
(package
(name "ghc-x509-store")
- (version "1.6.2")
+ (version "1.6.7")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
version ".tar.gz"))
(sha256
(base32
- "0yw09nwkvr324qz4sc27c0p28bz2h6gns6lkaz9mz92mgqf2dza9"))))
+ "1y8yyr1i95jkllg8k0z54k5v4vachp848clc07m33xpxidn3b1lp"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-mtl" ,ghc-mtl)
- ("ghc-pem" ,ghc-pem)
+ `(("ghc-pem" ,ghc-pem)
("ghc-asn1-types" ,ghc-asn1-types)
("ghc-asn1-encoding" ,ghc-asn1-encoding)
("ghc-cryptonite" ,ghc-cryptonite)
("ghc-x509" ,ghc-x509)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
(home-page "https://github.com/vincenthz/hs-certificate")
(synopsis "X.509 collection accessing and storing methods")
(description
(define-public ghc-x509-validation
(package
(name "ghc-x509-validation")
- (version "1.6.5")
+ (version "1.6.11")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
version ".tar.gz"))
(sha256
(base32
- "190w1sr3w6w49v3yvqz4grb0v09ym4gll3n8bxwijvbvcybk3xyi"))))
+ "16yihzljql3z8w5rgdl95fv3hgk7yd86kbl9b3glllsark5j2hzr"))))
(build-system haskell-build-system)
(inputs
`(("ghc-memory" ,ghc-memory)
("ghc-byteable" ,ghc-byteable)
- ("ghc-mtl" ,ghc-mtl)
("ghc-hourglass" ,ghc-hourglass)
("ghc-data-default-class" ,ghc-data-default-class)
("ghc-pem" ,ghc-pem)
("ghc-x509" ,ghc-x509)
("ghc-x509-store" ,ghc-x509-store)
("ghc-cryptonite" ,ghc-cryptonite)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
(home-page "https://github.com/vincenthz/hs-certificate")
(synopsis "X.509 certificate and revocation list validation")
(description
(define-public ghc-x509-system
(package
(name "ghc-x509-system")
- (version "1.6.4")
+ (version "1.6.6")
(source (origin
(method url-fetch)
(uri (string-append "https://hackage.haskell.org/package/"
version ".tar.gz"))
(sha256
(base32
- "0k7zc0xp7r6kqmi39rpiicvq78xb0pr2cq6q5s3kmmsshllg13nr"))))
+ "06a4m9c7vlr9nhp9gmqbb46arf0yj1dkdm4nip03hzy67spdmp20"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-mtl" ,ghc-mtl)
- ("ghc-pem" ,ghc-pem)
+ `(("ghc-pem" ,ghc-pem)
("ghc-x509" ,ghc-x509)
("ghc-x509-store" ,ghc-x509-store)))
(home-page "https://github.com/vincenthz/hs-certificate")
"This package provides a library to handle system accessors and storage
for X.509 certificates.")
(license license:bsd-3)))
+
+(define-public ghc-crypto-cipher-types
+ (package
+ (name "ghc-crypto-cipher-types")
+ (version "0.0.9")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "crypto-cipher-types-" version "/"
+ "crypto-cipher-types-" version ".tar.gz"))
+ (sha256
+ (base32
+ "03qa1i1kj07pfrxsi7fiaqnnd0vi94jd4jfswbmnm4gp1nvzcwr0"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-byteable" ,ghc-byteable)
+ ("ghc-securemem" ,ghc-securemem)))
+ (home-page "https://github.com/vincenthz/hs-crypto-cipher")
+ (synopsis "Generic cryptography cipher types for Haskell")
+ (description "This Haskell package provides basic typeclasses and types
+for symmetric ciphers.")
+ (license license:bsd-3)))
+
+(define-public ghc-cipher-aes
+ (package
+ (name "ghc-cipher-aes")
+ (version "0.2.11")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "cipher-aes-" version "/"
+ "cipher-aes-" version ".tar.gz"))
+ (sha256
+ (base32
+ "05ahz6kjq0fl1w66gpiqy0vndli5yx1pbsbw9ni3viwqas4p3cfk"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-byteable" ,ghc-byteable)
+ ("ghc-securemem" ,ghc-securemem)
+ ("ghc-crypto-cipher-types" ,ghc-crypto-cipher-types)))
+ (native-inputs `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+ ("ghc-crypto-cipher-tests" ,ghc-crypto-cipher-tests)))
+ (home-page "https://github.com/vincenthz/hs-cipher-aes")
+ (synopsis "AES cipher implementation with advanced mode of operations for
+Haskell")
+ (description "This Haskell package provides AES cipher implementation.
+
+The modes of operations available are ECB (Electronic code book), CBC (Cipher
+block chaining), CTR (Counter), XTS (XEX with ciphertext stealing),
+GCM (Galois Counter Mode).
+
+The AES implementation uses AES-NI when available (on x86 and x86-64
+architecture), but fallback gracefully to a software C implementation.
+
+The software implementation uses S-Boxes, which might suffer for cache timing
+issues. However do notes that most other known software implementations,
+including very popular one (openssl, gnutls) also uses similar
+implementation. If it matters for your case, you should make sure you have
+AES-NI available, or you'll need to use a different implementation.")
+ (license license:bsd-3)))
+
+(define-public ghc-crypto-random
+ (package
+ (name "ghc-crypto-random")
+ (version "0.0.9")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "crypto-random-" version "/"
+ "crypto-random-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0139kbbb2h7vshf68y3fvjda29lhj7jjwl4vq78w4y8k8hc7l2hp"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-securemem" ,ghc-securemem)
+ ("ghc-vector" ,ghc-vector)))
+ (home-page "https://github.com/vincenthz/hs-crypto-random")
+ (synopsis "Simple cryptographic random related types for Haskell")
+ (description "Simple cryptographic random related types: a safe
+abstraction for CPRNGs.")
+ (license license:bsd-3)))
+
+(define-public ghc-cprng-aes
+ (package
+ (name "ghc-cprng-aes")
+ (version "0.6.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "cprng-aes-" version "/"
+ "cprng-aes-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1wr15kbmk1g3l8a75n0iwbzqg24ixv78slwzwb2q6rlcvq0jlnb4"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-byteable" ,ghc-byteable)
+ ("ghc-crypto-random" ,ghc-crypto-random)
+ ("ghc-cipher-aes" ,ghc-cipher-aes)))
+ (home-page "https://github.com/vincenthz/hs-cprng-aes")
+ (synopsis "Crypto Pseudo Random Number Generator using AES in counter mode
+in Haskell")
+ (description "Simple crypto pseudo-random-number-generator with really
+good randomness property.
+
+Using ent, a randomness property maker on one 1Mb sample:
+
+@itemize
+@item Entropy = 7.999837 bits per byte.
+@item Optimum compression would reduce the size of this 1048576 byte file by 0
+percent.
+@item Chi square distribution for 1048576 samples is 237.02.
+@item Arithmbetic mean value of data bytes is 127.3422 (127.5 = random).
+@item Monte Carlo value for Pi is 3.143589568 (error 0.06 percent).
+@end itemize
+
+Compared to urandom with the same sampling:
+
+@itemize
+@item Entropy = 7.999831 bits per byte.
+@item Optimum compression would reduce the size of this 1048576 byte file by 0
+percent.
+@item Chi square distribution for 1048576 samples is 246.63.
+@item Arithmetic mean value of data bytes is 127.6347 (127.5 = random).
+@item Monte Carlo value for Pi is 3.132465868 (error 0.29 percent).
+@end itemize")
+ (license license:bsd-3)))
+
+(define-public ghc-ed25519
+ (package
+ (name "ghc-ed25519")
+ (version "0.0.5.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://hackage.haskell.org/package/ed25519/ed25519-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0v8msqvgzimhs7p5ri25hrb1ni2wvisl5rmdxy89fc59py79b9fq"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:cabal-revision
+ ("2" "1cq6h3jqkb1kvd9fjfhsllg5gq78sdiyf2gy9862xhlbv6wil19f")
+ ;; We omit these test suites because they require old versions of
+ ;; packages and packages we do not have.
+ #:configure-flags
+ '("--flags=-test-hlint -test-doctests -test-properties")))
+ (home-page "http://thoughtpolice.github.com/hs-ed25519")
+ (synopsis "Ed25519 cryptographic signatures")
+ (description "This package provides a simple, fast, self-contained
+copy of the Ed25519 public-key signature system with a clean interface.
+It also includes support for detached signatures, and thorough
+documentation on the design and implementation, including usage
+guidelines.")
+ (license license:expat)))
+
+(define-public ghc-tls
+ (package
+ (name "ghc-tls")
+ (version "1.4.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "tls/tls-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1y083724mym28n6xfaz7pcc7zqxdhjpaxpbvzxfbs25qq2px3smv"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-cereal" ,ghc-cereal)
+ ("ghc-data-default-class" ,ghc-data-default-class)
+ ("ghc-memory" ,ghc-memory)
+ ("ghc-cryptonite" ,ghc-cryptonite)
+ ("ghc-asn1-types" ,ghc-asn1-types)
+ ("ghc-asn1-encoding" ,ghc-asn1-encoding)
+ ("ghc-x509" ,ghc-x509)
+ ("ghc-x509-store" ,ghc-x509-store)
+ ("ghc-x509-validation" ,ghc-x509-validation)
+ ("ghc-async" ,ghc-async)
+ ("ghc-network" ,ghc-network)
+ ("ghc-hourglass" ,ghc-hourglass)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/vincenthz/hs-tls")
+ (synopsis
+ "TLS/SSL protocol native implementation (Server and Client)")
+ (description
+ "Native Haskell TLS and SSL protocol implementation for server and client.
+This provides a high-level implementation of a sensitive security protocol,
+eliminating a common set of security issues through the use of the advanced
+type system, high level constructions and common Haskell features. Currently
+implement the SSL3.0, TLS1.0, TLS1.1 and TLS1.2 protocol, and support RSA and
+Ephemeral (Elliptic curve and regular) Diffie Hellman key exchanges, and many
+extensions.")
+ (license license:bsd-3)))
+
+(define-public ghc-hsopenssl
+ (package
+ (name "ghc-hsopenssl")
+ (version "0.11.4.17")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "HsOpenSSL/HsOpenSSL-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0qivl9clmybfglwxqp2sq308rv4ia4rhwshcsc8b029bvpp0mpsi"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:extra-directories ("openssl")))
+ (inputs
+ `(("ghc-network" ,ghc-network)
+ ("openssl" ,openssl)))
+ (home-page "https://github.com/vshabanov/HsOpenSSL")
+ (synopsis "Partial OpenSSL binding for Haskell")
+ (description "HsOpenSSL is an OpenSSL binding for Haskell. It can
+generate RSA and DSA keys, read and write PEM files, generate message
+digests, sign and verify messages, encrypt and decrypt messages. It has
+also some capabilities of creating SSL clients and servers. This
+package is in production use by a number of Haskell based systems and
+stable. You may also be interested in the tls package,
+@uref{http://hackage.haskell.org/package/tls}, which is a pure Haskell
+implementation of SSL.")
+ (license license:public-domain)))
+
+(define-public ghc-openssl-streams
+ (package
+ (name "ghc-openssl-streams")
+ (version "1.2.2.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "openssl-streams/openssl-streams-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0rplym6ayydkpr7x9mw3l13p0vzzfzzxw244d7sd3jcvaxpv0rmr"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hsopenssl" ,ghc-hsopenssl)
+ ("ghc-io-streams" ,ghc-io-streams)
+ ("ghc-network" ,ghc-network)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
+ (home-page "https://hackage.haskell.org/package/openssl-streams")
+ (synopsis "OpenSSL network support for io-streams")
+ (description "This library contains io-streams routines for secure
+networking using OpenSSL (by way of HsOpenSSL).")
+ (license license:bsd-3)))
+
+(define-public ghc-cryptonite-conduit
+ (package
+ (name "ghc-cryptonite-conduit")
+ (version "0.2.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://hackage.haskell.org/package/"
+ "cryptonite-conduit/cryptonite-conduit-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1bldcmda4xh52mw1wfrjljv8crhw3al7v7kv1j0vidvr7ymnjpbh"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-conduit" ,ghc-conduit)
+ ("ghc-conduit-extra" ,ghc-conduit-extra)
+ ("ghc-cryptonite" ,ghc-cryptonite)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-memory" ,ghc-memory)
+ ("ghc-resourcet" ,ghc-resourcet)))
+ (native-inputs
+ `(("ghc-conduit-combinators" ,ghc-conduit-combinators)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (arguments
+ `(#:cabal-revision
+ ("1" "1hh2nzfz4qpxgivfilgk4ll416lph8b2fdkzpzrmqfjglivydfmz")))
+ (home-page "https://github.com/haskell-crypto/cryptonite-conduit")
+ (synopsis "Cryptonite bridge for conduit")
+ (description "This package provides conduit interfaces for some of
+cryptonite's implementations of cryptographic primitives.")
+ (license license:bsd-3)))
HCoop / jackhill / guix / guix.git / blobdiff