Linux, from user to firewall.

O que é o LinuxWhat Linux is

Linux é, em sentido estrito, só o kernel (o núcleo): o programa que fala com o hardware e reparte CPU, memória, disco e rede entre os outros programas. Tudo o que você usa no terminal (shell, ls, grep, ssh) são programas comuns que pedem coisas ao kernel. A combinação kernel + ferramentas + gerenciador de pacotes é uma distribuição (Ubuntu, Debian, Fedora, Arch).Strictly speaking, Linux is just the kernel: the program that talks to the hardware and shares CPU, memory, disk and network among the other programs. Everything you use in the terminal (shell, ls, grep, ssh) is an ordinary program that asks the kernel for things. Kernel + tools + package manager is a distribution (Ubuntu, Debian, Fedora, Arch).

Dois princípios explicam quase tudo nesta nota: “tudo é arquivo” (discos, terminais, processos e até a rede aparecem como arquivos ou descritores de arquivo) e “todo programa roda como algum usuário” (as permissões decidem o que ele pode tocar). Aprenda esses dois e o resto vira consequência.Two principles explain almost everything in this note: “everything is a file” (disks, terminals, processes and even the network show up as files or file descriptors) and “every program runs as some user” (permissions decide what it may touch). Learn these two and the rest follows.

Livros e fontes recomendadosRecommended books and sources

Usuários, grupos e superusuárioUsers, groups and the superuser

Para o kernel, um usuário é só um número: o UID. Nomes como “ana” existem para humanos; o kernel compara números. Cada usuário tem também um GID principal e pode pertencer a outros grupos. Os dados ficam em arquivos de texto em /etc.To the kernel a user is just a number: the UID. Names like “ana” exist for humans; the kernel compares numbers. Each user also has a primary GID and may belong to other groups. The data lives in plain text files in /etc.

O superusuário (root)The superuser (root)

O superusuário é quem tem UID 0, não quem se chama “root”. Para o kernel, UID 0 ignora as checagens de permissão de arquivos e pode, por exemplo, ler qualquer arquivo, matar qualquer processo e abrir portas abaixo de 1024. No Linux moderno esse poder é dividido em capabilities (ex.: CAP_NET_BIND_SERVICE só para abrir portas baixas), mas o root tradicional tem todas. Por isso a regra de ouro é: use root só no instante em que precisar.The superuser is whoever has UID 0, not whoever is named “root”. To the kernel, UID 0 skips file permission checks and can, for example, read any file, kill any process and bind ports below 1024. Modern Linux splits that power into capabilities (e.g. CAP_NET_BIND_SERVICE just for low ports), but the traditional root has them all. Hence the golden rule: use root only at the moment you need it.

id                         # uid=1000(ana) gid=1000(ana) groups=1000(ana),27(sudo),1001(dev)
whoami                     # ana
groups ana                 # grupos de ana
getent passwd ana          # a linha de ana (funciona com LDAP também)

sudo useradd -m -s /bin/bash -G sudo ana   # cria usuário + home + shell + grupo extra
sudo passwd ana                            # define a senha
sudo usermod -aG dev ana                   # ADICIONA ao grupo dev (sem -a, apaga os outros!)
sudo groupadd dev                          # cria grupo
sudo gpasswd -d ana dev                    # tira ana do grupo dev
sudo passwd -l ana                         # bloqueia a conta (-u desbloqueia)
sudo userdel -r ana                        # remove usuário e o home

su - ana                   # vira ana (pede a senha DE ANA); o "-" carrega o ambiente dela
sudo -i                    # shell de root, autenticando com a SUA senha
sudo -l                    # lista o que você pode rodar com sudo
sudo visudo                # edita o sudoers com validação de sintaxe

Arquivos e permissõesFiles and permissions

Todo arquivo tem um dono (usuário), um grupo e nove bits de permissão: leitura (r), escrita (w) e execução (x) para três públicos: o dono (u), o grupo (g) e todo o resto (o). O kernel escolhe um público, nesta ordem: se você é o dono, vale só a regra do dono; senão, se está no grupo, vale a do grupo; senão, a de outros.Every file has an owner (user), a group and nine permission bits: read (r), write (w) and execute (x) for three audiences: the owner (u), the group (g) and everybody else (o). The kernel picks one audience, in this order: if you are the owner, only the owner rule applies; otherwise, if you are in the group, the group rule; otherwise, the others rule.

O que r, w e x significam em cada tipoWhat r, w and x mean for each type

ls -l arquivo               # permissões, dono, grupo, tamanho, data
ls -ld /etc /tmp            # -d: o próprio diretório, não o conteúdo
stat arquivo                # tudo, inclusive inode e octal
namei -l /var/www/index.html   # mostra a permissão de CADA pedaço do caminho

chmod u+x script.sh         # simbólico: dono ganha x
chmod g-w,o-rwx arquivo     # grupo perde w; outros perdem tudo
chmod 640 arquivo           # octal: rw- r-- ---
chmod -R 755 pasta/         # recursivo (cuidado: põe x em arquivos também)
chmod a+r arquivo           # a = all (u+g+o)

sudo chown ana arquivo      # muda dono
sudo chown ana:dev arquivo  # dono e grupo de uma vez
sudo chown -R ana: pasta/   # "ana:" = grupo principal de ana
chgrp dev arquivo           # muda só o grupo (se você pertence a ele)

umask                       # máscara atual (típico 0022)
umask 027                   # novos arquivos: 640, novos diretórios: 750

A umask é subtraída das permissões-padrão (666 para arquivos, 777 para diretórios). Com umask 022: arquivos viram 644 e diretórios 755. Com 027: 640 e 750, ou seja, “outros” não veem nada.The umask is subtracted from the default permissions (666 for files, 777 for directories). With umask 022: files become 644 and directories 755. With 027: 640 and 750, meaning “others” see nothing.

Bits especiais: setuid, setgid e stickySpecial bits: setuid, setgid and sticky

chmod 4755 programa         # setuid + rwxr-xr-x
chmod g+s /srv/projeto      # setgid no diretório
chmod +t /srv/publico       # sticky
find / -perm -4000 -type f 2>/dev/null   # AUDITORIA: lista todos os programas setuid

ACLs: quando três públicos não bastamACLs: when three audiences are not enough

Se você precisa dar acesso a uma pessoa específica sem mexer no dono nem no grupo, use ACL (Access Control List; Kerrisk, cap. 17). O ls -l mostra um + no fim das permissões quando existe ACL.If you need to give access to one specific person without touching owner or group, use an ACL (Access Control List; Kerrisk, ch. 17). ls -l shows a + after the permissions when an ACL exists.

setfacl -m u:bia:rw relatorio.txt     # dá rw à usuária bia
setfacl -x u:bia relatorio.txt        # remove a regra
getfacl relatorio.txt                 # mostra todas

Estrutura de arquivosFile structure

O Linux tem uma única árvore de diretórios que começa em / (a raiz). Não existe “C:” ou “D:”: um pendrive ou outro disco é montado em algum diretório (por exemplo /mnt/usb) e seu conteúdo aparece ali. O Filesystem Hierarchy Standard (FHS) define o papel de cada diretório, e man 7 hier resume.Linux has one single tree of directories that starts at / (the root). There is no “C:” or “D:”: a USB stick or another disk is mounted on some directory (for example /mnt/usb) and its content appears there. The Filesystem Hierarchy Standard (FHS) defines each directory’s role, and man 7 hier summarises it.

Montagem, discos e inodesMounting, disks and inodes

Cada arquivo é, por baixo, um inode: um registro com dono, permissões, tamanhos e ponteiros para os blocos de dados. O nome do arquivo vive no diretório, que é só uma tabela “nome → número do inode”. Por isso um arquivo pode ter vários nomes (hard links) e por isso renomear é instantâneo (Kerrisk, cap. 14 e 18).Underneath, each file is an inode: a record with owner, permissions, sizes and pointers to the data blocks. The file’s name lives in the directory, which is just a “name → inode number” table. That is why a file can have several names (hard links) and why renaming is instant (Kerrisk, ch. 14 and 18).

lsblk                       # discos e partições em árvore
df -h                       # espaço livre por sistema de arquivos
du -sh * | sort -h          # quem está ocupando espaço aqui
findmnt                     # o que está montado onde
sudo mount /dev/sdb1 /mnt/usb
sudo umount /mnt/usb        # (é umount, sem "n")
cat /etc/fstab              # o que monta automaticamente no boot
ls -i arquivo               # número do inode

Comandos do dia a diaEveryday commands

Todo comando segue o mesmo molde: comando [opções] [argumentos]. As opções curtas (-l) podem ser juntadas (-la); as longas usam dois traços (--all). Quando em dúvida, man comando, comando --help ou tldr comando (exemplos curtos).Every command follows the same mould: command [options] [arguments]. Short options (-l) can be combined (-la); long ones use two dashes (--all). When in doubt, man command, command --help or tldr command (short examples).

Navegar e olharMove around and look

Criar, copiar, mover e removerCreate, copy, move and remove

mkdir projeto                  # cria pasta
mkdir -p a/b/c                 # cria o caminho inteiro (-p = parents)
touch notas.txt                # cria arquivo vazio (ou atualiza a data)
echo "oi" > notas.txt          # cria/sobrescreve com conteúdo
echo "mais" >> notas.txt       # acrescenta ao fim

cp origem destino              # copia arquivo
cp -r pasta/ copia/            # copia pasta (-r = recursivo)
mv antigo novo                 # renomeia OU move (mesmo comando)
mv *.log /tmp/                 # move vários

rm arquivo                     # remove (NÃO vai para a lixeira!)
rm -r pasta/                   # remove pasta e conteúdo
rm -i arquivo                  # pergunta antes
rmdir pasta_vazia              # só remove se estiver vazia

Buscar e processar textoSearch and process text

find /var/log -name "*.log" -mtime -1     # logs alterados nas últimas 24 h
find . -type f -size +100M                # arquivos grandes
find . -user ana -perm -o+w               # de ana e graváveis por todos
grep -rn "erro" /var/log/ 2>/dev/null     # procura texto (-r recursivo, -n linha)
grep -i -E "fail|denied" auth.log         # sem diferenciar maiúsculas, regex
locate nome                               # busca rápida num índice (updatedb)
which python3 ; type cd                   # onde está / o que é um comando

sort | uniq -c | sort -rn | head          # o trio clássico: contar e ranquear
wc -l arquivo                             # conta linhas
cut -d: -f1 /etc/passwd                   # só o 1º campo (nomes de usuário)
awk '{print $1}' access.log               # 1ª coluna
sed -i 's/foo/bar/g' arquivo              # troca texto no arquivo

Pipes e redirecionamentoPipes and redirection

O poder do shell está em ligar programas pequenos. O | (pipe) liga a saída de um à entrada do outro. Cada processo nasce com três canais: 0 = entrada padrão (stdin), 1 = saída padrão (stdout), 2 = erros (stderr).The shell’s power lies in connecting small programs. The | (pipe) connects one’s output to another’s input. Each process is born with three channels: 0 = standard input (stdin), 1 = standard output (stdout), 2 = errors (stderr).

Instalar, atualizar e gerenciar serviçosInstall, update and manage services

systemctl status ssh           # estado de um serviço (o nome pode ser sshd no Fedora)
sudo systemctl start|stop|restart ssh
sudo systemctl enable --now ssh    # liga no boot E agora
systemctl --failed             # o que falhou
journalctl -u ssh -f           # log do serviço ao vivo
journalctl -p err -b           # só erros desde o último boot

Processos, pais e filhosProcesses, parents and children

Um programa é um arquivo no disco; um processo é esse programa em execução, com seu PID (identificador), seu PPID (PID do pai), um dono (UID), memória própria, diretório atual e descritores de arquivos abertos. Em Linux todo processo tem um pai. A árvore começa no PID 1 (hoje, quase sempre o systemd), que o kernel inicia no boot.A program is a file on disk; a process is that program running, with its PID (identifier), its PPID (parent’s PID), an owner (UID), its own memory, a current directory and open file descriptors. In Linux every process has a parent. The tree starts at PID 1 (today almost always systemd), which the kernel launches at boot.

Como um processo nasce: fork, exec e waitHow a process is born: fork, exec and wait

Linux cria processos em duas etapas (Kerrisk, cap. 24–27). fork() clona o processo atual: nasce um filho idêntico, com PID novo. Em seguida o filho chama exec(), que troca o programa dentro dele (o PID continua). O pai chama wait() para esperar o filho terminar e ler o código de saída. É exatamente isso que o bash faz quando você digita ls.Linux creates processes in two steps (Kerrisk, ch. 24–27). fork() clones the current process: an identical child is born with a new PID. Then the child calls exec(), which swaps the program inside it (the PID stays). The parent calls wait() to wait for the child to finish and read its exit code. This is exactly what bash does when you type ls.

// fork_exec.c — gcc fork_exec.c -o fork_exec
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>

int main(void) {
    pid_t pid = fork();                       // clona o processo
    if (pid == -1) { perror("fork"); exit(1); }

    if (pid == 0) {                           // aqui roda o FILHO
        execlp("ls", "ls", "-l", (char *)NULL);
        perror("execlp");                     // só chega aqui se o exec falhar
        _exit(127);
    }

    int status;                               // aqui roda o PAI
    waitpid(pid, &status, 0);                 // espera e "colhe" o filho
    printf("pai %d: filho %d saiu com %d\n", getpid(), pid, WEXITSTATUS(status));
    return 0;
}

Estados de um processoProcess states

Sinais: como falar com um processoSignals: how to talk to a process

ps aux                          # todos os processos (user, PID, %CPU, %MEM, comando)
ps -eo pid,ppid,stat,user,cmd   # escolha as colunas: veja o PPID e o STAT
ps -ef --forest                 # a árvore em texto
pstree -p                       # a árvore, com PIDs
pgrep -a ssh                    # PIDs pelo nome
top        # ou htop / btop: ao vivo (q sai; k mata; M ordena por memória)

echo $$ ; echo $PPID            # PID do seu shell e do pai dele
bash -c 'echo eu=$$ pai=$PPID'  # um filho: o pai dele é o seu shell
cat /proc/$$/status | head      # o kernel descreve o processo como arquivo

kill 2301                       # SIGTERM (educado)
kill -9 2301                    # SIGKILL (último recurso)
kill -STOP 2301 ; kill -CONT 2301
pkill -f "python app.py"        # por padrão no comando
killall firefox                 # por nome

sleep 300 &                     # & = em segundo plano
jobs ; fg %1 ; bg %1            # lista; traz à frente; manda ao fundo
nohup ./job.sh &                # sobrevive ao fechar o terminal
nice -n 10 ./pesado.sh          # prioridade menor (-20 a 19; menor número = mais prioridade)
renice 5 -p 2301

Load average (uptime, top) mostra a média de processos prontos para rodar ou esperando disco em 1, 5 e 15 minutos. Compare com o número de CPUs (nproc): em 4 CPUs, load 4 é “cheio” e 12 é sobrecarga.Load average (uptime, top) shows the average number of processes ready to run or waiting for disk over 1, 5 and 15 minutes. Compare it with the number of CPUs (nproc): on 4 CPUs, load 4 is “full” and 12 is overload.

Redes: ver, entender e interagirNetworking: see, understand and interact

Para a rede, o Linux usa a pilha TCP/IP no kernel. Quem fala com ela são os sockets (Kerrisk, cap. 56–61): um programa pede ao kernel um socket, liga-o a um IP e uma porta e passa a enviar e receber bytes. Uma conexão é identificada por quatro valores: IP e porta de origem, IP e porta de destino.For networking, Linux uses the TCP/IP stack inside the kernel. Programs talk to it through sockets (Kerrisk, ch. 56–61): a program asks the kernel for a socket, binds it to an IP and a port, and sends and receives bytes. A connection is identified by four values: source IP and port, destination IP and port.

Ver o que existe: interfaces, rotas e DNSSee what exists: interfaces, routes and DNS

ip -br addr                     # interfaces e IPs, uma linha cada (-br = brief)
ip route                        # tabela de rotas; "default via X" é o seu gateway
ip neigh                        # vizinhos na LAN (tabela ARP): quem está na minha rede
ip -s link                      # contadores de pacotes e erros por interface
nmcli device status             # estado (NetworkManager); nmtui = menu em texto
resolvectl status               # servidores DNS em uso (systemd-resolved)
cat /etc/hosts                  # nomes locais fixos

Ver o que está acontecendo: conexões e portasSee what is happening: connections and ports

ss -tulpn                       # QUEM ESTÁ ESCUTANDO: t=TCP u=UDP l=listen p=processo n=numérico
ss -tn state established        # conexões ativas agora
ss -tnp dst :443                # conexões saindo para a porta 443, com o processo
sudo lsof -i :8080              # que processo usa a porta 8080
sudo tcpdump -i any -n port 53  # pacotes DNS ao vivo (Ctrl+C para parar)
sudo tcpdump -i eth0 -w captura.pcap   # salva para abrir no Wireshark
sudo nethogs                    # banda por PROCESSO (apt install nethogs)
sudo iftop                      # banda por conexão

Como ler ss -tulpn: a coluna Local Address é a chave. 0.0.0.0:22 ou *:22 = aceita de qualquer lugar; 127.0.0.1:5432 = só deste computador (seguro); [::]:80 = o mesmo, mas em IPv6. Cada linha com endereço público é uma porta que um atacante pode tentar.How to read ss -tulpn: the Local Address column is the key. 0.0.0.0:22 or *:22 = accepts from anywhere; 127.0.0.1:5432 = this computer only (safe); [::]:80 = the same, but over IPv6. Every line with a public address is a port an attacker may try.

Interagir: testar, resolver nomes e falar HTTPInteract: test, resolve names and speak HTTP

ping -c 4 1.1.1.1               # chega? (testa IP, sem DNS)
ping -c 4 example.com           # se o IP funciona e este não, o problema é DNS
mtr example.com                 # traceroute + ping contínuo (apt install mtr-tiny)
traceroute example.com          # por quais roteadores o pacote passa

dig example.com +short          # resolve nome → IP
dig MX example.com              # registros de e-mail
curl -I https://example.com     # só os cabeçalhos HTTP
curl -v https://example.com     # tudo, inclusive o handshake TLS
curl -s https://api.exemplo.dev/health | jq .

nc -zv servidor 22              # a porta 22 está aberta? (z = só testa)
nc -l 9000                      # abre um "servidor" simples na porta 9000

Um roteiro de diagnósticoA troubleshooting script

1. ip -br addr: a interface está UP e tem IP? Se não, o problema é cabo, Wi-Fi ou DHCP.ip -br addr: is the interface UP and does it have an IP? If not, it is the cable, Wi-Fi or DHCP.
2. ip route e ping <gateway>: você alcança o roteador?ip route and ping <gateway>: can you reach the router?
3. ping 1.1.1.1: sai para a internet?ping 1.1.1.1: does it reach the internet?
4. dig example.com: o nome resolve? Se o passo 3 funciona e este não, é DNS.dig example.com: does the name resolve? If step 3 works and this does not, it is DNS.
5. nc -zv host porta: a porta responde? Se não, firewall ou serviço parado.nc -zv host port: does the port answer? If not, firewall or stopped service.
6. curl -v e os logs do serviço (journalctl -u): a aplicação responde direito?curl -v and the service logs (journalctl -u): does the application answer properly?

SSH: entrar, acompanhar e protegerSSH: log in, watch and protect

O SSH abre um terminal remoto cifrado (porta 22). É a porta de entrada de quase todo servidor Linux, então vale entender como funciona e como acompanhá-lo. O servidor prova quem é com uma chave de host; você prova quem é com senha ou, melhor, com um par de chaves: a privada nunca sai da sua máquina, a pública vai para o servidor.SSH opens an encrypted remote terminal (port 22). It is the front door of almost every Linux server, so it is worth understanding how it works and how to watch it. The server proves who it is with a host key; you prove who you are with a password or, better, a key pair: the private key never leaves your machine, the public one goes to the server.

ssh-keygen -t ed25519 -C "ana@notebook"   # cria o par de chaves (defina uma passphrase)
ssh-copy-id ana@servidor                  # instala a pública no servidor
ssh ana@servidor                          # entra
ssh -v ana@servidor                       # diagnóstico: mostra cada etapa
ssh ana@servidor 'df -h'                  # roda um comando e sai
scp arquivo ana@servidor:/tmp/            # copia por SSH
rsync -avz --progress pasta/ ana@servidor:/backup/   # sincroniza (só o que mudou)
ssh -L 5432:localhost:5432 ana@servidor   # túnel: seu :5432 vira o banco do servidor
ssh -J bastion ana@interno                # salta por um bastion host

# ~/.ssh/config  ->  depois basta: ssh meuserver
Host meuserver
    HostName 203.0.113.10
    User ana
    IdentityFile ~/.ssh/id_ed25519

Quem está conectado e o que aconteceuWho is connected and what happened

who ; w                          # quem está logado agora e o que está executando
last -n 20                       # últimos logins
sudo lastb -n 20                 # tentativas de login que FALHARAM
ss -tnp state established '( sport = :22 )'   # sessões SSH abertas
sudo journalctl -u ssh --since "1 hour ago"   # log do sshd (Fedora: -u sshd)
sudo grep "Failed password" /var/log/auth.log | awk '{print $(NF-3)}' | sort | uniq -c | sort -rn | head

Endurecer o servidor SSHHardening the SSH server

Crie um arquivo em /etc/ssh/sshd_config.d/ (ou edite o sshd_config). Comentários ficam em linhas próprias.Create a file in /etc/ssh/sshd_config.d/ (or edit sshd_config). Comments go on their own lines.

# /etc/ssh/sshd_config.d/10-hardening.conf
# ninguém entra direto como root
PermitRootLogin no
# só chaves (copie a sua ANTES de ligar isto!)
PasswordAuthentication no
PubkeyAuthentication yes
# lista branca de usuários
AllowUsers ana bia
MaxAuthTries 3

sudo sshd -t                     # valida a sintaxe ANTES de aplicar
sudo systemctl reload ssh        # aplica sem derrubar as sessões atuais (Fedora: sshd)

Firewall: filtrar o que entraFirewall: filtering what comes in

Um firewall é um porteiro: olha cada pacote e decide deixar passar, descartar ou recusar. No Linux quem filtra é o netfilter, dentro do kernel. O que você usa são “controles” para ele: nftables (o moderno), iptables (o antigo, hoje muitas vezes um tradutor para nftables), e frentes simples como ufw (Ubuntu/Debian) e firewalld (Fedora/RHEL).A firewall is a doorman: it looks at each packet and decides to let it through, drop it or reject it. In Linux the filtering is done by netfilter, inside the kernel. What you use are “controls” for it: nftables (the modern one), iptables (the old one, today often a translator to nftables), and simple front ends such as ufw (Ubuntu/Debian) and firewalld (Fedora/RHEL).

A política certa: negar por padrãoThe right policy: deny by default

A ideia de ouro: bloqueie tudo que entra, libere só o necessário. O que sai continua livre, e as respostas a conexões que você iniciou entram sozinhas (o firewall é stateful: lembra das conexões).The golden idea: block everything coming in, allow only what is needed. Outgoing traffic stays free, and replies to connections you started come in on their own (the firewall is stateful: it remembers connections).

# ufw (Ubuntu/Debian): o caminho mais simples
sudo ufw status verbose                  # está ativo? quais regras?
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp                    # LIBERE O SSH ANTES de ativar, se for remoto!
sudo ufw allow from 192.168.1.0/24 to any port 9090 proto tcp   # só a sua LAN
sudo ufw limit ssh                       # permite, mas freia força bruta
sudo ufw enable
sudo ufw status numbered ; sudo ufw delete 3   # listar e apagar uma regra

# firewalld (Fedora/RHEL)
sudo firewall-cmd --list-all
sudo firewall-cmd --permanent --add-service=ssh
sudo firewall-cmd --reload

# /etc/nftables.conf
table inet filter {
  chain input {
    type filter hook input priority 0; policy drop;
    ct state established,related accept   # respostas ao que EU pedi
    ct state invalid drop
    iif "lo" accept                       # tráfego interno da máquina
    ip protocol icmp accept               # ping
    ip6 nexthdr icmpv6 accept
    tcp dport 22 accept                   # SSH
  }
  chain forward { type filter hook forward priority 0; policy drop; }
  chain output  { type filter hook output  priority 0; policy accept; }
}

sudo nft -f /etc/nftables.conf            # aplica o arquivo
sudo nft list ruleset                     # ver tudo o que está valendo
sudo systemctl enable --now nftables      # carrega no boot

Proteger o computador e como saberProtecting the computer and how to know

Firewall é uma camada, não a defesa inteira. Segurança é defesa em profundidade: se uma camada falha, a próxima segura. A ordem prática é: reduzir o que está exposto, atualizar, limitar quem entra, vigiar e ter cópia de segurança.A firewall is one layer, not the whole defence. Security is defence in depth: if one layer fails, the next holds. The practical order is: reduce what is exposed, update, limit who gets in, watch, and keep backups.

Como saber se o seu computador está protegidoHow to know whether your computer is protected

Lista de verificação mínimaMinimum checklist

1. Atualizações automáticas de segurança ligadas (unattended-upgrades no Debian/Ubuntu, dnf-automatic no Fedora).Automatic security updates on (unattended-upgrades on Debian/Ubuntu, dnf-automatic on Fedora).
2. Firewall com política de negar entrada por padrão.Firewall with a deny-incoming default policy.
3. Uso diário com usuário comum; sudo só quando preciso. Nunca navegar como root.Daily use with a regular user; sudo only when needed. Never browse as root.
4. SSH (se existir) só com chave, sem login de root, com fail2ban.SSH (if it exists) key-only, no root login, with fail2ban.
5. Serviços desnecessários desligados: systemctl disable --now nome.Unneeded services turned off: systemctl disable --now name.
6. Senhas fortes e únicas em um gerenciador; disco cifrado (LUKS) em notebooks.Strong, unique passwords in a manager; encrypted disk (LUKS) on laptops.
7. Backup 3-2-1 (3 cópias, 2 mídias, 1 fora do local) e teste de restauração.3-2-1 backup (3 copies, 2 media, 1 off-site) and a restore test.
8. Instalar software só de repositórios oficiais ou fontes verificadas; ler antes de rodar curl … | sh.Install software only from official repositories or verified sources; read before running curl … | sh.

Ferramentas visuais: TUI e webVisual tools: TUI and web

Você não precisa decorar tudo: existem interfaces de terminal (TUI) e web que mostram saúde do sistema, logs, SSH, Git e contêineres de forma visual. As “lazy” (lazygit, lazydocker…) seguem a ideia de resumir dezenas de comandos em atalhos de teclado. Todas abaixo são projetos abertos conhecidos; confira a página oficial do projeto para a forma de instalação mais atual da sua distribuição.You do not need to memorise everything: there are terminal (TUI) and web interfaces that show system health, logs, SSH, Git and containers visually. The “lazy” ones (lazygit, lazydocker…) follow the idea of folding dozens of commands into keyboard shortcuts. All of the below are well-known open projects; check the project’s official page for the most current install method for your distribution.

No terminal (TUI)In the terminal (TUI)

Pelo navegador (web)In the browser (web)

Painel de saúde com comandos purosA health panel using plain commands

uptime                          # há quanto tempo está ligado e o load average
free -h                         # memória (olhe "available", não "free")
df -h                           # discos cheios?
lsblk                           # discos e partições
vmstat 1 5                      # CPU, memória, swap e I/O a cada 1 s
iostat -x 1 3                   # utilização de disco (pacote sysstat)
systemctl --failed              # serviços que falharam
journalctl -p err -b            # erros desde o boot
sudo dmesg -T | tail            # mensagens recentes do kernel (disco, USB, memória)
sensors                         # temperaturas (lm-sensors)
sudo smartctl -H /dev/sda       # saúde do disco (smartmontools)
lscpu ; lspci ; lsusb           # inventário de hardware
uname -r ; cat /etc/os-release  # versão do kernel e da distribuição

Limpar o histórico do terminalClearing the terminal history

O shell guarda os comandos que você digita para poder repeti-los (seta para cima, Ctrl+R). No bash a lista fica na memória durante a sessão e é gravada em ~/.bash_history quando você sai. Por isso uma senha digitada na linha de comando fica gravada em texto puro.The shell keeps the commands you type so you can repeat them (up arrow, Ctrl+R). In bash the list stays in memory during the session and is written to ~/.bash_history when you exit. That is why a password typed on the command line stays stored in plain text.

history | tail -20              # veja os últimos
history -d 482                  # apaga UMA entrada (pelo número)
history -c                      # limpa a lista em MEMÓRIA
history -w                      # grava a memória no arquivo -> junto com -c, zera o arquivo
history -c && history -w        # zerar tudo de uma vez
> ~/.bash_history               # alternativa: esvazia o arquivo direto

Um detalhe que pega muita gente: history -c sozinho limpa só a memória; ao sair, o bash grava de volta o que ainda estiver no arquivo ou o que você digitar depois. Para uma sessão sem rastro, use um dos modos abaixo.A detail that catches many people: history -c alone clears only memory; on exit bash writes back what is still in the file or what you type afterwards. For a session without a trace, use one of the modes below.

Outros shells e a telaOther shells and the screen

# zsh: arquivo ~/.zsh_history
: > ~/.zsh_history ; unset HISTFILE ; exit      # esvazia e não regrava ao sair
setopt HIST_IGNORE_SPACE                         # espaço no começo = não grava

# fish
history clear

# limpar a TELA (não é o histórico!)
clear                           # limpa a tela (e, nos terminais modernos, o rolamento)
clear -x                        # limpa a tela mas mantém o rolamento
Ctrl+L                          # limpa a tela, mantém o rolamento
reset                           # reinicializa o terminal se ele "quebrou"

O histórico também vaza por outros lugaresHistory also leaks elsewhere

• Arquivos de histórico de outros programas: ~/.python_history, ~/.lesshst, ~/.viminfo, ~/.mysql_history, ~/.psql_history.Other programs’ history files: ~/.python_history, ~/.lesshst, ~/.viminfo, ~/.mysql_history, ~/.psql_history.
• Os logs do sistema: o sudo registra cada comando em /var/log/auth.log ou no journal, e isso não é apagado por limpar o histórico do shell.System logs: sudo records each command in /var/log/auth.log or the journal, and that is not erased by clearing the shell history.
• A lista de processos: argumentos de linha de comando aparecem para outros usuários em ps e em /proc/PID/cmdline enquanto o comando roda.The process list: command-line arguments are visible to other users in ps and /proc/PID/cmdline while the command runs.
• Ferramentas de histórico sincronizado (como o atuin) guardam cópias fora do arquivo local.Synced-history tools (such as atuin) keep copies outside the local file.

Questões de prova e revisãoExam questions and review

Estas perguntas cobrem o que costuma cair em Linux Essentials, LPIC-1 e RHCSA. Tente responder sem olhar a coluna da direita.These questions cover what usually shows up in Linux Essentials, LPIC-1 and RHCSA. Try to answer without looking at the right-hand column.

Mapa de revisão em uma tabelaReview map in one table