haserl - Online en la nube

PROGRAMA:

NOMBRE

haserl: un programa de secuencias de comandos CGI para entornos embebidos

SINOPSIS

#! / usr / bin / haserl [--shell =Pathpec] [--upload-dir =especificación de dirección] [--upload-handler =entrenador de animales]
[--upload-limit =límitar] [--aceptar todo] [--aceptar-ninguno] [--silencio] [--depurar]

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

DESCRIPCIÓN

Haserl es un pequeño contenedor cgi que permite la programación cgi estilo "PHP", pero usa UNIX
shell similar a bash o Lua como lenguaje de programación. Es muy pequeño, por lo que se puede utilizar.
en entornos embebidos, o donde algo como PHP es demasiado grande.

Combina tres características en un pequeño motor CGI:

Analiza las solicitudes POST y GET, colocando elementos de formulario como pares nombre = valor en el
entorno para que lo utilice el script CGI. Esto es algo como el uncgi envoltura.

Abre un caparazón y traduce todo el texto en declaraciones imprimibles. Todo el texto
dentro de <% ...%> las construcciones se pasan literalmente al shell. Esto es algo
como escribir PHP scripts.

Opcionalmente, se puede instalar para ceder sus permisos al propietario del script,
dándole algunas de las características de seguridad de suejec or envoltorio cgi.

CAMPUS RESUMEN

Este es un resumen de las opciones de la línea de comandos. Por favor vea el CAMPUS sección debajo del
nombre de opción largo para una descripción completa.

-a - aceptar-todo
-n - aceptar-ninguno
-d - depuración
-s, --cáscara
-S, - silencioso
-U, --subir-dir
-u, --límite de carga
-H, --carga-controlador

CAMPUS

--aceptar todo
El programa normalmente acepta datos POST solo cuando REQUEST_METHOD es POST y
solo acepta datos sobre los datos de la URL cuando REQUEST_METHOD es GET. Esta opción
permite que se acepten tanto datos POST como URL independientemente del REQUEST_METHOD.
Cuando se establece esta opción, REQUEST_METHOD tiene prioridad (por ejemplo, si el método
es POST, FORM_variables se toman de datos COOKIE, datos GET y datos POST, en
ese orden. Si el método es GET, FORM_variables se toman de los datos de COOKIE, POST
datos y GET.) El valor predeterminado es no aceptar todos los métodos de entrada, solo los
Datos de COOKIE y REQUEST_METHOD.

- aceptar-ninguno
Si se proporciona, haserl no analizará la entrada estándar como contenido http antes de procesar
la secuencia de comandos. Esto es útil si se llama a un script haserl desde otro script haserl.

--depurar
En lugar de ejecutar el script, imprima el script que se ejecutará. Si
se establece la variable de entorno 'REQUEST_METHOD', los datos se envían con el
tipo de contenido sin formato / texto. De lo contrario, el script de shell se imprime literalmente.

--shell =Pathpec
Especifique un shell alternativo similar a bash para usar. El valor predeterminado es "/ Bin / sh"

Para incluir parámetros de shell no use --shell =/ Bin / sh formato. En su lugar, utilice el
formato alternativo sin "=", como en --shell "/ bin / bash --norc ". Asegúrese de
cite la cadena de opciones para proteger cualquier carácter especial.

Si se compila con las bibliotecas de Lua, entonces la cadena "lua" se usa para usar un
Lua vm. Esta cadena distingue entre mayúsculas y minúsculas. Ejemplo: --shell =luna

Una alternativa es "luac". Esto hace que los analizadores haserl y lua se deshabiliten,
y se supone que el guión es un fragmento de lua precompilado. Ver LUAC a continuación para más
información.

--silencio
Haserl normalmente imprime un mensaje informativo sobre condiciones de error. Esta
suprime el mensaje de error, por lo que no se anuncia el uso de haserl.

--upload-dir =especificación de dirección
El valor predeterminado es "/ Tmp". Todos los archivos cargados se crean con un nombre de archivo temporal en este
directorio HASERL_xxx_ruta contiene el nombre del archivo temporal. FORM_xxx_nombre
contiene el nombre original del archivo, según lo especificado por el cliente.

--upload-handler =Pathpec
Cuando se especifica, las cargas de archivos son manejadas por este controlador, en lugar de escribirlas en
archivos temporales. Se debe proporcionar la especificación de ruta completa (no se busca la ruta), y
el controlador de carga recibe un parámetro de línea de comandos: el nombre del FIFO en
que se enviará el archivo de carga. Además, el manejador puede recibir 3
Variables de entorno: CONTENT_TYPE, NOMBRE DEL ARCHIVOy NOMBRE. Estos reflejan el MIME
encabezados de disposición de contenido para el contenido. Haserl bifurcará al manejador para cada
archivo cargado, y enviará el contenido del archivo de carga al FIFO especificado.
Luego, Haserl se bloqueará hasta que termine el controlador. Este método es para expertos
solamente.

--upload-limit =límitar
Permitir un archivo codificado en mime hasta límitar KB para ser subido. El valor predeterminado es 0KB (no
subidas permitidas). Tenga en cuenta que la codificación mime agrega un 33% al tamaño de los datos.

Visión general OF FUNCIONAMIENTO

En general, el servidor web configura varias variables de entorno y luego usa tenedor or
otro método para ejecutar el script CGI. Si el script usa el Haserl intérprete, el
sucede lo siguiente:

If Haserl está instalado suid root, luego uid / gid se establece en el propietario del script.

El entorno se analiza en busca de HTTP_COOKIE, que puede haber sido establecido por la web
servidor. Si existe, el contenido analizado se coloca en el entorno local.

El entorno se analiza en busca de REQUEST_METHOD, que fue configurado por el servidor web.
Según el método de solicitud, la entrada estándar se lee y analiza. El analizado
los contenidos se colocan en el entorno local.

El script está tokenizado, analizando Haserl bloques de código de texto sin formato. El texto sin formato es
convertido en declaraciones "echo", y luego todos los tokens se envían al sub-shell.

Haserl horquillas y un sub-caparazón (típicamente / Bin / sh) Está empezado.

Todos los tokens se envían al STDIN del subconjunto, con un final salida mando.

Cuando el sub-shell termina, el Haserl El intérprete realiza la limpieza final y
luego termina.

CLIENTE LADO ENTRADA

La Haserl El intérprete decodificará los datos enviados a través de la variable de entorno HTTP_COOKIE, y
el método GET o POST del cliente y almacenarlos como variables de entorno que pueden
ser accedido por haserl. El nombre de la variable sigue al nombre dado en la fuente,
excepto que un prefijo ( FORMULARIO_) se antepone. Por ejemplo, si el cliente envía "foo = bar",
la variable de entorno es FORM_foo=de caramelos.

Para el método HTTP_COOKIE, las variables también se almacenan con el prefijo ( COOKIE_) adicional.
Por ejemplo, si HTTP_COOKIE incluye "foo = bar", la variable de entorno es
COOKIE_foo=de caramelos.

Para el método GET, los datos enviados en la forma% xx se traducen a los caracteres que
representar, y las variables también se almacenan con el prefijo ( _) adicional. Por ejemplo, si
QUERY_STRING incluye "foo = bar", la variable de entorno es GET_foo=de caramelos.

Para el método POST, las variables también se almacenan con el prefijo ( PUBLICAR_) adicional. Para
Por ejemplo, si la transmisión de la publicación incluye "foo = bar", la variable de entorno es POST_foo=de caramelos.

Además, para el método POST, si los datos se envían utilizando multipart / form-data codificación, la
los datos se decodifican automáticamente. Esto se usa normalmente cuando los archivos se cargan desde una web.
cliente usando .

NOTA Cuando se carga un archivo en el servidor web, se almacena en el cargar-dir
directorio. FORM_variable_name = contiene el nombre del archivo cargado (como
especificado por el cliente.) HASERL_variable_path = contiene el nombre del archivo en
cargar-dir que contiene el contenido subido. Para evitar que los clientes malintencionados
Llenando cargar-dir en su servidor web, la carga de archivos solo se permite cuando el
--límite de carga La opción se utiliza para especificar el tamaño de un archivo que se puede cargar. Haserl
elimina automáticamente el archivo temporal cuando finaliza la secuencia de comandos. Para mantener el
archivo, muévalo o cámbiele el nombre en algún lugar del script.

Tenga en cuenta que el nombre del archivo se almacena en HASERL_ruta_variable Esto se debe a que el FORM_,
Las variables GET_ y POST_ son modificables por el cliente, y un cliente malintencionado puede
establecer una segunda variable con el nombre variable_path =/ Etc / passwd. Versiones mas antiguas
no almacenó la especificación de ruta en HASERL espacio de nombres A mantener hacia atrás
compatibilidad las nombre of las temporal presentar is también almacenados in FORM_variable = y
POST_variable =. Este is considerado inseguro y tienes no be usado.

Si el cliente envía datos ambas por los métodos POST y GET, luego Haserl analizará solo el
datos que se corresponden con el REQUEST_METHOD variable establecida por el servidor web, a menos que la
aceptar todo se ha establecido la opción. Por ejemplo, un formulario llamado a través del método POST, pero con un
URI de some.cgi? Foo = bar & otherdata = algo tendrá los datos POST analizados, y la foo
y otros datos las variables se ignoran.

Si el servidor web define un HTTP_COOKIE variable de entorno, se analizan los datos de la cookie.
Se analizan los datos de las cookies antes los datos GET o POST, por lo que en el caso de dos variables del
mismo nombre, los datos GET o POST sobrescriben la información de la cookie.

Cuando se envían varias instancias de la misma variable desde diferentes fuentes, el
FORM_variable se establecerá de acuerdo con el orden en que se procesan las variables.
HTTP_COOKIE siempre se procesa primero, seguido de REQUEST_METHOD. Si el aceptar-todo
se ha establecido la opción, luego HTTP_COOKIE se procesa primero, seguido por el método no
especificado por REQUEST_METHOD, seguido de REQUEST_METHOD. La última instancia del
La variable se utilizará para establecer FORM_variable. Tenga en cuenta que las variables también están por separado
crea como COOKIE_variable, GET_variable y POST_variable. Esto permite el uso de
nombres superpuestos de cada fuente.

Cuando se envían varias instancias de la misma variable desde la misma fuente, solo la última
uno se salva. Para conservar todas las copias (para selecciones múltiples, por ejemplo), agregue "[]" al final
del nombre de la variable. Se devolverán todos los resultados, separados por líneas nuevas. Por ejemplo,
host = Enoch & host = Esther & host = Joshua da como resultado "FORM_host = Joshua".
host [] = Enoch & host [] Esther & host [] = Joshua da como resultado "FORM_host = Enoch \ nEsther \ nJoshua"

IDIOMA

Las siguientes estructuras de lenguaje son reconocidas por Haserl.

CORRE
<% [script de shell]%>

Todo lo que esté encerrado por etiquetas <%%> se envía al sub-shell para su ejecución. El texto
se envía palabra por palabra.

INCLUIR
<% en pathpec%>

Incluya otro archivo literalmente en este script. El archivo se incluye cuando el script
se analiza inicialmente.

EVAL
<% = expresión%>

imprime la expresión de shell. Azúcar sintáctico para "echo expr".

COMENTARIO
<% # comentario%>

Bloque de comentarios. Todo lo que esté en un bloque de comentarios no se analiza. Los comentarios se pueden anidar
y puede contener otros elementos haserl.

EJEMPLOS

ADVERTENCIA
Los ejemplos siguientes están simplificados para mostrar cómo utilizar Haserl. Usted debería ser
familiarizado con la seguridad básica de secuencias de comandos web antes de usar Haserl (o cualquier secuencia de comandos
lenguaje) en un entorno de producción.

sencillos Comando
#! / usr / local / bin / haserl
tipo de contenido: texto / sin formato

<% # Este es un ejemplo de secuencia de comandos "env"%>
<% env%>

Imprime los resultados de la env comando como un documento "texto / plano" de tipo mimo. Este es
las Haserl versión del común printenv cgi.

bucle lugar de trabajo dinámico salida
#! / usr / local / bin / haserl
Tipo de contenido: texto / html




<% para a en rojo azul amarillo cian; hacer%>
"> <% echo -n" $ a "%>
<% done%>




Envía un documento "text / html" de tipo mime al cliente, con una tabla html de con
elementos etiquetados con el color de fondo.

Uso Cáscara se define funciones.
#! / usr / local / bin / haserl
tipo de contenido: texto / html

<% # define una función de usuario
table_element () {
eco " $ 1 "
}
%>



<% para a en rojo azul amarillo cian; hacer%>
<% table_element $ a%>
<% done%>




Igual que el anterior, pero usa una función de shell en lugar de html incrustado.

Propia Referenciando CGI a formulario
#! / usr / local / bin / haserl
tipo de contenido: texto / html


Formulario de muestra
" method="GET">
<% # Realice una validación básica de FORM_textfield
# Para prevenir ataques web comunes
FORM_textfield = $ (echo "$ FORM_textfield" | sed "s / [^ A-Za-z0-9] // g")
%>
<input type=text name=textfield
Valor = "<% echo -n" $ FORM_textfield "| tr az AZ%>" cols = 20>




Imprime un formulario. Si el cliente ingresa texto en el formulario, el CGI se recarga (definido
by $ SCRIPT_NAME) y el campo de texto se desinfecta para evitar ataques web, luego el
El formulario se vuelve a mostrar con el texto que ingresó el usuario. El texto está en mayúsculas.

¿Cómo subir tu libro? a Archive
#! / usr / local / bin / haserl --upload-limit = 4096 --upload-dir =/ Tmp
tipo de contenido: texto / html


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


<br/>
<% si prueba -n "$ HASERL_uploadfile_path"; entonces%>

Cargaste un archivo llamado <% echo -n $ FORM_uploadfile_name%> , y fue
. almacenado temporalmente en el servidor como . los
archivo era <% cat $ HASERL_uploadfile_path | wc -c%> bytes de longitud.
<% rm -f $ HASERL_uploadfile_path%> No se preocupe, el archivo acaba de ser eliminado.
desde el servidor web.
<% else%>
Aún no has subido un archivo.
<% fi%>



Muestra un formulario que permite la carga de archivos. Esto se logra utilizando el
--límite de carga y estableciendo la forma enctipo a multipart / form-data. Si
cliente envía un archivo, luego se imprime cierta información sobre el archivo y luego
eliminado. De lo contrario, el formulario indica que el cliente no ha subido un archivo.

RFC-2616 Conformidad
#! / usr / local / bin / haserl
<% echo -en "tipo de contenido: texto / html \ r \ n \ r \ n"%>

...


Para cumplir completamente con la especificación HTTP, los encabezados deben terminarse usando
CR + LF, en lugar de la terminación de línea normal de Unix LF solamente. La sintaxis anterior puede
utilizarse para producir encabezados que cumplan con RFC 2616.

MEDIO AMBIENTE

Además de las variables de entorno heredadas del servidor web, las siguientes
las variables de entorno siempre se definen al inicio:

HASERLVER
Haserl versión: una etiqueta informativa.

ID DE SESIÓN
Una etiqueta hexadecimal que es única durante la vida del CGI (se genera cuando el
cgi se inicia; y no cambia hasta que se genera otra consulta POST o GET).

HASERL_ACCEPT_ALL
Si --aceptar todo la bandera estaba puesta, -1, De lo contrario 0.

HASERL_SHELL
El nombre del shell en el que haserl comenzó a ejecutar comandos de sub-shell.

HASERL_UPLOAD_DIR
El directorio que haserl usará para almacenar archivos cargados.

HASERL_UPLOAD_LIMIT
El número de KB que se pueden enviar del cliente al servidor.

Estas variables se pueden modificar o sobrescribir dentro del script, aunque las
que comienzan con "HASERL_" son solo informativos y no afectan la secuencia de comandos en ejecución.

SEGURIDAD CATEGORIAS

Existe mucha literatura sobre los peligros de usar shell para programar scripts CGI.
Haserl contiene algo protecciones para mitigar este riesgo.

Entorno Variables
El código para completar las variables de entorno está fuera del alcance de la sub-
cascarón. ¿Analiza los personajes? y &, por lo que es más difícil para un cliente hacer
Ataques de "inyección". Como ejemplo, foo.cgi? a = prueba; gato / Etc / passwd podría resultar en
una variable a la que se le asigna el valor test y luego los resultados de correr gato
/ Etc / passwd siendo enviado al cliente. Haserl asignará a la variable el completo
valor: prueba; gato / Etc / passwd

Es seguro utilizar esta variable "peligrosa" en scripts de shell encerrándola en
citas; aunque la validación debe realizarse en todos los campos de entrada.

Privilegios Dejar caer
Si se instala como un script suid, Haserl establecerá su uid / gid al del propietario de
la secuencia de comandos. Esto se puede usar para tener un conjunto de scripts CGI que tienen varios
privilegio. Si el Haserl binary no está instalado suid, entonces los scripts CGI
ejecutar con el uid / gid del servidor web.

Rechazar comando línea parámetros dado on las Enlance
Si la URL no contiene un "=" no codificado, la especificación CGI indica las opciones
se utilizarán como parámetros de línea de comandos para el programa. Por ejemplo, de acuerdo
a la especificación CGI: http://192.168.0.1/test.cgi? - upload-limit% 3d2000 y foo% 3dbar
Debe establecer el límite de carga en 2000 KB además de establecer "Foo = bar". Proteger
contra los clientes que habilitan sus propias cargas, Haserl rechaza cualquier opción de la línea de comandos
más allá de argv [2]. Si se invoca como #! script, el intérprete es argv [0], todos
opciones de línea de comandos enumeradas en el #! línea se combinan en argv [1], y el
el nombre del script es argv [2].

LUNA

Si se compila con el soporte de lua, --shell = lua habilitará lua como lenguaje de script en su lugar
de bash shell. Las variables de entorno (SCRIPT_NAME, SERVER_NAME, etc.) se colocan en
la tabla ENV y las variables de formulario se colocan en la tabla FORM. Por ejemplo, el
El formulario de autorreferencia anterior se puede escribir así:

#! / usr / local / bin / haserl --shell = lua
tipo de contenido: texto / html


Formulario de muestra
"método =" OBTENER ">
<% # Realice una validación básica de FORM_textfield
# Para prevenir ataques web comunes
FORM.textfield = string.gsub (FORM.textfield, "[^% a% d]", "")
%>
<input type=text name=textfield
Valor = "<% io.write (string.upper (FORM.textfield))%>" cols = 20>




El operador <% = es azúcar sintáctico para io.escribir (Encadenar( ... )) Entonces, por ejemplo, el
Valor = la línea de arriba podría escribirse: Valor = "<% = string.upper (FORM.textfield) %> " cols = 20>

Los scripts haserl lua pueden usar la función haserl.loadfile (nombre de archivo) para procesar un objetivo
script como script haserl (lua). La función devuelve un tipo de "función".

Por ejemplo,

bar.lsp
<% io.write ("Hola mundo")%>

Su mensaje es <% = gvar%>

- Fin del archivo de inclusión -

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

gvar = "Cargar y ejecutar en un solo paso"
haserl.loadfile ("bar.lsp") ()
%>

Correr foo Producirá:

Hola Mundo
Su mensaje es Ejecutar como m ()
- Fin del archivo de inclusión -
Hola Mundo
Su mensaje es Cargar y ejecutar en un solo paso
- Fin del archivo de inclusión -

Esta función hace posible tener páginas de servidor haserl anidadas - fragmentos de página
que son procesados ​​por el tokenizador haserl.

LUAC

La luac "shell" es un fragmento de lua precompilado, por lo que la edición interactiva y la prueba de scripts
no es posible. Sin embargo, haserl solo se puede compilar con soporte luac, y esto permite
soporte lua incluso en un entorno de memoria pequeña. Todas las funciones de haserl lua enumeradas anteriormente son
aun disponible. (Si luac es el único shell integrado en haserl, haserl.loadfile es
deshabilitado, ya que el analizador haserl no está compilado).

Aquí hay un ejemplo de un script trivial, convertido en un script luac cgi:

Dado el archivo test.lua:
print ("Content-Type: text / plain0)
print ("Su UUID para esta ejecución es:" .. ENV.SESSIONID)

Se puede compilar con luac:
luac -o prueba.luac -s prueba.lua

Y luego se le agregó el encabezado haserl:
echo '#! / usr / bin / haserl --shell = luac' | gato - test.luac> luac.cgi

Alternativamente, es posible desarrollar un sitio web completo utilizando el shell lua estándar,
y luego hacer que haserl preprocese los scripts para el compilador luac como parte de un
proceso de construcción. Para hacer esto, use --shell = lua y desarrolle el sitio web. Cuando esté listo para construir
el entorno de ejecución, agregue la línea --debug a sus scripts lua y ejecútelos dando salida
los resultados a los archivos fuente .lua. Por ejemplo:

Dado el script de haserl test.cgi:
#! / usr / bin / haserl --shell = lua --debug
Content-Type: text / plain

Su UUID para esta ejecución es <% = ENV.SESSIONID%>

Precompile, compile y agregue el encabezado haserl luac:
./test.cgi> test.lua
luac -s -o prueba.luac prueba.lua
echo '#! / usr / bin / haserl --shell = luac' | gato - test.luac> luac.cgi

Use haserl en línea usando los servicios de onworks.net