1. Read the motherboard serial number
2. Read AWard Bios password
3. Read BIOS information
4. Obtain BIOS date information
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
1. Read the motherboard serial number
uses SHA1, Base64;
function GetHashedBiosInfo: string;
var
SHA1Context: TSHA1Context;
SHA1Digest: TSHA1Digest;
Begin
// Get the BIOS data
SetString(Result, PChar(Ptr($F0000)), $10000);
// Hash the string
SHA1Init(SHA1Context);
SHA1Update(SHA1Context, PChar(Result), Length(Result));
SHA1Final(SHA1Context, SHA1Digest);
SetString(Result, PChar(@SHA1Digest), sizeof(SHA1Digest));
// Return the hash string encoded in printable characters
Result := B64Encode(Result);
end;
function GetBiosInfoAsText: string;
var
p, q: pchar;
Begin
q := nil;
p := PChar(Ptr($FE000));
repeat
if q <> nil then begin
if not (p^ in [#10, #13, #32..#126, #169, #184]) then begin
/t if (p^ = #0) and (p - q >= 8) then begin
/t Result := Result + TrimRight(String(q)) + #13#10;
/t end;
/tq := nil;
end;
end else
if p^ in [#33..#126, #169, #184] then
/tq := p;
inc(p);
until p > PChar(Ptr($FFFFF));
Result := TrimRight(Result);
end;
procedure TForm1.FormCreate(Sender: TObject);
Begin
Memo1.Lines.Text := GetBiosInfoAsText;
end;
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
2. AWard Bios password reading (it should be a jingtao article, but the ID is not recorded)
Unit AwardBiosPas;
//Write by lovejingtao
//http://www.138soft.com
interface
uses windows,SysUtils;
function My_GetBiosPassword:String;
Implementation
function CalcPossiblePassword(PasswordValue: WORD): string;
var
I: BYTE;
C: CHAR;
S: string[8];
Begin
I := 0;
while PasswordValue <> 0 do
Begin
Inc(I);
if $263 > PasswordValue then
Begin
/t if $80 > PasswordValue then
/t S := CHAR(PasswordValue)
/t else if $B0 > PasswordValue then
/t S := CHAR(PasswordValue and $77)
/t else if $11D > PasswordValue then
/t S := CHAR($30 or (PasswordValue and $0F))
/t else if $114 > PasswordValue then
/t begin
/t S := CHAR($64 or (PasswordValue and $0F));
/t if ''0'' > S then
/t S := CHAR(BYTE(S ) + 8);
/t end
/t else if $1C2 > PasswordValue then
/t S := CHAR($70 or (PasswordValue and $03))
/t else if $1E4 > PasswordValue then
/t S := CHAR($30 or (PasswordValue and $03))
/t else
/t begin
/t S := CHAR($70 or (PasswordValue and $0F));
/t if ''z'' < S then
/t S := CHAR(BYTE(S ) - 8);
/t end;
end
else
S := CHAR($30 or (PasswordValue and $3));
PasswordValue := (PasswordValue - BYTE(S )) shr 2;
end;
S[0] := CHAR(I);
PasswordValue := I shr 1;
while PasswordValue < I do
begin {this is to do because award starts calculating with the last letter}
C := S[BYTE(S[0]) - I + 1];
S[BYTE(S[0]) - I + 1] := S ;
S := C;
Dec(I);
end;
CalcPossiblePassword := S;
end;
function readcmos(off: byte): byte;
var
value: byte;
Begin
asm
xor ax, ax
mov al, off
out 70h, al
in al, 71h
mov value, al
end;
readcmos := value;
end;
function My_GetBiosPassword:String;
var
superpw, userpw: word;
S:String;
Begin
if Win32Platform <> VER_PLATFORM_WIN32_NT then //Not NT
Begin
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 is:''+CalcPossiblePassword(superpw)+#13+''The user password is:''+CalcPossiblePassword(userpw);
Results:=S;
end
else
Result:=''The user system is NT, and the BISO password cannot be obtained!'';
end;
end.
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
3. Read BIOS information
{The program uses Windows 95/2000 platform, automatically detects the system type, and then makes different calls}
uses BiosHelp;
procedure TForm1.Button1Click(Sender: TObject);
var
Dump: TRomBiosDump;
i: Integer;
Begin
ReadRomBios(Dump, rrbmAutomatic);
for i := 1 to $000FFFFF - $000F0000 - 1 do
Memo1.Lines.Add(IntToHex(Dump[i + $000FFFFF], 2));
end;
(************************************************* ************************************
*/t/t/t/t/t/t/t/t/t/t/t/t *
* BIOS Help - read ROM BIOS on Windows 95/98/SE/ME/NT/2K/XP/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 *
* 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 *
********************************************************* ***************************************)
{ postum scriptum: sorry for the bad english, i wrote it in a hurry }
unit BiosHelp;
{$ALIGN ON}
{$MINENUMSIZE 4}
interface
uses
Windows;
type
PRomBiosDump = ^TRomBiosDump;
TRomBiosDump = array[$000F0000..$000FFFF] of Byte;
type
TReadRomBiosMethod = (
rrbmAutomatic,/t/t/t/t/t { Autodetect OS type and use proper method }
rrbmGeneric,/t/t/t/t/t/t { Use 16-bit COM program to dump the BIOS }
rrbmMemory,/t/t/t/t/t { Read from memory (Win9x)/t/t }
rrbmPhysical/t/t/t/t/t { Read from physical memory object (WinNT) }
);
function ReadRomBios(var Dump: TRomBiosDump; Method: TReadRomBiosMethod;
Timeout: DWORD = INFINITE): Boolean;
function GetRomBiosBuffer(const Dump: TRomBiosDump; Address: Pointer;
var Buffer; BufferSize: Cardinal): Cardinal;
function GetRomBiosString(const Dump: TRomBiosDump; Address: Pointer): string;
function GetRomBiosLongLong(const Dump: TRomBiosDump; Address: Pointer): LONGLONG;
function GetRomBiosDWord(const Dump: TRomBiosDump; Address: Pointer): DWORD;
function GetRomBiosWord(const Dump: TRomBiosDump; Address: Pointer): Word;
function GetRomBiosByte(const Dump: TRomBiosDump; Address: Pointer): Byte;
Implementation
{################################################################################################# ######################################################
#/t/t/t/t/t/t/t/t/t/t/t/t #
#/t/t/t GENERIC METHOD/t/t/t/t #
#/t/t/t/t/t/t/t/t/t/t/t/t #
# Create an temporary folder, save an 16bit COM program (RomDump.com) into it, #
# execute program redirected to an file (Rom.dmp, RomDump.com simply dumps the #
# memory range F000:0000-F000:FFFF to STDOUT), read dump file into the buffer, #
# and finally cleanup all temporary files and directories./t/t #
#/t/t/t/t/t/t/t/t/t/t/t/t #
# (the function RomDumpCode is x86 specific, which i wrote to generate 16-bit #
# code with the help of the 23-bit Delphi compiler, never try to execute the #
# pseudo-code in your program! it will not work in 32-bit protected mode) #
#/t/t/t/t/t/t/t/t/t/t/t/t #
######################################################################################### ##################################################}
{ *INTERNAL* - Pseudo 16-bit code }
type
PRomDumpCodeInfo = ^TRomDumpCodeInfo;
TRomDumpCodeInfo = (rdciStart, rdciEnd, rdciSize);
function _RomDumpCode(Info: TRomDumpCodeInfo): Pointer;
var
CodeStart: Pointer;
CodeEnd: Pointer;
Begin
asm
/t JMP @@End
/t { *BEGIN* 16-bit code }
/t { -- never use it in your program! -- }
/t { COM which writes ROM-BIOS to StdOut }
@@Start:
/t { Dump F000:0000-F000:FFFE }
/t XOR eDX, eDX // DS = 0xF000 ; Data segment
/t MOV DH, 0F0h
/t MOV DS, eDX
/t XOR eDX, eDX // DX = 0x0000 ; Data offset
/t XOR eCX, eCX // CX = 0xFFFF ; Data length
/t DEC eCX
/t XOR eBX, eBX // BX = 0x0001 ; STDOUT (file handle)
/t INC eBX
/t MOV AH, 40h // DosCall(0x40) ; INT21, DOS_WRITE_TO_HANDLE
/t INT 21h
/t JC @@Exit // On error exit ; AL = Error code
/t { Dump F000:FFFF }
/t XOR eDX, eDX // DS = 0xF000 ; Data segment
/t MOV DH, 0F0h
/t MOV DS, eDX
/t XOR eDX, eDX // DX = 0xFFFF ; Data offset
/t DEC eDX
/t XOR eCX, eCX // CX = 0x0001 ; Data length
/t INC eCX
/t MOV eBX, eCX // BX = 0x0001 ; STDOUT (file handle)
/t MOV AH, 40h // DosCall(0x40) ; INT21, DOS_WRITE_TO_HANDLE
/t INT 21h
/t JC @@Exit // On error exit ; AL = Error code
/t MOV AL, 0 // no error ; AL = 0
@@Exit:
/t MOV AH, 4Ch // DosCall(0x4C); INT21, DOS_TERMINATE_EXE
/t INT 21h
@@End:
/t { *END* 16-bit code }
/t MOV CodeStart, OFFSET @@Start
/t MOV CodeEnd, OFFSET @@End
end;
case Info of
rdciStart:
Result := CodeStart;
rdciEnd:
Result := CodeEnd;
rdciSize:
Result := Pointer(Cardinal(CodeEnd) - Cardinal(CodeStart));
else
Result := nil;
end;
end;
{ *INTERNAL* - Save 16-bit code to file }
function _RomDumpCodeToFile(const Filename: string): Boolean;
var
Comfile: THandle;
Size: Cardinal;
Begin
Result := False;
ComFile := CreateFile(PChar(Filename), GENERIC_WRITE, FILE_SHARE_READ, nil,
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
if ComFile <> INVALID_HANDLE_VALUE then
try
Result := WriteFile(ComFile, _RomDumpCode(rdciStart)^,
Cardinal(_RomDumpCode(rdciSize)), Size, nil) and
(Size = Cardinal(_RomDumpCode(rdciSize)));
If not Results then
DeleteFile(PChar(Filename));
Finally
CloseHandle(ComFile);
end;
end;
{ *INTERNAL* - Execute 16-bit code redirected to file }
function _RomDumpCodeExecute(const Com, Dmp: string; Timeout: DWORD): Boolean;
var
ComSpec: string;
si: TStartupInfo;
pi: TProcessInformation;
Begin
Result := False;
SetLength(ComSpec, MAX_PATH);
SetLength(ComSpec,
GetEnvironmentVariable(''ComSpec'', PChar(@ComSpec[1]), MAX_PATH));
if Length(ComSpec) > 0 then
Begin
FillChar(si, SizeOf(TStartupInfo), 0);
si.cb := SizeOf(TStartupInfo);
si.dwFlags := STARTF_USESHOWWINDOW;
si.wShowWindow := SW_HIDE;
if CreateProcess(nil, PChar(ComSpec + '' /C '' + Com + '' > '' + Dmp),
nil, nil, False, CREATE_NEW_CONSOLE or CREATE_NEW_PROCESS_GROUP, nil,
nil, si, pi) then
try
Result := WaitForSingleObject(pi.hProcess, Timeout) <> WAIT_TIMEOUT;
Finally
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
end;
end;
end;
function DirectoryExists(const Dir: string): Boolean;
var
Attr: DWORD;
Begin
Attr := GetFileAttributes(PChar(Dir));
Result := (Attr <> $FFFFFFFF) and
(Attr and FILE_ATTRIBUTE_DIRECTORY = FILE_ATTRIBUTE_DIRECTORY);
end;
{ Get BIOS dump the generic way }
function ReadRomBios16(var Buffer: TRomBiosDump; Timeout: DWORD): Boolean;
const
TempSub = ''~RomDmp'';
ComName = ''RomDump.com'';
DmpName = ''Rom.dmp'';
var
TempPath: string;
TempDir: string;
TempIdx: Integer;
TempIdxStr: string;
Comfile: string;
Dmpfile: string;
DmpHandle: THandle;
Written: DWORD;
Begin
Result := False;
SetLength(TempPath, MAX_PATH);
SetLength(TempPath, GetTempPath(MAX_PATH, PChar(@TempPath[1])));
if Length(TempPath) > 0 then
Begin
if (TempPath[Length(TempPath)] <> ''/'') then
TempPath := TempPath + ''/'';
TempIdx := 0;
repeat
Inc(TempIdx);
Str(TempIdx, TempIdxStr);
TempDir := TempPath + TempSub + TempIdxStr;
until not DirectoryExists(TempDir);
if CreateDirectory(PChar(TempDir), nil) then
try
TempDir := TempDir + ''/'';
ComFile := TempDir + ComName;
DmpFile := TempDir + DmpName;
if _RomDumpCodeToFile(ComFile) then
try
if _RomDumpCodeExecute(ComFile, DmpFile, Timeout) then
Begin
/t DmpHandle := CreateFile(PChar(DmpFile), GENERIC_READ,
/t FILE_SHARE_READ or FILE_SHARE_WRITE, nil, OPEN_EXISTING, 0, 0);
/t if DmpHandle <> INVALID_HANDLE_VALUE then
/t try
/t FillChar(Buffer, SizeOf(TRomBiosDump), 0);
/t Result := ReadFile(DmpHandle, Buffer, SizeOf(TRomBiosDump),
/t Written, nil) and (Written = SizeOf(TRomBiosDump));
/t finally
/t CloseHandle(DmpHandle);
/t end;
end;
Finally
DeleteFile(PChar(DmpFile));
DeleteFile(PChar(ComFile));
end;
Finally
RemoveDirectory(PChar(TempDir));
end;
end;
end;
{################################################################################################# ######################################################
#/t/t/t/t/t/t/t/t/t/t/t/t #
#/t/t/t DIRECT METHOD (Win9x)/t/t/t #
#/t/t/t/t/t/t/t/t/t/t/t/t #
# Due to the fact that Windows 95/98/ME maps the BIOS into every Win32 process #
# for read access it is very simple to fill the buffer from memory./t #
#/t/t/t/t/t/t/t/t/t/t/t/t #
########################################################################################## ##################################################}
function ReadRomBios9x(var Buffer: TRomBiosDump): Boolean;
Begin
Result := False;
try
FillChar(Buffer, SizeOf(TRomBiosDump), 0);
Move(Pointer(Low(TRomBiosDump))^, Buffer, SizeOf(TRomBiosDump));
Result := True;
except
// ignore exceptions
end
end;
{################################################################################################## ######################################################
#/t/t/t/t/t/t/t/t/t/t/t/t #
#/t/t PHYSICAL MEMORY METHOD (WinNT)/t/t/t #
#/t/t/t/t/t/t/t/t/t/t/t/t #
# On Windows NT the ROM BIOS is only available through the named kernel object #
# ''/Device/PhysicalMemory''. Because it is impossible to open kernel objects in #
# user mode with standard Win32 API functions we make use of NT''s nativeAPI in #
# NtDll.dll ("NT-Layer") namely ZwOpenSection./t/t/t/t #
#/t/t/t/t/t/t/t/t/t/t/t/t #
# (note: mostly there are two versions of every function ZwXxx and NtXxx. The #
# only difference in kernel mode is that the NtXxx version works in consider- #
# ration to security while ZwXxx not. But in user mode both work like NtXxx.) #
#/t/t/t/t/t/t/t/t/t/t/t/t #
# At first the section is opened with ZwOpenSection. Normally we would proceed #
# ZwMapViewOfSection, ZwUnmapViewOfSection, and NtClose. But the functions are #
# more complex and there is no needing for it. With the handle (because we are #
# in the "very simple" user mode =) we now use MapViewOfFile, UnmapViewOfFile, #
# and CloseHandle to map an memory window (the ROM BIOS) into our process. #
#/t/t/t/t/t/t/t/t/t/t/t/t #
# Due to the fact that ZwOpenSection returns NT error-codes in case of failure #
# we have to translate it to an Win32 error-code (RtlNtStatusToDosError). #
# All NT specific functions are dynamically loaded -- because the applications #
# should start on Win9x systems =)/t/t/t/t/t/t #
#/t/t/t/t/t/t/t/t/t/t/t/t #
######################################################################################### ##################################################}
{ For more information see Windows 2000/XP DDK }
{ It works on Windows NT 4.0 too, use NtDll.dll }
type
NTSTATUS = Integer;
const
STATUS_SUCCESS = NTSTATUS(0);
STATUS_INVALID_HANDLE = NTSTATUS($C0000008);
STATUS_ACCESS_DENIED = NTSTATUS($C0000022);
type
PUnicodeString = ^TUnicodeString;
TUnicodeString = packed record
Length: Word;
MaximumLength: Word;
Buffer: PWideChar;
end;
const
OBJ_INHERIT = $00000002;
OBJ_PERMANENT = $00000010;
OBJ_EXCLUSIVE = $00000020;
OBJ_CASE_INSENSITIVE = $00000040;
OBJ_OPENIF = $00000080;
OBJ_OPENLINK = $00000100;
OBJ_KERNEL_HANDLE = $00000200;
OBJ_VALID_ATTRIBUTES = $000003F2;
type
PObjectAttributes = ^TObjectAttributes;
TObjectAttributes = record
Length: ULONG;
RootDirectory: THandle;
ObjectName: PUnicodeString;
Attributes: ULONG;
SecurityDescriptor: PSCurityDescriptor;
SecurityQualityOfService: PScurityQualityOfService;
end;
const
ObjectPhysicalMemoryDeviceName = ''/Device/PhysicalMemory'';
ObjectPhysicalMemoryName: TUnicodeString = (
Length: Length(ObjectPhysicalMemoryDeviceName) * 2;
MaximumLength: Length(ObjectPhysicalMemoryDeviceName) * 2 + 2;
Buffer: ObjectPhysicalMemoryDeviceName;
);
ObjectPhysicalMemoryAccessMask: ACCESS_MASK = SECTION_MAP_READ;
ObjectPhysicalMemoryAttributes: TObjectAttributes = (
Length: SizeOf(TObjectAttributes);
RootDirectory: 0;
ObjectName: @ObjectPhysicalMemoryName;
Attributes: OBJ_CASE_INSENSITIVE;
SecurityDescriptor: nil;
SecurityQualityOfService: nil;
);
type
TFNZwOpenSection = function(out SectionHandle: THandle;
DesiredAccess: ACCESS_MASK; ObjectAttributes: PObjectAttributes): NTSTATUS;
stdcall;
TFNRtlNtStatusToDosError = function(Status: NTSTATUS): DWORD; stdcall;
const
ntdll = ''ntdll.dll'';
var
ZwOpenSection: TFNZwOpenSection;
RtlNtStatusToDosError: TFNRtlNtStatusToDosError;
function ReadRomBiosNt(var Buffer: TRomBiosDump; Timeout: DWORD): Boolean;
var
NtLayer: HMODULE;
Status: NTSTATUS;
Section: THandle;
View: Pointer;
Begin
Result := False;
NtLayer := GetModuleHandle(ntdll);
if NtLayer = 0 then
SetLastError(ERROR_CALL_NOT_IMPLEMENTED)
else
Begin
if not Assigned(ZwOpenSection) then
ZwOpenSection := GetProcAddress(NtLayer, ''ZwOpenSection'');
if not Assigned(RtlNtStatusToDosError) then
RtlNtStatusToDosError := GetProcAddress(NtLayer, ''RtlNtStatusToDosError'');
if not (Assigned(ZwOpenSection) and Assigned(RtlNtStatusToDosError)) then
SetLastError(ERROR_CALL_NOT_IMPLEMENTED)
else
Begin
Status := ZwOpenSection(Section, ObjectPhysicalMemoryAccessMask,
@ObjectPhysicalMemoryAttributes);
case Status of
STATUS_SUCCESS:
/t try
/t View := MapViewOfFile(Section, ObjectPhysicalMemoryAccessMask, 0,
/t Low(TRomBiosDump), SizeOf(TRomBiosDump));
/t if Assigned(View) then
/t try
/t FillChar(Buffer, SizeOf(TRomBiosDump), 0);
/t Move(View^, Buffer, SizeOf(TRomBiosDump));
/t Result := True;
/t finally
/t UnmapViewOfFile(View);
/t end;
/t finally
/t CloseHandle(Section);
/t end;
STATUS_ACCESS_DENIED:
/t Result := ReadRomBios16(Buffer, Timeout);
else
SetLastError(RtlNtStatusToDosError(Status))
end;
end;
end;
end;
{################################################################################################## ######################################################
#/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 #
########################################################################################## ##################################################}
function ReadRomBios(var Dump: TRomBiosDump; Method: TReadRomBiosMethod;
Timeout: DWORD = INFINITE): Boolean;
Begin
Result := False;
case Method of
rrbmAutomatic:
if (Integer(GetVersion) < 0) then
try
Result := ReadRomBios9x(Dump);
except
Result := ReadRomBios16(Dump, Timeout);
end
else
Result := ReadRomBiosNt(Dump, Timeout);
rrbmGeneric:
Result := ReadRomBios16(Dump, Timeout);
rrbmMemory:
Result := ReadRomBios9x(Dump);
rrbmPhysical:
Result := ReadRomBiosNt(Dump, Timeout);
else
SetLastError(ERROR_INVALID_PARAMETER);
end;
end;
{################################################################################################# ######################################################
#/t/t/t/t/t/t/t/t/t/t/t/t #
# Utilities to simplify the access to data as generic standard types #
#/t/t/t/t/t/t/t/t/t/t/t/t #
######################################################################################### ##################################################}
function GetRomBiosBuffer(const Dump: TRomBiosDump; Address: Pointer;
var Buffer; BufferSize: Cardinal): Cardinal;
Begin
Results := 0;
if (Cardinal(Address) >= Low(TRomBiosDump)) and
(Cardinal(Address) <= High(TRomBiosDump)) then
Begin
Result := BufferSize;
if (Cardinal(Address) + BufferSize > High(TRomBiosDump)) then
Result := High(TRomBiosDump) - Cardinal(Address) + 1;
Move(Dump[Cardinal(Address)], Buffer, Result);
end;
end;
function GetRomBiosString(const Dump: TRomBiosDump; Address: Pointer): string;
Begin
Results := '''';
if (Cardinal(Address) >= Low(TRomBiosDump)) and
(Cardinal(Address) <= High(TRomBiosDump)) then
Result := string(PChar(@Dump[Cardinal(Address)]));
end;
function GetRomBiosLongLong(const Dump: TRomBiosDump; Address: Pointer): LONGLONG;
type
PLongLong = ^LONGLONG;
Begin
Results := 0;
if (Cardinal(Address) >= Low(TRomBiosDump)) and
(Cardinal(Address) <= High(TRomBiosDump) - SizeOf(LONGLONG) + 1) then
Result := PLongLong(@Dump[Cardinal(Address)])^;
end;
function GetRomBiosDWord(const Dump: TRomBiosDump; Address: Pointer): DWORD;
Begin
Results := 0;
if (Cardinal(Address) >= Low(TRomBiosDump)) and
(Cardinal(Address) <= High(TRomBiosDump) - SizeOf(DWORD) + 1) then
Result := PDWORD(@Dump[Cardinal(Address)])^;
end;
function GetRomBiosWord(const Dump: TRomBiosDump; Address: Pointer): Word;
Begin
Results := 0;
if (Cardinal(Address) >= Low(TRomBiosDump)) and
(Cardinal(Address) <= High(TRomBiosDump) - SizeOf(Word) + 1) then
Result := PWord(@Dump[Cardinal(Address)])^;
end;
function GetRomBiosByte(const Dump: TRomBiosDump; Address: Pointer): Byte;
Begin
Results := 0;
if (Cardinal(Address) >= Low(TRomBiosDump)) and
(Cardinal(Address) <= High(TRomBiosDump) - SizeOf(Byte) + 1) then
Result := PByte(@Dump[Cardinal(Address)])^;
end;
end.
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
4. Obtain BIOS date information
{------------------------------------------------- ---------------------------------}
{get the date information of the BIOS, it is estimated that it may apply under 2000, but it may require permission}
function GetBiosDate1: String;
var
Buffer: Array[0..8] Of Char;
N: DWORD;
Begin
ReadProcessMemory(GetCurrentProcess,
Ptr($FFFF5),
@Buffer,
8,
N);
Buffer[8] := #0;
result := StrPas(Buffer)
end;
function GetBiosDate2: String;
Begin
result := string(pchar(ptr($FFFF5)));
end;