Parallax Completes Open Hardware Vision With Open Source CPU
First time accepted submitter PotatoHead (12771) writes "This is a big win for Open Hardware Proponents! The Parallax Propeller Microcontroller VERILOG code was released today, and it's complete! Everything you need to run Open Code on an Open CPU design. This matters because you can now build a device that is open hardware, open code all the way down to the CPU level! Either use a product CPU, and have access to its source code to understand what and how it does things, or load that CPU onto a suitable FPGA and modify it or combine it with your design."
I run a company that releases all its hardware designs and am a huge proponent of OSHW. This gesture has limited utility simply because the people who use MCUs in designs aren't typically interested in delving into the minutiae of how the processor that runs the system is built. They're more interested in open source circuits which have real-world applications -- a low pass filter for smoothing PWM signals, a nice clean USB power supply, and so on.
Sort of like OpenRISC? Except, later and worse?
Is there an open-source FPGA design/implementation that you can run this on? Otherwise it's not really open-hardware all the way down, is it..
Here's an open FPGA design:
Put a buttload of OR gates in parallel.
Follow them with a buttload of AND gates
There just isn't that much design in a basic FPGA to open up, not that I can see.
I wonder how this CPU performs? Does it compare to anything I'd care about, or is it more akin to something I'd build a wifi router out of?
I have no problem with your religion until you decide it's reason to deprive others of the truth.
Aside from absolutists positions like Stallman's, why is it important to have OS hardware? Why AMD64, Intel x86, or ARM is not good enough?
As customization reaches lower and lower levels, it becomes increasingly difficult to meaningfully compromise it. Probably the only way to meaningfully compromise an FPGA is to autodetect an internet connectin, and stream out to it everything you receive, possibly only on receiving a particular activation signal. That would be reasonably easy to detect, and even THAT compromise wouldn't be easy, but FPGAs don't have any memory capacity, so they can't accumulate and wait to be polled.
I think we've pushed this "anyone can grow up to be president" thing too far.
Something simple like a killswitch would still be possible.
the Prop came out before the Arduino and still blows anything in the Arduino family out of the water, except for needing some external parts to do ADC. Can't wait for the Prop 2.
Liberty - Security - Laziness - Pick any two.
For a second there I thought parallax had executed a machine vision sensor system driven by their micro-controller. That would have been so much cooler than this all but empty gesture.
Common Sense isn't as Common as people think...
...and anyone who isn't intimately familiar with microprocessor design, along with every other step of code along the way will still have to trust someone along the chain.
As customization reaches lower and lower levels, it becomes increasingly difficult to meaningfully compromise it. Probably the only way to meaningfully compromise an FPGA is to autodetect an internet connectin, and stream out to it everything you receive, possibly only on receiving a particular activation signal.
The "FP" in "FPGA" stands for "Field Programmable"; it's possible to compromise in the field, in a rather meaningful way.
Its a real nice gesture on their part and kudos to them, but I dont see this being a huge deal in the long run. I really do not see people that need to use a propeller in their product ( are there any ? ) wanting to go to a more expensive and slower FPGA ( or even a custom ASIC )..
I could be wrong...
---- Booth was a patriot ----
Looking at the source code (dismissing blank and comment lines) it seems to be only about 800 lines of Verilog.
The site suggests that this can run on the DE0-Nano Cyclone FPGA Board for $90 or the Altera DE2-115 FPGA Development Board for $600. As someone who doesn't know anything about this type of computing... can anyone explain what the difference is between the two?
-1 Uncomfortable Truth
I've always liked the PP for its novel approach to a multi-core micro. Opening up the hardware design like this can really grow its application space. Just because you can't imagine a use for this doesn't mean there is no use for it. And these days, FPGAs are making great strides in their accessibility. Verilog is the language of choice for most because of its similiarities with C. VHDL is mostly relegated to defense, because it has its roots in Ada (the syntax is almost identical). If you're into functional languages, check out BlueSpec, which will auto-generate SystemVerilog. And writing HDL is no longer for just EEs (which is a misnomer, btw). Tools like HDL Coder let anyone create a digital circuit. And there is greater selection these days for low-cost hobby boards. Plus, softcore micros have a long history in digital designs. Think microBlaze, NIOS II, even ARMs. Not to mention the OpenRISC core that's really quite capable. Imagine a robot where all of the software and control circuits are built into one chip, complete with ADC/DAC and PWM, all custom, and entirely reconfigurable. And FPGAs are getting better about power consumption, although they're still a long way away from 5V, 100mA, and more like 5V, 500mA for the smaller ones, but still. The big thing holding back OSHW, IMO, is access to tools that actually let you run a circuit on a chip without having to give blood to the tool vendor. Otherwise, AFAIC, the sky's the limit with this!
Well, apparently the license to everything is GPLv3, which could cause problems for those wanting to combine it with peripherals of other projects into one FPGA.
Or even if you decide you really want to make lots of them and make an ASIC out of it - how do you apply the GPLv3 to that since you can't really "rebuild" the ASIC...
Also, the tools they have are open-source too, under GPLv3. But since they're the toolchain, I don't think they include the output exemption, which would mean that not only is the processor hardware GPLv3, the software that it runs is also GPLv3. (GCC and the like have an output exemption that states the output of the compiler is NOT GPL)
True, but it would take some sort of hardware port to access the programming in the device and be capable of performing that sort of extremely low-level programming to rewrite the chip. I agree with you that it isn't impossible, but to be able to not just detect to also explicitly exploit that vector from much higher level protocols would be very tricky.
This sort of remote reworking of a FPGA was done with the Spirit & Opportunity rovers that are currently on Mars, where NASA (specifically the Jet Propulsion Lab) uploaded some new firmware through the Deep Space Network to another planet. If you can do that on Mars, having a home desktop computer reload new firmware as some sort of malware is trivial by comparison.
It's not that trivial. You cannot change the hardware description on the fly, you need a cable to do that. Additionally, a private key is stored in the FPGA and the contents of the external Flash chip containing the hardware description has the data encrypted with the public key. Xilinx has a document with more info about tamper resistant designs.
In the absence of interrupts, the average latency for responding to an input is one half the sampling time
In hard realtime, nobody gives a crap about average latency. All that matters is the maximum latency. If your timing requirements are flexible, then it is not hard realtime.
Depends on 'compromise.' It's not always about getting data out.
Compromise could mean 'upon detecting this sequence of bytes, suspend your packet filtering for ten seconds so we can sneak our exploit through the firewall.' Or 'upon this sequence of bytes, switch the random number generator off and start using the pre-stored crypto key for new conversations so we can intercept them.'
You write this response as if Windows XP has no market share at all, and that somehow software written for XP won't run on any newer operating systems or computers.
We aren't talking about something written in floating-point BASIC running on ProDOS 1.0 Surprisingly, emulators to run even that software exist on modern computers, so even that can be used.
Something simple like a killswitch would still be possible.
but obvious which is not something you want in a secret backdoor.
---Saying gnome 3 is better than windows 8 not so much a compliment as it is damning with light praise.
"not really, until you can 3-d print it yourself and then verify with an xray will security be verified."
What if both your 3D printer and X-Ray data analysis software are compromised? See also: ... The moral is obvious. You can't trust code that you did not totally create yourself. (Especially code from companies that employ people like me.) No amount of source-level verification or scrutiny will protect you from using untrusted code. In demonstrating the possibility of this kind of attack, I picked on the C compiler. I could have picked on any program-handling program such as an assembler, a loader, or even hardware microcode. As the level of program gets lower, these bugs will be harder and harder to detect. A well installed microcode bug will be almost impossible to detect."
"Reflections on Trusting Trust" by Ken Thompson
http://cm.bell-labs.com/who/ke...
"The final step is represented in Figure 7. This simply adds a second Trojan horse to the one that already exists. The second pattern is aimed at the C compiler. The replacement code is a Stage I self-reproducing program that inserts both Trojan horses into the compiler. This requires a learning phase as in the Stage II example. First we compile the modified source with the normal C compiler to produce a bugged binary. We install this binary as the official C. We can now remove the bugs from the source of the compiler and the new binary will reinsert the bugs whenever it is compiled. Of course, the login command will remain bugged with no trace in source anywhere
Still, the more angles you look at something from, the more likely you might detect some discrepancy... Like excess power usage, processing delays, slightly different electromagnetic signatures, etc...
In any case, the less you want, perhaps the easier it is to secure. Look into creating or using Forth chips for simplicity... The less gates you need, and the less cycles they need, the easier it would be to make your own hardware from scratch, even from discrete components if it is simple enough.
http://www.colorforth.com/
http://www.greenarraychips.com...
For software more complex than Forth that is still fairly understandable from the ground up, see also the FONC project by Alan Kay as well as Squeak on bare metal.
http://www.viewpointsresearch....
https://www.google.com/search?...
A 21st century issue: the irony of technologies of abundance in the hands of those still thinking in terms of scarcity.
FPGAs don't have any memory capacity? They absolutely do -- SRAM, Flash, whatever you're looking for. Some models can even self-modify their own configurations. Imagine a virus that can not only affect your OS, but actually re-wire the CPU in your computer. There are plenty of ways to compromise an FPGA both in terms of stealing the bit configuration or in terms of hiding malicious "code" inside the unused portion of the FPGA's fabric. The manufacturer could easily do this in cahoots with the NSA, or a highly-skilled operative could do it for any other reason.
-Ted http://www.freemathhelp.com/
No-one with brains or a budget is going to use a 15-20,000 gate FGA to do a job that a 10,000 gate chip can do.
If you need lots of pins on an FPGA, you pretty much have to get one with lots of gates, even if you don't need them all.
Other requirements can also dictate the part you choose.
If you can do that on Mars, having a home desktop computer reload new firmware as some sort of malware is trivial by comparison.
Except... NASA specifically designed that functionality into the system.
I currently have a network router that has similar capabilities. If you can download some firmware and flash it into a device for an update, some malware can certainly do the same thing without your permission.
If on the other hand you need a serial cable of some sort that as a completely separate port for updating the firmware that is code-wise unaddressable from the CPU, it is much harder to do that kind of update. It doesn't stop a co-worker from pulling a prank or somebody with physical access to the computer introducing malware, but it definitely is much harder. Still, if you have physical access to a computer you can do all sorts of other mischief that is harder to do through pure software processes.
Most hardware is moving in the direction of internal software updates though, where the NASA thing isn't really all that remarkable and more of the rule rather than the exception.
And? If you connect an FPGA (which is a programmable piece of hardware) to the outside world using some sort of (non-standard) connection, how is the FPGA going to find 1) which pins to drive 2) using what protocol, before it can establish a link home or something similar?
Ezekiel 23:20
https://plus.google.com/101541...
http://tintuc.oho.vn/news/c180...