Força o tráfego IP local para uma interface externa

Question

Eu tenho uma máquina com várias interfaces que eu posso configurar como eu quero, por exemplo:

• eth1: 192.168.1.1
• eth2: 192.168.2.2

Gostaria de encaminhar todo o tráfego enviado para um desses endereços locais por meio da outra interface. Por exemplo, todas as solicitações para um servidor iperf, ftp, http em 192.168.1.1 devem ser roteadas internamente, mas encaminhadas através de eth2 (e a rede externa cuidará de redirecionar o pacote para eth1).

Eu tentei e olhei vários comandos, como iptables, ip route, etc ... mas nada funcionou.

O comportamento mais próximo que consegui foi feito com:

ip route change to 192.168.1.1/24 dev eth2

que enviam todos os 192.168.1.x na eth2, exceto 192.168.1.1, que ainda é roteado internamente. Pode ser que eu poderia fazer o encaminhamento de NAT de todo o tráfego direcionado para o 192.168.1.2 falso na eth1, redirecionado para 192.168.1.1 internamente? Eu estou realmente lutando com o iptables, mas é muito difícil para mim.

O objetivo dessa configuração é testar o driver da interface sem usar dois PCs.

Estou usando o Linux, mas se você souber como fazer isso com o Windows, eu compro!

Editar:

A rede externa é apenas um cabo cruzado entre eth1 e eth2. Digamos que eu tenha um servidor http na minha máquina. Agora quero acessar esse servidor da mesma máquina, mas quero forçar o tráfego TCP / IP a passar por esse cabo eth1 / eth2. Como devo configurar minhas interfaces para isso?

    

Answer 1

Eu ampliei a resposta de caladona, já que não consegui ver os pacotes de resposta. Para este exemplo:

1. No meu PC local eu tenho placas de rede em diferentes sub-redes, 192.168.1 / 24 , 192.168.2 / 24
   
2. Existe um roteador / PC externo que tem acesso a ambas as sub-redes.
3. Quero enviar tráfego bidirecional pelas NICs no PC local.
4. A configuração requer dois endereços IP não usados para cada sub-rede.

As rotas iptables do PC local são definidas para o tráfego de saída SNAT e DNAT para o IP 'falso'.

iptables -t nat -A POSTROUTING -d 192.168.1.100 -s 192.168.2.0/24 -j SNAT --to-source      192.168.2.100
iptables -t nat -A PREROUTING  -d 192.168.1.100 -i eth0           -j DNAT --to-destination 192.168.1.1
iptables -t nat -A POSTROUTING -d 192.168.2.100 -s 192.168.1.0/24 -j SNAT --to-source      192.168.1.100
iptables -t nat -A PREROUTING  -d 192.168.2.100 -i eth1           -j DNAT --to-destination 192.168.2.1

As regras fazem o seguinte:

1. Reescreva 192.168.2.1 origem para 192.168.2.100 nos pacotes de saída
2. Reescreva 192.168.1.100 destino para 192.168.1.1 nos pacotes de entrada
3. Reescreva 192.168.1.1 origem para 192.168.1.100 nos pacotes de saída
4. Reescreva 192.168.2.100 destino para 192.168.2.1 nos pacotes de entrada

Para resumir, o sistema local agora pode falar com uma máquina 'virtual' com os endereços 192.168.1.100 e 192.168.2.100.

Em seguida, você precisa forçar seu PC local a usar o roteador externo para alcançar seu IP falso. Você faz isso criando uma rota direta para o IP através do roteador. Você quer ter certeza de forçar os pacotes para o oposto da sub-rede de destino.

ip route 192.168.1.100 via $ROUTER_2_SUBNET_IP 
ip route 192.168.2.100 via $ROUTER_1_SUBNET_IP

Finalmente, para que tudo isso funcione, o roteador externo precisa saber como alcançar os IPs falsos em seu PC local. Você pode fazer isso ativando o proxy ARP no seu sistema.

echo 1 | sudo tee /proc/sys/net/ipv4/conf/all/proxy_arp
echo 1 | sudo tee /proc/sys/net/ipv4/ip_forward

Com esta configuração, você pode agora tratar os IPs falsos como um sistema real no seu PC local. O envio de dados para a sub-rede .1 forçará os pacotes a sair da interface .2. O envio de dados para a sub-rede .2 forçará os pacotes a sair da interface .1.

ping 192.168.1.100
ping 192.168.2.100

    

Answer 2

Eu usei com sucesso o seguinte no Linux para testar a taxa de transferência em uma nova placa de 10 Gbps de porta dupla no modo "loopback", ou seja, uma porta conectada diretamente na outra. Isso tudo é apenas um pouco de vodu só para forçar os pacotes a saírem do fio, mas se você não o fizer, o Linux apenas causará um curto-circuito no tráfego através do kernel (daí a pergunta do OP). Na resposta de Casey acima, eu não tenho certeza se era realmente necessário ter um roteador externo ou não acima, mas o seguinte é completamente auto-contido. As duas interfaces são eth2 e eth3.

Dar IPs às interfaces e colocá-las em redes separadas:

ifconfig eth2 10.50.0.1/24
ifconfig eth3 10.50.1.1/24

Em seguida, vamos configurar um cenário duplo de NAT: duas novas redes falsas usadas para alcançar o outro. Ao sair, digite NAT para sua rede falsa. No caminho, corrija o destino. E vice-versa para a outra rede:

# nat source IP 10.50.0.1 -> 10.60.0.1 when going to 10.60.1.1
iptables -t nat -A POSTROUTING -s 10.50.0.1 -d 10.60.1.1 -j SNAT --to-source 10.60.0.1

# nat inbound 10.60.0.1 -> 10.50.0.1
iptables -t nat -A PREROUTING -d 10.60.0.1 -j DNAT --to-destination 10.50.0.1

# nat source IP 10.50.1.1 -> 10.60.1.1 when going to 10.60.0.1
iptables -t nat -A POSTROUTING -s 10.50.1.1 -d 10.60.0.1 -j SNAT --to-source 10.60.1.1

# nat inbound 10.60.1.1 -> 10.50.1.1
iptables -t nat -A PREROUTING -d 10.60.1.1 -j DNAT --to-destination 10.50.1.1

Agora diga ao sistema como chegar a cada rede falsa e preencha as entradas arp (certifique-se de substituir seus endereços MAC, não use os meus):

ip route add 10.60.1.1 dev eth2
arp -i eth2 -s 10.60.1.1 00:1B:21:C1:F6:0F # eth3's mac address

ip route add 10.60.0.1 dev eth3 
arp -i eth3 -s 10.60.0.1 00:1B:21:C1:F6:0E # eth2's mac address

Isso engana o Linux o suficiente para colocar os pacotes no fio. Por exemplo:

ping 10.60.1.1

sai da eth2, o IP de origem 10.50.0.1 é NATted para 10.60.0.1 e, conforme entra na eth3, o destino 10.60.1.1 é NATted para 10.50.1.1. E a resposta leva uma jornada similar.

Agora use o iperf para testar a taxa de transferência. Vincule-se aos IPs corretos e tenha certeza de qual IP você está contatando (o endereço falso da outra extremidade):

# server
./iperf -B 10.50.1.1 -s

# client: your destination is the other end's fake address
./iperf -B 10.50.0.1 -c 10.60.1.1 -t 60 -i 10

Certifique-se de que o tráfego está saindo realmente para o fio:

tcpdump -nn -i eth2 -c 500

Você também pode assistir / proc / interrupts apenas para ter certeza absoluta de que o cartão está sendo usado:

while true ; do egrep 'eth2|eth3' /proc/interrupts ; sleep 1 ; done

De qualquer forma, encontrei este post pesquisando como fazer isso, obrigado pelo pessoal da Q & A e espero que isso ajude qualquer pessoa a encontrar essa postagem no futuro.

    

Answer 3

Como sempre - estou um pouco atrasado - mas hoje em dia é possível usar namespaces de rede para isolar as interfaces e impedir qualquer encaminhamento local (e mexer com o iptables :)).

Crie namespaces (todos feitos com as permissões necessárias, por exemplo, como root):

ip netns add ns_server
ip netns add ns_client

Note que as interfaces status / config agora devem ser acessadas dentro o contexto do espaço de nomes atribuído - para que eles não apareçam se você executar um ip

como este é executado no contexto do espaço de nomes padrão. Executar um comando dentro de um namespace pode ser feito usando

ip netns exec <namespace-name> <command>

como prefixo.

Agora atribua namespaces a interfaces, aplique config e configure interfaces:

ip link set eth1 netns ns_server
ip netns exec ns_server ip addr add dev eth1 192.168.1.1/24
ip netns exec ns_server ip link set dev eth1 up
ip link set eth2 netns ns_client
ip netns exec ns_client ip addr add dev eth2 192.168.1.2/24
ip netns exec ns_client ip link set dev eth2 up

Agora você pode executar os aplicativos dentro do namespace - para a execução do servidor iperf

ip netns exec ns_server iperf -s -B 192.168.1.1

e o cliente:

ip netns exec ns_client iperf -c 192.168.1.1 -B 192.168.1.2

O tráfego agora será enviado por meio das interfaces físicas, pois toda a rede, interface, roteamento ... é isolada pelos namespaces, portanto, o kernel não pode corresponder aos endereços usados no tráfego com interfaces locais (disponíveis).

Se tiver concluído suas experiências, basta excluir os namespaces:

ip netns del <namespace-name>

As interfaces serão reatribuídas ao namespace padrão e todas as configurações feitas dentro do namespace desaparecem (por exemplo, não há necessidade de excluir endereços IP atribuídos).

    

Answer 4

Ok, finalmente consegui configurar minha configuração.

A idéia é usar outro endereço falso, para forçar a rota desse endereço falso para a interface 2, então para traduzir o endereço falso com o endereço real 2 com NAT / iptables.

Minha configuração é na verdade feita de um roteador que eu posso fazer telnet entre IF1 (interface 1) e IF2

Na minha configuração, FAKE_ADDR e IF1_ADDR estão na mesma sub-rede.

ifconfig $IF1 $IF1_ADDR netmask 255.255.255.0
ifconfig $IF2 $IF2_ADDR netmask 255.255.255.0

iptables -t nat -A PREROUTING -d $FAKE_ADDR -i $IF2 -j DNAT --to-destination $IF2_ADDR
iptables -t nat -A POSTROUTING -s $IF2_ADDR -d $IF1_ADDR/24 -j SNAT --to-source $FAKE_ADDR

route add $FAKE_ADDR gw $ROUTER_ADDR

E no roteador:

route add $FAKE_ADDR gw $IF2_ADDR

Se eu enviar algo para o FAKE_ADDR, o pacote será encaminhado através do IF1 para o roteador, encaminhado novamente para o IF2 e, em seguida, o FAKE_IP será substituído pelo IF2_ADDR. O pacote é processado pelo servidor, o resultado é enviado de volta para IF1_ADDR, de IF2_ADDR que é substituído por FAKE_ADDR.

Pode ser possível usar uma configuração mais simples com apenas um cabo cruzado, mas como eu não tentei, prefiro dar a minha solução de trabalho.

    

Answer 5

A resposta dada acima por Thomas Tannhäuser foi no local!

Eu tive uma situação semelhante: uma única máquina com duas interfaces enet. Meu plano era usar uma interface como servidor (receptor) e a outra como cliente (remetente). Cada interface seria conectada ao roteador e o iperf direcionaria o tráfego pelo roteador para medir a taxa de transferência, o PPS, o atraso, etc.

Infelizmente, a abordagem iptables não era intuitiva e cheia de problemas. Depois de algumas horas frustrantes, abandonei esse plano de ataque. Inspirado pela sugestão de Thomas, eu fiz um pequeno trabalho de casa nos Namespaces IP do Linux e comecei a apreciar a simplicidade e a elegância desta solução.

Abaixo está uma lista dos comandos exatos que eu usei para configurar o meu Fedora FC26 para servir nesta capacidade. As duas interfaces são enp1s0 e enp3s0. O roteador tem duas interfaces com os endereços 192.168.2.112 e 172.16.16.2. Cada conector FC26 ENET é conectado diretamente à interface do roteador correspondente.

# How to configure the IP Namespaces
ip netns add iperf-server
ip netns add iperf-client
ip link set enp1s0 netns iperf-server
ip link set enp3s0 netns iperf-client
ip netns exec iperf-server ip addr add dev enp1s0 192.168.2.139/20
ip netns exec iperf-client ip addr add dev enp3s0 172.16.16.2/24
ip netns exec iperf-client ip link set dev enp3s0 up
ip netns exec iperf-server ip link set dev enp1s0 up
ip netns exec iperf-server route add default gw 192.168.2.112
ip netns exec iperf-client route add default gw 172.16.16.1

# Test the interfaces and network using ping
ip netns exec iperf-client ping -c1 172.16.16.1
ip netns exec iperf-server ping -c1 192.168.2.112
ip netns exec iperf-server ping -c1 172.16.16.2
ip netns exec iperf-client ping -c1 192.168.2.139

# Start Iperf Server for UDP test
ip netns exec iperf-server iperf -u -s
# Run Client against Iperf server for UDP test
ip netns exec iperf-client iperf -u -c 192.168.2.139

    

Answer 6

Parece que você quer transformar sua caixa de linux em uma caixa do tipo router / bridge / gateway / firewall. Os seguintes recursos podem ser o que você está procurando:

O projeto do roteador Linux

Lista de distribuições de roteadores ou firewall

Linux LiveCD Router

Linux Journal - O Roteador Linux

Atualize com base em mais informações:

Eu não acho que você conseguirá fazer o que quiser. O sistema operacional sempre examinará sua tabela de roteamento interna e "verá" os dois endereços IP localmente. Em seguida, ele roteará o tráfego dentro do sistema operacional e nunca o colocará no fio. Você precisará de uma segunda máquina ou duas máquinas virtuais (confira Xen ).

    

Answer 7

Um monte de coisas para passar por aqui, então não posso garantir totalmente a minha precisão, mas a pergunta original parece estar procurando o que é conhecido como " enviar para si mesmo "técnica . A pesquisa vinculada mostra o que eu acho que é o melhor patch de kernel mantido como link superior + discussões e patches com outras abordagens em vários listas de discussão, esp. LKML.

Acho que também se deve olhar para os namespaces de rede , feitos com o " ip netns ". Isso também requer alguma interface extra e magia de roteamento, então pode até não ser menos complexo do que o maciço iptables nas outras respostas.

Os comentários definitivamente serão bem-vindos se alguém encontrar algo útil com eles - o como, o quê, o local da sua implementação.

    

Answer 8

Verifique este artigo. Aqui, as etapas detalhadas são mencionadas para habilitar o acesso à Internet a um virtualbox vm usando o encaminhamento de NAT.

link

    

Answer 9

aqui está como eu trabalhei para IPV6

ips estáticos atribuídos

/sbin/ifconfig eth1 inet6 add 2001:db8::1/127 
/sbin/ifconfig eth3 inet6 add 2001:db8::2/127 

configurar apenas rotas do host para endereços "FAKE"

ip -6 route add 2001:db8::2/128 dev eth1 metric 1
ip -6 route add 2001:db8::1/128 dev eth3 metric 1

preencheu a tabela do vizinho ... como o arp

ip -6 neighbor add 2001:db8::1 lladdr 90:e2:ba:0d:75:e8 dev eth3 # eth1's mac address
ip -6 neighbor add 2001:db8::2 lladdr 90:e2:ba:0d:75:e9 dev eth1 # eth3's mac address

adicionou as entradas do ip6tables

ip6tables -t nat -A POSTROUTING -s 2001:db8::1 -d 2013::2 -j SNAT --to-source 2001:db8::1
ip6tables -t nat -A PREROUTING -d 2001:db8::1 -j DNAT --to-destination 2001:db8::1
ip6tables -t nat -A POSTROUTING -s 2001:db8::2 -d 2013::1 -j SNAT --to-source 2001:db8::2
ip6tables -t nat -A PREROUTING -d 2001:db8::2 -j DNAT --to-destination 2001:db8::2