Nesse post, vou abordar a instalação do GitLab 15.0 em um Ubuntu Server 20.04.4 LTS / Focal Fossa. Também instalarei o gitlab-runner localmente e também em container. Além da instalação, farei o cadastro dos dois Runners.

Inicialmente, vamos instalar algum pacotes necessários:

apt install -y curl openssh-server ca-certificates tzdata perl

Em seguida, vamos adicionar o repositório oficial da versão community do GitLab.

curl -sS https://packages.gitlab.com/install/repositories/gitlab/gitlab-ce/script.deb.sh | sudo bash

Agora com o repositório oficial já na lista dos repositórios que o nosso gerenciador de pacotes irá verificar, basta instalar o gitlab usando apt

apt install gitlab-ce -y

Ao concluir a instalação, vamos configurar a URL que servirá de acesso ao Gitlab. No nosso caso, não estamos utilizando nenhuma entrada de DNS ou domínio, portanto vamos apontar o IP do servidor mesmo. Nesse caso, é o IP interno 192.168.0.115. Esse procedimento não é recomendável para produção, que deve ser utilizado inclusive com certificado válido.

Para fazer a configuração, vamos editar o arquivo /etc/gitlab/gitlab.rb. Esse arquivo será lido no momento de configuração do gitlab.

vim /etc/gitlab/gitlab.rb

Agora, vamos procurar a linha que contém “external_url” e vamos colocar nosso ip:

Para iniciar o modo de edição do vim, basta apertar a tecla “i”. Ao concluir, basta apertar “Esc” e depois para sair do vim, basta digitar :wq!

Agora, vamos iniciar a configuração do gitlab usando o binário gitlab-ctl:

gitlab-ctl reconfigure

Ao concluir a configuração, o gitlab informará que a senha inicial do usuário root está em um arquivo chamado initial_root_password. Portanto, vamos exibir esse arquivo para visualizarmos a senha.

cat /etc/gitlab/initial_root_password

A senha será exibida na tela. Vamos copiá-la para o acesso inicial ao gitlab. Esse acesso inicial se dará pelo navegador e com o endereço informado anteriormente. Nesse caso, vou usar o Firefox para acessar o ip 192.168.0.115.

1 – No campo Username or email vamos colocar o usuário root

2 – No campo Password, vamos colocar a senha que copiamos anteriormente.

Depois basta clicar em Sign In.

 

Para modificar a senha do root, clique no lado direito superior e depois em Preferences.

 

No menu esquerdo, clique em Password.

 

1 – Inserir a senha atual em Current Password que foi copiada do arquivo initial_root_password

2 – Inserir uma senha nova em New password / Password confirmation.

Depois basta clicar em Save password para confirmar a senha. Ao clicar, você será redirecionado para a página inicial onde deve entrar novamente com o usuário root e a nova senha.

 

Instalação e Registro dos Runners (Shell e Docker)

Vamos fazer a instalação de depois Runners: um localmente e outro utilizando Docker.

Assim como o Gitlab, vamos fazer a configuração do repositório oficial do Runners.

curl -L "https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.deb.sh" | sudo bash

Agora, vamos instalar o gitlab-runner

apt install gitlab-runner -y

Após a instalação, vamos registrar o primeiro Runner. Para fazer o registro, vamos precisar do token. Esse token pode ser acessado em Admin que fica no Menu da esquerda.

Após o acesso da área Admin, vamos em Runners, ainda do lado esquerdo.

Já em Runners, no lado direito, clique em Register an instance runner e logo em seguida, vamos clicar no segundo símbolo para fazer a cópia do token.

Agora com o Token copiado, vamos voltar ao terminal e registrar o Runner que já foi instalado.

Abaixo o comando que deve ser inserido no terminal para fazer o registro do Runner.

É necessária a substituição das opções url (colocar a URL que está acessando o Gitlab), registration-token (colar o token que foi copiado anteriormente).

gitlab-runner register -n --url http://192.168.0.115 --registration-token se8sztuB1o1ewFbXHVav --executor shell --description "Runner Shell"

Ao acessar novamente os Runners no Gitlab, verá que o Runner foi registrado como Shell e com o descrição Runner Shell.

Em seguida, vamos subir um Runner usando Docker e depois fazer o registro desse Runner que estará rodando em container.

Caso não tenha o Docker instalado, seguem os comandos para a instalação. Não será abordado os detalhes aqui, pois o foco é a instalação e configuração do GitLab.

apt remove -y docker docker-engine docker.io containerd runc
apt update -y
apt install ca-certificates curl gnupg lsb-release
mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
apt update -y
apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

Primeiramente, vamos executar o container do gitlab-runner:

Executando o Runner em Docker
docker run -dit \
--name runner-docker \
--restart always \
-v /var/run/docker.sock:/var/run/docker.sock \
-v /opt/gitlab-runner/config:/etc/gitlab-runner \
gitlab/gitlab-runner:latest

Agora com o Runner já sendo executado em container, vamos fazer o registro desse Runner. A ideia de registro é a mesma do Runner que está rodando localmente, porém precisamos fazer isso para o container, por tanto será necessário os ajustes da URL e Token assim como feito no anterior. Não é necessário a geração de um novo token. Pode-se aproveitar o token que foi utilizado para o runner anterior.

docker exec -it runner-docker \
gitlab-runner register -n \
--url http://192.168.0.115 \
--registration-token se8sztuB1o1ewFbXHVav \
--clone-url http://192.168.0.115 \
--executor docker \
--docker-image "docker:latest" \
--docker-privileged

Agora, onde havia apenas um Runner, há dois Runners sendo executados e registrados no Gitlab.

Referências:

https://about.gitlab.com/install/?version=ce
https://docs.gitlab.com/runner/install/
https://docs.docker.com/engine/install/ubuntu/

Ao som de: Ney Matogrosso – Sorte

Uma das maiores reclamações dos estudantes da segurança da informação, é o fato de utilizar máquinas virtuais para os estudos. Muitos acham frustante por não estar instalado em uma máquina física. Pensando nisso, foi desenvolvida uma distribuição para ser instalada em um Raspberry Pi e que é intencionalmente vulnerável. Essa distribuição é a RasPwn OS.

A distribuição RasPwn OS é baseada na distribuição Debian Wheezy. De acordo com o Github oficial, é uma distro Linux no espírito da distro “Damn Vulnerable Linux (DVL)” e usa o Raspberry Pi 2B e 3 para emular um servidor Linux vulnerável, por tanto esse é o único propósito do RasPwn OS e ele não deve ser exposto a internet, pois pode comprometer toda a sua rede interna. 

No meu caso, tenho um Raspberry Pi 3 com cartão de memória de 16 gb. É o suficiente para começar os estudos. Também é possível instalar no Raspberry Pi 2B, porém precisa de uma adaptador wifi conectado a uma das portas USB, pois não possui uma interface interna de wifi, ao contrário do Raspberry Pi 3 que já possui wifi integrado.

Meu Raspberry Pi 3... <3

Meu Raspberry Pi 3…

 

Baixei a imagem no site oficial, extrai usando o 7ZIP e fiz a cópia da ISO para o cartão utilizando o Etcher. O procedimento usado para gerar o conteúdo da imagem pode variar, não sendo uma regra.

Após esse procedimento, coloquei o cartão no slot do Raspberry e liguei a fonte na energia. Caso queira acompanhar a primeira inicialização do OS, basta colocar um monitor HDMI. O sistema reiniciará uma vez e após isso estará pronto para o uso.

 

A primeira coisa a se fazer é conectar-se o sistema operacional que você utilizará para estudar no wifi que o RasPwn criou. 
SSID: RasPwn OS
Senha: In53cur3!

Depois de conectar-se a rede wifi criada, utilize um browser e acesse o endereço: http://playground.raspwn.org/. Essa é a página principal do RasPwn OS e que dará acesso aos outros sistemas instalados no mesmo sistema. Você notará que a rede criada é a 192.168.99.0/24, assim você pode passar algum scanner de rede para testes.

A documentação oficial da distribuição informa os ips atribuídos a cada serviço:

Bind (192.168.99.1, 192.168.99.10) – DNS Server
Postfix (192.168.99.18) – Mail Transfer Agent
Dovecot (192.168.99.18) – Mail Client Server
Samba (192.168.99.10) – Windows File Sharing Server
Apache2 (192.168.99.13) – Web Server
Nginx (192.168.99.7) – Web Server
MySQL Server (127.0.0.1) – Database Server
OpenSSH (192.168.99.1) – SSH server

 

Além disso, há alguns aplicativos instalado com versões desatualizadas para as vulnerabilidades conhecidas serem exploradas:

Concrete 5.6.3.4 – http://playground.raspwn.org/concrete5/
Drupal 6.34 – http://playground.raspwn.org/drupal-6.34/
Drupal 7.34 – http://playground.raspwn.org/drupal-7.34/
Joomla 2.5.28 – http://playground.raspwn.org/joomla-2/
Joomla 3.4.0 – http://playground.raspwn.org/joomla-3/
osCommerce 2.3 – http://playground.raspwn.org/oscommerce/
phpBB 3.0.13 – http://playground.raspwn.org/phpBB3/
WordPress 3.8.1 – http://playground.raspwn.org/wordpress3/
WordPress 4.1 – http://playground.raspwn.org/wordpress4
Zen-Cart 1.5.4 – http://playground.raspwn.org/zencart
PhpMyAdmin 3.4.11 – http://playground.raspwn.org/phpmyadmin/
Samba SWAT 3.6.6 – http://playground.raspwn.org:901 (wifi adapter only)
Roundcube 0.7.2 – http://playground.raspwn.org/roundcube/

 

Há também serviços WEB para testes de vulnerabilidades:

OWASP Bricks – http://playground.raspwn.org/bricks
Damn Vulnerable Web Application (DVWA) – http://playground.raspwn.org/dvwa
OWASP Hackademic – http://playground.raspwn.org/hackademic
OWASP Mutillidae II – http://playground.raspwn.org/mutillidae
Peruggia – http://playground.raspwn.org/peruggia
WackoPicko – http://wackopicko.playground.raspwn.org (wifi adapter only)
WebGoat – http://playground.raspwn.org:8080/WebGoat (wifi adapter only)

 

Para título de exemplo, vou usar o DVWA para exemplificar a vulnerabilidade XSS (Cross-Site Scripting)

 

 

Primeiramente, vamos acessar o DVWA:

http://playground.raspwn.org/dvwa
Login: admin
Senha: password

 

 

Iremos fazer os testes com 3 níveis de segurança: Low, Medium e High.

Todos os 3 ataques abaixo são do tipo Refletido ou Não Persistente.

Vamos começar com o Low. Para fazer isso, no Menu da esquerda, basta clicar em DVWA Security.

 

Só escolher Low e depois clicar em Submit.

 

 

Agora, vamos acessar a página para testes XSS. No menu da esquerda, clicar em XSS (Reflected).

 

 

Como estamos estudando, vamos olhar o código do fonte da página para assim entender como funcionam as proteções.

 

 

Para ver o código fonte (lembre-se que não é possível ver em uma página comum da web, pois o código php será interpretado e exibido apenas o resultado HTML final), basta clicar no final da página em View Source.

 

 

Como é possível observar, não há nenhuma proteção para evitar o XSS, então podemos utilizar o XSS mais básico (afinal, a segurança está setada para Low)

 

 

No único campo que há (What’s your name?):

<script>alert(“Ataque XSS LOW”);</script>

 

 

Sucesso!

 

Agora com o nível de segurança em “Medium”. Lembre-se de mudar o nível na página de configuração.

 

 

Mais uma vez, vamos olhar o código fonte:

 

 

Agora é possível observar que no código há uma proteção para evitar que o código <script> seja interpretado. Porém, é apenas para <script>, caso utilize o mesmo texto, mas com letras maiúsculas e minúsculas, o script será interpretado. Logo, por exemplo, podemos utilizar <ScRiPt>.

 

 

<ScRiPt>alert(“Ataque XSS MEDIUM”);</sCrIpT>

 

 

Sucesso!

 

Uma outra forma é colocar o script dentro do código script. Estranha explicação, então vamos para a prática e ficará mais claro.

 

 

<scri<script>pt>alert(“Ataque XSS MEDIUM 2”);</scri<script>pt>

 

 

Sucesso!

A explicação é que com a proteção da forma que está, a string <script> será suprimida, isso fará que o texto que está “em volta” da string fica um texto só, e será novamente <script>, assim executando o código.

 

E finalmente, nível de segurança HIGH!

 

 

Novamente, olhando o código fonte, podemos perceber que o código agora está mais sofisticado, impedindo que o <script> seja executado de qualquer forma. Então, vamos tentar inserir código html.

 

 

<img src=x onError=alert(“document.cookie”);>

 

Sucesso!

Nesse exemplo, é inserido um código html de imagem, porém a imagem não existe, logo existe um tratamento para o erro que é executado quando essa condição for verdadeira, que é o caso. Assim, o código XSS é executado. Também é possível perceber que foi utilizado o parâmetro alert(document.cookie) que serve para exibir o cookie da sessão atual.

 

Depois de contemplado os 3 ataques em modo Refletido, agora em modo Persistente:

No menu da esquerda, clicar em XSS (Stored).

 

 

Em todos os exemplos, vamos colocar os códigos no campo “Name”

Começando pelo Persistente no modo LOW:

 

 

Sempre é bom olhar o código fonte para verificar se há alguma proteção.

Como é no nível LOW, não há nenhuma proteção:

 

 

Então, vamos usar o ataque básico:

<script>alert(“Ataque XSS LOW”);</script>

 

 

Pode observar que não foi possível inserir todo texto no campo Name. Logo, vamos inspecionar o elemento.

 

 

Observe que na linha destacada, há a limitação para apenas 10 caracteres . Vamos aumentar pra 100!

 

 

É possível observar que agora o código cabe todo. Agora é só executar:

 

 

Sucesso! 

Como as informações inseridas ficam no banco de dados, vamos dar um reset no banco antes de ir para o nível de segurança “Medium”

Para fazer isso, basta ir no menu do lado esquerdo e clicar em “Setup / Reset DB”.

 

 

No final da página, basta clicar em “Create / Reset Database DB”.

 

 

Ao fazer isso, os bancos serão apagados e criados novamente. Assim, podemos passar para o nível de segurança Medium.

 

 

Agora no nível “MEDIUM” e já olhando o código fonte:

 

 

Há a mesma proteção que já observamos no mesmo nível no modo Persistente, então vamos usar as mesmos scripts.

 

 

E aparentemente, também há a limitação de 10 caracteres. Então vamos mudar logo pra 100 também.

 

 

<ScRiPt>alert(“Ataque XSS MEDIUM”);</sCrIpT>

 

 

Também funciona a mesma técnica de colocar o “script” dentro de outro “script”.

 

 

<scri<script>pt>alert(“Ataque XSS MEDIUM 2”);</scri<script>pt>

 

 

Sucesso!

Agora, level “HIGH”. Não esquecer de dar reset no banco novamente.

 

 

Analisando o código fonte, também há a mesma proteção, logo vamos usar o mesmo código.

 

 

E adiantando também a limitação do campo “Name”, então vamos mudar logo pra 100 e colocar o código.

 

 

<img src=x onError=alert(“document.cookie”);>

 

 

Sucesso!

Isso é uma pequena amostra sobre o que é possível fazer com o RasPwn OS na parte de estudos. Espero trazer mais exemplos usando esse sistema, com outros sistemas e outras vulnerabilidades.

Caso queira testar com mais códigos XSS, no site GBHackers há uma lista com 500 exemplos: https://gbhackers.com/top-500-important-xss-cheat-sheet/

Espero ter ajudado e até uma próxima.

Ao som de: Rashid – Interior ft. Rapadura

 

Fontes:

http://raspwn.org/
https://github.com/alphacharlie/RasPwn
https://computersecuritystudent.com/SECURITY_TOOLS/DVWA/DVWAv107/lesson9/index.html
https://www.hackingarticles.in/xss-exploitation-dvwa-bypass-security/
http://2001594623noviani.blog.binusian.org/2018/05/27/cross-site-scripting-xss-on-dvwa/

Por padrão, a versão do Autopsy que vem nos repositórios oficiais do Debian é a versão 2.24 porém para Windows já existe a versão 4.10. Como o Autopsy roda com o SleuthKit e Java no linux, vamos fazer um passo a passo dessas instalações.

Um ponto importante de se observar é que as versões atualizadas do Autopsy “acompanham” as versões atualizadas do Sleuth Kit. No caso do Autopsy 4.10, a versão utilizada do Sleuth Kit é a 4.6.5. Essa verificação é feita pelo script de instalação e caso esteja diferente, a instalação não será concluída. No caso de atualização do Autopsy, também é necessário a atualização do Sleuth Kit.

No nosso caso, vamos utilizar o Debian 9, porém pode ser instalada em qualquer outra distribuição baseada no Debian (Ubuntu, Kali, Parrot, Caine…), pois vamos utilizar um arquivo .deb.
No final do post há uma lista com todos os comandos utilizados sem as explicações, caso seja um usuário avançado ou não queira ver as explicações do post.

Preparando o Ambiente

O Debian que estou utilizando está em sua configuração padrão, apenas com o Vim e Terminator instalados e o usuário utilizado é o root (apenas para melhor compreensão do post).

Então vamos começar atualizando o sistema:

apt update && apt -y upgrade

Agora vamos instalar o photorec, programa necessário para a execução do Autopsy

apt -y install testdisk

O Debian 9 já vem com o Java OpenJDK 8 instalado, não sendo necessário fazer qualquer instalação Java. Caso queira atualizar ou usar outra aplicação Java, como da Oracle, não fará diferença para a execução do Autopsy, apenas trará as melhorias de cada pacote ou de um sistema sempre atualizado.
Mesmo assim, precisamos fazer uma configuração no Java para indicarmos onde está instalado o java. E primeiramente, vamos pegar o diretório onde o OpenJDK está instalado com:

java -XshowSetting

Vamos procurar uma linha com o conteúdo parecido com esse: java.home = /usr/lib/jvm/java-8-openjdk-amd64/jre
Lembrando que a saída do “java.home” pode variar de acordo com o sistema instalado.

Em seguida, adicione essa informação na variável de ambiente do Debian para que o sistema reconheça através da variável $JAVA_HOME onde está instalado o Java.

vim /etc/environment 

Adicione a seguinte linha no final do arquivo:

JAVA_HOME="/usr/lib/jvm/java-8-openjdk-amd64/jre"

Depois basta salvar o arquivo e sair do editor com o comando:

:wq

Agora vamos carregar esse arquivo

source /etc/environment

E verificar se o sistema já reconhece o novo path

echo $JAVA_HOME

A saída será o diretório que consta no arquivo /etc/environment

Instalando o Sleuth Kit 4.6.5

Inicialmente, vamos baixar o arquivo .deb de instalação do SleuthKit

wget https://github.com/sleuthkit/sleuthkit/releases/download/sleuthkit-4.6.5/sleuthkit-java_4.6.5-1_amd64.deb

E em seguida instalar esse pacote

apt install ./sleuthkit-java_4.6.5-1_amd64.deb 

Caso apresente algum erro com falta de alguma dependência, basta executar “apt -f install” e depois fazer a instalação do sleuthkit novamente repetindo o comando acima (apt install ./sleuthkit-java_4.6.5-1_amd64.deb).

Instalando o Autopsy 4.10

Agora, basta fazer o download do Autopsy 4.10 no github oficial

wget https://github.com/sleuthkit/autopsy/releases/download/autopsy-4.10.0/autopsy-4.10.0.zip

Extrair o pacote:

unzip autopsy-4.10.0.zip && cd autopsy-4.10.0

Executar o instalador:

sh unix_setup.sh

Acessar o diretório bin/ dentro do diretório do autopsy

cd bin

E executar o autopsy

./autopsy
Debian 9.9 – Kernel 4.9 – Java 8 OpenJDK
Parrot OS 4.6 – Kernel 4.19 – Java 11 OpenJDK

Sugiro que criem um atalho para a execução do programa para não ter que acessar o diretório e executar o programa sempre for utilizar.

O objetivo deste post é apenas ajudar aos peritos que utilizam Linux, porém sentiam falta de uma versão mais atualizada do Autopsy no Linux e tinham que recorrer ao Windows, muita vezes tendo que interromper o fluxo de trabalho para a troca de sistema operacional.

Comando utilizados para caso alguém queira fazer um script (e postar nos comentários depois):

apt update && apt -y upgrade && apt -y install testdisk
echo JAVA_HOME=\"/usr/lib/jvm/java-8-openjdk-amd64/jre\" >> /etc/environment
source /etc/environment
wget https://github.com/sleuthkit/sleuthkit/releases/download/sleuthkit-4.6.5/sleuthkit-java_4.6.5-1_amd64.deb && wget https://github.com/sleuthkit/autopsy/releases/download/autopsy-4.10.0/autopsy-4.10.0.zip && unzip autopsy-4.10.0.zip
apt -y install ./sleuthkit-java_4.6.5-1_amd64.deb
cd autopsy-4.10.0
sh unix_setup.sh
./autopsy

Caso dê erro: apt -f install && apt -y install ./sleuthkit-java_4.6.5-1_amd64.deb

https://www.autopsy.com/
https://www.sleuthkit.org/
https://github.com/sleuthkit/sleuthkit/releases/tag/sleuthkit-4.6.5
https://github.com/sleuthkit/autopsy/releases/tag/autopsy-4.10.0
https://github.com/sleuthkit/autopsy/blob/develop/Running_Linux_OSX.txt

Ao som de: Testament – The Pale King

O Binwalk é uma ferramenta criada pelo Craig Heffner e feita para realizar buscas em arquivos de imagens (raw). Ela foi pensada para fazer a análise e extração de códigos e arquivos dentro de firmwares, porém como ela é bastante poderosa, acaba sendo utilizadas para outros fins. O intuito desse post é demonstrar que um desses possíveis cenários de utilização desse software no campo da computação forense, e assim apresentar mais uma ferramenta que possa ser utilizada em uma análise forense. Isso não quer dizer que ela substitui qualquer outra ferramenta! Existem ferramentas específicas para cada tipo situação e de análise. Porém, assim como qualquer outra ferramenta, ela server para ajudar um profissional capacitado a chegar um resultado desejado.

O programa utiliza a biblioteca libmagic, assim reconhece os “Magic Numbers” no bloco de dados de um arquivo, conseguindo identificar o tipo de arquivo dentro de uma imagem. Porém, ele também contém uma lista extra desses números mágicos para ficar ainda mais completo.

“Números Mágicos” ou “Magic Numbers” é o termo utilizado para designar as constantes de um tipo de arquivo, assim definindo as assinaturas desses arquivos e assim criando um padrão para a identificação desses arquivos. Essa assinatura se localiza no início do bloco de informação do arquivo. Por exemplo: Todo arquivo arquivo PNG irá começar com esse dados em HEXADECIMAL 89 50 4E 47 0D 0A 1A 0A.

Para observar esses dados, basta abrir qualquer arquivo em um editor Hexadecimal de sua preferência. Também iremos verificar esses dados usando o binwalk.
Caso queira uma lista de alguns números mágicos, existem várias listas na internet, como esta do Wikepédia: https://en.wikipedia.org/wiki/List_of_file_signatures

 

Instalação

Para fazer a instalação do binwalk, basta utilizar o gerenciador de repositórios da sua distribuição ou fazer o download no Github oficial da ferramenta: https://github.com/ReFirmLabs/binwalk

Algumas distribuições Linux já possuem essa ferramenta em seu repositório.

 

git clone https://github.com/ReFirmLabs/binwalk.git
cd binwalk
sudo python setup.py install
 
Caso esteja utilizando o Python 2.x, instale a dependência:
sudo apt install python-lzma ou sudo yum install pyliblzma

Utilização

A sintaxe do programa é bem simples

$ binwalk [opções] [arquivo]

Caso não utilize nenhum argumento, o binwalk fará uma varredura no arquivo e exibirá os arquivos correspondentes as suas assinaturas compostas nos cabeçalhos utilizando os números mágicos. Há basicamente 3 colunas: Decimal e Hexadecimal, exibe a posição, nos respectivos nomes, do início do número mágico de um arquivo. A terceira coluna é a descrição do arquivo que foi localizado nas duas primeiras colunas.

 

Filtros

Como o retorno da pesquisa dos arquivos pode ser muito grande, é possível aplicar “filtros” para você ver apenas o que está buscando especificamente.

Filtro de Inclusão

-y ou –include=<filtro>

A opção -y inclui apenas os resultados correspondentes para o texto (ou string) de pesquisa especificado. Nessa pesquisa, serão retornados apenas arquivos onde os “Magic Numbers” são possíveis de ser identificados. É possível utilizar expressões regulares para a pesquisa.

$ binwalk -y image exemplo.raw

Exibe apenas as imagens encontradas no arquivo

Filtro de Exclusão

-x ou –exclude=<filtro>

A opção -x é o oposto da anterior (-y) e exclui o texto especificado (ou string) que corresponde a regra nos resultados da pesquisa. Assim como a pesquisa, a exclusão também pode usar expressões regulares. Também apresenta os resultados baseado nas assinaturas dos arquivos.

$ binwalk -x image exemplo.raw

Comparação de Arquivos

 

-W ou –hexdump

O binwalk pode exibir os códigos hexadecimais de arquivos e exibir a diferença e semelhança entre eles. Para fazer essa diferenciação, ele utiliza 3 cores para demonstrar cada uma dessas diferenças e semelhanças.

Verde: Os bytes semelhantes em todos os arquivos;
Vermelho: Os bytes diferentes em todos os arquivos;
Azul: Os bytes diferentes em apenas um arquivos.

$ binwalk -W arquivo01.raw arquivo02.raw arquivo03.raw

Para melhor visualização, podemos aplicar alguns argumentos para limitar a exibição das informações. No nosso exemplo, vamos utilizar:

–block para limitar o tamanho do bloco, em bytes, que será exibido;
–length para exibir apenas a quantidade de bytes selecionados.

$ binwalk -W --block=8 --length=128 *.mp3

No nosso exemplo, podemos identificar nos 3 arquivos que os primeiros bytes são idênticos. Isso acontece pois são 3 arquivos de áudio em MP3 e os “Números Mágicos” nos informa que existe a ID3 Tag nesses arquivos. A assinatura da ID3 tag é “49 44 33”. Como o padrão se repete em todos, esses dados estão em verde.

Seguindo o arquivo, podemos observar que mais uma informação é idêntica nos 3 arquivos. É possível ver o “texto” TALB. Lendo a documentação do ID3tag (http://id3.org/id3v2.3.0), esse campo corresponde ao “Álbum” em que essa MP3 pertence (TALB [#TALB Album/Movie/Show title]). Mas isso não quer dizer que as 3 MP3 são do mesmo Álbum e sim que os 3 arquivos estão com esse campo da ID3 Tag preenchidas. Por esse motivo, podemos observar um bloco bem maior de dados em vermelho, pois são 3 músicas de álbuns diferentes.

Se avançarmos um poucos mais, veremos o “TPE1”, que corresponde ao “Artista” da música. Mesmo essa informação presente nos 3 arquivos, eles não estão na mesma posição, por isso continua em vermelho. Isso acontece por causa dos nomes dos Álbuns, que são diferentes e não tem o mesmo número de caracteres.

Observando essas informações, podemos concluir:
musica01.mp3: Álbum (TALB): “The Rise and Fall of Ziggy Stardust and The Spider From Mars” e Artista (TPE1): “David Bowie”
musica02.mp3: Álbum (TALB): “Scenes From a Memory” e Artista (TPE1): Dream Theater
musica03.mp3: Álbum (TALB): “Just The Two of Us, Me And Then” e Artista (TPE1): MindFlow

Os dados em azul são que estão iguais em 2 arquivos, mas no terceiro. No exemplo abaixo, peguei 2 músicas do mesmo álbum e uma de um terceiro álbum. Usando as informações acima, fica fácil ver a semelhança entre os 2 primeiros e o terceiro arquivo.

Pesquisa RAW

 

-R ou –raw=<string>

 

A pesquisa RAW permite que você faça uma busca diretamente no arquivo, podendo conter strings octal, hexadecimal ou texto puro.

No nosso exemplo, vou utilizar uma MP3 da banda MindFlow e ela contém os metadados da ID3 tag preenchida.

Vamos fazer a busca pelo nome da banda dentro da MP3. Como é um nome composto, vamos procurar pelos primeiro nome apenas:

$ binwalk -R "Mind" musica03.mp3

Caso não retorne nenhuma resposta, pode tentar com outros argumento, como o segundo nome, o nome completo, o texto em caixa alta ou baixa, ou até mesmo em Hexadecimal:

$ binwalk -R "\x4D\x69\x6E\x64" musica03.mp3

Observe que o retorno estão exatamente na mesma posição inicial da busca antetior. O binwalk fez uma varredura no hexadecimal da MP3 e encontrou essas informações no metadados ID3 Tag do arquivo.

Extração de Arquivos

Como o binwalk é capaz de reconhecer arquivos dentro de um outro arquivo, também é possível fazer a extração desses desses arquivos para um diretório.

Extraindo manualmente

 

-D ou -dd=<Tipo:Extensão:Comando>

 

O formato usado para extrair a regra especificada é:
Tipo:Extensão:Comando

Tipo: string, em “caixa baixa”, para informar o tipo do arquivo que se quer extrair;
Extensão: define qual será a extensão que o arquivo será salvo no diretório. Por padrão, o binwalk não coloca nenhuma extensão;
Comando: é um argumento opcional para ser executado após a extração para o diretório.

$ binwalk --dd='zip archive:zip:unzip %e' exemplo.raw

No exemplo acima:

–dd: informa que será feito uma extração de arquivo;
zip archive: será localizado todos os arquivos que contêm a assinatura de um arquivo ZIP;
zip: todos os arquivos localizados com essa assinatura será salvos com a extensão .zip;
unzip: após os arquivos “zip archive” serem localizados, depois salvos como .zip, esse arquivos serão extraídos com o unzip.
%e: é onde você deve informar onde o diretório para a extração desses “zip archives”

Por padrão, os nomes dos arquivos serão atribuídos às suas posições hexadecimais incluindo a extensão encontrada nos números mágicos. Os “zip archives” extraídos da imagem estarão com os nomes: 6BF9434.zip, 39F3593.zip, 39F3660.zip

Caso queira extrair tudo que o binwalk possa localizar, basta usar a expressão regular com * para fazer a extração:

$ binwalk --dd='.*' file.bin

Extraindo automaticamente

Caso utilize a extração automática, o binwalk irá criar um diretório automaticamente com os arquivos extraídos.

$ binwalk -e exemplo.raw

A opção -e é usada para executar a extração automática dos dados. O binwalk só vai conseguir extrair os arquivos que serão identificados pelos números mágicos.

Extração recursiva

 

-M ou –matryoshka

A opção -M (–matryoshka) fará a extração de forma recursiva, porém ela só pode ser usada se combinada com a opção -e (ou –extract)

$ binwalk -Me exemplo.raw

 

LOG

-f ou –log=<arquivo.log>

Nos sistemas operacionais modernos, podemos concatenar as informações de saída de fluxo (stdout) para outro fluxo de informações. Geralmente usamos essas saídas de informações concatenadas com ‘>’ para gerarmos um arquivo de “log” escrevendo um arquivo de texto. Porém, o binwalk já tem um argumento para isso, que é o -f (ou –log)

$ binwalk -f saída_dos_dados.log exemplo.raw

Caso queira que esses dados sejam extraídos diretamente para um arquivo no formato CSV, pode se utilizar o argumento –csv já combinado com o -f

$ binwalk -f saída_dos_dados.csv --csv exemplo.raw

Utilizando o comando acima, será exibida a informação na tela e também criado o arquivo csv. Se deseja que apenas o arquivo seja criado com essas informações, sem a exibição no terminal, basta usar o -q (ou –quiet).

$ binwalk -q -f saída_dos_dados.csv --csv exemplo.raw

 

 

Exemplo Prático:

Primeiramente, vamos usar o binwalk padrão:

$ binwalk Trabalho.pdf

 

No nosso caso, retornou algumas informações. Na primeira posição foi encontrada a assinatura do “PDF Document, version 1.4”. Verificando o arquivo no nosso editor hexadecimal, podemos ver o “número mágico” do pdf (25 50 44 46).

Seguindo o arquivo, o binwalk encontrou a biblioteca zlib, pois o pdf a utiliza para essa biblioteca para a compressão de dados, além dos metadados dos arquivos. Porém, foi encontrado uma assinatura de JPG (posição 0x90F6) e dois PDF (0x21C3C e 0x2F37D).

Agora, vamos fazer a extração de todos os arquivos para não perder muito tempo e depois da extração, localizar os arquivos.

$ binwalk --dd='.*' Trabalho.pdf

 

Após os arquivos extraídos, vamos separar os arquivos com os nomes das posições onde foram encontrados, com exceção da posição “0” pois já  sabendo que é o arquivo que conseguirmos ver normalmente.

90F6 = Imagem JPG
21C3C = Primeiro PDF
2F37D = Segundo PDF

Utilizando um editor hexadecimal, e olhando essas posições indicadas pela aplicação, podemos extrair os blocos e verificar os arquivos. A extração será feita nas assinaturas seguintes. Assim como o anterior, a primeira assinatura identificada foi depois do PDF visível foi o JPG, vamos selecionar o bloco entre o início do suposto JPG (0x90F6) e o início do segundo PDF (0x21C3C), logo em seguida vamos do início do segundo PDF até o começo do terceiro PDF (0x2F37D) e esse vai até o final do arquivo.

 

O resultado nos dois casos será o mesmo:

 

Em um arquivo PDF havia uma imagem e mais 2 PDFs “escondidos” dentro dele. Isso tudo foi possível observando os números mágicos que haviam no arquivo “principal”

Como disse inicialmente, a ideia deste post é apresentar mais uma ferramenta para análises forenses. Em alguns dos exemplos mostrados, existem softwares que nos exibem as informações mais legíveis e mais rápido, como é o caso do ID3 Tag, onde há vários leitores como o PoodleTag. Mas o binwalk também pode ser usado justamente para confirmar esses dados dos outros aplicativos. A combinação “binwalk + editor hexadecimal” podem nos trazer muitos resultados positivos nas mãos de bons peritos forense.

 

https://tools.kali.org/forensics/binwalk
https://github.com/ReFirmLabs/binwalk/wiki/quick-start-guide
https://securityonline.info/introduction-to-binwalk-firmware-analysis-tool/

 

Ao Som de: Criolo – Não Existe Amor em SP

Nesse post não vou explicar como o Bacula funciona e nem como fazer a sua configuração para backup. Planejo fazer isso mais a frente. Agora é só referente a instalação do Bacula

Para esse tutorial a configuração foi um servidor CentOs 7.4, com o Bacula 5.2.13, o Postgres 9.2.23 e o Webmin 1.870 para administração gráfica. As versões são as atuais nos repositórios no dia dessa postagem.


Primeiramente, desabilitei o SELinux e o Firewall para melhor instalação.

Caso não queira desabilitar o firewall, as portas utilizadas são:

Webmin: 10000

Bacula: 9101, 9102, 9103

Postgres: 5432

 

 

Instalando as dependências

Aqui estão as dependências do Webmin, instalação do Vim para edição dos arquivos e do wget para Download de arquivos.

 

 yum -y install wget vim perl-Authen-PAM perl-DBD-Pg perl-DBI perl-IO-Tty perl-Sys-Syslog perl-Digest-MD5 tcp_wrappers tcp_wrappers-devel

 

Adicionar repositório do Webmin

Para a instalação do Webmin, vamos adicionar seu repositório oficial. Caso queira fazer a instalação sem ser por repositório, basta ir ao site do Webmin e seguir o passo-a-passo deles.

cat &lt; /etc/yum.repos.d/Webmin.repo
 
[Webmin]
 
name=Webmin Distribution Neutral
 
mirrorlist=https://download.webmin.com/download/yum/mirrorlist
 
enabled=1
 
EOF

 

Baixando as chaves do Webmin

wget http://www.webmin.com/jcameron-key.asc
rpm --import jcameron-key.asc

 

Instalando o Bacula, Postgres e Webmin

yum -y install postgresql-devel postgresql-server bacula-director bacula-storage bacula-client bacula-console webmin

 

Configurando o Banco de Dados e Iniciando o Postgres

Nesse passo, vamos fazer a configuração do Postgres criando seu banco de dados e adicionando na inicialização do Centos7

postgresql-setup initdb
systemctl start postgresql
systemctl enable postgresql

 

Configuração do Bacula no Postgres

Com o banco de dados criado, precisamos criar as tabelas do bacula do nosso banco Postgres, assim como seu usuário e dar as permissões para esse usuário poder escrever no banco. Nesse momento vamos usar o usuário postgres para fazer esse processo.
O Bacula já disponibiliza scripts para esse processo. No Centos7, eles ficam em /usr/libexec/bacula/

 

su postgres
/usr/libexec/bacula/create_bacula_database
/usr/libexec/bacula/make_bacula_tables
/usr/libexec/bacula/grant_bacula_privileges

 

Ainda com o usuário postgres, vamos acessar o banco de dados e mudar a senha do usuário bacula.
Onde se lê senhabacula, coloque a senha que você deseja utilizar, mas lembre-se de usar as aspas simples no começo e no final da senha.

psql bacula
bacula=# alter user bacula with password 'senhabacula';
bacula=# \q

 

Agora sim podemos voltar ao nosso usuário

exit

Editando o Bacula Director 

Essa configuração do bacula-dir é necessária para que o Bacula possa conectar ao Postgres. Nela, vamos passar o endereço do Banco de Dados, o usuário e a senha criada no passo anterior.

vim /etc/bacula/bacula-dir.conf

aproximadamente na linha 235

original:  dbname = “bacula”; dbuser = “bacula”; dbpassword = “”

configurado:  dbname = “bacula”; dbuser = “bacula”; dbpassword = “senhabacula“; dbaddress = “127.0.0.1”

 

Configurando o banco de dados para aceitar as conexões:

Já que definimos um usuário e senha para o banco de dados, vamos fazer com que o Postgres reconheça essa requisição:

vim /var/lib/pgsql/data/pg_hba.conf

Onde estiver “peer” e/ou “ident”, mude para md5

Original:  local       all      all      peer    ou     host      all     all     127.0.0.1/32     ident

Configurado: local       all      all      md5    ou     host      all     all     127.0.0.1/32     md5

Ainda no mesmo arquivo, adicionar na última linha:

host    localhost       all     0.0.0.0/0       md5

 

Reiniciando os serviços

systemctl restart bacula-dir bacula-fd bacula-sd postgresql

 

Acesso ao Webmin

https://localhost:10000/ (no lugar de localhost, pode ser o IP da servidor)

login e senha são os usuários do seu servidor CentOs7

No menu da esquerda:

System > Bacula Backup System.

Caso não apareça, clicar em Refresh Modules no final do menu.

Ao clicar, vai aparecer um erro:

É normal, pois não informamos ao módulo Bacula do Webmin nosso usuário e senha do Banco de dados. Basta clicar em module configuration.

No menu Bacula Database Settings vamos informar qual banco de dados foi utilizado e qual seu usuário e senha:

 

Ao clicar em SAVE, vai aparecer a tela abaixo. Agora seu servidor bacula está instalado. Em post futuros pretendo falar sobre como ele funciona e como configurar seu backups.

Caso queira mudar o idioma para o Português do Brasil:

Webmin> Change Language and Theme

Portuguese (Brazilian) (PT_BR.UTF-8)

 

Fontes:

http://webmin.com/rpm.html
http://bacula.us/bacula-enterprise-automated-install-script-for-centos-7/

https://www.digitalocean.com/community/tutorials/how-to-install-bacula-server-on-centos-7
http://www.linuxtopic.com/2016/08/install-and-configure-mysql-postgresql.html#gsc.tab=0
https://www.digitalocean.com/community/tutorials/how-to-install-and-use-postgresql-on-centos-7

Ao som de: Seu Jorge – Life on Mars? (David Bowie Cover/Version)

Nesse post vou explicar como adicionar um servidor Linux em um domínio Samba. Digo servidor, pois recomendo a ferramenta CID, Close in Directory, do Eduardo Moraes, nos casos de ambientes gráficos.

Aqui foi utilizado um Ubuntu 16.04, mas a ideia é a mesma para qualquer distribuição, só observar se alguns arquivos de configuração estão caminhos diferente, como setar o IP no RHEL/CentOs.

O intuito aqui é ajudar quem quer colocar a máquina no domínio, por isso que ele é mais direto com os arquivos de configuração e não com as explicações detalhadas que cada arquivo e comando faz.
Ps: Caso apresente algum erro de autenticação durante o processo, criei um usuário com o hostname no seu AD.

 

Veja a disposição dos servidores na rede para explicação do artigo:

Domínio → dominio.local

Servidor controlador de domínio →192.168.0.4 servidor.dominio.local

Servidor DNS primário → 192.168.0.4

Servidor DNS Secundário →192.168.0.35

Servidor DHCP →192.168.0.1

Como os clientes serão configurados pelo serviço DHCP, só especificarei o nome da máquina cliente:

Desktop cliente → linuxcliente

 

SETAR O IP MANUALMENTE

Editar o arquivo interfaces:

# vim /etc/network/interfaces

auto enp0s3

iface enp0s3 inet static

address 192.168.0.100

netmask 255.255.255.0

gateway 192.168.0.1

dns-nameserver 192.1680.4 192.168.0.35

dns-search dominio.local

 

Editar o arquivo /ETC/HOSTS

Editar o arquivo /etc/hosts para incluir um alias para controlador de domínio e alterar o hostname do desktop cliente (linuxcliente), acrescentando o fqdn, ou seja, o nome do domínio junto ao hostname da máquina cliente.  No entanto, substitua os nomes abaixo pelos correspondentes na sua rede.

 

# vim /etc/hosts

Conteúdo a ser acrescentado:

127.0.0.1       linuxcliente.dominio.local    localhost   linuxcliente

192.168.0.4    servidor.dominio.local servidor

 

Agora vamos verificar se o nome da maquina foi alterado:
# hostname -f

 

Instalar os pacotes necessários

Para que o cliente possa ingressar no domínio, é necessário fazer a instalação dos seguintes pacotes (lembrando que os pacotes abaixo são para distros Debian Like):

# apt install vim ntp krb5-user krb5-config winbind samba samba-common smbclient cifs-utils libpam-krb5 libpam-winbind libnss-winbind

Se durante a instalação do kerberos forem apresentadas algumas telas com perguntas referentes ao KDC, pode continuar com um ENTER e seguir com a instalação dos pacotes.

 

Sincronizar data e hora com o servidor

Edite o arquivo de configuração do serviço NTP usando o Vim:

# vim /etc/ntp.conf

server 192.168.0.4

pool 192.168.0.4

restrict 192.168.0.4


Agora, reinicie o serviço de data e hora:

# /etc/init.d/ntp restart

ou

# service ntp restart

 

Resolução de DNS

Como o IP foi setado manualmente, provavelmente o resolv.conf já está com a configuração correta. Caso não esteja, basta adicionar o search e o nameserver

# vim /etc/resolv.conf

search dominio.local

nameserver 192.168.0.4

nameserver 192.168.0.35

 

Configurar o KERBEROS

Para um usuário autenticar-se no Active Directory, é necessário editar o arquivo /etc/krb5.conf e incluir informações sobre o servidor KDC (controlador de domínio kerberos). Nesse caso, o controlador de domínio com o Active Directory possui um KDC. Use o Vim para editar o arquivo e inclua as seguintes linhas no arquivo:

 

# vim /etc/krb5.conf

Conteúdo acrescentado:

[libdefaults]

default_realm = DOMINIO.LOCAL

[realms]

  DOMINIO.LOCAL  =  {

     kdc  =  servidor.dominio.local

     default_domain  =  DOMINIO.LOCAL

     admin_server  =  servidor.dominio.local

  }

[domain_realm]

.dominio.local = DOMINIO.LOCAL

 

Para fazer o teste de comunicação do nosso ubuntu com o servidor vamos utilizar o kinit. Execute o comando com o seu usuário cadastrado no servidor. No artigo estou usando o usuário “Administrator”.


# kinit Administrator

 

Agora vamos listar o ticket:

# klist

 

O retorno do  klist deverá ser algo parecido com:

Ticket cache: FILE:/tmp/krb5cc_1000

Default principal: administrator@DOMINIO.LOCAL

Valid       starting    Expires                 Service  principal

10-10-2017  12:00:32    09-10-2017  04:10:07    krbtgt/DOMINIO.LOCAL@DOMINIO.LOCAL

renew  until  13-10-2017  12:00:32

 

Configurar o SAMBA

Toda configuração é feita no/etc/samba/smb.conf. Vamos criar um arquivo de backup do smb.conf original e depois criar um arquivo novo em branco:

# mv /etc/samba/smb.conf /etc/samba/smb.conf.original
# vim /etc/samba/smb.conf

 

[global]

  security = ads

 realm= DOMINIO.LOCAL

  workgroup = DOMINIO

 idmap uid = 10000-15000

 idmap gid = 10000-15000

 winbind enum users = yes

 winbind enum groups = yes

 template homedir = /home/%D/%U

 template shell = /bin/bash

 client use spnego = yes

 winbind use default domain = yes

 restrict anonymous = 2

 winbind refresh tickets = yes

 

Agora restart o winbind e o samba

# service winbind restart

# service smbd restart

# service nmbd restart

Ingressar a máquina no domínio

Depois de configurar o Samba, execute o comando abaixo como root:

# net ads join -U Administrator

 

Assim como no Kinit, utilize um usuário com permissão para ingressar no domínio. O retorno do comando deve ser parecido com o que está abaixo:

 

Using short domain name – DOMINIO

Joined ‘LINUXCLIENTE’ to realm ‘DOMINIO.LOCAL’

 

Reinicie o Winbind:

# service winbind restart

 

Agora, faça o teste e liste os grupos e usuários do domínio com o comando wbinfo. Para listar usuários execute:

# wbinfo -u

 

Para listar os grupos execute:

# wbinfo -g

 

Caso não retorne nenhum nome de usuário ou grupo, reinicie o Winbind novamente.

Edite o arquivo NSSWITCH.CONF

Depois ingressar a máquina no domínio, é necessário editar o arquivo /etc/nsswitch.conf para que o sistema possa saber onde buscar informações de login dos usuários que estão se autenticando.

Edite o arquivo usando o Vim:

 

# vim /etc/nsswitch.conf

passwd: compat winbind

group: compat winbind

 

 

A partir desse momento, você já pode testar a maquina normalmente no domínio. Caso apresente algum erro, refaça o processo e verifique os usuários e suas permissões.

Leituras que me ajudaram a escrever esse artigo:
Viva o LinuxStato BlogTecMint

Ao som de Tulipa Ruiz – Proporcional

Dica rápida de como limpar o cache do Squid no PfSense 2.3.x. (versão que foi testada)
Obs: Antes de começar, veja qual é o proprietário e o grupo do diretório /var/squid/cache, pois será dada a permissão novamente a eles.

 

1 – Pare o serviço do Squid

/usr/local/etc/rc.d/squid.sh stop

 

2 – Remova o diretório do cache do squid e depois crie novamente

rm -rf /var/squid/cache/
mkdir -p /var/squid/cache/

 

3 – Altere o proprietário e o grupo para que estavam antes de apagar os diretórios:

chown proxy:proxy /var/squid/cache/
ou
chown squid:squid /var/squid/cache/

 

4 – Altere a permissão para 750:

chmod 750 /var/squid/cache/

 

5 – Reinicie o Squid:

squid -z
/usr/local/etc/rc.d/squid.sh start

Ao som de: Mamonas Assassinas – 1406

Linux é mais fácil que muita gente imagina. E essa simplicidade se torna uma ferramenta poderosa quando usada da forma certa.
Assim que comecei a usar o Linux, confesso, que usava essa simplicidade de forma não tão produtiva, pois dava certo, mas achava algumas coisas muito trabalhosas. Com o passar do tempo, fui aprendendo algumas formas mais efetivas de usar essas ferramentas.

O intuito desse post é passar algumas dicas que me ajudaram a melhorar a minha produtividade com o Linux. Todas as dicas são básicas, mas que economizam tempo e paciência.

Programas Básicos:

apt

Sei que muita gente é acostumada ao “apt-get” e acha que o “apt” é a mesma coisa, porém o “apt” vem com mais melhorias em seu código e é muito mais organizado para o usuário.

vim

Assim que você começa a usá-lo, não entende o porque as pessoas usam tanto. Até pra sair é “complicado”, tendo que digitar “:wq” para sair e salvar. Porém, algumas funcionalidades o fazem ser “amado” por tantos. Mais a frente vou colocar alguns comandos.

sl

Apenas instalem e nunca mais errem um list! Ou não!

htop

O caso do “htop” é semelhante ao “apt x apt-get”, onde seria “top x htop”. Nesse caso, a diferença é mais visível, pois a organização e as cores do htop dão uma organização melhor que a do “top”

iftop

É o “htop” para placas de redes.

iotop

É o “htop” de I/O de disco.

locate (ou mlocate)

O locate serve para pesquisar um arquivo dentro do sistema. Sim, já existe o “find”, que abordo mais a frente também, mas o locate torna a busca mais rápida, pois ele armazena a busca em um arquivo. Estando tudo indexado em um arquivo, o locate vai fazer a busca nesse arquivo e não no Hd todo, assim sendo mais rápido. Para atualizar esse arquivo basta usar o comando “updatedb”. Ele já vem por padrão no RHEL/Centos, mas na família Debian basta um “apt install mlocate”.

terminator

Depois que descobri esse emulador de terminal, consigo ter uma organização das telas dos terminais muito melhor. A forma que ele divide as telas ajuda bastante para deixar o trabalho mais efetivo, fora a sua customização.

Comandos Básicos:

Passado os programas básico (sim, lista pequena e quase óbvia), dicas de como costumo usar alguns comandos.

ps fuxa

Essa dica aprendi com o Mestre Pedro Veríssimo. O “fuxa” mostra o ps com usuário, PID, %cpu, %mem, TTY, horário do início do processo, o tempo desse processo e o comando no formato de árvore. Para saber o que cada argumento faz, leia o manual (man ps). Tente combinações que você consiga gerenciar melhor os processos rodando nos seus sistemas.

ss -a

O netstat está obsoleto a alguns anos, então essa dica é mais uma atualização. Você pode ler sobre isso nessa reportagem do site Linux Descomplicado. Sobre o assunto, estou criando coragem (e amadurecendo as ideias) para abordar isso de uma forma mais completa. “Manter velhos hábitos, mas que eu sei o que estou fazendo e meu sistemas fica estável” x “Me atualizar, utilizando novas ferramentas, aprendendo novas maneiras de gerir os sistemas, mas que não sei como é o comportamento a longo prazo”.

cd –

Comando básico que muita (mesmo) gente ignora. Serve para voltar ao diretório anterior que você estava. Favor não confundir com o “cd ..” que sobe um diretório. Exemplo: se vocês estava em “/etc/network/interfaces.d/” e foi para “/var/log/”, ao digitar “cd -” você “volta” para “/etc/network/interfaces.d/”. Caso o comando fosse “cd ..” você subiria um nível, indo para “/var/”.

cd ~

Comando que faz você voltar para o home do atual usuário. Se estiver em “/etc/network/interfaces.d/” e digitar “cd ~”, vou para “/home/bruno/”

sudo !!

Já aconteceu de você usar um comando “gigante” e quando apertou “Enter” viu que esqueceu o “sudo” no começo? Eu sei a raiva que isso gera. Aí você, no modo mais “prático”, usa a seta para cima, depois home, depois digita sudo e enter novamente. Não é isso? Era! Basta “sudo !!” e o último comando será executado como se o sudo estivesse no começo. Testa aí.

ctrl + r

Outra do Mestre Pedro Veríssimo. É uma busca dentro do history. Você vai digitando a busca e ele já mostra o comando, bastando um simples “Enter”. E cada vez que usa a combinação ctrl + r enquanto está buscando, ele vai mostrando outros resultados. Nada mais de “history | grep” quando se sabe o que quer procurar, certo?

history + !número

Mesmo com a dica acima, o history é importante. A busca serve pra quando você lembra o que foi digitado, mas e quando não se lembra? history, claro. Aí você acha o que quer, vai selecionar, copiar (ctrl + insert) e depois colar (shift + insert), né? Não mais. Digamos que o comando que você queira está listado como o 149, basta digitar !149 e o comando será executado.

Outras Dicas:

Abaixo alguns comandos precisei usar para situações diversas.

Localizar um tipo de arquivo e a partir de um certo tamanho.

Como assim? Preciso encontrar todos meus vídeos no formato AVI e com mais de 700MB:

find /home/bruno/Vídeos -type f -name “*.avi” -size “+700M” -exec ls -lah {} \;

Mas o segredo é tentar outras combinações como exemplo: arquivos maiores que 100Mb, mas menores que 200Mb:

find /home/bruno/Vídeos -type f -name “*.avi” -size “+100M” -size “-200M” -exec ls -lah {} \;

Dica boa pra quem ainda tem aquelas fotos com o nome “dsc000…”, só colocar o -iname

 

Trabalhando com diretórios em sequência.

Se você já fez “mkdir pasta01/ pasta02/ pasta03/ pasta04/”, você conseguiu o que queria, mas e se for 50 pastas? Vai fazer um shell script com alguma estrutura de laço para repetir até o 50? Pode ser, mas também dá um trabalho. E que tal um comando só?

mkdir -p /home/bruno/pasta{1..50}

Massa, né? E se dentro dessas pastas você tenha que criar outras 10 pastas?

mkdir -p /home/bruno/pasta{1..50}/subpastas{1..10}

Agora sim, muito massa. Mas não se limite aí, pois esse comando não é exclusivo do mkdir, muito pelo contrário. Qualquer comando que trabalhe com os diretórios e arquivos, aceita esses argumentos. Um bom exemplo é apagar essas 50 pastas

rm -rf /home/bruno/pasta{1..50}

 

Criando um “Alias” da maneira certa.

Já vi muitos “tutoriais” ensinando a criar tutorial da forma certa: alias ll=’ls -lahF’, por exemplo. Mas na hora de deixar isso permanente, muita gente criar um script pra iniciar junto com o sistema e assim atribuir esse alias. Só que no linux existe um arquivos pra isso e nele já existe alguns alias e até com exemplo. Basta editar (usando o vim, né?) o arquivo .bashrc que fica no diretório home do seu usuários:

vim ~/.bashrc

Depois só salvar, fechar o terminator (claro!) e abrir novamente. o “ll” foi exemplo, pois algumas distribuições já vem com esse alias, mas você pode adicionar qualquer alias nesse arquivo. Exemplo para atualização com o usuário root:

alias atualizar=”apt update && apt -y upgrade”

Usando melhor o VIM

O VIM tem milhões de atalhos, que você pode conferir alguns aqui, mas os mais básicos parecem ser os mais ignorados:

gg = Início da primeira linha do arquivo
G = Início da última linha do arquivo
yy = Copia a linha atual do cursor
y⇑ = Copia a linha do cursor mais a linha acima
y⇓ = Copia a linha do cursor mais a linha abaixo
y20⇑ = Copia a linha do cursor mais as 20 linha acima
y20⇓ = Copia a linha do cursor mais as 20 linha abaixo
p = Cola a linha abaixo da posição do cursor
P = Cola a linha acima da posição do cursor
dd = Apaga a linha atual do cursor
d⇑ = Apaga a linha do cursor mais a linha acima
d⇓ = Apaga a linha do cursor mais a linha abaixo
d20⇑ = Apaga a linha do cursor mais as 20 linha acima
d20⇓ = Apaga a linha do cursor mais as 20 linha abaixo
u = Desfaz o último comando

Se o seu terminator (né?) está com o fundo preto, diga ao VIM isso para que ele possa mostrar tudo nas cores certas.

:set backgroud=dark

Quando se faz uma busca dentro do VIM (/termo), há algumas opções:
N = Busca o próximo termo acima da posição atual do cursor
n = Busca o próximo termo abaixo da posição atual do cursor

Para realçar o termo que foi buscado no texto:

:set hlsearch

E para remover esse realce da busca:

:nohlsearch

 

Substituição dentro do VIM

Caso queira substituir um dentro da linha onde o cursor está posicionado, basta fazer:

:s/foo/bar/g

No nosso caso, onde tiver “foo” na linha atual, será substituído por “bar”.
Caso queira no documento todo, basta adicionar % no inicio:

:%s/foo/bar/g

 

Como disse no começo, são dicas básicas, mas que me ajudam muito e espero que ajude mais pessoas.
Vou postar os sites que descobri alguns desses comandos e que (alguns) estão mais completos em suas explicações e com outros exemplos:

https://debian-handbook.info/browse/pt-BR/stable/index.html
https://www.vivaolinux.com.br/artigo/Diario-de-um-SysAdmin-1-Truques-Macetes-Atalhos-e-Comandos
https://www.vivaolinux.com.br/artigo/Diario-de-um-SysAdmin-2-Truques-Macetes-Atalhos-e-Comandos
http://michael.peopleofhonoronly.com/vim/vim_cheat_sheet_for_programmers_colorblind.png
http://vim.wikia.com/wiki/Vim_Tips_Wiki 

Ao som de: Dream Theater – Erotomania/Voices/The Silent Man (A Mind Beside Itself) – Live Scenes from New York 

Esse post é uma continuação direta do anterior, onde foi criado um container baseado em um imagem. Nesse post vamos detalhar mais a utilização das imagens.
Caso não tenha lido, clique aqui: http://161.35.238.43/docker-instalando-o-docker/

 

Para ver as imagens contidas no Docker da sua máquina, basta digitar:

# docker images

 

Irá aparecer uma tela com 5 campos: REPOSITORY, TAG, IMAGE ID, CREATED e SIZE.

  • REPOSITORY é correspondente ao nome da imagem;
  • TAG é a versão da imagem criada;
  • IMAGE ID é o número de identificação que o Docker cria para a sua imagem. Mais a frente iremos ver outros comando onde poderemos informar tanto o nome quanto a ID da imagem;
  • CREATED é a data da criação da imagem;
  • SIZE é o tamanho total da imagem que foi criada.

 

Como dito anteriormente, foi realizado o download de uma imagem para a execução de uma aplicação, hello-world, dentro de um container. Já vimos a imagem, agora é hora de ver o container com o comando:

# docker ps

 

No nosso caso, não irá aparecer nenhum container, apenas os 7 campos de identificação dos containers: CONTAINER ID, IMAGE, COMMAND, CREATED, STATUS, PORTS e NAMES.

  • CONTAINER ID é o número de identificação do container, equivalente ao IMAGE ID do “docker images”;
  • IMAGE informa qual imagem foi utilizada para a criação do container;
  • COMMAND mostra qual é o comando que está em execução no container. Veremos mais informações a frente;
  • CREATED é a data de criação do container;
  • STATUS exibe o status atual do container;
  • PORTS informa as portas do host e do container que foram utilizadas. Também será tratado mais a frente;
  • NAMES informa o nome do container.

Você deve estar se perguntando por que não tem nenhum container se você executou o Hello World. Se ele é um container, ele era para aparecer quando digitou o comando docker ps ou não?


Para responder essa dúvida, vamos utilizar o parâmetro “-a” no comando anterior. Ficará assim:

# docker ps -a

 

Com a inserção do parâmetro “-a”, o docker exibe todos os containers, incluindo os que estão parados ou que já foram finalizados. Com este comando, o container “hello-world” irá aparecer. O que aconteceu é que o container “hello-world” foi criado e logo em seguida, finalizado. Nesse caso específico, esse container serve apenas como teste para ver se o docker está criando os containers normalmente. Então, o docker fez o download da imagem, criou o container, exibiu a tela da nossa primeira imagem e depois foi finalizado.

Para exemplo de como criar um container e deixá-lo funcionando, vamos criar um novo container com o conteúdo do Ubuntu 14.04.

O comando para criação é esse:

# docker run -ti ubuntu:14.04 /bin/bash

 

O docker run já havíamos visto anteriormente, mas há novos argumentos. O “-t” diz ao container que vamos precisar de um terminal. O “-i” que este container será interativo, ou seja, o STDIN ficará ativo. Também identificamos qual imagem e versão utilizamos com o argumento, o ubuntu:14.04. No último argumento estamos informando qual processo queremos que o container inicie, no caso, o Bash.

Assim que digitar o comando, o docker inicialmente vai procurar a imagem localmente, no nosso caso, Ubuntu 14.04. Como não vai encontrar, ele fará o download da imagem oficial no seu repositório (https://hub.docker.com/explore/) e irá criar o container baseado nessa imagem.

Ao terminar a criação do container, o docker já permite interação direta dentro do container. Para verificar a veracidade dessa informação, basta digitar um comando que identifique qual a versão instalada. No caso do Ubuntu 14.04 vamos exibir o arquivo issue.

 

# cat /etc/issue

 

Nesse ponto é importante que você se atente a infraestrutura que foi montada até agora. Caso você esteja executando seu Docker em uma máquina Debian 8, por exemplo, há um outro sistema operacional, o Ubuntu 14.04, funcionando dentro de um container.

Temos um Ubuntu 14.04 funcionando dentro de um container. Este container está sendo executado dentro do Debian 8 e os dois sistemas estão utilizando o mesmo Kernel, neste caso é Kernel do Debian 8 que é onde o Docker está instalado e gerenciando os containers.

Como estamos atualmente dentro do container do Ubuntu, digite “uname -r” e verá que o resultado vai ser o mesmo obtido anteriormente, no momento da verificação da versão do kernel do host.

Para sair do container sem finalizá-lo, segure a tecla Ctrl e digite na ordem a letra P e depois a Q, só aí você pode soltar o Ctrl. Há uma segunda maneira de sair do container, porém essa finaliza o bash, assim, finalizando o container também. O segundo comando é o Ctrl+D. Isso acontece, pois quando informamos o bash na hora da criação da imagem, estamos passando para o Docker que o Bash será o processo principal do container, chamado de entrypoint. Caso o entrypoint seja finalizado, o container também é finalizado.

 

No nosso exemplo, vamos usar o primeiro comando para manter o container ativo. Agora, executar o comando docker ps para ver se o container criado com a imagem do Ubuntu 14.04 está ativo.

docker ps

 

Caso queira acessar novamente um container, basta usar o attach e o seu ID para acessá-lo. Lembre-se, como o número do ID é único, ele irá aparecer diferente no seu ambiente.

# docker attach 5c595a8d4237

 

Na versão 1.13 (hoje renomeada para 17.03) foi foram realizadas mudanças que trouxeram mais organização ao Docker. Esse mesmo “docker attach” pode ser feito através do “docker container attach”. Isso porque foi implementado um submenu para cada função. Abaixo, alguns comandos do submenu container:

  • attach (container ID): Acessa um container ativo;
  • commit: Cria uma imagem baseado no container ativo;
  • create: Cria um novo container, mas sem acessá-lo;
  • exec (container ID): Executa um comando no container sem acessá-lo;
  • inspect (container ID): Mostra todas as informações do container;
  • kill (container ID): Finaliza um ou mais container;
  • ls: Lista todos os containers;
  • pause (container ID): Pausa o container (sério?);
  • port (container ID): Lista as portas usadas no momento da criação do container. Será visto mais a frente;
  • prune: Finaliza todos os containers que não estão sendo usados.
  • rm (container ID): Remove um ou mais container;
  • start (container ID): Inicia um ou mais container;
  • stats (container ID): Mostra o status do container;
  • stop (container ID): Para um ou mais container;

Para ver a lista completa:

# docker container –help

 

No próximo post vou abordar o Dockerfile!

Ao som de: Emerson, Lake & Palmer – Tarkus

No primeiro post falei um pouco sobre o que o Docker é (e o que não é também) e como ele funciona. Recomendo a leitura para não ficar perdido em alguns conceitos que apareceram nesse post e nos seguintes. Clique aqui para ir ao post “O que é Docker?”.

Nesse segundo post, como prometido, um pouco de prática. Vamos fazer a instalação do Docker em um Debian!

Primeiramente, vamos verificar os requisitos de instalação:

  1. O processador deve ser 64bits;
  2. O Kernel do sistema operacional base deve ser igual ou superior a versão 3.10 estável;
  3. O Kernel deve ter suporte à AUFS, Device Mapper, OverlayFS, Cgroups e Namespaces.

 

Caso não saiba qual versão do Kernel do seu sistema, basta digitar o comando no terminal:

# uname -r

 

Em algumas distribuições, o Docker já está no repositório. No nosso caso, vamos usar o Debian como Sistema Operacional Base para fazer a instalação do Docker.

 

Se não souber qual o Debian está usando, digite o comando lsb_release -cs que retornará uma das palavras: Wheezy (para o Debian 7), Jessie (para o Debian 8) ou Stretch (para o Debian 9).

 

Se o retorno que obteve foi Jessie ou Stretch, digite o seguinte comando:

# sudo apt-get -y install apt-transport-https ca-certificates curl software-properties-common

 

Caso tenha aparecido Wheezy:

# sudo apt-get -y install apt-transport-https ca-certificates curl python-software-properties

 

Para as duas situações acima, os próximos comandos são os mesmos:

# curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add –
# sudo add-apt-repository \
“deb [arch=amd64] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) \
stable”

# sudo apt-get update

 

Esses comandos irão instalar as dependências necessárias para fazer o download, a adição dos repositórios oficiais e atualização desses repositórios.

Observação: Se estiver usando o Wheezy e apresentar erro quando for atualizar o repositório, altere o arquivo /etc/apt/sources.list apagando a linha que contém essa informação:
deb-src [arch=amd64] https://download.docker.com/linux/debian wheezy stable

 

Agora basta fazer a instalação do docker-ce (O Docker CE, Community Edition, é a versão gratuita do docker) utilizando nosso querido APT-GET:

# sudo apt-get -y install docker-ce

 

O sistema operacional irá instalar a versão mais nova do docker. No momento dessa postagem o Docker está contando as versões pelo Ano.Mês, no caso a versão atual é a 17.05.

 

Agora vamos verificar se já foi feita a instalação normalmente e se é possível criar um container. Após o término da instalação, vamos digitar no terminal:

# docker run hello-world

 

Esse comando irá criar um container, com uma imagem personalizada, com a frase mais conhecida pelos estudantes de programação (com uma pequena variação): Hello World.

 

 

Caso tenha aparecido um texto igual a da imagem acima, você já criou o seu primeiro container!

Com esse comando o Docker verificou se já existia o container Hello-world. Como não existia, pois acabamos de fazer a instalação, o próprio Docker fez o download da imagem e depois criou o container utilizando, automaticamente, essa imagem. Mágico, não?

 

O objetivo desse post era abordar apenas a instalação do Docker-ce e verificar se a instalação ocorreu normalmente. Caso queira fazer a instalação do Docker em outros sistemas operacionais, vá a página oficial do Docker para as instruções de cada sistema operacional. Clique aqui para ir direto à pagina.

 

Ao som de Dream Theater – In The Name of God