Introduzindo um pouco mais a fundo o shell script (revisado)

removido

Shell Script é a linguagem de programação de alto nível interpretada pelo shell. Se você não entendeu o significado da frase anterior, é bem provável que este artigo possa lhe ser útil.

[ Hits: 25.351 ]

Por: Perfil removido em 31/03/2009

0 0

Denuncie Favoritos Indicar Impressora

Obviamente desconfiado

Novamente surgem termos que podem ser estranhos ao nosso vocabulário.

Sintaxe e interpretador de comandos?

Sem pretensões heróicas, este artigo pode salvar dos efeitos do obscurantismo tecnológico. Pois então, vamos a mais uma missão possível.

Cursinhu di purtugéys

O que é Sintaxe?

O significado do termo sintaxe referente às linguagens de programação é plenamente equiparável ao sentido dado ao mesmo em relação à comunicação humana. Você, se não sabia, desconfiava e muito disso. :)

Analogamente, assim como cada idioma humano escrito tem seu conjunto de regras fixas chamado costumeiramente de gramática, cada linguagem de programação tem as suas as quais chamamos de sintaxe.

Uma metamorfose ambulante chamada Shell

Se um nome diz muito sobre algo, a "limitação" dos recursos que uma linguagem de programação utiliza/manipula e/ou é destinado, ou seja, os objetivos para qual foi projetada ("core" de trabalho) são pontos altamente consideráveis.

Por exemplo, citaremos o PHP, sigla que originalmente significava Personal Home Page, e que hoje é um um acrônimo recursivo para PHP: Hypertext Preprocessor devido à evolução de seu core.

No caso Shell, a sintaxe usada por um interpretador de comandos, que é o tradutor entre o sistema operacional e o usuário, é (em minha opinião), muito levada em consideração como caracterizador do mesmo.

Expandindo a explicação sobre este conceito reafirmo que a sintaxe é um determinante dos tipos de shell; é um dos, senão, o principal fator usado para as denominar.

E a quantidade de recebimento ou não de herança de sintaxe e core entre elas e outras linguagens que originalmente não tenham sido criadas para serem utilizadas em Shells Scripts é também muito considerada.

Para ficar mais clara minha afirmação, entre os muitos tipos de shell, serão citados aqui, resumidamente por economia de espaço e manutenção de foco, mas procurando seguir uma sequência cronológica motivada pela importância histórica para os sistemas GNU/Linux atuais, apenas alguns. Ei-los;

Bourne shell (.sh)

Desenvolvido em 1977 por Stephen Bourne dos laboratórios AT&T. Por muito tempo foi o shell padrão de usuários em sistemas Unix. É a Shell padrão do super usuário (root) nas implementações *nix atuais.

Cshell (C Shell - .csh)

Como seu nome sugere, ela usa um modelo de sintaxe baseado na linguagem C. Talvez por ignorar o legado de facilidades didáticas do .sh está cada vez mais fora de uso no GNU/Linux.

Korn shell (.ksh)

Baseado no código do Cshell, foi o primeiro shell a introduzir recursos avançados.

Bash (Bourne again shell - .sh)

Atualmente é o mais utilizado interpretador para Shell em sistemas GNU/Linux. Desenvolvido para o projeto GNU é o padrão de várias distribuições Linux. É compatível com o Bourne shell, além de incorporar os melhores recursos do C shell e do Korn Shell e adicionar outros consecutivamente a cada nova versão.

Devido a estas qualidades (herança de recursos manipuláveis e de sintaxe e principalmente amplo uso no GNU/Linux) esta será a gramática (leia: tipo de shell e portanto a sintaxe) a ser estudada por nós no decorrer de nossos posts.

Além disso, Shells Scripts, especialmente os escritos para bash, possuem um core de objetivo geral limitado apenas pelos recursos que o sistema oferece (comandos) e estes mesmos sujeitos a ampliação se aliados à criatividade e conhecimento do programador pela possibilidade de adicionar novos recursos ao mesmo (novos comandos), claro, paridas de acordo com o surgimento de novas necessidades à serem solucionadas. Logo a potencialidade evolutiva de seus super poderes (tanto do sistema quanto do programador) são óbvios.

Além destas vantagens e outras que tenho como presunção posteriormente explicar em outros artigos (se Deus me permitir), Shells Scripts, oferecerem eficiência devastadora também em prototipagem.

Próxima página

Páginas do artigo

   1. Obviamente desconfiado
   2. Santa prototipagem Tux-man!
   3. Cara, cadê a tal da prototipagem?

Outros artigos deste autor

Resumo LPI 102: Tópico 107 - Tarefas Administrativas

Instalação e configuração do gdesklets no Slackware 10

Instalando Wine no Slackware 14.0

Estratégias de backup e ferramentas livres

Selecionando dados numa tabela para confecção de gráficos no oocalc

Leitura recomendada

As maravilhas do Shell Script

Introdução ao Shell Script

Personalize seu shell na entrada de seu logon

Explorando a entrada de dados com READ em Bash Shell

Como matar um processo - kill, killall, pkill e xkill

Comentários

[1] Comentário enviado por fabioarnoni em 31/03/2009 - 22:55h

Legal !!! gostei dos exemplos !! Estou estudando shell Script + python, também acho uma combinação poderosa heheheh Shell é utilidade total pra nós !

0 0

[2] Comentário enviado por removido em 01/04/2009 - 09:11h

Em breve! Como colocar este tipo de shell script em uma interface kommander... Ié?

0 0

[3] Comentário enviado por rikatz em 01/04/2009 - 18:42h

Só um comentário (nao eh critica nem sugestao, comentario mesmo :P )
Se alguém está pensando em fazer um Shell Script e embuti-lo em um código C para esconder suas instruções, como eu já vi ser feito, pensem que o compilador C trata aquelas instruções como exemplo.
Peguemos a string utilizada pelo autor, e após compilado o fonte, execute o comando "strings programa_compilado":
Um dos trechos expostos é exatamente:

clear; mysql -u root -p123456 -D testes -e ' SELECT * FROM minha_tabela' | less

Ou seja, se alguém tiver algum modo de ocultar essas strings, não é compilando o programa ;P

Sugestoes?

0 0

[4] Comentário enviado por stremer em 01/04/2009 - 18:57h

ae...
para esconder as strings de qualquer executavel (binario) é preciso encriptar o arquivo!
No caso do linux o executavel criado pelo C é um binário ELF.
Existe uma ferramente chamada Shiva que faz este trabalho. Infelizmente nunca a usei nem sei se funciona!

Quem tiver tempo de fazer um teste seria bem legal!

0 0

[5] Comentário enviado por mslomp em 01/04/2009 - 23:11h

um método braçal para esconder a string:

tomando a string do exemplo:
char comando[] = "clear; mysql -u root -p123456 -D testes -e ' SELECT * FROM minha_tabela' | less";

podemos declará-la no formato hexa, como no exemplo (reparem que adicionei o null (0x00) ao final):

==========================================
#include <stdio.h>

char comando[] = \
{0x63,0x6C,0x65,0x61,0x72,0x3B,0x20,0x6D,0x79,0x73, \
0x71,0x6C,0x20,0x2D,0x75,0x20,0x72,0x6F,0x6F,0x74, \
0x20,0x2D,0x70,0x31,0x32,0x33,0x34,0x35,0x36,0x20, \
0x2D,0x44,0x20,0x74,0x65,0x73,0x74,0x65,0x73,0x20, \
0x2D,0x65,0x20,0x27,0x20,0x53,0x45,0x4C,0x45,0x43, \
0x54,0x20,0x2A,0x20,0x46,0x52,0x4F,0x4D,0x20,0x6D, \
0x69,0x6E,0x68,0x61,0x5F,0x74,0x61,0x62,0x65,0x6C, \
0x61,0x27,0x20,0x7C,0x20,0x6C,0x65,0x73,0x73,0x00};

int main(void)
{
printf("%s\n",comando);
return 0;
}
==========================================

porém, ainda assim é possível enxergarmos a string através de um simples dump, inclusive através do comando strings citado pelo colega acima.
precisamos então que os valores de cada caractere "se percam" do universo de caracteres imprimíveis (que caracterizam uma string literal). ou seja, se nem todos estiverem contidos nesse universo, já não teremos mais uma string, e sim uma "zona".
para obter isso, tomei o menor valor - 0x20 (correspondente ao espaço) - e então peguei um valor arbitrário abaixo* desse (nesse caso, 0x19 - não é 0x20 -1!), e subtraí cada valor hexa desse índice. depois, para reverter, basta somar dinamicamente** 0x19 para cada elemento da cadeia.
* o índice deve ser inferior ao menor valor hexa da string para evitarmos valores negativos.
** para evitar que o gcc por si só otimize a coisa e reconstrua a string, o que estragaria a festa :D

resultado:

==========================================
#include <stdio.h>
#include <string.h>

char comando[] = \
{0x4A,0x53,0x4C,0x48,0x59,0x22,0x07,0x54,0x60,0x5A, \
0x58,0x53,0x07,0x14,0x5C,0x07,0x59,0x56,0x56,0x5B, \
0x07,0x14,0x57,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x07, \
0x14,0x2B,0x07,0x5B,0x4C,0x5A,0x5B,0x4C,0x5A,0x07, \
0x14,0x4C,0x07,0x0E,0x07,0x3A,0x2C,0x33,0x2C,0x2A, \
0x3B,0x07,0x11,0x07,0x2D,0x39,0x36,0x34,0x07,0x54, \
0x50,0x55,0x4F,0x48,0x46,0x5B,0x48,0x49,0x4C,0x53, \
0x48,0x0E,0x07,0x63,0x07,0x53,0x4C,0x5A,0x5A,0x00};

int main(void)
{
int i;
for(i=0;i<strlen(comando);i++)
comando[i] += 0x19;
printf("%s\n",comando);
return 0;
}
==========================================

e então, mesmo em um hex editor, a string não estará tão evidente - o que não é válido para um cracker bem treinado.
pode-se ainda utilizar algo como __attribute__ ((section ("blablabla"))) em nossa variável, a fim de evitarmos que nossa string vá para lugares óbvios no executável, como .bss e .data. isso daria um (pequeno, mas chato) trabalho extra para alguém mal intencionado.

0 0