Mobile: +61 (0) 414 488 851
Email: swilson@lockstep.com.au

gotofail and a defence of purists

'The widely publicised and very serious "gotofail" bug in iOS7 took me back ...

Early in my career I spent seven years in a very special software development environment. I didn't know it at the time, but this experience set the scene for much of my understanding of information security two decades later. I was in a team with a rigorous software development lifecycle; we attained ISO 9001 certification way back in 1998. My company deployed 30 software engineers in product development, 10 of whom were dedicated to testing. Other programmers elsewhere independently wrote manufacture test systems. We spent a lot of time researching leading edge development methodologies, such as Cleanroom, and formal specification languages like Z.

We wrote our own real time multi-tasking operating system; we even wrote our own C compiler and device drivers! Literally every single bit of the executable code was under our control. "Anal" doesn't even begin to describe our corporate culture.

Why all the fuss? Because at Telectronics Pacing Systems, over 1986-1990, we wrote the code for the world's first software controlled implantable defibrillator, the Guardian 4210.

The team spent relatively little time actually coding; we were mostly occupied writing and reviewing documents. And then there were the code inspections. We walked through pseudo-code during spec reviews, and source code during unit validation. And before finally shipping the product, we inspected the entire 40,000 lines of source code. That exercise took five people two months.

For critical modules, like the kernel and error correction routines, we walked through the compiled assembly code. We took the time to simulate the step-by-step operation of the machine code using pen and paper, each team member role-playing parts of the microprocessor (Phil would pretend to be the accumulator, Lou the program counter, me the index register). By the end of it all, we had several people who knew the defib's software like the back of their hand.

And we had demonstrably the most reliable real time software ever written. After amassing several thousand implant-years, we measured a bug rate of less than one in 10,000 lines.

The implant software team had a deserved reputation as pedants. Over 25 person years, the average rate of production was one line of debugged C per team member per day. We were painstaking, perfectionist, purist. And argumentative! Some of our debates were excruciating to behold. We fought over definitions of “verification” and “validation”; we disputed algorithms and test tools, languages and coding standards. We were even precious about code layout, which seemed to some pretty silly at the time.

Yet 20 years later, purists are looking good.

Last week saw widespread attention to a bug in Apple's iOS operating system which rendered website security impotent. The problem arose from a single superfluous line of code – an extra goto statement – that nullified checking of SSL connections, leaving users totally vulnerable to fake websites. The Twitterverse nicknamed the flaw #gotofail.

There are all sorts of interesting quality control questions in the #gotofail experience.

  • Was the code inspected? Do companies even do code inspections these days?
  • The extra goto was said to be a recent change to the source; if that's the case, what regression testing was performed on the change?
  • How are test cases selected?
  • For something as important as SSL, are there not test rigs with simulated rogue websites to stress test security systems before release?

There seems to have been egregious shortcomings at every level : code design, code inspection, and testing.

A lot of attention is being given to the code layout. The spurious goto is indented in such a way that it appears to be part of a branch, but it is not. If curly braces were used religiously, or if an automatic indenting tool was applied, then the bug would have been more obvious (assuming that the code gets inspected). I agree of course that layout and coding standards are important, but there is a much more robust way to make source code clearer.

Beyond the lax testing and quality control, there is also a software-theoretic question in all this that is getting hardly any attention: Why are programmers using ANY goto statements at all?

I was taught at college and later at Telectronics to avoid goto statements at all cost. Yes, on rare occasions a goto statement makes the code more compact, but with care, a program can almost always be structured to be compact in other ways. Don't programmers care anymore about elegance in logic design? Don't they make efforts to set out their code in a rigorous structured manner?

The conventional wisdom is that goto statements make source code harder to understand, harder to test and harder to maintain. Kernighan and Ritchie - UNIX pioneers and authors of the classic C programming textbook - said the goto statement is "infinitely abusable" and it "be used sparingly if at all." Before them, one of programming's giants, Edsger Dijkstra, wrote in 1968 that "The go to statement ... is too much an invitation to make a mess of one's program"; see Go To Statement Considered Harmful. The goto creates spaghetti code. The landmark structured programming language PASCAL doesn't even have a goto statement! At Telectronics our coding standard prohibited without exception gotos in all implantable software.

Hard to understand, hard to test and hard to maintain is exactly what we see in the flawed iOS7 code. The critical bug never would have happened if Apple too banned the goto.

Now, I am hardly going to suggest that fanatical coding standards and intellectual rigor are sufficient to make software secure (see also "Security Isn’t Secure). It's unlikely that many commercial developers will be able to cost-justify exhaustive code walkthroughs when millions of lines are involved even in the humble mobile phone. It’s not as if lives depend on commercial software.

Or do they?!

Let’s leave aside that vexed question for now and return to fundamentals.

The #gotofail episode will become a text book example of not just poor attention to detail, but moreover, the importance of disciplined logic, rigor, elegance, and fundamental coding theory.

A still deeper lesson in all this is the fragility of software. Prof Arie van Deursen nicely describes the iOS7 routine as "brittle". I want to suggest that all software is tragically fragile. It takes just one line of silly code to bring security to its knees. The sheer non-linearity of software – the ability for one line of software anywhere in a hundred million lines to have unbounded impact on the rest of the system – is what separates development from conventional engineering practice. Software doesn’t obey the laws of physics. No non-trivial software can ever be fully tested, and we have gone too far for the software we live with to be comprehensively proof read. We have yet to build the sorts of software tools and best practice and habits that would merit the title "engineering".

I’d like to close with a philosophical musing that might have appealed to my old mentors at Telectronics. Post-modernists today can rejoice that the real world has come to pivot precariously on pure text. It is weird and wonderful that technicians are arguing about the layout of source code – as if they are poetry critics.

We have come to depend daily on great obscure texts, drafted not by people we can truthfully call "engineers" but by a largely anarchic community we would be better of calling playwrights.

Posted in Software engineering, Security


AndrewJThu 27 Feb 2014, 9:34pm

Great little vignettes from Tele. It was a unique place. As for software, I still goggle at the immaturity of the industry. We're still regularly inventing new computing languages that, with very few recent exceptions, do little to improve the quality of increasingly critical software systems propping up our comfortable existence. How many typos are we away from disaster? Code review is one thing. Not being able to even code low-level errors in the first place would be even better.

Bill D StrongMon 9 Mar 2015, 12:43pm

I don't know that I would say that no non-trivial software can ever be fully tested. First, I submit the seL4 kernel as an example of a greater than 10k loc program that is provably secure, in that it can be mathematically proved to only do that which the engineers intended.

Yes, it needs to have a user space built around it, however, it is a step in the right direction. It is engineering, rather than the playwriting.

Stephen WilsonMon 9 Mar 2015, 3:43pm

Thanks Bill. Yes, NICTA's work on provably correct software like the sel4 OS kernel is terrific. Do you work at NICTA?

I actually stand by my comment but admit it should be qualified. I literally meant tested, as in empirically tested, as opposed to verified by other means. We knew at Telectronics that the real-time defibrillator code could not be thoroughly empirically tested, so we used exhaustive code inspection as well, and some simulation. [We also experimented with a formal specification language (Z) but there was so little expertise in Z and in the problem space (arrhythmia treatment) we couldn't get the formal specs independently reviewed by anyone outside the team, which defeated the purpose.]

If only more software development was even remotely like NICTA's provable code. Until that time comes, forgive me for generalising that programming is not engineeering.

Bill D StrongTue 10 Mar 2015, 1:29am

Thanks Stephen,

No, I do not work for NICTA. However, I do find that project very interesting.
True, they do have the benefit of their problem space, essentially a subset of most kernels today, known by many experts, so they can get many eyes on the problem. Which is one of the benefits of going open source for them.

I can see how you meant testing, I just didn't take it that way through the first read through.

In terms of testing, what is your opinion on Gary Bernhardt's "Functional Core, Imperative Shell," as presented in his Boundaries talk located here? Could this be a way toward a more purists approach?

Stephen WilsonTue 10 Mar 2015, 11:09am

Bill, sorry, it looks like a link you included got blocked by my comment dialog box.
I think you meant this: https://www.destroyallsoftware.com/talks/boundaries.
Great talk. I am still digesting it. Cheers.

Bill D StrongTue 10 Mar 2015, 12:05pm

Yes, that's the one.

Post a comment

If you are a registered user, Please click here to Sign In

Your Name*

Your Email Address* required, but won't be displayed on this site

To help prevent spam in our blog comments, please type in "defence" (without the quotation marks) below*