ark-ff 0.5.0

A library for finite fields
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use libtest_mimic::{run, Arguments, Failed, Trial};

use sha2::{Sha256, Sha384, Sha512};
use sha3::{Shake128, Shake256};
use std::{
    fs::{read_dir, File},
    io::BufReader,
    marker::PhantomData,
};

use super::{Expander, ExpanderXmd, ExpanderXof};

#[derive(Debug, serde_derive::Serialize, serde_derive::Deserialize)]
pub struct ExpanderVector {
    #[serde(rename = "DST")]
    pub dst: String,
    pub k: usize,
    pub hash: String,
    pub name: String,
    #[serde(rename = "tests")]
    pub vectors: Vec<TestExpander>,
}

#[derive(Debug, serde_derive::Serialize, serde_derive:: Deserialize)]
pub struct TestExpander {
    #[serde(rename = "DST_prime")]
    pub dst_prime: String,
    pub len_in_bytes: String,
    pub msg: String,
    pub msg_prime: String,
    pub uniform_bytes: String,
}

#[test]
fn expander() {
    let args = Arguments::from_args();
    let mut tests = Vec::<Trial>::new();

    for filename in read_dir("./src/fields/field_hashers/expander/testdata").unwrap() {
        let ff = filename.unwrap();
        let file = File::open(ff.path()).unwrap();
        let u: ExpanderVector = serde_json::from_reader(BufReader::new(file)).unwrap();

        tests.push(Trial::test(
            ff.file_name().to_str().unwrap().to_string(),
            move || do_test(u),
        ));
    }

    run(&args, tests).exit_if_failed();
}

#[derive(Copy, Clone)]
pub enum ExpID {
    XMD(HashID),
    XOF(XofID),
}

#[derive(Clone, Copy, PartialEq, Eq)]
pub enum HashID {
    SHA256,
    SHA384,
    SHA512,
}

#[derive(Clone, Copy, PartialEq, Eq)]
pub enum XofID {
    SHAKE128,
    SHAKE256,
}

fn do_test(data: ExpanderVector) -> Result<(), Failed> {
    let exp_id = match data.hash.as_str() {
        "SHA256" => ExpID::XMD(HashID::SHA256),
        "SHA384" => ExpID::XMD(HashID::SHA384),
        "SHA512" => ExpID::XMD(HashID::SHA512),
        "SHAKE128" => ExpID::XOF(XofID::SHAKE128),
        "SHAKE256" => ExpID::XOF(XofID::SHAKE256),
        _ => unimplemented!(),
    };
    let exp = get_expander(exp_id, data.dst.as_bytes(), data.k);
    for v in data.vectors.iter() {
        let len = usize::from_str_radix(v.len_in_bytes.trim_start_matches("0x"), 16).unwrap();
        let got = exp.expand(v.msg.as_bytes(), len);
        let want = hex::decode(&v.uniform_bytes).unwrap();
        if got != want {
            return Err(format!(
                "Expander: {}\nVector:   {}\ngot:  {:?}\nwant: {:?}",
                data.hash, v.msg, got, want,
            )
            .into());
        }
    }
    Ok(())
}

fn get_expander(id: ExpID, _dst: &[u8], k: usize) -> Box<dyn Expander> {
    let dst = _dst.to_vec();

    match id {
        ExpID::XMD(h) => match h {
            HashID::SHA256 => Box::new(ExpanderXmd {
                hasher: PhantomData::<Sha256>,
                block_size: 64,
                dst,
            }),
            HashID::SHA384 => Box::new(ExpanderXmd {
                hasher: PhantomData::<Sha384>,
                block_size: 128,
                dst,
            }),
            HashID::SHA512 => Box::new(ExpanderXmd {
                hasher: PhantomData::<Sha512>,
                block_size: 128,
                dst,
            }),
        },
        ExpID::XOF(x) => match x {
            XofID::SHAKE128 => Box::new(ExpanderXof {
                xofer: PhantomData::<Shake128>,
                k,
                dst,
            }),
            XofID::SHAKE256 => Box::new(ExpanderXof {
                xofer: PhantomData::<Shake256>,
                k,
                dst,
            }),
        },
    }
}