haserl - Online nel cloud

PROGRAMMA:

NOME

haserl - Un programma di scripting cgi per ambienti embedded

SINOSSI

#!/usr/bin/haserl [--guscio=pathpec] [--caricamento-dir=dispec] [--gestore-caricamento=Handler]
[--limite di caricamento=limitare] [--accettare tutti] [--accetta-nessuno] [--silenzioso] [--debug]

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

DESCRIZIONE

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

Combina tre funzionalità in un piccolo motore cgi:

Analizza le richieste POST e GET, inserendo gli elementi del modulo come coppie nome=valore nel file
ambiente da utilizzare per lo script CGI. 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 alla lettera alla shell. Questo è un po'
come scrivere PHP script.

Può facoltativamente essere installato per rilasciare le sue autorizzazioni al proprietario dello script,
dandogli alcune delle caratteristiche di sicurezza di suexec or cgiwrapper.

VERSIONI SOMMARIO

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

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

VERSIONI

--accettare tutti
Il programma normalmente accetta dati POST solo quando REQUEST_METHOD è POST e
accetta solo dati sui dati dell'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, FORM_variables sono presi dai dati COOKIE, POST
data e GET data.) L'impostazione predefinita è non accettare tutti i metodi di input - solo il
Dati COOKIE e REQUEST_METHOD.

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

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

--conchiglia=pathpec
Specifica una shell alternativa simile a bash da usare. 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 farlo
citare la stringa dell'opzione per proteggere eventuali caratteri speciali.

Se compilato con le librerie Lua, viene utilizzata la stringa "lua" per utilizzare un integrato
Lua vm. Questa stringa fa distinzione tra maiuscole e minuscole. Esempio: --conchiglia=luna

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

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

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

--upload-handler=pathpec
Quando specificato, i caricamenti di file sono gestiti da questo gestore, piuttosto che scritti su
file temporanei. Deve essere fornito il pathspecific completo (il PATH non viene cercato), e
al gestore di caricamento viene assegnato un parametro della riga di comando: Il nome della FIFO su
quale verrà inviato il file di caricamento. Inoltre, il conduttore può ricevere 3
variabili ambientali: TIPO DI CONTENUTO, NOME DEL FILEe NOME. Questi riflettono il MIME
intestazioni content-disposition per il contenuto. Haserl biforcherà il gestore per ciascuno
file caricato e invierà il contenuto del file di caricamento al FIFO specificato.
Haserl quindi bloccherà fino a quando il gestore non termina. Questo metodo è per esperti
solo.

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

OVERVIEW OF FUNZIONAMENTO

In generale, il server web imposta diverse variabili d'ambiente e poi usa forcella or
un altro metodo per eseguire lo script CGI. Se lo script usa il haserl interprete, il
accade quanto segue:

If haserl è installato suid root, quindi uid/gid è 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. il analizzato
i contenuti sono inseriti nell'ambiente locale.

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

haserl forchette e un sottoguscio (tipicamente /bin/sh) è avviato.

Tutti i token vengono inviati allo STDIN della sub-shell, con un finale exit comando.

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

CLIENTE LATO INGRESSO

I 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
essere accessibile da haserl. Il nome della variabile segue il nome dato nel sorgente,
tranne che un prefisso ( FORM_) è anteposto. Ad esempio, se il client invia "foo=bar",
la variabile d'ambiente è FORM_pippo=bar.

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

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

Per il metodo POST, le variabili sono anche memorizzate con il prefisso ( POST_) aggiunto. Per
esempio, se il post stream include "foo=bar", la variabile d'ambiente è POST_pippo=bar.

Inoltre, per il metodo POST, se i dati vengono inviati utilizzando multipart/forma-dati codifica, la
i dati vengono decodificati automaticamente. Questo è tipicamente usato quando i file vengono caricati da un web
cliente che usa .

NOTA Quando un file viene caricato sul server Web, viene memorizzato nella carica-dir
directory. FORM_nome_variabile= contiene il nome del file caricato (come
specificato dal cliente.) HESERL_variable_path= contiene il nome del file in
carica-dir che contiene il contenuto caricato. Per impedire ai client dannosi di
riempiendo carica-dir sul tuo server web, i caricamenti di file sono consentiti solo quando il
--limite di caricamento l'opzione viene utilizzata per specificare la dimensione di un file che può essere caricato. Haserl
elimina automaticamente il file temporaneo al termine dello script. Per mantenere il
file, spostalo o rinominalo da qualche parte nello script.

Nota che il nome del file è memorizzato in HASERL_percorso_variabile Questo perché il FORM_,
Le variabili GET_ e POST_ sono modificabili dal client e un client dannoso può
imposta una seconda variabile con il nome percorso_variabile=/etc/passwd. Versioni precedenti
non ha memorizzato il pathpec in HASERL spazio dei nomi. A mantenere arretrato
compatibilità, , il Nome of , il temporaneo filetto is anche memorizzati in FORM_variabile= ed
POST_variabile=. La sezione is considerato pericoloso ed dovrebbero non be Usato.

Se il cliente invia i dati entrambi con 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 l'opzione è stata impostata. Ad esempio, un modulo chiamato tramite il metodo POST, ma con a
L'URI di some.cgi?foo=bar&otherdata=something avrà i dati POST analizzati e il foo
ed altri dati le variabili vengono ignorate.

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

Quando più istanze della stessa variabile vengono inviate da origini diverse, il
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'accetta-tutto
è stata impostata l'opzione, quindi HTTP_COOKIE viene elaborato per primo, seguito dal metodo not
specificato da REQUEST_METHOD, seguito da REQUEST_METHOD. L'ultima istanza di
variabile verrà utilizzata per impostare FORM_variable. Nota che le variabili sono anche separate
crea come COOKIE_variable, GET_variable e POST_variable. Ciò consente l'uso di
nomi sovrapposti da ciascuna fonte.

Quando più istanze della stessa variabile vengono inviate dalla stessa sorgente, solo l'ultima
uno è salvato. Per conservare tutte le copie (per le selezioni multiple, ad esempio), aggiungi "[]" alla fine
del nome della variabile. Tutti i risultati verranno restituiti, separati da nuove righe. Per 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 dai tag <% %> viene inviato alla sub-shell per l'esecuzione. Il testo
viene inviato testualmente.

INCLUDERE
<%in pathpec %>

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

VAL
<%= espressione %>

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

COMMENTO
<%# commento %>

Blocco commenti. Qualsiasi cosa in un blocco di commenti non viene analizzata. I commenti possono essere nidificati
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 dell'uso haserl (o qualsiasi script
lingua) in un ambiente di produzione.

Un'espansione Comando
#!/usr/local/bin/haserl
tipo di contenuto: testo/normale

<%# Questo è uno script "env" di esempio %>
<% ambiente %>

Stampa i risultati del ENV comando come un documento "testo/normale" di tipo mime. Questo è
, il haserl versione del comune printenv cgi.

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 un documento "text/html" di tipo mime al client, con una tabella html di with
elementi etichettati con il colore di sfondo.

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

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



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




Come sopra, ma usa una funzione shell invece di html incorporato.

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


Modulo di esempio
" method="GET">
<% # Esegui alcune convalide di base di FORM_textfield
# Per prevenire attacchi web comuni
FORM_textfield=$( echo "$FORM_textfield" | sed "s/[^A-Za-z0-9 ]//g" )
%>
<tipo di input=nome testo=campotesto
Value="<% echo -n "$FORM_textfield" | tr az AZ %>" cols=20>




Stampa un modulo. Se il cliente inserisce del testo nel modulo, il CGI viene ricaricato (definito
by $NOME_SCRIPT) e il campo di testo viene disinfettato per prevenire attacchi web, quindi il
viene visualizzato nuovamente il modulo 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: text/html


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



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

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



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

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

...


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

AMBIENTE

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

HASERLVER
haserl versione - un tag informativo.

SESSIONID
Un tag esadecimale unico 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.)

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

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

HESERL_UPLOAD_DIR
La directory che haserl utilizzerà per archiviare i file caricati.

HESERL_UPLOAD_LIMIT
Il numero di KB che possono essere inviati dal client al server.

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

SICUREZZA CARATTERISTICHE

C'è 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-
guscio. Si analizza sui caratteri? e &, quindi è più difficile da fare per un cliente
attacchi di "iniezione". Come esempio, foo.cgi?a=prova;cat /etc/passwd potrebbe comportare
una variabile a cui viene assegnato il valore test e poi i risultati della corsa gatto
/etc/passwd essere inviato al cliente. Haserl assegnerà alla variabile il completo
valore: prova; gatto /etc/passwd

È sicuro usare questa variabile "pericolosa" negli script di shell racchiudendola in
citazioni; anche se la convalida dovrebbe essere eseguita su tutti i campi di input.

Privilegio lancio
Se installato come script suid, haserl imposterà il suo uid/gid a quello del proprietario di
il copione. Questo può essere usato per avere una serie di script CGI che hanno vari
privilegio. Se la haserl binary non è installato suid, gli script CGI lo faranno
eseguire 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 per il 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 su 2000 KB oltre a impostare "Foo=bar". Proteggere
contro i clienti che abilitano i propri caricamenti, haserl rifiuta qualsiasi opzione della riga di comando
oltre argv[2]. Se invocato come #! script, l'interprete è argv[0], all
opzioni della riga di comando elencate nel #! line sono combinati in argv[1], e il
il nome dello script è argv[2].

MOON

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

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


Modulo di esempio
" metodo="OTTIENI">
<% # Esegui alcune convalide di base di FORM_textfield
# Per prevenire attacchi web comuni
FORM.textfield=string.gsub(FORM.textfield, "[^%a%d]", "")
%>
<tipo di input=nome testo=campotesto
Value="<% io.write (string.upper(FORM.textfield)) %>" cols=20>




L'operatore <%= è zucchero sintattico per io.scrivi (accordare( ... )) Quindi, per esempio, il
Value= la riga sopra potrebbe essere scritta: Valore="<%= string.upper(FORM.campoditesto) %>" cols=20>

gli script haserl lua possono usare 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 ("Hello World" ) %>

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 solo 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 solo passaggio
--Fine del file di inclusione --

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

LUAC

I luca "shell" è un pezzo 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 caratteristiche di haserl lua 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 luac cgi:

Dato il file test.lua:
print ("Contenuto-tipo: testo/normale0)
print ("Il tuo UUID per questa esecuzione è: " .. ENV.SESSIONID)

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

E poi ha aggiunto l'intestazione haserl:
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 preprocessi gli script per il compilatore luac come parte di a
processo di costruzione. Per fare ciò, usa --shell=lua e sviluppa il sito web. Quando sei pronto per costruire
l'ambiente di runtime, aggiungi la riga --debug ai tuoi script lua ed eseguili in output
i risultati nei file sorgente .lua. Per 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 %>

Precompila, compila e aggiungi l'intestazione haserl luac:
./test.cgi > test.lua
luac -s -o prova.luac prova.lua
echo '#!/usr/bin/haserl --shell=luac' | cat - test.luac >luac.cgi

Usa haserl online utilizzando i servizi onworks.net