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

use bitfield::bitfield;
use bytes::Buf;
use serde_derive::Serialize;

#[derive(Serialize, Debug, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum KeyConfigType {
    Ecc,
    NotEcc,
}

impl From<u8> for KeyConfigType {
    fn from(v: u8) -> Self {
        match v & 4 == 4 {
            true => Self::Ecc,
            _ => Self::NotEcc,
        }
    }
}

impl From<KeyConfigType> for u8 {
    fn from(v: KeyConfigType) -> Self {
        match v {
            KeyConfigType::Ecc => 4,
            KeyConfigType::NotEcc => 7,
        }
    }
}

impl From<&[u8]> for KeyConfig {
    fn from(v: &[u8]) -> Self {
        let mut buf = v;
        Self(buf.get_u16())
    }
}

bitfield! {
    #[derive(PartialEq)]
    pub struct KeyConfig(u16);
    impl Debug;

    u8, auth_key, set_auth_key: 3, 0;
    intrusion_disable, set_intrusion_disable: 4;
    u8, x509_index, set_x509_index: 7, 6;

    private, set_private: 8;
    pub_info, set_pub_info: 9;
    u8, from into KeyConfigType, key_type, set_key_type: 12, 10;
    lockable, set_is_lockable: 13;
    req_random, set_req_random: 14;
    req_auth, set_req_auth: 15;
}

impl From<u16> for KeyConfig {
    fn from(v: u16) -> Self {
        Self(v)
    }
}

impl From<KeyConfig> for u16 {
    fn from(v: KeyConfig) -> Self {
        v.0
    }
}

impl From<&KeyConfig> for u16 {
    fn from(v: &KeyConfig) -> Self {
        v.0
    }
}

///  Returns a key configuration set up to store ECC key private keys.
impl Default for KeyConfig {
    fn default() -> Self {
        let mut result = KeyConfig(0);
        result.set_key_type(KeyConfigType::Ecc);
        result.set_is_lockable(true);
        result.set_private(true);
        result.set_pub_info(true);
        result
    }
}

impl serde::ser::Serialize for KeyConfig {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut state = serializer.serialize_struct("key_config", 9)?;
        state.serialize_field("auth_key", &self.auth_key())?;
        state.serialize_field("intrusion_disable", &self.intrusion_disable())?;
        state.serialize_field("x509_index", &self.x509_index())?;
        state.serialize_field("private", &self.private())?;
        state.serialize_field("pub_info", &self.pub_info())?;
        state.serialize_field("key_type", &self.key_type())?;
        state.serialize_field("lockable", &self.lockable())?;
        state.serialize_field("req_random", &self.req_random())?;
        state.serialize_field("req_auth", &self.req_auth())?;

        state.end()
    }
}