abe_policy 3.0.0

Policy and attributes definition for ABE cryptosystems
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

use crate::{EncryptionHint, Error, Policy, PolicyAxis};
use js_sys::{Array, Boolean, JsString, Reflect};
use wasm_bindgen::{prelude::wasm_bindgen, JsValue};

#[wasm_bindgen]
extern "C" {
    #[wasm_bindgen(typescript_type = "Array<string>")]
    pub type Attributes;
}

#[wasm_bindgen]
extern "C" {
    #[wasm_bindgen(typescript_type = "{name: string, isHybridized: boolean}")]
    pub type AttributeProperty;
}

#[wasm_bindgen]
pub fn webassembly_policy_axis(
    name: String,
    attribute_properties: Vec<AttributeProperty>,
    is_hierarchical: bool,
) -> Result<String, JsValue> {
    let attribute_properties = attribute_properties
        .into_iter()
        .map(|obj| -> Result<(String, EncryptionHint), JsValue> {
            let name = String::from(JsString::from(Reflect::get(
                &obj,
                &JsValue::from_str("name"),
            )?));
            let encryption_hint = bool::from(Boolean::from(Reflect::get(
                &obj,
                &JsValue::from_str("name"),
            )?));
            let encryption_hint = if encryption_hint {
                EncryptionHint::Hybridized
            } else {
                EncryptionHint::Classic
            };
            Ok((name, encryption_hint))
        })
        .collect::<Result<Vec<_>, _>>()?;

    serde_json::to_string(&PolicyAxis::new(
        &name,
        attribute_properties
            .iter()
            .map(|(name, encryption_hint)| (name.as_str(), *encryption_hint))
            .collect(),
        is_hierarchical,
    ))
    .map_err(|e| JsValue::from_str(&e.to_string()))
}

#[wasm_bindgen]
pub fn webassembly_policy(nb_creations: u32) -> Result<String, JsValue> {
    serde_json::to_string(&Policy::new(nb_creations)).map_err(|e| JsValue::from_str(&e.to_string()))
}

#[wasm_bindgen]
pub fn webassembly_add_axis(policy: Vec<u8>, axis: String) -> Result<String, JsValue> {
    let mut policy = Policy::parse_and_convert(&policy)?;
    policy.add_axis(serde_json::from_str(&axis).map_err(Error::DeserializationError)?)?;
    serde_json::to_string(&policy).map_err(|e| JsValue::from_str(&e.to_string()))
}

/// Rotates attributes, changing their underlying values with that of an unused
/// slot
///
/// - `attributes`  : user access policy (boolean expression as string)
/// - `policy`      : global policy data (JSON)
#[wasm_bindgen]
pub fn webassembly_rotate_attributes(
    attributes: Attributes,
    policy: Vec<u8>,
) -> Result<Vec<u8>, JsValue> {
    let attributes = Array::from(&JsValue::from(attributes));
    let mut policy = Policy::parse_and_convert(&policy)?;

    // Rotate attributes of the current policy
    for attr in attributes.values() {
        let attribute = serde_json::from_str(String::from(JsString::from(attr?)).as_str())
            .map_err(Error::DeserializationError)?;
        policy.rotate(&attribute)?;
    }

    Ok(serde_json::to_vec(&policy).map_err(Error::DeserializationError)?)
}