1use serde::{Deserialize, Serialize};
4
5#[derive(Debug, Clone, PartialEq, Eq)]
7pub enum KeyAlgorithm {
8 EcP256,
10 Rsa2048,
12}
13
14impl KeyAlgorithm {
15 pub fn parse(s: &str) -> Option<Self> {
17 match s {
18 "" => Some(KeyAlgorithm::Rsa2048), s if s.starts_with("ec") || s.contains("secp256") => Some(KeyAlgorithm::EcP256),
20 s if s.starts_with("rsa") => Some(KeyAlgorithm::Rsa2048),
21 _ => None,
22 }
23 }
24
25 pub fn is_ec(&self) -> bool {
27 matches!(self, KeyAlgorithm::EcP256)
28 }
29
30 pub fn is_rsa(&self) -> bool {
32 matches!(self, KeyAlgorithm::Rsa2048)
33 }
34}
35
36#[derive(Debug, Clone, Serialize, Deserialize)]
38#[serde(rename_all = "camelCase")]
39pub struct KeyAccessObject {
40 pub header: String,
42 #[serde(rename = "type")]
44 pub type_field: String,
45 pub url: String,
47 pub protocol: String,
49}
50
51#[derive(Debug, Clone)]
53pub struct KeyInfo {
54 pub algorithm: KeyAlgorithm,
56 pub wrapped_key: String,
58 pub policy_id: Option<String>,
60}
61
62#[derive(Debug, Clone, Serialize, Deserialize)]
64#[serde(rename_all = "camelCase")]
65pub struct RewrapResult {
66 pub status: String,
68 pub kas_wrapped_key: Option<String>,
70 pub error: Option<String>,
72}
73
74impl RewrapResult {
75 pub fn success(wrapped_key: String) -> Self {
77 Self {
78 status: "permit".to_string(),
79 kas_wrapped_key: Some(wrapped_key),
80 error: None,
81 }
82 }
83
84 pub fn failure(error: String) -> Self {
86 Self {
87 status: "fail".to_string(),
88 kas_wrapped_key: None,
89 error: Some(error),
90 }
91 }
92}
93
94#[cfg(test)]
95mod tests {
96 use super::*;
97
98 #[test]
99 fn test_algorithm_parsing() {
100 assert_eq!(
101 KeyAlgorithm::parse("ec:secp256r1"),
102 Some(KeyAlgorithm::EcP256)
103 );
104 assert_eq!(KeyAlgorithm::parse("ec"), Some(KeyAlgorithm::EcP256));
105 assert_eq!(KeyAlgorithm::parse("rsa:2048"), Some(KeyAlgorithm::Rsa2048));
106 assert_eq!(KeyAlgorithm::parse("rsa"), Some(KeyAlgorithm::Rsa2048));
107 assert_eq!(KeyAlgorithm::parse(""), Some(KeyAlgorithm::Rsa2048));
108 assert_eq!(KeyAlgorithm::parse("unknown"), None);
109 }
110
111 #[test]
112 fn test_rewrap_result() {
113 let success = RewrapResult::success("encoded_key".to_string());
114 assert_eq!(success.status, "permit");
115 assert!(success.kas_wrapped_key.is_some());
116 assert!(success.error.is_none());
117
118 let failure = RewrapResult::failure("error message".to_string());
119 assert_eq!(failure.status, "fail");
120 assert!(failure.kas_wrapped_key.is_none());
121 assert!(failure.error.is_some());
122 }
123}