src/include/gpxe/crypto.h

   1 #ifndef _GPXE_CRYPTO_H
   2 #define _GPXE_CRYPTO_H
   3
   4 /** @file
   5  *
   6  * Cryptographic API
   7  *
   8  */
   9
  10 #include <stdint.h>
  11 #include <stddef.h>
  12
  13 /** A message digest algorithm */
  14 struct digest_algorithm {
  15         /** Algorithm name */
  16         const char *name;
  17         /** Context size */
  18         size_t ctxsize;
  19         /** Block size */
  20         size_t blocksize;
  21         /** Digest size */
  22         size_t digestsize;
  23         /** Initialise digest
  24          *
  25          * @v ctx               Context
  26          */
  27         void ( * init ) ( void *ctx );
  28         /** Update digest with new data
  29          *
  30          * @v ctx               Context
  31          * @v src               Data to digest
  32          * @v len               Length of data
  33          *
  34          * @v len is not necessarily a multiple of @c blocksize.
  35          */
  36         void ( * update ) ( void *ctx, const void *src, size_t len );
  37         /** Finalise digest
  38          *
  39          * @v ctx               Context
  40          * @v out               Buffer for digest output
  41          */
  42         void ( * final ) ( void *ctx, void *out );
  43 };
  44
  45 /** A cipher algorithm */
  46 struct cipher_algorithm {
  47         /** Algorithm name */
  48         const char *name;
  49         /** Context size */
  50         size_t ctxsize;
  51         /** Block size */
  52         size_t blocksize;
  53         /** Set key
  54          *
  55          * @v ctx               Context
  56          * @v key               Key
  57          * @v keylen            Key length
  58          * @ret rc              Return status code
  59          */
  60         int ( * setkey ) ( void *ctx, const void *key, size_t keylen );
  61         /** Set initialisation vector
  62          *
  63          * @v ctx               Context
  64          * @v iv                Initialisation vector
  65          */
  66         void ( * setiv ) ( void *ctx, const void *iv );
  67         /** Encrypt data
  68          *
  69          * @v ctx               Context
  70          * @v src               Data to encrypt
  71          * @v dst               Buffer for encrypted data
  72          * @v len               Length of data
  73          *
  74          * @v len is guaranteed to be a multiple of @c blocksize.
  75          */
  76         void ( * encrypt ) ( void *ctx, const void *src, void *dst,
  77                              size_t len );
  78         /** Decrypt data
  79          *
  80          * @v ctx               Context
  81          * @v src               Data to decrypt
  82          * @v dst               Buffer for decrypted data
  83          * @v len               Length of data
  84          *
  85          * @v len is guaranteed to be a multiple of @c blocksize.
  86          */
  87         void ( * decrypt ) ( void *ctx, const void *src, void *dst,
  88                              size_t len );
  89 };
  90
  91 /** A public key algorithm */
  92 struct pubkey_algorithm {
  93         /** Algorithm name */
  94         const char *name;
  95         /** Context size */
  96         size_t ctxsize;
  97 };
  98
  99 static inline void digest_init ( struct digest_algorithm *digest,
 100                                  void *ctx ) {
 101         digest->init ( ctx );
 102 }
 103
 104 static inline void digest_update ( struct digest_algorithm *digest,
 105                                    void *ctx, const void *data, size_t len ) {
 106         digest->update ( ctx, data, len );
 107 }
 108
 109 static inline void digest_final ( struct digest_algorithm *digest,
 110                                   void *ctx, void *out ) {
 111         digest->final ( ctx, out );
 112 }
 113
 114 static inline int cipher_setkey ( struct cipher_algorithm *cipher,
 115                                   void *ctx, const void *key, size_t keylen ) {
 116         return cipher->setkey ( ctx, key, keylen );
 117 }
 118
 119 static inline void cipher_setiv ( struct cipher_algorithm *cipher,
 120                                   void *ctx, const void *iv ) {
 121         cipher->setiv ( ctx, iv );
 122 }
 123
 124 static inline void cipher_encrypt ( struct cipher_algorithm *cipher,
 125                                     void *ctx, const void *src, void *dst,
 126                                     size_t len ) {
 127         cipher->encrypt ( ctx, src, dst, len );
 128 }
 129 #define cipher_encrypt( cipher, ctx, src, dst, len ) do {               \
 130         assert ( ( len & ( (cipher)->blocksize - 1 ) ) == 0 );          \
 131         cipher_encrypt ( (cipher), (ctx), (src), (dst), (len) );        \
 132         } while ( 0 )
 133
 134 static inline void cipher_decrypt ( struct cipher_algorithm *cipher,
 135                                     void *ctx, const void *src, void *dst,
 136                                     size_t len ) {
 137         cipher->decrypt ( ctx, src, dst, len );
 138 }
 139 #define cipher_decrypt( cipher, ctx, src, dst, len ) do {               \
 140         assert ( ( len & ( (cipher)->blocksize - 1 ) ) == 0 );          \
 141         cipher_decrypt ( (cipher), (ctx), (src), (dst), (len) );        \
 142         } while ( 0 )
 143
 144 static inline int is_stream_cipher ( struct cipher_algorithm *cipher ) {
 145         return ( cipher->blocksize == 1 );
 146 }
 147
 148 extern struct digest_algorithm digest_null;
 149 extern struct cipher_algorithm cipher_null;
 150 extern struct pubkey_algorithm pubkey_null;
 151
 152 #endif /* _GPXE_CRYPTO_H */