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