ป้องกันการโจมตีแบบฉีดใน ASP.NET [การแปล]

ที่มา: MSDN

ขอบเขตการสมัคร

Yunzhongcheng BLOG

ASP.NET เวอร์ชัน 1.1.1
ASP.NET เวอร์ชัน 2.0

สรุป:

ข้อความนี้แนะนำวิธีการตรวจสอบอินพุตของผู้ใช้เป็นหลัก เพื่อป้องกันการโจมตีแบบฉีด จำเป็นอย่างยิ่งที่จะต้องตรวจสอบการโจมตีระดับโปรแกรมเกือบทั้งหมดมีวิธีอินพุตที่เป็นอันตราย

คุณควรตรวจสอบรวมถึงฟิลด์ พารามิเตอร์สตริงการสืบค้น คุกกี้ และผู้ใช้รายอื่น รายการอินพุตถูกใช้เพื่อปกป้องโปรแกรมของคุณจากการโจมตีแบบฉีด คุณต้องถือว่าอินพุตของผู้ใช้ทั้งหมดเป็นอันตรายและให้แน่ใจว่าอินพุตของผู้ใช้ทั้งหมดได้รับการตรวจสอบบนฝั่งเซิร์ฟเวอร์ การใช้การตรวจสอบความถูกต้องตามไคลเอ็นต์สามารถลดจำนวนการเข้าพักของเพจได้ ปรับปรุงประสิทธิภาพ และปรับปรุงประสบการณ์ผู้ใช้ แต่อย่าพึ่งพาสิ่งนี้เพียงอย่างเดียว เนื่องจากแฮกเกอร์สามารถหลอกการตรวจสอบฝั่งไคลเอ็นต์ได้อย่างง่ายดาย

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

หากคุณต้องการยอมรับอินพุตอักขระ HTML วิธีที่ดีที่สุดคือใช้วิธีการเช่น HtmlEncode เพื่อเข้ารหัสอย่างปลอดภัยก่อนที่จะแสดง

เนื้อหา:

ภาพรวม

วัตถุประสงค์

ฟีดการใช้งานทีละขั้นตอน

ขั้นตอนที่ 1 การใช้ ASP การตรวจสอบคำขอ NET

ตอน

ที่ 2 ใช้อินพุตข้อจำกัดด้านสิทธิ์

ขั้น

4

ใช้พารามิเตอร์คำสั่งสำหรับคำสั่ง Sql

-------------------------------------------------- -------------------------------------------------- ------------------------------

วัตถุประสงค์:

จำกัดความยาวสตริงอินพุต ช่วง รูปแบบ และประเภท
ใช้การตรวจสอบคำขอเพื่อป้องกันการโจมตีแบบฉีดเมื่อพัฒนาโปรแกรม ASP.NET
ใช้ตัวควบคุมการตรวจสอบ ASP.NET สำหรับการตรวจสอบอินพุต
เข้ารหัสเอาต์พุตที่ไม่ปลอดภัย
ป้องกันการโจมตีแบบฉีดโดยใช้รูปแบบชุดพารามิเตอร์คำสั่ง
ป้องกันไม่ให้รายละเอียดข้อผิดพลาดถูกส่งกลับไปยังไคลเอนต์
ภาพรวม:

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

การตรวจสอบอินพุตที่อ่อนแอมักจะให้โอกาสในการโจมตีแบบฉีด ต่อไปนี้เป็นวิธีการโจมตีทั่วไปโดยใช้การตรวจสอบอินพุตที่อ่อนแอหรือไม่มีการตรวจสอบอินพุต

การแทรก SQL หากคุณใช้ค่าอินพุตของผู้ใช้เพื่อสร้างคำสั่ง SQL แบบไดนามิกฐานข้อมูลอาจดำเนินการคำสั่ง SQL ที่น่ารังเกียจและเป็นอันตราย
การโจมตีด้วยสคริปต์ข้ามไซต์ใช้ประโยชน์จากช่องโหว่ในการตรวจสอบความถูกต้องของหน้าเว็บเพื่อแทรกสคริปต์ฝั่งไคลเอ็นต์ จากนั้นรหัสเหล่านี้จะถูกส่งไปยังคอมพิวเตอร์ไคลเอนต์ที่เชื่อถือได้และตีความและดำเนินการโดยเบราว์เซอร์ เบราว์เซอร์ไม่มีทางรู้ได้ว่าโค้ดนั้นเป็นอันตราย
การเข้าถึงไฟล์โดยไม่ได้รับอนุญาต หากรหัสของคุณยอมรับอินพุตจากผู้โทร ผู้ใช้ที่เป็นอันตรายจะสามารถเห็นการทำงานของไฟล์และเข้าถึงไฟล์ที่ได้รับการป้องกัน หรือใช้รหัสของคุณเพื่อแทรกข้อมูลที่ผิดกฎหมาย

หมายเหตุ: การโจมตีแบบฉีดสามารถทำได้โดยใช้การเชื่อมต่อ HTTP หรือ HTTPS Secure Socket Layer (SSL

) เช่นกล่องข้อความและฟิลด์อินพุตแบบฟอร์มอื่นๆ พารามิเตอร์สตริงการสืบค้น คุกกี้ ตัวแปรฝั่งเซิร์ฟเวอร์ และพารามิเตอร์วิธีเครือข่าย โปรดทราบว่ากลยุทธ์การกรองควรอนุญาตเฉพาะอินพุตที่ถูกต้องและปฏิเสธอินพุตที่ไม่ถูกต้อง เนื่องจากการกำหนดกลยุทธ์อินพุตที่ถูกต้องคือ ดีกว่าการกรองทั้งหมด ตรวจพบอินพุตที่ผิดกฎหมายได้ง่ายกว่า แต่โดยปกติแล้วจะรวมอินพุตที่ผิดกฎหมายทั้งหมดได้

ยาก

ข้อจำกัด ตรวจสอบว่าอินพุตเป็นประเภท ความยาวอักขระ รูปแบบ และช่วงที่ถูกต้อง สามารถใช้ตัวควบคุมการตรวจสอบความถูกต้องของเซิร์ฟเวอร์เพื่อจำกัดอินพุตควบคุมเซิร์ฟเวอร์ได้
ปฏิเสธ ตรวจจับการป้อนข้อมูลที่เป็นอันตรายและปฏิเสธ
การกรอง บางครั้งคุณอาจต้องการกรองการป้อนข้อมูลของผู้ใช้ที่ก่อให้เกิดความเสี่ยงด้านความปลอดภัยออกไป ตัวอย่างเช่น หากแอปพลิเคชันของคุณอนุญาตให้มีการป้อนข้อมูลในรูปแบบอิสระ เช่น ช่องบันทึก คุณจะอนุญาตแท็ก HTML ที่ปลอดภัย เช่น <b>, <i > และแท็ก HTML อื่นๆ

สรุปขั้นตอน

ปกป้องแอปพลิเคชัน ASP.NET ของคุณจากการโจมตีแบบฉีดโดยทำตามขั้นตอนเหล่านี้:

ขั้นตอนที่ 1 ใช้การตรวจสอบคำขอ ASP.NET
ขั้นตอนที่ 2 จำกัดอินพุต
ขั้นตอนที่ 3 เข้ารหัสเอาต์พุตที่ไม่ปลอดภัย
ขั้นตอนที่ 4 ใช้พารามิเตอร์คำสั่งสำหรับคำสั่งแบบสอบถาม SQL
ขั้นตอนที่ 5 ตรวจสอบว่าข้อมูลข้อผิดพลาด ASP.NET จะไม่รั่วไหลไปยังไคลเอนต์

บทต่อไปนี้จะกล่าวถึงขั้นตอนเหล่านี้โดยละเอียด

ขั้นตอนที่ 1 ใช้การตรวจสอบคำขอ ASP.NET

ตามค่าเริ่มต้น การตรวจสอบคำขอ ASP.NET 1.1 และ 2.0 จะตรวจสอบว่าข้อมูลที่ส่งไปยังเซิร์ฟเวอร์ประกอบด้วยองค์ประกอบมาร์กอัป HTML และอักขระที่สงวนไว้หรือไม่ จากการป้อนสคริปต์ลงในโปรแกรม การตรวจสอบความถูกต้องของคำขอจะถูกจับคู่กับรายการสตริงที่อาจเป็นอันตราย และหากพบข้อยกเว้น ก็จะส่งข้อยกเว้นประเภท HttpRequestValidationException

คุณสามารถทำได้ในไฟล์ web.config ของคุณโดย < เพิ่ม validateRequest= "false" ไปยังองค์ประกอบเพจ> หรือตั้งค่า ValidateRequest = "false" ในองค์ประกอบ @Pages ของเพจแยกต่างหากเพื่อปิดใช้งานคุณสมบัตินี้

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

ให้แน่ใจว่าได้เปิดใช้งานคุณลักษณะการตรวจสอบคำขอในไฟล์ Machine.config

แล้ว คุณลักษณะการตรวจสอบคำขอถูกเปิดใช้งานตามค่าเริ่มต้นใน ASP.NET คุณ สามารถทำได้ในไฟล์ Machine.config.comments คุณเห็นการตั้งค่าเริ่มต้นต่อไปนี้

<pages validateRequest = "true" ... />

ตรวจสอบให้แน่ใจว่าคุณไม่ได้แก้ไขการตั้งค่าเริ่มต้นใน Machine.config ของเซิร์ฟเวอร์และเว็บของแอปพลิเคชัน ไฟล์ config

ทดสอบการตรวจสอบคำขอ ASP.NET

คุณสามารถทดสอบผลของการตรวจสอบความถูกต้องของคำขอได้ สร้างเพจ ASP.NET และปิดใช้งานการตรวจสอบความถูกต้องของคำขอโดยการตั้งค่า ValidateRequest = "fasle" ดังนี้:

<%@ ภาษา = "C#" ValidateRequest = "false" %>
<html>
<script runat="เซิร์ฟเวอร์">
เป็นโมฆะ btnSubmit_Click (ผู้ส่งวัตถุ EventArgs e)
-
// หาก ValidateRequest เป็นเท็จ แสดงว่า 'สวัสดี'
// ถ้า ValidateRequest เป็นจริง ASP.NET จะส่งกลับข้อยกเว้น
Response.Write (txtString.Text);
-
</สคริปต์>
<ร่างกาย>
<form id="form1" runat="server">
<asp:TextBox id = "txtString" runat = "เซิร์ฟเวอร์"
Text="<script>alert('hello');</script>" />
<asp:Button id = "btnSubmit" runat = "เซิร์ฟเวอร์" OnClick = "btnSubmit_Click"
ข้อความ = "ส่ง" />
</แบบฟอร์ม>
</ร่างกาย>
</html>

เมื่อคุณเรียกใช้เพจ "Hello" จะแสดงในกล่องข้อความเนื่องจากมีการดำเนินการและประมวลผลสคริปต์ใน txtString โดยเบราว์เซอร์ของไคลเอ็นต์

หากคุณตั้งค่า ValidateRequest = "true" หรือลบแอตทริบิวต์ของเพจ ValidateRequest การตรวจสอบคำขอ ASP .NET จะปฏิเสธอินพุตสคริปต์และแสดงข้อความแสดงข้อผิดพลาดเหมือนกับข้อความด้านล่าง

ตรวจพบค่า Request.Form ที่อาจเป็นอันตรายจากไคลเอนต์ (txtString="<script>alert('hello")

ระวังอย่าใช้ฟังก์ชันการยืนยันคำขอเพียงอย่างเดียว แต่ใช้เป็นเพียงวิธีการแนะนำสำหรับการตรวจสอบแบบกำหนดเองเท่านั้น

ขั้นตอนที่ 2 จำกัดอินพุต

หากต้องการจำกัดอินพุต ให้ใช้วิธีการต่อไปนี้:

ใช้การตรวจสอบอินพุตฝั่งเซิร์ฟเวอร์ ไม่ต้องพึ่งพาการตรวจสอบฝั่งไคลเอ็นต์ เนื่องจากสามารถข้ามการตรวจสอบฝั่งไคลเอ็นต์ได้อย่างง่ายดาย เพื่อลดจำนวนการตีกลับของหน้า ปรับปรุงประสิทธิภาพ และปรับปรุงประสบการณ์ผู้ใช้
ตรวจสอบความยาว ช่วง รูปแบบ และประเภทของอินพุต ตรวจสอบให้แน่ใจว่าเนื้อหาอินพุตถูกต้องและตรงตามข้อกำหนด
ใช้ประเภทข้อมูลที่รัดกุม ระบุประเภท เช่น Integer หรือ Double สำหรับการป้อนตัวเลข

สอบ

ฟิลด์อินพุตควบคุม HTML ในแบบฟอร์ม ให้ดำเนินการตรวจสอบในโค้ดฝั่งเซิร์ฟเวอร์ การใช้ประเภทนิพจน์ทั่วไป Regex สามารถช่วยจำกัดการป้อนอักขระได้ ส่วนต่อไปนี้จะอธิบายวิธีการจำกัดตัวแปรของประเภทอินพุตทั่วไป

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

ใช้การควบคุมการตรวจสอบนิพจน์ทั่วไป (RegularExpresionValidator)

เมื่อต้องการใช้การควบคุมการตรวจสอบนิพจน์ทั่วไป คุณต้องตั้งชื่อตัวควบคุมที่จะตรวจสอบ (ControlToValidate) นิพจน์การตรวจสอบ (ValidationExpression) และข้อความแสดงข้อผิดพลาด (ErrorMessage) สำหรับการตั้งค่าคุณสมบัติที่เกี่ยวข้อง โปรดดูรหัส ตัวอย่างด้านล่าง

<form id="WebForm" method="post" runat="server">
<asp:TextBox id="txtName" runat="server"></asp:TextBox>
<asp:RegularExpressionValidator id = "nameRegex" runat = "เซิร์ฟเวอร์"
ControlToValidate = "txtName"
ValidationExpression="^[a-zA-Z'.s]{1,40}$"
ErrorMessage="ชื่อไม่ถูกต้อง">
</asp:regularexpressionvalidator>
</แบบฟอร์ม>

ในโค้ดข้างต้น นิพจน์ทั่วไปใช้เพื่อจำกัดชื่ออินพุตให้เป็นตัวอักษร (อนุญาตให้ใช้อักษรตัวพิมพ์ใหญ่และตัวพิมพ์เล็ก) ช่องว่าง ชื่อวงรีชื่อเดียว เช่น O'Dell และจุด นอกจากนี้ ความยาวอักขระอินพุตยังจำกัดอยู่ที่ 40 อักขระ อักขระ

โปรดทราบว่าตัวควบคุมการตรวจสอบนิพจน์ทั่วไป (RegularExpressionValidator) จะเพิ่มเครื่องหมายรูปหมวก (^) และเครื่องหมายดอลลาร์ ($) เป็นตัวคั่นเริ่มต้นและสิ้นสุดโดยอัตโนมัติ หากคุณไม่ได้เพิ่มอักขระเหล่านั้นในนิพจน์แบบกำหนดเอง วิธีที่ดีที่สุดคือเพิ่ม การเพิ่มตัวคั่นเป็นเพียงเพื่อให้นิพจน์ของคุณได้รับส่วนหนึ่งของข้อมูลที่คุณต้องการ

ใช้คลาสนิพจน์ทั่วไป (คลาส Regex)

หากคุณไม่ได้ใช้การควบคุมฝั่งเซิร์ฟเวอร์ (หมายความว่าคุณไม่สามารถใช้การควบคุมการตรวจสอบความถูกต้องอื่น ๆ ได้) แหล่งที่มาของฟิลด์อินพุตอื่นที่ไม่ใช่ฟิลด์แบบฟอร์ม (เช่นพารามิเตอร์สตริงการสืบค้นและคุกกี้) คุณสามารถใช้คลาสนิพจน์ทั่วไป (คลาส Regex)

ใช้คลาสนิพจน์ทั่วไป

เพื่อนำเข้าเนมสเปซ System.Text.RegularExpressions โดยการเพิ่มคำสั่งโดยใช้ คำนำหน้า
ตรวจสอบให้แน่ใจว่านิพจน์ทั่วไปมี "^" และ "$" (ที่จุดเริ่มต้นของสตริง ที่ส่วนท้ายของสตริง)
เรียกวิธีการIsMatchของคลาส Regex ต่อไปนี้เป็นตัวอย่างโค้ด

// วิธีการตัวอย่าง:
Regex reg = Regex ใหม่(@"^[a-zA-Z'.s]{1,40}$");
Response.Write(reg.IsMatch(txtName.Text));

// วิธีการคงที่:
ถ้า (!Regex.IsMatch(txtName.Text,@"^[a-zA-Z'.s]{1,40}$"))
-
// ชื่อไม่ตรงกับนิพจน์
-

หากคุณไม่สามารถแคชนิพจน์ทั่วไปที่ใช้บ่อยได้ คุณควรใช้วิธี IsMatch แบบคงที่เพื่อปรับปรุงประสิทธิภาพและป้องกันการสร้างวัตถุที่ไม่จำเป็น

ที่เป็นตัวเลข

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

หากต้องการใช้ตัวควบคุม RangeValidator คุณต้องตั้งชื่อตัวควบคุม (ControlToValidate) ประเภท (ประเภท) และค่าต่ำสุด (MinimumValue) ) ค่าสูงสุด (MaximumValue) และคุณสมบัติข้อความแสดงข้อผิดพลาด (ErrorMessage) นี่คือตัวอย่างโค้ด:

<asp:RangeValidator
ID = "ช่วง Validator1"
Runat = "เซิร์ฟเวอร์"
ErrorMessage="ช่วงไม่ถูกต้อง ตัวเลขต้องอยู่ระหว่าง 0 ถึง 255"
ControlToValidate = "ช่วงอินพุต"
ค่าสูงสุด = "255"
MinimumValue="0" Type="จำนวนเต็ม" />

หากคุณไม่ได้ใช้ตัวควบคุมเซิร์ฟเวอร์ คุณสามารถตรวจสอบช่วงตัวเลขให้เสร็จสิ้นได้โดยการแปลงค่าอินพุตเป็นจำนวนเต็ม จากนั้นตรวจสอบความถูกต้อง ตัวอย่างเช่น เมื่อต้องการตรวจสอบว่าจำนวนเต็มถูกต้องหรือไม่ ให้ใช้วิธีการใหม่ Int32.TryParse ที่ได้รับจาก ASP.NET 2.0 เพื่อแปลงค่าอินพุตเป็นประเภทตัวแปรของ System.Int32 วิธีนี้จะคืนค่าเท็จหากการแปลงล้มเหลว

Int32 ฉัน;
ถ้า (Int32.TryParse (txtInput.Text, ออก i) == false)
-
//การแปลงล้มเหลว
-

หากคุณกำลังใช้ ASP.NET เวอร์ชันก่อนหน้า คุณสามารถใช้เมธอด Int32.Parse หรือ Convert.ToInt32 ในบล็อก try/catch และจัดการ FormatException ที่เกิดขึ้นเมื่อการแปลงล้มเหลว

รหัสตัวอย่างต่อไปนี้สาธิตวิธีการตรวจสอบ จาก HTML ประเภทและช่วงของประเภทจำนวนเต็มของกล่องข้อความ

<%@ ภาษาเพจ = "C#" %>

<script runat = "เซิร์ฟเวอร์">

เป็นโมฆะ Page_Load (ผู้ส่งวัตถุ EventArgs e)
-
ถ้า (Request.RequestType == "POST")
-
ฉัน;
ถ้า (Int32.TryParse(Request.Form["integerTxt"], ออก i) == true)
-
// TryParse คืนค่าเป็นจริงหากการแปลงสำเร็จ
ถ้า ((0 <= ฉัน && ฉัน <= 255) == จริง)
-
Response.Write("ข้อมูลที่ป้อนถูกต้อง");
-
อื่น
Response.Write("ข้อมูลเข้าอยู่นอกขอบเขต");
-
อื่น
Response.Write("ข้อมูลที่ป้อนไม่ใช่จำนวนเต็ม");
-
-

</สคริปต์>

<html>
<ร่างกาย>
<form id = "form1" action = "NumericInput.aspx" method = "โพสต์">
<div>
ป้อนจำนวนเต็มระหว่าง 0 ถึง 255:
<ชื่ออินพุต = "integerTxt" type = "ข้อความ" />
<ชื่ออินพุต = "ส่ง" ประเภท = "ส่ง" ค่า = "ส่ง" />
</div>
</แบบฟอร์ม>
</ร่างกาย>
</html>

การตรวจสอบความถูกต้องของฟิลด์วันที่

คุณต้องตรวจสอบว่าฟิลด์วันที่นั้นเป็นประเภทที่ถูกต้อง ในกรณีส่วนใหญ่ คุณจะต้องตรวจสอบช่วงของฟิลด์เหล่านั้นด้วย เช่น ตรวจสอบว่าฟิลด์เหล่านั้นอยู่ในอนาคตหรือในอดีต หากคุณใช้ตัวควบคุมเซิร์ฟเวอร์ เพื่อบันทึกค่าอินพุตวันที่ และหากคุณต้องการให้ค่าอยู่ในช่วงที่ระบุ คุณสามารถใช้ตัวควบคุมการตรวจสอบช่วง (RangeValidator) และตั้งค่าประเภทที่อนุญาตเป็นประเภทวันที่ การควบคุมนี้ช่วยให้คุณระบุช่วงเวลาพิเศษได้ โดยการตั้งค่าช่วงเวลาเริ่มต้น หากคุณต้องการใช้เวลาวันนี้เป็นข้อมูลอ้างอิงในการตรวจสอบ เช่น การตรวจสอบว่าเวลาเป็นเวลาในอนาคตหรือในอดีต คุณสามารถใช้การควบคุมการตรวจสอบความถูกต้องของ CustomValidator
การใช้ตัวควบคุม CustomValidator เพื่อตรวจสอบวันที่จำเป็นต้องมีการตั้งค่าคุณสมบัติ ControlToValidate และ ErrorMessage และระบุวิธีการตรวจสอบตรรกะแบบกำหนดเองในเหตุการณ์ OnServerValidate ต่อไปนี้คือโค้ดตัวอย่าง

<%@ ภาษาเพจ = "C#" %>

<script runat = "เซิร์ฟเวอร์">

เป็นโมฆะ ValidateDateInFuture (แหล่งที่มาของวัตถุ ServerValidateEventArgs args)
-
DateTime dt;

// ตรวจสอบวันที่ที่ถูกต้องและเป็นวันที่ในอนาคต
ถ้า ((DateTime.TryParse (args.Value, ออก dt) == false) ||
(dt <= DateTime.วันนี้))
-
args.IsValid = เท็จ;
-
}

</สคริปต์>

<html>
<ร่างกาย>
<form id="form1" runat="server">
<div>
<asp:Label ID = "Label1" Runat = "เซิร์ฟเวอร์"
Text="วันที่ในอนาคต:"></asp:Label>
<asp:TextBox ID="futureDatetxt" Runat="เซิร์ฟเวอร์"></asp:TextBox>
<asp:CustomValidator
ID = "CustomValidator1" Runat = "เซิร์ฟเวอร์"
ErrorMessage="วันที่ไม่ถูกต้อง ป้อนวันที่ในอนาคต"
ControlToValidate = "futureDatetxt"
OnServerValidate = "ValidateDateInFuture">
</asp:CustomValidator>
<br />
<asp:Button ID="submitBtn" Runat = "เซิร์ฟเวอร์" Text = "ส่ง" />
</div>
</แบบฟอร์ม>
</ร่างกาย>
</html>

โปรดทราบว่าโค้ดด้านบนใช้เมธอด DateTime.TryParse ซึ่งเป็นวิธีการใหม่ที่มีให้ใน ASP.NET 2.0 หาก

ต้องการกรองฟิลด์ข้อความอิสระ

เพื่อกรองอินพุต คุณต้องแน่ใจว่าอินพุตที่ไม่ปลอดภัยไม่ถือเป็นโค้ด ตัวอย่างเช่น โปรแกรมของคุณ อนุญาตให้ผู้ใช้ไม่สามารถอ่านข้อมูลในฐานข้อมูลที่ใช้ร่วมกันได้ ก่อนอื่นคุณต้องกรองข้อมูลเพื่อไม่ให้เป็นอันตรายเมื่อส่งออก ใช้วิธี HttpUtility.HtmlEncode เพื่อเข้ารหัสค่าอินพุตก่อน

อนุญาตโค้ด HTML อินพุตที่จำกัด

เพิ่มฟิลด์ต่อไปนี้ให้กับองค์ประกอบหน้า @Page ValidateRequest = "false" เพื่อปิดใช้งานการตรวจสอบความถูกต้องของคำขอ ASP.NET ใช้วิธี HtmlEncode เพื่อเข้ารหัสสตริงอินพุต ใช้วัตถุ StringBuilder และเรียกวิธีการแทนที่เพื่อแทนที่ HTML ในอักขระ รหัสต่อไปนี้ให้ นี่คือตัวอย่างของวิธีการนี้ หน้านี้ปิดใช้งานการตรวจสอบความถูกต้องของคำขอ ASP.NET โดยการตั้งค่า ValidateRequest = "fasle" การเข้ารหัส HTML อนุญาตให้ใช้แท็ก <b> และ <i> เพื่อแสดงการจัดรูปแบบข้อความอย่างง่าย .

<%@ ภาษาเพจ = "C #" ValidateRequest = "false"%>

<script runat = "เซิร์ฟเวอร์">

เป็นโมฆะ sendBtn_Click (ผู้ส่งวัตถุ EventArgs e)
-
// เข้ารหัสอินพุตสตริง
StringBuilder sb = StringBuilder ใหม่ (
HttpUtility.HtmlEncode(htmlInputTxt.Text));
// เลือกอนุญาตและ <i>
sb.Replace("&lt;b&gt;", "<b>");
sb.Replace("&lt;/b&gt;", "");
sb.Replace("&lt;i&gt;", "<i>");
sb.Replace("&lt;/i&gt;", "");
Response.Write(sb.ToString());
-
</สคริปต์>

<html>
<ร่างกาย>
<form id="form1" runat="server">
<div>
<asp:TextBox ID="htmlInputTxt" Runat="เซิร์ฟเวอร์"
TextMode = "หลายบรรทัด" ความกว้าง = "318px"
ความสูง="168px"></asp:TextBox>
<asp:ID ปุ่ม = "submitBtn" Runat = "เซิร์ฟเวอร์"
ข้อความ = "ส่ง" OnClick = "submitBtn_Click" />
</div>
</แบบฟอร์ม>
</ร่างกาย>
</html>

ตรวจสอบค่าสตริงการสืบค้น

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

จำกัดค่าอินพุต ตั้งค่าการตรวจสอบช่วงที่ชัดเจน ระบุประเภทอินพุตและแปลงเป็น ASP.NET แพลตฟอร์มประเภทต่อไปนี้ จัดการข้อยกเว้นใดๆ ที่เกิดจากการแปลงประเภท ตัวอย่างโค้ดต่อไปนี้สาธิตการใช้คลาส Regex เพื่อตรวจสอบสตริงชื่อที่ส่งผ่านในสตริงการสืบค้น

เป็นโมฆะ Page_Load (ผู้ส่งวัตถุ EventArgs e)
-
ถ้า (!System.Text.RegularExpressions.Regex.IsMatch(
Request.QueryString["Name"], @"^[a-zA-Z'.s]{1,40}$"))
Response.Write("พารามิเตอร์ชื่อไม่ถูกต้อง");
อื่น
Response.Write("ชื่อคือ " + Request.QueryString["ชื่อ"]);
-

ตรวจสอบค่าคุกกี้

ที่เก็บไว้ในคุกกี้เช่นสตริงการสืบค้นสามารถแก้ไขได้โดยผู้ใช้ ตรวจสอบความยาว ช่วง รูปแบบ และประเภทของค่าเหล่านี้

ไฟล์

และที่อยู่ URL

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

ตรวจสอบเส้นทางของไฟล์

เพื่อ

ป้องกันไม่ให้โปรแกรมของคุณถูกเอาเปรียบโดยผู้ใช้ในการเข้าถึงไฟล์ ให้ป้องกันไม่ให้ยอมรับไฟล์หรือเส้นทางของไฟล์ที่ป้อนโดยโค้ดที่ผู้ใช้เขียน ตัวอย่างเช่น

หากคุณยอมรับชื่อไฟล์อินพุต ให้ใช้ระบบ วิธีการ .IO.Path.GetFileName เพื่อรับชื่อเต็มของไฟล์ หากคุณต้องยอมรับเส้นทางไฟล์อินพุต และใช้ System.IO.Path.GetFullPath เพื่อรับเส้นทางไฟล์แบบเต็ม ใช้วิธีการ MapPath เพื่อป้องกันการแมปข้ามแอปพลิเคชัน .

หากคุณใช้เมธอด MapPath เพื่อแมปไดเร็กทอรีเสมือนที่ระบุกับไดเร็กทอรีทางกายภาพบนเซิร์ฟเวอร์ ให้ใช้เมธอด Request.MapPath เวอร์ชันโอเวอร์โหลดพร้อมพารามิเตอร์บูลเพื่อป้องกันการแมปข้ามแอปพลิเคชัน นี่คือโค้ดตัวอย่างสำหรับเทคนิคนี้:

พยายาม
-
สตริง mappedPath = Request.MapPath ( inputPath.Text,
Request.ApplicationPath, เท็จ);
-
จับ (HttpException)
-
// พยายามแมปข้ามแอปพลิเคชัน
-

พารามิเตอร์เท็จสุดท้ายจะป้องกันการแมปข้ามแอปพลิเคชัน ซึ่งหมายความว่าผู้ใช้ไม่ได้รับอนุญาตให้ใช้ไวยากรณ์ "..." เพื่อจัดเตรียมเส้นทางที่ไม่ถูกต้องซึ่งไม่อยู่ในไดเรกทอรีเสมือนที่คุณระบุ

ถ้าคุณใช้ตัวควบคุมเซิร์ฟเวอร์ คุณสามารถใช้เมธอด Control.MapPathSecure เพื่อรับที่อยู่ไดเรกทอรีจริงที่สอดคล้องกับไดเรกทอรีเสมือน
วิธีการ Control.MapPathSecure พ่น HttpException เมื่อเข้าถึงไฟล์ที่ไม่ได้รับอนุญาต สำหรับข้อมูลเพิ่มเติม โปรดดูที่การแนะนำวิธีการ Control.MapPathSecure ในเอกสารประกอบของ .NET Framework

การใช้ความปลอดภัยในการเข้าถึงโค้ดเพื่อจำกัดอินพุตและเอาท์พุตของไฟล์

ผู้ดูแลระบบสามารถจำกัดความสามารถของโปรแกรมในการอ่านและเขียนไฟล์ไปยังไดเร็กทอรีเสมือนที่ไฟล์นั้นอยู่โดยตั้งค่าความน่าเชื่อถือเป็น "สื่อ" กลไกการรักษาความปลอดภัยของโค้ด .NET ช่วยให้มั่นใจได้ว่าโปรแกรมไม่มีสิทธิ์ในการเข้าถึงไฟล์ใดๆ นอกไดเร็กทอรีเสมือนที่ไฟล์นั้นตั้งอยู่

หากต้องการตั้งค่าระดับความน่าเชื่อถือของแอปพลิเคชันเป็น "ปานกลาง" คุณสามารถเพิ่ม:

< trust level = "Medium" />

ตรวจสอบ URL

คุณสามารถใช้นิพจน์ทั่วไปดังต่อไปนี้เพื่อจับคู่ URL ได้

^(?:http|https|ftp)://[a-zA-Z0-9 .-]+(?::d {1,5})?(?:[A-Za-z0-9.;:@&=+$,? /]|%u[0-9A-Fa- f]{4}|%[0-9A-Fa-f]{2})*$

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

ขั้นตอนที่ 3 เข้ารหัสรหัสที่ไม่ปลอดภัย

หากคุณป้อนข้อความลงในหน้าเว็บ ให้ใช้วิธี HttpUtility.HtmlEncode เพื่อเข้ารหัส หากข้อความมาจากอินพุตของผู้ใช้ ฐานข้อมูล หรือไฟล์ในเครื่อง ต้องแน่ใจว่าได้ทำเช่นนี้เสมอ ใน

ทำนองเดียวกัน หากคุณเขียน URL ที่มีอักขระที่ไม่ปลอดภัยเนื่องจากมาจาก สำหรับเนื้อหาที่ผู้ใช้ป้อน ฐานข้อมูล ฯลฯ ให้ใช้ วิธีการเข้ารหัส HttpUtility.UrlEncode

เพื่อป้องกันการเข้ารหัสก่อนที่จะจัดเก็บข้อมูล ซึ่งอาจทำให้ข้อมูลที่เก็บไว้เสียหาย โปรดตรวจสอบให้แน่ใจว่าได้เข้ารหัสเป็นขั้นตอนภายหลังที่สุดเท่าที่จะเป็นไปได้เมื่อแสดงข้อมูลเหล่านั้น

ใช้ HtmlEncode สำหรับการเข้ารหัสเอาต์พุตที่ไม่ปลอดภัย

HtmlEncode จะแทนที่แท็ก HTML ด้วยสตริงข้อความพิเศษเพื่อแสดงสัญลักษณ์เหล่านี้และป้องกันไม่ให้เบราว์เซอร์ตีความว่าเป็นแท็ก HTML ตัวอย่างเช่น "<" ถูกแทนที่ด้วย &lt; " ( โคลอน) จะถูกแทนที่ด้วย &quot; แท็กเหล่านี้จะแสดงเป็นข้อความที่ไม่เป็นอันตราย

<%@ ภาษาเพจ = "C #" ValidateRequest = "false" %>

<script runat = "เซิร์ฟเวอร์">
เป็นโมฆะ sendBtn_Click (ผู้ส่งวัตถุ EventArgs e)
-
Response.Write (HttpUtility.HtmlEncode (inputTxt.Text));
-
</script>

<html xmlns=" http://www.w3.org/1999/xhtml ">
<ร่างกาย>
<form id="form1" runat="server">
<div>
<asp:TextBox ID="inputTxt" Runat="เซิร์ฟเวอร์"
TextMode = "หลายบรรทัด" ความกว้าง = "382px" ความสูง = "152px">
</asp:กล่องข้อความ>
<asp:ID ปุ่ม = "submitBtn" Runat = "เซิร์ฟเวอร์" ข้อความ = "ส่ง"
OnClick = "submitBtn_Click" />
</div>
</แบบฟอร์ม>
</ร่างกาย>
</html>

หากต้องการดูผลกระทบของการเข้ารหัส HTML โปรดสร้างไดเร็กทอรีเสมือนและใส่ไฟล์ที่กล่าวมาข้างต้น เรียกใช้หน้านี้ ป้อนโค้ด HTML ในกล่องข้อความ และคลิกปุ่มส่ง ตัวอย่างเช่น ข้อมูลต่อไปนี้จะแสดงตามปกติ ข้อความ

เรียกใช้สคริปต์และกล่าวสวัสดี <script>alert('hello');</script>

หากคุณลบการเรียกเมธอด HtmlEncode และเพียงป้อนเนื้อหาข้อความ เบราว์เซอร์จะรันโค้ดและแสดงกล่องพร้อมท์ขึ้นมา

การใช้วิธี UrlEncode ไม่ปลอดภัย การเข้ารหัสที่อยู่ URL

HttpUtility.UrlEncode

เพื่อเข้ารหัสสตริงที่อยู่

;

ขั้นตอนที่ 4 SQL คำสั่งใช้วิธีพารามิเตอร์คำสั่ง

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

เมื่อเรียกใช้ Stored Procedure ให้ใช้พารามิเตอร์ที่ตั้ง

ไว้ด้านล่าง ข้อมูลโค้ดจะแสดงตัวอย่างการใช้ชุดพารามิเตอร์เมื่อเรียกใช้ Stored Procedure

SqlDataAdapter myCommand = ใหม่ SqlDataAdapter("AuthorLogin",
การเชื่อมต่อของฉัน);
myCommand.SelectCommand.CommandType = CommandType.StoredProcedure;
SqlParameter parm = myCommand.SelectCommand.Parameters.Add(
"@LoginId", SqlDbType.VarChar, 11);
parm.Value = เข้าสู่ระบบข้อความ;

ใช้ชุดพารามิเตอร์เมื่อสร้างคำสั่ง SQL ของคุณเอง

หากคุณไม่สามารถใช้ขั้นตอนที่เก็บไว้ คุณยังคงสามารถใช้ชุดพารามิเตอร์ได้ ดูโค้ดด้านล่าง

SqlDataAdapter myCommand = SqlDataAdapter ใหม่ (
"เลือก au_lname, au_fname จากผู้เขียนโดยที่ au_id = @au_id", myConnection);
SQLParameter parm = myCommand.SelectCommand.Parameters.Add(
"@au_id" ,SqlDbType.VarChar, 11);
Parm.Value = เข้าสู่ระบบข้อความ;

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับวิธีการป้องกันการโจมตีการฉีด SQL ดูวิธีการ: ป้องกันจากการฉีด SQL ใน ASP.NET

ขั้นตอนที่ 5 เพื่อตรวจสอบว่าข้อความแสดงข้อผิดพลาด ASP.NET จะไม่ถูกส่งกลับไปยังไคลเอน

ต์ คุณสามารถใช้องค์ประกอบ <customErrors> ในการกำหนดค่าไคลเอนต์ ควรส่งคืนข้อความแสดงข้อผิดพลาดทั่วไปไปยังไคลเอนต์โดยกลไกการตรวจจับข้อผิดพลาดของโปรแกรม

โปรดยืนยันว่าคุณได้เปลี่ยนแอตทริบิวต์โหมดใน web.config เป็น "remoteOnly" ต่อไปนี้คือตัวอย่าง

<customErrors mode = "remoteOnly">

ในหลังจากติดตั้งโปรแกรม ASP.NET คุณสามารถระบุหน้าข้อความแสดงข้อผิดพลาดของไคลเอ็นต์ได้ดังต่อไปนี้

<customErrors mode = "on" defaultRedirect = "YourErrorPage.htm">

สำหรับแหล่งข้อมูลเพิ่มเติม โปรดดูหัวข้อที่เกี่ยวข้อง:

วิธีใช้นิพจน์ทั่วไปเพื่อจำกัดอินพุตใน ASP.NET

ป้องกันการโจมตีแบบแทรก SQL

และป้องกันการโจมตีด้วยสคริปต์ข้ามไซต์

PS: ในที่สุดฉันก็อ่านจบแล้ว ฉันเหนื่อยมาก ฉันใช้เวลาเกือบสามวันจริงๆ นี่เป็นครั้งแรกที่ฉันแปล หากแปลไม่ดีก็ขออภัยด้วย