← Cloudflare Radar / radar / investigate

BGP anomálie

Chcete-li získat přístup k výsledkům Cloudflare Radar BGP Anomaly Detection, musíte nejprve vytvořit API token, který obsahuje Account:Radar oprávnění. Všechny následující příklady by měly fungovat i s účtem Cloudflare na bezplatné úrovni.

Vyhledávání událostí BGP hijack

V následujícím příkladu se dotážeme na API pro události únosů BGP pro nejnovější únosy původu BGP, které způsobila nebo které postihly AS64512 (příklad ASN).

curl "https://api.cloudflare.com/client/v4/radar/bgp/hijacks/events?invlovedAsn=64512&format=json&per_page=10" \
--header "Authorization: Bearer <API_TOKEN>"

Výsledek zobrazuje 10 nejnovějších událostí BGP hijacku, které se týkají AS64512.

{
  "success": true,
  "errors": [],
  "result": {
    "asn_info": [
      {
        "asn": 64512,
        "org_name": "XXXXX",
        "country_code": "XX"
      },
      ...
    ],
    "events": [
      {
        "duration": 0,
        "event_type": 0,
        "hijack_msgs_count": 1,
        "hijacker_asn": 64512,
        "id": 1234,
        "is_stale": false,
        "max_hijack_ts": "2023-04-27T14:01:55.952",
        "max_msg_ts": "2023-04-27T14:01:55.952",
        "min_hijack_ts": "2023-04-27T14:01:55.952",
        "on_going_count": 1,
        "peer_asns": [
          8455
        ],
        "peer_ip_count": 1,
        "prefixes": [
          "192.0.2.0/24"
        ],
        "tags": [
          {
            "name": "irr_new_origin_invalid",
            "score": 4
          },
          {
            "name": "irr_old_origin_valid",
            "score": 0
          },
          ...
        ],
        "victim_asns": [
          64513
        ],
        "confidence_score": 4
      },
    ],
    "total_monitors": 163
  },
  ...
}

Z odpovědi zjistíme o každé události následující informace:

hijack_msg_count: počet potenciálních zpráv o únosu BGP zaznamenaných od všech partnerů.
peer_asns: čísla AS partnerů kolektorů tras, kteří zaznamenali zprávy o únosu.
prefixes: dotčené prefixy.
hijacker_asn a victim_asns: ASN potenciálního únosce a ASN obětí.
confidence_score: číselné skóre vyjadřující míru jistoty systému, že se jedná o únos:
- 1-3: nízká důvěryhodnost.
- 4-7: střední spolehlivost.
- 8 a více: vysoká spolehlivost.
tags: důkazy shromážděné k událostem. Každý tag je také spojena se skóre, které ovlivňuje celkové skóre důvěryhodnosti:
- kladné skóre znamená, že událost je pravděpodobnější za hijack.
- záporné skóre znamená, že událost je méně pravděpodobné za hijack.

Uživatelé mohou dále odfiltrovat události s nízkou spolehlivostí přidáním minConfidence=8 parametr, který vrátí pouze události s confidence_score z 8 nebo vyšší.

curl "https://api.cloudflare.com/client/v4/radar/bgp/hijacks/events?invlovedAsn=64512&format=json&per_page=10&minConfidence=8" \
--header "Authorization: Bearer <API_TOKEN>"

Vyhledávání událostí BGP route leak

BGP route leak je další typ BGP anomálie, kterou Cloudflare Radar detekuje. V současnosti se zaměřujeme konkrétně na provider-customer-provider typ úniku tras (route leak). Více o našem návrhu a metodice se dozvíte v náš blogový příspěvek ↗.

V následujícím příkladu se dotážeme na API událostí úniků BGP tras pro nejnovější únikové události tras BGP, které postihly AS64512.

curl "https://api.cloudflare.com/client/v4/radar/bgp/leaks/events?invlovedAsn=64512&format=json&per_page=10" \
--header "Authorization: Bearer <API_TOKEN>"

Výsledek zobrazuje 10 nejnovějších událostí BGP route leaku, které se týkají AS64512.

{
  "success": true,
  "errors": [],
  "result": {
    "asn_info": [
      {
        "asn": 64512,
        "org_name": "XXXXXXX",
        "country_code": "XX"
      },
      ...
    ],
    "events": [
      {
        "detected_ts": "2023-04-21T23:10:06",
        "finished": false,
        "id": 1234,
        "leak_asn": 64512,
        "leak_count": 14,
        "leak_seg": [
          64514,
          64512,
          64513
        ],
        "leak_type": 1,
        "max_ts": "2023-04-21T23:10:56",
        "min_ts": "2023-04-21T23:09:46",
        "origin_count": 1,
        "peer_count": 13,
        "prefix_count": 1
      },
      ...
    ]
  },
  ...
}

Z odpovědi zjistíme o každé události následující informace:

leak_asn: AS, který únik pravděpodobně způsobil.
leak_seg: segment cesty AS, který byl zaznamenán a je považován za únik.
min_ts a max_ts: nejstarší a nejnovější časové značky oznámení o úniku.
leak_count: celkový počet zaznamenaných oznámení o úniku trasy BGP.
peer_count: počet partnerů kolektorů tras, kteří únik zaznamenali.
prefix_count a origin_count: počet prefixů a původních AS dotčených únikem.

Zasílání upozornění na události typu BGP hijack

V tomto příkladu vám ukážeme, jak vytvořit aplikaci Cloudflare Workers, která pomocí webhooků (funguje pro Google Hangouts, Discord, Telegram atd.) nebo e-mailu odesílá upozornění na únosy BGP tras týkající se daného ASN.

Jako platformu použijeme Cloudflare Workers a jejich Cron Triggers k pravidelné kontrole nových upozornění.

Od aplikace chceme, aby dělala následující:

Načíst data z Cloudflare API pomocí zadaného API tokenu.
Kontrola oproti Cloudflare KV zjistí, které události jsou nové.
Vytvářejte zprávy o novém route hijackingu a odesílejte upozornění pomocí webhook triggerů.

Nastavení aplikace Worker

Začneme nastavením aplikace Cloudflare Worker.

Nejprve vytvořte novou aplikaci Workers v lokálním adresáři:

npm create cloudflare@latest -- hijack-alerts

Při nastavení vyberte následující možnosti:

Pro S čím byste chtěli začít?, vyberte Hello World example.
Pro Jakou šablonu chcete použít?, vyberte Worker only.
Pro Jaký jazyk chcete použít?, vyberte JavaScript.
Pro Chcete používat git pro správu verzí?, vyberte Yes.
Pro Chcete nasadit svou aplikaci?, vyberte No (před nasazením provedeme ještě několik změn).

Chcete-li začít vyvíjet svůj Worker, cd do adresáře nového projektu:

cd hijack-alerts

Ve svém souboru Wrangler změňte výchozí frekvenci kontroly (jednou za hodinu) podle potřeby. Zde je příklad, jak nastavit workery tak, aby skript spouštěly každých pět minut.

{
	"$schema": "./node_modules/wrangler/config-schema.json",
	"name": "hijack-alerts",
	"main": "src/index.js",
	// Set this to today's date
	"compatibility_date": "2026-08-28",
	"triggers": {
		"crons": [
			"*/5 * * * *"
		]
	}
}

"$schema" = "./node_modules/wrangler/config-schema.json"
name = "hijack-alerts"
main = "src/index.js"
# Set this to today's date
compatibility_date = "2026-08-28"

[triggers]
crons = [ "*/5 * * * *" ]

V tomto příkladu budeme také potřebovat Cloudflare KV k uložení ID naposledy zkontrolovaných událostí, což nám umožní zjistit, které události jsou nové. Jakmile vytvoříte KV, můžete se vrátit zpět na wrangler.jsonc soubor a přidejte následující sekce:

{
	"kv_namespaces": [
		{
			"binding": "HIJACKS_KV",
			"id": "KV_ID_FOR_PRODUCTION",
			"preview_id": "TEMPORARY_KV_FOR_DEV_ENVIRONMENT"
		}
	]
}

[[kv_namespaces]]
binding = "HIJACKS_KV"
id = "KV_ID_FOR_PRODUCTION"
preview_id = "TEMPORARY_KV_FOR_DEV_ENVIRONMENT"

Načíst nově zjištěné únosy BGP

Začněte funkcí, která načítá data z API.

Následující apiFetch(env, paramsStr) se stará o zpracování řetězce parametrů požadavku, sestavení příslušných hlaviček a načtení dat z koncového bodu API Cloudflare pro únosy BGP.

async function apiFetch(env, paramsStr) {
	const config = {
		headers: {
			Authorization: `Bearer ${env.CF_API_TOKEN}`,
		},
	};
	const res = await fetch(
		`https://api.cloudflare.com/client/v4/radar/bgp/hijacks/events?${paramsStr}`,
		config,
	);

	if (!res.ok) {
		console.log(JSON.stringify(res));
		return null;
	}
	return await res.json();
}

env parametr předává volající, takže se nemusíme starat o jeho sestavení. paramsStr je řetězcová proměnná, která obsahuje parametry dotazu v URL adrese dotazu.

Nyní v naší hlavní funkci cron triggeru musíme sestavit parametry dotazu a zavolat funkci pro načtení dat z API. Výchozí skript workeru pro cron trigger je definován takto:


export default {
    async scheduled(controller, env, ctx) {
    ...
    }
}

V našem příkladu používáme env proměnné pro získání běhových proměnných, jako je TOKEN a příslušné ASN, a Cloudflare KV bindings. Nepoužíváme controller a ctx proměnné v tomto příkladu.

Nejprve si musíme ujasnit, co jsou nové události. Novými událostmi rozumíme události, které aplikace ještě nezpracovala. Použijeme Cloudflare KV bucket, který jsme dříve vytvořili a definovali (HIJACKS_KV) k uložení a načtení ID posledně zpracované události.

let kv_latest_id = parseInt(await env.HIJACKS_KV.get("latest_id"));
const first_batch = isNaN(kv_latest_id);

Hlavní smyčka, která kontroluje nejnovější události, vypadá takto (část validačního kódu je vynechána):

let new_events = [];
let page = 1;
while (true) {
	// query for events
	const query_params = `per_page=10&page=${page}&involvedAsn=${env.TARGET_ASN}&sortBy=ID&sortOrder=DESC`;
	const data = await apiFetch(env, query_params);

	// first batch, save KV value only
	if (first_batch) {
		await env.HIJACKS_KV.put("latest_id", events[0].id.toString());
		return;
	}

	// some validation skipped
	// ...

	let reached_last = false;
	for (const event of data.result.events) {
		if (event.id <= kv_latest_id) {
			// reached the latest events
			reached_last = true;
			break;
		}
		new_events.push(event);
	}
	if (reached_last) {
		break;
	}
	page += 1;
}

Nyní, když máme všechny nově zjištěné události uložené v new_events proměnnou pak můžeme odesílat upozornění:

// sort events by increasing ID order
new_events.sort((a, b) => a.id - b.id);
const kv_latest_id = new_events[new_events.length - 1].id;
// push new events
for (const event of new_events) {
	await send_alert(env, event);
}
// update latest_id KV value
await env.HIJACKS_KV.put("latest_id", kv_latest_id.toString());

Zasílání upozornění pomocí webhooku

Funkce send_alert se stará o sestavení upozornění a jeho odeslání pomocí webhooku. Níže je uveden příklad šablony prostého textového upozornění pomocí webhooku Google Hangouts. Uživatelé si mohou zprávu i způsob použití webhooku přizpůsobit podle zvolené platformy a svých potřeb.

async function send_hangout_alert(env, event) {
	const webhook_url = `${env.WEBHOOK_URL}&threadKey=bgp-hijacks-event-${event.id}`;

	const data = JSON.stringify({
		text: `Detected BGP hijack event (${event.id}):
Detected time: *${event.min_hijack_ts} UTC*
Detected ASN: *${event.hijacker_asn}*
Expected ASN(s): *${event.victim_asns.join(" ")}*
Prefixes: *${event.prefixes.join(" ")}*
Tags: *${event.tags.map((tag) => tag.name).join(" ")}*
Peer Count: *${event.peer_ip_count}*
`,
	});
	await fetch(webhook_url, {
		method: "POST",
		headers: {
			"Content-Type": "application/json; charset=UTF-8",
		},
		body: data,
	});
}

Upozorňujeme, že webhook je považován za tajný údaj a měl by být do prostředí nastaven pomocí wrangler secret put WEBHOOK_URL příkazu.

Posledním krokem je nasazení aplikace příkazem npx wrangler deploy a aplikace by měla být na vašem účtu Cloudflare spuštěná a funkční a bude se automaticky spouštět každých pět minut.

Zasílání e-mailových upozornění z Workers

Pokud máte Email Routing povoleno pro vaši doménu, můžete e-mailová upozornění odesílat přímo z Workers. Více informací najdete v Odesílání e-mailů z Workers a zjistěte více.

Aby toto upozornění fungovalo, musíte nakonfigurovat příslušné e-mailové vazby v Konfigurační soubor Wrangler.

{
	"send_email": [
		{
			"type": "send_email",
			"name": "SEND_EMAIL_BINDING",
			"destination_address": "<YOUR_EMAIL>@example.com"
		}
	]
}

[[send_email]]
type = "send_email"
name = "SEND_EMAIL_BINDING"
destination_address = "<YOUR_EMAIL>@example.com"

Poté můžete vytvořit funkci pro odesílání e-mailů, která bude posílat upozornění na vámi nastavenou cílovou adresu:

async function send_email_alert(hijacker, prefixes, victims) {
	const msg = createMimeMessage();
	msg.setSender({
		name: "BGP Hijack Alerter",
		addr: "<YOUR_APP>@<YOUR_APP_DOMAIN>",
	});
	msg.setRecipient("<YOUR_EMAIL>@example.com");
	msg.setSubject("BGP hijack alert");
	msg.addMessage({
		contentType: "text/plain",
		data: `BGP hijack detected:
    Detected origin: ${hijacker}
    Expected origins: ${victims.join(" ")}
    Prefixes: ${prefixes.join(" ")}
    `,
	});

	var message = new EmailMessage(
		"<YOUR_APP>@<YOUR_APP_DOMAIN>",
		"<YOUR_EMAIL>@example.com",
		msg.asRaw(),
	);
	try {
		await env.SEND_EMAIL_BINDING.send(message);
	} catch (e) {
		return new Response(e.message);
	}
}

Další kroky

Více informací najdete v dokumentaci k našemu API pro Úniky BGP tras a Únosy BGP pro další informace k těmto tématům.