Experimenting With RSA-Encrypted Signature Generation And Verification In ColdFusion

# Create the private key with 1024 bits.
openssl genrsa -out private.pem 1024

# Extract the public key from the private key.
openssl rsa -in private.pem -out public.pem -outform PEM -pubout

<cfscript>

	// Create a new instance of our RSA Signer using the public and private keys
	// (read-in as plain-text inputs). The signer stores the public and private
	// keys internally so that we don't have to pass them around to each method.
	signer = new RSASigner(
		fileRead( expandPath( "./public.pem" ) ),
		fileRead( expandPath( "./private.pem" ) ),
		"SHA512withRSA"
	);

	// NOTE: Adding BounceCastle as a crypto API provider, otherwise, I get:
	// "Invalid RSA private key encoding." in my local development environment.
	signer.addBouncyCastleProvider();


	// I am the message to be signed.
	message = "Not malfunction Stephanie. Number 5 is alive.";

	// Sign the message (uses the PRIVATE key).
	signature = signer.sign( message );

	// Verify the signature against the message (uses the PUBLIC key).
	verified = signer.verify( message, signature );


	// Output the results:
	writeOutput( "Message: #message# <br />" );
	writeOutput( "Verified: #yesNoFormat( verified )# <br />" );

	// For additional debugging.
	// writeOutput( "Signature: #binaryEncode( signature, 'base64' )# <br />" );

</cfscript>

component
	output = false
	hint = "I provide a ColdFusion wrapper to Java hashing and verification algorithms with RSA encryption."
	{

	/**
	* I create a new RSA Signer using the given public and private keys.
	*
	* NOTE: The algorithm uses the names provided in the Java Cryptography Architecture
	* Standard Algorithm Name documentation:
	*
	* - MD2withRSA
	* - MD5withRSA
	* - SHA256withRSA
	* - SHA384withRSA
	* - SHA512withRSA
	*
	* CAUTION: The keys are assumed to be in PEM format.
	*
	* @publicKey I am the plain-text public key.
	* @privateKey I am the plain-text private key.
	* @algorithm I am the RSA-based signature algorithm being used.
	* @output false
	*/
	public any function init(
		required string publicKey,
		required string privateKey,
		required string algorithm
		) {

		setPublicKeyFromText( publicKey );
		setPrivateKeyFromText( privateKey );
		setAlgorithm( algorithm );

		return( this );

	}


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


	/**
	* I add the BounceCastleProvider to the underlying crypto APIs.
	*
	* CAUTION: I don't really understand why this is [sometimes] required. But, if you
	* run into the error, "Invalid RSA private key encoding.", adding BouncyCastle may
	* solve the problem.
	*
	* This method only needs to be called once per ColdFusion application life-cycle.
	* But, it can be called multiple times without error.
	*
	* @output false
	*/
	public void function addBouncyCastleProvider() {

		createObject( "java", "java.security.Security" )
			.addProvider( createObject( "java", "org.bouncycastle.jce.provider.BouncyCastleProvider" ).init() )
		;

	}


	/**
	* I sign the given plain-text message.
	*
	* @message I am the plain-text (UTF-8) message being signed.
	* @encoding I am the encoding used when returning the signature (binary by default).
	* @output false
	*/
	public any function sign(
		required string message,
		string encoding = "binary"
		) {

		var signer = createObject( "java", "java.security.Signature" )
			.getInstance( javaCast( "string", algorithm ) )
		;

		signer.initSign( privateKey );
		signer.update( charsetDecode( message, "utf-8" ) );

		var signedBytes = signer.sign();

		// If the desired encoding is binary, just return the signed bytes.
		if ( encoding == "binary" ) {

			return( signedBytes );

		}

		// Otherwise, encode the binary data.
		return( binaryEncode( signedBytes, encoding ) );

	}


	/**
	* I verify the given signature using the given RSA-based signature algorithm.
	*
	* @message I am the plain-text (UTF-8) message being signed (and verified).
	* @signature I am the binary signature being verified.
	* @output false
	*/
	public boolean function verify(
		required string message,
		required binary signature
		) {

		var verifier = createObject( "java", "java.security.Signature" )
			.getInstance( javaCast( "string", algorithm ) )
		;

		verifier.initVerify( publicKey );
		verifier.update( charsetDecode( message, "utf-8" ) );

		return( verifier.verify( signature ) );

	}


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


	/**
	* I set the algorithm being used by the signer.
	*
	* NOTE: The algorithm uses the names provided in the Java Cryptography Architecture
	* Standard Algorithm Name documentation:
	*
	* - MD2withRSA
	* - MD5withRSA
	* - SHA256withRSA
	* - SHA384withRSA
	* - SHA512withRSA
	*
	* @newAlgorithm I am the RSA-based signature algorithm being set.
	* @output false
	*/
	private void function setAlgorithm( required string newAlgorithm ) {

		switch ( newAlgorithm ) {
			case "MD2withRSA":
			case "MD5withRSA":
			case "SHA256withRSA":
			case "SHA384withRSA":
			case "SHA512withRSA":

				algorithm = newAlgorithm;

			break;
			default:

				throw(
					type = "InvalidArgument",
					message = "Algorithm not supported.",
					detail = "The algorithm [#newAlgorithm#] is not currently supported."
				);

			break;
		}

	}


	/**
	* I set the public key using the plain-text public key content.
	*
	* NOTE: Keys are expected to be in PEM format.
	*
	* @publicKeyText I am the plain-text public key.
	* @output false
	*/
	private void function setPublicKeyFromText( required string publicKeyText ) {

		var publicKeySpec = createObject( "java", "java.security.spec.X509EncodedKeySpec" ).init(
			binaryDecode( stripKeyDelimiters( publicKeyText ), "base64" )
		);

		publicKey = createObject( "java", "java.security.KeyFactory" )
			.getInstance( javaCast( "string", "RSA" ) )
			.generatePublic( publicKeySpec )
		;

	}


	/**
	* I set the private key using the plain-text private key content.
	*
	* NOTE: Keys are expected to be in PEM format.
	*
	* @privateKeyText I am the plain-text private key.
	* @output false
	*/
	private void function setPrivateKeyFromText( required string privateKeyText ) {

		var privateKeySpec = createObject( "java", "java.security.spec.PKCS8EncodedKeySpec" ).init(
			binaryDecode( stripKeyDelimiters( privateKeyText ), "base64" )
		);

		privateKey = createObject( "java", "java.security.KeyFactory" )
			.getInstance( javaCast( "string", "RSA" ) )
			.generatePrivate( privateKeySpec )
		;

	}


	/**
	* I strip the plain-text key delimiters, to isolate the key content.
	*
	* @keyText I am the plain-text key input.
	* @output false
	*/
	private string function stripKeyDelimiters( required string keyText ) {

		// Strips out the leading / trailing boundaries:
		keyText = reReplace( keyText, "-----(BEGIN|END)[^\r\n]+", "", "all" );

		return( trim( keyText ) );

	}

}