Como capturar o tráfego de rede de um único processo?

Gostaria de examinar o tráfego de rede sendo manipulado por um único processo, mas as capturas simples de rede não funcionarão, pois estou lidando com um sistema tão ocupado (muitos outros tráfegos acontecendo ao mesmo tempo). Existe uma maneira de isolar tcpdumpou wiresharkcapturar o tráfego de rede de um único processo específico? (O uso netstaté insuficiente.)

De fato, existe uma maneira de usar os filtros Wireshark . Mas você não pode filtrar diretamente pelo nome do processo ou PID (porque não são quantidades de rede).

Você deve primeiro descobrir os protocolos e as portas usadas pelo seu processo (o comando netstat no comentário anterior funciona bem).

Em seguida, use o Wireshark para filtrar a porta de entrada (ou saída) com a que você acabou de recuperar. Isso deve isolar o tráfego de entrada e saída do seu processo.

Para iniciar e monitorar um novo processo:

strace -f -e trace=network -s 10000 PROCESS ARGUMENTS

Para monitorar um processo existente com um PID conhecido:

strace -p $PID -f -e trace=network -s 10000

• -f é para "seguir novos processos"
• -e define um filtro
• -s define o limite de strings para mais de 32
• -p leva a identificação do processo para anexar

Eu sei que este tópico é um pouco antigo, mas acho que isso pode ajudar alguns de vocês:

Se o seu kernel permitir, capturar o tráfego de rede de um único processo é muito fácil, executando o referido processo em um namespace de rede isolado e usando o wireshark (ou outras ferramentas de rede padrão) no referido namespace.

A configuração pode parecer um pouco complexa, mas depois que você a entender e se familiarizar com ela, facilitará muito o seu trabalho.

Para fazer isso:

• crie um espaço para nome da rede de teste:

  ip netns add test
  

• crie um par de interfaces de rede virtual (veth-a e veth-b):

  ip link add veth-a type veth peer name veth-b
  

• altere o espaço para nome ativo da interface veth-a:

  ip link set veth-a netns test
  

• configure os endereços IP das interfaces virtuais:

  ip netns exec test ifconfig veth-a up 192.168.163.1 netmask 255.255.255.0
  ifconfig veth-b up 192.168.163.254 netmask 255.255.255.0
  

• configure o roteamento no namespace de teste:

  ip netns exec test route add default gw 192.168.163.254 dev veth-a
  

• ative o ip_forward e estabeleça uma regra NAT para encaminhar o tráfego proveniente do namespace que você criou (você deve ajustar a interface de rede e o endereço IP do SNAT):

  echo 1 > /proc/sys/net/ipv4/ip_forward
  iptables -t nat -A POSTROUTING -s 192.168.163.0/24 -o <your internet interface, e.g. eth0> -j SNAT --to-source <your ip address>
  

  (Você também pode usar a regra MASQUERADE, se preferir)

• finalmente, você pode executar o processo que deseja analisar no novo espaço para nome e o wireshark também:

  ip netns exec test thebinarytotest
  ip netns exec test wireshark
  

  Você terá que monitorar a interface veth-a.

netstat -taucp | grep <pid or process name>

Isso mostrará as conexões que um aplicativo está fazendo, incluindo a porta que está sendo usada.

Apenas uma idéia: é possível vincular seu aplicativo a um endereço IP diferente? Nesse caso, você pode usar os suspeitos do costume ( tcpdump , etc.)

Ferramentas para aplicativos que não são capazes de se vincular a outro endereço IP:

http://freshmeat.net/projects/fixsrcip

fixsrcipé uma ferramenta para vincular soquetes de cliente TCP e UDP ( IPv4 ) de saída a endereços IP de origem específicos em hosts com várias residências

http://freshmeat.net/projects/force_bind

force_bindpermite forçar a ligação em um IP e / ou porta específicos. Funciona com IPv4 e IPv6 .

Cheguei a um problema semelhante e consegui resolvê- lo com base nesta resposta, ioerror , usando o NFLOG, conforme descrito aqui :

# iptables -A OUTPUT -m owner --uid-owner 1000 -j CONNMARK --set-mark 1
# iptables -A INPUT -m connmark --mark 1 -j NFLOG --nflog-group 30 
# iptables -A OUTPUT -m connmark --mark 1 -j NFLOG --nflog-group 30 
# dumpcap -i nflog:30 -w uid-1000.pcap

Em seguida, você pode criar o processo em questão a partir de uma conta de usuário que não faz mais nada - e pronto, você acabou de isolar e capturar o tráfego de um único processo.

Só queria postar de volta, caso isso ajude alguém.

Eu escrevi um aplicativo C que faz o que é descrito na grande resposta acima por felahdab!

Veja aqui: nsntrace github repo

Este é um hack sujo, mas eu sugeriria um desvio ou um destino de log com iptables para um determinado UID. por exemplo:

iptables -t nat -A OUTPUT -p tcp -m owner --uid-owner $USER -m tcp -j LOG 
iptables -t nat -A OUTPUT -p udp -m owner --uid-owner $USER -m udp -j LOG 

Também pode valer a pena procurar algo como '--log-tcp-sequence', '--log-tcp-options', '--log-ip-options', '--log-uid' para esse destino de log . Embora eu suspeite que isso só o ajude a postar um pcap de processo que inclui muitos outros dados.

O destino NFLOG pode ser útil se você deseja sinalizar pacotes e, em seguida, determinados pacotes marcados serão enviados por um soquete de netlink para um processo de sua escolha. Gostaria de saber se isso seria útil para hackear algo com o wireshark e seu aplicativo específico sendo executado como um usuário específico?

Você pode tentar o tracedump - http://mutrics.iitis.pl/tracedump

Ele faz exatamente o que você deseja. Você pode fornecer um ID do processo ou um programa para executar.

Tente executar o processo que você está interessado sob strace :

strace ping www.askubuntu.com

Ele fornecerá informações muito detalhadas sobre o que seu processo está fazendo. Como um processo pode abrir as portas que ele deseja em qualquer lugar, usando um filtro predefinido, você pode perder alguma coisa.

Outra abordagem seria usar uma máquina virtual simplificada ou uma máquina de teste em sua rede e colocar seu processo nela isoladamente. Então você pode simplesmente usar o Wireshark para capturar tudo dessa máquina. Você terá certeza de que o tráfego capturado será relevante.

Com base na resposta do ioerror , suspeito que você possa usar iptables --uid-ownerpara definir um marcador no tráfego e pedir ao wireshark para capturar apenas o tráfego com esse marcador. Você pode usar um DSCP (marcador de serviços diferenciais), ID de fluxo ou um marcador de qos.

Ou, de fato, você pode usar isso para enviar esses pacotes para uma interface diferente e capturar apenas nessa interface.

O wireshark bug # 1184 é esse recurso. Ainda não está implementado.
Copiado do usuário cmanynard em ask.wireshark.org

talvez iptables e ulog podem funcionar? Não que eu tenha uma receita exata, mas acho que o iptables pode corresponder aos processos, uma vez que você corresponda, você pode usar ulog.

Eu acho que você pode criar um script de shell para executar o netstat e registrá-lo em um arquivo de texto. Algo como (etapas muito difíceis):

echo "press q to quit"
while [ <q is not pressed>]
do
    `netstat -taucp | grep <pid or process name> 1>>logfile.txt`
done

Eu não sou um programador, então não posso refinar isso. Mas alguém aqui pode começar de onde eu parei e criar um script de trabalho para você.