crypto: move includes to kern/include
[akaros.git] / kern / include / crypto / 2sha.h
1 /* Copyright (c) 2014 The Chromium OS Authors. All rights reserved.
2  * Use of this source code is governed by a BSD-style license that can be
3  * found in the LICENSE file.
4  *
5  * These APIs may be called by external firmware as well as vboot.  External
6  * firmware must NOT include this header file directly; instead, define
7  * NEED_VB2_SHA_LIBRARY and include vb2api.h.  This is permissible because the
8  * SHA library routines below don't interact with the rest of vboot.
9  */
10
11 #ifndef VBOOT_REFERENCE_2SHA_H_
12 #define VBOOT_REFERENCE_2SHA_H_
13
14 #include "2crypto.h"
15
16 /* Hash algorithms may be disabled individually to save code space */
17
18 #ifndef VB2_SUPPORT_SHA1
19 #define VB2_SUPPORT_SHA1 1
20 #endif
21
22 #ifndef VB2_SUPPORT_SHA256
23 #define VB2_SUPPORT_SHA256 1
24 #endif
25
26 #ifndef VB2_SUPPORT_SHA512
27 #define VB2_SUPPORT_SHA512 1
28 #endif
29
30 /* These are set to the biggest values among the supported hash algorithms.
31  * They have to be updated as we add new hash algorithms */
32 #define VB2_MAX_DIGEST_SIZE     VB2_SHA512_DIGEST_SIZE
33 #define VB2_MAX_BLOCK_SIZE      VB2_SHA512_BLOCK_SIZE
34 #define VB2_INVALID_ALG_NAME    "INVALID"
35
36 #define VB2_SHA1_DIGEST_SIZE 20
37 #define VB2_SHA1_BLOCK_SIZE 64
38 #define VB2_SHA1_ALG_NAME       "SHA1"
39
40 /* Context structs for hash algorithms */
41
42 struct vb2_sha1_context {
43         uint32_t count;
44         uint32_t state[5];
45 #if defined(HAVE_ENDIAN_H) && defined(HAVE_LITTLE_ENDIAN)
46         union {
47                 uint8_t b[VB2_SHA1_BLOCK_SIZE];
48                 uint32_t w[VB2_SHA1_BLOCK_SIZE / sizeof(uint32_t)];
49         } buf;
50 #else
51         uint8_t buf[VB2_SHA1_BLOCK_SIZE];
52 #endif
53 };
54
55 #define VB2_SHA256_DIGEST_SIZE 32
56 #define VB2_SHA256_BLOCK_SIZE 64
57 #define VB2_SHA256_ALG_NAME     "SHA256"
58
59 struct vb2_sha256_context {
60         uint32_t h[8];
61         uint32_t total_size;
62         uint32_t size;
63         uint8_t block[2 * VB2_SHA256_BLOCK_SIZE];
64 };
65
66 #define VB2_SHA512_DIGEST_SIZE 64
67 #define VB2_SHA512_BLOCK_SIZE 128
68 #define VB2_SHA512_ALG_NAME     "SHA512"
69
70 struct vb2_sha512_context {
71         uint64_t h[8];
72         uint32_t total_size;
73         uint32_t size;
74         uint8_t block[2 * VB2_SHA512_BLOCK_SIZE];
75 };
76
77 /* Hash algorithm independent digest context; includes all of the above. */
78 struct vb2_digest_context {
79         /* Context union for all algorithms */
80         union {
81 #if VB2_SUPPORT_SHA1
82                 struct vb2_sha1_context sha1;
83 #endif
84 #if VB2_SUPPORT_SHA256
85                 struct vb2_sha256_context sha256;
86 #endif
87 #if VB2_SUPPORT_SHA512
88                 struct vb2_sha512_context sha512;
89 #endif
90         };
91
92         /* Current hash algorithm */
93         enum vb2_hash_algorithm hash_alg;
94
95         /* 1 if digest is computed with vb2ex_hwcrypto routines, else 0 */
96         int using_hwcrypto;
97 };
98
99 /**
100  * Initialize a hash context.
101  *
102  * @param ctx           Hash context
103  */
104 void vb2_sha1_init(struct vb2_sha1_context *ctx);
105 void vb2_sha256_init(struct vb2_sha256_context *ctx);
106 void vb2_sha512_init(struct vb2_sha512_context *ctx);
107
108 /**
109  * Update (extend) a hash.
110  *
111  * @param ctx           Hash context
112  * @param data          Data to hash
113  * @param size          Length of data in bytes
114  */
115 void vb2_sha1_update(struct vb2_sha1_context *ctx,
116                      const uint8_t *data,
117                      uint32_t size);
118 void vb2_sha256_update(struct vb2_sha256_context *ctx,
119                        const uint8_t *data,
120                        uint32_t size);
121 void vb2_sha512_update(struct vb2_sha512_context *ctx,
122                        const uint8_t *data,
123                        uint32_t size);
124
125 /**
126  * Finalize a hash digest.
127  *
128  * @param ctx           Hash context
129  * @param digest        Destination for hash; must be VB_SHA*_DIGEST_SIZE bytes
130  */
131 void vb2_sha1_finalize(struct vb2_sha1_context *ctx, uint8_t *digest);
132 void vb2_sha256_finalize(struct vb2_sha256_context *ctx, uint8_t *digest);
133 void vb2_sha512_finalize(struct vb2_sha512_context *ctx, uint8_t *digest);
134
135 /**
136  * Hash-extend data
137  *
138  * @param from  Hash to be extended. It has to be the hash size.
139  * @param by    Block to be extended by. It has to be the hash block size.
140  * @param to    Destination for extended data
141  */
142 void vb2_sha256_extend(const uint8_t *from, const uint8_t *by, uint8_t *to);
143
144 /**
145  * Convert vb2_crypto_algorithm to vb2_hash_algorithm.
146  *
147  * @param algorithm     Crypto algorithm (vb2_crypto_algorithm)
148  *
149  * @return The hash algorithm for that crypto algorithm, or VB2_HASH_INVALID if
150  * the crypto algorithm or its corresponding hash algorithm is invalid or not
151  * supported.
152  */
153 enum vb2_hash_algorithm vb2_crypto_to_hash(uint32_t algorithm);
154
155 /**
156  * Return the size of the digest for a hash algorithm.
157  *
158  * @param hash_alg      Hash algorithm
159  * @return The size of the digest, or 0 if error.
160  */
161 int vb2_digest_size(enum vb2_hash_algorithm hash_alg);
162
163 /**
164  * Return the block size of a hash algorithm.
165  *
166  * @param hash_alg      Hash algorithm
167  * @return The block size of the algorithm, or 0 if error.
168  */
169 int vb2_hash_block_size(enum vb2_hash_algorithm alg);
170
171 /**
172  * Return the name of a hash algorithm
173  *
174  * @param alg   Hash algorithm ID
175  * @return      String containing a hash name or VB2_INVALID_ALG_NAME
176  *              if <alg> is invalid.
177  */
178 const char *vb2_get_hash_algorithm_name(enum vb2_hash_algorithm alg);
179
180 /**
181  * Initialize a digest context for doing block-style digesting.
182  *
183  * @param dc            Digest context
184  * @param hash_alg      Hash algorithm
185  * @return VB2_SUCCESS, or non-zero on error.
186  */
187 int vb2_digest_init(struct vb2_digest_context *dc,
188                     enum vb2_hash_algorithm hash_alg);
189
190 /**
191  * Extend a digest's hash with another block of data.
192  *
193  * @param dc            Digest context
194  * @param buf           Data to hash
195  * @param size          Length of data in bytes
196  * @return VB2_SUCCESS, or non-zero on error.
197  */
198 int vb2_digest_extend(struct vb2_digest_context *dc,
199                       const uint8_t *buf,
200                       uint32_t size);
201
202 /**
203  * Finalize a digest and store the result.
204  *
205  * The destination digest should be at least vb2_digest_size(algorithm).
206  *
207  * @param dc            Digest context
208  * @param digest        Destination for digest
209  * @param digest_size   Length of digest buffer in bytes.
210  * @return VB2_SUCCESS, or non-zero on error.
211  */
212 int vb2_digest_finalize(struct vb2_digest_context *dc,
213                         uint8_t *digest,
214                         uint32_t digest_size);
215
216 /**
217  * Calculate the digest of a buffer and store the result.
218  *
219  * @param buf           Data to hash
220  * @param size          Length of data in bytes
221  * @param hash_alg      Hash algorithm
222  * @param digest        Destination for digest
223  * @param digest_size   Length of digest buffer in bytes.
224  * @return VB2_SUCCESS, or non-zero on error.
225  */
226 int vb2_digest_buffer(const uint8_t *buf,
227                       uint32_t size,
228                       enum vb2_hash_algorithm hash_alg,
229                       uint8_t *digest,
230                       uint32_t digest_size);
231
232 #endif  /* VBOOT_REFERENCE_2SHA_H_ */