This package implements a native XZ decompression in Golang.

This package defines basic interfaces to handle tar files. It is similar to fs.FS, but for tar files.

This package implements parallel gzip compression and decompression in Golang and is fully compatible with compress/gzip from the standard library. This is beneficial for large amounts of data, say more than 1MB at a time, as otherwise the internal gzip library will likely be faster.

Package archiver facilitates convenient, cross-platform, high-level archival and compression operations for a variety of formats and compression algorithms.

Features:

• stream-oriented APIs

• automatically identify archive and compression formats

• traverse directories, archive files, and any other file uniformly as io/fs file systems

• compress and decompress files

• create and extract archive files

• walk or traverse into archive files

• extract only specific files from archives

• insert (append) into .tar and .zip archives

• read from password-protected 7-Zip files

• numerous archive and compression formats supported

• extensible (add more formats just by registering them)

• cross-platform, static binary

• pure Golang (no cgo)

• multithreaded Gzip

• adjust compression levels

• automatically add compressed files to zip archives without re-compressing

• open password-protected rar archives

Supported compression formats:

• brotli (.br)

• bzip2 (.bz2)

• flate (.zip)

• gzip (.gz)

• lz4 (.lz4)

• lzip (.lz)

• snappy (.sz)

• xz (.xz)

• zlib (.zz)

• zstandard (.zst)

Supported archive formats:

• .zip

• .tar (including any compressed variants like .tar.gz)

• .rar (read-only)

• .7z (read-only)

This package provides an command line interface (CLI) tool.

lz4 provides a streaming interface to LZ4 data streams as well as low level compress and uncompress functions for LZ4 data blocks. The implementation is based on the reference C one. This package provides an additional command line interface tool to compress and decompress LZ4 files.

This package provides a library for reading RAR archives with Golang.

This package implements a functionality for pristinely disassembling a tar archive, and stashing needed raw bytes and offsets to reassemble a validating original archive.

compress provides various compression algorithms.

This package provides a Go wrapper to zstd C library.

This package provides a support of reading and writing of xz compressed streams. It includes also a gxz command for compressing and decompressing data. The package is completely written in Go and doesn't have any dependency on any C code.

This package implements a functionality for pristinely disassembling a tar archive, and stashing needed raw bytes and offsets to reassemble a validating original archive.

Fastzip is an opinionated Zip archiver and extractor with a focus on speed. Features:

• archiving and extraction of files and directories can only occur within a specified directory

• permissions, ownership (uid, gid on linux/unix) and modification times are preserved

• buffers used for copying files are recycled to reduce allocations

• files are archived and extracted concurrently

• by default, github.com/klauspost/compress/flate library is used for compression and decompression

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

Fast implementation of base58 encoding on Golang. A trivial big.Int encoding benchmark results in 6 times faster encoding and 8 times faster decoding.

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 provides an implementation of the PKCS#11 API. It wraps the library closely, but uses Go idiom where it makes sense. It has been tested with SoftHSM.

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.

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.

GoPtLib is a library for writing Tor pluggable transports in Go.

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.

Package blake256 implements BLAKE-256 and BLAKE-224 with SSE2, SSE4.1, and AVX acceleration and zero allocations.

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

This package provides a Go implementation of JSON Web Tokens and supports the parsing and verification as well as the generation and signing of JSON Web Tokens. The currently supported signing algorithms are HMAC SHA, RSA, RSA-PSS, and ECDSA, though hooks are present for adding your own.

This native Go library manages secrets via the freedesktop.org Secret Service DBus interface.