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 : 1740128 : set_spa_digest_type(fko_ctx_t ctx,
41 : : short *digest_type_field, const short digest_type)
42 : : {
43 : : #if HAVE_LIBFIU
44 [ + + ]: 1740128 : fiu_return_on("set_spa_digest_type_init", FKO_ERROR_CTX_NOT_INITIALIZED);
45 : : #endif
46 : : /* Must be initialized
47 : : */
48 [ + + ][ + - ]: 1740124 : if(!CTX_INITIALIZED(ctx))
49 : : return(FKO_ERROR_CTX_NOT_INITIALIZED);
50 : :
51 : : #if HAVE_LIBFIU
52 [ + + ]: 1738456 : fiu_return_on("set_spa_digest_type_val",
53 : : FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_VALIDFAIL);
54 : : #endif
55 [ + + ]: 1738452 : if(digest_type < 1 || digest_type >= FKO_LAST_DIGEST_TYPE)
56 : : return(FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_VALIDFAIL);
57 : :
58 : 1730248 : *digest_type_field = digest_type;
59 : :
60 : 1730248 : ctx->state |= FKO_DIGEST_TYPE_MODIFIED;
61 : :
62 : 1730248 : return(FKO_SUCCESS);
63 : : }
64 : :
65 : : int
66 : 1723133 : fko_set_spa_digest_type(fko_ctx_t ctx, const short digest_type)
67 : : {
68 : 1723133 : return set_spa_digest_type(ctx, &ctx->digest_type, digest_type);
69 : : }
70 : :
71 : : int
72 : 16995 : fko_set_raw_spa_digest_type(fko_ctx_t ctx, const short raw_digest_type)
73 : : {
74 : 16995 : 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 : 6761 : fko_get_spa_digest_type(fko_ctx_t ctx, short *digest_type)
81 : : {
82 : : #if HAVE_LIBFIU
83 [ + + ]: 6761 : fiu_return_on("fko_get_spa_digest_type_init",
84 : : FKO_ERROR_CTX_NOT_INITIALIZED);
85 : : #endif
86 : : /* Must be initialized
87 : : */
88 [ + + ][ + - ]: 6760 : if(!CTX_INITIALIZED(ctx))
89 : : return(FKO_ERROR_CTX_NOT_INITIALIZED);
90 : :
91 : : #if HAVE_LIBFIU
92 [ + + ]: 5776 : fiu_return_on("fko_get_spa_digest_type_val",
93 : : FKO_ERROR_INVALID_DATA);
94 : : #endif
95 : :
96 [ + + ]: 5775 : if(digest_type == NULL)
97 : : return(FKO_ERROR_INVALID_DATA);
98 : :
99 : 5707 : *digest_type = ctx->digest_type;
100 : :
101 : 5707 : return(FKO_SUCCESS);
102 : : }
103 : :
104 : : /* Return the SPA digest type.
105 : : */
106 : : int
107 : 16993 : fko_get_raw_spa_digest_type(fko_ctx_t ctx, short *raw_digest_type)
108 : : {
109 : : #if HAVE_LIBFIU
110 [ + + ]: 16993 : fiu_return_on("fko_get_raw_spa_digest_type_init",
111 : : FKO_ERROR_CTX_NOT_INITIALIZED);
112 : : #endif
113 : : /* Must be initialized
114 : : */
115 [ + - ][ + - ]: 16992 : if(!CTX_INITIALIZED(ctx))
116 : : return(FKO_ERROR_CTX_NOT_INITIALIZED);
117 : :
118 : 16992 : *raw_digest_type = ctx->raw_digest_type;
119 : :
120 : 16992 : return(FKO_SUCCESS);
121 : : }
122 : :
123 : : static int
124 : 866053 : set_digest(char *data, char **digest, short digest_type, int *digest_len)
125 : : {
126 : 866053 : char *md = NULL;
127 : : int data_len;
128 : :
129 : 866053 : data_len = strnlen(data, MAX_SPA_ENCODED_MSG_SIZE);
130 : :
131 : : #if HAVE_LIBFIU
132 [ + + ]: 866053 : fiu_return_on("set_digest_toobig",
133 : : FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_TOOBIG);
134 : : #endif
135 : :
136 [ + + ]: 866052 : if(data_len == MAX_SPA_ENCODED_MSG_SIZE)
137 : : return(FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_TOOBIG);
138 : :
139 : : #if HAVE_LIBFIU
140 [ + + ]: 821044 : fiu_return_on("set_digest_invalidtype", FKO_ERROR_INVALID_DIGEST_TYPE);
141 [ + + ]: 821043 : fiu_return_on("set_digest_calloc", FKO_ERROR_MEMORY_ALLOCATION);
142 : : #endif
143 : :
144 [ + + + + : 821042 : switch(digest_type)
+ - ]
145 : : {
146 : : case FKO_DIGEST_MD5:
147 : 31 : md = calloc(1, MD_HEX_SIZE(MD5_DIGEST_LEN)+1);
148 [ + - ]: 31 : if(md == NULL)
149 : : return(FKO_ERROR_MEMORY_ALLOCATION);
150 : :
151 : 31 : md5_base64(md,
152 : : (unsigned char*)data, data_len);
153 : 31 : *digest_len = MD5_B64_LEN;
154 : 31 : break;
155 : :
156 : : case FKO_DIGEST_SHA1:
157 : 41 : md = calloc(1, MD_HEX_SIZE(SHA1_DIGEST_LEN)+1);
158 [ + - ]: 41 : if(md == NULL)
159 : : return(FKO_ERROR_MEMORY_ALLOCATION);
160 : :
161 : 41 : sha1_base64(md,
162 : : (unsigned char*)data, data_len);
163 : 41 : *digest_len = SHA1_B64_LEN;
164 : 41 : break;
165 : :
166 : : case FKO_DIGEST_SHA256:
167 : 820896 : md = calloc(1, MD_HEX_SIZE(SHA256_DIGEST_LEN)+1);
168 [ + + ]: 820896 : if(md == NULL)
169 : : return(FKO_ERROR_MEMORY_ALLOCATION);
170 : :
171 : 820809 : sha256_base64(md,
172 : : (unsigned char*)data, data_len);
173 : 820809 : *digest_len = SHA256_B64_LEN;
174 : 820809 : break;
175 : :
176 : : case FKO_DIGEST_SHA384:
177 : 28 : md = calloc(1, MD_HEX_SIZE(SHA384_DIGEST_LEN)+1);
178 [ + - ]: 28 : if(md == NULL)
179 : : return(FKO_ERROR_MEMORY_ALLOCATION);
180 : :
181 : 28 : sha384_base64(md,
182 : : (unsigned char*)data, data_len);
183 : 28 : *digest_len = SHA384_B64_LEN;
184 : 28 : break;
185 : :
186 : : case FKO_DIGEST_SHA512:
187 : 46 : md = calloc(1, MD_HEX_SIZE(SHA512_DIGEST_LEN)+1);
188 [ + - ]: 46 : if(md == NULL)
189 : : return(FKO_ERROR_MEMORY_ALLOCATION);
190 : :
191 : 46 : sha512_base64(md,
192 : : (unsigned char*)data, data_len);
193 : 46 : *digest_len = SHA512_B64_LEN;
194 : 46 : 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 [ + + ]: 820955 : if(*digest != NULL)
204 : 410 : free(*digest);
205 : :
206 : 820955 : *digest = md;
207 : :
208 : 820955 : return(FKO_SUCCESS);
209 : : }
210 : :
211 : : int
212 : 850728 : fko_set_spa_digest(fko_ctx_t ctx)
213 : : {
214 : : #if HAVE_LIBFIU
215 [ + + ]: 850728 : fiu_return_on("fko_set_spa_digest_init", FKO_ERROR_CTX_NOT_INITIALIZED);
216 : : #endif
217 : : /* Must be initialized
218 : : */
219 [ + + ][ + - ]: 850727 : if(!CTX_INITIALIZED(ctx))
220 : : return(FKO_ERROR_CTX_NOT_INITIALIZED);
221 : :
222 : : /* Must have encoded message data to start with.
223 : : */
224 [ + + ]: 850311 : if(ctx->encoded_msg == NULL)
225 : : return(FKO_ERROR_MISSING_ENCODED_DATA);
226 : :
227 : : #if HAVE_LIBFIU
228 [ + + ]: 849063 : fiu_return_on("fko_set_spa_digest_encoded", FKO_ERROR_MISSING_ENCODED_DATA);
229 : : #endif
230 : :
231 : 849062 : return set_digest(ctx->encoded_msg, &ctx->digest,
232 : 849062 : ctx->digest_type, &ctx->digest_len);
233 : : }
234 : :
235 : : int
236 : 18656 : fko_set_raw_spa_digest(fko_ctx_t ctx)
237 : : {
238 : : #if HAVE_LIBFIU
239 [ + + ]: 18656 : fiu_return_on("fko_set_raw_spa_digest_init", FKO_ERROR_CTX_NOT_INITIALIZED);
240 : : #endif
241 : : /* Must be initialized
242 : : */
243 [ + + ][ + - ]: 18655 : if(!CTX_INITIALIZED(ctx))
244 : : return(FKO_ERROR_CTX_NOT_INITIALIZED);
245 : :
246 : : /* Must have encoded message data to start with.
247 : : */
248 [ + + ]: 18239 : if(ctx->encrypted_msg == NULL)
249 : : return(FKO_ERROR_MISSING_ENCODED_DATA);
250 : :
251 : : #if HAVE_LIBFIU
252 [ + - ]: 16991 : fiu_return_on("fko_set_raw_spa_digest_val", FKO_ERROR_MISSING_ENCODED_DATA);
253 : : #endif
254 : :
255 : 16991 : return set_digest(ctx->encrypted_msg, &ctx->raw_digest,
256 : 16991 : ctx->raw_digest_type, &ctx->raw_digest_len);
257 : : }
258 : :
259 : : int
260 : 3425 : fko_get_spa_digest(fko_ctx_t ctx, char **md)
261 : : {
262 : : #if HAVE_LIBFIU
263 [ + + ]: 3425 : fiu_return_on("fko_get_spa_digest_init", FKO_ERROR_CTX_NOT_INITIALIZED);
264 : : #endif
265 : : /* Must be initialized
266 : : */
267 [ + + ][ + - ]: 3424 : if(!CTX_INITIALIZED(ctx))
268 : : return(FKO_ERROR_CTX_NOT_INITIALIZED);
269 : :
270 : : #if HAVE_LIBFIU
271 [ + + ]: 3272 : fiu_return_on("fko_get_spa_digest_val", FKO_ERROR_INVALID_DATA);
272 : : #endif
273 [ + + ]: 3271 : if(md == NULL)
274 : : return(FKO_ERROR_INVALID_DATA);
275 : :
276 : 3203 : *md = ctx->digest;
277 : :
278 : 3203 : return(FKO_SUCCESS);
279 : : }
280 : :
281 : : int
282 : 16926 : fko_get_raw_spa_digest(fko_ctx_t ctx, char **md)
283 : : {
284 : : #if HAVE_LIBFIU
285 [ + + ]: 16926 : fiu_return_on("fko_get_raw_spa_digest_init", FKO_ERROR_CTX_NOT_INITIALIZED);
286 : : #endif
287 : : /* Must be initialized
288 : : */
289 [ + - ][ + - ]: 16925 : if(!CTX_INITIALIZED(ctx))
290 : : return(FKO_ERROR_CTX_NOT_INITIALIZED);
291 : :
292 : 16925 : *md = ctx->raw_digest;
293 : :
294 : 16925 : return(FKO_SUCCESS);
295 : : }
296 : :
297 : : /***EOF***/
|
