bgpkit-commons

A Rust library for common BGP-related data and functions. Each data source is a feature-gated module with lazy loading: call load_xxx() to fetch, then query.

Quick start

[dependencies]
bgpkit-commons = "0.13"

use bgpkit_commons::BgpkitCommons;

let mut commons = BgpkitCommons::new();
commons.load_bogons().unwrap();

assert!(commons.bogons_match("23456").unwrap()); // AS23456 is reserved

Data sources

Module	Feature	Source	Data
`asinfo`	`asinfo`	RIPE NCC, CAIDA, APNIC, IIJ IHR, PeeringDB, RIR delegated stats, IRR	AS names, countries, org mappings, population, hegemony, IRR registrations
`as2rel`	`as2rel`	BGPKIT inference	AS-level provider/customer/peer relationships
`bogons`	`bogons`	IANA special registries	Reserved/bogon ASN and IP prefix detection
`countries`	`countries`	GeoNames	ISO country codes, capitals, continents, neighbors
`mrt_collectors`	`mrt_collectors`	RouteViews, RIPE RIS	BGP collector metadata (name, project, country, dates)
`peeringdb`	`peeringdb`	PeeringDB API	All 12 endpoints: networks, IXPs, facilities, orgs, carriers
`rpki`	`rpki`	Cloudflare, RIPE NCC, RPKIviews, RPKISPOOL	ROA and ASPA validation (real-time and historical)
`delegated`	`delegated`	NRO/RIR delegated stats	RIR allocation records (ASN, IPv4, IPv6)
`irr`	`irr`	RIPE, APNIC, ARIN, LACNIC, AFRINIC, NTTCOM, RADB, ...	RPSL aut-num, route, route6, as-set records
`export`	`export`	All of the above	Parquet export of every loaded data source

Usage

AS information with enrichment

use bgpkit_commons::asinfo::AsInfoProfile;
use bgpkit_commons::BgpkitCommons;

let mut commons = BgpkitCommons::new();
commons.load_asinfo_with_profile(AsInfoProfile::Default).unwrap();

if let Ok(Some(asinfo)) = commons.asinfo_get(13335) {
    println!("AS{}: {} ({})", asinfo.asn, asinfo.name, asinfo.country);
}

Fine-grained source selection

use bgpkit_commons::BgpkitCommons;

let mut commons = BgpkitCommons::new();
let builder = commons.asinfo_builder()
    .with_as2org()
    .with_peeringdb();
commons.load_asinfo_with(builder).unwrap();

if let Ok(siblings) = commons.asinfo_are_siblings(13335, 132892) {
    println!("Sibling ASes: {siblings}");
}

RPKI validation

use bgpkit_commons::BgpkitCommons;

let mut commons = BgpkitCommons::new();
commons.load_rpki(None).unwrap(); // real-time Cloudflare data

let result = commons.rpki_validate(13335, "1.1.1.0/24").unwrap();
println!("RPKI: {result}"); // valid, invalid, or unknown

IRR source selection

use bgpkit_commons::asinfo::{AsInfoBuilder, IrrSourceConfig};

let asinfo = AsInfoBuilder::new()
    .with_irr_sources(IrrSourceConfig::only(&["RIPE", "RADB"]).unwrap())
    .build()
    .unwrap();

Bogon detection

use bgpkit_commons::BgpkitCommons;

let mut commons = BgpkitCommons::new();
commons.load_bogons().unwrap();

assert!(commons.bogons_match("10.0.0.0/8").unwrap());   // RFC 1918
assert!(commons.bogons_match_asn(65535).unwrap());       // reserved ASN

PeeringDB

use bgpkit_commons::peeringdb::Peeringdb;

let pdb = Peeringdb::new().unwrap(); // all 12 endpoints
let cf = pdb.get_network(13335).unwrap();
println!("{}: {} IXP memberships", cf.name.unwrap(), cf.ix_count.unwrap());

Direct module access

Modules work standalone without the BgpkitCommons facade:

use bgpkit_commons::bogons::Bogons;
use bgpkit_commons::countries::Countries;

let bogons = Bogons::new().unwrap();
let countries = Countries::new().unwrap();

Parquet export

The export feature enables source-faithful Parquet export of all loaded data. Each upstream source is written as its own file with full source fields preserved.

[dependencies]
bgpkit-commons = { version = "0.13", features = ["export"] }

use bgpkit_commons::BgpkitCommons;
use bgpkit_commons::export;

let mut commons = BgpkitCommons::new();
commons.load_countries().unwrap();

export::countries("./output", &commons).unwrap();
// writes ./output/countries.parquet

CLI tool

The export-cli feature adds the bgpkit-export binary:

cargo install bgpkit-commons --features export-cli

bgpkit-export --output-dir ./commons-export
bgpkit-export --output-dir ./output --with-peeringdb --with-irr --with-rpki
bgpkit-export --output-dir ./output --with-asninfo-jsonl

Output layout (one file per source):

commons-export/
  manifest.json
  asn_names.parquet
  countries.parquet
  iana_bogons.parquet
  mrt_collectors.parquet
  as_relationships.parquet
  rir_delegated.parquet
  peeringdb/          # 12 endpoint tables (--with-peeringdb)
  irr/records.parquet  # RPSL records (--with-irr)
  rpki/               # ROAs + ASPAs (--with-rpki)
  asninfo.jsonl        # legacy merged output (--with-asninfo-jsonl)

Feature flags

Feature	Description
`asinfo`	AS information with multi-source enrichment
`as2rel`	AS relationship inference data
`bogons`	Bogon prefix and ASN detection
`countries`	Country information lookup
`delegated`	RIR delegated-statistics parser
`irr`	IRR RPSL record parsing (aut-num, route, as-set)
`mrt_collectors`	MRT collector metadata
`peeringdb`	PeeringDB API data (all 12 endpoints)
`rpki`	RPKI validation (ROA and ASPA)
`all` (default)	Enables all data modules above
`export`	Parquet export of all loaded sources (adds `arrow` + `parquet`)
`export-cli`	Adds the `bgpkit-export` binary (adds `clap` + `tracing-subscriber`)

Minimal build:

[dependencies]
bgpkit-commons = { version = "0.13", default-features = false, features = ["bogons", "countries"] }

AsInfo loading profiles

Profile	Sources	Use case
`Minimum`	RIPE `asn.txt` only	Fast name/country lookup
`Default`	+ as2org, population, hegemony, PeeringDB	Production enrichment
`Full`	+ delegated stats, IRR (all sources, with route prefixes)	Complete dataset

use bgpkit_commons::asinfo::AsInfoProfile;
// or build custom:
use bgpkit_commons::asinfo::AsInfoBuilder;

let builder = AsInfoBuilder::new()
    .with_as2org()
    .with_delegated()
    .with_irr();

License

MIT

bgpkit-commons 0.13.0