마더 보드 바이오스에 대한 정보를 얻으십시오

저자：Eve Cole 업데이트 시간：2025-03-08 16:48:02

1. 마더 보드 일련 번호를 읽으십시오

2. 수상 BIOS 비밀번호를 읽으십시오

3. BIOS 정보를 읽으십시오

4. BIOS 날짜 정보를 얻으십시오

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

1. 마더 보드 일련 번호를 읽으십시오

SHA1, Base64를 사용하고;

기능 gethashedbiosinfo : String;

var

SHA1CONTEXT : TSHA1CONTEXT;

sha1digest : tsha1digest;

시작하다

// BIOS 데이터를 가져옵니다

setString (결과, pchar (ptr ($ f0000)), $ 100000);

// 문자열 해시

sha1init (sha1context);

sha1update (sha1context, pchar (결과), 길이 (결과));

sha1final (sha1context, sha1digest);

setString (결과, pchar (@sha1digest), sizeof (sha1digest));

// 인쇄 가능한 문자로 인코딩 된 해시 문자를 반환합니다

결과 : = b64encode (결과);

끝;

함수 getbiosinfoastext : String;

var

P, Q : PCHA;

시작하다

Q : = nil;

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

반복하다

q <> nil이 시작되면 시작하십시오

그렇지 않은 경우 ([ #10, #13, #32 .. #126, #169, #184]에서 시작한 다음 시작하십시오.

/t if (p^ = #0) 및 (P- Q> = 8) 그런 다음 시작합니다.

/t 결과 : = 결과 + trimright (문자열 (q)) + #13 #10;

/추세;

/tq : = nil;

끝;

다른 끝

[ #33 .. #126, #169, #184]에서 p^가 있다면

/tq : = p;

Inc (p);

p> pchar (ptr ($ fffff))까지;

결과 : = trimright (결과);

끝;

절차 tform1. formcreate (sender : tobject);

시작하다

memo1.lines.text : = getbiosinfoastext;

끝;

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

2. 수상 BIOS 비밀번호 읽기 (Jingtao 기사이어야하지만 ID는 기록되지 않아야합니다)

단원 상;

// LoveJingtao의 쓰기

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

인터페이스

창, sysutils를 사용합니다.

함수 my_getbiospassword : 문자열;

구현

함수 calcpossiblepassword (passwordValue : Word) : 문자열;

var

I : 바이트;

C : char;

S : 문자열 [8];

시작하다

I : = 0;

PasswordValue <> 0은 수행합니다

시작하다

Inc (i);

$ 263> passwordValue라면

시작하다

/t는 $ 80> passwordValue입니다

/t s : = char (passwordValue)

/t 다른 경우 $ b0> passwordValue

/t s : = char (passwordValue 및 $ 77)

/t one 경우 $ 11d> passwordValue라면

/t s : = char ($ 30 또는 (passwordValue 및 $ 0f))

/t 다른 경우 $ 114> passwordValue

/t 시작

/t s : = char ($ 64 또는 (passwordValue 및 $ 0f));

/t이면 ''0 ''> s 라면

/t s : = char (바이트 (s ) + 8);

/추세

/t 다른 경우 1c2> passwordValue라면

/t s : = char ($ 70 또는 (passwordValue 및 $ 03))

/t 다른 경우 $ 1e4> passwordValue라면

/t s : = char ($ 30 또는 (passwordValue 및 $ 03))

/t else

/t 시작

/t s : = char ($ 70 또는 (passwordValue 및 $ 0f));

/t if ''z ''<s 다음

/t S : = char (바이트 (s ) -8);

/추세;

끝

또 다른

s : = char ($ 30 또는 (passwordValue 및 $ 3));

passwordValue : = (PasswordValue -Byte (S )) SHR 2;

끝;

s [0] : = char (i);

passwordValue : = i shr 1;

PasswordValue <나는 그렇습니다

시작 {이것은 마지막 편지로 계산을 시작하기 때문에해야 할 것입니다}

C : = s [byte (s [0]) -I + 1];

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

S : = C;

12 월 (i);

끝;

calcpossible password : = s;

끝;

함수 readCMOS (OFF : 바이트) : 바이트;

var

가치 : 바이트;

시작하다

ASM

xor 도끼, 도끼

Mov al, Off

70h, al

Al, 71h

이동 가치, al

끝;

readcmos : = value;

끝;

함수 my_getbiospassword : 문자열;

var

superpw, userpw : Word;

S : 문자열;

시작하다

win32platform <> ver_platform_win32_nt 인 경우 // nt

시작하다

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 : = ''슈퍼 버스터 암호는 다음과 같습니다.

결과 : = S;

끝

또 다른

결과 : = ''사용자 시스템은 NT이고 비소 암호를 얻을 수 없습니다! ';

끝;

끝.

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

3. BIOS 정보를 읽으십시오

{프로그램은 Windows 95/2000 플랫폼을 사용하여 시스템 유형을 자동으로 감지 한 다음 다른 호출을합니다.}

bioshelp를 사용합니다.

절차 tform1.Button1click (sender : tobject);

var

덤프 : TrombioSdump;

I : 정수;

시작하다

readrombios (덤프, rrbmautomatic);

i : = 1 ~ $ 000fffff- $ 000f0000-1 do

memo1.lines.add (inttohex (덤프 [i + $ 000ffff], 2));

끝;

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

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

* BIOS 도움말 -Windows 95/98/SE/ME/NT/2K/XP/T/T에서 ROM BIOS 읽기 *

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

* 컴파일러 : Delphi 4.03/5.01/6.00/t/t/t/t/t/t/t *

* 버전 : 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/t *

***************************************************************************************** 누군가 ***********************************************)

{Postum Scriptum : 영어가 나쁘다는 죄송합니다. 서둘러 썼습니다}

단위 바이오 셀프;

{$ Align On}

{$ minenumsize 4}

인터페이스

용도

창;

유형

PROMBIOSDUMP = ^TROMBIOSDUMP;

Trombiosdump = 배열 [$ 000f0000 .. $ 000ffff]의 바이트;

유형

Treadrombiosmethod = (

rrbmautomatic,/t/t/t/t/t {AutoDetect OS 유형 및 적절한 방법 사용}

rrbmgeneric,/t/t/t/t/t/t {16 비트 COM 프로그램을 사용하여 BIOS를 덤프하십시오}

rrbmmemory,/t/t/t/t/t {메모리에서 읽기 (win9x)/t/t}

rrbmphysical/t/t/t/t/t {물리적 메모리 객체 (winnt)에서 읽기}}

);

함수 readrombios (var dump : trombiosdump; 메소드 : Treadrombiosmethod;

시간 초과 : dword = infinite) : 부울;

함수 getRombiosBuffer (const 덤프 : TrombioSdump; 주소 : 포인터;

var 버퍼;; 버퍼 크기 : 추기경) : 추기경;

함수 getRombiostring (const 덤프 : trombiosdump; 주소 : 포인터) : 문자열;

함수 getRombioslonglong (const 덤프 : trombiosdump; 주소 : 포인터) : longlong;

함수 getRombiosdword (const 덤프 : trombiosdump; 주소 : 포인터) : dword;

함수 getRombiosword (const 덤프 : trombiosdump; 주소 : 포인터) : Word;

함수 getRombiosByte (const 덤프 : trombiosdump; 주소 : 포인터) : 바이트;

구현

{###################################################################################################YOUMYD ############################################# ## #################################### ##########################################################################. ##

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

#/t/t/t 일반 방법/t/t/t/t #

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

# 임시 폴더를 만들고 16bit com 프로그램 (romdump.com)을 저장, #

# 파일로 리디렉션 된 프로그램 실행 프로그램 (rom.dmp, romdump.com은 단순히 #을 덤프합니다.

# 메모리 범위 F000 : 0000-F000 : ffff to stdout), 버퍼에 덤프 파일을 읽으십시오, #

# 마지막으로 모든 임시 파일 및 디렉토리를 정리합니다 ./t/t #

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

# (함수 romDumpCode는 x86 특이 적이며 16 비트 #을 생성하도록 썼습니다.

# 23 비트 델파이 컴파일러의 도움으로 코드는 #을 실행하지 마십시오.

# 프로그램의 Pseudo-Code! 32 비트 보호 모드에서 작동하지 않습니다.

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

#################################### ##########################################################################. ##################################### ############################################################ #################################}}

{ * 내부 * - 의사 16 비트 코드}

유형

promdumpcodeinfo = ^tromdumpCodeInfo;

tromDumpCodeInfo = (rdcistart, rdciend, rdcisize);

함수 _ROMDUMPCODE (정보 : tromDumpCodeInfo) : 포인터;

var

Codestart : 포인터;

코드 엔드 : 포인터;

시작하다

ASM

/t jmp @@ end

/t { * 시작 * 16 비트 코드}

/t { - 프로그램에서 사용하지 마십시오! -}

/t {rom-bios를 stdout에 쓰는 com}

@@시작:

/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 12 월 ecx

/t xor ebx, ebx // bx = 0x0001;

/t Inc ebx

/t mov ah, 40H // doscall (0x40), dos_write_to_handle

/t int 21h

/t jc @@ exit // 오류 종료;

/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 12 월 EDX

/t xor ecx, ecx // cx = 0x0001;

/t Incx

/t mov ebx, ecx // bx = 0x0001;

/t mov ah, 40H // doscall (0x40), dos_write_to_handle

/t int 21h

/t jc @@ exit // 오류 종료;

/t mov al, 0 // 오류 없음;

@@출구:

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

/t int 21h

@@끝:

/t { * end * 16 비트 코드}

/t mov codestart, 오프셋 @@ start

/t Mov Codeend, 오프셋 @@ end

끝;

사례 정보

rdcistart :

결과 : = CodestArt;

rdciend :

결과 : = 코드 엔드;

rdcisize :

결과 : = 포인터 (추기경 (코드 엔드) -Cardinal (CodestArt));

또 다른

결과 : = nil;

끝;

{ * 내부 * - 파일에 16 비트 코드를 저장}

함수 _romDumpCodetOfile (const filename : String) : 부울;

var

Comfile : Thandle;

크기 : 추기경;

시작하다

결과 : = 거짓;

comfile : = createFile (pchar (filename), generic_write, file_share_read, nil,

create_always, file_attribute_normal, 0);

comfile <> invalid_handle_value라면

노력하다

결과 : = writefile (comfile, _romdumpCode (rdcistart)^,

추기경 (_romdumpCode (rdcisize)), 크기, nil) 및

(size = cardinal (_romdumpCode (rdcisize)));

결과가 아니라면

deletefile (pchar (filename));

마지막으로

CloseHandle (Comfile);

끝;

{ * 내부 * - 파일로 리디렉션 된 16 비트 코드 실행}

함수 _ROMDUMPCODEEXECUTE (const com, dmp : string; timeout : dword) : boolean;

var

comspec : 문자열;

SI : tstartupinfo;

PI : tprocessinformation;

시작하다

결과 : = 거짓;

setLength (comspec, max_path);

setLength (comspec,

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

길이 (comspec)> 0이면

시작하다

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

si.cb : = sizeof (tstartupinfo);

si.dwflags : = startf_useshowwindow;

si.wshowwindow : = sw_hide;

CreateProcess (nil, pchar (comspec + ' /c' ' + com +' '>' ' + dmp) 인 경우,

nil, nil, false, create_new_console 또는 create_new_process_group, nil,

Nil, si, pi)

노력하다

결과 : = waitforsingleObject (pi.hprocess, timeout) <> wait_timeout;

마지막으로

CloseHandle (pi.hprocess);

CloseHandle (pi.hthread);

끝;

함수 directoryExists (const dir : string) : 부울;

var

attr : dword;

시작하다

attr : = getFileAttributes (pchar (dir));

결과 : = (attr <> $ ffffffff) 및

(attr 및 file_attribute_directory = file_attribute_directory);

끝;

{Bios가 일반적인 방식으로 덤프하기}}

함수 readrombios16 (var 버퍼 : trombiosdump; timeout : dword) : boolean;

Const

tempsub = ''~ romdmp '';

comname = ''romdump.com '';

dmpname = ''rom.dmp '';

var

온도 : 문자열;

Tempdir : 문자열;

tempidx : 정수;

tempidxstr : 문자열;

Comfile : 문자열;

dmpfile : 문자열;

dmphandle : thandle;

작성 : dword;

시작하다

결과 : = 거짓;

setLength (temppath, max_path);

setLength (temppath, getTemppath (max_path, pchar (@temppath [1]));

길이 (temppath)> 0이면

시작하다

if (temppath [length (temppath)] <> '/' ')

temppath : = temppath + ''/'';

tempidx : = 0;

반복하다

Inc (tempidx);

str (tempidx, tempidxstr);

tempdir : = temppath + tempsub + tempidxstr;

DirectoryExists (tempdir)가 될 때까지;

CreateDerectory (pchar (tempdir), nil)

노력하다

tempdir : = tempdir + ''/'';

comfile : = tempdir + comname;

dmpfile : = tempdir + dmpname;

_romdumpcodetofile (comfile)이면

노력하다

_romdumpcodeexecute (comfile, dmpfile, timeout) 인 경우

시작하다

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

/t file_share_read 또는 file_share_write, nil, Open_Existing, 0, 0);

/t If dmphandle <> invalid_handle_value

/t 시도

/t Fillchar (버퍼, 크기 (Trombiosdump), 0);

/t 결과 : = readFile (dmphandle, 버퍼, 크기 (TrombioSdump),

/t 작성, nil) 및 (write = sizeof (trombiosdump));

마침내 /t

/t CloseHandle (dmphandle);

/추세;

끝;

마지막으로

deletefile (pchar (dmpfile));

deletefile (pchar (comfile));

끝;

마지막으로

제거식 (pchar (tempdir));

끝;

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

# Windows 95/98/ME가 BIOS를 모든 Win32 프로세스에 맵핑한다는 사실 때문에 #

# 읽기 액세스의 경우 메모리에서 버퍼를 채우는 것이 매우 간단합니다 ./t #

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

#################################### ########################################################################. ##################################### ############################################################ #################################}}

함수 readrombios9x (var 버퍼 : trombiosdump) : 부울;

시작하다

결과 : = 거짓;

노력하다

충전재 (버퍼, 크기 (Trombiosdump), 0);

이동 (포인터 (Low (trombiosdump))^, 버퍼, sizeof (trombiosdump));

결과 : = 참;

제외하고

// 예외를 무시합니다

끝

끝;

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

#/t/t 물리적 메모리 방법 (winnt)/t/t/t #

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

# Windows nt에서 ROM BIOS는 이름이 지정된 커널 객체를 통해서만 사용할 수 있습니다.

# ''/Device/PhysicalMemory ''.

# 표준 WIN32 API 기능이있는 사용자 모드는 #에서 NT '의 NativeApi를 사용합니다.

# ntdll.dll ( "nt-layer"), 즉 zwopensection./t/t/t/t #

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

# (참고 : 대부분 모든 기능 ZWXXX 및 NTXXX의 두 가지 버전이 있습니다. #

# 커널 모드의 차이점 만 NTXXX 버전이 고려에서 작동한다는 것입니다.

# 보안에 대한 배급 Zwxxx는 아니지만 둘 다 NTXXX처럼 작동합니다.

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

# 처음에는 Zwopensection으로 섹션이 열립니다.

# zwmapviewofsection, zwunmapviewsection 및 ntclose.

# 더 복잡하고 손잡이가 필요하지 않습니다.

# "매우 간단한"사용자 모드 =)에서 우리는 이제 mapviewoffile, unmapviewoffile, #을 사용합니다.

# 그리고 닫기를 위해 메모리 창 (ROM BIOS)을 우리의 프로세스에 매핑하십시오.

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

# 실패의 경우 zwopensection이 nt 오류 코드를 반환한다는 사실로 인해 #

# win32 오류 코드 (rtlntstatustodoSerror)로 변환해야합니다.

# 모든 NT 특정 기능은 동적으로로드되어 있습니다.

# Win9X Systems =)/T/T/T/T/T/T에서 시작해야합니다.

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

{자세한 내용은 Windows 2000/xp ddk} 참조}

{Windows NT 4.0에서도 작동합니다. ntdll.dll} 사용하십시오.

유형

ntstatus = 정수;

Const

status_success = ntstatus (0);

status_invalid_handle = ntstatus ($ c0000008);

status_access_denied = ntstatus ($ c0000022);

유형

punicodestring = ^tunicodestring;

tunicodestring = 포장 레코드

길이 : 단어;

최대 길이 : 단어;

버퍼 : pwidechar;

끝;

Const

obj_inherit = $ 00000002;

obj_permanent = $ 00000010;

obj_excluction = $ 00000020;

OBJ_CASE_INSENSENTIVE = $ 00000040;

obj_openif = $ 00000080;

OBJ_OPENLINK = $ 00000100;

obj_kernel_handle = $ 00000200;

obj_valid_attributes = $ 000003f2;

유형

pobjectattributes = ^tobjectattributes;

tobjectattributes = record

길이 : ulong;

루트 디렉토리 : thandle;

ObjectName : Punicodestring;

속성 : ulong;

SecurityDescriptor : PscurityDescriptor;

SecurityQualityofService : PSCURITYQUALYONDOFSERVICE;

끝;

Const

ObjectPhysicalMemoryDeviceName = ''/Device/PhysicalMemory '';

ObjectPhysicalMemoryName : tunicodestring = (

길이 : 길이 (ObjectPhysicalMemoryDeviceName) * 2;

최대 길이 : 길이 (ObjectPhysicalMemoryDeviceName) * 2 + 2;

버퍼 : ObjectPhysicalMemoryDeviceName;

);

ObjectPhysicalMemoryAccessmask : access_mask = section_map_read;

ObjectPhysicalMemoryAttributes : tobjectattributes = (

길이 : sizeof (tobjectattributes);

루트 디렉토리 : 0;

ObjectName : @objectPhysicalMemoryName;

속성 : obj_case_insensive;

SecurityDescriptor : NIL;

SecurityQualityOfService : NIL;

);

유형

tfnzwopensection = 함수 (Out SectionHandle : Thandle;

원하는 Access : Access_mask;

stdcall;

tfnrtlntStatustodoSerror = 함수 (상태 : ntstatus) : dword;

Const

ntdll = ''ntdll.dll '';

var

zwopensection : tfnzwopensection;

rtlntstatustodoserror : tfnrtlntstatustodoSerror;

함수 readrombiosnt (var 버퍼 : trombiosdump; timeout : dword) : boolean;

var

ntlayer : hmodule;

상태 : ntstatus;

섹션 : thandle;

보기 : 포인터;

시작하다

결과 : = 거짓;

ntlayer : = getModuleHandle (ntdll);

ntlayer = 0이면

setLasterror (error_call_not_implemented)

또 다른

시작하다

할당되지 않은 경우 (zwopensection)

zwopensection : = getProcaddress (ntlayer, 'zwopensection' ');

할당되지 않은 경우 (rtlntStatusTodoSerror)

rtlntStatustodoSerror : = getProcadDress (ntlayer, ''rtlntStatUtoDoSerror '');

그렇지 않은 경우 (할당 된 (zwopensection) 및 할당 된 (rtlntStatusTodoSerror))

setLasterror (error_call_not_implemented)

또 다른

시작하다

상태 : = zwopensection (섹션, ObjectPhysicalMemoryAccessmask,

@objectPhysicalMemoryAttributes);

사례 상태

상태 _success :

/t 시도

/t보기 : = mapViewoffile (섹션, ObjectPhysicalMemoryAccessMask, 0,

/t low (trombiosdump), sizeof (trombiosdump));

(보기) 할당 된 경우 /t

/t 시도

/t Fillchar (버퍼, 크기 (Trombiosdump), 0);

/t 이동 (View^, 버퍼, sizeof (trombiosdump));

/t 결과 : = 참;

마침내 /t

/t unmapviewoffile (보기);

/추세;

마침내 /t

/t CloseHandle (섹션);

/추세;

상태_access_denied :

/t 결과 : = readRombios16 (버퍼, 타임 아웃);

또 다른

setLasterror (rtlntStatusTodoSerror (상태))

끝;

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

함수 readrombios (var dump : trombiosdump; 메소드 : Treadrombiosmethod;

시간 초과 : dword = infinite) : 부울;

시작하다

결과 : = 거짓;

사례 방법

rrbmautomatic :

if (Integer (getversion) <0) 그러면

노력하다

결과 : = readrombios9x (덤프);

제외하고

결과 : = readRombios16 (덤프, 타임 아웃);

끝

또 다른

결과 : = readrombiosnt (덤프, 타임 아웃);

rrbmgeneric :

결과 : = readRombios16 (덤프, 타임 아웃);

RRBMMEMORY :

결과 : = readrombios9x (덤프);

rrbmphysical :

결과 : = readrombiosnt (덤프, 타임 아웃);

또 다른

setLasterror (ERROR_INVALID_PARAMETER);

끝;

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

# 일반 표준 유형으로 데이터에 대한 액세스를 단순화하는 유틸리티 #

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

함수 getRombiosBuffer (const 덤프 : TrombioSdump; 주소 : 포인터;

var 버퍼;; 버퍼 크기 : 추기경) : 추기경;

시작하다

결과 : = 0;

if (추기경 (주소)> = Low (Trombiosdump)) 및

(추기경 (주소) <= high (trombiosdump))

시작하다

결과 : = 버퍼 크기;

if (추기경 (주소) + Buffersize> High (Trombiosdump))

결과 : = High (Trombiosdump) - 추기경 (주소) + 1;

이동 (덤프 [추기경 (주소)], 버퍼, 결과);

끝;

함수 getRombiostring (const 덤프 : trombiosdump; 주소 : 포인터) : 문자열;

시작하다

결과 : = '' '';

if (추기경 (주소)> = Low (Trombiosdump)) 및

(추기경 (주소) <= high (trombiosdump))

결과 : = 문자열 (pchar (@dump [cardinal (address)]);

끝;

함수 getRombioslonglong (const 덤프 : trombiosdump; 주소 : 포인터) : longlong;

유형

plonglong = ^longlong;

시작하다

결과 : = 0;

if (추기경 (주소)> = Low (Trombiosdump)) 및

(추기경 (주소) <= high (trombiosdump) -sizeof (longlong) + 1)

결과 : = plonglong (@dump [cardinal (주소)]^;

끝;

함수 getRombiosdword (const 덤프 : trombiosdump; 주소 : 포인터) : dword;

시작하다

결과 : = 0;

if (추기경 (주소)> = Low (Trombiosdump)) 및

(추기경 (주소) <= high (trombiosdump) -sizeof (dword) + 1)

결과 : = pdword (@dump [cardinal (주소)]^;

끝;

함수 getRombiosword (const 덤프 : trombiosdump; 주소 : 포인터) : Word;

시작하다

결과 : = 0;

if (추기경 (주소)> = Low (Trombiosdump)) 및

(추기경 (주소) <= high (trombiosdump) -sizeof (Word) + 1)

결과 : = pword (@dump [cardinal (주소)]^;

끝;

함수 getRombiosByte (const 덤프 : trombiosdump; 주소 : 포인터) : 바이트;

시작하다

결과 : = 0;

if (추기경 (주소)> = Low (Trombiosdump)) 및

(추기경 (주소) <= high (trombiosdump) -sizeof (byte) + 1)

결과 : = pbyte (@dump [cardinal (주소)]^;

끝;

끝.

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

4. BIOS 날짜 정보를 얻으십시오

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

{BIOS의 날짜 정보를 얻으십시오. 2000 년 미만으로 적용될 수 있지만 허가가 필요할 수 있습니다}

함수 getBiosDate1 : 문자열;

var

버퍼 : char의 배열 [0..8];

n : dword;

시작하다

ReadProcessMemory (GetCurrentProcess,

ptr ($ ffff5),

@완충기,

N);

버퍼 [8] : = #0;

결과 : = strpas (버퍼)

끝;

함수 getBiosDate2 : 문자열;

시작하다

결과 : = 문자열 (pchar (ptr ($ ffff5));

끝;