ถ้าคุณใช้ สตริปชาร์ ในการทำความสะอาดข้อมูลที่ผู้ใช้ป้อนเข้ามา คุณไม่ใช่คนเดียว นักพัฒนาหลายคนใช้เครื่องมือประเภทนี้ การฆ่าเชื้ออินพุต เพื่อบล็อกความพยายามในการฉีดโค้ด ในแง่แรกดูเหมือนจะสมเหตุสมผล คือลบอักขระอันตรายออก และเพย์โหลดก็จะหายไป อย่างไรก็ตาม แนวทางนี้ให้ความรู้สึกปลอดภัยที่ผิดพลาด อันที่จริง ผู้โจมตีสามารถหลีกเลี่ยงตัวกรองง่ายๆ เช่นนี้ได้ สตริปชาร์ ด้วย เพย์โหลดที่ถูกปกปิดการเข้ารหัส หรือการสลับบริบทอย่างชาญฉลาด นั่นเป็นเหตุผลที่นักพัฒนาที่ฉลาดไม่หยุดอยู่แค่นั้น แต่พวกเขาใช้เทคนิคอื่นๆ แทน แบบสอบถามที่กำหนดพารามิเตอร์ซึ่งจะป้องกันการโจมตีแบบฉีดโค้ดที่ระดับราก
ในบทความนี้ คุณจะได้เรียนรู้ว่าทำไม สตริปชาร์ เราจะมาดูกันว่าระบบเหล่านี้ล้มเหลวในสถานการณ์จริงอย่างไร ผู้โจมตีใช้ประโยชน์จากตัวกรองเหล่านี้อย่างไร และทางเลือกที่ปลอดภัยอื่นๆ ที่ใช้งานได้จริงมีอะไรบ้าง เราจะยกตัวอย่างโค้ด แสดงเทคนิคการหลีกเลี่ยงที่พบบ่อย และอธิบายวิธีการต่างๆ การฆ่าเชื้ออินพุต ต้องใช้ร่วมกับการป้องกันโครงสร้างเสมอ เช่น แบบสอบถามที่กำหนดพารามิเตอร์หรือคุณจะยังคงอยู่ในสถานะที่เปราะบางต่อไป
อะไร สตริปชาร์ จริงๆ แล้วเป็น (และไม่เป็น)
นักพัฒนาจำนวนมากใช้ stripchar หรือฟังก์ชันที่คล้ายกันเพื่อลบอักขระที่ไม่ปลอดภัยออกจากข้อมูลที่ผู้ใช้ป้อน โดยทั่วไปแล้ว จะลบเครื่องหมายวรรคตอน สัญลักษณ์พิเศษ หรือสิ่งใดก็ตามที่ไม่ใช่ตัวอักษรและตัวเลข ฟังดูเหมือนว่า... การฆ่าเชื้ออินพุตแต่นั่นไม่ใช่การป้องกันที่แท้จริง
มาลองวิเคราะห์กันดู ฟังก์ชันแบบนี้:
function stripchar(input) {
return input.replace(/[^\w\s]/gi, '');
}
ลบอักขระเช่น ', "หรือ ;ดังนั้น หากคุณป้อนข้อมูลดังนี้:
'; DROP TABLE users; --
มันจึงกลายเป็น:
DROP TABLE users
แม้ว่าข้อมูลที่ผู้ใช้ป้อนจะดูสะอาดตา แต่ผู้โจมตีก็ยังสามารถแทรกโค้ด SQL ได้โดยใช้ตรรกะเพียงอย่างเดียว โดยเฉพาะอย่างยิ่งเมื่อแอปพลิเคชันสร้างคำสั่งค้นหาผ่านการต่อสตริง เพื่อป้องกันการโจมตี SQL injection อย่างแท้จริงคุณต้องใช้แบบสอบถามที่มีพารามิเตอร์และการจัดการข้อมูลป้อนเข้าที่คำนึงถึงบริบท ตัวกรองอักขระเช่น stripchar() แค่นั้นไม่เพียงพอแน่นอน
แน่นอนว่า การลดข้อมูลที่เป็นอันตรายอาจดูปลอดภัยกว่าในแวบแรก อย่างไรก็ตาม วิธีนี้ไม่ได้กำจัดตรรกะที่เป็นอันตรายออกไป เพียงแต่เปลี่ยนวิธีการเขียนเท่านั้น ในความเป็นจริง ผู้โจมตีมักใช้ประโยชน์จากจุดนี้โดยการเข้ารหัสข้อมูล การแทรกช่องว่าง หรือใช้ตัวอักษรที่ถูกลบออกไปอย่างมีกลยุทธ์เพื่อหลีกเลี่ยงตัวกรองของคุณโดยสิ้นเชิง
นอกจากนี้ สตริปชาร์ ขาดบริบทที่สำคัญ มันไม่รู้ว่าข้อมูลที่ป้อนเข้ามานั้นกำลังจะไปที่ฐานข้อมูล เชลล์ หรือเบราว์เซอร์ นั่นหมายความว่ามันไม่สามารถใช้การหลีกเลี่ยงหรือการเข้ารหัสที่ถูกต้องได้ การตรวจสอบความปลอดภัยของข้อมูลที่ป้อนเข้ามาโดยไม่รู้ปลายทางนั้นก็เหมือนกับการหลีกเลี่ยง HTML ในขณะที่ภัยคุกคามที่แท้จริงอยู่ที่อื่น SQLi.
ในท้ายที่สุด สตริปชาร์ มันไม่ได้ตีความหรือรักษาความปลอดภัยอะไรเลย มันแค่แก้ไขสตริง และการแก้ไขไม่ใช่การรักษาความปลอดภัย ถ้าคุณต้องการการป้องกันที่แท้จริง ให้ใช้การสืบค้นที่มีโครงสร้าง ตรวจสอบความถูกต้อง และมีพารามิเตอร์ จบ.
เพื่อให้เห็นความแตกต่างได้ชัดเจนยิ่งขึ้น นี่คือการเปรียบเทียบระหว่าง stripchar กับ parameterized queries แบบเคียงข้างกัน:
Stripchar กับ Parameterized Queries: อันไหนปกป้องโค้ดของคุณได้จริงกว่ากัน?
| คุณสมบัติ (Feature) | stripchar() | ข้อความค้นหาที่กำหนดพารามิเตอร์ |
|---|---|---|
| ระดับการป้องกัน | การล้างสตริงขั้นพื้นฐาน สามารถหลีกเลี่ยงได้ง่ายด้วยการเข้ารหัสหรือเทคนิคทางตรรกะ | การป้องกันที่แข็งแกร่งต่อการโจมตีแบบ SQL injection ทุกรูปแบบ |
| การให้ความรู้บริบท | ไม่คำนึงถึงบริบท (SQL, HTML, shell ฯลฯ) ใช้กฎเดียวกันทุกที่ | รับรู้บริบทได้อย่างสมบูรณ์ ใช้การหลีกเลี่ยงอักขระพิเศษสำหรับสภาพแวดล้อมแต่ละแบบอย่างเหมาะสม |
| ความพยายามของนักพัฒนา | ติดตั้งได้รวดเร็ว แต่ไม่น่าเชื่อถือสำหรับการใช้งานในระยะยาว | ต้องมีการบูรณาการที่ถูกต้อง แต่มีความแข็งแกร่งและรองรับอนาคตได้ |
| ความต้านทานบายพาส | ระดับความเสี่ยงต่ำ — ผู้โจมตีสามารถปรับตัวได้ง่ายโดยใช้ช่องว่าง การเข้ารหัส หรือตรรกะ | ระดับสูง — แยกโค้ดออกจากข้อมูลและป้องกันการโจมตีแบบ Injection ได้อย่างน่าเชื่อถือ |
| ความมั่นใจด้านความปลอดภัย | ความรู้สึกปลอดภัยที่ผิดพลาด อาจปกปิดปัญหาโดยไม่แก้ไข | อุตสาหกรรมที่น่าเชื่อถือ standard เพื่อการดำเนินการคำสั่งค้นหาที่ปลอดภัย |
วิธีที่ผู้โจมตีหลีกเลี่ยงการตรวจสอบความปลอดภัยของข้อมูลขาเข้า
นี่คือลักษณะของช่องโหว่ที่พบได้ทั่วไป เมื่อนักพัฒนาใช้ช่องโหว่นี้ สตริปชาร์ สำหรับการตรวจสอบความปลอดภัยของข้อมูลขาเข้า:
ผู้โจมตีไม่จำเป็นต้องเจาะระบบกรองของคุณ พวกเขาแค่ต้อง... อ้อมพวกเขาไปเมื่อนักพัฒนาพึ่งพา สตริปชาร์ สำหรับการตรวจสอบความปลอดภัยของข้อมูลขาเข้า พวกเขามักจะคิดว่าการลบอักขระอย่างเช่นเครื่องหมายอัญประกาศหรือเครื่องหมายเซมิโคลอนจะช่วยป้องกันการโจมตีแบบแทรกโค้ดได้ อย่างไรก็ตาม ผู้โจมตีปรับตัวได้อย่างรวดเร็ว พวกเขาสร้างวิธีการใหม่ๆ เพย์โหลดที่ถูกปกปิด ซึ่งหลุดรอดจากการกรองด้วยนิพจน์ทั่วไป โดยเฉพาะอย่างยิ่งเมื่อตัวกรองเหล่านั้นขาดบริบท
ตัวอย่างเช่น สมมติว่าคุณพยายามกรองข้อมูลที่ป้อนเข้ามาในลักษณะนี้:
const input = stripchar(userInput);
// safe to use? maybe not.
db.query("SELECT * FROM users WHERE name = '" + input + "'");
แม้ว่าผู้ใช้จะไม่สามารถส่งแบบฟอร์มคลาสสิกได้ก็ตาม ' OR 1=1 --พวกเขาสามารถใช้เทคนิค Unicode, การต่อสตริง หรือไวยากรณ์ที่ผิดเพี้ยนแต่ยังคงทำงานได้ โค้ดลักษณะนี้มักจะได้ผล:
0x27206F7220313D31--
หรือ:
'+UNION+SELECT+null,null,null--
หากฟังก์ชันของคุณตัดอักขระที่ไม่ใช่คำออก คุณอาจ สร้างคำสั่ง SQL ที่ถูกต้องขึ้นมาใหม่โดยไม่ได้ตั้งใจที่แย่กว่านั้นคือ ผู้โจมตีสามารถเข้ารหัสค่าต่างๆ ในรูปแบบที่ผ่านตัวกรองของคุณได้ แต่ระบบเป้าหมายสามารถถอดรหัสได้
นอกจากการโจมตีแบบ SQL injection แล้ว... สตริปชาร์ นอกจากนี้ยังใช้งานไม่ได้ในบริบทอื่นๆ เช่น คำสั่งเชลล์ เส้นทางไฟล์ หรือแม้แต่การเรียกใช้ JavaScript เนื่องจากขาดความรู้ความเข้าใจว่าข้อมูลที่ป้อนเข้าไปจะถูกนำไปใช้ที่ใด จึงไม่สามารถใช้การหลีกเลี่ยงอักขระพิเศษหรือการตรวจสอบความถูกต้องได้อย่างเหมาะสม
เป็นผลให้ การฆ่าเชื้ออินพุต สีสดสวย สตริปชาร์ มันง่ายที่จะหลีกเลี่ยง ความปลอดภัยที่แท้จริงมาจากการ... การควบคุมที่คำนึงถึงบริบทโดยเฉพาะอย่างยิ่ง แบบสอบถามที่กำหนดพารามิเตอร์ ที่ป้องกันการแทรกตรรกะได้อย่างสมบูรณ์
เหตุผลที่คุณควรใช้ Parameterized Queries แทน
หากคุณต้องการหยุดการโจมตีแบบ Injection อย่างแท้จริง คุณจำเป็นต้อง... หยุดสร้างคำสั่งค้นหาด้วยสตริง. นั่นคือสิ่งที่ แบบสอบถามที่กำหนดพารามิเตอร์ เข้ามาสิ ไม่เหมือนกันเลย สตริปชาร์พวกเขาไม่กรองข้อมูล พวกเขา แยกโค้ดออกจากข้อมูล ในระดับเครื่องยนต์
ลองกลับมาดูคำสั่งค้นหาที่ผิดพลาดกันอีกครั้ง:
const input = stripchar(userInput);
const query = "SELECT * FROM users WHERE name = '" + input + "'";
วิธีนี้อันตรายเพราะข้อมูลจะถูกแทรกเข้าไปใน SQL โดยตรง แม้จะมีการตัดอักขระที่ไม่จำเป็นออกไปแล้ว คุณก็ยังคงสร้างสตริงที่อาจถูกนำไปใช้ในทางที่ผิดได้ ควรใช้คำสั่ง SQL แบบมีพารามิเตอร์แทน ดังนี้:
const query = "SELECT * FROM users WHERE name = ?";
db.execute(query, [userInput]);
ในที่นี้ ไดรเวอร์ฐานข้อมูลรู้ว่า userInput คือข้อมูล โค้ดที่ไม่สามารถเรียกใช้งานได้ระบบจะตรวจจับและบล็อกการโจมตีแบบ Injection โดยอัตโนมัติ แม้ว่าข้อมูลที่ป้อนเข้ามาจะมีเครื่องหมายคำพูด เครื่องหมายเซมิโคลอน หรือข้อมูลที่เข้ารหัสแบบเลขฐานสิบหกก็ตาม
ในภาษา Python:
cursor.execute("SELECT * FROM users WHERE name = %s", (user_input,))
ใน PHP ที่ใช้ PDO:
$stmt = $pdo->prepare("SELECT * FROM users WHERE name = :name");
$stmt->execute(['name' => $input]);
จากตัวอย่างทั้งหมดเหล่านี้ แบบสอบถามที่กำหนดพารามิเตอร์ ป้องกันการฉีดโดยไม่ต้องเดาว่าตัวอักษรใดอาจเป็นอันตราย คุณไม่จำเป็นต้อง สตริปชาร์, คุณจำเป็นต้องสร้างคำสั่งค้นหาที่มีโครงสร้างและคำนึงถึงบริบท
นอกจากนี้ เทคนิคนี้ยังบล็อกเพย์โหลดที่ซ่อนเร้น เทคนิค Unicode และการหลีกเลี่ยงการเข้ารหัส ซึ่งเป็นรูปแบบการหลบเลี่ยงแบบเดียวกันกับที่พบใน ช่องโหว่ XSSเครื่องมืออย่าง Xygeni สามารถตรวจจับภัยคุกคามเหล่านี้ได้ตั้งแต่เนิ่นๆ SAST การวิเคราะห์.
กล่าวโดยสรุป การป้องกันที่แท้จริงไม่ได้อาศัยตัวกรอง แต่ขึ้นอยู่กับโปรโตคอล API ที่เชื่อถือได้ และบริบทที่สมบูรณ์ หากคุณใช้เฟรมเวิร์กหรือการฉีดบริการแบบไดนามิก โปรดระวังวิธีการที่ข้อมูลนำเข้าแพร่กระจายผ่านโค้ดของคุณ การฉีดการพึ่งพาที่ปลอดภัย ช่วยให้มั่นใจได้ว่าแม้กระบวนการทำงานที่ซับซ้อนก็จะไม่เปิดช่องโหว่การโจมตีใหม่ๆ
อย่าพึ่งพา สตริปชาร์ใช้ Xygeni เพื่อบังคับใช้การป้องกันที่แท้จริง
แม้ว่าคุณจะใช้ แบบสอบถามที่กำหนดพารามิเตอร์ไม่มีการรับประกันว่าโค้ดเบสทั้งหมดของคุณจะใช้รูปแบบเดียวกัน standardตรรกะเดิม สคริปต์จากภายนอก หรือบรรทัดที่ถูกมองข้ามใน Pull Request (PR) อาจยังคงก่อให้เกิดความเสี่ยงจากการโจมตีแบบ Injection ได้ และนี่คือจุดที่ Xygeni เข้ามาช่วย
Xygeni สแกนซอร์สโค้ดของคุณ pull requestsและ CI pipelineสิ่งที่ต้องจับ:
- สตริงคำสั่ง SQL ที่สร้างด้วยการเชื่อมต่อ
- ตัวกรองที่อ่อนแอหรือสร้างขึ้นเอง เช่น สตริปชาร์
- ตรรกะที่น่าสงสัยซึ่งตรงกับข้อมูลที่ถูกเข้ารหัสซ่อนเร้นที่รู้จักกันดี
คุณไม่จำเป็นต้องตรวจสอบทุกบรรทัด Xygeni จะตรวจจับรูปแบบที่ไม่ปลอดภัยตั้งแต่เนิ่นๆ และนำไปใช้ แก้ไขอัตโนมัติ เท่าที่เป็นไปได้ และสามารถบล็อกการผสานรวมที่มีความเสี่ยงด้วยการปรับแต่งได้ Guardrails.
ในระยะสั้น Xygeni ทำให้มั่นใจได้ว่าการใช้พารามิเตอร์ในการค้นหาข้อมูลไม่ใช่แค่แนวทางปฏิบัติที่ดีที่สุด แต่ยังถูกบังคับใช้ในระดับใหญ่ด้วย ไม่ต้องเดาอีกต่อไป ไม่ต้องกังวลเรื่องการกรองที่ตกหล่นอีกต่อไป มีแต่การปกป้องที่แท้จริง
อยากรู้ไหมว่า Xygeni ตรวจหาคำสั่ง SQL ที่ไม่ปลอดภัยในโค้ดของคุณได้อย่างไร?
ประเด็นสำคัญ: สิ่งที่ควรจำเกี่ยวกับ สตริปชาร์ และความเสี่ยงจากการฉีด
- สตริปชาร์ ไม่ใช่ฟังก์ชันด้านความปลอดภัย — มันลบตัวอักษร ไม่ใช่ความเสี่ยง
- การตรวจสอบและกรองข้อมูลขาเข้าอย่างเดียวไม่เพียงพอ เมื่อคุณสร้างคำสั่งค้นหาโดยใช้การต่อสตริง
- แบบสอบถามที่มีพารามิเตอร์เป็นวิธีการป้องกันที่ถูกต้องและทุกภาษาหรือเฟรมเวิร์กสมัยใหม่ก็รองรับสิ่งเหล่านี้
- ข้อมูลที่เข้ารหัสลับอาจเล็ดลอดผ่านตัวกรองไปได้โดยเฉพาะอย่างยิ่งหากมีการใช้เทคนิคการเข้ารหัสเข้ามาเกี่ยวข้อง
- การวิเคราะห์แบบสถิต (SASTเครื่องมือช่วยตรวจจับสิ่งที่มนุษย์มองข้ามไปรวมถึงรูปแบบที่ไม่ปลอดภัยที่ซ่อนอยู่ในโค้ดเก่า
- Xygeni ช่วยให้การตรวจจับ การจัดลำดับความสำคัญ และการแก้ไขปัญหาเป็นไปโดยอัตโนมัติ เพื่อให้ทีมของคุณสามารถมุ่งเน้นไปที่การเขียนฟีเจอร์ต่างๆ แทนที่จะเสียเวลาไปกับการค้นหาช่องโหว่
สรุป: อย่าไว้ใจตัวกรอง ระบบมีความปลอดภัยตั้งแต่เริ่มต้น
โดยอาศัยฟังก์ชันต่างๆ เช่น สตริปชาร์ อาจดูเหมือนเป็นวิธีแก้ปัญหาที่รวดเร็ว แต่ก็สร้างความรู้สึกปลอดภัยที่ผิดพลาด ผู้โจมตีพัฒนาเร็วกว่าตัวกรองสตริง วิธีเดียวที่เชื่อถือได้ในการหยุดการโจมตีแบบ Injection คือการเขียนโค้ดที่ปลอดภัยตั้งแต่เริ่มต้น และบังคับใช้การออกแบบนั้นทุกที่
เครื่องมืออย่าง Xygeni ช่วยให้คุณทำสิ่งนั้นได้โดยอัตโนมัติ จาก pull request ไปยัง pipelineพวกมันจะตรวจจับสิ่งที่ตัวกรองของคุณตรวจไม่พบ และแก้ไขปัญหาก่อนที่จะถึงขั้นตอนการผลิต







