[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>

diff --git a/src/crypto/crypto_null.c b/src/crypto/crypto_null.c
index 687083be94c05c490981b9042b1bfbb82e8fe046..93580bb8852c4b46432091e6f178fa3f0ed11157 100644 (file)
--- a/src/crypto/crypto_null.c
+++ b/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 */
 }
 

diff --git a/src/crypto/md4.c b/src/crypto/md4.c
index a9184aa57c533cfdb0415090882da812921c0d79..e644bb195f524ae29d902a160536c6fb788a7d82 100644 (file)
--- a/src/crypto/md4.c
+++ b/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 */

diff --git a/src/crypto/md5.c b/src/crypto/md5.c
index 9418b006c925552ce3b2c43b97ec378a7d0de606..06d4c95289e6606a20d58d38805b32b5a1cac7fc 100644 (file)
--- a/src/crypto/md5.c
+++ b/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 */

diff --git a/src/crypto/md5_sha1.c b/src/crypto/md5_sha1.c
index b47a6c352522c4f8cd23542efa4aeaf836384718..da12b79a9a794b7b06da6c790a83f4322f0fdd0d 100644 (file)
--- a/src/crypto/md5_sha1.c
+++ b/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 */

diff --git a/src/crypto/sha1.c b/src/crypto/sha1.c
index 023becec6ac1b1ace65c4158dc8ed2cd6c29766e..d2b3c62ea614e1d518b486a93a401c0531de8837 100644 (file)
--- a/src/crypto/sha1.c
+++ b/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 */

diff --git a/src/crypto/sha224.c b/src/crypto/sha224.c
index 7e0cfd34eccbc68d218953eaf6c204e13a926aff..4eb55051ee5e4aea631f3bbcf0432e212995b9c3 100644 (file)
--- a/src/crypto/sha224.c
+++ b/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 );

diff --git a/src/crypto/sha256.c b/src/crypto/sha256.c
index 742393612604135e0280b840830d47e2b81ce9d3..9d87ca10a394c2b19d860de3ecd4fe082ceaaaec 100644 (file)
--- a/src/crypto/sha256.c
+++ b/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 );

diff --git a/src/crypto/sha384.c b/src/crypto/sha384.c
index 3e5e98a31bd98349578c63939921da343d47da0c..fd624cc5176896d98b36a12f7e2ef50dcc2ec515 100644 (file)
--- a/src/crypto/sha384.c
+++ b/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 );

diff --git a/src/crypto/sha512.c b/src/crypto/sha512.c
index 724cb71a59b73fc4e34e317b749d8b597b1d4ff2..5f6276095a0cfbd260152b1b5d444773696974b3 100644 (file)
--- a/src/crypto/sha512.c
+++ b/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 );

diff --git a/src/crypto/sha512_224.c b/src/crypto/sha512_224.c
index 3b256a3b98de803d95aac024bf7c78b43958e623..d9e0eb18d076c8f6967a7bc9bd09d8564643fd50 100644 (file)
--- a/src/crypto/sha512_224.c
+++ b/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 );

diff --git a/src/crypto/sha512_256.c b/src/crypto/sha512_256.c
index 04df3f5bcba5d2c334ce6e65fd6c887cc172840c..c8fd1a47fc29a05e3c6a43e4be9621bd736901cd 100644 (file)
--- a/src/crypto/sha512_256.c
+++ b/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 );

diff --git a/src/include/ipxe/crypto.h b/src/include/ipxe/crypto.h
index d27cba2937518c858fc44f06f04bee0abc3f1315..bf5bcc811d178f12f60977c82b550777725b038e 100644 (file)
--- a/src/include/ipxe/crypto.h
+++ b/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 );

diff --git a/src/include/ipxe/sha256.h b/src/include/ipxe/sha256.h
index e8a81b889b6a4712f9a9453ec83c2763ff9eade9..9f8864806bf73f3be94a10e605cf27e1e49fff1c 100644 (file)
--- a/src/include/ipxe/sha256.h
+++ b/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;

diff --git a/src/include/ipxe/sha512.h b/src/include/ipxe/sha512.h
index 74cdb413c98bd88272a2d6f1da7ff634d0fdf02e..e7ac87389dd662e5c9723e47357872d27b5e7bd6 100644 (file)
--- a/src/include/ipxe/sha512.h
+++ b/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;