Opa @ owasp 2010
by IamYoric on Jun 28, 2010
- 1,300 views
Web applications and services have critical needs in terms of safety, security and privacy: they need to remain available constantly and can at any time be the object of attacks by malicious and ...
Web applications and services have critical needs in terms of safety, security and privacy: they need to remain available constantly and can at any time be the object of attacks by malicious and anonymous distant users attempting to take control, alter data or steal it, or cause unwanted behaviors. Unfortunately, recent history shows numerous cases of popular web applications falling victim to such attacks, despite careful attempts to secure them.
In this talk, we introduce OPA (One Pot Application), a new platform based on formal methods, designed to make web development sane, safe and secure. OPA provides an integrated methodology where the complete application is written with one simple language with consistent semantics, enforces safe use of the infrastructure through compile-time static checking and a novel programming paradigm suited to the web and encourages correct-by-construction development.
Accessibility
Categories
Upload Details
Uploaded via SlideShare as Apple Keynote
Usage Rights
© All Rights Reserved
Statistics
- Likes
- 0
- Downloads
- 25
- Comments
- 0
- Embed Views
- Views on SlideShare
- 1,300
- Total Views
- 1,300
I had to swear upon everything I hold sacred that I would not attempt to sell anything to you. So, I’m going to do by something else. I’m going to steal one of yesterday’s presentations.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.
Ok, if you’re like me, at this stage, you’re starting to wonder just exactly where things went wrong. Well, I have one possible explanation. We’re in a 21st setting and we’re still using programming languages designed for command-line applications or desktop applications, and stacks of unrelated and mismatched technologies, to which we add plenty of glue. And when security issues appear, because they have to appear, we’re addressing them with what? With patches and sandboxing.