This packages provides a seekable ZSTD compression format implemented in Golang. It is a random access reader (using uncompressed file offsets) for ZSTD-compressed streams. This can be used for creating transparent compression layers. Coupled with Content Defined Chunking (CDC) it can also be used as a robust de-duplication layer. It is an alternative fork of https://github.com/SaveTheRbtz/zstd-seekable-format-go.

This package is a brotli compressor and decompressor implemented in Go. It was translated from the reference implementation (https://github.com/google/brotli) with the c2go tool at https://github.com/andybalholm/c2go.

This package provides some Golang interfaces for handling RPM packages, such extracting RPM header and CPIO content.

Package rpmpack packs files to rpm files. It is designed to be simple to use and deploy, not requiring any filesystem access to create rpm files.

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.

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

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.

go-rpmutils is a Golang library for parsing RPM file archives. It's a slimmed version of go-rpmutils.

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.

This package provides an enhanced version of the compress/lzw library included in the stdlib, and supports GIF, TIFF and PDF.

Package xz implements XZ decompression natively in Go.

This package implements a seekable version of gzip-format compressed files, compliant with RFC 1952. This implementation allows seeking in the compressed file. In normal gzip files that can only be achieved by decompressing from the start and discarding all data until the selected offset. This gzip implementation works around this by creating a special metadata file that maps uncompressed blocks to compressed blocks allowing it to only read the compressed blocks required.

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 is an implementation of Roaring bitmaps as described at https://roaringbitmap.org/about/ in Go. Roaring bitmaps are fast compressed bitmap data structures (also called bitset). They are ideally suited to represent sets of integers over relatively small ranges.

A seekable stream is a valid Zstandard stream made from one or more compressed frames followed by a final skippable frame containing a seek table. Standard Zstandard decoders can read the stream from the beginning, while Reader uses the seek table to serve Read, ReadAt, and Seek calls by uncompressed byte offset and exposes the parsed metadata through Reader.SeekTable.

The package accepts small encoder and decoder interfaces and is tested with github.com/klauspost/compress/zstd.

This package provides a Go wrapper to zstd C library.

This package provides readers and writers for CPIO archives. Currently, only the SVR4 (New ASCII) format is supported, both with and without checksums.

This package provides an implementation of the LZO1X decompression algorithm in Go. The implementation is derived from the Linux kernel documentation for the LZO stream format and the implementation from lzokay project (MIT licensed). It includes a Reader for streaming decompressed data and a standalone Decompress function for use with byte slices.

This package is a simple scp package to copy files over SSH.

This package implements a subset of PKCS #7 / Cryptographic Message Syntax (RFC 2315, RFC 5652).

This package implements crypto.Signer for PKCS #11 private keys.

ejson is a utility (CLI and Go library) for managing a collection of secrets in source control.

The secrets are encrypted using public key, elliptic curve cryptography (NaCl Box: Curve25519 + Salsa20 + Poly1305-AES). Secrets are collected in a JSON file, in which all the string values are encrypted. Public keys are embedded in the file, and the decrypter looks up the corresponding private key from its local filesystem.

The ocicrypt library is the OCI image spec implementation of container image encryption. More details of the spec can be seen in the OCI repository. The purpose of this library is to encode spec structures and consts in code, as well as provide a consistent implementation of image encryption across container runtimes and build tools.

ZLint is a X.509 certificate linter that checks for consistency with standards (e.g. RFC 5280) and other relevant PKI requirements (e.g. CA/Browser Forum Baseline Requirements).