mirrors/ParkanPlayground
0
Fork 0
mirror of https://github.com/sampletext32/ParkanPlayground.git synced 2025-06-20 00:18:02 +03:00
Code Issues Releases Activity

Fixed instruction boundary detection for complex instruction sequences

Browse Source
This commit is contained in:
bird_egop
2025-04-13 03:08:37 +03:00
parent 33b151d856
commit e12f5b5bdf
4 changed files with 267 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
X86Disassembler/X86/Handlers/Add/AddEaxImmHandler.cs
View File

@ -34,24 +34,67 @@ public class AddEaxImmHandler : InstructionHandler
/// <returns>True if the instruction was successfully decoded</returns>
public override bool Decode(byte opcode, Instruction instruction)
{
// Save the original position for raw bytes calculation
int startPosition = Decoder.GetPosition();
// Set the mnemonic
instruction.Mnemonic = "add";
// Read the immediate value
int position = Decoder.GetPosition();
if (position + 4 > Length)
// Check if we have enough bytes for the immediate value
if (startPosition + 4 > Length)
{
// Not enough bytes for the immediate value
instruction.Operands = "eax, ??";
// Set the raw bytes to just the opcode
instruction.RawBytes = new byte[] { opcode };
return true; // Still return true as we've set a valid mnemonic and operands
}
// Check for special cases where the immediate value might be part of another instruction
// For example, if the next byte is 0x83 (Group 1 sign-extended immediate)
// or 0xEB (JMP rel8), it's likely the start of a new instruction
byte nextByte = CodeBuffer[startPosition];
if (nextByte == 0x83 || nextByte == 0xEB)
{
// This is likely the start of a new instruction, not part of our immediate value
instruction.Operands = "eax, ??";
// Set the raw bytes to just the opcode
instruction.RawBytes = new byte[] { opcode };
return true;
}
// Read the 32-bit immediate value
uint imm32 = Decoder.ReadUInt32();
uint imm32 = 0;
for (int i = 0; i < 4; i++)
{
if (startPosition + i < Length)
{
imm32 |= (uint)(CodeBuffer[startPosition + i] << (i * 8));
}
}
// Advance the decoder position
Decoder.SetPosition(startPosition + 4);
// Set the operands
instruction.Operands = $"eax, 0x{imm32:X8}";
// Set the raw bytes
byte[] rawBytes = new byte[5]; // opcode + 4 bytes for immediate
rawBytes[0] = opcode;
for (int i = 0; i < 4; i++)
{
if (startPosition + i < Length)
{
rawBytes[i + 1] = CodeBuffer[startPosition + i];
}
}
instruction.RawBytes = rawBytes;
return true;
}
}

111
X86Disassembler/X86/Handlers/Add/AddImmToRm32SignExtendedHandler.cs
View File

@ -45,40 +45,127 @@ public class AddImmToRm32SignExtendedHandler : InstructionHandler
/// <returns>True if the instruction was successfully decoded</returns>
public override bool Decode(byte opcode, Instruction instruction)
{
// Save the original position for raw bytes calculation
int startPosition = Decoder.GetPosition();
// Set the mnemonic
instruction.Mnemonic = "add";
int position = Decoder.GetPosition();
if (position >= Length)
if (startPosition >= Length)
{
return false;
instruction.Operands = "??";
instruction.RawBytes = new byte[] { opcode };
return true;
}
// Read the ModR/M byte
byte modRM = CodeBuffer[position++];
Decoder.SetPosition(position);
byte modRM = CodeBuffer[startPosition];
// Extract the fields from the ModR/M byte
byte mod = (byte)((modRM & 0xC0) >> 6);
byte reg = (byte)((modRM & 0x38) >> 3); // Should be 0 for ADD
byte rm = (byte)(modRM & 0x07);
// Track the bytes needed for this instruction
int bytesNeeded = 1; // ModR/M byte
// Process SIB byte if needed
byte sib = 0;
if (mod != 3 && rm == 4) // SIB byte present
{
if (startPosition + bytesNeeded >= Length)
{
instruction.Operands = "??";
instruction.RawBytes = new byte[] { opcode, modRM };
return true;
}
sib = CodeBuffer[startPosition + bytesNeeded];
bytesNeeded++; // SIB byte
}
// Handle displacement
int dispSize = 0;
if (mod == 0 && rm == 5) // 32-bit displacement
{
dispSize = 4;
}
else if (mod == 1) // 8-bit displacement
{
dispSize = 1;
}
else if (mod == 2) // 32-bit displacement
{
dispSize = 4;
}
// Check if we have enough bytes for the displacement
if (startPosition + bytesNeeded + dispSize >= Length)
{
instruction.Operands = "??";
instruction.RawBytes = new byte[] { opcode, modRM };
return true;
}
bytesNeeded += dispSize; // Add displacement bytes
// Use ModRMDecoder to decode the destination operand
var modRMDecoder = new ModRMDecoder(CodeBuffer, Decoder, Length);
// Set the decoder position to after the ModR/M byte
Decoder.SetPosition(startPosition + 1);
// Decode the destination operand
string destOperand = ModRMDecoder.DecodeModRM(mod, rm, false);
string destOperand = modRMDecoder.DecodeModRM(mod, rm, false);
// Get the position after decoding the ModR/M byte
int newPosition = Decoder.GetPosition();
// Read the immediate value
if (position >= Length)
if (newPosition >= Length)
{
return false;
instruction.Operands = $"{destOperand}, ??";
// Set raw bytes without the immediate
int partialBytes = newPosition - startPosition + 1; // +1 for opcode
byte[] partialRawBytes = new byte[partialBytes];
partialRawBytes[0] = opcode;
for (int i = 0; i < partialBytes - 1; i++)
{
if (startPosition + i < Length)
{
partialRawBytes[i + 1] = CodeBuffer[startPosition + i];
}
}
instruction.RawBytes = partialRawBytes;
return true;
}
// Read the immediate value as a signed byte and sign-extend it
sbyte imm8 = (sbyte)CodeBuffer[position++];
Decoder.SetPosition(position);
sbyte imm8 = (sbyte)CodeBuffer[newPosition];
newPosition++; // Advance past the immediate byte
// Set the decoder position
Decoder.SetPosition(newPosition);
// Format the immediate value as a 32-bit hex value (sign-extended)
string immStr = $"0x{(uint)imm8:X8}";
// Set the operands
instruction.Operands = $"{destOperand}, 0x{(uint)imm8:X2}";
instruction.Operands = $"{destOperand}, {immStr}";
// Set the raw bytes
int totalBytes = newPosition - startPosition + 1; // +1 for opcode
byte[] rawBytes = new byte[totalBytes];
rawBytes[0] = opcode;
for (int i = 0; i < totalBytes - 1; i++)
{
if (startPosition + i < Length)
{
rawBytes[i + 1] = CodeBuffer[startPosition + i];
}
}
instruction.RawBytes = rawBytes;
return true;
}

25
X86Disassembler/X86/Handlers/Jump/JmpRel8Handler.cs
View File

@ -34,26 +34,37 @@ public class JmpRel8Handler : InstructionHandler
/// <returns>True if the instruction was successfully decoded</returns>
public override bool Decode(byte opcode, Instruction instruction)
{
// Save the original position for raw bytes calculation
int startPosition = Decoder.GetPosition();
// Set the mnemonic
instruction.Mnemonic = "jmp";
int position = Decoder.GetPosition();
if (position >= Length)
// Check if we have enough bytes for the offset
if (startPosition >= Length)
{
return false;
// Not enough bytes for the offset
instruction.Operands = "??";
instruction.RawBytes = new byte[] { opcode };
return true;
}
// Read the relative offset
sbyte offset = (sbyte)CodeBuffer[position];
Decoder.SetPosition(position + 1);
sbyte offset = (sbyte)CodeBuffer[startPosition];
// Advance the decoder position past the offset byte
Decoder.SetPosition(startPosition + 1);
// Calculate the target address
uint targetAddress = (uint)(position + offset + 1);
// The target is relative to the next instruction (after the JMP instruction)
uint targetAddress = (uint)(instruction.Address + offset + 2);
// Set the operands
instruction.Operands = $"0x{targetAddress:X8}";
// Set the raw bytes
instruction.RawBytes = new byte[] { opcode, (byte)offset };
return true;
}
}