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 *
* Copyright (C) 2001, Нико Бендлин ([email protected])/T/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,
8,
N);
Буфер [8]: = #0;
Результат: = strpas (буфер)
конец;
функция getBiosDate2: String;
Начинать
Результат: = String (pchar (ptr ($ ffff5)));
конец;