ในการพัฒนาซอฟต์แวร์การทำให้คลุมเครือ (obfuscation)คือการสร้าง โค้ด ต้นฉบับหรือโค้ดเครื่องที่ตั้งใจทำให้ยากต่อการเข้าใจสำหรับมนุษย์หรือคอมพิวเตอร์ คล้ายกับการทำให้คลุมเครือในภาษาธรรมชาติการทำให้โค้ดคลุมเครืออาจเกี่ยวข้องกับการใช้วิธีที่อ้อมค้อมโดยไม่จำเป็นในการเขียนคำสั่ง โปรแกรมเมอร์อาจทำให้โค้ดคลุมเครือเพื่อปกปิดวัตถุประสงค์ ตรรกะ หรือค่าที่ฝังอยู่ เหตุผลหลักในการทำเช่นนั้นคือเพื่อป้องกันการดัดแปลงป้องกันวิศวกรรมย้อนกลับหรือเพื่อสร้างปริศนาหรือความท้าทายเพื่อความบันเทิงในการถอดรหัสโค้ด ซึ่งเป็นความท้าทายที่มักรวมอยู่ในcrackmesแม้ว่าการทำให้คลุมเครือสามารถทำได้ด้วยตนเอง แต่โดยทั่วไปแล้วจะทำโดยใช้ โปรแกรม ทำให้คลุมเครือ^{[ 1 ]}

สถาปัตยกรรมและลักษณะเฉพาะของบางภาษาอาจทำให้การเข้ารหัสซ่อนเร้นได้ง่ายกว่าภาษาอื่นๆ^{[ 2 ] [ 3 ]} C , ^{[ 4 ]} C++ , ^{[ 5 ] [ 6 ]}และภาษาโปรแกรมPerl ^{[ 7 ]}เป็นตัวอย่างของภาษาที่เข้ารหัสซ่อนเร้นได้ง่ายHaskellก็เข้ารหัสซ่อนเร้นได้ค่อนข้างดีเช่นกัน^{[ 8 ]}แม้ว่าจะมีโครงสร้างที่แตกต่างกันมากก็ตาม

คุณสมบัติที่ทำให้ภาษาสามารถปกปิดความจริงได้นั้น ไม่ได้ชัดเจนในทันที

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

ตามที่นิค มอนต์ฟอร์ต กล่าวไว้ เทคนิคต่างๆ อาจรวมถึง:

1. การปกปิดชื่อตัวแปร ซึ่งรวมถึงการตั้งชื่อตัวแปรในลักษณะที่ไม่มีความหมายหรือชวนให้เข้าใจผิด
2. ความสับสนระหว่างข้อมูล/โค้ด/คำอธิบาย ซึ่งรวมถึงการทำให้โค้ดบางส่วนดูเหมือนคำอธิบาย หรือการสับสนระหว่างไวยากรณ์กับข้อมูล
3. การเข้ารหัสแบบคู่ ซึ่งสามารถแสดงรหัสในรูปแบบบทกวีหรือรูปทรงที่น่าสนใจได้^{[ 9 ]}

นอกจากนี้ยังมีเทคนิคที่ซับซ้อนกว่านั้นในการปกปิดโปรแกรมในระดับความหมายผ่านการแปลงโปรแกรม (แทนที่จะเป็นระดับซอร์สโค้ด) ซึ่งได้แก่:

1. การแปลงการควบคุมการไหลที่คลุมเครือ เช่น การรวมการคำนวณของนิพจน์ที่ไม่เกี่ยวข้องกันและการแยกการคำนวณของนิพจน์ที่เกี่ยวข้องกัน การสุ่มลำดับของคำสั่งที่สามารถคำนวณได้ในลำดับใดก็ได้ และการแทรกเงื่อนไขที่มีค่าที่ทราบแก่ผู้ทำให้คลุมเครือแต่คำนวณด้วยวิธีที่ไม่ชัดเจน^{[ 10 ]}
2. การแปลงโครงสร้างข้อมูลที่ไม่ชัดเจน เช่น การแก้ไขโครงสร้างของอาร์เรย์และการจัดเรียงกราฟการสืบทอดใหม่^{[ 11 ]}
3. การปกปิดการเปลี่ยนแปลงโครงสร้างเชิงขั้นตอนของโค้ดโดยการแทรกนามธรรมเชิงขั้นตอนใหม่และการเปลี่ยนแปลงนามธรรมเชิงขั้นตอนที่มีอยู่เพื่อเปลี่ยนโครงสร้างของโค้ดโดยสิ้นเชิง
4. การทำให้การไหลของข้อมูลของโปรแกรมไม่ชัดเจน^{[ 12 ]}

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

ล้างรหัส:

#include <stdio.h>int main ( void ) { int x = 5 ; int y = 7 ; printf ( "%d \n " , x + y ); return 0 ; }

โค้ดที่ถูกเข้ารหัส:

#include <stdio.h> int main (){ int _ = 5 , __ = 7 ; printf ( "%d \n " , _ -~ __ -1 );}

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

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

ในการเข้ารหัสแบบ XOR ผู้โจมตีจะเลือกคีย์ลับและใช้การดำเนินการบิตไวส์XOR กับไบนารีมัลแวร์ ซึ่งจะแปลงไฟล์ปฏิบัติการให้ดูเหมือนข้อมูลสุ่ม ชื่อฟังก์ชันในตารางนำเข้าจะหายไป ส่วนหัว PEจะเสียหาย และไฟล์ทั้งหมดจะสูญเสียโครงสร้าง จากนั้นเพย์โหลดที่เข้ารหัสจะถูกฝังลงในดรอปเปอร์ซึ่งเป็นไฟล์ปฏิบัติการที่ดูปกติซึ่งมีมัลแวร์ที่ซ่อนอยู่เป็นส่วนทรัพยากรหรือข้อมูล เมื่อผู้ใช้เรียกใช้ดรอปเปอร์ มันจะทำการดำเนินการ XOR อีกครั้งด้วยคีย์เดียวกันเพื่อสร้างมัลแวร์ดั้งเดิมขึ้นใหม่ จากนั้นจะเรียกใช้โดยตรงจากหน่วยความจำหรือเขียนลงดิสก์ก่อนที่จะเรียกใช้^{[ 13 ]}

กระบวนการนี้จะกำจัดตัวบ่งชี้หลายอย่างที่ซอฟต์แวร์ป้องกันไวรัสใช้ส่วนหัว MZ — ลาย เซ็น 2 ไบต์ "MZ" ที่ทำเครื่องหมายจุดเริ่มต้นของไฟล์ปฏิบัติการ ของ Windows ทุกไฟล์ — จะถูกบดบังอย่างสมบูรณ์โดยการ ดำเนินการ XOR โปรแกรมรักษาความปลอดภัยมักจะสแกนหาลายเซ็น 2 ไบต์นี้เมื่อค้นหาไฟล์ปฏิบัติการที่ฝังอยู่ การเข้ารหัส Base64 ให้ผลลัพธ์ที่คล้ายกันโดยใช้วิธีที่แตกต่างกัน: มันแปลงข้อมูลไบนารีเป็น ข้อความ ASCIIทำให้ไฟล์ปฏิบัติการมีลักษณะเหมือนข้อความธรรมดา (แทนที่จะเป็นโปรแกรม)

งานวิจัยจากการแข่งขัน Machine Learning Security Evasion Competition ปี 2020 แสดงให้เห็นว่าวิธีการเหล่านี้สามารถหลีกเลี่ยงระบบตรวจจับสมัยใหม่ได้ ผู้เข้าร่วมใช้การผสมผสานระหว่างการเข้ารหัส XOR การเข้ารหัส Base64 และการแทรกโค้ดที่ตายแล้วเพื่อหลีกเลี่ยงโมเดลการแข่งขันทั้งสามแบบด้วยความพยายามน้อยกว่าห้าครั้งต่อตัวอย่างการตรวจจับตามเอนโทรปีก็ล้มเหลวเช่นกัน และในบางกรณีการเข้ารหัส Base64 ยังลดเอนโทรปี ลง เมื่อเทียบกับไฟล์มัลแวร์ดั้งเดิม อีกด้วย ^{[ 14 ]}

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

มีเครื่องมือหลากหลายประเภทที่ใช้ในการหรือช่วยในการปกปิดรหัส (code obfuscation) ซึ่งรวมถึงเครื่องมือวิจัยเชิงทดลองที่พัฒนาโดยนักวิชาการ เครื่องมือสำหรับผู้ใช้งานทั่วไป ผลิตภัณฑ์เชิงพาณิชย์ที่เขียนโดยผู้เชี่ยวชาญ และซอฟต์แวร์โอเพนซอร์สนอกจากนี้ยังมีเครื่องมือถอดรหัส (deobfuscation tools) ที่มุ่งเป้าไปที่การย้อนกลับกระบวนการปกปิดรหัสด้วย

ในขณะที่โซลูชันการปกปิดโค้ดเชิงพาณิชย์ส่วนใหญ่จะแปลงโค้ดต้นฉบับของโปรแกรมหรือไบต์โค้ดที่ไม่ขึ้นกับแพลตฟอร์ม กล่าวคือโค้ดที่พกพาได้ (เช่นที่ใช้ในJavaและ.NET ) แต่บางโซลูชันก็ทำงานโดยตรงกับไบนารีที่คอมไพล์แล้วด้วย

• ตัวอย่าง Pythonบางส่วนสามารถพบได้ในคำถามที่พบบ่อยเกี่ยวกับการเขียนโปรแกรม Python อย่างเป็นทางการและที่อื่น ๆ^{[ 15 ] [ 16 ] [ 17 ]}
• คอมไพเลอร์C movfuscator สำหรับISA x86_32ใช้เฉพาะ คำสั่ง movเพื่อปกปิด^{[ 18 ] [ 19 ] [ 20 ]}

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

โปรแกรม Perlที่ถูกเข้ารหัสสั้น ๆอาจใช้ในลายเซ็นของโปรแกรมเมอร์ Perl ซึ่งรู้จักกันในชื่อ JAPH (" Just another Perl hacker ") ^{[ 21 ]}

นักวิทยาการเข้ารหัสได้สำรวจแนวคิดของการทำให้รหัสคลุมเครือเพื่อให้การวิศวกรรมย้อนกลับของรหัสทำได้ ยาก ในเชิงการเข้ารหัสแนวคิดนี้ได้รับการกำหนดเป็นทางการในข้อเสนอมากมายสำหรับการทำให้รหัสคลุมเครือที่ไม่สามารถแยกแยะได้ซึ่งเป็นหลักการพื้นฐานของการเข้ารหัส หากสามารถสร้างได้อย่างปลอดภัย จะทำให้สามารถสร้างการเข้ารหัสประเภทอื่นๆ ได้มากมาย รวมถึงประเภทใหม่ๆ ที่ไม่มีใครรู้วิธีสร้าง (แนวคิดที่แข็งแกร่งกว่าอย่างการทำให้รหัสคลุมเครือแบบกล่องดำนั้น เป็นที่ทราบกันดีว่าเป็นไปไม่ได้โดยทั่วไป) ^{[ 22 ] [ 23 ]}

• แม้ว่าการทำให้คลุมเครือจะทำให้การอ่าน การเขียน และการวิศวกรรมย้อนกลับของโปรแกรมทำได้ยากและใช้เวลานาน แต่ก็ไม่ได้หมายความว่าจะไม่สามารถทำได้เลย^{[ 24 ]}
• มันทำให้กระบวนการสร้างซอฟต์แวร์สำหรับนักพัฒนาใช้เวลานานขึ้นและซับซ้อนขึ้น
• การทำเช่นนี้อาจทำให้การแก้ไขปัญหาหลังจากที่ซอฟต์แวร์ถูกเข้ารหัสลับเป็นเรื่องยากอย่างยิ่ง
• เมื่อโค้ดไม่ได้รับการดูแลรักษาอีกต่อไป ผู้ที่ชื่นชอบงานอดิเรกอาจต้องการบำรุงรักษาโปรแกรม เพิ่มส่วนเสริม หรือทำความเข้าใจโปรแกรมให้ดียิ่งขึ้น การเข้ารหัสลับทำให้ผู้ใช้ปลายทางใช้งานโค้ดได้อย่างมีประโยชน์ได้ยาก
• การปกปิดโค้ดบางประเภท (เช่น โค้ดที่ไม่ใช่แค่ไฟล์ไบนารีในเครื่อง แต่ต้องดาวน์โหลดไฟล์ไบนารีขนาดเล็กจากเว็บเซิร์ฟเวอร์เมื่อจำเป็น) อาจทำให้ประสิทธิภาพการทำงานลดลง และ/หรือต้องใช้การเชื่อมต่ออินเทอร์เน็ต

ซอฟต์แวร์ป้องกันไวรัสบางตัว เช่นAVG AntiVirus [ ^{25 ] จะ}แจ้งเตือนผู้ใช้เมื่อเข้าชมเว็บไซต์ที่มีโค้ดที่ถูกเข้ารหัสแบบแมนนวล เนื่องจากวัตถุประสงค์หนึ่งของการเข้ารหัสคือการซ่อนโค้ดที่เป็นอันตราย อย่างไรก็ตาม นักพัฒนาบางรายอาจใช้การเข้ารหัสโค้ดเพื่อลดขนาดไฟล์หรือเพิ่มความปลอดภัย ผู้ใช้ทั่วไปอาจไม่คาดหวังว่าซอฟต์แวร์ป้องกันไวรัสจะแจ้งเตือนเกี่ยวกับโค้ดที่ไม่เป็นอันตราย โดยเฉพาะอย่างยิ่งจากบริษัทที่น่าเชื่อถือ ดังนั้นคุณสมบัติดังกล่าวอาจทำให้ผู้ใช้ไม่กล้าใช้ซอฟต์แวร์ที่ถูกต้องตามกฎหมาย

MozillaและGoogleไม่อนุญาตให้ส่วนขยายเบราว์เซอร์ที่มีโค้ดที่ถูกซ่อนไว้ในร้านค้าส่วนเสริม ของเบราว์เซอร์ ( FirefoxและChrome ตามลำดับ) ^{[ 26 ] [ 27 ]}

มีการถกเถียงกันว่าการหลีกเลี่ยงใบอนุญาตซอฟต์แวร์copyleft โดยการเผยแพร่ซอร์สโค้ดในรูปแบบที่ซ่อนเร้น เช่น ในกรณีที่ผู้เขียนไม่เต็มใจที่จะเปิดเผยซอร์สโค้ดนั้นผิดกฎหมายหรือไม่ ประเด็นนี้ได้รับการกล่าวถึงในใบอนุญาตสาธารณะทั่วไปของ GNUโดยกำหนดให้ต้องเปิดเผย "รูปแบบที่ต้องการสำหรับการแก้ไข" ^{[ 28 ]}เว็บไซต์ของ GNU ระบุว่า "ซอร์สโค้ดที่ซ่อนเร้นไม่ใช่ซอร์สโค้ดจริงและไม่นับว่าเป็นซอร์สโค้ด" ^{[ 29 ]}

โปรแกรมดีคอมไพเลอร์เป็นเครื่องมือที่สามารถวิศวกรรมย้อนกลับซอร์สโค้ดจากไฟล์ปฏิบัติการหรือไลบรารี กระบวนการนี้บางครั้งเรียกว่าการโจมตีแบบ "คนกลาง" (man-in-the-end หรือ mite attack) ซึ่งได้รับแรงบันดาลใจจากการโจมตีแบบ "คนกลาง " (man-in-the-middle attack) ในด้านการเข้ารหัสลับ ซอร์สโค้ดที่ถอดรหัสแล้วมักอ่านยาก มีชื่อฟังก์ชันและตัวแปรแบบสุ่ม ประเภทตัวแปรไม่ถูกต้อง และตรรกะที่แตกต่างจากซอร์สโค้ดดั้งเดิมเนื่องจากการปรับแต่งของคอมไพเลอร์

การปกปิดโมเดลเป็นเทคนิคในการซ่อนโครงสร้างภายในของโมเดลการเรียนรู้ของเครื่อง^{[ 30 ]}การปกปิดทำให้โมเดลกลายเป็นกล่องดำ ซึ่งขัดแย้งกับAI ที่อธิบายได้การปกปิดโมเดลยังสามารถนำไปใช้กับข้อมูลการฝึกอบรมก่อนป้อนเข้าสู่โมเดลเพื่อเพิ่มสัญญาณรบกวนแบบสุ่ม ซึ่งจะซ่อนข้อมูลที่ละเอียดอ่อนเกี่ยวกับคุณสมบัติของตัวอย่างแต่ละตัวและกลุ่มตัวอย่าง^{[ 31 ]}

• การแข่งขันเขียนโค้ด C ที่ซับซ้อนระดับนานาชาติ
• การปกป้องโค้ด Java ด้วยการปกปิดโค้ด (Code Obfuscation) , ACM Crossroads, ฉบับฤดูใบไม้ผลิ ปี 1998
• เราสามารถปกปิดรายละเอียดของโปรแกรมได้หรือไม่?
• ยูรี ลิฟชิตส์. บันทึกการบรรยายเรื่องการปกปิดโปรแกรม (ฤดูใบไม้ผลิ ปี 2005)
• c2:การคำนวณแบบกล่องดำ