[crypto] Use private data field for digest algorithms

Following the example of commit 25072c1 ("[crypto] Use private data
field for key exchange algorithms"), extend the definition of a digest
algorithm to include an opaque private data field.

Signed-off-by: Michael Brown <mcb30@ipxe.org>

src/crypto/crypto_null.c

@@ -34,16 +34,19 @@ FILE_SECBOOT ( PERMITTED );
 #include <errno.h>
 #include <ipxe/crypto.h>
 
-void digest_null_init ( void *ctx __unused ) {
+void digest_null_init ( struct digest_algorithm *digest __unused,
+			void *ctx __unused ) {
 	/* Do nothing */
 }
 
-void digest_null_update ( void *ctx __unused, const void *src __unused,
+void digest_null_update ( struct digest_algorithm *digest __unused,
+			  void *ctx __unused, const void *src __unused,
 			  size_t len __unused ) {
 	/* Do nothing */
 }
 
-void digest_null_final ( void *ctx __unused, void *out __unused ) {
+void digest_null_final ( struct digest_algorithm *digest __unused,
+			 void *ctx __unused, void *out __unused ) {
 	/* Do nothing */
 }
 

src/crypto/md4.c

@@ -121,9 +121,10 @@ static struct md4_step md4_steps[4] = {
 /**
  * Initialise MD4 algorithm
  *
+ * @v digest		Digest algorithm
  * @v ctx		MD4 context
  */
-static void md4_init ( void *ctx ) {
+static void md4_init ( struct digest_algorithm *digest __unused, void *ctx ) {
 	struct md4_context *context = ctx;
 
 	context->ddd.dd.digest.h[0] = cpu_to_le32 ( 0x67452301 );
@@ -206,11 +207,13 @@ static void md4_digest ( struct md4_context *context ) {
 /**
  * Accumulate data with MD4 algorithm
  *
+ * @v digest		Digest algorithm
  * @v ctx		MD4 context
  * @v data		Data
  * @v len		Length of data
  */
-static void md4_update ( void *ctx, const void *data, size_t len ) {
+static void md4_update ( struct digest_algorithm *digest __unused, void *ctx,
+			 const void *data, size_t len ) {
 	struct md4_context *context = ctx;
 	const uint8_t *byte = data;
 	size_t offset;
@@ -230,10 +233,12 @@ static void md4_update ( void *ctx, const void *data, size_t len ) {
 /**
  * Generate MD4 digest
  *
+ * @v digest		Digest algorithm
  * @v ctx		MD4 context
  * @v out		Output buffer
  */
-static void md4_final ( void *ctx, void *out ) {
+static void md4_final ( struct digest_algorithm *digest, void *ctx,
+			void *out ) {
 	struct md4_context *context = ctx;
 	uint64_t len_bits;
 	uint8_t pad;
@@ -244,13 +249,13 @@ static void md4_final ( void *ctx, void *out ) {
 	/* Pad with a single "1" bit followed by as many "0" bits as required */
 	pad = 0x80;
 	do {
-		md4_update ( ctx, &pad, sizeof ( pad ) );
+		md4_update ( digest, ctx, &pad, sizeof ( pad ) );
 		pad = 0x00;
 	} while ( ( context->len % sizeof ( context->ddd.dd.data ) ) !=
 		  offsetof ( typeof ( context->ddd.dd.data ), final.len ) );
 
 	/* Append length (in bits) */
-	md4_update ( ctx, &len_bits, sizeof ( len_bits ) );
+	md4_update ( digest, ctx, &len_bits, sizeof ( len_bits ) );
 	assert ( ( context->len % sizeof ( context->ddd.dd.data ) ) == 0 );
 
 	/* Copy out final digest */

src/crypto/md5.c

@@ -143,9 +143,10 @@ static struct md5_step md5_steps[4] = {
 /**
  * Initialise MD5 algorithm
  *
+ * @v digest		Digest algorithm
  * @v ctx		MD5 context
  */
-static void md5_init ( void *ctx ) {
+static void md5_init ( struct digest_algorithm *digest __unused, void *ctx ) {
 	struct md5_context *context = ctx;
 
 	context->ddd.dd.digest.h[0] = cpu_to_le32 ( 0x67452301 );
@@ -231,11 +232,13 @@ static void md5_digest ( struct md5_context *context ) {
 /**
  * Accumulate data with MD5 algorithm
  *
+ * @v digest		Digest algorithm
  * @v ctx		MD5 context
  * @v data		Data
  * @v len		Length of data
  */
-static void md5_update ( void *ctx, const void *data, size_t len ) {
+static void md5_update ( struct digest_algorithm *digest __unused, void *ctx,
+			 const void *data, size_t len ) {
 	struct md5_context *context = ctx;
 	const uint8_t *byte = data;
 	size_t offset;
@@ -255,10 +258,12 @@ static void md5_update ( void *ctx, const void *data, size_t len ) {
 /**
  * Generate MD5 digest
  *
+ * @v digest		Digest algorithm
  * @v ctx		MD5 context
  * @v out		Output buffer
  */
-static void md5_final ( void *ctx, void *out ) {
+static void md5_final ( struct digest_algorithm *digest, void *ctx,
+			void *out ) {
 	struct md5_context *context = ctx;
 	uint64_t len_bits;
 	uint8_t pad;
@@ -269,13 +274,13 @@ static void md5_final ( void *ctx, void *out ) {
 	/* Pad with a single "1" bit followed by as many "0" bits as required */
 	pad = 0x80;
 	do {
-		md5_update ( ctx, &pad, sizeof ( pad ) );
+		md5_update ( digest, ctx, &pad, sizeof ( pad ) );
 		pad = 0x00;
 	} while ( ( context->len % sizeof ( context->ddd.dd.data ) ) !=
 		  offsetof ( typeof ( context->ddd.dd.data ), final.len ) );
 
 	/* Append length (in bits) */
-	md5_update ( ctx, &len_bits, sizeof ( len_bits ) );
+	md5_update ( digest, ctx, &len_bits, sizeof ( len_bits ) );
 	assert ( ( context->len % sizeof ( context->ddd.dd.data ) ) == 0 );
 
 	/* Copy out final digest */

src/crypto/md5_sha1.c

@@ -36,9 +36,11 @@ FILE_SECBOOT ( PERMITTED );
 /**
  * Initialise MD5+SHA1 algorithm
  *
+ * @v digest		Digest algorithm
  * @v ctx		MD5+SHA1 context
  */
-static void md5_sha1_init ( void *ctx ) {
+static void md5_sha1_init ( struct digest_algorithm *digest __unused,
+			    void *ctx ) {
 	struct md5_sha1_context *context = ctx;
 
 	digest_init ( &md5_algorithm, context->md5 );
@@ -48,11 +50,13 @@ static void md5_sha1_init ( void *ctx ) {
 /**
  * Accumulate data with MD5+SHA1 algorithm
  *
+ * @v digest		Digest algorithm
  * @v ctx		MD5+SHA1 context
  * @v data		Data
  * @v len		Length of data
  */
-static void md5_sha1_update ( void *ctx, const void *data, size_t len ) {
+static void md5_sha1_update ( struct digest_algorithm *digest __unused,
+			      void *ctx, const void *data, size_t len ) {
 	struct md5_sha1_context *context = ctx;
 
 	digest_update ( &md5_algorithm, context->md5, data, len );
@@ -62,15 +66,17 @@ static void md5_sha1_update ( void *ctx, const void *data, size_t len ) {
 /**
  * Generate MD5+SHA1 digest
  *
+ * @v digest		Digest algorithm
  * @v ctx		MD5+SHA1 context
  * @v out		Output buffer
  */
-static void md5_sha1_final ( void *ctx, void *out ) {
+static void md5_sha1_final ( struct digest_algorithm *digest __unused,
+			     void *ctx, void *out ) {
 	struct md5_sha1_context *context = ctx;
-	struct md5_sha1_digest *digest = out;
+	struct md5_sha1_digest *output = out;
 
-	digest_final ( &md5_algorithm, context->md5, digest->md5 );
-	digest_final ( &sha1_algorithm, context->sha1, digest->sha1 );
+	digest_final ( &md5_algorithm, context->md5, output->md5 );
+	digest_final ( &sha1_algorithm, context->sha1, output->sha1 );
 }
 
 /** Hybrid MD5+SHA1 digest algorithm */

src/crypto/sha1.c

@@ -109,9 +109,10 @@ static struct sha1_step sha1_steps[4] = {
 /**
  * Initialise SHA-1 algorithm
  *
+ * @v digest		Digest algorithm
  * @v ctx		SHA-1 context
  */
-static void sha1_init ( void *ctx ) {
+static void sha1_init ( struct digest_algorithm *digest __unused, void *ctx ) {
 	struct sha1_context *context = ctx;
 
 	context->ddd.dd.digest.h[0] = cpu_to_be32 ( 0x67452301 );
@@ -202,11 +203,13 @@ static void sha1_digest ( struct sha1_context *context ) {
 /**
  * Accumulate data with SHA-1 algorithm
  *
+ * @v digest		Digest algorithm
  * @v ctx		SHA-1 context
  * @v data		Data
  * @v len		Length of data
  */
-static void sha1_update ( void *ctx, const void *data, size_t len ) {
+static void sha1_update ( struct digest_algorithm *digest __unused,
+			  void *ctx, const void *data, size_t len ) {
 	struct sha1_context *context = ctx;
 	const uint8_t *byte = data;
 	size_t offset;
@@ -226,10 +229,12 @@ static void sha1_update ( void *ctx, const void *data, size_t len ) {
 /**
  * Generate SHA-1 digest
  *
+ * @v digest		Digest algorithm
  * @v ctx		SHA-1 context
  * @v out		Output buffer
  */
-static void sha1_final ( void *ctx, void *out ) {
+static void sha1_final ( struct digest_algorithm *digest, void *ctx,
+			 void *out ) {
 	struct sha1_context *context = ctx;
 	uint64_t len_bits;
 	uint8_t pad;
@@ -240,13 +245,13 @@ static void sha1_final ( void *ctx, void *out ) {
 	/* Pad with a single "1" bit followed by as many "0" bits as required */
 	pad = 0x80;
 	do {
-		sha1_update ( ctx, &pad, sizeof ( pad ) );
+		sha1_update ( digest, ctx, &pad, sizeof ( pad ) );
 		pad = 0x00;
 	} while ( ( context->len % sizeof ( context->ddd.dd.data ) ) !=
 		  offsetof ( typeof ( context->ddd.dd.data ), final.len ) );
 
 	/* Append length (in bits) */
-	sha1_update ( ctx, &len_bits, sizeof ( len_bits ) );
+	sha1_update ( digest, ctx, &len_bits, sizeof ( len_bits ) );
 	assert ( ( context->len % sizeof ( context->ddd.dd.data ) ) == 0 );
 
 	/* Copy out final digest */

src/crypto/sha224.c

@@ -49,24 +49,6 @@ static const struct sha256_digest sha224_init_digest = {
 	},
 };
 
-/**
- * Initialise SHA-224 algorithm
- *
- * @v ctx		SHA-224 context
- */
-static void sha224_init ( void *ctx ) {
-	struct sha256_context *context = ctx;
-
-	sha256_family_init ( context, &sha224_init_digest, SHA224_DIGEST_SIZE );
-}
-
 /** SHA-224 algorithm */
-struct digest_algorithm sha224_algorithm = {
-	.name		= "sha224",
-	.ctxsize	= sizeof ( struct sha256_context ),
-	.blocksize	= sizeof ( union sha256_block ),
-	.digestsize	= SHA224_DIGEST_SIZE,
-	.init		= sha224_init,
-	.update		= sha256_update,
-	.final		= sha256_final,
-};
+SHA256_ALGORITHM ( sha224, sha224_algorithm, SHA224_DIGEST_SIZE,
+		   &sha224_init_digest );

src/crypto/sha256.c

@@ -83,33 +83,19 @@ static const struct sha256_digest sha256_init_digest = {
 	},
 };
 
-/**
- * Initialise SHA-256 family algorithm
- *
- * @v context		SHA-256 context
- * @v init		Initial digest values
- * @v digestsize	Digest size
- */
-void sha256_family_init ( struct sha256_context *context,
-			  const struct sha256_digest *init,
-			  size_t digestsize ) {
-
-	context->len = 0;
-	context->digestsize = digestsize;
-	memcpy ( &context->ddd.dd.digest, init,
-		 sizeof ( context->ddd.dd.digest ) );
-}
-
 /**
  * Initialise SHA-256 algorithm
  *
+ * @v digest		Digest algorithm
  * @v ctx		SHA-256 context
  */
-static void sha256_init ( void *ctx ) {
+void sha256_init ( struct digest_algorithm *digest, void *ctx ) {
+	struct sha256_algorithm *sha = digest->priv;
 	struct sha256_context *context = ctx;
 
-	sha256_family_init ( context, &sha256_init_digest,
-			     sizeof ( struct sha256_digest ) );
+	context->len = 0;
+	memcpy ( &context->ddd.dd.digest, sha->init,
+		 sizeof ( context->ddd.dd.digest ) );
 }
 
 /**
@@ -210,11 +196,13 @@ static void sha256_digest ( struct sha256_context *context ) {
 /**
  * Accumulate data with SHA-256 algorithm
  *
+ * @v digest		Digest algorithm
  * @v ctx		SHA-256 context
  * @v data		Data
  * @v len		Length of data
  */
-void sha256_update ( void *ctx, const void *data, size_t len ) {
+void sha256_update ( struct digest_algorithm *digest __unused, void *ctx,
+		     const void *data, size_t len ) {
 	struct sha256_context *context = ctx;
 	const uint8_t *byte = data;
 	size_t offset;
@@ -234,10 +222,11 @@ void sha256_update ( void *ctx, const void *data, size_t len ) {
 /**
  * Generate SHA-256 digest
  *
+ * @v digest		Digest algorithm
  * @v ctx		SHA-256 context
  * @v out		Output buffer
  */
-void sha256_final ( void *ctx, void *out ) {
+void sha256_final ( struct digest_algorithm *digest, void *ctx, void *out ) {
 	struct sha256_context *context = ctx;
 	uint64_t len_bits;
 	uint8_t pad;
@@ -248,26 +237,19 @@ void sha256_final ( void *ctx, void *out ) {
 	/* Pad with a single "1" bit followed by as many "0" bits as required */
 	pad = 0x80;
 	do {
-		sha256_update ( ctx, &pad, sizeof ( pad ) );
+		sha256_update ( digest, ctx, &pad, sizeof ( pad ) );
 		pad = 0x00;
 	} while ( ( context->len % sizeof ( context->ddd.dd.data ) ) !=
 		  offsetof ( typeof ( context->ddd.dd.data ), final.len ) );
 
 	/* Append length (in bits) */
-	sha256_update ( ctx, &len_bits, sizeof ( len_bits ) );
+	sha256_update ( digest, ctx, &len_bits, sizeof ( len_bits ) );
 	assert ( ( context->len % sizeof ( context->ddd.dd.data ) ) == 0 );
 
 	/* Copy out final digest */
-	memcpy ( out, &context->ddd.dd.digest, context->digestsize );
+	memcpy ( out, &context->ddd.dd.digest, digest->digestsize );
 }
 
 /** SHA-256 algorithm */
-struct digest_algorithm sha256_algorithm = {
-	.name		= "sha256",
-	.ctxsize	= sizeof ( struct sha256_context ),
-	.blocksize	= sizeof ( union sha256_block ),
-	.digestsize	= sizeof ( struct sha256_digest ),
-	.init		= sha256_init,
-	.update		= sha256_update,
-	.final		= sha256_final,
-};
+SHA256_ALGORITHM ( sha256, sha256_algorithm, SHA256_DIGEST_SIZE,
+		   &sha256_init_digest );

src/crypto/sha384.c

@@ -49,24 +49,6 @@ static const struct sha512_digest sha384_init_digest = {
 	},
 };
 
-/**
- * Initialise SHA-384 algorithm
- *
- * @v ctx		SHA-384 context
- */
-static void sha384_init ( void *ctx ) {
-	struct sha512_context *context = ctx;
-
-	sha512_family_init ( context, &sha384_init_digest, SHA384_DIGEST_SIZE );
-}
-
 /** SHA-384 algorithm */
-struct digest_algorithm sha384_algorithm = {
-	.name		= "sha384",
-	.ctxsize	= sizeof ( struct sha512_context ),
-	.blocksize	= sizeof ( union sha512_block ),
-	.digestsize	= SHA384_DIGEST_SIZE,
-	.init		= sha384_init,
-	.update		= sha512_update,
-	.final		= sha512_final,
-};
+SHA512_ALGORITHM ( sha384, sha384_algorithm, SHA384_DIGEST_SIZE,
+		   &sha384_init_digest );

src/crypto/sha512.c

@@ -99,33 +99,19 @@ static const struct sha512_digest sha512_init_digest = {
 	},
 };
 
-/**
- * Initialise SHA-512 family algorithm
- *
- * @v context		SHA-512 context
- * @v init		Initial digest values
- * @v digestsize	Digest size
- */
-void sha512_family_init ( struct sha512_context *context,
-			  const struct sha512_digest *init,
-			  size_t digestsize ) {
-
-	context->len = 0;
-	context->digestsize = digestsize;
-	memcpy ( &context->ddq.dd.digest, init,
-		 sizeof ( context->ddq.dd.digest ) );
-}
-
 /**
  * Initialise SHA-512 algorithm
  *
+ * @v digest		Digest algorithm
  * @v ctx		SHA-512 context
  */
-static void sha512_init ( void *ctx ) {
+void sha512_init ( struct digest_algorithm *digest, void *ctx ) {
+	const struct sha512_algorithm *sha = digest->priv;
 	struct sha512_context *context = ctx;
 
-	sha512_family_init ( context, &sha512_init_digest,
-			     sizeof ( struct sha512_digest ) );
+	context->len = 0;
+	memcpy ( &context->ddq.dd.digest, sha->init,
+		 sizeof ( context->ddq.dd.digest ) );
 }
 
 /**
@@ -227,11 +213,13 @@ static void sha512_digest ( struct sha512_context *context ) {
 /**
  * Accumulate data with SHA-512 algorithm
  *
+ * @v digest		Digest
  * @v ctx		SHA-512 context
  * @v data		Data
  * @v len		Length of data
  */
-void sha512_update ( void *ctx, const void *data, size_t len ) {
+void sha512_update ( struct digest_algorithm *digest __unused, void *ctx,
+		     const void *data, size_t len ) {
 	struct sha512_context *context = ctx;
 	const uint8_t *byte = data;
 	size_t offset;
@@ -251,10 +239,11 @@ void sha512_update ( void *ctx, const void *data, size_t len ) {
 /**
  * Generate SHA-512 digest
  *
+ * @v digest		Digest algorithm
  * @v ctx		SHA-512 context
  * @v out		Output buffer
  */
-void sha512_final ( void *ctx, void *out ) {
+void sha512_final ( struct digest_algorithm *digest, void *ctx, void *out ) {
 	struct sha512_context *context = ctx;
 	uint64_t len_bits_hi;
 	uint64_t len_bits_lo;
@@ -267,27 +256,20 @@ void sha512_final ( void *ctx, void *out ) {
 	/* Pad with a single "1" bit followed by as many "0" bits as required */
 	pad = 0x80;
 	do {
-		sha512_update ( ctx, &pad, sizeof ( pad ) );
+		sha512_update ( digest, ctx, &pad, sizeof ( pad ) );
 		pad = 0x00;
 	} while ( ( context->len % sizeof ( context->ddq.dd.data ) ) !=
 		  offsetof ( typeof ( context->ddq.dd.data ), final.len_hi ) );
 
 	/* Append length (in bits) */
-	sha512_update ( ctx, &len_bits_hi, sizeof ( len_bits_hi ) );
-	sha512_update ( ctx, &len_bits_lo, sizeof ( len_bits_lo ) );
+	sha512_update ( digest, ctx, &len_bits_hi, sizeof ( len_bits_hi ) );
+	sha512_update ( digest, ctx, &len_bits_lo, sizeof ( len_bits_lo ) );
 	assert ( ( context->len % sizeof ( context->ddq.dd.data ) ) == 0 );
 
 	/* Copy out final digest */
-	memcpy ( out, &context->ddq.dd.digest, context->digestsize );
+	memcpy ( out, &context->ddq.dd.digest, digest->digestsize );
 }
 
 /** SHA-512 algorithm */
-struct digest_algorithm sha512_algorithm = {
-	.name		= "sha512",
-	.ctxsize	= sizeof ( struct sha512_context ),
-	.blocksize	= sizeof ( union sha512_block ),
-	.digestsize	= sizeof ( struct sha512_digest ),
-	.init		= sha512_init,
-	.update		= sha512_update,
-	.final		= sha512_final,
-};
+SHA512_ALGORITHM ( sha512, sha512_algorithm, SHA512_DIGEST_SIZE,
+		   &sha512_init_digest );

src/crypto/sha512_224.c

@@ -49,25 +49,6 @@ static const struct sha512_digest sha512_224_init_digest = {
 	},
 };
 
-/**
- * Initialise SHA-512/224 algorithm
- *
- * @v ctx		SHA-512/224 context
- */
-static void sha512_224_init ( void *ctx ) {
-	struct sha512_context *context = ctx;
-
-	sha512_family_init ( context, &sha512_224_init_digest,
-			     SHA512_224_DIGEST_SIZE );
-}
-
 /** SHA-512/224 algorithm */
-struct digest_algorithm sha512_224_algorithm = {
-	.name		= "sha512/224",
-	.ctxsize	= sizeof ( struct sha512_context ),
-	.blocksize	= sizeof ( union sha512_block ),
-	.digestsize	= SHA512_224_DIGEST_SIZE,
-	.init		= sha512_224_init,
-	.update		= sha512_update,
-	.final		= sha512_final,
-};
+SHA512_ALGORITHM ( sha512_224, sha512_224_algorithm, SHA512_224_DIGEST_SIZE,
+		   &sha512_224_init_digest );

src/crypto/sha512_256.c

@@ -49,25 +49,6 @@ static const struct sha512_digest sha512_256_init_digest = {
 	},
 };
 
-/**
- * Initialise SHA-512/256 algorithm
- *
- * @v ctx		SHA-512/256 context
- */
-static void sha512_256_init ( void *ctx ) {
-	struct sha512_context *context = ctx;
-
-	sha512_family_init ( context, &sha512_256_init_digest,
-			     SHA512_256_DIGEST_SIZE );
-}
-
 /** SHA-512/256 algorithm */
-struct digest_algorithm sha512_256_algorithm = {
-	.name		= "sha512/256",
-	.ctxsize	= sizeof ( struct sha512_context ),
-	.blocksize	= sizeof ( union sha512_block ),
-	.digestsize	= SHA512_256_DIGEST_SIZE,
-	.init		= sha512_256_init,
-	.update		= sha512_update,
-	.final		= sha512_final,
-};
+SHA512_ALGORITHM ( sha512_256, sha512_256_algorithm, SHA512_256_DIGEST_SIZE,
+		   &sha512_256_init_digest );

src/include/ipxe/crypto.h

@@ -27,24 +27,31 @@ struct digest_algorithm {
 	size_t digestsize;
 	/** Initialise digest
 	 *
+	 * @v digest		Digest algorithm
 	 * @v ctx		Context
 	 */
-	void ( * init ) ( void *ctx );
+	void ( * init ) ( struct digest_algorithm *digest, void *ctx );
 	/** Update digest with new data
 	 *
+	 * @v digest		Digest algorithm
 	 * @v ctx		Context
 	 * @v src		Data to digest
 	 * @v len		Length of data
 	 *
 	 * @v len is not necessarily a multiple of @c blocksize.
 	 */
-	void ( * update ) ( void *ctx, const void *src, size_t len );
+	void ( * update ) ( struct digest_algorithm *digest, void *ctx,
+			    const void *src, size_t len );
 	/** Finalise digest
 	 *
+	 * @v digest		Digest algorithm
 	 * @v ctx		Context
 	 * @v out		Buffer for digest output
 	 */
-	void ( * final ) ( void *ctx, void *out );
+	void ( * final ) ( struct digest_algorithm *digest, void *ctx,
+			   void *out );
+	/** Algorithm private data */
+	void *priv;
 };
 
 /** A cipher algorithm */
@@ -259,18 +266,18 @@ struct elliptic_curve {
 
 static inline __attribute__ (( always_inline )) void
 digest_init ( struct digest_algorithm *digest, void *ctx ) {
-	digest->init ( ctx );
+	digest->init ( digest, ctx );
 }
 
 static inline __attribute__ (( always_inline )) void
 digest_update ( struct digest_algorithm *digest, void *ctx,
 		const void *data, size_t len ) {
-	digest->update ( ctx, data, len );
+	digest->update ( digest, ctx, data, len );
 }
 
 static inline __attribute__ (( always_inline )) void
 digest_final ( struct digest_algorithm *digest, void *ctx, void *out ) {
-	digest->final ( ctx, out );
+	digest->final ( digest, ctx, out );
 }
 
 static inline __attribute__ (( always_inline )) int
@@ -389,9 +396,11 @@ elliptic_add ( struct elliptic_curve *curve, const void *addend,
 	return curve->add ( curve, addend, augend, result );
 }
 
-extern void digest_null_init ( void *ctx );
-extern void digest_null_update ( void *ctx, const void *src, size_t len );
-extern void digest_null_final ( void *ctx, void *out );
+extern void digest_null_init ( struct digest_algorithm *digest, void *ctx );
+extern void digest_null_update ( struct digest_algorithm *digest, void *ctx,
+				 const void *src, size_t len );
+extern void digest_null_final ( struct digest_algorithm *digest, void *ctx,
+				void *out );
 
 extern int cipher_null_setkey ( void *ctx, const void *key, size_t keylen );
 extern void cipher_null_setiv ( void *ctx, const void *iv, size_t ivlen );

src/include/ipxe/sha256.h

@@ -62,12 +62,16 @@ union sha256_digest_data_dwords {
 struct sha256_context {
 	/** Amount of accumulated data */
 	size_t len;
-	/** Digest size */
-	size_t digestsize;
 	/** Digest and accumulated data */
 	union sha256_digest_data_dwords ddd;
 } __attribute__ (( packed ));
 
+/** A SHA-256 family algorithm */
+struct sha256_algorithm {
+	/** Initial digest values */
+	const struct sha256_digest *init;
+};
+
 /** SHA-256 context size */
 #define SHA256_CTX_SIZE sizeof ( struct sha256_context )
 
@@ -80,11 +84,27 @@ struct sha256_context {
 /** SHA-224 digest size */
 #define SHA224_DIGEST_SIZE ( SHA256_DIGEST_SIZE * 224 / 256 )
 
-extern void sha256_family_init ( struct sha256_context *context,
-				 const struct sha256_digest *init,
-				 size_t digestsize );
-extern void sha256_update ( void *ctx, const void *data, size_t len );
-extern void sha256_final ( void *ctx, void *out );
+extern void sha256_init ( struct digest_algorithm *digest, void *ctx );
+extern void sha256_update ( struct digest_algorithm *digest, void *ctx,
+			    const void *data, size_t len );
+extern void sha256_final ( struct digest_algorithm *digest, void *ctx,
+			   void *out );
+
+/** Define a SHA-256 family digest algorithm */
+#define SHA256_ALGORITHM( _name, _digest, _digestsize, _init )		\
+	static struct sha256_algorithm _name ## _sha256 = {		\
+		.init		= (_init),				\
+	};								\
+	struct digest_algorithm _digest = {				\
+		.name		= #_name,				\
+		.ctxsize	= sizeof ( struct sha256_context ),	\
+		.blocksize	= sizeof ( union sha256_block ),	\
+		.digestsize	= (_digestsize),			\
+		.init		= sha256_init,				\
+		.update		= sha256_update,			\
+		.final		= sha256_final,				\
+		.priv		= &_name ## _sha256,			\
+	}
 
 extern struct digest_algorithm sha256_algorithm;
 extern struct digest_algorithm sha224_algorithm;

src/include/ipxe/sha512.h

@@ -64,12 +64,16 @@ union sha512_digest_data_qwords {
 struct sha512_context {
 	/** Amount of accumulated data */
 	size_t len;
-	/** Digest size */
-	size_t digestsize;
 	/** Digest and accumulated data */
 	union sha512_digest_data_qwords ddq;
 } __attribute__ (( packed ));
 
+/** A SHA-512 family algorithm */
+struct sha512_algorithm {
+	/** Initial digest values */
+	const struct sha512_digest *init;
+};
+
 /** SHA-512 context size */
 #define SHA512_CTX_SIZE sizeof ( struct sha512_context )
 
@@ -88,11 +92,27 @@ struct sha512_context {
 /** SHA-512/224 digest size */
 #define SHA512_224_DIGEST_SIZE ( SHA512_DIGEST_SIZE * 224 / 512 )
 
-extern void sha512_family_init ( struct sha512_context *context,
-				 const struct sha512_digest *init,
-				 size_t digestsize );
-extern void sha512_update ( void *ctx, const void *data, size_t len );
-extern void sha512_final ( void *ctx, void *out );
+extern void sha512_init ( struct digest_algorithm *digest, void *ctx );
+extern void sha512_update ( struct digest_algorithm *digest, void *ctx,
+			    const void *data, size_t len );
+extern void sha512_final ( struct digest_algorithm *digest, void *ctx,
+			   void *out );
+
+/** Define a SHA-512 family digest algorithm */
+#define SHA512_ALGORITHM( _name, _digest, _digestsize, _init )		\
+	static struct sha512_algorithm _name ## _sha512 = {		\
+		.init		= (_init),				\
+	};								\
+	struct digest_algorithm _digest = {				\
+		.name		= #_name,				\
+		.ctxsize	= sizeof ( struct sha512_context ),	\
+		.blocksize	= sizeof ( union sha512_block ),	\
+		.digestsize	= (_digestsize),			\
+		.init		= sha512_init,				\
+		.update		= sha512_update,			\
+		.final		= sha512_final,				\
+		.priv		= &_name ## _sha512,			\
+	}
 
 extern struct digest_algorithm sha512_algorithm;
 extern struct digest_algorithm sha384_algorithm;