> For the complete documentation index, see [llms.txt](https://mysther.gitbook.io/knowledge-base/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://mysther.gitbook.io/knowledge-base/sistemas-operacionais/linux/utilizacao.md).

# Utilização

### Verificando o Hardware

Comando para ver configuração de hardware no Linux:

```bash
less /proc/cpuinfo
```

###

### Distribuição, Versão e Arquitetura

```bash
# Informações sobre o SO
cat /etc/issue
cat /etc/*-release

# Versão do Kernel
uname -a

# Arquitetura
arch
```

### Módulos do Kernel

Verificando módulos do kernel

```bash
lsmod
```

Selecione um módulo no resultado do comando acima e execute o comando abaixo para ver mais detalhes

```bash
modinfo <module>
```

###

### Manuais de Ferramentas

A maioria das ferramentas disponíveis do Linux, possui um manual (*man pages*), que podem ser acessados pelo comando:

```bash
man <command>
```

As páginas do manual são referenciadas por meio de seções enumeradas, por exemplo, `ping(8)` significa que determinada informação do comando `ping`, está na seção 8.  Então para acessarmos, vamos utilizar o comando:

```bash
man 8 ping
```

Caso não especifique a seção do manual, o comando `man` irá exibir o primeiro que achar. Segue abaixo uma lista com o significado das seções:

| SEÇÃO | DESCRIÇÃO                                                                          |
| ----- | ---------------------------------------------------------------------------------- |
| 1     | Comando de Usuário                                                                 |
| 2     | Chamadas de Sistema                                                                |
| 3     | Documentação geral da biblioteca de programação Unix                               |
| 4     | Interface de dispositivos e informações sobre drivers                              |
| 5     | Descrições de arquivo (arquivos de configuração de sistema)                        |
| 6     | Jogos                                                                              |
| 7     | Formatos de arquivo, convenções e codificações (ASCII, sufixos e assim por diante) |
| 8     | Comandos de sistema e servidores                                                   |

###

### Verificando Espaço em Disco

```bash
df -lh
df -h
```

### Verificando Memória

```bash
free -hw
```

### Monitorando Processos

```bash
htop
atop
top
iotop
```

### Arquivos de Processos

Em `/proc/self/fd/<id>`, podemos ver o descritor de arquivos de todos os processos. Útil para procurarmos por informações úteis e/ou flags escondidas

### Variáveis de Ambientes

#### Variáveis de Ambiente vs Variáveis de Shell

Antes de mais nada, vamos diferenciar as`Variável de Ambiente` com as`Variável de Shell.` A primeira não é específica do shell e todos os processos de sistemas UNIX podem armazenam e utilizar. Já a segunda é uma variável temporária para o shell (esta não aparece na saída do comando `env`).

```bash
# Definindo Variável de Ambiente
export MYVAR1=valor

# Definindo Variável de Shell
MYVAR2=valor

# Transformando a Variável de Shell em Variável de Ambiente
export MYVAR2

# Exibindo o valor de uma Variável
echo $MYVAR
```

#### Visualizando

Abaixo os comandos para visualizar as Variáveis de Ambiente já definidas

```bash
env
printenv
cat /etc/environment
cat /etc/profile
cat /etc/bashrc
cat ~/.bash_profile
cat ~/.bashrc
cat ~/.bash_logout
set
```

###

### Logar com Root

Para ficar logado como root, digite um dos seguintes comando:

```bash
sudo -s
sudo -su
sudo -
```

###

### Gerenciando Usuários

```bash
# Adicionando um usuário ao sudo
adduser <user> sudo

# Removendo um usuário do sudo
deluser <user> sudo

# Acessando o perfil de outro usuário
su <user>

# Executando comando como se fosse outro usuário
su -c <commad> - <user>
```

### Alterando Senha

```bash
echo "<user>:<pass>" | chpasswd
```

### APT

```bash
# Instala um software
sudo apt install <nome_pacote>

# Remove um software
sudo apt remove <nome_pacote>

# Remove pacotes antigos que não são mais necessários ao funcionamento correto do SO
sudo apt autoremove

# A função "remove" não destrói nenhum arquivo de configuração e deixa esses itens no HD, para o caso desses arquivos serem utilizados no futuro. Utilize o "purge" para remover esses arquivos
sudo apt purge <nome_pacote>

# Remove os pacotes já instalados (os instaladores), pois os mesmo depois de instalados, não são mais úteis
sudo apt clean

# Deve ser executada depois do "update" e "upgrade", pois este removerá pacotes antigos que foram substituídos por pacotes novos
sudo apt autoclean

# Verifica por atualizações para as várias aplicações e pacotes instalados no Linux. Utilize esse comando antes do "upgrade"
sudo apt update

# Instala todas as versões novas de pacotes de softwares já instalados e atualiza a versão da distribuição do Linux. Utilize esse comando depois do "sudo apt update"
sudo apt upgrade

# Pesquisando por softwares
sudo apt search <nome_programa>

# Atualizando todo o sistema
sudo apt update && sudo apt upgrade && sudo apt dist-upgrade && sudo apt autoremove && sudo apt autoclean
```

###

### Chaves do APT

Ao receber erro de chave no `apt install`, como `NO_PUBKEY 07DC563D1F41B907`, basta pegar os últimos 8 caracteres, nesse caso `1F41B907`, e digitar os seguintes comandos:

```bash
gpg --keyserver pgpkeys.mit.edu --recv-key 1F41B907  
gpg -a --export 1F41B907 | sudo apt-key add -
```

**OBS.:** Caso o primeiro comando acima dê erro, utilize um dos comandos abaixo:

```bash
gpg --keyserver pgp.mit.edu --recv-keys 1F41B907
gpg --keyserver pool.sks-keyservers.net --recv-keys 1F41B907
```

Se o erro ainda persistir, altere a URL `pgpkeys.mit.edu` por `pool.sks-keyservers.net`.

###

### Instalações Essenciais

```bash
sudo apt-get install build-essential linux-headers-`uname -r` module-assistant
sudo m-a prepare
```

###

### DPKG

```bash
# Instala um pacote deb
sudo dpkg -i <arquivo.deb>

# Remove um pacote deb
sudo dpkg -r <arquivo.deb>

# Faz o "purge" de um pacote deb, semelhante ao "apt-get". Atente-se ao "P" maiúsculo
sudo dpkg -P <arquivo.deb>

# Mostra o status corrente dos softwares instalados ou removidos
sudo dpkg -l <nome_pacote>

# Mostra as informações sobre determinado pacote
sudo dpkg -p <nome_pacote>
```

{% hint style="info" %}
**OBS.:** Depois de utilizar o comando **`dpkg -i`** (instalação), execute `sudo apt install -f`, para que o `apt` possa verificar o que foi feito e corrigir qualquer problema que tenha aparecido durante a instalação
{% endhint %}

### Desabilitando IPv6 (Debian)

```bash
sudo sysctl -w net.ipv6.conf.all.disable_ipv6=1
sudo sysctl -w net.ipv6.conf.default.disable_ipv6=1
sudo sysctl -w net.ipv6.conf.lo.disable_ipv6=1
```

### Arquivos passwd e shadow

#### passwd

O arquivo `/etc/passwd` (utilize o comando `vipw` para editá-lo) armazena informações da conta do usuário separadas por `:`. No exemplo abaixo temos a seguinte linha

```
teste:x:1001:1001:,,,:/home/teste:/bin/bashrc
```

| **BLOCO**     | DESCRIÇÃO                                                                                                                                                                                                                                                                                                                                                                                                 |
| ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `teste`       | Usuário                                                                                                                                                                                                                                                                                                                                                                                                   |
| `x`           | Senha criptograda que fica `/etc/shadow`. Se o usuário não tiver uma senha, o campo da senha terá um \* (asterisco)                                                                                                                                                                                                                                                                                       |
| `1001`        | Todo usuário deve receber um ID (UID). O UID 0 (zero) é mantido para o usuário root, os UID's de 1 a 99 são mantidos para contas pré-definidas adicionais, os UID's de 100 a 999 é mantido pelo sistema para fins administrativos e o UID 1000 é quase sempre o primeiro usuário que não é do sistema, geralmente um administrador. Se criarmos um novo usuário em nosso sistema, ele receberá o UID 1001 |
| `1001`        | Indica o grupo de cada usuário. Assim como os UID's, os 100 primeiros GIDs geralmente são mantidos para uso do sistema, o GID de 0 refere-se ao grupo raiz e o GID de 1000 geralmente significa os usuários. Geralmente, novos grupos recebem GID's iniciados a partir de 1000                                                                                                                            |
| `,,,`         | Este é o Gecos Field. Geralmente, esse é um conjunto de valores separados por vírgula que informa mais detalhes relacionados aos usuários. O formato para o campo GECOS indica as seguintes informações: Nome completo do usuário, número do edifício e da sala ou pessoa de contato, número de telefone do escritório, número de telefone residencial, qualquer outra informação de contato              |
| `/home/teste` | Indica o caminho do diretório inicial do usuário, onde todos os seus arquivos e programas são armazenados. Se não houver um diretório especificado, então `/` se tornará o diretório do usuário                                                                                                                                                                                                           |
| `/bin/bash`   | Denota o caminho completo do shell padrão que executa o comando (pelo usuário). Caso queira mudar de shell padrão, utilize o comando `chsh`                                                                                                                                                                                                                                                               |

#### shadow

As senhas do Linux (na maioria das distribuições), podem ser encontrada em `/etc/shadow` e seguem o seguinte padrão:

* São dividas em 3 partes, utilizando um cifrão ($) como delimitador
* A primeira parte (contendo apenas 1 dígito) informa o tipo de criptografia (1 = MD5 | 2 ou 2a = Blowfish | 5 = SHA-256 | 6 = SHA-512)
* A segunda parte indica o salt, para garantir que senhas iguais tenham hashes diferentes
* A terceira parte é o hash da senha

Linux utiliza `MCF (Modular Crypt Format)`, um dos formatos mais utilizados em sistemas UNIX. Sistemas como Iphone não usa MCF, o que facilita quebrar a senha

###

### Log de Logins

Mostra os últimos logins

```bash
last
```

Mostra os últimos logins para cada usuário do sistema

```bash
lastlog
```

### Rwho

Para enumerar usuários conectados a um host remoto e que esteja executando o daemon rwho (rwhod), digite:

```bash
rwho <ip>
```

### Procurando Ferramentas no Próprio SO

```bash
# Verifica onde está o executável do comando
which <command>
whereis <command>

# Procura por todas as ferramentas de determinado tipo (ex.: editor)
apropos <type>
```

### GRUB

As vezes podemos nos deperar na situação onde, o GRUD está instalado, porém não reconhece o Windows. Para corrigir isso, primeiro vamos veriricar se o Windows está disponível

```bash
sudo os-prober
```

Caso seja positivo, edite o arquivo `/etc/default/grub` e junto com as linhas onde não estão comentadas, adicione o conteúdo abaixo:

```bash
GRUB_DISABLE_OS_PROBER=false
```

Agora basta atualizar o grub com o comando abaixo e depois reiniciar o computador.

```bash
sudo update-grub
```

### Services

#### service

```bash
# Inicializando um Serviço
sudo service <service> start

# Parando um Serviço
sudo service <service> stop

# Reiniciando um Serviço
sudo service <service> restart

# Verificando status de Serviços
sudo service <service> status
sudo /etc/init.d/<service> status

# Listando todos os serviços e seus respectivos status
sudo service --status-all
```

#### systemctl

```bash
# Listando serviços
systemctl list-units --type service --all

# Listando arquivos de serviços
systemctl list-unit-files

# Ativando o serviço
systemctl enable <service>

# Ativando o serviço de maneira mais agressiva
systemctl enable --now <service>

# Desativando o serviço
systemctl disable <service>

# Verificando o status
systemctl status <service>
systemctl is-active <service>

# Inicializando o serviço
systemctl start <service>

# Parando o serviço
systemctl stop <service>

# Reiniciando o serviço
systemctl restart <service>
```

Ao utilizar o `enable`, pode-se utilizar o caminho completo do `file.service`, caso não esteja no diretório padrão.

#### update-rc.d

```bash
# Configura determinado serviço para inicializar junto com SO
update-rc.d <service> enable

# Configura determinado serviço para não inicializar junto com SO
update-rc.d <service> disable
```

### Cronjob

```bash
# Cria uma nova Cronjob para o usuário atual. Selecione o editor de texto e coloque algo como: */10 * * * * <script.sh>
crontab -e

# Cria uma cron para o usuário root
crontab -u root -e

# Lista todas as Cronjobs que estão configuradas para o usuário atual
crontab -l

# Visualiza as cronjobs de determinado usuário
crontab -u <user> -l
```

**OBS.:** Para gerenciarmos de forma que podemos escolher o usuário que irá executar o script, basta editar o arquivo `/etc/crontab`.

No arquivo `/etc/crontab` também é possível esconder a execução de um script é uma linha que está comentada (inicia com um `#`), como no exemplo abaixo, onde o script após o `\r` será executado normalmente.

```bash
# Comentário qualquer\r* * * * * echo "Executado com Sucesso!"
```

###

### Acessando Windows via RDP

#### rdesktop

```bash
rdesktop <ip>
```

#### freeRDP

```bash
xfreerdp <ip> /workarea
xfreerdp /u:<user> /v:<ip> /workarea
xfreerdp /u:<user> /p:<password> /v:<ip> /workarea
```

### Listando Portas e Seus Serviços

Para ver uma lista completa de portas e serviços que podem rodar em um Linux, digite no terminal:

```bash
cat /etc/services
```

### Executando Comandos sem Deixar no Histórico

Coloque um espaço antes dos comandos

```bash
 id
```

### Link Simbólico

O mesmo que atalhos no Windows

```bash
ln -s /etc/shadow shadow
```

### Subcomandos

```bash
echo 'meu usuario e '`whoami`
echo 'meu diretorio atual e '$(pwd)
```

###

### Deixando Comandos Universal

A vantagem disso, é que é possível chamar determinado arquivo de qualquer lugar do SO (no terminal)

```bash
cp </path/file> /usr/bin/
```

###

### lsof

```bash
# Mostra os arquivos abertos identificado pelo nome de usuário, representado aqui pelo identificador usuário
lsof -u <usuario>
# Mostra os arquivos abertos por um determinado grupo, identificado aqui numericamente pela variável n
lsof -g n
# Mostra os arquivos abertos por um determinado número de processo (PID), representado aqui pela variável n
lsof -p n
```

### Expect

Automatizando a conexão com FTP. Crie um arquivo chamado ftp.sh com o seguinte conteúdo.

```bash
#!/usr/bin/expect -f
set verbose_flag 1
spawn ftp <ip>
expect "Name "
send "<user>\r"
expect "Password:"
send "<password>\r"
expect "ftp>"
send "prompt\r"
expect "ftp>"
send "ls\r"
send "bye\r"
expect eof
```

### Criando e Montando um Diretório Próprio

```bash
# Cria um pedaço na memória
truncate -s 100MB nameOfFile

# Anexa um arquivo de sistema ao arquivo
mkfs.ext4 ./nameOfFile

# Monta-o em sistemas de arquivos
sudo mount ./nameOfFile /mnt/blablabla
```

### Unidade de Discos Disponíveis

```bash
lsblk
```

### Deixando o Pendrive Bootavel

```bash
sudo dd bs=4M if=arquivo.iso of=/dev/<partition> conv=fdatasync status=progress

# Ou

dd if:</path/to/file.iso> of=/dev/sdb
```

**OBS.:** Utilize `dmesg` ou `lsblk` para descobrir a partição do USB

###

### Montando e Desmontando Unidades (HD/USB)

Saber montar e desmontar um diretório pode ser muito útil, como por exemplo, caso queira ter acesso a um Diretório NFS remoto

```bash
# Montando um dispositivo USB acessível ("/dev/usb") em `/media/new`:
mkdir /media/new
mount -t ntfs /dev/usb /media/new # O paramêtro "-t" não é obrigatório
# Desmontando um dispositivo USB:
umount /media/new
```

**OBS.:** Caso o disco não esteja em `/dev/usb`, execute `sudo fdisk -l` e veja se consegue encontrá-lo e então executar o comando acima para montar.

### Montando Unidade de Disco de Outro Host

Para isso é preciso que outra máquina esteja compatilhando um ou mais diretórios.

```bash
sudo mkdir /mnt/tmp
sudo mount -t cifs -o 'user=<user>,password=<pass>' //<ip>/<diretorio> /mnt/tmp
```

### Lendo Arquivos Deletados do Pen Drive

Para ler conteúdo de arquivos deletados em um USB, primeiro é preciso ver a sua partição:

```bash
df -lh
```

Você então deverá ter uma saída como:

```bash
/dev/sdb        6.8M   53K  5.4M   9% /media/usbstick        6.8M   53K  5.4M   9% /media/usbstick
```

Após isso, execute o comando abaixo para ler conteúdos de arquivos:

```bash
strings /dev/sdb
grep -a <string> /dev/sdb
```

### noexec

Execute o comando `mount` e verifique sa há particões com a flag `noexec` ativa. Se tiver, significa que nessa montagem (diretório) não pode ser executado nenhum arquivo

###

### Output em Colunas

Dividindo a saída em colunas

```bash
echo 1 2 3 4 5 6 7 8 9 10 | xargs -n <quantidade_colunas>
```

###

### Acessando Site via Terminal

#### curl

```bash
# Retorna o HTML da página
curl <url>

# Acessando páginas com HTTPS
curl <url> -k

# Verificando se o host aceita HTTP 1.0
curl <url> -I --http1.0

# Modo silencioso
curl -s <url>

# Retorna somente o cabeçalho
curl -I <url>
curl <url> -o /dev/null --dump-header -

# Retornando somente o HTTP Code
curl -s -o /dev/null -w "%{http_code}" <url>

# Altera o User Agent, que por padrão é "curl/{version}". Bom alterar caso esteja utilizando o Curl como bot
curl --user-agent "{user_agent}" <url>

# Envia parâmetros via POST
curl --data "param1=teste&param2=teste" <url>

# Acesso via POST (mas com parâmetros vazios)
curl -X POST <url>

# Postando arquivo via POST
curl -X POST -F 'image=@/path/to/pictures/picture.jpg' <url>

# Acessando página que solicita Basic Authentication
curl -u <user>:<pass> <url>

# Acessando página que solicita autenticação digest
curl --digest -u <user>:<pass> <url>

# Utilize quando for fazer ataque de LFI, pois por padrão o curl irá tratar sequencias de caracteres como ../../
curl --path-as-is <url>

# Enviando um arquivo
curl -d @<file.txt> http://site.com/upload
curl --upload-file <file> http://site.com/upload
curl -T <file> -u <user:pass> http://site.com/upload
curl http://site.com/upload -X POST -F 'file1=@file1.txt' -F 'file2=@file2.txt'
curl -s -X PUT -H "Content-Type: text" -d '<Conteúdo do arquivo>' http://site/uploads/<file_name>

# Baixando um arquivo
curl <url> --output <output_file>

# Deletando um arquivo
curl http://site.com/<file> -X DELETE

# Salva somente a resposta do Header em um arquivo
curl <url> --dump-header <output_file>

# Utilizando Proxy (útil para usar com o Burp Suite)
curl <url> -x http://<ip>:<port>

# Salva o Cookie
curl <url> -c <cookiefile> -d "user=admin&pass=admin"
# Envia o Cookie, que pode ser uma string ou um arquivo
curl <url> -b <cookiefile>

# Acessando várias portas
curl <url>:[80-8000]
curl <url>:{80..8000}
```

#### Netcat

Ao digitar os comandos no Netcat, atente-se que o backspace e setas não funcionam. Outro ponto importante é, sempre que for utilizar a versão 1.1 do HTTP, passe a flag `host` no cabeçalho, caso contrário, provavelmente sua requisição será negada. Como um bom pentester, é sempre bom também utilizar a versão 1.0 (este não precisa informar o `host`) para verificar se é possível encontrar informações sensíveis no cabeçalho de retorno.

```bash
nc <site.com.br> 80
# Digite abaixo e dê ENTER.
GET / HTTP/1.1
Host: <site.com.br>
```

#### openssl

Acessa de forma semelhante ao Netcat, sendo preciso digitar os detalhes da requisição manualmente, porém com a diferença que este tem suporte a criptografia.

```bash
openssl s_client -connect <site.com.br>:443
```

### Wget

```bash
# Clonando site
wget -m -p -E -k -K -np -v <site>

# Destina onde irá ser baixado
wget <url> -P /<destino>

# Baixa arquivo e renomea
wget <url> -O <novo_nome>

# Caso esteja utilizando um site com HTTPS 
wget <url> --no-check-certificate
```

Explicação

| PARÂMETRO                   | DESCRIÇÃO                                                                            |
| --------------------------- | ------------------------------------------------------------------------------------ |
| `m (Mirror)`                | Habilita os opções adequadas ao espelhamento do site                                 |
| `p (Page)`                  | Garante que os arquivos necessários sejam baixados, incluindo imagens e arquivos CSS |
| `E (Ajust Extension)`       | Todas as páginas são salvas como HTML                                                |
| `k (Convert Links)`         | Fará todas as páginas serem convertidas para visualização local                      |
| `K (Keep Backup Converted)` | Faz backup do arquivo original, com o sufixo, com o sufixo .orig                     |

{% hint style="success" %}
**DICA:** As vezes é preciso ignorar o robots.txt para que o wget consiga trabalhar normalmente, então nesse caso é preciso adicionar um **`-e robots=off`** no comando.
{% endhint %}

###

### Chaves SSH

Existem algumas formas de trabalhar com chaves SSH e veremos aqui alguns desses métodos.\
Para todos os métodos, vamos utilizar o seguinte cenário:

`Host 1` = Host que irá acessar via SSH\
`Host 2` = Host SSH que será acessado

#### Método 1

O intuito deste cenário, serve para acessar determinado alvo via SSH sem precisar de senha.&#x20;

```bash
# Host 1
ssh-keygen
chmod 600 ~/.ssh/id_rsa
```

Irá ser criado dois arquivos: `~/.ssh/id_rsa` e `~/.ssh/id_rsa.pub` . Utilize o parâmetro `-f name` caso queira definir um nome manualmente.

Agora acesse o `Host 2` (da forma que preferir) e adicione o conteúdo de `id_rsa.pub` (`Host 1`) em `~/.ssh/authorized_keys`. Feito isso, o `Host 1` já consegue acessar o `Host 2` sem precisar de senha através do comando.

```bash
ssh -i ~/.ssh/id_rsa <ip_host_2>
```

Caso tenha utilizado alguma senha ao usar o comando `ssh-keygen`, utilize o comando `ssh-add id_rsa` para validar o acesso pela primeira vez.

#### Método 2

No `Host 2` digite o comando `ssh-keygen -t rsa` e escolha o lugar onde irá guardar as chaves (por padrão será `~/.ssh/id_rsa`), altere-o caso seja de sua preferência. Supondo que tenha deixado os valores padrões, serão criados dois arquivos, sendo eles `~/.ssh/id_rsa` e `~/.ssh/id_rsa.pub`. Agora transfira o arquivo `~/.ssh/id_rsa.pub` do `Host 2` para o `Host 1` (no mesmo diretório).

Agora acesse o `Host 1` e digite o comando `ssh-copy-id <user-host2>@<ip-host2>` e digite a senha de acesso SSH. Feito isso basta acessar o `Host 2` via SSH com o comando `ssh <user-host2>@<ip-host2>`, que irá conectar sem pedir senha.

Para verificar se a chave gerada está correta, utilize o comando `ssh-keygen -y -e -f </home/user/.ssh/id_rsa>`, lembrando que a chave deve ter permissão `600` para funcionar corretamente.

As vezes é preciso indicar o caminho da chave privada ao acessar via SSH, exemplo `ssh -i </home/user/.ssh/id_rsa> <user>@<ip>`.

Em alguns casos, podemos nos deparar com chaves que contém criptografia, que é indicada no início do arquivo, parecido como no exemplo abaixo:

```bash
-----BEGIN RSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: AES-128-CBC,AEB88C140F69BF2074788DE24AE48D46

DbPrO78k...
...
...
...
GHJE8MkhD3
-----END RSA PRIVATE KEY-----
```

{% hint style="info" %}
**DICA:** Caso não saiba a senha, utilize a seção de Brute Force Offline para verificar como quebrar senha de RSA.
{% endhint %}

Podemos reverter essa chave inserindo sua senha, utilizando o comando:

```bash
openssl rsa -in </home/user/.ssh/id_rsa>
```

Também podemos gerar chaves públicas a partir da chave primária

```bash
openssl rsa -in <private_key.pem> -pubout
```

#### Método 3

Gere as chaves no `host 2` e o arquivo `authorized_keys` com os seguintes comandos:

```bash
ssh-keygen -f rsa
cp id_rsa.pub authorized_keys
```

Agora envie o arquivo `id_rsa` (chave privada) para o `Host 1`, e então ainda no `Host 1`, execute o seguintes comandos para realizar o acesso.

```bash
chmod 600 id_rsa
ssh -i id_rsa <user>@<ip>
```

Em alguns  casos, temos acesso a um usuário mo qual já possui os arquivo `id_rsa` e `id_rsa.pub`. Nesse cenário basta apenas copiar o arquivo `id_rsa.pub` para `authorized_keys`.

#### Erro ao acessar via SSH

É comum as vezes recebermos o erro `Unable to negotiate with <ip> port 22: no matching key exchange method found. Their offer: diffie-hellman-group-exchange-sha1,diffie-hellman-group14-sha1,diffie-hellman-group1-sha1`, então precisamos modificar um pouco a nosso comando para realizar a conexão, ficando assim:

```bash
ssh <user>@<ip> -oKexAlgorithms=+diffie-hellman-group1-sha1
# ou
ssh -o KexAlgorithms=diffie-hellman-group14-sha1 -oHostKeyAlgorithms=+ssh-dss <user>@<ip>
```

####

### Tipo de Autenticação SSH

É sempre importanta validarmos o tipo de autenticação que pode ser realizado para conectarmos em um servidor SSH. Por exemplo, caso o server só aceite requisições utilizando chave pública, não adianta fazermos um brute force com usuário e senha procurando por credenciais válidas, porque isso não vai ser possível.

Para verificar as possibilidades de acesso, execute o comando abaixo, procure pela linha `Authentications that can continue` e verifique os seus valores.

```bash
ssh -v <ip>
```

| VALOR                  | **DESCRIÇÃO**                                                                                                |
| ---------------------- | ------------------------------------------------------------------------------------------------------------ |
| `publickey`            | Autenticação com arquivo de chave pública                                                                    |
| `password`             | Autenticação com usuário e senha. Caso não tenha essa opção disponível, ataques de Brute Force não funcionam |
| `keyboard-interactive` | Autenticação utilizando MFA                                                                                  |

### SSH Não-Interativo

Executando comando via SSH sem deixar o terminal no modo interativo

```bash
ssh <user>@<ip> "<command>"
```

### SSH Renderizando GUI na Máquina Client

#### SSH Server

Vá em `/etc/ssh/sshd_config` e descomente as seguintes linhas

```bash
X11Forwarding yes
X11DisplayOffset 10
X11UseLocalhost yes
```

Reinicie o serviço de SSH

```bash
sudo systemctl restart ssh
```

#### SSH Client

Habilite o Forward

```bash
echo 'ForwardX11 yes' >> ~/.ssh/config
```

Acesse via SSH. O encaminhamento de X11 com `-Y` (opção de confiança) pode resolver alguns problemas que `-X` (opção segura) não consegue, porém ambos podem ser eficaz:

```bash
ssh -Y <user>@<ip>
ssh -X <user>@<ip>
```

Agora abra serviço que tenha GUI, por exemplo:

```bash
firefox &
```

### Screen

A screen joga um processo para segundo plano e pode ser acessada futuramente. O ponto forte é que mesmo se a conexão cair (caso esteja conectado via SSH por exemplo), o processo continua rodando em background.\
Uma outra maneira de colocar o processo em segundo plano (para não deixar o terminal preso), coloque um `&` no final do comando.

```bash
# Lista todas as Screens
screen -ls

# Cria uma Screen
screen -S <nome_screen>

# Acessa uma Screen
screen -x <id_screen>

# Matar uma Screen
screen -X -S <id_screen> kill
```

**OBS.:** Para sair de uma screen sem perder a sessão, aperte `CTRL` + `A` + `D`

### tmux

Esse é um concorrente do `screen` mostrado acima, pois desempenha as mesmas funcionalidades básicas.

No TMUX, uma sessão pode possuir diversas janelas (canto inferior do terminal), e cada janela possuir diversos painéis (semelhante ao Terminator).

#### Arquivo de Configuração

Utilize (crie caso não tenha) o arquivo `~/.tmux.conf` para configurar o tmux do usuário atual. O exemplo de configuração abaixo, habilita o scroll do mouse, pesquisas por palavras semelhante ao VI e copiar palavras/texto utilizando o teclado.

```bash
set -g mouse on
set -g mode-keys vi
bind-key -T copy-mode-vi y send -X copy-pipe-and-cancel "pbcopy"
```

Para recarregar o arquivo, execute

```bash
tmux source-file ~/.tmux.conf
```

Caso queira configurar para todo o sistema, utilize o arquivo `/etc/tmux.conf`.

#### Comandos Básicos

{% hint style="info" %}
**IMPORTANTE:** Antes de executar os comandos, certifique-se de pressionar `CTRL` + `B` e depois de soltar as duas teclas, pressionar próxima tecla ou digitar algum comando seguido de `:` (dois pontos).
{% endhint %}

Habilitando o scroll do mouse

```bash
CTRL B, :set mouse on
```

Verificando sessões ativas

```bash
tmux ls
tmux lsw
```

Acessando uma sessão já ativa

```bash
tmux a -t <number_or_name>
```

Iniciando uma sessão com nome personalizado

```bash
tmux new -s <name>
```

Detached na sessão

```bash
CTRL + B, D
```

Criando nova janela

```bash
CTRL + B, C
```

Renomeando uma janela

```bash
CTRL + B, ,nn
```

Alterando para a próxima sessão

```bash
CTRL + B, N
```

Alterando para a sessão anterior

```bash
CTRL + B, P
```

Alterando para uma sessão através do seu número

```bash
CTRL + B, <numero>
```

Dividindo a painel horizontalmente

```bash
CTRL + B, "
```

Dividindo a painel verticalmente

```bash
CTRL + B, %
```

Invertendo posições dos painéis

```bash
CTRL + B, <espaço>
```

Alterando de painel

```bash
CTRL + B, <seta>
```

Exibindo o número dos painéis

```bash
CTRL + B, Q
```

Deixa o painel atual em tela cheia. Execute o comando novamente para voltar ao normal

```bash
CTRL + B, Z
```

Finalizando um painel

```bash
CTRL + X
```

Finalizando uma sessão

```bash
CTRL + W
```

Scroll no navegador como se fosse um editor de texto (caractere por caractere). Pressione `q` para sair

```bash
CTRL + B, [
```

Ainda nesse modo, é possível realizar buscas em strings no buffer do terminal, pressionando `CTRL` + `S`. Após fazer isso, pressione `N` para avançar ou `Shift` + `N` para voltar, semelhante ao `VI`.

Além disso, podemos aproveitar esse modo para copiar textos, bastando ir até o texto que deseja copiar, pressione `ESPAÇO`, use as setas para selection e agora pressione `y` para copiar. Lembre-se de ativar o modo de cópia no arquivo `~/.tmux.conf` conforme mostrado acima.

### Telnet

Geralmente acessamos o telnet através do comando `telnet <ip>`, porém nem sempre o telnet está disponível. Nesse caso, podemos utilizar o `netcat` para realizar o acesso.

```bash
nc -t <ip> <port>
```

### Acessando Windows via Remote Desktop

É possível acessar um Windows pelo RDP na porta 3389, a partir de um Linux

```bash
apt install rdesktop
rdesktop <ip>
```

###

### Criando Functions

Criar funcition pode ser útil para startar sistemas em background, conexões SSH, criar alias, etc. No exemplo abaixo, vamos inicializar uma tool e deixar o terminal livre para a utilização.\
Abra o arquivo com o comando `nano ~/.bashrc` e depois insira as seguintes linhas no final

```bash
function <name_metodo>() {
    </dir/tool> > /dev/null 2>&1 &
}
```

Para não precisar reiniciar o SO, utilize o comando `source ~/.bashrc` (disponível somente nesse mesmo terminal).\
Agora só digitar no terminal: `<name_metodo>` (sem os parênteses)

###

### Configurando Teclado

```bash
dpkg-reconfigure keyboard-configuration
sudo service keyboard-setup restart
```

Ou se preferir, pode editar manualmente o arquivo `/etc/default/keyboard`\
**OBS.:** Utilize o arquivo `/usr/share/doc/keyboard-configuration/xorg.lst` para mais detalhes

###

### Criando Diretórios com Vários Subdiretórios

Útil quando iremos criar um diretório e vários subdiretórios dentro desse diretório. Podemos fazer isso com um só comando ao invés de utilizar vários comandos.

```bash
mkdir -p <dir>/{<subdir1>,<subdir2>,<subdir2>}
```

###

### Diretórios com Nomes Camuflados

No Linux é possível criar pastas chamadas `..` ou `.` (atenção ao espaço no final). Isso é muito utilizado por hackers pra enganar os administradores de rede

###

### Executando Comando por Arquivo

```bash
# Executa todos os comandos que estão no arquivo informado
source <arquivo>
```

###

### Verificando Tempo de Execução

Útil para saber quanto tempo determinado comando gasta para executar

```bash
time <command>
```

### Timestamp / Data

Configurando Data/Hora manualmente

```bash
sudo timedatectl set-timezone America/Sao_Paulo
sudo apt install ntp
sudo timedatectl set-ntp off


sudo date -s "21 OCT 2022 23:09:40"
# Ou
sudo timedatectl set-time 19:56:06
sudo timedatectl set-local-rtc false
```

Para voltar com o horário normal  de forma automática (através do NTP), execute:

```bash
sudo timedatectl set-ntp on
```

Sincronizando com um server NTP

```bash
sudo ntpdate <ip_dc>
```

Convertendo valores

```bash
# Timestamp para data
date -d @<timestamp>

# Data para timestamp
date "+%s" -d "DD/MM/YYYY hh:mm:ss"
```

### Instalando Flash Player

Execute o comando abaixo e depois reinicie o nvegador

```bash
apt-get install flashplugin-nonfree
update-flashplugin-nonfree --install
```

###

### Xterm

Quando receber erro no terminal `Error opening terminal: xterm-256color`, execute o comando abaixo:

```bash
export TERM=xterm
```

Esse erro ocorre porque o terminal precisa trabalhar com mais cores, por exemplo o `ht editor`, onde o terminal fica azul. Fora isso, você poderá ter recursos como o comando `clear`, caso esteja em uma shell reversa.

###

### Montando Unidade de Disco com VMDK

Montando arquivos VMDK (HD de VM) como Unidade de Disco:

```bash
sudo apt install libguestfs-tools
guestmount -a <arquivo.vmdk> -i --ro /mnt/vmdk
```

### Navegando em Páginas Web via Terminal

#### lynx

```bash
lynx <site.com.br>
lynx --dump <site.com.br>
lynx --dump "https://google.com/search?&q=site:<site.com>+ext:pdf" | grep 'google.com/url' | cut -d "=" -f2
```

#### browsh

```bash
browsh --startup-url <http://domain.com>
```

#### netcat

```bash
nc <i> <port>
# Digite abaixo e pressione ENTER duas vezes
GET / HTTP/1.0


```

```bash
nc <ip> <port>
# Digite abaixo e pressione ENTER duas vezes
GET / HTTP/1.1
host: <ip>


```

```bash
echo -e "GET http://<ip>/ HTTP/1.0 \n\n " | nc -w 5 <ip> <port>
```

### Weechat

Este é um bate papo via terminal

```bash
# Instalação
sudo apt install weechat

# Conectando ao Freenode
/server add freenode chat.freenode.net
/set irc.server.freenode.autoconnect on

# Inserindo credenciais
/set irc.server.freenode.nicks "my-nickname"
/set irc.server.freenode.command "/msg nickserv identify ******"
```

###

### Lendo LOG's

Quando for abrir um arquivo de log como `/var/log/wtmp`, utilize o comando `who` ao invés de `cat`, pois esse arquivo está em binário.

###

### Transformando a VPS em Proxy

Antes de realizar esse procedimento, tome cuidado, pois não está configurado para pedir senha na utilização do proxy

```bash
apt update
apt upgrade
apt install squid
apt install wget
apt install screen
apt install dos2unix
cd /etc/squid3/  
echo 'http_port 3128' >> squid.conf
echo 'http_access allow all' >> squid.conf
service squid restart
```

### Placa de Vídeo NVidia (Ubuntu)

Exibindo as placas de vídeos no host

```bash
prime-select
```

Instalando drivers

```bash
sudo ubuntu-drivers autoinstall
```

Visualizando informações da placa de vídeo (versão da placa, cuda, etc) e processos que estão utilizando

```bash
nvidia-smi
```

Vendo tudo o que está executando na placa de vídeo onboarding

```bash
sudo apt install intel-gpu-tools
sudo intel_gpu_top 
```

### Vendo a Previsão do Tempo

No final da url, coloque a sua cidade, por exemplo: Sao\_Paulo

```bash
curl wttr.in/<cidade>
```

####

#### Sites

```bash
# Detalha o que cada parte de determinado comando do Linux faz
http://explainshell.com

# Chaves SSH
https://www.digitalocean.com/community/tutorials/como-configurar-chaves-ssh-no-ubuntu-18-04-pt

# Como criar serviços
https://linuxconfig.org/how-to-create-systemd-service-unit-in-linux

# Verifica a velocidade da internet
curl -s https://raw.githubusercontent.com/sivel/speedtest-cli/master/speedtest.py | python -
```