Branch data Line data Source code
1 : : /**
2 : : * \file lib/fko_digest.c
3 : : *
4 : : * \brief Create the base64-encoded digest for the current spa data. The
5 : : * digest used is determined by the digest_type setting in the
6 : : * fko context.
7 : : */
8 : :
9 : : /* Fwknop is developed primarily by the people listed in the file 'AUTHORS'.
10 : : * Copyright (C) 2009-2015 fwknop developers and contributors. For a full
11 : : * list of contributors, see the file 'CREDITS'.
12 : : *
13 : : * License (GNU General Public License):
14 : : *
15 : : * This program is free software; you can redistribute it and/or
16 : : * modify it under the terms of the GNU General Public License
17 : : * as published by the Free Software Foundation; either version 2
18 : : * of the License, or (at your option) any later version.
19 : : *
20 : : * This program is distributed in the hope that it will be useful,
21 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 : : * GNU General Public License for more details.
24 : : *
25 : : * You should have received a copy of the GNU General Public License
26 : : * along with this program; if not, write to the Free Software
27 : : * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
28 : : * USA
29 : : *
30 : : *****************************************************************************
31 : : */
32 : : #include "fko_common.h"
33 : : #include "fko.h"
34 : : #include "digest.h"
35 : :
36 : : /* Set the SPA digest type.
37 : : */
38 : : static int
39 : 1738753 : set_spa_digest_type(fko_ctx_t ctx,
40 : : short *digest_type_field, const short digest_type)
41 : : {
42 : : #if HAVE_LIBFIU
43 [ + + ]: 1738753 : fiu_return_on("set_spa_digest_type_init", FKO_ERROR_CTX_NOT_INITIALIZED);
44 : : #endif
45 : : /* Must be initialized
46 : : */
47 [ + + ][ + - ]: 1738749 : if(!CTX_INITIALIZED(ctx))
48 : : return(FKO_ERROR_CTX_NOT_INITIALIZED);
49 : :
50 : : #if HAVE_LIBFIU
51 [ + + ]: 1737045 : fiu_return_on("set_spa_digest_type_val",
52 : : FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_VALIDFAIL);
53 : : #endif
54 [ + + ]: 1737041 : if(digest_type < 1 || digest_type >= FKO_LAST_DIGEST_TYPE)
55 : : return(FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_VALIDFAIL);
56 : :
57 : 1728829 : *digest_type_field = digest_type;
58 : :
59 : 1728829 : ctx->state |= FKO_DIGEST_TYPE_MODIFIED;
60 : :
61 : 1728829 : return(FKO_SUCCESS);
62 : : }
63 : :
64 : : int
65 : 1722734 : fko_set_spa_digest_type(fko_ctx_t ctx, const short digest_type)
66 : : {
67 : 1722734 : return set_spa_digest_type(ctx, &ctx->digest_type, digest_type);
68 : : }
69 : :
70 : : int
71 : 16019 : fko_set_raw_spa_digest_type(fko_ctx_t ctx, const short raw_digest_type)
72 : : {
73 : 16019 : return set_spa_digest_type(ctx, &ctx->raw_digest_type, raw_digest_type);
74 : : }
75 : :
76 : : /* Return the SPA digest type.
77 : : */
78 : : int
79 : 7299 : fko_get_spa_digest_type(fko_ctx_t ctx, short *digest_type)
80 : : {
81 : : #if HAVE_LIBFIU
82 [ + + ]: 7299 : fiu_return_on("fko_get_spa_digest_type_init",
83 : : FKO_ERROR_CTX_NOT_INITIALIZED);
84 : : #endif
85 : : /* Must be initialized
86 : : */
87 [ + + ][ + - ]: 7298 : if(!CTX_INITIALIZED(ctx))
88 : : return(FKO_ERROR_CTX_NOT_INITIALIZED);
89 : :
90 : : #if HAVE_LIBFIU
91 [ + + ]: 6306 : fiu_return_on("fko_get_spa_digest_type_val",
92 : : FKO_ERROR_INVALID_DATA);
93 : : #endif
94 : :
95 [ + + ]: 6305 : if(digest_type == NULL)
96 : : return(FKO_ERROR_INVALID_DATA);
97 : :
98 : 6237 : *digest_type = ctx->digest_type;
99 : :
100 : 6237 : return(FKO_SUCCESS);
101 : : }
102 : :
103 : : /* Return the SPA digest type.
104 : : */
105 : : int
106 : 15985 : fko_get_raw_spa_digest_type(fko_ctx_t ctx, short *raw_digest_type)
107 : : {
108 : : #if HAVE_LIBFIU
109 [ + + ]: 15985 : fiu_return_on("fko_get_raw_spa_digest_type_init",
110 : : FKO_ERROR_CTX_NOT_INITIALIZED);
111 : : #endif
112 : : /* Must be initialized
113 : : */
114 [ + - ][ + - ]: 15984 : if(!CTX_INITIALIZED(ctx))
115 : : return(FKO_ERROR_CTX_NOT_INITIALIZED);
116 : :
117 : 15984 : *raw_digest_type = ctx->raw_digest_type;
118 : :
119 : 15984 : return(FKO_SUCCESS);
120 : : }
121 : :
122 : : static int
123 : 865079 : set_digest(char *data, char **digest, short digest_type, int *digest_len)
124 : : {
125 : 865079 : char *md = NULL;
126 : : int data_len;
127 : :
128 : 865079 : data_len = strnlen(data, MAX_SPA_ENCODED_MSG_SIZE);
129 : :
130 : : #if HAVE_LIBFIU
131 [ + + ]: 865079 : fiu_return_on("set_digest_toobig",
132 : : FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_TOOBIG);
133 : : #endif
134 : :
135 [ + + ]: 865078 : if(data_len == MAX_SPA_ENCODED_MSG_SIZE)
136 : : return(FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_TOOBIG);
137 : :
138 : : #if HAVE_LIBFIU
139 [ + + ]: 820070 : fiu_return_on("set_digest_invalidtype", FKO_ERROR_INVALID_DIGEST_TYPE);
140 [ + + ]: 820069 : fiu_return_on("set_digest_calloc", FKO_ERROR_MEMORY_ALLOCATION);
141 : : #endif
142 : :
143 [ + + + + : 820068 : switch(digest_type)
+ + + + ]
144 : : {
145 : : case FKO_DIGEST_MD5:
146 : 31 : md = calloc(1, MD_HEX_SIZE(MD5_DIGEST_LEN)+1);
147 [ + - ]: 31 : if(md == NULL)
148 : : return(FKO_ERROR_MEMORY_ALLOCATION);
149 : :
150 : 31 : md5_base64(md,
151 : : (unsigned char*)data, data_len);
152 : 31 : *digest_len = MD5_B64_LEN;
153 : 31 : break;
154 : :
155 : : case FKO_DIGEST_SHA1:
156 : 41 : md = calloc(1, MD_HEX_SIZE(SHA1_DIGEST_LEN)+1);
157 [ + - ]: 41 : if(md == NULL)
158 : : return(FKO_ERROR_MEMORY_ALLOCATION);
159 : :
160 : 41 : sha1_base64(md,
161 : : (unsigned char*)data, data_len);
162 : 41 : *digest_len = SHA1_B64_LEN;
163 : 41 : break;
164 : :
165 : : case FKO_DIGEST_SHA256:
166 : 819864 : md = calloc(1, MD_HEX_SIZE(SHA256_DIGEST_LEN)+1);
167 [ + + ]: 819864 : if(md == NULL)
168 : : return(FKO_ERROR_MEMORY_ALLOCATION);
169 : :
170 : 819830 : sha256_base64(md,
171 : : (unsigned char*)data, data_len);
172 : 819830 : *digest_len = SHA256_B64_LEN;
173 : 819830 : break;
174 : :
175 : : case FKO_DIGEST_SHA384:
176 : 28 : md = calloc(1, MD_HEX_SIZE(SHA384_DIGEST_LEN)+1);
177 [ + - ]: 28 : if(md == NULL)
178 : : return(FKO_ERROR_MEMORY_ALLOCATION);
179 : :
180 : 28 : sha384_base64(md,
181 : : (unsigned char*)data, data_len);
182 : 28 : *digest_len = SHA384_B64_LEN;
183 : 28 : break;
184 : :
185 : : case FKO_DIGEST_SHA512:
186 : 30 : md = calloc(1, MD_HEX_SIZE(SHA512_DIGEST_LEN)+1);
187 [ + - ]: 30 : if(md == NULL)
188 : : return(FKO_ERROR_MEMORY_ALLOCATION);
189 : :
190 : 30 : sha512_base64(md,
191 : : (unsigned char*)data, data_len);
192 : 30 : *digest_len = SHA512_B64_LEN;
193 : 30 : break;
194 : :
195 : : case FKO_DIGEST_SHA3_256:
196 : 21 : md = calloc(1, MD_HEX_SIZE(SHA3_256_DIGEST_LEN)+1);
197 [ + - ]: 21 : if(md == NULL)
198 : : return(FKO_ERROR_MEMORY_ALLOCATION);
199 : :
200 : 21 : sha3_256_base64(md,
201 : : (unsigned char*)data, data_len);
202 : 21 : *digest_len = SHA3_256_B64_LEN;
203 : 21 : break;
204 : :
205 : : case FKO_DIGEST_SHA3_512:
206 : 37 : md = calloc(1, MD_HEX_SIZE(SHA3_512_DIGEST_LEN)+1);
207 [ + - ]: 37 : if(md == NULL)
208 : : return(FKO_ERROR_MEMORY_ALLOCATION);
209 : :
210 : 37 : sha3_512_base64(md,
211 : : (unsigned char*)data, data_len);
212 : 37 : *digest_len = SHA3_512_B64_LEN;
213 : 37 : break;
214 : :
215 : : default:
216 : : return(FKO_ERROR_INVALID_DIGEST_TYPE);
217 : : }
218 : :
219 : : /* Just in case this is a subsequent call to this function. We
220 : : * do not want to be leaking memory.
221 : : */
222 [ + + ]: 820018 : if(*digest != NULL)
223 : 418 : free(*digest);
224 : :
225 : 820018 : *digest = md;
226 : :
227 : 820018 : return(FKO_SUCCESS);
228 : : }
229 : :
230 : : int
231 : 850786 : fko_set_spa_digest(fko_ctx_t ctx)
232 : : {
233 : : #if HAVE_LIBFIU
234 [ + + ]: 850786 : fiu_return_on("fko_set_spa_digest_init", FKO_ERROR_CTX_NOT_INITIALIZED);
235 : : #endif
236 : : /* Must be initialized
237 : : */
238 [ + + ][ + - ]: 850785 : if(!CTX_INITIALIZED(ctx))
239 : : return(FKO_ERROR_CTX_NOT_INITIALIZED);
240 : :
241 : : /* Must have encoded message data to start with.
242 : : */
243 [ + + ]: 850357 : if(ctx->encoded_msg == NULL)
244 : : return(FKO_ERROR_MISSING_ENCODED_DATA);
245 : :
246 : : #if HAVE_LIBFIU
247 [ + + ]: 849081 : fiu_return_on("fko_set_spa_digest_encoded", FKO_ERROR_MISSING_ENCODED_DATA);
248 : : #endif
249 : :
250 : 849080 : return set_digest(ctx->encoded_msg, &ctx->digest,
251 : 849080 : ctx->digest_type, &ctx->digest_len);
252 : : }
253 : :
254 : : int
255 : 17696 : fko_set_raw_spa_digest(fko_ctx_t ctx)
256 : : {
257 : : #if HAVE_LIBFIU
258 [ + + ]: 17696 : fiu_return_on("fko_set_raw_spa_digest_init", FKO_ERROR_CTX_NOT_INITIALIZED);
259 : : #endif
260 : : /* Must be initialized
261 : : */
262 [ + + ][ + - ]: 17695 : if(!CTX_INITIALIZED(ctx))
263 : : return(FKO_ERROR_CTX_NOT_INITIALIZED);
264 : :
265 : : /* Must have encoded message data to start with.
266 : : */
267 [ + + ]: 17267 : if(ctx->encrypted_msg == NULL)
268 : : return(FKO_ERROR_MISSING_ENCODED_DATA);
269 : :
270 : : #if HAVE_LIBFIU
271 [ + - ]: 15999 : fiu_return_on("fko_set_raw_spa_digest_val", FKO_ERROR_MISSING_ENCODED_DATA);
272 : : #endif
273 : :
274 : 15999 : return set_digest(ctx->encrypted_msg, &ctx->raw_digest,
275 : 15999 : ctx->raw_digest_type, &ctx->raw_digest_len);
276 : : }
277 : :
278 : : int
279 : 3931 : fko_get_spa_digest(fko_ctx_t ctx, char **md)
280 : : {
281 : : #if HAVE_LIBFIU
282 [ + + ]: 3931 : fiu_return_on("fko_get_spa_digest_init", FKO_ERROR_CTX_NOT_INITIALIZED);
283 : : #endif
284 : : /* Must be initialized
285 : : */
286 [ + + ][ + - ]: 3930 : if(!CTX_INITIALIZED(ctx))
287 : : return(FKO_ERROR_CTX_NOT_INITIALIZED);
288 : :
289 : : #if HAVE_LIBFIU
290 [ + + ]: 3778 : fiu_return_on("fko_get_spa_digest_val", FKO_ERROR_INVALID_DATA);
291 : : #endif
292 [ + + ]: 3777 : if(md == NULL)
293 : : return(FKO_ERROR_INVALID_DATA);
294 : :
295 : 3709 : *md = ctx->digest;
296 : :
297 : 3709 : return(FKO_SUCCESS);
298 : : }
299 : :
300 : : int
301 : 15951 : fko_get_raw_spa_digest(fko_ctx_t ctx, char **md)
302 : : {
303 : : #if HAVE_LIBFIU
304 [ + + ]: 15951 : fiu_return_on("fko_get_raw_spa_digest_init", FKO_ERROR_CTX_NOT_INITIALIZED);
305 : : #endif
306 : : /* Must be initialized
307 : : */
308 [ + - ][ + - ]: 15950 : if(!CTX_INITIALIZED(ctx))
309 : : return(FKO_ERROR_CTX_NOT_INITIALIZED);
310 : :
311 : 15950 : *md = ctx->raw_digest;
312 : :
313 : 15950 : return(FKO_SUCCESS);
314 : : }
315 : :
316 : : /***EOF***/
|
