# 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 -
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://mysther.gitbook.io/knowledge-base/sistemas-operacionais/linux/utilizacao.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.