Struct KeyManager 

pub struct KeyManager { /* private fields */ }

Manages FHE server keys for multiple clients

This structure provides thread-safe storage and retrieval of TFHE server keys. It supports both multi-client scenarios (where each client has their own key) and single-client scenarios (where a global key is used).

Example

use amaters_core::compute::KeyManager;
use tfhe::ServerKey;

let manager = KeyManager::new();

// Register a key for a client
let server_key = ServerKey::new(&client_key);
manager.register_key("client_1".to_string(), server_key);

// Retrieve the key
let key = manager.get_key("client_1").expect("Client key should exist");

// Set as global for convenience
manager.set_global("client_1")?;
let global_key = manager.get_global().expect("Global key should be set");

Implementations

impl KeyManager

pub fn new() -> Self

Create a new empty key manager

Example

use amaters_core::compute::KeyManager;

let manager = KeyManager::new();
assert_eq!(manager.key_count(), 0);

pub fn register_key(&self, client_id: ClientId, key: ServerKey)

Register a server key for a specific client

If a key already exists for this client, it will be replaced.

Arguments

• client_id - Unique identifier for the client
• key - The TFHE server key to register

Example

use amaters_core::compute::KeyManager;

let manager = KeyManager::new();
let server_key = ServerKey::new(&client_key);
manager.register_key("client_1".to_string(), server_key);

pub fn get_key(&self, client_id: &str) -> Option<Arc<ServerKey>>

Get server key for a specific client

Returns None if no key is registered for the given client.

Arguments

• client_id - The client identifier

Returns

An Arc<ServerKey> if found, None otherwise

Example

use amaters_core::compute::KeyManager;

let manager = KeyManager::new();
manager.register_key("client_1".to_string(), server_key);

let key = manager.get_key("client_1").expect("Key should exist");

pub fn set_global(&self, client_id: &str) -> Result<()>

Set a global server key from a registered client key

This is a convenience method for single-client scenarios where you want to use one client’s key as the default for all operations.

Arguments

• client_id - The client whose key should become the global key

Errors

Returns an error if no key is registered for the specified client.

Example

use amaters_core::compute::KeyManager;

let manager = KeyManager::new();
manager.register_key("default".to_string(), server_key);
manager.set_global("default")?;

let global = manager.get_global().expect("Global key should be set");

pub fn get_global(&self) -> Option<Arc<ServerKey>>

Get the global server key

Returns None if no global key has been set.

Returns

An Arc<ServerKey> if a global key is set, None otherwise

Example

use amaters_core::compute::KeyManager;

let manager = KeyManager::new();
assert!(manager.get_global().is_none());

manager.register_key("default".to_string(), server_key);
manager.set_global("default")?;
assert!(manager.get_global().is_some());

pub fn remove_key(&self, client_id: &str) -> bool

Remove a client’s key

Returns true if the key was found and removed, false otherwise.

Arguments

• client_id - The client identifier

Returns

true if a key was removed, false if no key was found

Example

use amaters_core::compute::KeyManager;

let manager = KeyManager::new();
manager.register_key("client_1".to_string(), server_key);

assert!(manager.remove_key("client_1"));
assert!(!manager.remove_key("client_1")); // Already removed

pub fn key_count(&self) -> usize

Get the number of registered keys

Returns

The count of currently registered client keys

Example

use amaters_core::compute::KeyManager;

let manager = KeyManager::new();
assert_eq!(manager.key_count(), 0);

manager.register_key("client_1".to_string(), server_key);
assert_eq!(manager.key_count(), 1);

pub fn clear(&self)

Clear all registered keys (including global)

This removes all client keys and clears the global key.

Example

use amaters_core::compute::KeyManager;

let manager = KeyManager::new();
manager.register_key("client_1".to_string(), server_key);
manager.set_global("client_1")?;

manager.clear();
assert_eq!(manager.key_count(), 0);
assert!(manager.get_global().is_none());

Trait Implementations

impl Default for KeyManager

fn default() -> KeyManager

Returns the “default value” for a type.