use crate::conn::OrFailure;
use crate::error::Result;
use mysql_async::prelude::Queryable;
use mysql_async::Conn;
use serde_json::{json, Value};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Permission {
pub abilities: Vec<String>,
pub scope: String,
pub may_delegate: bool,
}
impl Permission {
#[must_use]
pub fn writes(&self) -> Vec<&str> {
self.abilities
.iter()
.map(String::as_str)
.filter(|ability| WRITING.contains(ability))
.collect()
}
#[must_use]
pub fn far_reaching(&self) -> Vec<&str> {
let mut found: Vec<&str> = self
.abilities
.iter()
.map(String::as_str)
.filter(|ability| FAR_REACHING.contains(ability))
.collect();
if self.may_delegate {
found.push(DELEGATION);
}
found
}
#[must_use]
pub fn as_value(&self) -> Value {
json!({
"abilities": self.abilities,
"scope": self.scope,
"may_delegate": self.may_delegate,
"writes": self.writes(),
"far_reaching": self.far_reaching(),
})
}
}
static WRITING: &[&str] = &[
"ALL PRIVILEGES",
"ALTER",
"ALTER ROUTINE",
"CREATE",
"CREATE ROUTINE",
"CREATE TEMPORARY TABLES",
"CREATE VIEW",
"DELETE",
"DELETE HISTORY",
"DROP",
"EVENT",
"INDEX",
"INSERT",
"REFERENCES",
"TRIGGER",
"UPDATE",
];
static FAR_REACHING: &[&str] = &[
"ALL PRIVILEGES",
"BINLOG ADMIN",
"CREATE USER",
"FEDERATED ADMIN",
"FILE",
"PROCESS",
"RELOAD",
"REPLICATION CLIENT",
"REPLICATION SLAVE",
"SET USER",
"SHUTDOWN",
"SUPER",
];
const DELEGATION: &str = "GRANT OPTION";
pub async fn effective(connection: &mut Conn) -> Result<Value> {
let identity: Option<(String, String)> = connection
.query_first("SELECT CURRENT_USER(), USER()")
.await
.or_failure()?;
let lines: Vec<String> = connection.query("SHOW GRANTS").await.or_failure()?;
let permissions: Vec<Permission> = lines.iter().filter_map(|line| parse(line)).collect();
let understood = permissions.len();
let (authenticated_as, connected_as) = identity.unwrap_or_default();
Ok(json!({
"authenticated_as": authenticated_as,
"connected_as": connected_as,
"rows": permissions.iter().map(Permission::as_value).collect::<Vec<_>>(),
"can_write": permissions.iter().any(|entry| !entry.writes().is_empty()),
"far_reaching": permissions
.iter()
.flat_map(|entry| entry.far_reaching().into_iter().map(ToOwned::to_owned))
.collect::<Vec<String>>(),
"lines_read": lines.len(),
"lines_understood": understood,
}))
}
#[must_use]
pub fn parse(line: &str) -> Option<Permission> {
let body = line.strip_prefix("GRANT ")?;
let body = cut_at(body, " IDENTIFIED");
let (abilities, rest) = body.split_once(" ON ")?;
let (scope, tail) = rest.split_once(" TO ").unwrap_or((rest, ""));
Some(Permission {
abilities: split_abilities(abilities),
scope: scope.trim().to_owned(),
may_delegate: tail.contains("WITH GRANT OPTION"),
})
}
fn cut_at<'a>(text: &'a str, marker: &str) -> &'a str {
text.find(marker).map_or(text, |offset| &text[..offset])
}
fn split_abilities(text: &str) -> Vec<String> {
let mut abilities = Vec::new();
let mut current = String::new();
let mut depth = 0_usize;
for character in text.chars() {
match character {
'(' => {
depth += 1;
current.push(character);
}
')' => {
depth = depth.saturating_sub(1);
current.push(character);
}
',' if depth == 0 => {
push_ability(&mut abilities, ¤t);
current.clear();
}
_ => current.push(character),
}
}
push_ability(&mut abilities, ¤t);
abilities
}
fn push_ability(abilities: &mut Vec<String>, current: &str) {
let trimmed = current.trim();
if !trimmed.is_empty() {
abilities.push(trimmed.to_uppercase());
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_read_only_permission_says_it_cannot_write() {
let permission = parse("GRANT SELECT ON `shop`.* TO `reader`@`%`").expect("understood");
assert_eq!(permission.abilities, vec!["SELECT".to_owned()]);
assert_eq!(permission.scope, "`shop`.*");
assert!(permission.writes().is_empty());
assert!(permission.far_reaching().is_empty());
assert!(!permission.may_delegate);
}
#[test]
fn every_writing_ability_is_named() {
let permission = parse("GRANT SELECT, INSERT, UPDATE, DELETE ON `shop`.* TO `app`@`%`")
.expect("understood");
assert_eq!(permission.writes(), vec!["INSERT", "UPDATE", "DELETE"]);
}
#[test]
fn an_ability_that_reaches_past_the_data_is_pointed_at() {
let permission =
parse("GRANT SELECT, FILE, SUPER ON *.* TO `admin`@`localhost`").expect("understood");
assert_eq!(permission.far_reaching(), vec!["FILE", "SUPER"]);
}
#[test]
fn the_ability_to_pass_permissions_on_is_far_reaching() {
let permission =
parse("GRANT SELECT ON *.* TO `owner`@`%` WITH GRANT OPTION").expect("understood");
assert!(permission.may_delegate);
assert_eq!(permission.far_reaching(), vec!["GRANT OPTION"]);
}
#[test]
fn a_permission_over_everything_counts_as_both() {
let permission =
parse("GRANT ALL PRIVILEGES ON *.* TO `root`@`localhost`").expect("understood");
assert_eq!(permission.writes(), vec!["ALL PRIVILEGES"]);
assert_eq!(permission.far_reaching(), vec!["ALL PRIVILEGES"]);
}
#[test]
fn authentication_material_never_survives_reading() {
let permission =
parse("GRANT USAGE ON *.* TO `app`@`%` IDENTIFIED BY PASSWORD '*ABCDEF0123456789'")
.expect("understood");
let published = serde_json::to_string(&permission.as_value()).expect("serialises");
assert!(!published.contains("ABCDEF"), "{published}");
assert!(!published.contains("IDENTIFIED"), "{published}");
assert_eq!(permission.scope, "*.*");
}
#[test]
fn a_column_list_stays_attached_to_its_ability() {
let permission =
parse("GRANT SELECT (id, name), UPDATE (name) ON `shop`.`users` TO `app`@`%`")
.expect("understood");
assert_eq!(
permission.abilities,
vec!["SELECT (ID, NAME)".to_owned(), "UPDATE (NAME)".to_owned()]
);
}
#[test]
fn an_unreadable_line_produces_nothing_rather_than_a_guess() {
assert_eq!(parse("REVOKE SELECT ON `shop`.* FROM `x`@`%`"), None);
assert_eq!(parse("GRANT `role_reader` TO `app`@`%`"), None);
assert_eq!(parse(""), None);
}
#[test]
fn a_role_is_not_mistaken_for_a_permission_over_everything() {
assert!(parse("GRANT `analyst` TO `app`@`%`").is_none());
}
}