1. Leia o número de série da placa -mãe
2. Leia a senha do BIOS de prêmio
3. Leia as informações do BIOS
4. Obtenha informações de data do BIOS
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
1. Leia o número de série da placa -mãe
usa sha1, base64;
função gethashedbiosinfo: string;
var
SHA1CONTEXT: TSHA1CONTEXT;
SHA1Digest: TSHA1Digest;
Começar
// Obtenha os dados do BIOS
SetString (resultado, PChar (PTR ($ F0000)), US $ 10000);
// hash the string
Sha1init (sha1Context);
SHA1UPDATE (SHA1CONTEXT, PCHAR (resultado), comprimento (resultado));
Sha1final (sha1Context, sha1Digest);
SetString (resultado, PChar (@sha1Digest), sizeof (sha1Digest));
// retorna a string hash codificada em caracteres imprimíveis
Resultado: = b64Encode (resultado);
fim;
função getBiosinfoastext: string;
var
P, Q: PCHAR;
Começar
Q: = nil;
P: = PCHO (PTR ($ FE000));
repita
Se q <> nil, então comece
se não (p^ em [ #10, #13, #32 .. #126, #169, #184]) então comece
/t if (p^ = #0) e (p - q> = 8) então comece
/t Resultado: = Resultado + Trimright (String (q)) + #13 #10;
/tratar;
/tq: = nil;
fim;
fim mais
Se p^ em [ #33 .. #126, #169, #184] então
/tq: = p;
Inc (P);
até p> pchar (ptr ($ fffff));
Resultado: = Trimright (resultado);
fim;
procedimento TForm1.FormCreate (remetente: Tobject);
Começar
Memor1.lines.text: = getBiosinfoastext;
fim;
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
2. Prêmio de leitura de senha do BIOS (deve ser um artigo de Jingtao, mas o ID não está gravado)
Unit AwardBiospas;
// Escreva por Lovejingtao
//http://www.138soft.com
interface
usa janelas, sysutils;
função my_getbiossassword: string;
Implementação
function calcpossiblepassword (PasswordValue: word): string;
var
I: byte;
C: CHAR;
S: string [8];
Começar
I: = 0;
enquanto senha
Começar
Inc (i);
Se $ 263> PasswordValue então
Começar
/t Se $ 80> PasswordValue então
/t s : = char (PasswordValue)
/t else se $ B0> PasswordValue então
/t s : = char (PasswordValue e US $ 77)
/t else se $ 11d> senha
/t s : = char ($ 30 ou (PasswordValue e $ 0f))
/t else se $ 114> PasswordValue então
/t comece
/t s : = char (US $ 64 ou (PasswordValue e $ 0f));
/t se '' 0 ''> então
/t s : = char (byte (s ) + 8);
/tratar
/t else se $ 1c2> senha
/t s : = char ($ 70 ou (PasswordValue e $ 03))
/t else se $ 1E4> PasswordValue então
/t s : = char ($ 30 ou (PasswordValue e $ 03))
/t else
/t comece
/t s : = char (US $ 70 ou (PasswordValue e $ 0f));
/t se '' z '' então
/t s : = char (byte (s ) - 8);
/tratar;
fim
outro
S : = char (US $ 30 ou (PasswordValue e US $ 3));
PasswordValue: = (PasswordValue - byte (s )) SHR 2;
fim;
S [0]: = char (i);
PasswordValue: = I SHR 1;
enquanto senha
Comece {isso deve fazer porque o prêmio começa a calcular com a última letra}
C: = s [byte (s [0]) - i + 1];
S [byte (s [0]) - i + 1]: = s ;
S : = c;
Dez (i);
fim;
Calcpossiblepassword: = s;
fim;
função readcmos (off: byte): byte;
var
valor: byte;
Começar
ASM
XOR AX, AX
mov al, off
fora de 70h, Al
em Al, 71h
MOV Value, Al
fim;
readcmos: = value;
fim;
função my_getbiossassword: string;
var
superpw, userpw: word;
S: string;
Começar
Se win32platform <> ver_platform_win32_nt então // não nt
Começar
PChar (@superpw) [0]: = char (readcmos ($ 1c));
PCHO (@superpw) [1]: = char (readcmos (US $ 1d));
PCHO (@Userpw) [0]: = char (readcmos (US $ 64));
PCHO (@Userpw) [1]: = char (readcmos (US $ 65));
S: = '' A senha do superusuário é: ''+calcpossiblePassword (superpw)+#13+'' A senha do usuário é: ''+calcpossiblePassword (userpw);
Resultados: = S;
fim
outro
Resultado: = '' O sistema do usuário é NT e a senha do BISO não pode ser obtida! '';
fim;
fim.
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
3. Leia as informações do BIOS
{O programa usa a plataforma Windows 95/2000, detecta automaticamente o tipo de sistema e depois faz chamadas diferentes}
usa BioShelp;
procedimento TForm1.Button1Click (remetente: TOBJECT);
var
Dump: Trombiosdump;
I: Inteiro;
Começar
Readrombios (despejo, rrbmautomático);
para i: = 1 a $ 000FFFFF - $ 000F0000 - 1
Memor1.lines.add (inttohex (despejo [i + $ 000fffff], 2));
fim;
(***************************************************** ************************************
*/T/T/T/T/T/T/T/T/T/T/T/T/T *
* Ajuda do BIOS - Leia ROM BIOS no 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 *
* Versão: 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 *
**************************************************** *******
{scriptum postum: desculpe pelo inglês ruim, escrevi com pressa}
Unidade Bioshelp;
{$ Alinhado em}
{$ Minenumsize 4}
interface
usos
Windows;
tipo
Prombiosdump = ^trombiosdump;
Trombiosdump = matriz [$ 000F0000 .. $ 000ffff] de byte;
tipo
Treadrombiosmethod = (
rrbmautomatic,/t/t/t/t/t {AutoDetect OS Tipo e use o método adequado}
rrbmgeneric,/t/t/t/t/t/t {use o programa COM de 16 bits para despejar o BIOS}
rrbmmemory,/t/t/t/t/t {leia da memória (win9x)/t/t}
rrbmphysical/t/t/t/t/t {leia do objeto de memória física (winnt)}
);
Função readrombios (var dump: trombiosdump; Método: Treadrombiosmethod;
Tempo limite: dword = infinito): booleano;
função getRombiosBuffer (const dump: trombiosdump; endereço: ponteiro;
var buffer; buffersize: cardeal): cardeal;
função getRombioString (const dump: trombiosdump; endereço: ponteiro): string;
função getRombioslonglong (const dump: trombiosdump; endereço: ponteiro): longlong;
função getRombiOSDword (const dump: trombiosdump; endereço: ponteiro): dword;
função getRombiosword (const dump: trombiosdump; endereço: ponteiro): word;
função getRombiosbyte (const dump: trombiosdump; endereço: ponteiro): byte;
Implementação
{#####################################################D ################################################### ## ########Omas ##
#/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 #
# Crie uma pasta temporária, salve um programa de 16 bits com (romdump.com), #
# Execute o programa redirecionado para um arquivo (rom.dmp, romdump.com simplesmente despeja o #
# Faixa de memória F000: 0000-F000: ffff para stdout), leia o arquivo de despejo no buffer, #
# e finalmente limpe todos os arquivos e diretórios temporários./t/t #
#/t/t/t/t/t/t/t/t/t/t/t/t #
# (a função romDumpCode é específica x86, que escrevi para gerar # de 16 bits
# Código com a ajuda do compilador Delphi de 23 bits, nunca tente executar o #
# pseudo-código em seu programa!
#/t/t/t/t/t/t/t/t/t/t/t/t #
########Omas #######Omas #########################################}
{ * Interno * - Pseudo -16 bits Código}
tipo
PromDumpCodeInfo = ^tromdumpCodeInfo;
TromdumpCodeInfo = (rdcistart, rdciend, rdcisize);
função _romdumpCode (info: tromdumpCodeInfo): pointer;
var
Codestart: Ponteiro;
CodeEND: ponteiro;
Começar
ASM
/t jmp @@ final
/t { * BEGIN * Código de 16 bits}
/t { - nunca use -o em seu programa! -}
/t {com que escreve rom-bias to stdout}
@@Começar:
/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 @@ saída // na saída do erro;
/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 DEC 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 @@ saída // na saída do erro;
/t mov al, 0 // sem erro;
@@Saída:
/T MOV AH, 4CH // DOSCALL (0x4C);
/t int 21h
@@Fim:
/t { * end * código de 16 bits}
/t mov codestart, compensar @@ iniciar
/t MOV CodeEND, deslocamento @@ final
fim;
Informações do caso de
RDCISTART:
Resultado: = codestart;
RDCiend:
Resultado: = CodeEND;
rdcisize:
Resultado: = ponteiro (cardeal (codend) - cardeal (codestart));
outro
Resultado: = nil;
fim;
fim;
{ * Interno * - salve o código de 16 bits para arquivar}
função _ROMDUMPCODETOFILE (const FILENAME: String): boolean;
var
COMFILE: THANDLE;
Tamanho: cardeal;
Começar
Resultado: = false;
COMFILE: = createfile (pchar (nome do arquivo), genérico_write, file_share_read, nil,
Create_always, file_attribute_normal, 0);
Se COMFILE <> invalid_handle_value então
tentar
Resultado: = Writefile (COMFILE, _ROMDUMPCODE (RDCISTART)^,
Cardeal (_romdumpCode (rdcisize)), tamanho, nulo) e
(Size = cardeal (_romdumpCode (rdcisize)));
Se não resultar então
Deletefile (PCHO (nome do arquivo));
Finalmente
CloseHandle (Comfile);
fim;
fim;
{ * Interno * - Execute o código de 16 bits redirecionado para o arquivo}
função _ROMDUMPCODEEXECUTE (const com, dmp: string; timeout: dword): boolean;
var
CONSPEC: String;
SI: TSTARTUPINFO;
PI: TprocessInformation;
Começar
Resultado: = false;
SetLength (CONSPEC, MAX_PATH);
SetLength (COMSPEC,
GetenvironmentVariable ('' COMSPEC '', PCHAR (@ComSpec [1]), max_path));
Se comprimento (CONSPEC)> 0 Então
Começar
Preenchchar (Si, sizeof (tstartupinfo), 0);
si.cb: = sizeof (tstartupinfo);
si.dwflags: = startf_useshowwindow;
Si.WSHOWWindow: = sw_hide;
Se CreateProcess (nil, PChar (COMSPEC + '' ' /C' '' + COM + '' '' ' + DMP),
nil, nil, false, create_new_console ou create_new_process_group, nil,
nil, si, pi) então
tentar
Resultado: = waitforsingleObject (pi.hprocess, timeout) <> wait_timeout;
Finalmente
CloseHandle (PI.HProcess);
CloseHandle (pi.hthread);
fim;
fim;
fim;
DirectoryExists de função (const Dir: String): boolean;
var
Att: dword;
Começar
Att: = getFileAttributes (PChar (dir));
Resultado: = (att <> $ fffffff) e
(Att e file_attribute_directory = file_attribute_directory);
fim;
{Obtenha o BIOS despeje a maneira genérica}
Função ReadRombios16 (Var Buffer: Trombiosdump; Timeout: DWORD): Boolean;
const
Tempsub = '' ~ romdmp '';
Comname = '' romdump.com '';
Dmpname = '' rom.dmp '';
var
Temppath: string;
Tempdir: string;
Tempidx: Inteiro;
Tempidxstr: string;
COMFILE: String;
Dmpfile: string;
Dmphandle: Thandle;
Escrito: DWORD;
Começar
Resultado: = false;
SetLength (temppath, max_path);
SetLength (temppath, getTemppath (max_path, pchar (@temppath [1])));
se comprimento (temppath)> 0 então
Começar
if (temppath [comprimento (temppath)] <> ''/'') então
Temppath: = temppath + ''/'';
Tempidx: = 0;
repita
Inc (tempidx);
Str (tempidx, tempidxstr);
Tempdir: = temppath + tempsub + tempidxstr;
até que não o diretório existam (tempdir);
Se criado como retenção (pchar (tempdir), nil) então
tentar
Tempdir: = tempdir + ''/'';
COMFILE: = tempdir + comname;
Dmpfile: = tempdir + dmpName;
Se _ROMDUMPCODETOFILE (COMFILE)
tentar
Se _ROMDUMPCODEEXECUTE (COMFILE, DMPFILE, Timeout) então
Começar
/t dmphandle: = createfile (pchar (dmpfile), genérico_read,
/t file_share_read ou file_share_write, nil, open_existing, 0, 0);
/t se dmphandle <> invalid_handle_value então
/T tente
/T Fillchar (buffer, sizeof (trombiosdump), 0);
/t Resultado: = ReadFile (dmphandle, buffer, sizeof (trombiosdump),
/t escrito, nil) e (escrito = sizeof (trombiosdump));
/t finalmente
/T CloseHandle (Dmphandle);
/tratar;
fim;
Finalmente
Deletefile (PChar (DMPFile));
Deletefile (PChar (COMFILE));
fim;
Finalmente
Removedirectory (PChar (tempdir));
fim;
fim;
fim;
{#####################################################D ################################################### ## ########Omas ##
#/t/t/t/t/t/t/t/t/t/t/t/t #
Método direto #/t/t/t (win9x)/t/t/t #
#/t/t/t/t/t/t/t/t/t/t/t/t #
# Devido ao fato de que o Windows 95/98/me mapa o BIOS em cada processo Win32 #
# Para acesso de leitura, é muito simples preencher o buffer da memória./T #
#/t/t/t/t/t/t/t/t/t/t/t/t #
########Omas #######Omas #########################################}
Função ReadRombios9X (VAR Buffer: Trombiosdump): Boolean;
Começar
Resultado: = false;
tentar
Preenchchar (buffer, sizeof (trombiosdump), 0);
Mover (ponteiro (baixo (trombosdump))^, tampão, sizeof (trombiosdump));
Resultado: = true;
exceto
// ignora exceções
fim
fim;
{#####################################################D ################################################### ## ########Omas ##
#/t/t/t/t/t/t/t/t/t/t/t/t #
Método de memória física #/t/t (winnt)/t/t/t #
#/t/t/t/t/t/t/t/t/t/t/t/t #
# No Windows NT, o ROM BIOS está disponível apenas através do objeto Kernel nomeado #
# ''/Dispositivo/PhysicalMemory ''.
# Modo de usuário com as funções padrão da API Win32 que utilizamos o nativeapi da NT em #
# Ntdll.dll ("NT-camada") nomeadamente zwopensection./t/t/t #
#/t/t/t/t/t/t/t/t/t/t/t/t #
# (Nota: principalmente existem duas versões de todas as funções zwxxx e ntxxx. O #
# A única diferença no modo de kernel é que a versão ntxxx funciona em consideração- #
# ração para segurança enquanto zwxxx não.
#/t/t/t/t/t/t/t/t/t/t/t/t #
# No início, a seção é aberta com o Zwopensection.
# Zwmapviewofsection, zwunmapviewofsection e ntclose.
# mais complexo e não há necessidade de isso.
# No modo de usuário "muito simples" =) agora usamos o MapViewOffile, UMAPVIEWOFFILE, #
# e CloseHandle para mapear uma janela de memória (o ROM BIOS) em nosso processo.
#/t/t/t/t/t/t/t/t/t/t/t/t #
# Devido ao fato de o Zwopensection retornar os códigos de erro NT no caso de falha #
# Temos que traduzi-lo para um código de erro Win32 (rtlntStatustodoserror).
# Todas as funções específicas do NT são carregadas dinamicamente - porque os aplicativos #
# deve começar no Win9x Systems =)/T/T/T/T/T/T #
#/t/t/t/t/t/t/t/t/t/t/t/t #
########Omas #######Omas #########################################}
{Para mais informações, consulte o Windows 2000/XP DDK}
{Também funciona no Windows NT 4.0, use ntdll.dll}
tipo
Ntstatus = número inteiro;
const
Status_success = ntstatus (0);
Status_invalid_handle = ntstatus ($ c0000008);
Status_access_denied = ntstatus ($ c0000022);
tipo
Punicodestring = ^tunicodestring;
Tunicodestring = registro embalado
Comprimento: palavra;
MAXIMUMLENGLEME: palavra;
Buffer: pwidechar;
fim;
const
Obj_inherit = $ 00000002;
Obj_perMant = $ 00000010;
Obj_exclusive = $ 00000020;
Obj_case_insensitive = $ 00000040;
Obj_openif = $ 00000080;
Obj_openlink = $ 00000100;
Obj_kernel_handle = $ 00000200;
Obj_valid_attributes = $ 000003f2;
tipo
PobjectAttributes = ^TObjectAttributes;
TObjectAttributes = registro
Comprimento: Ulong;
Rootdirectory: thandle;
ObjectName: punicodestring;
Atributos: Ulong;
SecurityDescriptor: PScurityDescriptor;
Segurança de qualidade do service: pScurityquityityOfService;
fim;
const
ObjectPhysicalMemoryDevicename = ''/Device/PhysicalMemory '';
ObjectPhysicalMemoryName: tunicodestring = (
Comprimento: comprimento (objectphysicalMemoryDevicename) * 2;
MAXIMUMLEGRIMENTO: Length (ObjectPhysicalMemoryDevicename) * 2 + 2;
Buffer: ObjectPhysicalMemoryDevicename;
);
ObjectPhysicalMemoryAccessMask: Access_Mask = Section_map_read;
ObjectPhysicalMemoryAttributes: TObjectAttributes = (
Comprimento: tamanho de (tabjectAttributes);
Rootdirectory: 0;
ObjectName: @ObjectPhysicalMemoryName;
Atributos: obj_case_insensitive;
SecurityDescriptor: NIL;
Segurança de qualidade do service: nil;
);
tipo
Tfnzwopensection = função (out SeçãoHandle: THANDLE;
Desejadoaccess: access_mask;
stdcall;
TfnrtlntStatustodoserror = função (status: ntstatus): dword;
const
ntdll = '' ntdll.dll '';
var
Zwopensection: tfnzwopensection;
RtlntStatustodosError: tfnrtlntStatustodosError;
Função readrombiosnt (var buffer: trombiosdump; timeout: dword): boolean;
var
Ntlayer: hmodule;
Status: ntstatus;
Seção: Thandle;
Ver: ponteiro;
Começar
Resultado: = false;
Ntlayer: = getModuleHandle (ntdll);
Se ntlayer = 0 então
SetLasterRor (ERROR_CALL_NOT_IMPLEMENTED)
outro
Começar
Se não for atribuído (Zwopensection), então
Zwopensection: = getProcaddress (ntlayer, '' zwopensection '');
Se não for atribuído (rtlntstatustodoserror), então
RtlntStatustodosError: = getProcaddress (ntlayer, '' rtlntStatustodosError '');
se não (atribuído (zwopensection) e atribuído (rtlntstatustodoserror)) então
SetLasterRor (ERROR_CALL_NOT_IMPLEMENTED)
outro
Começar
Status: = zwopensection (seção, objectphysicalMemoryAccessMask,
@ObjectPhysicalMemoryAttributes);
status do caso de
Status_success:
/T tente
/t View: = MapViewOffile (Seção, ObjectPhysicalMemoryAccessMask, 0,
/t baixo (trombiosdump), sizeof (trombiosdump));
/t se atribuído (visualizar) então
/T tente
/T Fillchar (buffer, sizeof (trombiosdump), 0);
/t move (view^, buffer, sizeof (trombiosdump));
/t resultado: = true;
/t finalmente
/t UMAPVIELOFFILE (VIEW);
/tratar;
/t finalmente
/T CloseHandle (seção);
/tratar;
Status_access_denied:
/t resultado: = readrombios16 (buffer, tempo limite);
outro
SetLasterRor (rtlntStatustodosError (status))
fim;
fim;
fim;
fim;
{#####################################################D ################################################### ## ########Omas ##
#/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 #
########Omas #######Omas #########################################}
Função readrombios (var dump: trombiosdump; Método: Treadrombiosmethod;
Tempo limite: dword = infinito): booleano;
Começar
Resultado: = false;
Método de caso de
rrbmautomatic:
if (inteiro (getversion) <0) então
tentar
Resultado: = ReadRombios9x (despejo);
exceto
Resultado: = ReadRombios16 (despejo, tempo limite);
fim
outro
Resultado: = readrombiosnt (despejo, tempo limite);
rrbmgeneric:
Resultado: = ReadRombios16 (despejo, tempo limite);
rrbmmemory:
Resultado: = ReadRombios9x (despejo);
rrbmphysical:
Resultado: = readrombiosnt (despejo, tempo limite);
outro
Setlasterror (error_invalid_parameter);
fim;
fim;
{#####################################################D ################################################### ## ########Omas ##
#/t/t/t/t/t/t/t/t/t/t/t/t #
# Utilitários para simplificar o acesso aos dados como tipos padrão genéricos #
#/t/t/t/t/t/t/t/t/t/t/t/t #
########Omas #######Omas #########################################}
função getRombiosBuffer (const dump: trombiosdump; endereço: ponteiro;
var buffer; buffersize: cardeal): cardeal;
Começar
Resultados: = 0;
if (cardeal (endereço)> = baixo (trombiosdump)) e
(Cardeal (endereço) <= alto (trombiosdump)) Então
Começar
Resultado: = buffersize;
if (cardeal (endereço) + buffersize> alto (trombiosdump)) então
Resultado: = alto (trombiosdump) - cardeal (endereço) + 1;
Mover (despejo [cardeal (endereço)], buffer, resultado);
fim;
fim;
função getRombioString (const dump: trombiosdump; endereço: ponteiro): string;
Começar
Resultados: = '' '';
if (cardeal (endereço)> = baixo (trombiosdump)) e
(Cardeal (endereço) <= alto (trombiosdump)) Então
Resultado: = string (pchar (@dump [cardeal (endereço)]));
fim;
função getRombioslonglong (const dump: trombiosdump; endereço: ponteiro): longlong;
tipo
PLONglong = ^Longlong;
Começar
Resultados: = 0;
if (cardeal (endereço)> = baixo (trombiosdump)) e
(Cardeal (endereço) <= alto (trombiosdump) - sizeof (longo) + 1) Então
Resultado: = PLONglong (@Dump [Cardinal (endereço)])^;
fim;
função getRombiOSDword (const dump: trombiosdump; endereço: ponteiro): dword;
Começar
Resultados: = 0;
if (cardeal (endereço)> = baixo (trombiosdump)) e
(Cardeal (endereço) <= alto (trombiosdump) - sizeof (dword) + 1) então
Resultado: = pdword (@dump [cardeal (endereço)])^;
fim;
função getRombiosword (const dump: trombiosdump; endereço: ponteiro): word;
Começar
Resultados: = 0;
if (cardeal (endereço)> = baixo (trombiosdump)) e
(Cardeal (endereço) <= alto (trombosdump) - sizeof (word) + 1) então
Resultado: = pword (@dump [cardeal (endereço)])^;
fim;
função getRombiosbyte (const dump: trombiosdump; endereço: ponteiro): byte;
Começar
Resultados: = 0;
if (cardeal (endereço)> = baixo (trombiosdump)) e
(Cardeal (endereço) <= alto (trombosdump) - sizeof (byte) + 1) então
Resultado: = pbyte (@dump [cardeal (endereço)])^;
fim;
fim.
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
4. Obtenha informações de data do BIOS
{------------------------------------------------- -----------------------------------}
{Obtenha as informações da data do BIOS, estima -se que possa ser aplicado em 2000, mas pode exigir permissão}
função getBiOSDATE1: string;
var
Buffer: Array [0..8] de Char;
N: dWord;
Começar
ReadProcessMemory (getCurrentProcess,
Ptr ($ ffff5),
@Buffer,
8,
N);
Buffer [8]: = #0;
Resultado: = strpas (buffer)
fim;
função getBiOSDATE2: string;
Começar
resultado: = string (pchar (ptr ($ ffff5)));
fim;