haserl - Online sa Cloud

PROGRAMA:

NAME

haserl - Isang cgi scripting program para sa mga naka-embed na kapaligiran

SINOPSIS

#!/usr/bin/haserl [--shell=pathspec] [--upload-dir=dispec] [--upload-handler=Handler]
[--upload-limit=limitasyon] [--tanggapin lahat] [--accept-none] [--tahimik] [--debug]

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

DESCRIPTION

Ang Haserl ay isang maliit na cgi wrapper na nagbibigay-daan sa "PHP" style cgi programming, ngunit gumagamit ng UNIX
bash-like shell o Lua bilang programming language. Ito ay napakaliit, kaya maaari itong magamit
sa mga naka-embed na kapaligiran, o kung saan ang isang bagay tulad ng PHP ay masyadong malaki.

Pinagsasama nito ang tatlong feature sa isang maliit na cgi engine:

Pina-parse nito ang mga kahilingan sa POST at GET, na naglalagay ng mga form-element bilang name=value pairs sa
kapaligiran para magamit ng CGI script. Ito ay medyo katulad ng uncgi wrapper.

Nagbubukas ito ng shell, at isinasalin ang lahat ng teksto sa mga napi-print na pahayag. Lahat ng text
sa loob ng <% ... %> mga konstruksyon ay ipinapasa verbatim sa shell. Ito ay medyo
tulad ng pagsusulat PHP script.

Maaari itong opsyonal na mai-install upang i-drop ang mga pahintulot nito sa may-ari ng script,
binibigyan ito ng ilan sa mga tampok na panseguridad ng suexec or cgiwrapper.

Opsyon BUOD

Ito ay isang buod ng mga opsyon sa command-line. Mangyaring tingnan ang Opsyon seksyon sa ilalim ng
mahabang pangalan ng opsyon para sa kumpletong paglalarawan.

-a --tanggapin-lahat
-n --tanggap-wala
-d --debug
-s, --shell
-S, --tahimik
-U, --upload-dir
-u, --upload-limit
-H, --upload-handler

Opsyon

--tanggapin lahat
Ang programa ay karaniwang tumatanggap ng POST data lamang kapag ang REQUEST_METHOD ay POST at
tumatanggap lamang ng data sa data ng URL kapag ang REQUEST_METHOD ay GET. Ang pagpipiliang ito
nagbibigay-daan sa parehong data ng POST at URL na tanggapin anuman ang REQUEST_METHOD.
Kapag ang opsyong ito ay itinakda, ang REQUEST_METHOD ay mauuna (hal. kung ang pamamaraan
ay POST, FORM_variables ay kinuha mula sa COOKIE data, GET data, at POST data, sa
ang utos na iyon. Kung ang paraan ay GET, FORM_variables ay kinuha mula sa COOKIE data, POST
data, at GET data.) Ang default ay hindi tanggapin ang lahat ng paraan ng pag-input - ang
Data ng COOKIE at ang REQUEST_METHOD.

--tanggap-wala
Kung ibinigay, hindi ipapa-parse ng haserl ang karaniwang input bilang nilalamang http bago iproseso
ang script. Ito ay kapaki-pakinabang kung tumatawag ng haserl script mula sa isa pang haserl script.

--debug
Sa halip na isagawa ang script, i-print ang script na isasagawa. Kung
ang environment variable na 'REQUEST_METHOD' ay nakatakda, ang data ay ipinapadala kasama ang
plain/text na uri ng nilalaman. Kung hindi, ang shell script ay naka-print na verbatim.

--shell=pathspec
Tumukoy ng alternatibong shell na parang bash na gagamitin. Default sa "/ Bin / SH"

Upang isama ang mga parameter ng shell huwag gamitin ang --shell=/ Bin / SH pormat. Sa halip, gamitin ang
alternatibong format na walang "=", gaya ng --shell "/ basahan / bash --norc". Siguraduhin na
quote ang pagpipiliang string upang protektahan ang anumang mga espesyal na character.

Kung pinagsama-sama sa mga aklatan ng Lua, ang string na "lua" ay ginagamit upang gumamit ng isang pinagsama-samang
Lua vm. Case sensitive ang string na ito. Halimbawa: --shell=buwan

Ang isang alternatibo ay "luac". Nagiging sanhi ito ng pag-disable ng mga haserl at lua parser,
at ang script ay ipinapalagay na isang precompiled lua chunk. Tingnan mo LUAC sa ibaba para sa higit pa
impormasyon.

--tahimik
Karaniwang nagpi-print si Haserl ng mensaheng nagbibigay-impormasyon sa mga kundisyon ng error. Ito
pinipigilan ang mensahe ng error, upang hindi mai-advertise ang paggamit ng haserl.

--upload-dir=dispec
Default sa "/ Tmp". Lahat ng na-upload na file ay nilikha na may pansamantalang filename dito
direktoryo HASERL_xxx_path naglalaman ng pangalan ng pansamantalang file. FORM_xxx_name
naglalaman ng orihinal na pangalan ng file, gaya ng tinukoy ng kliyente.

--upload-handler=pathspec
Kapag tinukoy, ang mga pag-upload ng file ay pinangangasiwaan ng tagapangasiwa na ito, sa halip na isulat sa
pansamantalang mga file. Ang buong pathspec ay dapat ibigay (ang PATH ay hindi hinanap), at
ang upload-handler ay binibigyan ng isang command-line parameter: Ang pangalan ng FIFO sa
kung saan ipapadala ang upload file. Bilang karagdagan, ang handler ay maaaring makatanggap ng 3
mga variable ng kapaligiran: CONTENT_TYPE, FILENAME, at NAME. Ang mga ito ay sumasalamin sa MIME
mga header ng content-disposition para sa content. Haserl ay tinidor ang handler para sa bawat isa
file na na-upload, at ipapadala ang mga nilalaman ng upload file sa tinukoy na FIFO.
Haharangin ni Haserl hanggang sa matapos ang handler. Ang pamamaraang ito ay para sa mga eksperto
lamang.

--upload-limit=limitasyon
Payagan ang isang mime-encoded file hanggang sa limitasyon KB na i-upload. Ang default ay 0KB (walang
pinapayagan ang pag-upload). Tandaan na ang mime-encoding ay nagdaragdag ng 33% sa laki ng data.

PANGKALAHATANG-IDEYA OF OPERASYON

Sa pangkalahatan, nagse-set up ang web server ng ilang mga variable ng kapaligiran, at pagkatapos ay gumagamit tinidor or
isa pang paraan upang patakbuhin ang CGI script. Kung ang script ay gumagamit ng haserl interpreter, ang
sumusunod ang mangyayari:

If haserl ay naka-install suid root, pagkatapos uid/gid ay nakatakda sa may-ari ng script.

Ang kapaligiran ay na-scan para sa HTTP_COOKIE, na maaaring itinakda ng web
server. Kung mayroon ito, ang mga na-parse na nilalaman ay inilalagay sa lokal na kapaligiran.

Ang kapaligiran ay na-scan para sa REQUEST_METHOD, na itinakda ng web server.
Batay sa paraan ng kahilingan, binabasa at na-parse ang karaniwang input. Ang na-parse
ang mga nilalaman ay inilalagay sa lokal na kapaligiran.

Ang script ay tokenized, pag-parse haserl mga bloke ng code mula sa hilaw na teksto. Raw text ay
na-convert sa "echo" na mga pahayag, at pagkatapos ay ipapadala ang lahat ng mga token sa sub-shell.

haserl mga tinidor at isang sub-shell (karaniwang / Bin / SH) ay nagsimula.

Ang lahat ng mga token ay ipinapadala sa STDIN ng sub-shell, na may isang trailing lumabas utos.

Kapag natapos ang sub-shell, ang haserl ang interpreter ay nagsasagawa ng panghuling paglilinis at
pagkatapos ay magwawakas.

PAKIKITA SIDE INPUT

Ang haserl interpreter ay magde-decode ng data na ipinadala sa pamamagitan ng HTTP_COOKIE environment variable, at
ang GET o POST na paraan mula sa kliyente, at iimbak ang mga ito bilang mga variable ng kapaligiran na maaari
ma-access ng haserl. Ang pangalan ng variable ay sumusunod sa pangalang ibinigay sa pinagmulan,
maliban sa isang prefix ( FORM_) ay nakahanda. Halimbawa, kung ang kliyente ay nagpadala ng "foo=bar",
ang variable ng kapaligiran ay FORM_foo=bar.

Para sa pamamaraang HTTP_COOKIE, iniimbak din ang mga variable na may prefix ( COOKIES_) idinagdag.
Halimbawa, kung kasama sa HTTP_COOKIE ang "foo=bar", ang environment variable ay
COOKIE_foo=bar.

Para sa GET method, ang data na ipinadala sa form na %xx ay isinalin sa mga character na kanilang
kumakatawan, at ang mga variable ay iniimbak din na may prefix ( GET_) idinagdag. Halimbawa, kung
Kasama sa QUERY_STRING ang "foo=bar", ang environment variable ay GET_foo=bar.

Para sa pamamaraang POST, ang mga variable ay iniimbak din na may prefix ( POST_) idinagdag. Para sa
halimbawa, kung ang post stream ay may kasamang "foo=bar", ang environment variable ay POST_foo=bar.

Gayundin, para sa pamamaraang POST, kung ang data ay ipinadala gamit ang maramihang bahagi/form-data encoding, ang
ang data ay awtomatikong na-decode. Ito ay karaniwang ginagamit kapag ang mga file ay na-upload mula sa isang web
ginagamit ng kliyente .

NOTA Kapag ang isang file ay na-upload sa web server, ito ay naka-imbak sa upload-dir
direktoryo. FORM_variable_name= naglalaman ng pangalan ng file na na-upload (bilang
tinukoy ng kliyente.) HASERL_variable_path= naglalaman ng pangalan ng file sa
upload-dir na nagtataglay ng na-upload na nilalaman. Upang maiwasan ang mga malisyosong kliyente mula sa
pinupuno upload-dir sa iyong web server, ang mga pag-upload ng file ay pinapayagan lamang kapag ang
--upload-limit Ang opsyon ay ginagamit upang tukuyin kung gaano kalaki ang isang file na maaaring i-upload. Haserl
awtomatikong tinatanggal ang pansamantalang file kapag natapos na ang script. Upang mapanatili ang
file, ilipat ito o palitan ang pangalan nito sa isang lugar sa script.

Tandaan na ang filename ay naka-imbak sa HASERL_variable_path Ito ay dahil ang FORM_,
Ang mga variable na GET_, at POST_ ay nababago ng kliyente, at magagawa ng isang malisyosong kliyente
magtakda ng pangalawang variable na may pangalan variable_path=/ etc / passwd. Mga naunang bersyon
hindi nag-imbak ng pathspec sa HASERL namespace. Upang panatilihin pabalik
pagiging tugma, ang pangalan of ang pansamantala file is Rin nakaimbak in FORM_variable= at
POST_variable=. ito is isinasaalang-alang hindi ligtas at dapat hindi be ginagamit.

Kung ang kliyente ay nagpapadala ng data kapwa sa pamamagitan ng mga pamamaraan ng POST at GET, kung gayon haserl ay parse lamang ang
datos na tumutugma sa REQUEST_METHOD variable na itinakda ng web server, maliban kung ang
tanggapin lahat ang opsyon ay naitakda na. Halimbawa, isang form na tinatawag sa pamamagitan ng POST method, ngunit pagkakaroon ng a
URI ng some.cgi?foo=bar&otherdata=something ay mapapa-parse ang POST data, at ang foo
at ibang data hindi pinapansin ang mga variable.

Kung tinukoy ng web server ang a HTTP_COOKIE environment variable, na-parse ang data ng cookie.
Na-parse ang data ng cookie bago ang GET o POST data, kaya sa kaganapan ng dalawang variable ng
parehong pangalan, ang GET o POST data ay nag-o-overwrite sa impormasyon ng cookie.

Kapag maramihang mga pagkakataon ng parehong variable ay ipinadala mula sa iba't ibang mga mapagkukunan, ang
Itatakda ang FORM_variable ayon sa pagkakasunud-sunod kung saan pinoproseso ang mga variable.
Palaging unang pinoproseso ang HTTP_COOKIE, na sinusundan ng REQUEST_METHOD. Kung ang tanggapin-lahat
ang opsyon ay naitakda na, pagkatapos ay ang HTTP_COOKIE ay unang naproseso, na sinusundan ng paraan na hindi
tinukoy ng REQUEST_METHOD, na sinusundan ng REQUEST_METHOD. Ang huling pagkakataon ng
variable ay gagamitin upang itakda ang FORM_variable. Tandaan na ang mga variable ay hiwalay din
lumilikha bilang COOKIE_variable, GET_variable at POST_variable. Ito ay nagpapahintulot sa paggamit ng
magkakapatong na mga pangalan mula sa bawat pinagmulan.

Kapag maraming instance ng parehong variable ang ipinadala mula sa parehong pinagmulan, ang huli lang
ang isa ay naligtas. Upang panatilihin ang lahat ng mga kopya (para sa mga multi-select, halimbawa), idagdag ang "[]" sa dulo
ng variable na pangalan. Ibabalik ang lahat ng resulta, na pinaghihiwalay ng mga bagong linya. Halimbawa,
host=Enoch&host=Esther&host=Joshua ay nagreresulta sa "FORM_host=Joshua".
host[]=Enoch&host[]Esther&host[]=Joshua ay nagreresulta sa "FORM_host=Enoch\nEsther\nJoshua"

ANG WIKA

Ang mga sumusunod na istruktura ng wika ay kinikilala ng haserl.

RUN
<% [shell script] %>

Ang anumang bagay na nakapaloob sa <% %> na mga tag ay ipinapadala sa sub-shell para sa pagpapatupad. Ang teksto
ay ipinadala sa salita.

MAISASALI
<%sa pathspec %>

Magsama ng isa pang file verbatim sa script na ito. Ang file ay kasama kapag ang script
ay na-parse sa simula.

EVAL
<%= expression %>

i-print ang expression ng shell. Syntactic sugar para sa "echo expr".

PAANO
<%# komento %>

I-block ang komento. Ang anumang bagay sa isang bloke ng komento ay hindi na-parse. Maaaring ma-nest ang mga komento
at maaaring maglaman ng iba pang elemento ng haserl.

HALIMBAWA

BABALA
Ang mga halimbawa sa ibaba ay pinasimple upang ipakita kung paano gamitin haserl. Ikaw dapat
pamilyar sa pangunahing seguridad sa web scripting bago gamitin haserl (o anumang scripting
wika) sa isang kapaligiran ng produksyon.

Simple Utos
#!/usr/local/bin/haserl
uri ng nilalaman: text/plain

<%# Ito ay isang sample na "env" script %>
<% env %>

Nagpi-print ng mga resulta ng env command bilang isang mime-type na "text/plain" na dokumento. Ito ay
ang haserl bersyon ng karaniwan printenv cgi.

Nakakalusot sa dynamic output
#!/usr/local/bin/haserl
Uri ng nilalaman: text/html




<% para sa a sa Red Blue Yellow Cyan; gawin %>
"><% echo -n "$a" %>
<% tapos na %>




Nagpapadala ng mime-type na "text/html" na dokumento sa kliyente, na may html table ng with
mga elementong may label na kulay ng background.

paggamit Talukap ng alimango tinukoy function.
#!/usr/local/bin/haserl
uri ng nilalaman: text/html

<% # tukuyin ang isang function ng user
table_element() {
echo" $1 "
}
%>



<% para sa a sa Red Blue Yellow Cyan; gawin %>
<% table_element $a %>
<% tapos na %>




Pareho sa itaas, ngunit gumagamit ng shell function sa halip na naka-embed na html.

Sarili Pagsangguni CGI sa a anyo
#!/usr/local/bin/haserl
uri ng nilalaman: text/html


Halimbawang Form
" method="GET">
<% # Gumawa ng ilang pangunahing pagpapatunay ng FORM_textfield
# Upang maiwasan ang mga karaniwang pag-atake sa web
FORM_textfield=$( echo "$FORM_textfield" | sed "s/[^A-Za-z0-9 ]//g")
%>
<input type=text name=textfield
Value="<% echo -n "$FORM_textfield" | tr az AZ %>" cols=20>




Nagpi-print ng form. Kung ang kliyente ay nagpasok ng teksto sa form, ang CGI ay nire-reload (tinukoy
by $SCRIPT_NAME) at ang textfield ay nililinis upang maiwasan ang mga pag-atake sa web, pagkatapos ay ang
Ang form ay muling ipinapakita kasama ang tekstong ipinasok ng user. Ang teksto ay uppercase.

Pag-upload a talaksan
#!/usr/local/bin/haserl --upload-limit=4096 --upload-dir=/ Tmp
uri ng nilalaman: text/html


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



<% kung pagsubok -n "$HASERL_uploadfile_path"; pagkatapos %>

Nag-upload ka ng file na pinangalanang <% echo -n $FORM_uploadfile_name %> , at ito ay
. pansamantalang nakaimbak sa server bilang . Ang
ang file ay <% cat $HASERL_uploadfile_path | wc -c %> bytes ang haba.
<% rm -f $HASERL_uploadfile_path %> Huwag mag-alala, ang file ay tinanggal na
mula sa web server.
<% else %>
Hindi ka pa nakakapag-upload ng file.
<% fi %>



Nagpapakita ng form na nagbibigay-daan para sa pag-upload ng file. Naisasagawa ito sa pamamagitan ng paggamit ng
--upload-limit at sa pamamagitan ng pagtatakda ng form enctype sa maramihang bahagi/form-data. Kung ang
Nagpapadala ang kliyente ng file, pagkatapos ay ipi-print ang ilang impormasyon tungkol sa file, at pagkatapos
tinanggal. Kung hindi, ang form ay nagsasaad na ang kliyente ay hindi nag-upload ng isang file.

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

...


Upang ganap na makasunod sa detalye ng HTTP, dapat na wakasan ang paggamit ng mga header
CR+LF, sa halip na ang normal na unix LF line termination lang. Ang syntax sa itaas ay maaari
gamitin para makagawa ng mga header na sumusunod sa RFC 2616.

Kapaligiran

Bilang karagdagan sa mga variable ng kapaligiran na minana mula sa web server, ang mga sumusunod
Ang mga variable ng kapaligiran ay palaging tinutukoy sa pagsisimula:

HASERLVER
haserl bersyon - isang tag ng impormasyon.

SESSIONID
Isang hexadecimal tag na natatangi para sa buhay ng CGI (ito ay nabuo kapag ang
nagsisimula ang cgi; at hindi nagbabago hanggang sa mabuo ang isa pang POST o GET na query.)

HASERL_ACCEPT_ALL
Kung ang --tanggapin lahat itinakda ang bandila, -1, Kung hindi man 0.

HASERL_SHELL
Ang pangalan ng shell haserl ay nagsimulang magpatakbo ng mga sub-shell na utos.

HASERL_UPLOAD_DIR
Ang direktoryo na haserl ay gagamitin upang mag-imbak ng mga na-upload na file.

HASERL_UPLOAD_LIMIT
Ang bilang ng KB na pinapayagang ipadala mula sa kliyente patungo sa server.

Ang mga variable na ito ay maaaring mabago o ma-overwrite sa loob ng script, bagama't ang mga ito
na nagsisimula sa "HASERL_" ay impormasyon lamang, at hindi nakakaapekto sa tumatakbong script.

KALIGTASAN TAMPOK

Maraming literatura tungkol sa mga panganib ng paggamit ng shell upang magprogram ng mga script ng CGI.
haserl naglalaman ng ilan mga proteksyon upang mabawasan ang panganib na ito.

kapaligiran Variable
Ang code para i-populate ang mga variable ng kapaligiran ay nasa labas ng saklaw ng sub-
kabibi. Ito parses sa mga character ? at &, kaya mas mahirap para sa isang kliyente na gawin
pag-atake ng "injection". Bilang halimbawa, foo.cgi?a=test;cat / etc / passwd maaaring magresulta sa
isang variable na itinalaga ang halaga pagsusulit at pagkatapos ay ang mga resulta ng pagtakbo pusa
/ etc / passwd ipinapadala sa kliyente. Haserl ay magtatalaga sa variable na kumpleto
halaga: pagsubok; pusa / etc / passwd

Ligtas na gamitin ang "mapanganib" na variable na ito sa mga script ng shell sa pamamagitan ng paglalagay nito
quotes; bagama't dapat gawin ang pagpapatunay sa lahat ng mga field ng input.

Pribilehiyo Pag-drop
Kung naka-install bilang suid script, haserl ay itatakda ang uid/gid nito sa may-ari ng
ang script. Magagamit ito para magkaroon ng set ng mga CGI script na may iba't-ibang
pribilehiyo. Kung ang haserl binary ay hindi naka-install suid, pagkatapos ay ang CGI script ay
tumakbo gamit ang uid/gid ng web server.

Tanggihan utos linya parameter naibigay na on ang URL
Kung ang URL ay hindi naglalaman ng hindi naka-encode na "=", kung gayon ang CGI spec ay nagsasaad ng mga opsyon
ay gagamitin bilang mga parameter ng command-line sa programa. Halimbawa, ayon
sa spec ng CGI: http://192.168.0.1/test.cgi?--upload-limit%3d2000&foo%3dbar
Dapat itakda ang upload-limit sa 2000KB bilang karagdagan sa pagtatakda ng "Foo=bar". Para protektahan
laban sa mga kliyente na nagpapagana ng kanilang sariling mga pag-upload, haserl tinatanggihan ang anumang mga opsyon sa command-line
lampas sa argv[2]. Kung tinawag bilang isang #! script, ang interpreter ay argv[0], lahat
mga opsyon sa command-line na nakalista sa #! line ay pinagsama sa argv[1], at ang
Ang pangalan ng script ay argv[2].

LUA

Kung pinagsama-sama sa suporta ng lua, --shell=lua papaganahin ang lua bilang wika ng script sa halip
ng bash shell. Ang mga variable ng kapaligiran (SCRIPT_NAME, SERVER_NAME, atbp) ay inilagay sa
ang talahanayan ng ENV, at ang mga variable ng form ay inilalagay sa talahanayan ng FORM. Halimbawa, ang
Ang self-referencing form sa itaas ay maaaring isulat tulad nito:

#!/usr/local/bin/haserl --shell=lua
uri ng nilalaman: text/html


Halimbawang Form
" method="GET">
<% # Gumawa ng ilang pangunahing pagpapatunay ng FORM_textfield
# Upang maiwasan ang mga karaniwang pag-atake sa web
FORM.textfield=string.gsub(FORM.textfield, "[^%a%d]", "")
%>
<input type=text name=textfield
Value="<% io.write (string.upper(FORM.textfield)) %>" cols=20>




Ang operator na <%= ay syntactic sugar para sa io.sumulat (tostring( ... )) Kaya, halimbawa, ang
Value= line sa itaas ay maaaring isulat: Halaga="<%= string.upper(FORM.textfield) %>" cols=20>

Maaaring gamitin ng mga script ng haserl lua ang function haserl.loadfile(filename) upang iproseso ang isang target
script bilang haserl (lua) script. Ang function ay nagbabalik ng isang uri ng "function".

Halimbawa,

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

Ang iyong mensahe ay <%= gvar %>

-- Katapusan ng Isama ang file --

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

gvar = "Mag-load at tumakbo sa isang hakbang"
haserl.loadfile("bar.lsp")()
%>

Tumatakbo foo gagawa ng:

Kamusta Mundo
Ang iyong mensahe ay Run as m()
-- Katapusan ng Isama ang file --
Kamusta Mundo
Ang iyong mensahe ay I-load at tumakbo sa isang hakbang
-- Katapusan ng Isama ang file --

Ginagawang posible ng function na ito na magkaroon ng mga nested na pahina ng server ng haserl - mga snippet ng pahina
na pinoproseso ng haserl tokenizer.

LUAC

Ang luac Ang "shell" ay isang precompiled lua chunk, kaya interactive na pag-edit at pagsubok ng mga script
hindi pwede. Gayunpaman, ang haserl ay maaaring isama sa luac support lamang, at ito ay nagbibigay-daan
suporta ng lua kahit sa isang maliit na kapaligiran ng memorya. Ang lahat ng tampok na haserl lua na nakalista sa itaas ay
available pa rin. (Kung ang luac ay ang tanging shell na binuo sa haserl, ang haserl.loadfile ay
hindi pinagana, dahil hindi naka-compile ang haserl parser.)

Narito ang isang halimbawa ng isang maliit na script, na na-convert sa isang luac cgi script:

Dahil sa file test.lua:
print ("Uri ng Nilalaman: text/plain0)
print ("Ang iyong UUID para sa pagtakbo na ito ay: " .. ENV.SESSIONID)

Maaari itong isama sa luac:
luac -o test.luac -s test.lua

At pagkatapos ay idinagdag dito ang haserl header:
echo '#!/usr/bin/haserl --shell=luac' | pusa - test.luac >luac.cgi

Bilang kahalili, posible na bumuo ng isang buong website gamit ang karaniwang lua shell,
at pagkatapos ay ipa-preprocess mismo ni haserl ang mga script para sa luac compiler bilang bahagi ng a
proseso ng pagbuo. Upang gawin ito, gamitin ang --shell=lua, at i-develop ang website. Kapag handa na upang bumuo
ang runtime environment, idagdag ang --debug line sa iyong mga lua script, at patakbuhin ang mga ito sa pag-output
ang mga resulta sa .lua source file. Halimbawa:

Dahil sa haserl script test.cgi:
#!/usr/bin/haserl --shell=lua --debug
Uri ng Nilalaman: text/plain

Ang iyong UUID para sa pagtakbong ito ay <%= ENV.SESSIONID %>

I-precompile, i-compile, at idagdag ang haserl luac header:
./test.cgi > test.lua
luac -s -o test.luac test.lua
echo '#!/usr/bin/haserl --shell=luac' | pusa - test.luac >luac.cgi

Gamitin ang haserl online gamit ang mga serbisyo ng onworks.net