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

// Copyright 2020 Contributors to the Parsec project.
// SPDX-License-Identifier: Apache-2.0
use crate::{
    handles::AuthHandle,
    tss2_esys::{ESYS_TR, ESYS_TR_RH_OWNER, ESYS_TR_RH_PLATFORM},
    utils::Hierarchy,
    Error, Result, WrapperErrorKind,
};
use log::error;
use std::convert::{From, TryFrom};
/// Enum representing the only type of authorizations
/// allowed.
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub enum NvAuthorization {
    Owner,
    Platform,
}

impl From<NvAuthorization> for Hierarchy {
    fn from(nv_auhtorization: NvAuthorization) -> Hierarchy {
        match nv_auhtorization {
            NvAuthorization::Owner => Hierarchy::Owner,
            NvAuthorization::Platform => Hierarchy::Platform,
        }
    }
}

impl TryFrom<Hierarchy> for NvAuthorization {
    type Error = Error;

    fn try_from(hierarchy: Hierarchy) -> Result<NvAuthorization> {
        match hierarchy {
            Hierarchy::Owner => Ok(NvAuthorization::Owner),
            Hierarchy::Platform => Ok(NvAuthorization::Platform),
            _ => {
                error!("Error: Found invalid value when trying to convert Hierarchy to NV Authroization.");
                Err(Error::local_error(WrapperErrorKind::InvalidParam))
            }
        }
    }
}

impl TryFrom<AuthHandle> for NvAuthorization {
    type Error = Error;
    fn try_from(auth_handle: AuthHandle) -> Result<NvAuthorization> {
        match auth_handle.value() {
            ESYS_TR_RH_OWNER => Ok(NvAuthorization::Owner),
            ESYS_TR_RH_PLATFORM => Ok(NvAuthorization::Platform),
            _ => {
                error!("Error: Found invalid value when trying convert from auth handle");
                Err(Error::local_error(WrapperErrorKind::InvalidParam))
            }
        }
    }
}

impl From<NvAuthorization> for AuthHandle {
    fn from(nv_auhtorization: NvAuthorization) -> AuthHandle {
        match nv_auhtorization {
            NvAuthorization::Owner => AuthHandle::from(ESYS_TR_RH_OWNER),
            NvAuthorization::Platform => AuthHandle::from(ESYS_TR_RH_PLATFORM),
        }
    }
}

impl From<NvAuthorization> for ESYS_TR {
    fn from(nv_auhtorization: NvAuthorization) -> ESYS_TR {
        match nv_auhtorization {
            NvAuthorization::Owner => ESYS_TR_RH_OWNER,
            NvAuthorization::Platform => ESYS_TR_RH_PLATFORM,
        }
    }
}

impl TryFrom<ESYS_TR> for NvAuthorization {
    type Error = Error;

    fn try_from(esys_tr: ESYS_TR) -> Result<NvAuthorization> {
        match esys_tr {
            ESYS_TR_RH_OWNER => Ok(NvAuthorization::Owner),
            ESYS_TR_RH_PLATFORM => Ok(NvAuthorization::Platform),
            _ => {
                error!("Error: Found invalid value when trying parse NV Authroization");
                Err(Error::local_error(WrapperErrorKind::InvalidParam))
            }
        }
    }
}