Security Approaches That Don’t Work

Photo by CarbonNYC

If it’s not broken, then don’t fix it …

The problem is, you may have an approach that isn’t working, or it’s not as efficient as it could be, but you may not even know it.  Let’s take a quick look at some broken approaches and get to the bottom of why they fail.  If you understand why they fail, you can then take a look at your own approach and see what, if anything, you need to change.  The more prevalent broken approaches include:

The Bolt on Approach

  • The Do It All Up Front Approach
  • The Big Bang Approach
  • The Buckshot Approach
  • The All or Nothing Approach

The Bolt on Approach

Make it work, and then make it right.  This is probably the most common approach to security that I see, and it almost always results in failure or at least inefficiency.  This approach results in a development process that ignores security until the end, usually the testing phase, and then tries to make up for mistakes made earlier in the development cycle.   This is one way of addressing security.  This is effectively the bolt on approach. 

The assumption is that you can bolt on security at the end, just enough to get the job done.  While the bolt on approach is a common practice, the prevalence of security issues you can find in Web applications that use this approach, is not a coincidence.

The real weakness in the bolt on approach is that some of the more important design decisions that impact the security of your application have a cascading impact on the rest of your application’s design. If you’ve made a poor decision early in design, later you will be faced with some unpleasant choices.  You can either cut corners, further degrading security, or you can extend the development of your application missing project deadlines.  If you make your most important security design decisions at the end, how can you be confident you’ve implemented and tested your application to meet your objectives?

The Do It All Up Front Approach
The opposite of the bolt on approach is the do it all up front approach.   In this case, you attempt to address all of your security design up front.  There are two typical failure scenarios:

  1. You get overwhelmed and frustrated and give up, or
  2. You feel like you’ve covered all your bases and then don’t touch security again until you see your first vulnerability come in on the release product.

While considering security up front is a wise choice, you can’t expect to do it all at once.  For one thing, you can’t expect to know everything up front.  More importantly, this approach is not as capable of dealing with decisions throughout the application development that affect security, as an approach that integrates security consideration throughout the life cycle.

The Big Bang Approach
This can be similar to the do it all up front approach.  The big bang approach is where you depend on a single big effort, technique or activity to produce all of your security results.   Depending on where you drop your hammer, you can certainly accomplish some security benefits, if some security effort is better than none.  However, similar to the do it all up front approach, a small set of focused activities outshines the single big bang.

The typical scenario is a shop that ignores security (or pays it less than the optimal amount of attention) until the test phase.  Then they spend a lot of time/money on a security test pass that tells them all the things that are wrong.  They then make hard decisions on what to fix vs. what to leave and try to patch an architecture that wasn’t designed properly for security in the first place.

The Buckshot Approach
The buckshot approach is where you try a bunch of security techniques on your application, hoping you somehow manage to hit the right ones.  For example, it’s common to hear, “we’re secure, we have a firewall”, or “we’re secure, we’re using SSL”.  The hallmark of this approach is that you don’t know what your target is and the effort expended is random and without clear benefit. Beware the security zealot who is quick to apply everything in their tool belt without knowing what the actual issue is they are defending against.  More security doesn’t necessarily equate to good security.  In fact, you may well be trading off usability or maintainability or performance, without improving security at all.

You can’t get the security you want without a specific target.  Firing all over the place (with good weapons even) isn’t likely to get you a specific result.  Sure you’ll kill stuff but who knows what.

The All or Nothing Approach
With the all or nothing approach, you used to do nothing to address security and now you do it all.  Over-reacting to a previous failure is one reason you might see a switch to “All”.  Another is someone truly trying to do the best they can to solve a real problem and not realizing they are biting off more than they can chew.

While it can be a noble effort, it’s usually a path to disaster.  There are multiple factors, aside from your own experience, that impact success, including maturity of your organization and buy in from team members.  Injecting a dramatic change helps get initial momentum, but, if you take on too much at once, you may not create a lasting approach, and will eventually fall back to doing nothing

My Related Posts


  1. That is great write up.
    In the field I see more approaches that do not work than do work.
    But I also like Edison’s “I have not failed. I’ve just found 10,000 ways that won’t work.”

    You distilled precisly anti-patterns so it is easy to identify and avoid it.

    Here is my take on the security reviews that worked for me:

  2. This is a really nice write-up! Forget nice, I think it’s great. Your sum up of the bolt-on approach, which is the second most common approach today (next to no security ;P) is elegant: Make it work, and then make it right.

  3. @ Alik

    10,000 ways that won’t work 😉

    Thank you

    @ Kevin

    Thank you! I think it’s easier to relate to the approaches when we have simple metaphors or names for them. You’re right, no security is the most common approach!

  4. Very Nice.

    I’ve also seen approaches where dev and security are done by different orgs and there is an attempt to force-fit them as part of a certification and accreditation phase that the system/software needs to go through to be in production.

  5. @ Anil

    Cross-group criteria is tough. I’ve seen it work in two scenarios:
    1. Somebody from the other group joins the team as a partner
    2. The criteria is turned into a set of incremental hurdles, and again, there’s a partnership

    @ Mike

    Thank you. I like the fact it resonates with your experience.

Comments are closed.