Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
55 changes: 55 additions & 0 deletions clash-lib/src/app/router/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -538,6 +538,61 @@ mod tests {
assert_eq!(entry.interface(), Some("en0"));
}

#[tokio::test]
async fn test_composite_resolution_in_match_route() {
async fn route(rule: &str, expected_resolves: usize) -> String {
let mut resolver = MockClashResolver::new();
resolver
.expect_resolve()
.times(expected_resolves)
.returning(|_, _| Ok(Some("10.1.2.3".parse().unwrap())));

let router = super::Router::new(
vec![RuleType::try_from(rule.to_owned()).unwrap()],
Default::default(),
Arc::new(resolver),
None,
None,
None,
String::new(),
)
.await;

router
.match_route(&mut Session {
destination: crate::session::SocksAddr::Domain(
"internal.example".to_owned(),
53,
),
network: crate::session::Network::Udp,
..Default::default()
})
.await
.0
.to_owned()
}

// resolves the domain and matches the IP sub-rule
assert_eq!(
route("AND,((IP-CIDR,10.0.0.0/8),(NETWORK,UDP)),PROXY", 1).await,
"PROXY"
);
// no-resolve: no DNS lookup, so the IP sub-rule cannot match
assert_eq!(
route(
"AND,((IP-CIDR,10.0.0.0/8,no-resolve),(NETWORK,UDP)),PROXY",
0
)
.await,
"MATCH"
);
// source-address sub-rules never trigger a lookup
assert_eq!(
route("AND,((SRC-IP-CIDR,10.0.0.0/8),(NETWORK,UDP)),PROXY", 0).await,
"MATCH"
);
}

#[tokio::test]
async fn test_route_match() {
initialize();
Expand Down
167 changes: 166 additions & 1 deletion clash-lib/src/app/router/rules/composite.rs
Original file line number Diff line number Diff line change
Expand Up @@ -38,6 +38,36 @@ impl RuleExpression {
RuleExpression::Not(expr) => !expr.evaluate(sess),
}
}

/// Whether any leaf rule in this expression needs the destination IP
fn should_resolve_ip(&self) -> bool {
match self {
RuleExpression::Rule(matcher) => matcher.should_resolve_ip(),
Comment thread
coderabbitai[bot] marked this conversation as resolved.
Resolved
RuleExpression::And(exprs) | RuleExpression::Or(exprs) => {
exprs.iter().any(|e| e.should_resolve_ip())
}
RuleExpression::Not(expr) => expr.should_resolve_ip(),
}
}
}

/// Split trailing rule options (`no-resolve`, `interface=...`) off a sub-rule
/// body such as `cncidr,no-resolve`. Only recognized options are split off, so
/// payloads that contain commas (e.g. `DOMAIN-REGEX,^a{1,3}$`) are kept whole.
fn split_sub_rule_options(rest: &str) -> (&str, Vec<&str>) {
let mut payload = rest;
let mut params = Vec::new();
while let Some((head, last)) = payload.rsplit_once(',') {
let last = last.trim();
if last == "no-resolve" || last.starts_with("interface=") {
params.push(last);
payload = head;
} else {
break;
}
}
params.reverse();
(payload.trim(), params)
}

pub struct CompositeRule {
Expand Down Expand Up @@ -251,7 +281,14 @@ impl CompositeRule {
}

// It's a leaf rule - parse as RuleType
let rule = RuleType::new(rule_type, rest, "", None)?;
let (payload, params) = split_sub_rule_options(rest);
let rule = RuleType::new(rule_type, payload, "", Some(params))?;
if rule.interface().is_some() {
return Err(crate::Error::InvalidConfig(format!(
"rule option `interface` is not supported inside composite \
sub-rules, set it on the composite rule instead: {expr_str}"
)));
}
let matcher = map_rule_type(rule, mmdb, geodata, rule_provider_registry);
Ok(RuleExpression::Rule(matcher))
}
Expand Down Expand Up @@ -295,6 +332,10 @@ impl RuleMatcher for CompositeRule {
fn type_name(&self) -> &str {
&self.operator
}

fn should_resolve_ip(&self) -> bool {
self.expression.should_resolve_ip()
}
}

#[cfg(test)]
Expand All @@ -310,6 +351,130 @@ mod tests {
}
}

#[test]
fn test_sub_rule_no_resolve_option() {
// no-resolve is parsed as an option, not as part of the payload
let rule = CompositeRule::new(
"AND",
"((IP-CIDR,10.0.0.0/8,no-resolve),(NETWORK,UDP))",
"DIRECT",
None,
None,
None,
)
.unwrap();
assert!(!rule.should_resolve_ip());

let sess = Session {
destination: SocksAddr::Ip("10.1.2.3:53".parse().unwrap()),
network: Network::Udp,
..Default::default()
};
assert!(rule.apply(&sess));

// without no-resolve, a nested IP rule makes the composite resolve
let rule = CompositeRule::new(
"OR",
"((DOMAIN,example.com),(NOT,((IP-CIDR,10.0.0.0/8))))",
"DIRECT",
None,
None,
None,
)
.unwrap();
assert!(rule.should_resolve_ip());

// domain-only composites never resolve
let rule = CompositeRule::new(
"AND",
"((DOMAIN,example.com),(NETWORK,TCP))",
"DIRECT",
None,
None,
None,
)
.unwrap();
assert!(!rule.should_resolve_ip());
}

#[test]
fn test_sub_rule_whitespace() {
let rule = CompositeRule::new(
"AND",
"(( IP-CIDR , 10.0.0.0/8 , no-resolve ),( NETWORK, UDP ))",
"DIRECT",
None,
None,
None,
)
.unwrap();
assert!(!rule.should_resolve_ip());
assert!(rule.apply(&Session {
destination: SocksAddr::Ip("10.1.2.3:53".parse().unwrap()),
network: Network::Udp,
..Default::default()
}));
}

#[test]
fn test_src_ip_cidr_does_not_resolve() {
let rule = CompositeRule::new(
"AND",
"((DOMAIN,example.com),(SRC-IP-CIDR,192.168.0.0/16))",
"DIRECT",
None,
None,
None,
)
.unwrap();
assert!(!rule.should_resolve_ip());
}

#[test]
fn test_sub_rule_options() {
// payloads containing commas are kept whole
let rule = CompositeRule::new(
"AND",
r"((DOMAIN-REGEX,^a{1,3}\.example\.com$),(NETWORK,TCP))",
"DIRECT",
None,
None,
None,
)
.unwrap();
assert!(rule.apply(&create_test_session(
"aa.example.com",
443,
Network::Tcp
)));

// interface belongs on the composite rule, not on sub-rules
assert!(
CompositeRule::new(
"AND",
"((DOMAIN,example.com,interface=en0),(NETWORK,TCP))",
"DIRECT",
None,
None,
None,
)
.is_err()
);

// options still follow the per-rule-type rules
assert!(
CompositeRule::new(
"AND",
"((DOMAIN,example.com,no-resolve),(NETWORK,TCP))",
"DIRECT",
None,
None,
None,
)
.is_err()
);
}

#[test]
fn test_and_operator_both_match() {
let rule = CompositeRule::new(
Expand Down
4 changes: 3 additions & 1 deletion clash-lib/src/app/router/rules/ipcidr.rs
Original file line number Diff line number Diff line change
Expand Up @@ -40,7 +40,9 @@ impl RuleMatcher for IpCidr {
}

fn should_resolve_ip(&self) -> bool {
!self.no_resolve
// SRC-IP-CIDR matches the source address and never needs the
// destination resolved
!self.match_src && !self.no_resolve
}

fn payload(&self) -> String {
Expand Down
Loading