# Permissões de arquivos e diretórios

### 7.3) Mudando permissões de arquivos e diretórios

`chmod` - É um comando que altera as permissões dos arquivos e diretórios, através de uma representação simbólica ou de um número octal.

## Formato Simbólico

| chmod em formato simbólico                      |
| ----------------------------------------------- |
| `chmod [u g o a] {+ - =} {r w x s t} <arquivo>` |

O comando é divido em 3 partes, uma ou mais letras para indicar a quem vai ocorrer a mudança, um sinal indicando se vai adicionar, remover ou substituir, e uma letra que indicam as novas permissões do usuário.

Aqui será indicado **a quem** vai ocorrer essa mudança: **\[ u g o a ]**

* **\[ u ]** para indicar mudança para o dono do arquivo.
* **\[ g ]** para indicar mudança para o grupo do dono.
* **\[ o ]** para indicar mudança para outros usuários.
* **\[ a ]** para todos.

**Obs**: Se não for digitado nenhuma letra será assumido `a`.

Aqui será indicado **o que** vai ser essa mudança, remover, adicionar ou substituir: **{ + - = }**

* **{ + }** para adicionar uma permissão.
* **{ - }** para remover uma permissão.
* **{ = }** para substituir as permissões pela a indicada.

Aqui será indicado **qual** vai ser essa mudança: **{ r w x s t }**

* **{ r }** permissão de leitura.
* **{ w }** permissão de gravação.
* **{ x }** permissão executar um arquivo ou entrar em um diretório.
* **{ s }** permissão suid ou sgid.
* **{ t }** permissão sticky.

Exemplo:

| Comando               | Descrição                                                       |
| --------------------- | --------------------------------------------------------------- |
| `chmod u+r <arquivo>` | Foi adicionado a permissão leitura ao dono no arquivo.          |
| `chmod u-r <arquivo>` | Foi retirado a permissão leitura ao dono no arquivo.            |
| `chmod u=r <arquivo>` | Todas as permissões foram substitutas pela a informada ao dono. |

### Permissões especiais: SUID, SGID e Sticky bit

### SUID (Set User ID): user + s(pecial)

Essa permissão permite que o arquivo seja executado com privilégios de proprietário do arquivo.

Olhando o comando `/usr/bin/passwd`, esse comando tem por padrão a permissão suid definida. O passwd é um gerenciamento de senhas, tem o suid já definido para que um usuário comum possa alterar suas próprias senhas, pois um usuário comum não tem permissão de alterar um arquivo de sistema no /etc, apenas o root.

<figure><img src="https://3652049349-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FSsFzoXz7V7mLiRRuZlST%2Fuploads%2FlS0ESKfp8xlevavmFGsh%2Fimage.png?alt=media&#x26;token=e80c9299-4d19-42c5-938d-1d0a267f3bb6" alt=""><figcaption><p>passwd</p></figcaption></figure>

Observe o **s** onde o **x** normalmente indicaria permissões de execução para o usuário.

### SGID (Set Group ID): user + s(pecial)

A permissão SGID pode ser definida em arquivos e diretórios, nos arquivos é semelhante à permissão SUID, mas os privilégios serão os mesmos do proprietário do grupo.

### Como saber se o arquivo tem o suid ou sgid ativado

* **Usando o comando `ls -l`**

No lugar o x (executar) vai estar S ou s. A permissão SUID é representada pelo "s" (minúsculo) ou "S" (maiúsculo) na posição do usuário, enquanto a permissão SGID é representada pelo "s" (minúsculo) ou "S" (maiúsculo) na posição do grupo nas permissões de arquivo.

| permissões   | explicação                                                                                      |
| ------------ | ----------------------------------------------------------------------------------------------- |
| `-rwsr-xr-x` | A permissão SUID está ativada e pode ser executada (letra "s" minúscula na posição do usuário). |
| `-rwxr-sr-x` | A permissão SGID está ativada e pode ser executada (letra "s" minúscula na posição do grupo).   |

O "s" minúsculo em **rws** indica a presença do SUID no arquivo, junto com a permissão de execução. Se, no lugar dele, houvesse um "S" maiúsculo (rwS), isso significaria que a permissão de execução não foi definida.

Por exemplo:

O arquivo **arquivo.c** não tem a permissão de execução no usuário, se atribuirmos a permissão suid, ficará com o S.

Note que "S" maiúsculo indica que o suid está ativado, mas não tem permissão de execução, para ativar a execução suid é necessário ativar a permissão execução também.

<figure><img src="https://3652049349-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FSsFzoXz7V7mLiRRuZlST%2Fuploads%2FIp4C6Qw8QAgrWUGOjOaA%2Fimage.png?alt=media&#x26;token=13104fab-16c3-4943-88e7-7410b63e910d" alt=""><figcaption><p>permissão suid</p></figcaption></figure>

Assim fica o "s" minúsculo com o suid ativado e com permissão de execução.

* **Usando o comando `find`**

O comando find pode ser usado para localizar todos os arquivos com permissões SUID ou SGID no sistema.

Exemplo:

| comando                      | explicação                                          |
| ---------------------------- | --------------------------------------------------- |
| `find / -type f -perm -4000` | para encontrar todos os arquivos com permissão SUID |
| `find / -type f -perm -2000` | para encontrar todos os arquivos com permissão SGID |

Numericamente o **suid** é representado por **4000**, e **sgid** por **2000**.&#x20;

* **Usando o comando `stat`**

```bash
stat nome_do_arquivo
```

O comando stat pode ser usado para exibir informações detalhadas sobre um arquivo, incluindo as permissões SUID e SGID.

### Stick bit: other + t(sticky)

O sticky bit é usado em diretórios para evitar que usuários regulares excluam ou movam arquivos que não sejam seus.

Somente o proprietário do arquivo e o usuário root podem excluir arquivos em um diretório que possua o Sticky bit ativado.

Um exemplo disso é o diretório `/tmp`

Da mesma forma que se ativarmos o suid e sgid em um arquivo que não tem permissão de execução mostrará o "S" e não o "s", no sticky bit ocorre a mesma coisa. Se o diretório não tiver a permissão **o+x** irá mostrar o "T" e não o "t".

### Extra: alguns comandos utilizados durante a aula

<table><thead><tr><th width="380">Comando</th><th>Descrição</th></tr></thead><tbody><tr><td><code>mkdir -p dir1/dir2/dir3</code></td><td>para criar mais de um diretório em um único comando.</td></tr><tr><td><code>touch meu-arquivo.txt</code></td><td>vai criar um arquivo vazio.</td></tr><tr><td><code>touch arquivo1.txt arquivo2.txt arquivo3.txt</code></td><td>pode criar mais de um arquivo por vez.</td></tr><tr><td><code>ls -l carta*</code></td><td>vai listar todos os arquivos que comecem com "<strong>carta...</strong>".</td></tr></tbody></table>

## Formato numérico octal

O formato numérico octal é composto por 3 dígitos a partir de um conjunto de oito números onde cada número define um tipo de acesso diferente.

| Comando                            | Descrição                                                                                           |
| ---------------------------------- | --------------------------------------------------------------------------------------------------- |
| `chmod xxx <arquivo ou diretório>` | Altera as permissões do usuário, grupo ou outros usuários para ler, escrever ou executar o arquivo. |
| `chmod -R xxx <diretório>`         | Altera a permissão de todos arquivos e diretórios que estão no diretório recursivamente.            |

**Exemplo:**

Cada bit se refere as permissões leitura, gravação e execução (**rwx**). Quando o bit for 1 indica que a permissão será ativada.

<pre class="language-markdown"><code class="lang-markdown"><strong>                                     R W X
</strong></code></pre>

<table><thead><tr><th>Binário</th><th width="236.33333333333331">Octal</th><th>Permissão</th></tr></thead><tbody><tr><td>000</td><td>0</td><td>Nenhum é ativado</td></tr><tr><td>001</td><td>1</td><td>Permissão de execução</td></tr><tr><td>010</td><td>2</td><td>Permissão de de gravação</td></tr><tr><td>011</td><td>3</td><td>Permissão de gravação e execução</td></tr><tr><td>100</td><td>4</td><td>Permissão de leitura</td></tr><tr><td>101</td><td>5</td><td>Permissão de leitura e execução</td></tr><tr><td>110</td><td>6</td><td>Permissão de de leitura e gravação</td></tr><tr><td>111</td><td>7</td><td>Permissão de leitura, gravação e execução</td></tr></tbody></table>

Outra forma de usar o formato **octal** é somando cada permissão isolada, por exemplo:

* **( 4 )** permissão de leitura.
* **( 2 )** permissão de gravação.
* **( 1 )** permissão de execução.

Para atribuir as permissões de leitura e gravação soma 4+2 = 6, `chmod 6 <arquivo>`

Cada um dos 3 dígitos se refere ao usuário, grupo e outros, em sequência. Com isso se usarmos os dígitos 777 vamos atribuir todas as permissões ao dono, grupo e outros.

Exemplo de uso:

<figure><img src="https://3652049349-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FSsFzoXz7V7mLiRRuZlST%2Fuploads%2FO7GzqUa9IUemCMzlLFF8%2Fimage.png?alt=media&#x26;token=a52d1a78-02ec-488e-8a90-50b7c4a905dc" alt=""><figcaption><p>chmod 765</p></figcaption></figure>

Números não utilizados são consideramos como 0, então `chmod 6 arquivo.txt` é igual a `chmod 006`.

<figure><img src="https://3652049349-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FSsFzoXz7V7mLiRRuZlST%2Fuploads%2FLYzkwhFDFRxZIiNCAHWt%2Fimage.png?alt=media&#x26;token=9e89e715-aec5-4cde-9ada-700b820f53d3" alt=""><figcaption><p>chmod 6</p></figcaption></figure>

**Exemplos:**

| Comando               | Descrição                                  |
| --------------------- | ------------------------------------------ |
| `chmod 111 <arquivo>` | Todos podem executar o arquivo.            |
| `chmod 222 <arquivo>` | Todos podem gravar no arquivo.             |
| `chmod 700 <arquivo>` | O dono do arquivo tem todas as permissões. |
| `chmod 600 <arquivo>` | O dono do arquivo pode ler e gravar.       |
| `chmod 777 <arquivo>` | Todas as permissões para todos.            |

### Permissão SUID, SGID e Sticky bit no formato octal

No formato octal podemos utilizar o quarto digito, na frente dos 3 dígitos, para informar uma permissão especial.

Funciona da mesma forma que as permissões r, w e x, a sequência para as permissões especiais é suid, sgid e sticky.

| Binário | Octal | Permissão                        |
| ------- | ----- | -------------------------------- |
| 000     | 0     | Nenhum é ativado                 |
| 001     | 1     | Ativa apenas o sticky            |
| 010     | 2     | Ativa apenas o sgid              |
| 011     | 3     | Ativa o sgid e sticky            |
| 100     | 4     | Ativa apenas o suid              |
| 101     | 5     | Ativa apenas o suid e sticky     |
| 110     | 6     | Ativa o suid e sgid              |
| 111     | 7     | Ativa todos, suid, sgid e sticky |

Agora é só colocar mais um digito na frente para atribuir uma permissão especial, `chmod 4765 arquivo.txt`, vai atribuir as permissões de suid ao arquivo.

<figure><img src="https://3652049349-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FSsFzoXz7V7mLiRRuZlST%2Fuploads%2FUtaD8VcTSy2672dZJVGx%2Fimage.png?alt=media&#x26;token=26a6a423-3204-4466-8c47-fe7cabb75bd7" alt=""><figcaption><p>chmod 4765</p></figcaption></figure>

```bash
su # vai para o modo root, precisa inserir a senha do root
vim arquivoShell.sh # vai abrir um arquivo no vim, precisa salvar depois
```

### Conteúdo extra: compilando códigos no linux

**Linguagem C/C++**

```bash
sudo apt install gcc
```

**Para compilar os códigos use:**

```bash
gcc -o main arquivo.c
./main
```

O **gcc** é um compilador da linguagem C utilizado no linux, **-o main** indica o nome do arquivo de saída, o binário gerado, que vai se chamar main, arquivo.c é o seu arquivo com os códigos em C.

O ./main indica para executar o arquivo binário main que foi gerado ao compilar arquivo.

<figure><img src="https://3652049349-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FSsFzoXz7V7mLiRRuZlST%2Fuploads%2FBnYzotaPTlw0O4sTC8rG%2Fimage.png?alt=media&#x26;token=e84e6679-ac02-43d5-a5d8-28faa689483b" alt=""><figcaption><p>gcc</p></figcaption></figure>

**Código usado**

```c
#include <stdio.h>

int main(){
        int a = 10;
        int b = 5;

        int soma = a+b;

        printf("%d\n", soma);

        return 0;
}
```

O C++ funciona da mesma forma que o gcc, mas é chamado de g++, assim:

```bash
g++ -o main arquivo.cpp # arquivo em cpp por ser c++
./main
```

**Linguagem Python**

A linguagem Python por ser interpretada e não compilada você deve apenas executar o código, sem precisar gerar um binário, mas tenha o python3 instalado.

**Instalando:**

```bash
sudo apt install python3
```

Crie um arquivo em Python pelo vim.

**Executando:**

```bash
python3 arquivo.py
```

<figure><img src="https://3652049349-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FSsFzoXz7V7mLiRRuZlST%2Fuploads%2FiM7URhwCrszhkGRN90yy%2Fimage.png?alt=media&#x26;token=4b554620-6b7c-45bf-8328-a58c7bf8d498" alt=""><figcaption><p>python3</p></figcaption></figure>

**Código usado:**

```python
a = 10
b = 5

soma = a+b

print(soma)
```

Agora sua missão é pesquisar como executar esse código em **Golang** no linux:

```go
package main

import "fmt"

func main() {
    fmt.Println("Lista de números primos até o número 100. :D")
    limite := 100

    for num := 2; num <= limite; num++ {
        soma := 0
        for i := 1; i <= num; i++ {
            if num % i == 0 {
                soma++
            }
        }
        if soma == 2 {
            fmt.Println(num)
        }
    }
}
```

Utilize esse [site](https://dev.to/jeffotoni/primeiros-passos-em-go-kfn) e compile o código acima na sua máquina linux utilizando o [vim](https://lettymoon.gitbook.io/iso200-sistemas-operacionais-ii/introducao/edicao-de-textos) ou nano.

### Bibliografia

* [Red Hat](https://www.redhat.com/sysadmin/suid-sgid-sticky-bit)
* [LPI](https://learning.lpi.org/pt/learning-materials/102-500/110/110.1/110.1_01/)
* [Guia Linux](https://guialinux.uniriotec.br/permissao-de-acesso/)
* [Mateus Müller - O carinha do Linux](https://mateusmuller.me/2019/11/06/sudo-guia-completo-do-comando-sudo-no-linux/)
* [Primeiros passos em Go - Dev](https://dev.to/jeffotoni/primeiros-passos-em-go-kfn)
* [Um tuor por Go](https://go-tour-br.appspot.com/list) - Aprenda Golang