The bsaes is a portable pure-Go constant time AES implementation based on the code from BearSSL. On appropriate systems, with a sufficiently recent Go runtime, it will transparently call crypto/aes when NewCipher is invoked.

This package is a Go library for creating a unique hash value for arbitrary values in Go. This can be used to key values in a hash (for use in a map, set, etc.) that are complex. The most common use case is comparing two values without sending data across the network, caching values locally (de-dup), and so on.

Shapeshifter-Transports is a set of Pluggable Transports implementing the Go API from the Pluggable Transports 2.0 specification. Each transport implements a different method of shapeshifting network traffic. The goal is for application traffic to be sent over the network in a shapeshifted form that bypasses network filtering, allowing the application to work on networks where it would otherwise be blocked or heavily throttled.

This package provides a Go implementation of several rolling hashes.

This package implements file encryption according to the https://age-encryption.org/v1 specification. It features small explicit keys, no configuration options, and Unix-style composability.

ChaCha is a stream cipher family created by Daniel Bernstein. The most common ChaCha variant is ChaCha20 (20 rounds). ChaCha20 is standardized in RFC 7539.

ZCertificate parses X.509 certificates and runs @urlhttps://github.com/zmap/zlint,ZLint.

Package sshsig implements signing/verifying armored SSH signatures. It may be used to sign data and verify signatures using SSH private keys or SSH agent. It gives the same output as using ssh-keygen, eg when signing ssh-keygen -Y sign -f keyfile -n namespace data.

CIRCL (Cloudflare Interoperable, Reusable Cryptographic Library) is a collection of cryptographic primitives written in Go. The goal of this library is to be used as a tool for experimental deployment of cryptographic algorithms targeting Post-Quantum (PQ) and Elliptic Curve Cryptography (ECC).

Bigmod is a constant-time library for big integers modulo a prime, usable for cryptographic applications. Exported from crypto/internal/bigmod, the backend of crypto/rsa and crypto/ecdsa.

This package provides a drop-in replacement of the Golang standard encoding/base64 library.

This package provides an Ed25519 implementation with validation rules intended for consensus-critical contexts.

Package ssh wraps the crypto/ssh package with a higher-level API for building SSH servers. The goal of the API was to make it as simple as using net/http, so the API is very similar. It's alternative fork of https://github.com/gliderlabs/ssh.

Package ssh wraps the crypto/ssh package with a higher-level API for building SSH servers. The goal of the API was to make it as simple as using net/http, so the API is very similar.

This library is a JWT implementation that uses nkeys to digitally sign JWT tokens. Nkeys use Ed25519 to provide authentication of JWT claims.

pkcs8 implements functions to process private keys in PKCS#8 format, as defined in RFC 5208 and RFC 5958. It can handle both unencrypted PKCS#8 PrivateKeyInfo format and EncryptedPrivateKeyInfo format with PKCS#5 (v2.0) algorithms.

Package keccak implements the Keccak (SHA-3) hash algorithm. See http://keccak.noekeon.org.

Package pbkdf2 implements password-based key derivation using the PBKDF2 algorithm described in RFC 2898 and RFC 8018.

This package implements a functionality to convert keys between the PEM and JWK file formats.

The pgpmail package implements PGP encryption for e-mail messages.

Package crypt is a implementation of crypt(3) by golang, originated from https://code.google.com/p/go-crypt.

Package xxhash implements the 64-bit variant of xxHash (XXH64) as described at https://xxhash.com/.

Package imohash implements a fast, constant-time hash for files. It is based atop murmurhash3 and uses file size and sample data to construct the hash.

This package implements the edwards25519 elliptic curve in Go, exposing the necessary APIs to build a wide array of higher-level primitives.