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
use core::mem;
use core::ptr;
use sgx_crypto_sys::*;
use sgx_types::error::{SgxResult, SgxStatus};
use sgx_types::marker::ContiguousMemory;
use sgx_types::types::{Sha1Hash, ShaHandle};
pub struct Sha1 {
handle: ShaHandle,
}
impl Sha1 {
pub fn new() -> SgxResult<Sha1> {
let mut handle: ShaHandle = ptr::null_mut();
let status = unsafe { sgx_sha1_init(&mut handle as *mut ShaHandle) };
ensure!(status.is_success(), status);
Ok(Sha1 { handle })
}
pub fn update<T: ?Sized>(&mut self, data: &T) -> SgxResult
where
T: ContiguousMemory,
{
let size = mem::size_of_val(data);
ensure!(
(size > 0 && size < i32::MAX as usize),
SgxStatus::InvalidParameter
);
let status =
unsafe { sgx_sha1_update((data as *const T).cast(), size as u32, self.handle) };
ensure!(status.is_success(), status);
Ok(())
}
pub fn finalize(self) -> SgxResult<Sha1Hash> {
let mut hash = Sha1Hash::default();
self.finalize_into(&mut hash)?;
Ok(hash)
}
pub fn finalize_into(self, hash: &mut Sha1Hash) -> SgxResult {
let status = unsafe { sgx_sha1_get_hash(self.handle, hash as *mut Sha1Hash) };
ensure!(status.is_success(), status);
Ok(())
}
pub fn finalize_reset(&mut self) -> SgxResult<Sha1Hash> {
let mut hash = Sha1Hash::default();
self.finalize_into_reset(&mut hash)?;
Ok(hash)
}
pub fn finalize_into_reset(&mut self, hash: &mut Sha1Hash) -> SgxResult {
let status = unsafe { sgx_sha1_get_hash(self.handle, hash as *mut Sha1Hash) };
ensure!(status.is_success(), status);
let status = unsafe { sgx_sha1_close(self.handle) };
debug_assert!(status.is_success());
let status = unsafe { sgx_sha1_init(&mut self.handle as *mut ShaHandle) };
ensure!(status.is_success(), status);
Ok(())
}
pub fn digest<T: ?Sized>(data: &T) -> SgxResult<Sha1Hash>
where
T: ContiguousMemory,
{
let size = mem::size_of_val(data);
ensure!(
(size > 0 && size < i32::MAX as usize),
SgxStatus::InvalidParameter
);
let mut hash = Sha1Hash::default();
let status = unsafe {
sgx_sha1_msg(
(data as *const T).cast(),
size as u32,
&mut hash as *mut Sha1Hash,
)
};
ensure!(status.is_success(), status);
Ok(hash)
}
}
impl Drop for Sha1 {
fn drop(&mut self) {
let _ = unsafe { sgx_sha1_close(self.handle) };
}
}