dat 1.1.1

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
56
57

use dat::dat_bank::DatBank;
use dat::dat_key::DatKey;
use dat::error::DatError;
use dat::util::now_unix_timestamp;
use rand::RngExt;
use dat::crypto_algorithm::CryptoAlgorithm::{AES128GCMN, AES256GCMN};
use dat::signature_algorithm::SignatureAlgorithm::{P256, P384, P521};
use dat::signature_key::SignatureKeyOutOption;

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

fn gen_keys(store: &DatBank<i64>) -> Result<(), DatError> {
    let sign_alg_arr = [P256, P384, P521];
    let crypto_alg_arr = [AES128GCMN, AES256GCMN];
    let mut keys: Vec<DatKey<i64>> = vec![];
    let now = now_unix_timestamp();
    let mut i = 0;
    sign_alg_arr.iter().for_each(|sign_alg| {
        crypto_alg_arr.iter().for_each(|crypto_alg| {
            (1..5).for_each(|_| {
                let kid = i;
                i += 1;
                keys.push(DatKey::generate(kid, *sign_alg, *crypto_alg, now - 10, now + 600, 60).unwrap());
            });
        });
    });
    store.import_keys(keys, false)?;
    Ok(())
}

#[test]
fn test() {
    let bank = DatBank::<i64>::new();

    gen_keys(&bank).unwrap();
    assert!(gen_keys(&bank).is_ok());

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

    // copy keys
    let keys = bank.export_keys_format(SignatureKeyOutOption::FULL);
    let bank2: DatBank<i64> = DatBank::new();
    bank2.import_keys_format(keys, true).unwrap();

    // verify
    for dat in dat_list.iter() {
        let (plain, secure) = bank2.to_payload_verify(&dat).unwrap();
        println!("bank plain:{}.secure:{}", plain, secure);
    }
}