บทนำเทคโนโลยีการป้องกัน ซอฟต์แวร์การใช้คีย์ฮาร์ดแวร์แพร่หลายไปทั่วโลก แต่ละบริษัทตัดสินใจด้วยตัวเองว่าคุ้มค่าที่จะปกป้องผลิตภัณฑ์ของตนด้วยการผูกเข้ากับคีย์ฮาร์ดแวร์หรือไม่ หรือควรเลือกใช้กลไกอื่นในการรับรองความปลอดภัยที่ได้รับใบอนุญาตหรือไม่ ในบางครั้งคีย์ฮาร์ดแวร์จากผู้ผลิตรายใหญ่ที่สุดของโลกถูกแฮ็ก ซอฟต์แวร์จำลองของคีย์ฮาร์ดแวร์ปรากฏขึ้นอย่างอิสระบนอินเทอร์เน็ต... เพื่อตอบสนองต่อสิ่งนี้ นักพัฒนาจึงสร้างคีย์เวอร์ชันใหม่ซึ่งจะขัดขวางการละเมิดลิขสิทธิ์ในบางครั้ง ฯลฯ . การต่อสู้ระหว่าง "เปลือกและชุดเกราะ" นั้นไม่มีที่สิ้นสุด... บทความนี้จะบอกคุณเกี่ยวกับคีย์ HASP เวอร์ชันใหม่จาก Aladdin Software Security R.D.
เราได้เขียนเกี่ยวกับเทคโนโลยี HASP แล้วและยังทำการเปรียบเทียบกับเทคโนโลยี Sentinel จาก Rainbow Technologies อีกด้วย ถ้าคุณ ผู้อ่านที่รัก, สนใจ คำอธิบายโดยละเอียดเทคโนโลยี HASP องค์ประกอบของคีย์ฮาร์ดแวร์นั้นเอง ความสามารถพื้นฐานยูทิลิตี้สำหรับการตั้งค่า ฯลฯ เราขอแนะนำให้คุณอ้างอิงถึงบทความก่อนหน้าของเราตามลิงก์ที่ให้ไว้ด้านบน ต่อไปเราจะพยายามมุ่งเน้นไปที่ความแตกต่างระหว่างเทคโนโลยี HASP รุ่นที่ห้าใหม่ (รุ่นที่ห้าเรียกว่า HASP HL และนี่คือสิ่งที่จะกล่าวถึงต่อไป) จาก HASP4
สัมภาษณ์กับผู้เชี่ยวชาญ
Alexander Gurin ผู้จัดการแผนกป้องกันซอฟต์แวร์ของ Aladdin Software Security R.D. ตกลงที่จะบอกเราเกี่ยวกับเทคโนโลยีป้องกันซอฟต์แวร์ที่ใช้คีย์ HASP HL เวอร์ชันใหม่
Alexander Gurin ผู้จัดการแผนกป้องกันซอฟต์แวร์ของ Aladdin Software Security R.D.
อเล็กเซย์ โดลยา:คุณช่วยอธิบายสั้น ๆ ว่า HASP HL แตกต่างจากดองเกิล HASP รุ่นอื่น ๆ ได้อย่างไร
อเล็กซานเดอร์ กูริน: Aladdin ผลิตคีย์ป้องกันซอฟต์แวร์มาหลายปีแล้ว โดยปกติแล้ว เช่นเดียวกับผลิตภัณฑ์อื่นๆ พวกเขาได้รับการปรับปรุง มีประสิทธิภาพมากขึ้นและตอบสนองความต้องการของลูกค้าให้ได้มากที่สุด จนถึงขณะนี้ HASP4 อาจเป็นคีย์ที่ประสบความสำเร็จมากที่สุด มีความสมดุลที่ดีระหว่างความทนทานของการป้องกันและความง่ายในการใช้งาน
แต่ขอให้เป็นไปตามวัตถุประสงค์: คีย์ Aladdin ทั้งหมดรวมถึง HASP4 มีข้อบกพร่องเพียงจุดเดียวหรือไม่ใช่แม้แต่ข้อบกพร่อง แต่เป็นช่องโหว่ ฉันกำลังพูดถึงอัลกอริธึมการเข้ารหัสข้อมูลที่เรียกว่า "ความลับ"
อันตรายหลักของการใช้อัลกอริธึม "ลับ" รวมถึงอัลกอริธึมแบบกำหนดเองที่สร้างขึ้นสำหรับนักพัฒนาเฉพาะรายคือโอกาสที่อัลกอริทึมจะเป็นที่รู้จักและสามารถนำไปใช้งานโดยทางโปรแกรมได้ ในกรณีนี้ ซอฟต์แวร์จำลองคีย์ความปลอดภัยจะปรากฏขึ้น ซึ่งใช้ฟังก์ชันทั้งหมดได้อย่างสมบูรณ์ นอกจากนี้ผู้พัฒนาไม่เคยรู้เท่าไหร่ การป้องกันที่เชื่อถือได้เขาใช้ ความแรงของอัลกอริธึมได้รับการประเมินหลังจากข้อเท็จจริง: คีย์นี้ใช้งานไม่ได้ใน 3 ปี - เป็นการป้องกันที่ดี!
ในคีย์ HASP HL ใหม่ เราได้ละทิ้งการใช้อัลกอริธึมลับโดยสิ้นเชิง ในการเข้ารหัสข้อมูล จะใช้อัลกอริธึม AES สาธารณะที่ใช้ฮาร์ดแวร์พร้อมคีย์เข้ารหัส 128 บิต อัลกอริทึมนี้ได้รับการเผยแพร่และเป็นมาตรฐานการเข้ารหัสของสหรัฐอเมริกามาตั้งแต่ปี 2000 (แทนที่ DES ในตำนาน)
การใช้อัลกอริธึมสาธารณะทำให้การโจมตีคีย์ก่อนหน้านี้ทั้งหมดไร้ประโยชน์ สาระสำคัญของการแฮ็กการป้องกันแต่ละอย่างอยู่ที่การค้นหาคีย์เข้ารหัส คีย์เหล่านี้ถูกเก็บไว้ในหน่วยความจำบริการ HASP HL และไม่เคยออกไปข้างนอก บน ระดับทางกายภาพ- ไม่มีคำสั่งให้แยกออก ดังนั้น การทำลายการรักษาความปลอดภัยแต่ละครั้งจึงลดลงเหลือเพียงงานการเข้ารหัสลับ ซึ่งยากกว่าการจำลองคีย์ธรรมดาหลายเท่า
ใน การสัมภาษณ์ครั้งสุดท้ายของเราฉันเปรียบเทียบการรักษาความปลอดภัยด้วยคีย์ HASP4 กับเก้าอี้ในครัวทั่วไป คุณสามารถสร้างเก้าอี้ที่จะพังได้ในครั้งแรกที่คุณใช้ หรือคุณอาจสร้างเก้าอี้ที่จะใช้งานได้นานหลายปีก็ได้ หากเราวาดความคล้ายคลึงกับ HASP HL เพื่อที่จะทำลายเก้าอี้ที่สร้างมาอย่างดี (โดยใช้ HASP HL) อย่างน้อยก็ต้องแยกชิ้นส่วนออกเป็นอะตอม :)
อเล็กเซย์ โดลยา:มีคีย์ HASP HL ประเภทใดบ้าง?
อเล็กซานเดอร์ กูริน:กลุ่มผลิตภัณฑ์ HASP HL ประกอบด้วย:
HASP HL Basic - ไม่มีคีย์ที่ง่ายที่สุด หน่วยความจำภายในและหมายเลขประจำตัวที่ไม่ซ้ำใคร
HASP HL Pro - แทนที่มากที่สุด รุ่นยอดนิยม HASP4 M1. คีย์ประกอบด้วยหน่วยความจำที่ได้รับการป้องกัน 112 ไบต์และหมายเลข ID ที่ไม่ซ้ำกัน
HASP HL Max - จำเป็นหากหลายโปรแกรมได้รับการปกป้องด้วยปุ่มเดียว (สูงสุด 112 โปรแกรม) ประกอบด้วยหน่วยความจำที่ได้รับการป้องกันและหมายเลข ID จำนวน 4,096 ไบต์
HASP HL Time - มีนาฬิกาเรียลไทม์ในตัว, หน่วยความจำที่ได้รับการป้องกัน 4096 ไบต์และหมายเลขประจำตัว
HASP HL สุทธิ - รหัสเครือข่ายซึ่งช่วยให้คุณจำกัดจำนวนผู้ใช้ที่ทำงานกับโปรแกรมที่ได้รับการป้องกันไปพร้อมๆ กัน การแก้ไขมีให้สำหรับผู้ใช้ 10, 50 และ 250 คน
นอกจากนี้ ฉันอยากจะทราบว่าคีย์เครือข่ายทั้งหมดทำงานเหมือนกับคีย์ในเครื่อง และคีย์ในเครื่องทำงานเหมือนกับคีย์เครือข่าย เนื่องจาก HASP HL API ที่เป็นสากล ทำให้ตอนนี้ไม่จำเป็นต้องพัฒนาเครือข่ายแยกและการป้องกันในเครื่อง
อเล็กเซย์ โดลยา:โปรดบอกเราเกี่ยวกับความสามารถที่ใช้เทคโนโลยี HASP HL
อเล็กซานเดอร์ กูริน:เราพยายามทำให้การป้องกันโดยใช้คีย์ HASP HL มีความยืดหยุ่นและสะดวกที่สุดเท่าที่จะเป็นไปได้สำหรับนักพัฒนาและผู้จัดการ นวัตกรรมทั้งหมดในคีย์ HASP HL มีจุดมุ่งหมายเพื่อลดเวลาที่จำเป็นในการสร้างการป้องกัน ทำให้กระบวนการนำไปใช้และการบำรุงรักษาที่ได้รับการป้องกันในภายหลัง การใช้งานเป็นเรื่องง่ายและเรียบง่าย
บางทีนวัตกรรมที่สำคัญที่สุดในคีย์ HASP HL คือการมีอยู่ของระบบการออกใบอนุญาตอัตโนมัติที่เรียกว่า ระบบนี้ช่วยให้คุณสามารถแยกกระบวนการปกป้องและออกใบอนุญาตผลิตภัณฑ์ได้อย่างสมบูรณ์ ให้ฉันอธิบายว่าสิ่งนี้ทำงานอย่างไรพร้อมตัวอย่าง แอปพลิเคชันของคุณประกอบด้วยสามโมดูล - A, B และ C คุณกำลังเผชิญกับภารกิจในการเปิดตัวหลายเวอร์ชัน ซึ่งจะรวมโมดูลที่กล่าวถึงใน การรวมกันต่างๆ- เมื่อคุณเปิดตัวผลิตภัณฑ์ คุณอาจยังไม่ทราบว่าคุณจะต้องใช้เวอร์ชันใดในอนาคต ในขั้นแรก นักพัฒนาจะสร้างการป้องกันสำหรับแต่ละโมดูล ประการที่สอง - ผู้จัดการด้วยการคลิกเมาส์เพียงไม่กี่ครั้ง อินเตอร์เฟซแบบกราฟิกกำหนดว่าผลิตภัณฑ์นี้จะเป็นเวอร์ชันใดและจะมีโมดูลใดรวมอยู่ในนั้น นอกจากนี้ ผู้จัดการยังสามารถกำหนดการอัปเดตผลิตภัณฑ์ได้อย่างรวดเร็ว และทั้งหมดนี้เป็นอิสระจากนักพัฒนาโดยสิ้นเชิง ดังที่ฉันได้กล่าวไปแล้ว API ในคีย์ HASP HL นั้นเป็นสากล ไม่จำเป็นต้องสร้างท้องถิ่นแยกและแยกจากกัน การป้องกันเครือข่าย- ดังนั้นคุณจะช่วยประหยัดเวลาของนักพัฒนาในการดำเนินการรักษาความปลอดภัย นอกจากนี้ยังอำนวยความสะดวกด้วยตัวสร้างซอร์สโค้ด HASP HL API ในตัว
อเล็กเซย์ โดลยา:รูปแบบของกุญแจอิเล็กทรอนิกส์ใหม่คืออะไร?
อเล็กซานเดอร์ กูริน:ปุ่ม HASP HL ทั้งหมดมีเฉพาะในรูปแบบ USB เท่านั้น พร้อมทั้งสนับสนุน วินโดวส์อัพเดต- ช่วยให้มั่นใจได้ว่าการติดตั้งไดรเวอร์ HASP HL โดยอัตโนมัติซึ่งตามความเห็นของเราควรลดภาระลงอย่างมาก การสนับสนุนด้านเทคนิค.
อเล็กเซย์ โดลยา:ข้อกำหนดของระบบและฮาร์ดแวร์ของคีย์ HASP HL คืออะไร มีการดำเนินการสนับสนุนหรือไม่? แพลตฟอร์มยูนิกซ์และแมคอินทอช?
อเล็กซานเดอร์ กูริน:เหมือนเมื่อก่อนคีย์ HASP HL เป็นโซลูชันข้ามแพลตฟอร์ม HASP HL ทำงานภายใต้ Windows 98SE/ME/2000/XP/Server 2003, Mac OS 10.2.x และสูงกว่า รวมถึง Linux distribution หลักๆ (SuSE, RedHat, Alt ฯลฯ)
อเล็กเซย์ โดลยา:คุณให้การสนับสนุนด้านเทคนิคอะไรบ้างแก่ผู้ใช้ HASP HL ?
อเล็กซานเดอร์ กูริน:นโยบายการสนับสนุนด้านเทคนิค HASP ของ Aladdin ยังคงเหมือนเดิม: "ไม่ว่าคุณจะเป็นนักพัฒนาซอฟต์แวร์หรือเพียงผู้ใช้ซอฟต์แวร์ที่มีการป้องกัน HASP Aladdin จะให้การสนับสนุนทางเทคนิคฟรีสำหรับผลิตภัณฑ์ของคุณเสมอ"
อเล็กเซย์ โดลยา:ตำแหน่งที่ดี. คีย์ HASP HL ราคาเท่าไหร่และฉันจะซื้อได้ที่ไหน
อเล็กซานเดอร์ กูริน: นโยบายการกำหนดราคาสำหรับคีย์ HASP HL มีดังนี้: คีย์ท้องถิ่นมีราคาแพงกว่ารุ่น HASP4 ที่เกี่ยวข้อง 10% และคีย์เครือข่ายมีราคาถูกกว่า 15% ข้อมูลครบถ้วนราคาของคีย์ HASP HL แสดงอยู่ในเว็บไซต์ของเรา คุณสามารถซื้อกุญแจของเราได้โดยกรอกใบสมัครบนเว็บไซต์หรือผ่านเครือข่ายที่กว้างขวางของพันธมิตรของเราในรัสเซียและในประเทศเพื่อนบ้าน
อเล็กเซย์ โดลยา:คำพูดสุดท้ายที่จะพูดกับผู้อ่านของเรา?
อเล็กซานเดอร์ กูริน:ฉันขอแสดงความยินดีกับทุกคน วันหยุดปีใหม่และขอให้คุณโชคดีในปี 2548 ขอบคุณมากสำหรับความสนใจของคุณ หากคุณมีคำถามใด ๆ ฉันยินดีที่จะตอบ
อเล็กเซย์ โดลยา:ขอขอบคุณเช่นกันที่สละเวลากับเรา เราจะติดตามการพัฒนาเทคโนโลยีอะลาดินต่อไป ขอให้โชคดีกับคุณและบริษัทของคุณ!
ความคิดเห็นบางส่วน
ดังที่ Alexander Gurin กล่าวไว้ ตอนนี้ดองเกิล HASP HL ทั้งหมดมาในรูปแบบ USB แล้ว ควรเสริมด้วยว่าวิศวกรของ Aladdin สามารถลดคีย์ฮาร์ดแวร์ลงได้หนึ่งเท่าครึ่งแล้วในตอนนี้ ขนาดสูงสุดกุญแจคือ 38 มม. ตามที่ผู้จัดการของ Aladdin Software Security R.D. กล่าวว่านี่คือ "คีย์ที่มีขนาดกะทัดรัดที่สุดในตลาด" มาดูกันว่ามีคีย์ HASP HL ประเภทใดบ้าง
HASP HL ปุ่มพื้นฐาน นี้ โซลูชั่นราคาไม่แพง- คีย์ไม่มีหน่วยความจำและไม่มีหมายเลขประจำตัวที่ไม่ซ้ำกัน
คีย์ HASP HL Pro คีย์สากลที่ได้รับความนิยมมากที่สุดประกอบด้วยหน่วยความจำที่เขียนซ้ำได้อย่างปลอดภัยขนาด 112 ไบต์และหมายเลข ID ที่ไม่ซ้ำกัน ด้วยคีย์ HASP HL Pro หนึ่งอัน คุณสามารถป้องกันได้มากถึง 16 อัน แอพพลิเคชั่นต่างๆ.
คีย์ HASP HL Max. เหมาะสมที่สุดสำหรับกรณีที่จำเป็นต้องปกป้องหลายแอปพลิเคชันด้วยปุ่มเดียว รุ่นนี้มีหน่วยความจำที่เขียนซ้ำได้อย่างปลอดภัยขนาด 4,096 ไบต์และหมายเลข ID ที่ไม่ซ้ำกัน และสามารถใช้เพื่อป้องกันแอปพลิเคชันได้สูงสุด 112 รายการ
HASP HL ปุ่มเวลา มีการแสดงนาฬิกาแบบเรียลไทม์ในตัว วันที่ปัจจุบันและเวลา HASP HL Time ช่วยให้คุณสามารถถ่ายโอนแอปพลิเคชันที่ได้รับการป้องกันสำหรับการใช้งานชั่วคราว (สำหรับการประเมินหรือการทดสอบ) จัดระเบียบการเช่า การเช่าซื้อ และใช้ทรัพยากรแอปพลิเคชันใด ๆ ตามระยะเวลาที่กำหนด HASP HL Time ประกอบด้วยหน่วยความจำที่เขียนซ้ำได้อย่างปลอดภัย 4096 ไบต์และหมายเลข ID ที่ไม่ซ้ำกัน
คีย์ HASP HL Net คีย์เครือข่ายช่วยให้คุณสามารถปกป้องแอปพลิเคชันบนเครือข่ายและจำกัดจำนวนผู้ใช้ (ใบอนุญาต) ด้วยคีย์ HASP HL Net หนึ่งคีย์ คุณสามารถปกป้องแอปพลิเคชันหรือโมดูลโปรแกรมต่างๆ ได้ถึง 112 รายการ และจำกัดจำนวน ผู้ใช้พร้อมกัน- รุ่นนี้มีหน่วยความจำที่เขียนซ้ำได้อย่างปลอดภัยขนาด 4096 ไบต์และหมายเลข ID ที่ไม่ซ้ำกัน
HASP HL มาสเตอร์คีย์ คีย์ประกอบด้วยรหัสและตัวระบุที่ไม่ซ้ำกันซึ่งใช้โดยระบบ HASP HL ซึ่ง Aladdin กำหนดให้กับผู้พัฒนา รหัสผ่านสำหรับซีรีส์ HASP HL แต่ละชุดจะถูกจัดเก็บไว้ในหน่วยความจำที่ปลอดภัยของ HASP HL Master Key นักพัฒนาต้องการคีย์นี้เพื่อสร้างการป้องกันแอปพลิเคชันโดยใช้ทั้ง HASP API และยูทิลิตี้การป้องกันอัตโนมัติ HASP Envelope
หากคุณอ่านคำอธิบายของคีย์อย่างละเอียด คุณอาจสังเกตเห็นการเพิ่มขนาดของหน่วยความจำคีย์ที่ได้รับการป้องกัน: จาก 512 ไบต์เป็น 4096 ไบต์
Alexander Gurin ตั้งข้อสังเกตว่าขณะนี้ผู้จัดการสามารถทำงานแยกจากนักพัฒนาในแง่ของการกำหนดนโยบายลิขสิทธิ์ของผลิตภัณฑ์ ควรเพิ่มว่าด้วยความช่วยเหลือของระบบการออกใบอนุญาตอัตโนมัติ HASP HL ผู้จัดการสามารถกำหนดข้อ จำกัด สำหรับแต่ละโมดูลหรือฟังก์ชันของโปรแกรมที่ได้รับการป้องกันในแง่ของจำนวนการเริ่มต้น เวลาใช้งาน และจำนวนผู้ใช้พร้อมกัน เครือข่าย
ควรสังเกตว่าคีย์ HASP HL เข้ากันได้กับ HASP4 และ HASP3 อย่างสมบูรณ์ ดังนั้นคีย์ HASP HL จึงสามารถทำงานกับโปรแกรมที่ได้รับการป้องกันโดยใช้คีย์ HASP4 และ HASP3 โดยไม่ต้องทำการเปลี่ยนแปลงใด ๆ กับ ซอร์สโค้ด- แต่คีย์ HASP HL มีเฉพาะในรูปแบบ USB เท่านั้น ในกรณีที่ ขาด USBคุณต้องใช้คีย์ HASP4 LPT
ตารางสุดท้าย
สุดท้ายนี้ เราจะนำเสนอตารางสุดท้ายที่สะท้อนถึงส่วนหลัก ฟังก์ชั่น HASP HL และ HASP4 รวมถึงการเปรียบเทียบคีย์ฮาร์ดแวร์ทั้งสองรุ่นนี้ความสามารถที่สำคัญของ HASP
| ความเป็นไปได้ | ฮัสป์ เอช | HASP4 |
|---|---|---|
| การป้องกันอัตโนมัติ(ซองจดหมาย) | + | + |
| ระบบการออกใบอนุญาตอัตโนมัติ | + | - |
| อัลกอริธึมการเข้ารหัสข้อมูลที่ใช้ในฮาร์ดแวร์ในคีย์ | เออีเอส | ความลับ |
| เครื่องกำเนิดซอร์สโค้ดโมดูลความปลอดภัย | + | - |
| การเขียนโปรแกรมระยะไกล | + | + |
| ข้ามแพลตฟอร์ม | + | + |
| ขนาดหน่วยความจำ | มากถึง 4096 ไบต์ | สูงสุด 512 ไบต์ |
| อินเตอร์เฟซ USB | + | + |
| อินเทอร์เฟซ LPT | - | + |
| การติดตั้งอัตโนมัติไดรเวอร์ (อัพเดต Windows) | + | ยูเอสบีเท่านั้น |
จากตารางนี้ คุณสามารถตัดสินใจได้ตลอดเวลาเกี่ยวกับความเหมาะสมในการแนะนำคีย์เวอร์ชันใหม่เพื่อปกป้องผลิตภัณฑ์ของคุณ แน่นอนว่าทุกอย่างขึ้นอยู่กับสถานการณ์เฉพาะ...
เป็นที่ทราบกันดีว่าจำเป็นต้องมีใบอนุญาตในการทำงานใน 1C พัสดุของบริษัท 1C กุญแจต่างๆการป้องกัน: ท้องถิ่นและเครือข่าย รหัสท้องถิ่นสามารถใช้ได้เฉพาะกับคอมพิวเตอร์เครื่องเดียวเท่านั้นโดยมีรูปลักษณ์ของแฟลชไดรฟ์ที่คุ้นเคย
คีย์เครือข่ายสามารถให้ใบอนุญาตแก่ผู้ใช้หลายรายโดยขึ้นอยู่กับซีรีส์ของผู้ใช้ ในองค์กรขนาดใหญ่ คีย์สำหรับการเชื่อมต่อ 300 และ 500 มักใช้บ่อยที่สุด แต่หากจำเป็น คุณสามารถซื้อน้อยลงได้ โปรดทราบว่าคอมพิวเตอร์เครื่องหนึ่งไม่สามารถมีคีย์ซีรีส์เดียวกันได้มากกว่าหนึ่งคีย์
ในบทความนี้เราจะดูวิธีกำหนดค่าตัวจัดการใบอนุญาต 1C 8.3 ทีละขั้นตอนเพื่อให้คีย์ป้องกันเครือข่ายอยู่ในคอมพิวเตอร์เครื่องเดียว ผู้ใช้จากคอมพิวเตอร์เครื่องอื่นจะได้รับใบอนุญาตจากเขา พูดง่ายๆ ก็คือ มีคีย์เดียว แต่มีเซสชันผู้ใช้หลายเซสชัน
การตั้งค่าตัวจัดการใบอนุญาต HASP
เริ่มต้นด้วยการติดตั้งตัวจัดการใบอนุญาตบนคอมพิวเตอร์ที่จะแจกจ่ายใบอนุญาต ต่อไปนี้เราจะเรียกคอมพิวเตอร์เครื่องนี้ว่าเซิร์ฟเวอร์ลิขสิทธิ์ ซอฟต์แวร์ที่จำเป็นทั้งหมดรวมอยู่ในแพ็คเกจ 1C:Enterprise
คุณสามารถดาวน์โหลด Alladin HASP License Manager สำหรับ Windows x64 และ x32 ได้จากลิงก์
เพื่อให้ผู้จัดการทำงานได้อย่างถูกต้อง คุณต้องทำบางอย่าง ที่ตั้งไว้ล่วงหน้า- ไฟล์ที่คุณจะสร้างเรียกว่า nhsrv.ini โดยส่วนใหญ่สามารถพบได้ที่ "C:\Program Files\Aladdin\HASP LM" หากติดตั้งตัวจัดการใบอนุญาตเป็นแอปพลิเคชัน มิฉะนั้น (ติดตั้งเป็นบริการ) จะอยู่ในไดเร็กทอรีระบบของระบบปฏิบัติการ
เปิดไฟล์ที่คุณพบในโปรแกรมแก้ไขข้อความ เช่น Notepad และเพิ่มบรรทัดที่นั่น:
NHS_IP_LIMIT = 192.168.*.*
แทนที่จะใส่เครื่องหมายดอกจัน คุณสามารถป้อนตัวเลขใดก็ได้ตั้งแต่ 0 ถึง 254 นอกจากนี้ หากคุณทิ้งเครื่องหมาย "*" ไว้ ก็หมายความว่าคอมพิวเตอร์ทุกเครื่องในเครือข่ายที่ที่อยู่ขึ้นต้นด้วย 192.168 จะ "เห็น" ใบอนุญาต
ตัวอย่างเช่น หากคุณมี NHS_IP_LIMIT = 192.168.1.* Add-on ที่ระบุในไฟล์ nhsrv.ini สิทธิ์การใช้งานจะใช้ได้กับคอมพิวเตอร์ที่มี IP ในช่วงตั้งแต่ 192.168.1.0 ถึง 192.168.1.254 เท่านั้น
การตั้งค่าบนพีซีไคลเอนต์
หลังจากที่คุณทำทุกอย่างแล้ว การตั้งค่าที่จำเป็นบนเซิร์ฟเวอร์ลิขสิทธิ์ 1C คุณต้องกำหนดค่าคอมพิวเตอร์ไคลเอนต์ด้วยตนเอง
เมื่อรัน 1C บนพีซีของผู้ใช้ โปรแกรมจะขอใบอนุญาตไปยังที่อยู่ที่ระบุในไฟล์ nethasp.ini คุณสามารถค้นหาได้ในโฟลเดอร์ "conf" ของไดเร็กทอรีที่ติดตั้งแพลตฟอร์ม 1C ในกรณีของเรา ที่อยู่คือ: “d:\Program Files (x86)\1cv8\conf\”
โดยไม่มีเลย การตั้งค่าเพิ่มเติมโปรแกรม 1C จะค้นหาใบอนุญาตทั่วทั้งเครือข่ายท้องถิ่น เพื่อเร่งความเร็ว กระบวนการนี้เราสามารถระบุที่อยู่ IP ของเซิร์ฟเวอร์ลิขสิทธิ์ในไฟล์นี้ได้อย่างอิสระโดยเพิ่มข้อความที่ไฮไลต์ในรูปด้านล่าง
บทความนี้จะกล่าวถึงการใช้งานการป้องกันฮาร์ดแวร์และซอฟต์แวร์บนแฟลชไดรฟ์ แต่ควรระลึกไว้เสมอว่าเทคนิคที่เสนอนั้นไม่ใช่คู่แข่งที่สำคัญกับคีย์ฮาร์ดแวร์ที่มีอยู่เช่น HASP HL (พร้อมเฟิร์มแวร์ที่อัปเกรดได้) จาก Alladin, Sentinel, Rockey ฯลฯ...
คุณเคยสงสัยหรือไม่ว่าแฟลชไดรฟ์ธรรมดาสามารถนำไปใช้ทำอะไรได้บ้าง? หลายคนจะตอบทันทีว่า “... คำถามแบบไหนล่ะ? แต่ถ้าเรามองจากมุมมองของคนทั่วไป จะเป็นอย่างไรถ้าคุณมองมัน "ผ่านสายตาของคอมพิวเตอร์"? แน่นอนว่ากระบวนการนี้ค่อนข้างซับซ้อน รวมถึงโปรโตคอลการแลกเปลี่ยน USB กระบวนการชั่วคราว ตัวระบุ และ GUID (Globally Unique IDentifier)...
ทฤษฎีเล็กๆ น้อยๆ...
HASP (Hardware Against Software Piracy) เป็นระบบสำหรับปกป้องโปรแกรม (ซอฟต์แวร์) และฮาร์ดแวร์จากการใช้งานที่ผิดกฎหมาย พื้นฐานของคีย์ HASP ส่วนใหญ่มักจะเป็นชิปแบบกำหนดเองที่มีซอฟต์แวร์เฉพาะ เช่น ในแท็บเล็ต iBUTTON จาก Dallas Semiconductor ซึ่งปัจจุบันมีการใช้กันอย่างแพร่หลายในระบบอัตโนมัติของประตู
หลักการป้องกันคือในระหว่างกระบวนการเริ่มต้นโปรแกรมจะสำรวจดองเกิลที่เชื่อมต่อกับคอมพิวเตอร์ผ่าน I2C, LPT, PCMCIA หรือ USB หากคีย์ตอบว่า "ถูกต้อง" แสดงว่าโปรแกรมทำงานได้ตามปกติ มิฉะนั้นจะบล็อกการเข้าถึงฟังก์ชันบางอย่างหรือไม่เริ่มทำงาน ดังนั้นโปรแกรมที่ได้รับการป้องกันใดๆ จะประกอบด้วยตัวโปรแกรมโดยตรงและกลไกการตรวจสอบที่สำคัญ หน้าที่ของกลไกเหล่านี้คือการตรวจสอบการมีอยู่ของคีย์ รับตัวระบุเฉพาะ และอ่านหรือเปลี่ยนแปลงเนื้อหาของหน่วยความจำภายใน
ข้อกำหนดเบื้องต้นสำหรับการปกป้องซอฟต์แวร์ โซลูชั่นที่มีอยู่
เกณฑ์หลักในการใช้คีย์ฮาร์ดแวร์คือ:
- ราคาของคีย์ที่ใช้ควรจะน้อยกว่าราคาของซอฟต์แวร์อย่างล้นหลาม
- อายุการใช้งานยาวนานของผลิตภัณฑ์ซอฟต์แวร์
- อัลกอริธึมการโต้ตอบส่วนบุคคล
* PRAM (Phasechange Random Access Memory) - หน่วยความจำเข้าถึงโดยสุ่มตามการเปลี่ยนเฟสของสาร - chalcogenide ด้วยความเร็วการเข้าถึงประมาณ 10 ns ซึ่งเทียบได้กับ RAM สมัยใหม่
ประการที่สองเกี่ยวข้องกับผลิตภัณฑ์ดั้งเดิมและยอดนิยมที่มีอัลกอริธึมเฉพาะซึ่งต้องการการป้องกันขั้นต่ำ ประการที่สามถูกกำหนดโดยนักพัฒนาเอง ยิ่งผู้ใช้รู้เกี่ยวกับเรื่องนี้น้อยเท่าใด ความแข็งแกร่งของการเข้ารหัสก็จะยิ่งสูงขึ้นเท่านั้น ท้ายที่สุดแล้วความรู้เกี่ยวกับอัลกอริทึมทำให้สามารถสร้างโปรแกรมได้ - โปรแกรมจำลองที่ทำหน้าที่ทั้งหมดของอุปกรณ์ฮาร์ดแวร์ได้อย่างสมบูรณ์
มีปุ่มหลายรูปแบบ: ไม่มี หน่วยความจำของตัวเองพร้อมหน่วยความจำที่ได้รับการป้องกันด้วย REAL ในตัว นาฬิกาเวลาด้วยโปรโตคอลเครือข่ายในตัว
ในเวลาเดียวกัน นอกเหนือจากโซลูชันแบบฝังที่เสนอในบทความในรูปแบบของส่วนประกอบแล้ว ยังมีผลิตภัณฑ์เช่น StarForce และ HASP Envelope จากบริษัท Alladin ซึ่งช่วยให้คุณเพิ่มโมดูลการแลกเปลี่ยนความปลอดภัยพร้อมคีย์เพื่อเตรียมพร้อม- สร้างโปรแกรมในขั้นตอนการขายรวมเข้ากับรหัสผลิตภัณฑ์ แต่มีค่าใช้จ่ายที่เกี่ยวข้องกับค่าใช้จ่ายในการซื้อคีย์ HASP เองซึ่งมีราคาตั้งแต่ 25 ถึง 50 ดอลลาร์ต่ออัน (ขึ้นอยู่กับรุ่นของคีย์) และการฝังซอฟต์แวร์ (จาก 200 ดอลลาร์) ในขณะที่ราคาของโปรแกรมที่ได้รับการป้องกันอยู่ที่ 20 ดอลลาร์
เครื่องมือการพัฒนาซอฟต์แวร์และการดีบัก
ดังที่คุณทราบ วิธีการป้องกัน HASP ขึ้นอยู่กับการเชื่อมโยงโปรแกรมกับพารามิเตอร์เฉพาะบางตัวหรือชุดของคีย์และอุปกรณ์ เนื่องจากเราจะใช้ อุปกรณ์ยูเอสบีจากนั้นนิรนัยก็เพียงพอที่จะอ่านหมายเลขซีเรียลและ ID ของแฟลชไดรฟ์** เนื่องจากจะไม่เปลี่ยนแปลงเมื่อทำการฟอร์แมต
** แฟลชไดรฟ์บางรุ่นอาจมีหมายเลขนี้ เช่น ชิปบางรุ่นจาก LG
ในการทำงานคุณต้องมีสิ่งต่อไปนี้:
- สภาพแวดล้อม Borland Delphi 5-7
- ยูทิลิตี้ Dependency Walker จาก Visual C++ 6.0
... CM_Get_Device_IDA:function(dnDevInst: DWORD; บัฟเฟอร์: PChar; BufferLen: DWORD; ulFlags: DWORD): DWORD; stdcall; SetupDiGetClassDevsA:function (ClassGuid: PGUID; ตัวแจงนับ: PChar; hwndParent: HWND; ค่าสถานะ: DWORD): HDEVINFO; stdcall; SetupDiEnumDeviceInfo:ฟังก์ชั่น (DeviceInfoSet: HDEVINFO; MemberIndex: DWORD; DeviceInfoData: PSP_DEVINFO_DATA): บูลีน; stdcall; SetupDiDestroyDeviceInfoList:ฟังก์ชั่น (DeviceInfoSet: HDEVINFO): บูลีน; stdcall; CM_Get_Device_ID_Size:function (pulLen: PDWORD; dnDevInst: DWORD; ulFlags: DWORD): DWORD; stdcall; SetupDiCallClassInstaller: ฟังก์ชั่น (InstallFunction: DWORD; DeviceInfoSet: DWORD; DeviceInfoData: PSP_DEVINFO_DATA): BOOL; stdcall; SetupDiGetDeviceRegistryPropertyA:function (DeviceInfoSet: DWORD; DeviceInfoData: PSP_DEVINFO_DATA; คุณสมบัติ: DWORD; PropertyRegDataType: PWORD; PropertyBuffer: PByte; PropertyBufferSize: DWORD; RequiredSize: PWORD): BOOL; stdcall; SetupDiSetClassInstallParamsA:function (DeviceInfoSet: DWORD; DeviceInfoData: PSP_DEVINFO_DATA; ClassInstallParams: PSP_CLASSINSTALL_HEADER; ClassInstallParamsSize: DWORD): BOOL; stdcall; FLib: THandle; -
หากต้องการใช้งาน เราจะเชื่อมต่อพวกมันในส่วนประกอบแบบไดนามิก
ฟังก์ชัน LinkProc(ProcName: string):Pointer;
เริ่มลองผลลัพธ์:= GetProcAddress(FLib,PChar(ProcName));
Win32Check (มอบหมาย (ผลลัพธ์)) ยกเว้นส่วนท้าย; ... CM_Get_Device_IDA:= LinkProc("CM_Get_Device_IDA"); SetupDiGetClassDevsA:= LinkProc("SetupDiGetClassDevsA"); SetupDiEnumDeviceInfo:= LinkProc("SetupDiEnumDeviceInfo"); SetupDiDestroyDeviceInfoList:= LinkProc("SetupDiDestroyDeviceInfoList"); CM_Get_Device_ID_Size:= LinkProc("CM_Get_Device_ID_Size"); SetupDiCallClassInstaller:= LinkProc ("SetupDiCallClassInstaller"); SetupDiGetDeviceRegistryPropertyA:= LinkProc ("SetupDiGetDeviceRegistryPropertyA"); SetupDiSetClassInstallParamsA:= LinkProc ("SetupDiSetClassInstallParamsA"); -
มาแสดงในทางปฏิบัติกันเถอะว่ามันทำงานอย่างไร มารวมส่วนประกอบเข้ากับโปรแกรมสำเร็จรูปและเปิดใช้งานโหมด "mini HASP" ในเมนู (ดูรูป)
หลังจากใส่แฟลชไดรฟ์แล้ว เหตุการณ์จะเกิดขึ้น DBT_DEVICEARRIVAL
... //--- อ่านคิวข้อความและจับช่วงเวลาของการเชื่อมต่อ USB และขั้นตอนการลบ TDUSB.WndProc(var Msg:TMessage); เริ่มต้นด้วย Msg do if (Msg=WM_DEVICECHANGE)และ ((wParam=DBT_DEVICEARRIVAL)or(wParam=DBT_DEVICEREMOVECOMPLETE)) จากนั้นลอง DoDeviceChange(wParam,PDevBroadcastDeviceInterface(lParam));
ยกเว้นจุดสิ้นสุดอื่น ผลลัพธ์:= DefWindowProc(FWnd,Msg,wParam,lParam) end; -
เราอ่านหมายเลขซีเรียล ID และ GUID
วาร์ VID,PID: Word; อนุกรม GUID: สตริง; const USBNameMask="\\?\USB#Vid_%x&Pid_%x#%s#%s"; เริ่มต้นถ้า (Device.dbcc_devicetype=DBT_DEVTYP_DEVICEINTERFACE)และ Assigned(FonChange) และ ParseDeviceName(USBNameMask,PChar(@Device.dbcc_name), [@VID,@PID,@Serial,@GUID]) จากนั้น case Event ของ DBT_DEVICEARRIVAL: FOnChange(Self ,VID,PID,อนุกรม,GUID,doInsert); DBT_DEVICEREMOVECOMPLETE: FOnChange (Self, VID, PID, Serial, GUID, doRemove) สิ้นสุด; - เพื่อให้โปรแกรมทราบเกี่ยวกับการมีอยู่ของ “อุปกรณ์” ที่เราต้องการได้ตลอดเวลา และเราจะใช้ฟังก์ชันนี้ไม่ใช่แค่ตอนบันทึกเท่านั้น
การตั้งค่า DiGetClassDevsA
ห้องสมุดเดียวกันทั้งหมด - setapi.dllขั้นตอน TDUSB.CountDiskEnum; // จับเวลาการโทร ftimer- const GUID_DEVCLASS_DISKDRIVE: TGUID = (D1: $4D36E967; D2: $E325; D3: $11CE; D4: ($BF, $C1, $08, $00, $2B, $E1, $03, $18 ) ); var hDevInfoSet: HDEVINFO; ข้อมูล DevInfo: SP_DEVINFO_DATA;
ขั้นตอน BlockInput; ภายนอก "user32.dll"; ... //ตรวจสอบการบล็อกพีซี - pp:= false;
ถ้า (FActive) และ (fblock"") ให้เริ่มต้นสำหรับ i:= 0 ถึง list.Count-1 ทำถ้า list[i]= fblock จากนั้นเริ่มต้น pp:= true; แตกหัก; ถ้า pp แล้ว UnBlock อื่นบล็อกสิ้นสุด;// FSerChange(Self,list) // ส่งคืนเหตุการณ์ส่วนประกอบ - ...
 |  เต็ม ข้อความต้นฉบับส่วนประกอบและเครื่องมือตรวจสอบการทดสอบมีจำหน่ายที่ |
|
| ข้าว. - |
ทดสอบจอภาพ
ยูเอสบี
ข้าว. - ส่วนประกอบ HASP ขนาดเล็ก ทั้งหมด. ตอนนี้เมื่อคุณถอดแฟลชไดรฟ์ออก พีซีจะถูกล็อคจนกว่าจะกลับเข้าที่ ประเภทของการกระทำสำหรับกิจกรรมเหล่านี้ถูกจำกัดโดยจินตนาการของผู้พัฒนาเท่านั้น หรือคุณสามารถฝังฟังก์ชันที่กล่าวถึงข้างต้นลงในบริการและเรียกใช้ในเซฟโหมดได้...ผลลัพธ์
- โปรดทราบว่าวิธีการพิจารณาในการปกป้องแฟลชไดรฟ์ USB และคีย์ HASP นั้นมีช่องโหว่ - นี่คือการสกัดกั้นการโทรของอุปกรณ์ด้วยฮาร์ดแวร์ การมีดีบักเกอร์พร้อมการติดตามแบบทีละขั้นตอน คุณสามารถเลือกขั้นตอนในระหว่างที่เข้าถึงอุปกรณ์และ "ทำงาน" เพิ่มเติมได้ อย่างไรก็ตาม ด้วยต้นทุนที่ต่ำ ความเร็วในการพัฒนา และความเรียบง่ายที่สำคัญที่สุด -
- วิธีนี้
- สามารถใช้เพื่อการป้องกันขั้นต่ำของทั้งพีซีและการเชื่อมโยงโปรแกรมได้สำเร็จ
- เว็บไซต์อัลลาดิน http://www.alladin.ru Dependency Walker จากชุด Visual C++ 6.0 http://ra-xp.narod.ru/zip/dll.zipการดัดแปลงระบบควบคุมพีซี http://ra-xp.narod.ru/zip/ram.zip
miniHASP สำหรับส่วนประกอบ DELPHI และการคอมไพล์
http://ra-xp.narod.ru/zip/hsp.zipข้อมูลการติดต่อ: [ป้องกันอีเมล]โปรแกรมจำลอง
เป็นโปรแกรมจำลองการทำงานต่างๆ อุปกรณ์ทางกายภาพหรือโปรแกรมอื่นๆ ตัวอย่างเช่น,ดิสก์เสมือน
, อีมูเลเตอร์เกมคอนโซล , เกม ฯลฯ บทความนี้กล่าวถึงโปรแกรมจำลองคีย์ความปลอดภัย HASP HASP
– ฮาร์ดแวร์
แพคเกจซอฟต์แวร์
การป้องกันซอฟต์แวร์จากการใช้และการแจกจ่ายที่ผิดกฎหมาย (ไม่ได้รับอนุญาต)
ปุ่มพร้อมใช้งานสำหรับระบบปฏิบัติการต่างๆ - Windows, Linux, Android และคอมพิวเตอร์ 32 และ 64 บิต
ระบบได้รับการพัฒนาโดย Aladdin KS ซึ่งมีการป้องกันรวมถึง:
– กุญแจอิเล็กทรอนิกส์ (พวงกุญแจ USB)
– ซอฟต์แวร์พิเศษสำหรับผูกเข้ากับคีย์ ปกป้องโปรแกรมและข้อมูล
คีย์ HASP มีเวอร์ชันต่างๆ กัน:
– พวงกุญแจ USB;
– ปุ่ม LPT;
2) HASP SL (Soft Lock) - รหัสซอฟต์แวร์ คีย์นี้สะดวกกว่าสำหรับการกระจายแอปพลิเคชัน แต่มีระดับความปลอดภัยต่ำกว่า HL
3) HASP SRM เป็นโซลูชันแบบรวม โดยมีตัวเลือกว่าจะใช้อะไร: ฮาร์ดแวร์ HL หรือคีย์ SL ของซอฟต์แวร์
การป้องกัน HASP ถูกใช้โดยแพ็คเกจซอฟต์แวร์เช่น 1C, Consultant Plus ลำดับความคุ้มครองก็ประมาณนี้ กุญแจเชื่อมต่อกับพอร์ตเฉพาะบนคอมพิวเตอร์ ติดตั้งแล้ว ไดรเวอร์พิเศษการป้องกัน
โปรแกรมที่ได้รับการป้องกันจะส่งข้อมูลการป้องกันผ่านมัน หากคำตอบหลักถูกต้อง โปรแกรมยังคงทำงานต่อไป มิฉะนั้น: โหมดสาธิตหรือเพียงแค่หยุด
การจำลองคีย์ถูกนำมาใช้ใน กรณีต่อไปนี้:
– การป้องกันโปรแกรมแฮ็ก (การแฮ็ก การใช้งานที่ผิดกฎหมาย - น่าเสียดาย)
– การทำงานของคีย์ HASP ไม่เสถียร
– ความล้มเหลวหรือการสูญหายของกุญแจ;
– ความไม่สะดวกในการใช้คีย์บนคอมพิวเตอร์เครื่องอื่น
โปรแกรมจำลองดังกล่าวได้รับการพัฒนาสำหรับผู้ใช้ซอฟต์แวร์ลิขสิทธิ์เพื่ออำนวยความสะดวกในการทำงาน (ไม่จำเป็นต้องใช้คีย์ fob) ซึ่งไม่ถือเป็นการละเมิดกฎหมาย
ซึ่งหมายความว่าในการติดตั้งโปรแกรมจำลองใด ๆ คุณต้องมี รุ่นที่ได้รับอนุญาตโดย.
หากคุณต้องการโปรแกรมจำลองคีย์ด้วยเหตุผลบางประการ คุณต้องคำนึงถึงสิ่งต่อไปนี้ - ตัวเลือกโปรแกรมจำลอง ขึ้นอยู่กับ:
– จำนวนผู้ใช้โปรแกรม
– เวอร์ชันโปรแกรม – เครือข่ายหรือสำหรับ ผู้ใช้ท้องถิ่น;
– สำหรับเซิร์ฟเวอร์ใดที่คุณต้องการโปรแกรมจำลอง – เซิร์ฟเวอร์ 2003, 2008 เป็นต้น
โปรแกรมจำลองจำนวนมากได้ถูกสร้างขึ้น หนึ่งในนั้นคือ Sable complex ด้านล่างนี้คือสองตัวอย่างที่เฉพาะเจาะจง
การติดตั้งตัวจำลอง Hasp HL
ข้อมูลเพิ่มเติม:
www.xaker.name/forvb/showthread.php?t=20555&page=11
exctcryptor.ucoz.ru/haspharddong2007.zip
แกะกล่องแล้ววิ่ง HASPHL2007.exe
ต้องติดตั้งไดรเวอร์และคีย์การเชื่อมต่อดั้งเดิม
ใน โปรแกรมไดร์เวอร์คลิก INSTALL เพื่อติดตั้งไดรเวอร์
เรียกใช้โปรแกรม edgehasp.exe– การสร้างคีย์ ป้อนคีย์ผลลัพธ์ลงในแท็บ “EMULATOR” คลิก "เริ่มบริการ"
เปิดโปรแกรมที่ได้รับการป้องกัน ตรวจสอบการทำงานของมัน จากนั้นหากทุกอย่างใช้งานได้ ให้เปิดหน้าต่าง "DUMPER" รหัสผ่านจะแสดงในหน้าต่าง หากต้องการสร้างสำเนา ให้คลิก "DUMP" ผลลัพธ์ที่ได้คือไฟล์ประเภท .dmp
เรียกใช้โปรแกรม EDGEHASP.EXE เพื่อแปลงไฟล์
เปิดไฟล์ DONGLES ในหน้าต่าง HASP/Hardlock Emulator และระบุชื่อไฟล์
ล้างการถ่ายโอนข้อมูล – ปุ่ม CLEAN
คุณสามารถใช้มัน.
การติดตั้งโปรแกรมจำลอง Sable
สามารถดูข้อมูลได้ที่:
www.emus2.narod.ru/emulyator-sable.html
www.gigatorrent.net/programms/office
เปิดตัว Sable และรอการรีบูต
ลบทางลัดโปรแกรมจำลอง - C:\การตั้งค่าเอกสาร\ผู้ใช้ทั้งหมด\StartMenu\Programs\Startup
ปล่อย C:\ProgramFiles\SABLE\- ปล่อย delnt.bat– การลบ Hasp ออกจากรีจิสทรี
ติดตั้งตัวจำลอง Hasp - C:\ProgramFiles\SABLE- วิ่ง instnt.bat.
ปล่อย startnt.bat- PU – ระบบ – อุปกรณ์ – รีโมทคอนโทรล
มุมมองเมนู-ShowHiddenDevice – คลิก NonPlag... -สแกนหาฮาร์ดแวร์...
คุณสมบัติ (คุณสมบัติ – hasp อัตโนมัติ) ตกลง
สำเนา แพตช์77. อดีตจาก C:\ProgramFiles\sableไปยังโฟลเดอร์ 1C
เรียกใช้ patch77.exe /F1cv7.exe
บันทึก. คำแนะนำที่ให้ไว้เป็นตัวอย่างที่ต้องปฏิบัติตามในสถานการณ์จริง
ที่นี่คุณสามารถ ดาวน์โหลดโปรแกรมจำลอง HASPฟรีโดยสมบูรณ์
นั่นคือทั้งหมดที่ฉันมีสำหรับวันนี้ ติดตามบล็อกโดย อีเมล- ฉันหวังว่าจะได้รับความคิดเห็นของคุณในความคิดเห็น ลาก่อน!
บทความนี้อธิบายวิธีการเลี่ยงผ่านระบบความปลอดภัยของฮาร์ดแวร์ ตามตัวอย่าง เราจะพิจารณาเทคโนโลยี HASP (Hardware Against Software Piracy) ที่พัฒนาโดย Aladdin Knowledge Systems Ltd. ในอดีตที่ผ่านมา เทคโนโลยีนี้เป็นหนึ่งในระบบป้องกันซอฟต์แวร์ฮาร์ดแวร์ที่ได้รับความนิยมมากที่สุด
พลังของการป้องกันฮาร์ดแวร์ HASP ถูกใช้โดยนักพัฒนาซอฟต์แวร์ที่จริงจังจำนวนมากที่ไม่ต้องการให้ผลิตภัณฑ์ของตนถูกแจกจ่ายโดยไม่ได้รับอนุญาต ตัวอย่างเช่น Hasp ปกป้องแพ็คเกจ "1C.Accounting" หรือ "1C.Enterprise" โดยที่ธุรกิจที่มีการจัดระเบียบไม่มากก็น้อยจะสามารถอยู่รอดได้ ไดเรกทอรีทางกฎหมายยอดนิยม “ConsultantPlus” ยังปกป้องการเข้าถึงข้อมูลโดยใช้กุญแจอิเล็กทรอนิกส์ หากต้องการใช้ซอฟต์แวร์ที่กล่าวมาข้างต้นหรือซอฟต์แวร์อื่นที่มีราคาแพงพอๆ กันโดยไม่ต้องจ่ายเงินให้ใคร เพียงแค่ท่องเว็บเพื่อค้นหาเครื่องมือ txt พร้อมคีย์นั้นไม่เพียงพอ อย่างไรก็ตาม แฮกเกอร์มักจะคิดออกเสมอว่าต้องทำอย่างไรกับการป้องกัน แม้แต่ฮาร์ดแวร์ก็ตาม และเขาไม่จำเป็นต้องมีหัวแร้งสำหรับสิ่งนี้
มาดูกันดีกว่า
เกินจริงเราสามารถพูดได้ว่า HASP ประกอบด้วยสองส่วน: ฮาร์ดแวร์และซอฟต์แวร์ ฮาร์ดแวร์เป็นคีย์อิเล็กทรอนิกส์ในรูปแบบของพวงกุญแจ USB, การ์ด PCMCIA, อุปกรณ์ LTP หรือแม้แต่การ์ด PCI ภายใน ซอฟต์แวร์ที่ติดตั้งจะใช้งานได้เฉพาะกับรถยนต์ที่เสียบกุญแจอิเล็กทรอนิกส์ไว้เท่านั้น จริงๆ แล้ว เป็นความคิดที่ดีที่จะเลิกใช้ซอฟต์แวร์จากนิสัยที่ไม่พึงประสงค์สำหรับกระเป๋าเงิน
ส่วนของซอฟต์แวร์ประกอบด้วยไดรเวอร์คีย์อิเล็กทรอนิกส์และซอฟต์แวร์ต่างๆ ที่เชื่อมโยงคีย์อิเล็กทรอนิกส์กับไดรเวอร์กับผลิตภัณฑ์ที่ได้รับการป้องกันหรือกับข้อมูลที่เข้ารหัสบางส่วนโดยตรง ในบทความนี้ เราจะดูและเลี่ยงการป้องกันโดยใช้พวงกุญแจ USB ซึ่งอาจเป็นกุญแจอิเล็กทรอนิกส์ที่ได้รับความนิยมมากที่สุดในปัจจุบัน
กลไกระบบป้องกัน
ตัวกุญแจนั้นแทบจะไม่สนใจเราเลย ต่างจากซอฟต์แวร์ที่มาพร้อมกับมัน โมดูล hardlock.sys เป็นที่สนใจของเรามากที่สุด ฉันจะทราบว่าไดรเวอร์นี้มีหน้าที่โต้ตอบกับดองเกิลฮาร์ดแวร์ โดยไม่ต้องลงรายละเอียด มีอ็อบเจ็กต์อุปกรณ์สองตัว หนึ่งในนั้นมีชื่อเชิงสัญลักษณ์ DeviceFNT0 การใช้ออบเจ็กต์นี้ แอปพลิเคชันที่ได้รับการป้องกันจะตรวจสอบสิทธิ์การใช้งานซอฟต์แวร์นี้ผ่านตัวจัดการ I/O
ข้อเสียเปรียบหลักของระบบป้องกันคือความสามารถในการสกัดกั้นการเรียกไปยังผู้จัดการ I/O และจำลองคีย์ฮาร์ดแวร์ นอกจากนี้ยังมีตัวเลือกในการพัฒนาไดรเวอร์คีย์เสมือน แต่นี่เป็นงานทางเทคนิคที่ซับซ้อนกว่าการสกัดกั้นการโทร
ดังที่คุณทราบ รุ่นไดรเวอร์ได้รับการอธิบายไว้ในโครงสร้าง DRIVER_OBJECT เมื่อโหลดโมดูล มันเก็บอาร์เรย์ของตัวจัดการข้อความ ยิ่งไปกว่านั้น ไม่มีใครรบกวนคุณให้เขียนที่อยู่เหล่านี้ใหม่และเข้าควบคุมโดยการรันโค้ดของเรา ดังนั้นจึงเป็นไปได้ที่จะสกัดกั้นและแทนที่แพ็กเก็ต IRP โดยการแทนที่ข้อมูลใบอนุญาต กล่าวอีกนัยหนึ่ง หากคุณมีคีย์ความปลอดภัยที่ถ่ายโอนข้อมูล คุณสามารถส่งต่อไปยังโปรแกรมที่ตรวจสอบความถูกต้องของข้อมูลใบอนุญาตได้!
หากต้องการใช้งานวิธีอื่น จำเป็นต้องมีการถ่ายโอนข้อมูลคีย์ด้วย แต่การทดแทนข้อมูลจะดำเนินการแตกต่างออกไป กล่าวคือ ในการจำลองซอฟต์แวร์ นั่นคือไดรเวอร์ความปลอดภัยจะสามารถจัดการคีย์เสมือนได้ในลักษณะเดียวกับคีย์จริง
การสกัดกั้นและการจำลอง
ตามที่ระบุไว้แล้ว แนวคิดของการสกัดกั้นคือการเขียนทับตัวจัดการแพ็กเก็ต IRP เมื่อต้องการทำเช่นนี้ คุณจะต้องสามารถเปลี่ยนฟิลด์ของโครงสร้าง DRIVER_OBJECT ได้ โชคดีที่มีฟังก์ชันที่เรียกว่า IoGetDevicePointer ซึ่งจะส่งคืนตัวชี้ไปที่ด้านบนของวัตถุสแต็กอุปกรณ์ที่มีชื่อและตัวชี้ไปยังวัตถุไฟล์ที่เกี่ยวข้อง นี่คือข้อมูลโค้ดสำหรับฟังก์ชันที่ตั้งค่า hook:
UNICODE_STRING ชื่ออุปกรณ์;
PDEVICE_OBJECT วัตถุอุปกรณ์;
PFILE_OBJECT วัตถุไฟล์;
RtlInitUnicodeString(&ชื่ออุปกรณ์, lpDevice);
IoGetDeviceObjectPointer(&ชื่ออุปกรณ์, 1u, &FileObject, &DeviceObject);
หลังจากได้รับตัวชี้ไปยังโครงสร้าง DEVICE_OBJECT เราก็มีตัวชี้ไปยัง DRIVER_OBJECT ตอนนี้เรามาแทนที่ที่อยู่ของตัวจัดการและฟังก์ชันการขนถ่ายไดรเวอร์ด้วยของเราเอง:
อุปกรณ์ตะขอ NTSTATUS (LPWSTR lpDevice)
gDriverObject = DeviceObject->DriverObject;
gDeviceControl = gDriverObject->MajorFunction;
gDriverObject->MajorFunction = HookDispatch;
gInternalDeviceControl = gDriverObject->MajorFunction;
gDriverObject->MajorFunction = HookDispatch;
gDriverUnload = gDriverObject->ไดร์เวอร์อันโหลด;
gDriverObject->DriverUnload = HookUnload;
ObfDereferenceObject(FileObject);
บรรทัดสุดท้ายเรียกฟังก์ชัน ObfDereferenceObject ซึ่งจะลดจำนวนการอ้างอิงไปยังวัตถุไฟล์ จะต้องดำเนินการนี้เพื่อยกเลิกการโหลดไดรเวอร์อย่างถูกต้อง เพื่อหลีกเลี่ยงการรั่วไหลของทรัพยากรและข้อผิดพลาดที่คล้ายกัน
เนื่องจากตัวชี้ไปยังออบเจ็กต์ไดรเวอร์การป้องกันได้รับการบันทึกแล้ว หากต้องการลบกับดัก คุณเพียงแค่ต้องกู้คืนตัวจัดการแพ็กเก็ต IRP ก่อนหน้า:
เป็นโมฆะ UnhookDevice (เป็นโมฆะ)
gDriverObject->MajorFunction = gDeviceControl;
gDriverObject->MajorFunction = gInternalDeviceControl;
gDriverObject->DriverUnload = gDriverUnload;
แน่นอนว่าเราจำเป็นต้องเพิ่มการตรวจสอบความถูกต้องของพอยน์เตอร์ให้เหมาะสมและอื่นๆ
ตอนนี้คุณต้องใช้การขนถ่ายไดรเวอร์ที่ถูกต้อง เนื่องจากระบบป้องกันอาจทำงานเสร็จก่อนไดรเวอร์ของเราด้วยเหตุผลบางประการ เพื่อหลีกเลี่ยงไม่ให้ระบบล่มเนื่องจากตัวชี้ไม่ถูกต้อง เราจะประมวลผลเหตุการณ์นี้ในฟังก์ชัน HookUnload:
เป็นโมฆะ HookUnload (PDRIVER_OBJECT DrvObj)
ปลดอุปกรณ์();
gDriverUnload(DrvObj);
ที่นี่ฟิลด์ของโครงสร้าง DRIVER_OBJECT จะได้รับการกู้คืน และการควบคุมจะถูกถ่ายโอนไปยังโค้ดต้นฉบับเพื่อยกเลิกการโหลดไดรเวอร์อุปกรณ์ที่ถูกดักจับ
เราทำเช่นเดียวกันหากคนขับของเราปิดเครื่อง ก่อนระบบการป้องกัน คุณเพียงแค่ต้องปล่อยทรัพยากรที่บันทึกไว้ และไม่เรียก gHookUnload ที่บันทึกไว้
โปรแกรมจำลองทำงานอย่างไร
เครื่องสกัดกั้น
เมื่อทราบหลักการพื้นฐานของการสกัดกั้นแพ็กเก็ต IRP ที่ง่ายที่สุด เรามาดำเนินการใช้เฉพาะตัวสกัดกั้นเองเพื่อการวิเคราะห์ต่อไป ในการดำเนินการนี้ เราจะสร้างวัตถุไดรเวอร์ที่มีชื่อสัญลักษณ์ (เช่น DosDevicesHook) และจุดเข้าสร้าง ปิด อ่าน
IoCreateDevice (วัตถุไดรเวอร์, 0, &usDeviceName, FILE_DEVICE_NULL, 0, 0, &pDeviceObject);
IoCreateSymbolicLink(&usSymbolicDeviceName, &usDeviceName);
DriverObject->MajorFunction = DriverDispatch;
DriverObject->MajorFunction = DriverDispatch;
DriverObject->MajorFunction = DriverDispatch;
DriverObject->DriverUnload = DriverUnload;
นี่เป็นสิ่งจำเป็นเพื่อที่จะทำงานกับ interceptor ของเราเป็นไฟล์ โดยใช้ฟังก์ชัน CreateFileReadFileCloseHandle ด้วยการใช้การแลกเปลี่ยนข้อมูลระหว่างแอปพลิเคชันและตัวสกัดกั้น จึงเป็นไปไม่ได้ที่จะส่งไปยังโปรแกรมผู้ใช้ทันที ดังนั้นจึงจำเป็นต้องสร้างโครงสร้างบางอย่างเพื่อจัดเก็บข้อมูลที่จำเป็นเกี่ยวกับแพ็กเก็ตที่จับได้ ตัวอย่างเช่น รายการที่เชื่อมโยงเดี่ยวๆ ตามที่ฉันนำไปใช้ ตอนนี้คุณต้องตัดสินใจว่าข้อมูลใดที่ต้องบัฟเฟอร์ นี่เป็นข้อมูลทั่วไปเกี่ยวกับแพ็คเกจ (ประเภท แฟล็ก ฯลฯ) และแน่นอนว่ารวมถึงบัฟเฟอร์ คุณสามารถเพิ่มเวลาสกัดกั้นได้ เมื่อคัดลอกเนื้อหาของบัฟเฟอร์ คุณต้องจำประเภทของบัฟเฟอร์ ไม่เช่นนั้นบัฟเฟอร์จะเสียหาย เมื่อมองไปข้างหน้า ฉันจะทราบว่าไดรเวอร์การป้องกันใช้ I/O แบบบัฟเฟอร์ ซึ่งทำให้โค้ดง่ายขึ้นเล็กน้อย
รหัสจัดส่งของ Hook
ถ้า (idlTail->IrpData.InputLength)
{
idlTail->InputBuffer = ExAllocatePool (NonPagedPool, idlTail->IrpData.InputLength);
RtlCopyMemory (idlTail->InputBuffer, Irp->AssociatedIrp.SystemBuffer, idlTail->IrpData.InputLength);
}
ถ้า (IoSL->ฟังก์ชันหลัก == IRP_MJ_DEVICE_CONTROL)
สถานะ = pHookedDriverDispatch (DeviceObject, Irp);
ถ้า (idlTail->IrpData.OutputLength)
{
idlTail->OutputBuffer = ExAllocatePool (NonPagedPool, idlTail->IrpData.OutputLength);
RtlCopyMemory(idlTail->OutputBuffer, lpBuffer, idlTail->IrpData.OutputLength);
}
ยังคงต้องใช้การอ่านจากไดรเวอร์ เนื่องจากแพ็กเก็ตมีบัฟเฟอร์ที่มีเนื้อหาเป็นที่สนใจ ขนาดของข้อความจึงไม่ทราบล่วงหน้า ดังนั้นเราจึงดำเนินการดังนี้: ในการอ่านครั้งแรกที่เราได้รับ ข้อมูลทั่วไปเกี่ยวกับแพ็กเก็ตและขนาดของบัฟเฟอร์ เมื่ออ่านเนื้อหาอีกครั้งให้ลบลิงค์ออกจากรายการแพ็คเกจและอย่าลืมล็อคการหมุนด้วย การดำเนินการตามลำดับมีข้อมูล:
รหัสจัดส่งไดร์เวอร์
ความยาว = IoSL->พารามิเตอร์การอ่านความยาว;
ถ้า (ความยาว == ขนาดของ (IRP_DATA) && idlHead)
RtlCopyMemory(Irp->UserBuffer, &idlHead->IrpData, ความยาว);
อย่างอื่นถ้า (idlHead && ความยาว == (idlHead->IrpData.InputLength + idlHead->IrpData.OutputLength))
{
RtlCopyMemory (Irp->UserBuffer, idlHead->InputBuffer, idlHead->IrpData.InputLength);
RtlCopyMemory((PVOID)((ULONG)Irp->UserBuffer + idlHead->IrpData.InputLength), idlHead->OutputBuffer, idlHead->IrpData.OutputLength);
}
อย่างอื่นถ้า (ความยาว == 1 && idlHead)
{
ถ้า (idlHead->InputBuffer)
ExFreePool(idlHead->InputBuffer);
ถ้า (idlHead->OutputBuffer)
ExFreePool(idlHead->OutputBuffer);
idlTemp = idlHead->ldlNext;
ExFreePool(idlHead);
idlHead = idlTemp;
ถ้า (!idlTemp)
idlTail = โมฆะ;
}
เมื่อ Interceptor พร้อม เราจะเปิดมันก่อน จากนั้นจึงเปิดแอปพลิเคชันที่ได้รับการป้องกันทั้งแบบมีและไม่มีคีย์ จากบันทึกที่ได้รับ จะชัดเจนว่ารหัสควบคุมใดที่ถูกส่งไปและผลลัพธ์ คุณจะเห็นได้ว่าคำขอและการตอบกลับของรหัสสองรหัสที่แตกต่างกัน (9c402450, 9c4024a0) ไม่มีการเปลี่ยนแปลง ดูเหมือนว่าจะเป็นไปได้ที่จะสร้างโปรแกรมจำลองตาราง แต่หลังจากการเปิดตัวหลายครั้ง เรามั่นใจว่าสิ่งนี้เป็นไปไม่ได้ เนื่องจากเนื้อหาของบัฟเฟอร์แตกต่างกัน และไม่รู้ว่ามันเกิดขึ้นได้อย่างไร
แพ็กเก็ตที่บันทึกโดยไม่มีคีย์
ดักจับแพ็กเก็ตด้วยคีย์
มีหลายตัวเลือกสำหรับการดำเนินการเพิ่มเติม:
- สำรวจป่าของนักขับฝ่ายป้องกัน
- ใช้ข้อมูลจากผู้พัฒนาระบบเอง
ทั้งสองตัวเลือกให้ ข้อมูลที่จำเป็น- ปรากฎว่าเนื้อหาของแพ็กเก็ตถูกเข้ารหัสแบบสาธารณะ อัลกอริธึมแบบสมมาตร AES (มาตรฐานการเข้ารหัสขั้นสูง) เป้าหมายเชิงตรรกะคือการได้รับคีย์เข้ารหัส
แต่ถ้าเราเจาะลึกยิ่งขึ้นในการศึกษาการออกแบบระบบรักษาความปลอดภัย ปรากฎว่าคีย์ฮาร์ดแวร์มีหมายเลขเฉพาะและมีข้อมูลที่จำเป็นทั้งหมด แต่ต้องใช้คีย์ซอฟต์แวร์เพื่อเข้าถึง
ตัวอย่างดัมพ์คีย์
ดังนั้นสิ่งแรกที่คุณต้องทำคือรับกุญแจ ปัญหาสามารถแก้ไขได้ด้วยกำลังเดรัจฉานง่ายๆ:
คีย์สั้นที่ไม่ได้ลงนาม
RefKey ถ่านที่ไม่ได้ลงนาม, VerKey;
สำหรับ (คีย์ = 0; คีย์<= 0x7fff, Key++)
{
ถ้า (!HL_LOGIN(คีย์, 1, RefKey, VerKey))
{
HL_LOGOUT();
หยุดพัก;
}
}
ฟังก์ชัน HL_LOGIN, HL_LOGOUT พร้อมใช้งานจาก HASP SDK สำหรับนักพัฒนาแอปพลิเคชันที่ได้รับการป้องกันบนแพลตฟอร์มนี้ และมีต้นแบบดังต่อไปนี้:
WORD HL_LOGIN(WORD ModAd, การเข้าถึง Word, ไบต์ *RefKey, Byt *VerKey);
WORD HL_LOGOUT (เป็นโมฆะ);
ฟังก์ชันแรกใช้เพื่อเปิดเซสชันการทำงานกับคีย์ป้องกันโดยใช้ไดรเวอร์ ส่วนฟังก์ชันที่สองจะสิ้นสุดเซสชัน สิ่งเหล่านี้เป็นต้นแบบของ HASP SDK เวอร์ชันเก่า แต่ยังใช้งานได้กับคีย์ประเภทใหม่ด้วย เนื่องจากนักพัฒนาได้รับประกันความเข้ากันได้แบบย้อนหลัง
API ใหม่แตกต่างจากอันเก่าเล็กน้อย และสิ่งนี้ไม่มีผลกระทบต่อหลักการของการดำเนินการแบบเดรัจฉานแต่อย่างใด สามารถดูเอกสารประกอบ Hasp API โดยละเอียด การใช้งาน bruteforce และ key dumper สำเร็จรูปได้ที่
ตัวจัดการ
ตอนนี้คุณมีทุกสิ่งที่คุณต้องการเพื่อให้โมดูลทำงานได้อย่างถูกต้อง สิ่งที่เหลืออยู่คือการใช้การทดแทนข้อมูลใบอนุญาต นอกจากนี้ มีเพียงบางแพ็กเก็ต IRP เท่านั้นที่สามารถดักจับได้ ที่นี่ทุกอย่างขึ้นอยู่กับเวอร์ชันเฉพาะของคีย์และโปรแกรมที่ได้รับการป้องกัน
เป็นการดีกว่าที่จะไม่ฝังคีย์ดัมพ์ลงในไดรเวอร์ แต่ควรโหลดแบบไดนามิกจากรีจิสตรี เป็นการดีกว่าที่จะพึ่งพาตัวดักคำขอสำเร็จรูป ซึ่งจะช่วยให้แก้ไขข้อบกพร่องของไดรเวอร์ได้ง่ายขึ้นโดยการส่งแพ็กเก็ตที่ดักจับ/แทนที่เพื่อการวิเคราะห์ไปยังแอปพลิเคชันผู้ใช้ โดยพื้นฐานแล้ว ตรรกะของตัวสกัดกั้นจะมีลักษณะดังนี้:
NTSTATUS HookDispatch ():
PIO_STACK_LOCATION Stack = Irp->Tail.Overlay.CurrentStackLocation;
ULONG IoControlCode;
ถ้า (Stack->MajorFunction == 14)
{
IoControlCode = Stack.DeviceIoControl.IoControlCode;
ถ้า (IoControlCode != 0x9c402458)
{
ส่งคืน gDeviceControl (DeviceObject, Irp);
}
อื่น
{
เข้ารหัส (Irp->AssociatedIrp.SystemBuffer);
ห้องใต้ดิน (Irp->AssociatedIrp.SystemBuffer, คีย์, DumpMemory);
}
}
ส่งคืน STATUS_FAILED;
แพ็กเก็ตคำขอไดรเวอร์ได้รับการเข้ารหัส ดังนั้นการเข้าถึงเนื้อหาจึงจำเป็นต้องมีการถอดรหัสและการเข้ารหัส คำถามเกิดขึ้น: อัลกอริธึมอะไรและคีย์ใดที่ใช้ในการเข้ารหัส? เมื่อเจาะลึกซอร์สโค้ดจากผู้สร้างระบบแล้ว คุณจะได้รับอัลกอริธึมการเข้ารหัสแพ็กเก็ตหลักดังต่อไปนี้:
รหัสเข้ารหัส()
เป็นโมฆะการเข้ารหัส (BYTE * บัฟเฟอร์)
{
เมล็ดคำ = ((คำ)บัฟเฟอร์ + 0x5e);
เวิร์ด เวอร์ชั่น = ((คำ)บัฟเฟอร์ + 0xba);
ถ้า (เวอร์ชั่น)
{
สำหรับ (int i = 0; i< 0xB9; i++) {
(คำ)(บัฟเฟอร์ + i) += Seed;
เมล็ดพันธุ์ = (เมล็ดพันธุ์ >> 15) | (เมล็ดพันธุ์<< 1);
เมล็ดพืช -= (คำ)(บัฟเฟอร์ + i) ^ i;
}
สำหรับ (int i = 0xBE; i< 0xFF; i++) {
(คำ)(บัฟเฟอร์ + i) -= Seed;
เมล็ดพันธุ์ = (เมล็ดพันธุ์ >> 15) | (เมล็ดพันธุ์<< 1);
เมล็ด += (คำ)(บัฟเฟอร์ + i) ^ i;
}
((คำ)บัฟเฟอร์ + 0xba) = เมล็ด;
}
}
จะเห็นได้ว่าอัลกอริทึมนั้นซับซ้อนกว่าการเปลี่ยนแปลงปกติและ "หรือ" แบบเอกสิทธิ์เฉพาะบุคคลมาก และนี่คืออัลกอริธึมการถอดรหัส:
ถอดรหัสรหัส()
ถอดรหัสเป็นโมฆะ (บัฟเฟอร์ BYTE *)
{
เมล็ดคำ = ((คำ)บัฟเฟอร์ + 0x5e);
เวิร์ด เวอร์ชั่น = ((คำ)บัฟเฟอร์ + 0xba);
ถ้า (เวอร์ชั่น) (
สำหรับ (int i = 0xFE; i > 0xBD; i—) (
เมล็ดพืช -= (คำ)(บัฟเฟอร์ + i) ^ i;
เมล็ดพันธุ์ = (เมล็ด<< 15) | (Seed >> 1);
(คำ)(บัฟเฟอร์ + i) += Seed;
}
สำหรับ (int i = 0xB8; i >= 0; i—) (
เมล็ด += (คำ)(บัฟเฟอร์ + i) ^ i;
เมล็ดพันธุ์ = (เมล็ด<< 15) | (Seed >> 1);
(คำ)(บัฟเฟอร์ + i) -= Seed;
}
((คำ)บัฟเฟอร์ + 0xba) = เมล็ด;
}
}
จากนั้นทำตามขั้นตอนการแปลงข้อมูลอีกขั้นตอนหนึ่งซึ่งซับซ้อนกว่าและขึ้นอยู่กับโครงสร้างของคำขอโดยสมบูรณ์ คุณไม่สามารถทำสิ่งนี้ได้หากไม่มีตัวแยกชิ้นส่วน คุณจะต้องเจาะลึกถังขยะและยืมโค้ดจากผู้สร้าง นี่ไม่ใช่เรื่องง่าย เนื่องจากรหัสไดรเวอร์ความปลอดภัยมีความสับสนอย่างมาก แต่ไม่มีลูกเล่นที่หลากหลาย มันจะเพียงพอที่จะถอดรหัสไดรเวอร์ที่ไม่สมบูรณ์ แต่มีเพียงโค้ดบางส่วนเท่านั้น
โดยสรุป ฉันทราบว่าการสร้างโปรแกรมจำลองตารางโดยใช้การสกัดกั้น DeviceIoControl นั้นเป็นงานที่ค่อนข้างยาก แต่หลักการจำลองนี้สามารถนำไปใช้ในการโต้ตอบอีกระดับหนึ่งได้: เพื่อสร้างบัส USB เสมือน
บทสรุป
นี่ไม่ใช่ วิธีเดียวเท่านั้นกำจัดระบบรักษาความปลอดภัย มีวิธีอื่นขั้นสูงกว่านี้ หลักการที่สรุปไว้ในบทความนี้ยังสามารถใช้เพื่อวิเคราะห์การทำงานของไดรเวอร์โดยการสกัดกั้นแพ็กเก็ต IRP วิธีนี้ทำให้คุณสามารถเพิ่มอุปกรณ์ดีๆ ให้กับชุดอุปกรณ์ที่ทำไว้บริเวณหัวเข่าได้ ขอให้โชคดี!
