Use Delphi para implementar el cifrado y la compresión de archivos
Autor: E Mengyuan (Wnhoo)
Correo: [email protected]
Amor y amor
Haga clic para descargar este archivo de descripción detallada
Descripción general:
En este documento, hablaremos sobre la implementación del cifrado de datos, la compresión de datos y la autodecompresión de un solo archivo. Del mismo modo, la compresión de múltiples archivos o carpetas se puede lograr con una ligera modificación.
Palabras clave: compresión cifrada, ZLIB, transmisión, archivos de recursos
introducción:
En la vida diaria, debemos haber utilizado software de compresión famoso como Winzip y Winrar, lo que significa que inevitablemente encontraremos problemas, como el cifrado de datos y la compresión de datos durante el proceso de desarrollo de software. Este artículo analiza este problema técnico, y también gracias a todos los internautas por sus habilidades. Este artículo utiliza principalmente las poderosas habilidades de procesamiento de flujo de Delph para lograr el cifrado y la compresión de datos, y se utiliza en el desarrollo de programas de software real.
1. Funciones del sistema
1) Compresión de datos
Use dos clases de flujo proporcionadas por Delphi (TCompressionStream y TDecompressionStream) para completar la compresión y la descompresión de los datos.
2) Cifrado de datos y compresión
El cifrado de datos se realiza a través de la aplicación de "transmisión" en la programación de Delphi, principalmente utilizando tfilStram y tmemoryStream, dos clases derivadas de tstream;
3) Haga doble clic en el archivo comprimido para asociar y descomprimir automáticamente
Al cambiar la asociación de la extensión del registro con los archivos de programa, el Tregumiso se usa principalmente;
4) puede generar archivos autoextrantes
El archivo autodecomprimido realiza la descompresión automática de la compresión de datos 1) y la compresión de cifrado de datos 2); Se logra la autodecompresión de los datos.
2. Implementación del sistema
2.1.
2.2.
(I) Zlib
1) Clase base TCustomzlibStream: es la clase base de las clases de TCompressionStream y TDecompressionStream.
Formato: procedimientoEnProgress (remitente: tobject); Dynamic;
2) Clase de compresión TCompressionStream: además de heredar la propiedad OnProgress de la clase base, se agrega otro atributo: CompressionRate, que se define de la siguiente manera:
PropertyCompressionRate: SinglerAdgetCompressionRate;
A través de esta propiedad, se puede obtener la relación de compresión.
Varios métodos importantes se definen de la siguiente manera:
ConstructortCompressionStream.create (CompressionLevel: tCompressionLevel; des: tstream);
Entre ellos: TCompressionLevel (tipo de compresión), se define por lo siguiente:
1) Clnone: no se realiza compresión de datos;
2) Clastest: realiza una compresión rápida, sacrificando la eficiencia de compresión;
3) ClDefault: realizar compresión normal;
4) CLMAX: maximice la velocidad de compresión y sacrificio;
Dest: flujo de destino, utilizado para almacenar datos comprimidos.
FunctionTCompressionStream.write (constbuffer; Count: longint): longInt;
Entre ellos: Buffer: datos que deben comprimirse;
Cuento: el número de bytes de datos a comprimirse;
La función devuelve el número de bytes escritos a la transmisión.
Nota: Los datos de la clase comprimida TCompressionStream solo se pueden escribir. Los datos que deben comprimirse se escriben en la secuencia a través del método de escritura del método, y se comprime durante el proceso de escritura, y se guarda en la secuencia de memoria (TMemoryStream) proporcionada por el constructor, y el evento OnProcess se activa.
3) La clase de descompresión TDecompressionStream: en contraste con la clase comprimida TCompressionStream, sus datos solo se pueden leer.
Sus varios métodos importantes se definen de la siguiente manera:
ConstructorCreate (fuente: tstream);
Entre ellos: la fuente es un flujo que almacena datos comprimidos;
FunctionRead (varbuffer; count: longint): longInt;
Función de lectura de datos, búfer: almacenamiento de datos;
La función devuelve el número de bytes de lectura. Durante el proceso de lectura, los datos se descomprimen y se activa el evento OnProcess.
(Ii)
En Delphi, la clase base de todos los objetos de transmisión es la clase tstream, que define propiedades y métodos comunes de todas las transmisiones.
Las propiedades definidas en la clase tstream son las siguientes:
1), Tamaño: esta propiedad devuelve el tamaño de los datos en la secuencia en bytes.
2) Posición: esta propiedad controla la posición de acceder a punteros en el flujo.
Hay cuatro métodos virtuales definidos en tstream:
1) Lea: Este método implementa datos de lectura de la transmisión, y el valor de retorno es el número real de bytes que leen, que puede ser menor o igual al valor especificado.
2) Escribir: Este método implementa la escritura de datos en la transmisión, y el valor de retorno es el número de bytes realmente escritos en la transmisión.
3) Busque: Este método se da cuenta del movimiento del puntero de lectura en la transmisión, y el valor de retorno es la posición del puntero después del movimiento.
El prototipo de funciones es: functionseek (offset: longInt; orurint: word): longInt; virtual; abstract;
El desplazamiento de parámetros es el número de bytes de compensación.
Sofrombeginning: Offset es el datos de distancia del puntero. En este momento, el desplazamiento debe ser mayor o igual a cero.
Sofromcurrent: Offset es la posición relativa del puntero y el puntero actual después de moverse.
Sofromend: Offset es la posición donde termina los datos de distancia del puntero después de moverse. En este momento, el desplazamiento debe ser menor o igual a cero.
4) SetSize: este método se da cuenta de cambiar el tamaño de los datos.
Además, se definen varios métodos estáticos en la clase TStream:
1) ReadBuffer: la función de este método es leer datos de la posición actual en la transmisión, lo mismo que la lectura anterior.
Nota: Cuando el número de bytes leídos es diferente del número de bytes a leer, se generará una excepción de EreadError.
2) WriteBuffer: la función de este método es escribir datos en la transmisión en la ubicación actual, lo mismo que la escritura anterior.
Nota: Cuando el número de bytes escritos en datos es diferente del número de bytes a escribir, se generará una excepción de EWriteRor.
3) Copiar desde: la función de este método es copiar flujos de datos de otras secuencias.
El prototipo de funciones es: functCopyFrom (fuente: tstream; cuenta: longint): longInt;
La fuente de parámetros es la secuencia que proporciona datos, y el recuento es el número de bytes de datos copiados. Cuando el recuento es mayor que 0, Copias de copias de los datos de la posición actual del parámetro de origen;
Clases comúnmente derivadas de tstream:
TFILEnstream (Acceso a las transmisiones de archivo)
TStringStream (procesa datos de tipo de cadena en la memoria)
TMemoryStream (para el procesamiento de datos del área de memoria de trabajo)
TBLOBStream (procesamiento de datos de campos de tipo blob)
TwinSocketstream (lea y escriba procesamiento de socket)
Tolestream (Procesamiento de datos de la interfaz COM)
TresourCstream (procesamiento de secuencias de archivos de recursos)
El más comúnmente utilizado es la clase tfilestream. Para acceder a archivos utilizando la clase TFILEntream, primero debe crear una instancia. La declaración es la siguiente:
constructorCreate (constfileName: string; mode: word);
El nombre de archivo es el nombre del archivo (incluida la ruta)
El modo es la forma de abrir un archivo.
Modo abierto:
FMCreate: cree un archivo con el nombre del archivo especificado y ábralo si el archivo ya existe.
fMopenRead: abra el archivo especificado en solo lectura
fMopenWrite: abra el archivo especificado de manera solo de escritura
fMopenreadWrite: abra el archivo especificado en modo de escritura
Modo de intercambio:
fmsharecompat: el modo compartido es compatible con FCBS
fmshareExClusive: ningún otro programa puede abrir el archivo de ninguna manera
fmsharedenywrite: ningún otro programa puede abrir el archivo por escrito
fmsharedenyread: ningún otro programa puede abrir el archivo en modo de lectura
fmsharedenynone: otros programas pueden abrir el archivo de cualquier manera
(Iii) archivo de recursos
1) Crear archivos de recursos
Primero cree un archivo de texto sin formato de .rc.
Formato: identificador de recursos Nombre del archivo de recursos
Identificador de recursos: una etiqueta especial al llamar a un recurso en el programa;
Palabras clave: identificar el tipo de archivo de recursos;
Wave: el archivo de recursos es un archivo de sonido;
RcData: archivo jpeg;
AVI: Avi Animation;
Icono: archivo icon;
Mapa de bits: archivo de mapas de bits;
Cursor: archivo cursor;
Exefile: archivo exe
Nombre del archivo de recursos: el nombre completo del archivo almacenado en el disco del archivo de recursos
Por ejemplo:
myzjyexefilezjy.exe
2) compilar archivos de recursos
Debajo /bin del directorio de instalación de Delphi, use BRCC32.exe para compilar el archivo de recursos.rc. Por supuesto, también puede copiar BRCC32 en el directorio de documentos del programa por separado para su uso.
Por ejemplo:
Brcc32wnhoo_reg.rc
3) Referencia de archivo de recursos
…
Implementación
{$ R*.dfm}
{$ Rwnhoo_reg.res}
…
4) Llame a archivos de recursos
(1) Acceda al mapa de bits en el archivo de recursos (mapa de bits)
Image.picture.bitmap.handle: = loadBitMap (hinstance, 'identificador de recursos');
Nota: Si el mapa de bits no se carga correctamente, el programa aún se ejecutará, pero la imagen ya no se mostrará. Puede juzgar si la carga es exitosa en función del valor de retorno de la función LoadBitMap.
Otro método para acceder y mostrar mapa de bits es el siguiente
Image.picture.bitmap.loadFromResourCeName (Hinstance, 'Identificador de recursos');
(2) Acceda al cursor en el archivo de recursos
Screen.cursors [] es una matriz de cursor. Debido a que el valor predeterminado del índice del cursor en la matriz es 0, es mejor establecer el valor de índice de cursor personalizado en 1 a menos que desee reemplazar el cursor predeterminado.
Screen.cursors [1]: = LoadCursor (HinStance, 'Identificador de recursos');
Image.cursor: = 1;
(3) Acceda a iconos en archivos de recursos
Poner el icono en el archivo de recursos le permite cambiar dinámicamente el icono de la aplicación.
Application.icon.handle: = loadiCon (hinstance, 'identificador de recursos');
(4) Acceda al AVI en el archivo de recursos
Animate.resname: = 'myavi'; // número de identificador de recursos
Animate.active: = true;
(5) Acceda a JPEG en el archivo de recursos
Agregue la unidad JPEG a la unidad de uso.
varilla
Fjpg: tjpegimage;
Fstream: Tresourcstream;
Comenzar
Fjpg: = tjpegimage.create;
// Uso de TresourCestream
Fstream: = TresourCestream.Create (Hinstance, 'Identificador de recursos', tipo de recurso);
Fjpg.loadFromStream (fstream);
Image.picture.bitmap.assign (fjpg);
(6) Acceso a la onda en el archivo de recursos
Agregar mmsystem a la unidad usos
PlaySound (pChar ('mywav'), hinstance, snd_asyncorsnd_memoryorsnd_resource);
(Iv) Operación de archivo INI
(1) Estructura del archivo INI:
; Esta es la sección de comentarios sobre el archivo ini
[nodo]
Palabra clave = valor
...
El archivo INI permite múltiples nodos, y cada nodo permite múltiples palabras clave. El archivo ini, el verdadero valor booleano está representado por 1, y el valor booleano falso está representado por 0). Los comentarios comienzan con un punto y coma ";".
(2) Operación del archivo INI
1. Agregue Inifiles a la sección Usos de la interfaz;
2. Agregue una línea a la Parte de definición de variable VAR: Inifile: Tinifile;
3. Abra el archivo INI: Inifile: = tinifile.create ('tmp.ini');
4. Lea el valor de la palabra clave:
A: = IniFile.ReadString ('nodo', 'Palabra clave', valor predeterminado);
b: = iniFile.readInteger ('nodo', 'palabra clave', valor predeterminado); // tipo entero
c: = iniFile.readBool ('nodo', 'palabra clave', valor predeterminado);
Donde [predeterminado] es el valor predeterminado devuelto cuando la palabra clave no existe en el archivo ini.
5. Escribe en el archivo INI:
IniFile.WriteString ('nodo', 'Palabra clave', Variable o Valor de cadena);
iniFile.writeInteger ('nodo', 'palabra clave', valor variable o entero);
iniFile.writebool ('nodo', 'palabra clave', variable o verdadera o falsa);
Cuando el nodo de este archivo INI no existe, la instrucción anterior también creará automáticamente el archivo INI.
6. Eliminar palabras clave:
iniFile.deletekey ('nodo', 'palabra clave'); // Keyword Eliminar
iniFile.erassection ('nodo'); // eliminación de nodo
7. Operación de nodo:
INiFile.ReadSection ('nodo', tstrings variable); // Todos los nombres de palabras clave en la sección especificada se pueden leer en una variable de lista de cadenas;
INiFile.ReadSections (tstrings variable); // Puede leer todos los nombres de la subsección en el archivo INI en una variable de lista de cadenas.
INiFile.ReadSectionValues ('nodo', tstrings variable); // Todas las líneas (incluidas las palabras clave, =, valores) en la sección especificada en el archivo INI se pueden leer en una variable de lista de cadenas.
8. Liberación: Inifile.Distory;
(V) Relación de documento
usos
Registro, Shlobj;
// Realice el registro relacionado
proceduretmyzip.regzzz;
varilla
REG: Tregistry;
Comenzar
reg: = tregumistry.create;
reg.rootkey: = hkey_classes_root;
reg.openkey ('. zzz', verdadero);
reg.writeString ('', 'myzip');
Reg.CloseKey;
reg.openkey ('myzip/shell/open/command', true);
// programa ejecutable utilizado para abrir archivos .zzz
reg.writeString ('', '"'+Application.exename+'" "%1" ");
Reg.CloseKey;
reg.openkey ('myzip/defaultiCon', true);
// Por favor, el icono del programa ejecutable actual como el icono del archivo .zzz
Reg.WriteString ('', ''+Application.exename+', 0');
Reg. Desde;
// Actualizar ahora
Shchangenotify (shcne_assocchanged, shcnf_idlist, nil, nil);
fin;
2.3.
1. Generar un archivo cifrado temporal ini
Formato de archivo temporal para INI para el cifrado:
[File1] // nodo, el cifrado de múltiples archivos se puede lograr usando File1..N en software
Nombre de archivo = nombre de archivo comprimido
Contraseña = descompresión contraseña
Silsize = tamaño de archivo
Artilate = Crear fecha
ISJM = ¿Es necesario descomprimir?
Si implementa el almacenamiento de información de múltiples archivos y carpetas, puede almacenar la palabra clave de contraseña en un nodo total. Este artículo solo implementa el cifrado de un solo archivo, por lo que siempre que el formato anterior sea suficiente.
2. Fusionar el archivo de datos con el archivo INI utilizado para el cifrado, que se puede implementar en forma de una transmisión de archivo.
Diagrama de estructura de archivo cifrado:
Figura (1)
Figura (2)
Las dos formas anteriores se pueden usar de acuerdo con las condiciones reales. Este artículo adopta la estructura de la figura (1).
3. Para los datos cifrados, la tecnología ZLIB se utiliza para realizar el almacenamiento comprimido y generar nuevos archivos comprimidos.
2.4. Ver 2.2 (v) para la implementación de asociaciones de archivos
2.5.
1. Cree un archivo de programa ejecutable específicamente desde la descompresión
2. Crear archivos de recursos en 1
3. Coloque el archivo de recursos en el programa de esta herramienta de compresión en este artículo y compile él juntos.
4. Genere un archivo autoextrante fusionando el archivo de recursos con el archivo comprimido.
Diagrama de estructura de archivo autoextrante:
5. Implementación de autodecompresión: descomponiendo los datos comprimidos encriptados en su propio archivo, luego descomprimiendo los datos comprimidos encriptados descompuestos nuevamente y descomponiendo el archivo de datos real.
2.6 Programación del sistema
Este es todo el código de la parte central de esta implementación de software, y aquí explicaremos todos los detalles técnicos de este software en detalle.
//wnhoo_zzz.pas
unitwnhoo_zzz;
interfaz
usos
Windows, formularios, sysutils, clases, zlib, registro, infiles, diálogos, shlobj;
tipo
pase = string [20];
tipo
Tmyzip = clase
Privado
{PrivatedClarationShere}
protegido
{ProtectedDeclarationShere}
público
procedimientoReGzzz;
procedimientos_file (infileName, outfileName: string; contraseña: pass; isjm: boolean; ysbz: integer);
functionJy_file (infileName: string; contraseña: pass = ''): boolean;
procedimientoZjyWJ (varfileName: string);
constructorCreate;
Destructordestroy; anular;
{publicDeclarationShere}
publicado
{Publicado DeclarationShere}
fin;
Implementación
constructortmyzip.create;
Comenzar
HerededCreate; // Inicializa la parte hereditaria
fin;
// ############################################ ############################################## ######################### #####
// cifrado de archivo original
procedimientojm_file (vfile: string; vartarget: tMemoryStream; contraseña: pass; isjm: boolean);
{
VFILE: archivo cifrado
objetivo: flujo de destino de salida después del cifrado 》》》》》
Contraseña: contraseña
ISJM: ¿Está encriptado?
-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ------ -----------------
Tamaño de archivo cifrado = tamaño de archivo original + [archivo de información comprimida cifrada INI] tamaño + tamaño almacenamiento del tipo de datos de tamaño de [archivo de información comprimida cifrada ini]
-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ------ ----------------------
}
varilla
tmpStream, InSEAM: tfilErtream;
Filesize: integer;
IniFile: Tinifile;
nombre de archivo: cadena;
Comenzar
// La apertura requiere [archivo comprimido cifrado]
tmpStream: = tfilEntream.create (vfile, fMopenReadorfmshareExClusive);
intentar
// Escribir [transmisión de archivo original] hasta el final de [transmisión de archivo comprimido cifrado temporal]
Target.seek (0, softomendio);
Target.CopyFrom (tmpStream, 0);
// Obtener la ruta del archivo y generar [archivo de información comprimido cifrado INI]
FileName: = ExtractFilePath (paramstr (0))+'tmp.in_';
INFILE: = TINIFILE.CREATE (nombre de archivo);
iniFile.writeString ('file1', 'nombre de archivo', extractFileName (vfile));
iniFile.writeString ('file1', 'contraseña', contraseña);
iniFile.WriteInteger ('file1', 'filesize', target.size);
iniFile.WritedateTime ('file1', 'fileedate', ahora ());
iniFile.writebool ('file1', 'isjm', isjm);
IniFile.Free;
// Leer en [flujo de archivo de información comprimido en cifrado INI]
InSteam: = tfilErtream.create (nombre de archivo, fMopenReadorfmshareExClusive);
intentar
// Continuar agregando [Archivo de información comprimido cifrado INI] al final de [transmisión de archivos comprimido cifrado temporal]
Instance.Position: = 0;
Target.seek (0, softomendio);
Target.CopyFrom (inistream, 0);
// Calcule el tamaño de la corriente [archivo de información comprimido cifrado INI]
Filesize: = inistream.size;
// Continuar agregando la información de tamaño de [archivo de información comprimido cifrado INI] al final de [archivo cifrado temporal]
Target.Writebuffer (filesize, sizeof (filesize));
Finalmente
Insteam.Free;
DeleteFile (nombre de archivo);
fin;
Finalmente
tmpStream.free;
fin;
fin;
// ****************************************************** ************************************************************ ************************************************************ ************************************************************ ************************************************************ ************************************************************ ************************************************************ ***************************** ******************
// compresión de flujo
procedimientos_stream (InSteam, Outstream: tstream; ysbz: integer);
{
INSTAÑO: transmisión de archivo cifrado a comprimirse
Transmisión de archivo de salida de compresión fuera del mar
YSBZ: estándar de compresión
}
varilla
YS: TCompressionStream;
Comenzar
// El puntero de flujo apunta a la cabeza
Instance.Position: = 0;
// Selección de estándares de compresión
casosbzof
1: ys: = tcompressionStream.create (clnone, outstream); // no comprimido
2: ys: = tcompressionStream.Create (ClFastest, Outstream); // Compresión rápida
3: YS: = tCompressionStream.Create (clDefault, Outstream); // Compresión estándar
4: ys: = tcompressionStream.create (clmax, outstream); // compresión máxima
demás
ys: = tcompressionStream.create (ClFastest, Outstream);
fin;
intentar
// flujo de compresión
Ys.CopyFrom (InSteam, 0);
Finalmente
Ys.Free;
fin;
fin;
// ****************************************************** ************************************************************ ************************************************************ ************************************************************ ************************************************************ ************************************************************ ************************************************************ ***************************** ************************
// flujo de descompresión
procedimientojy_stream (InSteam, Outstream: tstream);
{
INSTAÑO: archivo de transmisión comprimido original
Outstream: descomprima el archivo de transmisión
}
varilla
Jyl: TDecompressionStream;
BUF: Array [1..512] OfByte;
sjread: entero;
Comenzar
Instance.Position: = 0;
jyl: = tDecompressionStream.create (InstaLe);
intentar
repetir
// Lee el tamaño real
sjread: = jyl.read (buf, sizeof (buf));
ifsjread> 0then
Outstream.write (buf, sjread);
hasta que (sjRead = 0);
Finalmente
Jyl.Free;
fin;
fin;
// ****************************************************** ************************************************************ ************************************************************ ************************************************************ ************************************************************ ************************************************************ ************************************************************ ***************************** ******************
// Realice el registro relacionado
proceduretmyzip.regzzz;
varilla
REG: Tregistry;
Comenzar
reg: = tregumistry.create;
reg.rootkey: = hkey_classes_root;
reg.openkey ('. zzz', verdadero);
reg.writeString ('', 'myzip');
Reg.CloseKey;
reg.openkey ('myzip/shell/open/command', true);
// programa ejecutable utilizado para abrir archivos .zzz
reg.writeString ('', '"'+Application.exename+'" "%1" ");
Reg.CloseKey;
reg.openkey ('myzip/defaultiCon', true);
// Por favor, el icono del programa ejecutable actual como el icono del archivo .zzz
Reg.WriteString ('', ''+Application.exename+', 0');
Reg. Desde;
// Actualizar ahora
Shchangenotify (shcne_assocchanged, shcnf_idlist, nil, nil);
fin;
// Comprimir archivos
procedimientoTmyzip.ys_file (infileName, outfileName: string; contraseña: pass; isjm: boolean; ysbz: entero);
{
InfileName: // Los archivos encriptados deben comprimirse
outFileName: // Comprimir el archivo generado después del cifrado
contraseña: // sin compresión contraseña
YSBZ: // Estándar de compresión
}
varilla
INSTEAM: TMemoryStream; // transmisión temporal después del cifrado de archivo
Outstream: tfilEsTream; // Compress de salida de archivo de la transmisión
Comenzar
// Crear [Cifrado de archivo temporal después de un archivo]
InSteam: = TMemoryStream.Create;
// Cifrado de archivo
JM_FILE (infileName, InSteam, Password, ISJM);
// Crear una transmisión de archivo de salida comprimida
Outstream: = tfilErtream.create (outFileName, fmCreate);
intentar
// [Cifrado de archivo temporal después del archivo] Compresión
YS_Stream (InSteam, Outstream, YSBZ);
Finalmente
Outstream.free;
enterStream.free;
fin;
fin;
// descomprime el archivo
functionTmyzip.jy_file (infileName: string; contraseña: pass = ''): boolean;
varilla
InSEAM, INSTEAM, FILESTREAM_OK: TFILRESTREAM;
{
Intileam: // nombre de archivo descifrado
sydeam: // flujo de archivo temporal ini
filreSteam_ok: // descifrado el archivo OK
}
Outstream: tmemorystream; // flujo de memoria temporal
IniFile: tinifile; // archivo ini temporal
Filesize: entero; // tamaño del archivo de contraseña
ResultValue: boolean; // Valor de retorno
Comenzar
intentar
InSteam: = tfilErtream.create (infileName, fMopenRead);
intentar
Outstream: = tMemoryStream.Create;
intentar
jy_stream (InSteam, Outstream);
// Generar archivo ini temporal
INSTEAM: = TFILSTREAM.CREATE (ExtractFilePath (paramstr (0))+'tmp.in _', fmCreate);
intentar
// señala la posición variable de tipo entero que almacena la información decodificada
Outstream.seek (-sizeOf (filesize), sofromend);
// Leer en información variable
Outstream.readbuffer (filesize, sizeof (filesize));
// señala la ubicación de información decodificada
Outstream.seek (-(filesize+sizeof (filesize)), sofromend);
// Lea la información decodificada en la transmisión INI
Intileam.CopyFrom (Outstream, filesize);
// Relase INI File Stream
Insteam.Free;
// Lea la información del archivo INI
INiFile: = tinifile.create (ExtractFilePath (paramstr (0))+'tmp.in_');
ResultValue: = IniFile.ReadBool ('file1', 'isjm', falso);
ifresultvaluethen
Comenzar
ifinifile.ReadString ('file1', 'contraseña', '') = trim (contraseña) entonces
ResultValue: = verdadero
demás
ResultValue: = false;
fin
demás
ResultValue: = True;
ifresultvaluethen
Comenzar
fileSteam_ok: = tfilEntream.Create (ExtractFilePath (paramstr (1))+INiFile.ReadString ('file1', 'FileName', 'wnhoo.zzz'), fmCreate);
intentar
Outstream.Position: = 0;
FileStream_ok.CopyFrom (Outstream, Inifile.ReadInteger ('file1', 'filesize', 0));
Finalmente
FileStream_ok.Free;
fin;
fin;
IniFile.Free;
Finalmente
// eliminar el archivo ini temporal
deletefile (ExtractFilePath (paramstr (0))+'tmp.in_');
fin;
//
Finalmente
Outstream.free;
fin;
Finalmente
Insteam.Free;
fin;
excepto
ResultValue: = false;
fin;
resultado: = ResultValue;
fin;
// Creación de autoextracto
procedimientoTmyzip.zjywj (varfileName: string);
varilla
Myres: TrsourCressam; // almacena temporalmente el archivo exe autoextrante
myFile: tfilErteam; // transmisión de archivo original
xfilename: string; // nombre de archivo temporal
file_ok: tmemorystream; // La secuencia de memoria del archivo generado
filesize: integer; // tamaño de archivo original
Comenzar
iffileExists (nombre de archivo) entonces
Comenzar
// Crear transmisión de memoria
file_ok: = tMemoryStream.Create;
// Release el archivo de recursos-Self-Exact el archivo exe
Myres: = TresourCestream.Create (Hinstance, 'myzjy', pchar ('exefile'));
// Lea el archivo original en la memoria
myFile: = tfilErteam.create (nombre de archivo, fMopenRead);
intentar
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 (FileName, '. Exe');
file_ok.savetofile (xfileName);
Finalmente
myFile.Free;
Myres.
file_ok.free;
fin;
DeleteFile (nombre de archivo);
nombre de archivo: = xfileName;
fin;
fin;
// ############################################ ############################################## ######################### #####
destructortmyzip.destroy;
Comenzar
Destrodo heredado;
fin;
fin.
3. Conclusión
El nuevo entorno de programación visual de Delphi nos proporciona una herramienta de desarrollo de aplicaciones de Windows conveniente y rápida. Para los desarrolladores de programas, el uso de Delphi para desarrollar el software de aplicación, sin duda, mejorará en gran medida la eficiencia de la programación. En Delphi, puede usar fácilmente flujos para implementar varios formularios de datos, como procesamiento de archivos, procesamiento de memoria dinámica, procesamiento de datos de red, etc., y los programas de escritura mejorarán en gran medida la eficiencia.
Referencias:
1. Ayuda del sistema Delphi
2. Feng Zhiqiang.
3. Chen Jingtao.