Jerry Lawson And The Fairchild Channel F; Father Of The Video Game Cartridge

July 14, 2020 by Jenny List 14 Comments

The video game console is now a home entertainment hub that pulls in all forms of entertainment via an internet connection, but probably for most readers it was first experienced as an offline device that hooked up to the TV and for which new game software had to be bought as cartridges or for later models, discs. Stepping back through the history of gaming is an unbroken line to the 1970s, but which manufacturer had the first machine whose games could be purchased separately from the console? The answer is not that which first comes to mind, and the story behind its creation doesn’t contain the names you are familiar with today.

The Fairchild Channel F never managed to beat its rival, the Atari 2600, in the hearts of American youngsters so its creator Jerry Lawson isn’t a well-known figure mentioned in the same breath as Atari’s Nolan Bushnell or Apple’s two Steves, but without this now-forgotten console the history of gaming would have been considerably different.

Continue reading “Jerry Lawson And The Fairchild Channel F; Father Of The Video Game Cartridge” →

Tales From The Sysadmin: Impending Hard Drive Doom

July 14, 2020 by Jonathan Bennett 70 Comments

It should have been another fine day, but not all was well in paradise. Few things bring a creeping feeling of doom like a computer that hardlocks and then refuses to boot. The clicking sound coming from the tower probably isn’t a good sign either. Those backups are up to date, right? Right?

There are some legends and old stories about hard drive repair. One of my favorites is the official solution to stiction for old drives: Smack it with a mallet. Another trick I’ve heard repeatedly is to freeze a hard drive before trying to read data off of it. This could actually be useful in a couple instances. The temperature change can help with stiction, and freezing the drive could potentially help an overheating drive last a bit longer. The downside is the potential for condensation inside the drive. Don’t turn to one of these questionable fixes unless you’ve exhausted the safer options.

For the purpose of this article, we’ll assume the problem is the hard drive, and not another component like a power supply or SATA cable causing problems. A truly dead drive is a topic for another time, but if the drive is alive enough to show up as a block device when plugged in, then there’s hope for recovering the data. One of the USB to SATA cables available on your favorite online store is a great way to recover data. Another option is booting off a Linux DVD or flash drive, and accessing the drive in place. If you’re lucky, you can just copy your files and call it a day. If the file transfer fails because of the dying drive, or you need a full disk image, it’s time to pull out some tools and get to work. Continue reading “Tales From The Sysadmin: Impending Hard Drive Doom” →

Surgery On The Arduino IDE Makes Bigger Serial Buffers

July 13, 2020 by Al Williams 20 Comments

It is pretty well-known that I’m not a big fan of the Arduino infrastructure. Granted, these days you have more options with the pro IDE and Platform IO, for example. But the original IDE always gives me heartburn. I realized just how much heartburn the other day when I wanted to something very simple: increase the receive buffer on an ATmega32 serial port. The solution I arrived at might help you do some other things, so even if you don’t need that exact feature, you still might find it useful to see what I did.

Following this experience I am genuinely torn. On the one hand, I despise the lackluster editor for hiding too much detail from me and providing little in the way of useful tools. On the other hand, I was impressed with how extensible it was if you can dig out the details of how it works internally.

First, you might wonder why I use the IDE. The short answer is I don’t. But when you produce things for other people to use, you almost can’t ignore it. No matter how you craft your personal environment, the minute your code hits the Internet, someone will try to use it in the IDE. A while back I’d written about the $4 Z80 computer by [Just4Fun]. I rarely have time to build things I write about, but I really wanted to try this little computer. The parts sat partially assembled for a while and then a PCB came out for it. I got the PCB and — you guessed it — it sat some more, partially assembled. But I finally found time to finish it and had CP/M booted up.

The only problem was there were not many good options for transferring data back and forth to the PC. It looked like the best bet was to do Intel hex files and transfer them copy and paste across the terminal. I wanted better, and that sent me down a Saturday morning rabbit hole. What I ended up with is a way to make your own menus in the Arduino IDE to set compiler options based on the target hardware for the project. It’s a trick worth knowing as it will come in handy beyond this single problem.

Continue reading “Surgery On The Arduino IDE Makes Bigger Serial Buffers” →

Changing System Architectures And The Complexities Of Apple’s Butterfly Approach To ISAs

July 13, 2020 by Maya Posch 64 Comments

Apple computers will be moving away from Intel chips to its own ARM-based design. An interesting thing about Apple as a company is that it has never felt the need to tie itself to a particular system architecture or ISA. Whereas a company like Microsoft mostly tied its fortunes to Intel’s x86 architecture, and IBM, Sun, HP and other giants preferred vertical integration, Apple is currently moving towards its fifth system architecture for its computers since the company was formed.

What makes this latest change possibly unique, however, is that instead of Apple relying on an external supplier for CPUs and peripheral ICs, they are now targeting a vertical integration approach. Although the ARM ISA is licensed to Apple by Arm Holdings, the ‘Apple Silicon’ design that is used in Apple’s ARM processors is their own, produced by Apple’s own engineers and produced by foundries at the behest of Apple.

In this article I would like to take a look back at Apple’s architectural decisions over the decades and how they made Apple’s move towards vertical integration practically a certainty.

Continue reading “Changing System Architectures And The Complexities Of Apple’s Butterfly Approach To ISAs” →

How Early Radio Receivers Worked

July 10, 2020 by Al Williams 43 Comments

If you’ve ever built a crystal radio, there’s something magical about being able to pull voices and music from far away out of thin air. If you haven’t built one, maybe you should while there’s still something on the AM band. Of course, nowadays the equivalent might be an SDR. But barring a computer solution, there are not many ways to convert radio waves into intelligence. From a pocket radio to advanced RADAR to a satellite in orbit, receiving a radio wave is accomplished in pretty much the same way.

There are, however, many ways to modulate and demodulate that radio wave. Of course, an AM radio works differently than an FM radio. A satellite data downlink works differently, too. But the process of capturing the radio wave from the air and getting them into a form ready for further processing hasn’t changed much over the years.

In this article, I’ll talk about the most common radio receiver architectures you may have seen in years past, and next week I’ll talk about modern architectures. Either way, understanding receiver architectures will help you design new radios or troubleshoot them.

Continue reading “How Early Radio Receivers Worked” →

This Week In Security: F5, Novel Ransomware, Freta, And Database Woes

July 10, 2020 by Jonathan Bennett 5 Comments

The big story of the last week is a problem in F5’s BIG-IP devices. A rather trivial path traversal vulnerability allows an unauthenticated user to call endpoints that are intended to be restricted to authenticated. That attack can apparently be as simple as:

'https://[F5 Host]/tmui/login.jsp/..;/tmui/locallb/workspace/tmshCmd.jsp?command=list+auth+user+admin'

A full exploit has been added to the metasploit framework. The timeline on this bug is frighteningly quick, as it’s apparently being actively exploited in the wild. F5 devices are used all over the world, and this vulnerability requires no special configuration, just access to the opened management port. Thankfully F5 devices don’t expose the vulnerable interface to the internet by default, but there are still plenty of ways this can be a problem.

Freta

Microsoft has made a new tool publicly available, Freta. This tool searches for rootkits in uploaded memory snapshots from a Linux VM. The name, appropriately, is taken from the street where Marie Curie was born.

The project’s namesake, Warsaw’s Freta Street, was the birthplace of Marie Curie, a pioneer of battlefield imaging.

The impetus behind the project is the realization that once a malicious actor has compromised a machine, it’s possible to compromise any security software running on that machine. If, instead, one could perform a security x-ray of sorts, then a more reliable conclusion could be reached. Freta takes advantage of the VM model, and the snapshot capability built into modern hypervisors.

Continue reading “This Week In Security: F5, Novel Ransomware, Freta, And Database Woes” →

3D Printering: Selling Prints, And Solving The Pickup Problem

July 8, 2020 by Donald Papp 23 Comments

After getting a 3D printer up and running, it’s not uncommon for an enterprising hacker to dabble in 3D printing to make a little money on the side. Offering local pickup of orders is a common startup choice since it’s simple and avoids shipping entirely. It’s virtually tailor-made to make a great bootstrapping experiment, but anyone who tries it sooner or later bumps up against a critical but simple-seeming problem: how to get finished prints into a customer’s hands in a sustainable way that is not a hassle for either the provider, or the customer?

It’s very easy to accept a 3D file and get paid online, but the part about actually getting the print into the customer’s hands does not have a one-size-fits-all solution. This is what I call The Pickup Problem, and left unsolved, it can become unsustainable. Let’s look at why local pickup doesn’t always measure up, then examine possible solutions.

The Problems with Local Pickup

Local pickup for delivery of print jobs is great because there is no mucking about with shipping supplies or carriers. Also, many 3D prints when starting out will be relatively low-value jobs that no one is interested in stacking shipping fees onto, anyway.

“Your order is complete. Come to this address to pick up your order.” It is straightforward and hits all the bases, so what’s the problem?

Continue reading “3D Printering: Selling Prints, And Solving The Pickup Problem” →