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