Using Ghidra to Reverse Engineer Super Monkey Ball for GameCube

You mentioned collaborating on annotating the decompiled code. Is the linked code something created manually based on the "raw" results of the decompilation? Or does the toolset allow you to annotate memory addresses etc in such a way that when you invoke the decompilation it uses the nice names automatically?

And once your more or less proficient then just crack some software. Find something old, like protected by purchasing key or whatever, and on the simpler side, don't go straight for photoshop or whatever. Its gonna take a long time but even if you don't succeed you'll get a much better feel for it in the process. Best way to learn is by doing, thats my experience anyways.

It's very windows focused but teaches skills that are (somewhat) easily transferable.

The one thing I'd say is a real pre-requisite is to learn C. And I mean really learn C: pointers, including arithmetic and aliasing; memory allocation; stack vs heap; statics and globals. C is the lingua franca of this environment, and learning C will give you a good window into what the compiler is doing to turn your code into what's actually running on the CPU.

It's also good to understand how computers actually work. I strongly recommend the book "Code" by Charles Petzold (Microsoft Press, be wary of counterfeits and don't buy from Amazon). It starts literally from scratch. Like, light bulbs with electricity and a switch. Then it builds on that to create a fundamental CPU, and then shows how to go from there into the real CPUs used today, including an introduction to assembly language and machine code. It's a fantastic book if you ever want to do anything low-level on a computer.

Once you've got C and a basic level of understanding of assembly/machine code, I think you're ready to do something real. Start simple. The NES runs on a 6502, which is 8-bit, has three registers and only a handful of opcodes, and is single-threaded. In the past I've used FCEUX-DSP's debugger features[1], but I think these days most people use Mesen. You can use the same basic techniques I did in these articles: scan memory for the values you want (the player's score or life count; the player character's velocity), then set watch points to find the code that modifies them, then go understand what that code is doing and change it to do what you want. Give yourself infinite lives or a crazy high jump in Super Mario Bros or something.

From there you can move on to more modern CPUs and such, but the complexity goes _way_ up once you move on from environments where most stuff was actually written in ASM or very simple C without fancy compilers. I was very relieved to see how readable Super Monkey Ball's disassembly actually was.

[1] My first real game RE project was dumping PNG pictures of the levels in M.C. Kids for NES, for comparison on TCRF:

https://gitlab.com/mcmapper/mcmapper/-/blob/master/main.c

https://tcrf.net/Proto:M.C._Kids

https://news.ycombinator.com/item?id=26296951

I learned (intel x86)assembly from joining a cracking group when I was adolescent, it was my first programming language. Nothing beats being taught by masters of the craft and competing and contributing as a team.

Today I teach kids ARM assembly using microcontrollers like arduino unos or nanos and controlling a motor or servo, then I add more and more complexity like explaining klipper architecture, so they learn c and python.

With kids, the social part is very important, and making real things that move and react on the real world too. I suspect is of great help for adults too.

It is probably too dull to learn assembler today, on your own (alone) on a powerful computer. With a microcontroller you have a machine that is so constrained in resources that you really need to use c or assembly.

HN has very good resources about assembly, you can search them on google "hacker news assembly" or "hacker news reverse engineer", use zotero to aggregate the links.

The best thing for RE learning though is to use Visual Studio to write a few programs. From the debugger view you can use the assembly, and see what your program ends up in.

You also want to think about it as the programmer. You have a MASSIVE program. You want to see where it creates files. You know that on windows, it HAS to go through CreateFile, or at least NTcreatefile function or system call. So you can watch for these, or look where they are called in Ghidra. Now you can mark all the functions in the chain using xrefs (What references this) and then get all the functions that use createfile out of the way!

And lastly, as a programmer, you know the apis. So think of what cases someone would use printf for example. There's not many. You know by the use of printf, there's some sort of logging at that location. If they use openfile. You have a good idea that all the code surrounding that call is going to be about the file being opened.

TL;DR. Start from api calls, and work backwards. Use your knowledge as a dev for what these api calls are used for. And walk that call chain and mark. Eventually every function is mapped.

https://www.youtube.com/watch?v=RDZnlcnmPUA&list=PLhixgUqwRT...

pretty easy and fun, there is a difficulty wall after a few stages though. but once you get there, you might be able to get through it with some general deduction skills.

The speed runs for that game are mind melting, if you're into watching those.

I loved this game. It had an IRC server included so you could chat while in game, a forumboard, and a pretty diverse community. The gameplay was simple to learn but difficult to master, with a lot of fun for everyones.

Sadly, it was open-source but not so much. The sole developer never opened up the source of the server, and even the client's were not keep up to date, so it was impossible to play elsewhere than the official server.

The sole developer had a little revenue stream by selling premium account (which enabled the possibility to use custom skins and access to a private server) and never accepted to let the community fix bugs or host other servers. There was quiet a bit of friction and drama between him and some members of the community, and in the end he prefered letting the game die than giving it to the community.

[1] http://web.archive.org/web/20111028123349/http://www.mtp-tar... [2] http://web.archive.org/web/20110310131659/https://www.mtp-ta... [3] https://fr.m.wikipedia.org/wiki/Mtp_Target

It looks to be incredibly close to those original games.

On the other hand, hand-authored assembly is easier to read directly, because, of course, it was written and read in that form originally anyway!

This Github bug summarises the problem I was having with it: https://github.com/NationalSecurityAgency/ghidra/issues/201

https://www.youtube.com/playlist?list=PLn5sTGew1WGD2Tnspn9vh...