Debian Codegraph @

third_party/rust/nss-gk-api/src/hkdf.rs

raw
1 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
2 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
4 // option. This file may not be copied, modified, or distributed
5 // except according to those terms.
6
7 #![allow(non_camel_case_types)]
8
9 use crate::SECItem;
10 use crate::SECItemType;
11
12 use crate::p11;
13 use crate::p11::SymKey;
14 use crate::p11::CKA_DERIVE;
15 use crate::p11::CKF_HKDF_SALT_DATA;
16 use crate::p11::CKF_HKDF_SALT_NULL;
17 use crate::p11::CKM_HKDF_DATA;
18 use crate::p11::CKM_HKDF_DERIVE;
19 use crate::p11::CK_BBOOL;
20 use crate::p11::CK_INVALID_HANDLE;
21 use crate::p11::CK_MECHANISM_TYPE;
22 use crate::ssl::CK_OBJECT_HANDLE;
23
24 use crate::SECItemBorrowed;
25
26 use pkcs11_bindings::CKA_SIGN;
27 use pkcs11_bindings::CKM_HKDF_KEY_GEN;
28 use pkcs11_bindings::CK_ULONG;
29
30 use std::convert::TryFrom;
31 use std::marker::PhantomData;
32 use std::mem;
33 use std::os::raw::c_int;
34 use std::os::raw::c_uint;
35 use std::ptr::null_mut;
36
37 #[derive(Clone, Copy, Debug)]
38
39 pub enum HkdfError {
40 InvalidPrkLength,
41 InvalidLength,
42 InternalError,
43 }
44
45 #[derive(Clone, Copy, Debug)]
46 pub enum HkdfAlgorithm {
47 HKDF_SHA2_256,
48 HKDF_SHA2_384,
49 HKDF_SHA2_512,
50 }
51
52 #[derive(Clone, Copy, Debug)]
53 pub enum KeyMechanism {
54 Hkdf,
55 }
56
57 impl KeyMechanism {
58 fn mech(self) -> CK_MECHANISM_TYPE {
59 CK_MECHANISM_TYPE::from(match self {
60 Self::Hkdf => CKM_HKDF_DERIVE,
61 })
62 }
63
64 fn len(self) -> usize {
65 match self {
66 Self::Hkdf => 0, // Let the underlying module decide.
67 }
68 }
69 }
70 #[derive(Clone, Copy, Debug)]
71
72 pub(crate) struct ParamItem<'a, T: 'a> {
73 item: SECItem,
74 marker: PhantomData<&'a T>,
75 }
76
77 impl<'a, T: Sized + 'a> ParamItem<'a, T> {
78 pub fn new(v: &'a mut T) -> Self {
79 let item = SECItem {
80 type_: SECItemType::siBuffer,
81 data: (v as *mut T).cast::<u8>(),
82 len: c_uint::try_from(mem::size_of::<T>()).unwrap(),
83 };
84 Self {
85 item,
86 marker: PhantomData::default(),
87 }
88 }
89
90 pub fn ptr(&mut self) -> *mut SECItem {
91 std::ptr::addr_of_mut!(self.item)
92 }
93 }
94
95 pub struct Hkdf {
96 kdf: HkdfAlgorithm,
97 }
98
99 impl Hkdf {
100 pub fn new(kdf: HkdfAlgorithm) -> Self {
101 Self { kdf }
102 }
103
104 pub fn import_secret(&self, ikm: &[u8]) -> Result<SymKey, HkdfError> {
105 crate::init();
106
107 let slot = p11::Slot::internal().map_err(|_| HkdfError::InternalError)?;
108 let ikm_item = SECItemBorrowed::wrap(ikm);
109 let ikm_item_ptr = ikm_item.as_ref() as *const _ as *mut _;
110
111 let ptr = unsafe {
112 p11::PK11_ImportSymKey(
113 *slot,
114 CK_MECHANISM_TYPE::from(CKM_HKDF_KEY_GEN),
115 p11::PK11Origin::PK11_OriginUnwrap,
116 p11::CK_ATTRIBUTE_TYPE::from(CKA_SIGN),
117 ikm_item_ptr,
118 null_mut(),
119 )
120 };
121 let s = unsafe { SymKey::from_ptr(ptr).expect("HkdfError::InternalError") };
122 Ok(s)
123 }
124
125 fn mech(&self) -> CK_MECHANISM_TYPE {
126 CK_MECHANISM_TYPE::from(match self.kdf {
127 HkdfAlgorithm::HKDF_SHA2_256 => p11::CKM_SHA256,
128 HkdfAlgorithm::HKDF_SHA2_384 => p11::CKM_SHA384,
129 HkdfAlgorithm::HKDF_SHA2_512 => p11::CKM_SHA512,
130 })
131 }
132
133 pub fn extract(&self, salt: &[u8], ikm: &SymKey) -> Result<SymKey, HkdfError> {
134 crate::init();
135
136 let salt_type = if salt.is_empty() {
137 CKF_HKDF_SALT_NULL
138 } else {
139 CKF_HKDF_SALT_DATA
140 };
141 let mut params = p11::CK_HKDF_PARAMS {
142 bExtract: CK_BBOOL::from(true),
143 bExpand: CK_BBOOL::from(false),
144 prfHashMechanism: self.mech(),
145 ulSaltType: CK_ULONG::from(salt_type),
146 pSalt: salt.as_ptr() as *mut _, // const-cast = bad API
147 ulSaltLen: CK_ULONG::try_from(salt.len()).unwrap(),
148 hSaltKey: CK_OBJECT_HANDLE::from(CK_INVALID_HANDLE),
149 pInfo: null_mut(),
150 ulInfoLen: 0,
151 };
152 let mut params_item = ParamItem::new(&mut params);
153 let ptr = unsafe {
154 p11::PK11_Derive(
155 **ikm,
156 CK_MECHANISM_TYPE::from(CKM_HKDF_DERIVE),
157 params_item.ptr(),
158 CK_MECHANISM_TYPE::from(CKM_HKDF_DERIVE),
159 CK_MECHANISM_TYPE::from(CKA_DERIVE),
160 0,
161 )
162 };
163
164 let prk = unsafe { SymKey::from_ptr(ptr) }.expect("HkdfError::InternalError");
165 Ok(prk)
166 }
167
168 // NB: `info` must outlive the returned value.
169 fn expand_params(&self, info: &[u8]) -> p11::CK_HKDF_PARAMS {
170 p11::CK_HKDF_PARAMS {
171 bExtract: CK_BBOOL::from(false),
172 bExpand: CK_BBOOL::from(true),
173 prfHashMechanism: self.mech(),
174 ulSaltType: CK_ULONG::from(CKF_HKDF_SALT_NULL),
175 pSalt: null_mut(),
176 ulSaltLen: 0,
177 hSaltKey: CK_OBJECT_HANDLE::from(CK_INVALID_HANDLE),
178 pInfo: info.as_ptr() as *mut _, // const-cast = bad API
179 ulInfoLen: CK_ULONG::try_from(info.len()).unwrap(),
180 }
181 }
182
183 pub fn expand_key(
184 &self,
185 prk: &SymKey,
186 info: &[u8],
187 key_mech: KeyMechanism,
188 ) -> Result<SymKey, HkdfError> {
189 crate::init();
190
191 let mut params = self.expand_params(info);
192 let mut params_item = ParamItem::new(&mut params);
193 let ptr = unsafe {
194 p11::PK11_Derive(
195 **prk,
196 CK_MECHANISM_TYPE::from(CKM_HKDF_DERIVE),
197 params_item.ptr(),
198 key_mech.mech(),
199 CK_MECHANISM_TYPE::from(CKA_DERIVE),
200 c_int::try_from(key_mech.len()).unwrap(),
201 )
202 };
203 let okm = unsafe { SymKey::from_ptr(ptr) }.expect("HkdfError::InternalError");
204 Ok(okm)
205 }
206
207 pub fn expand_data(&self, prk: &SymKey, info: &[u8], len: usize) -> Result<Vec<u8>, HkdfError> {
208 crate::init();
209
210 let mut params = self.expand_params(info);
211 let mut params_item = ParamItem::new(&mut params);
212 let ptr = unsafe {
213 p11::PK11_Derive(
214 **prk,
215 CK_MECHANISM_TYPE::from(CKM_HKDF_DATA),
216 params_item.ptr(),
217 CK_MECHANISM_TYPE::from(CKM_HKDF_DERIVE),
218 CK_MECHANISM_TYPE::from(CKA_DERIVE),
219 c_int::try_from(len).unwrap(),
220 )
221 };
222 let k = unsafe { SymKey::from_ptr(ptr) }.expect("HkdfError::InternalError");
223 let r = Vec::from(k.key_data().expect("HkdfError::InternalError"));
224 Ok(r)
225 }
226 }