This repository (apple/swift-collections) is a pure Swift library providing high-performance, specialized data structures that extend the Swift standard library. It includes stable modules like DequeModule (ring-buffer deque), OrderedCollections (ordered set/dictionary), HeapModule (min-max heap), BitCollections (BitSet/BitArray), and HashTreeCollections (persistent hash-array mapped trie TreeSet/TreeDictionary). It also contains experimental preview modules (e.g., SortedCollections using B-trees, RopeModule for rope-based BigString, and BasicContainers with non-copyable collections). The code is heavily optimized with copy-on-write, unsafe pointer usage, and advanced Swift ownership features. It is designed for production use with source stability guarantees, while preview modules are explicitly unstable. The library is consumed as a Swift package and integrates seamlessly with standard collection protocols.
This repository provides Python bindings for the BLAKE3 cryptographic hash function, using the official Rust implementation via PyO3. It exposes a single `blake3` class that mimics the Python `hashlib` API, supporting incremental hashing, keyed hashing, key derivation, extendable output (XOF), multithreading via Rayon, and memory-mapped file hashing. The core implementation is in `src/lib.rs`, which demonstrates careful handling of Python buffer protocol types (signed/unsigned bytes), GIL release for long operations, and interior mutability with `Mutex` for thread safety. An experimental C implementation in `c_impl/` provides a fallback for platforms without Rust support. The package is published on PyPI as `blake3` and includes comprehensive test vectors, type stubs, and CI for multiple platforms and Python versions (3.8 to 3.14, including free-threaded).
HAITI (HAsh IdenTIfIer) is a Ruby library and CLI tool for identifying hash types from input strings. It matches against a comprehensive database of over 675 hash types (including modern algorithms like SHA3, Blake2, and VeraCrypt) using regex patterns. The library provides concise output with hashcat mode numbers, John the Ripper format names, and example hashes. Multiple CLI entry points exist: the main `haiti` command, `haiti-parsable` for script-friendly output, `haiti-fzf` for interactive selection, and `hashcat-haiti`/`john-haiti` for converting hashes into hashcat/JtR formats. The codebase is well-structured, with clean separation between the identification engine, data definitions, and CLI wrappers. It includes comprehensive documentation (man pages, YARD API docs, a docsify site) and is packaged for numerous Linux distributions and Homebrew. The identification logic is straightforward but effective: iterate over a JSON array of prototypes, apply each regex to the input, and return matching types. The data file (`prototypes.json`) is manually maintained and extended with each release.
This repository is a high-quality .NET library implementing the OpenBSD BCrypt password hashing algorithm. It serves as a security-critical dependency for authentication systems, providing robust password hashing, verification, and salt generation. The codebase is multi-targeted, supporting legacy .NET Framework versions (4.6.2+) alongside modern .NET standards (2.0/2.1) and recent runtimes (.NET 8.0, 10.0). It includes specialized extensions for ASP.NET Core Identity, allowing seamless integration into existing authentication pipelines without custom implementation. The architecture prioritizes security through constant-time comparisons, secure memory handling, and thread-safe key schedule management using ThreadLocal storage. The library includes extensive test vectors from the original Java reference implementation to ensure algorithmic correctness across different BCrypt revisions (2a, 2b, 2y, 2x). While the core library is production-ready and widely adopted, the repository exhibits some hygiene issues, including the presence of a signing key file in the root directory and a 'dists/' folder containing legacy binary artifacts, which suggests a mix of automated and manual release processes. For engineers evaluating reuse, this library offers a reliable, well-tested foundation for password security. The Identity extension component is particularly valuable for .NET developers needing to replace default password hashers. However, consumers should be aware of the technical drift regarding legacy framework support and the potential security implications of the repository's artifact management practices.
Apache Commons Codec is a mature Java library providing a comprehensive set of encoders and decoders for binary-to-text formats (Base16, Base32, Base64, Base45, Base58, Hex), digest and hash algorithms (MD5, SHA-1/2/3, MurmurHash, XXHash32, Blake3, CRC16/32), phonetic encoding (Soundex, Metaphone, Caverphone, Beider-Morse, Daitch-Mokotoff), and network codecs (URL encoding, Quoted-Printable, RFC 1522 MIME). The architecture is modular with clear package separation: `binary`, `digest`, `language`, `net`, and `cli`. Key design patterns include a builder pattern for configuring codecs (e.g., `Base64.builder()`), an abstract base class `BaseNCodec` with streaming support via `BaseNCodecInputStream`/`OutputStream`, and a `CodecPolicy` enum for strict vs. lenient decoding. The library has no production dependencies; only test dependencies on commons-lang3 and commons-io. It is widely used across the Java ecosystem, with extensive test coverage including RFC vectors and backward compatibility tests. However, some deprecated methods and known bugs (e.g., in MurmurHash3 legacy methods) are preserved for compatibility, and certain algorithms (SHAKE) require Java 25, introducing version drift.
The repository implements the Ascon family of lightweight cryptographic algorithms, including authenticated encryption (Ascon-AEAD128), hashing (Ascon-Hash256), extendable output functions (Ascon-XOF128), message authentication codes (Ascon-Mac), and pseudorandom functions (Ascon-Prf). It provides both reference and highly optimized implementations for diverse architectures (ARM, AVR, RISC-V, x86 with AVX512/NEON) and optimization levels (speed, size, side-channel resistance). The library follows the CAESAR API style with functions like crypto_aead_encrypt, crypto_aead_decrypt, and crypto_hash. Core operations use a 5-word state structure and apply permutation rounds (6, 8, or 12) based on the mode. The architecture is modular, separating algorithms into directories with subdirectories for implementation variants (reference, architecture-specific, low-size). While the code demonstrates strong cryptographic engineering and portability, it exhibits significant duplication across variants, increasing maintenance burden. However, reusable components exist, such as endianness handling, word abstraction, and bit-interleaving algorithms from 'Hacker's Delight'. The repository is actively maintained with recent commits and shows low technical drift.