Generalise digest_algorithm to crypto_algorithm.
authorMichael Brown <mcb30@etherboot.org>
Tue, 30 Jan 2007 14:55:17 +0000 (14:55 +0000)
committerMichael Brown <mcb30@etherboot.org>
Tue, 30 Jan 2007 14:55:17 +0000 (14:55 +0000)
src/crypto/chap.c
src/crypto/md5.c
src/include/gpxe/chap.h
src/include/gpxe/crypto.h
src/include/gpxe/md5.h

index 6bebaca..2f62456 100644 (file)
@@ -42,7 +42,7 @@
  * eventually be freed by a call to chap_finish().
  */
 int chap_init ( struct chap_challenge *chap,
  * eventually be freed by a call to chap_finish().
  */
 int chap_init ( struct chap_challenge *chap,
-               struct digest_algorithm *digest ) {
+               struct crypto_algorithm *digest ) {
        size_t state_len;
        void *state;
 
        size_t state_len;
        void *state;
 
@@ -52,7 +52,7 @@ int chap_init ( struct chap_challenge *chap,
 
        DBG ( "CHAP %p initialising with %s digest\n", chap, digest->name );
 
 
        DBG ( "CHAP %p initialising with %s digest\n", chap, digest->name );
 
-       state_len = ( digest->context_len + digest->digest_len );
+       state_len = ( digest->ctxsize + digest->digestsize );
        state = malloc ( state_len );
        if ( ! state ) {
                DBG ( "CHAP %p could not allocate %d bytes for state\n",
        state = malloc ( state_len );
        if ( ! state ) {
                DBG ( "CHAP %p could not allocate %d bytes for state\n",
@@ -62,9 +62,9 @@ int chap_init ( struct chap_challenge *chap,
        
        chap->digest = digest;
        chap->digest_context = state;
        
        chap->digest = digest;
        chap->digest_context = state;
-       chap->response = ( state + digest->context_len );
-       chap->response_len = digest->digest_len;
-       chap->digest->init ( chap->digest_context );
+       chap->response = ( state + digest->ctxsize );
+       chap->response_len = digest->digestsize;
+       digest_init ( chap->digest, chap->digest_context );
        return 0;
 }
 
        return 0;
 }
 
@@ -83,7 +83,7 @@ void chap_update ( struct chap_challenge *chap, const void *data,
        if ( ! chap->digest )
                return;
 
        if ( ! chap->digest )
                return;
 
-       chap->digest->update ( chap->digest_context, data, len );
+       digest_update ( chap->digest, chap->digest_context, data, len );
 }
 
 /**
 }
 
 /**
@@ -104,7 +104,7 @@ void chap_respond ( struct chap_challenge *chap ) {
        if ( ! chap->digest )
                return;
 
        if ( ! chap->digest )
                return;
 
-       chap->digest->finish ( chap->digest_context, chap->response );
+       digest_final ( chap->digest, chap->digest_context, chap->response );
 }
 
 /**
 }
 
 /**
index 182b625..6064233 100644 (file)
@@ -177,7 +177,8 @@ static void md5_init(void *context)
        mctx->byte_count = 0;
 }
 
        mctx->byte_count = 0;
 }
 
-static void md5_update(void *context, const void *data, size_t len)
+static void md5_update(void *context, const void *data, void *dst __unused,
+                      size_t len)
 {
        struct md5_ctx *mctx = context;
        const u32 avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f);
 {
        struct md5_ctx *mctx = context;
        const u32 avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f);
@@ -207,7 +208,7 @@ static void md5_update(void *context, const void *data, size_t len)
        memcpy(mctx->block, data, len);
 }
 
        memcpy(mctx->block, data, len);
 }
 
-static void md5_finish(void *context, void *out)
+static void md5_final(void *context, void *out)
 {
        struct md5_ctx *mctx = context;
        const unsigned int offset = mctx->byte_count & 0x3f;
 {
        struct md5_ctx *mctx = context;
        const unsigned int offset = mctx->byte_count & 0x3f;
@@ -233,11 +234,12 @@ static void md5_finish(void *context, void *out)
        memset(mctx, 0, sizeof(*mctx));
 }
 
        memset(mctx, 0, sizeof(*mctx));
 }
 
-struct digest_algorithm md5_algorithm = {
+struct crypto_algorithm md5_algorithm = {
        .name           = "md5",
        .name           = "md5",
-       .context_len    = sizeof ( struct md5_ctx ),
-       .digest_len     = MD5_DIGEST_SIZE,
+       .ctxsize        = sizeof ( struct md5_ctx ),
+       .blocksize      = 1,
+       .digestsize     = MD5_DIGEST_SIZE,
        .init           = md5_init,
        .init           = md5_init,
-       .update         = md5_update,
-       .finish         = md5_finish,
+       .encode         = md5_update,
+       .final          = md5_final,
 };
 };
index c85d92f..0ea7ac5 100644 (file)
 #include <stdint.h>
 #include <gpxe/md5.h>
 
 #include <stdint.h>
 #include <gpxe/md5.h>
 
-struct digest_algorithm;
+struct crypto_algorithm;
 
 /** A CHAP challenge/response */
 struct chap_challenge {
        /** Digest algorithm used for the response */
 
 /** A CHAP challenge/response */
 struct chap_challenge {
        /** Digest algorithm used for the response */
-       struct digest_algorithm *digest;
+       struct crypto_algorithm *digest;
        /** Context used by the digest algorithm */
        uint8_t *digest_context;
        /** CHAP response */
        /** Context used by the digest algorithm */
        uint8_t *digest_context;
        /** CHAP response */
@@ -25,7 +25,7 @@ struct chap_challenge {
 };
 
 extern int chap_init ( struct chap_challenge *chap,
 };
 
 extern int chap_init ( struct chap_challenge *chap,
-                      struct digest_algorithm *digest );
+                      struct crypto_algorithm *digest );
 extern void chap_update ( struct chap_challenge *chap, const void *data,
                          size_t len );
 extern void chap_respond ( struct chap_challenge *chap );
 extern void chap_update ( struct chap_challenge *chap, const void *data,
                          size_t len );
 extern void chap_respond ( struct chap_challenge *chap );
index 023a002..9023c35 100644 (file)
@@ -9,38 +9,78 @@
 
 #include <stdint.h>
 
 
 #include <stdint.h>
 
-/**
- * A message-digest algorithm
- *
- */
-struct digest_algorithm {
+/** A cryptographic algorithm */
+struct crypto_algorithm {
        /** Algorithm name */
        const char *name;
        /** Algorithm name */
        const char *name;
-       /** Size of a context for this algorithm */
-       size_t context_len;
-       /** Size of a message digest for this algorithm */
-       size_t digest_len;
-       /**
-        * Initialise digest algorithm
-        *
-        * @v context           Context for digest operations
+       /** Context size */
+       size_t ctxsize;
+       /** Block size */
+       size_t blocksize;
+       /** Final output size */
+       size_t digestsize;
+       /** Initialise algorithm
+        *
+        * @v ctx               Context
         */
         */
-       void ( * init ) ( void *context );
-       /**
-        * Calculate digest over data buffer
+       void ( * init ) ( void *ctx );
+       /** Set key
         *
         *
-        * @v context           Context for digest operations
-        * @v data              Data buffer
-        * @v len               Length of data buffer
+        * @v ctx               Context
+        * @v key               Key
+        * @v keylen            Key length
+        * @ret rc              Return status code
         */
         */
-       void ( * update ) ( void *context, const void *data, size_t len );
-       /**
-        * Finish calculating digest
+       int ( * setkey ) ( void *ctx, void *key, size_t keylen );
+       /** Encode data
+        *
+        * @v ctx               Context
+        * @v src               Data to encode
+        * @v dst               Encoded data, or NULL
+        * @v len               Length of data
+        * @ret rc              Return status code
         *
         *
-        * @v context           Context for digest operations
-        * @v digest            Buffer for message digest
+        * For a cipher algorithm, the enciphered data should be
+        * placed in @c dst.  For a digest algorithm, only the digest
+        * state should be updated, and @c dst will be NULL.
+        *
+        * @v len is guaranteed to be a multiple of @c blocksize.
         */
         */
-       void ( * finish ) ( void *context, void *digest );
+       void ( * encode ) ( void *ctx, const void *src, void *dst,
+                           size_t len );
+       /** Decode data
+        *
+        * @v ctx               Context
+        * @v src               Data to decode
+        * @v dst               Decoded data
+        * @v len               Length of data
+        * @ret rc              Return status code
+        *
+        * @v len is guaranteed to be a multiple of @c blocksize.
+        */
+       void ( * decode ) ( void *ctx, const void *src, void *dst,
+                           size_t len );
+       /** Finalise algorithm
+        *
+        * @v ctx               Context
+        * @v out               Algorithm final output
+        */
+       void ( * final ) ( void *ctx, void *out );
 };
 
 };
 
+static inline void digest_init ( struct crypto_algorithm *crypto,
+                                void *ctx ) {
+       crypto->init ( ctx );
+}
+
+static inline void digest_update ( struct crypto_algorithm *crypto,
+                                  void *ctx, const void *data, size_t len ) {
+       crypto->encode ( ctx, data, NULL, len );
+}
+
+static inline void digest_final ( struct crypto_algorithm *crypto,
+                                 void *ctx, void *out ) {
+       crypto->final ( ctx, out );
+}
+
 #endif /* _GPXE_CRYPTO_H */
 #endif /* _GPXE_CRYPTO_H */
index 56120ca..f82c946 100644 (file)
@@ -1,8 +1,8 @@
 #ifndef _GPXE_MD5_H
 #define _GPXE_MD5_H
 
 #ifndef _GPXE_MD5_H
 #define _GPXE_MD5_H
 
-struct digest_algorithm;
+struct crypto_algorithm;
 
 
-extern struct digest_algorithm md5_algorithm;
+extern struct crypto_algorithm md5_algorithm;
 
 #endif /* _GPXE_MD5_H */
 
 #endif /* _GPXE_MD5_H */