use std::ffi::c_void;
use confium_store::backend::{Compartment, Options, StoreBackend, StoreInstance};
use confium_store::error::{Error, Result};
use confium_store::register_backend;
pub const OPT_CREDENTIALS: &str = "credentials";
pub const OPT_CREDENTIALS_JSON: &str = "credentials_json";
pub const OPT_PROJECT: &str = "project";
pub const OPT_LOCATION: &str = "location";
pub const OPT_KEY_RING: &str = "key_ring";
pub struct GcpKmsBackend;
impl StoreBackend for GcpKmsBackend {
fn name(&self) -> &'static str {
"gcp-kms"
}
fn open(&self, opts: &Options) -> Result<Box<dyn StoreInstance>> {
Ok(Box::new(GcpKmsInstance {
config: GcpKmsConfig {
credentials: opts.get(OPT_CREDENTIALS).cloned(),
credentials_json: opts.get(OPT_CREDENTIALS_JSON).cloned(),
project: opts.get(OPT_PROJECT).cloned(),
location: opts.get(OPT_LOCATION).cloned(),
key_ring: opts.get(OPT_KEY_RING).cloned(),
},
rt: tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.map_err(|e| Error::Wrapped {
message: format!("gcp-kms tokio runtime: {e}"),
})?,
client: std::sync::OnceLock::new(),
}))
}
}
register_backend!(GcpKmsBackend);
#[allow(dead_code)]
#[derive(Clone, Debug, Default)]
struct GcpKmsConfig {
credentials: Option<String>,
credentials_json: Option<String>,
project: Option<String>,
location: Option<String>,
key_ring: Option<String>,
}
pub struct GcpKmsInstance {
config: GcpKmsConfig,
rt: tokio::runtime::Runtime,
client: std::sync::OnceLock<google_cloud_kms::client::Client>,
}
impl GcpKmsInstance {
fn ensure_client(&self) -> Result<&google_cloud_kms::client::Client> {
if let Some(client) = self.client.get() {
return Ok(client);
}
let cfg = google_cloud_kms::client::ClientConfig::default();
let cfg = if let Some(path) = &self.config.credentials {
let cred = self
.rt
.block_on(
google_cloud_auth::credentials::CredentialsFile::new_from_file(path.clone()),
)
.map_err(|e| Error::Wrapped {
message: format!("gcp-kms credentials file: {e}"),
})?;
self.rt
.block_on(cfg.with_credentials(cred))
.map_err(|e| Error::Wrapped {
message: format!("gcp-kms credentials: {e}"),
})?
} else if let Some(json) = &self.config.credentials_json {
let cred = self
.rt
.block_on(google_cloud_auth::credentials::CredentialsFile::new_from_str(json))
.map_err(|e| Error::Wrapped {
message: format!("gcp-kms credentials json: {e}"),
})?;
self.rt
.block_on(cfg.with_credentials(cred))
.map_err(|e| Error::Wrapped {
message: format!("gcp-kms credentials: {e}"),
})?
} else {
self.rt
.block_on(cfg.with_auth())
.map_err(|e| Error::Wrapped {
message: format!("gcp-kms application default credentials: {e}"),
})?
};
let built = self
.rt
.block_on(google_cloud_kms::client::Client::new(cfg))
.map_err(|e| Error::Wrapped {
message: format!("gcp-kms client: {e}"),
})?;
Ok(self.client.get_or_init(|| built))
}
fn crypto_key_version_path(&self, key_id: &str) -> Result<String> {
if key_id.starts_with("projects/") {
if key_id.contains("/cryptoKeyVersions/") {
return Ok(key_id.to_string());
}
return Ok(format!("{key_id}/cryptoKeyVersions/1"));
}
let project = self
.config
.project
.as_deref()
.ok_or_else(|| Error::Wrapped {
message: "gcp-kms sign: option 'project' is required for a bare key id".to_string(),
})?;
let location = self.config.location.as_deref().unwrap_or("global");
let key_ring = self
.config
.key_ring
.as_deref()
.ok_or_else(|| Error::Wrapped {
message: "gcp-kms sign: option 'key_ring' is required for a bare key id"
.to_string(),
})?;
Ok(format!(
"projects/{project}/locations/{location}/keyRings/{key_ring}/cryptoKeys/{key_id}/cryptoKeyVersions/1"
))
}
}
impl StoreInstance for GcpKmsInstance {
fn put_secret(
&mut self,
_module: &str,
_app: &str,
_key_id: &str,
_key: *mut c_void,
) -> Result<()> {
self.ensure_client()?;
Err(Error::NotImplemented {
what: "gcp-kms put_secret",
})
}
fn get_secret(&self, _module: &str, _app: &str, _key_id: &str) -> Result<*mut c_void> {
Err(Error::NotImplemented {
what: "gcp-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: "gcp-kms put_public",
})
}
fn get_public(
&self,
_module: &str,
_app: &str,
_identity: &str,
) -> Result<(*mut c_void, Vec<u8>)> {
Err(Error::NotImplemented {
what: "gcp-kms get_public",
})
}
fn enumerate(
&self,
_module: &str,
_app: &str,
_compartment: Compartment,
) -> Result<Vec<(*mut c_void, String)>> {
Err(Error::NotImplemented {
what: "gcp-kms enumerate",
})
}
fn sign(
&self,
_module: &str,
_app: &str,
key_id: &str,
algorithm: &str,
message: &[u8],
) -> Result<Vec<u8>> {
if algorithm.is_empty() {
return Err(Error::Wrapped {
message: "gcp-kms sign: algorithm is required (it is only a hint for ".to_string()
+ "logging; the key version's own algorithm signs)",
});
}
let name = self.crypto_key_version_path(key_id)?;
let client = self.ensure_client()?;
let req = google_cloud_kms::grpc::kms::v1::AsymmetricSignRequest {
name,
data: message.to_vec(),
..Default::default()
};
let resp = self
.rt
.block_on(client.asymmetric_sign(req, None))
.map_err(|e| Error::Wrapped {
message: format!("gcp-kms AsymmetricSign: {e}"),
})?;
Ok(resp.signature)
}
}
unsafe impl Send for GcpKmsInstance {}
unsafe impl Sync for GcpKmsInstance {}
#[cfg(test)]
mod tests {
use super::*;
static ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
struct EnvVarGuard(&'static str, Option<String>);
impl EnvVarGuard {
fn remove(name: &'static str) -> Self {
let prev = std::env::var(name).ok();
unsafe { std::env::remove_var(name) };
Self(name, prev)
}
}
impl Drop for EnvVarGuard {
fn drop(&mut self) {
if let Some(v) = &self.1 {
unsafe { std::env::set_var(self.0, v) };
}
}
}
fn sentinel(n: usize) -> *mut c_void {
n as *mut c_void
}
#[test]
fn name_is_stable_wire_name() {
assert_eq!(GcpKmsBackend.name(), "gcp-kms");
}
#[test]
fn open_returns_instance_without_calling_gcp() {
let opts = Options::new();
let mut instance = GcpKmsBackend.open(&opts).expect("open");
assert!(instance.put_secret("m", "a", "k", sentinel(1)).is_err());
}
#[test]
fn put_secret_without_credentials_surfaces_the_auth_error() {
let _env = ENV_LOCK.lock().unwrap();
let _g1 = EnvVarGuard::remove("GOOGLE_APPLICATION_CREDENTIALS");
let _g2 = EnvVarGuard::remove("GOOGLE_APPLICATION_CREDENTIALS_JSON");
let mut instance = GcpKmsBackend.open(&Options::new()).expect("open");
let err = instance.put_secret("m", "a", "k", sentinel(1)).unwrap_err();
match err {
Error::Wrapped { message } => {
assert!(message.contains("gcp-kms"), "message: {message}");
}
other => panic!("expected Wrapped, got {other:?}"),
}
}
#[test]
fn put_secret_with_malformed_credentials_reports_the_parse_error() {
let _env = ENV_LOCK.lock().unwrap();
let _g1 = EnvVarGuard::remove("GOOGLE_APPLICATION_CREDENTIALS");
let _g2 = EnvVarGuard::remove("GOOGLE_APPLICATION_CREDENTIALS_JSON");
let mut opts = Options::new();
opts.insert(OPT_CREDENTIALS_JSON.to_string(), "not json".to_string());
let mut instance = GcpKmsBackend.open(&opts).expect("open");
let err = instance.put_secret("m", "a", "k", sentinel(1)).unwrap_err();
match err {
Error::Wrapped { message } => {
assert!(message.contains("credentials json"), "message: {message}");
}
other => panic!("expected Wrapped, got {other:?}"),
}
}
#[test]
fn sign_rejects_a_bare_key_id_without_project_options() {
let _env = ENV_LOCK.lock().unwrap();
let _g1 = EnvVarGuard::remove("GOOGLE_APPLICATION_CREDENTIALS");
let _g2 = EnvVarGuard::remove("GOOGLE_APPLICATION_CREDENTIALS_JSON");
let instance = GcpKmsBackend.open(&Options::new()).expect("open");
let err = instance
.sign("m", "a", "my-key", "EC_SIGN_P256_SHA256", b"msg")
.unwrap_err();
match err {
Error::Wrapped { message } => {
assert!(message.contains("project"), "message: {message}");
}
other => panic!("expected Wrapped, got {other:?}"),
}
}
#[test]
fn sign_requires_an_algorithm() {
let instance = GcpKmsBackend.open(&Options::new()).expect("open");
let err = instance
.sign(
"m",
"a",
"projects/p/locations/l/keyRings/r/cryptoKeys/k/cryptoKeyVersions/1",
"",
b"msg",
)
.unwrap_err();
match err {
Error::Wrapped { message } => {
assert!(message.contains("algorithm"), "message: {message}");
}
other => panic!("expected Wrapped, got {other:?}"),
}
}
#[test]
fn backend_is_registered() {
let backend = confium_store::backend::find("gcp-kms").expect("gcp-kms backend registered");
assert_eq!(backend.name(), "gcp-kms");
}
}