haserl - ออนไลน์ในคลาวด์

โครงการ:

ชื่อ

haserl - โปรแกรมสคริปต์ cgi สำหรับสภาพแวดล้อมแบบฝังตัว

เรื่องย่อ

#!/usr/bin/haserl [--เชลล์=เส้นทางพิเศษ] [--อัพโหลด-dir=ไดร์สเปค] [--ตัวจัดการอัพโหลด=จัดการ]
[--อัพโหลด-จำกัด=จำกัด] [--ยอมรับ-ทั้งหมด] [--ยอมรับ-ไม่มี] [--เงียบ] [--ดีบัก]

[ ข้อความ ] [ <% เชลล์สคริปต์ %> ] [ ข้อความ ] ...

DESCRIPTION

Haserl เป็น wrapper cgi ขนาดเล็กที่อนุญาตให้เขียนโปรแกรม cgi สไตล์ "PHP" แต่ใช้ UNIX
bash-like shell หรือ Lua เป็นภาษาโปรแกรม มีขนาดเล็กมากจึงสามารถใช้ได้
ในสภาพแวดล้อมแบบฝังตัว หรือในกรณีที่ PHP มีขนาดใหญ่เกินไป

รวมคุณสมบัติสามประการไว้ในเอ็นจิ้น cgi ขนาดเล็ก:

มันแยกวิเคราะห์คำขอ POST และ GET โดยวางองค์ประกอบแบบฟอร์มเป็นคู่ของชื่อ=ค่าใน
สภาพแวดล้อมสำหรับสคริปต์ CGI ที่จะใช้ นี้ค่อนข้างเช่น อุ๊งจิ กระดาษห่อ

มันเปิดเปลือกและแปลข้อความทั้งหมดเป็นคำสั่งที่พิมพ์ได้ ข้อความทั้งหมด
ภายใน <% ... %> โครงสร้างจะถูกส่งต่อคำต่อคำไปยังเชลล์ มันค่อนข้าง
ชอบเขียน PHP สคริปต์

สามารถเลือกติดตั้งเพื่อปล่อยสิทธิ์ให้กับเจ้าของสคริปต์
ให้คุณสมบัติด้านความปลอดภัยบางอย่างของ ฟ้อง or cgiwrapper.

OPTIONS สรุป

นี่คือบทสรุปของตัวเลือกบรรทัดคำสั่ง โปรดดูที่ OPTIONS ภายใต้
ชื่อตัวเลือกแบบยาวสำหรับคำอธิบายที่สมบูรณ์

-a --accept-ทั้งหมด
-n -- ยอมรับไม่มี
-d --debug
-s, --เปลือก
-S, --เงียบ
-U, --อัพโหลด-dir
-u, --อัพโหลด-จำกัด
-H, --ตัวจัดการอัปโหลด

OPTIONS

--ยอมรับทั้งหมด
โดยปกติโปรแกรมจะยอมรับข้อมูล POST เฉพาะเมื่อ REQUEST_METHOD เป็น POST และ
ยอมรับเฉพาะข้อมูลในข้อมูล URL เมื่อ REQUEST_METHOD เป็น GET ตัวเลือกนี้
อนุญาตให้ยอมรับทั้งข้อมูล POST และ URL โดยไม่คำนึงถึง REQUEST_METHOD
เมื่อตั้งค่าตัวเลือกนี้ REQUEST_METHOD จะมีความสำคัญกว่า (เช่น ถ้า method
คือ POST FORM_variables ถูกนำมาจากข้อมูลคุกกี้ ข้อมูล GET และข้อมูล POST ใน
คำสั่งนั้น หากวิธีการคือ GET FORM_variables จะถูกนำมาจากข้อมูลคุกกี้ POST
data และ GET data) ค่าเริ่มต้นคือไม่ยอมรับวิธีการป้อนข้อมูลทั้งหมด - เพียงแค่
ข้อมูลคุกกี้และ REQUEST_METHOD

--ยอมรับ-ไม่มี
หากได้รับ haserl จะไม่แยกวิเคราะห์อินพุตมาตรฐานเป็นเนื้อหา http ก่อนประมวลผล
บท. สิ่งนี้มีประโยชน์หากเรียกใช้สคริปต์ haserl จากสคริปต์ haserl อื่น

--debug
แทนที่จะรันสคริปต์ ให้พิมพ์สคริปต์ที่จะถูกดำเนินการ ถ้า
มีการตั้งค่าตัวแปรสภาพแวดล้อม 'REQUEST_METHOD' ข้อมูลจะถูกส่งด้วย
ประเภทเนื้อหาธรรมดา/ข้อความ มิฉะนั้น เชลล์สคริปต์จะถูกพิมพ์แบบคำต่อคำ

--เชลล์=เส้นทางพิเศษ
ระบุเชลล์แบบ bash-like ทางเลือกที่จะใช้ ค่าเริ่มต้นเป็น "bin / sh /"

หากต้องการรวมพารามิเตอร์เชลล์อย่าใช้ --shell=bin / sh / รูปแบบ. ให้ใช้ .แทน
รูปแบบทางเลือกที่ไม่มี "=" เช่นเดียวกับใน --shell "/ bin / bash --norc" อย่าลืม
อ้างสตริงตัวเลือกเพื่อป้องกันอักขระพิเศษใด ๆ

หากคอมไพล์ด้วยไลบรารี Lua สตริง "lua" จะถูกใช้เพื่อใช้การรวม
ลัวะ วีเอ็ม. สตริงนี้คำนึงถึงขนาดตัวพิมพ์ ตัวอย่าง: --เชลล์=ดวงจันทร์

อีกทางเลือกหนึ่งคือ "luac" สิ่งนี้ทำให้ haserl และ lua parsers ถูกปิดใช้งาน
และสคริปต์จะถือว่าเป็นกลุ่ม lua ที่คอมไพล์ล่วงหน้า ดู ลูเอค ด้านล่างสำหรับเพิ่มเติม
ข้อมูล

--เงียบ
โดยปกติแล้ว Haserl จะพิมพ์ข้อความแจ้งเกี่ยวกับเงื่อนไขข้อผิดพลาด นี้
ระงับข้อความแสดงข้อผิดพลาดเพื่อไม่ให้มีการโฆษณาการใช้ haserl

--อัพโหลด-dir=ไดร์สเปค
ค่าเริ่มต้นเป็น "/ Tmp" ไฟล์ที่อัปโหลดทั้งหมดถูกสร้างขึ้นด้วยชื่อไฟล์ชั่วคราวในนี้
ไดเรกทอรี HASRL_xxx_path มีชื่อของไฟล์ชั่วคราว FORM_xxx_name
มีชื่อเดิมของไฟล์ตามที่ลูกค้าระบุ

--upload-handler=เส้นทางพิเศษ
เมื่อระบุไว้ ไฟล์ที่อัปโหลดจะได้รับการจัดการโดยตัวจัดการนี้ แทนที่จะเขียนถึง
ไฟล์ชั่วคราว. ต้องระบุ pathspec แบบเต็ม (ไม่ได้ค้นหา PATH) และ
ตัวจัดการการอัปโหลดจะได้รับหนึ่งพารามิเตอร์บรรทัดคำสั่ง: ชื่อของ FIFO on
ซึ่งไฟล์อัพโหลดจะถูกส่ง นอกจากนี้ ตัวจัดการอาจได้รับ 3
ตัวแปรสภาพแวดล้อม: ชนิดของเนื้อหา, ชื่อไฟล์และ ชื่อ. สิ่งเหล่านี้สะท้อนถึง MIME
ส่วนหัวการจัดการเนื้อหาสำหรับเนื้อหา Haserl จะแยกตัวจัดการสำหรับแต่ละ
ไฟล์ที่อัพโหลดแล้วและจะส่งเนื้อหาของไฟล์อัพโหลดไปยัง FIFO ที่ระบุ
Haserl จะบล็อกจนกว่าตัวจัดการจะยุติลง วิธีนี้เหมาะสำหรับผู้เชี่ยวชาญ
เท่านั้น

--upload-จำกัด=จำกัด
อนุญาตไฟล์ที่เข้ารหัส mime ได้ถึง จำกัด KB ที่จะอัปโหลด ค่าเริ่มต้นคือ 0KB (ไม่ได้
อนุญาตให้อัพโหลดได้) โปรดทราบว่าการเข้ารหัส mime จะเพิ่ม 33% ให้กับขนาดของข้อมูล

ภาพรวม OF ในการดำเนินกิจการ

โดยทั่วไป เว็บเซิร์ฟเวอร์ตั้งค่าตัวแปรสภาพแวดล้อมหลายตัว แล้วใช้ ส้อม or
วิธีอื่นในการเรียกใช้สคริปต์ CGI หากสคริปต์ใช้ ฮาเซิ่ล ล่าม the
ต่อไปนี้เกิดขึ้น:

If ฮาเซิ่ล ได้รับการติดตั้ง suid root จากนั้น uid/gid จะถูกตั้งค่าเป็นเจ้าของสคริปต์

สภาพแวดล้อมถูกสแกนหา HTTP_COOKIEซึ่งอาจถูกกำหนดโดยเว็บ
เซิร์ฟเวอร์ หากมีอยู่ เนื้อหาที่แยกวิเคราะห์จะถูกวางไว้ในสภาพแวดล้อมท้องถิ่น

สภาพแวดล้อมถูกสแกนหา คำขอ_วิธีการซึ่งถูกกำหนดโดยเว็บเซิร์ฟเวอร์
ตามวิธีการขอ อินพุตมาตรฐานจะถูกอ่านและแยกวิเคราะห์ การแยกวิเคราะห์
เนื้อหาจะอยู่ในสภาพแวดล้อมท้องถิ่น

สคริปต์ถูก tokenized แยกวิเคราะห์ ฮาเซิ่ล โค้ดบล็อกจากข้อความดิบ ข้อความดิบคือ
แปลงเป็นคำสั่ง "echo" จากนั้นโทเค็นทั้งหมดจะถูกส่งไปยัง sub-shell

ฮาเซิ่ล ส้อมและเปลือกย่อย (โดยทั่วไป bin / sh /) เริ่มแล้ว

โทเค็นทั้งหมดจะถูกส่งไปยัง STDIN ของเชลล์ย่อย โดยมีการต่อท้าย ทางออก คำสั่ง

เมื่อเชลล์ย่อยสิ้นสุดลง ฮาเซิ่ล ล่ามดำเนินการทำความสะอาดขั้นสุดท้ายและ
แล้วสิ้นสุด

CLIENT SIDE INPUT

พื้นที่ ฮาเซิ่ล ล่ามจะถอดรหัสข้อมูลที่ส่งผ่านตัวแปรสภาพแวดล้อม HTTP_COOKIE และ
วิธี GET หรือ POST จากไคลเอนต์ และเก็บไว้เป็นตัวแปรสภาพแวดล้อมที่สามารถ
สามารถเข้าถึงได้โดย haserl ชื่อของตัวแปรตามชื่อที่ระบุในแหล่งที่มา
เว้นแต่คำนำหน้า ( รูปแบบ_) ถูกนำหน้า ตัวอย่างเช่น หากลูกค้าส่ง "foo=bar"
ตัวแปรสภาพแวดล้อมคือ FORM_foo=บาร์.

สำหรับเมธอด HTTP_COOKIE ตัวแปรจะถูกเก็บไว้ด้วยคำนำหน้าด้วย ( คุกกี้_) เพิ่ม
ตัวอย่างเช่น หาก HTTP_COOKIE มี "foo=bar" ตัวแปรสภาพแวดล้อมคือ
COOKIE_foo=บาร์.

สำหรับวิธี GET ข้อมูลที่ส่งในรูปแบบ %xx จะถูกแปลเป็นอักขระที่พวกเขา
เป็นตัวแทนและตัวแปรจะถูกเก็บไว้ด้วยคำนำหน้า ( GET_) เพิ่ม ตัวอย่างเช่น if
QUERY_STRING รวม "foo=bar" ตัวแปรสภาพแวดล้อมคือ GET_foo=บาร์.

สำหรับวิธี POST ตัวแปรจะถูกเก็บไว้ด้วยคำนำหน้า ( POST_) เพิ่ม สำหรับ
ตัวอย่าง หากโพสต์สตรีมมี "foo=bar" ตัวแปรสภาพแวดล้อมคือ POST_foo=บาร์.

นอกจากนี้ สำหรับวิธี POST หากข้อมูลถูกส่งโดยใช้ หลายส่วน / แบบฟอร์มข้อมูล การเข้ารหัส the
ข้อมูลจะถูกถอดรหัสโดยอัตโนมัติ โดยทั่วไปจะใช้เมื่อไฟล์ถูกอัพโหลดจากเว็บ
ลูกค้าที่ใช้ .

หมายเหตุ เมื่อไฟล์ถูกอัปโหลดไปยังเว็บเซิร์ฟเวอร์ ไฟล์นั้นจะถูกเก็บไว้ในไฟล์ อัพโหลด-dir
ไดเรกทอรี FORM_variable_name= มีชื่อไฟล์ที่อัพโหลด (as
ที่ลูกค้ากำหนด) HASRL_variable_path= มีชื่อไฟล์ใน
อัพโหลด-dir ที่เก็บเนื้อหาที่อัปโหลด เพื่อป้องกันไคลเอนต์ที่เป็นอันตรายจาก
เติมขึ้น อัพโหลด-dir บนเว็บเซิร์ฟเวอร์ของคุณ อนุญาตให้อัปโหลดไฟล์ได้ก็ต่อเมื่อ
--อัพโหลดจำกัด ตัวเลือกใช้เพื่อระบุขนาดไฟล์ที่สามารถอัปโหลดได้ Haserl
จะลบไฟล์ชั่วคราวโดยอัตโนมัติเมื่อสคริปต์เสร็จสิ้น เพื่อให้
ไฟล์ ย้ายหรือเปลี่ยนชื่อที่ใดที่หนึ่งในสคริปต์

โปรดทราบว่าชื่อไฟล์ถูกเก็บไว้ใน ฮาเซิร์ล_ตัวแปร_เส้นทาง ทั้งนี้เป็นเพราะ FORM_,
ตัวแปร GET_ และ POST_ สามารถแก้ไขได้โดยไคลเอนต์ และไคลเอนต์ที่เป็นอันตรายสามารถ
ตั้งค่าตัวแปรที่สองด้วยชื่อ Variable_path=/ etc / passwd. เวอร์ชันก่อนหน้า
ไม่ได้เก็บ pathspec ใน ฮาเซล เนมสเปซ ไปยัง เก็บรักษา ย้อนกลับ
ความเข้ากันได้, ชื่อ of ชั่วคราว ไฟล์ is ด้วย เก็บไว้ in FORM_ตัวแปร= และ
POST_ตัวแปร=. is ถือว่า ไม่ปลอดภัย และ น่า ไม่ be มือสอง

หากลูกค้าส่งข้อมูล ทั้งสอง โดยวิธี POST และ GET จากนั้น ฮาเซิ่ล จะแยกเฉพาะ
ข้อมูลที่สอดคล้องกับ คำขอ_วิธีการ ตัวแปรที่กำหนดโดยเว็บเซิร์ฟเวอร์ ยกเว้นกรณีที่
รับทั้งหมด ตั้งค่าตัวเลือกแล้ว เช่น เรียกแบบฟอร์มผ่านวิธี POST แต่มี
URI ของ some.cgi?foo=bar&otherdata=something จะมีการแยกวิเคราะห์ข้อมูล POST และ foo
และ ข้อมูลอื่นๆ ตัวแปรจะถูกละเว้น

หากเว็บเซิร์ฟเวอร์กำหนด a HTTP_COOKIE ตัวแปรสภาพแวดล้อม ข้อมูลคุกกี้จะถูกแยกวิเคราะห์
ข้อมูลคุกกี้ถูกแยกวิเคราะห์ ก่อน ข้อมูล GET หรือ POST ดังนั้นในกรณีที่มีตัวแปรสองตัวของ
ชื่อเดียวกัน ข้อมูล GET หรือ POST จะเขียนทับข้อมูลคุกกี้

เมื่อตัวแปรเดียวกันหลายตัวถูกส่งจากแหล่งที่ต่างกัน
FORM_variable จะถูกตั้งค่าตามลำดับการประมวลผลตัวแปร
HTTP_COOKIE จะถูกประมวลผลก่อนเสมอ ตามด้วย REQUEST_METHOD ถ้ารับทั้งหมด
ตั้งค่าตัวเลือกแล้ว HTTP_COOKIE จะถูกประมวลผลก่อน ตามด้วยเมธอดnot
ระบุโดย REQUEST_METHOD ตามด้วย REQUEST_METHOD ตัวอย่างสุดท้ายของ
ตัวแปรจะถูกใช้ในการตั้งค่า FORM_variable โปรดทราบว่าตัวแปรยังแยกจากกัน
สร้างเป็น COOKIE_variable, GET_variable และ POST_variable ซึ่งช่วยให้สามารถใช้
ชื่อที่ทับซ้อนกันจากแต่ละแหล่ง

เมื่อตัวแปรเดียวกันหลายอินสแตนซ์ถูกส่งจากแหล่งเดียวกัน เฉพาะตัวสุดท้ายเท่านั้น
หนึ่งจะถูกบันทึกไว้ หากต้องการเก็บสำเนาทั้งหมด (เช่น การเลือกหลายรายการ) ให้เพิ่ม "[]" ต่อท้าย
ของชื่อตัวแปร ผลลัพธ์ทั้งหมดจะถูกส่งกลับ โดยคั่นด้วยการขึ้นบรรทัดใหม่ ตัวอย่างเช่น,
host=Enoch&host=Esther&host=Joshua ให้ผลลัพธ์ใน "FORM_host=Joshua"
host[]=Enoch&host[]Esther&host[]=Joshua results in "FORM_host=Enoch\nEsther\nJoshua"

ภาษา

โครงสร้างภาษาต่อไปนี้ได้รับการยอมรับโดย ฮาเซิ่ล.

วิ่ง
<% [เชลล์สคริปต์] %>

สิ่งที่ปิดล้อมด้วยแท็ก <% %> จะถูกส่งไปยังเชลล์ย่อยเพื่อดำเนินการ ข้อความ
ถูกส่งเป็นคำต่อคำ

รวม
<% ใน pathspec %>

รวมไฟล์คำต่อคำอื่นในสคริปต์นี้ ไฟล์จะถูกรวมไว้เมื่อสคริปต์
ถูกแยกวิเคราะห์ในขั้นต้น

การประเมิน
<%= นิพจน์ %>

พิมพ์นิพจน์เชลล์ น้ำตาลวากยสัมพันธ์สำหรับ "echo expr"

วิธี
<%# ความคิดเห็น %>

บล็อกความคิดเห็น สิ่งใดในบล็อกความคิดเห็นจะไม่ถูกแยกวิเคราะห์ ความคิดเห็นสามารถซ้อนกันได้
และสามารถมีองค์ประกอบ haserl อื่น ๆ

ตัวอย่าง

คำเตือน
ตัวอย่างด้านล่างมีความเรียบง่ายเพื่อแสดงวิธีใช้ ฮาเซิ่ล. คุณควรจะ
คุ้นเคยกับการรักษาความปลอดภัยการเขียนสคริปต์เว็บขั้นพื้นฐานก่อนใช้งาน ฮาเซิ่ล (หรือสคริปต์ใดๆ
ภาษา) ในสภาพแวดล้อมการผลิต

ง่าย คำสั่ง
#!/usr/local/bin/haserl
ประเภทเนื้อหา: ข้อความ/ธรรมดา

<%# นี่คือตัวอย่างสคริปต์ "env" %>
<% env %>

พิมพ์ผลลัพธ์ของ env คำสั่งเป็นเอกสาร "ข้อความ/ธรรมดา" แบบ mime นี่คือ
ฮาเซิ่ล รุ่นทั่วไป เครื่องพิมพ์ ซีจี

วนลูป กับ พลวัต เอาท์พุต
#!/usr/local/bin/haserl
ประเภทเนื้อหา: text/html




<% สำหรับ a ใน สีแดง สีน้ำเงิน สีเหลือง สีฟ้า; ทำ%>
"><% echo -n "$a" %>
<% เสร็จแล้ว %>




ส่งเอกสาร mime-type "text/html" ไปยังไคลเอนต์โดยมีตาราง html เป็น with
องค์ประกอบที่มีสีพื้นหลัง

ใช้ เปลือก กำหนด ฟังก์ชั่น
#!/usr/local/bin/haserl
ประเภทเนื้อหา: text/html

<% # กำหนดฟังก์ชั่นผู้ใช้
ตารางธาตุ () {
เสียงสะท้อน " $1 "
}
%>



<% สำหรับ a ใน สีแดง สีน้ำเงิน สีเหลือง สีฟ้า; ทำ%>
<% table_element $a %>
<% เสร็จแล้ว %>




เช่นเดียวกับด้านบน แต่ใช้ฟังก์ชันเชลล์แทน HTML แบบฝัง

ตนเอง อ้างอิง CGI กับ a ฟอร์ม
#!/usr/local/bin/haserl
ประเภทเนื้อหา: text/html


แบบฟอร์มตัวอย่าง
" method="GET">
<% # ทำการตรวจสอบพื้นฐานของ FORM_textfield
#เพื่อป้องกันการโจมตีเว็บทั่วไป
FORM_textfield=$( echo "$FORM_textfield" | sed "s/[^A-Za-z0-9 ]//g" )
%>
<ประเภทอินพุต=ชื่อข้อความ=ฟิลด์ข้อความ
Value="<% echo -n "$FORM_textfield" | tr az AZ %>" cols=20>




พิมพ์แบบฟอร์ม หากไคลเอนต์ป้อนข้อความในแบบฟอร์ม CGI จะถูกโหลดซ้ำ (กำหนด
by $SCRIPT_NAME) และช่องข้อความจะถูกล้างเพื่อป้องกันการโจมตีเว็บ จากนั้น
แบบฟอร์มจะแสดงอีกครั้งพร้อมข้อความที่ผู้ใช้ป้อน ข้อความเป็นตัวพิมพ์ใหญ่

อัปโหลด a เนื้อไม่มีมัน
#!/usr/local/bin/haserl --upload-limit=4096 --upload-dir=/ Tmp
ประเภทเนื้อหา: text/html


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



<% ถ้า test -n "$HASERL_uploadfile_path"; แล้ว %>

คุณอัปโหลดไฟล์ชื่อ <% echo -n $FORM_uploadfile_name %> และมันก็เป็น
. เก็บไว้ชั่วคราวบนเซิร์ฟเวอร์เป็น ดิ
ไฟล์คือ <% cat $HASERL_uploadfile_path | wc -c %> ไบต์ยาว
<% rm -f $HASERL_uploadfile_path %> ไม่ต้องกังวล ไฟล์เพิ่งถูกลบ
จากเว็บเซิร์ฟเวอร์
<% อื่น %>
คุณยังไม่ได้อัปโหลดไฟล์
<% fi %>



แสดงแบบฟอร์มที่อนุญาตให้อัปโหลดไฟล์ ทำได้โดยใช้
--อัพโหลดจำกัด และโดยการกำหนดรูปแบบ เข้ารหัส ไปยัง หลายส่วน/ข้อมูลแบบฟอร์ม ถ้า
ลูกค้าส่งไฟล์ จากนั้นข้อมูลบางอย่างเกี่ยวกับไฟล์จะถูกพิมพ์ จากนั้น
ถูกลบ มิฉะนั้น แบบฟอร์มจะระบุว่าไคลเอ็นต์ไม่ได้อัปโหลดไฟล์

อาร์เอฟซี-2616 สอดคล้อง
#!/usr/local/bin/haserl
<% echo -en "content-type: text/html\r\n\r\n" %>

...


เพื่อให้เป็นไปตามข้อกำหนด HTTP อย่างสมบูรณ์ ส่วนหัวควรถูกยกเลิกโดยใช้
CR+LF แทนที่จะสิ้นสุดบรรทัด unix LF ปกติเท่านั้น ไวยากรณ์ข้างต้นสามารถ
ใช้ในการผลิตส่วนหัวที่สอดคล้องกับ RFC 2616

และพวกเรา

นอกเหนือจากตัวแปรสภาพแวดล้อมที่สืบทอดมาจากเว็บเซิร์ฟเวอร์แล้ว ดังต่อไปนี้
ตัวแปรสภาพแวดล้อมถูกกำหนดเสมอเมื่อเริ่มต้น:

ฮาเซอร์ลแวร์
ฮาเซิ่ล รุ่น - แท็กข้อมูล

รหัสเซสชัน
แท็กเลขฐานสิบหกที่ไม่ซ้ำกันสำหรับชีวิตของ CGI (จะถูกสร้างขึ้นเมื่อ
cgi เริ่ม; และไม่เปลี่ยนแปลงจนกว่าจะสร้างข้อความค้นหา POST หรือ GET อื่น)

HASERL_ACCEPT_ALL
ถ้า --ยอมรับทั้งหมด ธงถูกตั้ง -1มิฉะนั้น 0.

HASRL_SHELL
ชื่อของเชลล์ haserl เริ่มรันคำสั่ง sub-shell ใน

HASRL_UPLOAD_DIR
haserl ไดเร็กทอรีจะใช้เพื่อเก็บไฟล์ที่อัพโหลด

HASRL_UPLOAD_LIMIT
จำนวน KB ที่อนุญาตให้ส่งจากไคลเอนต์ไปยังเซิร์ฟเวอร์

ตัวแปรเหล่านี้สามารถแก้ไขหรือเขียนทับได้ภายในสคริปต์ ถึงแม้ว่าตัวแปรเหล่านั้น
ที่ขึ้นต้นด้วย "HASERL_" เป็นข้อมูลเท่านั้น และไม่มีผลกับสคริปต์ที่ทำงานอยู่

ความปลอดภัย คุณลักษณะเด่น

มีวรรณกรรมมากมายเกี่ยวกับอันตรายของการใช้เชลล์ในการเขียนโปรแกรมสคริปต์ CGI
ฮาเซิ่ล มี บาง การป้องกันเพื่อลดความเสี่ยงนี้

สิ่งแวดล้อม ตัวแปร
รหัสเพื่อเติมตัวแปรสภาพแวดล้อมอยู่นอกขอบเขตของ sub-
เปลือก. มันแยกวิเคราะห์ตัวละคร ? และ & จึงเป็นเรื่องยากสำหรับลูกค้าที่จะทำ
การโจมตีแบบ "ฉีด" ตัวอย่างเช่น, foo.cgi?a=test;แมว / etc / passwd อาจส่งผลให้
ตัวแปรที่ได้รับการกำหนดค่า ทดสอบ แล้วผลการวิ่ง แมว
/ etc / passwd กำลังส่งให้ลูกค้า ฮาเซิล จะกำหนดตัวแปรให้สมบูรณ์
ราคา: ทดสอบ;แมว / etc / passwd

การใช้ตัวแปร "อันตราย" นี้ในเชลล์สคริปต์ได้อย่างปลอดภัยโดยใส่ไว้ใน
คำพูด; แม้ว่าการตรวจสอบความถูกต้องควรทำในทุกช่องป้อนข้อมูล

สิทธิพิเศษ ลดลง
หากติดตั้งเป็นสคริปต์ suid ฮาเซิ่ล จะตั้งค่า uid/gid ของเจ้าของ
บท. สามารถใช้เพื่อให้มีชุดของสคริปต์ CGI ที่หลากหลาย
สิทธิพิเศษ. ถ้า ฮาเซิ่ล ไม่ได้ติดตั้งไบนารี suid จากนั้นสคริปต์ CGI จะ
ทำงานด้วย uid/gid ของเว็บเซิร์ฟเวอร์

ปฏิเสธ คำสั่ง เส้น พารามิเตอร์ กำหนด on URL
หาก URL ไม่มี "=" ที่ไม่ได้เข้ารหัส ข้อมูลจำเพาะ CGI จะระบุตัวเลือก
เพื่อใช้เป็นพารามิเตอร์บรรทัดคำสั่งของโปรแกรม ตัวอย่างเช่นตาม
ตามข้อกำหนด CGI: http://192.168.0.1/test.cgi?--upload-limit%3d2000&foo%3dbar
ควรตั้งค่าจำกัดการอัปโหลดเป็น 2000KB นอกเหนือจากการตั้งค่า "Foo=bar" ป้องกัน
กับลูกค้าที่เปิดใช้งานการอัปโหลดของตนเอง ฮาเซิ่ล ปฏิเสธตัวเลือกบรรทัดคำสั่งใด ๆ
เกิน argv[2] ถ้าเรียกเป็น #! สคริปต์, ล่ามคือ argv[0], all
ตัวเลือกบรรทัดคำสั่งที่แสดงอยู่ใน #! เส้นรวมกันเป็น argv[1] และ the
ชื่อสคริปต์คือ argv[2]

หลัว

หากรวบรวมด้วยการสนับสนุน lua --shell=ลัวะ จะเปิดใช้งาน lua เป็นภาษาสคริปต์แทน
ของเปลือกทุบตี ตัวแปรสภาพแวดล้อม (SCRIPT_NAME, SERVER_NAME ฯลฯ) ถูกวางไว้ใน
ตาราง ENV และตัวแปรแบบฟอร์มจะอยู่ในตารางแบบฟอร์ม ตัวอย่างเช่น
แบบฟอร์มอ้างอิงตัวเองด้านบนสามารถเขียนได้ดังนี้:

#!/usr/local/bin/haserl --shell=lua
ประเภทเนื้อหา: text/html


แบบฟอร์มตัวอย่าง
" method="GET">
<% # ทำการตรวจสอบพื้นฐานของ FORM_textfield
#เพื่อป้องกันการโจมตีเว็บทั่วไป
FORM.textfield=string.gsub(FORM.textfield, "[^%a%d]", "")
%>
<ประเภทอินพุต=ชื่อข้อความ=ฟิลด์ข้อความ
ค่า="<% io.write (string.upper(FORM.textfield)) %>" cols=20>




ตัวดำเนินการ <%= คือน้ำตาลประโยคสำหรับ io.เขียน (โทสตริง( ... )) ตัวอย่างเช่น
ค่า= บรรทัดด้านบนสามารถเขียนได้: ค่า="<%= string.upper(FORM.ฟิลด์ข้อความ) %>" cols=20>

สคริปต์ haserl lua สามารถใช้ฟังก์ชันได้ haserl.โหลดไฟล์(ชื่อไฟล์) เพื่อประมวลผลเป้าหมาย
สคริปต์เป็นสคริปต์ haserl (lua) ฟังก์ชันส่งคืนประเภทของ "ฟังก์ชัน"

ตัวอย่างเช่น

บาร์.แอลเอสพี
<% io.write ("สวัสดีชาวโลก") %>

ข้อความของคุณคือ <%= gvar %>

-- สิ้นสุดไฟล์รวม --

foo.haserl
#!/usr/local/bin/haserl --shell=lua
<% m = haserl.loadfile("bar.lsp")
gvar = "เรียกใช้เป็น m()"
ม. ()

gvar = "โหลดและรันในขั้นตอนเดียว"
haserl.loadfile("bar.lsp")()
%>

เล่น foo จะผลิต:

สวัสดีชาวโลก
ข้อความของคุณทำงานเป็น m()
-- สิ้นสุดไฟล์รวม --
สวัสดีชาวโลก
ข้อความของคุณกำลังโหลดและเรียกใช้ในขั้นตอนเดียว
-- สิ้นสุดไฟล์รวม --

ฟังก์ชันนี้ทำให้สามารถซ้อนหน้าเซิร์ฟเวอร์ haserl - page snippets
ที่ประมวลผลโดย haserl tokenizer

ลูเอค

พื้นที่ ลุก "เชลล์" เป็น lua ที่คอมไพล์ล่วงหน้า ดังนั้นการแก้ไขและทดสอบสคริปต์แบบโต้ตอบ
เป็นไปไม่ได้ อย่างไรก็ตาม haserl สามารถคอมไพล์ได้ด้วยการสนับสนุน luac เท่านั้นและสิ่งนี้ช่วยให้
lua รองรับแม้ในสภาพแวดล้อมหน่วยความจำขนาดเล็ก คุณสมบัติ haserl lua ทั้งหมดที่ระบุไว้ข้างต้นคือ
ยังคงใช้ได้ (หาก luac เป็นเชลล์เดียวที่สร้างไว้ใน haserl แล้ว haserl.loadfile จะเป็น
ปิดการใช้งานเนื่องจากไม่ได้รวบรวม haserl parser)

นี่คือตัวอย่างของสคริปต์เล็กน้อยที่แปลงเป็นสคริปต์ luac cgi:

รับไฟล์ test.lua:
พิมพ์ ("เนื้อหา-ประเภท: ข้อความ/ธรรมดา0)
พิมพ์ ("UUID ของคุณสำหรับการเรียกใช้ครั้งนี้คือ: " .. ENV.SESSIONID)

สามารถคอมไพล์ด้วย luac:
luac -o test.luac -s test.lua

จากนั้นส่วนหัว haserl ก็เพิ่มเข้าไป:
echo '#!/usr/bin/haserl --shell=luac' | แมว - test.luac >luac.cgi

อีกทางหนึ่ง เป็นไปได้ที่จะพัฒนาเว็บไซต์ทั้งหมดโดยใช้ lua shell มาตรฐาน
จากนั้นให้ haserl ประมวลผลสคริปต์ล่วงหน้าสำหรับคอมไพเลอร์ luac ซึ่งเป็นส่วนหนึ่งของa
กระบวนการสร้าง ในการดำเนินการนี้ ให้ใช้ --shell=lua และพัฒนาเว็บไซต์ เมื่อพร้อมที่จะสร้าง
สภาพแวดล้อมรันไทม์ เพิ่ม --debug บรรทัดในสคริปต์ lua ของคุณและเรียกใช้เอาต์พุต
ผลลัพธ์ไปยังไฟล์ต้นฉบับ .lua ตัวอย่างเช่น:

รับสคริปต์ haserl test.cgi:
#!/usr/bin/haserl --shell=lua --debug
เนื้อหา-ประเภท: ข้อความ/ธรรมดา

UUID ของคุณสำหรับการรันนี้คือ <%= ENV.SESSIONID %>

คอมไพล์ล่วงหน้า คอมไพล์ และเพิ่มส่วนหัว haserl luac:
./test.cgi > test.lua
luac -s -o test.luac test.lua
echo '#!/usr/bin/haserl --shell=luac' | แมว - test.luac >luac.cgi

ใช้ haserl ออนไลน์โดยใช้บริการ onworks.net