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