Hacker Crack โปรแกรมอย่างไร

หากใครที่อายุใกล้ ๆ 30 ต้องเคยผ่านประสบการณ์โลกออนไลน์ในยุค 90s' มาไม่มากก็น้อย เป็นยุคที่เราเน้นใช้โปรแกรมเถื่อน ขายกันอยู่ในห้างพั____พ กันฉ่ำ ๆ ตำรวจตรวจแล้วเราไม่มีขายตัว แต่เคยสงสัยถึงที่มาของโปรแกรมเหล่านี้มั้ยว่า เขา Crack กันอย่างไร วันนี้เราจะมาเล่าให้อ่านกัน

ปล. แก ๆ การรู้เรื่อง Crack Software พวกนี้ไม่ได้บอกว่ากรูเป็นคน Crack นะเว้ย มันเป็นเรื่องทั่ว ๆ ไปที่คนเรียนคอมต้องเรียนอยู่แล้ว

สิ่งที่เราเห็น

เวลาเราโหลดพวกโปรแกรม Cracked เหล่านี้มา สิ่งที่เขาจะให้เราทำนั้นมีหลากหลายรูปแบบมาก ๆ ตั้งแต่ การให้ Executable File ถ้าเป็นใน Windows เป็น .exe หรือถ้าเป็น macOS ก็จะเป็น .app แล้วเอาไปก๊อปแปะทับกับ Executable File ที่ติดตั้งไปก่อนหน้านี้ก็จะใช้งานได้

เวลาผ่านไปอีก เราเริ่มต้องก๊อปหลายไฟล์มากขึ้น จนเขาเริ่มทำเป็น Crack Installer Wizard สักอย่างขึ้นมา จริง ๆ มันก็คือ Shell Script ที่สั่ง Copy File เหมือนเดิม แค่ทำเป็นหน้าต่างโปรแกรมเพื่อให้ใช้งานง่ายขึ้นเท่านั้นเอง จนไปถึง การรันโปรแกรมแปลก ๆ ไว้เป็นเบื้องหลังเอาไว้เวลาจะใช้งานโปรแกรมนั้น ๆ หรือการห้ามต่อเน็ตต่าง ๆ นา ๆ อันนี้คือ ภาพที่เราเห็นทั้งหมดจากวงการ Crack Software ทั้งหลาย

Reverse Engineering Software

ก่อนที่เราจะไปทำความเข้าใจในเรื่องนี้ให้ลึกขึ้น สำหรับคนทั่วไป เราจะต้องมาเล่าก่อนว่า โปรแกรมที่เขียน มันทำงานอะไรอย่างไร

โดยปกติโปรแกรมจะเขียนโดยใช้ Programming Language เช่น Python, Java, Rust และอื่น ๆ อีกมากมาย เราเรียกมันว่า Source Code ซึ่งเป็นภาษาที่ค่อนข้างเป็นมิตรกับมนุษย์มาก ๆ แต่เครื่องคอมพิวเตอร์ไม่ได้ออกแบบมาให้ทำงานกับภาษาพวกนี้ จึงทำให้เราจะต้อง แปลง ให้อยู่ในรูปของภาษา Machine Code ที่เครื่องคอมพิวเตอร์อ่านและทำงานได้ เราเคยเขียนเรื่องนี้ไว้แล้วกลับไปอ่านได้ที่ลิงค์ด้านบนนี้เลย

สิ่งที่เราได้จากการติดตั้งโปรแกรมมาจะเป็น Executable File คือไฟล์ที่เครื่องใช้รันได้ละ มันอยู่ในรูปของ Machine Code เรียบร้อย ดังนั้น หากเราต้องการคุ้ยข้อมูลและเปลี่ยนแปลงการทำงาน เราก็ต้องเข้าไปเปลี่ยนใน Machine Code พวกนี้แหละ เราเรียกงานพวกนี้ว่า Reverse Engineering หรือวิศวกรรมย้อนกลับ

การทำ Reverse Engineering นั้นจริง ๆ ไม่ใช่เรื่องผิดนะ มันเป็นเรื่องที่เราทำทั่ว ๆ ไปอยู่แล้ว และมันมี Software เข้ามาช่วยให้เราทำงานได้ง่ายขึ้นกว่าเดิมเยอะ อย่างพวก Disassembler ที่ทำหน้าที่แปลง Machine Code กลับมาเป็น Source Code ที่อยู่ในภาษา Assembly หรือกระทั่ง Decompiler แปลง Machine Code ให้กลับไปเป็น Source Code ภาษาอย่างพวก C และ C++ ได้เลยละ นอกจากนั้นโปรแกรมพวกนี้ยังมาพร้อมกับ Debugging Tools มาให้ด้วย ทำให้เราสามารถสร้างพวก Break Point และเข้าถึงค่าใน Memory เพื่อตรวจสอบการทำงานของโปรแกรมอย่างละเอียดยิบ ๆ ได้เลยแหละ

ตัวเลือกโปรแกรมมันมีเยอะมาก ๆ แต่ส่วนตัวเราเน้นใช้ในการตรวจสอบ Software และ Debugging ในบางสถานการณ์ เราเลือกใช้ Ghidra เจ้านี่เป็นเหมือนกล่องเครื่องมือสำหรับการทำ Software Reverse Engineering ที่ดูแลโดย NSA ของประเทศสหรัฐ เรียกว่าครบมือทำได้ตั้งแต่ Disassembly, Assembly, Decompilation, Graphing และ Scripting

โปรแกรมตรวจ License ได้อย่างไร

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

การตรวจสอบแบบ Offline นั้นทำได้ง่ายมาก ๆ คือ เราจะมีการสร้างเงื่อนไขบางอย่างขึ้นมา โดยเงื่อนไขนั้นจะต้องสามารถตรวจสอบได้ว่า ผู้ใช้ได้รับ License มาจริง ๆ สิ่งที่มักจะใช้ในการตรวจสอบ ณ เวลานั้นคือ CD Key ให้เราคิดภาพว่า มันเหมือนกับ Password เลย ในตัวเริ่มต้น ง่ายที่สุดนักพัฒนาอาจจะใช้สูตรทางคณิตศาสตร์บางอย่างมาเพื่อ Generate Key ขึ้นมา และส่งให้กับคนซื้อ

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

สิ่งที่เกิดขึ้นคือ วิธีการ หรือ Algorithm ที่ใช้ตรวจสอบความถูกต้อง มันจะต้องฝังอยู่ในโปรแกรมที่ถูกติดตั้งลงไปบนเครื่องของผู้ใช้ นั่นแปลว่า หากผู้ใช้เป็น Cracker เขาสามารถที่จะพยายามแกะวิธีการที่โปรแกรมใช้ในการตรวจสอบ และย้อนกลับมาเป็นวิธีการในการสร้าง Key จึงออกมาเป็นพวกโปรแกรม Keygen อะไรพวกนั้น

ในยุคต่อมา การเชื่อมต่ออินเตอร์เน็ตดูเป็นเรื่องทั่วไปมากขึ้น การตรวจสอบ License ผ่านอินเตอร์เน็ตเลยเริ่มถูกใช้งานกันมากขึ้นเรื่อย ๆ หลักการของมันคือ มันจะมี Local License Server (LLS) ภายในเครื่องของเรา ทำหน้าที่ส่งข้อมูลกลับไปที่ Server ของผู้พัฒนา Software ตรวจสอบว่า ผู้ใช้คนนี้มีสิทธิ์ใช้ Software ของเราจริงหรือไม่ มันก็จะส่งข้อมูลการตรวจสอบกลับมาให้เครื่องเราแล้วจัดการตามผลการตรวจสอบ พอระบบที่ใช้ในการตรวจสอบทั้งหมดมันไปอยู่บนฝั่ง Server ที่สามารถเข้าถึงได้ยากกว่า เลยทำให้การ Crack นั้นทำได้ยากขึ้น แต่ไม่ได้บอกนะว่า มันทำไม่ได้

เขาสามารถ Crack Software ได้อย่างไร

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

license_input = input()

if (check_license(license_input) :
  unlock_software_with_license()
else :
  lock_that_bi_ch_out()
  call_mothership("Invalid License Detected", license_input, system_info)

หลักการทำงาน "พื้นฐาน" ที่สุด น่าจะคล้ายกับ Code ด้านบนนี้คือ เรารับ License บางอย่างเข้ามา จากนั้น มันจะไปเรียกระบบตรวจสอบ License ไม่ว่าจะเป็น Online หรือ Offline ก็ตาม หาก License ถูกต้อง ก็ปลดล๊อคโปรแกรมให้ใช้งานได้ แต่ถ้าไม่ถูก ก็ Lock ใส่แมร่งเลย บางตัวแถมส่งข้อมูลกลับไปหาผู้พัฒนาด้วยว่ามีการใช้ License ผิดพร้อมข้อมูลเครื่องซะครบมือเลยก็มีเหมือนกัน

หากเราเป็น Cracker สิ่งที่เราต้องทำก็คือ การเปลี่ยนผลของเงื่อนไขสำหรับการตรวจสอบให้ออกมาเป็นจริงให้ได้ เขาก็จะต้องใช้ Reverse Engineering เข้าไปค้นหาจุดนั้นแหละ แล้วก็ทำการแก้ไข เพื่อให้มันผ่านเงื่อนไขเข้าไปใช้งานโปรแกรมได้ หรือบางตัว หากเราหาเงื่อนไขพวกนี้เจอได้ เราก็อาจจะเขียนคำสั่งเพิ่มเพื่อให้มัน Jump หนี ไม่ทำงานคำสั่งสำหรับการตรวจสอบเลยก็ได้เหมือนกัน จากนั้น เราก็ทำการ Assemble กลับไปเป็น Executable File อีกครั้ง เรามักจะเรียกว่า Patched File

ท่าที่เรามักจะเจอในแบบ Offline

หรือ ๆ ท่าที่เราเห็นเยอะมากตอนเราเด็ก ๆ คือ บางโปรแกรมมันจะมี Free Trial ให้เรากดได้ หรือคือให้เราสามารถกดทดลองใช้ก่อนที่จะซื้อโปรแกรมจริงได้ เช่นทดลองใช้ 30 เป็นต้น Crack บางตัวมันกวนประสาทหนักมากคือ มันไม่ได้ไปยุ่งกับ Logic ของการเช็ค License แต่มันไปปรับ เวลาที่ยังสามารถทดลองใช้งานได้

trial_start_date = get_trial_start_date()

if (is_trial() and today() - trial_start_date <= 30) :
  unlock_software_with_trial_license()
else :
  check_license()

สิ่งที่น่าจะถูกเขียน Logic ง่าย ๆ ในโปรแกรมคือ มันจะไปดึงวันที่เราเริ่มกด Free Trial ขึ้นมา เอามาเทียบกับวันนี้ว่าวันที่เท่าไหร่ ลบกัน แล้วถ้ามันน้อยกว่าหรือเท่ากับ 30 วันก็ให้ใช้งานโปรแกรมในฐานะของ Free Trial ได้หรือไม่ใช่ เลยวันไปละก็ให้เด้งหน้าต่างสำหรับกรอก License ขึ้นมา แล้วเข้ากระบวนการเช็คอะไรก็ว่ากันไป

trial_start_date = today()

// trial_start_date = get_trial_start_date()

if (is_trial() and today() - trial_start_date <= 30) :
  unlock_software_with_trial_license()
else :
  check_license()

ในเมื่อเราเช็คแบบนี้ ก็เอางี้เลย เราไป Jump ตรงส่วนที่สั่งให้ไปดึงวันที่กดเริ่ม Free Trial ออกแล้วแทนที่ด้วยตัวแปรเดียวกัน แต่เปลี่ยนค่าเป็นวันนี้แทน ดังนั้น ระยะเวลาของวันนี้กับวันนี้ก็จะเป็น 0 วันซึ่งผ่านเงื่อนไขการตรวจสอบได้นั่นเอง ก็เรียกว่าเป็นท่าหนึ่งที่เราเจอได้ในช่วงสักปี 1996-2010 จำได้ว่าตอนเราเด็ก ๆ เจออะไรแบบนี้เยอะมาก

ต่อมาในยุคที่พวก Online License Check เริ่มเข้ามา ตอนนั้นบางคนมีอินเตอร์เน็ต บางคนไม่มี ถ้าเราบีบไปใช้ Online 100% เลย ผู้ใช้บางคนไม่ซื้อแน่นอน ทำให้ถ้าเราเชื่อมต่อ Internet โปรแกรมมันจะเชื่อมต่อเข้าไปหาผู้พัฒนาตรวจสอบ License เป็น Online Activation ปกติ แต่ถ้าไม่มี มันจะเด้งอีกตัวเลือกคือ Telephone Activation เด็กรุ่นใหม่ ๆ งง แน่นอนว่ามันคืออะไร มันเป็นวิธีการที่เราติดตั้งโปรแกรมใส่ Serial Number ลงไปแล้วเวลาจะ Activate มันจะให้ตัวเลขมาชุดนึง เช่น Installation ID หรือ User ID บางอย่าง แล้วให้เราโทรไปหาเบอร์ของผู้พัฒนา มันจะต่อสายไปที่ระบบ Activation เราก็กด Installation ID เข้าไป แล้วเขาจะบอก Activation Code กลับมาให้ เราก็จดเอาไว้ แล้วเอาไปกรอกก็จะใช้งานโปรแกรมได้ ดังนั้นจริง ๆ แล้วหลักการ Crack ก็ไม่ต่างจากโปรแกรมที่ใช้ Offline License Check เลย แค่ว่า เราจะต้องเพิ่มกระบวนการตัดอินเตอร์เน็ตออกไป ง่ายสุด ๆ ดึงสายออกไปเลย และบางตัวเก่ง ๆ หน่อย หากเราใช้ Phone Activation และเครื่องเราต่อเน็ตมันจะคุยเช็คกับ Server เขาเลยต้องเพิ่มพวก Patched File ที่เข้าไปปิดการทำงานตรงนี้ไป

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

Code Obfuscation

แน่นอนว่า ผู้พัฒนาโปรแกรมเขาไม่นั่งโง่ปล่อยให้คน Crack โปรแกรมเขาจนต้องสูญเสียรายได้ไปแน่นอน เขาจะต้องมีการปกป้อง Software ของตัวเองจากการโดน Crack ให้ได้ หนึ่งในวิธีการที่เขาใช้กันคือ Code Obfuscation หรือการทำให้ Code มันอ่านได้ยาก หน้าตามันอ่านไม่รู้เรื่อง เพื่อให้ทำ Reverse Engineer ได้ยากมากขึ้น โดยปัจจุบันมันมีเครื่องมือหลายตัวมาก ๆ ที่เข้ามาช่วยเรา เช่น PyArmor ที่เราเคยเขียนไว้ก่อนหน้านี้

ท่าที่เรามักจะเจอในแบบ Online

มาถึงในยุค Online เต็มตัวกันบ้าง ผู้พัฒนาเอาส่วนที่ใช้ในการตรวจสอบออกไปไว้ใน Server หมดแล้ว หมดยุคที่เราจะเข้ามานั่งไล่หาวิธีการที่ใช้ในการตรวจสอบแล้ว แต่.... เมื่อมันอยู่ใน Server นั่นแปลว่า มันจะต้องมีวิธีการพูดคุยบางอย่างปะ เช่นตอนที่โปรแกรมส่ง Request ไปมันจะพูดว่าอะไรกับใคร และตอนรับ มันรับมาด้วยข้อมูลหน้าตาแบบไหนถึงจะผ่านเงื่อนไขการตรวจสอบได้ งั้นเรา Reverse Engineering ทำ License Server เลยมั้ยละ ทำให้ Local License Server บนเครื่องเราคุยกับ License Server ปลอมที่ทำขึ้นมา ก็น่าจะได้แล้วนิ

ตัวอย่างที่ดี และเราคิดว่า คนคิดแมร่งก็นะ คือ การ Crack Microsoft Product อย่างพวก Windows และ Office เขาใช้หลักการ License Server ทิพย์ในการจัดการอย่างที่เราบอกเลย

เราต้องเข้าใจก่อนว่า Software อย่าง Microsoft Windows มันใช้งานในหลายสถานการณ์มาก ๆ หนึ่งในสถานการณ์คือการนำไปใช้งานในองค์กรที่มีเครื่องจำนวนมากอยู่ หากเราติดตั้งทีนึง แล้วให้ IT Support เข้าไปใส่ License ทีละเครื่อง มีพันเครื่องก็ต้องทำพันลำมันไม่ไหวเหมือนกัน Microsoft เลยมีระบบที่เรียกว่า KMS ขึ้นมา

หลักการง่าย ๆ สำหรับการใช้งานแบบถูกต้องคือ ในองค์กรจะตั้ง KMS ขึ้นมา และสั่งให้เครื่องที่อยู่ในองค์กรนั้น อาจจะกำหนดสิทธิ์จากพวก Active Directory เพื่อให้เข้ามาหา Key ผ่านระบบ KMS เมื่อได้รับแล้วมันก็จะทำการ Activate ก็จะใช้งาน Windows ได้เลย นั่นแปลว่า IT Support ก็ไม่ต้องวิ่งใส่ License ทั่วบริษัทอีกต่อไป และไม่ต้องกลัวว่าจะโดนเอาไปแอบใช้ เพราะเครื่องจะต้องเชื่อมต่อกับ KMS ทุก 180 วันเพื่อยืนยันตัวตนอีกด้วย

สิ่งที่โปรแกรม Crack มันทำคือ งั้นเราก็รัน Local KMS เอาไว้ในเครื่องเลยดิ ครั้งแรกมันจะติดตั้ง Local KMS Server ลงไปในเครื่องของเรา จากนั้นมันจะไปเรียก Activation Service ให้ไปคุยกับ KMS Server บอกว่า นาย ๆ เรามี KMS อยู่นี่นะ เรียกได้เลย นอกจากมันจะเช็ค License ครั้งแรกได้แล้ว ในอีก 180 วันถัดไปมันก็ไม่มีปัญหาอะไรเพราะ KMS Server ที่ทำขึ้นมาก็ยังติดตั้งอยู่บนเครื่องของเรา พอมันเรียก ก็เจอ ก็จบไม่มีอะไร

หลักการนี้มันเป็นช่องโหว่นึงที่โดนเอามาใช้สำหรับการ Crack Software กันได้ แต่หลักการพื้นฐานของทั้งหมดในเรื่องนี้ก็คือ การที่เราพยายามหลอกโปรแกรมว่า มัน Activate ผ่านนะแค่นั้นเลย ไม่ว่าจะใช้ License Server ที่ Reverse Engineering มา หรือจะไปหลอกผลในโปรแกรมตอน Activate ก็ตาม

Modern Software Piracy Protection

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

แต่บางครั้ง Software ป้องกันพวกนี้ก็สามารถสร้างความชิบหายให้กับ Software นั้น ๆ ได้เช่นกัน ตัวอย่างที่พึ่งเกิดขึ้นเมื่อไม่นานมานี้อย่างเกมจากผู้สร้าง Dead Space อย่าง Callisto Protocol ที่ใช้โปรแกรมป้องกันอย่าง Denuvo ที่วิธีการของมันค่อนข้างโหดมาก ๆ จนทำให้เสีย Performance ไปกับการรัน DRM Software ตัวนี้ไปจนผู้เล่นออกมาด่ากันฉ่ำ ดูจากคลิปด้านบนที่เขาเปรียบเทียบ ตัวเกมที่ใช้ Denuvo และตัวเกมที่ภายหลังผู้พัฒนา Patch เอา Denuvo ออกไปแล้ว (เพราะโดนด่าฉ่ำ แต่กว่าจะรู้สึกตัวได้ อ่อ ปีครึ่งค๊าาา) เราจะเห็นได้เลยว่าบางฉากเราได้ Frame Rate กลับมาเยอะมาก ๆ เห็นตัวเลข เรามั่นใจเลยว่า มันรู้สึกได้แน่นอน

ต้องบอกเลยว่า วิธีการที่ Denuvo ใช้แมร่งคือ สุดทรีนมาก ๆ มันใช้ทุกท่าที่มีบนโลก ณ วันนี้เลย คือตั้งแต่การทำ Authentication ที่ต้องเชื่อมต่อกับ Server มีการ Generate Key พ่วงกับ Hardware ของเราที่ซับซ้อนเพื่อความยากในการปลอมแปลง จนไปถึงการใช้ท่าต่าง ๆ เพื่อป้องกันการ Reversing Engineering อย่าง Debugging (Anti-Debugging), Obfuscation จนไปถึงการ Visualise Secure Hardware เพื่อป้องกันกันเลยทีเดียว ดังนั้น บอกเลยว่า มันไม่ได้เช็ค License แค่ตอนติดตั้ง กับทุกครั้งที่รันโปรแกรมนะ แต่เรียกว่า แมร่งเช็คกันแทบจะตลอดเวลาที่เรารันโปรแกรมเลย มันทำยันการใช้ Software Driver รันอยู่บน Kernel เครื่องเราเพื่อ Monitor การทำงานของโปรแกรม ป้องกันการที่เราพยายาม Hook หรือเขียน Backdoor เข้าไป Bypass กระบวนการบางอย่างด้วย หลักการคล้าย ๆ กับ Falcon Sensor ของ CrownStrike และพวก Kernel-Level Anti Cheat ในท้องตลาด

ด้วยกลไกการทำงานที่ซับซ้อนขนาดนี้ มีการตรวจสอบเยอะขนาดนี้ แน่นอนว่า Overhead ในการทำงานเยอะแน่นอน ส่งผลไปถึงเรื่องผลกระทบต่อการรันโปรแกรม ทำให้ผู้ใช้ออกมาด่ากันฉ่ำ แต่กลับกันมันแลกมากับการป้องกันที่ดีเยี่ยมจริง ๆ มี Hacker หลายคนยอมแพ้กับท่าที่ Denuvo ทำไปเลยทีเดียว

อย่างที่เราชอบพูดเสมอว่า งาน Cyber Security มันคือ แมวจับหนู แมร่งต้องมีสักคนที่ Crack ได้ ใช่แล้ว เคสนี้เกิดกับเกมที่หลาย ๆ คนชื่นชอบอย่าง Hogworts Legacy ที่ไส้ในเขาก็ใช้ Denevo ที่เราบอกว่ามันแข็งแกร่งนี่แหละ มีคน Crack มันได้หลังจากเกมออกประมาณ 6 เดือนเท่านั้นเอง เรียกว่าก็ต้องต่อสู้กันต่อไป ฝั่งของ Denuvo เอง เมื่อเขาทราบช่องโหว่ที่ใช้ เขาก็รีบ Patch ทันที และเกมก็ Apply Patch นั้นกลับไปให้ผู้เล่นเพื่อป้องกันต่อไป

ไว้วันหลังจะมาเล่าถึงเรื่องพวกหลักการการทำงานของ DRM Software อีกที แมร่งคือ สุดจริง โดยเฉพาะนัง SecuROM แมร่งเด็ดแบบเด็ดจริง