haserl - Online na nuvem

PROGRAMA:

NOME

haserl - Um programa de script cgi para ambientes incorporados

SINOPSE

#! / usr / bin / haserl [--shell =especificação de caminho] [--upload-dir =dirspec] [--upload-handler =treinador]
[--upload-limit =limitar] [--aceitar tudo] [--accept-nenhum] [--silento] [--depurar]

[texto] [<% shell script%>] [texto] ...

DESCRIÇÃO

Haserl é um pequeno invólucro cgi que permite a programação cgi no estilo "PHP", mas usa um UNIX
shell semelhante ao bash ou Lua como linguagem de programação. É muito pequeno, então pode ser usado
em ambientes embarcados, ou onde algo como PHP é muito grande.

Ele combina três recursos em um pequeno motor cgi:

Ele analisa as solicitações POST e GET, colocando os elementos do formulário como pares nome = valor no
ambiente para o script CGI usar. Isso é um pouco como o Ungi embrulho.

Ele abre um shell e traduz todo o texto em instruções para impressão. Todo o texto
dentro de <% ...%>, as construções são passadas literalmente para o shell. Isso é um pouco
gosto de escrever PHP scripts.

Ele pode ser instalado opcionalmente para deixar suas permissões para o proprietário do script,
dando a ele alguns dos recursos de segurança de suexec or cgiwrapper.

OPÇÕES RESUMO

Este é um resumo das opções de linha de comando. por favor veja o OPÇÕES seção sob o
nome longo da opção para uma descrição completa.

-a --aceitar-tudo
-n --aceitar-nenhum
-d --depurar
-s, --concha
-S, --silêncio
-U, --upload-dir
-u, --upload-limite
-H, --upload-manipulador

OPÇÕES

--aceitar tudo
O programa normalmente aceita dados POST apenas quando REQUEST_METHOD é POST e
só aceita dados nos dados de URL quando REQUEST_METHOD é GET. Esta opção
permite que os dados POST e URL sejam aceitos, independentemente do REQUEST_METHOD.
Quando esta opção é definida, o REQUEST_METHOD tem precedência (por exemplo, se o método
é POST, FORM_variables são retirados de dados COOKIE, dados GET e dados POST, em
esse pedido. Se o método for GET, FORM_variables são retirados dos dados COOKIE, POST
dados e GET dados.) O padrão é não aceitar todos os métodos de entrada - apenas o
Dados do COOKIE e o REQUEST_METHOD.

--aceito-nenhum
Se fornecido, o haserl não analisará a entrada padrão como conteúdo http antes de processar
o script. Isso é útil se chamar um script haserl de outro script haserl.

--depurar
Em vez de executar o script, imprima o script que será executado. Se
a variável de ambiente 'REQUEST_METHOD' é definida, os dados são enviados com o
tipo de conteúdo simples / texto. Caso contrário, o script de shell é impresso literalmente.

--shell =especificação de caminho
Especifique um shell alternativo do tipo bash para usar. O padrão é "/ Bin / sh"

Para incluir parâmetros de shell, não use o --shell =/ Bin / sh formato. Em vez disso, use o
formato alternativo sem o "=", como em --shell "/ bin / bash --norc ". Certifique-se de
entre aspas a string de opção para proteger quaisquer caracteres especiais.

Se compilado com bibliotecas Lua, então a string "lua" é usada para usar um integrado
Lua vm. Esta string diferencia maiúsculas de minúsculas. Exemplo: --shell =tomar

Uma alternativa é "luac". Isso faz com que os analisadores haserl e lua sejam desabilitados,
e o script é considerado um trecho lua pré-compilado. Ver LUAC abaixo para mais
informações.

- silencioso
Haserl normalmente imprime uma mensagem informativa sobre condições de erro. Isto
suprime a mensagem de erro, para que o uso de haserl não seja anunciado.

--upload-dir =dirspec
O padrão é "/ Tmp". Todos os arquivos carregados são criados com um nome de arquivo temporário neste
anuário HASERL_xxx_caminho contém o nome do arquivo temporário. FORM_xxx_nome
contém o nome original do arquivo, conforme especificado pelo cliente.

--upload-handler =especificação de caminho
Quando especificado, os uploads de arquivos são tratados por este manipulador, em vez de gravados em
arquivos temporários. O pathspec completo deve ser fornecido (o PATH não é pesquisado), e
o manipulador de upload recebe um parâmetro de linha de comando: O nome do FIFO em
para o qual o arquivo de upload será enviado. Além disso, o manipulador pode receber 3
variáveis ​​ambientais: CONTENT_TYPE, NOME DO ARQUIVO e NOME. Estes refletem o MIME
cabeçalhos de disposição de conteúdo para o conteúdo. Haserl irá bifurcar o manipulador para cada
arquivo carregado e enviará o conteúdo do arquivo carregado para o FIFO especificado.
O Haserl irá então bloquear até que o manipulador termine. Este método é para especialistas
só.

--upload-limit =limitar
Permitir um arquivo codificado por MIME até limitar KB para ser carregado. O padrão é 0KB (não
uploads permitidos). Observe que a codificação mime adiciona 33% ao tamanho dos dados.

VISÃO GERAL OF OPERAÇÃO

Em geral, o servidor da web configura várias variáveis ​​de ambiente e, em seguida, usa garfo or
outro método para executar o script CGI. Se o script usa o Haserl intérprete, o
o seguinte acontece:

If Haserl é instalado suid root, então uid / gid é definido como o proprietário do script.

O ambiente é verificado para HTTP_COOKIE, que pode ter sido definido pela web
servidor. Se existir, o conteúdo analisado é colocado no ambiente local.

O ambiente é verificado para REQUEST_METHOD, que foi definido pelo servidor da web.
Com base no método de solicitação, a entrada padrão é lida e analisada. O analisado
os conteúdos são colocados no ambiente local.

O script é tokenizado, analisando Haserl blocos de código de texto bruto. O texto bruto é
convertidos em instruções "echo" e, em seguida, todos os tokens são enviados para o sub-shell.

Haserl garfos e uma sub-concha (normalmente / Bin / sh) começou.

Todos os tokens são enviados para o STDIN do sub-shell, com um saída comando.

Quando o sub-shell termina, o Haserl o intérprete realiza a limpeza final e
em seguida, termina.

CLIENTE LADO INPUT

A Haserl o intérprete decodificará os dados enviados por meio da variável de ambiente HTTP_COOKIE, e
o método GET ou POST do cliente e os armazena como variáveis ​​de ambiente que podem
ser acessado por haserl. O nome da variável segue o nome dado na fonte,
exceto que um prefixo ( FORMATO_) é anexado. Por exemplo, se o cliente enviar "foo = bar",
a variável de ambiente é FORM_foo=Barra.

Para o método HTTP_COOKIE, as variáveis ​​também são armazenadas com o prefixo ( BOLINHO_) adicionado.
Por exemplo, se HTTP_COOKIE inclui "foo = bar", a variável de ambiente é
COOKIE_foo=Barra.

Para o método GET, os dados enviados no formulário% xx são traduzidos nos caracteres que eles
representam, e as variáveis ​​também são armazenadas com o prefixo ( ENTRE_) adicionado. Por exemplo, se
QUERY_STRING inclui "foo = bar", a variável de ambiente é GET_foo=Barra.

Para o método POST, as variáveis ​​também são armazenadas com o prefixo ( POST_) adicionado. Por
exemplo, se o fluxo de postagem inclui "foo = bar", a variável de ambiente é POST_foo=Barra.

Além disso, para o método POST, se os dados forem enviados usando multipart / form-data codificação, o
os dados são decodificados automaticamente. Isso normalmente é usado quando os arquivos são carregados de uma web
cliente usando .

NOTA Quando um arquivo é carregado no servidor web, ele é armazenado no diretório de upload
diretório. FORM_variable_name = contém o nome do arquivo carregado (como
especificado pelo cliente.) HASERL_variable_path = contém o nome do arquivo em
diretório de upload que contém o conteúdo carregado. Para evitar que clientes maliciosos de
encher diretório de upload no seu servidor da web, o upload de arquivos só é permitido quando o
--limite de upload opção é usada para especificar o quão grande um arquivo pode ser carregado. Haserl
exclui automaticamente o arquivo temporário quando o script é concluído. Para manter o
arquivo, mova-o ou renomeie-o em algum lugar do script.

Observe que o nome do arquivo é armazenado em HASERL_caminho_variável Isso ocorre porque o FORM_,
As variáveis ​​GET_ e POST_ são modificáveis ​​pelo cliente, e um cliente malicioso pode
defina uma segunda variável com o nome caminho_variável =/ Etc / passwd. Versões recentes
não armazenou o pathspec em HASERL espaço para nome. Para a manter para trás
compatibilidade, que o nome of que o temporário lima is tb armazenadas in FORM_variable = e
POST_variable =. Esta is considerado inseguro e rede de apoio social não be usava.

Se o cliente enviar dados ambos pelos métodos POST e GET, então Haserl irá analisar apenas o
dados que correspondem com o REQUEST_METHOD variável definida pelo servidor web, a menos que o
aceitar tudo opção foi definida. Por exemplo, um formulário chamado via método POST, mas tendo um
URI de some.cgi? Foo = bar & otherdata = something terá os dados POST analisados, e o Foo
e outros dados variáveis ​​são ignoradas.

Se o servidor da web definir um HTTP_COOKIE variável de ambiente, os dados do cookie são analisados.
Os dados do cookie são analisados antes os dados GET ou POST, portanto, no caso de duas variáveis ​​do
mesmo nome, os dados GET ou POST substituem as informações do cookie.

Quando várias instâncias da mesma variável são enviadas de fontes diferentes, o
FORM_variable será definido de acordo com a ordem em que as variáveis ​​são processadas.
HTTP_COOKIE é sempre processado primeiro, seguido por REQUEST_METHOD. Se o aceitar tudo
opção foi definida, então HTTP_COOKIE é processado primeiro, seguido pelo método não
especificado por REQUEST_METHOD, seguido por REQUEST_METHOD. A última instância do
variável será usada para definir FORM_variable. Observe que as variáveis ​​também são separadamente
cria como COOKIE_variable, GET_variable e POST_variable. Isso permite o uso de
nomes sobrepostos de cada fonte.

Quando várias instâncias da mesma variável são enviadas da mesma fonte, apenas o último
um é salvo. Para manter todas as cópias (para seleções múltiplas, por exemplo), adicione "[]" ao final
do nome da variável. Todos os resultados serão retornados, separados por novas linhas. Por exemplo,
host = Enoch & host = Esther & host = Joshua resulta em "FORM_host = Joshua".
host [] = Enoch & host [] Esther & host [] = Josué resulta em "FORM_host = Enoch \ nEsther \ nJoshua"

IDIOMA

As seguintes estruturas de linguagem são reconhecidas por Haserl.

CORRE
<% [script de shell]%>

Qualquer coisa entre tags <%%> é enviada para o sub-shell para execução. O texto
é enviado literalmente.

INCLUIR
<% in pathspec%>

Inclua outro arquivo literalmente neste script. O arquivo é incluído quando o script
é inicialmente analisado.

AVALIAÇÃO
<% = expressão%>

imprimir a expressão do shell. Açúcar sintático para "echo expr".

COMO
<% # comentário%>

Bloco de comentários. Qualquer coisa em um bloco de comentário não é analisada. Os comentários podem ser aninhados
e pode conter outros elementos haserl.

EXEMPLOS

ATENÇÃO
Os exemplos abaixo são simplificados para mostrar como usar Haserl. Você deveria ser
familiarizado com a segurança básica de scripts da web antes de usar Haserl (ou qualquer script
idioma) em um ambiente de produção.

simples Command
#! / usr / local / bin / haserl
content-type: text / plain

<% # Este é um exemplo de script "env"%>
<% env%>

Imprime os resultados do env comando como um documento "texto / simples" do tipo MIME. Isto é
que o Haserl versão do comum printenv cgi.

laço com dinâmico saída
#! / usr / local / bin / haserl
Content-type: text / html




<% para a em Vermelho Azul Amarelo Ciano; faça%>
"> <% echo -n" $ a "%>
<% done%>




Envia um documento mime-type "text / html" para o cliente, com uma tabela html de com
elementos rotulados com a cor de fundo.

Use concha definido funções.
#! / usr / local / bin / haserl
content-type: text / html

<% # define uma função do usuário
table_element () {
echo " $ 1 "
}
%>



<% para a em Vermelho Azul Amarelo Ciano; faça%>
<% table_element $ a%>
<% done%>




O mesmo que acima, mas usa uma função shell em vez de html embutido.

Eu Referenciando CGI com a formulário
#! / usr / local / bin / haserl
content-type: text / html


Formulário de amostra
" method="GET">
<% # Faça alguma validação básica de FORM_textfield
# Para evitar ataques comuns na web
FORM_textfield = $ (echo "$ FORM_textfield" | sed "s / [^ A-Za-z0-9] // g")
%>
<tipo de entrada=nome do texto=campo de texto
Value = "<% echo -n" $ FORM_textfield "| tr az AZ%>" cols = 20>




Imprime um formulário. Se o cliente inserir texto no formulário, o CGI é recarregado (definido
by $ SCRIPT_NAME) e o campo de texto é limpo para evitar ataques da web, então o
o formulário é mostrado novamente com o texto que o usuário inseriu. O texto está em letras maiúsculas.

Upload a Envie o
#! / usr / local / bin / haserl --upload-limit = 4096 --upload-dir =/ Tmp
content-type: text / html


" method=POST enctype="multipart/form-data" >



<% if test -n "$ HASERL_uploadfile_path"; então%>

Você carregou um arquivo chamado <% echo -n $ FORM_uploadfile_name%> , e foi
. temporariamente armazenado no servidor como . O
arquivo era <% cat $ HASERL_uploadfile_path | wc -c%> bytes de comprimento.
<% rm -f $ HASERL_uploadfile_path%> Não se preocupe, o arquivo acaba de ser excluído
do servidor da web.
<% else%>
Você ainda não carregou um arquivo.
<% fi%>



Exibe um formulário que permite o upload de arquivos. Isso é feito usando o
--limite de upload e definindo a forma ctipo para multipart / form-data. Se o
o cliente envia um arquivo, algumas informações sobre o arquivo são impressas e, em seguida,
excluído. Caso contrário, o formulário informa que o cliente não carregou um arquivo.

RFC-2616 Conformidade
#! / usr / local / bin / haserl
<% echo -en "content-type: text / html \ r \ n \ r \ n"%>

...


Para cumprir totalmente com a especificação HTTP, os cabeçalhos devem ser encerrados usando
CR + LF, em vez da terminação de linha Unix LF normal apenas. A sintaxe acima pode
ser usado para produzir cabeçalhos compatíveis com RFC 2616.

MEIO AMBIENTE

Além das variáveis ​​de ambiente herdadas do servidor web, o seguinte
variáveis ​​de ambiente são sempre definidas na inicialização:

HASERLVER
Haserl versão - uma etiqueta informativa.

IDENTIFICAÇÃO DE SESSÃO
Uma etiqueta hexadecimal que é única durante a vida do CGI (é gerada quando o
cgi começa; e não muda até que outra consulta POST ou GET seja gerada.)

HASERL_ACCEPT_ALL
Se o --aceitar tudo bandeira foi definida, -1, Caso contrário 0.

HASERL_SHELL
O nome do shell haserl começou a executar comandos de sub-shell em.

HASERL_UPLOAD_DIR
O diretório haserl será usado para armazenar os arquivos carregados.

HASERL_UPLOAD_LIMIT
O número de KB que podem ser enviados do cliente para o servidor.

Essas variáveis ​​podem ser modificadas ou substituídas no script, embora as
começando com "HASERL_" são apenas informativos e não afetam o script em execução.

SEGURANÇA CARATERÍSTICAS

Há muita literatura sobre os perigos de usar shell para programar scripts CGI.
Haserl contém alguns proteções para mitigar esse risco.

Meio Ambiente Variáveis
O código para preencher as variáveis ​​de ambiente está fora do escopo do sub
Concha. Ele analisa os personagens? e &, por isso é mais difícil para um cliente fazer
ataques de "injeção". Como um exemplo, foo.cgi? a = teste; gato / Etc / passwd poderia resultar em
uma variável sendo atribuída o valor teste e então os resultados da corrida gato
/ Etc / passwd sendo enviado ao cliente. Haserl irá atribuir a variável o completo
valor: teste; gato / Etc / passwd

É seguro usar esta variável "perigosa" em scripts de shell, incluindo-a
citações; embora a validação deva ser feita em todos os campos de entrada.

Privilégio Caindo
Se instalado como um script suid, Haserl irá definir seu uid / gid para aquele do proprietário de
o script. Isso pode ser usado para ter um conjunto de scripts CGI que têm vários
privilégio. Se o Haserl binário não está instalado suid, então os scripts CGI irão
executado com o uid / gid do servidor web.

Rejeitar comando linha parâmetros dado on que o URL
Se o URL não contiver um "=" não codificado, a especificação CGI indica as opções
devem ser usados ​​como parâmetros de linha de comando para o programa. Por exemplo, de acordo
para a especificação CGI: http://192.168.0.1/test.cgi? - limite de upload% 3d2000 e foo% 3dbar
Deve definir o limite de upload para 2000 KB, além de definir "Foo = bar". Proteger
contra clientes que permitem seus próprios uploads, Haserl rejeita qualquer opção de linha de comando
além de argv [2]. Se invocado como um #! script, o interpretador é argv [0], todos
opções de linha de comando listadas no #! linha são combinados em argv [1], e o
o nome do script é argv [2].

LUA

Se compilado com suporte lua, --shell = lua iráactivar lua como a linguagem do script em vez disso
de shell bash. As variáveis ​​de ambiente (SCRIPT_NAME, SERVER_NAME, etc) são colocadas em
a tabela ENV e as variáveis ​​do formulário são colocadas na tabela FORM. Por exemplo, o
O formulário de autorreferência acima pode ser escrito assim:

#! / usr / local / bin / haserl --shell = lua
content-type: text / html


Formulário de amostra
"method =" GET ">
<% # Faça alguma validação básica de FORM_textfield
# Para evitar ataques comuns na web
FORM.textfield = string.gsub (FORM.textfield, "[^% a% d]", "")
%>
<tipo de entrada=nome do texto=campo de texto
Value = "<% io.write (string.upper (FORM.textfield))%>" cols = 20>




O operador <% = é um açúcar sintático para io.write (para sequenciar( ... )) Então, por exemplo, o
Valor = linha acima pode ser escrito: Valor = "<% = string.upper (FORM.textfield) %> " cols = 20>

scripts haserl lua podem usar a função haserl.loadfile (nome do arquivo) para processar um alvo
script como um script haserl (lua). A função retorna um tipo de "função".

Por exemplo,

barra.lsp
<% io.write ("Hello World")%>

Sua mensagem é <% = gvar%>

- Fim do arquivo de inclusão -

foo.haserl
#! / usr / local / bin / haserl --shell = lua
<% m = haserl.loadfile ("bar.lsp")
gvar = "Executar como m ()"
m ()

gvar = "Carregar e executar em uma etapa"
haserl.loadfile ("bar.lsp") ()
%>

Corrida Foo vai produzir:

Olá Mundo
Sua mensagem é Executar como m ()
- Fim do arquivo de inclusão -
Olá Mundo
Sua mensagem é carregar e executar em uma etapa
- Fim do arquivo de inclusão -

Esta função torna possível ter páginas do servidor haserl aninhadas - trechos de página
que são processados ​​pelo tokenizer haserl.

LUAC

A luac "shell" é um pedaço lua pré-compilado, portanto, edição interativa e teste de scripts
não é possível. No entanto, haserl pode ser compilado com suporte luac apenas, e isso permite
suporte lua mesmo em um ambiente de memória pequena. Todos os recursos haserl lua listados acima são
ainda disponível. (Se luac é o único shell integrado ao haserl, o haserl.loadfile é
desativado, pois o analisador haserl não é compilado.)

Aqui está um exemplo de um script trivial, convertido em um script luac cgi:

Dado o arquivo test.lua:
imprimir ("Content-Type: text / plain0)
print ("Seu UUID para esta execução é:" .. ENV.SESSIONID)

Ele pode ser compilado com luac:
luac -o teste.luac -s teste.lua

E então o cabeçalho haserl adicionado a ele:
echo '#! / usr / bin / haserl --shell = luac' | cat - test.luac> luac.cgi

Alternativamente, é possível desenvolver um site inteiro usando o shell lua padrão,
e então o próprio haserl pré-processa os scripts para o compilador luac como parte de um
processo de construção. Para fazer isso, use --shell = lua e desenvolva o site. Quando estiver pronto para construir
o ambiente de tempo de execução, adicione a linha --debug aos seus scripts lua e execute-os gerando
os resultados para arquivos de origem .lua. Por exemplo:

Dado o script haserl test.cgi:
#! / usr / bin / haserl --shell = lua --debug
Tipo de Conteúdo: text / plain

Seu UUID para esta execução é <% = ENV.SESSIONID%>

Pré-compilar, compilar e adicionar o cabeçalho haserl luac:
./test.cgi> test.lua
luac -s -o teste.luac teste.lua
echo '#! / usr / bin / haserl --shell = luac' | cat - test.luac> luac.cgi

Use haserl online usando serviços onworks.net