Преобразовать целое число в массив байтов

Question

Я пытаюсь преобразовать целое число в 10 цифр для байта, но функция возвращает мне только 4 значения, мне нужно 6 баллов, как решить?

Функция, которую я использую, чтобы преобразовать целое число в байтах

var
  i, j: integer;
  bbI : array[1.. sizeof(integer)] of byte;
begin
  i := 2337669003;
  Move(i, bbI[1], SizeOf(Integer));
  for j := Low(bbI) to High(bbI) do
  Memo1.Lines.Append(IntToHex(bbI[j],2))
end;

функция возвращает меня

8B FF 55 8B

значения, которые возвращаются но мне нужно больше 2 значений

EC 51

функция должна вернуть меня

8B FF 55 8B EC 51

правильное значение в соответствии с чит-движком

Answer 1

Я пытаюсь преобразовать целое число в 10 цифр для байта, но функция возвращает мне только 4 значения, мне нужно 6 баллов, как решить?

Ты не можешь Integer только 4 байта в размере. Integer значение 2337669003 это последовательность байтов 8B FF 55 8B, Там нет никакого способа, вы можете получить дополнительную EC 51 байты из этого.

Int64 имеет размер 8 байт. Последовательность байтов 8B FF 55 8B EC 51 будет Int64 ценность 5903246413051658240 с его старшими 2 байтами (00 00урезано.

На скриншоте ясно видно, что последовательность байтов 8B FF 55 8B EC 51 на самом деле соответствует первым 4 x86 инструкциям по сборке Win32 BitBlt() функция. Почему вы используете целочисленные значения для представления инструкций по сборке? Это не хороший способ приблизиться к этому. Вы понимаете, как на самом деле работает набор инструкций x86? Вы понимаете, как работают целые числа?

В этой ситуации я бы предложил использовать фактический байтовый массив вместо целочисленного:

var
  Instructions: array[0..5] of byte;
  i: Integer;
begin
  // mov edi,edi
  Instructions[0] := $8B;
  Instructions[1] := $FF;

  // push ebp
  Instructions[2] := $55;

  // mov ebp,esp
  Instructions[3] := $8B;
  Instructions[4] := $EC;

  // push ecx
  Instructions[5] := $51;

  for i := Low(Instructions) to High(Instructions) do
    Memo1.Lines.Append(IntToHex(Instructions[i], 2));
end;

Или даже использовать запись вместо:

type
  BitBltInstructions = packed record
    MovEdiEdi: array[0..1] of byte; // $8B $FF
    PushEbp: byte; // $55
    MovEbpEsp: array[0..1] of byte; // $8B $EC
    PushEcx: byte; // $51
  end;

var
  Instructions: BitBltInstructions;
  bytes: array[0..Sizeof(BitBltInstructions)-1] of byte absolute Instructions;
  i: Integer;
begin
  Instructions.MovEdiEdi[0] := $8B;
  Instructions.MovEdiEdi[1] := $FF;
  Instructions.PushEbp      := $55;
  Instructions.MovEbpEsp[0] := $8B;
  Instructions.MovEbpEsp[1] := $EC;
  Instructions.PushEcx      := $51;

  for i := Low(bytes) to High(bytes) do
    Memo1.Lines.Append(IntToHex(bytes[i], 2));
end;

Answer 2

Вы можете использовать директиву absolute:

procedure Main;
var
  i: Integer;
  x: array[0..3] of Byte absolute i;
begin
  i := 123456;
  Writeln(x[0]);
  Writeln(x[1]);
  Writeln(x[2]);
  Writeln(x[3]);
end;

Answer 3

Для этого вы используете вариант записи. В этом случае оба поля записи совместно используют одну и ту же память:

program Test;
uses
  System.SysUtils;

type
  TInteger = record
    case Byte of
      0: (AsValue: Integer);
      1: (AsArray: array [0..3] of Byte);
  end;

var
  X: TInteger;
begin
  X.AsValue := 123456;
  Writeln(X.AsArray[0]);
  Writeln(X.AsArray[1]);
  Writeln(X.AsArray[2]);
  Writeln(X.AsArray[3]);
end.