use super::{ConditionError, ConditionValue};
use std::str::FromStr;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ConditionOperator {
StringEquals,
StringNotEquals,
StringLike,
StringNotLike,
StringEqualsIgnoreCase,
StringNotEqualsIgnoreCase,
StringEqualsIfExists,
StringNotEqualsIfExists,
StringLikeIfExists,
StringNotLikeIfExists,
NumericEquals,
NumericNotEquals,
NumericLessThan,
NumericLessThanEquals,
NumericGreaterThan,
NumericGreaterThanEquals,
NumericEqualsIfExists,
NumericNotEqualsIfExists,
NumericLessThanIfExists,
NumericLessThanEqualsIfExists,
NumericGreaterThanIfExists,
NumericGreaterThanEqualsIfExists,
DateEquals,
DateNotEquals,
DateLessThan,
DateLessThanEquals,
DateGreaterThan,
DateGreaterThanEquals,
DateEqualsIfExists,
DateNotEqualsIfExists,
DateLessThanIfExists,
DateLessThanEqualsIfExists,
DateGreaterThanIfExists,
DateGreaterThanEqualsIfExists,
IpAddress,
NotIpAddress,
IpAddressIfExists,
NotIpAddressIfExists,
ArnEquals,
ArnNotEquals,
ArnLike,
ArnNotLike,
ArnEqualsIfExists,
ArnNotEqualsIfExists,
ArnLikeIfExists,
ArnNotLikeIfExists,
Bool,
BoolIfExists,
BinaryEquals,
BinaryEqualsIfExists,
Null,
NullIfExists,
ForAllValuesStringEquals,
ForAllValuesStringNotEquals,
ForAllValuesStringLike,
ForAllValuesStringNotLike,
ForAllValuesArnEquals,
ForAllValuesArnLike,
ForAllValuesNumericLessThan,
ForAllValuesNumericGreaterThan,
ForAllValuesIpAddress,
ForAllValuesDateLessThan,
ForAllValuesDateGreaterThan,
ForAnyValueStringEquals,
ForAnyValueStringNotEquals,
ForAnyValueStringLike,
ForAnyValueStringNotLike,
ForAnyValueArnEquals,
ForAnyValueArnLike,
ForAnyValueNumericLessThan,
ForAnyValueNumericGreaterThan,
ForAnyValueIpAddress,
ForAnyValueDateLessThan,
ForAnyValueDateGreaterThan,
}
impl FromStr for ConditionOperator {
type Err = ConditionError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"StringEquals" => Ok(ConditionOperator::StringEquals),
"StringNotEquals" => Ok(ConditionOperator::StringNotEquals),
"StringLike" => Ok(ConditionOperator::StringLike),
"StringNotLike" => Ok(ConditionOperator::StringNotLike),
"StringEqualsIgnoreCase" => Ok(ConditionOperator::StringEqualsIgnoreCase),
"StringNotEqualsIgnoreCase" => Ok(ConditionOperator::StringNotEqualsIgnoreCase),
"StringEqualsIfExists" => Ok(ConditionOperator::StringEqualsIfExists),
"StringNotEqualsIfExists" => Ok(ConditionOperator::StringNotEqualsIfExists),
"StringLikeIfExists" => Ok(ConditionOperator::StringLikeIfExists),
"StringNotLikeIfExists" => Ok(ConditionOperator::StringNotLikeIfExists),
"NumericEquals" => Ok(ConditionOperator::NumericEquals),
"NumericNotEquals" => Ok(ConditionOperator::NumericNotEquals),
"NumericLessThan" => Ok(ConditionOperator::NumericLessThan),
"NumericLessThanEquals" => Ok(ConditionOperator::NumericLessThanEquals),
"NumericGreaterThan" => Ok(ConditionOperator::NumericGreaterThan),
"NumericGreaterThanEquals" => Ok(ConditionOperator::NumericGreaterThanEquals),
"NumericEqualsIfExists" => Ok(ConditionOperator::NumericEqualsIfExists),
"NumericNotEqualsIfExists" => Ok(ConditionOperator::NumericNotEqualsIfExists),
"NumericLessThanIfExists" => Ok(ConditionOperator::NumericLessThanIfExists),
"NumericLessThanEqualsIfExists" => Ok(ConditionOperator::NumericLessThanEqualsIfExists),
"NumericGreaterThanIfExists" => Ok(ConditionOperator::NumericGreaterThanIfExists),
"NumericGreaterThanEqualsIfExists" => {
Ok(ConditionOperator::NumericGreaterThanEqualsIfExists)
}
"DateEquals" => Ok(ConditionOperator::DateEquals),
"DateNotEquals" => Ok(ConditionOperator::DateNotEquals),
"DateLessThan" => Ok(ConditionOperator::DateLessThan),
"DateLessThanEquals" => Ok(ConditionOperator::DateLessThanEquals),
"DateGreaterThan" => Ok(ConditionOperator::DateGreaterThan),
"DateGreaterThanEquals" => Ok(ConditionOperator::DateGreaterThanEquals),
"DateEqualsIfExists" => Ok(ConditionOperator::DateEqualsIfExists),
"DateNotEqualsIfExists" => Ok(ConditionOperator::DateNotEqualsIfExists),
"DateLessThanIfExists" => Ok(ConditionOperator::DateLessThanIfExists),
"DateLessThanEqualsIfExists" => Ok(ConditionOperator::DateLessThanEqualsIfExists),
"DateGreaterThanIfExists" => Ok(ConditionOperator::DateGreaterThanIfExists),
"DateGreaterThanEqualsIfExists" => Ok(ConditionOperator::DateGreaterThanEqualsIfExists),
"IpAddress" => Ok(ConditionOperator::IpAddress),
"NotIpAddress" => Ok(ConditionOperator::NotIpAddress),
"IpAddressIfExists" => Ok(ConditionOperator::IpAddressIfExists),
"NotIpAddressIfExists" => Ok(ConditionOperator::NotIpAddressIfExists),
"ArnEquals" => Ok(ConditionOperator::ArnEquals),
"ArnNotEquals" => Ok(ConditionOperator::ArnNotEquals),
"ArnLike" => Ok(ConditionOperator::ArnLike),
"ArnNotLike" => Ok(ConditionOperator::ArnNotLike),
"ArnEqualsIfExists" => Ok(ConditionOperator::ArnEqualsIfExists),
"ArnNotEqualsIfExists" => Ok(ConditionOperator::ArnNotEqualsIfExists),
"ArnLikeIfExists" => Ok(ConditionOperator::ArnLikeIfExists),
"ArnNotLikeIfExists" => Ok(ConditionOperator::ArnNotLikeIfExists),
"Bool" => Ok(ConditionOperator::Bool),
"BoolIfExists" => Ok(ConditionOperator::BoolIfExists),
"BinaryEquals" => Ok(ConditionOperator::BinaryEquals),
"BinaryEqualsIfExists" => Ok(ConditionOperator::BinaryEqualsIfExists),
"Null" => Ok(ConditionOperator::Null),
"NullIfExists" => Ok(ConditionOperator::NullIfExists),
"ForAllValues:StringEquals" => Ok(ConditionOperator::ForAllValuesStringEquals),
"ForAllValues:StringNotEquals" => Ok(ConditionOperator::ForAllValuesStringNotEquals),
"ForAllValues:StringLike" => Ok(ConditionOperator::ForAllValuesStringLike),
"ForAllValues:StringNotLike" => Ok(ConditionOperator::ForAllValuesStringNotLike),
"ForAllValues:ArnEquals" => Ok(ConditionOperator::ForAllValuesArnEquals),
"ForAllValues:ArnLike" => Ok(ConditionOperator::ForAllValuesArnLike),
"ForAllValues:NumericLessThan" => Ok(ConditionOperator::ForAllValuesNumericLessThan),
"ForAllValues:NumericGreaterThan" => {
Ok(ConditionOperator::ForAllValuesNumericGreaterThan)
}
"ForAllValues:IpAddress" => Ok(ConditionOperator::ForAllValuesIpAddress),
"ForAllValues:DateLessThan" => Ok(ConditionOperator::ForAllValuesDateLessThan),
"ForAllValues:DateGreaterThan" => Ok(ConditionOperator::ForAllValuesDateGreaterThan),
"ForAnyValue:StringEquals" => Ok(ConditionOperator::ForAnyValueStringEquals),
"ForAnyValue:StringNotEquals" => Ok(ConditionOperator::ForAnyValueStringNotEquals),
"ForAnyValue:StringLike" => Ok(ConditionOperator::ForAnyValueStringLike),
"ForAnyValue:StringNotLike" => Ok(ConditionOperator::ForAnyValueStringNotLike),
"ForAnyValue:ArnEquals" => Ok(ConditionOperator::ForAnyValueArnEquals),
"ForAnyValue:ArnLike" => Ok(ConditionOperator::ForAnyValueArnLike),
"ForAnyValue:NumericLessThan" => Ok(ConditionOperator::ForAnyValueNumericLessThan),
"ForAnyValue:NumericGreaterThan" => {
Ok(ConditionOperator::ForAnyValueNumericGreaterThan)
}
"ForAnyValue:IpAddress" => Ok(ConditionOperator::ForAnyValueIpAddress),
"ForAnyValue:DateLessThan" => Ok(ConditionOperator::ForAnyValueDateLessThan),
"ForAnyValue:DateGreaterThan" => Ok(ConditionOperator::ForAnyValueDateGreaterThan),
_ => Err(ConditionError::UnknownOperator(s.to_string())),
}
}
}
pub fn evaluate_operator(
operator: ConditionOperator,
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
match operator {
ConditionOperator::StringEquals => evaluate_string_equals(actual, expected),
ConditionOperator::StringNotEquals => evaluate_string_equals(actual, expected).map(|r| !r),
ConditionOperator::StringLike => evaluate_string_like(actual, expected),
ConditionOperator::StringNotLike => evaluate_string_like(actual, expected).map(|r| !r),
ConditionOperator::StringEqualsIgnoreCase => {
evaluate_string_equals_ignore_case(actual, expected)
}
ConditionOperator::StringNotEqualsIgnoreCase => {
evaluate_string_equals_ignore_case(actual, expected).map(|r| !r)
}
ConditionOperator::StringEqualsIfExists => {
evaluate_if_exists(actual, |a| evaluate_string_equals(Some(a), expected))
}
ConditionOperator::StringNotEqualsIfExists => evaluate_if_exists(actual, |a| {
evaluate_string_equals(Some(a), expected).map(|r| !r)
}),
ConditionOperator::StringLikeIfExists => {
evaluate_if_exists(actual, |a| evaluate_string_like(Some(a), expected))
}
ConditionOperator::StringNotLikeIfExists => evaluate_if_exists(actual, |a| {
evaluate_string_like(Some(a), expected).map(|r| !r)
}),
ConditionOperator::NumericEquals => evaluate_numeric_equals(actual, expected),
ConditionOperator::NumericNotEquals => {
evaluate_numeric_equals(actual, expected).map(|r| !r)
}
ConditionOperator::NumericLessThan => evaluate_numeric_less_than(actual, expected),
ConditionOperator::NumericLessThanEquals => {
evaluate_numeric_less_than_equals(actual, expected)
}
ConditionOperator::NumericGreaterThan => evaluate_numeric_greater_than(actual, expected),
ConditionOperator::NumericGreaterThanEquals => {
evaluate_numeric_greater_than_equals(actual, expected)
}
ConditionOperator::NumericEqualsIfExists => {
evaluate_if_exists(actual, |a| evaluate_numeric_equals(Some(a), expected))
}
ConditionOperator::NumericNotEqualsIfExists => evaluate_if_exists(actual, |a| {
evaluate_numeric_equals(Some(a), expected).map(|r| !r)
}),
ConditionOperator::NumericLessThanIfExists => {
evaluate_if_exists(actual, |a| evaluate_numeric_less_than(Some(a), expected))
}
ConditionOperator::NumericLessThanEqualsIfExists => evaluate_if_exists(actual, |a| {
evaluate_numeric_less_than_equals(Some(a), expected)
}),
ConditionOperator::NumericGreaterThanIfExists => {
evaluate_if_exists(actual, |a| evaluate_numeric_greater_than(Some(a), expected))
}
ConditionOperator::NumericGreaterThanEqualsIfExists => evaluate_if_exists(actual, |a| {
evaluate_numeric_greater_than_equals(Some(a), expected)
}),
ConditionOperator::DateEquals => evaluate_date_equals(actual, expected),
ConditionOperator::DateNotEquals => evaluate_date_equals(actual, expected).map(|r| !r),
ConditionOperator::DateLessThan => evaluate_date_less_than(actual, expected),
ConditionOperator::DateLessThanEquals => evaluate_date_less_than_equals(actual, expected),
ConditionOperator::DateGreaterThan => evaluate_date_greater_than(actual, expected),
ConditionOperator::DateGreaterThanEquals => {
evaluate_date_greater_than_equals(actual, expected)
}
ConditionOperator::DateEqualsIfExists => {
evaluate_if_exists(actual, |a| evaluate_date_equals(Some(a), expected))
}
ConditionOperator::DateNotEqualsIfExists => evaluate_if_exists(actual, |a| {
evaluate_date_equals(Some(a), expected).map(|r| !r)
}),
ConditionOperator::DateLessThanIfExists => {
evaluate_if_exists(actual, |a| evaluate_date_less_than(Some(a), expected))
}
ConditionOperator::DateLessThanEqualsIfExists => evaluate_if_exists(actual, |a| {
evaluate_date_less_than_equals(Some(a), expected)
}),
ConditionOperator::DateGreaterThanIfExists => {
evaluate_if_exists(actual, |a| evaluate_date_greater_than(Some(a), expected))
}
ConditionOperator::DateGreaterThanEqualsIfExists => evaluate_if_exists(actual, |a| {
evaluate_date_greater_than_equals(Some(a), expected)
}),
ConditionOperator::IpAddress => evaluate_ip_address(actual, expected),
ConditionOperator::NotIpAddress => evaluate_ip_address(actual, expected).map(|r| !r),
ConditionOperator::IpAddressIfExists => {
evaluate_if_exists(actual, |a| evaluate_ip_address(Some(a), expected))
}
ConditionOperator::NotIpAddressIfExists => evaluate_if_exists(actual, |a| {
evaluate_ip_address(Some(a), expected).map(|r| !r)
}),
ConditionOperator::ArnEquals => evaluate_arn_equals(actual, expected),
ConditionOperator::ArnNotEquals => evaluate_arn_equals(actual, expected).map(|r| !r),
ConditionOperator::ArnLike => evaluate_arn_like(actual, expected),
ConditionOperator::ArnNotLike => evaluate_arn_like(actual, expected).map(|r| !r),
ConditionOperator::ArnEqualsIfExists => {
evaluate_if_exists(actual, |a| evaluate_arn_equals(Some(a), expected))
}
ConditionOperator::ArnNotEqualsIfExists => evaluate_if_exists(actual, |a| {
evaluate_arn_equals(Some(a), expected).map(|r| !r)
}),
ConditionOperator::ArnLikeIfExists => {
evaluate_if_exists(actual, |a| evaluate_arn_like(Some(a), expected))
}
ConditionOperator::ArnNotLikeIfExists => {
evaluate_if_exists(actual, |a| evaluate_arn_like(Some(a), expected).map(|r| !r))
}
ConditionOperator::Bool => evaluate_bool(actual, expected),
ConditionOperator::BoolIfExists => {
evaluate_if_exists(actual, |a| evaluate_bool(Some(a), expected))
}
ConditionOperator::BinaryEquals => evaluate_binary_equals(actual, expected),
ConditionOperator::BinaryEqualsIfExists => {
evaluate_if_exists(actual, |a| evaluate_binary_equals(Some(a), expected))
}
ConditionOperator::Null => evaluate_null(actual, expected),
ConditionOperator::NullIfExists => {
evaluate_if_exists(actual, |a| evaluate_null(Some(a), expected))
}
ConditionOperator::ForAllValuesStringEquals => {
set_string_equals(Quantifier::All, actual, expected)
}
ConditionOperator::ForAllValuesStringNotEquals => {
set_string_equals(Quantifier::All, actual, expected).map(|r| !r)
}
ConditionOperator::ForAllValuesStringLike => {
set_string_like(Quantifier::All, actual, expected)
}
ConditionOperator::ForAllValuesStringNotLike => {
set_string_like(Quantifier::All, actual, expected).map(|r| !r)
}
ConditionOperator::ForAllValuesArnEquals => {
set_string_equals(Quantifier::All, actual, expected)
}
ConditionOperator::ForAllValuesArnLike => {
set_string_like(Quantifier::All, actual, expected)
}
ConditionOperator::ForAllValuesNumericLessThan => without_key(operator),
ConditionOperator::ForAllValuesNumericGreaterThan => without_key(operator),
ConditionOperator::ForAllValuesIpAddress => without_key(operator),
ConditionOperator::ForAllValuesDateLessThan => without_key(operator),
ConditionOperator::ForAllValuesDateGreaterThan => without_key(operator),
ConditionOperator::ForAnyValueStringEquals => {
set_string_equals(Quantifier::Any, actual, expected)
}
ConditionOperator::ForAnyValueStringNotEquals => {
set_string_equals(Quantifier::Any, actual, expected).map(|r| !r)
}
ConditionOperator::ForAnyValueStringLike => {
set_string_like(Quantifier::Any, actual, expected)
}
ConditionOperator::ForAnyValueStringNotLike => {
set_string_like(Quantifier::Any, actual, expected).map(|r| !r)
}
ConditionOperator::ForAnyValueArnEquals => {
set_string_equals(Quantifier::Any, actual, expected)
}
ConditionOperator::ForAnyValueArnLike => set_string_like(Quantifier::Any, actual, expected),
ConditionOperator::ForAnyValueNumericLessThan => without_key(operator),
ConditionOperator::ForAnyValueNumericGreaterThan => without_key(operator),
ConditionOperator::ForAnyValueIpAddress => without_key(operator),
ConditionOperator::ForAnyValueDateLessThan => without_key(operator),
ConditionOperator::ForAnyValueDateGreaterThan => without_key(operator),
}
}
fn evaluate_if_exists<F>(
actual: Option<ConditionValue>,
evaluator: F,
) -> Result<bool, ConditionError>
where
F: FnOnce(ConditionValue) -> Result<bool, ConditionError>,
{
match actual {
Some(value) => evaluator(value),
None => Ok(true), }
}
fn evaluate_string_equals(
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
match actual {
Some(ConditionValue::String(actual_str)) => {
let expected_str = expected.as_string()?;
Ok(actual_str == expected_str)
}
None => Ok(false), Some(other) => Err(other.mismatch("String")),
}
}
fn evaluate_string_equals_ignore_case(
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
match actual {
Some(ConditionValue::String(actual_str)) => {
let expected_str = expected.as_string()?;
Ok(actual_str.eq_ignore_ascii_case(&expected_str))
}
None => Ok(false),
Some(other) => Err(other.mismatch("String")),
}
}
fn evaluate_string_like(
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
match actual {
Some(ConditionValue::String(actual_str)) => {
let pattern = expected.as_string()?;
Ok(matches_wildcard_pattern(&actual_str, &pattern))
}
None => Ok(false),
Some(other) => Err(other.mismatch("String")),
}
}
fn matches_wildcard_pattern(value: &str, pattern: &str) -> bool {
if pattern == "*" {
return true;
}
let mut value_chars = value.chars();
let mut pattern_chars = pattern.chars();
while let Some(pc) = pattern_chars.next() {
match pc {
'*' => {
let remaining_pattern: String = pattern_chars.collect();
if remaining_pattern.is_empty() {
return true; }
let remaining_value: String = value_chars.as_str().chars().collect();
if matches_wildcard_pattern(&remaining_value, &remaining_pattern) {
return true; }
while let Some(_) = value_chars.next() {
let remaining_value: String = value_chars.as_str().chars().collect();
if matches_wildcard_pattern(&remaining_value, &remaining_pattern) {
return true;
}
}
return false;
}
'?' => {
if value_chars.next().is_none() {
return false;
}
}
_ => {
if value_chars.next() != Some(pc) {
return false;
}
}
}
}
value_chars.next().is_none()
}
fn evaluate_numeric_equals(
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
match actual {
Some(actual_val) => {
let actual_num = actual_val.as_number()?;
let expected_num = expected.as_number()?;
Ok((actual_num - expected_num).abs() < f64::EPSILON)
}
None => Ok(false),
}
}
fn evaluate_numeric_less_than(
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
match actual {
Some(actual_val) => {
let actual_num = actual_val.as_number()?;
let expected_num = expected.as_number()?;
Ok(actual_num < expected_num)
}
None => Ok(false),
}
}
fn evaluate_numeric_less_than_equals(
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
match actual {
Some(actual_val) => {
let actual_num = actual_val.as_number()?;
let expected_num = expected.as_number()?;
Ok(actual_num <= expected_num)
}
None => Ok(false),
}
}
fn evaluate_numeric_greater_than(
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
match actual {
Some(actual_val) => {
let actual_num = actual_val.as_number()?;
let expected_num = expected.as_number()?;
Ok(actual_num > expected_num)
}
None => Ok(false),
}
}
fn evaluate_numeric_greater_than_equals(
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
match actual {
Some(actual_val) => {
let actual_num = actual_val.as_number()?;
let expected_num = expected.as_number()?;
Ok(actual_num >= expected_num)
}
None => Ok(false),
}
}
fn evaluate_date_equals(
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
match actual {
Some(ConditionValue::String(actual_str)) => {
let expected_str = expected.as_string()?;
let actual_time = parse_rfc3339(&actual_str)?;
let expected_time = parse_rfc3339(&expected_str)?;
Ok(actual_time == expected_time)
}
None => Ok(false),
Some(other) => Err(other.mismatch("String")),
}
}
fn evaluate_date_less_than(
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
match actual {
Some(ConditionValue::String(actual_str)) => {
let expected_str = expected.as_string()?;
let actual_time = parse_rfc3339(&actual_str)?;
let expected_time = parse_rfc3339(&expected_str)?;
Ok(actual_time < expected_time)
}
None => Ok(false),
Some(other) => Err(other.mismatch("String")),
}
}
fn evaluate_date_less_than_equals(
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
match actual {
Some(ConditionValue::String(actual_str)) => {
let expected_str = expected.as_string()?;
let actual_time = parse_rfc3339(&actual_str)?;
let expected_time = parse_rfc3339(&expected_str)?;
Ok(actual_time <= expected_time)
}
None => Ok(false),
Some(other) => Err(other.mismatch("String")),
}
}
fn evaluate_date_greater_than(
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
match actual {
Some(ConditionValue::String(actual_str)) => {
let expected_str = expected.as_string()?;
let actual_time = parse_rfc3339(&actual_str)?;
let expected_time = parse_rfc3339(&expected_str)?;
Ok(actual_time > expected_time)
}
None => Ok(false),
Some(other) => Err(other.mismatch("String")),
}
}
fn evaluate_date_greater_than_equals(
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
match actual {
Some(ConditionValue::String(actual_str)) => {
let expected_str = expected.as_string()?;
let actual_time = parse_rfc3339(&actual_str)?;
let expected_time = parse_rfc3339(&expected_str)?;
Ok(actual_time >= expected_time)
}
None => Ok(false),
Some(other) => Err(other.mismatch("String")),
}
}
pub(crate) fn parse_rfc3339(s: &str) -> Result<chrono::DateTime<chrono::Utc>, ConditionError> {
chrono::DateTime::parse_from_rfc3339(s)
.map(|dt| dt.with_timezone(&chrono::Utc))
.map_err(|e| ConditionError::InvalidDate {
error: e.to_string(),
})
}
fn evaluate_ip_address(
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
match actual {
Some(ConditionValue::String(actual_ip)) => {
check_address(&actual_ip, None)?;
let networks: Vec<&str> = match expected {
ConditionValue::String(network) => vec![network.as_str()],
ConditionValue::Array(networks) => networks.iter().map(String::as_str).collect(),
other => return Err(other.mismatch("an IP address or a list of them")),
};
for (index, network) in networks.iter().enumerate() {
check_ip_or_cidr(
network,
matches!(expected, ConditionValue::Array(_)).then_some(index),
)?;
}
Ok(networks
.iter()
.any(|network| ip_matches_cidr(&actual_ip, network)))
}
None => Ok(false),
Some(other) => Err(other.mismatch("an IP address")),
}
}
pub(crate) fn is_address(s: &str) -> bool {
parse_ipv4(s).is_some() || s.parse::<std::net::Ipv6Addr>().is_ok()
}
fn not_an_address(expected: &str, position: Option<usize>) -> ConditionError {
ConditionError::TypeMismatch {
expected: match position {
Some(index) => format!("{expected} at element {index}"),
None => expected.to_string(),
},
actual: "String".to_string(),
}
}
fn check_address(s: &str, position: Option<usize>) -> Result<(), ConditionError> {
if is_address(s) {
Ok(())
} else {
Err(not_an_address("an IP address", position))
}
}
pub(crate) fn check_ip_or_cidr(s: &str, position: Option<usize>) -> Result<(), ConditionError> {
let is_v4 = |a: &str| parse_ipv4(a).is_some();
let is_v6 = |a: &str| a.parse::<std::net::Ipv6Addr>().is_ok();
let readable = match s.split_once('/') {
None => is_address(s),
Some((network, prefix)) => match prefix.parse::<u8>() {
Ok(p) if is_v4(network) => p <= 32,
Ok(p) if is_v6(network) => p <= 128,
_ => false,
},
};
if readable {
Ok(())
} else {
Err(not_an_address("an IP address or CIDR", position))
}
}
fn ip_matches_cidr(ip: &str, cidr: &str) -> bool {
if ip == cidr {
return true; }
if let Some((network, prefix_len_str)) = cidr.split_once('/') {
if let Ok(prefix_len) = prefix_len_str.parse::<u8>() {
if let (Some(ip_addr), Some(net_addr)) = (parse_ipv4(ip), parse_ipv4(network)) {
return ip_in_cidr_v4(ip_addr, net_addr, prefix_len);
}
if ip.contains(':') && cidr.contains(':') {
if let Some((network_part, _)) = cidr.split_once('/') {
if prefix_len <= 128 {
return ip.starts_with(network_part) || ip == network;
}
}
return ip == network; }
}
}
false
}
pub(crate) fn parse_ipv4(ip: &str) -> Option<[u8; 4]> {
let parts: Vec<&str> = ip.split('.').collect();
if parts.len() != 4 {
return None;
}
let mut bytes = [0u8; 4];
for (i, part) in parts.iter().enumerate() {
bytes[i] = part.parse().ok()?;
}
Some(bytes)
}
fn ip_in_cidr_v4(ip: [u8; 4], network: [u8; 4], prefix_len: u8) -> bool {
if prefix_len > 32 {
return false;
}
let mask_bits = prefix_len;
let full_bytes = (mask_bits / 8) as usize;
let remaining_bits = mask_bits % 8;
for i in 0..full_bytes {
if ip[i] != network[i] {
return false;
}
}
if remaining_bits > 0 && full_bytes < 4 {
let mask = !((1u8 << (8 - remaining_bits)) - 1);
if (ip[full_bytes] & mask) != (network[full_bytes] & mask) {
return false;
}
}
true
}
fn evaluate_arn_equals(
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
match actual {
Some(ConditionValue::String(actual_arn)) => {
let expected_arn = expected.as_string()?;
Ok(actual_arn == expected_arn)
}
None => Ok(false),
Some(other) => Err(other.mismatch("String")),
}
}
fn evaluate_arn_like(
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
match actual {
Some(ConditionValue::String(actual_arn)) => {
let pattern = expected.as_string()?;
Ok(matches_wildcard_pattern(&actual_arn, &pattern))
}
None => Ok(false),
Some(other) => Err(other.mismatch("String")),
}
}
fn evaluate_bool(
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
match actual {
Some(actual_val) => {
let actual_bool = actual_val.as_boolean()?;
let expected_bool = expected.as_boolean()?;
Ok(actual_bool == expected_bool)
}
None => Ok(false),
}
}
fn evaluate_binary_equals(
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
match actual {
Some(ConditionValue::String(actual_base64)) => {
let expected_base64 = expected.as_string()?;
Ok(actual_base64 == expected_base64)
}
None => Ok(false),
Some(other) => Err(other.mismatch("String")),
}
}
fn evaluate_null(
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
let expected_bool = expected.as_boolean()?;
let is_null = actual.is_none();
Ok(is_null == expected_bool)
}
#[derive(Clone, Copy)]
enum Quantifier {
All,
Any,
}
impl Quantifier {
fn over<T>(self, items: &[T], test: impl Fn(&T) -> bool) -> bool {
match self {
Quantifier::All => items.iter().all(test),
Quantifier::Any => items.iter().any(test),
}
}
fn on_nothing(self) -> bool {
matches!(self, Quantifier::All)
}
}
fn request_values(actual: ConditionValue) -> Result<Vec<String>, ConditionError> {
match actual {
ConditionValue::Array(values) => Ok(values),
ConditionValue::String(value) => Ok(vec![value]),
other => Err(other.mismatch("a String or an Array of Strings")),
}
}
fn set_string_equals(
quantifier: Quantifier,
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
let Some(actual) = actual else {
return Ok(quantifier.on_nothing());
};
let values = request_values(actual)?;
if values.is_empty() {
return Ok(quantifier.on_nothing());
}
let expected = expected.as_array()?;
Ok(quantifier.over(&values, |value| expected.contains(value)))
}
fn set_string_like(
quantifier: Quantifier,
actual: Option<ConditionValue>,
expected: &ConditionValue,
) -> Result<bool, ConditionError> {
let Some(actual) = actual else {
return Ok(quantifier.on_nothing());
};
let values = request_values(actual)?;
if values.is_empty() {
return Ok(quantifier.on_nothing());
}
let patterns = expected.as_array()?;
Ok(quantifier.over(&values, |value| {
patterns
.iter()
.any(|pattern| matches_wildcard_pattern(value, pattern))
}))
}
fn without_key(operator: ConditionOperator) -> Result<bool, ConditionError> {
Err(ConditionError::OperatorWithoutKey {
operator: crate::validate::without_key(operator)
.unwrap_or("a set operator")
.to_string(),
})
}