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 cryptographic algorithm */
  14 struct crypto_algorithm {
  15         /** Algorithm name */
  16         const char *name;
  17         /** Context size */
  18         size_t ctxsize;
  19         /** Block size */
  20         size_t blocksize;
  21         /** Final output size */
  22         size_t digestsize;
  23         /** Initialise algorithm
  24          *
  25          * @v ctx               Context
  26          */
  27         void ( * init ) ( void *ctx );
  28         /** Set key
  29          *
  30          * @v ctx               Context
  31          * @v key               Key
  32          * @v keylen            Key length
  33          * @ret rc              Return status code
  34          */
  35         int ( * setkey ) ( void *ctx, const void *key, size_t keylen );
  36         /** Set initialisation vector
  37          *
  38          * @v ctx               Context
  39          * @v iv                Initialisation vector
  40          */
  41         void ( *setiv ) ( void *ctx, const void *iv );
  42         /** Encode data
  43          *
  44          * @v ctx               Context
  45          * @v src               Data to encode
  46          * @v dst               Encoded data, or NULL
  47          * @v len               Length of data
  48          * @ret rc              Return status code
  49          *
  50          * For a cipher algorithm, the enciphered data should be
  51          * placed in @c dst.  For a digest algorithm, only the digest
  52          * state should be updated, and @c dst will be NULL.
  53          *
  54          * @v len is guaranteed to be a multiple of @c blocksize.
  55          */
  56         void ( * encode ) ( void *ctx, const void *src, void *dst,
  57                             size_t len );
  58         /** Decode data
  59          *
  60          * @v ctx               Context
  61          * @v src               Data to decode
  62          * @v dst               Decoded data
  63          * @v len               Length of data
  64          * @ret rc              Return status code
  65          *
  66          * @v len is guaranteed to be a multiple of @c blocksize.
  67          */
  68         void ( * decode ) ( void *ctx, const void *src, void *dst,
  69                             size_t len );
  70         /** Finalise algorithm
  71          *
  72          * @v ctx               Context
  73          * @v out               Algorithm final output
  74          */
  75         void ( * final ) ( void *ctx, void *out );
  76 };
  77
  78 static inline void digest_init ( struct crypto_algorithm *crypto,
  79                                  void *ctx ) {
  80         crypto->init ( ctx );
  81 }
  82
  83 static inline void digest_update ( struct crypto_algorithm *crypto,
  84                                    void *ctx, const void *data, size_t len ) {
  85         crypto->encode ( ctx, data, NULL, len );
  86 }
  87
  88 static inline void digest_final ( struct crypto_algorithm *crypto,
  89                                   void *ctx, void *out ) {
  90         crypto->final ( ctx, out );
  91 }
  92
  93 static inline void cipher_setiv ( struct crypto_algorithm *crypto,
  94                                   void *ctx, const void *iv ) {
  95         crypto->setiv ( ctx, iv );
  96 }
  97
  98 static inline int cipher_setkey ( struct crypto_algorithm *crypto,
  99                                   void *ctx, const void *key, size_t keylen ) {
 100         return crypto->setkey ( ctx, key, keylen );
 101 }
 102
 103 static inline int is_stream_cipher ( struct crypto_algorithm *crypto ) {
 104         return ( crypto->blocksize == 1 );
 105 }
 106
 107 extern struct crypto_algorithm crypto_null;
 108
 109 extern int cipher_encrypt ( struct crypto_algorithm *crypto,
 110                             void *ctx, const void *src, void *dst,
 111                             size_t len );
 112 extern int cipher_decrypt ( struct crypto_algorithm *crypto,
 113                             void *ctx, const void *src, void *dst,
 114                             size_t len );
 115
 116 #endif /* _GPXE_CRYPTO_H */