Facebook Open-Sources their Capture-the-Flag Hacking Challenges

If you want to learn how to defeat computer security, nothing beats hands-on experience. Of course, if you get your hands on someone’s system without their permission, you may end up having a very short training that ends with a jail term. And that’s where capture-the-flag (CTF) events come in.

A CTF is a system of increasingly-difficult challenges that can’t be too easy or too hard. A well-designed CTF teaches all of the participants stuff that they didn’t know, no matter how far they get and what skills they came in with. Designing a good CTF is difficult.

But since it’s also a competition, running one also involves a lot of horrible bookkeeping for the folks running it. Registering teams and providing login pages is the dirty work that you have to do in the background, that takes away time from building the systems which others are going to take apart.

Which is why it’s great that Facebook is opening up their CTF-hosting platform, along with a few starter challenges, for us all to play along. We love CTFs and related hacking challenges. If this spurs the creation of more, we’re all for it. You can find the whole setup on GitHub.

If you’re new to CTFs, here’s an awesome collection of CTF-related material on GitHub to get you started. And if your tastes run more toward hardware hacking, we’ve covered previous firmware CTFs, but frankly there’s a lot more material out there. We feel a feature post coming on…

Thanks [ag4ve] for the unintentional tip!

Windows 95 On An Apple Watch

What happens if the slick user interface and tight iOS integration of your Apple Watch leave you wanting more? A real operating system, from the days when men were men and computers were big grey boxes!

[Nick Lee] solved this unexpected problem with his Watch by getting a working copy of Windows 95 to run on it. On paper it shouldn’t be at all difficult, with a 520 MHz ARM, 512 MB of RAM, and 8GB of storage you might think that it would eclipse the quick 486s and low-end Pentiums we ran ’95 on back in the day with ease. But of course, the ability to run aged Redmond operating systems on a Watch was probably not at the top of the Apple dev team’s feature list, so [Nick] had to jump through quite a few hoops to achieve it.

As you might expect, the ’95 installation isn’t running directly on the Watch. In the absence of an x86 processor his complex dev process involved getting the Bochs x86 emulator to compile for the Watch, and then giving that a ’95 image to boot. The result is comically slow, with a 1-hour boot time and a little motor attached to the Watch to vibrate it and stop it going to sleep. It’s not in any way a useful exercise, after all who’d really want to use ’95 on a Watch? Internet Explorer 3 and The Microsoft Network, how handy! But it’s one of those “because you can” exercises, and we applaud [Nick] for making it happen. If you want to give it a try, his Bochs-forWatchOS code is on Github.

The video below the break shows the process of booting the ’95 Watch, opening the Start Menu, and running one of the card games. One can almost feel the lengthening shadows outside as it goes.

Continue reading “Windows 95 On An Apple Watch”

Bootstrapping an Amiga 2000 Graphics Card Because Vintage is Pricey

If you have a computer on your desk today, the chances are that it has an Intel architecture and is in some way a descendant of the IBM PC. It may have an Apple badge on the front, it may run Linux, or Windows, but in hardware terms the overwhelming probability is that it will be part of the Intel monoculture. A couple of decades ago though in the 16- and early 32-bit era you would have found a far greater diversity of architectures. Intel 3-, and 486s in PCs and clones, Macintosh, Commodore, and Atari platforms with the 68000 family, the WDC 65C816 in the Apple IIGS, and the Acorn Archimedes with an early ARM processor to name but a few.

In the tough environment of the 1990s most of these alternative platforms fell by the wayside. Apple survived to be revitalised under a returning Steve Jobs, Atari and Commodore withered under a bewildering succession of takeovers, and Acorn split up and lost its identity with its processor licensing subsidiary going on to power most of the mobile devices we take for granted today.

Surprisingly though some of the 16-bit platforms refused to die when their originators faded from view. In particular Commodore’s Amiga has lived on with new OS versions, new platforms, and community-supported hardware upgrades. News of just such a device came our way this morning, [Lukas Hartmann]’s MNT VA2000, a graphics card for the Amiga 2000 using a GPU implemented on an FPGA.

Continue reading “Bootstrapping an Amiga 2000 Graphics Card Because Vintage is Pricey”

Dump Your (Old) Computer’s ROM Using Audacity

If you’ve got an old calculator, Commodore 64, or any other device that used a tape recorder to store and retrieve data, you’ve probably also got a bunch of cassettes lying around, right? Well, you can get rid of them now (or sell them to nostalgic collectors for outrageous prices) because you can just as easily dump them to Audacity, decode them and archive them on a more sane medium.

In [Kai]’s case, the computer was a Sharp Pocket Computer system, and in his post there’s a lot of detail that’s specific to that particular system. If that’s applicable to you, go read up. In particular, you’ll be glad to find that the Pocket-Tools is a software suite that will encode and decode files between the Sharp binary formats and audio. Along the way, we found similar tools for Casio pocket computers too.

For a more general-purpose approach, like if you’re trying to dump and load data from a more standard computer that uses 1200/2400 Hz FSK encoding, this Python library may be useful, or you can implement the Goerzel algorithm yourself on your platform of choice. If you’ve got a particular binary format in mind, though, you’ll have to do the grunt work yourself.

Anyone out there still using these audio data encodings? We know that ham radio’s APRS system runs on two tones. What else? Why and when would you ever transfer data this way these days?

via the Adafruit blog!

Wooden Computer Case Adds a Touch of Modern

When [LouisVW] decided to build a new gaming rig, he wanted to try something different. So instead of buying a pre-built tower, he made one — out of wood!

Coming from someone who has no experience in 1GNAWU0woodworking (or computer building) we’re seriously impressed with what he’s made. He was originally inspired to build the case when he saw boxes made by stacking pieces of plywood together — he got one and decided to turn it into a case.

Using a jigsaw, chisel and Dremel he was able to cut out all of the fan holes and drive bays fairly easily, and thanks to overlapping plastic covers it wasn’t that hard to make everything look perfect.
Continue reading “Wooden Computer Case Adds a Touch of Modern”

Peering Inside the GPU Black Box

Researchers at Binghamton University have built their own graphics processor unit (GPU) that can be flashed into an FGPA. While “graphics” is in the name, this GPU design aims to provide a general-purpose computing peripheral, a GPGPU testbed. Of course, that doesn’t mean that you can’t play Quake (slowly) on it.

The Binghamton crew’s design is not only open, but easily modifiable. It’s a GPGPU where you not only know what’s going on inside the silicon, but also have open-source drivers and interfaces. As Prof. [Timothy Miller] says,

 It was bad for the open-source community that GPU manufacturers had all decided to keep their chip specifications secret. That prevented open source developers from writing software that could utilize that hardware. With contributions from the ‘open hardware’ community, we can incorporate more creative ideas and produce an increasingly better tool.

That’s where you come in. [Jeff Bush], a member of the team, has a great blog with a detailed walk-through of a known GPU design. All of the Verilog and C++ code is up on [Jeff]’s GitHub, including documentation.

If you’re interested in the deep magic that goes on inside GPUs, here’s a great way to peek inside the black box.

Crawl, Walk, Run: A Starter CPU

Last time I talked about getting started with CPU design by looking at older designs before trying to tackle a more modern architecture. In particular, I recommended Caxton Foster’s Blue, even though (or maybe because) it was in schematic form. Even though the schematics are easy to understand, Blue does use a few dated constructs and you probably ought to build your take on the design using your choice of VHDL or Verilog.

In my case, my choice was Verilog. You can find my implementation of Blue on Opencores.org. I made quite a few changes to Foster’s original design. For example, armed with semiconductor memory, I managed to get all instructions to operate in one major cycle (which is, of course, 8 minor cycles). I also modernized the clock generation and added some resources and instructions.

Continue reading “Crawl, Walk, Run: A Starter CPU”