kryoptic-lib 1.5.0

A PKCS #11 software token written in Rust
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
132

// Copyright 2024 Simo Sorce
// See LICENSE.txt file for terms

use crate::attribute::Attribute;
use crate::error::Result;
use crate::hash::is_valid_hash;
use crate::mechanism::{Derive, MechOperation, Mechanisms};
use crate::misc::{
    bytes_to_slice, cast_params, common_derive_data_object,
    common_derive_key_object,
};
use crate::object::{Object, ObjectFactories};
use crate::ossl::common::{mech_type_to_digest_alg, osslctx};
use crate::pkcs11::vendor::KR_SSHKDF_PARAMS;
use crate::pkcs11::*;

use ossl::derive::{SshKdfPurpose, SshkdfDerive};

#[cfg(feature = "fips")]
use crate::fips::FipsApproval;

#[derive(Debug)]
pub struct SSHKDFOperation {
    mech: CK_MECHANISM_TYPE,
    finalized: bool,
    prf: CK_MECHANISM_TYPE,
    purpose: SshKdfPurpose,
    exchange_hash: &'static [u8], /* TODO: static -> a */
    session_id: &'static [u8],    /* TODO: static -> a */
    #[cfg(feature = "fips")]
    fips_approval: FipsApproval,
}

impl SSHKDFOperation {
    pub fn new(mech: &CK_MECHANISM) -> Result<SSHKDFOperation> {
        let params = cast_params!(mech, KR_SSHKDF_PARAMS);

        if !is_valid_hash(params.prfHashMechanism) {
            return Err(CKR_MECHANISM_PARAM_INVALID)?;
        }

        let purpose = match params.derivedKeyType {
            b'A' => SshKdfPurpose::InitialIVClientToServer,
            b'B' => SshKdfPurpose::InitialIVServerToClient,
            b'C' => SshKdfPurpose::EncryptioKeyClientToServer,
            b'D' => SshKdfPurpose::EncryptioKeyServerToClient,
            b'E' => SshKdfPurpose::IntegrityKeyClientToServer,
            b'F' => SshKdfPurpose::IntegrityKeyServerToClient,
            _ => return Err(CKR_MECHANISM_PARAM_INVALID)?,
        };

        Ok(SSHKDFOperation {
            mech: mech.mechanism,
            finalized: false,
            prf: params.prfHashMechanism,
            purpose: purpose,
            exchange_hash: bytes_to_slice!(
                params.pExchangeHash,
                params.ulExchangeHashLen,
                u8
            ),
            session_id: bytes_to_slice!(
                params.pSessionId,
                params.ulSessionIdLen,
                u8
            ),
            #[cfg(feature = "fips")]
            fips_approval: FipsApproval::init(),
        })
    }
}

impl MechOperation for SSHKDFOperation {
    fn mechanism(&self) -> Result<CK_MECHANISM_TYPE> {
        Ok(self.mech)
    }

    fn finalized(&self) -> bool {
        self.finalized
    }
    #[cfg(feature = "fips")]
    fn fips_approved(&self) -> Option<bool> {
        self.fips_approval.approval()
    }
}

impl Derive for SSHKDFOperation {
    fn derive(
        &mut self,
        key: &Object,
        template: &[CK_ATTRIBUTE],
        _mechanisms: &Mechanisms,
        objfactories: &ObjectFactories,
    ) -> Result<Vec<Object>> {
        if self.finalized {
            return Err(CKR_OPERATION_NOT_INITIALIZED)?;
        }
        self.finalized = true;

        key.check_key_ops(CKO_SECRET_KEY, CKK_GENERIC_SECRET, CKA_DERIVE)?;

        let (mut dobj, value_len) = match self.purpose {
            SshKdfPurpose::InitialIVClientToServer
            | SshKdfPurpose::InitialIVServerToClient => {
                common_derive_data_object(template, objfactories, 0)?
            }
            _ => common_derive_key_object(key, template, objfactories, 0)?,
        };
        if value_len == 0 || value_len > usize::try_from(u32::MAX)? {
            return Err(CKR_TEMPLATE_INCONSISTENT)?;
        }

        let mut kdf =
            SshkdfDerive::new(osslctx(), mech_type_to_digest_alg(self.prf)?)?;
        kdf.set_purpose(self.purpose);
        kdf.set_key(key.get_attr_as_bytes(CKA_VALUE)?.as_slice());
        kdf.set_hash(self.exchange_hash);
        kdf.set_session(self.session_id);

        #[cfg(feature = "fips")]
        self.fips_approval.clear();

        let mut dkm = vec![0u8; value_len];
        kdf.derive(&mut dkm)?;

        #[cfg(feature = "fips")]
        self.fips_approval.finalize();

        dobj.set_attr(Attribute::from_bytes(CKA_VALUE, dkm))?;
        Ok(vec![dobj])
    }
}