แแก แแแแ แกแแแแแแ แแแคแฃแญแแแฃแแแ, แแแชแ. แแแแแแแแแ, แแ แแก แแแแ
แแแแก แแแแ, แ แแ แกแแกแแแแ แแแแแแ แแ RKN แแแแแแแก แงแแแแแคแแ แก แแแ แฏแแแแ แแ แแแ แชแฎแแแ, แฎแแแ แแ แแแแแแแ แแแ แชแแแแแแแ แแ แแแฎแแแแแ Revizorro-แก แแแแ แแแชแแแฃแแ แฏแแ แแแแแแก แฅแแแจ, แแแแแแแแแกแแแ แแแแแแจแแ แแแฃแแ แแแ แแแ แกแแแแแแ แแแแแ. แแ "แแแแแแแแ แแ" แแแแแแแแ แกแแแขแแแก แจแแ แแก แแ แแก แแแแ แ แกแแกแแ แแแแแ (แแแแแ แฏแแแ, rutracker)
แแ แแชแฎแแแ แแ RKN-แแก แแฃแ แแกแแแฅแชแแแก แแแ แแ, แแแแ แแ แฉแแแ แแจแแแแแแ, แแแแแกแแแแแ แแ แแแแแแ แแแ แกแแฎแแจแ แแแ แฉแแแ. แแกแ แ แแ, แแแแแฌแงแแ, แแแแแแแแแ แแแ แขแแแ แแแ IT-แแกแแแ แจแแ แก แแงแแคแ แแแแแแแแแแแกแแแแก, แ แแแ แแแแ แแแก แแแแแ แแแแแแแแ, แกแแกแฃแ แแแแแ แกแแแ แแแ แแแแ แแแแแฌแแแแแแแก แแแ แแจแ.
แแ แฉแแแแฌแแ แจแ แแ แแ แแฆแแฌแแ แฅแกแแแแก แซแแ แแแแ แแแแแแแก แแขแแแแแ แแแแ, แแแแ แแ แแฆแแฌแแ แแแแแ แแ แแแชแแแแแก, แแฃ แ แแแแ แจแแแซแแแแ แแ แกแฅแแแแก แแแแฎแแ แชแแแแแแ. แแกแ แ แแ, แชแแแแ แแแแก แจแแกแแฎแแ, แแฃ แ แแแแ แแฃแจแแแแก แฅแกแแแ แแแแแแแ แแ แแแแแ แแขแฃแแแ Linux-แจแ, แแฃแชแแแแแแแแ.
แกแแแแขแแแแก แกแแฎแแแแ
แแแ แแแ แ แแแจแ, แแแแแ แแแแแแแฎแแแ แแแฎแกแแแ แแแ แแแแก แจแแกแแฎแแ, แ แแช แแแแแแแแแแ.
RKN-แแแ แฉแแแแขแแแ แแฃแ XML-แจแ แแ แกแแแแแก แ แแแแแแแแ แขแแแแก แกแแแแขแ:
- IP
- แแแแแแแก
- URL
แกแแแแ แขแแแแกแแแแก, แฉแแแ แแแ แแ แแแแ แแแแชแแ แแแ: IP-แก แแ แแแแแแก, แแ แฃแแ แแแแ แแแแแแแงแแแแ แแแแแแก URL-แแ แแแแแแแแแกแแแ (แฃแคแ แ แแฃแกแขแแ, แแแ แแก แฃแแแ แแแแแแแแก แฉแแแแแแแก).
แแแ แแ แฎแแแฎแแแแ
- IP:
https://api.reserve-rbl.ru/api/v2/ips/json - แแแแแแแแ:
https://api.reserve-rbl.ru/api/v2/domains/json
แฌแแแแแ แแแแแแแแ แกแแแขแแแแ
แแแแกแแแแแก แฉแแแ แแแญแแ แแแแ แ แแแแแแแแ แแแขแแ แ แฃแชแฎแแฃแ แ VPS, แกแแกแฃแ แแแแแ แจแแฃแแฆแฃแแแแ แขแ แแคแแแแ - แแกแแแ แแแแ แแ 3-5 แแแแแ แแ. แแฅแแแ แฃแแแ แฌแแแฆแแ แแแ แแฎแแ แกแแแฆแแแ แแแ แแ แแกแ, แ แแ แแแแแ แแ แแงแแก แซแแแแแ แแแแ, แแแแ แแ แแแแแ แแ แแฎแแ แแแแแแแแแกแฌแแแแ, แ แแ แแแขแแ แแแขแ แแ แแแแแ แแคแแ แงแแแแแแแแก แแ แแแแฎแแแแ แแ แแแแแแแก. แแ แ แแแแแ แแ แแ แกแแแแแก SLA 5 แแแแแ แแ, แฃแแฏแแแแกแแ แแแฆแแ 2+ แชแแแ แกแฎแแแแแกแฎแแ แแ แแแแแแแ แแแแกแแแ แจแแชแแแแแก แขแแแแ แแแขแแแแกแแแแก.
แจแแแแแแ, แฉแแแ แฃแแแ แแแแแงแแแแ แแแจแแคแ แฃแแ แแแแ แแแ แแแแแแขแแก แ แแฃแขแแ แแแแ VPS-แแแ. แแ แแแงแแแแ Wireguard-แก, แ แแแแ แช แงแแแแแแ แกแฌแ แแคแแ แแ แแแ แขแแแแ แแแกแแงแแแแแแแ. แแกแแแ แแแฅแแก แแแแแแขแแก แ แแฃแขแแ แแแ Linux-แแ แแแคแฃแซแแแแฃแแ (
แแแขแแ แแกแแ แขแ แแคแแแแก แแแแแขแแคแแชแแ แแแ แแ แแแแแแแกแแแแ แแแแ
แแฅแแแ, แ แ แแฅแแ แฃแแแ, แจแแแแซแแแแ แแแแแ แแแ แแแแแ แแแขแแ แแแข แขแ แแคแแแ แฃแชแฎแ แฅแแแงแแแแจแ. แแแแ แแ, แกแแแแ แแฃแแแ, แแแแแแแแ แแ แแแแขแแแขแแแ แแฃแจแแแแแก แกแแฉแฅแแ แ แแแแแ แแแแแ แแแแแแ. แแแ แแ แแแแกแ, VPS-แแ แแแแขแแ แฃแแแ แแแแแแแก แแแแฎแแแแแแ แแแชแแแแแแ แแแฆแแแ แแฅแแแแ.
แแแแขแแ, แฉแแแ แแแแแญแแ แแแแ แ แแแแ แแ แแแแแแงแแ แขแ แแคแแแ แแแแแแแแ แกแแแขแแแแ แแ แจแแ แฉแแแแ แแแแแแ แแแ แแแแ แแแจแ. แแแจแแแแช แแ, แแฃ แแแแแแ แแ "แแแแแขแแแแแ" แขแ แแคแแแ แแฅ แแแฎแแแแแ, แแก แแแแแช แแแแ แแ แฃแแแแแกแแ, แแแแ แ แงแแแแแคแ แแก แแแขแแ แแแ แแแแ แแแจแ.
แขแ แแคแแแแก แกแแแแ แแแแแ, แฉแแแ แแแแแแแงแแแแแ BGP แแ แแขแแแแแก แแ แแแแแแแชแฎแแแแแ แแแ แจแ แฃแขแแแก แกแแญแแ แ แฅแกแแแแแแกแแแ แฉแแแแ VPS-แแแ แแแแแแขแแแแแแ. แแแแฆแแ BIRD, แ แแแแ แช แแ แ-แแ แแ แงแแแแแแ แคแฃแแฅแชแแแแแแฃแ แ แแ แแแกแแฎแแ แฎแแแแแ BGP แแแแแแ.
IP
IP-แแ แแแแแแแแแ, แงแแแแแคแแ แ แแแแแแแ: แฉแแแ แฃแแ แแแแ แแแชแฎแแแแแ แงแแแแ แแแแแแแแ IP-แก VPS-แแ. แแ แแแแแแ แแก แแ แแก, แ แแ แกแแแจแ แแ แแก แแแแฎแแแแแแ 600 แแแแกแ แฅแแแฅแกแแแ, แ แแแแแกแแช API แแแ แฃแแแแก แแ แแแแ แแแแ แฃแแ แแแแแกแแแ แแ แแก /32 แฐแแกแขแ. แแแ แจแ แฃแขแแแแก แแ แ แแแแแแแแแ แจแแแซแแแแ แแแแแแแแก แแแแแแขแแก แกแฃแกแขแ แแแ แจแ แฃแขแแแแขแแ แแแ.
แแแแขแแ, แกแแแก แแแแฃแจแแแแแแกแแก, แแแแแฌแงแแ แฅแกแแแแก / 24-แแแ แจแแฏแแแแแ, แแฃ แแแก แแฅแแก 2 แแ แแแขแ แฐแแกแขแ. แแแ แแแแ, แแแ แจแ แฃแขแแแแก แ แแแแแแแแ ~100 แแแแกแแแแ แจแแแชแแ แแ. แแแแก แกแชแแแแ แ แแแฐแงแแแแ.
Domains
แแก แฃแคแ แ แ แแฃแแแ แแ แ แแแแแแแแ แแแ แแ แกแแแแแก. แแแแแแแแแ, แแฅแแแ แจแแแแซแแแแ แแแแแแกแขแแแแ แแ แแแแญแแแ แแแแ Squid แแแแแแฃแ แแแแแแขแแก แ แแฃแขแแ แแ แแ แฉแแแขแแ แแ HTTP แฉแแ แแแ แแ แแแแแฎแแแแ TLS แฎแแแฉแแกแแญแแแก, แ แแแ แแแแฆแแ แแแแฎแแแแแแ URL แแแ แแแ แจแแแแฎแแแแแจแ แแ แแแแแแ SNI-แแแ แแแแ แแจแ.
แแแแ แแ แงแแแแ แกแแฎแแก แแฎแแแ TLS1.3 + eSNI-แแก แแแแ, HTTPS แแแแแแแ แกแฃแ แฃแคแ แ แแ แฃแคแ แ แแแแแแแแ แ แแแแฃแ แ แฎแแแแ แงแแแแแแฆแ. แแแแฎ, แแ แแแแแแขแแก แแฎแ แแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แ แฃแคแ แ แ แแฃแแ แฎแแแแ - แแฅแแแ แฃแแแ แแแแแแงแแแแ แแแแแแฃแ OpenWRT.
แแแแขแแ, แแ แแแแแแฌแงแแแขแ แแแแฆแ DNS แแแแฎแแแแแแแ แแแกแฃแฎแแแแก แแฆแแแแแแก แแแ. แแฅแแช, แแแแแกแแแแ แ DNS-over-TLS / HTTPS แแฌแงแแแก แแฅแแแแก แแแแแ แขแ แแแแก, แแแแ แแ แฉแแแ แจแแแแแซแแแ (แแแแแแแ) แแแแแแแแขแ แแแแ แแก แแแฌแแแ แแแแแแขแแ - แแ แแแแแ แแแ แแแ แแ แแแแแแแงแแแแ แแฅแแแแ แกแแแฃแแแ แ แกแแ แแแ แ DoT/DoH-แกแแแแก.
แ แแแแ แฉแแแญแ แแ DNS?
แแฅแแช แจแแแซแแแแ แแงแแก แ แแแแแแแแ แแแแแแแ.
- DNS แขแ แแคแแแแก แฉแแ แแแ PCAP แแ NFLOG-แแก แกแแจแฃแแแแแแ
แฉแแ แแแแก แแ แแแ แแแแแแ แแแแแ แแแแแ แแแแฃแแแแฃแ แจแแกแแแแแข . แแแแ แแ แแก แแแแ แฎแแแแ แแ แแ แแก แแฎแแ แแแญแแ แแแ แแ แคแฃแแฅแชแแแแแ แแแ แซแแแแแ แแ แแแแขแแฃแแแ, แแกแ แ แแ แแฅแแแ แฏแแ แแแแแ แแญแแ แแแแแ แแแแกแแแแก แแฆแแแแแฃแแแแ. - DNS แกแแ แแแ แแก แแฃแ แแแแแแแก แแแแแแแ
แกแแแฌแฃแฎแแ แแ, แฉแแแแแแก แชแแแแแ แ แแแฃแ แกแแ แแแก แแ แจแแฃแซแแแแ แแแกแฃแฎแแแแก แแฆแ แแชแฎแแ, แแ แแแแ แแฎแแแแ แแแแฎแแแแแแแก แแฆแ แแชแฎแแ. แแ แแแชแแแจแ, แแก แแแแแแฃแ แแ, แแแแแแแแ, แแแแฎแแแแแแแกแแแ แแแแกแฎแแแแแแแ, แแแกแฃแฎแแแก แแฅแแ แ แแฃแแ แกแขแ แฃแฅแขแฃแ แ แแ แ แแฃแแแ แแแแ แขแแฅแกแขแแก แกแแฎแแ แแแฌแแ แ. DNSTap
แกแแแแแแแแ แแ, แแแแ แ แแแแแแแ แฃแแแ แแฎแแ แก แฃแญแแ แก DNSTap แแ แแแแแแ.
แ แ แแ แแก DNSTap?
แแก แแ แแก แแแแแแข-แกแแ แแแ แแก แแ แแขแแแแแ, แ แแแแแแช แแแคแฃแซแแแแฃแแแ แแ แแขแแแแแแก แแฃแคแแ แแแกแ แแ แคแ แแแ แกแขแ แแแแแแ, DNS แกแแ แแแ แแแแ แกแขแ แฃแฅแขแฃแ แแ แแแฃแแ DNS แแแแฎแแแแแแแกแ แแ แแแกแฃแฎแแแแก แจแแแแ แแแแแแแแ แแแแแกแแขแแแแ. แแ แกแแแแแแ, DNS แกแแ แแแ แ แแแแแกแชแแแก แแแแฎแแแแแกแ แแ แแแกแฃแฎแแแแก แแแขแแแแแแชแแแแแก (แจแแขแงแแแแแแแแแแก แขแแแ, แแแแแแขแ/แกแแ แแแ แแก IP แแ แ.แจ.) แแ แแกแแแ แกแ แฃแ DNS แจแแขแงแแแแแแแแแก (แแ แแแแแ) แคแแ แแแ, แ แแแแแจแแช แแก แแฃแจแแแแก แแแแแแ แฅแกแแแจแ.
แแแแจแแแแแแแแแแ แแแแกแแแแแก, แ แแ DNSTap แแแ แแแแแแแจแ, DNS แกแแ แแแ แ แแแฅแแแแแแก แ แแแแ แช แแแแแแขแ, แฎแแแ แแแแแฅแชแแแแแ แ แแแฅแแแแแแก แ แแแแ แช แกแแ แแแ แ. แแแฃ DNS แกแแ แแแ แ แฃแแ แแแแแ แแแแแฅแขแแ แก แแ แแ แ แแแ แแฅแแ.
แแฆแแก DNSTap แแฎแแ แแแญแแ แแแแ แงแแแแ แแแแฃแแแ แฃแ DNS แกแแ แแแ แแ. แแแแ แแ, แแแแแแแแแ, BIND แแแแ แแแกแขแ แแแฃแชแแแจแ (แ แแแแ แแชแแ Ubuntu LTS) แฎแจแแ แแ แแแแแฃแแแ แ แแแแ แแแแแแแ แแแกแ แแฎแแ แแแญแแ แแก แแแ แแจแ. แแกแ แ แแ, แแฃ แจแแแแฌแฃแฎแแแ แฎแแแแฎแแ แแฌแงแแแแก, แแแแ แแ แแแแฆแแ แฃแคแ แ แแกแฃแแฃแฅแ แแ แกแฌแ แแคแ แ แแแฃแ แกแแ แ - Unbound.
แ แแแแ แแแแแญแแ แแ DNSTap?
แแ แกแแแแแก
แแฃแจแแแแแก แแแแแ แแแแ:
- แแแจแแแแแกแแก แแก แแขแแแ แแแแ แแแแแแแแแก แกแแแก แขแแฅแกแขแฃแ แ แคแแแแแแแ, แแแ แฃแแแแก แแแ (habr.com -> com.habr), แแแแแ แแชแฎแแแก แแแขแแฎแแ แฎแแแแแก, แแฃแแแแแแขแแแก แแ แฅแแแแแแแแแแก (แแแ., แแฃ โโแกแแ แจแแแชแแแก habr.com แแ www.habr.com, แแก แฉแแแขแแแ แแแแ แแฎแแแแ แแแ แแแแ) แแ แแจแแแแแก แแ แแคแแฅแกแแก แฎแแก แแ แกแแแก แกแฌแ แแคแ แซแแแแแกแแแแก
- แแแฅแแแแแแก แ แแแแ แช DNSTap แกแแ แแแ แ, แแก แแแแแแแ แแแแจแแ แก DNS แกแแ แแแ แแแแ. แแ แแแชแแแจแ, แแก แแฎแแ แก แฃแญแแ แก แ แแแแ แช UNIX, แแกแแแ TCP แกแแแแขแแแก, แแแแ แแ DNS แกแแ แแแ แแแก, แ แแแแแแกแแช แแแชแ, แจแแฃแซแแแแ แแฎแแแแ UNIX แกแแแแขแแแแก แแแแแงแแแแแ.
- แจแแแแแแแแแ DNSTap แแแแแขแแแ แฏแแ แแแกแแ แแแแแแแแแ Protobuf แกแขแ แฃแฅแขแฃแ แแจแ, แจแแแแแ แแ แแแแแ แแแแแ แฃแแ DNS แจแแขแงแแแแแแแ, แ แแแแแแช แแแแแแ แแแแก Protobuf-แแก แแ แ-แแ แ แแแแจแ, แแแแแแแแแแ DNS RR แฉแแแแฌแแ แแแแก แแแแแแ.
- แแแฌแแแแแ แแ แแก แแฃ แแ แ แแแแฎแแแแแแ แฐแแกแขแ (แแ แแแกแ แแแแแแ แ แแแแแแ) แฉแแขแแแ แแฃแ แกแแแจแ, แแฃ แแ แ, แแแกแฃแฎแ แแแแแ แแ แแแฃแแแ.
- แแแกแฃแฎแแแแ แแ แฉแแฃแแแ แแฎแแแแ A/AAAA/CNAME RR แแ แแแแแแ แแแแฆแแแฃแแแ แจแแกแแแแแแกแ IPv4/IPv6 แแแกแแแแ แแแแ
- IP แแแกแแแแ แแแแ แฅแแจแแ แแแฃแแแ แแแแคแแแฃแ แแ แแแแแ TTL-แแ แแ แ แแแแแแแ แแแฃแแแ แงแแแแ แแแแคแแแฃแ แแ แแแฃแแ BGP แแแแแขแแแแกแแแแก
- แแแกแฃแฎแแก แแแฆแแแแกแแก, แ แแแแแแช แแแฃแแแแแแก แฃแแแ แฅแแจแแแฃแ IP-แแ, แแแกแ TTL แแแแแฎแแแแแ
- TTL แแแแแก แแแแฌแฃแ แแแก แจแแแแแ, แฉแแแแฌแแ แ แแแแฆแแแฃแแแ แฅแแจแแแแ แแ BGP แแแแชแฎแแแแแแแแแแ
แแแแแขแแแแแ แคแฃแแฅแชแแแแแ แแแ:
- แแแแแแแแแก แกแแแก แฎแแแแฎแแ แฌแแแแแฎแแ SIGHUP-แแก แแแแ
- แฅแแจแแก แจแแแแ แฉแฃแแแแ แกแฎแแ แแแกแขแแแชแแแแแแ แกแแแฅแ แแแจแ dnstap-bgp HTTP/JSON-แแก แกแแจแฃแแแแแแ
- แแแแแแแแ แแ แฅแแจแ แแแกแแแ (BoltDB แแแแแชแแแแ แแแแแจแ), แ แแแ แแฆแแแแแแแ แแแกแ แจแแแแแ แกแ แแแแแขแแแ แแแแก แจแแแแแ
- แกแฎแแ แฅแกแแแแก แกแแฎแแแแ แกแแแ แชแแจแ แแแแแ แแแแก แแฎแแ แแแญแแ แ (แ แแขแแ แแ แแก แแก แกแแญแแ แ แฅแแแแแ แแฅแแแแ แแฆแฌแแ แแแ)
- IPv6 แแฎแแ แแแญแแ แ
แจแแแฆแฃแแแแแ:
- IDN แแแแแแแแ แฏแแ แแ แแ แแก แแฎแแ แแแญแแ แแแ
- แ แแแแแแแแ BGP แแแ แแแแขแ แ
แจแแแแแ แแแ
แกแฅแแแ
แแกแ แ แแ, แแแแแฌแงแแ แงแแแแ แแแแแแแแแขแแก แแ แแแ แจแแแ แแแ. แจแแแแแแ, แฉแแแ แฃแแแ แแแแแฆแแ แแกแแแแกแ แฅแกแแแแก แขแแแแแแแแ:
แแฃแจแแแแแก แแแแแแ, แแคแแฅแ แแ, แแแแแแแ แแแแแ แแแแแแ:
- แแแแแแขแก แแฅแแก แฉแแแแ แกแแ แแแ แ แแแแคแแแฃแ แแ แแแฃแแ แ แแแแ แช DNS แแ DNS แแแแฎแแแแแแ แแกแแแ แฃแแแ แแแแแแแแแก VPN-แแ. แแก แแฃแชแแแแแแแแ แแแแกแแแแแก, แ แแ แแ แแแแแแแ แแ แแแ แแแแแแงแแแแก DNS แฉแแ แแแ แแแแแแแแแกแแแแก.
- แกแแแขแแก แแแฎแกแแแกแแก แแแแแแขแ แแแแแแแแก DNS แจแแแแแฎแแแก, แ แแแแ แแชแแ โแ แ แแ แแก xxx.org-แแก IP-แแแโ
- unbound แแแแแ แแแก xxx.org-แก (แแ แแฆแแแก แแแก แฅแแจแแแแ) แแ แฃแแแแแแแก แแแกแฃแฎแก แแแแแแขแก: โxxx.org-แก แแฅแแก แแกแแแ แแ แแกแแแ IPโ, แแฃแแแแ แแแก แแแก แแแ แแแแแฃแ แแ DNSTap-แแก แกแแจแฃแแแแแแ.
- dnstap-bgp แแชแฎแแแแแก แแ แแแกแแแแ แแแแก แฅ BIRD BGP-แแก แกแแจแฃแแแแแแ, แแฃ แแแแแแ แแแแแแแแ แกแแแจแแ
- BIRD แ แแแแแแแ แแแก แแแ แจแ แฃแขแก แแ IP-แแแแกแแแ
next-hop self
แแแแแแขแแก แ แแฃแขแแ แ - แจแแแแแแ แแแแแขแแแ แแแแแแขแแแแ แแ IP-แแแแแแ แแแแแก แแแแ แแแจแ
แกแแ แแแ แแ, แแแแแแแแ แกแแแขแแแแ แแแ แจแ แฃแขแแแแกแแแแก, แแแงแแแแ แชแแแแ แชแฎแ แแแก BIRD-แแก แจแแแแแ แแ แแก แแ แแแแแ แแ แแ แแแแแก OS-แก.
แแ แกแฅแแแแก แแฅแแก แแแแแ: แแแแแแขแแกแแแ แแแ แแแ SYN แแแแแขแก, แกแแแแ แแฃแแแ, แแฅแแแแ แแ แ, แ แแ แแแขแแแแก แจแแแ แแ แแแแแแแ แแก แแแจแแแแแแ. แแแ แจแ แฃแขแ แแแฃแงแแแแแแแแ แแ แแ แแก แแแแแชแฎแแแแแฃแแ. แแ แแฅ แแแ แแแแขแแแ แจแแกแแซแแแแแแแ แแแแกแแ แแแฎแแแแแ, แแฃ แ แแแแ แแแแแแแก แแ แแแแแแแ แ แแแแแแแแแก. แแฃ แแก แฃแแ แแแแ แฉแแแแแแแแแก แแแซแ แแแแแก, แแแจแแ แแ แแแแแแ แแ แแ แแก. แแ แแฃ แแก แแแแแแแกแแแแ แแแแก แแแแแแ แ DPI-แแ, แแแจแแ (แแแแ แแฃแแแ) แจแแกแแซแแแแแแแ แกแแแชแแแแฃแ แ แแคแแฅแขแแแ.
แแกแแแ แจแแกแแซแแแแแแแ, แ แแ แแแแแแขแแแแ แแ แกแชแแ แแแขแแแก DNS TTL แกแแกแฌแแฃแแแแก, แ แแแแช แจแแแซแแแแ แแแแแแฌแแแแก แแแแแแขแแ แแแแแแงแแแแก แแแ แแแแฃแแ แจแแแแ แฉแแแแแ แฉแแแแฌแแ แแแ แแแกแ แแแแแแแ แฅแแจแแแแ, Unbound-แแก แแแแฎแแแแแก แแแชแแแแ.
แแ แแฅแขแแแแจแ แแ แช แแแ แแแแก แแ แแ แช แแแแ แแก แแ แจแแฃแฅแแแแ แแ แแแแแแ, แแแแ แแ แแฅแแแแ แแแ แแแแ แจแแแซแแแแ แแแแกแฎแแแแแแแแแแก.
แกแแ แแแ แแก แแแงแแแแแ
แแแแแฎแแแแแก แแแกแแแแแแแแแแแ แแแแฌแแ แ
แแแแแ แแแแแแ แแ แซแแ แแแแแ แแแแแแแแแขแแแ.
BGP
แแ แ BGP แแแแแแแก แแแจแแแแแก แแ แแกแ แแ แแแแแ แฐแแกแขแแ แแฅแแก แคแฃแแแแแแแขแฃแ แ แแ แแแแแแ: BIRD-แก แแ แกแฃแ แก BGP peering-แแก แแแงแแแแแ แแแแแแฐแแกแขแแแ (แแ แ แแแแแแแ แแแแแแฃแ แแแขแแ แคแแแกแแแ). แกแแขแงแแแแแ แกแแแ แแแ. แแฃแแแแแแแ แแ แแแแแแแแแก แกแแแแแก แแแแฎแแแ แแ แฃแจแแแแ, แแกแแแ แแแขแแแชแแแแ, แ แแ แแก แแ แแก แแแแแแแแ. แแแแแ แแ แแก แ แแฆแแช แแแ, แแแแ แแ แแแ แแแแแแ.
แจแแแแซแแแแ แกแชแแแแ แกแฎแแ BGP แแแแแแ, แแแแ แแ แแ แแแแฌแแแก BIRD แแ แแก แงแแแแแแ แแแแแแงแแแแแ แฉแแแก แแแแ , แแ แแแแแ แแแแแฅแขแแ แฌแแ แแแแแ.
แแแแขแแ, แแ แแแแแแแ dnstap-bgp แฅแกแแแแก แกแแฎแแแแ แกแแแ แชแแก แจแแแแแ, แ แแแแแแช แแแแแแจแแ แแแฃแแแ root-แแแ veth แแแขแแ แคแแแกแแก แกแแจแฃแแแแแแ: แแก แฐแแแแก แแแแก, แ แแแแแก แแแแแแแ แแแแแแแแแแแแ แกแฎแแแแแกแฎแแ แกแแฎแแแแแแก แกแแแ แชแแจแ. แแแแแแฃแ แแ แแแแแแ แฉแแแ แแแแแแ แแแ แแแ แซแ p2p IP แแแกแแแแ แแแแก, แ แแแแแแแช แแ แกแชแแแแแแแแ แฐแแกแขแก, แแกแ แ แแ, แแกแแแ แจแแแซแแแแ แแงแแก แแแแแกแแแแ แ. แแก แแ แแก แแแแแ แแแฅแแแแแแ, แ แแแแแแช แแแแแแงแแแแแ แจแแแแแ แแ แแชแแกแแแแ แฌแแแแแแกแแแแก แงแแแแแก แฃแงแแแ แก แแแแแ แ แแ แกแฎแแ แแแแขแแแแแ แแแ.
แแแแกแแแแก แแฌแแ แ
แกแแ แแแขแแก แแแแแแแแ แกแแฎแแแแ แกแแแ แชแแก แจแแกแแฅแแแแแแ
#!/bin/bash
NS="dtap"
IP="/sbin/ip"
IPNS="$IP netns exec $NS $IP"
IF_R="veth-$NS-r"
IF_NS="veth-$NS-ns"
IP_R="192.168.149.1"
IP_NS="192.168.149.2"
/bin/systemctl stop dnstap-bgp || true
$IP netns del $NS > /dev/null 2>&1
$IP netns add $NS
$IP link add $IF_R type veth peer name $IF_NS
$IP link set $IF_NS netns $NS
$IP addr add $IP_R remote $IP_NS dev $IF_R
$IP link set $IF_R up
$IPNS addr add $IP_NS remote $IP_R dev $IF_NS
$IPNS link set $IF_NS up
/bin/systemctl start dnstap-bgp
dnstap-bgp.conf
namespace = "dtap"
domains = "/var/cache/rkn_domains.txt"
ttl = "168h"
[dnstap]
listen = "/tmp/dnstap.sock"
perm = "0666"
[bgp]
as = 65000
routerid = "192.168.149.2"
peers = [
"192.168.149.1",
]
แฉแแขแ.แแแแค
router id 192.168.1.1;
table rkn;
# Clients
protocol bgp bgp_client1 {
table rkn;
local as 65000;
neighbor 192.168.1.2 as 65000;
direct;
bfd on;
next hop self;
graceful restart;
graceful restart time 60;
export all;
import none;
}
# DNSTap-BGP
protocol bgp bgp_dnstap {
table rkn;
local as 65000;
neighbor 192.168.149.2 as 65000;
direct;
passive on;
rr client;
import all;
export none;
}
# Static routes list
protocol static static_rkn {
table rkn;
include "rkn_routes.list";
import all;
export none;
}
rkn_routes.list
route 3.226.79.85/32 via "ens3";
route 18.236.189.0/24 via "ens3";
route 3.224.21.0/24 via "ens3";
...
DNS
แแแแฃแแแกแฎแแแแแ, Ubuntu-แจแ Unbound แแ แแแแแ แแ แแก แแแแแแ แแแฃแแ AppArmor แแ แแคแแแแ, แ แแแแแแช แแ แซแแแแแก แแแก แงแแแแ แกแแฎแแก DNSTap แกแแแแขแแแ แแแแแแจแแ แแแแก. แจแแแแซแแแแ แแ แฌแแจแแแแ แแก แแ แแคแแแ, แแ แแแแแ แแแ:
# cd /etc/apparmor.d/disable && ln -s ../usr.sbin.unbound .
# apparmor_parser -R /etc/apparmor.d/usr.sbin.unbound
แแก แแแแแ แฃแแแ แแแแแแขแแก แกแแแแแแจแ แฌแแแแก. แแแแแแฃแ แแ, แ แ แแฅแแ แฃแแแ, แแ แแคแแแแก แแแแแกแฌแแ แแแ แแ แกแแญแแ แ แฃแคแแแแแแแก แแแชแแแ, แแแแ แแ แซแแแแแ แแแ แแแชแ แแแงแแแ.
แจแแฃแแฆแฃแแแแ.conf
server:
chroot: ""
port: 53
interface: 0.0.0.0
root-hints: "/var/lib/unbound/named.root"
auto-trust-anchor-file: "/var/lib/unbound/root.key"
access-control: 192.168.0.0/16 allow
remote-control:
control-enable: yes
control-use-cert: no
dnstap:
dnstap-enable: yes
dnstap-socket-path: "/tmp/dnstap.sock"
dnstap-send-identity: no
dnstap-send-version: no
dnstap-log-client-response-messages: yes
แกแแแแแก แฉแแแแขแแแ แแแ แแ แแแแฃแจแแแแแ
แฉแแแแขแแแ แแแแก แกแแแก, แแฏแแแแแก แแ แแคแแฅแกแก pfx. In แแ แแแแแแขแ ะธ แแฃ_แจแแแฏแแแแ แจแแแแซแแแแ แฃแแฎแ แแ IP-แแแก แแ แฅแกแแแแแก, แ แแ แแแแแขแแแแ แแ แแ แจแแแฏแแแแ. แแญแแ แแแแแแ. แฉแแแ VPS-แแก แฅแแแฅแกแแแ แแงแ แแแแ แกแแแจแ ๐
แกแแกแแชแแแ แแก แแ แแก, แ แแ RosKomSvoboda API แแแแแแแก แแแแฎแแแแแแก แแแแฃแแแกแฎแแแแ Python แแแแฎแแแ แแแแแก แแแแแขแแ. แ แแแแ แช แฉแแแก, แกแแ แแแขแแ แแก แแแแแ. แแแแขแแ แแชแแแแ แแแแแแก.
แฏแแ แฏแแ แแแแ, แแก แแฃแจแแแแก แแฎแแแแ IPv4-แแ. IPv6-แแก แฌแแแ แแชแแ แแ, แแแแ แแ แแแกแ แแแแแกแฌแแ แแแ แแแแแแ แแฅแแแแ. แแฃ แแฅแแแ แแ แฃแแแ แแแแแแงแแแแ bird6 แแกแแแ.
rkn.py
#!/usr/bin/python3
import json, urllib.request, ipaddress as ipa
url = 'https://api.reserve-rbl.ru/api/v2/ips/json'
pfx = '24'
dont_summarize = {
# ipa.IPv4Network('1.1.1.0/24'),
}
dont_add = {
# ipa.IPv4Address('1.1.1.1'),
}
req = urllib.request.Request(
url,
data=None,
headers={
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.1916.47 Safari/537.36'
}
)
f = urllib.request.urlopen(req)
ips = json.loads(f.read().decode('utf-8'))
prefix32 = ipa.IPv4Address('255.255.255.255')
r = {}
for i in ips:
ip = ipa.ip_network(i)
if not isinstance(ip, ipa.IPv4Network):
continue
addr = ip.network_address
if addr in dont_add:
continue
m = ip.netmask
if m != prefix32:
r[m] = [addr, 1]
continue
sn = ipa.IPv4Network(str(addr) + '/' + pfx, strict=False)
if sn in dont_summarize:
tgt = addr
else:
tgt = sn
if not sn in r:
r[tgt] = [addr, 1]
else:
r[tgt][1] += 1
o = []
for n, v in r.items():
if v[1] == 1:
o.append(str(v[0]) + '/32')
else:
o.append(n)
for k in o:
print(k)
แแแแ แแแแแแ แแฆแแจแ แแ แแฎแแ แแแแ แแแแแ , แแฅแแแ แฆแแ แแแก แงแแแแ 4 แกแแแแจแ แแแกแ แแแงแแแแ. แแก, แฉแแแ แแแ แแ, แแ แแก แแแแแฎแแแแแก แแแ แแแแ, แ แแแแแกแแช RKN แแแแแฎแแแก แแ แแแแแแแ แแแแกแแแ. แแแ แแ แแแแกแ, แแแ แแฅแแ แกแฎแแ แกแฃแแแ แแแแแฃแแแแแแ แแแแแแ แแแ, แ แแแแแแช แจแแแซแแแแ แฃแคแ แ แกแฌแ แแคแแ แแแแแแแก.
แแแแแแแก แจแแแแแแก:
- แแฌแแ แแแแแก แแแ แแแ แกแแ แแแขแก แแ แแแแแแฎแแแแก แแแ แจแ แฃแขแแแแก แกแแแก (
rkn_routes.list
) แคแ แแแแแแแกแแแแก - แแแแแขแแแ แแแ BIRD
- แแแแแแฎแแแแก แแ แแกแฃแคแแแแแแก แแแแแแแแแก แกแแแก dnstap-bgp
- แแแแแขแแแ แแแ dnstap-bgp
rkn_update.sh
#!/bin/bash
ROUTES="/etc/bird/rkn_routes.list"
DOMAINS="/var/cache/rkn_domains.txt"
# Get & summarize routes
/opt/rkn.py | sed 's/(.*)/route 1 via "ens3";/' > $ROUTES.new
if [ $? -ne 0 ]; then
rm -f $ROUTES.new
echo "Unable to download RKN routes"
exit 1
fi
if [ -e $ROUTES ]; then
mv $ROUTES $ROUTES.old
fi
mv $ROUTES.new $ROUTES
/bin/systemctl try-reload-or-restart bird
# Get domains
curl -s https://api.reserve-rbl.ru/api/v2/domains/json -o - | jq -r '.[]' | sed 's/^*.//' | sort | uniq > $DOMAINS.new
if [ $? -ne 0 ]; then
rm -f $DOMAINS.new
echo "Unable to download RKN domains"
exit 1
fi
if [ -e $DOMAINS ]; then
mv $DOMAINS $DOMAINS.old
fi
mv $DOMAINS.new $DOMAINS
/bin/systemctl try-reload-or-restart dnstap-bgp
แแกแแแ แแแแฌแแ แ แแแแ แคแแฅแ แแก แแแ แแจแ, แแกแ แ แแ, แแฃ แฎแแแแแ แ แแแแแก, แ แแแแแก แแแฃแแฏแแแแกแแแแช แจแแกแแซแแแแแแแ - แฌแแแแ.
แแแแแแขแแก แแแงแแแแแ
แแฅ แแแแแงแแแ แแแแแแแแแแก Linux แ แแฃแขแแ แแแแกแแแแก, แแแแ แแ Mikrotik / Cisco-แก แจแแแแฎแแแแแจแ แแก แแแแแ แฃแคแ แ แแแแแแ แฃแแแ แแงแแก.
แแแ แแแแ, แฉแแแ แแแแแงแแแแ BIRD:
แฉแแขแ.แแแแค
router id 192.168.1.2;
table rkn;
protocol device {
scan time 10;
};
# Servers
protocol bgp bgp_server1 {
table rkn;
local as 65000;
neighbor 192.168.1.1 as 65000;
direct;
bfd on;
next hop self;
graceful restart;
graceful restart time 60;
rr client;
export none;
import all;
}
protocol kernel {
table rkn;
kernel table 222;
scan time 10;
export all;
import none;
}
แแแ แแแแ, BGP-แแแ แแแฆแแแฃแ แแแ แจแ แฃแขแแแก แกแแแฅแ แแแแแแชแแแก แแแแแฎแแแแ แแแ แแแแก แแแ แจแ แฃแขแแแแชแแแก แชแฎแ แแแแแ แแแแ แแ 222.
แแแแก แจแแแแแ, แกแแแแแ แแกแแ แกแแฎแแแแ แแแ แแแก, แแแแแฎแแแแก แแ แคแแ แคแแขแแก, แกแแแแ แแแแฃแแแกแฎแแแแก แจแแฎแแแแแ:
# ip rule add from all pref 256 lookup 222
# ip rule
0: from all lookup local
256: from all lookup 222
32766: from all lookup main
32767: from all lookup default
แงแแแแแคแแ แ, แ แฉแแแ DHCP-แแก แแแแคแแแฃแ แแชแแ แ แแฃแขแแ แแ แกแแ แแแ แแก แแแแ แแแแก IP แแแกแแแแ แแแก DNS-แแ แแแแแฌแแแแแแกแแแแก แแ แกแฅแแแ แแแแ แแ แแก.
แจแแแฆแฃแแแแแ
แแแแแแแแแก แกแแแก แแแแแ แแ แแแแกแ แแ แแแแฃแจแแแแแแก แแแแแแแแแแแ แแแแแ แแแแแ, แแแ แแแแชแแแก, แกแฎแแ แกแแแแแฎแแแแแ แแ แแแ, youtube.com
แแ แแแกแ CDN-แแแ.
แแ แแก แแแแงแแแแ แ แแ แคแแฅแขแก, แ แแ แงแแแแ แแแแแ แแแแแแแก VPN-แแ, แ แแแแช แจแแแซแแแแ แแแแแแแแก แแแแแ แแ แฎแ. แแแแแ, แฆแแ แก แแแแฃแแแ แฃแแ แแแแแแแแแก แกแแแก แจแแแแแแ-แแแแแ แแชแฎแแแแ, แ แแแแแแแช แแแแแแแก RKN-แก แแ แแ แแแกแแแแก, แแแฌแแแแแแ แแฎแแแแ. แแ แแแแแขแแแแ แแกแแแ แแแ แฉแแแแกแแก.
แแแกแแแแ
แแฆแฌแแ แแแ แแแแแแ แกแแจแฃแแแแแแก แแแซแแแแ แแแแ แแแก แแแแแ แแแแฅแแแก แแแแแกแแแแ แ แแแแแแแแ, แ แแแแแกแแช แแแแแแแ แแฎแแ แชแแแแแแแ แแ แแแแแแแ แแแ.
แแ แแแชแแแจแ, dnstap-bgp แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แแแแแกแแแแ แ แกแฎแแ แแแแแแ, แกแแแแช แกแแญแแ แแ แขแ แแคแแแแก แแแแขแ แแแแก แแแ แแแแฃแแ แแแแ แแแแแแแก แกแแฎแแแแแแ แแแแแแแแแแ แ. แฃแแ แแแแ แแแแแแแแแกแฌแแแแ, แ แแ แฉแแแแก แแ แแจแ แแแแก แกแแแขแก แจแแฃแซแแแ แแแแแแแก แแ แแ แแ แแแแแ IP แแแกแแแแ แแ (แแแแแแแแแ, แแแแแแ แแ Cloudflare-แแก แฃแแแ), แแแแขแแ แแ แแแแแแก แกแแแแแแ แแแแแแ แกแแแฃแกแขแ แแฅแแก.
แแแแ แแ แกแแแแขแแแแก แแแแ แแแก แแแแแ, แแก แกแแแกแแแแ แกแแแแแ แแกแแ.
แแแแแขแแแแแ, แ แแแแฅแขแแ แแแแแ, แแแแฎแแแแแแ - แแแแแกแแแแแแแ!
แฌแงแแ แ: www.habr.com