PINCE is a front-end/reverse engineering tool for the GNU Project Debugger (GDB), focused on games.

Overview

PINCE

PINCE is a front-end/reverse engineering tool for the GNU Project Debugger (GDB), focused on games. However, it can be used for any reverse-engineering related stuff. PINCE is an abbreviation for "PINCE is not Cheat Engine". PINCE is in development right now, read Features part of the project to see what is done and Roadmap part to see what is currently planned. Also, please read Wiki Page of the project to understand how PINCE works.

Feel free to join our discord server!

Disclaimer: Do not trust to any source other than Trusted Sources that claims to have the source code or package for PINCE and remember to report them immediately

Disclaimer: YOU are responsible for your actions. PINCE does NOT take any responsibility for the damage caused by the users

Pre-release screenshots:

Features

  • Memory searching: PINCE uses libscanmem to search the memory efficiently [Done]
  • Variable Inspection&Modification [Done/Basic]
    • CheatEngine-like value type support: Byte to 8 Bytes, Float, Double, Strings(including utf-8, utf-16, utf-32 and zero-terminate strings), Array of Bytes [Done]
    • Symbol Recognition: See here [Done]
    • Automatic Variable Allocation: See here [Done]
    • Dynamic Address Table: Supports drag&drop, recursive copy&pasting&inserting and many more [Done]
    • Manual Address Table Update: [Done]
    • Smart casting: PINCE lets you modify multiple different-type values together as long as the input is parsable. All parsing/memory errors are directed to the terminal [Done]
    • Continuous Address Table Update: You can adjust update timer or cancel updating by modifying settings. Non-stop version is Postponed\Quarterway Done [Done\Only works when the inferior is stopped]
    • Variable Locking: PINCE lets you freeze(constantly write a value to memory cell) variables [Done]
  • Memory View [Done/Basic]
    • Infinite Scrolling: PINCE automatically disassembles the next available instruction(s) on mouse wheel/scrollbar move. Instruction count can be changed from settings. Hex View also supports this feature [Done]
    • Dissect Code: You can dissect desired memory regions to find referenced calls, jumps and strings. Disassemble screen will automatically handle the referenced data and show you if there's a referenced address in the current dissasemble view. It can be used from Tools->Dissect Code in the MemoryView window. Using its hotkey instead in the MemoryView window automatically dissects the currently viewed region. You can separately view referenced calls and strings after the search from View->Referenced Calls/Strings. Note: If you decide to uncheck 'Discard invalid strings' before the search, PINCE will try to search for regular pointers as well [Done]
    • Bookmarking: Bookmark menu is dynamically created when right clicked in the disassemble screen. So unlike Cheat Engine, PINCE lets you set unlimited number of bookmarks. List of bookmarks can also be viewed from View->Bookmarks in the MemoryView window. Commenting on an address automatically bookmarks it. [Done]
    • Modify on the fly: PINCE lets you modify registers on the fly. Unlike CE, you can also change XMM and FPU registers. Check GDB expressions in the Wiki page for additional information [Done]
    • Opcode Search: You can search opcodes with python regular expressions. To use this feature, click Tools->Search Opcode in the MemoryView window. [Done]
  • Debugging [Done/Basic]
    • Has basic debugging features such as stepping, stepping over, execute till return, break, continue. Also has breakpoints, watchpoints and breakpoint conditions. Has advanced debugging utilities such as Watchpoint/Breakpoint Tracking and Tracing
    • Chained Breakpoints: Just like CE, PINCE allows you to set multiple, connected breakpoints at once. If an event(such as condition modification or deletion) happens in one of the breakpoints, other connected breakpoints will get affected as well [Done]
    • Watchpoint Tracking: Allows you to see which instructions have been accessing to the specified address, just like "What accesses/writes to this address" feature in CE [Done]
    • Breakpoint Tracking: Allows you to track down addresses calculated by the given register expressions at the specified instruction, just like "Find out what addresses this instruction accesses" feature in CE with a little addon, you can enter multiple register expressions, this allows you to check the value of "esi" even if the instruction is something irrelevant like "mov [eax],edx" [Done]
    • Tracing: Almost the same with CE. But unlike CE, you can stop tracing whenever you want. Created from scratch with shittons of custom features instead of using gdb's trace&collect commands because some people have too much time on their hands [Done]
    • Collision Detection: GDB normally permits setting unlimited watchpoints next to each other. But this behaviour leads to unexpected outcomes such as causing GDB or the inferior become completely inoperable. GDB also doesn't care about the number(max 4) or the size(x86->max 4, x64->max 8) of hardware breakpoints. Fortunately, PINCE checks for these problems whenever you set a new breakpoint and detects them before they happen and then inhibits them in a smart way. Lets say you want to set a breakpoint in the size of 32 bytes. But the maximum size for a breakpoint is 8! So, PINCE creates 4 different breakpoints with the size of 8 bytes and then chains them for future actions [Done]
  • Code Injection [Working on it]
    • Run-time injection: Only .so injection is supported for now. In Memory View window, click Tools->Inject .so file to select the .so file. An example for creating .so file can be found in "libPINCE/Injection/". PINCE will be able to inject single line instructions or code caves in near future [Partially Done?]
  • GDB Console [Done]
    • Is the power of PINCE not enough for you? Then you can use the gdb console provided by PINCE, it's on the top right in main window
  • Simplified/Optimized gdb command alternatives [Working on it]
    • Custom scripts instead of using gdb's x command for reading memory [Done]
    • Custom scripts instead of using gdb's set command for modifying memory [Done]
  • libPINCE- A reusable python library
    • PINCE provides a reusable python library. You can either read the code or check Reference Widget by clicking Help->libPINCE in Memory Viewer window to see docstrings. Contents of this widget is automatically generated by looking at the docstrings of the source files. PINCE has a unique parsing technique that allows parsing variables. Check the function get_comments_of_variables in SysUtils for the details. This feature might be replaced with Sphinx in the future
  • Extendable with .so files at runtime
  • Automatic Trainer Generation: [Planned]
    • PINCE provides a trainer auto-generated from current address table on demand by using libPINCE and PyQT5 together

Installing

Clone this repo by running git clone --recursive https://github.com/korcankaraokcu/PINCE then run sudo sh install_pince.sh in the PINCE directory. Install script currently supports Ubuntu and Debian. For Archlinux, use the AUR package instead.

If you like to uninstall PINCE, just delete this folder. Almost everything is installed locally, including gdb. Config and user files of PINCE can be found in "~/.config/PINCE", you can manually delete them if you want.

Notes:

  • GDB enhancements (peda, pwndbg, etc) that use a global gdbinit file might cause PINCE to misfunction at times. Please disable them or use them locally before starting PINCE
  • Having spaces in your path might cause GDB to fail compiling

Running PINCE

Just run sh PINCE.sh in the PINCE directory

For developers:

sudo apt-get install qttools5-dev-tools (qt5 form designer)
sudo apt-get install pyqt5-dev-tools (pyuic5)
sudo pip3 install line_profiler (for performance testing)

How to use line_profiler: Add @profile tag to the desired function and run PINCE with sudo kernprof -l -v PINCE.py

History

  • A few weeks till 17/01/2016 : Learned GDB, process of analysis
  • 17/01/2016-22/01/2016 : Basic design, grasping of Python3 and Pyqt5, proof-testing
  • 22/01/2016 : First commit
  • 19/02/2016 : Moved to Github from Bitbucket
  • 25/02/2016 : First successful implementation of thread injection[Update-08/05/2016 : PINCE now uses linux-inject as a secondary injection method]
  • 18/06/2016 : PINCE now supports all-stop mode instead of non-stop mode
  • 21/06/2016 : Variable Inspection&Modification is finished(At basic level)
  • 21/08/2016 : Memory View is finished(At basic level)
  • 24/08/2016 : PINCE no more uses linux-inject because of stability issues(a fix for the race conditions in the inferior would be nice)
  • 26/12/2016 : Debugging is finished(At basic level)
  • 19/05/2020 : libscanmem integration is complete, enjoy memory searching. Huge thanks to fisu, xk and 12345ieee (libscanmem team)

Current Roadmap

  • Refactor file naming conventions(libPINCE->libpince, decide on snake_case or camelCase for modules etc)
  • Create CONTRIBUTING.md and combine all non-tutorial notes within it
  • Consider replacing read/write_memory_multiple functions with mem_handle&read/write_memory functions, this fixes the "read_memory_multiple follows a bad design pattern" step
  • Implement non-stop Continuous Address Table Update feature
  • Refactorize memory write/read functions
    • ReferencedStringsWidgetForm refreshes the cache everytime the comboBox_ValueType changes, this creates serious performance issues if total results are more than 800k. Only update the visible rows to prevent this(check disassemble_check_viewport for an example)
    • Implement same system for the TrackBreakpointWidgetForm if necessary. Do performance tests
    • Consider using a class instead of primitive return types to store the raw bytes. This also gets rid of the unnecessary parameter only_bytes. This class should also include a method to display None type as red '??' text for Qt
    • text_to_valuetype is a bad design pattern. Store the information inside the items of tableWidget_AddressTable instead
    • read_memory_multiple follows a bad design pattern, use named tuples or something like that
    • Provide an option to cut BOM bytes when writing to memory with the types UTF-16 and UTF-32
    • Put a warning for users about replacement bytes for non UTF-8 types
    • Extend string types with LE and BE variants of UTF-16 and UTF-32
    • Change comboBox_ValueType string order to be ... String_UTF-8 String_Others Array of Bytes
    • Implement a custom combobox class for comboBox_ValueType and create a context menu for String_Others item
  • Indent docstrings properly like GDB_Engine.get_breakpoint_info does(independent from other steps)
  • Implement "Investigate Registers" button to gather information about the addresses registers point to(independent from other steps)
  • Implement selectionChanged signal of lineEdit_HexView
  • Implement multi selection for HexView
  • Add the ability to track down registers and addresses in tracer(unsure)(independent from other steps)
  • Implement CE's Ultimap-like feature for tracing data, dissect code data and raw instruction list. Search for calls and store their hit counts to filter out the functions that haven't or have executed specific number of times. Implement a flexible input field for the execution count. For instance, 2^x only searches for hit counts 2, 4, 8 and so on, 3x only searches for 3, 6, 9 etc.(independent from other steps)(CE#358)
  • Extend search_referenced_strings with relative search
  • Consider adding type guessing for the StackView(independent from other steps)
  • Move GUI classes of PINCE.py to their own files
  • Handle signals and internal errors that causes gdb to halt, such as SIGSEGV and overlapping breakpoints(independent from other steps)
  • Use gdb python API breakpoints instead of breakpoint commands for optimization, also find a way to eliminate output coming from stepping commands such as stepi or nexti(independent from other steps)
  • Implement a psuedo-terminal for the inferior like edb does(independent from other steps)
  • Implement libPINCE engine
  • Implement auto-ESP&aimbot (depends on libPINCE engine)
  • Try to optimize TrackBreakpoint and TrackWatchpoint return data structures further, adding an id field might simplify traversing of the tree, performance tests are required(independent from other steps)
  • Extend tagging system to PINCE GUI functions
  • Implement inject_with_advanced_injection(independent from other steps)
  • Implement single-line code injection
  • Implement multi-line code injection
  • Break on/Catch signals and syscalls
  • Move non-communication functions in GDB_Engine to ScriptUtils and create corresponding fields in GDB_Engine and GDBCommandExtensions automatically. This lets entire functionality of libPINCE to be used with both python scripts and gdb python scripts, thus allowing it to be used as a plugin for projects such as radare2
  • Flowcharts based on disassembled output
  • Automatic function bypassing(make it return the desired value, hook specific parts etc.)
  • Implement speedhack(independent from other steps)
  • Implement unrandomizer(independent from other steps)
  • Implement pointer-scan
  • Write at least one test for each function in libPINCE
  • Migrate to Sphinx documentation from the custom libPINCE documentation(independent from other steps)
  • Embedded tutorial videos
  • Super-Uber-Rad credits roll with chiptune tunes
  • Implement extra MemoryViewerWindow tabs(independent from other steps)
  • Consider removing the command file layer of IPC system for GDB_Engine.send_command to speed up things(independent from other steps)[Update-29/04/2018 : Delaying this until GDB/MI implements a native multiline command feature or improves interpreter-exec command to cover every single multiline command type(including define commands)]
  • Implement thread info widget
  • Add ability to change logo and other assets if people contribute more than one asset per usage. Also consider using PINCE-media for development if needed(independent from other steps)
  • Implement developer mode in settings. Developer mode will include features like dissection of GUI elements on events such as mouse-over(independent from other steps)
  • Add ability to include non-absolute calls for dissect code feature(i.e call rax). Should be considered after the first version release. Might be useful for multi-breakpoint related features
  • Implement toggling of arrows for easier navigation for dissected regions(independent from other steps)
  • Provide information about absolute addresses in disassemble screen(independent from other steps)
  • Use type hints(py 3.5) and variable annotations(py 3.6) when support drops for older systems(independent from other steps)
  • All tables that hold large amount of data should only update the visible rows(check disassemble_check_viewport for an example)(independent from other steps)
  • Add different kinds of themes and the ability to change between them on runtime. Implement dark theme first. Also add the ability to create a custom theme and modify the existing ones(independent from other steps)

License

GPLv3+. See COPYING file for details

Contact Information

Korcan Karaokçu(korcankaraokcu) [email protected]
Çağrı Ulaş(cagriulas) [email protected]
Jakob Kreuze(TsarFox) [email protected]
Gibus [email protected]

Supported platforms

  • Kubuntu 18.04 & 16.04(Also tested on x86 variants)
  • Debian 9 (Stretch)
  • Kali Linux
  • Parrot OS
  • Linux Mint 19 (Tara)(install the package "python3-psutil" if you encounter ImportError or NameError, thanks Gibus)
  • Archlinux(tag cagriulas or TsarFox when creating an issue)

Trusted Sources

Comments
  • Duplication of effort

    Duplication of effort

    I see @korcankaraokcu around the scanmem/GC issues, I thought about paying a courtesy visit.

    On my system I probably need to recompile gdb, as PINCE opens but cannot attach to any process, so I don't have a definite opinion.

    My question is, how much overlap do you have with GC? I know you want to use libscanmem, I'm interested in the gui.

    question 
    opened by 12345ieee 23
  • Won't install

    Won't install

    Because the installation insists on gdb 8.2 while my system reports it already has the latest version and refuses to install which causes the whole script to bail outright, please just set your install script to require min gdb 8.2 instead of insisting on that exact version

    opened by awsdert 18
  • Make the address table items store the original address expression

    Make the address table items store the original address expression

    Fixes #45.

    Changes:

    • Since the address table items store address_expr, address_expr needs to be passed into change_address_table_entries.
    • So, calling convention (parameters) of change_address_table_entries is changed, and all of its occurences needs to be modified accordingly. That is a big change and I hope there is no bug.
    • There are some redundant text_to_valuetype and valuetype_to_text calls. To solve it, it's necessary to refactor the code to store the details inside the items ("text_to_valuetype is a bad design pattern. Store the information inside the items of tableWidget_AddressTable instead" inside roadmap)
    opened by user202729 14
  • EOFError when trying to attach

    EOFError when trying to attach

    When trying to attach to a process, command line says

    0.0014507770538330078
    Last command: pince-get-stack-trace-info
     
    &"source /tmp/PINCE-connection/10995/gdb_command.txt\n"
    &"Python Exception <class 'gdb.MemoryError'> Cannot access memory at address 0x850fb148: \n"
    &"/tmp/PINCE-connection/10995/gdb_command.txt:1: Error in sourced command file:\n"
    &"Error occurred in Python command: Cannot access memory at address 0x850fb148\n"
    ^error,msg="/tmp/PINCE-connection/10995/gdb_command.txt:1: Error in sourced command file:\nError occurred in Python command: Cannot access memory at address 0x850fb148"
    
    Traceback (most recent call last):
      File "PINCE.py", line 1590, in on_process_stop
        self.update_stacktrace()
      File "PINCE.py", line 1680, in update_stacktrace
        stack_trace_info = GDB_Engine.get_stacktrace_info()
      File "/home/trent/PINCE-master/libPINCE/GDB_Engine.py", line 927, in get_stacktrace_info
        contents_recv = send_command("pince-get-stack-trace-info", recv_with_file=True)
      File "/home/trent/PINCE-master/libPINCE/GDB_Engine.py", line 121, in send_command
        output = pickle.load(open(recv_file, "rb"))
    EOFError: Ran out of input
    

    Then when I try to scan for a value It says

    Exception test
    Traceback (most recent call last):
      File "PINCE.py", line 450, in newfirstscan_onclick
        x = 0 / 0
    ZeroDivisionError: division by zero
    
    opened by tbillington 14
  • Suggested default icon until you make a logo

    Suggested default icon until you make a logo

    I found one in my pre-installed icons (on manjaro) called custom-toolbox, I think that would be a suitable icon for time being, as for future logo I think a joypad with a wrench on top would make for a good logo since this is focused on cheating, if you want a more general suggestion then the only thing that comes to mind is similar but with a gear instead of a joypad

    opened by awsdert 13
  • Error during process attaching

    Error during process attaching

    OS: Debian 8 x64 Desktop environment: KDE 4

    Traceback (most recent call last):
      File "PINCE.py", line 571, in pushbutton_open_onclick
        code_injection_status = GDB_Engine.attach(str(pid), initial_code_injection_method)
      File "/usr/share/PINCE/GDB_Engine.py", line 213, in attach
        SysUtils.create_PINCE_IPC_PATH(pid)
      File "/usr/share/PINCE/SysUtils.py", line 242, in create_PINCE_IPC_PATH
        is_path_valid(get_PINCE_IPC_directory(pid), "create")
      File "/usr/share/PINCE/SysUtils.py", line 208, in is_path_valid
        fix_path_permissions(dest_path)
      File "/usr/share/PINCE/SysUtils.py", line 221, in fix_path_permissions
        uid = int(os.environ.get('SUDO_UID'))
    TypeError: int() argument must be a string or a number, not 'NoneType'
    
    bug 
    opened by davidebeatrici 13
  • Pauses after resuming

    Pauses after resuming

    When I attach a process, the game automatically pauses. (I guess that is fine) However, when I press F3 to resume, it takes about 1 second before it pauses again by itself. If I were to close the memory viewer and press F3 to resume again, it pauses and the memory viewer opens up again.

    I do not believe this is intentionally designed to behave like this (I hope). If there is any additional information I can provide, let me know.

    opened by ivanskodje 12
  • I CAN NOT RUN PINCE

    I CAN NOT RUN PINCE

    sh PINCE.sh [sudo] cloversss 的密码:

    (PINCE.py:1539): Gtk-WARNING **: 10:39:10.868: Theme parsing error: gtk-contained-dark.css:2871:228: Missing closing bracket for :not() /home/cloversss/PINCE/libpince/libscanmem/misc.py:24: PyGIWarning: Gtk was imported without specifying a version first. Use gi.require_version('Gtk', '3.0') before import to ensure that the right version gets loaded. from gi.repository import Gtk QStandardPaths: runtime directory '/run/user/1000' is not owned by UID 0, but a directory permissions 0700 owned by UID 1000 GID 1000 Detached from the process with PID:-1 Last command: set logging off ^done 0.0013473033905029297 Last command: set logging file /dev/shm/PINCE-connection/-1/gdb_log.txt =cmd-param-changed,param="logging file",value="/dev/shm/PINCE-connection/-1/gdb_log.txt" ^done 0.0006613731384277344 Last command: source /home/cloversss/.config/PINCE/PINCE_USER_FILES/gdbinit ^done 0.000644683837890625 Last command: handle SIGSEGV stop print ^done 0.0009517669677734375 Last command: set logging off ^done 0.0009047985076904297 Last command: set logging file /dev/shm/PINCE-connection/-1/gdb_log.txt ^done 0.0007500648498535156 Traceback (most recent call last): File "/home/cloversss/PINCE/PINCE.py", line 5261, in window = MainForm() File "/home/cloversss/PINCE/PINCE.py", line 375, in init self.memory_view_window = MemoryViewWindowForm(self) File "/home/cloversss/PINCE/PINCE.py", line 2239, in init self.initialize_disassemble_view() File "/home/cloversss/PINCE/PINCE.py", line 2283, in initialize_disassemble_view GuiUtils.center_scroll_bar(self.verticalScrollBar_Disassemble) File "/home/cloversss/PINCE/libpince/GuiUtils.py", line 77, in center_scroll_bar QScrollBar.setValue((maximum + minimum) / 2) TypeError: setValue(self, int): argument 1 has unexpected type 'float'

    opened by FxmlesXD 11
  • Searching for array of bytes does not guarantee searching in read/execute-only segments.

    Searching for array of bytes does not guarantee searching in read/execute-only segments.

    If you find any assembly instruction that you would like to get address of by pattern. If you try searching for it, apparently it won't yield any results, even if you copy bytes directly by inspecting the memory section. On the other hand, when performing similar search for array of bytes for something in data section, pince correctly finds the data.

    opened by eLeCtrOssSnake 10
  • Built gdb segfaults on ubuntu 21.04

    Built gdb segfaults on ubuntu 21.04

    On commit : 90142e02b4e4baf72e4040d478a57494a7a81e4a OS: Ubuntu 21.04, 5.11.0-25-generic #27-Ubuntu SMP

    got this error when I set to absolute path to the built gdb

    qt.qpa.xcb: QXcbConnection: XCB error: 3 (BadWindow), sequence: 2020, resource id: 14683379, major code: 40 (TranslateCoords), minor code: 0
    Detached from the process with PID:-1
    Traceback (most recent call last):
      File "/home/user/PINCE/PINCE.py", line 1790, in accept
        GDB_Engine.init_gdb(gdb_path=selected_gdb_path)
      File "/home/user/PINCE/libPINCE/GDB_Engine.py", line 499, in init_gdb
        child.expect_exact("(gdb)")
      File "/usr/lib/python3/dist-packages/pexpect/spawnbase.py", line 421, in expect_exact
        return exp.expect_loop(timeout)
      File "/usr/lib/python3/dist-packages/pexpect/expect.py", line 179, in expect_loop
        return self.eof(e)
      File "/usr/lib/python3/dist-packages/pexpect/expect.py", line 122, in eof
        raise exc
    pexpect.exceptions.EOF: End Of File (EOF). Exception style platform.
    <pexpect.pty_spawn.spawn object at 0x7f6be806ba30>
    command: /usr/bin/sudo
    args: [b'/usr/bin/sudo', b'LC_NUMERIC=C', b'/home/user/PINCE/libPINCE/gdb_pince/gdb-8.3.1/bin/gdb', b'--interpreter=mi']
    
    

    So I ran gdb inside gdb and its segfaulting, Not sure if i have missed anything gdb --args /home/user/PINCE/libPINCE/gdb_pince/gdb-8.3.1/bin/gdb --interpreter=mi

    [Thread debugging using libthread_db enabled]
    Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
    
    Program received signal SIGSEGV, Segmentation fault.
    -----------------------------------------------------------------------------------------------------------------------[regs]
      RAX: 0x00007FFFF7F15040  RBX: 0x00007FFFFFFFD940  RCX: 0x0000555555B020DC  RDX: 0x0000000000000000  o d I t s Z a P c 
      RSI: 0x0000000000000000  RDI: 0x00007FFFF7F15198  RBP: 0x00007FFFF6E0B030  RSP: 0x00007FFFFFFFD918  RIP: 0x00007FFFF7B4B959
      R8 : 0x0000555555B020D7  R9 : 0x0000555555E359D0  R10: 0x00000000000001FF  R11: 0x5933A120734F50A4  R12: 0x0000555555DBF250
      R13: 0x00007FFFFFFFD930  R14: 0x0000000000000010  R15: 0x0000000000000000
      CS: 0033  DS: 0000  ES: 0000  FS: 0000  GS: 0000  SS: 002B
    -----------------------------------------------------------------------------------------------------------------------[code]
    => 0x7ffff7b4b959 <PyEval_ReleaseLock+25>:      mov    rcx,QWORD PTR [rdx+0x10]
       0x7ffff7b4b95d <PyEval_ReleaseLock+29>:      lea    rsi,[rcx+0x40]
       0x7ffff7b4b961 <PyEval_ReleaseLock+33>:      jmp    0x7ffff7b4b760
       0x7ffff7b4b966:      nop    WORD PTR cs:[rax+rax*1+0x0]
       0x7ffff7b4b970 <_PyEval_SignalReceived>:     endbr64 
       0x7ffff7b4b974 <_PyEval_SignalReceived+4>:   mov    rax,QWORD PTR [rdi+0x10]
       0x7ffff7b4b978 <_PyEval_SignalReceived+8>:   push   r12
       0x7ffff7b4b97a <_PyEval_SignalReceived+10>:  push   rbp
    -----------------------------------------------------------------------------------------------------------------------------
    0x00007ffff7b4b959 in PyEval_ReleaseLock () from /lib/x86_64-linux-gnu/libpython3.9.so.1.0
    gdb$ bt
    #0  0x00007ffff7b4b959 in PyEval_ReleaseLock () from /lib/x86_64-linux-gnu/libpython3.9.so.1.0
    #1  0x0000555555885c58 in do_start_initialization () at python/python.c:1740
    #2  _initialize_python () at python/python.c:1828
    #3  0x0000555555983ffe in initialize_all_files () at init.c:204
    #4  0x0000555555935dc9 in gdb_init (argv0=<optimized out>) at top.c:2185
    #5  0x000055555580ad62 in captured_main_1 (context=0x7fffffffda58) at main.c:868
    #6  captured_main (data=0x7fffffffda58) at main.c:1172
    #7  gdb_main (args=0x7fffffffda58, [email protected]=0x7fffffffdb40) at main.c:1198
    #8  0x0000555555626f70 in main (argc=<optimized out>, argv=<optimized out>) at gdb.c:32
    
    opened by hstejas 10
  • PINCE totally locks down search interface

    PINCE totally locks down search interface

    No matter what I try when I try to hack the memory of game via PINCE it outright refuses to do anything but show the debugger/memory (reader?), I'd like an option to ignore risks and just scan anyway, GameConqueror can get into the same memory just fine but it lacks the ability to search for values based on number of bits which I was trying to use PINCE for but everything is just permanently disabled The game I'm trying is Dragon Quest Builders on RPCS3

    duplicate 
    opened by awsdert 10
  • Flatpak builds

    Flatpak builds

    It would be really useful to have flatpak builds of the app.

    The main reason I would appreciate it is that the steam deck only officially supports flatpak installs.

    opened by jcc10 1
  • Pince doesn't start

    Pince doesn't start

    So after running the install script then running pince by doing sh PINCE.sh it gives this and then doesn't do anything

    /home/alib234/Gits/PINCE/libpince/libscanmem/misc.py:24: PyGIWarning: Gtk was imported without specifying a version first. Use gi.require_version('Gtk', '4.0') before import to ensure that the right version gets loaded.
      from gi.repository import Gtk
    QStandardPaths: runtime directory '/run/user/1000' is not owned by UID 0, but a directory permissions 0700 owned by UID 1000 GID 985
    QSocketNotifier: Can only be used with threads started with QThread
    QStandardPaths: runtime directory '/run/user/1000' is not owned by UID 0, but a directory permissions 0700 owned by UID 1000 GID 985
    /home/alib234/Gits/PINCE/PINCE.py:5613: Warning: cannot register existing type 'GtkWidget'
      app = QApplication(sys.argv)
    /home/alib234/Gits/PINCE/PINCE.py:5613: Warning: g_type_add_interface_static: assertion 'G_TYPE_IS_INSTANTIATABLE (instance_type)' failed
      app = QApplication(sys.argv)
    /home/alib234/Gits/PINCE/PINCE.py:5613: Warning: cannot register existing type 'GtkBuildable'
      app = QApplication(sys.argv)
    /home/alib234/Gits/PINCE/PINCE.py:5613: Warning: g_type_interface_add_prerequisite: assertion 'G_TYPE_IS_INTERFACE (interface_type)' failed
      app = QApplication(sys.argv)
    /home/alib234/Gits/PINCE/PINCE.py:5613: Warning: g_once_init_leave: assertion 'result != 0' failed
      app = QApplication(sys.argv)
    /home/alib234/Gits/PINCE/PINCE.py:5613: Warning: g_type_register_static: assertion 'parent_type > 0' failed
      app = QApplication(sys.argv)
    
    opened by Alib234 3
  • Cannot use Print Screen button in PINCE UI

    Cannot use Print Screen button in PINCE UI

    Since the keyboard shortcut update, I am no longer able to use the Print Screen key and OS functionality within the app.

    If I give the UI focus, I am unable to use the key.

    If I select another window, Print Screen works fine and I am able to take screenshots.

    I am on Ubuntu 20.04 if that matters.

    opened by jaredballou 1
  • PINCE unusable in Arch Linux

    PINCE unusable in Arch Linux

    PINCE is unusable in Arch Linux. I am not sure where it fails, but I can't scan any values of the memory. Also after attaching, the process gets halted but PINCE is still showing that no process is attached. At this point (after attaching a process) I get errors in my terminal. Also the process selection window does not close itself after selecting a process, which is not intended I suppose. I am starting pince through terminal without sudo. There are lots of errors, here are some snippets

    Last command: source gdb_python_scripts/GDBCommandExtensions.py &"Traceback (most recent call last):\n" &" File "gdb_python_scripts/GDBCommandExtensions.py", line 27, in \n" &" from libpince import SysUtils, type_defs, common_regexes\n" &" File "/usr/share/PINCE/libpince/SysUtils.py", line 32, in \n" &" from pygdbmi import gdbmiparser\n" &"ModuleNotFoundError: No module named 'pygdbmi'\n" ^done 0.09264874458312988 Last command: pince-parse-and-eval &"/dev/shm/PINCE-connection/2974/gdb_command.txt:1: Error in sourced command file:\n" &"Undefined command: "pince-parse-and-eval". Try "help".\n" ^error,msg="/dev/shm/PINCE-connection/2974/gdb_command.txt:1: Error in sourced command file:\nUndefined command: "pince-parse-and-eval". Try "help"." Traceback (most recent call last): File "/usr/share/PINCE/PINCE.py", line 1452, in pushButton_Open_clicked if self.parent().attach_to_pid(pid): File "/usr/share/PINCE/PINCE.py", line 1117, in attach_to_pid attach_result = GDB_Engine.attach(pid, gdb_path) File "/usr/share/PINCE/libpince/GDB_Engine.py", line 607, in attach inferior_arch = get_inferior_arch() File "/usr/share/PINCE/libpince/GDB_Engine.py", line 1155, in get_inferior_arch if parse_and_eval("$rax") == "void": File "/usr/share/PINCE/libpince/GDB_Engine.py", line 1024, in parse_and_eval return send_command("pince-parse-and-eval", send_with_file=True, file_contents_send=(expression, cast), File "/usr/share/PINCE/libpince/GDB_Engine.py", line 238, in send_command output = pickle.load(open(recv_file, "rb")) EOFError: Ran out of input

    also

    Last command: pince-examine-expressions &"/dev/shm/PINCE-connection/2974/gdb_command.txt:1: Error in sourced command file:\n" &"Undefined command: "pince-examine-expressions". Try "help".\n" ^error,msg="/dev/shm/PINCE-connection/2974/gdb_command.txt:1: Error in sourced command file:\nUndefined command: "pince-examine-expressions". Try "help"." Traceback (most recent call last): File "/usr/share/PINCE/PINCE.py", line 2844, in on_process_stop self.disassemble_expression("$pc") File "/usr/share/PINCE/PINCE.py", line 2679, in disassemble_expression program_counter = GDB_Engine.examine_expression("$pc").address File "/usr/share/PINCE/libpince/GDB_Engine.py", line 989, in examine_expression return send_command("pince-examine-expressions", send_with_file=True, file_contents_send=[expression], File "/usr/share/PINCE/libpince/GDB_Engine.py", line 238, in send_command output = pickle.load(open(recv_file, "rb")) EOFError: Ran out of input

    When I try starting Pince through terminal with sudo, it doesn't even start, I get the error

    Traceback (most recent call last): File "/usr/share/PINCE/PINCE.py", line 31, in from libpince import GuiUtils, SysUtils, GDB_Engine, type_defs File "/usr/share/PINCE/libpince/GuiUtils.py", line 24, in from . import SysUtils, type_defs, common_regexes File "/usr/share/PINCE/libpince/SysUtils.py", line 32, in from pygdbmi import gdbmiparser ModuleNotFoundError: No module named 'pygdbmi'

    note that pygdbmi is installed on my system.

    opened by MuradTroll 8
  • Fedora support?

    Fedora support?

    Hey there,

    I'd love to see this packaged for Fedora, as it is a very capable piece of software. Distribution could be made easier using Copr (Fedora's user repository); there's a publishing guide and full user docs that have more information.

    Also, I had to dnf install libtool intltool readline-devel to get install_pince.sh to complete correctly on my system, as they are not present by default.

    Thanks, Elliott

    opened by pointydev 2
  • Unable to create io-slave

    Unable to create io-slave

    I get that error popup when I try to open a pct file.

    Clicking ok on the error dialogue closes it and the open file window that is left behind can move to different folders, but is not able to locate any files in any folder, and if I type the file name manually, when I press load I get an error message saying the file could not be found though it definitely exists in the path displayed in the error message.

    I'm running Kubuntu 20.04 which uses

    • KDE Plasma version 5.18.8
    • KDE Framework version 5.68.0
    • Qt version 5.12.8
    • kernel version 5.4.0-109-generic

    The full io-slave error is Unable to create io-slave. Can not create socket for launching io-slave for protocol 'file'.

    opened by Karnor 1
Owner
Korcan Karaokçu
Reverse Engineer
Korcan Karaokçu
GDB plugin for streaming defmt messages over RTT from e.g. JLinkGDBServer

Defmt RTT plugin from GDB This small plugin runs defmt-print on the RTT stream produced by JLinkGDBServer, so that you can see the defmt logs in the G

Gaute Hope 1 Dec 30, 2021
The official code of LM-Debugger, an interactive tool for inspection and intervention in transformer-based language models.

LM-Debugger is an open-source interactive tool for inspection and intervention in transformer-based language models. This repository includes the code

Mor Geva 96 Sep 19, 2022
pdb++, a drop-in replacement for pdb (the Python debugger)

pdb++, a drop-in replacement for pdb What is it? This module is an extension of the pdb module of the standard library. It is meant to be fully compat

null 988 Sep 29, 2022
Full-screen console debugger for Python

PuDB: a console-based visual debugger for Python Its goal is to provide all the niceties of modern GUI-based debuggers in a more lightweight and keybo

Andreas Klöckner 2.5k Sep 26, 2022
An improbable web debugger through WebSockets

wdb - Web Debugger Description wdb is a full featured web debugger based on a client-server architecture. The wdb server which is responsible of manag

Kozea 1.6k Sep 18, 2022
Debugger capable of attaching to and injecting code into python processes.

DISCLAIMER: This is not an official google project, this is just something I wrote while at Google. Pyringe What this is Pyringe is a python debugger

Google 1.6k Sep 23, 2022
pdb++, a drop-in replacement for pdb (the Python debugger)

pdb++, a drop-in replacement for pdb What is it? This module is an extension of the pdb module of the standard library. It is meant to be fully compat

null 987 Sep 23, 2022
Graphical Python debugger which lets you easily view the values of all evaluated expressions

birdseye birdseye is a Python debugger which records the values of expressions in a function call and lets you easily view them after the function exi

Alex Hall 1.5k Sep 19, 2022
Voltron is an extensible debugger UI toolkit written in Python.

Voltron is an extensible debugger UI toolkit written in Python. It aims to improve the user experience of various debuggers (LLDB, GDB, VDB an

snare 5.8k Sep 23, 2022
NoPdb: Non-interactive Python Debugger

NoPdb: Non-interactive Python Debugger Installation: pip install nopdb Docs: https://nopdb.readthedocs.io/ NoPdb is a programmatic (non-interactive) d

Ondřej Cífka 66 Sep 19, 2022
Tracing instruction in lldb debugger.Just a python-script for lldb.

lldb-trace Tracing instruction in lldb debugger. just a python-script for lldb. How to use it? Break at an address where you want to begin tracing. Im

null 147 Sep 4, 2022
Full featured multi arch/os debugger built on top of PyQt5 and frida

Full featured multi arch/os debugger built on top of PyQt5 and frida

iGio90 1.1k Sep 27, 2022
Arghonaut is an interactive interpreter, visualizer, and debugger for Argh! and Aargh!

Arghonaut Arghonaut is an interactive interpreter, visualizer, and debugger for Argh! and Aargh!, which are Befunge-like esoteric programming language

Aaron Friesen 2 Dec 10, 2021
A simple rubber duck debugger

Rubber Duck Debugger I found myself many times asking a question on StackOverflow or to one of my colleagues just for finding the solution simply by d

null 1 Nov 10, 2021
Visual Interaction with Code - A portable visual debugger for python

VIC Visual Interaction with Code A simple tool for debugging and interacting with running python code. This tool is designed to make it easy to inspec

Nathan Blank 1 Nov 16, 2021
Hdbg - Historical Debugger

hdbg - Historical Debugger This is in no way a finished product. Do not use this

Fivreld 2 Jan 2, 2022
Trashdbg - TrashDBG the world's worse debugger

The world's worse debugger Over the course of multiple OALABS Twitch streams we

OALabs 21 Jun 17, 2022
🔥 Pyflame: A Ptracing Profiler For Python. This project is deprecated and not maintained.

Pyflame: A Ptracing Profiler For Python (This project is deprecated and not maintained.) Pyflame is a high performance profiling tool that generates f

Uber Archive 3k Sep 29, 2022
VizTracer is a low-overhead logging/debugging/profiling tool that can trace and visualize your python code execution.

VizTracer is a low-overhead logging/debugging/profiling tool that can trace and visualize your python code execution.

null 2.5k Sep 25, 2022