6 posts tagged with "cryptography"

This week, the Leios team made significant progress across multiple areas. Major developments included detailed DeltaQ analysis of network topologies, extensive BLS cryptography benchmarking, and improvements to both simulations. The team also explored succinct schemes for BLS key registration and conducted a detailed certificate performance analysis. Both Haskell and Rust simulations received substantial updates to improve visualization and support more realistic testing conditions.

DeltaQ analysis​

• Enhanced the topology-checker with ΔQSD analysis capabilities:
  • Extracts inter-node latencies from given topologies
  • Classifies latencies into near/far components
  • Builds parameterized ΔQ models
  • Outputs fitted models in delta_q web app syntax
• Key findings from topology analysis:
  • Clear distinction between near/far components in examined topologies
  • Unexpectedly high hop counts in latency-weighted Dijkstra paths:
    • Min 4-5, max 8 for topology - 100
    • Min 8, max 20 for 'realistic' topology
  • Model fitting achieved rough shape matching but showed significant deviations at low latencies
  • Resource usage tracking goals remain unmet due to complexity in understanding load multiplication factors.

BLS cryptography​

• Completed comprehensive benchmarking of certificate operations:
  • Detailed performance analysis across committee sizes (500-1000 seats)
  • Certificate generation: 63.4ms - 92.5ms
  • Certificate verification: 104.8ms - 144.9ms
  • Certificate weighing: ~12ms consistently
• Explored succinct schemes for key registration:
  • Proposed 90-day key evolution with 124-byte KZG commitments
  • Analyzed message sizes for key opening (316 bytes per pool)
  • Investigated SNARK-based alternatives for proof of possession
• Added BLS crypto to the CI pipeline with automated testing
• Documented parallelization strategies for certificate operations.

Formal methods​

• Added a conformance testing client for the executable Short Leios specification
• Successfully merged the executable specification for Simplified Leios into main.

Haskell simulation​

• Updated configuration defaults for block sizes and timings
• Added support for idealized simulation conditions:
  • Single-peer block body requests
  • TCP congestion window modeling
  • Mini-protocol multiplexing
  • Unlimited bandwidth links support
• Enhanced simulation output and analysis:
  • Added raw field for accumulated data
  • Implemented block diffusion CDF extraction
  • Created multi-CDF plotting capabilities.

Rust simulation​

• Enhanced visualization capabilities:
  • Added block size breakdown display
  • Implemented total bytes sent/received tracking
  • Added total TX count and CPU time metrics
• Improved event handling:
  • Updated to standard timestamp format (seconds)
  • Enhanced CPU task event structure
  • Added CBOR output support
• Added support for multiple strategies:
  • Implemented ib-diffusion-strategy (freshest-first, oldest-first, peer-order)
  • Added relay-strategy affecting TXs, IBs, EBs, votes, and RBs
  • Enabled unlimited EB and vote bundle downloads from peers.

This week, the Leios team worked on cryptography benchmarking and cost calculator improvements. The team completed a reference implementation for Leios cryptography and enhanced the online cost calculator with user-requested features. They also updated both Haskell and Rust simulations to improve visualization and network modeling capabilities.

Haskell simulation​

• Added support for Send and Receive voting stages, providing:
  • A new leios-vote-send-recv-stages configuration option
  • A configurable stage length via leios-stage-active-voting-slots
• Implemented multiple diffusion strategies:
  • Added oldest-first strategy
  • Added configurable strategies for IBs, EBs, and votes via *-diffusion-strategy configurations
• Created a new small scenario for 100 nodes with 2,000 kB links
  • Tuned IB parameters to utilize one-third of link capacity
  • Added configurations for both single-stage and send-recv voting
• Fixed several simulation behaviors:
  • Improved block generation logic
  • Prevented duplicate EB inclusion in the base chain
  • Confirmed proper EB inclusion timing relative to vote diffusion
• The main difference observed between single-stage and send-recv is that the former shows a longer tail in the CPU usage CDF when the simulation is run with unlimited cores.

Cryptography implementation​

The Rust benchmarks for Leios cryptography were redesigned as a reference implementation:

• Implemented the Fait Accompli sortition
• Enhanced sortition to use rational arithmetic instead of quad-precision floats
• Added Quickcheck tests for all capabilities
• Added benchmarks for serialization
• Optimized vote and certificate size.

Cost calculator improvements​

The team enhanced the online Leios cost calculator:

• Added support for both hyperscale and discount cloud providers
• Made discount providers the default option
• Added option to amortize storage costs perpetually
• Updated defaults:
  • Single relay deployment
  • More conservative 50% disk compression
  • Perpetual storage cost amortization.

Throughput simulator​

The team updated the Cardano throughput simulator with:

• The latest cloud-computing cost model
• Synchronized assumptions with an online cost calculator.

Rust simulation​

• Made minor fixes to the new graph generation strategy
• Planned out a roadmap for visualization work focusing on the Leios transaction lifecycle.

Cryptography benchmarks​

• Implemented and benchmarked the complete Leios cryptography suite in the leios_crypto_benchmarks Rust crate
• Key VRF performance metrics:
  • Proving: 240 µs
  • Verifying: 390 µs
• Sortition performance (excluding VRF):
  • Leadership checks (RB/IB/EB): 0.17 µs per slot/pipeline
  • Vote number calculation: 3.8 µs per pipeline
• BLS operations benchmarked:
  • Key possession proof verification: 1.5 ms per key
  • Vote generation/verification: 280 µs / 1.4 ms per vote
  • Certificate operations (300-vote quorum): 50 ms generation, 90 ms verification.

Cryptography design progress​

• Optimized vote signature size to potentially as small as 192 bytes
• Determined that 500-vote committee certificates (60% quorum) would fit within Praos blocks at ~58 kB
• Explored potential synergies with KES rotation and Praos VRF BLS keys
• Completed cryptography sections for the first technical report
• Decision made to freeze current report content and move new findings to future documents.

Simulation development​

Haskell simulation​

• Achieved diffusion latency comparable to benchmark cluster data for Praos blocks
• Integrated agreed-upon simulation parameters with the Rust team
• Added event log output functionality with JSON support
• Implemented 'short-leios' simulation variant matching mainnet ranking block interval
• Fixed coordination issues in Relay mini-protocol consumers
• Completed the PI goal by adding total data transmitted per node visualization.

Rust simulation​

• Implemented more granular CPU simulation times
• Fixed race condition in the simulated clock
• Started consuming a new shared configuration file format
• Established a shared configuration format with default parameters in data/simulation/default.yaml.

Rust simulation​

• Added a basic simulation of central processing unit (CPU) usage/latency
• Implemented 'lottery won' events to identify the start of CPU processing
• Configured each node with four simulated cores, adjustable per node
• Transaction validation and ranking block/input block/endorser block generation/validation each take one CPU task
• All virtual CPU costs were copied from the cost estimator.

DeltaQ summary update​

• Added MIN/MAX combinators for best- and worst-case simulation results
• The Rust simulation best case does not match the analytically best behavior
• The Haskell simulation best case is too fast; the ΔQ expression must assume more than 200 peers per node.

Cost dashboard updates​

• Improved input parameters and computations
• Lengthened phases and reduced endorser block rate
• Updated CPU costs for votes and certificates
• Revised input/output operations per second (IOPS) values based on empirical data from Cardano nodes.

Benchmarking BLS signatures​

• Benchmarked BLS votes using the Rust bls-signatures package
• Aggregate verification significantly speeds up the process
• Provided CPU time estimates for various operations.

Votes and certificates​

• Updated size estimates for votes
• Added CPU time estimates for BLS votes and certificates
• Drafted technical report sections on BLS and MUSEN certificates.

Sortition analysis​

• Analyzed sortition for input and endorser blocks and votes
• Added findings to the draft of the first technical report.

Rust simulation​

• Abandoned Waxman graph generation favoring a more straightforward distance-weighted approach to better control graph connectivity.

Haskell simulation​

• Added support for bounded and unbounded parallelism to the Leios node
• Fixed relay protocol messages to ensure ordered delivery
• Next steps include loading protocol configuration from disk and investigating endorser block (EB) inclusion rates.

Revised analysis of votes and certificates​

• Continued research on cryptographic options for Leios votes and certificates
• BLS was identified as the most viable option.

Jupyter support for DeltaQ​

• Introduced new high-performance Haskell packages for DeltaQ with comprehensive test suites.

Rust simulation​

• Optimized virtual clock to be lock-free, removing contention from the previous implementation.

Haskell simulation​

• Merged Leios visualizations on main
• Improved peer-to-peer (P2P) visualization with block type differentiation and latency charting.

Analysis of vote size and ALBA certificates​

• Estimated minimum possible size for votes using ephemeral keys or key evolving signatures (KES)
• Benchmarked central processing unit (CPU) time for ALBA certificates.