use std::ffi::c_void;
use aws_sdk_kms::Client as KmsClient;
use aws_sdk_kms::primitives::Blob;
use aws_sdk_kms::types::MessageType;
use confium_store::backend::{Compartment, Options, StoreBackend, StoreInstance};
use confium_store::error::{Error, Result};
use confium_store::register_backend;
pub const OPT_REGION: &str = "region";
pub const OPT_KEY_ID: &str = "key_id";
pub const OPT_ENDPOINT: &str = "endpoint";
pub struct AwsKmsBackend;
impl StoreBackend for AwsKmsBackend {
fn name(&self) -> &'static str {
"aws-kms"
}
fn open(&self, opts: &Options) -> Result<Box<dyn StoreInstance>> {
Ok(Box::new(AwsKmsInstance {
config: AwsKmsConfig {
region: opts.get(OPT_REGION).cloned(),
key_id: opts.get(OPT_KEY_ID).cloned(),
endpoint: opts.get(OPT_ENDPOINT).cloned(),
},
rt: tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.map_err(|e| Error::Wrapped {
message: format!("aws-kms tokio runtime: {e}"),
})?,
client: std::sync::OnceLock::new(),
}))
}
}
register_backend!(AwsKmsBackend);
#[allow(dead_code)]
#[derive(Clone, Debug, Default)]
struct AwsKmsConfig {
region: Option<String>,
key_id: Option<String>,
endpoint: Option<String>,
}
#[allow(dead_code)]
pub struct AwsKmsInstance {
config: AwsKmsConfig,
rt: tokio::runtime::Runtime,
client: std::sync::OnceLock<KmsClient>,
}
impl AwsKmsInstance {
fn ensure_client(&self) -> Result<&KmsClient> {
if let Some(client) = self.client.get() {
return Ok(client);
}
let mut loader = aws_config::defaults(aws_config::BehaviorVersion::latest());
if let Some(region) = &self.config.region {
loader = loader.region(aws_config::Region::new(region.clone()));
}
let sdk_cfg = self.rt.block_on(loader.load());
let mut builder = aws_sdk_kms::config::Builder::from(&sdk_cfg);
if let Some(endpoint) = &self.config.endpoint {
builder = builder.endpoint_url(endpoint);
}
let built = KmsClient::from_conf(builder.build());
Ok(self.client.get_or_init(|| built))
}
}
impl StoreInstance for AwsKmsInstance {
fn put_secret(
&mut self,
_module: &str,
_app: &str,
_key_id: &str,
_key: *mut c_void,
) -> Result<()> {
self.ensure_client()?;
Err(Error::NotImplemented {
what: "aws-kms put_secret",
})
}
fn get_secret(&self, _module: &str, _app: &str, _key_id: &str) -> Result<*mut c_void> {
Err(Error::NotImplemented {
what: "aws-kms get_secret",
})
}
fn put_public(
&mut self,
_module: &str,
_app: &str,
_identity: &str,
_key: *mut c_void,
_sig: &[u8],
) -> Result<()> {
let _ = self.ensure_client()?;
Err(Error::NotImplemented {
what: "aws-kms put_public",
})
}
fn get_public(
&self,
_module: &str,
_app: &str,
_identity: &str,
) -> Result<(*mut c_void, Vec<u8>)> {
Err(Error::NotImplemented {
what: "aws-kms get_public",
})
}
fn enumerate(
&self,
_module: &str,
_app: &str,
compartment: Compartment,
) -> Result<Vec<(*mut c_void, String)>> {
if matches!(compartment, Compartment::Public) {
return Err(Error::NotImplemented {
what: "aws-kms enumerate (public compartment)",
});
}
let client = self.ensure_client()?;
let mut out = Vec::new();
let mut marker: Option<String> = None;
loop {
let mut req = client.list_keys().limit(100);
if let Some(m) = marker.as_deref() {
req = req.marker(m);
}
let page = self.rt.block_on(req.send()).map_err(|e| Error::Wrapped {
message: format!("aws-kms ListKeys: {e}"),
})?;
for key in page.keys() {
if let Some(id) = key.key_id() {
out.push((std::ptr::null_mut(), id.to_string()));
}
}
marker = page.next_marker().map(|m| m.to_string());
if marker.is_none() {
break;
}
}
Ok(out)
}
fn sign(
&self,
_module: &str,
_app: &str,
key_id: &str,
algorithm: &str,
message: &[u8],
) -> Result<Vec<u8>> {
let id = if key_id.is_empty() {
self.config
.key_id
.as_deref()
.ok_or_else(|| Error::Wrapped {
message: "aws-kms sign: no key_id given and no default 'key_id' option"
.to_string(),
})?
} else {
key_id
};
if algorithm.is_empty() {
return Err(Error::Wrapped {
message: "aws-kms sign: algorithm is required (e.g. ECDSA_SHA_256)".to_string(),
});
}
let client = self.ensure_client()?;
let resp = self
.rt
.block_on(
client
.sign()
.key_id(id)
.signing_algorithm(algorithm.into())
.message_type(MessageType::Raw)
.message(Blob::new(message.to_vec()))
.send(),
)
.map_err(|e| Error::Wrapped {
message: format!("aws-kms Sign: {e}"),
})?;
resp.signature()
.map(|b| b.as_ref().to_vec())
.ok_or_else(|| Error::Wrapped {
message: "aws-kms Sign: response carried no signature".to_string(),
})
}
}
unsafe impl Send for AwsKmsInstance {}
unsafe impl Sync for AwsKmsInstance {}
#[cfg(test)]
mod tests {
use super::*;
fn sentinel(n: usize) -> *mut c_void {
n as *mut c_void
}
static ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
struct EnvVarGuard(&'static str, Option<String>);
impl EnvVarGuard {
fn set(name: &'static str, value: &str) -> Self {
unsafe { std::env::set_var(name, value) };
Self(name, None)
}
}
impl Drop for EnvVarGuard {
fn drop(&mut self) {
match &self.1 {
Some(v) => unsafe { std::env::set_var(self.0, v) },
None => unsafe { std::env::remove_var(self.0) },
}
}
}
#[test]
fn name_is_stable_wire_name() {
assert_eq!(AwsKmsBackend.name(), "aws-kms");
}
#[test]
fn open_returns_instance_without_calling_aws() {
let opts = Options::new();
let mut instance = AwsKmsBackend.open(&opts).expect("open");
assert!(instance.put_secret("m", "a", "k", sentinel(1)).is_err());
}
#[test]
fn enumerate_private_lists_kms_keys_over_the_wire() {
let _env = ENV_LOCK.lock().unwrap();
let _creds = EnvVarGuard::set("AWS_ACCESS_KEY_ID", "test");
let _secret = EnvVarGuard::set("AWS_SECRET_ACCESS_KEY", "test");
let _no_imds = EnvVarGuard::set("AWS_EC2_METADATA_DISABLED", "true");
let _region = EnvVarGuard::set("AWS_REGION", "us-east-1");
let _certs = EnvVarGuard::set("SSL_CERT_FILE", "/etc/ssl/cert.pem");
let server = tokio::runtime::Runtime::new()
.expect("test runtime")
.block_on(async {
let server = wiremock::MockServer::start().await;
wiremock::Mock::given(wiremock::matchers::method("POST"))
.and(wiremock::matchers::path("/"))
.respond_with(wiremock::ResponseTemplate::new(200).set_body_string(
r#"{"Keys":[{"KeyId":"1234abcd-12ab-34cd-56ef-1234567890ab"},
{"KeyId":"abcd1234-ab12-cd34-ef56-ab1234567890ab"}]}"#,
))
.mount(&server)
.await;
server
});
let mut opts = Options::new();
opts.insert(OPT_ENDPOINT.to_string(), server.uri());
let instance = AwsKmsBackend.open(&opts).expect("open");
let entries = instance
.enumerate("m", "a", Compartment::Private)
.expect("enumerate");
let ids: Vec<String> = entries.into_iter().map(|(_, id)| id).collect();
assert_eq!(ids.len(), 2, "ids: {ids:?}");
assert!(ids.contains(&"1234abcd-12ab-34cd-56ef-1234567890ab".to_string()));
assert!(ids.contains(&"abcd1234-ab12-cd34-ef56-ab1234567890ab".to_string()));
}
#[test]
fn sign_round_trips_through_the_kms_stub() {
let _env = ENV_LOCK.lock().unwrap();
let _creds = EnvVarGuard::set("AWS_ACCESS_KEY_ID", "test");
let _secret = EnvVarGuard::set("AWS_SECRET_ACCESS_KEY", "test");
let _no_imds = EnvVarGuard::set("AWS_EC2_METADATA_DISABLED", "true");
let _region = EnvVarGuard::set("AWS_REGION", "us-east-1");
let _certs = EnvVarGuard::set("SSL_CERT_FILE", "/etc/ssl/cert.pem");
let expected: Vec<u8> = (0u8..64).collect();
use base64::Engine as _;
let sig_b64 = base64::engine::general_purpose::STANDARD.encode(&expected);
let server = tokio::runtime::Runtime::new()
.expect("test runtime")
.block_on(async {
let server = wiremock::MockServer::start().await;
wiremock::Mock::given(wiremock::matchers::method("POST"))
.and(wiremock::matchers::path("/"))
.and(wiremock::matchers::header(
"X-Amz-Target",
"TrentService.Sign",
))
.respond_with(wiremock::ResponseTemplate::new(200).set_body_string(
format!(r#"{{"KeyId":"alias/test","Signature":"{sig_b64}","SigningAlgorithm":"ECDSA_SHA_256"}}"#),
))
.mount(&server)
.await;
server
});
let mut opts = Options::new();
opts.insert(OPT_ENDPOINT.to_string(), server.uri());
let instance = AwsKmsBackend.open(&opts).expect("open");
let sig = instance
.sign(
"m",
"a",
"alias/test",
"ECDSA_SHA_256",
b"hello, remote world",
)
.expect("sign");
assert_eq!(sig, expected);
}
#[test]
fn sign_requires_a_key_id() {
let instance = AwsKmsBackend.open(&Options::new()).expect("open");
let err = instance
.sign("m", "a", "", "ECDSA_SHA_256", b"msg")
.unwrap_err();
match err {
Error::Wrapped { message } => {
assert!(message.contains("key_id"), "message: {message}");
}
other => panic!("expected Wrapped, got {other:?}"),
}
}
#[test]
fn enumerate_public_compartment_is_not_implemented() {
let instance = AwsKmsBackend.open(&Options::new()).expect("open");
let err = instance
.enumerate("m", "a", Compartment::Public)
.unwrap_err();
assert!(matches!(err, Error::NotImplemented { .. }));
}
#[test]
fn put_secret_still_not_implemented_but_client_builds() {
let _env = ENV_LOCK.lock().unwrap();
let _creds = EnvVarGuard::set("AWS_ACCESS_KEY_ID", "test");
let _secret = EnvVarGuard::set("AWS_SECRET_ACCESS_KEY", "test");
let _no_imds = EnvVarGuard::set("AWS_EC2_METADATA_DISABLED", "true");
let _region = EnvVarGuard::set("AWS_REGION", "us-east-1");
let _certs = EnvVarGuard::set("SSL_CERT_FILE", "/etc/ssl/cert.pem");
let mut instance = AwsKmsBackend.open(&Options::new()).expect("open");
let err = instance.put_secret("m", "a", "k", sentinel(1)).unwrap_err();
assert!(matches!(err, Error::NotImplemented { .. }));
}
#[test]
fn backend_is_registered() {
let backend = confium_store::backend::find("aws-kms").expect("aws-kms backend registered");
assert_eq!(backend.name(), "aws-kms");
}
}