From what I’ve seen, it started with some discussion on the mailing list where people speculated on the dangers of using RdRand to feed the Linux entropy pool (and speculation about it being used exclusively for things like ASLR), and ended up discussing more subtle microcode level attacks.
Beyond people not understanding how XOR works, and the fact that bits from RdRand are just getting mixed into the entropy pool as yet another source (and, if you’re using /dev/urandom as you should be, you only need a small amount of re-seeding to maintain your cryptographic security), it seems that the NSA backdooring the Linux PRNG would just be attacking crypto for the sake of attacking crypto. Less polite company have words for that.
If you have the ability to backdoor a CPU instruction, why do it in what might be the most roundabout way possible? Why not just extract keys from memory? And if you’re going to attack crypto, going through biasing some bits of the entropy pool seems much, much harder than is necessary. I think this is well summed up in this tweet:
People do not trust RDRAND but will totally use MOV and CMP
Last year, I worked on reverse engineering Android implementations of IMS, the next generation 4G IP based telephony suite of protocols, with Jethro Beekman at Berkeley.
In addition to our technical report on MITM vulnerabilities against T-Mobile’s Wi-Fi Calling feature (due to unvalidated SSL certificates), we continued to look at IMS systems in general, and how T-Mobile and Android implemented them. We found that, amongst other things, Digest AKAv1, the authentication and key exchange protocol used in IMS, doesn’t correctly require use of the generated secret keys, allowing a variety of attacks. Furthermore, generally accessible APIs in both core Android and in T-Mobile’s customized ROMs allow apps with just the READ_PHONE_STATE permission to access the IMS authentication routines in the SIM card, making it possible for low-privilege malware on a phone to let a remote attacker authenticate as that phone.
A simple example of why you might care: An attacker can pretend to be you (your number, your subscriber ID, your phone) and call premium 1-900 numbers or send text premium text messages, costing you real money.
“What Leggett described is exactly how I felt about the widget when I first saw it. I immediately figured out how to use it, but my gut reaction was «most people are not going to get how this works.» It seems I was wrong. This is one of the reasons why I don’t put too much trust into opinion-based usability reviews: There’s a lot of guesswork involved, and guessing how humans behave is an endeavor fraught with peril.”
“Would you like a pocket-size device that reminded you of each appointment and daily event? I would. I am waiting for the day when portable computers become small enough that I can keep one with me at all times. I will definitely put all my reminding burdens upon it. It has to be small. It has to be convenient to use. And it has to be relatively powerful, at least by today’s standards. It has to have a full, standard typewriter keyboard and a reasonably large display. It needs good graphics, because that makes a tremendous difference in usability, and a lot of memory—a huge amount, actually. And it should be easy to hook up to the telephone; I need to connect it to my home and laboratory computers. Of course, it should be relatively inexpensive.
What I ask for is not unreasonable. The technology I need is available today. It’s just that the full package has never been put together, partly because the cost in today’s world would be prohibitive. But it will exist in imperfect form in five years, possibly in perfect form in ten.”
I’ve been looking at ant-algorithms for pathfinding lately. They’re interesting because they are very simple multi-agent search, but some of the benefits that I originally thought it might have (dealing with imperfect last-known-information, dynamic environment, etc.) seem to be negated by the fact that it isn’t terribly great when you don’t have a ton of agents.
I’ll have a more concrete idea of how feasible ant-algorithms are once my implementations are done and I can run simulations. Never hurts to separate the hype from the substance, though.
Update (2011-12-31): We ended up implementing some various pathfinding mechanisms for many-agent movement in a semi-unknown environment. Turns out that ant colony optimization is actually not so great… at least in the classic “pathfinding” sense. Convergence is slow, the actual amount of shared information is weak, etc. The test program is at least pretty, thanks to wxPython. The settings are all at the top of the Python script, and a little arcane, but you can run it with
Another much-linked chart, this one deemed beautiful enough to grace the cover of a book. An appealing image, certainly. I’m not sure how it relates to flowers, but ok.
Now let’s try using the actual chart. Find what the cultural significance of red is in the Muslim culture. No? Ok, it doesn’t work that way – let’s instead find what color symbolizes peace in Eastern European cultures. Find it yet? Need a compass, perhaps, to trace from the in-chart legend to the desired slice?
Please stop the madness. The purpose of a chart is to illuminate; if it’s harder to read than a raw-data table or a paragraph of text saying the same, then don’t use a chart. And if your goal is simply to create a pretty graphic, then don’t try beefing up your science cred with this “information” stuff.
Arranging data in an aesthetically pleasing way with no regard for how the arrangement affects the viewer’s understanding is simply dishonest. It’s only popular because no one really cares to use these charts for any real purpose. (Color significance in cultures – I mean, does it get any fluffier?) Imagine someone with no database experience “visualizing” a SQL query in this way and trying to sell a database administrator on it.
Information can be beautiful. Information can also be ugly. It can be helpful or misleading, educational or confusing. Information doesn’t care; the designer has to.
The chart is question is definitely good looking. I’ve made good looking figures (not with as much art to them).
The point I get out of this: the chart isn’t designed.
It’s simply made to look good.
But can this chart be designed? The post on Neven Mrgan’s Tumblr argues that the data doesn’t work in a chart.
Too often school assignments I’ve had require figures/charts, and looking back, these really often were unnecessary, redundant, etc. Almost all of them fell under the “harder to read than a raw-data table or a paragraph of text saying the same“. The issue was that there was no freedom in the assignment to makedesign choices. And there certainly wasn’t design thought going into the construction of most of the assignments, either.
When GCC identified bad C++ code, it tried to start NetHack, Rogue, or Towers of Hanoi. Failing all three, GCC printed out a cryptic error message. Wow.
This just goes to show you that when the official C++ specification talks about undefined behavior, they mean business:
[Undefined behavior is] behavior, such as might arise upon use of an erroneous program construct or erroneous data, for which the Standard imposes no requirements
No requirements indeed.
I found this immensely entertaining. “Undefined Behavior” indeed. Also, not surprising that those who have to use C++ could stand have some humor injected into their otherwise painful lives (I kid… kind of).
My time spent playing around with cSound has both delighted me, and made me kind of sad. There’s so much more I could learn, and a lot of that is fundamental to really understanding signal processing, digital instrumentation, and computer music. But, I have learned a lot about actually using HRTFs, as one of the things I toyed with while building my little game sound_fall. While they didn’t work out for that project, I still wanted to dig around a little more, and share some of what I found (since real discussion of HRTFs is lacking).
If you’re interested in cSound, the online manual is very useful, if a bit dense. Looking through the examples included in the pages for the HRTF opcodes was more immediately enlightening, at least from getting immediate use. The relevant opcodes here are hrtfer, hrtfmove, hrtfmove2, and hrtfstat.
To get a feel for this, I’ve made a simple .csd file — the file that contains the instrument and score information for cSound. It plays a fractal phased sine wave that I whipped up in Audacity.
; non-realtime output
sr = 44100 ; standard sample rates
kr = 4410
ksmps = 10
nchnls = 2 ; final output is stereo
kaz line 0, p3, 180 ; move azimuth from front around right to back
kelev line 50, p3, -30 ; move elevation in arc from 50 to -30 deg
; (above you to below you)
ain soundin "fast_tone.wav" ; input sound
; set left and right channels to results of the hrtfmove2 opcode
; this has less clicking, especially when used for real-time synthesis
; this processes ain, with azimuth 0, the predefined elevation arc,
; and the two HRTF data files (that contain the impule responses)
; aleft,aright hrtfmove2 ain, 0, kelev, "hrtf-44100-left.dat","hrtf-44100-right.dat"
; This does the same, but with the predefined azimuth arc and an
; elevation of zero.
aleft,aright hrtfmove2 ain, kaz, 0, "hrtf-44100-left.dat","hrtf-44100-right.dat"
outs aleft, aright
i10 0 20 ; play for 20 seconds
This will output a file named hrtf.wav. Try listening to it with decent headphones:
You may notice that you need to pay a bit of attention to where the sound is coming from to really get the effect. The sound I used has enough edge and variation that the motion in space is more noticeable than a more solid tone might be under the same transformations. You can pass the hrtfmove2 opcode any mono input, so experimentation is easy.
The actual math for using the HRTF datafiles involves FFTs and discrete-time convolutions — since I skipped out of being an electrical engineer, I’ve avoided needing to learn about things like that, but I can’t help being curious. If I was a little more competent, I might try to build an extension for OpenAL (which is woefully neglected these days, from the looks of it) to add this functionality. That would make it a little easier to integrate into applications that aren’t music synthesis oriented. Oh well.
Moving on from here, I’d really like to find a good system for real-time synthesis. cSound seems like a possibility, but it isn’t really designed for it from the ground up — the HRTF example here is outputted to a wavefile to avoid buffer and clicking issues. We’ll see what I dig up.