1. Lea el número de serie de la placa base
2. Lea la contraseña de BIOS de premios
3. Lea la información del BIOS
4. Obtenga información de fecha de BIOS
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
1. Lea el número de serie de la placa base
usa sha1, base64;
función gethashedbiosinfo: string;
varilla
Sha1Context: TSHA1Context;
Sha1Digest: TSHA1DIGEST;
Comenzar
// Obtener los datos del BIOS
SetString (resultado, PCHAR (PTR ($ F0000)), $ 10000);
// hash la cadena
Sha1Init (Sha1Context);
Sha1Update (sha1Context, PChar (resultado), longitud (resultado));
Sha1final (sha1context, sha1digest);
SetString (resultado, pchar (@sha1digest), sizeof (sha1digest));
// Devuelve la cadena hash codificada en caracteres imprimibles
Resultado: = B64Encode (resultado);
fin;
function getBiosinfoastext: string;
varilla
P, P: PCHAR;
Comenzar
P: = nil;
p: = pChar (PTR ($ Fe000));
repetir
Si q <> nil entonces comience
Si no (P^ en [ #10, #13, #32 .. #126, #169, #184]) Entonces comience
/t if (p^ = #0) y (p - q> = 8) Entonces comience
/t resultado: = resultado + trimright (cadena (q)) + #13 #10;
/tender;
/tq: = nil;
fin;
fin
Si p^ en [ #33 .. #126, #169, #184] Entonces
/tq: = p;
Inc (p);
hasta p> pchar (ptr ($ fffff));
Resultado: = Trimright (resultado);
fin;
procedimiento tForm1.FormCreate (remitente: tobject);
Comenzar
Memo1.lines.text: = getBiosinfoEteTxt;
fin;
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
2. Premio lectura de contraseña de BIOS (debería ser un artículo de Jingtao, pero la identificación no está registrada)
Unidad de premios Biospas;
// Escribir por LoveJingtao
//http://www.138soft.com
interfaz
Utiliza ventanas, sysutils;
function my_getbiospassword: string;
Implementación
función calcPossiblePassword (PasswordValue: Word): String;
varilla
I: byte;
C: char;
S: cadena [8];
Comenzar
I: = 0;
mientras que PasswordValue <> 0 do
Comenzar
Inc (i);
Si $ 263> PasswordValue entonces
Comenzar
/t si $ 80> PasswordValue entonces
/T S : = Char (PasswordValue)
/t else si $ b0> contraseña Value entonces
/t s : = char (contraseña Value y $ 77)
/t else si $ 11d> PasswordValue entonces
/t s : = char ($ 30 o (contraseña y $ 0f))
/t else si $ 114> PasswordValue entonces
/t comienza
/t s : = char ($ 64 o (contraseña Valor y $ 0f));
/t si '' 0 ''> s entonces
/t s : = char (byte (s ) + 8);
/tender
/t else si $ 1C2> PasswordValue entonces
/T S : = char ($ 70 o (Password Value y $ 03))
/t else si $ 1e4> PasswordValue entonces
/T s : = char ($ 30 o (contraseña y $ 03))
/t else
/t comienza
/t s : = char ($ 70 o (contraseña Valor y $ 0f));
/t si '' z '' <s entonces
/t s : = char (byte (s ) - 8);
/tender;
fin
demás
S : = char ($ 30 o (Valor de contraseña y $ 3));
PasswordValue: = (PasswordValue - byte (s )) SHR 2;
fin;
S [0]: = char (i);
PasswordValue: = I SHR 1;
Mientras que PasswordValue <lo hago
Comienza {Esto es para hacer porque el premio comienza a calcular con la última letra}
C: = s [byte (s [0]) - i + 1];
S [byte (s [0]) - i + 1]: = s ;
S : = c;
Dec (i);
fin;
CalcPossiblePassword: = s;
fin;
función readCMOS (OFF: byte): byte;
varilla
valor: byte;
Comenzar
ASM
Xor hacha, hacha
Mov al, Off
Fuera 70h, Al
en Al, 71h
valor de mov, al
fin;
readCMOS: = valor;
fin;
function my_getbiospassword: string;
varilla
superpw, userpw: word;
S: cadena;
Comenzar
Si win32platform <> ver_platform_win32_nt entonces // no nt
Comenzar
pchar (@superpw) [0]: = char (readcmos ($ 1c));
pchar (@superpw) [1]: = char (readcmos ($ 1d));
pchar (@userpw) [0]: = char (readcmos ($ 64));
pchar (@userpw) [1]: = char (readcmos ($ 65));
S: = '' SuperUser Password es: ''+CalcPossiblePassword (SuperPW)+#13+'' La contraseña del usuario es: ''+CalcPossiblePassword (userPW);
Resultados: = S;
fin
demás
Resultado: = '' El sistema de usuario es NT, ¡y la contraseña de BISO no se puede obtener! '' ';
fin;
fin.
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
3. Lea la información del BIOS
{El programa utiliza la plataforma Windows 95/2000, detecta automáticamente el tipo de sistema y luego hace diferentes llamadas}
usa bioshelp;
procedimiento tForm1.Button1Click (remitente: tobject);
varilla
Dump: Trombiosdump;
I: entero;
Comenzar
ReadRombios (vertedero, rrbmautomatic);
para i: = 1 a $ 000ffffff - $ 000F0000 - 1 do
Memo1.lines.add (inttoHex (volteo [i + $ 000fffff], 2));
fin;
(****************************************************** **************************************
*/t/t/t/t/t/t/t/t/t/t/t/t/t *
* Ayuda de BIOS - Lee BIOS ROM en Windows 95/98/SE/ME/NT/2K/XP/T/T *
*/t/t/t/t/t/t/t/t/t/t/t/t/t *
* Copyright (c) 2001, Nico Bendlin ([email protected])/t/t/t *
*/t/t/t/t/t/t/t/t/t/t/t/t/t *
* Compilador: Delphi 4.03/5.01/6.00/t/t/t/t/t/t/t *
* Versión: 1.03, 2001-09-02/t/t/t/t/t/t/t/t * *
*/t/t/t/t/t/t/t/t/t/t/t/t/t *
************************************************************ ******* **************************************)
{Postum scriptum: perdón por el mal inglés, lo escribí a toda prisa}
Unidad BioShelp;
{$ Alinearse en}
{$ Minenumsize 4}
interfaz
usos
Ventanas;
tipo
Prombiosdump = ^trombiosdump;
Trombiosdump = matriz [$ 000f0000 .. $ 000ffff] de byte;
tipo
Treadrombiosmethod = (
rrbmautomatic,/t/t/t/t/t {Autodetect OS tipo y use el método adecuado}
RRBMGENERIC,/T/T/T/T/T/T {Use el programa COM de 16 bits para volcar el BIOS}
rrbmmemory,/t/t/t/t/t {lea desde la memoria (win9x)/t/t}
rrbmphysical/t/t/t/t/t {lea del objeto de memoria física (winnt)}
);
function readRombios (Var dump: trombiosdump; método: treadrombiosmethod;
Tiempo de espera: dword = infinito): boolean;
function getRombiosBuffer (const ver: trombiosdump; dirección: puntero;
VAR Buffer;
function getRombiosString (const ver: trombiosdump; dirección: puntero): string;
función getRombioslonglong (constante constante: trombiosdump; dirección: puntero): longlong;
function getRombiosDword (const Dump: trombiosdump; dirección: puntero): dword;
function getRombiosword (const Dump: trombiosdump; dirección: puntero): word;
function getRombiosbyte (const ver: trombiosdump; dirección: puntero): byte;
Implementación
{############################################# ############################################## ############################################## ##
#/t/t/t/t/t/t/t/t/t/t/t/t/t #
#/t/t/t Método genérico/t/t/t/t # #
#/t/t/t/t/t/t/t/t/t/t/t/t/t #
# Crear una carpeta temporal, guarde un programa de 16 bits com (romdump.com), #
# Ejecutar el programa redirigido a un archivo (ROM.DMP, ROMDUMP.com simplemente descarga el #
# Rango de memoria F000: 0000-F000: FFFF a Stdout), lea el archivo de volcado en el búfer, #
# y finalmente limpie todos los archivos y directorios temporales ./t/t #
#/t/t/t/t/t/t/t/t/t/t/t/t/t #
# (La función RomDumpcode es específica x86, que escribí para generar # de 16 bits
# Código con la ayuda del compilador Delphi de 23 bits, nunca intente ejecutar el #
# Pseudo-código en su programa!
#/t/t/t/t/t/t/t/t/t/t/t/t/t #
############################################## ############################################## ####################################}
{ * Interno * - pseudo 16 bits}
tipo
PromDumpCodeInfo = ^tromDumpCodeInfo;
TromdumpCodeInfo = (rdCistart, rdciend, rdcisize);
función _romdumpCode (información: tromdumpcodeInfo): pointer;
varilla
CodeStart: Pointer;
Codeend: puntero;
Comenzar
ASM
/t jmp @@ end
/T { * Begin * Código de 16 bits}
/T { - ¡Nunca lo use en su programa!
/T {com que escribe Rom-Bios a Stdout}
@@Comenzar:
/T {Dump F000: 0000-F000: FFFE}
/T Xor Edx, EDX // DS = 0xf000;
/T MOV DH, 0F0H
/t mov ds, edx
/T Xor Edx, EDX // DX = 0x0000;
/t xor ecx, ecx // cx = 0xffff;
/t dec ECX
/T Xor Ebx, Ebx // Bx = 0x0001;
/t inc ebx
/t mov ah, 40h // doscall (0x40);
/t int 21h
/t jc @@ Salir // en salida de error;
/t {dump f000: ffff}
/T Xor Edx, EDX // DS = 0xf000;
/T MOV DH, 0F0H
/t mov ds, edx
/t Xor Edx, edx // dx = 0xffff;
/T dic edx
/t Xor ECX, ECX // CX = 0x0001;
/t inc ECX
/t mov ebx, ecx // bx = 0x0001;
/t mov ah, 40h // doscall (0x40);
/t int 21h
/t jc @@ Salir // en salida de error;
/t mov al, 0 // sin error;
@@Salida:
/t mov ah, 4ch // doscall (0x4c);
/t int 21h
@@Fin:
/T { * End * 16 bits}
/t mov codeStart, offset @@ comenzar
/T Mov codeend, compensación @@ end
fin;
Información de caso de
rdcistart:
Resultado: = codeStart;
rdciend:
Resultado: = CodeEnd;
rdcisize:
Resultado: = puntero (cardinal (codeend) - cardinal (codeStart));
demás
Resultado: = nil;
fin;
fin;
{ * Interno * - Guarde el código de 16 bits en el archivo}
función _romDumpCodetOfile (const fileName: String): boolean;
varilla
Comfile: Thandle;
Tamaño: Cardinal;
Comenzar
Resultado: = falso;
COMFILE: = CreateFile (pChar (nombre de archivo), genic_write, file_share_read, nil,
Create_always, file_attribute_normal, 0);
Si cómico <> invalid_handle_value entonces
intentar
Resultado: = WriteFile (COMFILE, _ROMDUMPCODE (RDCISTART)^,
Cardinal (_romdumpcode (rdcisize)), tamaño, nulo) y
(Size = cardinal (_romdumpcode (rdcisize)));
Si no es resultados, entonces
Deletefile (pchar (nombre de archivo));
Finalmente
CloseHandle (cómplice);
fin;
fin;
{ * Interno * - Ejecutar código de 16 bits redirigido a archivo}
function _romDumpCodeExeCute (const com, dmp: string; timeout: dword): boolean;
varilla
Compec: string;
SI: TStartUpinfo;
PI: TProcessInformation;
Comenzar
Resultado: = falso;
SetLength (comspec, max_path);
SetLength (comSpec,
GetVirirmentVariable ('' Compec '', pchar (@comSpec [1]), max_path));
Si longitud (comspec)> 0 entonces
Comenzar
Rellenochar (si, sizeof (tStartupinfo), 0);
si.cb: = sizeof (tStartupinfo);
si.dwflags: = startf_useshowwindow;
si.wshowwindow: = sw_hide;
if createProcess (nil, pchar (compec + '' /c '' + com + '' '>' ' + dmp),
nil, nil, falso, create_new_console o create_new_process_group, nil,
nulo, si, pi) entonces
intentar
Resultado: = waitForSingleObject (pi.hprocess, tiempo de espera) <> wait_timeout;
Finalmente
CloseHandle (pi.hprocess);
CloseHandle (pi.hthread);
fin;
fin;
fin;
function DirectoryExists (const Dir: String): boolean;
varilla
Attr: dword;
Comenzar
Attr: = getFileAtTributes (PCHAR (DIR));
Resultado: = (attr <> $ ffffffff) y
(Attr y file_attribute_directory = file_attribute_directory);
fin;
{Get BIOS Dump the Generic Way}
función readRombios16 (buffer var: trombiosdump; tiempo de espera: dword): boolean;
estúpido
Tempsub = '' ~ RomDMP '';
ComName = '' RomDump.com '';
Dmpname = '' Rom.dmp '';
varilla
TEMPPATH: cadena;
Tempdir: string;
Tempidx: entero;
Tempidxstr: string;
Cómplice: cadena;
Dmpfile: string;
Dmphandle: Thandle;
Escrito: dword;
Comenzar
Resultado: = falso;
SetLength (temppath, max_path);
SetLength (Temppath, getTemppath (max_path, pchar (@temppath [1])));
Si longitud (temppath)> 0 entonces
Comenzar
if (temppath [longitud (temppath)] <> ''/'') entonces
TEMPPATH: = TEMPPATH + ''/'';
Tempidx: = 0;
repetir
Inc (tempidx);
Str (tempidx, tempidxstr);
TEMPDIR: = TEMPPATH + TEMPSUB + TEMPIDXSTR;
hasta que no directorioxists (tempdir);
Si creatingIrectory (pChar (tempDir), nil) entonces
intentar
TempDir: = tempDir + '' '/' ';
COMFILE: = TEMPDIR + COMNAME;
DMPFILE: = TEMPDIR + DMPNAME;
Si _romDumpCodetOfile (cómplice) entonces
intentar
Si _romDumpCodeexeCute (cómplice, dmpfile, timeout) entonces
Comenzar
/t dmphandle: = createFile (pChar (dmpfile), genic_read,
/t file_share_read o file_share_write, nil, open_existing, 0, 0);
/t if dmphandle <> invalid_handle_value entonces
/T intente
/T Fillchar (buffer, sizeOf (trombiosdump), 0);
/t resultado: = readfile (dmphandle, buffer, sizeOf (trombiosdump),
/t escrito, nil) y (escrito = sizeOf (trombiosdump));
/t finalmente
/t CloseHandle (dmphandle);
/tender;
fin;
Finalmente
Deletefile (pChar (dmpfile));
Deletefile (pchar (cómfile));
fin;
Finalmente
Eliminadoirectory (pchar (tempDir));
fin;
fin;
fin;
{############################################# ############################################## ############################################## ##
#/t/t/t/t/t/t/t/t/t/t/t/t/t #
#/t/t/t método directo (win9x)/t/t/t #
#/t/t/t/t/t/t/t/t/t/t/t/t/t #
# Debido al hecho de que Windows 95/98/ME asigna el BIOS en cada proceso Win32 #
# Para el acceso a la lectura, es muy simple llenar el búfer desde la memoria ./t #
#/t/t/t/t/t/t/t/t/t/t/t/t/t #
############################################## ############################################## ####################################}
función readRombios9x (buffer var: trombiosdump): boolean;
Comenzar
Resultado: = falso;
intentar
Fillchar (buffer, sizeOf (trombiosdump), 0);
Mover (puntero (bajo (trombiosdump))^, tampón, sizeOf (trombiosdump));
Resultado: = verdadero;
excepto
// ignorar las excepciones
fin
fin;
{############################################# ############################################## ############################################## ##
#/t/t/t/t/t/t/t/t/t/t/t/t/t #
#/t/t Método de memoria física (winnt)/t/t/t #
#/t/t/t/t/t/t/t/t/t/t/t/t/t #
# En Windows nt, el BIOS ROM solo está disponible a través del objeto Kernel nombrado #
# '' '/Dispositivo/físico' '.
# Modo de usuario con funciones de API Win32 estándar Usamos NativePi de NT 'en #
# Ntdll.dll ("nt-layer") es decir, zwopensection./t/t/t/t #
#/t/t/t/t/t/t/t/t/t/t/t/t/t #
# (Nota: sobre todo hay dos versiones de cada función ZWXXX y NTXXX. El #
# La única diferencia en el modo de núcleo es que la versión NTXXX funciona en consideración- #
# ración a la seguridad mientras que ZWXXX no.
#/t/t/t/t/t/t/t/t/t/t/t/t/t #
# Al principio se abre la sección con ZWopensection.
# ZWMapViewOfSection, ZwunMapViewOfSection y NTClose.
# más complejo y no hay necesidad de ello.
# En el modo de usuario "muy simple" =) ahora usamos MAPVIEWOFFILE, UNMAPVIEWOFFILE, #
# y CloseHandle para mapear una ventana de memoria (el BIOS ROM) en nuestro proceso.
#/t/t/t/t/t/t/t/t/t/t/t/t/t #
# Debido al hecho de que Zwopensection devuelve los codificaciones de errores NT en caso de falla #
# Tenemos que traducirlo a un código de error Win32 (rtlntstatustodosError).
# Todas las funciones específicas de NT se cargan dinámicamente, porque las aplicaciones #
# debería comenzar en sistemas win9x =)/t/t/t/t/t/t # #
#/t/t/t/t/t/t/t/t/t/t/t/t/t #
############################################## ############################################## ####################################}
{Para más información, consulte Windows 2000/XP DDK}
{Funciona en Windows NT 4.0 también, use ntdll.dll}
tipo
Ntstatus = entero;
estúpido
Status_success = ntstatus (0);
Status_invalid_handle = ntstatus ($ c0000008);
Status_access_denied = ntstatus ($ c0000022);
tipo
PunicodeString = ^tunicodeString;
TunicodeString = Registro empacado
Longitud: palabra;
Máxima longitud: palabra;
Buffer: pwidechar;
fin;
estúpido
Obj_inherit = $ 00000002;
Obj_permanent = $ 00000010;
Obj_exclusive = $ 000000220;
Obj_case_insensitive = $ 00000040;
Obj_openif = $ 0000000080;
Obj_openlink = $ 00000100;
Obj_kernel_handle = $ 00000200;
Obj_valid_attributes = $ 000003F2;
tipo
POBJECTATTRIBUTOS = ^TOBECTATTRIBUTOS;
Tobjectattributes = registro
Longitud: Ulong;
RootDirectory: Thandle;
ObjectName: PunicodeString;
Atributos: Ulong;
SecurityDescriptor: PSCurityDescriptor;
Security QualityOfService: PSCURITYQualityOfService;
fin;
estúpido
ObjectPhysicalMemoryDeviceName = ''/dispositivo/PhysicaMemory '';
ObjectPhySicalMemoryName: TunicodeString = ((
Longitud: Longitud (ObjectPhySicalMemoryDeviceName) * 2;
Máximo longitud: longitud (ObjectPhysicalMemoryDeviceName) * 2 + 2;
Buffer: ObjectPhySicalMemoryDeviceName;
);
ObjectPhySicalMemoryAccessmask: access_mask = section_map_read;
ObjectPhySicalMemoryAttributes: TobjectAttributes = ((
Longitud: sizeOf (tobjectAttributes);
RootDirectory: 0;
ObjectName: @ObjectPhySicalMemoryName;
Atributos: obj_case_insensitive;
SecurityDescriptor: nulo;
SecurityQualityOfService: nulo;
);
tipo
Tfnzwopensection = function (out sectionhandle: thandle;
DeseedAccess: access_mask;
stdcall;
TfnrtlntstatustodosError = function (status: ntstatus): dword;
estúpido
ntdll = '' ntdll.dll '';
varilla
ZWopensection: tfnzwopensection;
RtlntstatustodosError: tfnrtlntstatustodosError;
función readRombiosnt (var buffer: trombiosdump; tiempo de espera: dword): boolean;
varilla
Ntlayer: hmodule;
Estado: ntstatus;
Sección: Thandle;
Vista: puntero;
Comenzar
Resultado: = falso;
Ntlayer: = getModuleHandle (ntdll);
Si ntlayer = 0 entonces
SetLasterRor (ERROR_CALL_NOT_IMPLEMENTED)
demás
Comenzar
si no se asigna (zwopensection) entonces
Zwopensection: = getProcAddress (ntlayer, '' zwopensection '');
si no se asigna (rtlntstatustodosError) entonces
RtlntstatustodosError: = getProcAddress (ntlayer, '' rtlntStatusTodosError '');
Si no (asignado (zwopensection) y asignado (rtlntstatustodosError)) entonces
SetLasterRor (ERROR_CALL_NOT_IMPLEMENTED)
demás
Comenzar
Estado: = ZWOpensection (sección, ObjectPhysicalMemoryAccessmask,
@ObjectPhysicalMemoryAttributes);
estado de caso de
Status_success:
/T intente
/T View: = MAPViewOffile (sección, ObjectPhySicalMemoryAccessmask, 0,
/t bajo (trombiosdump), sizeOf (trombiosdump));
/t si se asigna (ver) entonces
/T intente
/T Fillchar (buffer, sizeOf (trombiosdump), 0);
/t mover (ver^, búfer, sizeOf (trombiosdump));
/t resultado: = verdadero;
/t finalmente
/t unmapViewoffile (ver);
/tender;
/t finalmente
/t CloseHandle (sección);
/tender;
Status_access_denied:
/t resultado: = readRombios16 (buffer, tiempo de espera);
demás
SetLasterRor (rtlntStatustodosError (status))
fin;
fin;
fin;
fin;
{############################################# ############################################## ############################################## ##
#/t/t/t/t/t/t/t/t/t/t/t/t/t #
#/t/t/t readrombios/t/t/t/t # #
#/t/t/t/t/t/t/t/t/t/t/t/t/t #
############################################## ############################################## ####################################}
function readRombios (Var dump: trombiosdump; método: treadrombiosmethod;
Tiempo de espera: dword = infinito): boolean;
Comenzar
Resultado: = falso;
método de caso de
rrbmautomatic:
if (integer (getVersion) <0) entonces
intentar
Resultado: = readRombios9x (volteo);
excepto
Resultado: = readRombios16 (volteo, tiempo de espera);
fin
demás
Resultado: = readRombiosnt (volteo, tiempo de espera);
RRBMGeneric:
Resultado: = readRombios16 (volteo, tiempo de espera);
RRBMMEMORY:
Resultado: = readRombios9x (volteo);
rrbmfísico:
Resultado: = readRombiosnt (volteo, tiempo de espera);
demás
SetLasterRor (error_invalid_parameter);
fin;
fin;
{############################################# ############################################## ############################################## ##
#/t/t/t/t/t/t/t/t/t/t/t/t/t #
# Utilidades para simplificar el acceso a los datos como tipos estándar genéricos #
#/t/t/t/t/t/t/t/t/t/t/t/t/t #
############################################## ############################################## ####################################}
function getRombiosBuffer (const ver: trombiosdump; dirección: puntero;
VAR Buffer;
Comenzar
Resultados: = 0;
if (cardinal (dirección)> = low (trombiosdump)) y
(Cardenal (dirección) <= high (trombiosdump)) entonces
Comenzar
Resultado: = bufferSize;
if (cardinal (dirección) + buffersize> alto (trombiosdump)) entonces entonces
Resultado: = alto (trombiosdump) - cardinal (dirección) + 1;
Mover (volcar [cardenal (dirección)], amortiguador, resultado);
fin;
fin;
function getRombiosString (const ver: trombiosdump; dirección: puntero): string;
Comenzar
Resultados: = '' '';
if (cardinal (dirección)> = low (trombiosdump)) y
(Cardenal (dirección) <= high (trombiosdump)) entonces
Resultado: = string (pchar (@dump [cardinal (dirección)]));
fin;
función getRombioslonglong (constante constante: trombiosdump; dirección: puntero): longlong;
tipo
Plonglong = ^Longlong;
Comenzar
Resultados: = 0;
if (cardinal (dirección)> = low (trombiosdump)) y
(Cardinal (dirección) <= High (Trombiosdump) - SizeOf (Longlong) + 1) Entonces
Resultado: = PLONGLONG (@Dump [Cardinal (dirección)])^;
fin;
function getRombiosDword (const Dump: trombiosdump; dirección: puntero): dword;
Comenzar
Resultados: = 0;
if (cardinal (dirección)> = low (trombiosdump)) y
(Cardinal (dirección) <= High (trombiosdump) - sizeOf (dword) + 1) luego
Resultado: = PDWord (@Dump [Cardinal (dirección)])^;
fin;
function getRombiosword (const Dump: trombiosdump; dirección: puntero): word;
Comenzar
Resultados: = 0;
if (cardinal (dirección)> = low (trombiosdump)) y
(Cardinal (dirección) <= High (Trombiosdump) - SizeOf (Word) + 1) Entonces
Resultado: = PWord (@Dump [Cardinal (dirección)])^;
fin;
function getRombiosbyte (const ver: trombiosdump; dirección: puntero): byte;
Comenzar
Resultados: = 0;
if (cardinal (dirección)> = low (trombiosdump)) y
(Cardinal (dirección) <= alto (trombiosdump) - sizeOf (byte) + 1) Entonces
Resultado: = pbyte (@dump [cardinal (dirección)])^;
fin;
fin.
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
4. Obtenga información de fecha de BIOS
{------------------------------------------------- ---------------------------------}
{Obtenga la información de la fecha del BIOS, se estima que puede aplicarse bajo 2000, pero puede requerir permiso}
función getBiosdate1: string;
varilla
Búfer: matriz [0..8] de char;
N: dword;
Comenzar
ReadProcessMemory (GetCurrentProcess,
PTR ($ FFFF5),
@Buffer,
8,
NORTE);
Buffer [8]: = #0;
Resultado: = strpas (búfer)
fin;
función getBiosdate2: string;
Comenzar
resultado: = string (pchar (ptr ($ ffff5)));
fin;