1use serde::{Deserialize, Serialize};
5
6use crate::{Hex, SecretBytes, SecretString};
7
8#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
10#[non_exhaustive]
11pub enum HashAlgorithm {
12 #[default]
14 #[serde(rename = "sha256")]
15 Sha256,
16 #[serde(rename = "sha384")]
18 Sha384,
19 #[serde(rename = "sha512")]
21 Sha512,
22 #[serde(rename = "sha3-256")]
24 Sha3_256,
25 #[serde(rename = "sha3-512")]
27 Sha3_512,
28 #[serde(rename = "blake2b")]
30 Blake2b,
31 #[serde(rename = "blake3")]
33 Blake3,
34}
35
36#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
38#[non_exhaustive]
39pub enum MacAlgorithm {
40 #[default]
42 #[serde(rename = "sha256")]
43 Sha256,
44 #[serde(rename = "sha384")]
46 Sha384,
47 #[serde(rename = "sha512")]
49 Sha512,
50 #[serde(rename = "sha3-256")]
52 Sha3_256,
53 #[serde(rename = "sha3-512")]
55 Sha3_512,
56}
57
58#[derive(Debug, Clone, Default, Serialize, Deserialize)]
60#[serde(rename_all = "camelCase", deny_unknown_fields)]
61pub struct HashRequest {
62 pub algorithm: HashAlgorithm,
64 pub data: SecretString,
66}
67
68#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
70#[serde(rename_all = "camelCase")]
71#[non_exhaustive]
72pub struct HashResult {
73 pub digest: Hex,
75 pub algorithm: String,
77 pub length: u64,
79}
80
81#[derive(Debug, Clone, Default, Serialize, Deserialize)]
83#[serde(rename_all = "camelCase", deny_unknown_fields)]
84pub struct MacRequest {
85 pub algorithm: MacAlgorithm,
87 pub data: SecretString,
89 pub key: SecretBytes,
91}
92
93#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
95#[serde(rename_all = "camelCase")]
96#[non_exhaustive]
97pub struct MacResult {
98 pub mac: Hex,
100 pub algorithm: String,
102}
103
104#[derive(Debug, Clone, Default, Serialize, Deserialize)]
106#[serde(rename_all = "camelCase", deny_unknown_fields)]
107pub struct MacVerifyRequest {
108 pub algorithm: MacAlgorithm,
110 pub data: SecretString,
112 pub key: SecretBytes,
114 pub mac: Hex,
116}
117
118#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
120#[serde(rename_all = "kebab-case")]
121#[non_exhaustive]
122pub enum KdfAlgorithm {
123 Scrypt,
125 #[default]
127 HkdfSha256,
128 Pbkdf2Sha256,
130}
131
132#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
134#[serde(deny_unknown_fields)]
135pub struct KdfParams {
136 #[serde(rename = "N", default, skip_serializing_if = "Option::is_none")]
138 pub n: Option<u64>,
139 #[serde(default, skip_serializing_if = "Option::is_none")]
141 pub r: Option<u32>,
142 #[serde(default, skip_serializing_if = "Option::is_none")]
144 pub p: Option<u32>,
145 #[serde(default, skip_serializing_if = "Option::is_none")]
147 pub iterations: Option<u32>,
148 #[serde(default, skip_serializing_if = "Option::is_none")]
150 pub info: Option<String>,
151}
152
153#[derive(Debug, Clone, Default, Serialize, Deserialize)]
155#[serde(rename_all = "camelCase", deny_unknown_fields)]
156pub struct KdfRequest {
157 pub algorithm: KdfAlgorithm,
159 pub password: SecretString,
161 #[serde(default, skip_serializing_if = "Option::is_none")]
163 pub salt: Option<Hex>,
164 #[serde(default, skip_serializing_if = "Option::is_none")]
166 pub key_length: Option<u32>,
167 #[serde(default, skip_serializing_if = "Option::is_none")]
169 pub params: Option<KdfParams>,
170}
171
172#[derive(Debug, Clone, Serialize, Deserialize)]
174#[serde(rename_all = "camelCase")]
175#[non_exhaustive]
176pub struct KdfResult {
177 pub derived_key: SecretBytes,
179 pub salt: Hex,
181 pub algorithm: String,
183 pub key_length: u64,
185}
186
187#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
189#[serde(deny_unknown_fields)]
190pub struct Argon2Params {
191 pub m: u32,
193 pub t: u32,
195 pub p: u32,
197}
198
199#[derive(Debug, Clone, Default, Serialize, Deserialize)]
201#[serde(rename_all = "camelCase", deny_unknown_fields)]
202pub struct PasswordHashRequest {
203 pub password: SecretString,
205 #[serde(default, skip_serializing_if = "Option::is_none")]
207 pub time_cost: Option<u32>,
208 #[serde(default, skip_serializing_if = "Option::is_none")]
210 pub memory_cost: Option<u32>,
211 #[serde(default, skip_serializing_if = "Option::is_none")]
213 pub parallelism: Option<u32>,
214}
215
216#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
218#[serde(rename_all = "camelCase")]
219#[non_exhaustive]
220pub struct PasswordHashResult {
221 pub hash: Hex,
223 pub salt: Hex,
225 pub params: Argon2Params,
227 pub algorithm: String,
229 pub phc: String,
231}
232
233#[derive(Debug, Clone, Default, Serialize, Deserialize)]
235#[serde(rename_all = "camelCase", deny_unknown_fields)]
236pub struct PasswordVerifyRequest {
237 pub password: SecretString,
239 pub hash: Hex,
241 pub salt: Hex,
243 pub params: Argon2Params,
245}
246
247#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
249#[non_exhaustive]
250pub struct PasswordVerifyResult {
251 pub valid: bool,
253}