Получите информацию о биографиях материнской платы

Автор：Eve Cole Время обновления：2025-03-08 16:48:02

1. Прочитайте серийный номер материнской платы

2. Читать пароль наградного биоса

3. Читайте информацию BIOS

4. Получить информацию о дате BIOS

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

1. Прочитайте серийный номер материнской платы

использует sha1, base64;

Функция gethashedbiosinfo: String;

вар

SHA1Context: TSHA1CONTEXT;

SHA1Digest: TSHA1DIGEST;

Начинать

// Получить данные BIOS

SetString (Result, PCHAR (PTR ($ F0000)), $ 10000);

// Хэш строка

Sha1init (sha1context);

Sha1update (sha1context, pchar (результат), длина (результат));

Sha1final (sha1context, sha1digest);

SetString (результат, pchar (@sha1digest), sizeof (sha1digest));

// возвращать хеш -строку, закодированную в символах печати,

Результат: = b64encode (результат);

конец;

Функция getBiosInfoaStext: String;

вар

P, Q: PCHAR;

Начинать

Q: = nil;

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

повторить

Если Q <> nil, тогда начинайте

Если нет (p^ in [ #10, #13, #32 .. #126, #169, #184]), затем начните

/t if (p^ = #0) и (p - q> = 8), затем начните

/t Результат: = Результат + Trimright (String (q)) + #13 #10;

/иметь тенденцию;

/tq: = nil;

конец;

конец еще

Если p^ in [ #33 .. #126, #169, #184] тогда

/TQ: = P;

Inc (P);

до p> pchar (ptr ($ fffff));

Результат: = trimright (результат);

конец;

Процедура tform1.formcreate (отправитель: tobject);

Начинать

Memo1.lines.text: = getBiosInfoaStext;

конец;

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

2. Награждение Bios Password Reading (это должна быть статья Jingtao, но идентификатор не записан)

Unit Awardbiospas;

// Написать от LoveJingtao

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

интерфейс

использует Windows, Sysutils;

Функция my_getbiospassword: String;

Выполнение

Функция CalcPossiblePassword (PasswordValue: Word): String;

вар

Я: байт;

C: Чар;

S: String [8];

Начинать

I: = 0;

В то время как PasswordValue <> 0

Начинать

Inc (i);

Если $ 263> PasswordValue, тогда

Начинать

/T, если $ 80> PasswordValue, тогда

/t s : = char (passwordvalue)

/t else, если $ b0> passwordvalue тогда

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

/t еще, если $ 11d> passwordvalue, тогда

/t s : = char ($ 30 или (passwordvalue и $ 0f)))

/t еще, если $ 114> PasswordValue Then Then

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

/t s : = char ($ 30 или (passwordvalue и $ 03)))

/т еще

/t начинается

/t s : = char ($ 70 или (пароль и $ 0f));

/t, если '' z '' <s тогда

/t s : = char (байт (s ) - 8);

/иметь тенденцию;

конец

еще

S : = char ($ 30 или (пароль и 3 доллара США));

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

конец;

S [0]: = char (i);

PasswordValue: = I SHR 1;

пока пароль.

начинать {это должно сделать, потому что награда начинает расчет с последней буквой}

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

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

S : = c;

Дек (i);

конец;

CalcPossiblePassword: = s;

конец;

Функция readcmos (OFF: Byte): Byte;

вар

значение: байт;

Начинать

Асм

xor ax, ax

MOV AL, OFF

Вне 70h, al

В AL, 71H

Значение движения, AL

конец;

readcmos: = value;

конец;

Функция my_getbiospassword: String;

вар

SuperPW, userPW: Word;

S: String;

Начинать

Если 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: = '' Пароль суперзарера: ''+calcpossiblePassword (superpw)+#13+'' Пароль пользователя: ''+calcpossiblePassword (userPw);

Результаты: = s;

конец

еще

Результат: = '' Пользовательская система NT, а пароль BISO не может быть получен! '';

конец;

конец.

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

3. Читайте информацию BIOS

{Программа использует платформу Windows 95/2000, автоматически обнаруживает тип системы, а затем делает разные вызовы}

использует BioShelp;

Процедура tform1.button1click (отправитель: tobject);

вар

Свалки: тромбиосдумп;

я: целое число;

Начинать

Readrombios (Damp, Rrbmautomatic);

для i: = от 1 до $ 000fffff - $ 000F0000 - 1 DO

Memo1.lines.add (inttoHex (дамп [i + $ 000fffff], 2));

конец;

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

*/T/T/T/T/T/T/T/T/T/T/T/T *

* BIOS HELP - Читать ROM BIOS в Windows 95/98/SE/ME/NT/2K/XP/T/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 *

********************************************* ******* ***********************************

{Postum scriptum: извините за плохой английский, я спешил}

единица BioShelp;

{$ Выравнивать}

{$ MinenumSize 4}

интерфейс

Использование

Windows;

тип

PROMBIOSDUMP = ^TROMBIOSDUMP;

Trombiosdump = array [$ 000f0000 .. $ 000ffff] байта;

тип

Treatrombiosmethod = (

Rrbmautomatic,/T/T/T/T/T {AutoDetect OS Тип и используйте правильный метод}

rrbmgeneric,/t/t/t/t/t/t {используйте 16-разрядную программу Com, чтобы сбросить BIOS}

rrbmmemory,/t/t/t/t/t {reade from memory (win9x)/t/t}

rrbmphysical/t/t/t/t/t {читать из объекта физической памяти (winnt)}

);

Функция readrombios (var -дамп: trombiosdump; метод: treadrombiosmethod;

Тайм -аут: dword = бесконечно): логический;

Функция getRombiosBuffer (const Dimply: TrombiosDump; адрес: pointer;

VAR Buffer;

функция getRombiosstring (const dilmbel: trombiosdump; адрес: pointer): string;

Функция getRombioSlonglong (const dilmbel: trombiosdump; адрес: pointer): longlong;

функция getRombiosdword (const dilmbel: trombiosdump; адрес: pointer): dword;

Функция getRombiosWord (const dilmbel: trombiosdump; адрес: pointer): word;

Функция getRombiosbyte (const dilmbel: trombiosdump; адрес: pointer): byte;

Выполнение

{####################################################################################################### вместе ######################################################################################## вместе ######################################################################## вместе ##

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

# Создать временную папку, сохранить 16 -битную программу 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 #

# (Функция RomdumpCode имеет специфику x86, которую я написал для создания 16-битного #

# код с помощью 23-битного компилятора Delphi, никогда не пытайтесь выполнить #

# Псевдо-код в вашей программе!

#/T/T/T/T/T/T/T/T/T/T/T/T #

######################################################################## вместе ####################################################################### вместе #########################################################################}

{ * Внутренний * - псевдо 16 -битный код}

тип

PROMDUPCODEINFO = ^TROMDUMPCODEINFO;

Tromdumpcodeinfo = (rdcistart, rdciend, rdcisize);

Функция _romdumpCode (Info: tromdumpcodeinfo): pointer;

вар

Codestart: Pointer;

Codeend: Pointer;

Начинать

Асм

/t jmp @@ end

/t { * begin * 16-битный код}

/t { - никогда не используйте его в своей программе!

/t {com, который пишет rom-bios в stdout}

@@Начинать:

/t {дамп 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 // in exit exit;

/t {дамп 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 // in exit exit;

/T MOV AL, 0 // Нет ошибки;

@@Выход:

/T MOV AH, 4CH // DOSCALL (0x4C);

/t int 21h

@@Конец:

/t { * end * 16-битный код}

/T MOV CODESTART, OFFSET @@ start

/t Mov Codeend, Offset @@ End

конец;

Информация о случае

rdcistart:

Результат: = CODESTART;

rdciend:

Результат: = Codeend;

rdcisize:

Результат: = pointer (cardinal (codeend) - cardinal (codestart));

еще

Результат: = NIL;

конец;

{ * Internal * - Сохранить 16 -битный код для файла}

функция _romdumpcodetofile (const filename: string): boolean;

вар

Comfile: Thandle;

Размер: кардинал;

Начинать

Результат: = false;

Comfile: = createfile (pchar (filename), generic_write, file_share_read, ноль,

Create_always, file_attribute_normal, 0);

Если comfile <> Invalid_handle_value тогда

пытаться

Результат: = writefile (comfile, _romdumpcode (rdcistart)^,

Cardinal (_romdumpcode (rdcisize)), размер, ноль) и

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

Если не результаты, тогда

Deletefile (pchar (имя файла));

Окончательно

Крупный рукой (комфиль);

конец;

{ * Internal * - выполнить 16 -битный код, перенаправленный на файл}

Функция _romDumpCodeexeCute (const com, dmp: string; timeout: dword): boolean;

вар

Comspec: string;

SI: tStartupinfo;

PI: Tprocessinformation;

Начинать

Результат: = false;

SetLength (compec, max_path);

SetLength (comspec,

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

Если длина (compec)> 0, тогда

Начинать

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

si.cb: = sizeof (tstartupinfo);

si.dwflags: = startf_useshowwindow;

si.wshowwindow: = sw_hide;

if createProcess (nil, pchar (compec + '' /c '' + com + ''> '' + dmp),

nil, nil, false, create_new_console или create_new_process_group, nil,

Nil, si, pi) тогда

пытаться

Результат: = waitForsingleObject (pi.hprocess, timeout) <> wait_timeout;

Окончательно

Крупный рукой (PI.HProcess);

Крупный руск (Pi.hthread);

конец;

Функции DirectoryExists (const Dir: String): Boolean;

вар

Attr: dword;

Начинать

Attr: = getFileatTributes (pchar (dir));

Результат: = (attr <> $ fffffffff) и

(Attr и file_attribute_directory = file_attribute_directory);

конец;

{Get Bios сбросить общий путь}

Функция readrombios16 (VAR Buffer: TrombiosDump; Timeout: DWORD): BOOLEAN;

констант

Tempsub = '' ~ romdmp '';

Comname = '' romdump.com '';

Dmpname = '' rom.dmp '';

вар

Temppath: String;

Tempdir: string;

TempiDX: целое число;

TempiDxstr: string;

Comfile: String;

Dmpfile: string;

Dmphandle: Thandle;

Написано: DWORD;

Начинать

Результат: = false;

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;

до тех пор, пока не каталогэксуалы (Tempdir);

Если Creatementirectory (pchar (tempdir), nil) тогда

пытаться

Tempdir: = tempdir + ''/'';

Comfile: = tempdir + comname;

Dmpfile: = tempdir + dmpname;

Если _romdumpcodetofile (comfile), то

пытаться

Если _romdumpcodeexecute (comfile, dmpfile, тайм -аут) тогда

Начинать

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

/t file_share_read или file_share_write, nil, open_existing, 0, 0);

/t, если dmphandle <> Invalid_handle_value тогда

/t попробуй

/t fillchar (буфер, sizeof (trombiosdump), 0);

/t Результат: = readfile (dmphandle, buffer, sizeof (trombiosdump),

/t написано, ноль) и (написано = sizeof (trombiosdump));

/T наконец

/T Close Handle (dmphandle);

/иметь тенденцию;

конец;

Окончательно

Deletefile (pchar (dmpfile));

Deletefile (pchar (comfile));

конец;

Окончательно

EmortedErectory (pchar (tempdir));

конец;

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

# Из -за того, что Windows 95/98/ME отображает BIOS в каждом процессе Win32 #

# Для получения чтения доступа очень просто заполнить буфер из памяти ./T #

#/T/T/T/T/T/T/T/T/T/T/T/T #

Функция readrombios9x (VAR Buffer: TrombiosDump): Boolean;

Начинать

Результат: = false;

пытаться

FillChar (Buffer, Sizeof (TrombiosDump), 0);

Переместить (указатель (низкий (тромбиосдумп))^, буфер, размер (тромбиосдумп));

Результат: = true;

кроме

// Игнорировать исключения

конец

конец;

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

# В Windows NT BIOS доступен только через названный объект ядра #

# ''/Device/Physicalmemory ''.

# Пользовательский режим со стандартными функциями API Win32 Мы используем NTIVEAPI NT 'в #

# Ntdll.dll ("nt-layer"), а именно zwopensection./t/t/t/t #

#/T/T/T/T/T/T/T/T/T/T/T/T #

# (Примечание: в основном есть две версии каждой функции ZWXXX и NTXXX. #

# только разница в режиме ядра заключается в том, что версия NTXXX работает в рассмотрении #

# Рейн в безопасность, пока zwxxx не.

#/T/T/T/T/T/T/T/T/T/T/T/T #

# Сначала раздел открыт с Zwopensection.

# Zwmapviewofsection, zwunmapviewofsection и ntclose.

# более сложный, и нет необходимости для этого.

# В «очень простом» пользовательском режиме =) мы теперь используем MapViewOffile, UnmapViewOffile, #

# и близкий отряд, чтобы составить карту окна памяти (ПЗУ биос) в нашем процессе.

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

{Для получения дополнительной информации см. Windows 2000/XP DDK}

{Он также работает на Windows NT 4.0, используйте ntdll.dll}

тип

Ntstatus = целое число;

констант

Status_success = ntstatus (0);

Status_invalid_handle = ntstatus ($ c0000008);

Status_access_denied = ntstatus ($ c0000022);

тип

Punicodestring = ^tunicodestring;

TunicoDestring = упакованная запись

Длина: Слово;

Максимальная длина: слово;

Буфер: Pwidechar;

конец;

констант

Obj_inherit = $ 00000002;

Obj_permanent = $ 00000010;

Obj_exclusive = $ 00000020;

OBJ_CASE_INSENSITITE = $ 00000040;

Obj_openif = $ 00000080;

Obj_openlink = $ 00000100;

Obj_kernel_handle = $ 00000200;

Obj_valid_attributes = $ 000003f2;

тип

Pobjectattributes = ^tobjectattributes;

Tobjectattributes = record

Длина: Ulong;

RootDirectory: Thandle;

ObjectName: Punicodestring;

Атрибуты: Ulong;

SecurityDescriptor: PSCURTIONDESCRIPTOR;

SecurityTailationOfService: PSCURTICALITOFSERVICE;

конец;

констант

ObjectPhysicalMemoryDevicEname = ''/Device/PhysicalMemory '';

ObjectPhysicalMemoryName: TunicoDestring = (

Длина: длина (ObjectPhysicalMemoryDevicEname) * 2;

Максимальная длина: длина (ObjectPhysicalMemoryDevicEname) * 2 + 2;

Буфер: ObjectPhysicalMemoryDevicEname;

);

ObjectPhysicalMemoryAccessmask: access_mask = section_map_read;

ObjectPhysicalMemoryattributes: tobjectattributes = (

Длина: размер (Tobjectattributes);

Rootdirectory: 0;

ObjectName: @ObjectPhysicalMemoryName;

Атрибуты: OBJ_CASE_INSENSITITY;

SecurityDescriptor: ноль;

SecurityTailationOfService: ноль;

);

тип

Tfnzwopensection = функция (Out SectionHandle: Thandle;

Желание: access_mask;

stdcall;

Tfnrtlntstatustodoserror = function (статус: ntstatus): dword;

констант

ntdll = '' ntdll.dll '';

вар

Zwopensection: tfnzwopensection;

Rtlntstatustodoserror: tfnrtlntstatustodoserror;

функция readrombiosnt (var buffer: trombiosdump; timeout: dword): boolean;

вар

Ntlayer: hmodule;

Статус: ntstatus;

Раздел: Тандл;

Просмотр: Указатель;

Начинать

Результат: = false;

Ntlayer: = getModuleHandle (ntdll);

Если ntlayer = 0, тогда

SetLasterRor (error_call_not_implemented)

еще

Начинать

Если не назначено (Zwopensection), то тогда

ZWopensection: = getProcadDress (ntlayer, '' Zwopensection '');

Если не назначено (rtlntstatustodoserror), то тогда

Rtlntstatustodoserror: = getProcadDress (ntlayer, '' rtlntStatustoSerror '');

Если нет (назначен (ZWOPensection) и назначен (rtlntstatustodoserror)) тогда

SetLasterRor (error_call_not_implemented)

еще

Начинать

Статус: = Zwopensection (раздел, ObjectPhysicalMemoryAccessmask,

@Objectphysicalmemoryattributes);

Статус случая

Status_success:

/t попробуй

/T View: = MapViewOffile (раздел, ObjectPhysicalMemoryAccessmask, 0,

/t Low (TrombiosDump), Sizeof (TrombiosDump));

/t, если назначено (просмотреть), тогда

/t попробуй

/t fillchar (буфер, sizeof (trombiosdump), 0);

/t Move (View^, Buffer, Sizeof (TrombiosDump));

/t Результат: = true;

/T наконец

/t unmapviewoffile (view);

/иметь тенденцию;

/T наконец

/t CloseDhandle (раздел);

/иметь тенденцию;

Status_access_denied:

/t Результат: = readrombios16 (буфер, тайм -аут);

еще

SetLasterRor (rtlntstatustodoSerror (Status)))

конец;

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

Функция readrombios (var -дамп: trombiosdump; метод: treadrombiosmethod;

Тайм -аут: dword = бесконечно): логический;

Начинать

Результат: = false;

Метод случая

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 #

Функция getRombiosBuffer (const Dimply: TrombiosDump; адрес: pointer;

VAR Buffer;

Начинать

Результаты: = 0;

if (cardinal (адрес)> = low (trombiosdump)) и

(Кардинал (адрес) <= высокий (тромбиоздумп)) тогда

Начинать

Результат: = BufferSize;

if (cardinal (адрес) + buffersize> high (trombiosdump)), тогда

Результат: = High (TrombiosDump) - кардинал (адрес) + 1;

Перемещать (дамп [кардинал (адрес)], буфер, результат);

конец;

функция getRombiosstring (const dilmbel: trombiosdump; адрес: pointer): string;

Начинать

Результаты: = '' '';

if (cardinal (адрес)> = low (trombiosdump)) и

(Кардинал (адрес) <= высокий (тромбиоздумп)) тогда

Результат: = String (pchar (@dump [cardinal (адрес)]));

конец;

Функция getRombioSlonglong (const dilmbel: trombiosdump; адрес: pointer): longlong;

тип

Plonglong = ^longlong;

Начинать

Результаты: = 0;

if (cardinal (адрес)> = low (trombiosdump)) и

(Cardinal (адрес) <= высокий (тромбиосдумп) - sizeof (longlong) + 1) тогда

Результат: = Plonglong (@dump [cardinal (адрес)])^;

конец;

функция getRombiosdword (const dilmbel: trombiosdump; адрес: pointer): dword;

Начинать

Результаты: = 0;

if (cardinal (адрес)> = low (trombiosdump)) и

(Cardinal (адрес) <= High (TrombiosDump) - sizeof (dword) + 1) Тогда

Результат: = pdword (@Dump [cardinal (адрес)])^;

конец;

Функция getRombiosWord (const dilmbel: trombiosdump; адрес: pointer): word;

Начинать

Результаты: = 0;

if (cardinal (адрес)> = low (trombiosdump)) и

(Cardinal (адрес) <= High (TrombiosDump) - sizeof (word) + 1) Затем

Результат: = pword (@dump [cardinal (адрес)])^;

конец;

Функция getRombiosbyte (const dilmbel: trombiosdump; адрес: pointer): byte;

Начинать

Результаты: = 0;

if (cardinal (адрес)> = low (trombiosdump)) и

(Cardinal (адрес) <= высокий (тромбиосдумп) - sizeof (byte) + 1) Затем

Результат: = pbyte (@dump [cardinal (адрес)])^;

конец;

конец.

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

4. Получить информацию о дате BIOS

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

{Получите информацию о дате BIOS, подсчитано, что она может применяться до 2000 года, но это может потребовать разрешения}

функция getBiosDate1: String;

вар

Буфер: массив [0..8] char;

N: DWORD;

Начинать

ReadProcessMemory (GetCurrentProcess,

PTR ($ ffff5),

@Buffer,

N);

Буфер [8]: = #0;

Результат: = strpas (буфер)

конец;

функция getBiosDate2: String;

Начинать

Результат: = String (pchar (ptr ($ ffff5)));

конец;