artisan_keystore 2.1.1

A keystore server designed for AH
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use ais_keystore_lib::{
    get_key_data,
    grpc::keystore::{key_store_client::KeyStoreClient, KeyStatus},
    key_store::store::generate_new_key,
    migrate_key,
    shared::consts::{ADDR, PORT},
    store_key,
};
use dusa_collection_utils::platform::functions::generate_random_string;
use std::time::{Duration, Instant};
use tonic::transport::Channel;

#[tokio::main]
async fn main() {
    // const MIN_TTL: u64 = 20; // Minimum TTL in seconds

    // Generate a random key ID
    let key_id = generate_random_string(10).unwrap();

    let key_value = generate_new_key(Some(32));

    let addr = format!("http://{}:{}", ADDR, PORT);
    let mut client: KeyStoreClient<Channel> = KeyStoreClient::connect(addr).await.unwrap();

    // Store the key with a TTL
    store_key(&mut client, key_id.clone(), key_value, Some(60))
        .await
        .unwrap();

    // println!("Key '{}' stored with a minimum TTL of {} seconds", key_id, MIN_TTL);
    println!("Key '{}' stored with default ttl settings", key_id);

    // Periodically check the key status
    let mut start_time = Instant::now();
    loop {
        tokio::time::sleep(Duration::from_secs(5)).await;
        let elapsed = start_time.elapsed().as_secs();

        let key_data = get_key_data(&mut client, key_id.clone(), None)
            .await
            .unwrap();

        {
            let status = KeyStatus::try_from(key_data.status).unwrap_or(KeyStatus::Invalid);
            println!("Key status: {:?}", status);
            let time_left = if key_data.ttl > elapsed {
                key_data.ttl - elapsed
            } else {
                0
            };
            println!("Time left until expiration: {} seconds", time_left);

            if status == KeyStatus::Expired {
                println!("Key '{}' has expired. Attempting migration.", key_id);

                match migrate_key(&mut client, key_id.clone()).await {
                    Ok(_) => {
                        println!("Migration successful");
                        start_time = Instant::now();
                    }
                    Err(_) => {
                        println!("Unexpected response during migration");
                    }
                }
            }
        }
    }
}

// TODO auditing system
// TODO     - add ip tracking to the audit
// TODO logging system
// TODO add some RBAC based on conditions a client must give
// TODO seperation and permissions user / key _ x