« Henry Roberts mentioned in the history of software copy protection | Home | Who cares about the Software Piracy problem anyway? »
The history of Application Software Anti-Piracy
By Jon Gillespie-Brown | February 5, 2007
The problem with copy protection as a concept is that it creates as many questions as it solves.
There are many different types of copy protection working at many different levels. Companies wanting to protect their source code and binaries have a confusing array of options. Part of the reason for this involves the way that the copy protection industry developed. Various techniques evolved over time, often in parallel with each other:
Manual protection—literally!
Copy protection evolved to help software vendors combat an enemy—the software pirate. Because the war against piracy is fought on a virtual battleground, the rules of engagement change frequently as the weapons evolve. In the early days, for example, the weapons used against software pirates were often analogue.
Software publishers would ask questions about the text of the manual accompanying the program, meaning that unless a user had the manual, the software would be impossible to use. Pirates soon got around that problem by photocopying the manuals, until photocopier- proof manuals came along, at which point they had to either become more devious or less lazy, re-keying the manual by hand.
Encoding code: making software secret
Software vendors became more devious, encrypting their code to make it impossible for crackers to disassemble the binary files. This stopped crackers for a short time, but not for very long—they soon realized that although the source files were encrypted on disk, they could not be encrypted in memory because of the performance overhead involved in decrypting code during execution. Software vendors were using loader programs to take the encrypted disk-based file and load it into memory, decrypting it in the process. Once the program was in memory, it was unprotected and therefore vulnerable to the conventional analysis that enabled crackers to strip the copy protection from the source code.
Debuggers proved to be an invaluable tool for the pirates and led to the continuing rise in cracker clubs and the emergence of the warez community, which distributed cracked programs online. While many pirates sold bootleg software for commercial benefit, others cracked and distributed the code as a hobby, enjoying the status associated with being the first to break a particular program’s copy protection.
Riding the loader
The discovery that pirates continued to thwart copy protection mechanisms led to yet another stage of development, as software vendors began introducing loaders that sucked parts of the encrypted program into memory separately, on an as-needed basis. This made it difficult for crackers to analyze the source code using a debugger, because it was never all in memory at the same time. It was difficult, but not impossible. Innovative crackers learned to simply run the program repeatedly through all of its configurations, examining the decrypted segments
as they appeared until the whole binary had passed through the RAM, in a technique known as ‘riding the loader’.
The dongle
Using accompanying text to verify the authenticity of the software was only ever going to be a short term solution. Instead, software vendors took the battle to a more sophisticated level. One popular method in the early days was hardware protection, using the dongle.
This was a plug-in device that would connect to one of the machine’s interface ports. The software would check for the presence of the device before it would run. While effective, dongles were expensive to produce, and so cheaper systems had to be devised.
Today is very different, with a number of options to choose from including the Dongle, Wrapper software and Software Developer’s Kits.
Popularity: 30% [?]
Topics: Software Licensing |
No related posts
Learn more about software copy protection and licensing »
