key_handling.rs

Overview

The key_handling.rs file provides functionality to load cryptographic key pairs from a JSON file into memory. It focuses on deserializing keys used by a BLS (Boneh–Lynn–Shacham) signature scheme, along with an associated random seed for each key pair. This file is essential for initializing cryptographic components that rely on BLS keys and ensuring that the keys and seeds are correctly parsed from external storage into usable Rust types.

Functionality

key_pairs_from_file<T>

Purpose

Reads a JSON file containing an array of key pairs and random seeds, parses each entry, and returns a map from public keys to tuples of secret keys and random seeds.

Signature

pub fn key_pairs_from_file<T>(keys_path: &str) -> HashMap<T::PubKey, (T::Secret, RndSeed)>
where
    T: BLSSignatureScheme,
    T::PubKey: FromStr + Sized + Hash + Eq,
    <T::PubKey as FromStr>::Err: Debug,
    T::Secret: FromStr + Sized,
    <T::Secret as FromStr>::Err: Debug,

Parameters

• keys_path: &str
  The file path to a JSON file containing the key data.

Returns

• HashMap<T::PubKey, (T::Secret, RndSeed)>
  A hash map where each key is a public key, and each value is a tuple consisting of the corresponding secret key and a random seed.

Detailed Behavior

• Reads the entire JSON file into a string.

• Parses the JSON into a vector of hash maps (Vec<HashMap<String, String>>), where each map corresponds to a key pair entry.

• For each map in the vector:

  • Extracts strings for "public", "secret", and "rnd" keys.

  • Converts these strings into typed values:

    • Public key of type T::PubKey, using the FromStr trait.

    • Secret key of type T::Secret, also using FromStr.

    • Random seed of type RndSeed, parsed via FromStr.

• Collects these into a hash map with public keys as keys and (secret, rnd_seed) tuples as values.

• Uses expect for error handling with descriptive messages for file reading, JSON parsing, and key decoding errors.

Usage Example

use crate::bls::MyBLSScheme;

let key_map: HashMap<MyBLSScheme::PubKey, (MyBLSScheme::Secret, RndSeed)> =
    key_pairs_from_file::<MyBLSScheme>("path/to/keys.json");

This code reads a JSON file "path/to/keys.json", expecting it to contain an array of objects, each with "public", "secret", and "rnd" string fields representing keys and seeds encoded as strings. It returns a map usable in cryptographic operations.

Implementation Details

• The function is generic over any type T implementing the BLSSignatureScheme trait, making it flexible for various BLS schemes.

• It requires that the public and secret key types implement FromStr for conversion from their string representations.

• The JSON structure expected is an array of objects, each object having string fields "public", "secret", and "rnd".

• Uses Rust's tracing::trace! macro to log the file path being read, aiding debugging and observability.

• Errors during file reading or parsing are handled via expect, which will panic with an explanatory message if something goes wrong. This is suitable for initialization code where failure to load keys should be fatal.

Interaction with Other Components

• BLSSignatureScheme Trait (crate::bls::BLSSignatureScheme)
  The generic parameter T must implement this trait, indicating that the keys are compatible with the BLS cryptographic functions defined there.

• Random Seed Type (crate::types::RndSeed)
  RndSeed represents a random seed associated with each key pair, parsed alongside the keys. This might be used for deterministic randomness in cryptographic protocols.

• File I/O and JSON Parsing
  Uses Rust standard library for file reading and the serde_json crate for JSON deserialization, linking external data to internal cryptographic structures.

This file is typically used during system initialization, where key material needs to be loaded from persistent storage into runtime structures usable by cryptographic operations.

Mermaid Diagram

flowchart TD
A[key_pairs_from_file<T>] -->|Read keys_path| B[Read JSON file]
B --> C[Parse JSON into Vec<HashMap<String,String>>]
C --> D[Iterate over each HashMap]
D --> E[Extract "public", "secret", "rnd" strings]
E --> F[Parse public key: T::PubKey::from_str]
E --> G[Parse secret key: T::Secret::from_str]
E --> H[Parse rnd seed: RndSeed::from_str]
F --> I["Collect (public, (secret, rnd_seed)) pairs"]
G --> I
H --> I
I --> J["Return HashMap<T::PubKey, (T::Secret, RndSeed)>"]