How coders are creating software that's impossible to hack | Kathleen Fisher | Big Think

New videos DAILY

How coders are creating software that's impossible to hack

Join Big Think Edge for exclusive video lessons from top thinkers and doers

----------------------------------------------------------------------------------

Hackers thrive on human error, but a new method of coding is ending that. Recent developments by the HACMS (High-Assurance Cyber Military Systems) program at DARPA has allowed computer scientists to use mathematical proofs to verify that code—up to 100,000 lines of it at a time—is functionally correct and free of bugs. Kathleen Fisher, professor of computer science and former program manager at DARPA, explains how this allows coders to build a thin base of hyper-secure code that is verified to be functionally correct, "and then you can have lots of software running on top of it that doesn’t have that same level of assurance associated with it but that you can prove: it doesn’t matter what it does, it’s not going to affect the operation of the overall system." To illustrate this technology in the real world, Fisher tells the story of how this new method of coding defended a Boeing Little Bird helicopter from a "red team" of hackers charged with causing havoc in the system and bringing that baby down. So is there anything hackers can't hack? Now there is, thanks to the beauty (and rigor) of formal mathematics.

----------------------------------------------------------------------------------

KATHLEEN FISHER:

Kathleen Fisher is aProfessor in and the Chair of the Computer Science Department at Tufts. Previously, she was a program manager at DARPA where she started and managed the HACMS and PPAML programs, a Consulting Faculty Member in the Computer Science Department at Stanford University, and a Principal Member of the Technical Staff at AT&T Labs Research. Kathleen's research focuses on advancing the theory and practice of programming languages and on applying ideas from the programming language community to the problem of ad hoc data management. The main thrust of her work has been in domain-specific languages to facilitate programming with massive amounts of ad hoc data. Recently, she has been exploring synergies between machine learning and programming languages and studying how to apply advances in programming languages to the problem of building more secure systems.

Kathleen is an ACM Fellow. She has served as Program Chair for OOPSLA ICFP, CUFP, and FOOL, and as General Chair for ICFP 2015. She is an Associate Editor for TOPLAS and a former editor of the Journal of Functional Programming. Kathleen is a past Chair of the ACM Special Interest Group in Programming Languages (SIGPLAN) and past Co-Chair of CRA's Committee on the Status of Women (CRA-W). Kathleen is a recipient of the SIGPLAN Distinguished Service Award. She is Vice Chair of DARPA's ISAT Study Group and a member of the Board of Trustees of Harvey Mudd College.

----------------------------------------------------------------------------------

TRANSCRIPT:

Kathleen Fisher: HACMS is a program at DARPA that ran for four-and-a-half years that was focused on using techniques from what is called the 'formal methods community', so techniques based on math more or less, to produce software for vehicles that came with proofs that the software had certain desirable properties; that parts of it were functionally correct, that there were no certain kinds of bugs in the software. And the consequence of those proofs is that the system is much harder to hack into.

So the formal methods community has been promising for, like, 50 years that they could produce software that provably didn’t have certain kind of vulnerabilities. And for more or less 50 years they have failed to deliver on that promise. Yes, they could produce proofs of correctness for code but for ten lines of code or 100 lines of code—not enough code to make a difference for any kind of practical purpose.

But recently there have been advances in a bunch of different research areas that have changed that equation, and so now formal methods researchers can prove important properties about code bases that are 10,000 or 100,000 lines of code. And that’s still small potatoes compared to the size of Microsoft Windows or the size of Linux which are millions, hundreds of millions of lines of code. But when you start to get to 10,000 or 100,000 lines of code there are really interesting software artifacts that fit in that size. Things like compilers and microkernels, and you can leverage those kinds of exquisite artifacts to build much more complex software systems where only a small part of the system has to be verified to be functionally correct, and then you can have lots of software running on top of it that doesn’t have that same level of assurance associ...

For the full transcript, check out