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