# Permissões no Linux e Calculadora Chmod: Arquitetura Técnica e Guia Avançado

Unix e sistemas POSIX garantem isolamento de processos e segurança via Controle de Acesso Discricionário (Discretionary Access Control - DAC). Na base dessa arquitetura opera a palavra de modo de arquivo (file mode word): bitmask de 16 bits que governa privilégios de leitura, escrita e execução em três camadas de usuários. Ao configurar Nginx, Terraform, OpenSSH ou contêineres Docker sem root, administrar modos de acesso é vital para a resiliência operacional.

O utilitário chmod (change mode) altera esses bits. Contudo, traduzir a intenção operacional entre a notação octal (755, 644) e as representações simbólicas (rwxr-xr-x, rw-r--r--) induz a erros. Um bit configurado incorretamente expõe chaves privadas ou dispara erros HTTP 403 Forbidden.

A Calculadora Chmod e de Permissões Linux do ToolsAA é um utilitário corporativo visual, validador POSIX em tempo real, calculadora chmod interativa e gerador confiável de chmod 755 e 644. Construída sob arquitetura 100% cliente ("use client"), os cálculos binários e a matemática de umask rodam no navegador, sem rede ou telemetria, assegurando total privacidade e conformidade com LGPD e GDPR.

# Visão Geral Abrangente e Casos de Uso no Mundo Real

O modelo POSIX define três níveis de autorização:

• Proprietário (u - Owner): Usuário dono da entidade no sistema.
• Grupo (g - Group): Grupo associado para fluxos colaborativos.
• Outros (o - Others): Qualquer outra conta autenticada no sistema operacional.

Em cada nível, avaliam-se três operações fundamentais:

• Leitura (r / 4): Visualizar arquivos ou listar diretórios (readdir()).
• Escrita (w / 2): Modificar arquivos ou alterar entradas em pastas.
• Execução (x / 1): Executar binários (execve()) ou atravessar diretórios (chdir()).

+-----------------------------------------------------------------------------------------+
|                          POSIX File Mode Word (Bitmask de 16 Bits)                      |
|  [ Tipo: 4 bits ]   [ Especiais: 3b ] [ Dono (u): 3b ]  [ Grupo (g): 3b ] [ Outros: 3b ]|
|  0100000 (Arquivo)  4: SetUID         4: Read (r)       4: Read (r)       4: Read (r)   |
|  0040000 (Diretório)2: SetGID         2: Write (w)      2: Write (w)      2: Write (w)  |
|  Modo 755:          Especiais: 0      Dono: 7 (rwx)     Grupo: 5 (r-x)    Outros: 5 (r-x)|
|  Modo 644:          Especiais: 0      Dono: 6 (rw-)     Grupo: 4 (r--)    Outros: 4 (r--)|
+-----------------------------------------------------------------------------------------+

# Casos de Uso Críticos em Entornos Corporativos

• Raízes Web (Nginx, Apache): Leitura para ativos e busca para navegação (755 pastas, 644 arquivos).
• Blindagem SSH: Regras do OpenSSH (600 ou 400 para id_rsa, 700 para ~/.ssh/).
• Colaboração com SetGID: Pastas compartilhadas (chmod 2775 /shared) herdam o grupo pai.
• Armazenamento Temporário: Pastas scratch usam Sticky Bit (chmod 1777 /tmp) contra deleções indevidas.
• Contêineres Docker Não-Root: Modos somente leitura (440 ou 400) para segredos montados.

# Processamento no Cliente para Vazamento Zero de Dados

DevOps lidam com caminhos confidenciais (/var/run/secrets, ~/.aws/credentials). Calculadoras legadas enviam dados via HTTP POST, vazando topologias. O ToolsAA opera 100% no navegador, em conformidade com SOC 2 e LGPD.

# Arquitetura Técnica e Funcionamento Sob o Capô

Calcular permissões de arquivos no Linux requer manipulação binária em nível de bits, chamadas POSIX e conversões numéricas.

# 1. A Palavra de Modo POSIX e Inodes

Metadados residem em inodos. O campo st_mode (<sys/stat.h>) é um inteiro de 16 bits:

• Tipo (Bits 15–12): Regular (0100000), diretório (0040000), link (0120000), socket (0140000).
• Especiais (Bits 11–9): SetUID (04000), SetGID (02000), Sticky Bit (01000).
• Permissões (Bits 8–0): Dono (0700), Grupo (0070), Outros (0007).

# 2. Aritmética Octal Bit a Bit

A base 8 alinha-se ao Unix: cada dígito octal engloba três bits binários ($2^3 = 8$):

$$\text{Valor da Tríade} = (r \times 4) + (w \times 2) + (x \times 1)$$

Permutações vão de 0 (---) a 7 (rwx). Três tríades geram o modo padrão (755). Bits especiais adicionam um quarto dígito (4755).

# 3. Bits Especiais na Notação Simbólica

No ls -l, bits especiais substituem a execução (x):

• SetUID: Minúscula s com execução (rwsr-xr-x); maiúscula S sem execução (rwSr-xr-x).
• SetGID: Minúscula s com execução (rwxrwsr-x); maiúscula S sem execução.
• Sticky Bit: Minúscula t com execução (rwxrwxrwt); maiúscula T sem execução.

# 4. A Equação de Inversão da Umask

Processos herdam uma máscara umask que filtra modos de criação (0666 arquivos, 0777 diretórios):

$$\text{Modo Efetivo} = \text{Modo Base} \ \& \ (\sim\text{Umask})$$

Sob umask 0022: arquivos recebem 0666 & 0022 = 0644; diretórios recebem 0777 & 0022 = 0755.

# 5. O Dualismo Semântico do Bit de Execução

Em arquivos, x permite execução via execve(). Em diretórios, x é a flag de busca: sem ela, o kernel bloqueia navegação (cd) e leitura de metadados (stat()), mesmo que arquivos internos possuam modo 0644.

# 6. APIs Modernas da Web e Arquitetura do ToolsAA

• Motor Bitwise em Memória: Transições com operadores binários (&, |, ~) em menos de 1ms.
• Web Crypto API: Somas SHA-256 (crypto.subtle.digest) para validar integridade de perfis.
• Zero Telemetria: Execução isolada na memória volátil do navegador sem tráfego de rede.

# Guia Prático Passo a Passo de Utilização

# Passo 1: Manipulação da Grade Interativa

Marque ou desmarque a grade 3x3 de Leitura (4), Escrita (2) e Execução (1) para Proprietário, Grupo e Outros. O valor octal (755) e o formato simbólico (rwxr-xr-x) atualizam instantaneamente.

# Passo 2: Aplicação de Presets Corporativos Validados

• 755: Diretórios web públicos e binários (public_html/).
• 644: Documentos web (HTML, CSS), imagens e configs.
• 600: Chaves privadas SSH (id_rsa) e variáveis em .env.
• 700: Pastas privadas (~/.ssh/) e rotinas do root.
• 400: Certificados em nuvem somente leitura (chaves PEM).
• 1777: Pastas temporárias com Sticky Bit (/tmp).

# Passo 3: Configuração de Bits Especiais

Expanda a seção para habilitar SetUID (4000), SetGID (2000) ou Sticky Bit (1000).

# Passo 4: Geração de Comandos Recursivos Seguros

Insira o caminho alvo (/var/www/html) para gerar comandos bifurcados com find, aplicando 755 a pastas e 644 a arquivos separadamente.

# Passo 5: Exportação e Aplicação no Terminal

Escolha notação octal (chmod 755 /caminho) ou simbólica (chmod u=rwx,go=rx /caminho), clique em copiar e execute no terminal.

# Implementações de Código para Produção

# 1. Modern TypeScript Implementation

Motor tipado para conversões octais e simbólicas e aplicação de umask:

export interface Triad { read: boolean; write: boolean; execute: boolean; }
export interface SpecialBits { setuid: boolean; setgid: boolean; sticky: boolean; }

// Converte tríades e bits especiais para octal
export function toOctal(u: Triad, g: Triad, o: Triad, s: SpecialBits): string {
  const spec = (s.setuid ? 4 : 0) + (s.setgid ? 2 : 0) + (s.sticky ? 1 : 0);
  const val = (t: Triad) => (t.read ? 4 : 0) + (t.write ? 2 : 0) + (t.execute ? 1 : 0);
  const mode = `${val(u)}${val(g)}${val(o)}`;
  return spec > 0 ? `${spec}${mode}` : mode;
}

// Converte octal para notação simbólica (ls -l)
export function toSymbolic(octal: string, isDir = false): string {
  const [s, u, g, o] = octal.padStart(4, "0").split("").map(Number);
  const fmt = (v: number, spec: boolean, sx: string, snx: string) => {
    const r = v & 4 ? "r" : "-", w = v & 2 ? "w" : "-", x = v & 1;
    return `${r}${w}${spec ? (x ? sx : snx) : (x ? "x" : "-")}`;
  };
  return `${isDir ? "d" : "-"}${fmt(u, !!(s & 4), "s", "S")}${fmt(g, !!(s & 2), "s", "S")}${fmt(o, !!(s & 1), "t", "T")}`;
}

// Aplica umask via operadores bitwise
export function applyUmask(mode: number, umask: number): string {
  return ((mode & ~umask) & 0o777).toString(8).padStart(3, "0");
}

# 2. Modern JavaScript Implementation (Node.js / ESM)

Utilitário em JavaScript para inspeção de inodos e comandos seguros com find:

import fs from "node:fs";

// Inspeciona permissões POSIX no disco
export function inspectPermissions(filePath) {
  const stat = fs.statSync(filePath);
  return {
    octal: (stat.mode & 0o7777).toString(8).padStart(4, "0"),
    isDir: stat.isDirectory(),
  };
}

// Comandos bifurcados com find
export function getSafeChmodCommands(path) {
  return {
    dirs: `find ${path} -type d -exec chmod 755 {} +`,
    files: `find ${path} -type f -exec chmod 644 {} +`,
  };
}

# 3. Modern Python 3.11+ Implementation

Implementação Python para validação e auditoria de modos de arquivo:

# Converte tuplas (r, w, x) para octal
def to_octal(u: tuple, g: tuple, o: tuple, s: tuple = (0, 0, 0)) -> str:
    spec = s[0] * 4 + s[1] * 2 + s[2] * 1
    val = lambda t: t[0] * 4 + t[1] * 2 + t[2] * 1
    mode = f"{val(u)}{val(g)}{val(o)}"
    return f"{spec}{mode}" if spec else mode

# Gera string simbólica (ls -l)
def to_symbolic(octal: str, is_dir: bool = False) -> str:
    s, u, g, o = [int(d) for d in octal.zfill(4)]
    fmt = lambda v, spec, sx, snx: f"{'r' if v & 4 else '-'}{'w' if v & 2 else '-'}{(sx if v & 1 else snx) if spec else ('x' if v & 1 else '-')}"
    return f"{'d' if is_dir else '-'}{fmt(u, bool(s & 4), 's', 'S')}{fmt(g, bool(s & 2), 's', 'S')}{fmt(o, bool(s & 1), 't', 'T')}"

# Comandos bifurcados com find
def bifurcated_commands(path: str, dir_m="755", file_m="644") -> dict[str, str]:
    return {
        "dirs": f"find {path} -type d -exec chmod {dir_m} {{}} +",
        "files": f"find {path} -type f -exec chmod {file_m} {{}} +"
    }

# Armadilhas Comuns, Casos Limite e Solução de Problemas

# 1. O Antipadrão de chmod 777

Atribuir chmod 777 (rwxrwxrwx) concede acesso total a qualquer processo, facilitando injeção de webshells. Em produção, use sempre 755 para pastas e 644 para arquivos.

# 2. A Armadilha do chmod -R Recursivo

Executar chmod -R 644 /caminho remove o bit x de pastas, quebrando a navegação. Já chmod -R 755 torna arquivos comuns executáveis. Use comandos bifurcados com find:

find /var/www/html -type d -exec chmod 755 {} +
find /var/www/html -type f -exec chmod 644 {} +

# 3. Travessia de Diretórios (x) vs. Leitura (r)

A leitura em pastas (r--) apenas lista nomes com readdir(). Sem execução (--x), o kernel bloqueia comandos cd e consultas de inodo com stat().

# 4. Ineficácia do SetUID em Scripts Interpretados

Definir SetUID (chmod 4755 script.sh) em scripts iniciados por #!/bin/bash não concede privilégios de root. O kernel ignora SetUID em scripts interpretados por segurança. Utilize o /etc/sudoers.

# 5. O Mito da Subtração Aritmética da Umask

Umask não opera por subtração aritmética. Com umask 0027, a subtração em octal falha, enquanto a operação bit a bit 0666 & ~0027 resulta corretamente em 0640 (rw-r-----).

# 6. Alerta de Chave Aberta do OpenSSH

O OpenSSH rejeita chaves privadas acessíveis por terceiros (WARNING: UNPROTECTED PRIVATE KEY FILE!). Isole o acesso executando chmod 600 ~/.ssh/id_rsa ou chmod 400 chave.pem.

# Perguntas Frequentes Técnicas (FAQ)

# Q1: Qual é a diferença técnica entre chmod 755 e chmod 644?

Resposta: Chmod 755 atribui rwxr-xr-x (dono controle total; grupo e outros leem e executam). Chmod 644 atribui rw-r--r-- (dono leitura e escrita; outros apenas leitura). Em produção, 755 aplica-se a pastas e binários; 644 a arquivos estáticos.

# Q2: Por que é perigoso executar chmod 777 em ambientes de produção?

Resposta: Chmod 777 concede acesso irrestrito (rwxrwxrwx), anulando o princípio do menor privilégio e permitindo que invasores sobrescrevam binários do sistema.

# Q3: O que fazem SetUID, SetGID e Sticky Bit, e o que significam S e T maiúsculos?

Resposta: SetUID (4000) executa processos com privilégios do dono; SetGID (2000) força herança de grupo; Sticky Bit (1000) impede apagar arquivos alheios em /tmp. Minúsculas (s/t) indicam execução ativa; maiúsculas (S/T), bit sem execução.

# Q4: Como a umask determina as permissões padrão de novos arquivos?

Resposta: O kernel calcula: $\text{Modo Efetivo} = \text{Modo Base} \ \& \ (\sim\text{Umask})$. Sob umask 0022, arquivos (0666) recebem 0644 e diretórios (0777) recebem 0755.

# Q5: Por que não consigo acessar arquivos em uma pasta com leitura mas sem execução?

Resposta: A leitura lista apenas nomes com readdir(). Entrar no diretório (cd) e inspecionar inodos com stat() exige execução (x). Sem ela, o acesso interno é bloqueado.

# Q6: Como resolver o erro do OpenSSH "Permissions are too open" em chaves privadas?

Resposta: O OpenSSH bloqueia chaves acessíveis por terceiros. Isole permissões para o proprietário via chmod 600 ~/.ssh/id_rsa ou chmod 400 chave.pem.

# Q7: Como aplicar permissões recursivas com segurança em arquivos e pastas?

Resposta: Evite chmod -R 644. Separe arquivos e pastas utilizando comandos bifurcados com find (chmod 755 em pastas, chmod 644 em arquivos).

# Q8: A Calculadora Chmod do ToolsAA envia meus caminhos para servidores externos?

Resposta: Não. A ferramenta opera 100% no cliente ("use client"). Todos os cálculos de máscara e conversões acontecem no navegador com privacidade total.

# Matriz de Referência Técnica: Modos Padrão de Permissão no Linux

# Conclusão

O modelo de permissões POSIX é o alicerce da administração Unix. No perímetro do sistema operacional, os modos de arquivo definidos no kernel isolam processos e blindam credenciais críticas contra acessos indevidos.

Evitar suposições empíricas e o uso de chmod 777 previne incidentes graves de segurança. Uma calculadora chmod interativa capacita engenheiros a dominar a lógica de bits, configurar modificadores e gerar comandos confiáveis.

A Calculadora Chmod do ToolsAA entrega precisão técnica para calcular permissões no Linux. Processando 100% no navegador sem telemetria, garante máxima proteção para suas operações.