Take the 2-minute tour ×

The following is all purely hypothetical and any particular portion of it may or may not accurately describe real persons or situations, whether living, dead or just pretending.

Let's say I'm a senior dev or architect in charge of a dev team working on a project. This project includes a security library for user authentication/authorization of the application under development. The library must be available for developers to edit; however, I wish to "trust but verify" that coders are not doing things that could compromise the security of the finished system, and because this isn't my only responsibility I want it to be done in an automated way.

As one example, let's say I have an interface that represents a user which has been authenticated by the system's security library. The interface exposes basic user info and a list of things the user is authorized to do (so that the client app doesn't have to keep asking the server "can I do this?"), all in an immutable fashion of course. There is only one implementation of this interface in production code, and for the purposes of this post we can say that all appropriate measures have been taken to ensure that this implementation can only be used by the one part of our code that needs to be able to create concretions of the interface.

The coders have been instructed that this interface and its implementation are sacrosanct and any changes must go through me. However, those are just words; the security library's source is open for editing by necessity. Any of my devs could decide that this secured, private, hash-checked implementation needs to be public so that they could do X, or alternately they could create their own implementation of this public interface in a different library, exposing the hashing algorithm that provides the secure checksum, in order to do Y. I may not be made aware of these changes so that I can beat the developer over the head for it. An attacker could then find these little nuggets in an unobfuscated library of the compiled product, and exploit it to provide fake users and/or falsely-elevated administrative permissions, bypassing the entire security system.

This possibility keeps me awake for a couple of nights, and then I create an automated test that reflectively checks the codebase for types deriving from the interface, and fails if it finds any that are not exactly what and where I expect them to be. I compile this test into a project under a separate folder of the VCS that only I have rights to commit to, have CI compile it as an external library of the main project, and set it up to run as part of the CI test suite for user commits. Now, I have an automated test under my complete control that will tell me (and everyone else) if the number of implementations increases without my involvement, or an implementation that I did know about has anything new added or has its modifiers or those of its members changed. I can then investigate further, and regain the opportunity to beat developers over the head as necessary.

Is this considered "reasonable" to want to do in situations like this? Am I going to be seen in a negative light for going behind my devs' backs to ensure they aren't doing something they shouldn't?

share|improve this question
what necessity is there to allow editing on a source they aren't allowed to edit? –  Ryathal Apr 4 '12 at 20:03
They may have a legitimate need to edit other source files that compile into the security library, and maybe even make certain edits to the objects in question, BUT if they do something that indicates they're trying to circumvent the design of the security library, I need to know. –  KeithS Apr 4 '12 at 20:15
add comment

2 Answers

up vote 4 down vote accepted

This isn't unreasonable, because it is a very good idea to do code reviews for security-based code. You could mandate that developers do code-reviews before checking in code, but this doesn't protect you if they forget and check in anyway.

share|improve this answer
add comment

What you want is completely reasonable. Our CI build process, besides compiling the code, runs StyleCop, FxCop and NCover and runs unit tests. The result has been much higher quality code, code which is more readable and maintainable. You could also do some other automated things, like C# code contracts static analysis.

A nice side effect is that during our code reviews we can focus on things that really matter instead of styling / best practices.

share|improve this answer
add comment

Your Answer


