Kali Linux Revealed 1st Edition Páginas 201 341 Páginas 81 141.en - PT

10,2.
Aproveitando o gerenciamento de configuração
Com a capacidade de instalar o Kali em vários computadores muito rapidamente, você precisará de alguma ajuda no gerenciamento dessas máquinas
após a instalação. Você pode aproveitar as ferramentas de gerenciamento de configuração para gerenciar máquinas ou configurar computadores
substitutos para qualquer estado desejado.
Kali Linux contém muitas ferramentas populares de gerenciamento de configuração que você pode querer usar ( ansible, chef, fantoche,
saltstack, etc.), mas nesta seção, abordaremos apenas SaltStack.
è https://saltstack.com
10.2.1. Configurando SaltStack
SaltStack é um serviço de gerenciamento de configuração centralizado: a mestre de sal gerencia muitos minions de sal. Você deve instalar o
mestre do sal pacote em um servidor que pode ser alcançado por todos os hosts que você deseja gerenciar e sal-minion nos hosts que você
deseja gerenciar. Cada lacaio deve ser informado de onde encontrar seu mestre. Simplesmente edite / etc / salt / minion e definir o mestre chave
para o nome DNS (ou endereço IP) do mestre Salt. Observe que o Salt usa YAML como formato para seus arquivos de configuração.
servo # vim / etc / salt / minion

servo # grep ^ m̂aster / etc / salt / minion
mestre: 192.168.122.105
Cada lacaio tem um identificador único armazenado em / etc / salt / minion_id, cujo padrão é seu nome de host. Este identificador
de lacaio será usado nas regras de configuração e, como tal, é importante defini-lo corretamente antes que o lacaio abra sua
conexão com o mestre:
servo # echo kali-scratch> / etc / salt / minion_id

servo # systemctl ativar salt-minion
servo # systemctl start salt-minion
Quando o sal-minion serviço estiver em execução, ele tentará se conectar ao mestre do Salt para trocar algumas chaves
criptográficas. No lado mestre, você tem que aceitar a chave que o lacaio está usando para se identificar e permitir que a conexão
prossiga. As conexões subsequentes serão automáticas:
mestre# systemctl enable salt-master

mestre# systemctl start salt-master
mestre# salt-key - listar todos
Chaves aceitas:
Chaves negadas:
Chaves não aceitas:
kali-scratch
Chaves rejeitadas:
mestre# salt-key --aceite kali-scratch
As seguintes chaves serão aceitas:
Capítulo 10 - Kali Linux na empresa 255

kali-scratch
Continuar? [Nova Iorque] y
Aceita-se a chave para arranhões Kali lacaios.
10.2.2. Executando comandos em lacaios
Assim que os lacaios estiverem conectados, você pode executar comandos sobre eles a partir do mestre:
mestre# salt '*' test.ping

kali-scratch:
Verdadeiro
mestre kali:
Verdadeiro
Este comando pergunta a todos os lacaios (o '*' é um curinga direcionado a todos os lacaios) para executar o ping
função do teste módulo de execução. Esta função retorna um Verdadeiro valor no sucesso e é uma maneira simples de
garantir que a conexão entre o mestre e os vários lacaios está funcionando.
Você também pode mirar em um lacaio específico fornecendo seu identificador no primeiro parâmetro, ou possivelmente um
subconjunto de lacaios usando um curinga menos genérico (como '* -scratch' ou 'kali- *'). Aqui está um exemplo de como executar um
comando de shell arbitrário no minion kali-scratch:
mestre# salt kali-scratch cmd.shell 'uptime; uname -a '

kali-scratch:
05:25:48 até 44 min, 2 usuários, média de carregamento: 0,00, 0,01, 0,05
Linux kali-scratch 4.5.0-kali1-amd64 # 1 SMP Debian 4.5.3-2kali1 (2016-05-09) x86_64
uma GNU / Linux
Referência do módulo de sal Existem muitos módulos de execução disponíveis para todos os tipos de casos de uso. Não cobriremos todos
aqui, mas a lista completa está disponível em https://docs.saltstack.com/ en / mais recente / ref / modules / all / index.html . Você
também pode obter uma descrição de todos os módulos de execução e suas funções disponíveis em um
determinado lacaio com o sal
lacaio sys.doc comando. A execução desse comando retorna uma lista muito longa de funções, mas você pode
filtrar a lista passando o nome de uma função ou módulo prefixado por seu módulo pai como um parâmetro:
mestre# salt kali-scratch sys.doc disk.usage

Uso de disco:
Retornar informações de uso para volumes montados neste

uma lacaio
Um dos módulos mais úteis é pacote, que é uma abstração do gerenciador de pacotes que depende do gerenciador de pacotes
apropriado para o sistema ( apt-get para o Debian e seus derivados, como Kali).
256 Kali Linux revelado

o pkg.refresh_db comando atualiza a lista de pacotes (isto é, ele executa apt-get update)
enquanto pkg.upgrade instala todas as atualizações disponíveis (executa apt-get upgrade ou apt-get dist-upgrade, dependendo
das opções recebidas). o pkg.list_upgrades comando lista as operações de atualização pendentes (que seriam realizadas
pelo pkg.upgrade dist_upgrade = True
comando).
o serviço módulo é uma abstração do gerenciador de serviços ( systemd no caso de Kali), o que permite
você executa tudo o de costume systemctl operações: service.enable, service.disable, service. start, service.stop, service.restart, e service.reload:
mestre# salt '*' service.enable ssh

kali-scratch:
Verdadeiro
mestre kali:
Verdadeiro
mestre# salt '*' service.start ssh

mestre kali:
Verdadeiro
kali-scratch:
Verdadeiro
mestre# salt '*' pkg.refresh_db

kali-scratch:
----------
mestre kali:
----------
mestre# salt '*' pkg.upgrade dist_upgrade = True
kali-scratch:
----------
alterar:
----------
arquivos-base:
----------
Novo:
1: 2016.2.1
velho:
1: 2016.2.0
[...]
zaproxy:
----------
Novo:
2.5.0-0kali1
velho:
2.4.3-0kali3
Comente:
resultado:
Verdadeiro

Como um exemplo mais concreto, você poderia facilmente configurar um Nmap digitalizar com dnmap. Depois de instalar o pacote em
todos os minions, você inicia o servidor em um primeiro terminal:
servidor# salt '*' pkg.install dnmap

[...]
servidor# vim dnmap.txt
servidor# dnmap_server -f dnmap.txt
Supondo que o IP do servidor seja 1.2.3.4, você pode dizer a todos os lacaios para iniciar um processo cliente que se conecta ao servidor:
servidor# salt '*' cmd.run_bg template = jinja 'dnmap_client -s 1.2.3.4 -a {{grains.id}}'

kali-scratch:
----------
pid:
17137
[...]
Observe que o exemplo usa cmd.run_bg para executar o dnmap_client comando em segundo plano. Não espere até que termine, pois
é um processo de longa duração. Infelizmente, ele não se mata adequadamente quando você interrompe o servidor, portanto, talvez
seja necessário limpá-lo:
servidor# salt '*' cmd.shell 'pkill -f dnmap_client'
10.2.3. Salt States e outros recursos
Embora a execução remota seja um bloco de construção importante, é apenas uma pequena fração do que o SaltStack pode fazer.
Ao configurar uma nova máquina, você geralmente executa muitos comandos e testes para determinar os detalhes do sistema antes da
instalação. Essas operações podem ser formalizadas em modelos de configuração reutilizáveis chamados arquivos de estado. As
operações descritas nos arquivos de estado podem ser realizadas com um único state.apply comando salt.
Para economizar tempo, você pode contar com muitos arquivos de estado prontos para uso que foram criados pela comunidade e que
são distribuídos em “fórmulas do Salt”:
è https://docs.saltstack.com/en/latest/topics/development/conventions/formulas. html
Existem muitos outros recursos que podem ser combinados:
• Execução programada de ações
• Definir ações em resposta a eventos desencadeados por lacaios
• Coleta de dados de lacaios

• Orquestração de uma sequência de operações em vários lacaios
• Aplicação de estados sobre SSH sem instalar o serviço de salt-minion
• Provisionar sistemas em infraestruturas de nuvem e colocá-los sob gerenciamento
• E mais
O SaltStack é muito vasto e não podemos cobrir todos os recursos aqui. Na verdade, existem livros dedicados
inteiramente ao SaltStack e a documentação online também é muito extensa. Confira se quiser saber mais sobre seus
recursos:
è https://docs.saltstack.com/en/latest/
Se você gerencia um número significativo de máquinas, seria aconselhável aprender mais sobre o SaltStack, pois você
pode economizar uma quantidade significativa de tempo ao implantar novas máquinas e poderá manter uma configuração
coerente em toda a sua rede.
Para lhe dar uma ideia de como é trabalhar com arquivos de estado, cobriremos um exemplo simples: como habilitar o repositório
APT e instalar um pacote que você cria na seção 10.3.3 , “ Criando um Repositório de Pacotes para APT ”[Página 269] e seção 10.3.2 ,
“ Criação de pacotes de configuração ”[Página 263]. Você também irá registrar uma chave SSH na conta do root para que possa fazer
o login remotamente em caso de problemas.
Por padrão, os arquivos de estado são armazenados em / srv / salt no mestre; eles são arquivos estruturados YAML com
uma . sls extensão. Assim como para executar comandos, a aplicação de um estado depende de muitos módulos de estado:
è https://docs.saltstack.com/en/latest/topics/tutorials/starting_states.html
è https://docs.saltstack.com/en/latest/ref/states/all/
Seu / srv / salt / offsec.sls arquivo irá chamar três desses módulos:
offsec_repository:
pkgrepo.managed:
- nome: deb http://pkgrepo.offsec.com offsec-interno principal
- arquivo: /etc/apt/sources.list.d/offsec.list
- key_url: salt: //offsec-apt-key.asc
- require_in:
- pkg: offsec-defaults
offsec-defaults:
pkg.installed
ssh_key_for_root:
ssh_auth.present:
- usuário: root
- nome: ssh-rsa AAAAB3NzaC1yc2 ... 89C4N rhertzog @ kali
o offsec_repository estado depende do pkgrepo módulo de estado. O exemplo usa o gerenciou

função nesse módulo de estado para registrar um repositório de pacotes. Com o key_url atributo, você

avise salt que a chave GPG (blindada ASCII) necessária para verificar se a assinatura do repositório pode ser obtida de / srv
/ salt / offsec-apt-key.asc no mestre de sal. o require_in atributo garante que este estado seja processado antes do offsec-defaults,
já que o último precisa do repositório configurado corretamente para poder instalar o pacote.
o offsec-defaults state instala o pacote com o mesmo nome. Isso mostra que o nome da chave é muitas vezes um valor
importante para estados, embora possa sempre ser substituído por um nome atributo (como feito para o primeiro estado).
Para casos simples como este, isso é legível e conciso.
O último estado ( ssh_key_for_root) adiciona a chave SSH fornecida no nome atribuir a / root / .ssh / authorized_keys ( o
usuário-alvo é definido no do utilizador atributo). Observe que encurtamos a chave para legibilidade aqui, mas você deve
colocar a chave completa no atributo name.
Este arquivo de estado pode ser aplicado a um determinado lacaio:
servidor# salt kali-scratch state.apply offsec

kali-scratch:
----------
ID: offsec_repository
Função: pkgrepo.managed
Nome: deb http://pkgrepo.offsec.com offsec-interno principal Resultado: Verdadeiro
Comentário: Repo 'de pacote configurado deb http://pkgrepo.offsec.com offsec-internal

uma a Principal'
Iniciado: 06: 00: 15.767794

Duração: 4707,35 ms
Alterar:
----------
repo:
deb http://pkgrepo.offsec.com offsec-internal main
----------
ID: offsec-defaults
Função: pkg.installed
Resultado: Verdadeiro
Comentário: Os seguintes pacotes foram instalados / atualizados: offsec-defaults Duração: 19246,041 ms

Iniciado: 06: 00: 21.325184
Alterar:
----------
offsec-defaults:
----------
Novo:
1.0
velho:
----------
ID: ssh_key_for_root
Função: ssh_auth.present

Nome: ssh-rsa AAAAB3NzaC1yc2 ... 89C4N rhertzog @ kali Resultado: Verdadeiro
Comentário: A chave de host autorizada AAAAB3NzaC1yc2 ... 89C4N para o usuário root foi adicionada Iniciado: 06: 00: 40.582539
Alterar:
----------
AAAAB3NzaC1yc2 ... 89C4N:
Novo
Resumo para kali-scratch

-------------
Bem-sucedido: 3 (alterado = 3)
Falhou: 0
-------------
Total de estados executados: 3
Tempo total de execução: 24.015 s
Ele também pode ser associado permanentemente ao lacaio, gravando-o no / srv / salt / top.sls
arquivo, que é usado pelo state.highstate comando para aplicar todos os estados relevantes em uma única passagem:
servidor# cat /srv/salt/top.sls

base:
kali-scratch:
- offsec
servidor# sal kali-scratch state.highstate
kali-scratch:
----------
ID: offsec_repository
Função: pkgrepo.managed
Nome: deb http://pkgrepo.offsec.com offsec-interno principal Resultado: Verdadeiro
Comentário: Pacote repo 'deb http://pkgrepo.offsec.com offsec-internal main' já

uma configurado
Iniciado: 06: 06: 20.650053
Alterar:
----------
ID: offsec-defaults
Função: pkg.installed
Resultado: Verdadeiro
Comentário: O pacote offsec-defaults já está instalado. Iniciado: 06: 06: 21.436193
Alterar:
----------
ID: ssh_key_for_root

Função: ssh_auth.present
Nome: ssh-rsa AAAAB3NzaC1yc2 ... 89C4N rhertzog @ kali Resultado: Verdadeiro
Comentário: A chave de host autorizada AAAAB3NzaC1yc2 ... 89C4N já está presente para
uma usuário root
Iniciado: 06: 06: 21.821811
Duração: 1,936 ms
Alterar:
Resumo para kali-scratch

-------------
Sucesso: 3
Falhou: 0
-------------
Total de estados executados: 3
Tempo total de execução: 449,833 ms
10,3. Extensão e personalização do Kali Linux
Às vezes, você precisa modificar o Kali Linux para torná-lo adequado às suas necessidades locais. A melhor maneira de fazer isso é manter
seu próprio repositório de pacotes hospedando as versões modificadas dos pacotes Kali que você teve que bifurcar, bem como pacotes
suplementares que fornecem configuração personalizada e software extra (não fornecido pelo Kali Linux).
10.3.1. Pacotes de bifurcação Kali
Consulte a seção 9,1 , “ Modificando Pacotes Kali ”[Página 222] para explicações sobre esse tópico.
Todos os pacotes podem ser bifurcados se você tiver um bom motivo, mas deve estar ciente de que bifurcar um pacote tem um custo, já que
você deve atualizá-lo toda vez que Kali publicar uma atualização. Aqui estão alguns motivos pelos quais você pode querer bifurcar um pacote:
• Para adicionar um patch para corrigir um bug ou adicionar um novo recurso. Embora, na maioria dos casos, você deseje enviar esse patch
aos desenvolvedores upstream para que o bug seja corrigido ou o recurso seja adicionado na fonte.
• Para compilá-lo com opções diferentes (assumindo que há boas razões para Kali não compilá-lo com essas opções; caso
contrário, pode ser melhor discutir isso com os desenvolvedores Kali para ver se eles podem habilitar as opções
desejadas).
Por outro lado, aqui estão alguns motivos ruins para bifurcar um pacote junto com sugestões de como lidar com seu problema:

• Para modificar um arquivo de configuração. Você tem várias opções melhores, como usar o gerenciamento de configuração para
instalar automaticamente um arquivo de configuração modificado ou instalar um pacote de configuração que colocará um arquivo em
um diretório de configuração (quando disponível) ou que desviará o arquivo de configuração original.
• Para atualizar para uma versão superior mais recente. Novamente, é melhor trabalhar com desenvolvedores para atualizar o pacote diretamente no
Debian ou Kali. Com o modelo de lançamento contínuo, as atualizações são bastante rápidas para alcançar os usuários finais.
Entre todos os pacotes disponíveis, existem alguns que são blocos de construção do Kali Linux e que podem ser interessantes de
bifurcar em algumas situações:
• kali-meta: este pacote fonte constrói todos os pacotes meta kali-linux- * e notavelmente kali-linux- full, que define quais
pacotes são instalados na imagem ISO padrão do Kali Linux.
• desktop-base: Este pacote de origem contém vários arquivos diversos que são usados por padrão em instalações
de desktop. Considere bifurcar este pacote se desejar mostrar a marca da sua organização no plano de fundo
padrão ou alterar o tema da área de trabalho.
• menu kali: este pacote define a estrutura do menu Kali e fornece. Área de Trabalho arquivos para todos os aplicativos
que devem ser listados no menu Kali.
10.3.2. Criação de pacotes de configuração
Agora que tocamos na inicialização PXE e discutimos o gerenciamento de configuração com Salt-Stack, bem como bifurcação de
pacote, é hora de resumir esses processos em um exemplo prático e estender o cenário criando um pacote de configuração
personalizado para implantar uma configuração personalizada em várias máquinas semi-automaticamente.
Neste exemplo, você criará um pacote personalizado que configura e utiliza seu próprio repositório de pacote e chave de assinatura
GnuPG, distribui uma configuração SaltStack, envia um fundo personalizado e fornece configurações de desktop padrão de uma forma
unificada para todas as suas instalações Kali.
Isso pode parecer uma tarefa difícil (especialmente se você olhar através do Guia para novos mantenedores do Debian 1 ) mas, felizmente para
nós, um pacote de configuração é principalmente um arquivo de arquivos sofisticado e transformá-lo em um pacote é bastante fácil.
Olhando em uma amostra Se você quiser olhar para um pacote real que é basicamente um pacote de configuração, con
Pacote considerar o kali-defaults pacote. Não é tão simples quanto o exemplo nesta seção, mas
tem todas as características relevantes e até usa algumas técnicas avançadas (como
dpkg-divert) para substituir arquivos já fornecidos por outros pacotes.
1 https://www.debian.org/doc/manuals/maint-guide/

o offsec-defaults pacote conterá alguns arquivos:
• /etc/apt/sources.list.d/offsec.list: uma sources.list entrada para APT, permitindo o

repositório interno de pacotes da empresa
• /etc/apt/trusted.gpg.d/offsec.gpg: a chave GnuPG usada para assinar o repositório interno de pacotes da empresa
• /etc/salt/minion.d/offsec.conf: um arquivo de configuração SaltStack para indicar onde encontrar o mestre Salt
• /usr/share/images/offsec/background.png: uma bela imagem de fundo com o

Logotipo da Offensive Security
• /usr/share/glib-2.0/schemas/90_offsec-defaults.gschema.override: um arquivo provid-

criando configurações padrão alternativas para a área de trabalho GNOME
Primeiro, crie um offsec-defaults-1.0 diretório e coloque todos os arquivos nesse diretório. Então corra
dh_make --native ( de dh-make pacote) para adicionar instruções de empacotamento Debian, que serão armazenadas em um debian subdiretório:
$ mkdir offsec-defaults-1.0; cd offsec-defaults-1.0

$ dh_make --native
Tipo de pacote: (único, indep, biblioteca, python) [s / i / l / p]? Eu
Endereço de e-mail : buxy@kali.org

Licença : gpl3
Nome do pacote : offsec-defaults
Nome do mantenedor : Raphaël Hertzog
Versão : 1.0
Tipo de Pacote : indep
Encontro : Qui, 16 de junho de 2016 18:04:21 +0200
Os detalhes estão corretos? [S / n / q] y
Atualmente não há Makefile de nível superior. Isso pode exigir ajuste adicional Feito. Por favor, edite os arquivos no subdiretório
debian / agora.
Primeiro, você é solicitado a fornecer um tipo de pacote. No exemplo, selecionamos indep, o que indica que este pacote fonte irá gerar um
único pacote binário que pode ser compartilhado entre todas as arquiteturas ( Arquitetura: tudo). solteiro atua como uma contraparte e
produz um único pacote binário que depende da arquitetura de destino ( Arquitetura: qualquer). Nesse caso, indep é mais relevante, uma
vez que o pacote contém apenas arquivos de texto e nenhum programa binário, de forma que pode ser usado de forma semelhante em
computadores de todas as arquiteturas. o biblioteca type é útil para bibliotecas compartilhadas, pois elas precisam seguir regras estritas de
empacotamento. De maneira semelhante, Pitão deve ser restrito a módulos Python.

Nome do mantenedor e A maioria dos programas envolvidos na manutenção de pacotes procuram seu nome e endereço de e-mail no
Endereço de e-mail DEBFULLNAME e DEBEMAIL ou O EMAIL variáveis ambientais. Defini-los de uma vez por todas evita
redigitá-los várias vezes. Se o seu shell usual é o Bash, é uma simples questão de adicionar as duas linhas a
seguir em seu ~ /. bashrc
Arquivo. Por exemplo:
exportar EMAIL = ” buxy@kali.org ”

export DEBFULLNAME = ”Raphael Hertzog”
o dh_make comando criou um debian subdiretório contendo muitos arquivos. Alguns são obrigatórios, em particular regras, controle, log
de mudanças, e direito autoral. Arquivos com o. ex extensão são arquivos de exemplo que podem ser usados modificando-os e
removendo a extensão. Quando não forem necessários, recomendamos removê-los. o compat arquivo deve ser mantido, uma vez que
é necessário para o correto funcionamento do debhelper conjunto de programas (todos começando com o dh_ prefixo) usado em
vários estágios do processo de construção do pacote.
o direito autoral O arquivo deve conter informações sobre os autores dos documentos incluídos no pacote e a licença relacionada. Se a
licença padrão selecionada por dh_make não combina com você, então você deve editar este arquivo. Aqui está a versão modificada do
arquivo de direitos autorais:
Formato: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ Upstream-Name: offsec-defaults
Arquivos: *
Copyright: 2016 Licença de segurança ofensiva: GPL-3.0 +
Licença: GPL-3.0 +
Este programa é um software livre: você pode redistribuí-lo e / ou modificá-lo de acordo com os termos da GNU
General Public License publicada pela Free Software Foundation, seja a versão 3 da Licença ou (conforme sua opção)
qualquer versão posterior.
.
Este pacote é distribuído na esperança de que seja útil, mas SEM NENHUMA GARANTIA; sem mesmo a
garantia implícita de COMERCIABILIDADE ou ADEQUAÇÃO A UM DETERMINADO FIM. Veja a GNU
General Public License para mais detalhes.
.
Você deve ter recebido uma cópia da Licença Pública Geral GNU junto com este programa. Caso contrário, consulte
<https://www.gnu.org/licenses/>.
.
Em sistemas Debian, o texto completo do GNU General
A Licença Pública versão 3 pode ser encontrada em ”/ usr / share / common-licences / GPL-3”.

O padrão changelog arquivo é geralmente apropriado; substituir o "lançamento inicial" por uma explicação mais detalhada deve
ser suficiente:
offsec-defaults (1.0) instável; urgência = média
* Adicione o arquivo de configuração do salt minion.

* Adicione uma entrada sources.list do APT e uma chave GPG confiável do APT.
* Substitua o esquema gsettings que define a imagem de fundo.
- - Raphaël Hertzog < buxy@kali.org > Qui, 16 de junho de 2016 18:04:21 +0200
No exemplo, faremos alterações no ao controle Arquivo. Vamos mudar o Seção campo para misc
e remova o Homepage, Vcs-Git, e Vcs-Browser Campos. Por fim, preencheremos o Descrição
campo:
Fonte: offsec-defaults
Seção: misc
Prioridade: opcional
Mantenedor: Raphaël Hertzog < buxy@kali.org > Build-Depends: debhelper
(> = 9)
Versão padrão: 3.9.8
Pacote: offsec-defaults
Arquitetura: tudo
Depende: $ {misc: Depends}
Descrição: configurações padrão para segurança ofensiva
Este pacote contém vários arquivos para configurar computadores de propriedade da Offensive
Security.
.
Modifica notavelmente:
- configuração do APT
- configuração do minion de sal
- as configurações padrão da área de trabalho
o regras O arquivo geralmente contém um conjunto de regras usadas para configurar, construir e instalar o software em um
subdiretório dedicado (nomeado após o pacote binário gerado). O conteúdo deste subdiretório é então arquivado dentro do
pacote Debian como se fosse a raiz do sistema de arquivos. Neste caso, os arquivos serão instalados no debian / offsec-defaults
/ subdiretório. Por exemplo, para acabar com a instalação de um pacote / etc / apt / sources.list.d / offsec.list, instale o arquivo em
debian / offsec-defaults /etc/apt/source.list.d/offsec.list. o regras arquivo é usado como um

Makefile, com alguns alvos padrão (incluindo limpar \ limpo e binário, usado respectivamente para limpar o diretório de origem
e gerar o pacote binário).

O que é uma Makefile Arquivo? Você deve ter notado a mensagem sobre a falta Makefile no final de dh_make saída e a menção de sua semelhança
com o regras Arquivo. UMA Makefile é um arquivo de script usado pelo faço programa; ele descreve as regras de como
construir um conjunto de arquivos entre si em uma árvore de dependências. Por exemplo, um programa pode ser
construído a partir de um conjunto de arquivos de origem. o Makefile arquivo descreve essas regras no seguinte
formato:
target: source1 source2 ...

comando1
command2
A interpretação de tal regra é a seguinte: se um dos fonte* arquivos são mais recentes que o alvo arquivo,
então o destino precisa ser gerado, usando comando1
e command2.
Observe que as linhas de comando devem começar com um caractere de tabulação; Observe também que quando
uma linha de comando começa com um traço (-), a falha do comando não interrompe todo o processo.
Embora este arquivo seja o coração do processo, ele contém apenas o mínimo necessário para executar um conjunto padrão de
comandos fornecidos pelo debhelper ferramenta. Esse é o caso de arquivos gerados por dh_make. Para instalar a maioria dos seus
arquivos, recomendamos configurar o comportamento do
dh_install comando criando o seguinte debian / offsec-defaults.install Arquivo:
apt / offsec.list etc / apt / sources.list.d /

apt / offsec.gpg etc / apt / trusted.gpg.d /
salt / offsec.conf etc / salt / minion.d /
images / background.png usr / share / images / offsec /
Você também pode usar isso para instalar o arquivo de substituição de gsettings, mas o debhelper fornece uma ferramenta dedicada para isso ( dh_installgsettings)
então você pode confiar nele. Primeiro, coloque suas configurações em debian /
offsec-defaults.gsettings-override:
[org.gnome.desktop.background]
opções de imagem = 'zoom'
picture-uri = 'file: ///usr/share/images/offsec/background.png'
Em seguida, substitua o dh_installgsettings ligar debian / rules para aumentar a prioridade para o nível esperado para uma
substituição da organização (que é 90 de acordo com a página do manual):
#! / usr / bin / make -f
%:
dh $ @
override_dh_installgsettings:
dh_installgsettings --priority = 90

Neste ponto, o pacote fonte está pronto. Tudo o que resta fazer é gerar o pacote binário com o mesmo método usado
anteriormente para reconstruir pacotes: execute o dpkg-buildpackage -us
- uc comando de dentro do offsec-defaults-1.0 diretório:
$ dpkg-buildpackage -us -uc

dpkg-buildpackage: info: fonte pacote offsec-defaults dpkg-buildpackage: info: fonte versão 1.0
dpkg-buildpackage: info: distribuição de fonte instável

dpkg-buildpackage: info: fonte alterada por Raphaël Hertzog < buxy@kali.org > dpkg-buildpackage: info: arquitetura host amd64
dpkg-source --before-build offsec-defaults-1.0

fakeroot debian / rules clean
dh limpo
dh_testdir
dh_auto_clean
dh_clean
dpkg-source -b offsec-defaults-1.0
dpkg-source: info: usando o formato de origem '3.0 (nativo)'
dpkg-source: info: construindo offsec-defaults em offsec-defaults_1.0.tar.xz dpkg-source: info: construindo offsec-defaults em
offsec-defaults_1.0.dsc debian / rules build
dh build
dh_testdir
dh_update_autotools_config
dh_auto_configure
dh_auto_build
dh_auto_test
fakeroot debian / rules binário
binário dh
dh_testroot
dh_prep
dh_auto_install
dh_install
dh_installdocs
dh_installchangelogs
debian / rules override_dh_installgsettings
make [1]: Entrando no diretório '/home/rhertzog/kali/kali-book/samples/offsec-defaults-1.0' dh_installgsettings --priority = 90
make [1]: Saindo do diretório '/home/rhertzog/kali/kali-book/samples/offsec-defaults-1.0'

dh_perl
dh_link
dh_strip_nondeterminism
dh_compress
dh_fixperms
dh_installdeb
dh_gencontrol
dh_md5sums

dh_builddeb
dpkg-deb: construindo pacote 'offsec-defaults' em '../offsec-defaults_1.0_all.deb'. dpkg-genchanges> ../ offsec-defaults_1.0_amd64.changes
dpkg-genchanges: info: incluindo código-fonte completo no upload dpkg-source --after-build

offsec-defaults-1.0
dpkg-buildpackage: info: upload completo; Pacote nativo Debian (fonte completa incluída)
10.3.3. Criando um Repositório de Pacotes para APT
Agora que você tem um pacote personalizado, pode distribuí-lo por meio de um repositório de pacotes APT. Usar reprepro para criar o
repositório desejado e preenchê-lo. Esta ferramenta é bastante poderosa e sua página de manual certamente vale a pena ler.
Um repositório de pacotes normalmente é hospedado em um servidor. Para separá-lo adequadamente de outros serviços executados no
servidor, é melhor criar um usuário dedicado a este serviço. Na conta de usuário dedicada, você poderá hospedar os arquivos do
repositório e também a chave GnuPG que será usada para assinar o repositório de pacotes:
# apt install reprepro gnupg

[...]
# adduser --system --group pkgrepo
Adicionando usuário do sistema 'pkgrepo' (UID 136) ... Adicionando novo
grupo 'pkgrepo' (GID 142) ...
Adicionando novo usuário 'pkgrepo' (UID 136) com o grupo 'pkgrepo' ... Criando diretório home '/ home /
pkgrepo' ...
# chown pkgrepo $ (tty)
# su - -s / bin / bash pkgrepo
$ gpg --gen-key
gpg (GnuPG) 2.1.11; Copyright (C) 2016 Free Software Foundation, Inc. Este é um software livre: você é livre para
alterá-lo e redistribuí-lo. NÃO HÁ GARANTIA, na extensão permitida por lei.
gpg: diretório '/home/pkgrepo/.gnupg' criado

gpg: novo arquivo de configuração '/home/pkgrepo/.gnupg/dirmngr.conf' criado gpg: novo arquivo de configuração
'/home/pkgrepo/.gnupg/gpg.conf' criado gpg: keybox '/home/pkgrepo/.gnupg/ pubring.kbx 'criado
Nota: Use ”gpg --full-gen-key” para um diálogo completo de geração de chave.
O GnuPG precisa construir um ID de usuário para identificar sua chave.
Nome real: Chave de assinatura do repositório de segurança ofensiva

Endereço de e-mail: repoadmin@offsec.com
Você selecionou este USER-ID:
” Ofensive Security Repository Signing Key < repoadmin@offsec.com >”

Alterar (N) ame, (E) mail ou (O) kay / (Q) uit? o
Precisamos gerar muitos bytes aleatórios. É uma boa idéia realizar alguma outra ação (digitar no teclado, mover o mouse,
utilizar os discos) durante a geração principal; isso dá ao gerador de números aleatórios uma chance melhor de ganhar
entropia suficiente.
[...]
gpg: /home/pkgrepo/.gnupg/trustdb.gpg: trustdb criado gpg: chave B4EF2D0D marcada como
confiável
gpg: diretório '/home/pkgrepo/.gnupg/openpgp-revocs.d' criado
gpg: certificado de revogação armazenado como '/home/pkgrepo/.gnupg/openpgp-revocs.d/
uma F8FE22F74F1B714E38DA6181B27F74F7B4EF2D0D.rev '
chave pública e secreta criada e assinada.
gpg: verificação do banco de dados confiável
gpg: marginais necessários: 3 completos necessários: 1 modelo de confiança: PGP gpg: profundidade: 0
válido: 1 assinado: 0 confiança: 0-, 0q, 0n, 0m, 0f, 1u
bar rsa2048 / B4EF2D0D 2016-06-17 [S]
Impressão digital da chave = F8FE 22F7 4F1B 714E 38DA 6181 B27F 74F7 B4EF 2D0D uid
[ultimate] Chave de assinatura do repositório de segurança ofensiva < repoadmin@offsec.com >
sub rsa2048 / 38035F38 2016-06-17 []
Observe que, quando for solicitada uma frase-senha, você deve inserir um valor vazio (e confirmar que não deseja proteger sua
chave privada), pois deseja poder assinar o repositório de forma não interativa. Observe também que gpg requer acesso de gravação
ao terminal para poder solicitar com segurança uma senha longa: é por isso que você alterou a propriedade do terminal virtual (que é
propriedade do root, uma vez que inicialmente se conectou como aquele usuário) antes de iniciar um shell como pkgrepo.
Agora você pode começar a configurar o repositório. Um diretório dedicado é necessário para reprepro e dentro desse diretório
você deve criar um conf / distribuições arquivo documentando quais distribuições estão disponíveis no repositório de pacotes:
$ mkdir -p reprepro / conf

$ cd reprepro
$ cat> conf / distributions << END Codename:
offsec-internal
AlsoAcceptFor: instável
Origem: Segurança Ofensiva
Descrição: Pacotes internos da Offsec Arquiteturas: source
amd64 i386 Componentes: main
SignWith: F8FE22F74F1B714E38DA6181B27F74F7B4EF2D0D
FIM
Os campos obrigatórios são Nome de código, que dá o nome da distribuição, Arquiteturas, que indica quais arquiteturas
estarão disponíveis na distribuição (e aceitas no lado da entrada), e Componentes, que indica os vários componentes
disponíveis na distribuição (com

ponentes são uma espécie de subseção da distribuição, que pode ser habilitada separadamente em sources.list do APT. o Origem e Descrição
campos são puramente informativos e são copiados como estão no Liberação Arquivo. o SignWith campo pergunta reprepro para
assinar o repositório com a chave GnuPG cujo identificador está listado (coloque a impressão digital completa aqui para garantir que
você usa a chave correta, e não outra colidindo no identificador curto). o AlsoAcceptFor configuração não é necessária, mas torna
possível o processamento. alterar arquivos cujo campo Distribution tem um valor listado aqui (sem isso, ele aceitaria apenas o
codinome da distribuição nesse campo).
Com esta configuração básica estabelecida, você pode permitir reprepro gere um repositório vazio:
$ exportação reprepro
Exportando índices ...
$ encontrar .
.
. / db
. / db / versão
. /db/references.db
. /db/contents.cache.db
. /db/checksums.db
. /db/packages.db
. /db/release.caches.db
. / conf
. / conf / distributions
. / dists
. / dists / offsec-internal
. /dists/offsec-internal/Release.gpg
. / dists / offsec-internal / Release
. / dists / offsec-internal / main
. / dists / offsec-internal / main / source
. / dists / offsec-internal / main / source / Release
. /dists/offsec-internal/main/source/Sources.gz
. / dists / offsec-internal / main / binary-amd64
. / dists / offsec-internal / main / binary-amd64 / Pacotes
. / dists / offsec-internal / main / binary-amd64 / Release
. /dists/offsec-internal/main/binary-amd64/Packages.gz
. / dists / offsec-internal / main / binary-i386
. / dists / offsec-internal / main / binary-i386 / Pacotes
. / dists / offsec-internal / main / binary-i386 / Versão
. /dists/offsec-internal/main/binary-i386/Packages.gz
. / dists / offsec-internal / InRelease
Como você pode ver, reprepro criou a meta-informação do repositório em um dists subdiretório. Ele também inicializou um banco de
dados interno em um db subdiretório.
Agora é hora de adicionar seu primeiro pacote. Primeiro, copie os arquivos gerados pela construção do offsec-
padrões pacote ( offsec-defaults_1.0.dsc, offsec-defaults_1.0.tar.xz,

offsec-defaults_1.0_all.deb, e offsec-defaults_1.0_amd64.changes) para dentro / tmp
no servidor que hospeda o repositório de pacotes e pergunte reprepro para incluir o pacote:
$ reprepro inclui offsec-internal /tmp/offsec-defaults_1.0_amd64.changes

Exportando índices ...
$ encontrar piscina
piscina
piscina / principal
piscina / principal / o
pool / main / o / offsec-defaults

pool / main / o / offsec-defaults / offsec-defaults_1.0.dsc
pool / main / o / offsec-defaults / offsec-defaults_1.0.tar.xz
pool / main / o / offsec-defaults / offsec-defaults_1.0_all.deb
Como você pode ver, ele adicionou os arquivos em seu próprio conjunto de pacotes em um piscina subdiretório.
o dists e piscina Os diretórios são os dois diretórios que você precisa tornar (publicamente) disponível em HTTP para concluir a
configuração do seu repositório APT. Eles contêm todos os arquivos que o APT deseja baixar.
Supondo que você deseja hospedar isso em um host virtual chamado pkgrepo.offsec.com, você pode criar o seguinte arquivo de
configuração do Apache, salvá-lo em / etc / apache2 / sites-available / pkgrepo.
offsec.com.conf, e habilite-o com a2ensite pkgrepo.offsec.com):
<VirtualHost *: 80>
ServerName pkgrepo.offsec.com
ServerAdmin repoadmin@offsec.com
ErrorLog /var/log/apache2/pkgrepo.offsec.com-error.log
CustomLog /var/log/apache2/pkgrepo.offsec.com-access.log ”% h% l% u% t \”% r \ ”%> s% O”
DocumentRoot / home / pkgrepo / reprepro
<Diretório ”/ home / pkgrepo / reprepro”>

Opções Índices FollowSymLinks MultiViews Requer todos concedidos
AllowOverride All
</Directory>
</VirtualHost>
E o correspondente sources.list entrada para adicionar em máquinas que precisam de pacotes deste repositório ficaria
assim:
deb http://pkgrepo.offsec.com offsec-internal main
# Habilite a próxima linha se você quiser acessar os pacotes fonte também

# deb-src http://pkgrepo.offsec.com offsec-internal main
Seu pacote agora está publicado e deve estar disponível para seus hosts de rede.

Embora esta tenha sido uma configuração demorada, o “trabalho pesado” agora está concluído. Você pode inicializar suas máquinas em
rede via PXE, instalar uma versão personalizada do Kali Linux sem interação graças a uma pré-configuração fornecida pela rede, configurar
o SaltStack para gerenciar suas configurações (e controlar minions!), Criar pacotes personalizados bifurcados e distribuir esses pacotes
através de seu próprio pacote. repositório de idade. Isso fornece gerenciamento centralizado e controle de nível empresarial sobre várias
instalações do Kali Linux. Resumindo, agora você pode implantar rapidamente sistemas Kali altamente seguros pré-configurados para suas
necessidades específicas e mantê-los sincronizados graças à instalação (semiautomática) de Kali de todas as atualizações de pacote.
10,4. Resumo
O Kali Linux vai além do desktop para implantações em média ou grande escala e até mesmo para o nível empresarial. Neste capítulo,
abordamos como centralizar o gerenciamento de várias instalações Kali com SaltStack, permitindo que você implante rapidamente
sistemas Kali altamente seguros pré-configurados para suas necessidades específicas. Também revelamos como você pode mantê-los
sincronizados graças à instalação (semiautomática) de atualizações de pacotes de Kali.
Discutimos a bifurcação de pacotes, que permite criar seus próprios pacotes de origem distribuíveis personalizados.
Em resumo, vamos revisar as principais etapas necessárias para estabelecer mestres e lacaios do Salt, que permitem o controle
remoto e a configuração de hosts remotos.
Dicas de resumo:
• Inicialize a máquina a partir da rede com PXE, com pelo menos um servidor de arquivo TFTP, um servidor DHCP / BOOTP (e um
servidor web para pré-configuração debconf). dnsmasq lida com DHCP e TFTP, e o apache2 o servidor web vem pré-instalado
(mas desabilitado) no Kali.
• O manual de instalação do Debian cobre a configuração de isc-dhcp-server e tftpd-hpa para inicialização PXE:
è https://www.debian.org/releases/stable/amd64/ch04s05.html
• dnsmasq está configurado através de / etc / dnsmasq.conf. Uma configuração básica consiste em apenas algumas linhas principais:
# Interface de rede para lidar com interface = eth0
# Opções de DHCP
# Intervalo de IP para alocar

dhcp-range = 192.168.101.100,192.168.101.200,12h
# Gateway para anunciar aos clientes
opção dhcp = opção: roteador, 192.168.101.1
# Servidores DNS para anunciar aos clientes
dhcp-option = option: dns-server, 8.8.8.8,8.8.4.4
# Arquivo de inicialização para anunciar aos clientes

dhcp-boot = pxelinux.0
# Opções TFTP
enable-tftp
# Arquivos de hospedagem de diretório para servir tftp-root
= / tftpboot /
• Descompacte os arquivos de inicialização de instalação de 32 bits (i386), 64 bits (amd64), padrão ou gráfico (gtk) do arquivo Kali para / tftpboot
/. Os arquivos podem ser encontrados aqui:
è http://http.kali.org/dists/kali-rolling/main/installer-amd64/current/ images / netboot / gtk / netboot.tar.gz
è http://http.kali.org/dists/kali-rolling/main/installer-amd64/current/ images / netboot / netboot.tar.gz
è http://http.kali.org/dists/kali-rolling/main/installer-i386/current/ images / netboot / gtk / netboot.tar.gz
è http://http.kali.org/dists/kali-rolling/main/installer-i386/current/ images / netboot / netboot.tar.gz
# mkdir / tftpboot
# cd / tftpboot
# wget http://http.kali.org/dists/kali-rolling/main/installer-amd64/current/
uma images / netboot / netboot.tar.gz
# tar xf netboot.tar.gz
• Opcionalmente, modifique txt.cfg para pré-configurar parâmetros ou tempos limite personalizados. Veja a seção 4,3 , “ Instalações autônomas ”[Página
91]. Em seguida, você pode aproveitar as ferramentas de gerenciamento de configuração para gerenciar máquinas ou configurar computadores
remotos para qualquer estado desejado.
• SaltStack é um serviço de gerenciamento de configuração centralizado: um Salt master gerencia muitos Salt minions. Instale o mestre
do sal pacote em um servidor acessível e sal-minion em hosts gerenciados.
• Edite o / etc / salt / minion Arquivo de configuração formatado em YAML e definir o mestre chave para o nome DNS (ou endereço IP)
do mestre Salt.
• Defina o identificador único do minion em / etc / salt / minion_id:
servo # echo kali-scratch> / etc / salt / minion_id

servo # systemctl ativar salt-minion
servo # systemctl start salt-minion
• A troca de chaves acontecerá. No mestre, aceite a chave de identificação do minion. As conexões subsequentes serão
automáticas:
mestre# systemctl enable salt-master

mestre# systemctl start salt-master
mestre# salt-key - listar todos

Chaves aceitas:
Chaves negadas:
kali-scratch
Chaves rejeitadas:
mestre# salt-key --aceite kali-scratch
As seguintes chaves serão aceitas: Chaves não aceitas:
kali-scratch
Continuar? [Nova Iorque] y
Aceita-se a chave para arranhões Kali lacaios.
• Assim que os lacaios estiverem conectados, você pode executar comandos sobre eles a partir do mestre. Exemplos:
mestre# salt '*' test.ping

kali-scratch:
Verdadeiro
mestre kali:
Verdadeiro
mestre# salt kali-scratch cmd.shell 'uptime; uname -a '

mestre# salt kali-scratch sys.doc '
mestre# salt '*' service.enable ssh
[...]
mestre# salt '*' service.start ssh
[...]
mestre# salt '*' pkg.refresh_db
[...]
mestre# salt '*' pkg.upgrade dist_upgrade = True
servidor# salt '*' cmd.shell 'pkill -f dnmap_client'
• A lista completa de módulos de execução pode ser encontrada em https://docs.saltstack.com/en/

mais recente / ref / modules / all / index.html .
• Use arquivos de estado Salt (modelos de configuração reutilizáveis) para agendar ações, coletar dados, orquestrar
sequências de operações em vários minions, provisionar sistemas em nuvem e gerenciá-los, e muito mais. Economize
tempo com fórmulas de sal predefinidas:
è https://docs.saltstack.com/en/latest/topics/development/conventions/ formulas.html
• Quando chegar a hora de bifurcar um pacote, primeiro decida se é uma tarefa que você precisa realizar. Existem vantagens
e desvantagens significativas. Revise-os cuidadosamente. o kali-meta, desktop-base, e menu kali os pacotes são escolhas
interessantes e prováveis. O processo de bifurcar um pacote pode ser assustador e difícil de resumir.

Agora que cobrimos todas as bases em termos de instalação, configuração, personalização e implantação do Kali Linux,
vamos nos voltar para o papel do Kali Linux no campo da Segurança da Informação.

Palavras-chave
Tipos de avaliações
Vulnerabilidade
avaliação
Conformidade
teste de penetração
Tradicional
Inscrição
avaliação
Tipos de ataques
Negação de serviço
Corrupção de memória
Vulnerabilidades da web
Ataques de senha
Ataques do lado do cliente
pter
Introdução a 1 1 Cha
Segurança
Assessments
Conteúdo
Kali Linux em uma avaliação 281 Tipos de avaliações 283 Formalização da Avaliação 293
Tipos de Ataques 294 Resumo 297

Nós cobrimos muitos recursos específicos do Kali Linux até este ponto, então você deve ter um forte entendimento do que
torna o Kali especial e como realizar uma série de tarefas complexas.
Antes de colocar o Kali em uso, no entanto, existem alguns conceitos relacionados às avaliações de segurança que você deve
entender. Neste capítulo, apresentaremos esses conceitos para você começar e fornecer referências que ajudarão se você precisar
usar Kali para realizar uma avaliação de segurança.
Para começar, vale a pena dedicar algum tempo para explorar exatamente o que "segurança" significa ao lidar com sistemas de
informação. Ao tentar proteger um sistema de informação, você se concentra em três atributos principais do sistema:
• Confidencialidade: os atores que não deveriam ter acesso ao sistema ou às informações podem acessar o sistema ou as
informações?
• Integridade: os dados ou o sistema podem ser modificados de alguma forma não pretendida?
• Disponibilidade: os dados ou o sistema estão acessíveis quando e como devem ser?
Juntos, esses conceitos formam a tríade CIA (Confidencialidade, Integridade, Disponibilidade) e, em grande parte, são os itens
primários nos quais você se concentrará ao proteger um sistema que faz parte da implantação, manutenção ou avaliação padrão.
Também é importante observar que, em alguns casos, você pode estar muito mais preocupado com um aspecto da tríade
da CIA do que com outros. Por exemplo, se você tem um diário pessoal que contém seus pensamentos mais secretos, a
confidencialidade do diário pode ser muito mais importante para você do que a integridade ou a disponibilidade. Em outras
palavras, você pode não estar tão preocupado se alguém pode escrever para o diário (ao invés de lê-lo) ou se o diário
está ou não sempre acessível. Por outro lado, se você estiver protegendo um sistema que rastreia prescrições médicas, a
integridade dos dados será mais crítica. Embora seja importante evitar que outras pessoas leiam quais medicamentos
alguém usa e é importante que você possa acessar esta lista de medicamentos,
Quando você estiver protegendo um sistema e um problema for descoberto, você terá que considerar em qual desses três
conceitos, ou em qual combinação deles, o problema se enquadra. Isso ajuda a compreender o problema de uma maneira mais
abrangente e permite categorizar os problemas e responder de acordo. É possível identificar vulnerabilidades que afetam um
único ou vários itens da tríade da CIA. Para usar um aplicativo da web com uma vulnerabilidade de injeção de SQL como
exemplo:
• Confidencialidade: uma vulnerabilidade de injeção de SQL que permite a um invasor extrair todo o conteúdo do aplicativo da web,
permitindo que ele tenha acesso total para ler todos os dados, mas sem capacidade de alterar as informações ou desabilitar o
acesso ao banco de dados.
• Integridade: uma vulnerabilidade de injeção de SQL que permite a um invasor alterar as informações existentes no banco de
dados. O invasor não pode ler os dados ou impedir que outros acessem o banco de dados.

• Disponibilidade: uma vulnerabilidade de injeção de SQL que inicia uma consulta de longa duração, consumindo uma grande
quantidade de recursos no servidor. Essa consulta, quando iniciada várias vezes, leva a uma situação de negação de serviço
(DoS). O invasor não tem capacidade de acessar ou alterar dados, mas pode impedir que usuários legítimos acessem o aplicativo
da web.
• Múltiplo: uma vulnerabilidade de injeção de SQL leva ao acesso de shell interativo completo ao sistema operacional
host que executa o aplicativo da web. Com esse acesso, o invasor pode violar a confidencialidade do sistema
acessando os dados como quiser, comprometer a integridade do sistema alterando dados e, se assim escolher,
destruir o aplicativo da web, comprometendo a disponibilidade do sistema.
Os conceitos por trás da tríade da CIA não são excessivamente complicados e, realisticamente, são itens com os quais você está
trabalhando intuitivamente, mesmo que não os reconheça. No entanto, é importante interagir conscientemente com o conceito, pois
ele pode ajudá-lo a reconhecer para onde direcionar seus esforços. Essa base conceitual o ajudará a identificar os componentes
críticos de seus sistemas e a quantidade de esforço e recursos que vale a pena investir na correção dos problemas identificados.
Outro conceito que abordaremos em detalhes é risco, e como é feito de ameaças e vulnerabilidades. Esses conceitos não são muito
complexos, mas são fáceis de errar. Abordaremos esses conceitos em detalhes mais tarde, mas em um alto nível, é melhor pensar em risco
como o que você está tentando evitar que aconteça, ameaça como quem faria isso com você, e vulnerabilidade como o que lhes
permite fazer isso. Os controles podem ser implementados para lidar com a ameaça ou vulnerabilidade, com o objetivo de mitigar o
risco.
Por exemplo, ao visitar algumas partes do mundo, você pode estar em risco de contrair malária. Isso ocorre porque o ameaça O
número de mosquitos é muito alto em algumas áreas e é quase certo que você não esteja imune à malária. Felizmente, você
pode controlar o vulnerabilidade com medicação e tentar controlar o ameaça com o uso de repelente de insetos e
mosquiteiros. Com os controles implantados, abordando os ameaça e a vulnerabilidade, você pode ajudar a garantir que risco não
atualiza.
11.1. Kali Linux em uma avaliação
Ao se preparar para usar o Kali Linux em campo, você deve primeiro garantir que tenha uma instalação limpa e funcional. Um
erro comum que muitos profissionais de segurança novatos cometem é usar uma única instalação em várias avaliações. Este é
um problema por dois motivos principais:
• No decorrer de uma avaliação, você frequentemente instala, ajusta ou altera manualmente o sistema. Essas
alterações únicas podem colocá-lo em operação rapidamente ou resolver um problema específico, mas são
difíceis de controlar; eles tornam seu sistema mais difícil de manter; e eles complicam configurações futuras.
• Cada avaliação de segurança é única. Deixar para trás notas, códigos e outras alterações pode levar à confusão ou pior -
contaminação cruzada de dados do cliente.
Capítulo 11 - Introdução às avaliações de segurança 281

É por isso que começar com uma instalação limpa do Kali é altamente recomendado e porque ter uma versão pré-personalizada do Kali
Linux que está pronta para instalação automatizada rapidamente compensa. Certifique-se de consultar a seção 9,3 , “ Criação de imagens
ISO personalizadas do Kali Live ”[Página 237] e seção 4,3 , “ Instalações autônomas ”[Página 91] sobre como fazer isso, pois quanto mais
você automatiza hoje, menos tempo você perde amanhã.
Todo mundo tem requisitos diferentes quando se trata de como eles gostam do Kali Linux configurado quando estão em campo, mas
existem algumas recomendações universais que você realmente deseja seguir. Primeiro, considere usar uma instalação criptografada
conforme documentado na seção 4.2.2 , “ Instalação em um sistema de arquivos totalmente criptografado ”[Página 85]. Isso protegerá
seus dados na máquina física, o que salva vidas se o seu laptop for roubado.
Para maior segurança durante a viagem, você pode querer detonar a chave de descriptografia (consulte “ Adicionando uma senha Nuke para
segurança extra ”[Página 246]) após ter enviado uma cópia (criptografada) da chave para um colega de trabalho no escritório. Dessa forma, seus
dados ficarão protegidos até você voltar ao escritório, onde poderá restaurar o laptop com a chave de descriptografia.
Outro item que você deve verificar novamente é a lista de pacotes que você instalou. Considere quais ferramentas você pode precisar
para o trabalho que está se preparando para realizar. Por exemplo, se você está embarcando em uma avaliação de segurança sem
fio, você pode considerar instalar o kali-linux-wireless
metapacote, que contém todas as ferramentas de avaliação sem fio disponíveis no Kali Linux, ou se uma avaliação de aplicativo
estiver chegando, você pode instalar todas as ferramentas de teste de aplicativo da web disponíveis com o kali-linux-web metapacote.
É melhor presumir que você não terá acesso fácil à Internet durante a realização de uma avaliação de segurança; portanto,
prepare-se o máximo possível com antecedência.
Pelo mesmo motivo, você pode querer revisar suas configurações de rede (consulte a seção 5,1 , “ Configurando a Rede ”[Página 104] e
seção 7,3 , “ Protegendo serviços de rede ”[Página 153]). Verifique novamente suas configurações de DHCP e analise os serviços que
estão escutando em seu endereço IP atribuído. Essas configurações podem ter um impacto crítico para o seu sucesso. Você não pode
avaliar o que não pode ver e os serviços de escuta excessivos podem sinalizar seu sistema e fazer com que você desligue antes de
começar.
Se a sua função envolver a investigação de invasões de rede, prestar atenção às configurações de rede é ainda mais
importante e você precisa evitar alterar os sistemas afetados. Uma versão personalizada de Kali com o kali-linux-forense O
metapacote inicializado no modo forense não montará discos automaticamente ou usará uma partição swap. Dessa forma,
você pode ajudar a manter a integridade do sistema em análise enquanto usa as várias ferramentas forenses disponíveis no
Kali Linux.
É fundamental que você prepare adequadamente a instalação do Kali Linux para o trabalho. Você descobrirá que um
ambiente Kali limpo, eficiente e eficaz sempre tornará tudo o que se segue muito mais suave.

11,2. Tipos de avaliações
Agora que você garantiu que seu ambiente Kali está pronto, a próxima etapa é definir exatamente que tipo de avaliação você está
conduzindo. No nível mais alto, podemos descrever quatro tipos de avaliações: a avaliação de vulnerabilidade, uma teste de
conformidade, uma teste de penetração tradicional, e um avaliação da aplicação. Um compromisso pode envolver vários elementos
de cada tipo de avaliação, mas vale a pena descrevê-los com alguns detalhes e explicar sua relevância para a construção e
ambiente do Kali Linux.
Antes de mergulhar nos diferentes tipos de avaliações, é importante primeiro observar a diferença entre uma vulnerabilidade e
uma exploração.
UMA vulnerabilidade é definido como uma falha que, quando aproveitada, compromete a confidencialidade, integridade ou
disponibilidade de um sistema de informação. Existem muitos tipos diferentes de vulnerabilidades que podem ser encontradas,
incluindo:
• Inclusão de arquivo: Vulnerabilidades de inclusão de arquivo 1 em aplicativos da web permitem que você incluir o conteúdo de
um arquivo local ou remoto na computação de um programa. Por exemplo, um aplicativo da web pode ter uma função
“Mensagem do dia” que lê o conteúdo de um arquivo e o inclui na página da web para exibi-lo ao usuário. Quando esse tipo
de recurso é programado incorretamente, pode permitir que um invasor modifique sua solicitação da Web para forçar o site a
incluir o conteúdo de um arquivo de sua escolha.
• SQL Injection: A injeção SQL 2 O ataque é aquele em que as rotinas de validação de entrada para o programa são contornadas,
permitindo que um invasor forneça comandos SQL para o programa alvo executar. Esta é uma forma de execução de comando
que pode levar a possíveis problemas de segurança.
• Estouro de buffer: A estouro de buffer 3 é uma vulnerabilidade que ignora as rotinas de validação de entrada para gravar dados na
memória adjacente de um buffer. Em alguns casos, essa localização de memória adjacente pode ser crítica para a operação do
programa de destino e o controle da execução do código pode ser obtido por meio da manipulação cuidadosa dos dados de
memória sobrescritos.
• Condições da corrida: A condição de corrida 4 é uma vulnerabilidade que tira proveito das dependências de tempo em um programa. Em
alguns casos, o fluxo de trabalho de um programa depende da ocorrência de uma sequência específica de eventos. Se você pode
alterar esta sequência de eventos, isso pode levar a uma vulnerabilidade.
A explorar, por outro lado, é um software que, quando usado, tira proveito de uma vulnerabilidade específica, embora nem todas as
vulnerabilidades sejam exploráveis. Uma vez que uma exploração deve alterar um processo em execução, forçando-o a realizar uma ação
não intencional, a criação de uma exploração pode ser complexa. Além disso, há uma série de tecnologias anti-exploit em plataformas de
computação modernas que foram
1 https://en.wikipedia.org/wiki/File_inclusion_vulnerability
2 https://en.wikipedia.org/wiki/SQL_injection
3 https://en.wikipedia.org/wiki/Buffer_overflow
4 https://en.wikipedia.org/wiki/Race_condition

projetado para dificultar a exploração de vulnerabilidades, como Prevenção de Execução de Dados 5 ( DEP) e
Randomização do Layout do Espaço de Endereço 6 ( ASLR). No entanto, só porque não há exploit publicamente conhecido para uma
vulnerabilidade específica, isso não significa que não exista (ou que não possa ser criado). Por exemplo, muitas organizações vendem
exploits comercializados que nunca são tornados públicos, portanto, todas as vulnerabilidades devem ser tratadas como potencialmente
exploráveis.
11.2.1. Avaliação de vulnerabilidade
UMA vulnerabilidade é considerada uma fraqueza que pode ser usada de alguma forma para comprometer a confidencialidade,
integridade ou disponibilidade de um sistema de informação. Em uma avaliação de vulnerabilidade, seu objetivo é criar um
inventário simples de vulnerabilidades descobertas dentro do ambiente alvo. Este conceito de ambiente de destino é extremamente
importante. Você deve se certificar de permanecer dentro do escopo da rede-alvo de seu cliente e dos objetivos exigidos. Sair do
escopo de uma avaliação pode causar uma interrupção do serviço, uma quebra de confiança com seu cliente ou uma ação legal
contra você e seu empregador.
Devido à sua relativa simplicidade, um teste de vulnerabilidade é frequentemente realizado em ambientes mais maduros regularmente
como parte da demonstração de sua devida diligência. Na maioria dos casos, uma ferramenta automatizada, como as do Análise de
Vulnerabilidade 7 e Aplicativos da web 8 categorias do site de ferramentas Kali e menu de aplicativos de desktop Kali, é usado para descobrir
sistemas ativos em um ambiente de destino, identificar serviços de escuta e enumerá-los para descobrir o máximo de informações
possível, como software de servidor, versão, plataforma e assim por diante .
Essas informações são então verificadas em busca de assinaturas conhecidas de possíveis problemas ou vulnerabilidades. Essas assinaturas
são compostas de combinações de pontos de dados destinadas a representar problemas conhecidos. Vários pontos de dados são usados,
porque quanto mais pontos de dados você usa, mais precisa é a identificação. Existe um grande número de pontos de dados potenciais,
incluindo, mas não se limitando a:
• Versão do sistema operacional: não é incomum que o software seja vulnerável em uma versão do sistema operacional,
mas não em outra. Por causa disso, o scanner tentará determinar, da forma mais precisa possível, qual versão do
sistema operacional está hospedando o aplicativo de destino.
• Nível do patch: muitas vezes, serão lançados patches para um sistema operacional que não aumentam as informações
de versão, mas ainda mudam a forma como uma vulnerabilidade responde, ou mesmo a eliminam totalmente.
• Arquitetura do processador: Muitos aplicativos de software estão disponíveis para várias arquiteturas de processador, como
Intel x86, Intel x64, várias versões de ARM, UltraSPARC e assim por diante.
5 https://en.wikipedia.org/wiki/Executable_space_protection#Windows
6 https://en.wikipedia.org/wiki/Address_space_layout_randomization
7 http://tools.kali.org/category/vulnerability-analysis
8 http://tools.kali.org/category/web-applications

Em alguns casos, uma vulnerabilidade existirá apenas em uma arquitetura específica, portanto, conhecer esse bit de informação pode
ser crítico para uma assinatura precisa.
• Versão do software: a versão do software de destino é um dos itens básicos que precisam ser capturados para identificar
uma vulnerabilidade.
Esses e muitos outros pontos de dados serão usados para criar uma assinatura como parte de uma varredura de vulnerabilidade. Como
esperado, os mais pontos de dados que correspondem, mais precisa a assinatura será. Ao lidar com correspondências de assinatura, você pode
ter alguns resultados potenciais diferentes:
• Verdadeiro positivo: a assinatura é correspondida e captura uma verdadeira vulnerabilidade. Esses resultados são os que você
precisará acompanhar e corrigir, pois esses são os itens que indivíduos mal-intencionados podem aproveitar para prejudicar
sua organização (ou a de seu cliente).
• Falso positivo: a assinatura é correspondida; entretanto, o problema detectado não é uma vulnerabilidade verdadeira. Em uma
avaliação, geralmente são considerados ruídos e podem ser bastante frustrantes. Você nunca quer descartar um verdadeiro positivo
como um falso positivo sem uma validação mais extensa.
• Verdadeiro negativo: a assinatura não é compatível e não há vulnerabilidade. Este é o cenário ideal, verificando se
não existe uma vulnerabilidade em um alvo.
• Falso negativo: a assinatura não é compatível, mas existe uma vulnerabilidade. Por pior que seja um falso positivo, um falso
negativo é muito pior. Nesse caso, existe um problema, mas o scanner não o detectou, portanto, você não tem nenhuma
indicação de sua existência.
Como você pode imaginar, a precisão das assinaturas é extremamente importante para resultados precisos. Quanto mais dados são
fornecidos, maior a chance de obter resultados precisos de uma varredura automatizada baseada em assinatura, motivo pelo qual as
varreduras autenticadas costumam ser tão populares.
Com uma varredura autenticada, o software de varredura usará as credenciais fornecidas para autenticar no destino. Isso fornece um
nível mais profundo de visibilidade de um alvo do que seria possível de outra forma. Por exemplo, em uma varredura normal, você só
pode detectar informações sobre o sistema que podem ser derivadas de serviços de escuta e da funcionalidade que eles fornecem. Isso
pode ser um pouco de informação às vezes, mas não pode competir com o nível e a profundidade dos dados que serão obtidos se você
se autenticar no sistema e revisar de forma abrangente todos os softwares instalados, patches aplicados, processos em execução e
assim por diante. Essa amplitude de dados é útil para detectar vulnerabilidades que de outra forma podem não ter sido descobertas.
Uma avaliação de vulnerabilidade bem conduzida apresenta um instantâneo dos problemas potenciais em uma organização e fornece métricas
para medir as mudanças ao longo do tempo. Esta é uma avaliação bastante leve, mas mesmo assim, muitas organizações realizarão regularmente
varreduras automatizadas de vulnerabilidade fora do horário comercial para evitar possíveis problemas durante o dia, quando a disponibilidade do
serviço e a largura de banda são mais críticas.
Como mencionado anteriormente, uma varredura de vulnerabilidade terá que verificar muitos pontos de dados diferentes para obter
um resultado preciso. Todas essas verificações diferentes podem criar carga no sistema de destino e também consumir largura de
banda. Infelizmente, é difícil saber exatamente como muitos recursos serão consumidos no destino, pois depende do número de
serviços abertos e dos tipos de

verificações que seriam associadas a esses serviços. Este é o custo de fazer uma varredura; vai ocupar recursos do
sistema. Ter uma ideia geral dos recursos que serão consumidos e quanta carga o sistema de destino pode suportar é
importante ao executar essas ferramentas.
Scanning Threads A maioria dos scanners de vulnerabilidade inclui uma opção para definir threads por varredura, que equivale ao
número de verificações simultâneas que ocorrem ao mesmo tempo. O aumento desse número terá um impacto direto
na carga da plataforma de avaliação, bem como nas redes e alvos com os quais você está interagindo. É importante
ter isso em mente ao usar esses scanners. É tentador aumentar os encadeamentos para concluir as varreduras mais
rapidamente, mas lembre-se do aumento substancial de carga associado a isso.
Quando uma varredura de vulnerabilidade é concluída, os problemas descobertos são normalmente vinculados a identificadores padrão da
indústria, como Número CVE 9 , EDB-ID 10 , e recomendações de fornecedores. Esta informação, junto com as vulnerabilidades Pontuação CVSS 11 , é
usado para determinar uma classificação de risco. Junto com falsos negativos (e falsos positivos), essas classificações de risco arbitrárias são
problemas comuns que precisam ser considerados ao analisar os resultados da varredura.
Como as ferramentas automatizadas usam um banco de dados de assinaturas para detectar vulnerabilidades, qualquer ligeiro desvio de
uma assinatura conhecida pode alterar o resultado e também a validade da vulnerabilidade percebida. Um falso positivo sinaliza
incorretamente uma vulnerabilidade que não existe, enquanto um falso negativo é efetivamente cego para uma vulnerabilidade e não a
relata. Por isso, costuma-se dizer que um scanner é tão bom quanto sua base de regras de assinatura. Por esse motivo, muitos
fornecedores fornecem vários conjuntos de assinaturas: um que pode ser gratuito para usuários domésticos e outro conjunto bastante caro
que é mais abrangente, geralmente vendido para clientes corporativos.
O outro problema freqüentemente encontrado nas varreduras de vulnerabilidade é a validade das classificações de risco sugeridas. Essas
classificações de risco são definidas de forma genérica, considerando muitos fatores diferentes, como nível de privilégio, tipo de software e
pré ou pós-autenticação. Dependendo do seu ambiente, essas classificações podem ou não ser aplicáveis, portanto, não devem ser aceitas
cegamente. Somente aqueles que conhecem bem os sistemas e as vulnerabilidades podem validar adequadamente as classificações de
risco.
Embora não haja um acordo universalmente definido sobre as classificações de risco, Publicação especial NIST 800-30 12
é recomendado como uma linha de base para avaliação de classificações de risco e sua precisão em seu ambiente. NIST SP 800-30
define o verdadeiro risco de uma vulnerabilidade descoberta como uma combinação da probabilidade de ocorrência e do impacto potencial.
9 https://cve.mitre.org
10 https://www.exploit-db.com/about/
11 https://www.first.org/cvss
12 http://csrc.nist.gov/publications/PubsSPs.html#800-30

Probabilidade de ocorrência
De acordo com o Instituto Nacional de Padrões e Tecnologia (NIST), a probabilidade de ocorrência é baseada na probabilidade
de que uma ameaça particular seja capaz de explorar uma vulnerabilidade particular, com possíveis classificações de Baixa,
Média ou Alta.
• Alta: o adversário potencial é altamente qualificado e motivado e as medidas implementadas para proteger contra a
vulnerabilidade são insuficientes.
• Médio: o adversário potencial está motivado e habilidoso, mas as medidas implementadas para proteger contra a
vulnerabilidade podem impedir seu sucesso.
• Baixo: o adversário potencial não é qualificado ou não está motivado e existem medidas para proteger contra a
vulnerabilidade que são parcial ou totalmente eficazes.
Impacto
O nível de impacto é determinado avaliando a quantidade de dano que poderia ocorrer se a vulnerabilidade em questão
fosse explorada ou aproveitada de outra forma.
• Alta: aproveitar a vulnerabilidade pode resultar em perdas financeiras muito significativas, danos graves à missão
ou à reputação da organização, ou mesmo ferimentos graves, incluindo morte.
• Médio: tirar vantagem da vulnerabilidade pode levar a perdas financeiras, danos à missão ou reputação da
organização ou ferimentos humanos.
• Baixa: aproveitar a vulnerabilidade pode resultar em algum grau de perda financeira ou impacto na missão e
reputação da organização.
Risco Geral
Uma vez que a probabilidade de ocorrência e o impacto foram determinados, você pode determinar a classificação de risco geral, que é
definida como uma função das duas classificações. O risco geral pode ser classificado como Baixo, Médio ou Alto, o que fornece
orientação aos responsáveis pela proteção e manutenção dos sistemas em questão.
• Alta: há um forte requisito de medidas adicionais a serem implementadas para proteger contra a vulnerabilidade.
Em alguns casos, o sistema pode continuar operando, mas um plano deve ser elaborado e implementado o mais
rápido possível.
• Médio: há um requisito para medidas adicionais a serem implementadas para proteger contra a vulnerabilidade.
Um plano para implementar as medidas necessárias deve ser feito em tempo hábil.

• Baixo: O proprietário do sistema determinará se implementará medidas adicionais para proteger contra a
vulnerabilidade ou poderá optar por aceitar o risco e deixar o sistema inalterado.
Em suma
Com tantos fatores constituindo o verdadeiro risco de uma vulnerabilidade descoberta, as classificações de risco predefinidas da saída da ferramenta
devem ser usadas apenas como um ponto de partida para determinar o verdadeiro risco para a organização como um todo.
Relatórios criados com competência a partir de uma avaliação de vulnerabilidade, quando analisados por um profissional, podem fornecer
uma base inicial para outras avaliações, como testes de penetração de conformidade. Como tal, é importante compreender como obter os
melhores resultados possíveis a partir desta avaliação inicial.
Kali é uma excelente plataforma para conduzir uma avaliação de vulnerabilidade e não precisa de nenhuma configuração
especial. No menu Aplicativos Kali, você encontrará várias ferramentas para vul-
avaliações de capacidade no Coleta de informações, análise de vulnerabilidade, e Aplicativo da Web
Análise categorias. Vários sites, incluindo o acima mencionado Lista de ferramentas Kali Linux 13 , Documentação oficial do Kali
Linux 14 site, e o gratuito Metasploit Unleashed 15 O curso fornece recursos excelentes para usar o Kali Linux durante uma
avaliação de vulnerabilidade.
11.2.2. Teste de penetração de conformidade
O próximo tipo de avaliação em ordem de complexidade é um teste de penetração baseado em conformidade. Esses são os testes
de penetração mais comuns, pois são requisitos exigidos pelo governo e pelo setor, com base em uma estrutura de conformidade
sob a qual toda a organização opera.
Embora existam muitas estruturas de conformidade específicas do setor, o mais comum provavelmente seria Padrão de segurança de dados
da indústria de cartões de pagamento 16 ( PCI DSS), uma estrutura ditada por empresas de cartão de pagamento que os varejistas que
processam pagamentos com cartão devem cumprir. No entanto, existem vários outros padrões, como o Guias de implementação técnica de
segurança de agências de sistemas de informações de defesa 17 ( DISA STIG), Programa Federal de Gerenciamento de Risco e Autorização 18
(FedRAMP), Lei Federal de Gestão de Segurança da Informação 19 ( FISMA) e outros. Em alguns casos, um cliente corporativo pode
solicitar uma avaliação ou pedir para ver os resultados da avaliação mais recente por vários motivos. Quer sejam ad-hoc ou
solicitados, esses tipos de avaliações são coletivamente
13 http://tools.kali.org/tools-listing
14 http://docs.kali.org
15 https://www.offensive-security.com/metasploit-unleashed/
16 https://www.pcisecuritystandards.org/documents/Penetration_Testing_Guidance_March_2015.pdf
17 http://iase.disa.mil/stigs/Pages/index.aspx
18 https://www.fedramp.gov/about-us/about/
19 http://csrc.nist.gov/groups/SMA/fisma/

chamados de testes de penetração baseados em conformidade ou simplesmente “avaliações de conformidade” ou “verificações de conformidade”.
Um teste de conformidade geralmente começa com uma avaliação de vulnerabilidade. No caso de Auditoria de conformidade PCI 20 , uma
avaliação de vulnerabilidade, quando realizada corretamente, pode satisfazer vários dos requisitos básicos, incluindo: “2. Não use
padrões fornecidos pelo fornecedor para senhas de sistema e outros parâmetros de segurança ”(por exemplo, com ferramentas do Ataques
de senha categoria do menu), “11. Teste regularmente os sistemas e processos de segurança ”(com ferramentas do Avaliação de banco
de dados categoria) e outros. Alguns requisitos, como “9. Restringir o acesso físico aos dados do titular do cartão ”e“ 12. Manter uma
política que trate da segurança das informações para todos os funcionários ”não parecem se adequar à avaliação de vulnerabilidade
tradicional baseada em ferramentas e exigem criatividade e testes adicionais.
Apesar do fato de que pode não parecer simples usar Kali Linux para alguns elementos de um teste de conformidade, o fato é que Kali
se encaixa perfeitamente neste ambiente, não apenas por causa da ampla gama de ferramentas relacionadas à segurança, mas por
causa do ambiente Debian de código aberto no qual é construído, permitindo a instalação de uma ampla gama de ferramentas.
Pesquisar o gerenciador de pacotes com palavras-chave cuidadosamente escolhidas de qualquer estrutura de conformidade que você
esteja usando quase certamente gerará vários resultados. Do jeito que está, muitas organizações usam Kali Linux como plataforma
padrão para esses tipos exatos de avaliações.
11.2.3. Teste de Penetração Tradicional
Um teste de penetração tradicional tornou-se um item difícil de definir, com muitos trabalhando a partir de definições diferentes,
dependendo do espaço em que operam. Parte dessa confusão de mercado é motivada pelo fato de que o termo “Teste de
Penetração” se tornou mais comum usado para o teste de penetração baseado em conformidade mencionado anteriormente (ou
mesmo uma avaliação de vulnerabilidade) onde, por design, você não está se aprofundando muito na avaliação porque isso iria
além dos requisitos mínimos.
Para os fins desta seção, evitaremos esse debate e usaremos essa categoria para cobrir avaliações que vão além dos
requisitos mínimos; avaliações que são projetadas para realmente melhorar a segurança geral da organização.
Ao contrário dos tipos de avaliação discutidos anteriormente, os testes de penetração nem sempre começam com uma definição de escopo,
mas sim um objetivo como "simular o que aconteceria se um usuário interno fosse comprometido" ou "identificar o que aconteceria se o
organização sofreu um ataque direcionado por uma parte externa mal-intencionada. ” O principal diferencial desses tipos de avaliação é que
eles não apenas localizam e validam vulnerabilidades, mas, em vez disso, aproveitam os problemas identificados para descobrir o pior
cenário. Em vez de depender apenas de conjuntos de ferramentas de varredura de vulnerabilidades pesadas, você deve acompanhar com a
validação das descobertas por meio do uso de explorações ou testes para eliminar falsos positivos e fazer o melhor para detectar
vulnerabilidades ocultas ou falsos negativos. Isso muitas vezes envolve explorar
20 https://www.pcisecuritystandards.org/documents/PCIDSS_QRGv3_2.pdf

vulnerabilidades descobertas inicialmente, explorando o nível de acesso que a exploração fornece e usando esse acesso aumentado
como alavanca para ataques adicionais contra o alvo.
Isso requer uma revisão crítica do ambiente de destino junto com pesquisa manual, criatividade e pensamento inovador para
descobrir outras vias de vulnerabilidade potencial e, em última análise, usar outras ferramentas e testes fora daqueles encontrados
pelos scanners de vulnerabilidade mais pesados. Depois de concluído, geralmente é necessário reiniciar todo o processo várias
vezes para fazer um trabalho completo e completo.
Mesmo com essa abordagem, você frequentemente descobrirá que muitas avaliações são compostas de fases diferentes. Kali torna
mais fácil encontrar programas para cada fase por meio do Menu Kali:
• Coleta de informações: nesta fase, você se concentra em aprender o máximo possível sobre o ambiente de destino.
Normalmente, esta atividade não é invasiva e aparecerá semelhante à atividade do usuário padrão. Essas ações
constituirão a base do restante da avaliação e, portanto, precisam ser o mais completas possível. Kali's Coleta de
informações A categoria possui dezenas de ferramentas para revelar o máximo de informações possível sobre o
ambiente que está sendo avaliado.
• VulnerabilityDiscovery: Isso geralmente será chamado de “coleta ativa de informações”, onde você não ataca, mas se envolve
em um comportamento de usuário não padrão na tentativa de identificar vulnerabilidades potenciais no ambiente de destino. É
aqui que a verificação de vulnerabilidade discutida anteriormente ocorrerá com mais frequência. Os programas listados no Análise
de vulnerabilidade,
Análise de aplicativos da Web, avaliação de banco de dados, e Engenharia reversa categorias serão
útil para esta fase.
• Exploração: com as vulnerabilidades potenciais descobertas, nesta fase você tenta explorá-las para se firmar no
alvo. Ferramentas para auxiliá-lo nesta fase podem ser encontradas no
Análise de aplicativos da Web, avaliação de banco de dados, ataques de senha, e Ferramentas de exploração
categorias.
• Pivotagem e Exfiltração: Uma vez que a base inicial é estabelecida, outras etapas devem ser concluídas.
Freqüentemente, esses privilégios são escalonados para um nível adequado para atingir seus objetivos como invasor,
direcionando-se para outros sistemas que podem não estar disponíveis para você e exfiltrando informações
confidenciais dos sistemas visados. Consulte o
Ataques de senha, ferramentas de exploração, sniffing e falsificação, e Pós-exploração categorias

para ajudar nesta fase.
• Relatório: depois que a parte ativa da avaliação for concluída, você deve documentar e relatar as atividades que foram
realizadas. Essa fase geralmente não é tão técnica quanto as fases anteriores; no entanto, é muito importante
garantir que seu cliente obtenha o valor total do trabalho concluído. o Ferramentas de relatórios A categoria contém
uma série de ferramentas que se mostraram úteis na fase de relatório.
Na maioria dos casos, essas avaliações serão muito exclusivas em seu design, pois cada organização operará com diferentes
ameaças e ativos para proteger. Kali Linux é uma base muito versátil para

esses tipos de avaliações e é aqui que você pode realmente tirar proveito dos muitos recursos de personalização do Kali Linux.
Muitas organizações que conduzem esses tipos de avaliações manterão versões altamente personalizadas do Kali Linux para uso
interno para acelerar a implantação de sistemas antes de uma nova avaliação.
As personalizações que as organizações fazem em suas instalações Kali Linux geralmente incluem:
• Pré-instalação de pacotes comerciais com informações de licenciamento. Por exemplo, você pode ter um pacote como um
scanner de vulnerabilidade comercial que gostaria de usar. Para evitar ter que instalar este pacote com cada construção, você
pode fazer isso uma vez 21 e fazer com que apareça em cada implantação de Kali que você fizer.
• Redes privadas virtuais (VPN) de conexão pré-configuradas. Eles são muito úteis para deixar para trás dispositivos que
permitem que você conduza avaliações "internas remotas". Na maioria dos casos, esses sistemas se conectarão a um
sistema controlado pelo avaliador, criando um túnel que o avaliador pode usar para acessar os sistemas internos. o Kali
Linux ISO of Doom 22 é um exemplo desse tipo exato de personalização.
• Software e ferramentas desenvolvidos internamente pré-instalados. Muitas organizações terão conjuntos de ferramentas privadas, portanto,
configurá-los uma vez em um instalação Kali personalizada 23 poupa tempo.
• Configurações de sistema operacional pré-configuradas, como mapeamentos de host, papel de parede de mesa, configurações de proxy, etc.
Muitos usuários Kali têm configurações específicas 24 eles gostam de ter ajustado exatamente isso. Se você vai fazer uma nova implantação
de Kali regularmente, capturar essas mudanças faz muito sentido.
11.2.4. Avaliação de Aplicação
Embora a maioria das avaliações tenha um escopo amplo, uma avaliação de aplicativo é uma especialidade que se concentra apenas em um
único aplicativo. Esses tipos de avaliações estão se tornando mais comuns devido à complexidade dos aplicativos essenciais que as
organizações usam, muitos dos quais são desenvolvidos internamente. Uma avaliação de aplicativo geralmente é adicionada a uma
avaliação mais ampla, conforme necessário. Os aplicativos que podem ser avaliados desta maneira incluem, mas não estão limitados a:
• Aplicativos da Web: a superfície de ataque mais comum voltada para o exterior, os aplicativos da Web são ótimos alvos
simplesmente porque são acessíveis. Freqüentemente, as avaliações padrão encontrarão problemas básicos em aplicativos da
web, no entanto, uma revisão mais focada geralmente vale o tempo para identificar problemas relacionados ao fluxo de trabalho
do aplicativo. o kali-linux-web O meta-pacote tem várias ferramentas para ajudar nessas avaliações.
• Aplicativos de desktop compilados: o software de servidor não é o único alvo; os aplicativos de desktop também constituem uma
excelente superfície de ataque. Nos últimos anos, muitos aplicativos de desktop, como
21 http://docs.kali.org/kali-dojo/02-mastering-live-build
22 https://www.offensive-security.com/kali-linux/kali-rolling-iso-of-doom/
23 http://docs.kali.org/development/live-build-a-custom-kali-iso
24 https://www.offensive-security.com/kali-linux/kali-linux-recipes/

Leitores de PDF ou programas de vídeo baseados na web foram altamente direcionados, forçando-os a amadurecer. No entanto, ainda há um
grande número de aplicativos de desktop que apresentam uma grande variedade de vulnerabilidades quando revisados adequadamente.
• Aplicativos móveis: conforme os dispositivos móveis se tornam mais populares, os aplicativos móveis se tornarão muito mais uma
superfície de ataque padrão em muitas avaliações. Esta é uma meta em rápida evolução e as metodologias ainda estão em maturação
nesta área, levando a novos desenvolvimentos praticamente todas as semanas. Ferramentas relacionadas à análise de aplicativos
móveis podem ser encontradas em
a Engenharia reversa categoria do menu.
As avaliações de aplicativos podem ser realizadas de várias maneiras diferentes. Como um exemplo simples, uma ferramenta automatizada
específica do aplicativo pode ser executada no aplicativo na tentativa de identificar possíveis problemas. Essas ferramentas usarão a lógica
específica do aplicativo na tentativa de identificar problemas desconhecidos, em vez de apenas depender de um conjunto de assinaturas
conhecidas. Essas ferramentas devem ter um entendimento integrado do comportamento do aplicativo. Um exemplo comum disso seria um
scanner de vulnerabilidade de aplicativo da web, como Suíte Burp 25 , direcionado contra um aplicativo que primeiro identifica vários campos de
entrada e, em seguida, envia ataques de injeção de SQL comuns a esses campos enquanto monitora a resposta do aplicativo em busca de
indicações de um ataque bem-sucedido.
Em um cenário mais complexo, uma avaliação do aplicativo pode ser conduzida interativamente em um
caixa preta ou caixa branca maneira.
• Avaliação da caixa preta: a ferramenta (ou avaliador) interage com o aplicativo sem nenhum conhecimento especial
ou acesso além do usuário padrão. Por exemplo, no caso de um aplicativo da web, o avaliador só pode ter acesso às
funções e recursos que estão disponíveis para um usuário que não se logou no sistema. Quaisquer contas de
usuário usadas seriam aquelas em que um usuário geral pode se autorregistrar. Isso evitaria que o invasor pudesse
revisar qualquer funcionalidade disponível apenas para usuários que precisem ser criados por um administrador.
• Avaliação da caixa branca: a ferramenta (ou avaliador) geralmente terá acesso total ao código-fonte, acesso administrativo à
plataforma que executa o aplicativo e assim por diante. Isso garante que uma revisão completa e abrangente de todas as
funcionalidades do aplicativo seja concluída, independentemente de onde essa funcionalidade esteja no aplicativo. A
desvantagem disso é que a avaliação não é de forma alguma uma simulação da atividade maliciosa real.
Obviamente, há tons de cinza entre eles. Normalmente, o fator decisivo é o objetivo da avaliação. Se o objetivo for identificar o
que aconteceria no caso de o aplicativo sofrer um ataque externo focado, uma avaliação de caixa preta provavelmente seria a
melhor. Se o objetivo é identificar e eliminar tantos problemas de segurança quanto possível em um período de tempo
relativamente curto, uma abordagem de caixa branca pode ser mais eficiente.
25 https://portswigger.net/burp/

Em outros casos, uma abordagem híbrida pode ser adotada em que o avaliador não tem acesso total ao código-fonte do aplicativo da
plataforma que executa o aplicativo, mas as contas de usuário são fornecidas por um administrador para permitir o acesso ao máximo
possível de funcionalidade do aplicativo.
Kali é uma plataforma ideal para todos os tipos de avaliações de aplicativos. Em uma instalação padrão, uma variedade de diferentes
scanners específicos para aplicativos estão disponíveis. Para avaliações mais avançadas, existe uma variedade de ferramentas,
editores de origem e ambientes de script. Você pode encontrar o Aplicação Web 26 e Engenharia reversa 27 seções do Ferramentas Kali 28 site
útil.
11.3. Formalização da Avaliação
Com seu ambiente Kali pronto e o tipo de avaliação definido, você está quase pronto para começar a trabalhar. Seu último passo é
formalizar o trabalho a ser feito. Isso é extremamente importante, pois define quais serão as expectativas para o trabalho e concede a
você permissão para conduzir o que, de outra forma, poderia ser uma atividade ilegal. Abordaremos isso em um alto nível, mas esta é
uma etapa muito complexa e importante, então você provavelmente desejará verificar com o representante legal de sua organização
para obter ajuda.
Como parte do processo de formalização, você precisará definir as regras de contratação para a obra. Isso cobre itens
como:
• Com quais sistemas você tem permissão para interagir? É importante garantir que você não interfira acidentalmente com nada
que seja crítico para as operações de negócios.
• A que hora do dia e em que janela de ataque a avaliação pode ocorrer? Algumas organizações gostam de limitar os
horários em que o trabalho de avaliação pode ser realizado.
• Quando você descobre uma vulnerabilidade potencial, tem permissão para explorá-la? Se não, qual é o processo de aprovação?
Existem algumas organizações que adotam uma abordagem muito controlada para cada tentativa de exploração, enquanto outras
gostariam de uma abordagem mais realista. É melhor definir essas expectativas claramente antes de o trabalho começar.
• Se um problema significativo for descoberto, como ele deve ser tratado? Às vezes, as organizações desejam ser informadas
imediatamente, caso contrário, normalmente isso é tratado no final da avaliação.
• Em caso de emergência, quem você deve contatar? É sempre importante saber com quem entrar em contato quando ocorrer um
problema de qualquer tipo.
• Quem saberá sobre a atividade? Como isso será comunicado a eles? Em alguns casos, as organizações desejarão
testar sua resposta a incidentes e desempenho de detecção como parte da avaliação. É sempre uma boa ideia saber
isso com antecedência, para que você saiba se deve tomar algum grau de discrição na abordagem da avaliação.
26 http://tools.kali.org/category/web-applications
27 http://tools.kali.org/category/reverse-engineering
28 http://tools.kali.org

• Quais são as expectativas no final da avaliação? Como os resultados serão comunicados? Saiba o que todas as
partes esperam no final da avaliação. Definir a entrega é a melhor maneira de manter todos felizes após a
conclusão do trabalho.
Embora não seja completa, esta lista dá uma ideia dos detalhes que devem ser cobertos. No entanto, você deve perceber que
não há substituto para uma boa representação legal. Uma vez que esses itens são definidos, você precisa adquirir a autorização
adequada para realizar a avaliação, uma vez que muitas das atividades que você fará no decorrer de uma avaliação podem não
ser legais sem a devida autoridade de alguém com autoridade para dar essa permissão.
Com tudo isso implementado, ainda há uma última etapa que você deve dar antes de começar a trabalhar: a validação. Nunca
confie no escopo fornecido - sempre valide-o. Use várias fontes de informação para confirmar que os sistemas dentro do
escopo são de fato propriedade do cliente e que são operados pelo cliente também. Com a prevalência dos serviços em
nuvem, uma organização pode esquecer que não possui realmente os sistemas que fornecem o serviço. Você pode descobrir
que precisa obter permissão especial de um provedor de serviços em nuvem antes de começar a trabalhar. Além disso,
sempre valide os blocos de endereços IP. Não conte com a suposição de que a organização possui blocos inteiros de IP,
mesmo que eles sejam alvos viáveis. Por exemplo, vimos exemplos de organizações que solicitam uma avaliação de toda uma
faixa de rede de classe C quando, na verdade, elas possuíam apenas um subconjunto desses endereços. Ao atacar todo o
espaço de endereço de classe C, teríamos acabado atacando os vizinhos de rede da organização. o Análise OSINT subcategoria
do Coleta de informações O menu contém várias ferramentas que podem ajudá-lo neste processo de validação.
11,4. Tipos de Ataques
Uma vez que o trabalho esteja ocorrendo, quais são alguns dos tipos específicos de ataques que você estará conduzindo? Cada tipo de
vulnerabilidade 29 tem suas próprias técnicas de exploração associadas. Esta seção cobrirá as várias classes de vulnerabilidades com as
quais você irá interagir com mais freqüência.
Não importa a categoria de vulnerabilidade que você esteja procurando, Kali torna essas ferramentas e exploits fáceis de encontrar. O
menu Kali na interface gráfica do usuário é dividido em categorias para ajudar a tornar a ferramenta certa mais fácil de encontrar. Além
disso, o Site da Kali Tools 30 tem listas abrangentes das várias ferramentas disponíveis em Kali, organizadas por categoria e marcadas para
facilitar a navegação. Cada entrada contém informações detalhadas sobre a ferramenta, bem como exemplos de uso.
29 https://www.cvedetails.com/vulnerabilities-by-types.php
30 http://tools.kali.org/tools-listing

11.4.1. Negação de serviço
Ataques de negação de serviço alavancam uma vulnerabilidade para criar uma perda de serviço, frequentemente travando o processo
vulnerável. o Teste de Estresse categoria do Kali Linuxmenu contém uma série de ferramentas para esse propósito.
Quando muitas pessoas ouvem o termo “ataque de negação de serviço”, elas imediatamente pensam em ataques de consumo de recursos
que são enviados de várias fontes ao mesmo tempo contra um único alvo. Isso seria um distribuído ataque de negação de serviços ou
DDoS. Esses tipos de ataques raramente fazem parte de uma avaliação de segurança profissional.
Em vez disso, um ataque de negação de serviço singular é geralmente o resultado de uma tentativa inadequada de explorar uma
vulnerabilidade. Se um gravador de exploit liberar código parcialmente funcional ou de prova de conceito (PoC) e for usado em campo, isso
pode criar uma condição de negação de serviço. Mesmo um exploit devidamente codificado pode funcionar apenas em circunstâncias muito
específicas, mas causar uma negação de serviço em circunstâncias menores. Pode parecer que a solução é usar apenas código de
exploração seguro e testado ou escrever o seu próprio. Mesmo com essa solução, não há garantias e isso limita muito o avaliador, causando
constrangimentos indevidos, o que resulta em uma avaliação menor. Em vez disso, a chave é o compromisso. Evite código PoC e exploits
não testados no campo e sempre certifique-se de que um advogado o tenha coberto para outros contratempos.
Normalmente, os ataques de negação de serviço não são iniciados intencionalmente. A maioria das ferramentas de vulnerabilidade automatizadas irá
declarar vulnerabilidades de negação de serviço como risco mais baixo devido ao fato de que embora você possa remover um serviço de operação,
esse serviço não pode ser explorado para execução de código. No entanto, é importante lembrar que nem todos os exploits são lançados publicamente
e uma vulnerabilidade de negação de serviço pode mascarar uma ameaça mais profunda e séria. Uma exploração de execução de código para uma
negação de serviço conhecida pode existir, mas não ser pública. A questão é: preste atenção às vulnerabilidades de negação de serviço e incentive seu
cliente a fazer o patch, independentemente de sua classificação de ameaça (geralmente baixa).
11.4.2. Corrupção de memória
Uma corrupção de memória ocorre quando um local dentro do espaço de memória de um processo é modificado acidentalmente devido a erros
de programação. Os erros de corrupção de memória geralmente levam a um comportamento imprevisível do programa, no entanto, em muitos
casos, esses erros permitem a manipulação da memória do processo de tal forma que o fluxo de execução do programa pode ser controlado,
permitindo a atividade definida pelo invasor.
Esses ataques são normalmente chamados de estouros de buffer, embora esse termo seja uma simplificação excessiva. Os
tipos mais comuns de corrupção de memória são muito diferentes uns dos outros e têm suas próprias táticas e técnicas
necessárias para uma exploração bem-sucedida.
• Estouro do buffer da pilha: quando um programa grava mais dados em um buffer da pilha do que o espaço disponível para ele, a
memória adjacente pode ser corrompida, geralmente causando o travamento do programa.

• Corrupção de heap: a memória de heap é alocada em tempo de execução e geralmente contém dados do programa em execução. As
corrupções de heap ocorrem ao manipular os dados para sobrescrever por meio da lista vinculada de ponteiros de memória de heap.
• Estouro de inteiros: esses estouros ocorrem quando um aplicativo tenta criar um valor numérico que não pode ser contido em seu
espaço de armazenamento alocado.
• Format String: quando um programa aceita a entrada do usuário e a formata sem verificá-la, os locais da memória podem
ser revelados ou substituídos, dependendo dos tokens de formato usados.
11.4.3. Vulnerabilidades da web
Devido ao fato de que os sites modernos da web não são páginas estáticas mais longas, mas, em vez disso, gerados dinamicamente para
o usuário, o site médio é bastante complexo. As vulnerabilidades da Web tiram proveito dessa complexidade em um esforço para atacar a
lógica de geração da página de back-end ou a apresentação ao visitante do site.
Esses tipos de ataques são extremamente comuns, pois muitas organizações chegaram ao ponto em que têm poucos
serviços externos. Dois dos tipos de ataques de aplicativos da web mais prevalentes 31 são injeção de SQL e script entre
sites (XSS).
• Injeção de SQL: esses ataques tiram proveito de aplicativos mal programados que não higienizam adequadamente a
entrada do usuário, levando à capacidade de extrair informações do banco de dados ou até mesmo ao controle total do
servidor.
• Scripts entre sites: como ocorre com a injeção de SQL, os ataques XSS resultam da higienização inadequada da entrada do usuário,
permitindo que os invasores manipulem o usuário ou site para executar o código no contexto de sua própria sessão do navegador.
Aplicativos da web complexos, ricos e complicados são muito comuns, apresentando uma superfície de ataque bem-vinda para partes
mal-intencionadas. Você encontrará um grande número de ferramentas úteis no Análise de aplicativos da web categoria de menu e o kali-linux-web
metapacote.
11.4.4. Ataques de senha
Ataques de senha são ataques contra o sistema de autenticação de um serviço. Esses ataques são frequentemente divididos
em ataques de senha online e ataques de senha offline, que você encontrará refletidos no Ataques de senha categoria do
menu. Em um ataque de senha online, várias senhas são tentadas contra um sistema em execução. Em um ataque de senha
offline, os valores criptografados ou criptografados das senhas são obtidos e o invasor tenta obter os valores de texto não
criptografado. A proteção contra esse tipo de ataque é o fato de que é computacionalmente caro trabalhar nesse processo,
limitando o número de tentativas por segundo que você pode gerar. Contudo,
31 https://www.owasp.org/index.php/Top_10_2013-Top_10

existem soluções alternativas para isso, como usar unidades de processador gráfico (GPUs) para acelerar o número de tentativas que
podem ser feitas. o kali-linux-gpu O metapacote contém uma série de ferramentas que exploram esse poder.
Mais comumente, os ataques de senha têm como alvo senhas padrão fornecidas pelo fornecedor. Como esses são valores bem
conhecidos, os invasores farão a varredura dessas contas padrão, na esperança de ter sorte. Outros ataques comuns incluem ataques de
dicionário personalizado em que uma lista de palavras é criada sob medida para o ambiente de destino e, em seguida, um ataque de
senha online contra contas comuns, padrão ou conhecidas é conduzido onde cada palavra é tentada em sequência.
Em uma avaliação, é muito importante entender as consequências potenciais desse tipo de ataque. Primeiro, eles costumam ser muito
barulhentos devido às repetidas tentativas de autenticação. Em segundo lugar, esses ataques podem muitas vezes resultar em uma
situação de bloqueio de conta após muitas tentativas inválidas serem realizadas contra uma única conta. Finalmente, o desempenho
desses ataques costuma ser bastante lento, resultando em dificuldade ao tentar usar uma lista de palavras abrangente.
11.4.5. Ataques do lado do cliente
A maioria dos ataques é conduzida contra servidores, mas como os serviços se tornaram mais difíceis de atacar, alvos mais fáceis foram
selecionados. Os ataques do lado do cliente são o resultado disso, em que um invasor tem como alvo os vários aplicativos instalados na
estação de trabalho de um funcionário dentro de uma organização alvo. o Ferramentas de Engenharia Social A categoria de menu tem vários
aplicativos excelentes que podem ajudar a conduzir esses tipos de ataques.
Esse tipo de ataque é mais bem explorado pelos ataques Flash, Acrobat Reader e Java, que eram muito comuns no início dos anos 2000.
Nesses casos, os invasores tentariam solicitar a um alvo para visitar uma página da web ilegal. Essas páginas conteriam código
especializado que desencadearia vulnerabilidades nesses aplicativos do lado do cliente, resultando na capacidade de executar código
malicioso no sistema de destino.
Ataques do lado do cliente são incrivelmente difíceis de prevenir, exigindo muita educação do usuário, atualizações constantes de
aplicativos e controles de rede para mitigar o risco de forma eficaz.
11,5. Resumo
Neste capítulo, demos uma breve olhada no papel de Kali no campo da segurança da informação. Discutimos a importância
de uma instalação limpa e funcional e o uso de criptografia antes de sair para o campo para proteger as informações do seu
cliente, e a importância da representação legal para proteger você e os interesses do seu cliente.
Os componentes da tríade CIA (confidencialidade, integridade, disponibilidade) são os itens principais nos quais você se
concentrará ao proteger um sistema como parte da implantação, manutenção ou avaliação padrão. Esta base conceitual irá
ajudá-lo com a identificação do componente crítico

componentes de seus sistemas e a quantidade de esforço e recursos que vale a pena investir para corrigir os problemas identificados.
Discutimos vários tipos de vulnerabilidades, incluindo inclusão de arquivo, injeção de SQL, estouro de buffer e condições de
corrida.
A precisão das assinaturas é extremamente importante para obter resultados úteis de avaliação de vulnerabilidade. Quanto mais dados são
fornecidos, maior a chance de obter resultados precisos de uma varredura automatizada baseada em assinatura, motivo pelo qual as
varreduras autenticadas costumam ser tão populares.
Como as ferramentas automatizadas usam um banco de dados de assinaturas para detectar vulnerabilidades, qualquer pequeno desvio de uma
assinatura conhecida pode alterar o resultado e também a validade da vulnerabilidade percebida.
Também discutimos os quatro tipos de avaliações: o avaliação de vulnerabilidade, teste de conformidade, teste de penetração tradicional, e a
avaliação de aplicação. Embora cada tipo de avaliação aproveite um conjunto básico de ferramentas, muitas das ferramentas e técnicas se
sobrepõem.
A avaliação de vulnerabilidade é relativamente simples em comparação com os outros tipos de avaliação e geralmente consiste em um
inventário automatizado de problemas descobertos em um ambiente de destino. Nesta seção, discutimos que uma vulnerabilidade é uma
falha que, quando explorada, compromete a confidencialidade, integridade ou disponibilidade de um sistema de informação. Por ser
baseado em assinaturas, esse tipo de avaliação conta com assinaturas precisas e pode apresentar falsos positivos e negativos. Você
encontrará as principais ferramentas para este tipo de avaliação no Análise de Vulnerabilidade e Ferramentas de exploração categorias de
menu do Kali Linux.
Os testes de conformidade são baseados em requisitos exigidos pelo governo e pelo setor (como PCI DSS, DISA STIG e FISMA), que por
sua vez são baseados em uma estrutura de conformidade. Este teste geralmente começa com uma avaliação de vulnerabilidade.
Um teste de penetração tradicional é uma avaliação de segurança completa projetada para melhorar a postura geral de
segurança de uma organização com base em certas ameaças do mundo real. Este tipo de teste envolve várias etapas
(espelhadas pela estrutura do menu Kali Linux) e culmina na exploração de vulnerabilidades e acesso dinâmico a outras
máquinas e redes dentro do escopo alvo.
As avaliações de aplicativos (geralmente caixa branca ou preta) se concentram em um único aplicativo e usam especialidades
ferramentas especializadas, como as encontradas no Análise de aplicativos da Web, avaliação de banco de dados, engenharia reversa, e Ferramentas
de exploração categorias do menu.
Vários tipos de ataques foram discutidos, incluindo: negação de serviço, que interrompe o comportamento de um aplicativo e o torna
inacessível; corrupção de memória, que leva à manipulação da memória do processo, muitas vezes permitindo a execução de código do
invasor; ataques da Web, que atacam serviços da Web usando técnicas como injeção de SQL e ataques XSS; e ataques de senha, que
muitas vezes aproveitam listas de senha para atacar credenciais de serviço.

Palavras-chave
Mudanças constantes
Certificações
Treinamentos
pter
Conclusão: o 1 2 Cha
Estrada adiante
Conteúdo
Acompanhando as mudanças 302 Mostrando o seu conhecimento recém-adquirido 302 Indo além 302
Parabéns! Esperamos que você agora esteja mais familiarizado com seu sistema Kali Linux e não tenha medo de usá-lo
para qualquer experiência que possa imaginar. Você descobriu seus recursos mais interessantes, mas também conhece
seus limites e várias maneiras de contornar essas limitações.
Se você não colocou todos os recursos em prática, mantenha este livro por perto para fins de referência e refresque sua memória quando
estiver prestes a experimentar um novo recurso. Lembre-se de que não há nada melhor do que prática (e perseverança) para desenvolver
novas habilidades. Tente mais 1 , como os treinadores de segurança ofensiva continuam repetindo.
12,1. Acompanhando as mudanças
Com uma distribuição em constante mudança, como kali-rolling, algumas partes do livro necessariamente se tornarão obsoletas.
Faremos o nosso melhor para mantê-lo atualizado (pelo menos para a versão online), mas na maioria das partes tentamos fornecer
explicações genéricas que devem ser úteis por muito tempo.
Dito isso, você deve estar pronto para abraçar as mudanças e descobrir soluções para qualquer problema que possa surgir.
Com o melhor entendimento do Kali Linux e seu relacionamento com o Debian, você pode contar com as comunidades Kali e
Debian e seus numerosos recursos (rastreadores de bugs, fóruns, listas de e-mail, etc.) quando tiver problemas.
Não tenha medo de enviar bugs (veja a seção 6,3 , “ Arquivando um bom relatório de bug ”[Página 129])! Se você for como eu, quando tiver
concluído as etapas envolvidas no preenchimento de um bom relatório de bug (e isso leva algum tempo), você terá resolvido o problema ou
pelo menos encontrado uma boa solução alternativa. E ao preencher o bug, você estará ajudando outras pessoas que são afetadas pelo
problema.
12,2. Mostrando o seu conhecimento recém-adquirido
Você está orgulhoso de suas novas habilidades no Kali Linux? Você gostaria de se certificar de que se lembra das coisas realmente
importantes? Se você responder sim a uma dessas perguntas, você deve considerar a inscrição no programa Profissional Certificado
Kali Linux.
É uma certificação abrangente que garantirá que você saiba como implantar e usar o Kali Linux em muitos casos de uso realistas.
É uma boa adição ao seu currículo e também prova que você está pronto para ir mais longe.
12,3. Indo além
Este livro ensinou muitas coisas que qualquer usuário do Kali Linux deve saber, mas fizemos algumas escolhas difíceis para
mantê-lo curto, e há muitos tópicos que não foram abordados.
1 https://www.offensive-security.com/offsec/say-try-harder/

12.3.1. Em direção à administração do sistema
Se você quiser aprender mais sobre administração de sistema, então só podemos recomendar que você verifique o Manual
do Administrador Debian:
è https://debian-handbook.info/get/
Você encontrará muitos capítulos suplementares cobrindo serviços Unix comuns que ignoramos totalmente neste livro. E mesmo
para capítulos que foram reutilizados no livro Kali, você encontrará muitas dicas suplementares, principalmente sobre o sistema
de embalagem (que também é abordado de forma mais extensa em seu nível mais baixo).
O livro Debian obviamente apresenta mais profundamente a comunidade Debian e a maneira como ela é organizada. Embora este
conhecimento não seja vital, é realmente útil quando você precisa interagir com contribuidores Debian, por exemplo, através de relatórios
de bug.
12.3.2. Rumo ao teste de penetração
Você provavelmente já percebeu que este livro não lhe ensinou o teste de penetração. Mas as coisas que você aprendeu ainda são
importantes. Agora você está pronto para explorar totalmente o poder do Kali Linux, a melhor estrutura de teste de penetração. E você tem
as habilidades básicas do Linux necessárias para participar do treinamento do Offensive Security.
Se você acha que ainda não está pronto para um curso pago, pode começar seguindo o Metasploit Unleashed 2 treinamento online
gratuito. Metasploit é uma ferramenta de teste de penetração muito popular e você tem que saber se você está levando a sério seus
planos de aprender o teste de penetração.
O próximo passo lógico seria seguir o Teste de penetração com Kali Linux 3 curso online conduzindo o caminho para a
famosa certificação “Offensive Security Certified Professional”. Este curso online pode ser seguido no seu próprio ritmo,
mas a certificação é na verdade um difícil teste de penetração prático, com duração de 24 horas e que ocorre em uma
rede VPN isolada.
Você está pronto para o desafio?
2 https://www.offensive-security.com/metasploit-unleashed/
3 https://www.offensive-security.com/information-security-training/
Capítulo 12 - Conclusão: O Caminho à Frente 303

Índice
_ adicionar um usuário a um grupo, 108
. config, 235 adicionar grupo, 109
. d, 195 adicionar usuário, 108
. htaccess, 116 senha de administrador, 72

/ dev, 48 Ferramenta de Pacote Avançado, 171
/etc/apt/apt.conf.d/, 195 auxiliar (pacote Debian), 163

/ etc / apt / preferências, 196 AllowOverride, diretiva Apache, 115 , 116
/etc/apt/sources.list, 172 análise
/etc/apt/trusted.gpg.d/, 203 vulnerabilidade, 6
/ etc / group, 107 aplicação web, 6

/ etc / gshadow, 107 ansible, 255
/ etc / network / interfaces, 105 Apache, 113
/ etc / passwd, 107 diretivas, 115
/ etc / salt / minion, 255 Diretivas Apache, 116
/ etc / shadow, 107 avaliações de aplicativos, 291
/ etc / ssh / sshd_config, 110 formulários
/ proc, 48 coleção, 10
/ sys, 48 cardápio, 5
/ var / lib / dpkg /, 212 aplicando um patch, 227
/ var / www / html /, 114 a propósito, 124
CPU de 32 bits, 16 APT, 171
CPU de 64 bits, 16 configuração, 195

exibição do cabeçalho, 185
UMA configuração inicial, 81

a2dismod, 113 interfaces, 190
a2enmod, 113 busca de pacotes, 185
a2ensite, 114 fixação, 196
ACEITAR, 155 preferências, 196
conta apto, 176
criação, 107 apt build-dep, 226

desativar, 109 apt dist-upgrade, 179
modificação, 108 apt full-upgrade, 179
atividade, monitoramento, 162 apt install, 177
purge apt, 180 Instalações ARM, 94
apt remove, 180 avaliação
busca apt, 186 inscrição, 291
show apt, 186 caixa preta, 292
fonte apt, 223 formalização, 293

atualização do apt, 176 vulnerabilidade, 284
atualização apt, 179 caixa branca, 292
apt-cache, 185 ataques
apt-cache dumpavail, 187 lado do cliente, 297
pkgnames apt-cache, 187 base de dados, 6
política apt-cache, 187 negação de serviço, 295
busca apt-cache, 186 corrupção de memória, 295
apt-cache show, 186 senha, 6 , 296
apt-cdrom, 172 tipos de, 294

rede, 296
apt-get, 176
apt-get dist-upgrade, 179 sem fio, 6
auditoria, segurança, 5
apt-get install, 177
autenticação
apt-get purge, 181
autenticação de pacote, 202
apt-get remove, 180
AuthName, diretiva Apache, 116
apt-get update, 176
AuthType, diretiva Apache, 116
apt-get upgrade, 179
AuthUserFile, diretiva Apache, 116
apt-key, 203
instalação automática, 91
apt-mark auto, 200
pacotes instalados automaticamente, 199
manual do apt-mark, 200
efeito avalanche, 163
apt-xapian-index, 186
axi-cache, 186
apt.conf.d /, 195
aptidão, 176 , 190 B
aptitude dist-upgrade, 179 processo de segundo plano, 57
atualização completa do aptitude, 179
Retroceder, XXI , 2
aptitude install, 177 bg, 57
aptitude markauto, 200 BIOS, 24
purga de aptidão, 181 bloquear arquivo de dispositivo, 49
aptitude remove, 180 boot preseed, 92
aptitude safe-upgrade, 179 tela de inicialização, 67
pesquisa de aptidão, 186 chave USB inicializável, 19
show de aptidão, 186 bootloader, 83

aptitude unmarkauto, 200 BOOTP, 252
atualização de aptitude, 176 Quebras, campo de cabeçalho, 209
aptidão porque, 200 dependência quebrada, 189

arquitetura Bruce Schneier, 150
suporte multi-arco, 200 ataques de força bruta, 296
Índice 305
amortecedor de um kernel, 233
transbordar, 295 teste de penetração de conformidade, 288
receber buffer, 156 componente (de um repositório), 173

relatório de erro, 129 conffiles, 214
bugs.kali.org, 133 confidencialidade
construir dependências, instalação, 226 arquivos, 85
opções de construção, 229 config, script debconf, 214

Build-Depends, 226 configuração
construção criando pacotes de configuração, 263
uma imagem ISO ao vivo personalizada, 237 arquivos, 214
um pacote, 231 configuração inicial do APT, 81
gestão, 255
C
rede
cache, proxy, 82
DHCP, 71
gato, 56
estático, 71
CD, 52
do kernel, 235
cdimage.kali.org, 14 , 175
configuração do programa, 110
cdrom preseed, 93
conflitos, 208
certificação, 302
Conflitos, campo de cabeçalho, 208
chage, 108
contrib, seção, 173
corrente, 154
ao controle, 206
arquivo changelog, 266
arquivo de controle, 266
changelog.Debian.gz, 126
soma de controle, 163
arquivo de dispositivo de personagem, 49
control.tar.gz, 211
verifica a segurança, 164
cópia, imagem ISO, 19
somas de verificação, 214
direito autoral, 127
chefe de cozinha, 255
arquivo de direitos autorais, 265
chfn, 108
chgrp, 58 seleção de país, 69
chmod, 58 cp, 53
escolha createdb, 112
do país, 69 createuser, 112
da linguagem, 68 criação
chown, 58 de um banco de dados PostgreSQL, 112
chroot, 239 de um usuário PostgreSQL, 112
chsh, 108 de grupos, 109
ataques do lado do cliente, 297 de contas de usuário, 107
cluster, cluster PostgreSQL, 111 , 113 credenciais, padrão, 153

linha de comando, 51 cross-site scripting (XSS), 296
comunidades, 128 cryptsetup, 243
comparação de versões, 185 senha nuke, 246
compilação personalização da imagem ISO ao vivo, 237

D ataques de dicionário, 296
avaliação de banco de dados, 6 diretivas, Apache, 115 , 116

servidor de banco de dados, 111 DirectoryIndex, diretiva Apache, 115
dch, 226 desabilitar uma conta, 109
dd, 22 disco preseed, 93
debconf, 214 Discos (programa), 20
debconf-get, 97 diskutil, 23
debconf-get-selections, 94 distribuição, Linux, 2
debconf-set, 97 dm-crypt, 86
DEBEMAIL, 265 dmesg, 60
DEBFULLNAME, 265 DNAT, 155
Debian dnsmasq, 252
relacionamento com Kali Linux, 4 docs.kali.org, 127
Manual do administrador Debian, 303 documentação, 124 , 126
Diretrizes de Software Livre Debian, 5 baixar

Imagem ISO, 14
Debian GNU / Linux, 2
as fontes, 223
Política Debian, 5
dpkg, 170
debian-archive-keyring, 203
base de dados, 212
debian-kernel-handbook, 233
dpkg --verify, 162
debian / changelog, 226 , 266
operação interna, 213
debian / control, 266
dpkg-buildpackage, 231
debian / copyright, 265
dpkg-deb, 232
debian / patches, 225
dpkg-source --commit, 227
debian / rules, 229 , 267
unidade, unidade USB, 19
debuild, 232
SOLTA, 155
senhas padrão, 153
dropdb, 112
default.target, 117
dropuser, 112
deleção de um grupo, 109
Bota dupla, 84
delgroup, 109
negação de serviço, 295 E
dependência, 207 eco, 54
Depende, campo de cabeçalho, 207 editor, 56
ambiente de trabalho, 3 partição criptografada, 85
escolha durante a construção do ISO ao vivo, 238 persistência criptografada, 243
desktop-base, 263 Engenharia
detectar mudanças no sistema de arquivos, 162 reverter, 6
arquivo de dispositivo, 49 Engenharia social, 7
df, 60 Aprimoramentos, campo de cabeçalho, 208
dh-make, 264 meio Ambiente

dh_install, 267 variável de ambiente, 54
DHCP, 252 ExecCGI, diretiva Apache, 115
Índice 307
módulos de execução, salt, 256 gpasswd, 109
execução, certo, 57 Chave GPG, 17
experimental, 197 graphical.target, 117

Explicação, 198 grep, 56
ferramentas de exploração, 7 grupo
adicionar um usuário, 108
F mudança, 109
fail2ban, 152 criação, 109
características, 7 eliminação, 109
fg, 57 de volumes, 86
Arquivo proprietário, 57
confidencialidade, 85 groupmod, 109
arquivos de configuração, 214 GRUB, 83
sistema de arquivo, 49 gui-apt-key, 204
sistema de arquivo particionamento guiado, 75
hierarquia, 54
regra de filtragem, 154 , 157 H
encontrar, 56 descoberta de hardware, 61
impressão digital, 163 corrupção de pilha, 295

firewall, 153 história do Kali Linux, 2
FollowSymLinks, diretiva Apache, 115 CASA, 55
forense, 7 diretório home, 55
modo, 8 host, host virtual, 114
formalização da avaliação, 293 htpasswd, 116
formatar disco, 49 Proxy HTTP, 82
fóruns, 128 Servidor HTTP, 113
forums.kali.org, 128 http.kali.org, 174

FRENTE, 154 HTTPS, 114
livre, 60 Hyper-V, 25
Freenode, 128
fwbuilder, 160 Eu
ICMP, 156
G Eu iria, 60 , 109
obter as fontes, 223 ifupdown, 105

getent, 108 representação, 7
git clone, 225 Inclui, diretiva Apache, 115
Problemas do GitHub, 144 incompatibilidades, 209
GNOMO, 3 Índices, diretiva Apache, 115
gnome-disk-utility, 20 informação, 126
gnome-system-monitor, 162 coleta de informações, 6

GNU initrd preseed, 92
Info, 126 ENTRADA, 154

instalação, 66 kali-dev, 4 , 174
automático, 91 kali-linux- * meta-pacotes, 239
de dependências de construção, 226 menu kali, 263
em dispositivos ARM, 94 kali-meta, 263
instalação de pacote, 176 , 177 kali-rolling, 4 , 173
solução de problemas, 95 KDE, 3
sem vigilância, 91 núcleo, 48

pré-configuração do instalador, 92 compilação, 233
estouro de inteiro, 295 configuração, 235
Internet Control Message Protocol, 156 Histórico, 60
ip6tables, 153 , 157 fontes, 234

iptables, 153 , 157 chave
Canal IRC, 128 Chaves de autenticação do APT, 204
isc-dhcp-server, 252 Chave USB, 19
Imagem ISO layout do teclado, 70

autenticação, 16 matar, 57
inicializando, 24 konqueror, 126

copiando, 19 KVM, 25
Construção personalizada, 237
eu
baixar, 14
seleção de idioma, 68
espelhos, 14
layout, teclado, 70
variantes, 16
Menos, 56
J libapache-mod-php, 113
Diário, 60 Linux, 48
journalctl, 60 distribuição, 2
núcleo, 2 , 8
K fontes do kernel, 234
Kali Linux imagem ISO ao vivo, 14
comunidades, 128 Construção personalizada, 237
documentação, 127 live-boot, 240

baixar, 14 live-build, 237
características, 7 adicionando arquivos, 240
começando, 14 debconf preseed, 239

história, 2 ganchos, 239
meta-pacotes, 239 pacotes para instalar, 238

políticas, 9 carregador
relacionamento com o Debian, 4 bootloader, 83

repositórios, 173 REGISTRO, 155
kali-archive-keyring, 203 logcheck, 161

kali-sangramento-limite, 174 , 197 exploração madeireira, 161
kali-defaults, 263 Gerenciador de volume lógico, 86
Índice 309
login, login remoto, 110 espelhos, 14 , 81 , 174
Histórico mkdir, 53
aptidão, 193 mkfs, 49
dpkg, 188 modificação de um pacote, 222
Diário, 60 modificação, certo, 57
núcleo, 60 monitoramento, 161
monitoramento, 161 atividade, 162

ls, 52 arquivos, 163
lsdev, 61 arquivos de log, 161
lshw, 61 Mais, 56
lspci, 61 montar, 49
lspcmcia, 61 ponto de montagem, 79
lsusb, 61 Multi-Arch, 200

LUKS, 86 multi-user.target, 117
LVM, 86 MultiViews, diretiva Apache, 115
LXDE, 3 mv, 53
M N
máquina, máquina virtual, 24 netfilter, 153
seção principal, 173 configuração de rede, 71 , 104
fazer deb-pkg, 236 com ifupdown, 105
Makefile, 267 com NetworkManager, 104
homem, 124 com a rede systemd, 106
gestão instalação de rede, 252
gerenciamento de configurações, 255 espelhos de rede, 81
de serviços, 117 rede preseed, 93
páginas de manual, 124 serviços de rede, 10
pacotes instalados manualmente, 199 protegendo, 153
mascarar Gerente da rede, 104
máscara de direitos, 59 newgrp, 58 , 109
MASCARADA, 155 NEWS.Debian.gz, 126
registro mestre de inicialização, 84 não livre, seção, 173
mestre, mestre de sal, 255 senha nuke, 246
COMPANHEIRO, 3
MD5, 163 O
md5sums, 214 representação octal de direitos, 59
corrupção de memória, 295 Segurança ofensiva, 2
menu, menu de aplicativos do Kali Linux, 5 servidor openssh, 110
meta-pacote, 207 , 209 Opções, diretiva Apache, 115
kali-linux- *, 239 RESULTADO, 154
Metasploit Unleashed, 303 estouro, buffer, 295

servo, servo de sal, 255 sistema de arquivos de sobreposição, 241

proprietário pacote
grupo, 57 filtro, 153
do utilizador, 57 IP, 153
PAE (extensão de endereço físico), 35

P
separou, 242
pacote
partição
verificação de autenticidade, 202
criptografado, 85
pacote binário, 170
partição de troca, 79
Construir, 231
particionamento, 74
configuração, 263
particionamento guiado, 75
conflito, 208
particionamento manual, 77
inspeção de conteúdo, 184
passwd, 108
Pacote Debian, 170
senha, 108
dependência, 207
ataques, 296
lista de arquivos, 181
senhas padrão, 153
lista de cabeçalhos, 184
política, 152
incompatibilidade, 209
ataques de senha, 6
informação, 184
fragmento, 227
instalação, 176 , 177
aplicação de patch, 227
fazendo mudanças, 226
CAMINHO, 53
Meta informação, 204 , 206
PCI, 288
modificação, 222
prioridade, 196
conformidade, 288
purga, 181
tradicional, 289
remoção, 177 , 180
teste de penetração, 5
substituição, 210
curso de teste de penetração, 303
repositório, 269
foca, 202
permissões, 57
pesquisa, 182 , 185

persistência, 240
assinatura, 202 criptografado, 243
fonte de, 172 várias lojas, 244
pacote fonte, 170 pg_createcluster, 113
status, 182 pg_ctlcluster, 113
desempacotando, 177 pg_dropcluster, 113

comparação de versão, 185 pg_hba.conf, 111
pacote virtual, 209 pg_lsclusters, 113

rastreador de pacote, 4 pg_renamecluster, 113
Packages.xz, 171 pg_upgradecluster, 113
embalagem Chave PGP, 17
opções de construção, 229 PHP, 113
pacotes de configuração, 263 PID, identificador de processo, 50
nova versão upstream, 229 PIN, 198
Índice 311
Pin-Priority, 198 redirecionamento, 56
pinfo, 126 reinstalação, 189

ping, 156 REJEITAR, 155
fixação, fixação APT, 196 Release.gpg, 203

ponto, ponto de montagem, 79 login remoto, 110
pós-exploração, 7 remoção de um pacote, 177
PostgreSQL, 111 removendo um pacote, 180
postinst, 211 substituição, 210
postrm, 211 Substitui, campo de cabeçalho, 210
POSTROUTING, 154 reportar um erro, 129
pré-dependência, 207 reportbug, 139

Pré-dependências, campo de cabeçalho, 207 ferramentas de relatórios, 7
preferências, 196 repositório de pacotes, 269

preinst, 211 reprepro, 269
prerm, 211 Requer, diretiva Apache, 116
PREROUTING, 154 requisitos, requisitos mínimos de instalação
arquivo de preseed, 93 mentos, 66
pré-configurar o debian-installer, 92 modo de resgate do instalador, 84
prioridade redimensionar uma partição, 77
prioridade do pacote, 196 recuperar as fontes, 223

programa Engenharia reversa, 6
configuração, 110 direitos, 57
Fornece, campo de cabeçalho, 209 mascarar, 59
proxy, 82 representação octal, 59

cache de proxy, 82 modelo de risco, 150
ps, 57 classificações de risco, 286
fantoche, 255 rkhunter, 164

purga de um pacote, 181 rm, 53
purgando um pacote, 181 rmdir, 53

pwd, 52 Rolling, Kali Rolling, 3
Inicialização PXE, 252 raiz, 10
senha de root, 72 , 153
Q RTFM, 124
QCOW, 30 arquivo de regras, 267
QEMU, 25
S
R módulos de execução salt, 256
ler, certo, 57 fórmulas de sal, 258
LEIA-ME.Debian, 126 módulos de estado de sal, 259
receber buffer, 156 estados de sal, 258
Recomenda, campo de cabeçalho, 208 sal-chave, 255
REDIRECT, 155 saltstack, 255

samhain, 164 fazendo mudanças, 226
escaneando tópicos, 286 sources.list, 172

Schneier, Bruce, 150 Sources.xz, 171
busca de pacotes, 185 spoofing, 7
seção Injeção SQL, 296
contrib, 173 SSH, 110
a Principal, 173 SSL, 114
não livre, 173 módulos de estado, sal, 259
modo de segurança, 24 pedaço pegajoso, 58
protegendo, 150 sudo, 10
um laptop, 152 Sugere, campo de cabeçalho, 208
um servidor, 152 troca, 79
serviços de rede, 153 partição de troca, 79
segurança SymLinksIfOwnerMatch, diretiva Apache, 115
Assessments, 280 sináptica, 190 , 194
auditoria, 5 administração do Sistema, 303

serviços de sistema, 7
política, 150
sistema, sistema de arquivos, 49
arquivo de serviço, arquivo de serviço systemd, 117
systemctl, 117
gestão de serviços, 117
systemd, 117
diretório setgid, 58
systemd-network, 106
setgid, certo, 58
resolvido pelo sistema, 107
setuid, certo, 58
Configuração, 24
T
sg, 109
destino, destino systemd, 117
SHA1, 163
TFTP, 252
SHA256SUMS, 16
tftpd-hpa, 252
Concha, 52
modelo de ameaça, 150
encolher uma partição, 77
TLS, 114
sinal, 57
topo, 162
assinatura
rastreador
assinatura do pacote, 202
rastreador de pacote, 4
SNAT, 155
teste de penetração tradicional, 289
cheirando, 7
Treinamento, 302
ferramentas de engenharia social, 7
arame, 164
fonte resolução de problemas de instalações, 95
de pacotes, 172 confiança, teia de confiança, 17
do kernel Linux, 234 chave confiável, 204
pacote, 170
recuperação, 223 você
pacote fonte UEFI, 24

Construir, 231 ULOG, 155
Índice 313
umask, 59 rede, 296
uname, 60
instalação autônoma, 91 W
montagem sindical, 241

WantedBy, diretiva systemd, 118
unidade, unidade systemd, 117

Quer, diretiva systemd, 118
restrição de acesso à web, 116
desempacotando
análise de aplicativos da web, 6
pacote binário, 177
ataques na web, 296
melhoria
autenticação da web, 115
lidar com problemas após uma atualização, 187
teia de confiança, 17
atualização do sistema, 179
servidor web, 113
versão upstream, empacotando uma nova, 229
Chave USB, 19
Win32 Disk Imager, 19
do utilizador
ataques sem fio, 6
escrever, certo, 57
proprietário, 57
espaço do usuário, 48
X
XDG, 55
V
Xen, 25
variável, ambiente, 54
Xfce, 3
variantes de imagem ISO ao vivo, 238
VDI, 30
Y
versão, comparação, 185
uivo, 126
vigr, 107
vipw, 107
host virtual, 114
máquina virtual, 24
memória virtual, 79
pacote virtual, 209
VirtualBox, 25
VMware, 25
volume
grupo, 86
volume lógico, 86
volume físico, 86
vulnerabilidade
análise, 6
Assessments, 284
lado do cliente, 297
negação de serviço, 295
corrupção de memória, 295

senha, 296
varreduras, 286
tipos de, 294

Kali Linux Revealed 1st Edition Páginas 201 341 Páginas 81 141.en - PT

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Kali Linux Revealed 1st Edition Páginas 201 341 Páginas 81 141.en - PT

Enviado por

Direitos autorais:

Formatos disponíveis

10,2.

Aproveitando o gerenciamento de configuração

substitutos para qualquer estado desejado.

10.2.1. Configurando SaltStack

servo # vim / etc / salt / minion

servo # echo kali-scratch> / etc / salt / minion_id

mestre# systemctl enable salt-master

Capítulo 10 - Kali Linux na empresa 255

Aceita-se a chave para arranhões Kali lacaios.

10.2.2. Executando comandos em lacaios

mestre# salt '*' test.ping

mestre# salt kali-scratch cmd.shell 'uptime; uname -a '

mestre# salt kali-scratch sys.doc disk.usage

Retornar informações de uso para volumes montados neste

256 Kali Linux revelado

mestre# salt '*' service.enable ssh

mestre# salt '*' service.start ssh

mestre# salt '*' pkg.refresh_db

Capítulo 10 - Kali Linux na empresa 257

servidor# salt '*' pkg.install dnmap

servidor# salt '*' cmd.run_bg template = jinja 'dnmap_client -s 1.2.3.4 -a {{grains.id}}'

servidor# salt '*' cmd.shell 'pkill -f dnmap_client'

10.2.3. Salt States e outros recursos

Existem muitos outros recursos que podem ser combinados:

• Execução programada de ações

• Definir ações em resposta a eventos desencadeados por lacaios

• Coleta de dados de lacaios

258 Kali Linux revelado

• Aplicação de estados sobre SSH sem instalar o serviço de salt-minion

• Provisionar sistemas em infraestruturas de nuvem e colocá-los sob gerenciamento

o offsec_repository estado depende do pkgrepo módulo de estado. O exemplo usa o gerenciou

Capítulo 10 - Kali Linux na empresa 259

Este arquivo de estado pode ser aplicado a um determinado lacaio:

servidor# salt kali-scratch state.apply offsec

Comentário: Repo 'de pacote configurado deb http://pkgrepo.offsec.com offsec-internal

Iniciado: 06: 00: 15.767794

Comentário: Os seguintes pacotes foram instalados / atualizados: offsec-defaults Duração: 19246,041 ms

260 Kali Linux revelado

Resumo para kali-scratch

servidor# cat /srv/salt/top.sls

Comentário: Pacote repo 'deb http://pkgrepo.offsec.com offsec-internal main' já

Comentário: O pacote offsec-defaults já está instalado. Iniciado: 06: 06: 21.436193

Capítulo 10 - Kali Linux na empresa 261

Resumo para kali-scratch

10,3. Extensão e personalização do Kali Linux

10.3.1. Pacotes de bifurcação Kali

262 Kali Linux revelado

10.3.2. Criação de pacotes de configuração

Capítulo 10 - Kali Linux na empresa 263

• /etc/apt/sources.list.d/offsec.list: uma sources.list entrada para APT, permitindo o

• /usr/share/images/offsec/background.png: uma bela imagem de fundo com o

• /usr/share/glib-2.0/schemas/90_offsec-defaults.gschema.override: um arquivo provid-

$ mkdir offsec-defaults-1.0; cd offsec-defaults-1.0

Endereço de e-mail : buxy@kali.org

264 Kali Linux revelado

exportar EMAIL = ” buxy@kali.org ”

Formato: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ Upstream-Name: offsec-defaults

Capítulo 10 - Kali Linux na empresa 265

offsec-defaults (1.0) instável; urgência = média

* Adicione o arquivo de configuração do salt minion.

debian / offsec-defaults /etc/apt/source.list.d/offsec.list. o regras arquivo é usado como um

266 Kali Linux revelado

target: source1 source2 ...