Informieren Sie sich über das Motherboard -BIOS

Autor：Eve Cole Aktualisierungszeit：2025-03-08 16:48:02

1. Lesen Sie die Seriennummer der Motherboard

2. Lesen Sie das BIOS -Kennwort für das BIOS

3.. Lesen Sie die BIOS -Informationen

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

1. Lesen Sie die Seriennummer der Motherboard

verwendet SHA1, Base64;

Funktion Gethashedbiosinfo: String;

var

SHA1Context: TSHA1Context;

SHA1Digest: TSHA1Digest;

Beginnen

// Die BIOS -Daten erhalten

SetString (Ergebnis, PCHR (PTR ($ f0000)), 10000 $);

// Hash die Zeichenfolge

SHA1INIT (SHA1CONTEXT);

SHA1UPDATE (SHA1CONTEXT, PCHAR (Ergebnis), Länge (Ergebnis));

SHA1FINAL (SHA1CONTEXT, SHA1Digest);

SetString (Ergebnis, pChar (@SHA1Digest), sizeof (SHA1Digest));

// Geben Sie die in druckbare Zeichen codierte Hash -Zeichenfolge zurück

Ergebnis: = B64Codode (Ergebnis);

Ende;

Funktion getbiosinfoastext: String;

var

p, q: pchar;

Beginnen

F: = nil;

p: = pchar (ptr ($ fe000));

wiederholen

Wenn q <> nil dann beginnen

wenn nicht

/t if (p^ = #0) und (p - q> = 8) dann beginnen

/T Ergebnis: = Ergebnis + Trimright (String (q)) + #13 #10;

/t Ende;

/tq: = nil;

Ende;

Ende sonst

Wenn p^ in [ #33 .. #126, #169, #184] dann

/tq: = p;

Inc (p);

bis p> pchar (ptr ($ fffff));

Ergebnis: = trimRight (Ergebnis);

Ende;

procedure tform1.formcreate (Absender: tobject);

Beginnen

Memo1.lines.text: = getbiosinfoastext;

Ende;

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

2. BIOS -Passwort lesen (es sollte ein Jingtao -Artikel sein, aber die ID wird nicht aufgezeichnet)

Einheit preisgültig;

// Schreiben Sie von Lovejingtao

//http://www.138soft.com

Schnittstelle

verwendet Fenster, Systeme;

Funktion my_getbiospassword: String;

Durchführung

Funktion calcPossiblePassword (PasswortValue: Wort): String;

var

I: Byte;

C: Char;

S: String [8];

Beginnen

I: = 0;

während passwordValue <> 0 tun

Beginnen

Inc (i);

Wenn $ 263> passwordValue dann

Beginnen

/t if $ 80> passwordValue dann

/t s : = char (passwordValue)

/t sonst wenn $ b0> passwordValue dann

/t s : = char (passwordvalue und 77 $)

/t sonst wenn $ 11d> passwordValue dann

/t s : = char (30 $ oder (PasswordValue und $ 0F))

/t sonst wenn $ 114> passwordValue dann

/t beginnen

/t s : = char ($ 64 oder (passwordValue und $ 0f));

/t if '' 0 ''> s dann

/t s : = char (byte (s ) + 8);

/t Ende

/t sonst wenn $ 1c2> passwordValue dann

/t s : = char ($ 70 oder (PasswordValue und $ 03))

/t sonst wenn $ 1E4> Passwortwert dann

/t s : = char (30 $ oder (PasswordValue und $ 03))

/t sonst

/t beginnen

/t s : = char ($ 70 oder (passwordValue und $ 0f));

/t if '' z '' <s dann

/t s : = char (byte (s ) - 8);

/t Ende;

Ende

anders

S : = char (30 $ oder (PasswortValue und 3 $));

PasswordValue: = (passwordValue - byte (s )) SHR 2;

Ende;

S [0]: = char (i);

PasswortValue: = I SHR 1;

während passwordvalue <ich tue

Beginnen Sie {Dies ist zu tun, weil die Auszeichnung mit dem letzten Buchstaben berechnet wird}

C: = S [Byte (s [0]) - i + 1];

S [Byte (s [0]) - i + 1]: = s ;

S : = C;

Dec (i);

Ende;

CalcPossiblePassword: = s;

Ende;

Funktion readCmos (aus: byte): byte;

var

Wert: Byte;

Beginnen

Asm

XOR AX, AX

MOV AL, aus

Aus 70H, Al

in Al, 71H

MOV -Wert, Al

Ende;

ReadCmos: = Wert;

Ende;

Funktion my_getbiospassword: String;

var

SuperPW, UserPW: Word;

S: String;

Beginnen

Wenn win32Platform <> ver_PLATFORM_WIN32_NT, dann // nicht nt

Beginnen

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 -Passwort lautet: ''+calcPossiblePassword (SuperPW)+#13+'' Das Benutzerkennwort lautet: ''+calcPossiblePassword (userPW);

Ergebnisse: = S;

Ende

anders

Ergebnis: = '' Das Benutzersystem ist NT und das Biso -Passwort kann nicht erhalten werden! '';

Ende;

Ende.

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

3.. Lesen Sie die BIOS -Informationen

{Das Programm verwendet die Windows 95/2000 -Plattform, erkennt automatisch den Systemtyp und tätigt dann verschiedene Aufrufe}}

verwendet Bioshelp;

procedure tform1.button1click (Absender: tobject);

var

Dump: TrombiosDump;

I: Ganzzahl;

Beginnen

Readrombios (Dump, rrbmautomatisch);

für i: = 1 bis 000FFFFFF - $ 000F0000 - 1 tun

Memo1.lines.add (inttohex (Dump [i + $ 000FFFFF], 2));

Ende;

(********************************************************* ************************************************************

*/t/t/t/t/t/t/t/t/t/t/t/t/t *

* BIOS -Hilfe - Lesen Sie ROM BIOS unter Windows 95/98/SE/ME/NT/2K/XP/T/T *

*/t/t/t/t/t/t/t/t/t/t/t/t/t *

* Compiler: Delphi 4.03/5.01/6.00/t/t/t/t/t/t/t * *

* Version: 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: Entschuldigung für das schlechte Englisch, ich habe es in Eile geschrieben}

Einheit Bioshelp;

{$ Ausrichten auf}

{$ Minenumsize 4}

Schnittstelle

Verwendung

Fenster;

Typ

PrombiosDump = ^ptrombiosDump;

TrombiosDump = Array [$ 000F0000 .. $ 000FFFF] von Byte;

Typ

Treadrombiosmethod = (

rrbmautomatisch,/t/t/t/t/t/t {Autodetekte OS -Typ und verwenden die richtige Methode}

rrbmgeneric,/t/t/t/t/t/t/t {verwenden Sie das 16-Bit-COM-Programm, um das BIOS} abzuwerfen}

rrbmmemory,/t/t/t/t/t/t {lesen aus dem Speicher (Win9x)/T/T}

rrbmphysical/t/t/t/t/t/t {lesen aus dem physischen Speicherobjekt (WinNT)}

);

Funktion readrombios (var Dump: TrombiosDump; Methode: Treadrombiosmethode;

Timeout: dWord = unendlich): boolean;

Funktion getrombiosBuffer (const Dump: TrombiosDump; Adresse: Zeiger;

var puffer;

Funktion getrombiosstring (const Dump: TrombiosDump; Adresse: Zeiger): String;

Funktion getrombioslonglong (const Dump: TrombiosDump; Adresse: Zeiger): longlong;

Funktion getrombiosdWord (const Dump: TrombiosDump; Adresse: Zeiger): DWORD;

Funktion getrombiosword (const Dump: TrombiosDump; Adresse: Zeiger): Wort;

Funktion getrombiosbyte (const Dump: TrombiosDump; Adresse: Zeiger): Byte;

Durchführung

{##################################################################################################### zu erhalten ################################################# ## ## ####################################################################################################################### zu erhalten ##

#/t/t/t/t/t/t/t/t/t/t/t/t/t # #

#/t/t/t Generische Methode/t/t/t/t # #

#/t/t/t/t/t/t/t/t/t/t/t/t/t # #

# Erstellen Sie einen temporären Ordner und speichern Sie ein 16 -Bit -COM -Programm (romdump.com), # #

# Programm ausführen, das in eine Datei umgeleitet wird (rom.dmp, romdump.com legt einfach die # ab

# Speicherbereich F000: 0000-F000: FFFF bis STDOut), Lesen Sie die Dump-Datei in den Puffer, #

# und schließlich alle temporären Dateien und Verzeichnisse aufräumen./t/t # #

#/t/t/t/t/t/t/t/t/t/t/t/t/t # #

# (Die Funktion romdumpcode ist x86 spezifisch, die ich geschrieben habe, um 16-Bit # zu generieren

# Code mit Hilfe des 23-Bit-Delphi-Compilers, versuchen Sie niemals, die # auszuführen

# Pseudo-Code in Ihrem Programm!

#/t/t/t/t/t/t/t/t/t/t/t/t/t # #

####################################################################################################################### zu erhalten ############################################################################################################################### zurild ########################################}}

{ * Intern * - Pseudo 16 -Bit -Code}

Typ

PromdumpcodeInfo = ^tromdumpcodeInfo;

TromdumpcodeInfo = (rdcistart, rdciend, rdcisize);

Funktion _romdumpcode (info: tromdumpcodeInfo): Zeiger;

var

Codestart: Zeiger;

Codeend: Zeiger;

Beginnen

Asm

/t JMP @@ End

/t { * begin * 16-Bit-Code}

/T { - Verwenden Sie es niemals in Ihrem Programm!

/t {com, das Rom-Bios in Stdout schreibt}

@@Start:

/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 @@ Exit // beim Fehler -Beenden;

/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 @@ Exit // beim Fehler -Beenden;

/t mov al, 0 // kein Fehler;

@@Ausfahrt:

/T mov ah, 4ch // doscall (0x4c);

/t int 21h

@@Ende:

/t { * Ende * 16-Bit-Code}

/T Mov Codestart, offset @@ starten

/T MOV CODEEND, OUTSET @@ ENDE

Ende;

Fall Info von

rdcistart:

Ergebnis: = Codestart;

rdciend:

Ergebnis: = Codeend;

rdcisize:

Ergebnis: = Zeiger (Cardinal (Codeend) - Cardinal (Codestart));

anders

Ergebnis: = nil;

Ende;

{ * Intern * - 16 -Bit -Code in Datei speichern}

Funktion _romdumpcodetofile (const Dateiname: String): boolean;

var

Kombination: Thandle;

Größe: Kardinal;

Beginnen

Ergebnis: = falsch;

COMFILE: = CREATEFILE (PCAR (Dateiname), generic_write, File_Share_Read, nil,

Create_always, file_attribute_normal, 0);

Wenn Kombination <> Invaly_handle_value dann dann

versuchen

Ergebnis: = WriteFile (Kombination, _romdumpcode (rdcistart)^,,

Kardinal (_romdumpcode (rdcisize)), Größe, nil) und

(Size = cardinal (_romdumpcode (rdcisize)));

Wenn nicht Ergebnisse, dann

DeleteFile (pchar (Dateiname));

Endlich

Nahe Handle (Kombination);

Ende;

Oder

Funktion _romdumpCodeexexecute (const com, dmp: string; timeout: dword): boolean;

var

Comspec: String;

SI: TStartupinfo;

PI: Tprocessinformation;

Beginnen

Ergebnis: = falsch;

SetLength (comspec, max_path);

SetLength (comspec,

GetenvironmentVariable ('' comspec '', pchar (@comSpec [1]), max_path));

Wenn Länge (comspec)> 0 dann

Beginnen

Fillchar (si, sizeof (tstartupinfo), 0);

Si.cb: = sizeof (tstartUpInfo);

si.dwflags: = startf_useshowwindow;

si.wshowwindow: = sw_hide;

Wenn createRcoesse (nil, pchar (comspec + '' /c '' + com + ''> '' + dmp),

nil, nil, false, create_new_console oder create_new_process_group, nil,

nil, si, pi) dann

versuchen

Ergebnis: = WaitForsingleObject (pi.hprocess, Timeout) <> Wait_Timeout;

Endlich

CloseHandle (pi.hprocess);

CloseHandle (pi.hThread);

Ende;

Funktionsverzeichnissexisten (const ide: String): boolean;

var

Attr: DWORD;

Beginnen

Attr: = getFileTtributes (pchar (Dir));

Ergebnis: = (attr <> $ fffffffff) und

(Attr und file_attribute_directory = file_attribute_directory);

Ende;

{GET BIOS DUPEN SIE DEN GENERISCHEN WEGEN}

Funktion readrombios16 (var buffer: prubiosdump; timeout: dword): boolean;

Const

Tempsub = '' ~ romdmp '';

Comname = '' romdump.com '';

Dmpname = '' rom.dmp '';

var

Temppath: String;

Tempdir: String;

Tempidx: Ganzzahl;

Tempidxstr: String;

Kombination: String;

DMPFile: String;

Dmphandle: Thandle;

Geschrieben: DWORD;

Beginnen

Ergebnis: = falsch;

SetLength (temppath, max_path);

SetLength (temppath, gettemppath (max_path, pchar (@temppath [1])));

Wenn Länge (Temppath)> 0 dann

Beginnen

if (temppath [länge (temppath)] <> ''/'') dann

Temppath: = temppath + ''/'';

Tempidx: = 0;

wiederholen

Inc (tempidx);

Str (tempidx, tempidxstr);

Tempdir: = TEMPPATH + TEMPSUB + TEMPIDXSTR;

bis nicht verzeichnisExisten (tempdir);

Wenn erstellt wird (pchar (tempdir), nil), dann dann

versuchen

Tempdir: = tempdir + ''/'';

Kombination: = tempdir + comname;

Dmpfile: = tempdir + dmpname;

Wenn _romdumpcodetofile (bequem) dann

versuchen

Wenn _romdumpcodeexexecute (ComFile, DMPFile, Timeout) dann dann

Beginnen

/t dmphandle: = createFile (pchar (dmpfile), generic_read,

/t File_Share_read oder File_Share_Write, NIL, Open_EXISTING, 0, 0);

/t if dmphandle <> Invaly_handle_value dann dann

/t versuchen

/t fillchar (Puffer, Größe (TrombiosDump), 0);

/T Ergebnis: = ReadFile (dmphandle, Puffer, Größe (TrombiosDump),

/t geschrieben, nil) und (schriftlich = sizeof (posbiosDump));

/T endlich

/t nahe Handle (dmphandle);

/t Ende;

Ende;

Endlich

DeleteFile (pChar (DMPFile));

DeleteFile (PCHAR (Kombination));

Ende;

Endlich

REMED -Anleiter (pchar (tempdir));

Ende;

#/t/t/t/t/t/t/t/t/t/t/t/t/t # #

#/t/t/t Direct -Methode (Win9x)/T/T/T # #

#/t/t/t/t/t/t/t/t/t/t/t/t/t # #

# Aufgrund der Tatsache, dass Windows 95/98/Me das BIOS in jeden Win32 -Prozess # ordnet

# Für den Zugriff ist es sehr einfach, den Puffer aus dem Speicher zu füllen./t # #

#/t/t/t/t/t/t/t/t/t/t/t/t/t # #

Funktion readrombios9x (var buffer: posombiosDump): boolean;

Beginnen

Ergebnis: = falsch;

versuchen

FillChar (Puffer, Größe (TrombiosDump), 0);

Move (Zeiger (niedrig (posbiosDump))^, Puffer, Größe (TrombiosDump));

Ergebnis: = wahr;

außer

// Ausnahmen ignorieren

Ende

Ende;

#/t/t/t/t/t/t/t/t/t/t/t/t/t # #

#/t/t Physische Speichermethode (WinNT)/T/T/T # #

#/t/t/t/t/t/t/t/t/t/t/t/t/t # #

# Unter Windows NT Das ROM BIOS ist nur über das benannte Kernel -Objekt # erhältlich

# ''/Gerät/physikalischer Memory '', weil es unmöglich ist, Kernel -Objekte in # zu öffnen

# Benutzermodus mit Standard -Win32 -API -Funktionen Wir verwenden NATiveApi von NT in #

# Ntdll.dll ("nt-layer") nämlich Zwopensection./t/t/t/t # #

#/t/t/t/t/t/t/t/t/t/t/t/t/t # #

# (Hinweis: Meistens gibt es zwei Versionen jeder Funktion zwxxx und ntxxx. Die # #

# Der einzige Unterschied im Kernel-Modus besteht darin, dass die NTXXX-Version in Achtung funktioniert

# Ration zur Sicherheit, während zwxxx nicht.

#/t/t/t/t/t/t/t/t/t/t/t/t/t # #

# Der Abschnitt wird zunächst mit Zwopensektion geöffnet.

# ZwmapviewofSektion, ZwunmapviewofSection und Ntclose.

# komplexer und es gibt keine Notwendigkeit.

# Im "Sehr einfachen" Benutzermodus =) verwenden wir jetzt MapViewoffile, UnmapViewoffile, #

# und näher, um ein Speicherfenster (das ROM -BIOS) in unseren Prozess abzubilden.

#/t/t/t/t/t/t/t/t/t/t/t/t/t # #

# Aufgrund der Tatsache, dass Zwopensection NT-Fehlercodes im Falle eines Fehlers # zurückgibt

# Wir müssen es in einen Win32-Fehler-Code (rtlntStatustodoSror) übersetzen.

# Alle NT -spezifischen Funktionen sind dynamisch geladen - weil die Anwendungen #

# sollte auf Win9x Systems beginnen =)/t/t/t/t/t/t # #

#/t/t/t/t/t/t/t/t/t/t/t/t/t # #

{Weitere Informationen finden Sie unter Windows 2000/XP DDK}

{Es funktioniert auch unter Windows NT 4.0, verwenden Sie ntdll.dll}

Typ

Ntstatus = Integer;

Const

Status_success = ntstatus (0);

Status_invalid_handle = ntstatus ($ C0000008);

Status_access_denied = ntstatus ($ C0000022);

Typ

Punicodestring = ^tunicodestring;

Tunikodestring = verpackter Datensatz

Länge: Wort;

Maximumlänge: Wort;

Puffer: Pwidechar;

Ende;

Const

Obj_inherit = 00000002;

Obj_permanent = 00000010;

Obj_exclusive = 00000020;

Obj_case_insensitiv = $ 00000040;

Obj_openif = 00000080;

Obj_openlink = 00000100;

Obj_kernel_handle = $ 00000200;

Obj_valid_attributes = 000003f2;

Typ

PObjectAttributes = ^tobjectAttributes;

Tobjectattributes = record

Länge: Ulong;

RootDirectory: Thandle;

Objektname: Punicodestring;

Attribute: Ulong;

SecurityDescriptor: pScurityDescriptor;

SecurityQualityOfService: PSCURITYQUALITYOFService;

Ende;

Const

ObjectPhyScysicalMemoryDevicename = ''/Device/PhysicalMemory '' ';

ObjectPhysicalMemoryName: Tunicodestring = ((

Länge: Länge (ObjectPhysicalMemoryDevicename) * 2;

Maximumlänge: Länge (ObjectPhysicalMemoryDevicename) * 2 + 2;

Puffer: ObjectPhysicalMemoryDevicename;

);

ObjectPhysicalMemoryAccessmask: Access_mask = Abschnitt_MAP_READ;

ObjectPhysicalMemoryAttributes: TobjectAttributes = ((

Länge: sizeof (tobjectattributes);

RootDirectory: 0;

Objektname: @ObjectphysicalMemoryName;

Attribute: OBJ_Case_inemsitiv;

SecurityDescriptor: Nil;

SecurityQualityofService: Nil;

);

Typ

TfnZWOPensection = Funktion (OUT SECTIONHANDLE: THANDLE;

Gewünschtes Access: Access_mask;

stdcall;

TfnrtlntStatustodoSerror = Funktion (Status: ntstatus): DWORD;

Const

ntdll = '' ntdll.dll '';

var

Zwopensektion: tfnzwopensection;

RtlntStatustodoSerror: tfnrtlntStatustodoSerror;

Funktion readrombiosnt (var buffer: pulbombiosdump; timeout: dword): boolean;

var

Ntlayer: hmodule;

Status: ntstatus;

Abschnitt: Thandle;

Ansicht: Zeiger;

Beginnen

Ergebnis: = falsch;

Ntlayer: = getModuleHandle (ntdll);

Wenn ntlayer = 0 dann

SetLasterror (error_call_not_implemented)

anders

Beginnen

wenn nicht zugewiesen (Zwopensektion) dann

Zwopensection: = GetProcaddress (ntlayer, '' zwopensection '');

Wenn nicht zugewiesen (rtlntStatustodoSError), dann dann

RtlntStatustodoSerror: = GetProcaddress (ntlayer, '' rtlntStatustodoSerror '');

wenn nicht

SetLasterror (error_call_not_implemented)

anders

Beginnen

Status: = Zwopensection (Abschnitt, ObjectPhysicalMemoryAccessmask,,

@ObjectphysicalMemoryAttributes);

Fallstatus von

Status_success:

/t versuchen

/t Ansicht: = MapViewoffile (Abschnitt, ObjectPhysicalMemoryAccessmask, 0,,

/t niedrig (TrombiosDump), Größe (TrombiosDump));

/t Wenn zugewiesen (Ansicht) dann

/t versuchen

/t fillchar (Puffer, Größe (TrombiosDump), 0);

/t Move (View^, Puffer, Größe (TrombiosDump));

/t Ergebnis: = wahr;

/T endlich

/t UnmapViewOfoffile (Ansicht);

/t Ende;

/T endlich

/t nahe Handle (Abschnitt);

/t Ende;

Status_access_denied:

/T Ergebnis: = Readrombios16 (Puffer, Zeitüberschreitungen);

anders

Setlasterror (rtlntStatustodoSerror (Status))

Ende;

#/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 # #

Funktion readrombios (var Dump: TrombiosDump; Methode: Treadrombiosmethode;

Timeout: dWord = unendlich): boolean;

Beginnen

Ergebnis: = falsch;

Fallmethode von

rrbmautomatisch:

if (Ganzzahl (Getversion) <0) dann

versuchen

Ergebnis: = Readrombios9X (Dump);

außer

Ergebnis: = Readrombios16 (Dump, Timeout);

Ende

anders

Ergebnis: = Readrombiosnt (Dump, Timeout);

rrbmgeneric:

Ergebnis: = Readrombios16 (Dump, Timeout);

rrbmmemory:

Ergebnis: = Readrombios9X (Dump);

rrbmphysical:

Ergebnis: = Readrombiosnt (Dump, Timeout);

anders

SetLasterRor (error_invalid_parameter);

Ende;

#/t/t/t/t/t/t/t/t/t/t/t/t/t # #

# Dienstprogramme, um den Zugriff auf Daten als generische Standardtypen zu vereinfachen #

#/t/t/t/t/t/t/t/t/t/t/t/t/t # #

Funktion getrombiosBuffer (const Dump: TrombiosDump; Adresse: Zeiger;

var puffer;

Beginnen

Ergebnisse: = 0;

if (kardinal (Adresse)> = niedrig (TrombiosDump)) und

(Kardinal (Adresse) <= hoch (TrombiosDump)) dann

Beginnen

Ergebnis: = puffersize;

if (kardinal (Adresse) + puffersize> hoch (TrombiosDump)) dann

Ergebnis: = hoch (TrombiosDump) - Kardinal (Adresse) + 1;

Move (Dump [Cardinal (Adresse)], Puffer, Ergebnis);

Ende;

Funktion getrombiosstring (const Dump: TrombiosDump; Adresse: Zeiger): String;

Beginnen

Ergebnisse: = '' ';

if (kardinal (Adresse)> = niedrig (TrombiosDump)) und

(Kardinal (Adresse) <= hoch (TrombiosDump)) dann

Ergebnis: = String (pChar (@dump [kardinal (adresse)]));

Ende;

Funktion getrombioslonglong (const Dump: TrombiosDump; Adresse: Zeiger): longlong;

Typ

Plonglong = ^longlong;

Beginnen

Ergebnisse: = 0;

if (kardinal (Adresse)> = niedrig (TrombiosDump)) und

(Kardinal (Adresse) <= hoch (TrombiosDump) - sizeof (longlong) + 1) Dann

Ergebnis: = Plonglong (@dump [kardinal (Adresse)])^;

Ende;

Funktion getrombiosdWord (const Dump: TrombiosDump; Adresse: Zeiger): DWORD;

Beginnen

Ergebnisse: = 0;

if (kardinal (Adresse)> = niedrig (TrombiosDump)) und

(Kardinal (Adresse) <= hoch (TrombiosDump) - Größe (DWORD) + 1) Dann

Ergebnis: = pDWord (@dump [kardinal (Adresse)])^;

Ende;

Funktion getrombiosword (const Dump: TrombiosDump; Adresse: Zeiger): Wort;

Beginnen

Ergebnisse: = 0;

if (kardinal (Adresse)> = niedrig (TrombiosDump)) und

(Kardinal (Adresse) <= hoch (TrombiosDump) - Größe (Wort) + 1) Dann

Ergebnis: = pWord (@dump [kardinal (Adresse)])^;

Ende;

Funktion getrombiosbyte (const Dump: TrombiosDump; Adresse: Zeiger): Byte;

Beginnen

Ergebnisse: = 0;

if (kardinal (Adresse)> = niedrig (TrombiosDump)) und

(Kardinal (Adresse) <= hoch (TrombiosDump) - Größe (Byte) + 1) Dann

Ergebnis: = pByte (@dump [kardinal (Adresse)])^;

Ende;

Ende.

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

{--------------------------------------------- ----------------------------------}

{Holen Sie sich die Datumsinformationen des BIOS, es wird geschätzt, dass es unter 2000 gelten kann, aber möglicherweise Erlaubnis erforderlich ist.}

Funktion getbiosDate1: String;

var

Puffer: Array [0..8] von Char;

N: DWORD;

Beginnen

ReadProcessMemory (getCurrentProcess,

PTR ($ ffff5),

@Puffer,

8,,

N);

Puffer [8]: = #0;

Ergebnis: = Strpas (Puffer)

Ende;

Funktion getbiosDate2: String;

Beginnen

Ergebnis: = String (pchar (ptr ($ ffff5)));

Ende;