haserl - En ligne dans le Cloud

PROGRAMME:

Nom

haserl - Un programme de script cgi pour les environnements embarqués

SYNOPSIS

#!/usr/bin/haserl [--shell=spéc. chemin] [--upload-dir=spec] [--upload-handler=maître]
[--upload-limit=limite] [--accepter tout] [--accepter-aucun] [--silencieux] [--déboguer]

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

DESCRIPTION

Haserl est un petit wrapper cgi qui permet la programmation cgi de style "PHP", mais utilise un UNIX
shell de type bash ou Lua comme langage de programmation. Il est très petit, il peut donc être utilisé
dans des environnements embarqués, ou là où quelque chose comme PHP est trop gros.

Il combine trois fonctionnalités dans un petit moteur cgi :

Il analyse les requêtes POST et GET, en plaçant les éléments de formulaire sous forme de paires nom=valeur dans le
environnement pour le script CGI à utiliser. C'est un peu comme le uncgi emballage.

Il ouvre un shell et traduit tout le texte en instructions imprimables. Tout le texte
dans <% ... %> les constructions sont transmises textuellement au shell. C'est un peu
comme écrire PHP scripts.

Il peut éventuellement être installé pour déposer ses autorisations au propriétaire du script,
en lui donnant certaines des caractéristiques de sécurité de suexec or cgiwrapper.

OPTIONS RÉSUMÉ

Ceci est un résumé des options de la ligne de commande. S'il vous plaît voir le OPTIONS section sous la
nom d'option long pour une description complète.

-a --accepter-tout
-n --accepter-aucun
-d --débogage
-s, --shell
-S, --silencieux
-U, --upload-dir
-u, --upload-limite
-H, --upload-handler

OPTIONS

--accepter tout
Le programme accepte normalement les données POST uniquement lorsque REQUEST_METHOD est POST et
accepte uniquement les données sur les données URL lorsque REQUEST_METHOD est GET. Cette option
permet à la fois aux données POST et URL d'être acceptées quel que soit le REQUEST_METHOD.
Lorsque cette option est définie, REQUEST_METHOD est prioritaire (par exemple si la méthode
est POST, les variables FORM sont extraites des données COOKIE, GET et POST, dans
cet ordre. Si la méthode est GET, les variables FORM sont extraites des données COOKIE, POST
data et GET data.) La valeur par défaut n'est pas d'accepter toutes les méthodes de saisie - juste la
Les données COOKIE et le REQUEST_METHOD.

--accepter-aucun
Si donné, haserl n'analysera pas l'entrée standard en tant que contenu http avant le traitement
le script. Ceci est utile si vous appelez un script haserl à partir d'un autre script haserl.

--déboguer
Au lieu d'exécuter le script, imprimez le script qui serait exécuté. Si
la variable d'environnement 'REQUEST_METHOD' est définie, les données sont envoyées avec le
type de contenu brut/texte. Sinon, le script shell est imprimé textuellement.

--shell=spéc. chemin
Spécifiez un autre shell de type bash à utiliser. La valeur par défaut est "/ Bin / sh"

Pour inclure les paramètres du shell, n'utilisez pas --shell=/ Bin / sh format. Utilisez plutôt le
format alternatif sans le "=", comme dans --shell "/ bin / bash --norc". Assurez-vous de
guillemets la chaîne d'option pour protéger les caractères spéciaux.

Si compilé avec les bibliothèques Lua, la chaîne "lua" est utilisée pour utiliser un
Lua vm. Cette chaîne est sensible à la casse. Exemple: --shell=lune

Une alternative est "luac". Cela provoque la désactivation des analyseurs syntaxiques haserl et lua,
et le script est supposé être un morceau lua précompilé. Voir LUAC ci-dessous pour plus
</br>L’Information.

--silencieux
Haserl imprime normalement un message d'information sur les conditions d'erreur. Cette
supprime le message d'erreur, de sorte que l'utilisation de haserl n'est pas annoncée.

--upload-dir=spec
La valeur par défaut est "/ Tmp". Tous les fichiers téléchargés sont créés avec un nom de fichier temporaire dans ce
annuaire HASERL_xxx_chemin contient le nom du fichier temporaire. FORM_xxx_nom
contient le nom d'origine du fichier, tel que spécifié par le client.

--upload-handler=spéc. chemin
Lorsqu'il est spécifié, les téléchargements de fichiers sont gérés par ce gestionnaire, plutôt qu'écrits dans
fichiers temporaires. Le pathspec complet doit être donné (le PATH n'est pas recherché), et
le gestionnaire de téléchargement reçoit un paramètre de ligne de commande : le nom de la FIFO sur
lequel le fichier de téléchargement sera envoyé. De plus, le manieur peut recevoir 3
Variables d'environnement: CONTENT_TYPE, NOM DE FICHIERet Nom. Ceux-ci reflètent le MIME
en-têtes content-disposition pour le contenu. Haserl va fork le gestionnaire pour chaque
fichier téléchargé, et enverra le contenu du fichier de téléchargement à la FIFO spécifiée.
Haserl bloquera alors jusqu'à ce que le gestionnaire se termine. Cette méthode est pour les experts
seulement.

--upload-limit=limite
Autoriser un fichier encodé en mime jusqu'à limite KB à télécharger. La valeur par défaut est 0KB non
téléchargements autorisés). Notez que l'encodage mime ajoute 33 % à la taille des données.

APERÇU OF FONCTIONNEMENT

En général, le serveur Web configure plusieurs variables d'environnement, puis utilise fourche or
une autre méthode pour exécuter le script CGI. Si le script utilise le Haserl interprète, le
ce qui suit arrive:

If Haserl est installé suid root, alors uid/gid est défini sur le propriétaire du script.

L'environnement est analysé pour HTTP_COOKIE, qui peut avoir été défini par le Web
serveur. S'il existe, le contenu analysé est placé dans l'environnement local.

L'environnement est analysé pour REQUEST_METHOD, qui a été défini par le serveur Web.
Sur la base de la méthode de demande, l'entrée standard est lue et analysée. L'analyse
les contenus sont placés dans l'environnement local.

Le script est tokenisé, l'analyse Haserl blocs de code à partir de texte brut. Le texte brut est
convertis en instructions "echo", puis tous les jetons sont envoyés au sous-shell.

Haserl fourches et une sous-coque (généralement / Bin / sh) a démarré.

Tous les jetons sont envoyés au STDIN du sous-shell, avec un sortie commander.

Lorsque le sous-shell se termine, le Haserl l'interprète effectue le nettoyage final et
puis se termine.

CLIENT CÔTÉ CONTRIBUTION

La Haserl l'interpréteur décodera les données envoyées via la variable d'environnement HTTP_COOKIE, et
la méthode GET ou POST du client, et les stocker en tant que variables d'environnement qui peuvent
être accessible par haserl. Le nom de la variable suit le nom donné dans la source,
sauf qu'un préfixe ( POUR FEMMES_) est préfixé. Par exemple, si le client envoie "foo=bar",
la variable d'environnement est FORM_foo=barre.

Pour la méthode HTTP_COOKIE, les variables sont également stockées avec le préfixe ( COOKIE_) ajoutée.
Par exemple, si HTTP_COOKIE inclut "foo=bar", la variable d'environnement est
COOKIE_foo=barre.

Pour la méthode GET, les données envoyées sous la forme %xx sont traduites dans les caractères qu'elles
représentent, et les variables sont également stockées avec le préfixe ( ÉCONOMISEZ_) ajoutée. Par exemple, si
QUERY_STRING inclut "foo=bar", la variable d'environnement est GET_foo=barre.

Pour la méthode POST, les variables sont également stockées avec le préfixe ( POSTEZ_) ajoutée. Pour
exemple, si le flux de publication inclut "foo=bar", la variable d'environnement est POST_foo=barre.

Aussi, pour la méthode POST, si les données sont envoyées en utilisant données multipart/formulaire encodage, le
les données sont décodées automatiquement. Ceci est généralement utilisé lorsque les fichiers sont téléchargés à partir d'un site Web.
client utilisant .

REMARQUE Lorsqu'un fichier est téléchargé sur le serveur Web, il est stocké dans le rép-upload
répertoire. FORM_nom_variable= contient le nom du fichier téléchargé (comme
spécifié par le client.) HASERL_variable_path= contient le nom du fichier dans
rép-upload qui contient le contenu téléchargé. Pour empêcher les clients malveillants de
remplir rép-upload sur votre serveur Web, les téléchargements de fichiers ne sont autorisés que lorsque le
--upload-limite L'option est utilisée pour spécifier la taille d'un fichier pouvant être téléchargé. Haserl
supprime automatiquement le fichier temporaire lorsque le script est terminé. Pour garder le
fichier, déplacez-le ou renommez-le quelque part dans le script.

Notez que le nom du fichier est stocké dans HASERL_chemin_variable C'est parce que le FORM_,
Les variables GET_ et POST_ sont modifiables par le client, et un client malveillant peut
définir une deuxième variable avec le nom chemin_variable=/ Etc / passwd. Versions précédentes
n'a pas stocké le pathspec dans HASERL espace de noms. À maintenir vers l'arrière
compatibilité, le prénom of le temporaire filet is aussi stockée in FORM_variable= ainsi que
variable_POST=. Ce is considéré le danger ainsi que devrait ne sauraient be utilisé.

Si le client envoie des données tous les deux par les méthodes POST et GET, puis Haserl analysera uniquement le
des données qui correspondent aux REQUEST_METHOD variable définie par le serveur Web, à moins que le
accepter tout l'option a été définie. Par exemple, un formulaire appelé via la méthode POST, mais ayant un
L'URI de some.cgi?foo=bar&otherdata=something aura les données POST analysées, et le foo
ainsi que autre informations les variables sont ignorées.

Si le serveur Web définit un HTTP_COOKIE variable d'environnement, les données du cookie sont analysées.
Les données des cookies sont analysées before les données GET ou POST, donc en cas de deux variables du
même nom, les données GET ou POST écrasent les informations du cookie.

Lorsque plusieurs instances de la même variable sont envoyées à partir de différentes sources, le
FORM_variable sera défini en fonction de l'ordre dans lequel les variables sont traitées.
HTTP_COOKIE est toujours traité en premier, suivi de REQUEST_METHOD. Si le tout accepter
option a été définie, puis HTTP_COOKIE est traité en premier, suivi de la méthode non
spécifié par REQUEST_METHOD, suivi de REQUEST_METHOD. La dernière instance de la
variable sera utilisée pour définir FORM_variable. Notez que les variables sont également séparément
crée comme COOKIE_variable, GET_variable et POST_variable. Cela permet l'utilisation de
noms qui se chevauchent de chaque source.

Lorsque plusieurs instances de la même variable sont envoyées depuis la même source, seule la dernière
on est sauvé. Pour conserver toutes les copies (pour les sélections multiples, par exemple), ajoutez "[]" à la fin
du nom de la variable. Tous les résultats seront renvoyés, séparés par des sauts de ligne. Par exemple,
host=Enoch&host=Esther&host=Joshua donne "FORM_host=Joshua".
host[]=Enoch&host[]Esther&host[]=Joshua donne "FORM_host=Enoch\nEsther\nJoshua"

LANGUAGE

Les structures linguistiques suivantes sont reconnues par Haserl.

COURT
<% [script shell] %>

Tout ce qui est entouré par les balises <% %> est envoyé au sous-shell pour exécution. Le texte
est envoyé textuellement.

COMPRENDRE
<%in pathspec %>

Incluez un autre fichier textuellement dans ce script. Le fichier est inclus lorsque le script
est initialement analysé.

ÉVALUER
<%=expression %>

imprimer l'expression du shell. Sucre syntaxique pour "echo expr".

COMMENTAIRE
<%# commentaire %>

Bloc de commentaires. Tout ce qui se trouve dans un bloc de commentaires n'est pas analysé. Les commentaires peuvent être imbriqués
et peut contenir d'autres éléments haserl.

EXEMPLES

ATTENTION
Les exemples ci-dessous sont simplifiés pour montrer comment utiliser Haserl. Tu devrais être
familiarisé avec la sécurité de base des scripts Web avant d'utiliser Haserl (ou tout script
langue) dans un environnement de production.

étapes Command
#!/usr/local/bin/haserl
type de contenu : text/plain

<%# Ceci est un exemple de script "env" %>
<% env%>

Imprime les résultats de la env commande en tant que document "text/plain" de type mime. C'est
le Haserl version du commun printenv cgi.

Looping avec Dynamic sortie
#!/usr/local/bin/haserl
Type de contenu: text / html




<% pour a en Rouge Bleu Jaune Cyan ; faire %>
"><% echo -n "$a" %>
<% terminé %>




Envoie un document "text/html" de type mime au client, avec une table html de with
éléments étiquetés avec la couleur d'arrière-plan.

Utilisez coquillage défini fonctions.
#!/usr/local/bin/haserl
type de contenu : texte/html

<% # définit une fonction utilisateur
élément_table() {
écho " 1 $ "
}
%>



<% pour a en Rouge Bleu Jaune Cyan ; faire %>
<% table_element $a %>
<% terminé %>




Identique à ci-dessus, mais utilise une fonction shell au lieu du code HTML intégré.

Soi Référencement CGI avec a formulaire
#!/usr/local/bin/haserl
type de contenu : texte/html


Exemple de formulaire
" method="GET">
<% # Effectuez une validation de base de FORM_textfield
# Pour empêcher les attaques Web courantes
FORM_textfield=$( echo "$FORM_textfield" | sed "s/[^A-Za-z0-9 ]//g" )
%>
<type d'entrée=nom du texte=champ de texte
Value="<% echo -n "$FORM_textfield" | tr az AZ %>" cols=20>




Imprime un formulaire. Si le client saisit du texte dans le formulaire, le CGI est rechargé (défini
by $SCRIPT_NAME) et le champ de texte est nettoyé pour empêcher les attaques Web, puis le
le formulaire est réaffiché avec le texte saisi par l'utilisateur. Le texte est en majuscule.

Téléchargement a Déposez votre dernière attestation
#!/usr/local/bin/haserl --upload-limit=4096 --upload-dir=/ Tmp
type de contenu : texte/html


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


<br>
<% if test -n "$HASERL_uploadfile_path" ; puis %>

Vous avez téléchargé un fichier nommé <% echo -n $FORM_uploadfile_name %> , et il était
. temporairement stocké sur le serveur en tant que . Les
fichier était <% cat $HASERL_uploadfile_path | wc -c %> octets de long.
<% rm -f $HASERL_uploadfile_path %> Ne vous inquiétez pas, le fichier vient d'être supprimé
depuis le serveur Web.
<% autre %>
Vous n'avez pas encore téléchargé de fichier.
<% fi %>



Affiche un formulaire qui permet le téléchargement de fichiers. Ceci est accompli en utilisant le
--upload-limite et en définissant la forme enctype à multipart/form-data. Si la
client envoie un fichier, puis des informations concernant le fichier sont imprimées, puis
supprimé. Sinon, le formulaire indique que le client n'a pas téléchargé de fichier.

RFC-2616 Conformité
#!/usr/local/bin/haserl
<% echo -en "type de contenu : texte/html\r\n\r\n" %>




Pour se conformer pleinement à la spécification HTTP, les en-têtes doivent être terminés à l'aide de
CR+LF, plutôt que la terminaison de ligne Unix LF normale uniquement. La syntaxe ci-dessus peut
être utilisé pour produire des en-têtes conformes à la RFC 2616.

ENVIRONNEMENT

En plus des variables d'environnement héritées du serveur Web, les éléments suivants
les variables d'environnement sont toujours définies au démarrage :

HASERLVER
Haserl version - une balise d'information.

ID DE SESSION
Une balise hexadécimale unique pour la vie du CGI (elle est générée lorsque le
cgi démarre ; et ne change pas jusqu'à ce qu'une autre requête POST ou GET soit générée.)

HASERL_ACCEPT_ALL
Si la --accepter tout le drapeau a été placé, -1, Autrement 0.

HASERL_SHELL
Le nom du shell haserl a commencé à exécuter des commandes de sous-shell.

HASERL_UPLOAD_DIR
Le répertoire haserl utilisera pour stocker les fichiers téléchargés.

HASERL_UPLOAD_LIMIT
Le nombre de Ko autorisés à être envoyés du client au serveur.

Ces variables peuvent être modifiées ou écrasées dans le script, bien que celles
commençant par "HASERL_" ne sont qu'informatifs et n'affectent pas le script en cours d'exécution.

SÉCURITÉ CARACTERISTIQUES

Il existe de nombreuses publications concernant les dangers de l'utilisation du shell pour programmer des scripts CGI.
Haserl contient quelques protections pour atténuer ce risque.

Environment Variables
Le code pour remplir les variables d'environnement est en dehors de la portée de la sous-
coquille. Il analyse sur les caractères ? et &, il est donc plus difficile pour un client de faire
attaques « par injection ». Par exemple, foo.cgi?a=test;chat / Etc / passwd pourrait entraîner
une variable se voit attribuer la valeur tester puis les résultats de la course cat
/ Etc / passwd envoyé au client. Haserl affectera à la variable la totalité
valeur: test; chat / Etc / passwd

Il est sûr d'utiliser cette variable "dangereuse" dans les scripts shell en l'enfermant dans
devis; bien que la validation doive être effectuée sur tous les champs de saisie.

Privilège Goutte
S'il est installé en tant que script suid, Haserl définira son uid/gid sur celui du propriétaire de
le script. Cela peut être utilisé pour avoir un ensemble de scripts CGI qui ont divers
privilège. Si la Haserl le binaire n'est pas installé suid, alors les scripts CGI seront
exécuter avec l'uid/gid du serveur Web.

Rejeter commander en ligne paramètres donné on le URL
Si l'URL ne contient pas de "=" non codé, la spécification CGI indique les options
doivent être utilisés comme paramètres de ligne de commande pour le programme. Par exemple, selon
à la spécification CGI : http://192.168.0.1/test.cgi?--upload-limit%3d2000&foo%3dbar
Devrait définir la limite de téléchargement à 2000 Ko en plus de définir "Foo=bar". Protéger
contre les clients qui autorisent leurs propres téléchargements, Haserl rejette toutes les options de ligne de commande
au-delà de argv[2]. Si invoqué en tant que # ! script, l'interpréteur est argv[0], tout
les options de ligne de commande répertoriées dans le #! sont combinés dans argv[1], et les
le nom du script est argv[2].

MOON

Si compilé avec le support lua, --shell=lua activera lua comme langage de script à la place
de bash shell. Les variables d'environnement (SCRIPT_NAME, SERVER_NAME, etc.) sont placées dans
la table ENV, et les variables de formulaire sont placées dans la table FORM. Par exemple, le
Le formulaire d'auto-référencement ci-dessus peut s'écrire comme ceci :

#!/usr/local/bin/haserl --shell=lua
type de contenu : texte/html


Exemple de formulaire
" method="GET">
<% # Effectuez une validation de base de FORM_textfield
# Pour empêcher les attaques Web courantes
FORM.textfield=string.gsub(FORM.textfield, "[^%a%d]", "")
%>
<type d'entrée=nom du texte=champ de texte
Value="<% io.write (string.upper(FORM.textfield)) %>" cols=20>




L'opérateur <%= est un sucre syntaxique pour io.écrire (àchaîne( )) Ainsi, par exemple, le
Valeur = la ligne ci-dessus pourrait être écrite : Valeur="<%= chaîne.upper(FORM.textfield) %>" cols=20>

les scripts haserl lua peuvent utiliser la fonction haserl.loadfile(nom de fichier) traiter une cible
script en tant que script haserl (lua). La fonction renvoie un type de "fonction".

Par exemple,

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

Votre message est <%= gvar %>

-- Fin du fichier d'inclusion --

foo.haserl
#!/usr/local/bin/haserl --shell=lua
<% m = haserl.loadfile("bar.lsp")
gvar = "Exécuter en tant que m()"
m ()

gvar = "Charger et exécuter en une seule étape"
haserl.loadfile("bar.lsp")()
%>

Fonctionnement foo produira:

Bonjour tout le monde
Votre message est Exécuter en tant que m()
-- Fin du fichier d'inclusion --
Bonjour tout le monde
Votre message est Charger et exécuter en une seule étape
-- Fin du fichier d'inclusion --

Cette fonction permet d'avoir des pages serveur haserl imbriquées - extraits de page
qui sont traités par le tokenizer haserl.

LUAC

La luac "shell" est un morceau lua précompilé, donc édition et test interactifs des scripts
n'est pas possible. Cependant, haserl ne peut être compilé qu'avec le support luac, ce qui permet
prise en charge de lua même dans un environnement de petite mémoire. Toutes les fonctionnalités de haserl lua énumérées ci-dessus sont
toujours disponible. (Si luac est le seul shell intégré à haserl, le fichier haserl.load est
désactivé, car l'analyseur haserl n'est pas compilé.)

Voici un exemple de script trivial, converti en un script luac cgi :

Étant donné le fichier test.lua :
print ("Content-Type: text/plain0)
print ("Votre UUID pour cette exécution est : " .. ENV.SESSIONID)

Il peut être compilé avec luac :
luac -o test.luac -s test.lua

Et puis l'en-tête haserl y a été ajouté :
echo '#!/usr/bin/haserl --shell=luac' | chat - test.luac >luac.cgi

Alternativement, il est possible de développer un site Web entier en utilisant le shell lua standard,
et puis haserl lui-même prétraite les scripts pour le compilateur luac dans le cadre d'un
processus de construction. Pour ce faire, utilisez --shell=lua et développez le site Web. Lorsque vous êtes prêt à construire
l'environnement d'exécution, ajoutez la ligne --debug à vos scripts lua et exécutez-les en sortie
les résultats dans les fichiers source .lua. Par exemple:

Étant donné le script haserl test.cgi :
#!/usr/bin/haserl --shell=lua --debug
Content-Type: text / plain

Votre UUID pour cette exécution est <%= ENV.SESSIONID %>

Précompilez, compilez et ajoutez l'en-tête haserl luac :
./test.cgi > test.lua
luac -s -o test.luac test.lua
echo '#!/usr/bin/haserl --shell=luac' | chat - test.luac >luac.cgi

Utiliser haserl en ligne en utilisant les services onworks.net