Performance Data

Performance Benchmarks

Real-world performance measurements on actual hardware

Test Environment

Date: November 18, 2025

Python: 3.x

Platform: Windows

Version: Latest

Handshakes

1,557

per second

642 µs average

Throughput

3.29

GB/s

64 KB messages

Latency

2.19

µs

64 byte messages

Key Generation

31,900

per second

Curve25519

Handshake Performance

Complete handshake flow including key generation, message exchange, and transport creation

Pattern Comparison (500 iterations)

Pattern	Mean	Median	Std Dev	Rate (hs/sec)
Noise_XX_25519_ChaChaPoly_SHA256	642.13 µs	552.40 µs	1.03 ms	1,557
Noise_XX_25519_AESGCM_SHA256	557.93 µs	538.35 µs	89.13 µs	1,792

Key Insights

AES-GCM is ~13% faster than ChaCha20-Poly1305 for handshakes
Real-world performance: ~0.5-0.6ms per complete handshake
Suitable for thousands of WebSocket connections per second

Transport Encryption Performance

Post-handshake message encryption/decryption using NoiseTransport

Encryption Performance (5,000 iterations)

Message Size	Mean Latency	Throughput
64 bytes	2.19 µs	27.90 MB/s
256 bytes	2.35 µs	104.09 MB/s
1 KB	2.42 µs	403.48 MB/s
4 KB	3.15 µs	1.21 GB/s
16 KB	6.14 µs	2.48 GB/s
64 KB	18.54 µs	3.29 GB/s

Analysis

• Encryption and decryption performance are nearly identical (within measurement variance)

• Throughput scales excellently with message size: from 28 MB/s (64 bytes) to 3.3 GB/s (64 KB)

• Fixed overhead per operation: ~2 µs (function call, nonce increment, setup)

• Small messages (chat, API): ~450,000 messages/sec

• Large messages (file transfer): 3+ GB/s sustained throughput

Key Generation Performance

DH keypair generation for different curves

Curve Comparison (1,000 iterations)

DH Function	Mean	Median	Std Dev	Rate (keypairs/sec)
Curve25519	31.35 µs	29.60 µs	12.55 µs	31,900
Curve448	226.16 µs	220.80 µs	33.09 µs	4,421

Key Insights

Curve25519 is ~7x faster than Curve448 for keypair generation
Curve25519: Fast enough for ephemeral key generation per-connection
Curve448: Still fast enough for most use cases, provides higher security margin
Recommendation: Use Curve25519 unless you specifically need extra security of Curve448

Performance Recommendations

Choose the right pattern for your use case

Low Latency

Chat, Gaming, Real-Time

Recommended: Noise_XX_25519_AESGCM_SHA256

✓ Fastest handshake: ~558 µs
✓ Sub-microsecond encryption for small messages
✓ Hardware-accelerated AES-GCM on most platforms

High Throughput

File Transfer, Streaming

Recommended: Noise_XX_25519_ChaChaPoly_SHA256

✓ Excellent throughput: 3+ GB/s for large messages
✓ ChaCha20 performs well on all platforms
✓ Consistent performance across hardware

Embedded/IoT

IoT, Resource-Constrained

Recommended: Noise_NN_25519_ChaChaPoly_SHA256

✓ No static keys required (saves memory)
✓ Curve25519: small key size (32 bytes)
✓ ChaCha20: software-friendly cipher

Maximum Security

High-Security Applications

Recommended: Noise_XX_448_ChaChaPoly_SHA256

✓ Curve448: higher security margin
✓ Still fast: ~1,400 handshakes/sec
✓ Minimal throughput impact on transport

Performance Optimization Tips

1. Reuse Transport Objects

Avoid creating new handshakes for every message

Bad

for _ in range(1000):
    hs = NoiseHandshake(pattern)
    hs.initialize()
    # ... handshake ...
    transport = hs.to_transport()
    transport.send(data)

Good

# Setup once
hs = NoiseHandshake(pattern)
# ... complete handshake ...
transport = hs.to_transport()

for _ in range(1000):
    transport.send(data)

Performance gain: ~1000x faster (avoids handshake overhead)

2. Use Larger Messages When Possible

Batch small messages to amortize fixed overhead

Bad

for chunk in small_chunks:
    # Fixed overhead per call
    transport.send(chunk)

Good

batch = b"".join(small_chunks)
# Amortized overhead
transport.send(batch)

Performance gain: Up to 100x throughput improvement

3. Choose the Right Pattern

Balance security needs with performance requirements

NN: Fastest (no static keys), but no authentication
IK: Fast (1-RTT), but requires pre-shared public keys
XX: Balanced (mutual auth, 1.5-RTT)
Choose based on security needs, not just speed

Run Benchmarks Yourself

Reproduce these benchmarks on your own hardware

# Clone repository
git clone https://github.com/juliuspleunes4/noiseframework.git
cd noiseframework

# Setup environment
python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate

# Run benchmarks
python benchmark.py

View benchmark.py on GitHub

Conclusion

✓Fast handshakes: ~1,500-1,800 per second

✓High throughput: 3+ GB/s for large messages

✓Low latency: <3 µs per small message encryption

✓Efficient key generation: ~32,000 keypairs/sec (Curve25519)

✓Production-ready performance for most applications

NoiseFramework prioritizes correctness and security while maintaining competitive performance for a Python framework.