1use serde::{Deserialize, Serialize};
8use serde_json::{Map, Value};
9
10use crate::encoding::encode_hex;
11use crate::{SecretBytes, SecretString};
12
13#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
15#[serde(rename_all = "lowercase")]
16#[non_exhaustive]
17pub enum KmsKeyUsage {
18 Encrypt,
20 Sign,
22 Wrap,
24}
25
26#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
28#[serde(rename_all = "camelCase", deny_unknown_fields)]
29pub struct KmsCreateKeyRequest {
30 #[serde(default, skip_serializing_if = "Option::is_none")]
32 pub provider: Option<String>,
33 #[serde(default, skip_serializing_if = "Option::is_none")]
35 pub algorithm: Option<String>,
36 #[serde(default, skip_serializing_if = "Option::is_none")]
38 pub usage: Option<KmsKeyUsage>,
39 #[serde(default, skip_serializing_if = "Option::is_none")]
41 pub metadata: Option<Map<String, Value>>,
42}
43
44#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
46#[serde(rename_all = "camelCase")]
47#[non_exhaustive]
48pub struct KmsKey {
49 pub key_id: String,
51 pub provider: String,
53 pub algorithm: String,
55 pub usage: String,
57 pub created_at: String,
59 pub enabled: bool,
61 #[serde(default, skip_serializing_if = "Option::is_none")]
63 pub current_version: Option<u64>,
64}
65
66#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
68#[serde(rename_all = "lowercase")]
69#[non_exhaustive]
70pub enum KmsEncoding {
71 Utf8,
73 Hex,
75}
76
77#[derive(Debug, Clone, Default, Serialize, Deserialize)]
80#[serde(rename_all = "camelCase", deny_unknown_fields)]
81pub struct KmsEncryptRequest {
82 pub key_id: String,
84 pub plaintext: SecretString,
86 #[serde(default, skip_serializing_if = "Option::is_none")]
88 pub encoding: Option<KmsEncoding>,
89 #[serde(default, skip_serializing_if = "Option::is_none")]
91 pub provider: Option<String>,
92 #[serde(default, skip_serializing_if = "Option::is_none")]
94 pub context: Option<Map<String, Value>>,
95}
96
97impl KmsEncryptRequest {
98 pub fn text(key_id: impl Into<String>, text: impl Into<SecretString>) -> Self {
100 KmsEncryptRequest {
101 key_id: key_id.into(),
102 plaintext: text.into(),
103 ..Self::default()
104 }
105 }
106
107 pub fn bytes(key_id: impl Into<String>, bytes: &[u8]) -> Self {
109 KmsEncryptRequest {
110 key_id: key_id.into(),
111 plaintext: SecretString::new(encode_hex(bytes)),
112 encoding: Some(KmsEncoding::Hex),
113 ..Self::default()
114 }
115 }
116}
117
118#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
120#[serde(rename_all = "camelCase")]
121#[non_exhaustive]
122pub struct KmsCiphertext {
123 pub ciphertext: String,
125 pub key_id: String,
127 pub provider: String,
129 #[serde(default, skip_serializing_if = "Option::is_none")]
131 pub key_version: Option<u64>,
132 #[serde(default, skip_serializing_if = "Option::is_none")]
134 pub context: Option<Map<String, Value>>,
135}
136
137#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
139#[serde(rename_all = "camelCase", deny_unknown_fields)]
140pub struct KmsDecryptRequest {
141 pub key_id: String,
143 pub ciphertext: String,
145 #[serde(default, skip_serializing_if = "Option::is_none")]
147 pub provider: Option<String>,
148 #[serde(default, skip_serializing_if = "Option::is_none")]
150 pub context: Option<Map<String, Value>>,
151}
152
153#[derive(Debug, Clone, Serialize, Deserialize)]
156#[serde(rename_all = "camelCase")]
157#[non_exhaustive]
158pub struct KmsPlaintext {
159 pub plaintext: SecretString,
161 pub hex: SecretBytes,
163 pub key_id: String,
165 pub provider: String,
167}
168
169#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
171#[serde(rename_all = "camelCase", deny_unknown_fields)]
172pub struct KmsGenerateDataKeyRequest {
173 pub key_id: String,
175 #[serde(default, skip_serializing_if = "Option::is_none")]
177 pub key_spec: Option<String>,
178 #[serde(default, skip_serializing_if = "Option::is_none")]
180 pub provider: Option<String>,
181}
182
183#[derive(Debug, Clone, Serialize, Deserialize)]
185#[serde(rename_all = "camelCase")]
186#[non_exhaustive]
187pub struct KmsDataKey {
188 pub plaintext: SecretBytes,
190 pub ciphertext: String,
192 pub key_id: String,
194 pub provider: String,
196}
197
198#[derive(Debug, Clone, Default, Serialize, Deserialize)]
200#[serde(rename_all = "camelCase", deny_unknown_fields)]
201pub struct KmsWrapRequest {
202 pub key_id: String,
204 pub unwrapped_key: SecretBytes,
206 #[serde(default, skip_serializing_if = "Option::is_none")]
208 pub provider: Option<String>,
209 #[serde(default, skip_serializing_if = "Option::is_none")]
211 pub context: Option<Map<String, Value>>,
212}
213
214#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
216#[serde(rename_all = "camelCase")]
217#[non_exhaustive]
218pub struct KmsWrapped {
219 pub wrapped_key: String,
221 pub key_id: String,
223 pub provider: String,
225}
226
227#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
229#[serde(rename_all = "camelCase", deny_unknown_fields)]
230pub struct KmsUnwrapRequest {
231 pub key_id: String,
233 pub wrapped_key: String,
235 #[serde(default, skip_serializing_if = "Option::is_none")]
237 pub provider: Option<String>,
238 #[serde(default, skip_serializing_if = "Option::is_none")]
240 pub context: Option<Map<String, Value>>,
241}
242
243#[derive(Debug, Clone, Serialize, Deserialize)]
245#[serde(rename_all = "camelCase")]
246#[non_exhaustive]
247pub struct KmsUnwrapped {
248 pub unwrapped_key: SecretBytes,
250 pub key_id: String,
252 pub provider: String,
254}