1. Lesen Sie die Seriennummer der Motherboard
2. Lesen Sie das BIOS -Kennwort für das BIOS
3.. Lesen Sie die BIOS -Informationen
V.
=========================================
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 *
* Copyright (C) 2001, Nico Bendlin ([email protected])/t/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;
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;
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;
Ende;
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;
Ende;
Ende;
{##################################################################################################### zu erhalten ################################################# ## ## ####################################################################################################################### zu erhalten ##
#/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 # #
####################################################################################################################### zu erhalten ############################################################################################################################### zurild ########################################}}
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;
{##################################################################################################### zu erhalten ################################################# ## ## ####################################################################################################################### zu erhalten ##
#/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 # #
####################################################################################################################### zu erhalten ############################################################################################################################### zurild ########################################}}
{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;
Ende;
Ende;
Ende;
{##################################################################################################### zu erhalten ################################################# ## ## ####################################################################################################################### zu erhalten ##
#/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 # #
####################################################################################################################### zu erhalten ############################################################################################################################### zurild ########################################}}
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;
Ende;
{##################################################################################################### zu erhalten ################################################# ## ## ####################################################################################################################### zu erhalten ##
#/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 # #
####################################################################################################################### zu erhalten ############################################################################################################################### zurild ########################################}}
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;
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.
==========================================
V.
{--------------------------------------------- ----------------------------------}
{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;