แแแแแ แฏแแแ. แแก แแแจแแแแก, แ แแ แแ แกแแแแแก 5 แแแแกแ แแแแแแขแแก แฅแกแแแ. แแฎแแแฎแแ แแแแแ แแ แช แแฃ แแกแ แกแแกแแแแแแแ แแแแแแขแ - แฅแกแแแแก แชแแแขแ แจแ แแแแฅแแก Brocade RX8 แแ แแแ แแแแฌแงแ แแแแ แ แฃแชแแแแ-แฃแแแแแกแขแแก แแแแแขแแก แแแแแแแแ, แ แแแแแ แฅแกแแแ แแแงแแคแแแแ vlan-แแแแ - แแก แแแฌแแแแแ แแ แแ แแ แแก แแ แแแแแแ, แแแแ แแ แแ แแก แกแแแชแแแแฃแ แ แแแแแแแ แแแแ แ แแแกแแแแ แแแแแกแแแแก แแ แ.แจ. แแ แแกแแแ แแแแแญแแแฃแแแ แฅแกแแแแก แงแแแแ แแแแแ แแฃแแแแแ. แแฎแแ แฌแแ แแแแแแแแแ แจแแแแแแแแแ แแแแแแ แแแแแแขแแก แแแกแแแแ แแแ, แ แแแแแแช แแ แกแฌแแแแแแก แกแแแฆแแ แแก แกแขแฃแแแแขแแ แแ แแก แแแแแแ แแแคแ แแแแแก แ แแแแแแแแจแแ แแกแแแ แ แแแแแแแ (แแ แงแแแแ) แกแแคแแแกแแแ - แแ แฎแ แฉแแแแขแแแแ - แแแแแแขแแแ แแ แแแแแแแแ - แกแแแแ...
แแแแแแ แแ แแก แจแแชแแแแแก แคแฃแแฅแชแแแ แแแแแฅแชแแแ. แแ แแคแแฅแ แแแแ q-in-q-แแก แแแแแ แแฃแแแแแ แกแ แฃแแคแแกแแแแแ แแแแแแขแแก vlan-แแ, แแแแ แแ แงแแแแ แกแแฎแแก แแแแ แแขแฃแ แ, แ แแแแ แแชแแ P3310, แ แแแแกแแช dot1q แฉแแ แแฃแแแ, แฌแงแแแขแก DHCP-แก แแแจแแแแแก, แแแ แแกแแแ แแ แแชแแแ แ แแแแ แจแแแกแ แฃแแแ qinq แแ แแ แแแแแ. แแ แกแแฎแแก แฎแแคแแแแแแ. แ แ แแ แแก ip-unnamebered แแ แ แแแแ แแฃแจแแแแก? แซแแแแแ แแแแแแ: แแแ แแแญแแก แแแกแแแแ แแ + แแแ แจแ แฃแขแ แแแขแแ แคแแแกแแ. แฉแแแแ แแแแชแแแแกแแแแก แฉแแแ แแแญแแ แแแแ: แแแแญแ แแ แคแแ แแแ แแแแแ, แแแแแฌแแแแ แแแกแแแแ แแแแ แแแแแแขแแแก, แแแแแแแขแแ แแแ แจแ แฃแขแแแ แแแแแแขแแแก แแแ แแแแฃแแ แแแขแแ แคแแแกแแแแ. แ แแแแ แแแแแแแแแ แแก แงแแแแแคแแ แ? Shaper - lisg, dhcp - db2dhcp แแ แแแแแฃแแแแแแแ แกแแ แแแ แแ, dhcprelay แแฃแจแแแแก แฌแแแแแแก แกแแ แแแ แแแแ, ucarp แแกแแแ แแฃแจแแแแก แฌแแแแแแก แกแแ แแแ แแแแ - แกแแ แแแแ แแ แแกแแแกแแแแก. แแแแ แแ แ แแแแ แแแแแแแขแแ แแแ แจแ แฃแขแแแ? แแฅแแแ แจแแแแซแแแแ แงแแแแแคแแ แ แฌแแแแกแฌแแ แแแแแแขแแ แแแแ แกแแ แแแขแแ - แแแแ แแ แแก แแกแ แแ แแ แแก. แแกแ แ แแ, แฉแแแ แแแแแแแแแแ แแแแแแแฌแแ แ แงแแแแ แฏแแแ.
แแแขแแ แแแขแจแ แกแแคแฃแซแแแแแแ แซแแแแแก แจแแแแแ แแแแแแ แจแแกแแแแจแแแแ แแแฆแแแ แแแแแก แแแแแแแแแแ C++-แแกแแแแก, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแแ แแแแแกแฃแแแฅแแ แขแ แแคแแแ. แแ แแแ แแแแก แแแแแ แแแแ, แ แแแแแแช แแแแขแแแก แแแ แจแ แฃแขแแแก, แแกแแแแ - แฉแแแ แแฃแกแแแแ arp แแแแฎแแแแแแก แแแขแแ แคแแแกแแ, แแฃ แกแแ แแแ แแ แแแแฅแแก แแแกแแแแ แแ lo แแแขแแ แคแแแกแแ, แ แแแแแแช แแแแฎแแแแแแแ, แแแจแแ แแแแแขแแแ แแแ แจแ แฃแขแก แแ แแแขแแ แคแแแกแแก แแแจแแแแแแ แแ แแแแแขแแแ แกแขแแขแแแฃแ arp-แก. แฉแแฌแแ แแ แแ ip-แแ - แแแแแแแ, แ แแแแแแแแ แแแแแ -แแแกแขแ, แแแขแแ แ แแแแกแแ แแแแ แกแแฎแแแ แแ แแแแกแ แฃแแแ
"แ แแฃแขแแ แแก" แฌแงแแ แแแแ
#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;
}
}libtins แแแกแขแแแแชแแแก แกแแ แแแขแ
#!/bin/bash
git clone https://github.com/mfontanini/libtins.git
cd libtins
mkdir build
cd build
cmake ../
make
make install
ldconfig
แแ แแแแแ แแแ แกแแแก แแจแแแแแแก แแ แซแแแแแ
g++ main.cpp -o arp-rt -O3 -std=c++11 -lpthread -ltinsแ แแแแ แแแแฃแจแแแ แแแ?
start-stop-daemon --start --exec /opt/ipoe/arp-routes/arp-rt -b -m -p /opt/ipoe/arp-routes/daemons/eth0.800.pid -- eth0.800
แแแแฎ - แแก แแฆแแแแแแก แชแฎแ แแแแแก HUP แกแแแแแแแก แกแแคแฃแซแแแแแ. แ แแขแแ แแ แแงแแแแ แแแขแแแแแก? แแก แฃแแ แแแแ แกแแแแ แแแชแแ แแ Linux แแ แแก แกแแ แแแขแ แกแแ แแแขแแ - แแกแ แ แแ, แงแแแแแคแแ แ แแแ แแแแแ. แแแ แจแ แฃแขแแแ แแแ แจแ แฃแขแแแแ, แ แ แแ แแก แจแแแแแแ? แจแแแแแแ, แฉแแแ แฃแแแ แแแแแแแแแแแ แแแ แจแ แฃแขแแแ, แ แแแแแแแช แแ แแก แแ แกแแ แแแ แแ แกแแแฆแแแ แแ - แแฅ, แแแแแ แแแซแแแแแแฃแแ แขแแฅแแแแแก แแแแ, แฉแแแ แแแแฆแแ แงแแแแแแ แแชแแ แ แฌแแแแแฆแแแแแแแแก แแแ - แแก แแแแแแแแ แแแแแชแแ BGP-แก.
bgp แแแแคแแแฃแ แแชแแแแแกแแแแซแแแก แกแแฎแแแ *******
แแแ แแแ ******
แแฃแ แแแแแก แคแแแแ /var/log/bgp.log
!
# AS แแแแแ แ, แแแกแแแแ แแแแ แแ แฅแกแแแแแ แคแแฅแขแแฃแ แแ
แ แแฃแขแแ แ bgp 12345
bgp แ แแฃแขแแ แแก ID 1.2.3.4
แแแแแแจแแ แแแฃแแ แแแแแแแฌแแแแแ
แกแขแแขแแแฃแ แ แแแแแแแฌแแแแแ
แแแแแแแแ 1.2.3.1 แแแกแขแแแชแแฃแ แ - แ แแแแ แช 12345
แแแแแแแแ 1.2.3.1 แจแแแแแแ hop-self
แแแแแแแแ 1.2.3.1 แแแ แจแ แฃแขแแก แ แฃแแ แแ แแ แแก
แแแแแแแแ 1.2.3.1 แแแ แจแ แฃแขแแก แ แฃแแ แแฅแกแแแ แขแ
!
แฌแแแแแแก แกแแ แแฅแกแแแ แขแแก แแแแแ แแแ 1.2.3.0/24
!
แแแ แจแ แฃแขแแก แ แฃแแ แแฅแกแแแ แขแแก แแแแแ แแแ 10
แแแแฎแแแแ IP แแแกแแแแ แแแก แแฅแกแแแ แขแก
!
แแแ แจแ แฃแขแแก แ แฃแแ แแฅแกแแแ แขแแก แฃแแ แงแแคแ 20
แฒแแแแแ แซแแแแ. แแแแกแแแแแก, แ แแ แกแแ แแแ แแ แฃแแแกแฃแฎแแก arp แแแแฎแแแแแแก, แแฅแแแ แฃแแแ แฉแแ แแแ arp แแ แแฅแกแ.
echo 1 > /proc/sys/net/ipv4/conf/eth0.800/proxy_arp
แแแแแแ แซแแแแ - แฃแแแ แแ. แฉแแแ แแแแแแ แแฌแแ แ แแ แกแแกแฌแแฃแแแก แแแจแแแแแก แกแแ แแแขแแแก.
แแ แแ แแแแแแแก แแแจแแแแแก แแแแแแแแ
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"
แแแแแ.แจ
#!/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
แฅแแแแแ.แจ
#!/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
แแแแกแแแแแก, แ แแ dhcprelay แแแขแแ แคแแแกแแ แแแฃแจแแแก, แแแก แแแกแแแแ แแ แกแญแแ แแแแ. แแแแขแแ, แแแขแแ แคแแแกแแแแ, แ แแแแแแกแแช แฉแแแ แแแงแแแแแ, แแแแแแแขแแแ แแแ แชแฎแแแ แแแกแแแแ แแแแก - แแแแแแแแแ 10.255.255.1/32, 10.255.255.2/32 แแ แ.แจ. แแ แแ แแแขแงแแแ, แแฃ แ แแแแ แฃแแแ แแแแแแแคแแแฃแ แแ แแ แ แแแ - แงแแแแแคแแ แ แแแ แขแแแแ.
แแแจ แ แ แแแแฅแแก? แแแ แแแญแแแแแก แกแแ แแแแ แแ แแกแแ, แแแ แจแ แฃแขแแแแก แแแขแแแแขแฃแ แ แแแแคแแแฃแ แแชแแ, dhcp. แแก แแ แแก แแแแแแแแฃแ แ แแแแ แแแ - lisg แแกแแแ แแฎแแแแก แงแแแแแคแแ แก แแ แฉแแแ แฃแแแ แแแแฅแแก แคแแ แแ. แ แแขแแ แแ แแก แงแแแแแคแแ แ แแกแ แแ แซแแแ แแ แ แแฃแแ? แฃแคแ แ แแแแแแ แแ แแ แแก accel-pppd-แแก แแฆแแแ แแ แกแแแ แแแ pppoe-แแก แแแแแงแแแแแ? แแ แ, แแก แแ แแ แแก แฃแคแ แ แแแ แขแแแ - แแแแแแแแแแ แซแแแแแ แแแแแกแแแแ แแแฉแแแ แแก แ แแฃแขแแ แจแ, แ แแ แแฆแแ แแคแแ แ แแแฅแแแ pppoe-แแ. accel-ppp แแแแแ แ แ แแแแ - แแแแ แแ แฉแแแแแแ แแ แแแแแแแแ - แแแแจแ แแแแ แ แจแแชแแแแแ - แแจแแแแ, แญแ แแก แแ แงแแแแแแ แกแแแฌแฃแฎแแ แ แแก แแ แแก, แ แแ แแฃ แแแแ แฌแงแแแแ - แแแจแแ แฎแแแฎแก แแแแแขแแแ แแแ แกแญแแ แแแแ แงแแแแแคแแ แ - แขแแแแคแแแแแ แฌแแแแแแ - แกแแแ แแแ แแ แแฃแจแแแแแ. แ แ แฃแแแ แแขแแกแแแ แแฅแแก แฃแแแ แแแก แแแแแงแแแแแแก, แแแแ แ แจแแแแฎแแ? แแแแฎ, แงแแแแแคแแ แจแ - แแ แแก 100 แแแ แแแญแ, แจแแแแฎแฃแแ แแ แแ แแ แจแแชแแแแ แแแแคแแแฃแ แแชแแแจแ - แงแแแแแคแแ แ แแ แแฃแจแแแแก. 1 แแแ แแแญแ แแ แแฃแจแแแแก แฃแแแ แแแแ. แฃแกแแคแ แแฎแแแแแกแแแ แแแแแแจแแ แแแแ แแแแแแแ, แ แแ แแแ แชแฎแแแแแแ แแแแ แแแแกแขแ แแ แแแแ แแแกแแแแ แแแแก แแ แแแแแแงแแแแแแ แแแ แฌแแแแ - แแ แแแแแแขแแก แแแกแแแแแขแ แแแแแแแ แงแแแแ แแแแแแ แแแแแแ/แแแขแก/แแแแแ แแแแแงแแแแ dhcp-snooping + source-guard + arp แแแกแแแฅแขแแ แแแ. แแฃ แแแแแแขแก แแ แแฅแแก dhpc, แแแแ แแ แกแขแแขแแแฃแ แ - แฌแแแแแแก แกแแ แแแ แขแแ.
แ แแขแแ แแแแแแแ แแก แงแแแแแคแแ แ? แแ แแกแแกแฃแ แแแแ แแแซแ แแแแแก แแแแแแแฃแ แแแ. แแฎแแ แแแแแแฃแ แแแแแแ แแแแแก แแฅแแก แแแแแกแ vlan แแ แฃแชแแแแ-unicast แแฆแแ แแ แแก แกแแจแแแแแ, แ แแแแแ แแแก แแฎแแแแ แแ แ แแแ แขแจแ แกแญแแ แแแแ แฌแแกแแแ แแ แแ แ แงแแแแ... แแกแ, แแแแ แแแแ แแคแแฅแขแแแ แแ แแก แแฆแญแฃแ แแแแแแแก แกแขแแแแแ แขแแแแแฃแแ แแแแคแแแฃแ แแชแแ, แฃแคแ แ แแแแ แแคแแฅแขแฃแ แแแ แแแกแแแแ แแแแแก แกแแแ แชแแก แแแแแงแแคแแจแ.
Lisg-แแก แแแแคแแแฃแ แแชแแ แชแแแแ แแแแแ. แแแแแแแแแแแแแก แแแฃแแแแ แแ แแแแก. แจแแกแแซแแแ, แแแแแแฆแแแจแแฃแแ แแแแแแก แแแแฎแแแ แแก แแแแแแแแก แแแฆแฌแแแแจแ. แแแ แกแแ 6 แฏแแ แแ แแ แแก แแแแแ แแแแ แฉแแแแก แฅแกแแแจแ - แแแแ แแ แแฅแแแแ แแ แแแแแแ - แแแแแแแแ 6 แแแ แกแแแกแแแแก lisg-แแก แแแแแฌแแ แ แแ แกแแญแแ แ แแฅแแแแ แแ แแแ แแแแก แแแกแฌแแ แแแ, แ แแแแแแช แแแแขแแแก แแแ แจแ แฃแขแแแก.
แฌแงแแ แ: www.habr.com