Considering Encrypting Passwords At Rest In ColdFusion

<cfscript>

	passwordEncoder = new PasswordEncoder();

	// Note: normally this key would be generated once and stored securely outside the
	// code. For the sake of the demo, I'm just creating a new secret key on each request.
	secretKey = passwordEncoder.generateKeyForAlgorithm();
	// This is the password that we want to encrypt at rest.
	password = "MyNameIsOzymandiasKingOfKings";

	encoding = passwordEncoder.encode( password, secretKey );
	decoding = passwordEncoder.decode( encoding, secretKey );
	
	writeDump([
		input: password,
		encrypted: encoding,
		decrypted: decoding,
		isMatch: ( password == decoding )
	]);

</cfscript>

component
	output = false
	hint = "I provide methods for encrypting passwords at rest."
	{

	/**
	* I initialize the password encoder.
	*/
	public void function init() {

		// For more aesthetically pleasing data storage strings.
		variables.base64UrlEncoder = new Base64UrlEncoder();

		// [AES] = Advanced Encryption Standard. This is the new default as of the latest
		// ColdFusion update; but, I'm defining it explicitly for clarity.
		// [CBC] = Cipher Block Chaining. This uses a single thread to process one block
		// of data at a time, using the results of the previous block as the key used to
		// encrypt the next block.
		variables.algorithm = "AES/CBC/PKCS5Padding";

		// Note: the ColdFusion documentation states that the AES algorithm is limited to
		// 128 bits unless the Java Unlimited Strength Jurisdiction Policy Files are
		// installed. It's unclear to me if that is the common case or an outlier case.
		// Regardless, it seems to work for me in my development environment no problem.
		variables.keySize = 256;

		// The initialize vector (IV) size is tied to the block size of the AES algorithm,
		// which uses a fixed-block size of 16-bytes (128 bits). This has nothing to do
		// with the size of the encryption key that we will use.
		variables.ivSize = 128;

	}

	// ---
	// PUBLIC METHODS.
	// ---

	/**
	* I decode the given encrypted password.
	*/
	public string function decode(
		required string input,
		required string key
		) {

		// The encoded password is actually a compound token that includes both the unique
		// initialization vector and the encrypted password. To decrypt the password, we
		// have to break the token apart.
		var parts = input.listToArray( "." );
		var initializationVector = base64UrlEncoder.decode( parts[ 1 ] );
		var encodedPassword = base64UrlEncoder.decodeToBase64( parts[ 2 ] );

		return decrypt(
			encodedPassword,
			key,
			algorithm,
			"base64",
			initializationVector
		);

	}


	/**
	* I encode the given plain-text password.
	*/
	public string function encode(
		required string input,
		required string key
		) {

		// The initialization vector works much like the salt in a hashing routine. It
		// ensures that similar inputs always produce a different output, thereby making
		// it harder for a malicious actor to brute-force a decryption routine.
		var initializationVector = generateInitializationVectorForAlgorithm();

		var encodedPassword = encrypt(
			input,
			key,
			algorithm,
			"base64",
			initializationVector
		);

		// Much like the bCrypt hashing, we're going to return a compound token value that
		// contains both the "salt" and the encrypted payload. This way, the token can be
		// stored and passed around a single unit.
		// --
		// Note: there's no technical reason that I have to encode these values using the
		// Base64url format - this is just for aesthetics (I rather dislike those padding
		// characters at the end, seems entirely unnecessary).
		return (
			base64UrlEncoder.encode( initializationVector ) &
			"." &
			base64UrlEncoder.encodeFromBase64( encodedPassword )
		);

	}

	/**
	* I generate a Base64-encoded key for use with the AES encryption algorithm.
	* 
	* Note: this is a utility function to help generate one-off keys to be stored securely
	* outsize of the ColdFusion code.
	*/
	public string function generateKeyForAlgorithm() {

		return generateSecretKey( "AES", keySize );

	}

	// ---
	// PRIVATE METHODS.
	// ---

	/**
	* I generate a Base64-encoded initialization vector for the AES algorithm.
	*/
	private binary function generateInitializationVectorForAlgorithm() {

		return binaryDecode( generateSecretKey( "AES", ivSize ), "base64" );

	}

}

component
	output = false
	hint = "I provide methods for encoding and decoding values as Base64Url."
	{

	/**
	* I decode the given Base64Url input into a binary value.
	*/
	public binary function decode( required string input ) {

		return binaryDecode( decodeToBase64( input ), "base64" );

	}


	/**
	* I decode the given Base64Url input into a Base64 value.
	*/
	public string function decodeToBase64( required string input ) {

		var unpadded = input
			.replace( "-", "+", "all" )
			.replace( "_", "/", "all" )
		;
		// When we generate the URL-safe value, we strip out the padding characters at the
		// end. When we decode the input, we then need to append the padding characters
		// back on the end.
		var paddingLength = ( 4 - ( unpadded.len() % 4 ) );
		var padding = repeatString( "=", paddingLength );

		return ( unpadded & padding );

	}


	/**
	* I decode the given Base64Url input into a string value with the given encoding.
	*/
	public string function decodeToString(
		required string input,
		string encoding = "utf-8"
		) {

		return charsetEncode( decode( input ), encoding );

	}


	/**
	* I encode the given binary input into a Base64Url value.
	*/
	public string function encode( required binary input ) {

		return encodeFromBase64( binaryEncode( input, "base64" ) );

	}


	/**
	* I encode the given Base64 input into a Base64Url value.
	*/
	public string function encodeFromBase64( required string input ) {

		return input
			.replace( "+", "-", "all" )
			.replace( "/", "_", "all" )
			.replace( "=", "", "all" )
		;

	}


	/**
	* I encode the given string input with given encoding into a Base64Url value.
	*/
	public string function encodeFromString(
		required string input,
		string encoding = "utf-8"
		) {

		return encode( charsetDecode( input, encoding ) );

	}


	/**
	* I encode the given HEX input into a Base64Url value.
	*/
	public string function encodeFromHex( required string input ) {

		return encode( binaryDecode( input, "hex" ) );

	}

}