dat 0.2.0

DAT - Data Access Token
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

use dat::crypt::CryptAlgorithm::{AES128GCMN, AES256GCMN};
use dat::dat_key::DatKeySet;
use dat::dat_key_store::DatKeyStore;
use dat::error::DatError;
use dat::sign::SignAlgorithm::{P256, P384, P521};
use dat::util::now_unix_timestamp;
use rand::RngExt;

fn rand_string() -> String {
    let mut rng = rand::rng();
    (0..100).map(|_| { rng.sample(rand::distr::Alphanumeric) as char }).collect()
}

fn gen_keys(store: &DatKeyStore) -> Result<(), DatError> {
    let sign_alg_arr = [P256, P384, P521];
    let crypt_alg_arr = [AES128GCMN, AES256GCMN];
    let mut keys: Vec<DatKeySet> = vec![];
    let now = now_unix_timestamp()?;
    sign_alg_arr.iter().for_each(|sign_alg| {
        crypt_alg_arr.iter().for_each(|crypt_alg| {
            (1..5).for_each(|_| {
                let kid = rand_string();
                keys.push(DatKeySet::generate(kid, *sign_alg, *crypt_alg, now - 10, now + 600, 60).unwrap());
            });
        });
    });
    store.add_keys(keys, true)?;
    store.apply()?;
    Ok(())
}

#[test]
fn test() {
    let store = DatKeyStore::new();

    assert!(gen_keys(&store).is_ok());

    // get all keys
    let dat_list = store.get_keys().iter().map(|key| {
        let act = key.clone().into_active().unwrap();
        act.to_dat((rand_string(), rand_string())).unwrap()
    }).collect::<Vec<String>>();

    // copy keys
    let keys = store.format();
    let store2 = DatKeyStore::new();
    store2.add_keys_by_format(keys, true).unwrap();
    store2.apply().unwrap();

    // verify
    for dat in dat_list.iter() {
        let (plain, secure) = store2.verify(dat.clone()).unwrap();
        println!("plain: {}, secure: {}", plain, secure);
    }
}