private void BreakProcess()
{
if (!OrbisDbg.IsProcessPaused())
{
if (OrbisDbg.SendProcessSignal(OrbisDbg.SIGNALS.SIGSTOP) == 0)
{
return;
}
if (breakpoints.Count > 0)
{
for (int i = 0; i < breakpoints.Count; i++)
{
Breakpoint bp = breakpoints[i];
if (SelectedProcess.Equals(bp.process) && bp.enabled)
{
OrbisDbg.Ext.WriteByte(bp.address, bp.instruction);
}
}
}
/*OrbisDbg.registers regs = OrbisDbg.GetRegisters();
*
* if (registersForm != null)
* registersForm.UpdateRegisterWindow(regs);
*
* if(memoryForm != null)
* memoryForm.UpdateMemoryView(regs.r_rip, 0x1000, OrbisDbg.GetMemory(regs.r_rip, 0x1000));
*
* if(disassemblyForm != null)
* disassemblyForm.UpdateDisassembly(regs.r_rip, OrbisDbg.GetMemory(regs.r_rip, 0x100), disassemblyForm.IsShowingBytes());*/
OrbisDbg.SetSingleStep();
}
}
private void ContinueProcess()
{
bUpdatedOnPause = false;
PreviousRip = 0x0;
if (OrbisDbg.IsProcessPaused())
{
OrbisDbg.ClearSingleStep();
if (breakpoints.Count > 0)
{
for (int i = 0; i < breakpoints.Count; i++)
{
Breakpoint bp = breakpoints[i];
if (SelectedProcess.Equals(bp.process) && bp.enabled)
{
OrbisDbg.Ext.WriteByte(bp.address, 0xCC);
}
}
}
if (registersForm != null)
{
registersForm.FreezeRegisters();
}
if (disassemblyForm != null)
{
disassemblyForm.ClearDisassembly();
}
OrbisDbg.ContinueProcess();
}
}
private void RebootConsole()
{
OrbisDbg.Reboot();
breakpoints.Clear();
if (breakpointForm != null)
{
breakpointForm.Close();
}
if (memoryForm != null)
{
memoryForm.Close();
}
if (disassemblyForm != null)
{
disassemblyForm.Close();
}
if (registersForm != null)
{
registersForm.Close();
}
SetButtonsEnabled(false);
AttachToolStripButton.Enabled = false;
ProcessesToolStripButton.Enabled = false;
}
private void ForceQuitProcess()
{
if (AllowQuit())
{
if (memoryForm != null)
{
memoryForm.Close();
}
if (disassemblyForm != null)
{
disassemblyForm.Close();
}
if (registersForm != null)
{
registersForm.Close();
}
if (breakpointForm != null)
{
breakpointForm.Close();
}
OrbisDbg.SendProcessSignal(OrbisDbg.SIGNALS.SIGKILL);
SetButtonsEnabled(false);
}
else
{
MessageBox.Show("Please clear breakpoints and detach before quittting the game", "Process can't quit");
}
}
private void AttachToProcess(int rowIndex)
{
string processName = ProcessesListDataGridView.Rows[rowIndex].Cells[0].Value.ToString();
int pid = Convert.ToInt32(ProcessesListDataGridView.Rows[rowIndex].Cells[1].Value);
mainForm.SelectedProcess = processName;
OrbisDbg.SetProcess(processName);
mainForm.SetButtonsEnabled(true);
if (!Convert.ToBoolean(ProcessesListDataGridView.Rows[rowIndex].Cells[2].Value))
{
ProcessesListDataGridView.Rows[rowIndex].Cells[2].Value = true;
for (int i = 0; i < mainForm.pList.Count; i++)
{
if (mainForm.pList[i].pid == pid)
{
mainForm.pList[i].attached = 1;
break;
}
}
OrbisDbg.AttachProcess();
}
}
private void SendPlayloadFunction()
{
IPAddress = IPAddressToolStripTextBox.Text;
OrbisDbg.SetIP(IPAddress);
byte[] OrbisDbgPayload = File.ReadAllBytes(@"OrbisDbg\OrbisDbg.bin");
OrbisDbg.SendPayload(OrbisDbgPayload);
}
private void UpdateDisassemblyToolStripButton_Click(object sender, EventArgs e)
{
ulong address = Convert.ToUInt64(DisassemblyAddress.Text, 16);
byte[] memory = OrbisDbg.GetMemory(address, 0x200);
UpdateDisassembly(address, memory, ShowBytesCheckBox.Checked);
}
public static void WriteFloats(ulong offset, float[] input)
{
byte[] buff = new byte[4];
for (int i = 0; i < input.Length; i++)
{
BitConverter.GetBytes(input[i]).CopyTo(buff, 0);
OrbisDbg.SetMemory(offset + ((uint)i * 4), buff);
}
}
private void PokeToolStripButton_Click(object sender, EventArgs e)
{
ulong address = Convert.ToUInt64(AddressToolStripTextBox.Text, 16);
DynamicFileByteProvider dynamicFileByteProvider = MemoryViewHexBox.ByteProvider as DynamicFileByteProvider;
dynamicFileByteProvider.ApplyChanges();
OrbisDbg.SetMemory(address, MemoryData);
}
public static float[] ReadFloats(ulong offset, int arrayLength = 3)
{
float[] vec = new float[arrayLength];
for (int i = 0; i < arrayLength; i++)
{
byte[] buffer = OrbisDbg.GetMemory(offset + ((uint)i * 4), 4);
vec[i] = BitConverter.ToSingle(buffer, 0);
}
return(vec);
}
public static int SetRegisters(registers regs)
{
if (IPAddress.Equals("") || ProcessName.Equals(""))
{
return(0);
}
byte[] data = OrbisDbg.getBytes(regs);
return(ProcessSetRegisters(IPAddress, ProcessName, data));
}
private void SetRegistersButton_Click(object sender, EventArgs e)
{
if (OrbisDbg.IsProcessPaused())
{
OrbisDbg.SetRegisters(GetRegisters());
}
else
{
MessageBox.Show("The process must be paused before you can get/set registers", "Error Getting Registers");
}
}
private void StepProcess()
{
if (OrbisDbg.IsProcessPaused())
{
OrbisDbg.SingleStep();
if (registersForm != null)
{
registersForm.UpdateRegisterWindow(OrbisDbg.GetRegisters());
}
}
}
private static void CheckForPausedStateThread(MainForm main)
{
while (true)
{
bool isPaused = OrbisDbg.IsProcessPaused();
if (isPaused)
{
main.Invoke((MethodInvoker) delegate() { main.UpdateFormsOnPaused(); });
}
Thread.Sleep(500);
}
}
private void DetachFromProcess(int rowIndex)
{
string processName = ProcessesListDataGridView.Rows[rowIndex].Cells[0].Value.ToString();
int pid = Convert.ToInt32(ProcessesListDataGridView.Rows[rowIndex].Cells[1].Value);
OrbisDbg.SetProcess(processName);
if (mainForm.AllowDetach())
{
mainForm.SetButtonsEnabled(false);
if (mainForm.memoryForm != null)
{
mainForm.memoryForm.Close();
}
if (mainForm.disassemblyForm != null)
{
mainForm.disassemblyForm.Close();
}
if (mainForm.breakpointForm != null)
{
mainForm.breakpointForm.Close();
}
if (mainForm.registersForm != null)
{
mainForm.registersForm.Close();
}
if (Convert.ToBoolean(ProcessesListDataGridView.Rows[rowIndex].Cells[2].Value))
{
ProcessesListDataGridView.Rows[rowIndex].Cells[2].Value = false;
for (int i = 0; i < mainForm.pList.Count; i++)
{
if (mainForm.pList[i].pid == pid)
{
mainForm.pList[i].attached = 0;
break;
}
}
OrbisDbg.DetachProcess();
}
}
else
{
MessageBox.Show("Please clear breakpoints before detaching from this process", "Process can't detach");
}
}
private void UpdateFormsOnPaused()
{
OrbisDbg.registers regs = OrbisDbg.GetRegisters();
if (!bUpdatedOnPause)
{
bool isBreakpoint = OrbisDbg.Ext.ReadByte(regs.r_rip - 1) == 0xCC;
ulong breakAddress = isBreakpoint ? regs.r_rip - 1 : regs.r_rip;
if (isBreakpoint)
{
for (int i = 0; i < breakpoints.Count; i++)
{
if (breakpoints[i].address == breakAddress)
{
OrbisDbg.Ext.WriteByte(breakAddress, breakpoints[i].instruction);
break;
}
}
regs.r_rip -= 1;
OrbisDbg.SetRegisters(regs);
}
if (memoryForm != null)
{
memoryForm.UpdateMemoryView(regs.r_rip, 0x1000, OrbisDbg.GetMemory(regs.r_rip, 0x1000));
}
if (registersForm != null)
{
registersForm.UpdateRegisterWindow(regs);
}
}
if (disassemblyForm != null && regs.r_rip != PreviousRip)
{
if (PreviousRip != 0 && regs.r_rip > PreviousRip && regs.r_rip - PreviousRip < 0xD0)
{
disassemblyForm.UpdateDisassemblyKeepMemory(regs.r_rip);
}
else
{
PreviousRip = regs.r_rip;
byte[] memory = OrbisDbg.GetMemory(regs.r_rip, 0x100);
disassemblyForm.UpdateDisassembly(regs.r_rip, memory, disassemblyForm.IsShowingBytes());
}
}
bUpdatedOnPause = true;
}
private void Register_DoubleClick(object sender, EventArgs e)
{
if (OrbisDbg.IsProcessPaused())
{
TextBox textBox = sender as TextBox;
registerValue = textBox.Text;
textBox.ReadOnly = false;
textBox.ForeColor = Color.Red;
}
else
{
MessageBox.Show("The process must be paused before you can get/set registers", "Error Getting Registers");
}
}
private void PeekToolStripButton_Click(object sender, EventArgs e)
{
ulong address = Convert.ToUInt64(AddressToolStripTextBox.Text, 16);
int size = Convert.ToInt32(LengthToolStripTextBox.Text, 16);
this.address = address;
this.offset = 0;
byte[] memory = OrbisDbg.GetMemory(address, size);
MemoryData = memory;
MemoryStream stream = new MemoryStream(MemoryData);
MemoryViewHexBox.ByteProvider = new DynamicFileByteProvider(stream);
}
private void backtracePointerToolStripMenuItem_Click(object sender, EventArgs e)
{
if (pointers.Count > 0)
{
ulong address = pointers.Pop().address;
AddressToolStripTextBox.Text = "0x" + address.ToString("X");
if (address != 0x0)
{
byte[] memory = OrbisDbg.GetMemory(address, Convert.ToInt32(LengthToolStripTextBox.Text, 16));
MemoryData = memory;
MemoryStream stream = new MemoryStream(MemoryData);
MemoryViewHexBox.ByteProvider = new DynamicFileByteProvider(stream);
}
}
}
private void ConnectToConsole()
{
IPAddress = IPAddressToolStripTextBox.Text;
OrbisDbg.SetIP(IPAddress);
pList = OrbisDbg.GetProcessList();
if (pList.Count > 0)
{
AttachToolStripButton.Enabled = true;
ProcessesToolStripButton.Enabled = true;
bool bAnyProcessesAttached = false;
for (int i = 0; i < pList.Count; i++)
{
if (pList[i].attached != 0)
{
bAnyProcessesAttached = true;
}
}
if (bAnyProcessesAttached)
{
SelectAttachedTarget selectAttachedTarget = new SelectAttachedTarget(pList);
selectAttachedTarget.ShowDialog();
if (selectAttachedTarget.DialogResult == DialogResult.OK)
{
SelectedProcess = selectAttachedTarget.SelectedProcess;
OrbisDbg.SetProcess(selectAttachedTarget.SelectedProcess);
SetButtonsEnabled(true);
}
}
processesWindowToolStripMenuItem.Enabled = true;
ProcessesToolStripButton.Enabled = true;
}
else
{
string message = "Orbis Debugger could not connect to the Playstation 4 System\n" +
"Please make sure your console is turned on and the payload has been loaded";
MessageBox.Show(message, "Error Connecting");
}
}
public OrbisDbg.registers GetRegisters()
{
OrbisDbg.registers result = OrbisDbg.GetRegisters();
result.r_rax = Convert.ToUInt64(RAXRegisterValue.Text, 16);
result.r_rbx = Convert.ToUInt64(RBXRegisterValue.Text, 16);
result.r_rdi = Convert.ToUInt64(RDIRegisterValue.Text, 16);
result.r_rsi = Convert.ToUInt64(RSIRegisterValue.Text, 16);
result.r_rdx = Convert.ToUInt64(RDXRegisterValue.Text, 16);
result.r_rcx = Convert.ToUInt64(RCXRegisterValue.Text, 16);
result.r_r8 = Convert.ToUInt64(R8RegisterValue.Text, 16);
result.r_r9 = Convert.ToUInt64(R9RegisterValue.Text, 16);
result.r_r10 = Convert.ToUInt64(R10RegisterValue.Text, 16);
result.r_r11 = Convert.ToUInt64(R11RegisterValue.Text, 16);
result.r_r12 = Convert.ToUInt64(R12RegisterValue.Text, 16);
result.r_r13 = Convert.ToUInt64(R13RegisterValue.Text, 16);
result.r_r14 = Convert.ToUInt64(R14RegisterValue.Text, 16);
result.r_r15 = Convert.ToUInt64(R15RegisterValue.Text, 16);
result.r_rsp = Convert.ToUInt64(RSPRegisterValue.Text, 16);
result.r_rbp = Convert.ToUInt64(RBPRegisterValue.Text, 16);
result.r_rip = Convert.ToUInt64(RIPRegisterValue.Text, 16);
return(result);
}
private void followPointerToolStripMenuItem_Click(object sender, EventArgs e)
{
ulong previousAddress = 0x0;
if (pointers.Count > 0)
{
previousAddress = pointers.Peek().address;
}
pointers.Push(new Pointers(address + offset));
ulong newAddress = OrbisDbg.Ext.ReadUInt64(address + offset);
AddressToolStripTextBox.Text = "0x" + newAddress.ToString("X");
byte[] memory = OrbisDbg.GetMemory(newAddress, Convert.ToInt32(LengthToolStripTextBox.Text, 16));
MemoryData = memory;
MemoryStream stream = new MemoryStream(MemoryData);
MemoryViewHexBox.ByteProvider = new DynamicFileByteProvider(stream);
}
private void loadELFFileToolStripMenuItem_Click(object sender, EventArgs e)
{
try {
OpenFileDialog openFileDialog1 = new OpenFileDialog();
openFileDialog1.Filter = "ELF Files|*.elf";
openFileDialog1.Title = "Select a File";
if (openFileDialog1.ShowDialog() == DialogResult.OK)
{
string fileName = openFileDialog1.FileName;
byte[] fileBytes = File.ReadAllBytes(fileName);
if (OrbisDbg.InjectELF(fileBytes, fileBytes.Length) == 0)
{
string message = "Orbis Debugger could not load the selected ELF\n" +
"Please make sure you are attached to the desired process";
MessageBox.Show(message, "Error Loading ELF");
}
}
}
catch (Exception) {
MessageBox.Show("Unable to open File Dialog");
}
}
private void OpenProcessWindow()
{
pList = OrbisDbg.GetProcessList();
if (pList.Count > 0)
{
if (processesForm == null)
{
processesForm = new ProcessesForm(this);
processesForm.MdiParent = this;
processesForm.Show();
}
else
{
processesForm.UpdateProcesses();
processesForm.BringToFront();
}
}
else
{
string message = "Orbis Debugger could not connect to the Playstation 4 System\n" +
"Please make sure your console is turned on and the payload has been loaded";
MessageBox.Show(message, "Error Grabbing Processes");
}
}
public static void WriteByte(ulong offset, byte input)
{
byte[] buff = new byte[1];
buff[0] = input;
OrbisDbg.SetMemory(offset, buff);
}
public static void WriteBytes(ulong offset, byte[] input)
{
byte[] buff = input;
OrbisDbg.SetMemory(offset, buff);
}
public static void WriteString(ulong offset, string input)
{
byte[] buff = Encoding.UTF8.GetBytes(input);
Array.Resize(ref buff, buff.Length + 1);
OrbisDbg.SetMemory(offset, buff);
}
public static void WriteUInt16(ulong offset, ushort input)
{
byte[] buff = new byte[2];
BitConverter.GetBytes(input).CopyTo(buff, 0);
OrbisDbg.SetMemory(offset, buff);
}
public static void WriteFloat(ulong offset, float input)
{
byte[] buff = new byte[4];
BitConverter.GetBytes(input).CopyTo(buff, 0);
OrbisDbg.SetMemory(offset, buff);
}
public static void WriteDouble(ulong offset, double input)
{
byte[] buff = new byte[8];
BitConverter.GetBytes(input).CopyTo(buff, 0);
OrbisDbg.SetMemory(offset, buff);
}
