Permissão é um conceito importantíssimo, principalmente para garantir a segurança do sistema contra acessos indevidos a arquivos importantes.
Todo arquivo do sistema pertence a um dono e a um grupo, podendo pertencer somente a um usuário ou fazer parte de um grupo de vários usuários. Estes dois parâmetros (dono do arquivo e grupo ao qual o arquivo pertence) é que determinam as permissões do arquivo, por quem o arquivo foi criado, que permissões foram dadas pelo dono, quem poderá acessá-lo e a forma de acesso de que irão dispor todos aqueles que fizerem operações com o arquivo, entre outros.
No Linux a implementação de permissões é feita para três grupos de usuários. São esses grupos:
O dono do arquivo, o grupo de trabalho ao qual o arquivo pertence e, finalmente, os demais usuários que não se encaixam nos dois grupos anteriores.
Esses dados podem ser visualizados através do comando ls -l e modificado através dos comandos chown, que muda o dono do arquivo e também o seu grupo; o comando chgrp é usado para mudar apenas o grupo do arquivo.
Como os dados são tratados como arquivos, mesmo que sejam apenas indicadores para dispositivos (por exemplo, /dev/mouse), as permissões fazem com que se possa proibir determinado usuário ou grupo de usuários de acessar algum recurso específico da máquina, como por exemplo recursos de áudio ou o acesso a um drive de disquetes. No entanto, o superusuário pode acessar qualquer arquivo ou dispositivo, independente de suas permissões.
Quando um arquivo é criado ele recebe certos valores de propriedade, como o UID do dono (normalmente o criador do arquivo), o valor de propriedade do grupo GID (geralmente o grupo a que o dono pertence quando o arquivo é criado) e outros valores de permissão de acesso derivados dos valores associados ao valor umask do dono, no momento da criação. Estes valores umask são definidos geralmente no arquivo /etc/profile com os seguintes valores:
Para o superusuário:
# umask 022
Para os demais usuários do sistema:
# umask 002
A umask funciona retirando permissões, ou seja, a permissão padrão do sistema seria 666, mas com um valor de 022, no caso do superusuário, teríamos 644 (666-022=644), o que significa que quando um arquivo for criado pelo superusuário ele vai ter suas permissões inicias em -rw-r-r–, permitindo escrita e leitura para o dono do arquivo e somente leitura ao grupo ao qual ele pertence e para os demais usuários do sistema.
Já no caso dos usuários comuns do sistema, todo arquivo iniciará sua vida com permissões 664 (666-002=664), o que significa leitura e escrita para o dono e para o grupo (no formato absoluto será -rw-rw-r–) e aos outros usuários do sistema permite apenas leitura.
Com o comando abaixo você terá informações sobre o arquivo:
$ ls -l arquivo
-rw-rw-r– 1 andre projeto 71815 2007-02-12 15:52 arquivo
O primeiro bit do campo -rw-rw-r– determina o seu tipo, pois tudo em um sistema Linux é tratado como se fosse arquivo, incluindo os diretórios, links e dispositivos do sistema.
Os principais tipos e seus significados são:
-: atributo de arquivo.
d: quando se trata de um diretório.
l: o arquivo é um link simbólico.
b: dispositivos de bloco.
c: dispositivos de caractere.
s: trata-se de um socket, atribuído para arquivos de comunicação e memória.
t: sticky bit.
O restante do campo indica as permissões para cada grupo. Os tipos de permissões para arquivos são:
r: leitura (copiar, imprimir, visualizar).
w: escrita (mover, apagar, modificar).
x: execução (programas, scripts, diretórios).
-: sem permissão.
E para os diretórios:
r: permite que você liste o conteúdo do diretório.
w: permite que você crie, altere a apague arquivos no diretório.
x: permite que você efetue buscas no diretório.
-: sem permissões para o diretório.
Estas permissões podem ser aplicadas para:
u: o dono do arquivo (user).
g: um grupo de usuários ao qual o arquivo pertence (group).
o: todos os usuários que não estão incluídos em nenhuma das duas categorias anteriores (others ou outros).
a: as permissões para todos (u+g+o).
O campo com o número 1 pode ter dois significados. Se for um arquivo, este número indica quantos hard links estão sendo apontados para ele, e neste caso, existe apenas um só: o arquivo apontando para ele mesmo. Se for um diretório, indica quantos subdiretórios existem.
A seguir, os campos andre e projeto mostram o nome do usuário e do grupo no qual o arquivo se encontra. Caso o usuário dono do arquivo ou o seu grupo não estejam adicionados ao sistema, serão visualizados os números de UID (User Identification) e GID (Group Identification) do arquivo.
Enfim, os últimos campos indicam o tamanho do arquivo, a data e o horário em que ele foi pela última vez modificado e o nome do arquivo.
O dono do arquivo tem total controle sobre todos os seus parâmetros a qualquer hora; se um usuário não for o dono do arquivo mas pertencer ao grupo, poderá acessá-lo mas não poderá restringir ou permitir acessos ao arquivo.
Se o usuário tem permissões de escrita no diretório e tentar apagar um arquivo que não tenha permissão de escrita, o sistema perguntará se ele confirma a exclusão do arquivo apesar do modo leitura. Caso tenha permissões de escrita no arquivo, o arquivo será apagado por padrão sem mostrar nenhuma mensagem de erro. Por outro lado, mesmo que se tenha permissões de escrita em um arquivo mas não se tenha permissões de escrita em um diretório, a exclusão do arquivo será negada.
Isto mostra que é levada mais em consideração a permissão de acesso do diretório do que as permissões dos arquivos e subdiretórios que ele contém. Esta característica é muitas vezes ignorada por muitas pessoas e expõe o sistema a riscos de segurança. Imagine o problema que algum usuário que não tenha permissão de escrita em um arquivo mas que a tenha no diretório pode causar em um sistema mal administrado.
As mudanças aplicadas em diretórios também podem ser feitas recursivamente, ou seja, alterando todos os arquivos e diretórios contidos no diretório. Para isso, basta usar os comandos chown e chgrp com o parâmetro -R.
Além destas permissões, existe uma permissão especial que permite que usuários possam executar arquivos de outros donos, com as permissões destes últimos. É o chamado suid bit.
Exemplo utilizando o SUID
# chmod a+s teste.sh
Com esta linha de comando, o arquivo teste.sh pode ser executado por qualquer usuário (parâmetro a – all), utilizando as permissões do dono do arquivo.
Além da identificação do usuário para a execução de um arquivo, esta identificação pode ser configurada também para um grupo de usuários (SGID).
Configurando permissões com chmod:
Um detalhe interessante deste comando é que você pode configurar permissões de duas maneiras: simbolicamente e numericamente. Primeiramente veremos o método simbólico.
Para ter uma visão mais clara da forma simbólica com o chmod, imagine que tais símbolos se encontram em duas listas, e a combinação deles gera a permissão:
Lista 1
Símbolo
u => usuário
g => grupo
O (letra o maiúscula) => outro
a => todos
Lista 2
Símbolo
r => leitura
w => gravação
x => execução
Para poder combinar os símbolos destas duas listas, usam-se os operadores:
+ (sinal de adição) => adicionar permissão
- (sinal de subtração) => remover permissão
= (sinal de igualdade) => definir permissão
Para mostrar como essa combinação é feita, vamos supor que você deseje adicionar permissão de gravação no arquivo teste.old para um usuário. Então o comando a ser digitado será:
chmod u+w teste.old
O “u” indica que a permissão será dada a um usuário, o sinal de adição (+) indica que está sendo adicionada a permissão e “w” indica que a permissão que está sendo dada é de gravação.
Caso você queira dar permissões de leitura e execução ao seu grupo, o comando será:
chmod g+rw teste.old
Agora, vamos supor que o arquivo teste.old deverá estar com todas as permissões disponíveis para o grupo. Podemos usar então:
chmod g=rwx teste.old
Usando chmod com o método numérico
Usar o chmod com valores numéricos é algo bastante prático. Em vez de usar letras como símbolos para cada permissão, usam-se números. Se determinada permissão é habilitada, atribui-se valor 1, caso contrário, atribui-se valor 0. Sendo assim, a string de permissões r-xr—– na forma numérica fica 101100000. Essa combinação de 1 e 0 é um número binário. Mas temos ainda que acrescentar a forma decimal (ou seja, números de 0 a 9). Para isso, observe a tabela abaixo:
Permissão Binário Decimal
— => 000 => 0
–x => 001 => 1
-w- => 010 => 2
-wx => 011 => 3
r– => 100 => 4
r-x => 101 => 5
rw- => 110 => 6
rwx => 111 => 7
Como o sistema binário somente trabalha com os números 0 e 1 (decimal trabalha com os números de 0 a 9, ou seja, é o sistema de numeração que utilizamos no nosso dia-a-dia), ele precisa de uma seqüência para representar os valores. Sendo assim, na tabela acima, a coluna Binário mostra como são os valores binários dos números de 0 a 7 do sistema decimal.
Para exemplificar, vamos utilizar a permissão rw-, cujo valor em binário é 110, que por sua vez, em decimal corresponde ao número 6. Então, em vez de usar rw- ou 110 para criar a permissão, simplesmente usa-se o número 6.
Repare então que com o método numérico, usamos somente um dígito para representar uma permissão, ao invés de três. Com isso a string de permissões r–r–r– pode ser representa por 444, pois r– em decimal é igual a quatro.
Observe o exemplo abaixo:
chmod 600 arquivo.txt
Acima, estão sendo dadas as permissões rw——- ao arquivo arquivo.txt, pois 6 equivale a rw- e 0 equivale a —. Como zero aparece duas vezes, forma-se então o valor 600. Faça o comando acima com um arquivo de teste e depois digite ls- l arquivo.txt e veja o retorno.
A tabela abaixo mostra as configurações de permissões mais usadas:
——— => 000
r——– => 400
r–r–r– => 444
rw——- => 600
rw-r–r– => 644
rw-rw-r– => 666
rwx—— => 700
rwxr-x— => 750
rwxr-xr-x => 755
rwxrwxrwx => 777
