When I worked as a programmer in a company that had a share of products, one of them was this behemoth C++ program with a half a million line codebase. Even when I joined the company, the product was considered legacy, but we were still pushing updates to it.

The problem was that the software could only be compiled with MSVC 2010 and the whole build-chain itself was held together by duct tape and ritual sacrifices to Cthulhu. Getting the toolchain working could take several full workdays, and even then, required searching mummified links on microsoft.com for any hints of a download to the old MSVC installers. And this was all before you got the Visual Studio installer cooperating with Windows 10 and your existing, more recent Visual Studio installations.

Years passed, and eventually the product went out of sale. However, we still had existing customers who used this software, so we couldn't tear down the whole complicated mushroom infrastructure that had spread and grown around the product. In particular, the licensing system was made in-house with its own share of problems. There were a few bugs on modern processors, causing crashes upon using some deprecated CPU features. When the computer's unique ID would be sent to the licensing server, it might be misgenerated. Sometimes the ID would change if a new display was plugged in or if it was Wednesday. This would cause the server to think the license did not apply to this specific computer and proceeded to deactivate the software.

In the meetings that followed the decision was made that one more hotfix would be made: we would make the software free for those who already had copies and we would just disable the licensing system entirely. This was also brought by a need to plug off an old, vulnerability-infested server that ran on an old release of Ubuntu, something the server admins somehow kept afloat but which couldn't be deleted before the software could operate on its own.

This meant getting MSVC 2010 (and the dependencies) running on systems that would erupt in laughter upon seeing the version number. No one could build the software anymore, and those who once knew the insides of the build chain had long ago chosen to forget. This was where I came in.

I spent several days persuading the MSVC installer to spew out its files on my disk while also specializing in software archaeology as I dug through the build system. Regardless of my best efforts, ultimately I had to give the verdict: this just wasn't a good use of my expensive time. However, as a joke, I had an alternative plan in mind to ensure our customers wouldn't lose access to software they already paid money for: We would write a crack for our own software.

I don't think the others took it as a joke.

To my surprise I was given the green light to pursue this task. So, with some confusion, I downloaded the latest version of Ghidra and got cracking. We had releases of the software for Windows and Mac, and I had to do the same crack on both operating systems for four different binaries (there was a time software was released as 32-bit and 64-bit versions). To make my task easier, I at least had access to the source code, which essentially acted as my Rosetta Stone.

One by one I went through instructions in the executable files, always running the program and observing what manner of a crash or illegal instruction I would get after my changes. Yet, some two days later, I had managed to modify the decade old executable files, in-place, and disabled the licensing system. Every time the program started, it merely skipped the few critical points about the file signatures and server communications and would set the license flags to maximum.

In all my years as a software developer, before or after, have I never been asked to write a crack for our own software.