마더보드 일련 번호 읽기

        _delphi Delphi    - delphi2007.net
http://www.delphi2007.net/delphiblog/html/delphi_20048251109524910.html

1、       

2、AWard Bios    

3、  BIOS  

4、  BIOS    



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

1、       



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 

         if (p^ = #0) and (p - q >= 8) then begin 

           Result := Result + TrimRight(String(q)) + #13#10; 

         end; 

         q := nil; 

       end; 

     end else 

       if p^ in [#33..#126, #169, #184] then 

         q := 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    (   jingtao   ，  ID    )

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

         if $80 > PasswordValue then

           S[I] := CHAR(PasswordValue)

         else if $B0 > PasswordValue then

           S[I] := CHAR(PasswordValue and $77)

         else if $11D > PasswordValue then

           S[I] := CHAR($30 or (PasswordValue and $0F))

         else if $114 > PasswordValue then

           begin

             S[I] := CHAR($64 or (PasswordValue and $0F));

             if '0' > S[I] then

               S[I] := CHAR(BYTE(S[I]) + 8);

           end

         else if $1C2 > PasswordValue then

           S[I] := CHAR($70 or (PasswordValue and $03))

         else if $1E4 > PasswordValue then

           S[I] := CHAR($30 or (PasswordValue and $03))

         else

           begin

             S[I] := CHAR($70 or (PasswordValue and $0F));

             if 'z' < S[I] then

               S[I] := CHAR(BYTE(S[I]) - 8);

           end;

       end

     else

       S[I] := CHAR($30 or (PasswordValue and $3));

     PasswordValue := (PasswordValue - BYTE(S[I])) 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[I];

     S[I] := 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 //  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:='       :'+CalcPossiblePassword(superpw)+#13+'     :'+CalcPossiblePassword(userpw);

 Result:=S;

 end

 else

 Result:='     NT,    BISO  !';

 end;

end.



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

3、  BIOS  

{    Windows 95/2000  ，        ，        }

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;

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

*                                                                              *

* BIOS Help - read ROM BIOS on Windows 95/98/SE/ME/NT/2K/XP                    *

*                                                                              *

* Copyright (C) 2001, Nico Bendlin ([email protected])                           *

*                                                                              *

* Compiler: Delphi 4.03/5.01/6.00                                              *

* Version: 1.03, 2001-09-02                                                    *

*                                                                              *

*******************************************************************************)



{ 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..$000FFFFF] of Byte;



type

 TReadRomBiosMethod = (

   rrbmAutomatic,                                          { Autodetect OS type and use proper method }

   rrbmGeneric,                                            { Use 16-bit COM program to dump the BIOS  }

   rrbmMemory,                                             { Read from memory (Win9x)                 }

   rrbmPhysical                                            { 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



{###############################################################################

#                                                                              #

#                             GENERIC METHOD                                   #

#                                                                              #

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

#                                                                              #

# (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)     #

#                                                                              #

###############################################################################}



{ *INTERNAL* - Pseudo 16-bit code }



type

 PRomDumpCodeInfo = ^TRomDumpCodeInfo;

 TRomDumpCodeInfo = (rdciStart, rdciEnd, rdciSize);



function _RomDumpCode(Info: TRomDumpCodeInfo): Pointer;

var

 CodeStart: Pointer;

 CodeEnd: Pointer;

begin

 asm

         JMP     @@End



         { *BEGIN* 16-bit code  }

         { -- never use it in your program! -- }

         { COM which writes ROM-BIOS to StdOut }

 @@Start:

         { Dump F000:0000-F000:FFFE }

         XOR     eDX, eDX  // DS = 0xF000   ; Data segment

         MOV     DH, 0F0h

         MOV     DS, eDX

         XOR     eDX, eDX  // DX = 0x0000   ; Data offset

         XOR     eCX, eCX  // CX = 0xFFFF   ; Data length

         DEC     eCX

         XOR     eBX, eBX  // BX = 0x0001   ; STDOUT (file handle)

         INC     eBX

         MOV     AH, 40h   // DosCall(0x40) ; INT21, DOS_WRITE_TO_HANDLE

         INT     21h

         JC      @@Exit    // On error exit ; AL = Error code

         { Dump F000:FFFF }

         XOR     eDX, eDX  // DS = 0xF000   ; Data segment

         MOV     DH, 0F0h

         MOV     DS, eDX

         XOR     eDX, eDX  // DX = 0xFFFF   ; Data offset

         DEC     eDX

         XOR     eCX, eCX  // CX = 0x0001   ; Data length

         INC     eCX

         MOV     eBX, eCX  // BX = 0x0001   ; STDOUT (file handle)

         MOV     AH, 40h   // DosCall(0x40) ; INT21, DOS_WRITE_TO_HANDLE

         INT     21h

         JC      @@Exit    // On error exit ; AL = Error code

         MOV     AL, 0     // no error      ; AL = 0

 @@Exit:

         MOV     AH, 4Ch   // DosCall(0x4C) ; INT21, DOS_TERMINATE_EXE

         INT     21h

 @@End:

         { *END* 16-bit code  }



         MOV     CodeStart, OFFSET @@Start

         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 Result 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

         DmpHandle := CreateFile(PChar(DmpFile), GENERIC_READ,

           FILE_SHARE_READ or FILE_SHARE_WRITE, nil, OPEN_EXISTING, 0, 0);

         if DmpHandle <> INVALID_HANDLE_VALUE then

         try

           FillChar(Buffer, SizeOf(TRomBiosDump), 0);

           Result := ReadFile(DmpHandle, Buffer, SizeOf(TRomBiosDump),

             Written, nil) and (Written = SizeOf(TRomBiosDump));

         finally

           CloseHandle(DmpHandle);

         end;

       end;

     finally

       DeleteFile(PChar(DmpFile));

       DeleteFile(PChar(ComFile));

     end;

   finally

     RemoveDirectory(PChar(TempDir));

   end;

 end;

end;



{###############################################################################

#                                                                              #

#                           DIRECT METHOD (Win9x)                              #

#                                                                              #

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

#                                                                              #

###############################################################################}



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;



{###############################################################################

#                                                                              #

#                       PHYSICAL MEMORY METHOD (WinNT)                         #

#                                                                              #

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

#                                                                              #

# (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 conside-  #

#  ration to security while ZwXxx not. But in user mode both work like NtXxx.) #

#                                                                              #

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

#                                                                              #

# 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 =)                                             #

#                                                                              #

###############################################################################}



{ 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: PSecurityDescriptor;

   SecurityQualityOfService: PSecurityQualityOfService;

 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:

         try

           View := MapViewOfFile(Section, ObjectPhysicalMemoryAccessMask, 0,

             Low(TRomBiosDump), SizeOf(TRomBiosDump));

           if Assigned(View) then

           try

             FillChar(Buffer, SizeOf(TRomBiosDump), 0);

             Move(View^, Buffer, SizeOf(TRomBiosDump));

             Result := True;

           finally

             UnmapViewOfFile(View);

           end;

         finally

           CloseHandle(Section);

         end;

       STATUS_ACCESS_DENIED:

         Result := ReadRomBios16(Buffer, Timeout);

     else

       SetLastError(RtlNtStatusToDosError(Status))

     end;

   end;

 end;

end;



{###############################################################################

#                                                                              #

#                               ReadRomBios                                    #

#                                                                              #

###############################################################################}



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;



{###############################################################################

#                                                                              #

#     Utilities to simplify the access to data as generic standard types       #

#                                                                              #

###############################################################################}



function GetRomBiosBuffer(const Dump: TRomBiosDump; Address: Pointer;

 var Buffer; BufferSize: Cardinal): Cardinal;

begin

 Result := 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

 Result := '';

 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

 Result := 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

 Result := 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

 Result := 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

 Result := 0;

 if (Cardinal(Address) >= Low(TRomBiosDump)) and

   (Cardinal(Address) <= High(TRomBiosDump) - SizeOf(Byte) + 1) then

   Result := PByte(@Dump[Cardinal(Address)])^;

end;



end.



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

4、  BIOS    



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

{  BIOS     ，     2000   ，          }

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;