Open-source alternatives to Rustls

CrowdSec is a collaborative, distributed security engine designed for threat detection and infrastructure protection. It functions as an intrusion detection system that parses logs and network traffic to identify malicious patterns, utilizing a bucket-based threshold detection model to aggregate events and trigger alerts. The platform is built on a modular architecture that includes a centralized local API server for managing security signals and a relational database for persistent storage of remediation decisions. What distinguishes the project is its decoupled enforcement model, which offl

This is a header-only C++ library and asynchronous network framework used to implement WebSocket clients and servers. It provides a full implementation of the WebSocket protocol, including handshakes, subprotocol negotiation, and frame parsing. The framework is distinguished by a policy-based transport layer and template-driven protocol negotiation, allowing the underlying network implementation to be swapped between raw buffers, streams, or custom policies. It supports per-message deflate compression to reduce data transmission volume and integrates Transport Layer Security for encrypted bid

libhv is a high-performance C/C++ network library and event-driven I/O framework used to build TCP, UDP, SSL, HTTP, WebSocket, and MQTT clients and servers. It provides a non-blocking event loop for managing network sockets, timers, and system signals across multiple threads. The project is distinguished by its integrated support for specialized network roles, including a full HTTP web server with RESTful routing and middleware, an MQTT messaging client for IoT communication, and the ability to implement SOCKS5 and HTTP proxies. It also features a reliable UDP implementation to ensure ordered

This project is a library for establishing bidirectional, real-time communication channels between clients and servers using the WebSocket protocol. It provides a foundational toolkit for managing persistent network connections and processing data frames in accordance with the RFC 6455 standard. The library distinguishes itself through its focus on low-level control and network efficiency. It utilizes an asynchronous, event-driven architecture to manage multiple concurrent connections without requiring dedicated threads for each session. Developers can fine-tune data transmission through manu

grpc-rust is a native gRPC framework for Rust designed for building high-performance remote procedure call clients and servers. It provides an asynchronous communication stack and a protocol buffers implementation for encoding, decoding, and generating type-safe code from service definitions. The project enables the implementation of unary and bi-directional data streaming over the HTTP/2 protocol. It includes specialized support for gRPC-Web integration, allowing browser-based clients to communicate with services through protocol translation. The infrastructure covers a broad range of distr

This project is a cross-platform implementation of the WebRTC standard, providing a comprehensive library for building real-time audio, video, and data communication applications. It functions as a peer-to-peer networking framework and media processing engine, enabling direct, low-latency connections between devices without relying on central servers. By strictly adhering to official protocol specifications, the library ensures interoperability with browsers and other native communication software across mobile, desktop, and server environments. The engine distinguishes itself through a modul

This library is a high-level networking tool for the Rust programming language, designed to execute HTTP requests and interact with remote services and REST APIs. It provides both asynchronous and blocking interfaces, allowing developers to send data using formats such as JSON or multipart forms while maintaining type-safe communication with external web services. The library distinguishes itself through a comprehensive architecture that manages network sessions and data flow. It utilizes connection pooling to maintain persistent sockets, which reduces latency during consecutive requests to t

This project serves as a comprehensive tutorial and technical resource for developing network applications in the C programming language. It focuses on the practical application of the Berkeley socket interface, guiding users through the implementation of low-level network protocols and the management of data transmission across both connection-oriented and connectionless streams. The material distinguishes itself by covering the full lifecycle of network communication, from initializing system-level protocol stacks and resolving domain names to managing complex connection behaviors. It provi

Octelium is a zero-trust network access platform and identity-aware proxy designed to secure private HTTP, SSH, and SQL resources. It functions as a secure gateway that validates human and workload identities using OIDC, SAML, and FIDO2 passkeys before granting access to internal applications and SaaS APIs. The system is distinguished by its secretless access broker, which injects credentials—such as API keys, passwords, and AWS Sigv4 signatures—at the gateway level so users can access databases and cloud resources without managing secrets. It further specializes in AI gateway administration,

This is a header-only C++ library that provides implementations for HTTP clients, HTTP servers, and a WebSocket framework. It allows for the creation of network services and the consumption of remote APIs without requiring a separate compilation step or external binary linking. The project features backend-agnostic TLS integration for secure HTTPS and WSS communication and employs a thread-pool model to process concurrent requests. It distinguishes itself with a full-duplex WebSocket state-machine and a middleware-based request pipeline that supports regular-expression path routing. The libr

This project provides a TypeScript software development kit for the Model Context Protocol, a standard designed to facilitate bidirectional communication between AI applications and external data sources or tools. It serves as a foundational framework for building both clients and servers, enabling language models to interact with external systems through a unified, decoupled interface. The SDK distinguishes itself by implementing a transport-agnostic connection layer that supports both local standard input-output streams and remote HTTP endpoints. It utilizes a JSON-RPC message bus to manage

Lantern is a network utility designed to provide access to restricted internet content by tunneling traffic through encrypted connections. It functions as a censorship circumvention tool that enables private web browsing and ensures reliable connectivity in environments where standard network access is blocked or monitored. The application employs a decentralized infrastructure that routes data through a network of distributed proxy nodes. To maintain connectivity in the face of interference, it utilizes dynamic proxy discovery and adaptive fallback mechanisms that automatically switch betwee

Vector is a high-performance observability data pipeline designed to collect, transform, and route logs, metrics, and traces across distributed infrastructure. It functions as a modular engine that decouples data ingestion from processing and transmission, utilizing a component-based architecture to connect diverse sources to multiple destinations. The project distinguishes itself through a focus on reliability and flow control. It implements backpressure-aware data movement to prevent data loss during traffic spikes and utilizes disk-backed event buffering to ensure durability during network

Cerbos is an open-source authorization service that provides a centralized, language-agnostic engine for managing access control. It functions as a policy-as-code platform, allowing teams to define, test, and distribute authorization rules using declarative YAML or JSON configurations. By decoupling access logic from application code, it enables consistent permission enforcement across diverse service stacks. The project distinguishes itself through its ability to translate high-level authorization policies into native database query filters. This capability allows applications to enforce sec

Quarkus is a Kubernetes-native Java framework designed for building high-performance, memory-efficient applications. It utilizes ahead-of-time native compilation to transform Java code into standalone, optimized binaries that eliminate the need for a virtual machine, enabling rapid startup and reduced memory consumption. By performing code augmentation during the build phase, it shifts heavy processing tasks away from runtime, ensuring that applications are optimized for cloud-native environments. The framework distinguishes itself through a unified approach to reactive and imperative program

Covenant is a .NET-based command and control framework designed for red team operations and adversary simulation. It serves as a collaborative platform for coordinating security assessments, managing remote implants, and executing tasks on compromised systems through a centralized server. The project is distinguished by its dynamic payload generator, which compiles and obfuscates executable binaries and scripts on the fly to bypass detection. It further separates itself through a collaborative environment that allows multiple authenticated operators to share a synchronized state, track operat

GlusterFS is a software-defined distributed file system and scale-out storage cluster that aggregates disk resources from multiple servers into a single global namespace. It functions as a unified storage platform, allowing the same underlying data to be exposed through file, block, and object storage interfaces. The system distinguishes itself through a decentralized architecture that uses consistent hashing to distribute files across network nodes without a central metadata server. It ensures data integrity and availability using self-healing replication, quorum-based consistency to prevent

Mongoose is an embedded networking library providing TCP/IP stacks, web server hosting, and IoT device connectivity. It enables microcontrollers and desktop systems to implement network protocols including HTTP, WebSocket, and MQTT. The project provides a bare-metal TCP/IP stack for environments without a native operating system and includes built-in TLS and ECC encryption to secure network traffic. It features a binary-embedded file system to serve web content directly from the executable and supports over-the-air firmware updates for managing device fleets. Additional capabilities cover as

This is a Ruby HTTP client designed for REST API integration, resource modeling, and automated network communication. It provides a set of tools for managing headers, cookies, and SSL configurations, along with a dedicated command-line interface for executing one-off HTTP commands and managing interactive API testing sessions. The project differentiates itself through its resource modeling capabilities, which allow for the definition of persistent base URLs and credentials to construct nested subresource endpoints. It also features a multipart request handler that detects MIME types to upload

libwebsockets is an event-driven networking framework written in C. It provides a suite of tools for implementing HTTP servers and clients, WebSocket bidirectional communication, MQTT client messaging, and TLS-enabled socket encryption. The project distinguishes itself through a non-blocking event-loop architecture capable of scaling to high connection volumes by distributing network sessions across multiple service threads. It uses a protocol-based callback system and a pluggable event loop integration that allows the networking core to synchronize with external system event libraries. The

Forge is a JavaScript cryptography library providing a comprehensive set of tools for symmetric and asymmetric encryption, hashing, and digital signatures. It includes a full Transport Layer Security implementation for establishing secure network connections and managing encrypted traffic. The project implements a wide array of public key infrastructure tools, including X.509 certificate management, the generation of certificate signing requests, and the validation of certificate chains. It provides a PKCS cryptographic toolkit for handling secure archives and signed messages, alongside suppo

Beast is a C++ library for implementing low-level HTTP and WebSocket clients and servers. It functions as an asynchronous networking framework designed to compose non-blocking I/O operations and layered stream stacks for managing concurrent network traffic, specifically utilizing the Boost.Asio asynchronous model. The library provides a comprehensive implementation of the HTTP/1.1 and WebSocket protocols. For HTTP, it includes primitives for parsing and serializing messages with support for chunked transfer encoding, incremental body reading, and request pipelining. Its WebSocket implementati

Java-WebSocket is a collection of classes for implementing WebSocket clients and servers using pure Java. It provides a framework for hosting servers that manage connections via event-driven subclasses and tools for establishing client connections to remote servers. The library includes a secure communication tool for encrypting traffic using the WSS protocol and a compression library that uses per-message deflate extensions to reduce transmitted data size. It supports the configuration of cipher suites to limit encryption protocols and ensure compatible communication. The project enables bi

This project provides a collection of practical implementations and code references for establishing secure network communications using transport layer security protocols. It serves as a guide for developers to implement public key infrastructure and enforce encryption standards within client and server applications. The repository focuses on cryptographic certificate management, including the generation of public and private key pairs and the creation of self-signed certificates for local testing environments. It covers the configuration of secure web servers, offering methods to harden ser

This project is a memory-safe implementation of the QUIC transport protocol and HTTP/3, designed for high-throughput and efficient network communication. It provides a comprehensive toolkit for building secure, low-latency network applications by managing the full lifecycle of transport connections, including protocol negotiation, stream data exchange, and connection state management. The library distinguishes itself through a focus on performance and protocol integrity. It utilizes a formal state machine to enforce strict adherence to transport rules and employs zero-copy buffer management t

Socket.io is a real-time communication engine that enables bidirectional, event-based data exchange between clients and servers. It provides a robust transport-agnostic protocol layer that automatically manages connection lifecycles, including heartbeat signals, automatic reconnection, and seamless fallback between WebSockets and HTTP long-polling. By maintaining persistent links, it ensures reliable messaging across diverse network environments. The project distinguishes itself through a scalable, distributed architecture that supports multi-node synchronization and room-based message routin

Syncthing is a decentralized file synchronization engine that maintains consistent data states across multiple devices through peer-to-peer mesh networking. It operates as a background daemon that automatically replicates file creations, modifications, and deletions between trusted nodes without requiring central servers. By utilizing content-addressable block indexing and block-level delta synchronization, the system identifies and transfers only the modified segments of files, ensuring efficient data propagation across heterogeneous environments. The project distinguishes itself through a s