haserl - Online nel Cloud

PROGRAMMA:

NOME

haserl - Un programma di scripting cgi per ambienti embedded

SINOSSI

#!/usr/bin/haserl [--shell=pathpec] [--carica-dir=dirspec] [--gestore-caricamento=Handler]
[--limite di caricamento=limitare] [--accetta-tutto] [--accetta-none] [--silenzioso] [--debug]

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

DESCRIZIONE

Haserl è un piccolo wrapper cgi che consente la programmazione cgi in stile "PHP", ma utilizza un UNIX
Shell tipo bash o Lua come linguaggio di programmazione. È molto piccolo, quindi può essere utilizzato
in ambienti embedded o dove qualcosa come PHP è troppo grande.

Combina tre caratteristiche in un piccolo motore CGI:

Analizza le richieste POST e GET, inserendo gli elementi del modulo come coppie nome=valore nel
ambiente per lo script CGI da utilizzare. Questo è un po' come il uncgi involucro.

Apre una shell e traduce tutto il testo in istruzioni stampabili. Tutto il testo
all'interno di <% ... %> i costrutti vengono passati letteralmente alla shell. Questo è in qualche modo
come scrivere PHP script.

Può essere installato facoltativamente per rilasciare i permessi al proprietario dello script,
conferendogli alcune delle caratteristiche di sicurezza di suexec or cgiwrapper.

VERSIONI SOMMARIO

Questo è un riepilogo delle opzioni della riga di comando. Si prega di vedere VERSIONI sezione sotto il
nome lungo dell'opzione per una descrizione completa.

-a --accetta-tutto
-n --accept-none
-d --debug
-s, --shell
-S, --silenzioso
-U, --carica-dir
-u, --limite-di-caricamento
-H, --gestore-caricamento

VERSIONI

--accettare tutti
Il programma normalmente accetta dati POST solo quando REQUEST_METHOD è POST e
accetta solo dati sui dati URL quando REQUEST_METHOD è GET. Questa opzione
consente di accettare sia i dati POST che URL indipendentemente da REQUEST_METHOD.
Quando questa opzione è impostata, REQUEST_METHOD ha la precedenza (ad esempio se il metodo
è POST, le variabili FORM sono prese dai dati COOKIE, dai dati GET e dai dati POST, in
quell'ordine. Se il metodo è GET, le variabili FORM vengono prese dai dati COOKIE, POST
dati e GET dati.) L'impostazione predefinita non accetta tutti i metodi di input, ma solo quelli
Dati COOKIE e REQUEST_METHOD.

--accetta-nessuno
Se specificato, haserl non analizzerà l'input standard come contenuto http prima dell'elaborazione
lo script. Questo è utile se si chiama uno script haserl da un altro script haserl.

- debug
Invece di eseguire lo script, stampare lo script che verrebbe eseguito. Se
la variabile d'ambiente 'REQUEST_METHOD' è impostata, i dati vengono inviati con
tipo di contenuto semplice/testo. In caso contrario, lo script della shell viene stampato alla lettera.

--conchiglia=pathpec
Specificare una shell alternativa simile a bash da utilizzare. Il valore predefinito è "/bin/sh"

Per includere i parametri della shell non usare --shell=/bin/sh formato. Invece, usa il
formato alternativo senza "=", come in --shell "/ bin / bash --norc". Assicurati di
racchiudere tra virgolette la stringa dell'opzione per proteggere eventuali caratteri speciali.

Se compilato con le librerie Lua, la stringa "lua" viene utilizzata per utilizzare un integrato
VM Lua. Questa stringa è sensibile alle maiuscole e alle minuscole. Esempio: --conchiglia=luna

Un'alternativa è "luac". Questo fa sì che i parser haserl e lua vengano disabilitati,
e si presume che lo script sia un frammento lua precompilato. Vedi LUAC sotto per saperne di più
informazioni.

--silenzioso
Haserl normalmente stampa un messaggio informativo in caso di condizioni di errore. Questo
sopprime il messaggio di errore, in modo che l'uso di haserl non venga pubblicizzato.

--carica-dir=dirspec
Il valore predefinito è "/ Tmp". Tutti i file caricati vengono creati con un nome file temporaneo in questo
elenco HASERL_xxx_path contiene il nome del file temporaneo. FORM_xxx_nome
contiene il nome originale del file, come specificato dal client.

--gestore-caricamento=pathpec
Se specificato, i caricamenti dei file vengono gestiti da questo gestore, anziché essere scritti su
file temporanei. È necessario fornire il pathspec completo (il PATH non viene cercato) e
al gestore di caricamento viene fornito un parametro della riga di comando: il nome del FIFO su
a cui verrà inviato il file caricato. Inoltre, il gestore può ricevere 3
variabili ambientali: TIPO DI CONTENUTO, NOME DEL FILEe NOMEQuesti riflettono il MIME
intestazioni content-disposition per il contenuto. Haserl biforcherà il gestore per ogni
file caricato e invierà il contenuto del file caricato al FIFO specificato.
Haserl si bloccherà quindi fino alla chiusura del gestore. Questo metodo è per esperti
solo.

--limite-di-caricamento=limitare
Consenti un file codificato MIME fino a limitare KB da caricare. L'impostazione predefinita è 0KB (non
caricamenti consentiti). Si noti che la codifica MIME aggiunge il 33% alla dimensione dei dati.

OVERVIEW OF FUNZIONAMENTO

In generale, il server web imposta diverse variabili di ambiente e quindi utilizza forcella or
un altro metodo per eseguire lo script CGI. Se lo script utilizza haserl interprete, il
succede quanto segue:

If haserl è installato suid root, quindi uid/gid viene impostato sul proprietario dello script.

L'ambiente viene scansionato per HTTP_COOKIE, che potrebbe essere stato impostato dal web
server. Se esiste, i contenuti analizzati vengono inseriti nell'ambiente locale.

L'ambiente viene scansionato per REQUEST_METHOD, che è stato impostato dal server web.
In base al metodo di richiesta, l'input standard viene letto e analizzato. L'input analizzato
i contenuti vengono inseriti nell'ambiente locale.

Lo script è tokenizzato, analizzando haserl blocchi di codice da testo grezzo. Il testo grezzo è
convertiti in istruzioni "echo", quindi tutti i token vengono inviati alla subshell.

haserl forchette e un sotto-guscio (tipicamente /bin/sh) è avviato.

Tutti i token vengono inviati allo STDIN della subshell, con un finale exit comando.

Quando la sotto-shell termina, il haserl l'interprete esegue la pulizia finale e
poi termina.

CLIENTE LATO INGRESSO

. haserl l'interprete decodificherà i dati inviati tramite la variabile di ambiente HTTP_COOKIE e
il metodo GET o POST dal client e memorizzarli come variabili di ambiente che possono
accessibile tramite haserl. Il nome della variabile segue il nome fornito nella sorgente,
eccetto che un prefisso ( ._) è anteposto. Ad esempio, se il client invia "foo=bar",
la variabile d'ambiente è FORM_foo=bar.

Per il metodo HTTP_COOKIE, le variabili vengono memorizzate anche con il prefisso ( COOKIE_) aggiunto.
Ad esempio, se HTTP_COOKIE include "foo=bar", la variabile d'ambiente è
COOKIE_foo=bar.

Per il metodo GET, i dati inviati nel formato %xx vengono tradotti nei caratteri che
rappresentano e le variabili vengono memorizzate anche con il prefisso ( GET_) aggiunto. Ad esempio, se
QUERY_STRING include "foo=bar", la variabile d'ambiente è GET_foo=bar.

Per il metodo POST, le variabili vengono memorizzate anche con il prefisso ( POST_) aggiunto. Per
ad esempio, se il flusso di post include "foo=bar", la variabile di ambiente è POST_foo=bar.

Inoltre, per il metodo POST, se i dati vengono inviati utilizzando multipart/forma-dati codifica, il
i dati vengono decodificati automaticamente. Questo è in genere utilizzato quando i file vengono caricati da un sito web
cliente che utilizza .

NOTA Quando un file viene caricato sul server web, viene memorizzato nel caricamento-dir
directory. FORM_nome_variabile= contiene il nome del file caricato (come
specificato dal cliente.) HASERL_variable_path= contiene il nome del file in
caricamento-dir che contiene il contenuto caricato. Per impedire ai client malintenzionati di
riempiendo caricamento-dir sul tuo server web, i caricamenti di file sono consentiti solo quando
--limite di caricamento l'opzione viene utilizzata per specificare la dimensione massima di un file caricato. Haserl
elimina automaticamente il file temporaneo al termine dello script. Per mantenere il
file, spostarlo o rinominarlo in un punto qualsiasi dello script.

Si noti che il nome del file è memorizzato in HASERL_variabile_percorso Questo perché il FORM_,
Le variabili GET_ e POST_ sono modificabili dal client e un client malintenzionato può
imposta una seconda variabile con il nome variabile_percorso=/etc/passwdVersioni precedenti
non ha memorizzato il pathspec in HASERL spazio dei nomi. A mantenere arretrato
compatibilità, , il Nome of , il temporaneo filetto is anche memorizzati in FORM_variabile= e
POST_variabile=. Questo is considerato pericoloso e dovrebbero non è un be Usato.

Se il client invia dati entrambi tramite i metodi POST e GET, quindi haserl analizzerà solo il
dati che corrispondono a REQUEST_METHOD variabile impostata dal server web, a meno che il
accettare tutto è stata impostata l'opzione. Ad esempio, un modulo chiamato tramite metodo POST, ma con un
L'URI di some.cgi?foo=bar&otherdata=something avrà i dati POST analizzati e foo
e altri dati le variabili vengono ignorate.

Se il server web definisce un HTTP_COOKIE variabile d'ambiente, i dati del cookie vengono analizzati.
I dati dei cookie vengono analizzati prima i dati GET o POST, quindi nel caso di due variabili di
stesso nome, i dati GET o POST sovrascrivono le informazioni del cookie.

Quando più istanze della stessa variabile vengono inviate da fonti diverse,
FORM_variable verrà impostato in base all'ordine in cui vengono elaborate le variabili.
HTTP_COOKIE viene sempre elaborato per primo, seguito da REQUEST_METHOD. Se l'opzione accept-all
è stata impostata l'opzione, quindi HTTP_COOKIE viene elaborato per primo, seguito dal metodo non
specificato da REQUEST_METHOD, seguito da REQUEST_METHOD. L'ultima istanza di
La variabile verrà utilizzata per impostare FORM_variabile. Nota che le variabili sono anche separate
crea come COOKIE_variable, GET_variable e POST_variable. Questo consente l'uso di
nomi sovrapposti da ciascuna fonte.

Quando più istanze della stessa variabile vengono inviate dalla stessa origine, solo l'ultima
uno è salvato. Per conservare tutte le copie (per selezioni multiple, ad esempio), aggiungere "[]" alla fine
del nome della variabile. Tutti i risultati verranno restituiti, separati da nuove righe. Ad esempio,
host=Enoch&host=Esther&host=Joshua risulta in "FORM_host=Joshua".
host[]=Enoch&host[]Esther&host[]=Joshua risulta in "FORM_host=Enoch\nEsther\nJoshua"

LINGUA

Le seguenti strutture linguistiche sono riconosciute da haserl.

CORRERE
<% [script di shell] %>

Tutto ciò che è racchiuso tra i tag <% %> viene inviato alla subshell per l'esecuzione. Il testo
viene inviato letteralmente.

INCLUDERE
<%in pathspec %>

Includi un altro file alla lettera in questo script. Il file viene incluso quando lo script
viene inizialmente analizzato.

VAL
<%= espressione %>

stampa l'espressione della shell. Zucchero sintattico per "echo expr".

COMMENTO
<%# commento %>

Blocco di commenti. Nessun elemento in un blocco di commenti viene analizzato. I commenti possono essere annidati.
e può contenere altri elementi haserl.

ESEMPI

AVVERTIMENTO
Gli esempi seguenti sono semplificati per mostrare come utilizzare haserl. Tu dovresti essere
familiarità con la sicurezza di base degli script web prima di utilizzare haserl (o qualsiasi scripting
linguaggio) in un ambiente di produzione.

Semplice Comando
#!/usr/local/bin/haserl
tipo di contenuto: testo/semplice

<%# Questo è un esempio di script "env" %>
<% env %>

Stampa i risultati del ENV comando come documento di tipo MIME "text/plain". Questo è
, il haserl versione del comune printenv computer grafica.

cappio con dinamico produzione
#!/usr/local/bin/haserl
Tipo di contenuto: testo/html




<% per a in Rosso Blu Giallo Ciano; fai %>
"><% echo -n "$a" %>
<% fatto %>




Invia al client un documento di tipo mime "text/html", con una tabella html di
elementi etichettati con il colore di sfondo.

Usa il Conchiglia definito funzioni.
#!/usr/local/bin/haserl
tipo di contenuto: testo/html

<% # definisce una funzione utente
elemento_tabella() {
eco " 1 dollaro "
}
%>



<% per a in Rosso Blu Giallo Ciano; fai %>
<% elemento_tabella $a %>
<% fatto %>




Come sopra, ma utilizza una funzione shell invece dell'HTML incorporato.

Auto Riferimenti CGI con a modulo
#!/usr/local/bin/haserl
tipo di contenuto: testo/html


Modulo di esempio
" method="GET">
<% # Esegui una convalida di base di FORM_textfield
# Per prevenire i comuni attacchi web
FORM_campo_testo=$( echo "$FORM_campo_testo" | sed "s/[^A-Za-z0-9 ]//g" )
%>
<input type=text name=textfield
Valore="<% echo -n "$FORM_textfield" | tr az AZ %>" cols=20>




Stampa un modulo. Se il client immette del testo nel modulo, il CGI viene ricaricato (definito
by $SCRIPT_NAME) e il campo di testo viene sanificato per prevenire attacchi web, quindi il
Il modulo viene visualizzato nuovamente con il testo inserito dall'utente. Il testo è in maiuscolo.

Caricamento a Compila il
#!/usr/local/bin/haserl --upload-limit=4096 --upload-dir=/ Tmp
tipo di contenuto: testo/html


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



<% if test -n "$HASERL_uploadfile_path"; then %>

Hai caricato un file denominato <% echo -n $FORM_uploadfile_name %> , ed è stato
temporaneamente memorizzato sul server come . Il
il file era lungo <% cat $HASERL_uploadfile_path | wc -c %> byte.
<% rm -f $HASERL_uploadfile_path %> Non preoccuparti, il file è stato appena eliminato
dal server web.
<% altro %>
Non hai ancora caricato alcun file.
<% fi %>



Visualizza un modulo che consente il caricamento di file. Ciò si ottiene utilizzando
--limite di caricamento e impostando il modulo entipo a multipart/form-data. Se l'
il client invia un file, quindi vengono stampate alcune informazioni relative al file e quindi
eliminato. In caso contrario, il modulo indica che il cliente non ha caricato alcun file.

RFC-2616 conformità
#!/usr/local/bin/haserl
<% echo -en "tipo di contenuto: testo/html\r\n\r\n" %>

...


Per essere pienamente conformi alle specifiche HTTP, le intestazioni devono essere terminate utilizzando
CR+LF, anziché la normale terminazione di linea LF di Unix. La sintassi sopra può
essere utilizzato per produrre intestazioni conformi a RFC 2616.

AMBIENTE

Oltre alle variabili di ambiente ereditate dal server web, quanto segue
le variabili d'ambiente sono sempre definite all'avvio:

HASERLVER
haserl versione - un tag informativo.

SESSIONID
Un tag esadecimale univoco per tutta la durata del CGI (viene generato quando il
cgi si avvia e non cambia finché non viene generata un'altra query POST o GET.)

HASERL_ACCETTA_TUTTO
Se l' --accettare tutti la bandiera è stata impostata, -1, Altrimenti 0.

HASERL_SHELL
Il nome della shell haserl ha iniziato a eseguire comandi sub-shell.

HASERL_UPLOAD_DIR
La directory che haserl utilizzerà per memorizzare i file caricati.

HASERL_UPLOAD_LIMIT
Numero di KB che possono essere inviati dal client al server.

Queste variabili possono essere modificate o sovrascritte all'interno dello script, anche se quelle
che iniziano con "HASERL_" sono solo informativi e non influiscono sullo script in esecuzione.

SICUREZZA CARATTERISTICHE

Esiste molta letteratura sui pericoli dell'uso della shell per programmare script CGI.
haserl contiene alcuni protezioni per mitigare questo rischio.

Ambiente Variabili
Il codice per popolare le variabili di ambiente è al di fuori dell'ambito del sotto-
shell. Analizza i caratteri ? e &, quindi è più difficile per un client farlo
attacchi "iniezione". Ad esempio, foo.cgi?a=test;cat /etc/passwd potrebbe comportare
una variabile a cui viene assegnato il valore test e poi i risultati della corsa gatto
/etc/passwd inviato al cliente. Haserl assegnerà alla variabile il completo
valore: prova;gatto /etc/passwd

È sicuro utilizzare questa variabile "pericolosa" negli script shell racchiudendola tra
virgolette; sebbene la convalida debba essere effettuata su tutti i campi di input.

Privilegio lancio
Se installato come script suid, haserl imposterà il suo uid/gid a quello del proprietario di
lo script. Questo può essere utilizzato per avere un set di script CGI che hanno vari
privilegio. Se il haserl il binario non è installato suid, quindi gli script CGI saranno
eseguito con l'uid/gid del server web.

Rifiuto command linea parametri dato on , il URL
Se l'URL non contiene un "=" non codificato, la specifica CGI indica le opzioni
devono essere utilizzati come parametri della riga di comando del programma. Ad esempio, secondo
alle specifiche CGI: http://192.168.0.1/test.cgi?--limite di caricamento%3d2000&foo%3dbar
Dovrebbe impostare il limite di caricamento a 2000 KB oltre a impostare "Foo=bar". Per proteggere
contro i clienti che abilitano i propri caricamenti, haserl rifiuta tutte le opzioni della riga di comando
oltre argv[2]. Se richiamato come uno script #!, l'interprete è argv[0], tutto
le opzioni della riga di comando elencate nella riga #! vengono combinate in argv[1] e
il nome dello script è argv[2].

MOON

Se compilato con il supporto lua, --shell=lua abiliterà invece lua come linguaggio di script
della shell bash. Le variabili d'ambiente (SCRIPT_NAME, SERVER_NAME, ecc.) sono inserite in
la tabella ENV e le variabili del modulo vengono inserite nella tabella FORM. Ad esempio,
la forma autoreferenziale sopra può essere scritta così:

#!/usr/local/bin/haserl --shell=lua
tipo di contenuto: testo/html


Modulo di esempio
" metodo="GET">
<% # Esegui una convalida di base di FORM_textfield
# Per prevenire i comuni attacchi web
FORM.campo di testo=stringa.gsub(FORM.campo di testo, "[^%a%d]", "")
%>
<input type=text name=textfield
Valore="<% io.write (string.upper(FORM.textfield)) %>" cols=20>




L'operatore <%= è zucchero sintattico per io.scrivi (tostring( ... )) Quindi, per esempio, il
La riga Value= sopra potrebbe essere scritta: Valore="<%= string.upper(FORM.campo di testo) %>" colonne=20>

Gli script lua haserl possono utilizzare la funzione haserl.loadfile(Nome del file) elaborare un obiettivo
script come script haserl (lua). La funzione restituisce un tipo di "funzione".

Per esempio,

bar.lsp
<% io.write ("Ciao mondo" ) %>

Il tuo messaggio è <%= gvar %>

-- Fine del file di inclusione --

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

gvar = "Carica ed esegui in un unico passaggio"
haserl.loadfile("bar.lsp")()
%>

corsa foo produrrà:

Ciao a tutti
Il tuo messaggio è Esegui come m()
-- Fine del file di inclusione --
Ciao a tutti
Il tuo messaggio è Carica ed esegui in un unico passaggio
-- Fine del file di inclusione --

Questa funzione consente di avere pagine del server haserl annidate - frammenti di pagina
che vengono elaborati dal tokenizzatore haserl.

LUAC

. luca "shell" è un blocco lua precompilato, quindi modifica e test interattivi degli script
non è possibile. Tuttavia, haserl può essere compilato solo con il supporto luac, e questo consente
Supporto Lua anche in un ambiente con poca memoria. Tutte le funzionalità Lua di Haserl elencate sopra sono
ancora disponibile. (Se luac è l'unica shell integrata in haserl, haserl.loadfile è
disabilitato, poiché il parser haserl non è compilato.)

Ecco un esempio di uno script banale, convertito in uno script cgi luac:

Dato il file test.lua:
stampa ("Content-Type: text/plain0)
print ("Il tuo UUID per questa esecuzione è: " .. ENV.SESSIONID)

Può essere compilato con luac:
luac -o test.luac -s test.lua

E poi l'intestazione haserl aggiunta:
echo '#!/usr/bin/haserl --shell=luac' | cat - test.luac >luac.cgi

In alternativa, è possibile sviluppare un intero sito web utilizzando la shell lua standard,
e quindi fare in modo che haserl stesso preelabori gli script per il compilatore luac come parte di un
processo di compilazione. Per farlo, usa --shell=lua e sviluppa il sito web. Quando sei pronto per la compilazione
l'ambiente di runtime, aggiungi la riga --debug agli script lua ed eseguili producendo l'output
i risultati nei file sorgente .lua. Ad esempio:

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

Il tuo UUID per questa esecuzione è <%= ENV.SESSIONID %>

Precompilare, compilare e aggiungere l'intestazione haserl luac:
./test.cgi > test.lua
luac -s -o test.luac test.lua
echo '#!/usr/bin/haserl --shell=luac' | cat - test.luac >luac.cgi

Utilizzare haserl online utilizzando i servizi onworks.net