ปกป้องปฏิบัติการจากวิศวกรรมย้อนกลับ?

ฉันได้ไตร่ตรองวิธีการป้องกันรหัส C / C ++ ของฉันจากการถอดและวิศวกรรมย้อนกลับ ปกติฉันจะไม่เอาผิดพฤติกรรมนี้ในรหัสของฉัน อย่างไรก็ตามโปรโตคอลปัจจุบันที่ฉันทำงานอยู่นั้นจะต้องไม่ถูกตรวจสอบหรือเข้าใจได้เพื่อความปลอดภัยของผู้คนต่าง ๆ

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

บางสิ่งที่ฉันคิดว่าจนถึงตอนนี้คือ:

• การฉีดโค้ด (การเรียกใช้ฟังก์ชันดัมมี่ก่อนและหลังการเรียกใช้ฟังก์ชันจริง)
• รหัส obfustication (mangles ถอดแยกชิ้นส่วนของไบนารี)

• เขียนกิจวัตรการเริ่มต้นของตัวเอง (ยากกว่าสำหรับผู้ debuggers ที่จะผูกไว้)

  void startup();  
  int _start()   
  {  
      startup( );  
      exit   (0)   
  }  
  void startup()  
  {  
      /* code here */  
  }

• ตรวจสอบ Runtime สำหรับ debuggers (และบังคับให้ออกหากตรวจพบ)

• ฟังก์ชั่นแทมโพลีน

   void trampoline(void (*fnptr)(), bool ping = false)  
   {  
     if(ping)  
       fnptr();  
     else  
       trampoline(fnptr, true);  
   }

• การจัดสรรและการจัดสรรคืนแบบไม่มีจุดหมาย (สแต็กจะเปลี่ยนไปมาก)

• การโทรแบบไม่มีจุดหมายและแทมโพลีน (กระโดดจำนวนมากในเอาต์พุตการถอดแยกชิ้นส่วน)
• ตันของการหล่อ (สำหรับการถอดชิ้นส่วนที่ทำให้ยุ่งเหยิง)

ฉันหมายถึงสิ่งเหล่านี้เป็นสิ่งที่ฉันคิด แต่พวกเขาทั้งหมดสามารถแก้ไขและหรือคิดออกโดยนักวิเคราะห์รหัสที่กำหนดกรอบเวลาที่เหมาะสม ฉันมีทางเลือกอื่นอีกไหม?

สิ่งที่อำพันพูดถูกต้อง คุณสามารถทำให้วิศวกรรมย้อนกลับยากขึ้น แต่คุณไม่สามารถป้องกันได้ คุณไม่ควรไว้วางใจ"ความปลอดภัย" ที่อาศัยการป้องกันการวิศวกรรมย้อนกลับ

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

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

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

Safe Net Sentinel (ชื่อเดิม Aladdin) อย่างไรก็ตาม Caveats - API ของพวกเขา sucks เอกสารประกอบและทั้งสองอย่างนั้นยอดเยี่ยมเมื่อเปรียบเทียบกับเครื่องมือ SDK ของพวกเขา

ฉันใช้วิธีการป้องกันฮาร์ดแวร์ ( Sentinel HASP HL ) มาหลายปีแล้ว ต้องใช้กุญแจ USB ที่เป็นกรรมสิทธิ์ซึ่งทำหน้าที่เป็น 'ลิขสิทธิ์' สำหรับซอฟต์แวร์ SDK ของพวกเขาเข้ารหัสและทำให้งงงวยปฏิบัติการและไลบรารีของคุณและช่วยให้คุณสามารถผูกคุณสมบัติที่แตกต่างกันในแอปพลิเคชันของคุณเพื่อเผาคุณสมบัติเป็นกุญแจ หากไม่มีคีย์ USB ที่ผู้ให้อนุญาตใช้งานให้และเปิดใช้งานซอฟต์แวร์จะไม่สามารถถอดรหัสและด้วยเหตุนี้จะไม่ทำงาน The Key ใช้โปรโตคอลการสื่อสาร USB แบบกำหนดเอง (นอกขอบเขตความรู้ของฉันฉันไม่ใช่คนขับอุปกรณ์) เพื่อทำให้การสร้างคีย์เสมือนยากหรือยุ่งเกี่ยวกับการสื่อสารระหว่าง wrapper รันไทม์และคีย์ SDK ของพวกเขาไม่เป็นมิตรกับนักพัฒนาและค่อนข้างเจ็บปวดที่จะรวมการเพิ่มการป้องกันเข้ากับกระบวนการสร้างอัตโนมัติ (แต่เป็นไปได้)

ก่อนที่เราจะใช้การป้องกัน HASP HL ​​มีโจรสลัดที่รู้จักกัน 7 คนที่ปล้น 'การป้องกัน' dotfuscator จากผลิตภัณฑ์ เราได้เพิ่มการป้องกัน HASP ในเวลาเดียวกันกับการอัปเดตที่สำคัญไปยังซอฟต์แวร์ซึ่งทำการคำนวณอย่างหนักเกี่ยวกับวิดีโอแบบเรียลไทม์ อย่างดีที่สุดที่ฉันสามารถบอกได้จากการทำโปรไฟล์และการเปรียบเทียบการป้องกัน HASP HL ​​จะชะลอการคำนวณอย่างเข้มข้นเพียงประมาณ 3% เนื่องจากซอฟต์แวร์ดังกล่าวเปิดตัวเมื่อประมาณ 5 ปีที่ผ่านมาจึงไม่มีการตรวจพบโจรสลัดตัวใหม่ของผลิตภัณฑ์ ซอฟต์แวร์ที่ปกป้องนั้นเป็นที่ต้องการสูงในกลุ่มตลาดและลูกค้าตระหนักถึงคู่แข่งหลายรายที่พยายามจะพลิกวิศวกรรม (โดยไม่ประสบความสำเร็จ) เรารู้ว่าพวกเขาได้พยายามขอความช่วยเหลือจากกลุ่มไม่กี่แห่งในรัสเซียที่โฆษณาบริการเพื่อหยุดการป้องกันซอฟต์แวร์

เมื่อเร็ว ๆ นี้เราได้ลองใช้โซลูชันซอฟต์แวร์ลิขสิทธิ์ของพวกเขา (HASP SL) ในโครงการขนาดเล็กซึ่งตรงไปตรงมามากพอที่จะทำงานหากคุณคุ้นเคยกับผลิตภัณฑ์ HL แล้ว ดูเหมือนว่าจะทำงาน ไม่มีรายงานการละเมิดลิขสิทธิ์ แต่ผลิตภัณฑ์นี้มีความต้องการลดลงมาก ..

แน่นอนว่าไม่มีการป้องกันใดที่สมบูรณ์แบบ หากใครบางคนมีแรงจูงใจเพียงพอและมีเงินสดจำนวนมากในการเผาไหม้ฉันมั่นใจว่า HASP จะได้รับความคุ้มครองจาก HASP

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

CLC
BCC over
.byte 0x09
over:

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

ฉันคิดว่ามันใกล้ถึงจุดเริ่มต้นของ Zen of Assembly Language ของ Michael Abrash ที่ซึ่งเขาแสดงให้เห็นถึงเคล็ดลับการถอดแยกชิ้นส่วนและเคล็ดลับการป้องกันการดีบั๊กอย่างง่าย 8088/6 มีคิวการดึงข้อมูลล่วงหน้าสิ่งที่คุณทำคือมีคำสั่งที่แก้ไขคำสั่งถัดไปหรือสองสามล่วงหน้า หากการก้าวเดียวคุณดำเนินการตามคำสั่งที่แก้ไขแล้วหากชุดจำลองการเรียนการสอนของคุณไม่ได้จำลองฮาร์ดแวร์อย่างสมบูรณ์คุณจะดำเนินการตามคำแนะนำที่แก้ไขแล้ว ในการใช้งานฮาร์ดแวร์จริงโดยปกติคำสั่งจริงจะอยู่ในคิวและตำแหน่งหน่วยความจำที่แก้ไขแล้วจะไม่ทำให้เกิดความเสียหายใด ๆ ตราบใดที่คุณไม่ได้เรียกใช้งานคำสั่งนั้นอีกครั้ง คุณอาจจะยังคงใช้กลอุบายเช่นนี้ได้ในวันนี้เนื่องจากตัวประมวลผลแบบไปป์ไลน์เรียกคำสั่งต่อไป หรือถ้าคุณรู้ว่าฮาร์ดแวร์มีคำสั่งและแคชข้อมูลแยกต่างหากคุณสามารถแก้ไขจำนวนไบต์ล่วงหน้าหากคุณจัดรหัสนี้ในบรรทัดแคชอย่างถูกต้องไบต์ที่ถูกแก้ไขจะไม่ถูกเขียนผ่านแคชคำสั่ง แต่แคชข้อมูลและ ตัวจำลองชุดคำสั่งที่ไม่มีตัวจำลองแคชที่เหมาะสมจะไม่สามารถทำงานได้อย่างถูกต้อง ฉันคิดว่าโซลูชันเฉพาะซอฟต์แวร์จะไม่ช่วยให้คุณไปได้ไกลมาก

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

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

อ่านหนังสือของเควินมิทนิคเรื่อง The Art of Deception บุคคลเช่นนั้นสามารถรับโทรศัพท์และให้คุณหรือเพื่อนร่วมงานส่งความลับให้กับระบบโดยคิดว่ามันเป็นผู้จัดการหรือผู้ร่วมงานหรือวิศวกรฮาร์ดแวร์คนอื่นในส่วนอื่นของ บริษัท และความปลอดภัยของคุณก็ปลิวไป ความปลอดภัยไม่ได้เกี่ยวกับการจัดการเทคโนโลยี แต่ต้องจัดการกับมนุษย์ด้วย

ใช้ตัวอย่างเช่นที่อัลกอริทึม AES มันเป็นอัลกอริทึมสาธารณะที่ดีมากและมีความปลอดภัยมาก ทำไม? สองเหตุผล: มันถูกตรวจสอบโดยคนฉลาดจำนวนมากและส่วน "ความลับ" ไม่ใช่อัลกอริธึมเอง - ส่วนความลับเป็นกุญแจสำคัญซึ่งเป็นหนึ่งในอินพุตของอัลกอริทึม มันเป็นวิธีที่ดีกว่ามากในการออกแบบโปรโตคอลของคุณด้วย "ความลับ" ที่สร้างขึ้นซึ่งอยู่นอกรหัสของคุณแทนที่จะทำให้ตัวเองเป็นรหัสลับ รหัสสามารถตีความได้เสมอไม่ว่าคุณจะทำอะไรและ (ในทางที่ดี) ความลับที่สร้างขึ้นสามารถถูกโจมตีได้โดยวิธีการใช้กำลังดุร้ายหรือโดยการขโมย

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

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

การทำให้โค้ดกลับยากวิศวกรเรียกว่า code obfuscation

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

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

a = useless_computation();
a = 42;

ทำเช่นนี้:

a = complicated_computation_that_uses_many_inputs_but_always_returns_42();

หรือแทนที่จะทำสิ่งนี้:

if (running_under_a_debugger()) abort();
a = 42;

ทำสิ่งนี้ (ซึ่งrunning_under_a_debuggerไม่ควรระบุได้ง่าย ๆ ว่าเป็นฟังก์ชันที่ทดสอบว่ารหัสกำลังทำงานภายใต้ดีบักเกอร์หรือไม่ - ควรผสมการคำนวณที่มีประโยชน์กับการตรวจจับดีบักเกอร์):

a = 42 - running_under_a_debugger();

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

some_function();

ทำสิ่งนี้เมื่อคุณรู้รูปแบบบิตที่แน่นอนในsome_data_structure:

goto (md5sum(&some_data_structure, 42) & 0xffffffff) + MAGIC_CONSTANT;

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

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

โปรโตคอลปัจจุบันที่ฉันทำงานอยู่ต้องไม่ถูกตรวจสอบหรือเข้าใจได้เพื่อความปลอดภัยของผู้คนต่าง ๆ

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

อ่านแนะนำ:

• พระคัมภีร์ความปลอดภัย: วิศวกรรมความปลอดภัยโดย Ross Anderson
• The obfuscation Bible : ซอฟต์แวร์แอบแฝงโดย Christian Collberg และ Jasvir Nagra

หลายครั้งที่ความกลัวว่าผลิตภัณฑ์ของคุณได้รับการออกแบบเชิงวิศวกรรมกลับถูกวางผิดที่ ใช่มันสามารถทำการออกแบบวิศวกรรมย้อนกลับได้ แต่มันจะโด่งดังในช่วงเวลาสั้น ๆ หรือแฮกเกอร์จะพบว่ามันคุ้มค่าที่จะย้อนกลับ มัน? (งานนี้ไม่ใช่กิจกรรมเล็ก ๆ สำหรับรหัสบรรทัดที่สำคัญ)

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

IMHO ปฏิบัติตามข้อควรระวังพื้นฐานที่คุณจะรับและปล่อยตัว ถ้ามันกลายเป็นจุดของวิศวกรรมย้อนกลับที่หมายความว่าคุณทำงานได้ดีจริงๆคุณจะพบกับวิธีที่ดีกว่าในการเอาชนะมัน โชคดี.

ใช้เวลาในการอ่านของhttp://en.wikipedia.org/wiki/Security_by_obscurity#Arguments_against ฉันแน่ใจว่าคนอื่นอาจให้แหล่งที่มาที่ดีกว่าว่าทำไมความปลอดภัยโดยความคลุมเครือนั้นเป็นสิ่งที่ไม่ดี

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

นับตั้งแต่เดือนกรกฎาคมปี 2013 มีความสนใจใน obfuscation แข็งแกร่งเข้ารหัส (ในรูปแบบของindistinguishability Obfuscation ) ซึ่งดูเหมือนว่าจะมีการกระตุ้นจากการวิจัยจากเดิมAmit สหาย

• Sahai, Garg, Gentry, Halevi, Raykova, Waters, ผู้สมัครไม่สามารถแยกแยะ Obfuscation และการเข้ารหัสหน้าที่สำหรับทุกวงจร (21 กรกฎาคม 2013)
• สหายน้ำ, วิธีการใช้ indistinguishability Obfuscation: เห็นด้วยการเข้ารหัส, และอื่น ๆ
• Sahai, Barak, Garg, Kalai, Paneth, ปกป้องการทำให้งงงวยจากการโจมตีพีชคณิต (4 กุมภาพันธ์ 2014)

คุณสามารถค้นหาข้อมูลกลั่นบางอย่างในนี้บทความ Quanta นิตยสารและในการที่บทความ IEEE Spectrum

ในปัจจุบันจำนวนทรัพยากรที่จำเป็นต้องใช้ในการใช้เทคนิคนี้ทำให้เป็นไปไม่ได้ แต่ AFAICT ฉันทามติค่อนข้างเป็นแง่ดีเกี่ยวกับอนาคต

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

จะแจ้งให้ตัวเองอ่านวรรณกรรมทางวิชาการเกี่ยวกับobfuscation รหัส Christian Collberg แห่งมหาวิทยาลัยอริิเป็นนักวิชาการที่มีชื่อเสียงในสาขานี้ Salil Vadhan จากมหาวิทยาลัยฮาร์วาร์ดก็ทำงานได้ดีเช่นกัน

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

มีรายงานเมื่อเร็ว ๆ นี้ที่เรียกว่า " โปรแกรมทำให้งงงวยและโปรแกรมครั้งเดียว " หากคุณจริงจังกับการปกป้องแอปพลิเคชันของคุณจริงๆ กระดาษโดยทั่วไปไปรอบ ๆ ผลลัพธ์เป็นไปไม่ได้ทางทฤษฎีโดยการใช้ฮาร์ดแวร์ที่ง่ายและสากล

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

อย่างน้อยเอกสารเหล่านั้นควรทำให้คุณมีบรรณานุกรมเพียงพอที่จะเดินไปในวรรณคดีที่เกี่ยวข้องหากผลลัพธ์เหล่านี้ไม่ได้ผลสำหรับความต้องการของคุณ

อัปเดต: แนวคิดใหม่ของการทำให้งงงวยที่เรียกว่าการทำให้งงที่แยกไม่ออกสามารถลดผลที่เป็นไปไม่ได้(กระดาษ)

หากมีคนต้องการใช้เวลาในการย้อนกลับไบนารีของคุณก็ไม่มีอะไรที่คุณสามารถทำได้เพื่อหยุดพวกเขา คุณสามารถทำได้ถ้ายากกว่านี้เล็กน้อย แต่มันเกี่ยวกับมัน หากคุณต้องการเรียนรู้เกี่ยวกับสิ่งนี้จริงๆให้รับสำเนาของhttp://www.hex-rays.com/idapro/และแยกส่วนสองสามไบนารี

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

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

เพื่อให้สามารถเลือกตัวเลือกที่เหมาะสมคุณควรคิดถึงประเด็นต่อไปนี้:

1. มีแนวโน้มว่า "ผู้ใช้ใหม่" ไม่ต้องการชำระเงิน แต่ใช้ซอฟต์แวร์ของคุณหรือไม่
2. เป็นไปได้หรือไม่ที่ลูกค้าปัจจุบันต้องการใบอนุญาตมากกว่าที่เป็นอยู่?
3. ผู้มีโอกาสเป็นลูกค้ายินดีจ่ายเท่าใด
4. คุณต้องการมอบสิทธิ์การใช้งานต่อผู้ใช้ / ผู้ใช้พร้อมกัน / เวิร์กสเตชัน / บริษัท หรือไม่
5. ซอฟต์แวร์ของคุณต้องการการฝึกอบรม / การปรับแต่งเองให้มีประโยชน์หรือไม่?

หากคำตอบของคำถาม 5 คือ "ใช่" ไม่ต้องกังวลกับสำเนาที่ผิดกฎหมาย พวกเขาจะไม่เป็นประโยชน์ต่อไป

หากคำตอบสำหรับคำถามที่ 1 คือ "ใช่" อันดับแรกให้คิดถึงการคิดราคา (ดูคำถาม 3)

หากคุณตอบคำถาม 2 "ใช่" ดังนั้นรูปแบบ "จ่ายต่อการใช้งาน" อาจเหมาะสมสำหรับคุณ

จากประสบการณ์ของฉันการจ่ายต่อการใช้งาน + การปรับแต่งและการฝึกอบรมเป็นการป้องกันที่ดีที่สุดสำหรับซอฟต์แวร์ของคุณเนื่องจาก:

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

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

รหัสที่ได้รับการป้องกันในเครื่องเสมือนดูเหมือนจะเป็นไปไม่ได้ที่จะย้อนกลับวิศวกรในตอนแรก Themida Packer

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

IDA Pro ยังมาพร้อมกับรหัสแอสเซมบลีที่ดีไปยังตัวแปลงรหัสต้นฉบับ C แม้ว่ารหัสที่สร้างขึ้นจะมีลักษณะเหมือนตัวชี้ / ที่อยู่ทางคณิตศาสตร์ที่ยุ่งเหยิง .. หากคุณเปรียบเทียบกับต้นฉบับคุณสามารถแก้ไขข้อผิดพลาดทั้งหมด

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

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

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

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

สิ่งที่มนุษย์ประกอบสามารถถอดประกอบได้

เป็นเรื่องจริงที่การแยกส่วน (เหมาะสม) มักจะเป็นงานที่ยากขึ้นเล็กน้อยดังนั้นฝ่ายตรงข้ามของคุณจะต้องมีทักษะมากกว่าแต่คุณสามารถสมมติได้ว่ามีบางคนที่มีคุณภาพเช่นนี้และเป็นทางออกที่ปลอดภัย

หากคุณต้องการปกป้องบางสิ่งจาก REs คุณต้องรู้เทคนิคทั่วไปอย่างน้อยที่ใช้โดย REs

ดังนั้นคำพูด

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

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

(มีตัวอย่างของซอฟต์แวร์ที่ใช้การป้องกันในทางที่ผิดการป้องกันดังกล่าวไม่มีอยู่จริงเพื่อหลีกเลี่ยงการพูดอย่างคลุมเครือฉันจะให้ตัวอย่างที่อธิบายสั้น ๆ ในอินเทอร์เน็ต: Oxford English Dictionary Second Edition บน CD-ROM v4 คุณสามารถอ่านเกี่ยวกับ การใช้ SecuROM ล้มเหลวในหน้าต่อไปนี้: Oxford English Dictionary (OED) บนซีดีรอมในสภาพแวดล้อม Windows 16-, 32- หรือ 64- บิต: การติดตั้งฮาร์ดดิสก์, บั๊ก, มาโครประมวลผลคำ, เครือข่าย, แบบอักษรและ อื่น ๆ )

ทุกอย่างต้องใช้เวลา

หากคุณยังใหม่กับเรื่องนี้และไม่มีเวลาเป็นเดือนหรือหลายปีกว่าจะเข้าสู่เรื่อง RE ได้อย่างเหมาะสมไปกับโซลูชันที่มีให้โดยผู้อื่น ปัญหาที่นี่เห็นได้ชัดพวกเขามีอยู่แล้วดังนั้นคุณรู้อยู่แล้วว่าพวกเขาไม่ปลอดภัย 100% แต่การสร้างการป้องกันแบบใหม่ของคุณเองจะทำให้คุณรู้สึกถึงการป้องกันที่ผิดพลาดเว้นแต่คุณจะรู้ว่าศิลปะใน วิศวกรรมย้อนกลับและการป้องกัน (แต่คุณทำไม่ได้อย่างน้อยในขณะนี้)

จุดประสงค์ของการป้องกันซอฟต์แวร์คือสร้างความกลัวให้กับมือใหม่วางแผง REs ทั่วไปและสร้างรอยยิ้มให้กับใบหน้าของ RE ที่มีประสบการณ์หลังจากการเดินทางของเขา / เธอ

ในการพูดคุยทางธุรกิจคุณอาจพูดได้ว่ามันเป็นเรื่องของการชะลอการแข่งขันมากที่สุดเท่าที่จะเป็นไปได้

(ดูที่การนำเสนอที่ดีของSilver Needle ใน Skypeโดย Philippe Biondi และ Fabrice Desclaux ที่แสดงใน Black Hat 2006)

คุณทราบว่ามีหลายสิ่งหลายอย่างเกี่ยวกับ RE ที่นั่นดังนั้นเริ่มอ่านมัน :)

ฉันพูดเกี่ยวกับการจำลองเสมือนดังนั้นฉันจะให้ลิงก์ไปยังเธรดที่เป็นแบบอย่างหนึ่งจากEXETOOLS FORUM : ตัวป้องกันซอฟต์แวร์ที่ดีที่สุด: Themida หรือ Enigma Protector? . มันอาจช่วยคุณได้เล็กน้อยในการค้นหาเพิ่มเติม

ฉันไม่คิดว่ารหัสใด ๆ ที่ไม่สามารถสับเปลี่ยนได้ แต่รางวัลจะต้องดีสำหรับใครบางคนที่ต้องการลองใช้

ต้องบอกว่ามีสิ่งที่คุณควรทำเช่น:

• ใช้ระดับการปรับให้เหมาะสมสูงสุดเท่าที่จะเป็นไปได้ (วิศวกรรมย้อนกลับไม่เพียง แต่เกี่ยวกับการรับลำดับแอสเซมบลีเท่านั้น แต่ยังเกี่ยวกับการทำความเข้าใจรหัส รหัสที่ได้รับการปรับปรุงให้ดีที่สุดนั้นสามารถทำตามได้
• ทำให้โครงสร้างมีความหนาแน่นโดยไม่มีชนิดข้อมูลที่ใหญ่กว่าที่จำเป็น จัดโครงสร้างสมาชิกใหม่ระหว่างรหัสทางการ ฟิลด์บิตที่จัดเรียงใหม่ในโครงสร้างเป็นสิ่งที่คุณสามารถใช้ได้
• คุณสามารถตรวจสอบการมีอยู่ของค่าบางอย่างที่ไม่ควรเปลี่ยน (ข้อความลิขสิทธิ์เป็นตัวอย่าง) หาก byte vector มี "vwxyz" คุณสามารถมีอีก byte vector ที่มี "abcde" และเปรียบเทียบความแตกต่าง ฟังก์ชั่นที่ทำมันไม่ควรส่งผ่านพอยน์เตอร์ไปยังพาหะ แต่ใช้พอยน์เตอร์ภายนอกที่กำหนดในโมดูลอื่นเป็น (รหัสหลอก -C) "ถ่าน * p1 = & string1 [539];" และ "char p2 = & string2 [-11731];" ด้วยวิธีนี้จะไม่มีพอยน์เตอร์ชี้ไปที่สตริงทั้งสอง ในรหัสเปรียบเทียบคุณเปรียบเทียบสำหรับ " (p1-539 + i) - * (p2 + 11731 + i) == ค่าบางค่า" แคร็กเกอร์จะคิดว่ามันปลอดภัยที่จะเปลี่ยน string1 เพราะไม่มีใครอ้างอิงได้ ฝังการทดสอบในสถานที่ที่ไม่คาดคิด

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

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

แต่มีอีก 3 หมายเหตุ:

1. เป็นไปได้ที่จะทำให้วิศวกรรมย้อนกลับเป็นไปไม่ได้แต่ (และนี่เป็นเรื่องที่ใหญ่มาก แต่) คุณไม่สามารถทำได้บนซีพียูทั่วไป ฉันยังพัฒนาฮาร์ดแวร์มากและมักใช้ FPGA เช่น Virtex 5 FX มี CPU ของ PowerPC อยู่และคุณสามารถใช้ APU เพื่อใช้ซีพียู opcode ของคุณเองในฮาร์ดแวร์ของคุณ คุณสามารถใช้สิ่งอำนวยความสะดวกนี้ในการถอดรหัส incstuctions สำหรับ PowerPC ซึ่งไม่สามารถเข้าถึงได้โดยซอฟต์แวร์ภายนอกหรือซอฟต์แวร์อื่นหรือแม้แต่เรียกใช้คำสั่งในฮาร์ดแวร์ เนื่องจาก FPGA มีการเข้ารหัส AES ในตัวสำหรับการกำหนดค่าบิตสตรีมคุณไม่สามารถทำวิศวกรรมย้อนกลับได้ (ยกเว้นบางคนจัดการเพื่อทำลาย AES แต่แล้วฉันคิดว่าเรามีปัญหาอื่น ๆ ... ) วิธีนี้ทำให้ผู้ขายทรัพย์สินทางปัญญาของฮาร์ดแวร์ยังปกป้องงานของพวกเขา

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

3. อย่าทำให้โปรแกรมของคุณไม่สามารถเรียกโปรแกรมได้ / ไม่สามารถรันได้ ลองใช้การตรวจจับการดีบั๊กบางประเภทและนำไปใช้เช่นในสูตรบางอย่างหรือเพิ่มเนื้อหาการดีบักลงในค่าคงที่เวทย์มนตร์ จะยากกว่านี้หากโปรแกรมของคุณดูในโหมดแก้ไขข้อบกพร่องคือหากโปรแกรมทำงานปกติ แต่ทำให้การคำนวณการดำเนินการผิดพลาดอย่างสมบูรณ์ เช่นฉันรู้ว่าเกม eco บางเกมที่มีการป้องกันการคัดลอกที่น่ารังเกียจจริงๆ (ฉันรู้ว่าคุณไม่ต้องการให้มีการป้องกันการคัดลอก แต่คล้ายกัน): รุ่นที่ถูกขโมยเปลี่ยนทรัพยากรที่ขุดได้หลังจากเล่นเกม 30 นาทีและทันใดนั้น ทรัพยากร. โจรสลัดเพิ่งแตกมัน (เช่นทำวิศวกรรมย้อนกลับ) - ตรวจสอบว่ามันทำงานหรือไม่และ volia ปล่อยมัน การเปลี่ยนพฤติกรรมเล็กน้อยเช่นนั้นเป็นการยากที่จะตรวจจับ หากพวกเขาไม่ปรากฏขึ้นเพื่อตรวจจับทันที แต่ล่าช้าเท่านั้น

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

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

นี่คือตัวอย่างหนึ่งของคำสั่งโปรแกรมที่ทำให้งงงวยอย่างสมบูรณ์เพื่อแสดงจุดของฉัน:

printf("1677741794\n");

ไม่มีใครคาดเดาได้ว่าสิ่งที่มันทำคือ

printf("%d\n", 0xBAADF00D ^ 0xDEADBEEF);

มีบทความที่น่าสนใจเกี่ยวกับเรื่องนี้ซึ่งพิสูจน์ผลลัพธ์ที่เป็นไปไม่ได้ มันถูกเรียกว่า"ใน (IM) เป็นไปได้ของโปรแกรมเครื่องมือ obfuscating"

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

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

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

ฉันเป็นผู้เขียนชุดประกอบวิศวกรรมย้อนกลับสำหรับ x86 หากคุณพร้อมที่จะเซอร์ไพรส์มาก ๆ ส่งผลของความพยายามอย่างเต็มที่มาให้ฉัน (ติดต่อฉันผ่านเว็บไซต์ของฉัน) ไม่กี่คนที่ฉันเห็นคำตอบจะนำเสนอสิ่งกีดขวางมากมายสำหรับฉัน หากคุณต้องการดูว่าโค้ดวิศวกรรมย้อนกลับที่ซับซ้อนทำงานอย่างไรคุณควรศึกษาเว็บไซต์ที่มีความท้าทายด้านวิศวกรรมย้อนกลับ

คำถามของคุณสามารถใช้การชี้แจงบางอย่าง คุณคาดหวังให้โปรโตคอลเป็นความลับได้อย่างไรหากรหัสคอมพิวเตอร์สามารถแก้ไขวิศวกรรมย้อนกลับได้ หากโปรโตคอลของฉันจะส่งข้อความที่เข้ารหัส RSA (แม้แต่กุญแจสาธารณะ) คุณจะได้อะไรจากการรักษาความลับโปรโตคอล สำหรับวัตถุประสงค์ในทางปฏิบัติผู้ตรวจสอบจะต้องเผชิญหน้ากับลำดับของบิตสุ่ม

Groetjes Albert

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

คุณสามารถทำได้โดยอาศัย Halting Program ("program X halt?") ซึ่งโดยทั่วไปไม่สามารถแก้ไขได้ การเพิ่มโปรแกรมที่ยากต่อการให้เหตุผลกับโปรแกรมของคุณทำให้โปรแกรมของคุณยากที่จะให้เหตุผล การสร้างโปรแกรมดังกล่าวง่ายกว่าการแยกออกจากกัน คุณสามารถเพิ่มรหัสลงในโปรแกรมที่มีระดับความยากในการให้เหตุผลที่แตกต่างกัน ผู้สมัครที่ดีคือโปรแกรมการให้เหตุผลเกี่ยวกับนามแฝง ("พอยน์เตอร์")

Collberg et al มีกระดาษ ("การผลิตราคาถูกความยืดหยุ่นและการสร้างความทึบแสงทึบแสง") ที่กล่าวถึงหัวข้อเหล่านี้และกำหนดความหลากหลายของคำว่า "ทึบแสง" ที่สามารถทำให้เหตุผลเรื่องรหัสยากมาก:

http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.39.1946&rep=rep1&type=pdf

ฉันไม่เห็นวิธีเฉพาะของ Collberg ที่ใช้กับรหัสการผลิตโดยเฉพาะอย่างยิ่งไม่ใช่ซอร์สโค้ด C หรือ C ++

Obfuscator DashO Java ดูเหมือนว่าจะใช้แนวคิดที่คล้ายกัน http://www.cs.arizona.edu/~collberg/Teaching/620/2008/Assignments/tools/DashO/

สิ่งแรกที่ต้องจดจำเกี่ยวกับการซ่อนรหัสของคุณ : ไม่จำเป็นต้องซ่อนรหัสของคุณทั้งหมด

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

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

เหตุผลที่คุณทำเช่นนี้ก็เพราะคุณต้องการเข้ารหัสจำนวนน้อยที่สุดเท่าที่จะเป็นไปได้

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

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

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

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

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

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

ขั้นตอนที่สาม : ทำซ้ำขั้นตอนที่สองหลาย ๆ ครั้งตามที่คุณต้องการ เมื่อคุณทำงานได้อย่างถูกต้องโดยไม่ต้องถอดรหัสข้อผิดพลาดแล้วคุณจะต้องเริ่มสร้างในเหมืองที่ดินสำหรับฝ่ายตรงข้าม

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

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

ฉันแน่ใจว่าคุณสามารถเกิดขึ้นกับคุณเองกับระเบิดได้สนุกกับมัน

สิ่งที่ควรจดจำ : คุณสามารถเข้ารหัสรหัสของคุณได้จริงแทนที่จะเป็นรหัส 64 ด้วยวิธีนี้ base64 แบบง่ายจะไม่ถอดรหัสโปรแกรม

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

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

โชคดี!

มีใครเคยลองใช้ CodeMorth: http://www.sourceformat.com/code-obfuscator.htmหรือไม่ หรือ Themida: http://www.oreans.com/themida_features.php ?

หลังจากนั้นหนึ่งดูพรอมต์มากขึ้น