Bloqueia o acesso à rede de um processo?

Question

É possível bloquear o acesso à rede (de saída) de um único processo?

    

Answer 1

Com o Linux 2.6.24+ (considerado experimental até 2.6.29), você pode usar namespaces de rede para isso. Você precisa ter os 'namespaces de rede' habilitados em seu kernel ( CONFIG_NET_NS=y ) e util-linux com o unshare ferramenta.

Em seguida, iniciar um processo sem acesso à rede é tão simples quanto:

unshare -n program ...

Isso cria um namespace de rede vazio para o processo. Ou seja, ele é executado sem interfaces de rede, incluindo sem loopback . No exemplo abaixo, adicionamos -r para executar o programa somente depois que os IDs de usuário e grupo efetivos atuais tiverem sido mapeados para os superusuários (evite sudo):

$ unshare -r -n ping 127.0.0.1
connect: Network is unreachable

Se o seu aplicativo precisar de uma interface de rede, você poderá configurar um novo:

$ unshare -n -- sh -c 'ip link set dev lo up; ping 127.0.0.1'
PING 127.0.0.1 (127.0.0.1) 56(84) bytes of data.
64 bytes from 127.0.0.1: icmp_seq=1 ttl=32 time=0.066 ms

Observe que isso criará um novo loopback local . Ou seja, o processo gerado não poderá acessar as portas abertas do 127.0.0.1 do host.

Se você precisar de acesso à rede original dentro do namespace, use nsenter para entrar no outro espaço de nomes.

O exemplo a seguir executa ping com o namespace de rede usado pelo PID 1 (é especificado por meio de -t 1 ):

$ nsenter -n -t 1 -- ping -c4 example.com
PING example.com (93.184.216.119) 56(84) bytes of data.
64 bytes from 93.184.216.119: icmp_seq=1 ttl=50 time=134 ms
64 bytes from 93.184.216.119: icmp_seq=2 ttl=50 time=134 ms
64 bytes from 93.184.216.119: icmp_seq=3 ttl=50 time=134 ms
64 bytes from 93.184.216.119: icmp_seq=4 ttl=50 time=139 ms

--- example.com ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3004ms
rtt min/avg/max/mdev = 134.621/136.028/139.848/2.252 ms

    

Answer 2

O Linux tem um recurso chamado namespaces de rede que permitem que você tenha essencialmente várias pilhas de rede na mesma máquina e atribua uma para um programa ao executá-lo. Esse é um recurso normalmente usado para contêineres, mas você também pode usá-lo para realizar o que deseja.

Os subcomandos ip netns o gerenciam. Criar um novo namespace de rede sem acesso a nada é fácil, é o estado padrão de um novo namespace:

root@host:~# ip netns add jail

Agora, se você entrar nesse namespace, poderá configurá-lo com bastante facilidade. Você provavelmente vai querer falar sobre isso, e é isso:

root@host:~# ip netns exec jail /bin/bash
root@host:~# ip addr add 127.0.0.1/8 dev lo
root@host:~# ip link set dev lo up
root@host:~# exit

Agora, quando você quiser executar seu comando sem rede, basta executá-lo nessa cadeia:

root@host:~# ip netns exec jail su user -c 'ping  8.8.8.8'
connect: Network is unreachable

A rede é, conforme desejado, inacessível. (Você pode fazer todo tipo de coisas interessantes, pois uma pilha de rede separada inclui iptables , etc.)

    

Answer 3

Sim, com perfil apparmor personalizado, por exemplo

/usr/bin/curl {
    ...

    # block ipv4 acces
    deny network inet,
    # ipv6 
    deny network inet6,
    # raw socket
    deny network raw,

}

Mas, dessa forma, você precisará gerar uma lista de arquivos permitidos para acessar também, todo o procedimento pode ser um pouco complicado. E consulte o documento de ajuda aqui

    

Answer 4

Você pode usar o iptables e mover esse processo para um cgroup:

mkdir /sys/fs/cgroup/net_cls/block
echo 42 > /sys/fs/cgroup/net_cls/block/net_cls.classid

iptables -A OUTPUT -m cgroup --cgroup 42 -j DROP

echo [pid] > /sys/fs/cgroup/net_cls/block/tasks

    

Answer 5

Você não pode fazer isso apenas com o iptables. Esse recurso existia brevemente , mas não podia ser feito para funcionar de maneira confiável e foi abandonado.

Se você puder executar o processo como um ID de usuário dedicado, o iptables poderá fazê-lo com o módulo owner :

iptables -A OUTPUT -m owner --uid-owner 1234 -j DROP

Veja exemplos em Iptables: correspondência de tráfego de saída com conntrack e proprietário. Funciona com gotas estranhas , iptables / pf regra para permitir somente o aplicativo / usuário XY?

Se você puder executar o processo em seu próprio contêiner, será possível firewallá-lo independentemente (até mesmo desconectá-lo completamente da rede).

Um módulo de segurança pode filtrar o acesso de um processo a recursos de rede. A resposta de warl0ck dá um exemplo com o AppArmor.

    

Answer 6

Você pode usar sandbox firejail (deve funcionar em kernels com o recurso seccomp).

Para usá-lo, basta fazer

firejail --noprofile --net=none <path to executable>

--noprofile desativa a sandbox padrão --net=none desativa a rede

Eu acredito que a maioria das distros já oferece pacotes, mas mesmo que eles não possuam o firejail, virtualmente não há dependências além de construir o conjunto de ferramentas e o kernel habilitado para namespace / seccomp.

Existem alguns outros recursos interessantes do firejail que podem ser mostrados com firejail --help com relação à rede (como fornecer apenas interface de loopback ou bloquear ip / dns etc), mas isso deve fazer o trabalho. Além disso, é doesn't require root .

    

Answer 7

Depende de qual distro você está usando, mas esse é um recurso normalmente incluído no sistema MAC do sistema operacional. Como dito anteriormente, o Ubuntu ou o AppArmor da SuSE podem fazer isso. Se você estiver usando o RHEL, poderá configurar o SELinux para permitir ou negar acesso a um número de porta específico com base no rótulo do processo em execução. Isso é tudo o que eu consegui encontrar depois de um rápido googling, mas provavelmente há recursos mais profundos on-line se você olhar mais difícil e dá-lhe a ideia geral.

    

Answer 8

Você pode usar o seccomp-bpf para bloquear algumas chamadas do sistema. Por exemplo, pode querer bloquear a chamada do sistema socket para evitar o processo de criar soquetes FD.

Eu escrevi um exemplo deste approcah que impede que o socket chamada de sistema para trabalhar usando o libseccomp. O resumo é (sem verificação de erros):

scmp_filter_ctx ctx = seccomp_init(SCMP_ACT_ALLOW);
seccomp_arch_add(ctx, SCMP_ARCH_NATIVE);
seccomp_rule_add(ctx, SCMP_ACT_ERRNO(EACCES), SCMP_SYS(socket), 1, SCMP_CMP(0, SCMP_CMP_EQ, pf));
seccomp_load(ctx);
execvp(argv[1], argv+1);

Isso não precisa de privilégios de root.

No entanto, um sandbox completo é muito mais complexo, portanto, você não deve usar esse un order para bloquear programas não cooperativos / maliciosos.

    

Answer 9

Solução 1: Firewall:

Poderíamos usar firewalls como Douane ou Opensnitch MAS essas aplicações não são 100% eficientes ou estão em estágio inicial de desenvolvimento (possuem muitos bugs etc.)

Solução 2: Kernel MAC:

Kernel MACs podem ser usados como firewalls mais conhecidos são Tomoyo , Selinux e Apparmor Esta solução é a melhor quando se trata de estabilidade e eficiência, mas na maioria das vezes não há configuração confiável de gui plus de alguma forma complicada.

Solução 3: Proxify:

Uma solução é a proxificação do aplicativo para um proxy null / fake . Podemos usar tsocks ou proxies . Aqui estão alguns detalhes sobre a configuração

Solução 4: Iptables:

Tão fácil quanto a solução 3 iptables podem ser configurados para bloquear um aplicativo

1. Crie, valide novo grupo ; adicionar usuários necessários a este grupo:
   • Criar: groupadd no-internet
   • Validar: grep no-internet /etc/group
   • Adicionar usuário: useradd -g no-internet username
     
     Observação: Se você estiver modificando um usuário já existente, deverá executar: usermod -a -G no-internet userName verifique com: sudo groups userName
     
     
2. Crie um script em seu caminho e torne-o executável:
   • Criar: nano /home/username/.local/bin/no-internet
   • Executável: chmod 755 /home/username/.local/bin/no-internet
   • Conteúdo: #!/bin/bash
     %código%
     
     
3. Adicione regra iptables para eliminar a atividade de rede do grupo no-internet :
   • sg no-internet "$@"
     
     Observação: não se esqueça de tornar as alterações permanentes, então seria aplicado automaticamente após a reinicialização . Fazê-lo depende da sua distribuição Linux.

4. Verifique, por exemplo, no Firefox executando:

• iptables -I OUTPUT 1 -m owner --gid-owner no-internet -j DROP

5. No caso de você querer fazer uma exceção e permitir que um programa acesse rede local :

• no-internet "firefox"
• iptables -A OUTPUT -m owner --gid-owner no-internet -d 192.168.1.0/24 -j ACCEPT
• iptables -A OUTPUT -m owner --gid-owner no-internet -d 127.0.0.0/8 -j ACCEPT

6. Torne-o permanente

Uma maneira de aplicar a regra iptables na inicialização é adicionar a regra como um serviço com o systemd

cat /usr/lib/systemd/system/nonet.service
[Unit]
Description=Nonet group iptable update
After=network.target
After=xsession.target
After=iptables.service
After=shorewall.service

[Service]
Type=oneshot
RemainAfterExit=true
StandardOutput=journal
ExecStart=/bin/bash /home/user/Scripts/Nonet.iptables.sh

    

Answer 10

Você pode usar um programa de linha de comando chamado "proxychains" e tentar uma das seguintes possibilidades:

Configure o que ele usa ...

• ... um proxy que não existe? (Eu não sei se ele será executado com um proxy "inválido")
• ... um proxy local (como "tinyproxy", "squid", "privoxy", ...) que limita o acesso à internet? (Apenas use ACLs)

Eu mesmo não testei, então não sei se funciona ...