This repository is a Java library for JSON Web Token (JWT) handling per RFC 7519. It provides comprehensive functionality for creating, signing, verifying, and decoding JWTs, supporting multiple cryptographic algorithms including HMAC (HS256/384/512), RSA (RS256/384/512, PS256/384/512), EC (ES256/384/512), and EdDSA (Ed25519/Ed448). The library also includes utilities for JSON Web Key (JWK) management, PEM encoding/decoding of keys and certificates, and ASN.1 DER parsing for low-level cryptographic operations. Architecturally, the library follows a modular structure with clear separation of concerns: core JWT operations in the `jwt` package, JWK handling in `jwks`, PEM utilities in `pem`, and DER parsing in `der`. Cryptographic operations are abstracted through `Signer` and `Verifier` interfaces, enabling the Strategy pattern for pluggable algorithm implementations. Object creation uses the Builder pattern for immutable, fluent APIs (e.g., `JWT.addClaim()`, `KeyPair.build()`). JSON processing is centralized via a configured Jackson `Mapper` with custom serializers/deserializers for Java 8+ date-time types. The design minimizes coupling, allowing components like `JWTUtils` or `HMACSigner` to be reused independently. The library is actively maintained, with recent commits (2026-07-15) and ongoing security updates (e.g., patches for CVE-2022-21449). Dependencies are managed via Maven/Savant, relying primarily on Jackson for JSON processing with optional Bouncy Castle for certain algorithms. The codebase demonstrates strong engineering practices: comprehensive unit tests cover all algorithms and edge cases, clear exception hierarchies provide specific error handling, and Java 9+ module system support is included. It serves as a robust, reusable foundation for any Java application requiring secure token-based authentication or authorization.
PySyft is a privacy-preserving data science platform that enables data owners to share private datasets and approve code execution without exposing raw data. The codebase is a monorepo with multiple interdependent packages: `syft` (sync engine, peer management, encryption), `syft-rds` (high-level remote data science client for datasets and jobs), `syft-job` (job lifecycle, runner, disclosures), `syft-datasets` (dataset storage with versioned protocol codecs), `syft-enclave` (confidential computing with TEE attestation via Confidential Spaces or Tinfoil, signed receipts), `syft-bg` (background services for auto-approval, email notifications, systemd management, TUI), `syft-permissions` (declarative ACL engine), `syft-restrict` (static code verification and obfuscation for private regions), `syft-migration` (generic versioned migration framework for objects), `syft-notebook-ui` (rich HTML representation for Jupyter), and `syft-perms` (file-level permission browser). The core workflow: data scientists submit Python jobs encapsulating analysis code → data owners approve (manually or automatically) → jobs run in sandboxed environments or TEE enclaves → results and logs are staged and released according to multi-party disclosure policies. The system uses Google Drive as the default sync transport with offline-first P2P file exchange, protocol versioning for backward compatibility, and cryptographic key pinning for trust.
Blitzar is a high-performance C++ library for GPU-accelerated cryptographic zero-knowledge proofs, developed by Space and Time. It provides multi-scalar multiplication (MSM), Pedersen commitments, inner product arguments, sumcheck proofs, and sequential commitments over multiple elliptic curves (Curve25519/Ristretto255, BLS12-381, BN254, Grumpkin). The library supports both CPU and CUDA GPU backends, with a stable C API and Rust bindings (blitzar-sys). It is designed for use in Space and Time's Proof of SQL, enabling analytic queries on large datasets with sub-second proof generation. The codebase is well-structured with extensive unit tests, benchmarks, and a Bazel/Nix build system. It incorporates optimized algorithms (Pippenger, bucket methods) and low-level field/curve arithmetic adopted from libsodium and zkcrypto, demonstrating strong engineering craftsmanship in GPU cryptography.
This is the official JavaScript/TypeScript SDK for the Algorand blockchain, version 3.7.0. It provides a comprehensive set of tools for constructing, signing, encoding, and submitting transactions to Algorand nodes, as well as querying blockchain state via the Algod v2, Indexer, and KMD APIs. The SDK supports all transaction types (payment, asset management, application calls, key registration, state proofs, heartbeats), atomic transaction groups, ABI encoding/decoding for smart contract interactions, logic signatures (escrow, delegation, multisig), and post-quantum Falcon-1024 signatures. It is designed for both Node.js and browser environments, with CommonJS, ESM, and webpack bundle outputs. The architecture is modular: a core encoding layer (schema-based msgpack/JSON serialization) underpins all data types; a client layer abstracts HTTP communication with token-based authentication; a transaction builder pattern provides ergonomic construction; and a signer abstraction decouples signing logic from transaction assembly. Key entry points include the `Algodv2`, `Indexer`, and `Kmd` client classes, the `Transaction` class, `AtomicTransactionComposer` for atomic groups, and the `LogicSig`/`LogicSigAccount` classes. Data flows involve constructing transactions, signing them (via raw keys, multisig, or external signers), encoding to msgpack, and submitting to the network. The SDK also handles decoding of responses, including complex structures like block headers, state deltas, and simulation results. External dependencies include the `algorand-msgpack` package for msgpack encoding, `@algorandfoundation/falcon-wasm` for post-quantum signatures, and `hi-base32` for address encoding. The SDK is extensively tested with unit tests (Mocha), integration tests (Cucumber with mock servers), and browser tests (Selenium). It is actively maintained with regular releases, automated code generation from Algorand API specifications, and CI/CD pipelines for linting, testing, and publishing.
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).
Lightning Network Daemon (lnd) is a full-featured Lightning Network node implementation written in Go. It enables users to participate in the Lightning Network by opening and managing payment channels, sending/receiving payments, routing payments for others, and enforcing channel contracts via blockchain monitoring. The architecture is modular, separating concerns into distinct subsystems: peer-to-peer networking (brontide, lnpeer), channel state management (channeldb, chanstate, lnwallet), payment switching and routing (htlcswitch, routing), blockchain monitoring (chainntnfs), contract enforcement (contractcourt), RPC services (lnrpc), watchtower functionality, and autopilot for automated channel management. Key entry points include the daemon (cmd/lnd/main.go), CLI (cmd/lncli/main.go), and various RPC servers. Data flows involve processing peer messages to update channel state, persisting state to pluggable backends (BoltDB, PostgreSQL, SQLite, etcd), monitoring blockchain events affecting channels, and handling RPC commands for node control and queries. External dependencies include Bitcoin full nodes (bitcoind/btcd or Neutrino), database libraries, and various Go utilities (btcutil, btcec, gRPC).
Bouncy Castle for .NET is a comprehensive, production-grade cryptographic library providing implementations of a vast range of symmetric and asymmetric ciphers, hash functions, message authentication codes, digital signatures, key agreement protocols, key encapsulation mechanisms (including post-quantum schemes like ML-KEM, ML-DSA, SLH-DSA), secure random number generation (NIST SP 800-90A DRBG), and ASN.1 encoding/decoding (DER, BER, DL). It supports high-level protocol implementations for TLS/DTLS (client and server, including PSK, SRP, and post-quantum key exchange), OpenPGP (RFC 4880/9580), CMS (Cryptographic Message Syntax), CMP, CRMF, OCSP, TSP, and X.509 certificate generation and validation. The library is designed as a class library with a monolithic architecture organized into namespaces (Org.BouncyCastle.Crypto, .Asn1, .Tls, .Bcpg, .Cms, etc.), exposing both low-level primitives and high-level builders. It targets multiple .NET runtimes with conditional compilation for hardware intrinsics (AES-NI, PCLMULQDQ, SSE/AVX) and Span<T> support. The codebase is actively maintained, with ongoing migration from older algorithm names (e.g., Dilithium → ML-DSA) and extensive use of factory patterns and interface-based abstractions, making it a solid foundation for secure application development.
JSTprove is a production-grade zero-knowledge proof system for verifying ONNX neural network inference. It compiles ML models into arithmetic circuits using the Expander Compiler Collection (ECC) frontend, generates witnesses, and produces proofs via a GKR/sumcheck-based prover with multiple polynomial commitment schemes (KZG, Hyrax, Orion, Basefold, WHIR). The system supports multiple efficient field arithmetics (Mersenne31, BabyBear, Goldilocks, BN254, GF2) with SIMD/AVX/NEON optimizations, and provides hardware acceleration through Metal and CUDA backends. The codebase is organized as a Rust workspace with ~30 crates, offering a CLI (`jstprove`, `jstprove-remainder`), Python bindings via PyO3, and a zkVM guest (Jolt). It is actively maintained by Inference Labs with regular commits, CI/CD pipelines, and e2e tests covering full model pipelines (LeNet, CIFAR CNN, MiniResNet). While primarily an application toolkit, it contains deep cryptographic research contributions in the form of advanced polynomial commitment constructions (sparse WHIR, hyper-bivariate KZG) and circuit optimizations (cross-layer GKR, LogUp range checks). Some hints (e.g., sigmoid, gridsample) carry documented soundness caveats, and the system relies on nightly Rust and platform-specific intrinsics, which may limit portability.
JSON::JWT is a Ruby library implementing the JSON Web Token (JWT) family of standards, including JWS (JSON Web Signature), JWE (JSON Web Encryption), and JWK (JSON Web Key). It provides comprehensive cryptographic operations for signing, verifying, encrypting, and decrypting tokens using various algorithms (HMAC, RSA, ECDSA, RSA-PSS, and symmetric encryption). The library also includes JWK Set management with remote fetching and caching capabilities. The architecture is modular: JSON::JWT serves as the main entry point, delegating to JSON::JWS for signing/verification and JSON::JWE for encryption/decryption. JSON::JWK handles key representation and conversion between OpenSSL keys and JWK format. The JWK Set Fetcher provides a configurable HTTP client with pluggable caching, suitable for OpenID Connect discovery. The code demonstrates strong security practices, including constant-time comparison for MAC verification, protection against padding oracle attacks in CBC mode, and proper validation of algorithm headers to prevent algorithm confusion attacks. The test suite covers interop with other JWT libraries (Nimbus JOSE, jsrsasign) and RFC examples, ensuring correctness. Key external dependencies include OpenSSL for cryptographic primitives, Faraday for HTTP, and ActiveSupport for hash extensions. The library is actively maintained with support for Ruby 3.2-4.0 and recent security fixes.
PrivateBin is a self-hosted, zero-knowledge pastebin web application. The PHP backend (Controller, Model, Data) handles paste/comment lifecycle, expiration, deletion, traffic limiting, and storage backend selection; the JavaScript frontend performs all encryption/decryption in the browser using AES-256-GCM (WebCrypto) with PBKDF2 key derivation and optional zlib/WASM compression. The server only ever stores ciphertext and metadata, never plaintext. Data flows from browser encryption into a pluggable persistence layer (filesystem, PDO database, Google Cloud Storage, S3), then back to the browser for decryption; JSON API endpoints accept and return encrypted bodies. Architecturally it is a classic server-rendered MVC app with a frontend state layer: index.php bootstraps a Controller, which delegates to Paste/Comment models over an AbstractData storage interface. Views are rendered via PHP templates with Bootstrap 3/5 themes, and the frontend is a vanilla-JS module namespace (PrivateBin) with submodules for encryption, editor, viewer, discussion, attachments, and i18n. The feature set includes expiration times, burn-after-reading, password-protected pastes, discussion threads, file attachments, URL shortening proxies (YOURLS/Shlink), QR codes, dark mode, and multi-language support. Engineering practices are strong for a mature open-source project: PHPUnit tests cover backend behavior, fast-check property tests cover frontend utilities, CI includes CodeQL/Snyk scans, and security hardening (DOMPurify, CSP, SRI hashes, HTTPS guidance) is explicit. Maintenance is active with recent commits and issue triage. Technical drift is moderate: the project retains legacy browser support and old Bootstrap 3/darkstrap assets, still supports PHP 7.4, and ships a monolithic JS file without a build step, but pinned frontend libraries (Bootstrap 5.3.8, Showdown 2.1.0, DOMPurify 3.4.17) are current.
snarkOS is a production-grade Rust blockchain node for the Aleo zero-knowledge network. It implements validator, client, prover, and bootstrap client node roles, with AleoBFT consensus built on a Narwhal/Bullshark-style certificate DAG, TCP P2P networking with Noise and legacy handshakes, block synchronization (including CDN fast sync), a REST API, Prometheus metrics, and a CLI. The repository is organized as a modular workspace of roughly 20 crates such as node/bft, node/router, node/tcp, node/sync, node/network, node/rest, cli, display, and utilities, with the binary entry point in snarkos/main.rs. The architecture is trait-heavy and decoupled: node/tcp provides a generic pluggable TCP protocol stack, node/bft abstracts ledger and storage services behind traits, node/router handles peer message dispatch and rate limiting, and node/sync contains a reusable block synchronization engine. Data flows primarily through P2P peer messages into routing and BFT event dispatch, then through batch proposal, certificate aggregation, DAG commitment, and finally ledger/storage updates that feed REST queries and telemetry. The strongest reusable components are the storage/ledger service abstractions, the generic time-windowed cache, the Noise handshake implementation, and the TCP protocol hooks. This is not a data-research repository, though it contains research-grade consensus algorithms and extensive property-based tests. The codebase is actively maintained and generally well-engineered, but shows medium technical drift: snarkVM is pinned to a git revision, there are dual legacy and Noise handshake paths gated by consensus versions, many feature flags create conditional compilation complexity, and several TODOs or commented-out sections remain. Extracting components is feasible but requires respecting the existing crate boundaries.
This repository is a .NET library for JWT (JSON Web Token) key management that provides automatic generation and rotation of cryptographic keys for JWT signing (JWS) and encryption (JWE). It features a modular architecture with a core library handling key generation/storage, multiple storage providers (in-memory, file system, Entity Framework Core), and framework-specific integrations for ASP.NET Core and IdentityServer4. The library exposes a JWKS endpoint for sharing public keys and integrates with ASP.NET Core authentication systems to validate tokens using the managed keys. Key entry points include the AddJwksManager() service registration method, UseJwksDiscovery() middleware for the JWKS endpoint, and the IJwtService interface for token generation and validation. The primary data flow involves generating cryptographic keys, storing them via pluggable storage providers, retrieving current keys for token operations, and exposing public keys through the JWKS endpoint. The library depends on System.IdentityModel.Tokens.Jwt for JWT handling, Microsoft.AspNetCore.DataProtection for key protection in the default storage implementation, and various Microsoft.Extensions packages for caching, options, and logging.
Trussed is a no_std Rust library and framework for building cryptographic firmware on microcontrollers. It implements a client-service syscall architecture: applications use strongly-typed client traits such as CryptoClient, FilesystemClient, and CertificateClient to send Request enums through an interchange channel; Service::process dispatches requests to pluggable mechanism implementations or custom backends, persists keys and files across three littlefs2 filesystems (internal, external, volatile), and returns Reply enums. It is not a standalone application or CLI but an embedded component used by firmware runners such as Solo 2 and Nitrokey 3.
Anoma is an Elixir/OTP implementation of the Anoma protocol - a distributed operating system for intent-centric applications. The codebase implements a full node architecture with multiple supervised engines: Mempool (transaction submission/ordering), Ordering (consensus sequencing), Executor (parallel transaction execution), Storage (Merkelized key-value store with RocksDB/Mnesia), Shard (partitioned KV store with watermark-based concurrency), IntentPool/Solver (intent matching and composition), Logging (event persistence and replay), and Transport (gRPC/IntraNode networking with proxy-based remote node communication). The system uses Nock/Noun as its core computation model (via anoma-lib), with a Cairo backend for shielded/zero-knowledge transactions. Transactions are submitted as jammed Nock nouns, executed in isolated workers, and results flow through an event-driven architecture (event_broker). The node supports distributed operation via gRPC transport with automatic peer discovery and advertisement. Key architectural patterns: CQRS-style engines (casts for mutations, calls for queries), typed event definitions with filters (defevent macro), supervisor hierarchies with dynamic child management, and a replay mechanism that validates persisted state on restart by spinning up a mock node. The codebase follows an "examples over tests" philosophy - extensive executable examples in lib/examples/ serve as both documentation and integration tests.
Themis is a cross-platform cryptographic library developed by Cossack Labs, providing high-level security primitives such as Secure Cell (symmetric encryption with three modes: Seal, Token Protect, Context Imprint), Secure Message (asymmetric encryption and digital signing), Secure Session (mutual authentication and key exchange), Secure Comparator (zero-knowledge password comparison), and key generation (EC, RSA, symmetric). The core is implemented in C with a cryptographic engine abstraction layer (Soter) that supports OpenSSL, BoringSSL, and a custom Ed25519 implementation. The library exposes consistent APIs across 13+ language wrappers including Python, Go, Rust, Java, Swift, Objective-C, JavaScript (Node.js and WebAssembly), PHP, Ruby, C++, and React Native. The codebase is well-structured with extensive unit, integration, and fuzz testing, CI/CD pipelines for each wrapper, and cross-language compatibility tests. While the repository has deprecated older APIs and maintains multiple backends, it remains actively maintained with regular releases, security patches, and community engagement.
This repository is a curated list (awesome list) of resources about post-quantum cryptography. It is not a software application or a data research project. It aggregates links to standards, initiatives, libraries, research papers, and other resources related to PQC. The content is maintained by the community and appears to be regularly updated.
The Java Stellar SDK is a comprehensive client library for interacting with the Stellar blockchain network, providing both Horizon REST API bindings and Soroban smart contract support. It handles transaction construction, signing, and submission, as well as account management, asset operations, liquidity pools, and decentralized exchange path finding. The library is built on a robust XDR codec layer generated from protocol definitions, with handcrafted decoders that enforce depth limits and size constraints for safe binary parsing. It also includes a SPI-based platform abstraction for Base32/Base64 encoding to support Android deployments, and a sophisticated contract client that manages Soroban transaction lifecycle (simulation, restoration, signing, and submission). The codebase is actively maintained, with a large test suite spanning Java and Kotlin, CI/CD pipelines, and support for the latest Stellar protocol features (CAP-71, CAP-85, SEP-10/45/51/53). While the XDR generation pipeline requires periodic regeneration, the core SDK abstractions are well-isolated and exhibit strong engineering practices such as builder patterns, immutable value objects, and custom Gson deserializers for Horizon response parsing.
NBitcoin is a comprehensive .NET library for Bitcoin and altcoin protocol support. It provides low-level primitives for transactions, blocks, keys, scripts, addresses, HD wallets (BIP32/39), PSBT (BIP174/370), Taproot/Schnorr, and a full P2P networking stack. The library also includes internal cryptographic implementations (secp256k1, SHA-256, BouncyCastle) and supports 30+ altcoins via custom network definitions and consensus factories. It is used in production by BTCPay Server, Wasabi Wallet, and other Bitcoin infrastructure. The architecture is a set of interconnected NuGet packages (NBitcoin, NBitcoin.Altcoins, NBitcoin.Secp256k1, NBitcoin.TestFramework, NBitcoin.Bench) with extensive integration tests that run against real Bitcoin Core nodes. While the core library is well-engineered with clean abstractions, the altcoin surface introduces some duplication and conditional compilation complexity, and the internal BouncyCastle fork may diverge from upstream. Overall, it is a high-quality, actively maintained library with strong reusability of its core components.
This repository provides a WebCrypto API polyfill for Node.js, implementing the W3C Web Cryptography API using Node's native crypto module. It supports a comprehensive set of algorithms including AES (CBC, CTR, GCM, ECB, KW, CMAC), DES (CBC, EDE3-CBC), RSA (SSA, PSS, OAEP, ES), ECDSA, ECDH, EdDSA, ECDH-ES, Ed25519, X25519, HMAC, PBKDF2, HKDF, SHA-1/256/384/512, SHA3-256/384/512, and SHAKE128/256. The architecture follows a provider pattern where each algorithm is implemented as a separate class extending a base provider from the 'webcrypto-core' library. Key management is handled through internal CryptoKey classes with serialization support for JWK, raw, PKCS8, and SPKI formats. The library is designed as a drop-in replacement for the browser's crypto.subtle API, enabling isomorphic JavaScript cryptography.
MCUboot is a secure bootloader for 32-bit microcontrollers, providing signed and encrypted firmware upgrade capabilities. The repository contains the core bootloader library (C) with support for multiple RTOS platforms (Zephyr, Mynewt, NuttX, Mbed OS, Espressif, Cypress), a Python image signing and management tool (imgtool), a Rust-based simulator for testing boot scenarios, and vendored cryptographic libraries (TinyCrypt, Mbed TLS subset, fiat-crypto). The system architecture is a library with platform-specific ports: the common boot logic (bootutil) handles image validation, swap algorithms (scratch, move, offset, direct-XIP, RAM-load), encryption, and fault-injection hardening. Each platform provides flash map, logging, watchdog, and boot entry point implementations. The codebase is highly configurable via compile-time flags, supporting multiple signature schemes (RSA, ECDSA, Ed25519), encryption backends, and upgrade modes. It is not a standalone application but a bootloader intended to be integrated into embedded firmware projects.