305 lines
8.7 KiB
Rust
305 lines
8.7 KiB
Rust
use std::fs;
|
||
use std::net::IpAddr;
|
||
use std::path::Path;
|
||
use std::str::FromStr;
|
||
|
||
use anyhow::{Context, Result, anyhow};
|
||
|
||
use crate::data_model::resources::as_resources::Asn;
|
||
use crate::data_model::resources::ip_resources::{IPAddress, IPAddressPrefix};
|
||
use crate::rtr::payload::{Aspa, Payload, RouteOrigin, RouterKey, Ski};
|
||
|
||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||
pub struct ParsedVrp {
|
||
pub prefix_addr: IpAddr,
|
||
pub prefix_len: u8,
|
||
pub max_len: u8,
|
||
pub asn: u32,
|
||
}
|
||
|
||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||
pub struct ParsedAspa {
|
||
pub customer_asn: u32,
|
||
pub provider_asns: Vec<u32>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||
pub struct ParsedRouterKey {
|
||
pub ski: [u8; 20],
|
||
pub asn: u32,
|
||
pub spki: Vec<u8>,
|
||
}
|
||
|
||
/// 从文本文件中加载 VRP，并转换成 RTR Payload::RouteOrigin。
|
||
///
|
||
/// 文件格式：
|
||
///
|
||
/// ```text
|
||
/// # prefix,max_len,asn
|
||
/// 10.0.0.0/24,24,65001
|
||
/// 10.0.1.0/24,24,65002
|
||
/// 2001:db8::/32,48,65003
|
||
/// ```
|
||
pub fn load_vrps_from_file(path: impl AsRef<Path>) -> Result<Vec<Payload>> {
|
||
let path = path.as_ref();
|
||
|
||
let content = fs::read_to_string(path)
|
||
.with_context(|| format!("failed to read VRP file: {}", path.display()))?;
|
||
|
||
let mut payloads = Vec::new();
|
||
|
||
for (idx, raw_line) in content.lines().enumerate() {
|
||
let line_no = idx + 1;
|
||
let line = raw_line.trim();
|
||
|
||
if line.is_empty() || line.starts_with('#') {
|
||
continue;
|
||
}
|
||
|
||
let vrp = parse_vrp_line(line)
|
||
.with_context(|| format!("invalid VRP line {}: {}", line_no, raw_line))?;
|
||
|
||
payloads.push(Payload::RouteOrigin(build_route_origin(vrp)?));
|
||
}
|
||
|
||
Ok(payloads)
|
||
}
|
||
|
||
pub fn load_aspas_from_file(path: impl AsRef<Path>) -> Result<Vec<Payload>> {
|
||
let path = path.as_ref();
|
||
|
||
let content = fs::read_to_string(path)
|
||
.with_context(|| format!("failed to read ASPA file: {}", path.display()))?;
|
||
|
||
let mut payloads = Vec::new();
|
||
|
||
for (idx, raw_line) in content.lines().enumerate() {
|
||
let line_no = idx + 1;
|
||
let line = raw_line.trim();
|
||
|
||
if line.is_empty() || line.starts_with('#') {
|
||
continue;
|
||
}
|
||
|
||
let aspa = parse_aspa_line(line)
|
||
.with_context(|| format!("invalid ASPA line {}: {}", line_no, raw_line))?;
|
||
|
||
payloads.push(Payload::Aspa(build_aspa(aspa)?));
|
||
}
|
||
|
||
Ok(payloads)
|
||
}
|
||
|
||
pub fn load_router_keys_from_file(path: impl AsRef<Path>) -> Result<Vec<Payload>> {
|
||
let path = path.as_ref();
|
||
|
||
let content = fs::read_to_string(path)
|
||
.with_context(|| format!("failed to read Router Key file: {}", path.display()))?;
|
||
|
||
let mut payloads = Vec::new();
|
||
|
||
for (idx, raw_line) in content.lines().enumerate() {
|
||
let line_no = idx + 1;
|
||
let line = raw_line.trim();
|
||
|
||
if line.is_empty() || line.starts_with('#') {
|
||
continue;
|
||
}
|
||
|
||
let router_key = parse_router_key_line(line)
|
||
.with_context(|| format!("invalid Router Key line {}: {}", line_no, raw_line))?;
|
||
|
||
payloads.push(Payload::RouterKey(build_router_key(router_key)?));
|
||
}
|
||
|
||
Ok(payloads)
|
||
}
|
||
|
||
/// 解析单行 VRP。
|
||
///
|
||
/// 格式：
|
||
/// `prefix/prefix_len,max_len,asn`
|
||
///
|
||
/// 例如：
|
||
/// `10.0.0.0/24,24,65001`
|
||
pub fn parse_vrp_line(line: &str) -> Result<ParsedVrp> {
|
||
let parts: Vec<_> = line.split(',').map(|s| s.trim()).collect();
|
||
if parts.len() != 3 {
|
||
return Err(anyhow!(
|
||
"expected format: <prefix>/<prefix_len>,<max_len>,<asn>"
|
||
));
|
||
}
|
||
|
||
let prefix_part = parts[0];
|
||
let max_len =
|
||
u8::from_str(parts[1]).with_context(|| format!("invalid max_len: {}", parts[1]))?;
|
||
let asn = u32::from_str(parts[2]).with_context(|| format!("invalid asn: {}", parts[2]))?;
|
||
|
||
let (addr_str, prefix_len_str) = prefix_part
|
||
.split_once('/')
|
||
.ok_or_else(|| anyhow!("prefix must be in CIDR form, e.g. 10.0.0.0/24"))?;
|
||
|
||
let prefix_addr = IpAddr::from_str(addr_str.trim())
|
||
.with_context(|| format!("invalid IP address: {}", addr_str))?;
|
||
|
||
let prefix_len = u8::from_str(prefix_len_str.trim())
|
||
.with_context(|| format!("invalid prefix length: {}", prefix_len_str))?;
|
||
|
||
validate_vrp(prefix_addr, prefix_len, max_len)?;
|
||
|
||
Ok(ParsedVrp {
|
||
prefix_addr,
|
||
prefix_len,
|
||
max_len,
|
||
asn,
|
||
})
|
||
}
|
||
|
||
pub fn parse_aspa_line(line: &str) -> Result<ParsedAspa> {
|
||
let parts: Vec<_> = line.split(',').map(|s| s.trim()).collect();
|
||
if parts.len() != 2 {
|
||
return Err(anyhow!(
|
||
"expected format: <customer_asn>,<provider_asn> [provider_asn ...]"
|
||
));
|
||
}
|
||
|
||
let customer_asn =
|
||
u32::from_str(parts[0]).with_context(|| format!("invalid customer_asn: {}", parts[0]))?;
|
||
|
||
let provider_asns = parts[1]
|
||
.split_whitespace()
|
||
.map(|provider| {
|
||
u32::from_str(provider).with_context(|| format!("invalid provider_asn: {}", provider))
|
||
})
|
||
.collect::<Result<Vec<_>>>()?;
|
||
|
||
validate_aspa(customer_asn, &provider_asns)?;
|
||
|
||
Ok(ParsedAspa {
|
||
customer_asn,
|
||
provider_asns,
|
||
})
|
||
}
|
||
|
||
pub fn parse_router_key_line(line: &str) -> Result<ParsedRouterKey> {
|
||
let parts: Vec<_> = line.split(',').map(|s| s.trim()).collect();
|
||
if parts.len() != 3 {
|
||
return Err(anyhow!("expected format: <ski_hex>,<asn>,<spki_hex>"));
|
||
}
|
||
|
||
let ski_vec = decode_hex(parts[0]).with_context(|| format!("invalid SKI hex: {}", parts[0]))?;
|
||
if ski_vec.len() != 20 {
|
||
return Err(anyhow!("SKI must be exactly 20 bytes"));
|
||
}
|
||
let mut ski = [0u8; 20];
|
||
ski.copy_from_slice(&ski_vec);
|
||
|
||
let asn = u32::from_str(parts[1]).with_context(|| format!("invalid asn: {}", parts[1]))?;
|
||
let spki = decode_hex(parts[2]).with_context(|| format!("invalid SPKI hex: {}", parts[2]))?;
|
||
|
||
validate_router_key(asn, &spki)?;
|
||
|
||
Ok(ParsedRouterKey { ski, asn, spki })
|
||
}
|
||
|
||
fn validate_vrp(prefix_addr: IpAddr, prefix_len: u8, max_len: u8) -> Result<()> {
|
||
match prefix_addr {
|
||
IpAddr::V4(_) => {
|
||
if prefix_len > 32 {
|
||
return Err(anyhow!("IPv4 prefix length must be <= 32"));
|
||
}
|
||
if max_len > 32 {
|
||
return Err(anyhow!("IPv4 max_len must be <= 32"));
|
||
}
|
||
if max_len < prefix_len {
|
||
return Err(anyhow!("IPv4 max_len must be >= prefix length"));
|
||
}
|
||
}
|
||
IpAddr::V6(_) => {
|
||
if prefix_len > 128 {
|
||
return Err(anyhow!("IPv6 prefix length must be <= 128"));
|
||
}
|
||
if max_len > 128 {
|
||
return Err(anyhow!("IPv6 max_len must be <= 128"));
|
||
}
|
||
if max_len < prefix_len {
|
||
return Err(anyhow!("IPv6 max_len must be >= prefix length"));
|
||
}
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
fn validate_aspa(customer_asn: u32, provider_asns: &[u32]) -> Result<()> {
|
||
if customer_asn == 0 {
|
||
return Err(anyhow!("customer_asn must not be AS0"));
|
||
}
|
||
|
||
if provider_asns.is_empty() {
|
||
return Err(anyhow!("provider list must not be empty"));
|
||
}
|
||
|
||
if provider_asns.iter().any(|asn| *asn == 0)
|
||
&& !(provider_asns.len() == 1 && provider_asns[0] == 0)
|
||
{
|
||
return Err(anyhow!(
|
||
"provider list containing AS0 must be exactly [0]"
|
||
));
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
|
||
fn validate_router_key(asn: u32, spki: &[u8]) -> Result<()> {
|
||
crate::rtr::payload::RouterKey::new(Ski::default(), Asn::from(asn), spki.to_vec())
|
||
.validate()
|
||
.map_err(|err| anyhow!(err.to_string()))?;
|
||
Ok(())
|
||
}
|
||
|
||
pub fn build_route_origin(vrp: ParsedVrp) -> Result<RouteOrigin> {
|
||
let address = match vrp.prefix_addr {
|
||
IpAddr::V4(addr) => IPAddress::from_ipv4(addr),
|
||
IpAddr::V6(addr) => IPAddress::from_ipv6(addr),
|
||
};
|
||
|
||
let prefix = IPAddressPrefix::new(address, vrp.prefix_len);
|
||
let asn = Asn::from(vrp.asn);
|
||
|
||
Ok(RouteOrigin::new(prefix, vrp.max_len, asn))
|
||
}
|
||
|
||
pub fn build_aspa(aspa: ParsedAspa) -> Result<Aspa> {
|
||
let customer_asn = Asn::from(aspa.customer_asn);
|
||
let provider_asns = aspa
|
||
.provider_asns
|
||
.into_iter()
|
||
.map(Asn::from)
|
||
.collect::<Vec<_>>();
|
||
let aspa = Aspa::new(customer_asn, provider_asns);
|
||
aspa.validate_announcement()?;
|
||
Ok(aspa)
|
||
}
|
||
|
||
pub fn build_router_key(router_key: ParsedRouterKey) -> Result<RouterKey> {
|
||
let asn = Asn::from(router_key.asn);
|
||
let ski = Ski::from_bytes(router_key.ski);
|
||
let router_key = RouterKey::new(ski, asn, router_key.spki);
|
||
Ok(router_key)
|
||
}
|
||
|
||
fn decode_hex(input: &str) -> Result<Vec<u8>> {
|
||
let trimmed = input.trim();
|
||
if trimmed.len() % 2 != 0 {
|
||
return Err(anyhow!("hex string must have even length"));
|
||
}
|
||
|
||
(0..trimmed.len())
|
||
.step_by(2)
|
||
.map(|idx| {
|
||
u8::from_str_radix(&trimmed[idx..idx + 2], 16)
|
||
.map_err(|err| anyhow!("invalid hex at byte {}: {}", idx / 2, err))
|
||
})
|
||
.collect()
|
||
}
|