rabe 0.4.2

ABE Schemes implemented in rust.
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

use rabe_bn::*;
use std::collections::HashSet;
use utils::policy::pest::{PolicyValue, PolicyType};
use utils::secretsharing::node_index;

pub fn is_negative(attr: &String) -> bool {
    let first_char = &attr[..1];
    return first_char == '!'.to_string();
}

pub fn usize_to_fr(i: usize) -> Fr {
    return Fr::from_str(&i.to_string()).unwrap();
}

pub fn contains(data: &Vec<String>, value: &String) -> bool {
    let len = data.into_iter()
        .filter(|&i| i == value)
        .collect::<Vec<_>>()
        .len();
    return len >= 1;
}

// used to check if a set of attributes is a subset of another
pub fn is_subset(subset: &[&str], attr: &[&str]) -> bool {
    let super_set: HashSet<_> = attr.iter().cloned().collect();
    let sub_set: HashSet<_> = subset.iter().cloned().collect();
    return sub_set.is_subset(&super_set);
}

// used to traverse / check policy tree
pub fn traverse_policy(attr: &Vec<String>, policy_value: &PolicyValue, policy_type: PolicyType) -> bool {
    return (attr.len() > 0) && match policy_value {
        PolicyValue::String(node) => (&attr).into_iter().any(|x| x == node.0),
        PolicyValue::Object(obj) => {
            return match obj.0 {
                PolicyType::And => traverse_policy(attr, &obj.1.as_ref(), PolicyType::And),
                PolicyType::Or => traverse_policy(attr, &obj.1.as_ref(), PolicyType::Or),
                _ => true,
            }
        },
        PolicyValue::Array(arrayref) => {
            return match policy_type {
                PolicyType::And => {
                    let mut ret = true;
                    for obj in arrayref.iter() {
                        ret &= traverse_policy(attr, obj, PolicyType::Leaf)
                    }
                    ret
                },
                PolicyType::Or => {
                    let mut ret = false;
                    for obj in arrayref.iter() {
                        ret |= traverse_policy(attr, obj, PolicyType::Leaf)
                    }
                    ret
                }
                PolicyType::Leaf => false
            };
        }
    };
}

pub fn get_value(_json: &PolicyValue) -> String {
    return match _json {
        PolicyValue::String(node) => node_index(node),
        _ => "".to_string()
    }
}

#[cfg(test)]
mod tests {

    use super::*;
    use utils::policy::pest::{PolicyLanguage, parse};

    #[test]
    fn test_traverse() {
        let policy_false = String::from(r#"what-the-heck?"#);
        let policy1 = String::from(r#"{"name": "and", "children": [{"name": "A"}, {"name": "B"}]}"#);
        let policy2 = String::from(r#"{"name": "or", "children": [{"name": "A"}, {"name": "B"}]}"#);
        let policy3 = String::from(r#"{"name": "and", "children": [{"name":"or", "children": [{"name": "C"}, {"name": "D"}]}, {"name": "B"}]}"#);
        let mut _set0: Vec<String> = Vec::new();
        _set0.push(String::from("X"));
        _set0.push(String::from("Y"));

        let mut _set1: Vec<String> = Vec::new();
        _set1.push(String::from("A"));
        _set1.push(String::from("B"));

        let mut _set2: Vec<String> = Vec::new();
        _set2.push(String::from("C"));
        _set2.push(String::from("D"));

        let mut _set3: Vec<String> = Vec::new();
        _set3.push(String::from("A"));
        _set3.push(String::from("B"));
        _set3.push(String::from("C"));
        _set3.push(String::from("D"));

        assert_eq!(parse(policy_false.as_ref(), PolicyLanguage::JsonPolicy).is_ok() , false);

        match parse(policy1.as_ref(), PolicyLanguage::JsonPolicy) {
            Ok(pol) => {
                assert_eq!(traverse_policy(&_set0, &pol, PolicyType::Leaf), false);
                assert_eq!(traverse_policy(&_set1, &pol, PolicyType::Leaf), true);
                assert_eq!(traverse_policy(&_set2, &pol, PolicyType::Leaf), false);
                assert_eq!(traverse_policy(&_set3, &pol, PolicyType::Leaf), true);
            },
            Err(e) => println!("test_traverse: could not parse policy1 {}", e)
        }

        match parse(policy2.as_ref(), PolicyLanguage::JsonPolicy) {
            Ok(pol) => {
                assert_eq!(traverse_policy(&_set1, &pol, PolicyType::Leaf), true);
                assert_eq!(traverse_policy(&_set2, &pol, PolicyType::Leaf), false);
                assert_eq!(traverse_policy(&_set3, &pol, PolicyType::Leaf), true);
            },
            Err(e) => println!("test_traverse: could not parse policy2 {}", e)
        }

        match parse(policy3.as_ref(), PolicyLanguage::JsonPolicy) {
            Ok(pol) => {
                assert_eq!(traverse_policy(&_set1, &pol, PolicyType::Leaf), false);
                assert_eq!(traverse_policy(&_set2, &pol, PolicyType::Leaf), false);
                assert_eq!(traverse_policy(&_set3, &pol, PolicyType::Leaf), true);
            },
            Err(e) => println!("test_traverse: could not parse policy3 {}", e)
        }
    }
}