Hola. Això vol dir que hi ha una xarxa de 5k clients. Recentment va sorgir un moment poc agradable: al centre de la xarxa tenim un Brocade RX8 i va començar a enviar molts paquets unicast desconeguts, ja que la xarxa està dividida en vlans; això parcialment no és un problema, PERÒ hi ha vlans especials per a adreces blanques, etc. i s'estenen en totes les direccions de la xarxa. Així que ara imagineu un flux entrant a l'adreça d'un client que no estudia com a estudiant fronterer i aquest flux vola cap a un enllaç de ràdio cap a algun (o tot) poble - el canal està obstruït - els clients estan enfadats - tristesa...
L'objectiu és convertir un error en una característica. Estava pensant en la direcció de q-in-q amb un client vlan complet, però tot tipus de maquinari com P3310, quan dot1q està habilitat, deixa de passar DHCP, tampoc saben com seleccionar qinq i molts inconvenients de aquest tipus. Què és IP-unnambered i com funciona? Molt breument: adreça de passarel·la + ruta a la interfície. Per a la nostra tasca, necessitem: tallar el modelador, distribuir adreces als clients, afegir rutes als clients a través de determinades interfícies. Com fer tot això? Shaper - lisg, dhcp - db2dhcp en dos servidors independents, dhcprelay s'executa als servidors d'accés, ucarp també s'executa als servidors d'accés - per a la còpia de seguretat. Però, com afegir rutes? Podeu afegir-ho tot per endavant amb un script gran, però això no és cert. Així que farem una crossa autoescrita.
Després d'una recerca exhaustiva a Internet, vaig trobar una meravellosa biblioteca d'alt nivell per a C++, que us permet ensumar molt bé el trànsit. L'algorisme per al programa que afegeix rutes és el següent: escoltem les sol·licituds d'arp a la interfície, si tenim una adreça a la interfície lo del servidor que se sol·licita, afegim una ruta a través d'aquesta interfície i afegim un arp estàtic. enregistreu a aquesta ip: en general, unes quantes còpies i enganxes, una mica d'adjectiu i ja està
Fonts del "encaminador"
#include <stdio.h>
#include <sys/types.h>
#include <ifaddrs.h>
#include <netinet/in.h>
#include <string.h>
#include <arpa/inet.h>
#include <tins/tins.h>
#include <map>
#include <iostream>
#include <functional>
#include <sstream>
using std::cout;
using std::endl;
using std::map;
using std::bind;
using std::string;
using std::stringstream;
using namespace Tins;
class arp_monitor {
public:
void run(Sniffer &sniffer);
void reroute();
void makegws();
string iface;
map <string, string> gws;
private:
bool callback(const PDU &pdu);
map <string, string> route_map;
map <string, string> mac_map;
map <IPv4Address, HWAddress<6>> addresses;
};
void arp_monitor::makegws() {
struct ifaddrs *ifAddrStruct = NULL;
struct ifaddrs *ifa = NULL;
void *tmpAddrPtr = NULL;
gws.clear();
getifaddrs(&ifAddrStruct);
for (ifa = ifAddrStruct; ifa != NULL; ifa = ifa->ifa_next) {
if (!ifa->ifa_addr) {
continue;
}
string ifName = ifa->ifa_name;
if (ifName == "lo") {
char addressBuffer[INET_ADDRSTRLEN];
if (ifa->ifa_addr->sa_family == AF_INET) { // check it is IP4
// is a valid IP4 Address
tmpAddrPtr = &((struct sockaddr_in *) ifa->ifa_addr)->sin_addr;
inet_ntop(AF_INET, tmpAddrPtr, addressBuffer, INET_ADDRSTRLEN);
} else if (ifa->ifa_addr->sa_family == AF_INET6) { // check it is IP6
// is a valid IP6 Address
tmpAddrPtr = &((struct sockaddr_in6 *) ifa->ifa_addr)->sin6_addr;
inet_ntop(AF_INET6, tmpAddrPtr, addressBuffer, INET6_ADDRSTRLEN);
} else {
continue;
}
gws[addressBuffer] = addressBuffer;
cout << "GW " << addressBuffer << " is added" << endl;
}
}
if (ifAddrStruct != NULL) freeifaddrs(ifAddrStruct);
}
void arp_monitor::run(Sniffer &sniffer) {
cout << "RUNNED" << endl;
sniffer.sniff_loop(
bind(
&arp_monitor::callback,
this,
std::placeholders::_1
)
);
}
void arp_monitor::reroute() {
cout << "REROUTING" << endl;
map<string, string>::iterator it;
for ( it = route_map.begin(); it != route_map.end(); it++ ) {
if (this->gws.count(it->second) && !this->gws.count(it->second)) {
string cmd = "ip route replace ";
cmd += it->first;
cmd += " dev " + this->iface;
cmd += " src " + it->second;
cmd += " proto static";
cout << cmd << std::endl;
cout << "REROUTE " << it->first << " SRC " << it->second << endl;
system(cmd.c_str());
cmd = "arp -s ";
cmd += it->first;
cmd += " ";
cmd += mac_map[it->first];
cout << cmd << endl;
system(cmd.c_str());
}
}
for ( it = gws.begin(); it != gws.end(); it++ ) {
string cmd = "arping -U -s ";
cmd += it->first;
cmd += " -I ";
cmd += this->iface;
cmd += " -b -c 1 ";
cmd += it->first;
system(cmd.c_str());
}
cout << "REROUTED" << endl;
}
bool arp_monitor::callback(const PDU &pdu) {
// Retrieve the ARP layer
const ARP &arp = pdu.rfind_pdu<ARP>();
if (arp.opcode() == ARP::REQUEST) {
string target = arp.target_ip_addr().to_string();
string sender = arp.sender_ip_addr().to_string();
this->route_map[sender] = target;
this->mac_map[sender] = arp.sender_hw_addr().to_string();
cout << "save sender " << sender << ":" << this->mac_map[sender] << " want taregt " << target << endl;
if (this->gws.count(target) && !this->gws.count(sender)) {
string cmd = "ip route replace ";
cmd += sender;
cmd += " dev " + this->iface;
cmd += " src " + target;
cmd += " proto static";
// cout << cmd << std::endl;
/* cout << "ARP REQUEST FROM " << arp.sender_ip_addr()
<< " for address " << arp.target_ip_addr()
<< " sender hw address " << arp.sender_hw_addr() << std::endl
<< " run cmd: " << cmd << endl;*/
system(cmd.c_str());
cmd = "arp -s ";
cmd += arp.sender_ip_addr().to_string();
cmd += " ";
cmd += arp.sender_hw_addr().to_string();
cout << cmd << endl;
system(cmd.c_str());
}
}
return true;
}
arp_monitor monitor;
void reroute(int signum) {
monitor.makegws();
monitor.reroute();
}
int main(int argc, char *argv[]) {
string test;
cout << sizeof(string) << endl;
if (argc != 2) {
cout << "Usage: " << *argv << " <interface>" << endl;
return 1;
}
signal(SIGHUP, reroute);
monitor.iface = argv[1];
// Sniffer configuration
SnifferConfiguration config;
config.set_promisc_mode(true);
config.set_filter("arp");
monitor.makegws();
try {
// Sniff on the provided interface in promiscuous mode
Sniffer sniffer(argv[1], config);
// Only capture arp packets
monitor.run(sniffer);
}
catch (std::exception &ex) {
std::cerr << "Error: " << ex.what() << std::endl;
}
}script d'instal·lació de libtins
#!/bin/bash
git clone https://github.com/mfontanini/libtins.git
cd libtins
mkdir build
cd build
cmake ../
make
make install
ldconfig
Ordre per construir el binari
g++ main.cpp -o arp-rt -O3 -std=c++11 -lpthread -ltinsCom posar-lo en marxa?
start-stop-daemon --start --exec /opt/ipoe/arp-routes/arp-rt -b -m -p /opt/ipoe/arp-routes/daemons/eth0.800.pid -- eth0.800
Sí, reconstruirà les taules en funció del senyal HUP. Per què no vas fer servir netlink? Només és mandra i Linux és un script en un script, així que tot està bé. Bé, les rutes són rutes, què passa? A continuació, hem d'enviar les rutes que hi ha en aquest servidor a la frontera -aquí, a causa del mateix maquinari obsolet, vam agafar el camí de menys resistència- hem assignat aquesta tasca a BGP.
bgp confignom d'amfitrió ******
contrasenya ******
fitxer de registre /var/log/bgp.log
!
# El número AS, les adreces i les xarxes són ficticis
encaminador bgp 12345
bgp router-id 1.2.3.4
redistribuir connectat
redistribueix l'estàtica
veí 1.2.3.1 remote-com 12345
veí 1.2.3.1 next-hop-self
veí 1.2.3.1 mapa de ruta cap a
exportació del mapa de ruta veïna 1.2.3.1
!
permís d'exportació de la llista d'accés 1.2.3.0/24
!
permís d'exportació de mapes de ruta 10
exporta l'adreça IP de coincidència
!
exportació de mapa de ruta denegada 20
Continuem. Perquè el servidor respongui a les sol·licituds d'arp, heu d'habilitar el proxy arp.
echo 1 > /proc/sys/net/ipv4/conf/eth0.800/proxy_arp
Seguim endavant - ucarp. Escrivim els guions de llançament d'aquest miracle nosaltres mateixos.
Exemple d'execució d'un dimoni
start-stop-daemon --start --exec /usr/sbin/ucarp -b -m -p /opt/ipoe/ucarp-gen2/daemons/$iface.$vhid.$virtualaddr.pid -- --interface=eth0.800 --srcip=1.2.3.4 --vhid=1 --pass=carpasword --addr=10.10.10.1 --upscript=/opt/ipoe/ucarp-gen2/up.sh --downscript=/opt/ipoe/ucarp-gen2/down.sh -z -k 10 -P --xparam="10.10.10.0/24"
amunt.sh
#!/bin/bash
iface=$1
addr=$2
gw=$3
vlan=`echo $1 | sed "s/eth0.//"`
ip ad ad $addr/32 dev lo
ip ro add blackhole $gw
echo 1 > /proc/sys/net/ipv4/conf/$iface/proxy_arp
killall -9 dhcrelay
/etc/init.d/dhcrelay zap
/etc/init.d/dhcrelay start
killall -HUP arp-rt
avall.sh
#!/bin/bash
iface=$1
addr=$2
gw=$3
ip ad d $addr/32 dev lo
ip ro de blackhole $gw
echo 0 > /proc/sys/net/ipv4/conf/$iface/proxy_arp
killall -9 dhcrelay
/etc/init.d/dhcrelay zap
/etc/init.d/dhcrelay start
Perquè dhcprelay funcioni en una interfície, necessita una adreça. Per tant, a les interfícies que utilitzem afegirem adreces esquerra - per exemple 10.255.255.1/32, 10.255.255.2/32, etc. No us diré com configurar el relé: tot és senzill.
Què tenim doncs? Còpia de seguretat de passarel·les, autoconfiguració de rutes, dhcp. Aquest és el conjunt mínim: lisg també envolta tot el que l'envolta i ja tenim un modelador. Per què tot és tan llarg i complicat? No és més fàcil prendre accel-pppd i utilitzar pppoe del tot? No, no és més senzill: la gent difícilment pot encaixar un cable de connexió en un encaminador, per no parlar de pppoe. accel-ppp és una cosa genial, però no ens va funcionar; hi ha molts errors al codi; s'enfonsa, es talla malament i el més trist és que si s'il·lumina, la gent ha de tornar a carregar. tot -els telèfons són vermells- no va funcionar gens. Quin és l'avantatge d'utilitzar ucarp en lloc de keepalive? Sí, en tot - hi ha 100 passarel·les, keepalived i un error a la configuració - tot no funciona. 1 gateway no funciona amb ucarp. Pel que fa a la seguretat, diuen que els de l'esquerra registraran adreces per si mateixos i les utilitzaran a la compartició; per controlar aquest moment, vam configurar dhcp-snooping + source-guard + inspecció arp a tots els interruptors/olts/bases. Si el client no té dhpc sinó estàtica - llista d'accés al port.
Per què es va fer tot això? Per destruir el trànsit no desitjat. Ara cada commutador té el seu propi vlan i unknown-unicast ja no fa por, ja que només cal anar a un port i no a tots... Bé, els efectes secundaris són una configuració estandarditzada de l'equip, una major eficiència en l'assignació de l'espai d'adreces.
Com configurar lisg és un tema independent. S'adjunten enllaços a biblioteques. Potser l'anterior ajudarà algú a assolir els seus objectius. La versió 6 encara no s'està implementant a la nostra xarxa, però hi haurà un problema, hi ha plans per reescriure el lisg per a la versió 6 i caldrà corregir el programa que afegeix rutes.
Font: www.habr.com