Como verificar quais portas estão abertas, com nmap

O nmap e o netstat são ferramentas tradicionais de monitoramento da rede no Linux e no UNIX.
O primeiro é comumente usado em filmes sobre hackers (ou crackers), por que tem uma “saída bonitinha” 😉
nmap list listening ports
Recentemente escrevi sobre como mudar a porta de escuta do servidor SSH, como medida bastante efetiva de segurança contra ataques. Neste caso, é útil saber quais portas estão em uso, para evitar conflitos entre serviços no seu sistema.
Neste contexto, o nmap e o netstat também podem ajudar a descobrir pontos vulneráveis do seu sistema.
Veja um exemplo de uso do nmap:


sudo nmap -sT -O localhost 

[sudo] senha para justincase:          

Starting Nmap 7.50 ( https://nmap.org ) at 2017-07-03 16:33 -03
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000092s latency).
Other addresses for localhost (not scanned): ::1
Not shown: 998 closed ports
PORT    STATE SERVICE
22/tcp  open  ssh
631/tcp open  ipp
Device type: general purpose
Running: Linux 3.X|4.X
OS CPE: cpe:/o:linux:linux_kernel:3 cpe:/o:linux:linux_kernel:4
OS details: Linux 3.8 - 4.9
Network Distance: 0 hops

OS detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 2.61 seconds

Destaquei, acima, o trecho em que se exibe as portas abertas (open). Aqui é mais adequado usar o comando grep, para filtrar e exibir apenas os números das portas abertas:


sudo nmap -sT -O localhost | grep -i open

22/tcp  open  ssh
631/tcp open  ipp

Entenda melhor o comando:

  • -sT — trata-se de uma opção inteira, como é possível ver no manual do comando (use ‘man nmap’, para ver mais).
    Esta opção manda o nmap fazer um rastreio da conexão TCP.
  • -O — faz a tentativa de detectar o sistema operacional sobre o qual está sendo pedida a varredura.
    A detecção permite habilitar testes específicos da plataforma analisada durante o processo.

Se acrescentarmos a opção -A, podemos obter detalhamentos da versão do sistema operacional e dos daemons:


sudo nmap -sT -O -A localhost | grep -i open

22/tcp  open  ssh     OpenSSH 7.5p1 Debian 5 (protocol 2.0)
631/tcp open  ipp     CUPS 2.2

Inclua as portas relacionadas ao protoclo UDP também:


sudo nmap -sT -sU localhost

Starting Nmap 7.50 ( https://nmap.org ) at 2017-07-03 17:26 -03
Nmap scan report for localhost (127.0.0.1)
Host is up (0.00017s latency).
Other addresses for localhost (not scanned): ::1
Not shown: 1994 closed ports
PORT     STATE         SERVICE
22/tcp   open          ssh
631/tcp  open          ipp
68/udp   open|filtered dhcpc
631/udp  open|filtered ipp
1900/udp open|filtered upnp
5353/udp open|filtered zeroconf

Nmap done: 1 IP address (1 host up) scanned in 2.81 seconds

Você pode combinar as opções do comando acima — com a obtenção do mesmo resultado – da seguinte forma:


sudo nmap -sTU localhost

Assinar blog por e-mail

Digite seu endereço de e-mail para assinar este blog e receber notificações de novas publicações por e-mail.

Projeto A3 — Software auto-reparável já é uma realidade.

Pesquisadores da Universidade de Utah têm trabalhado em projetos de softwares com capacidade de, não somente, se recuperar de danos causados por vírus, como também defender-se de futuros ataques vindos da mesma fonte.
eric-eide-1-selfrepairin
Os engenheiros desenvolveram softwares que são capazes de detectar e erradicar, até mesmo, vírus desconhecidos e outros tipos de malwares — e, automaticamente, reconstroem o sistema, reparando os danos.
Além disto, o software impede o invasor de infectar novamente o sistema.
O A3 é uma suite de aplicativos que trabalha com uma máquina virtual — projetado para vigiar seu sistema operacional e aplicativos.
A suite é projetada para proteger servidores ou computadores de porte similar, que rodam sistemas operacionais Linux.
Aplicações militares também são contempladas pelo projeto.
O nome A3 corresponde a Advanced Adaptive Applications — Aplicações Adaptáveis e Avançadas, em uma tradução livre.
Foi desenvolvido em conjunto com a Raytheon BBN, empresa do setor de defesa, sediada em Massachusetts —, por sua vez, fundada pela Clean-Slate Design of Resilient, Adaptive, Secure hosts, um programa da (famosa) agência DARPADefense Advanced Research Projects Agency.

“A ideia é usar a tecnologia de hypervisor e máquinas virtuais, como base para defender uma aplicação escolhida pelo usuário.
Se uma ameaça consegue penetrar a segurança e se for detectada, o ambiente A3 pode responder (1) tentando consertar a aplicação e sua VM, (2) reiniciando a aplicação a partir de um checkpoint e/ou (3) com o uso de um replay e da introspecção da VM, diagnosticar a ameaça a partir dos sintomas percebidos no sistema — uma vez compreendido o quadro geral, será possível implementar medidas defensivas e a readequação do sistema.”

O projeto foi concluído em Setembro/2014, após 4 anos de trabalhos — e não há planos de desenvolver versões para computadores domésticos ou laptops, embora isto seja possível no futuro.
De acordo com Eric Eide, professor assistente de ciência da computação da Universidade de Utah, as tecnologias A3 podem chegar aos produtos de consumo algum dia, o que poderá ajudá-los a proteger-se contra malwares ou corrupção interna de componentes de software — “Mas ainda não fizemos esta experiência”.
Em vez de realizar uma busca por vírus, comparando o alvo infeccioso com descrições em um catálogo, o A3 detecta vírus desconhecidos e código malicioso a partir da percepção de que algo não está funcionando bem no sistema.
Ele pode parar a ação do intruso e reparar os danos, além de aprender a nunca mais permitir que aquele malware entre e aja dentro da máquina novamente.
Uma vez que os militares têm interesse na cibersegurança proporcionada pelo A3, aplicada a seus sistemas de missão crítica, o A3 também poderia ser usado em dispositivos de consumidor final.
Serviços web, como o da Amazon, também são candidatos.
Se um vírus ou um ataque tentar derrubar o serviço, o A3 poderia pará-lo e consertar os danos, antes mesmo deles tirarem o serviço do ar.
O infame bug Shellshock foi usado para demonstrar a eficácia do software para oficiais da DARPA, em Jacksonsville, na Florida, ainda em Setembro deste ano.
O ataque do Shellshock foi detectado e parado em um dos servidores Web. Os danos foram reparados em 4 minutos.

Referências

Fonte: University of Utah. (2014, November 13). Self-repairing software tackles malware. ScienceDaily. Retrieved November 24, 2014 from www.sciencedaily.com/releases/2014/11/141113140011.htm.

Como obter estatísticas sobre o tempo de execução de comandos no Linux

Entre os comandos que todo administrador deveria dominar, o time é, com certeza, um deles.
Útil para obter valores sobre a performance do sistema e para monitorar alguns aspectos da execução de tarefas, o comando time retorna o tempo decorrido desde o início de uma atividade.
Veja como é fácil usá-lo.
tag heuer semi cronograph time cronômetro
Desenvolvedores também podem se beneficiar deste comando, para testar a performance de aplicativos ou scripts.

Como usar o comando time

A sintaxe do comando time é a seguinte:

time <comando> <parâmetros do comando>

É mais fácil entender com um exemplo prático.
Veja como determinar o tempo que o comando ‘ls -l’ leva para retornar a lista de arquivos dentro do seu diretório atual:

time ls -l

Depois de exibir a lista de arquivos, o time mostra a tempo de execução, conforme o exemplo abaixo (2 centésimos de segundo):

real   0m0.002s
user   0m0.000s
sys    0m0.000s

As três linhas se referem aos números referentes ao tempo total (em>real) gasto para rodar o comando ls, o tempo gasto dentro do user mode e o tempo dispendido dentro do kernel mode (sys).
Saiba mais sobre o que são kernel mode e user mode.

Um desenvolvedor preocupado com a performance, pode rodar diversas seu programa ou script, à medida em que faz modificações no código para torná-lo mais eficiente.

time vs /usr/bin/time

Você tem 2 comandos para usar:
time e
/usr/bin/time.
O primeiro, é um comando built-in, ou embutido, no Bash. O segundo, é um aplicativo GNU.
A versão embutida pode fornecer uma precisão de milisegundos, enquanto o programa externo oferece precisão de centésimos de segundos.
A versão Bash tem precisão maior por que usa a função getrusage(), enquanto a versão externa usa a função times().
Por outro lado a versão GNU, oferece mais opções de formatação da saída.

Diferentes shells têm diferentes implementações de comandos internos ou built in commands. Assim, você pode esperar diferentes comportamentos do time executado no zsh, no ksh etc.

Nossos exemplos, a seguir, se baseiam na versão externa (ou GNU), invocada através do comando /usr/bin/time.

Como direcionar a saída do comando para arquivos

Como comportamento padrão, a saída do time é colocada ao final da saída do comando que você executou com ele.
Para redirecionar a saída para um arquivo, veja o seguinte exemplo:

/usr/bin/time -o timelog.log sudo apt update

Para ver o resultado, use o comando cat:

cat timelog.log 
4.72user 0.43system 0:11.99elapsed 42%CPU (0avgtext+0avgdata 47476maxresident)k
14400inputs+557216outputs (8major+55843minor)pagefaults 0swaps

No exemplo acima, as estatísticas referentes ao comando “sudo apt update” são gravadas no arquivo “timelog.log”:
Repare que as opções dadas ao comando time, são feitas antes do comando que você deseja rodar.
Para não apagar os dados anteriores, contidos no arquivo, use a opção ‘append’. Com esta opção, o time acrescenta a nova saída ao arquivo, em vez de sobrepor todo o conteúdo anterior:

/usr/bin/time -a -o timelog.log sudo apt update
cat timelog.log

O resultado, abaixo, se refere a 4 execuções do comando acima:

0.78user 0.06system 0:02.76elapsed 30%CPU (0avgtext+0avgdata 43964maxresident)k
0inputs+155440outputs (0major+37247minor)pagefaults 0swaps
0.79user 0.05system 0:01.14elapsed 74%CPU (0avgtext+0avgdata 44888maxresident)k
0inputs+155408outputs (0major+37269minor)pagefaults 0swaps
0.85user 0.06system 0:01.23elapsed 74%CPU (0avgtext+0avgdata 44252maxresident)k
0inputs+155248outputs (0major+37174minor)pagefaults 0swaps
0.82user 0.06system 0:01.19elapsed 74%CPU (0avgtext+0avgdata 45080maxresident)k
0inputs+155248outputs (0major+37239minor)pagefaults 0swaps

Desta forma, é possível comparar as estatísticas de várias execuções, dentro do mesmo arquivo.

Opções de formatação da saída do comando time

Como você já sabe, ao final da execução o time (Bash built-in) exibe uma saída padrão de dados assim:

real    0m3.789s
user    0m0.912s
sys     0m0.076s

ou assim (GNU):

0.00user 0.00system 0:00.00elapsed ?%CPU (0avgtext+0avgdata 2352maxresident)k
0inputs+0outputs (0major+110minor)pagefaults 0swaps

Neste tópico, vamos ver como melhorar isto.
Você pode usar uma série de opções para alterar a formatação e adequar a apresentação dos dados estatísticos às suas necessidades. Veja uma lista:

  • C — Argumentos usados de nome e linha de comando
  • D — Tamanho médio da área de dados não-compartilhada do processo (em KiB)
  • E — Tempo decorrido no formato de relógio
  • F — Número de page faults (falhas de página)
  • I — Número de entradas no sistema de arquivos feitas pelo processo
  • K — Média geral da memória usada pelo processo em KiB
  • M — Tamanho máximo do resident set do processo durante seu tempo de vida, em KiB.
  • O — Número de saídas geradas pelo processo
  • P — Percentual da CPU que o trabalho (ou job) recebeu
  • R — Número de page faults menores ou recuperáveis
  • S — Total de segundos da CPU usados pelo sistema no kernel mode
  • U — Total de segundos da CPU usados pelo sistema no user mode
  • W — Número de vezes em que o processo foi varrido da memória principal
  • X — Quantidade média de texto compartilhado no processo
  • Z — Tamanho da página do sistema em KiB
  • c — Quantidade de vezes em que processo foi alternado, baseado em contexto
  • e — Tempo real decorrido relacionado ao processo, em segundos
  • k — Número de sinais entregues ao processo
  • p — Tamanho médio do stack não compartilhado do processo em KiB
  • r — Número de mensagens socket recebidas pelo processo
  • s — Número de mensagens socket enviadas pelo processo
  • t — Tamanho médio do resident set do processo em KiB
  • w — Número de vezes em que o processo sofreu alternâncias no modo de execução voluntariamente
  • x — Status de saída do comando.
  • Veja alguns exemplos da formatação da saída do comando, a seguir.

    /usr/bin/time -f "\nResultado do time:\nTempo decorrido = %E, Entradas %I, Saídas %O" apt search weston
    

    Veja como ficou, nas 2 últimas linhas da saída abaixo:

    Sorting... Pronto
    Full Text Search... Pronto
    weston/testing 1.11.0-1 amd64
      reference implementation of a wayland compositor
    
    
    Resultado do time:
    Tempo decorrido = 0:00.77, Entradas 0, Saídas 0
    

    Altere o código, acima, usando outras opções da tabela anterior.
    Para inserir novas linhas e deixar o visual mais fácil de entender, use ‘\n’.

    Referências

    http://linux.about.com/od/commands/a/Example-Uses-Of-The-Command-Time.htm.

Use o systemd para determinar o tempo que sua máquina leva para dar boot.

Há várias formas de medir o tempo que a sua máquina leva para dar o boot.
Apertar o botão POWER, ao mesmo tempo em que se dispara um cronômetro externo, é uma das formas.
Mas, se você usa um sistema com o systemd, pode usar outra alternativa mais cômoda — que permite obter o tempo decorrido desde o boot, até a tela de login do ambiente gráfico, sem precisar desligar e ligar o computador.
Há outros métodos, claro, mas a gente vai abordar apenas este, aqui.
O systemd.services vem com o comando systemd-analyze que, entre outras coisas, serve para mostrar o tempo exato que o seu sistema levou (em segundos) para ficar pronto para uso. Veja um exemplo de uso:

systemd-analyze 

Segundo o resultado, abaixo, deu 16 segundos (e alguns quebrados):

Startup finished in 3.020s (kernel) + 13.080s (userspace) = 16.101s

Entenda como funciona o systemd-analyze

O systemd-analyze pode ser usado para determinar o desempenho de arranque do sistema, obter estatísticas, analisar problemas e descobrir possíveis gargalos no processo.
O comando ‘systemd-analyze time’ mostra os seguintes dados:

  1. o tempo dispendido no kernel antes de chegar ao userspace
  2. o tempo dispendido no espaço do RAM disk (initrd), antes de alcançar o userspace normal
  3. o tempo que o userspace, em si, levou para ser inicializado

Note que estas medidas levam apenas em conta o tempo passado até o momento em que todos os system services forem gerados — e não necessariamente até que eles tenham finalizado completamente.
Você pode obter uma imagem gráfica vetorial detalhada do processo todo, com o uso da opção plot.
Veja como:

systemd-analyze plot > meuboot.svg

Você pode usar o GIMP ou qualquer outro visualizador de imagens para ver este conteúdo. No exemplo abaixo, uso o eye of gnome:

eog meuboot.svg

systemd-analyze plot
A imagem pode ajudar a entender melhor quais processos tomam mais tempo da inicialização no seu computador.

Acesse múltiplos terminais do seu sistema com o Tmux

Administradores de sistemas usam os terminais para realizar a maior parte de suas tarefas — ou, pelo menos aquelas sobre as quais precisam ter mais controle ou, ainda, executar com um nível maior de flexibilidade.
Para isto, é comum abrir mais de um terminal no sistema.
Quando se realiza várias atividades simultâneas de monitoramento, também é comum abrir um terminal para cada.
Em um ambiente gráfico, é possível alternar entre uma janela e outra com ‘Alt + Tab’.
Neste artigo, vamos falar do tmux — abreviatura para terminal multiplexer — um aplicativo simples, que permite controlar uma variedade de terminais a partir de uma só janela.

Um multiplexador de terminal ou terminal multiplexer permite alternar entre vários programas que estejam rodando, dentro de um único terminal.

O tmux permite alternar os programas entre o foreground e o background, além de retribuí-los a outros terminais.

Como instalar o tmux

Embora o processo de instalação varie muito pouco, nos dias atuais, entre uma distro e outra, vale ressaltar que escrevo este texto baseado no Debian 8.3 “Jessie”.
Você só precisa adaptar o comando de instalação à sua própria distribuição GNU/linux.

Se você usa os backports no Debian, dá para encontrar uma versão mais atualizada do aplicativo neste repositório. Observe o exemplo abaixo:

/* Versão disponível nos backports do Debian: */
aptitude -t jessie-backports show tmux | grep -i vers
Versão: 2.1-3~bpo8+1
/* Versão disponível no repositório padrão */
aptitude show tmux | grep -i vers
Versão: 1.9-6

Se você sabe lidar com o repositório dos backports no Debian (que não é difícil), com certeza não precisa da minha ajuda para instalar este software — neste caso, pule esta seção.

Não havendo um motivo muito forte para fazer o contrário, na minha máquina de trabalho, sempre uso o repositório padrão para instalar softwares:

sudo aptitude update
sudo aptitude install tmux

No Ubuntu, você provavelmente vai preferir usar o apt-get:

sudo apt-get update
sudo apt-get install tmux

Distribuições como o CentOS, RHEL e Fedora também devem ter o aplicativo nos seus repositórios básicos:

yum update
yum install tmux

Como funciona o tmux

A função do tmux é tornar possível a criação, o acesso e o controle de múltiplos terminais dentro de uma única tela.
Ao ser iniciado, o aplicativo cria uma nova sessão em uma janela, exibida na tela.
Uma linha de status, na parte inferior da janela de sessão do tmux, mostra informações concernentes à sessão atual. Pode também ser usada para fornecer comandos ao aplicativo.
Uma sessão é uma coleção de pseudo terminais sob a gestão do tmux.
Cada sessão tem uma ou mais janelas ligadas a ela.

Uma sessão é um contêiner para os consoles individuais gerenciados pelos tmux.

Uma janela ocupa uma tela inteira e pode ser dividida em painéis retangulares.
Cada painel representa um emulador de terminal.
Qualquer instância do tmux pode se conectar à mesma sessão e qualquer número de janelas pode estar presente na mesma sessão.
O tmux termina sua execução após a finalização da última sessão.

Cada sessão do tmux é persistente o suficiente para sobreviver a desconexões acidentais — como um timeout do ssh ou um desacoplamento intencional.

Para reacoplar use o seguinte comando:

tmux attach

Uma sessão é exibida na tela por um cliente e todas elas são gerenciadas por um único servidor. Este, cada cliente e todas as sessões pertencem a processos separados que se comunicam através de um soquete no diretório /tmp

Como usar o tmux

Para iniciar uma nova sessão chamada ‘mon’, digite:

tmux new -s mon

tmux new session
O nome da nova sessão é exibido no canto inferior esquerdo da janela.
Ações possíveis nesta sessão:

  • dividir o terminal em quantos painéis você quiser.
    Use Ctrl + b + ” para abrir um novo espaço horizontalmente e Ctrl + b + % para abrir um espaço verticalmente — você provavelmente irá ter que usar a tecla Shift para conseguir estas combinações de teclas.
    Cada painel representará um console em separado.
  • Ctrl + b + →↓↑← — use a combinação com as teclas direcionais para se movimentar entre os painéis.
  • Se você usar a mesma combinação de teclas, anterior, pode alterar o tamanho do painel ativo. Para isto, é necessário manter pressionada a tecla direcional, na direção que você deseja arrastar o quadro do painel.
  • Ctrl + b + t — para mostrar a hora atual dentro do painel ativo.
  • Ctrl + b + x — fecha o painel ativo. O tmux vai pedir confirmação antes de executar esta operação.
  • Ctrl + b + d — desacopla o painel ativo da sessão atual do tmux — ele volta a ser um terminal comum, dentro de uma janela comum.

No tmux, a combinação de teclas para realizar ações são chamadas de key bindings.
Se você sente que as key bindings padrão são inconvenientes para o seu uso, é possível alterá-las no arquivo .tmux.conf que pode ser encontrado dentro do /home de cada usuário.
Para fazer alterações que abranjam todo o sistema, edite o arquivo /etc/tmux.conf — se ele não existir, você vai ter que criá-lo. Para isto, use o primeiro como exemplo.
Havendo os dois arquivos de configuração, o tmux prioriza o de cada usuário.
Na documentação do programa, é possível encontrar mais informações sobre este e outros procedimentos — além de uma relação completa de teclas de atalho ou key bindings.