This was written just a couple days ago, it's just in the formatting of files written 30 years ago. The writing and explanation style is definitely a lot more modern and detailed.
> The writing and explanation style is definitely a lot more modern and detailed.
Especially since many of the original crackers usually did not want to share all of the details, only just enough to aggrandize themselves without supporting others.
This is spot on, that's exactly how I remember the scene back then.
"Beneath Apple DOS" (and later ProDOS) were the cracker bibles back then. It's pretty much the only official documentation you could buy that described how the floppy drives work at the lowest levels. There was no internet and BBS were reserved for the most wealthy hackers. Basically, you were on your own to figure things out.
With the knowledge from this book, you could theoretically crack anything, but as the article shows, you also need to have total mastery of the 6502 and of the Apple ][ ROM layouts too.
We were not anywhere near as connected as we are today. So yes, there were a fair number of people able to do this kind of thing, but they were well distributed and not always motivated to do it.
In my little town, a few of us reached that level. Together. All we had was the usual books, and a massive amount of time. After cracking one or two, we moved on to doing other things. It was about getting some of those skills, then putting them to use. It's my perception that the hardcore types were, in fact, pretty rare because of this.
Remember: the C64 and the Apple II were sold in very large numbers as was the BBC Micro and the Acorn Atom. 6502 Assembly language was the only way to get those computers to do much of anything at appreciable speed. Almost all those programmers went through the same path: first the Basic that came with the system, then frustration and enlightenment as they discovered the layer underneath the Basic interpreter that gave them both better control of the system and much higher execution speeds. The number of people capable of programming the 6502 at a very high level must have numbered in the 10's of thousands. And quite a large number of those were just as good at piecing things together again from binary data as they were producing that stuff in the first place. The reason for that is that the correspondence between assembly and machine code is 1:1, in other words the output of a dis-assembler looks very closely like the input to an assembler for the same processor.
In my little circle of programming friends at the time all of us would have been able to do this (and more), and were definitely weren't gods by programming standards, merely average and with too much time on our hands. Persistence is a good substitute for talent if you have a lot of time.
In my small town, there were maybe 5 people, and one or two of those were at this level. I was somewhere in there, but not at the peak for sure.
Many did explore assembly language, but there is still a difference between, say writing an assembly language program, and digging deep into the guts of the disk system.
You are right about binary data. But, I must say access to information wasn't the same either. Many of us worked from what we could find in the magazines found in the grocery store. I used to take really long bus trips to the university library to photocopy useful bits.
The books we all know well, "Inside the Apple..." and "Inside DOS" were out there, but not everywhere. Our group didn't have them for quite some time.
Access to better tools was an issue on many machines too. The Apple and BBC Micro came with some assembly language support. Other machines, C64, Atari, didn't. And stuff wasn't cheap. People who came from those two machines were a little different than those coming from the C64 or Atari, for example.
One of the first things I learned to do was write a disassembler in BASIC, then an assembler. My first home machine was an Atari. Awesome capabilities, but not anywhere near the learning machine the Apple 2 was. I missed the monitor and mini-assembler big. A friend had a 6809 computer, and we both were mentored by someone who was fairly advanced, showing us things. Took a while to get ML tools. So a ton of stuff got done from the BASIC.
This is small town perspective. I think we aren't in disagreement as much as differences in perspective are in play. If you didn't live somewhere with a notable population, information often came from the school of hard knocks.
One other thing... those assembly skills varied. I still struggle with larger programs in assembly, though I'm good at hacking something, or doing little helper routines. The people showing real mastery often had tools, or were able to put bigger projects together. They ended up doing those bigger projects.
In any case, awesome times.
One thing I do find notable is those skills did have an impact. I'm on a project right now that requires some bootstrapping, and or low level development. At one point, a system monitor was discussed. A lot of people today are just used to pretty awesome tools. You use your PC to target whatever it is and go.
Not a thing wrong with that.
But, say you want to do it on chip, or piece together a big project, test, or do other things. A monitor can be used to run things from RAM, move stuff around, and of course, if you've got an assembler, you assemble to RAM, stash it somewhere, ideally storage, get all the pieces done, link 'em, or page / bank 'em, jump tables, etc... and eventually write it all out as a larger project.
Those kinds of things are foreign to many today. And that's fine because of where computing is. But you can tell who was there early and who was not, just by how they may attempt things, or the tools they use, or create.
Precisely. A lot of the stuff he's cracked has never had a usable rip done even 30 years after people started moving on to bigger and better, and he's still finding new stuff that has never been dumped before and needs copy protection removed.
Right after he put out the crack, I was working on a (hard-drive friendly) port to ProDOS based on it.
see https://archive.org/details/apple_ii_library_4am
A collection of historical software for Apple II computers from the 1980s and early 1990s. Each item was originally copy protected (i.e. the original floppy disk could not be copied to another floppy disk), but the copy protection has been removed and documented. Most items also include a "work disk" comprising the intermediate files created during the deprotection.
To send feedback, ask questions, or get notified of new releases, follow @a2_4am on Twitter.
Do you know how they do it? I mean, in order to crack these games, they need to have the original physical floppy, don't they? Or do they have a digital version of the protected floppy with all its weird sectoring and data on it?.
Well you'd have to start with an original floppy or cassette, wouldn't you? Some still enjoy cracking on the real hardware, but most make a low level floppy or tape image and work from that.
I've only cracked relatively simple stuff, but working in an emulator is a LOT easier than working on real hardware. In an emulator you can freeze the system and inspect both the computer and the disk drive, set breakpoints, modify memory, and so on, and it's totally undetectable to the protection code.
Thanks for pointing out! I was also assuming it was an article from 1982 at first. I was already wondering about terms like "bare metal" and "automated tools" in the first paragraph. Not sure if they'd have been used in '82.
Would be interesting to analyze further possible differences in the language if the article would have been written in 1982.
The term "bare metal" goes way back and wouldn't have been out of place in 1982 (IBM was Big Iron, after all). I don't think "automated tools" was in use, certainly not in everyday use, although I think we would have understood it. Maybe. That's a pretty fascinating question, really.
It was called machine language, or assembly language. References to the hardware were common in pretty much all language contexts. Since very little didn't involve the hardware directly, "bare metal" didn't even have the context yet.
Perhaps it would in some academic circles, but not for the general population of microcomputer users.
Well, so was I, of course, but since I failed to take careful dated terminological field notes, I can't really say much more than feeling that I would have understood it at the time. But frankly I don't know. It just doesn't seem as freighted with modernity as the concept of "automation" in this context.
Seems kind of like maybe something Gibson would have used, but yeah, that's probably later than 1982. Now my interest is really starting to get piqued.
