We developed an SDK that turns participating devices into proxy exit nodes for GeoNode. Our team studied the existing backend, completed the SDK’s integration with the platform, and built the supporting tools for working with it.
GeoNode operates proxy infrastructure and web data services. Our work focused on the software running on exit-node devices and its connection to GeoNode’s backend. That required understanding how the existing platform works, then carrying the SDK through the full integration.
Our team examined the backend architecture and the way it interacts with device software. This gave us the integration requirements for connecting the Rust SDK to GeoNode’s platform and handling proxy traffic within its network.
We implemented the SDK’s integration with GeoNode’s backend and built a supporting toolkit for integrating and working with it inside the platform. The delivered work covers both the device component and the software needed to connect it to the existing service.
Devices running the SDK connect to GeoNode’s platform. Proxy traffic passes through those devices to its destination, with the SDK handling connections and enforcing safeguards around local and protected resources.
Requests enter
GeoNode’s network
Backend integration
Connection to SDK nodes
Traffic exits through
the participating device
Built around GeoNode’s existing platform and the Rust SDK.
Block local network scanning and access attempts to protected resources.
The SDK implements SOCKS5 proxy traffic handling, including SOCKS5 UDP ASSOCIATE for UDP communication. Connection processing and device-side protection are part of the SDK itself.
Because requests leave through a participating device, the implementation also needs to control what those requests can reach. The SDK includes protection against local network scanning and attempts to access protected resources.
We developed the SDK in Rust with particular attention to allocation behavior and device resource use. The optimization work supports fast proxy traffic handling while keeping the SDK’s operating overhead low on mobile and desktop devices.
We optimized memory allocations in the SDK’s traffic-handling code to reduce the work performed while processing proxy connections.
The implementation is tuned for efficient use of device resources while the SDK operates as a proxy exit node.
The Rust implementation brings connection processing and TCP and UDP traffic handling into the same optimized SDK.
The SDK builds for Windows, Android, iOS, macOS, and Linux. The shared Rust implementation carries the proxy functionality and backend integration across the supported mobile and desktop environments.
The SDK is written in Rust and integrated with GeoNode’s existing backend. The implementation brings proxy traffic handling, local resource protection, and device resource management into the same SDK.
Full SDK support for the following operating systems.
Full support for TCP and UDP traffic.
The SDK runs on exit-node devices and includes safeguards against local network scanning and access to protected resources.
Schedule a consultation with our proxy infrastructure experts and discover how enterprise-grade solutions can accelerate your growth.
