Por que a fonte do Bash não precisa do bit de execução?

Com o Bash's source, é possível executar um script sem um bit de execução definido. Este é um comportamento documentado e esperado, mas não é contra o uso de um bit de execução?

Eu sei, isso sourcenão cria um subshell.

Bash é um intérprete; aceita entrada e faz o que quiser. Não precisa atender ao bit executável. De fato, o Bash é portátil e pode ser executado em sistemas operacionais e sistemas de arquivos que não possuem nenhum conceito de bit executável.

O que importa com o bit executável é o kernel do sistema operacional. Quando o kernel do Linux executa exec, por exemplo, verifica se o sistema de arquivos não está montado com uma noexecopção, verifica o bit executável do arquivo do programa e aplica todos os requisitos impostos pelos módulos de segurança (como SELinux ou AppArmor).

Observe que o bit executável é um tipo de controle bastante discricionário. Em um sistema Linux x86-64, por exemplo, você pode ignorar a verificação do bit executável do kernel invocando explicitamente /lib/x86_64-linux-gnu/ld-linux-x86-64.so.2como intérprete :

cp /bin/ls /tmp/
chmod -x /tmp/ls
/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 /tmp/ls

Isso é um pouco análogo ao fornecimento do código-fonte do Bash no Bash, exceto que esse ld.soé o intérprete e o código que ele executa é o código da máquina no formato ELF.

sourceou o ponto. equivalente, mas padrão , não executa o script, mas lê os comandos do arquivo de script e, em seguida, executa-os, linha por linha, no ambiente atual do shell.

Não há nada contra o uso de bit de execução, porque o shell precisa apenas ler permissão para ler o conteúdo do arquivo.

O bit de execução é necessário apenas quando você executa o script. Aqui, o shell fará um fork()novo processo, usando a execve()função para criar uma nova imagem de processo a partir do script, que é necessário para ser um arquivo executável regular.

O bit executável (ao contrário do resto) nos arquivos não-setetid e não-setetidid não é um mecanismo de segurança. Qualquer coisa que você possa ler, poderá executar indiretamente, e o Linux permitirá que você leia indiretamente qualquer coisa que possa executar, mas não possa ler diretamente (isso deve ser suficiente para abrir um buraco no conceito de que o xid não definido (g) é um medida de segurança).

É mais uma coisa conveniente: deixe o sistema executá-lo diretamente para mim se o bit estiver definido, caso contrário, eu preciso fazê-lo indiretamente ( bash the_script;ou alguns hackers para obter a imagem de memória de um executável sem permissão de leitura ).

Você pode configurá-lo por conveniência, se você pretende tanto na fonte quanto executar seu insourcable.

Aparentemente, no entanto, muitos implementadores de bibliotecas compartilhadas compartilham seu pensamento e, consequentemente, muitos sistemas exigem que as bibliotecas compartilhadas, que são essencialmente o equivalente nativo dos insourcables do shell, sejam marcadas como executáveis ​​para serem utilizáveis. Consulte Por que as bibliotecas compartilhadas são executáveis? .

Esta é uma boa pergunta! O Unix usa o bit executável para distinguir entre programas e dados. O sistema operacional não requer o bit de execução, pois um script de origem não é passado ao sistema operacional para execução como um novo processo. Mas o shell trata um script de origem como um programa e procurará $PATHo arquivo que você deseja obter. Portanto, o próprio shell poderia ter exigido permissão de execução para arquivos de origem; mas não.

A questão deve ter surgido há muito tempo. O design do shell Bourne foi o resultado de "uma longa sequência de modificação, diálogo, discussão" entre os habitantes do Bell Labs, e muitas decisões de design foram discutidas por SR Bourne e outros ao longo dos anos. Infelizmente, meu olhar rápido não encontrou nenhuma discussão sobre o recurso de origem (em minha defesa, é difícil pesquisar no Google). O que eu encontrei é que o "." O comando não aparece nesta introdução inicial ao shell pelo próprio Bourne, mas está presente na versão mais madura da Versão 7 .

Autoridade ausente, aqui está minha própria interpretação:

1. O .comando, aka source, é na verdade a inclusão de texto (como #includeno pré-processador C) no código-fonte do script em execução ou da sessão interativa. Como tal, o arquivo incluído não pode ser "executado".

2. A filosofia do Unix sempre foi dar aos programadores corda suficiente para se enforcarem. Muitas restrições de mão-de-obra e arbitrárias simplesmente atrapalham. Recentemente, algumas distribuições se rm -r /recusaram a fazer o que você pede. (Este comando diz rmpara excluir tudo no seu computador. Não tente fazer root! Ou, melhor ainda, de jeito nenhum.) Então, talvez Bourne. apenas decidi que, quando você tenta obter um arquivo, você deve saber o que está fazendo. Isso também evita trabalho desnecessário, e os ciclos importavam muito na época.

No que diz respeito ao sistema operacional, um arquivo que contém shell script é apenas dados. Se você passa o nome desse arquivo de dados para o sourcecomando ou na linha de comando para uma chamada do shell bash, tudo o que o SO vê é uma sequência que coincide com o nome de um arquivo que contém dados.

Como o bit de execução seria relevante nesse caso?

A distinção é importante porque você pode ter um arquivo de comandos do shell que não é útil como executável, mas somente quando é originado. Para esse arquivo, você pode desativar o bit de execução e nunca será acessado, a menos que explicitamente em um comando de origem. A razão para isso é ter efeitos colaterais no shell do qual é executado. Para um exemplo específico, eu tenho um script chamado fix_path que analisa e modifica o caminho.

Caso alguém esteja interessado em mais estudos e / ou esclarecimentos: Em um shell quase compatível com POSIX implementado há pouco tempo, o funcionamento interno das funções 'exec_program ()' e 'builtin_source ()' é muito exemplar. Nessas funções, você vê exatamente qual é a diferença entre elas:

https://github.com/rsenn/shish/blob/master/src/builtin/builtin_source.c

https://github.com/rsenn/shish/blob/master/src/exec/exec_program.c

basicamente o sourcing pode ser visto como o shell redirecionando temporariamente seu descritor de arquivo interno de onde analisa o shell script (o terminal no modo interativo). por isso, é muito semelhante a outros redirecionamentos como <input_file.txte >>append_to_something.liste estes só precisa abrir e fechar arquivos.

portanto, a execução é tratada pela execve()chamada do sistema para a qual o bit de execução é obrigatório.

Lembro-me de ver alguns sistemas que permitem a execução de binários ELF / a.out, mas executando o "/lib/ld-dynamic-linker.so" e com o programa binário (sem bit exec) como primeiro argumento. Acredito que isso ocorreu em algumas máquinas DEC Alpha ou VAX (poderia ter sido o SCO Unix?)

Outro ponto de vista:

O script de origem consiste basicamente em componentes internos do shell e chamadas de programa. sourceOs componentes internos do shell ( entre eles) são partes do shell e o shell deve ser executável em primeiro lugar. Todo programa chamado (que é ELF, outro script com shebang, qualquer que seja) deve ter o bit de execução definido, caso contrário, não será executado.

Portanto, não é contra o uso de um bit de execução, porque nada sem o bit de execução será executado. A validação não ocorre para o script de origem como um todo; é executado para cada parte separadamente, mas é.