{"id":1502,"date":"2018-08-13T13:00:43","date_gmt":"2018-08-13T18:00:43","guid":{"rendered":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/?p=1502"},"modified":"2018-08-23T05:53:10","modified_gmt":"2018-08-23T10:53:10","slug":"security-programming-languages-issue","status":"publish","type":"post","link":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/2018\/08\/13\/security-programming-languages-issue\/","title":{"rendered":"Software Security is a Programming Languages Issue"},"content":{"rendered":"

This is the the last of three posts on the course I regularly teach, CS 330, Organization of Programming Languages<\/a>. The first two posts covered programming language styles<\/a> and mathematical concepts<\/a>. This post covers the last 1\/4 of the course, which focuses on software security, and related to that, the programming language Rust<\/a>.<\/p>\n

This course topic might strike you as odd: Why teach security in a programming languages course? Doesn’t it belong in, well, a security<\/em> course? I believe that if we are to solve our security problems, then we must build software with security in mind right from the start. To do that, all<\/em> programmers need to know something about security, not just a handful of specialists. Security vulnerabilities are both enabled and prevented by various language (mis)features, and programming (anti)patterns. As such, it makes sense to introduce these concepts in a programming (languages) course, especially one that all students must take.<\/p>\n

This post is broken into three parts: the need for security-minded programming, how we cover this topic in 330, and our presentation of Rust. The post came to be a bit longer than I’d anticipated; apologies!<\/p>\n

\"Software<\/a>

Security is a programming (languages) concern<\/p><\/div>\n

<\/p>\n

The Status Quo: Too Much Post-hoc Security<\/h2>\n

There is a lot of interest these days in securing computer systems. This interest follows from the highly publicized roll call of serious data breaches, denial of service attacks, and system hijacks. In response, security companies are proliferating, selling computerized forms of spies, firewalls, and guard towers. There is also a regular call for more “cybersecurity professionals”<\/a> to help man the digital walls.<\/p>\n

It might be that these efforts are worth their collective cost, but call me skeptical. I believe that a disproportionate portion of our efforts focuses on adding security to a system after it has been built<\/em>. Is your server vulnerable to attack? If so, no problem: Prop an intrusion detection system<\/a> in front of it to identify and neuter network packets attempting to exploit the vulnerability. There’s no doubt that such an approach is appealing; too bad it doesn’t actually work<\/a>. As computer security experts have been saying since at least the 60s, if you want a system to actually be secure then it must be designed and built with security in mind. Waiting until the system is deployed is too late.<\/p>\n

Building Security In<\/h3>\n

There is a mounting body of work that supports building secure systems from the outset. For example, the Building Security In Maturity Model (BSIMM)<\/a> catalogues the processes followed by a growing list of companies to build more secure systems. Companies such as Synopsys<\/a> and Veracode<\/a>\u00a0offer code analysis products that look for security flaws. Processes such as Microsoft’s Security Development Lifecycle<\/a> and books such as Gary McGraw<\/a>‘s Software Security: Building Security In<\/a>, and Sami Saydjari<\/a>‘s recently released Engineering Trustworthy Systems<\/a>\u00a0identify a path toward better designed and built systems.<\/p>\n

These are good efforts. Nevertheless, we need even more<\/em> emphasis on the “build security in” mentality so we can rely far less on necessary, but imperfect, post-hoc stuff. For this shift to happen, we need better education.<\/p>\n

Security in a Programming Class<\/h2>\n
\"Running<\/a>

Choosing performance over security<\/p><\/div>\n

Programming courses typically focus on how to use particular languages to solve problems efficiently. Functionality is obviously paramount, with performance an important secondary concern.<\/p>\n

But in today’s climate shouldn’t security be at the same level of importance as performance? If you argue that security is not important for every application, I would say the same is true of performance. Indeed the rise of slow, easy-to-use scripting languages is a testament to that. But sometimes performance is very important, or becomes so later, and the same is true of security. Indeed, many security bugs arise because code originally written for a benign setting ends up in a security-sensitive one. As such, I believe educators should regularly talk about how to make code more secure<\/em> just as we regularly talk about how to make it more efficient.<\/p>\n

To do this requires a change in mindset. A reasonable approach, when focusing on correctness and efficiency, is to aim for code that works under expected conditions. But expected use is not good enough for security: Code must be secure under all<\/em> operating conditions.<\/p>\n

Normal users are not going to input weirdly formatted files to to PDF viewers. But adversaries will.\u00a0As such, students need to understand how a bug in a program can be turned into a security vulnerability, and how to stop it from happening.\u00a0Our two lectures in CS 330 on security shift between illustrating a kind of security vulnerability, identifying the conditions that make that vulnerability possible, and developing a defense that eliminates those conditions. For the latter we focus on language properties (e.g., type safety) and programming patterns (e.g., validating input).<\/p>\n

Security Bugs<\/h3>\n

In our first lecture<\/a>, we start by introducing the high-level idea of a buffer overflow<\/a> vulnerability, in which an input is larger than the buffer designed to hold it. We hint at how to exploit it by smashing the stack<\/a>. A key feature of this attack is that while the program intends for an input to be treated as data, the attacker is able to trick the program to treat it as code<\/em>\u00a0which does something harmful. We also look at\u00a0command injection<\/a>, and see how it similarly manifests when an attacker tricks the program to treat data as code.<\/p>\n

\"SQL<\/a>

SQL injection: malicious code from benign parts<\/p><\/div>\n

Our second lecture<\/a> covers vulnerabilities and attacks specific to web applications, including SQL injection<\/a>, Cross-site Request Forgery (CSRF)<\/a>, and Cross-site scripting (XSS)<\/a>. Once again, these vulnerabilities all have the attribute that untrusted data provided by an attacker can be cleverly crafted to trick a vulnerable application to treat that data as code. This code can be used to hijack the program, steal secrets, or corrupt important information.<\/p>\n

Coding Defenses<\/h3>\n

It turns out the defense against many of these vulnerabilities is the same, at a high level:\u00a0validate any untrusted input before using it<\/em>, to make sure it’s benign. We should make sure an input is not larger than the buffer allocated to hold it, so the buffer is not overrun. In any language other than C or C++, this check happens automatically (and is generally needed to ensure type safety<\/a>).<\/p>\n

For the other four attacks, the vulnerable application uses the attacker input when piecing together another program. For example, an application might expect user inputs to correspond to a username and password, splicing these inputs into a template SQL program with which it queries a database. But the inputs could contain SQL commands that cause the query to do something different than intended. The same is true when constructing shell commands (command injection), or Javascript and HTML programs (cross-site scripting). The defense is also the same, at a high level: user inputs need to either have potentially dangerous content removed or made inert by construction (e.g., through the use of prepared statements<\/a>).<\/p>\n

None of this stuff is new, of course. Most security courses talk about these topics. What is unusual is that we are talking about them in a “normal” programming languages course.<\/p>\n

Our security project<\/a> reflects the defensive-minded orientation of the material. While security courses tend to focus on vulnerability exploitation, CS 330 focuses on fixing<\/em> the bugs that make an application vulnerable. We do this by giving the students a web application, written in Ruby, with several vulnerabilities in it. Students must fix the vulnerabilities without breaking the core functionality. We test the fixes automatically by having our auto-grading system test functionality and exploitability. Several hidden tests exploit the initially present vulnerabilities.\u00a0The students must modify the application so these cases pass (meaning the vulnerability has been removed and\/or can no longer be exploited) without causing any of the functionality-based test cases to fail.<\/p>\n

Low-level Control, Safely<\/h2>\n

The most dangerous kind of vulnerability allows an attacker to gain arbitrary code execution<\/a>\u00a0(ACE): Through exploitation, the attacker is able to execute code of their choice on the target system. Memory management errors in type-unsafe languages (C and C++) comprise a large class of ACE vulnerabilities. Use-after-free errors, double-frees, and buffer overflows are all examples. The latter is still the single largest category of vulnerability<\/a> today, according to MITRE’s Common Weakness Enumeration (CWE)<\/a> database.<\/p>\n

Programs written in type-safe languages, such as Java or Ruby,[ref]Ruby is dynamically typed, but arguably type-safe<\/a>.[\/ref] are immune to these sorts of memory errors. Writing applications in these languages would thus eliminate a large category of vulnerabilities straightaway.[ref]This is not strictly true as parts of these languages’ implementations are written in C\/C++, and programs in type-safe languages can call out to C\/C++ via a foreign function interface. Even so, eliminating C\/C++ as a normal source programming language would dramatically reduce the attack surface.[\/ref] The problem is that type-safe languages’ use of abstract data representations and garbage collection<\/a> (GC), which make programming easier, remove low-level control and add overhead that is sometimes hard to bear. C and C++ are essentially the only game in town[ref]And even if it is not needed<\/em>, C\/C++ is still used quite a bit<\/a> anyway. Old habits, and legacy code, die hard.[\/ref] for operating systems, device drivers, and embedded devices (e.g., IoT<\/a>), which cannot tolerate the overhead and\/or lack of control.\u00a0And we see that these systems are regularly and increasingly under attack. What are we to do?<\/p>\n

Rust: Type safety without GC<\/h3>\n

In 2010, the Mozilla<\/a> corporation (which brings you Firefox) officially began an ambitious project to develop a safe language suitable for writing high-performance programs.\u00a0The result is Rust<\/a>.[ref]Rust development began in 2006, but was not officially supported by Mozilla until later.[\/ref] In Rust, type-safety ensures (with various caveats) that a program is free of memory errors and free of data races. In Rust, type safety is possible without<\/em> garbage collection, which is not true of any other mainstream language.<\/p>\n

\"Rust<\/a>

Rust, the programming language<\/p><\/div>\n

In CS 330, we introduce Rust<\/a> and its basic constructs<\/a>, showing how Rust is arguably closer to a functional programming language than it is to C\/C++. (Rust’s use of curly braces and semi-colons might make it seem familiar to C\/C++ programmers, but there’s a whole lot more that’s different than is the same!)<\/p>\n

We spend much of our time talking about Rust’s use of ownership<\/em> and lifetimes<\/em><\/a>. Ownership (aka linear typing<\/a>) is used to carefully track pointer aliasing, so that memory modified via one alias cannot mistakenly corrupt an invariant assumed by another. Lifetimes track the scope in which pointed-to memory is live, so that it is freed automatically, but no sooner than is safe. These features support managing memory without GC. They also support sophisticated programming patterns via smart pointers<\/a>\u00a0and traits<\/a> (a construct I was unfamiliar with, but now really like). We provide a simple programming project<\/a> to familiarize students with the basic and advanced features of Rust.<\/p>\n

Assessment<\/h3>\n

I enjoyed learning Rust in preparation for teaching it. I had been wanting to learn it since my interview with Aaron Turon<\/a> some years back. The Rust documentation<\/a> is first-rate, so that really helped.<\/p>\n

I also enjoyed seeing connections to my own prior research on the Cyclone programming language<\/a>. (I recently reflected on Cyclone, and briefly connected it to Rust, in a talk at the ISSISP’18 summer school<\/a>.) Rust’s ownership relates to Cyclone’s unique\/affine pointers, and Rust’s lifetimes relate to Cyclone’s regions. Rust’s smart pointers match patterns we also implemented in Cyclone, e.g., for reference counted pointers. Rust has taken these ideas much further, e.g., a really cool integration with traits handles tricky aspects of polymorphism. The Rust compiler’s error messages are also really impressive!<\/p>\n

A big challenge in Cyclone was finding a way to program with unique pointers without tearing your hair out. My impression is that Rust\u00a0programmers face the same challenge (as long as you don’t resort to frequent use of unsafe<\/strong> blocks<\/a>). Nevertheless, Rust is a much-loved programming language<\/a>, so the language designers are clearly doing something right! Oftentimes facility is a matter of comfort, and comfort is a matter of education and experience. As such, I think Rust fits into the philosophy of CS 330, which aims to introduce new language concepts that are interesting in and of themselves, and may yet have expanded future relevance.<\/p>\n

Conclusions<\/h2>\n

We must build software with security in mind from the start<\/a>. Educating all future programmers about security is an important step toward increasing the security mindset. In CS 330 we illustrate common vulnerability classes and how they can be defended against by the language (e.g., by using those languages, like Rust, that are type safe) and programming patterns (e.g., by validating untrusted input). By doing so, we are hopefully making our students more fully cognizant of the task\u00a0that awaits them in their future software development jobs. We might also interest them to learn more about security in a subsequent security class.<\/p>\n

In writing this post, I realize we could do more to illustrate how type abstraction can help with security. For example, abstract types can be used to increase assurance that input data is properly validated, as explained by Google’s Christoph Kern in his 2017 SecDev Keynote<\/a>. This fact is also a consequence of semantic<\/em> type safety, as argued well by Derek Dreyer in his POPL’18 Keynote<\/a>. Good stuff to do for Spring’19 !<\/p>\n","protected":false},"excerpt":{"rendered":"

This is the the last of three posts on the course I regularly teach, CS 330, Organization of Programming Languages. The first two posts covered programming language styles and mathematical concepts. This post covers the last 1\/4 of the course, … Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"Software Security is a Programming Languages Issue","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[12,3,31],"tags":[179,182,181,180],"class_list":["post-1502","post","type-post","status-publish","format-standard","hentry","category-education","category-softsec","category-types","tag-rust-language","tag-secure-coding","tag-type-safety","tag-vulnerability"],"yoast_head":"\nSoftware Security is a Programming Languages Issue - The PL Enthusiast<\/title>\n<meta name=\"description\" content=\"Software security must be addressed by all programmers, not just security experts. So we teach it in CS 330, a programming (languages) class.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/2018\/08\/13\/security-programming-languages-issue\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Software Security is a Programming Languages Issue - The PL Enthusiast\" \/>\n<meta property=\"og:description\" content=\"Software security must be addressed by all programmers, not just security experts. So we teach it in CS 330, a programming (languages) class.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/2018\/08\/13\/security-programming-languages-issue\/\" \/>\n<meta property=\"og:site_name\" content=\"The Programming Languages Enthusiast\" \/>\n<meta property=\"article:published_time\" content=\"2018-08-13T18:00:43+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2018-08-23T10:53:10+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/wp-content\/uploads\/2018\/08\/code-1839406_960_720-300x200.jpg\" \/>\n<meta name=\"author\" content=\"Michael Hicks\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Michael Hicks\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"11 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/2018\\\/08\\\/13\\\/security-programming-languages-issue\\\/#article\",\"isPartOf\":{\"@id\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/2018\\\/08\\\/13\\\/security-programming-languages-issue\\\/\"},\"author\":{\"name\":\"Michael Hicks\",\"@id\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/#\\\/schema\\\/person\\\/7d875a015cb2e83e9cd476df91028d5d\"},\"headline\":\"Software Security is a Programming Languages Issue\",\"datePublished\":\"2018-08-13T18:00:43+00:00\",\"dateModified\":\"2018-08-23T10:53:10+00:00\",\"mainEntityOfPage\":{\"@id\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/2018\\\/08\\\/13\\\/security-programming-languages-issue\\\/\"},\"wordCount\":2293,\"commentCount\":45,\"image\":{\"@id\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/2018\\\/08\\\/13\\\/security-programming-languages-issue\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/wp-content\\\/uploads\\\/2018\\\/08\\\/code-1839406_960_720-300x200.jpg\",\"keywords\":[\"rust language\",\"secure coding\",\"type safety\",\"vulnerability\"],\"articleSection\":[\"Education\",\"Software Security\",\"Types\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"http:\\\/\\\/www.pl-enthusiast.net\\\/2018\\\/08\\\/13\\\/security-programming-languages-issue\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/2018\\\/08\\\/13\\\/security-programming-languages-issue\\\/\",\"url\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/2018\\\/08\\\/13\\\/security-programming-languages-issue\\\/\",\"name\":\"Software Security is a Programming Languages Issue - The PL Enthusiast\",\"isPartOf\":{\"@id\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/2018\\\/08\\\/13\\\/security-programming-languages-issue\\\/#primaryimage\"},\"image\":{\"@id\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/2018\\\/08\\\/13\\\/security-programming-languages-issue\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/wp-content\\\/uploads\\\/2018\\\/08\\\/code-1839406_960_720-300x200.jpg\",\"datePublished\":\"2018-08-13T18:00:43+00:00\",\"dateModified\":\"2018-08-23T10:53:10+00:00\",\"author\":{\"@id\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/#\\\/schema\\\/person\\\/7d875a015cb2e83e9cd476df91028d5d\"},\"description\":\"Software security must be addressed by all programmers, not just security experts. So we teach it in CS 330, a programming (languages) class.\",\"breadcrumb\":{\"@id\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/2018\\\/08\\\/13\\\/security-programming-languages-issue\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"http:\\\/\\\/www.pl-enthusiast.net\\\/2018\\\/08\\\/13\\\/security-programming-languages-issue\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/2018\\\/08\\\/13\\\/security-programming-languages-issue\\\/#primaryimage\",\"url\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/wp-content\\\/uploads\\\/2018\\\/08\\\/code-1839406_960_720.jpg\",\"contentUrl\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/wp-content\\\/uploads\\\/2018\\\/08\\\/code-1839406_960_720.jpg\",\"width\":960,\"height\":640,\"caption\":\"Security is a programming concern\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/2018\\\/08\\\/13\\\/security-programming-languages-issue\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Software Security is a Programming Languages Issue\"}]},{\"@type\":\"WebSite\",\"@id\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/#website\",\"url\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/\",\"name\":\"The Programming Languages Enthusiast\",\"description\":\"Developments in PL, and why they matter\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/#\\\/schema\\\/person\\\/7d875a015cb2e83e9cd476df91028d5d\",\"name\":\"Michael Hicks\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/dd0371ad9a0cb821df683b5d6a6cccc911e6e2af1778f28b77e8c90b0c319d14?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/dd0371ad9a0cb821df683b5d6a6cccc911e6e2af1778f28b77e8c90b0c319d14?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/dd0371ad9a0cb821df683b5d6a6cccc911e6e2af1778f28b77e8c90b0c319d14?s=96&d=mm&r=g\",\"caption\":\"Michael Hicks\"},\"sameAs\":[\"http:\\\/\\\/www.cs.umd.edu\\\/~mwh\\\/\"],\"url\":\"http:\\\/\\\/www.pl-enthusiast.net\\\/author\\\/mwh\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Software Security is a Programming Languages Issue - The PL Enthusiast","description":"Software security must be addressed by all programmers, not just security experts. So we teach it in CS 330, a programming (languages) class.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/2018\/08\/13\/security-programming-languages-issue\/","og_locale":"en_US","og_type":"article","og_title":"Software Security is a Programming Languages Issue - The PL Enthusiast","og_description":"Software security must be addressed by all programmers, not just security experts. So we teach it in CS 330, a programming (languages) class.","og_url":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/2018\/08\/13\/security-programming-languages-issue\/","og_site_name":"The Programming Languages Enthusiast","article_published_time":"2018-08-13T18:00:43+00:00","article_modified_time":"2018-08-23T10:53:10+00:00","og_image":[{"url":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/wp-content\/uploads\/2018\/08\/code-1839406_960_720-300x200.jpg","type":"","width":"","height":""}],"author":"Michael Hicks","twitter_misc":{"Written by":"Michael Hicks","Est. reading time":"11 minutes"},"schema":{"@context":"https:\/\/fd.xuwubk.eu.org:443\/https\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/2018\/08\/13\/security-programming-languages-issue\/#article","isPartOf":{"@id":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/2018\/08\/13\/security-programming-languages-issue\/"},"author":{"name":"Michael Hicks","@id":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/#\/schema\/person\/7d875a015cb2e83e9cd476df91028d5d"},"headline":"Software Security is a Programming Languages Issue","datePublished":"2018-08-13T18:00:43+00:00","dateModified":"2018-08-23T10:53:10+00:00","mainEntityOfPage":{"@id":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/2018\/08\/13\/security-programming-languages-issue\/"},"wordCount":2293,"commentCount":45,"image":{"@id":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/2018\/08\/13\/security-programming-languages-issue\/#primaryimage"},"thumbnailUrl":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/wp-content\/uploads\/2018\/08\/code-1839406_960_720-300x200.jpg","keywords":["rust language","secure coding","type safety","vulnerability"],"articleSection":["Education","Software Security","Types"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/2018\/08\/13\/security-programming-languages-issue\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/2018\/08\/13\/security-programming-languages-issue\/","url":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/2018\/08\/13\/security-programming-languages-issue\/","name":"Software Security is a Programming Languages Issue - The PL Enthusiast","isPartOf":{"@id":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/#website"},"primaryImageOfPage":{"@id":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/2018\/08\/13\/security-programming-languages-issue\/#primaryimage"},"image":{"@id":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/2018\/08\/13\/security-programming-languages-issue\/#primaryimage"},"thumbnailUrl":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/wp-content\/uploads\/2018\/08\/code-1839406_960_720-300x200.jpg","datePublished":"2018-08-13T18:00:43+00:00","dateModified":"2018-08-23T10:53:10+00:00","author":{"@id":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/#\/schema\/person\/7d875a015cb2e83e9cd476df91028d5d"},"description":"Software security must be addressed by all programmers, not just security experts. So we teach it in CS 330, a programming (languages) class.","breadcrumb":{"@id":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/2018\/08\/13\/security-programming-languages-issue\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/2018\/08\/13\/security-programming-languages-issue\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/2018\/08\/13\/security-programming-languages-issue\/#primaryimage","url":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/wp-content\/uploads\/2018\/08\/code-1839406_960_720.jpg","contentUrl":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/wp-content\/uploads\/2018\/08\/code-1839406_960_720.jpg","width":960,"height":640,"caption":"Security is a programming concern"},{"@type":"BreadcrumbList","@id":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/2018\/08\/13\/security-programming-languages-issue\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/"},{"@type":"ListItem","position":2,"name":"Software Security is a Programming Languages Issue"}]},{"@type":"WebSite","@id":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/#website","url":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/","name":"The Programming Languages Enthusiast","description":"Developments in PL, and why they matter","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/#\/schema\/person\/7d875a015cb2e83e9cd476df91028d5d","name":"Michael Hicks","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/fd.xuwubk.eu.org:443\/https\/secure.gravatar.com\/avatar\/dd0371ad9a0cb821df683b5d6a6cccc911e6e2af1778f28b77e8c90b0c319d14?s=96&d=mm&r=g","url":"https:\/\/fd.xuwubk.eu.org:443\/https\/secure.gravatar.com\/avatar\/dd0371ad9a0cb821df683b5d6a6cccc911e6e2af1778f28b77e8c90b0c319d14?s=96&d=mm&r=g","contentUrl":"https:\/\/fd.xuwubk.eu.org:443\/https\/secure.gravatar.com\/avatar\/dd0371ad9a0cb821df683b5d6a6cccc911e6e2af1778f28b77e8c90b0c319d14?s=96&d=mm&r=g","caption":"Michael Hicks"},"sameAs":["https:\/\/fd.xuwubk.eu.org:443\/http\/www.cs.umd.edu\/~mwh\/"],"url":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/author\/mwh\/"}]}},"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/wp-json\/wp\/v2\/posts\/1502","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/wp-json\/wp\/v2\/comments?post=1502"}],"version-history":[{"count":10,"href":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/wp-json\/wp\/v2\/posts\/1502\/revisions"}],"predecessor-version":[{"id":1550,"href":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/wp-json\/wp\/v2\/posts\/1502\/revisions\/1550"}],"wp:attachment":[{"href":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/wp-json\/wp\/v2\/media?parent=1502"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/wp-json\/wp\/v2\/categories?post=1502"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/fd.xuwubk.eu.org:443\/http\/www.pl-enthusiast.net\/wp-json\/wp\/v2\/tags?post=1502"}],"curies":[{"name":"wp","href":"https:\/\/fd.xuwubk.eu.org:443\/https\/api.w.org\/{rel}","templated":true}]}}