dat 0.1.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
56
57
58

use dat::crypt::CryptAlgorithm;
use dat::crypt::CryptAlgorithm::{AES128GCMN, AES256GCMN};
use dat::dat_key::{DatKeySet, DatKeySetActive};
use dat::error::DatError;
use dat::sign::SignAlgorithm;
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 unit(fail_key: &DatKeySetActive, kid: String, sign_alg: SignAlgorithm, crypt_alg: CryptAlgorithm, plain: String, secure: String) -> Result<(), DatError> {
    let tag = format!("dat_key.{}.{}.{}", sign_alg.to_str(), crypt_alg.to_str(), &kid);

    let new_key = DatKeySet::generate(kid, sign_alg, crypt_alg, now_unix_timestamp()? - 10, now_unix_timestamp()? + 600, 60)?;
    let new_key_str = new_key.to_json()?;
    let new_key_active = new_key.into_active()?;

    let read_key = DatKeySet::from_json(&new_key_str)?;
    let read_key_active = read_key.into_active()?;

    let dat = new_key_active.to_dat((plain.clone(), secure.clone()))?;
    println!("{tag}: {}", dat);

    let (de_plain, de_secure) = read_key_active.verify(dat.clone())?;
    assert_eq!(plain, de_plain);
    assert_eq!(secure, de_secure);
    assert!(fail_key.verify(dat.clone()).is_err());

    Ok(())
}


#[test]
fn test() {
    let sign_alg_arr = [P256, P384, P521];
    let crypt_alg_arr = [AES128GCMN, AES256GCMN];

    let fail_key = &DatKeySet::generate("x".to_string(), P256, AES256GCMN, now_unix_timestamp().unwrap() - 10, now_unix_timestamp().unwrap() + 600, 60).unwrap().into_active().unwrap();

    sign_alg_arr.iter().for_each(|sign_alg| {
        crypt_alg_arr.iter().for_each(|crypt_alg| {
            // random
            (1..20).for_each(|_| {
                let kid = rand_string();
                let plain = rand_string();
                let secure = rand_string();
                assert!(unit(fail_key, kid, *sign_alg, *crypt_alg, plain, secure).is_ok())
            });
            // empty
            assert!(unit(fail_key, "".to_string(), *sign_alg, *crypt_alg, "".to_string(), "".to_string()).is_ok())
        });
    });
}