Oh yeah, I have a blog! I almost forgot. I've been busy working. Let's talk about an extraordinarily fascinating topic: Federal compliance!
FIPS (Federal Information Processing Standard) has many different standards. FIPS holds sway mainly in the U.S. and Canada. Within each standard, there are multiple revisions and multiple levels of classification. FIPS 140 is about encryption and hashing algorithms. It’s about accrediting cryptographic modules. Here’s an example of a certificate. The FIPS 140-2 revision is the current standard, and FIPS 140-3 is under development with no announced release date yet. It does not matter if your homebrew cryptography is technically “better” than anything else ever. If your cryptographic module has not gone through the code submission and certification process, then it is not FIPS-approved. You have to submit your source code/device/module to the government, in order to gain FIPS approval. Even if you have the most amazing cryptography the world has ever seen, it is still not FIPS approved or compliant until it goes through the process. In fact, the government is free to certify weaker algorithms in favor of stronger ones just because the weaker algorithms have undergone the certification process when the stronger ones have not, and they have historically done so. (Triple-DES being the prime example.)
There is even a welcome kit, with stickers. You need to put these tamper-proof stickers on your stuff for certain levels of FIPS compliance.
So if you are ever writing any software of your own, please do not try to roll your own cryptography. Use the approved libraries that have already gone through certification. Your custom crypto has about a 100% chance of being worse than AES/SHA (NSA backdoors notwithstanding,) and it will never be certifiable for use in a secure Federal environment anyway. Also avoid things like re-hashing your hash with another hashing algorithm in attempt to be ‘clever’ – doing so can ironically make your hash weaker.
And the Feds are picky. For instance, if programming for Windows in .NET, the use of System.Security.Cryptography.SHA1 classes may be acceptable while the use of System.Security.Cryptography.SHA1Managed classes are not acceptable. It doesn’t mean the methods in the SHA1Managed classes are any worse, it simply means Microsoft has not submitted them for approval.
Many major vendors such as Microsoft and Cisco go through this process for every new version of product that they release. It costs money and time to get your product FIPS-certified. Maybe it’s a Cisco ASA appliance, or maybe it’s a simple Windows DLL.
The most recent publication of FIPS 140-2 Annex A lists approved security functions (algorithms.) It lists AES and SHA-1 as acceptable, among others. So if your application uses only approved implementations of AES and SHA-1 algorithms, then that application should be acceptable according to FIPS 140-2. If your application uses an MD5 hashing algorithm during communication, that product is NOT acceptable for use in an environment where FIPS compliance must be maintained.
However, there is also this contradictory quote from NIST:
“The U.S. National Institute of Standards and Technology says, "Federal agencies should stop using SHA-1 for...applications that require collision resistance as soon as practical, and must use the SHA-2 family of hash functions for these applications after 2010" ”
So it seems to me that there are contradictory government statements regarding the usage of security functions. The most recent draft of FIPS 140-2 Annex A clearly lists SHA-1 as an acceptable hashing algorithm, yet, the quote from NIST says that government agencies must use only SHA-2 after 2010. Not sure what the answer is to that.
These algorithms can be broken up into two categories: encryption algorithms and hashing algorithms. An example of a FIPS encryption algorithm is AES (which consists of three members of the Rijndael family of ciphers, adopted in 2001, and has a much cooler name.) Encryption algorithms can be reversed/decrypted, that is, converted back into their original form from before they were encrypted.
Hashing algorithms on the other hand, are also known as one-way functions. They are mathematically one-way and cannot be reversed. Once you hash something, you cannot “un-hash” it, no matter how much computing power you have. Hashing algorithms take any amount of data, of an arbitrary size, and mathematically map it to a “hash” of fixed length. For instance, the SHA-256 algorithm will map any chunk of data, whether it be 10 bytes or 2 gigabytes, into a 256 bit hash. Always 256 bit output, no matter the size of the input.
This is why the hash of a password is generally considered decently secure, because there is NO way to reverse the hash, so you can pass that hash to someone else via insecure means (e.g. over a network connection,) and if the other person knows what your password should be, then they can know that the hash you gave them proves that you know the actual password. That's a bit of a simplification, but it gets the point across.
If you were trying to attack a hash, all you can do, if you know what hash algorithm was used, is to keep feeding that same hash algorithm new inputs, maybe millions or billions of new inputs a second, and hope that maybe you can reproduce the same hash. If you can reproduce the same hash, then you know your input was the same as the original ‘plaintext’ that you were trying to figure out. Maybe it was somebody’s password. This is the essence of a ‘brute-force’ attack against a password hash.
Logically, if all inputs regardless of size, are mapped to a fixed size, then it stands to reason that there must be multiple sets of data that, when hashed, result in the same hash. These are known as hash collisions. They are very rare, but they are very bad, and collisions are the reason we needed to migrate away from the MD5 hashing algorithm, and we will eventually need to migrate away from the SHA-1 hashing algorithm. (No collisions have been found in SHA-1 yet that I know of.) Imagine if I could create a fake SSL certificate that, when I creatively flipped a few bits here and there, resulted in the same hash as a popular globally trusted certificate! That would be very bad.
Also worth noting is that SHA-2 is an umbrella term, that includes SHA256, SHA384, SHA512, etc.
FIPS 140 is only concerned with algorithms used for external communication. Any communication outside of the application or module, whether that be network communication, or communication to another application on the same system, etc. FIPS 140 is not concerned with algorithms used to handle data within the application itself, within its own private memory, that never leaves the application and cannot be accessed by unauthorized users. Here is an excerpt from the 140-2 standard to back up my claim:
“Cryptographic keys stored within a cryptographic module shall be stored either in plaintext form or encrypted form. Plaintext secret and private keys shall not be accessible from outside the cryptographic module to unauthorized operators…”
Let’s use Active Directory as an example. This is why, when someone gets concerned about what algorithms AD uses internally, you should refer them to the above paragraph and tell them not to worry about it. Even if it were plaintext (it’s not, but even if hypothetically it were,) it isn’t in scope for FIPS because it is internal only to the application. When Active Directory and its domain members are operated in FIPS mode, connections made via Schannel.dll, Remote Desktop, etc., will only use FIPS compliant algorithms. If you had applications before that make calls to non-FIPS crypto libraries, those applications will now crash.
Another loophole that has appeared to satisfy FIPS requirements in the past, is wrapping a weaker algorithm inside of a stronger one. For instance, a classic implementation of the RADIUS protocol utilizes the MD5 hashing algorithm during network communications. MD5 is a big no-no. However, see this excerpt from Cisco:
“RADIUS keywrap support is an extension of the RADIUS protocol. It provides a FIPS-certifiable means for the Cisco Access Control Server (ACS) to authenticate RADIUS messages and distribute session keys.”
So by simply wrapping weaker RADIUS keys inside of AES, it becomes FIPS-certifiable once again. It would seem to follow that this logic also applies when using TLS and IPsec, as they are able to use very strong algorithms (such as SHA-2) that most applications do not natively support.
So with all that said, if you need the highest levels of network security, you need 802.1x and IPsec if you need to protect all those applications that can't protect themselves.