Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

20.8 KB
Raw Blame
use std::fmt;

use reqwest::Method;
use serde::{Deserialize, Serialize};

use crate::connection::AppState;

use super::client::{client_for_state, ConsulClient};
use super::response::{decode_json_response, ConsulResponseMetadata};

/// Sensitive Consul value. Deliberately does not implement `Debug`.
#[derive(Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct ConsulSecret(String);

impl ConsulSecret {
    pub fn expose_once(self) -> String {
        self.0
    }
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub enum ConsulAclKind {
    Token,
    Policy,
    Role,
    AuthMethod,
    BindingRule,
    TemplatedPolicy,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct ConsulAclLink {
    #[serde(rename = "ID", default)]
    pub id: String,
    #[serde(default)]
    pub name: String,
}

#[derive(Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct ConsulAclToken {
    #[serde(rename = "AccessorID", default)]
    pub accessor_id: String,
    #[serde(rename = "SecretID", default, skip_serializing_if = "Option::is_none")]
    pub secret_id: Option<ConsulSecret>,
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub local: bool,
    #[serde(default)]
    pub auth_method: String,
    #[serde(default)]
    pub policies: Vec<ConsulAclLink>,
    #[serde(default)]
    pub roles: Vec<ConsulAclLink>,
    #[serde(default)]
    pub service_identities: Vec<serde_json::Value>,
    #[serde(default)]
    pub node_identities: Vec<serde_json::Value>,
    #[serde(default)]
    pub templated_policies: Vec<serde_json::Value>,
    #[serde(default)]
    pub create_index: u64,
    #[serde(default)]
    pub modify_index: u64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct ConsulAclPolicy {
    #[serde(rename = "ID", default)]
    pub id: String,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub rules: String,
    #[serde(default)]
    pub datacenters: Vec<String>,
    #[serde(default)]
    pub create_index: u64,
    #[serde(default)]
    pub modify_index: u64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct ConsulAclRole {
    #[serde(rename = "ID", default)]
    pub id: String,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub policies: Vec<ConsulAclLink>,
    #[serde(default)]
    pub service_identities: Vec<serde_json::Value>,
    #[serde(default)]
    pub node_identities: Vec<serde_json::Value>,
    #[serde(default)]
    pub templated_policies: Vec<serde_json::Value>,
    #[serde(default)]
    pub create_index: u64,
    #[serde(default)]
    pub modify_index: u64,
}

#[derive(Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct ConsulAclAuthMethod {
    #[serde(default)]
    pub name: String,
    #[serde(rename = "Type", default)]
    pub method_type: String,
    #[serde(default)]
    pub display_name: String,
    #[serde(default)]
    pub description: String,
    #[serde(rename = "MaxTokenTTL", default)]
    pub max_token_ttl: String,
    #[serde(default)]
    pub token_locality: String,
    #[serde(default)]
    pub config: serde_json::Value,
}

impl fmt::Debug for ConsulAclAuthMethod {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter
            .debug_struct("ConsulAclAuthMethod")
            .field("name", &self.name)
            .field("method_type", &self.method_type)
            .field("display_name", &self.display_name)
            .field("description", &self.description)
            .field("max_token_ttl", &self.max_token_ttl)
            .field("token_locality", &self.token_locality)
            .field("config", &"[REDACTED]")
            .finish()
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct ConsulAclBindingRule {
    #[serde(rename = "ID", default)]
    pub id: String,
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub auth_method: String,
    #[serde(default)]
    pub selector: String,
    #[serde(default)]
    pub bind_type: String,
    #[serde(default)]
    pub bind_name: String,
    #[serde(default)]
    pub bind_vars: serde_json::Value,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct ConsulAclTemplatedPolicy {
    #[serde(default)]
    pub template_name: String,
    #[serde(default)]
    pub schema: serde_json::Value,
}

#[derive(Clone, Serialize, Deserialize)]
#[serde(tag = "kind", content = "items", rename_all = "camelCase")]
pub enum ConsulAclList {
    Token(Vec<ConsulAclToken>),
    Policy(Vec<ConsulAclPolicy>),
    Role(Vec<ConsulAclRole>),
    AuthMethod(Vec<ConsulAclAuthMethod>),
    BindingRule(Vec<ConsulAclBindingRule>),
    TemplatedPolicy(Vec<ConsulAclTemplatedPolicy>),
}

#[derive(Clone, Serialize, Deserialize)]
#[serde(tag = "kind", content = "item", rename_all = "camelCase")]
pub enum ConsulAclItem {
    Token(ConsulAclToken),
    Policy(ConsulAclPolicy),
    Role(ConsulAclRole),
    AuthMethod(ConsulAclAuthMethod),
    BindingRule(ConsulAclBindingRule),
    TemplatedPolicy(ConsulAclTemplatedPolicy),
}

#[derive(Clone, Serialize, Deserialize)]
#[serde(tag = "kind", content = "item", rename_all = "camelCase")]
pub enum ConsulAclWrite {
    Token(ConsulAclToken),
    Policy(ConsulAclPolicy),
    Role(ConsulAclRole),
    AuthMethod(ConsulAclAuthMethod),
    BindingRule(ConsulAclBindingRule),
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConsulAclReferences {
    pub token_accessor_ids: Vec<String>,
    pub role_ids: Vec<String>,
    pub binding_rule_ids: Vec<String>,
    pub complete: bool,
    pub filtered_by_acls: bool,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct ConsulAclTokenClone {
    #[serde(default)]
    pub description: String,
}

pub async fn consul_acl_token_self_core(state: &AppState, connection_id: &str) -> Result<ConsulAclToken, String> {
    let client = client_for_state(state, connection_id).await?;
    let url = client.api_url("/v1/acl/token/self")?;
    client.request_json(Method::GET, url, None::<&()>, true, "read current ACL token").await.map(without_token_secret)
}

pub async fn consul_acl_token_clone_core(
    state: &AppState,
    connection_id: &str,
    accessor_id: &str,
    request: ConsulAclTokenClone,
) -> Result<ConsulAclToken, String> {
    super::ensure_writable(state, connection_id, "ACL token clone").await?;
    let client = client_for_state(state, connection_id).await?;
    let accessor_id = percent_encoding::utf8_percent_encode(accessor_id, percent_encoding::NON_ALPHANUMERIC);
    let url = client.api_url(&format!("/v1/acl/token/{accessor_id}/clone"))?;
    client.request_json(Method::PUT, url, Some(&request), false, "clone ACL token").await
}

pub async fn consul_acl_list_core(
    state: &AppState,
    connection_id: &str,
    kind: ConsulAclKind,
) -> Result<ConsulAclList, String> {
    let client = client_for_state(state, connection_id).await?;
    match kind {
        ConsulAclKind::Token => Ok(ConsulAclList::Token(
            list::<ConsulAclToken>(&client, "/v1/acl/tokens", "list ACL tokens")
                .await?
                .into_iter()
                .map(without_token_secret)
                .collect(),
        )),
        ConsulAclKind::Policy => {
            Ok(ConsulAclList::Policy(list(&client, "/v1/acl/policies", "list ACL policies").await?))
        }
        ConsulAclKind::Role => Ok(ConsulAclList::Role(list(&client, "/v1/acl/roles", "list ACL roles").await?)),
        ConsulAclKind::AuthMethod => Ok(ConsulAclList::AuthMethod(
            list::<ConsulAclAuthMethod>(&client, "/v1/acl/auth-methods", "list ACL auth methods")
                .await?
                .into_iter()
                .map(without_auth_method_secrets)
                .collect(),
        )),
        ConsulAclKind::BindingRule => {
            Ok(ConsulAclList::BindingRule(list(&client, "/v1/acl/binding-rules", "list ACL binding rules").await?))
        }
        ConsulAclKind::TemplatedPolicy => Ok(ConsulAclList::TemplatedPolicy(
            list(&client, "/v1/acl/templated-policies", "list ACL templated policies").await?,
        )),
    }
}

pub async fn consul_acl_get_core(
    state: &AppState,
    connection_id: &str,
    kind: ConsulAclKind,
    id: &str,
) -> Result<ConsulAclItem, String> {
    let client = client_for_state(state, connection_id).await?;
    if kind == ConsulAclKind::TemplatedPolicy {
        return list::<ConsulAclTemplatedPolicy>(&client, "/v1/acl/templated-policies", "list ACL templated policies")
            .await?
            .into_iter()
            .find(|policy| policy.template_name == id)
            .map(ConsulAclItem::TemplatedPolicy)
            .ok_or_else(|| "CONSUL_ACL_NOT_FOUND: Templated policy not found".to_string());
    }
    let url = client.api_url(&item_path(kind, id)?)?;
    match kind {
        ConsulAclKind::Token => Ok(ConsulAclItem::Token(without_token_secret(
            client.request_json(Method::GET, url, None::<&()>, true, "read ACL token").await?,
        ))),
        ConsulAclKind::Policy => Ok(ConsulAclItem::Policy(
            client.request_json(Method::GET, url, None::<&()>, true, "read ACL policy").await?,
        )),
        ConsulAclKind::Role => {
            Ok(ConsulAclItem::Role(client.request_json(Method::GET, url, None::<&()>, true, "read ACL role").await?))
        }
        ConsulAclKind::AuthMethod => Ok(ConsulAclItem::AuthMethod(without_auth_method_secrets(
            client.request_json(Method::GET, url, None::<&()>, true, "read ACL auth method").await?,
        ))),
        ConsulAclKind::BindingRule => Ok(ConsulAclItem::BindingRule(
            client.request_json(Method::GET, url, None::<&()>, true, "read ACL binding rule").await?,
        )),
        ConsulAclKind::TemplatedPolicy => unreachable!("templated policy reads are handled by the collection"),
    }
}

pub async fn consul_acl_apply_core(
    state: &AppState,
    connection_id: &str,
    id: Option<&str>,
    value: ConsulAclWrite,
) -> Result<ConsulAclItem, String> {
    super::ensure_writable(state, connection_id, "ACL write").await?;
    let client = client_for_state(state, connection_id).await?;
    match value {
        ConsulAclWrite::Token(item) => Ok(ConsulAclItem::Token(apply(&client, ConsulAclKind::Token, id, &item).await?)),
        ConsulAclWrite::Policy(item) => {
            Ok(ConsulAclItem::Policy(apply(&client, ConsulAclKind::Policy, id, &item).await?))
        }
        ConsulAclWrite::Role(item) => Ok(ConsulAclItem::Role(apply(&client, ConsulAclKind::Role, id, &item).await?)),
        ConsulAclWrite::AuthMethod(mut item) => {
            if let Some(id) = id {
                let url = client.api_url(&item_path(ConsulAclKind::AuthMethod, id)?)?;
                let existing: ConsulAclAuthMethod = client
                    .request_json(Method::GET, url, None::<&()>, true, "read ACL auth method before update")
                    .await?;
                merge_missing_sensitive_config(&mut item.config, &existing.config);
            }
            Ok(ConsulAclItem::AuthMethod(without_auth_method_secrets(
                apply(&client, ConsulAclKind::AuthMethod, id, &item).await?,
            )))
        }
        ConsulAclWrite::BindingRule(item) => {
            Ok(ConsulAclItem::BindingRule(apply(&client, ConsulAclKind::BindingRule, id, &item).await?))
        }
    }
}

pub async fn consul_acl_delete_core(
    state: &AppState,
    connection_id: &str,
    kind: ConsulAclKind,
    id: &str,
) -> Result<ConsulAclReferences, String> {
    super::ensure_writable(state, connection_id, "ACL delete").await?;
    let references = consul_acl_references_core(state, connection_id, kind, id).await?;
    if !references.complete {
        return Err("CONSUL_IMPACT_INCOMPLETE: ACL references could not be enumerated completely".to_string());
    }
    let client = client_for_state(state, connection_id).await?;
    let url = client.api_url(&item_path(kind, id)?)?;
    client.send_json(Method::DELETE, url, None::<&()>, false, "delete ACL resource").await?;
    Ok(references)
}

pub async fn consul_acl_references_core(
    state: &AppState,
    connection_id: &str,
    kind: ConsulAclKind,
    id: &str,
) -> Result<ConsulAclReferences, String> {
    let client = client_for_state(state, connection_id).await?;
    let tokens = if matches!(kind, ConsulAclKind::Policy | ConsulAclKind::Role | ConsulAclKind::AuthMethod) {
        list_with_meta::<ConsulAclToken>(&client, "/v1/acl/tokens", "list ACL token references").await
    } else {
        Ok((Vec::new(), false))
    };
    let roles = if kind == ConsulAclKind::Policy {
        list_with_meta::<ConsulAclRole>(&client, "/v1/acl/roles", "list ACL role references").await
    } else {
        Ok((Vec::new(), false))
    };
    let binding_rules = if kind == ConsulAclKind::AuthMethod {
        list_with_meta::<ConsulAclBindingRule>(&client, "/v1/acl/binding-rules", "list ACL binding rule references")
            .await
    } else {
        Ok((Vec::new(), false))
    };
    let complete = tokens.is_ok() && roles.is_ok() && binding_rules.is_ok();
    let (tokens, token_filtered) = tokens.unwrap_or_default();
    let (roles, role_filtered) = roles.unwrap_or_default();
    let (binding_rules, binding_rule_filtered) = binding_rules.unwrap_or_default();
    let mut result = ConsulAclReferences {
        complete: complete && !(token_filtered || role_filtered || binding_rule_filtered),
        filtered_by_acls: token_filtered || role_filtered || binding_rule_filtered,
        ..Default::default()
    };
    match kind {
        ConsulAclKind::Policy => {
            result.token_accessor_ids = tokens
                .iter()
                .filter(|token| token.policies.iter().any(|link| link.id == id || link.name == id))
                .map(|token| token.accessor_id.clone())
                .collect();
            result.role_ids = roles
                .iter()
                .filter(|role| role.policies.iter().any(|link| link.id == id || link.name == id))
                .map(|role| role.id.clone())
                .collect();
        }
        ConsulAclKind::Role => {
            result.token_accessor_ids = tokens
                .iter()
                .filter(|token| token.roles.iter().any(|link| link.id == id || link.name == id))
                .map(|token| token.accessor_id.clone())
                .collect()
        }
        ConsulAclKind::AuthMethod => {
            result.token_accessor_ids =
                tokens.iter().filter(|token| token.auth_method == id).map(|token| token.accessor_id.clone()).collect();
            result.binding_rule_ids =
                binding_rules.iter().filter(|rule| rule.auth_method == id).map(|rule| rule.id.clone()).collect();
        }
        _ => {}
    }
    Ok(result)
}

async fn list<T: serde::de::DeserializeOwned>(
    client: &ConsulClient,
    path: &str,
    action: &str,
) -> Result<Vec<T>, String> {
    let url = client.api_url(path)?;
    client.request_json(Method::GET, url, None::<&()>, true, action).await
}

async fn list_with_meta<T: serde::de::DeserializeOwned>(
    client: &ConsulClient,
    path: &str,
    action: &str,
) -> Result<(Vec<T>, bool), String> {
    let url = client.api_url(path)?;
    let response = client.send_json(Method::GET, url, None::<&()>, true, action).await?;
    let filtered = ConsulResponseMetadata::from_response(&response).filtered_by_acls.unwrap_or(false);
    let items = decode_json_response(response, action).await?;
    Ok((items, filtered))
}

async fn apply<T: Serialize + serde::de::DeserializeOwned>(
    client: &ConsulClient,
    kind: ConsulAclKind,
    id: Option<&str>,
    item: &T,
) -> Result<T, String> {
    let (method, path) = if let Some(id) = id {
        (Method::PUT, item_path(kind, id)?)
    } else {
        (Method::PUT, collection_create_path(kind)?.to_string())
    };
    let url = client.api_url(&path)?;
    client.request_json(method, url, Some(item), false, "write ACL resource").await
}

fn without_token_secret(mut token: ConsulAclToken) -> ConsulAclToken {
    token.secret_id = None;
    token
}

fn without_auth_method_secrets(mut method: ConsulAclAuthMethod) -> ConsulAclAuthMethod {
    redact_sensitive_config(&mut method.config);
    method
}

fn redact_sensitive_config(value: &mut serde_json::Value) {
    match value {
        serde_json::Value::Object(object) => {
            object.retain(|key, _| !is_sensitive_config_key(key));
            for value in object.values_mut() {
                redact_sensitive_config(value);
            }
        }
        serde_json::Value::Array(values) => {
            for value in values {
                redact_sensitive_config(value);
            }
        }
        _ => {}
    }
}

fn is_sensitive_config_key(key: &str) -> bool {
    let key = key.to_ascii_lowercase();
    key.contains("secret")
        || key.contains("password")
        || key.contains("passphrase")
        || key.contains("token")
        || key == "jwt"
        || key.ends_with("jwt")
        || key == "bootstrap"
}

fn merge_missing_sensitive_config(target: &mut serde_json::Value, existing: &serde_json::Value) {
    let (serde_json::Value::Object(target), serde_json::Value::Object(existing)) = (target, existing) else {
        return;
    };
    for (key, existing_value) in existing {
        if is_sensitive_config_key(key) {
            target.entry(key.clone()).or_insert_with(|| existing_value.clone());
        } else if let Some(target_value) = target.get_mut(key) {
            merge_missing_sensitive_config(target_value, existing_value);
        }
    }
}

fn collection_create_path(kind: ConsulAclKind) -> Result<&'static str, String> {
    match kind {
        ConsulAclKind::Token => Ok("/v1/acl/token"),
        ConsulAclKind::Policy => Ok("/v1/acl/policy"),
        ConsulAclKind::Role => Ok("/v1/acl/role"),
        ConsulAclKind::AuthMethod => Ok("/v1/acl/auth-method"),
        ConsulAclKind::BindingRule => Ok("/v1/acl/binding-rule"),
        ConsulAclKind::TemplatedPolicy => Err("CONSUL_UNSUPPORTED: templated policies are read-only".to_string()),
    }
}

fn item_path(kind: ConsulAclKind, id: &str) -> Result<String, String> {
    let segment = percent_encoding::utf8_percent_encode(id, percent_encoding::NON_ALPHANUMERIC);
    Ok(format!("{}/{}", collection_create_path(kind)?, segment))
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn acl_paths_are_safe() {
        assert_eq!(item_path(ConsulAclKind::Policy, "team/a").unwrap(), "/v1/acl/policy/team%2Fa");
        assert!(item_path(ConsulAclKind::TemplatedPolicy, "x").is_err());
    }

    #[test]
    fn ordinary_token_reads_do_not_serialize_secret_id() {
        let token = without_token_secret(ConsulAclToken {
            accessor_id: "accessor".into(),
            secret_id: Some(ConsulSecret("connection-token".into())),
            ..Default::default()
        });
        let serialized = serde_json::to_string(&token).unwrap();
        assert!(!serialized.contains("connection-token"));
        assert!(!serialized.contains("SecretID"));
    }

    #[test]
    fn auth_method_output_and_debug_redact_nested_secrets() {
        let method = without_auth_method_secrets(ConsulAclAuthMethod {
            name: "oidc".into(),
            config: serde_json::json!({
                "OIDCClientID": "public-client",
                "OIDCClientSecret": "top-secret",
                "ServiceAccountJWT": "kubernetes-jwt",
                "Nested": { "bearer_token": "nested-secret", "JWKSURL": "https://issuer.example/jwks" }
            }),
            ..Default::default()
        });
        let serialized = serde_json::to_string(&method).unwrap();
        let debug = format!("{method:?}");
        assert!(!serialized.contains("top-secret"));
        assert!(!serialized.contains("nested-secret"));
        assert!(!serialized.contains("kubernetes-jwt"));
        assert!(serialized.contains("public-client"));
        assert!(!debug.contains("public-client"));
        assert!(debug.contains("[REDACTED]"));
    }

    #[test]
    fn auth_method_update_preserves_omitted_sensitive_config() {
        let existing = serde_json::json!({
            "Host": "https://kubernetes.example",
            "ServiceAccountJWT": "keep-me",
            "Nested": { "OIDCClientSecret": "also-keep", "Issuer": "old" }
        });
        let mut update = serde_json::json!({
            "Host": "https://new.example",
            "Nested": { "Issuer": "new" }
        });
        merge_missing_sensitive_config(&mut update, &existing);
        assert_eq!(update["ServiceAccountJWT"], "keep-me");
        assert_eq!(update["Nested"]["OIDCClientSecret"], "also-keep");
        assert_eq!(update["Nested"]["Issuer"], "new");
    }
}