Aula 1.5 — Permissões e ACL

📋 Conceito de Permissões no Linux

No Linux, todo arquivo e diretório possui um conjunto de permissões que define quem pode fazer o quê. Esse sistema é fundamental para a segurança: sem ele, qualquer usuário poderia ler, modificar ou apagar arquivos de outros — inclusive arquivos do sistema.

As permissões se aplicam a três categorias de usuário:

👤 user (u) O dono do arquivo — quem o criou ou para quem foi transferido

👥 group (g) O grupo ao qual o arquivo pertence — todos os membros do grupo

🌐 other (o) Todos os demais usuários do sistema que não são dono nem grupo

Lendo as permissões: `ls -l`

Cada linha do ls -l começa com 10 caracteres que descrevem tipo e permissões:

- tipo

r u

w u

x u

r g

- g

x g

r o

- o

Tipo (- arquivo • d diretório • l link)

Dono (user)

Grupo (group)

Outros (other)

ls -l — lendo permissões

user@srv:~$ ls -l total 12 drwxr-xr-x 2 user devs 4096 jan 10 Documentos/ -rw-r--r-- 1 user devs 1024 jan 10 config.txt -rwxr-x--- 1 user devs 2048 jan 10 deploy.sh # d=diretório rwx=dono r-x=grupo ---=outros

🔒 Regra de ouro: o Linux verifica as permissões sempre nesta ordem — dono, grupo, outros. A primeira categoria que corresponde ao usuário é a que vale; as demais são ignoradas.

🔢 Notação Octal

Além da notação simbólica (rwx), as permissões podem ser representadas em octal (números 0 a 7). Cada categoria (u, g, o) recebe um dígito que é a soma dos valores concedidos.

rwx = 7

r

w

x

7

rw- = 6

r

w

-

6

r-x = 5

r

-

x

5

r-- = 4

r

-

4

-wx = 3

-

w

x

3

-w- = 2

-

w

-

2

--x = 1

-

x

1

--- = 0

-

0

Permissões mais comuns (3 dígitos)

755

rwxr-xr-x — script/programa Dono: tudo • Grupo e outros: ler + executar

644

rw-r--r-- — arquivo de texto Dono: ler + escrever • Demais: só ler

700

rwx------ — script privado Dono: tudo • Grupo e outros: nada

600

rw------- — chave SSH / senha Dono: ler + escrever • Demais: nada

💡 Dica prática: 755 para scripts e programas • 644 para arquivos de texto e configuração • 600 para chaves SSH e arquivos sensíveis.

🔧 chmod — Alterando Permissões

O chmod (change mode) altera as permissões de arquivos e diretórios. Aceita tanto a notação octal quanto a simbólica.

Modo octal

chmod — modo octal

# chmod [permissão] [arquivo] user@srv:~$ chmod 755 script.sh # rwxr-xr-x — dono executa, demais leem e executam user@srv:~$ chmod 644 config.txt # rw-r--r-- — dono lê/escreve, demais só leem user@srv:~$ chmod 600 ~/.ssh/id_rsa # rw------- — somente o dono (chave privada SSH) user@srv:~$ chmod -R 755 projeto/ # -R aplica recursivamente em todo o diretório

Modo simbólico

A notação simbólica usa: categoria (u g o a) + operador (+ adiciona • - remove • = define) + permissão (r w x)

chmod u+x script.sh Adiciona execução para o dono

chmod g-w arquivo.txt Remove escrita do grupo

chmod o=r arquivo.txt Define outros: só leitura

chmod a+x script.sh Adiciona execução para todos

chmod ug+rw doc.pdf Leitura + escrita para dono e grupo

chmod u-x,o-x bin Remove execução do dono e outros

⚠️ Nunca use chmod 777 em produção! Isso concede todas as permissões a todos os usuários — uma brecha grave de segurança. Use sempre a permissão mínima necessária.

👤 chown e chgrp — Mudando Proprietário

Além das permissões, cada arquivo tem um dono e um grupo. Os comandos chown e chgrp permitem alterar esses atributos. Apenas o root (ou usuário com sudo) pode mudar o dono de um arquivo.

chown — Change Owner

Muda o dono do arquivo
Pode mudar dono e grupo juntos
Sintaxe: chown usuario:grupo arquivo
Recursivo com -R

chgrp — Change Group

Muda apenas o grupo
Usuário pode mudar o próprio grupo
Sintaxe: chgrp grupo arquivo
Recursivo com -R

chown e chgrp na prática

# Mudar somente o dono root@srv:~# chown joao arquivo.txt # Mudar dono E grupo ao mesmo tempo (mais eficiente) root@srv:~# chown joao:devs projeto/ # Recursivo — toda a pasta do servidor web root@srv:~# chown -R www-data:www-data /var/www/html # Mudar somente o grupo com chgrp root@srv:~# chgrp vendas relatorio.pdf # Verificar o resultado user@srv:~$ ls -la projeto/ drwxr-xr-x 3 joao devs 4096 jan 10 projeto/ # ↑ ↑ # dono grupo

💡 Atalho: chown usuario:grupo arquivo equivale a rodar chown + chgrp separados — mais eficiente e menos propenso a erros.

★ Permissões Especiais: SUID, SGID e Sticky Bit

Além do trio rwx, o Linux possui três permissões especiais representadas por um 4º dígito à esquerda na notação octal, ou por letras especiais (s, t) na notação simbólica.

🔴

SUID

4xxx — u+s

Executa o arquivo com as permissões do dono, não de quem executa.
Exemplo: /usr/bin/passwd — qualquer usuário muda sua senha mas o binário roda como root.

🔵

SGID

2xxx — g+s

Em diretórios: novos arquivos herdam o grupo do diretório.
Ideal para pastas de projetos compartilhados onde todos precisam do mesmo grupo.

🟢

Sticky Bit

1xxx — +t

Em diretórios: cada usuário só pode deletar seus próprios arquivos.
Padrão em /tmp — todos escrevem, ninguém apaga o do outro.

aplicando permissões especiais

# SUID — programa roda como root (s no lugar do x do dono) root@srv:~# chmod u+s /usr/bin/meu_prog -rwsr-xr-x 1 root root 12345 /usr/bin/meu_prog # SGID — arquivos criados herdam o grupo do diretório root@srv:~# chmod g+s /var/projeto drwxrwsr-x 2 root devs 4096 /var/projeto/ # Sticky Bit — só o dono deleta seus arquivos (t no lugar do x) root@srv:~# chmod +t /tmp drwxrwxrwt 20 root root 4096 /tmp/ # Usando octal: 4=SUID | 2=SGID | 1=Sticky root@srv:~# chmod 4755 /usr/bin/meu_prog root@srv:~# chmod 2775 /var/projeto root@srv:~# chmod 1777 /tmp

⚠️ SUID em scripts Shell não tem efeito na maioria dos sistemas Linux modernos por razões de segurança. Funciona apenas em binários compilados.

🧹 umask — Permissão Padrão para Novos Arquivos

O umask define quais permissões são retiradas automaticamente ao criar novos arquivos e diretórios. Funciona como uma máscara subtrativa.

Como calcular: base − umask = resultado

Permissão Base

666

arquivos

−

umask padrão

022

remove grupo w e outros w

=

Resultado

644

rw-r--r--

Permissão Base

777

diretórios

−

umask padrão

022

remove grupo w e outros w

=

Resultado

755

rwxr-xr-x

umask — ver e definir

# Ver o umask atual user@srv:~$ umask 0022 # Definir umask mais restritivo (só o dono acessa) user@srv:~$ umask 077 # 666 - 077 = 600 (arquivos) | 777 - 077 = 700 (diretórios) # Testar: criar arquivo com novo umask user@srv:~$ touch teste.txt && ls -l teste.txt -rw------- 1 user user 0 jan 10 teste.txt # 600 — somente o dono lê/escreve # Tornar permanente — adicionar ao ~/.bashrc # echo "umask 027" >> ~/.bashrc

🔧 O umask 0022 é o padrão equilibrado. Para ambientes mais seguros use 0027 (sem acesso para "outros") ou 0077 (somente o dono). Quanto maior o umask, mais restrito o acesso.

🛡 Permissões Seguras: Casos Reais

Permissões corretas são a primeira linha de defesa. Veja como aplicar o conceito de privilégio mínimo em situações reais.

640

Arquivo de configuração Dono lê/escreve • Grupo só lê • Outros: nada

600

Chave SSH / senha Apenas o dono lê/escreve • Todos os outros: nada

750

Script de deploy Dono executa • Grupo executa • Outros: nada

755

Diretório público Dono: tudo • Grupo e outros: entrar e listar

Servidor web (Nginx / Apache)

configuração segura de servidor web

# Diretório do site: dono e grupo www-data, 750 root@srv:~# chown -R www-data:www-data /var/www/html root@srv:~# chmod -R 750 /var/www/html # Arquivo de configuração: somente root lê/escreve root@srv:~# chmod 600 /etc/nginx/nginx.conf # Script de deploy: somente o dono executa root@srv:~# chmod 700 /opt/scripts/deploy.sh # Arquivo absolutamente bloqueado root@srv:~# chmod 000 segredo.txt user@srv:~$ cat segredo.txt cat: segredo.txt: Permissão negada

Auditoria de permissões suspeitas

auditoria — encontrando problemas

# Encontrar arquivos com SUID no sistema root@srv:~# find / -perm -4000 -type f 2>/dev/null # Encontrar arquivos com permissão 777 (perigoso!) root@srv:~# find /var/www -perm 777 # Detalhes completos de um arquivo user@srv:~$ stat config.txt File: config.txt Access: (0644/-rw-r--r--) Uid: (1000/user) Gid: (1000/user)

✅ Checklist de permissões seguras: configurações → 640 ou 600 • scripts → 750 ou 700 • diretórios públicos → 755 • nunca use 777 em produção.

🎯 Exercício — Arraste e Conecte

Arraste cada comando para sua descrição correta.

Comando

chmod 755 script.sh

chmod u+x arquivo

chown joao:devs projeto/

chmod 644 config.txt

chmod 000 segredo.txt

umask 022

Descrição

Dá permissão de execução para todos

Adiciona execução apenas para o dono

Muda dono e grupo do diretório

Leitura para todos, escrita só para dono

Remove todas as permissões

Define permissão padrão para novos arquivos

❓ Verifique seu Conhecimento

Qual é a permissão octal equivalente a rwxr-xr-x?

A644

B755

C777

D700

✓ rwx = 4+2+1 = 7 (dono) • r-x = 4+0+1 = 5 (grupo) • r-x = 5 (outros) → 755. Padrão para scripts e programas executáveis.

O que faz o comando chmod u+x script.sh?

ARemove a permissão de execução do usuário

BAdiciona execução para todos os usuários

CAdiciona execução somente para o dono do arquivo

DDefine permissão total somente para o dono

✓ u = user (dono) • + = adiciona • x = execução. Para todos os usuários seria a+x ou ugo+x.

Com umask 022, qual será a permissão de um arquivo recém-criado?

A644 (rw-r--r--)

B755 (rwxr-xr-x)

C777 (rwxrwxrwx)

D600 (rw-------)

✓ Arquivos partem de 666 (sem execução por padrão). 666 - 022 = 644. Diretórios partem de 777, então 777 - 022 = 755.

O que acontece quando o Sticky Bit é aplicado em um diretório?

AO diretório fica oculto para outros usuários

BNovos arquivos herdam o grupo do diretório

CO diretório fica somente leitura

DCada usuário só pode deletar seus próprios arquivos

✓ O Sticky Bit (+t, 1xxx) é o padrão do /tmp: todos escrevem livremente mas ninguém apaga arquivos de outros. A letra t aparece no lugar do x de "outros".

🛠️ Atividade Prática — Laboratório de Permissões

⏱ ~30 min 💻 Ubuntu Server / Terminal 📸 Tirar screenshot da saída

1

Criar estrutura de diretórios

Crie a estrutura base: mkdir -p ~/lab-perm/{publico,privado,scripts}. Crie arquivos de teste: touch ~/lab-perm/publico/doc.txt ~/lab-perm/privado/senha.txt ~/lab-perm/scripts/deploy.sh. Verifique com ls -lR ~/lab-perm/.

2

Aplicar permissões adequadas

Configure as permissões corretas: chmod 644 ~/lab-perm/publico/doc.txt (leitura pública), chmod 600 ~/lab-perm/privado/senha.txt (só o dono), chmod 750 ~/lab-perm/scripts/deploy.sh (script para dono e grupo).

3

Testar acesso com diferentes usuários

Crie um usuário de teste: sudo useradd -m testuser. Tente acessar o arquivo privado: sudo -u testuser cat ~/lab-perm/privado/senha.txt — deve retornar "Permissão negada". Com sudo cat (root) deve funcionar pois root ignora permissões.

4

Usar chmod simbólico e octal

Adicione execução com notação simbólica: chmod u+x ~/lab-perm/scripts/deploy.sh. Depois use octal para um diretório completo: chmod -R 755 ~/lab-perm/publico/. Verifique cada mudança com ls -l.

5

Configurar e testar umask

Veja o umask atual com umask. Mude para umask 077 e crie um arquivo: touch ~/lab-perm/privado/novo.txt && ls -l ~/lab-perm/privado/novo.txt. Deve ter permissão 600. Restaure com umask 022.

6

Auditoria final com ls -la e stat

Liste tudo com permissões: ls -laR ~/lab-perm/. Use stat ~/lab-perm/privado/senha.txt para ver detalhes completos (dono, grupo, permissões em octal). Tire um screenshot da saída.

📌 Para refletir: Permissões não são apenas uma questão técnica — são a diferença entre um servidor seguro e um comprometido. Em ambientes de produção, cada arquivo precisa ter exatamente as permissões mínimas necessárias. Um arquivo de configuração legível por todos pode vazar senhas de banco de dados; um script executável por todos pode ser explorado por atacantes.

🔐 Permissões e Controle de Acesso