[crypto] Change cipher_{en,de}crypt() to void functions
[people/asdlkf/gpxe.git] / 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 */