Felsäker IPeE-nätverk med hjälp av tillgängliga resurser

Hej. Det finns ett nätverk med 5k kunder. Nyligen uppstod ett mindre trevligt problem - i centrum av nätverket har vi en Brocade RX8 och den har börjat skicka en massa unknown-unicast paket, eftersom nätverket är uppdelat i VLAN - det här är delvis inte ett problem MEN det finns speciella VLAN för vita adresser osv. och de är sträckt i alla riktningar av nätverket. Så, tänk er nu det inkommande flödet till kundens adress, som gränslandet inte känner igen och det flödet flyger mot en radio länk till något (och så till hela) by - kanalen är blockerad - kunderna är arga - sorgligt...

Uppgiften - att förvandla en bugg till en funktion. Jag tänkte i riktning mot q-in-q med en fullständig klient-vlan men olika hårdvaror som P3310 slutar att passera DHCP när dot1q aktiveras, de kan inte heller selective qinq och det finns många underliggande problem av denna typ. Vad är ip-unnumbered och hur fungerar det? Om vi ska vara kortfattade - gateway-adressen + rutt på gränssnittet. För vår uppgift behöver vi: skära shaper, dela ut adresser till kunder, lägga till rutter till kunder via specifika gränssnitt. Vad ska vi göra allt detta med? Shaper - lisg, dhcp - db2dhcp på två oberoende servrar, på åtkomstservrarna körs dhcprelay, och på åtkomstservrarna fungerar också ucarp - för backup. Men hur lägger vi till rutter? Man kan använda ett stort skript för att på förhand lägga till allt - men det är inte riktigt sant. Så vi kommer att bygga en egen lösning.

Efter att ha sökt ordentligt på internet har jag hittat ett fantastiskt hög nivå bibliotek för c++, som gör det möjligt att snyggt sniffa trafik. Algoritmen för programmet som lägger till rutter är följande - vi lyssnar på ARP-förfrågningar på gränssnittet, om vi har en adress på servern på gränssnittet lo, som efterfrågas så lägger vi till en rutt genom detta gränssnitt och lägger till en statisk ARP-post för denna ip - sammanfattningsvis några kopior av koden, lite egenhet och klart.

Källkod för 'rutten'

#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;
    }
}

Installationsskript för libtins

#!/bin/bash

git clone https://github.com/mfontanini/libtins.git
cd libtins
mkdir build
cd build
cmake ../
make
make install
ldconfig

Kommandot för att bygga binärfilen

g++ main.cpp -o arp-rt -O3 -std=c++11 -lpthread -ltins

Hur kör man den?

start-stop-daemon --start --exec  /opt/ipoe/arp-routes/arp-rt -b -m -p /opt/ipoe/arp-routes/daemons/eth0.800.pid -- eth0.800

Ja — den byggs om av HUP-signal för att omstrukturera tabellerna. Varför använda netlink? Det är bara lathet, och Linux är skript på skript — så det är helt okej. Nåväl, rutter är rutterna, vad händer nu? Vidare måste vi skicka rutter till border som finns på den här servern — här, på grund av samma föråldrade hårdvara, valde vi den enklaste vägen — vi lägger den här uppgiften på BGP.

BGP-konfigurationvärdnamn *******
lösenord *******
loggfil /var/log/bgp.log
!
# номер ас-ки, адреса и сети выдуманы
router bgp 12345
bgp router-id 1.2.3.4
redistribuera ansluten
redistribuera statiska
granne 1.2.3.1 remote-as 12345
granne 1.2.3.1 next-hop-self
granne 1.2.3.1 route-map none in
granne 1.2.3.1 route-map export out
!
åtkomstlista export tillåt 1.2.3.0/24
!
route-map export tillåt 10
matcha IP-adress export
!
route-map export neka 20

Vi fortsätter. För att servern ska svara på ARP-förfrågningar behöver vi aktivera proxy ARP.

echo 1 > /proc/sys/net/ipv4/conf/eth0.800/proxy_arp

Vi går vidare — ucarp. Skripten för att starta detta underverk skriver vi själva.

Exempel på att starta en demon

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"

up.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

down.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

För att dhcprelay ska fungera på gränssnittet — behöver det en adress. Så vi kommer att lägga till falska adresser på gränssnitten som vi använder — till exempel 10.255.255.1/32, 10.255.255.2/32 och så vidare. Jag kommer inte att gå in på hur man konfigurerar relay — det är enkelt.

Så, vad har vi? Backup-gateways, automatisk ruttkonfiguration, DHCP. Detta är den minimala uppsättningen — ovanpå detta lägger vi till lisg och vi har redan en shaper. Varför är allt så långt och komplicerat? Skulle det inte vara lättare att ta accel-pppd och använda PPPoE istället? Nej, det är inte enklare — folk har svårt att få en patchkabel i routern, för att inte tala om PPPoE. accel-ppp är bra — men det fungerade inte för oss — massor av fel i koden — det kraschar, skär illa, och det mest sorgliga är att när det kraschar behöver folk alltid starta om — telefonerna ringer — i allmänhet passade det inte. Vad är fördelen med att använda ucarp istället för keepalived? Jo, allt — det finns 100 gateways, keepalived och ett fel i konfigurationen — allt fungerar inte. Med ucarp fungerar inte 1 gateway. När det gäller säkerhet, att folk kan skriva in främmande adresser och använda dem på nätet — för att kontrollera detta konfigurerar vi dhcp-snooping + source-guard + arp-inspektion på alla switchar/oltar/servrar. Om kunden inte har DHCP utan statiska adresser — access-list på porten.

Varför gjordes allt detta? För att förstöra oönskad trafik. Nu har varje switch sin egen VLAN, och unknown-unicast är inte längre ett problem, eftersom det bara behöver gå till en port och inte till alla... Och biverkningarna — standardiserad konfiguration av utrustningen, större effektivitet i fördelningen av adresser.

Hur man konfigurerar lisg — det är ett separat ämne. Länkar till biblioteken ingår. Kanske hjälper det någon i ovanstående med att genomföra sina uppgifter. Version 6 har vi inte implementerat i vårt nät än — men det kommer att bli ett problem — vi planerar att skriva om lisg för version 6, och då måste programmet som lägger till rutter justeras.

Linux ISG
DB2DHCP
Libtins

Källa: habr.com