ใช้ Delphi เพื่อใช้การเข้ารหัสและการบีบอัดไฟล์
ผู้แต่ง: E Mengyuan (wnhoo)
จดหมาย: [email protected]
ความรักและความรัก
คลิกเพื่อดาวน์โหลดไฟล์คำอธิบายโดยละเอียดนี้
ภาพรวม:
ในเอกสารนี้เราจะพูดคุยเกี่ยวกับการใช้การเข้ารหัสข้อมูลการบีบอัดข้อมูลและการแสดงออกของตนเองของไฟล์เดียว ในทำนองเดียวกันการบีบอัดไฟล์หรือโฟลเดอร์หลายไฟล์สามารถทำได้ด้วยการปรับเปลี่ยนเล็กน้อย
คำสำคัญ: การบีบอัดที่เข้ารหัส, zlib, สตรีม, ไฟล์ทรัพยากร
การแนะนำ:
ในชีวิตประจำวันเราต้องใช้ซอฟต์แวร์การบีบอัดที่มีชื่อเสียงเช่น Winzip และ Winrar ซึ่งหมายความว่าเราจะพบปัญหาเช่นการเข้ารหัสข้อมูลและการบีบอัดข้อมูลในระหว่างกระบวนการพัฒนาซอฟต์แวร์อย่างหลีกเลี่ยงไม่ได้! บทความนี้กล่าวถึงปัญหาทางเทคนิคนี้และต้องขอบคุณชาวเน็ตทุกคนสำหรับทักษะของพวกเขา บทความนี้ส่วนใหญ่ใช้ทักษะการประมวลผลสตรีมที่ทรงพลังของ Delph เพื่อให้ได้การเข้ารหัสและการบีบอัดข้อมูลและใช้ในการพัฒนาโปรแกรมซอฟต์แวร์จริง
1. ฟังก์ชั่นระบบ
1) การบีบอัดข้อมูล
ใช้คลาสสตรีมสองคลาสที่จัดทำโดย Delphi (TcompressionsTream และ TDECOMPRESSIONSTREAM) เพื่อให้การบีบอัดและการบีบอัดข้อมูลเสร็จสมบูรณ์
2) การเข้ารหัสข้อมูลและการบีบอัด
การเข้ารหัสข้อมูลได้รับการรับรู้ผ่านแอปพลิเคชันของ "สตรีม" ในการเขียนโปรแกรม Delphi ส่วนใหญ่ใช้ Tfilestream และ Tmemorystream สองคลาสที่ได้รับของ TStream;
3) ดับเบิลคลิกที่ไฟล์บีบอัดเพื่อเชื่อมโยงและคลายการบีบอัดโดยอัตโนมัติ
โดยการเปลี่ยนความสัมพันธ์ของส่วนขยายรีจิสทรีด้วยไฟล์โปรแกรม Tregistry ส่วนใหญ่จะใช้งาน
4) สามารถสร้างไฟล์ที่สกัดด้วยตนเองได้
ไฟล์ที่แสดงออกด้วยตนเองตระหนักถึงการบีบอัดข้อมูลการบีบอัดข้อมูลโดยอัตโนมัติ 1) และการบีบอัดการเข้ารหัสข้อมูล 2) และผ่านการใช้ไฟล์ทรัพยากรการแสดงออกของข้อมูลด้วยตนเองจะได้รับการรับรู้ การแสดงออกของข้อมูลด้วยตนเองทำได้
2. การใช้งานระบบ
2.1.
2.2.
(i) zlib
1) คลาส Base Tcustomzlibstream: เป็นคลาสพื้นฐานของคลาส TcompressionsTream และ TDecompressionsTream
รูปแบบ: ProcedureOnProgress (ผู้ส่ง: tobject); Dynamic;
2) คลาสการบีบอัด TcompressionStream: นอกเหนือจากการสืบทอดคุณสมบัติ onprogress ของคลาสฐานแล้วยังมีการเพิ่มแอตทริบิวต์อื่น: การบีบอัดซึ่งกำหนดไว้ดังนี้:
Propertycompressionrate: SinglerEadGetCompressionrate;
ผ่านคุณสมบัตินี้สามารถรับอัตราส่วนการบีบอัดได้
วิธีการสำคัญหลายประการถูกกำหนดดังนี้:
ConstructOrmpressionStream.create (PrompressionLevel: TcompressionLevel; Dest: TStream);
ในหมู่พวกเขา: tcompressionlevel (ประเภทการบีบอัด) มันถูกกำหนดโดยสิ่งต่อไปนี้:
1) Clnone: ไม่มีการบีบอัดข้อมูล
2) Clfastest: ดำเนินการบีบอัดอย่างรวดเร็วการเสียสละประสิทธิภาพการบีบอัด;
3) Cldefault: ทำการบีบอัดปกติ
4) Clmax: เพิ่มความเร็วในการบีบอัดและการเสียสละสูงสุด
DEST: สตรีมปลายทางใช้เพื่อจัดเก็บข้อมูลที่ถูกบีบอัด
FunctionTcompressionStream.write (Constbuffer; Count: Longint): Longint;
ในหมู่พวกเขา: บัฟเฟอร์: ข้อมูลที่ต้องบีบอัด;
นับ: จำนวนไบต์ของข้อมูลที่จะถูกบีบอัด;
ฟังก์ชั่นส่งคืนจำนวนไบต์ที่เขียนไปยังสตรีม
หมายเหตุ: ข้อมูลของ TompressionsTream ที่ถูกบีบอัดสามารถเขียนได้เท่านั้น ข้อมูลที่ต้องถูกบีบอัดถูกเขียนลงในสตรีมผ่านวิธีการเขียนวิธีการและถูกบีบอัดในระหว่างกระบวนการเขียนและบันทึกไว้ในสตรีมหน่วยความจำ (TMemorystream) ที่สร้างโดยตัวสร้างและเหตุการณ์ onProcess จะถูกเรียก
3) การบีบอัดคลาส TDECOMPRESSIONSTREAM: ตรงกันข้ามกับการบีบอัดคลาส TOCPRESSIONSTREAM ข้อมูลของมันสามารถอ่านได้เท่านั้น
วิธีการสำคัญหลายประการถูกกำหนดดังนี้:
ConstructorCreate (ที่มา: TStream);
ในหมู่พวกเขา: แหล่งที่มาคือสตรีมที่เก็บข้อมูลที่บีบอัด;
functionRead (varbuffer; count: longint): longint;
ฟังก์ชั่นการอ่านข้อมูล, บัฟเฟอร์: เก็บข้อมูลบัฟเฟอร์;
ฟังก์ชั่นส่งคืนจำนวนไบต์อ่าน ในระหว่างกระบวนการอ่านข้อมูลจะถูกบีบอัดและเหตุการณ์ OnProcess จะถูกเรียกใช้
(ii)
ใน Delphi คลาสพื้นฐานของวัตถุสตรีมทั้งหมดคือคลาส TStream ซึ่งกำหนดคุณสมบัติและวิธีการทั่วไปของสตรีมทั้งหมด
คุณสมบัติที่กำหนดในคลาส TStream มีดังนี้:
1) ขนาด: คุณสมบัตินี้ส่งคืนขนาดข้อมูลในสตรีมในไบต์
2) ตำแหน่ง: คุณสมบัตินี้ควบคุมตำแหน่งของการเข้าถึงพอยน์เตอร์ในการไหล
มีสี่วิธีเสมือนที่กำหนดไว้ใน TStream:
1) อ่าน: วิธีนี้ใช้การอ่านข้อมูลจากสตรีมและค่าส่งคืนเป็นจำนวนจริงของไบต์ที่อ่านซึ่งอาจน้อยกว่าหรือเท่ากับค่าที่ระบุ
2) เขียน: วิธีนี้ใช้การเขียนข้อมูลลงในสตรีมและค่าที่ส่งคืนคือจำนวนไบต์ที่เขียนลงในสตรีมจริง
3) ค้นหา: วิธีนี้ตระหนักถึงการเคลื่อนไหวของตัวชี้การอ่านในสตรีมและค่าการส่งคืนเป็นตำแหน่งของตัวชี้หลังจากการเคลื่อนไหว
ต้นแบบฟังก์ชั่นคือ: functionseek (ออฟเซ็ต: longint; Origint: Word): Longint; Virtual; Abstract;
การชดเชยพารามิเตอร์คือจำนวนไบต์ออฟเซ็ต
Sofrombeginning: Offset เป็นข้อมูลระยะทางของตัวชี้เริ่มต้นขึ้น ในเวลานี้ชดเชยจะต้องมากกว่าหรือเท่ากับศูนย์
Sofromcurrent: Offset เป็นตำแหน่งสัมพัทธ์ของตัวชี้และตัวชี้ปัจจุบันหลังจากเคลื่อนที่
Sofromend: Offset เป็นตำแหน่งที่ข้อมูลระยะทางของตัวชี้สิ้นสุดลงหลังจากเคลื่อนที่ ในเวลานี้ชดเชยจะต้องน้อยกว่าหรือเท่ากับศูนย์
4) SetSize: วิธีนี้ตระหนักถึงการเปลี่ยนขนาดของข้อมูล
นอกจากนี้มีการกำหนดวิธีการคงที่หลายวิธีในคลาส TStream:
1) ReadBuffer: ฟังก์ชั่นของวิธีนี้คือการอ่านข้อมูลจากตำแหน่งปัจจุบันในสตรีมเหมือนกับการอ่านด้านบน
หมายเหตุ: เมื่อจำนวนไบต์ที่อ่านแตกต่างจากจำนวนไบต์ที่จะอ่านจะมีการสร้างข้อยกเว้น eReadError
2) Writebuffer: ฟังก์ชั่นของวิธีนี้คือการเขียนข้อมูลไปยังสตรีมที่ตำแหน่งปัจจุบันเหมือนกับการเขียนด้านบน
หมายเหตุ: เมื่อจำนวนไบต์ที่เขียนในข้อมูลแตกต่างจากจำนวนไบต์ที่จะเขียนจะมีการสร้างข้อยกเว้น eWriteError
3) CopyFrom: ฟังก์ชั่นของวิธีนี้คือการคัดลอกสตรีมข้อมูลจากสตรีมอื่น ๆ
ต้นแบบฟังก์ชั่นคือ: functionCopyFrom (ที่มา: tstream; count: longint): longint;
แหล่งที่มาของพารามิเตอร์คือสตรีมที่ให้ข้อมูลและการนับคือจำนวนข้อมูลไบต์ที่คัดลอก เมื่อการนับมากกว่า 0, Copy From คัดลอกจำนวนไบต์ของข้อมูลจากตำแหน่งปัจจุบันของพารามิเตอร์แหล่งที่มา
คลาสที่ได้มาโดยทั่วไปของ TStream:
tfilestream (เข้าถึงสตรีมไฟล์)
tStringStream (ประมวลผลข้อมูลประเภทสตริงในหน่วยความจำ)
TMemoryStream (สำหรับการประมวลผลข้อมูลพื้นที่หน่วยความจำในการทำงาน)
tblobstream (การประมวลผลข้อมูลของฟิลด์ประเภท Blob)
TwinsocketStream (อ่านและเขียนการประมวลผลของซ็อกเก็ต)
Tolestream (การประมวลผลข้อมูลของ COM อินเตอร์เฟส)
TresourCestream (การประมวลผลสตรีมไฟล์ทรัพยากร)
สิ่งที่ใช้กันมากที่สุดคือคลาส Tfilestream ในการเข้าถึงไฟล์โดยใช้คลาส TFilestream คุณต้องสร้างอินสแตนซ์ก่อน คำสั่งมีดังนี้:
ConstructorCreate (Constfilename: String; Mode: Word);
ชื่อไฟล์คือชื่อไฟล์ (รวมถึงเส้นทาง)
โหมดเป็นวิธีที่จะเปิดไฟล์
โหมดเปิด:
fmCreate: สร้างไฟล์ด้วยชื่อไฟล์ที่ระบุและเปิดหากไฟล์มีอยู่แล้ว
fmopenread: เปิดไฟล์ที่ระบุในการอ่านอย่างเดียว
fmopenwrite: เปิดไฟล์ที่ระบุในลักษณะการเขียนเท่านั้น
fmopenreadWrite: เปิดไฟล์ที่ระบุในโหมดการเขียน
โหมดการแชร์:
FMShareCompat: โหมดที่ใช้ร่วมกันเข้ากันได้กับ FCBS
fmshareexclusive: ไม่อนุญาตให้เปิดโปรแกรมอื่น ๆ ในทางใดทางหนึ่ง
fmsharedenywrite: ไม่อนุญาตให้เปิดโปรแกรมอื่น ๆ ให้เปิดไฟล์เป็นลายลักษณ์อักษร
fmsharedenyread: ไม่อนุญาตให้เปิดโปรแกรมอื่น ๆ ในโหมดอ่าน
fmsharedenynone: โปรแกรมอื่น ๆ สามารถเปิดไฟล์ได้ แต่อย่างใด
(iii) ไฟล์ทรัพยากร
1) สร้างไฟล์ทรัพยากร
ก่อนอื่นสร้างไฟล์ข้อความธรรมดาของ. rc
รูปแบบ: ชื่อไฟล์คีย์เวิร์ดตัวระบุทรัพยากร
ตัวระบุทรัพยากร: ฉลากพิเศษเมื่อเรียกทรัพยากรในโปรแกรม
คำสำคัญ: ระบุประเภทไฟล์ทรัพยากร;
Wave: ไฟล์ทรัพยากรเป็นไฟล์เสียง
rcdata: ไฟล์ jpeg;
Avi: Avi Animation;
ไอคอน: ไฟล์ไอคอน;
บิตแมป: ไฟล์บิตแมป;
เคอร์เซอร์: ไฟล์เคอร์เซอร์;
exefile: ไฟล์ exe
ชื่อไฟล์ทรัพยากร: ชื่อเต็มของไฟล์ที่เก็บไว้ในดิสก์ของไฟล์ทรัพยากร
ตัวอย่างเช่น:
myzjyexefilezjy.exe
2) รวบรวมไฟล์ทรัพยากร
ภายใต้ /bin ของไดเรกทอรีการติดตั้ง Delphi ใช้ brcc32.exe เพื่อรวบรวมไฟล์ทรัพยากร แน่นอนคุณสามารถคัดลอก BRCC32 ไปยังไดเรกทอรีเอกสารโปรแกรมแยกต่างหากเพื่อใช้งาน
ตัวอย่างเช่น:
brcc32wnhoo_reg.rc
3) การอ้างอิงไฟล์ทรัพยากร
-
การดำเนินการ
{$ r*.dfm}
{$ rwnhoo_reg.res}
-
4) ไฟล์ทรัพยากรโทร
(1) เข้าถึงบิตแมปในไฟล์ทรัพยากร (บิตแมป)
image.picture.bitmap.handle: = loadbitmap (hinstance, 'ตัวระบุทรัพยากร');
หมายเหตุ: หากบิตแมปไม่ได้โหลดสำเร็จโปรแกรมจะยังคงดำเนินการอยู่ แต่ภาพจะไม่ปรากฏอีกต่อไป คุณสามารถตัดสินได้ว่าการโหลดนั้นสำเร็จตามค่าการส่งคืนของฟังก์ชัน LoadBitMap หรือไม่
อีกวิธีหนึ่งในการเข้าถึงและแสดงบิตแมปมีดังนี้
image.picture.bitmap.loadfromresourcename (Hinstance, 'ตัวระบุทรัพยากร');
(2) เข้าถึงเคอร์เซอร์ในไฟล์ทรัพยากร
Screen.cursors [] เป็นอาร์เรย์เคอร์เซอร์ เนื่องจากค่าดัชนีเคอร์เซอร์เริ่มต้นในอาร์เรย์คือ 0 จึงเป็นการดีที่สุดที่จะตั้งค่าดัชนีเคอร์เซอร์ที่กำหนดเองเป็น 1 เว้นแต่คุณต้องการแทนที่เคอร์เซอร์เริ่มต้น
Screen.cursors [1]: = loadcursor (Hinstance, 'ตัวระบุทรัพยากร');
image.cursor: = 1;
(3) ไอคอนการเข้าถึงในไฟล์ทรัพยากร
การใส่ไอคอนในไฟล์ทรัพยากรช่วยให้คุณสามารถเปลี่ยนไอคอนแอปพลิเคชันแบบไดนามิกได้
application.icon.handle: = loadicon (hinstance, 'ตัวระบุทรัพยากร');
(4) เข้าถึง AVI ในไฟล์ทรัพยากร
animate.resname: = 'myavi'; // หมายเลขตัวระบุทรัพยากร
Animate.active: = true;
(5) เข้าถึง JPEG ในไฟล์ทรัพยากร
เพิ่มหน่วย JPEG ลงในหน่วยการใช้งาน
วาจา
fjpg: tjpegimage;
fstream: Tresourcestream;
เริ่ม
fjpg: = tjpegimage.create;
// tresourcestream ใช้
fstream: = tresourcestream.create (hinstance, 'ตัวระบุทรัพยากร', ประเภททรัพยากร);
fjpg.loadfromstream (fstream);
image.picture.bitmap.assign (fjpg);
(6) Access Wave ในไฟล์ทรัพยากร
เพิ่ม mmsystem ในหน่วยการใช้งาน
Playsound (pchar ('mywav'), hinstance, snd_asyncorsnd_memoryorsnd_resource);
(iv) การดำเนินการไฟล์ INI
(1) โครงสร้างของไฟล์ INI:
นี่คือส่วนความคิดเห็นเกี่ยวกับไฟล์ ini
[โหนด]
คำสำคัญ = ค่า
-
ไฟล์ INI อนุญาตให้มีหลายโหนดและแต่ละโหนดอนุญาตให้ใช้คำหลักหลายคำ ไฟล์ INI ค่าบูลีนที่แท้จริงจะแสดงโดย 1 และค่าบูลีนเท็จจะแสดงด้วย 0) ความคิดเห็นเริ่มต้นด้วยเครื่องหมายอัฒภาค ";"
(2) การทำงานของไฟล์ INI
1. เพิ่ม inifiles ลงในส่วนการใช้งานของอินเทอร์เฟซ
2. เพิ่มบรรทัดไปยังส่วนนิยามตัวแปร VAR: inifile: Tinifile;
3. เปิดไฟล์ ini: inifile: = tinifile.create ('tmp.ini');
4. อ่านค่าของคำหลัก:
A: = inifile.ReadString ('node', 'คำหลัก', ค่าเริ่มต้น);
b: = inifile.readinteger ('node', 'คำหลัก', ค่าเริ่มต้น); // ประเภทจำนวนเต็ม
c: = inifile.readbool ('node', 'คำหลัก', ค่าเริ่มต้น);
โดยที่ [ค่าเริ่มต้น] เป็นค่าเริ่มต้นที่ส่งคืนเมื่อไม่มีคำหลักในไฟล์ INI
5. เขียนไปยังไฟล์ ini:
inifile.writestring ('โหนด', 'คำหลัก', ตัวแปรหรือค่าสตริง);
inifile.writeInteger ('โหนด', 'คำหลัก', ค่าตัวแปรหรือจำนวนเต็ม);
inifile.writeBool ('โหนด', 'คำหลัก', ตัวแปรหรือจริงหรือเท็จ);
เมื่อโหนดของไฟล์ INI นี้ไม่มีอยู่คำสั่งข้างต้นจะสร้างไฟล์ INI โดยอัตโนมัติ
6. ลบคำหลัก:
inifile.deleteKey ('โหนด', 'คำหลัก'); // คำหลักลบลบ
inifile.eraseesection ('node'); // การลบโหนด
7. การทำงานของโหนด:
inifile.ReadSection ('โหนด', ตัวแปร tStrings); // ชื่อคำหลักทั้งหมดในส่วนที่ระบุสามารถอ่านลงในตัวแปรรายการสตริง;
inifile.ReadSections (ตัวแปร tStrings); // คุณสามารถอ่านชื่อส่วนย่อยทั้งหมดในไฟล์ INI ลงในตัวแปรรายการสตริง
inifile.ReadSectionValues ('โหนด', ตัวแปร tStrings); // ทุกบรรทัด (รวมถึงคำหลัก, =, ค่า) ในส่วนที่ระบุในไฟล์ INI สามารถอ่านลงในตัวแปรรายการสตริงได้
8. การเปิดตัว: inifile.distory; หรือ inifile.free;
(v) ความสัมพันธ์ของเอกสาร
ใช้
Registry, Shlobj;
// ตระหนักถึงการลงทะเบียนที่เกี่ยวข้อง
ProcedureTmyzip.regzzz;
วาจา
Reg: Tregistry;
เริ่ม
reg: = tregistry.create;
reg.rootkey: = hkey_classes_root;
reg.openkey ('. zzz' จริง);
reg.writestring ('', 'myzip');
reg.closekey;
reg.openkey ('myzip/shell/open/command', จริง);
// โปรแกรมปฏิบัติการที่ใช้ในการเปิดไฟล์. zzz
reg.writestring ('', '' '+application.exename+' ""%1 "');
reg.closekey;
reg.openkey ('myzip/defaulticon', จริง);
// โปรดไอคอนของโปรแกรมปฏิบัติการปัจจุบันเป็นไอคอนของไฟล์. zzz
reg.writestring ('', ''+application.exename+', 0');
Reg.Free;
// รีเฟรชทันที
shchangenotify (shcne_assocchanged, shcnf_idlist, nil, nil);
จบ;
2.3.
1. สร้างไฟล์ที่เข้ารหัสชั่วคราว INI
รูปแบบไฟล์ชั่วคราวสำหรับ INI สำหรับการเข้ารหัส:
[file1] // node, การเข้ารหัสแบบหลายไฟล์สามารถทำได้โดยใช้ file1..n ในซอฟต์แวร์
filename = ชื่อไฟล์บีบอัด
รหัสผ่าน = รหัสผ่านการบีบอัด
filesize = ขนาดไฟล์
Peledate = สร้างวันที่
ISJM = จำเป็นต้องคลายการบีบอัดหรือไม่?
หากคุณใช้การจัดเก็บข้อมูลหลายไฟล์และโฟลเดอร์คุณสามารถจัดเก็บคำหลักรหัสผ่านภายใต้โหนดทั้งหมด บทความนี้ใช้เฉพาะการเข้ารหัสของไฟล์เดียวดังนั้นตราบใดที่รูปแบบข้างต้นก็เพียงพอแล้ว
2. ผสานไฟล์ข้อมูลกับไฟล์ INI ที่ใช้สำหรับการเข้ารหัสซึ่งสามารถนำไปใช้ในรูปแบบของสตรีมไฟล์
ไดอะแกรมโครงสร้างไฟล์ที่เข้ารหัส:
รูป (1)
รูป (2)
สองรูปแบบข้างต้นสามารถใช้ตามเงื่อนไขจริง บทความนี้ใช้โครงสร้างของรูป (1)
3. สำหรับข้อมูลที่เข้ารหัสเทคโนโลยี ZLIB ใช้เพื่อรับรู้การจัดเก็บข้อมูลที่ถูกบีบอัดและสร้างไฟล์บีบอัดใหม่
2.4. ดู 2.2 (v) สำหรับการใช้งานการเชื่อมโยงไฟล์
2.5.
1. สร้างไฟล์โปรแกรมที่ใช้งานได้โดยเฉพาะจากการบีบอัด
2. สร้างไฟล์ทรัพยากรใน 1
3. ใส่ไฟล์ทรัพยากรลงในโปรแกรมของเครื่องมือการบีบอัดนี้ในบทความนี้และรวบรวมเข้าด้วยกัน
4. สร้างไฟล์การสกัดด้วยตนเองโดยการรวมไฟล์ทรัพยากรเข้ากับไฟล์ที่ถูกบีบอัด
ไดอะแกรมโครงสร้างไฟล์ที่สกัดด้วยตนเอง:
5. การใช้การประกาศด้วยตนเอง: โดยการย่อยสลายข้อมูลที่ถูกเข้ารหัสที่เข้ารหัสในไฟล์ของตัวเองจากนั้นจะบีบอัดข้อมูลที่ถูกบีบอัดที่เข้ารหัสที่สลายตัวอีกครั้งและย่อยสลายไฟล์ข้อมูลจริง
2.6 การเขียนโปรแกรมระบบ
นี่คือรหัสทั้งหมดของส่วนหลักของการใช้งานซอฟต์แวร์นี้และที่นี่เราจะอธิบายรายละเอียดทางเทคนิคทั้งหมดของซอฟต์แวร์นี้โดยละเอียด
//wnhoo_zzz.pas
Unitwnhoo_zzz;
ส่วนต่อประสาน
ใช้
Windows, รูปแบบ, sysutils, คลาส, zlib, รีจิสทรี, inifiles, กล่องโต้ตอบ, shlobj;
พิมพ์
pass = string [20];
พิมพ์
tmyzip = คลาส
ส่วนตัว
{privatedeclarationshere}
ได้รับการคุ้มครอง
{ProtectedDeclarationShere}
สาธารณะ
Procedureregzzz;
procedures_file (infilename, outfilename: String; รหัสผ่าน: pass; isjm: boolean; ysbz: จำนวนเต็ม);
functionjy_file (infilename: string; รหัสผ่าน: pass = ''): บูลีน;
procedurezjywj (varfilename: string);
ConstructorCreate;
Destructordestroy; แทนที่;
{PublicDeclarationShere}
ที่ตีพิมพ์
{PublishedDeclarationShere}
จบ;
การดำเนินการ
constructortmyzip.create;
เริ่ม
สืบทอด; // เริ่มต้นส่วนที่สืบทอดมา
จบ;
// ############################################################### ################################################################### ################################################################### ################################################################### ################################################################### ##### #####
// การเข้ารหัสไฟล์ต้นฉบับ
ProcedureJM_FILE (VFILE: String; VartArget: TMemoryStream; รหัสผ่าน: Pass; ISJM: บูลีน);
-
vfile: ไฟล์ที่เข้ารหัส
เป้าหมาย: สตรีมเป้าหมายเอาต์พุตหลังจากการเข้ารหัส 》》》》》
รหัสผ่าน: รหัสผ่าน
ISJM: มันเข้ารหัสหรือไม่?
------------------------------------------------------ ------------------------------------------------------ ------------------------ -----------------
ขนาดไฟล์ที่เข้ารหัส = ขนาดไฟล์ต้นฉบับ + [Ini Incrypted ข้อมูลบีบอัดไฟล์] ขนาด + ขนาดจัดเก็บขนาดข้อมูลขนาดของไฟล์ข้อมูลบีบอัดที่เข้ารหัส [INI ที่เข้ารหัส]]
------------------------------------------------------ ------------------------------------------------------ ------------------------ ----------------------------------------------------------------------------------------------------------------
-
วาจา
tmpstream, instream: tfilestream;
Filesize: จำนวนเต็ม;
inifile: Tinifile;
ชื่อไฟล์: สตริง;
เริ่ม
// การเปิดต้องการ [ไฟล์บีบอัดที่เข้ารหัส]
tmpStream: = tfilestream.create (vfile, fmopenreadorfmshareexclusive);
พยายาม
// เขียน [สตรีมไฟล์ต้นฉบับ] ไปยังจุดสิ้นสุดของ [สตรีมไฟล์บีบอัดที่เข้ารหัสชั่วคราว]
Target.Seek (0, Sofromend);
target.copyfrom (tmpstream, 0);
// รับพา ธ ไฟล์และสร้างไฟล์ข้อมูลบีบอัดที่เข้ารหัส [INI ที่เข้ารหัส]]
ชื่อไฟล์: = extractFilePath (paramstr (0))+'tmp.in_';
inifile: = tinifile.create (ชื่อไฟล์);
inifile.writestring ('file1', 'filename', extractfilename (vfile));
inifile.writestring ('file1', 'รหัสผ่าน', รหัสผ่าน);
inifile.writeInteger ('file1', 'filesize', target.size);
inifile.writedatetime ('file1', 'ยื่น', ตอนนี้ ());
inifile.writeBool ('file1', 'isjm', isjm);
infile.free;
// อ่านใน [สตรีมไฟล์ข้อมูลบีบอัดที่เข้ารหัส Ini ที่เข้ารหัส]
INSTREAM: = tfilestream.create (ชื่อไฟล์, fmopenreadorfmshareexclusive);
พยายาม
// ดำเนินการต่อเพื่อเพิ่ม [INI Encrypted INFOFALISE FILE] ในตอนท้ายของ [สตรีมไฟล์บีบอัดที่เข้ารหัสชั่วคราว]
INSTREAM.POSITION: = 0;
Target.Seek (0, Sofromend);
target.copyfrom (inistream, 0);
// คำนวณขนาดของไฟล์ข้อมูลบีบอัดที่เข้ารหัส [INI ที่เข้ารหัส Ini]
Filesize: = inistream.size;
// ดำเนินการต่อเพื่อเพิ่มข้อมูลขนาดของไฟล์ข้อมูลบีบอัด [INI ที่เข้ารหัส] ในตอนท้ายของ [ไฟล์เข้ารหัสชั่วคราว]
target.writeBuffer (filesize, sizeof (filesize));
ในที่สุด
stream.free;
DELETEFILE (ชื่อไฟล์);
จบ;
ในที่สุด
tmpstream.free;
จบ;
จบ;
// ***************************************************** ******************************************************** ******************************************************** ******************************************************** ******************************************************** ******************************************************** ******************************************************** *********************** *********************
// การบีบอัดการไหล
procedures_stream (stream, outstream: tstream; ysbz: จำนวนเต็ม);
-
INSTREAM: สตรีมไฟล์ที่เข้ารหัสจะถูกบีบอัด
สตรีมไฟล์เอาต์พุตการบีบอัดที่สูงกว่า
YSBZ: มาตรฐานการบีบอัด
-
วาจา
YS: TcompressionsTream;
เริ่ม
// ตัวชี้การไหลชี้ไปที่หัว
INSTREAM.POSITION: = 0;
// การเลือกมาตรฐานการบีบอัด
casebzof
1: ys: = tcompressionstream.create (clnone, outstream); // ไม่บีบอัด
2: ys: = tcompressionstream.create (clfastest, outstream); // การบีบอัดเร็ว
3: ys: = tcompressionstream.create (cldefault, outstream); // การบีบอัดมาตรฐาน
4: ys: = tcompressionstream.create (clmax, outstream); // การบีบอัดสูงสุด
อื่น
ys: = tcompressionsTream.create (Clfastest, Outstream);
จบ;
พยายาม
// สตรีมการบีบอัด
ys.copyfrom (instream, 0);
ในที่สุด
ys.free;
จบ;
จบ;
// ***************************************************** ******************************************************** ******************************************************** ******************************************************** ******************************************************** ******************************************************** ******************************************************** ************************* *******************************
// การบีบอัดการไหล
procedurejy_stream (โปรแกรม, Outstream: TStream);
-
INSTREAM: ไฟล์สตรีมบีบอัดดั้งเดิม
Outstream: คลายซิปไฟล์สตรีมมิ่ง
-
วาจา
jyl: tdecompressionstream;
BUF: Array [1..512] OFBYTE;
sjread: จำนวนเต็ม;
เริ่ม
INSTREAM.POSITION: = 0;
jyl: = tdecompressionStream.create (โปรแกรม);
พยายาม
ทำซ้ำ
// อ่านขนาดจริง
sjread: = jyl.read (buf, sizeof (buf));
ifsjread> 0 แล้ว
Outstream.write (buf, sjread);
จนกระทั่ง (sjread = 0);
ในที่สุด
jyl.free;
จบ;
จบ;
// ***************************************************** ******************************************************** ******************************************************** ******************************************************** ******************************************************** ******************************************************** ******************************************************** *********************** *********************
// ตระหนักถึงการลงทะเบียนที่เกี่ยวข้อง
ProcedureTmyzip.regzzz;
วาจา
Reg: Tregistry;
เริ่ม
reg: = tregistry.create;
reg.rootkey: = hkey_classes_root;
reg.openkey ('. zzz' จริง);
reg.writestring ('', 'myzip');
reg.closekey;
reg.openkey ('myzip/shell/open/command', จริง);
// โปรแกรมปฏิบัติการที่ใช้ในการเปิดไฟล์. zzz
reg.writestring ('', '' '+application.exename+' ""%1 "');
reg.closekey;
reg.openkey ('myzip/defaulticon', จริง);
// โปรดไอคอนของโปรแกรมปฏิบัติการปัจจุบันเป็นไอคอนของไฟล์. zzz
reg.writestring ('', ''+application.exename+', 0');
Reg.Free;
// รีเฟรชทันที
shchangenotify (shcne_assocchanged, shcnf_idlist, nil, nil);
จบ;
// บีบอัดไฟล์
ProcedureTmyzip.ys_file (infilename, outfilename: String; รหัสผ่าน: pass; isjm: boolean; ysbz: จำนวนเต็ม);
-
Infilename: // ไฟล์ที่เข้ารหัสจะต้องถูกบีบอัด
outfilename: // บีบอัดไฟล์ที่สร้างขึ้นหลังจากการเข้ารหัส
รหัสผ่าน: // UNIMPLENT PASTROND
YSBZ: // มาตรฐานการบีบอัด
-
วาจา
Instream: tmemorystream; // สตรีมชั่วคราวหลังจากการเข้ารหัสไฟล์
Outstream: tfilestream; // การบีบอัดไฟล์ส่งออกไฟล์เอาท์พุท
เริ่ม
// สร้าง [สตรีมชั่วคราวหลังการเข้ารหัสไฟล์]
เครื่องมือ: = tmemorystream.create;
// การเข้ารหัสไฟล์
JM_FILE (Infilename, Instream, Password, ISJM);
// สร้างสตรีมไฟล์เอาต์พุตที่บีบอัด
Outstream: = tfilestream.create (outfilename, fmcreate);
พยายาม
// [สตรีมชั่วคราวหลังการเข้ารหัสไฟล์] การบีบอัด
ys_stream (stream, outstream, ysbz);
ในที่สุด
Outstream.free;
Enterstream.free;
จบ;
จบ;
// บีบอัดไฟล์
functiontmyzip.jy_file (infilename: string; รหัสผ่าน: pass = ''): บูลีน;
วาจา
Instram, Instram, FileStream_ok: tfilestream;
-
stream: // ชื่อไฟล์ unzip
stream: // ini สตรีมไฟล์ชั่วคราว
filestream_ok: // คลายซิปไฟล์ตกลง
-
Outstream: tmemorystream; // สตรีมหน่วยความจำชั่วคราว
inifile: tinifile; // ไฟล์ ini ชั่วคราว
Filesize: จำนวนเต็ม; // ขนาดของไฟล์รหัสผ่าน
ResultValue: บูลีน; // ค่าส่งคืน
เริ่ม
พยายาม
โปรแกรม: = tfilestream.create (infilename, fmopenread);
พยายาม
Outstream: = tmemorystream.create;
พยายาม
jy_stream (stream, outstream);
// สร้างไฟล์ INI ชั่วคราว
INSTREAM: = tfilestream.create (ExtractFilePath (Paramstr (0))+'tmp.in _', fmcreate);
พยายาม
// ชี้ไปที่ตำแหน่งตัวแปรประเภทจำนวนเต็มที่เก็บข้อมูลที่ถอดรหัสไว้
Outstream.seek (-sizeof (filesize), sofromend);
// อ่านในข้อมูลตัวแปร
Outstream.readBuffer (Filesize, sizeof (filesize));
// ชี้ไปที่ตำแหน่งข้อมูลที่ถอดรหัส
Outstream.seek (-(Filesize+sizeof (filesize)), sofromend);
// อ่านข้อมูลที่ถอดรหัสลงในกระแส INI
Instream.CopyFrom (Outstream, Filesize);
// release stream ไฟล์ ini
stream.free;
// อ่านข้อมูลไฟล์ INI
inifile: = tinifile.create (ExtractFilePath (paramstr (0))+'tmp.in_');
ResultValue: = inifile.readbool ('file1', 'isjm', false);
Ifresultvaluethen
เริ่ม
ifinifile.readString ('file1', 'รหัสผ่าน', '') = trim (รหัสผ่าน) จากนั้น
ResultValue: = true
อื่น
ResultValue: = FALSE;
จบ
อื่น
ResultValue: = true;
Ifresultvaluethen
เริ่ม
filestream_ok: = tfilestream.create (ExtractFilePath (paramstr (1))+inifile.readString ('file1', 'ชื่อไฟล์', 'wnhoo.zzz'), fmcreate);
พยายาม
Outstream.position: = 0;
filestream_ok.copyfrom (Outstream, inifile.readinteger ('file1', 'filesize', 0));
ในที่สุด
filestream_ok.free;
จบ;
จบ;
infile.free;
ในที่สุด
// ลบไฟล์ INI ชั่วคราว
DELETEFILE (ExtractFilePath (Paramstr (0))+'tmp.in_');
จบ;
-
ในที่สุด
Outstream.free;
จบ;
ในที่สุด
stream.free;
จบ;
ยกเว้น
ResultValue: = FALSE;
จบ;
ผลลัพธ์: = resultValue;
จบ;
// การสร้างการสกัดด้วยตนเอง
ProcedureetMyzip.zjywj (varfilename: String);
วาจา
myres: trsourcestream; // จัดเก็บไฟล์ exe ที่สกัดด้วยตนเองชั่วคราว
myFile: tfilestream; // สตรีมไฟล์ต้นฉบับ
xfilename: string; // ชื่อไฟล์ชั่วคราว
file_ok: tmemorystream; // สตรีมหน่วยความจำของไฟล์ที่สร้างขึ้น
Filesize: Integer; // ขนาดไฟล์ต้นฉบับ
เริ่ม
IFFileExists (ชื่อไฟล์) จากนั้น
เริ่ม
// สร้างสตรีมหน่วยความจำ
file_ok: = tmemorystream.create;
// เปิดตัวไฟล์ทรัพยากร-extract the exe ไฟล์
myres: = tresourcestream.create (hinstance, 'myzjy', pchar ('exefile'));
// อ่านไฟล์ต้นฉบับลงในหน่วยความจำ
myFile: = tfilestream.create (ชื่อไฟล์, fmopenread);
พยายาม
myres.position: = 0;
file_ok.copyfrom (myres, 0);
file_ok.seek (0, sofromend);
myfile.position: = 0;
file_ok.copyfrom (myfile, 0);
file_ok.seek (0, sofromend);
Filesize: = myfile.size;
file_ok.writeBuffer (filesize, sizeof (filesize));
file_ok.position: = 0;
xfilename: = changefileext (ชื่อไฟล์, '. exe');
file_ok.savetofile (xfilename);
ในที่สุด
myfile.free;
myres.free;
file_ok.free;
จบ;
DELETEFILE (ชื่อไฟล์);
ชื่อไฟล์: = xfilename;
จบ;
จบ;
// ############################################################### ################################################################### ################################################################### ################################################################### ################################################################### ##### #####
Destructortmyzip.destroy;
เริ่ม
มรดก
จบ;
จบ.
3. บทสรุป
สภาพแวดล้อมการเขียนโปรแกรมภาพใหม่ของ Delphi ช่วยให้เรามีเครื่องมือพัฒนาแอปพลิเคชัน Windows ที่สะดวกและรวดเร็ว สำหรับนักพัฒนาโปรแกรมการใช้ Delphi เพื่อพัฒนาซอฟต์แวร์แอปพลิเคชันจะปรับปรุงประสิทธิภาพการเขียนโปรแกรมอย่างมากอย่างไม่ต้องสงสัย ใน Delphi คุณสามารถใช้สตรีมเพื่อใช้แบบฟอร์มข้อมูลต่าง ๆ เช่นการประมวลผลไฟล์การประมวลผลหน่วยความจำแบบไดนามิกการประมวลผลข้อมูลเครือข่าย ฯลฯ และโปรแกรมการเขียนจะปรับปรุงประสิทธิภาพอย่างมาก
ข้อมูลอ้างอิง:
1. ความช่วยเหลือระบบ Delphi
2. Feng Zhiqiang
3. Chen Jingtao