Dead Drop Concept Inspired By [Ender Wiggin] Family

August 3, 2013 by 9 Comments

encrypted-dead-drop-concept

[Tyler Spilker’s] DDD project is a Digital Dead Drop system based on Python and a Raspberry Pi as a server. It’s pretty rough around the edges at this point — which he freely admits. But we like the concept and figure it might spark an interesting conversation in the comments section.

Now by far our favorite dead drop concept is this USB drive lewdly sticking out of a brick wall. But you actually need to be on-site where this drive is mortared into the wall in order to access it. [Tyler] instead developed a webpage that gives him a text box to enter his messages. These are encrypted using key pairs and pushed to his remote RPi server. This way he can write down his thoughts knowing they’re stored securely and never in danger of being accessed from a lost or stolen cellphone.

If free thought isn’t what you’re trying to transfer from one place to another you probably want something like a Pirate Box.

Protoboard Line Following Robot

August 3, 2013 by 11 Comments

dspic-line-follower

We love a good line-following robot project and this really hits the spot. It’s got sharp edges, gobs of solder bridging, and look at all those jumper wires! Despite its appearance it puts in a performance that won’t disappoint.

It uses a dsPIC33 to read from half a dozen analog sensors on the bottom of the board. We’re not all that familiar with the chip’s features, but [Exapod] says it’s got an auto-scan feature he uses to read the sensors. This allows him to sample with 12-bit resolution from all six of them at about 30 kHz. No wonder the thing is so responsive in the demo video embedded below. The track he’s using is just some white printer paper with a fat circuit of black electrical tape placed in a somewhat squiggly pattern.

This is also a fun challenge with toys. Here’s one that hacks a hexapod to follow the lines.

Continue reading “Protoboard Line Following Robot” →

Leapcast Emulates Chromecast In Your Chrome Browser

August 2, 2013 by 17 Comments

Our Chrome browser thinks it’s a Chromecast dongle. Here’s a screenshot of it playing a YouTube video. Note the tile banner and onscreen controls which are just like the ones you’d see on the actual hardware. Give it a try yourself by downloading the Leapcast Python package which [dz0ny] programmed.

After cloning the GitHub repo we had a few problems compiling the package. Turns out we needed to install python-dev and that took care of it. Starting the daemon is a simple command, we specified our Chrome binary path as well as added a few flags

leapcast --name HAD --chrome /usr/bin/google-chrome --fullscreen

Once that was running the Android YouTube app automatically detected Leapcast as a Chromecast device. It gave us a tutorial overlay mentioning the new share icon on the interface. Pressing that icon during playback launched an Incognito window which played the video. [dz0ny] links to a device config JSON file in the README. If you check it out you’ll notice that Netflix is listed as “external” while the others are not. This is because the Chromecast protocol uses a binary for Netflix. The others do it with local websockets or a cloud proxy so they work just fine with this setup.

The Mill CPU Architecture

August 2, 2013 by 55 Comments

There are basically two ways to compute data. The first is with a DSP, a chip that performs very specialized functions on a limited set of data. These are very cheap, have amazing performance per watt, but can’t do general computation at all. If you’d like to build a general-purpose computer, you’ll have to go with a superscalar processor – an x86, PowerPC, or any one of the other really beefy CPU architectures out there. Superscalars are great for general purpose computing, but their performance per watt dollar is abysmal in comparison to a DSP.

A lot of people have looked into this problem and have come up with nothing. This may change, though, if [Ivan Godard] of Out-of-the-Box computing is able to produce The Mill – a ground-up rethink of current CPU architectures.

Unlike DSPs, superscalar processors you’d find in your desktop have an enormous amount of registers, and most of these are rename registers, or places where the CPU stores a value temporarily. Combine this with the fact that connecting hundreds of these temporary registers to places where they’ll eventually be used eats up about half the power budget in a CPU, and you’ll see why DSPs are so much more efficient than the x86 sitting in your laptop.

[Ivan]’s solution to this problem is replacing the registers in a CPU with something called a ‘belt’ – basically a weird combination of a stack and a shift register. The CPU can take data from any position on the belt, perform an operation, and places the result at the front of the belt. Any data that isn’t used simply falls off the belt; this isn’t a problem, as most data used in a CPU is used only once.

On paper, it’s a vastly more efficient means of general purpose computation. Unfortunately, [Ivan] doesn’t quite have all the patents in for The Mill, so his talks (two available below) are a little compartmentalized. Still, it’s one of the coolest advances in computer architecture in recent memory and something we’d love to see become a real product.

Continue reading “The Mill CPU Architecture” →

[Sprite_TM] OHM2013 Talk: Hacking Hard Drive Controller Chips

August 2, 2013 by 16 Comments

Even if he hadn’t done any firmware hacking on this hard drive [Sprite_TM’s] digital exploration of the controller is fascinating. He gave a talk at this year’s Observe, Hack, Make (OHM2013) — a non-commercial community run event in the Netherlands and we can’t wait for the video. But all the information on how he hacked into the three-core controller chip is included in his write up.

[Sprite_TM] mentions that you’re not going to find datasheets for the controllers on these drives. He got his foot in the door after finding a JTAG pinout mentioned on a forum post. The image above shows his JTAG hardware which he’s controlling with OpenOCD. This led him to discover that there are three cores inside the controller, each used for a different purpose. The difference between [Sprite_TM’s] work and that of mere mortals is that he has a knack for drawing surprisingly accurate conclusions from meager clues. To see what we mean check out the memory map for the second core which he posted on page 3 of his article.

Using JTAG he was able to inject a jump into the code (along with a filler word to keep the checksum valid) and run his own code. To begin the firmware hacking portion of the project he pulled the flash ROM off of the board and installed it on that little board sticking out on the left. This made it easy for him to backup and reflash the chip. Eventually this let him pull off the same proof of concept as a firmware-only hack (no JTAG necessary). He goes onto detail how an attacker who has root access could flash hacked firmware which compromises data without any indication to they system admin or user. But we also like his suggestion that you should try this out on your broken hard drives to see if you can reuse the controllers for embedded projects. That idea is a ton a fun!

When we were poking around the OHM2013 website (linked above) we noticed that the tickets are sold out; good for them! But if you were still able to buy them they take Bitcoin as one payment option. Are there any other conferences that allow Bitcoin for registration?

Building A Hard Drive Scratch Controller

August 2, 2013 by 12 Comments

hard-disk-scratch-controller

If you’re reading this blog then chances are you have a dead hard drive hanging out somewhere in your house. Here’s a weekend project that will put it back into use. [Andreas] took on the popular project which combines a hard drive and optical mouse to build a scratch controller.

The gist of the build is that you use an optical mouse sensor to track the movement of the platter. But [Andreas] made things harder on himself by not using the USB capability of the mouse and mapping it in software for his needs. Instead he plucked the sensor from the mouse, reading it using an Arduino. After much trial and error with the best way to coat the underside of the platter to play nicely with the sensor he managed to get it up and running. The controller issues commands using the MIDI protocol, forming a strong foundation for future upgrades which could lead to a full-blown DJ console hack.

Continue reading “Building A Hard Drive Scratch Controller” →