Branch data Line data Source code
1 : : /* enckdcreppart.c --- Key distribution encrypted reply part functions
2 : : * Copyright (C) 2002, 2003, 2004, 2006, 2007, 2008 Simon Josefsson
3 : : *
4 : : * This file is part of Shishi.
5 : : *
6 : : * Shishi is free software; you can redistribute it and/or modify it
7 : : * under the terms of the GNU General Public License as published by
8 : : * the Free Software Foundation; either version 3 of the License, or
9 : : * (at your option) any later version.
10 : : *
11 : : * Shishi is distributed in the hope that it will be useful, but
12 : : * WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : : * GNU General Public License for more details.
15 : : *
16 : : * You should have received a copy of the GNU General Public License
17 : : * along with Shishi; if not, see http://www.gnu.org/licenses or write
18 : : * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
19 : : * Floor, Boston, MA 02110-1301, USA
20 : : *
21 : : */
22 : :
23 : : #include "internal.h"
24 : :
25 : :
26 : : Shishi_asn1
27 : 0 : shishi_enckdcreppart (Shishi * handle)
28 : : {
29 : : int res;
30 : : Shishi_asn1 node;
31 : :
32 : 0 : node = shishi_asn1_enckdcreppart (handle);
33 [ # # ]: 0 : if (!node)
34 : 0 : return NULL;
35 : :
36 : : /* XXX remove these two: */
37 : 0 : res = shishi_asn1_write (handle, node, "key-expiration", NULL, 0);
38 [ # # ]: 0 : if (res != SHISHI_OK)
39 : 0 : return NULL;
40 : :
41 : 0 : res = shishi_asn1_write (handle, node, "caddr", NULL, 0);
42 [ # # ]: 0 : if (res != SHISHI_OK)
43 : 0 : return NULL;
44 : :
45 : 0 : res = shishi_enckdcreppart_flags_set (handle, node, 0);
46 [ # # ]: 0 : if (res != SHISHI_OK)
47 : 0 : return NULL;
48 : :
49 : 0 : return node;
50 : : }
51 : :
52 : : Shishi_asn1
53 : 2 : shishi_encasreppart (Shishi * handle)
54 : : {
55 : : int res;
56 : : Shishi_asn1 node;
57 : :
58 : 2 : node = shishi_asn1_encasreppart (handle);
59 [ - + ]: 2 : if (!node)
60 : 0 : return NULL;
61 : :
62 : : /* XXX remove these two: */
63 : 2 : res = shishi_asn1_write (handle, node, "key-expiration", NULL, 0);
64 [ - + ]: 2 : if (res != SHISHI_OK)
65 : 0 : puts ("urk");
66 : 2 : res = shishi_asn1_write (handle, node, "caddr", NULL, 0);
67 [ - + ]: 2 : if (res != SHISHI_OK)
68 : 0 : puts ("urk2");
69 : :
70 : 2 : return node;
71 : : }
72 : :
73 : : /**
74 : : * shishi_enckdcreppart_get_key:
75 : : * @handle: shishi handle as allocated by shishi_init().
76 : : * @enckdcreppart: input EncKDCRepPart variable.
77 : : * @key: newly allocated encryption key handle.
78 : : *
79 : : * Extract the key to use with the ticket sent in the KDC-REP
80 : : * associated with the EncKDCRepPart input variable.
81 : : *
82 : : * Return value: Returns %SHISHI_OK iff successful.
83 : : **/
84 : : int
85 : 0 : shishi_enckdcreppart_get_key (Shishi * handle,
86 : : Shishi_asn1 enckdcreppart, Shishi_key ** key)
87 : : {
88 : : int res;
89 : : char *buf;
90 : : size_t buflen;
91 : : int32_t keytype;
92 : :
93 : 0 : res = shishi_asn1_read_int32 (handle, enckdcreppart,
94 : : "key.keytype", &keytype);
95 [ # # ]: 0 : if (res != SHISHI_OK)
96 : 0 : return res;
97 : :
98 : 0 : res = shishi_asn1_read (handle, enckdcreppart, "key.keyvalue",
99 : : &buf, &buflen);
100 [ # # ]: 0 : if (res != SHISHI_OK)
101 : 0 : return res;
102 : :
103 : 0 : res = shishi_key_from_value (handle, keytype, buf, key);
104 : 0 : free (buf);
105 [ # # ]: 0 : if (res != SHISHI_OK)
106 : 0 : return res;
107 : :
108 : 0 : return SHISHI_OK;
109 : : }
110 : :
111 : : /**
112 : : * shishi_enckdcreppart_key_set:
113 : : * @handle: shishi handle as allocated by shishi_init().
114 : : * @enckdcreppart: input EncKDCRepPart variable.
115 : : * @key: key handle with information to store in enckdcreppart.
116 : : *
117 : : * Set the EncKDCRepPart.key field to key type and value of supplied
118 : : * key.
119 : : *
120 : : * Return value: Returns %SHISHI_OK iff successful.
121 : : **/
122 : : int
123 : 2 : shishi_enckdcreppart_key_set (Shishi * handle,
124 : : Shishi_asn1 enckdcreppart, Shishi_key * key)
125 : : {
126 : : int res;
127 : :
128 : 2 : res = shishi_asn1_write_integer (handle, enckdcreppart, "key.keytype",
129 : : shishi_key_type (key));
130 [ - + ]: 2 : if (res != SHISHI_OK)
131 : 0 : return SHISHI_ASN1_ERROR;
132 : :
133 : 2 : res = shishi_asn1_write (handle, enckdcreppart, "key.keyvalue",
134 : : shishi_key_value (key), shishi_key_length (key));
135 [ - + ]: 2 : if (res != SHISHI_OK)
136 : 0 : return SHISHI_ASN1_ERROR;
137 : :
138 : 2 : return SHISHI_OK;
139 : : }
140 : :
141 : : /**
142 : : * shishi_enckdcreppart_nonce_set:
143 : : * @handle: shishi handle as allocated by shishi_init().
144 : : * @enckdcreppart: input EncKDCRepPart variable.
145 : : * @nonce: nonce to set in EncKDCRepPart.
146 : : *
147 : : * Set the EncKDCRepPart.nonce field.
148 : : *
149 : : * Return value: Returns %SHISHI_OK iff successful.
150 : : **/
151 : : int
152 : 3 : shishi_enckdcreppart_nonce_set (Shishi * handle,
153 : : Shishi_asn1 enckdcreppart, uint32_t nonce)
154 : : {
155 : : int res;
156 : :
157 : 3 : res = shishi_asn1_write_uint32 (handle, enckdcreppart, "nonce", nonce);
158 [ - + ]: 3 : if (res != SHISHI_OK)
159 : 0 : return res;
160 : :
161 : 3 : return SHISHI_OK;
162 : : }
163 : :
164 : : /**
165 : : * shishi_enckdcreppart_flags_set:
166 : : * @handle: shishi handle as allocated by shishi_init().
167 : : * @enckdcreppart: input EncKDCRepPart variable.
168 : : * @flags: flags to set in EncKDCRepPart.
169 : : *
170 : : * Set the EncKDCRepPart.flags field.
171 : : *
172 : : * Return value: Returns %SHISHI_OK iff successful.
173 : : **/
174 : : int
175 : 2 : shishi_enckdcreppart_flags_set (Shishi * handle,
176 : : Shishi_asn1 enckdcreppart, int flags)
177 : : {
178 : : int res;
179 : :
180 : 2 : res = shishi_asn1_write_bitstring (handle, enckdcreppart, "flags", flags);
181 [ - + ]: 2 : if (res != SHISHI_OK)
182 : 0 : return res;
183 : :
184 : 2 : return SHISHI_OK;
185 : : }
186 : :
187 : : /**
188 : : * shishi_enckdcreppart_authtime_set:
189 : : * @handle: shishi handle as allocated by shishi_init().
190 : : * @enckdcreppart: input EncKDCRepPart variable.
191 : : * @authtime: character buffer containing a generalized time string.
192 : : *
193 : : * Set the EncTicketPart.authtime to supplied value.
194 : : *
195 : : * Return value: Returns %SHISHI_OK iff successful.
196 : : **/
197 : : int
198 : 2 : shishi_enckdcreppart_authtime_set (Shishi * handle,
199 : : Shishi_asn1 enckdcreppart,
200 : : const char *authtime)
201 : : {
202 : : int res;
203 : :
204 : 2 : res = shishi_asn1_write (handle, enckdcreppart, "authtime",
205 : : authtime, SHISHI_GENERALIZEDTIME_LENGTH);
206 [ - + ]: 2 : if (res != SHISHI_OK)
207 : 0 : return res;
208 : :
209 : 2 : return SHISHI_OK;
210 : : }
211 : :
212 : : /**
213 : : * shishi_enckdcreppart_starttime_set:
214 : : * @handle: shishi handle as allocated by shishi_init().
215 : : * @enckdcreppart: input EncKDCRepPart variable.
216 : : * @starttime: character buffer containing a generalized time string.
217 : : *
218 : : * Set the EncTicketPart.starttime to supplied value. Use a NULL
219 : : * value for @starttime to remove the field.
220 : : *
221 : : * Return value: Returns %SHISHI_OK iff successful.
222 : : **/
223 : : int
224 : 2 : shishi_enckdcreppart_starttime_set (Shishi * handle,
225 : : Shishi_asn1 enckdcreppart,
226 : : const char *starttime)
227 : : {
228 : : int res;
229 : :
230 [ - + ]: 2 : if (!starttime)
231 : 0 : res = shishi_asn1_write (handle, enckdcreppart, "starttime", NULL, 0);
232 : : else
233 : 2 : res = shishi_asn1_write (handle, enckdcreppart, "starttime",
234 : : starttime, SHISHI_GENERALIZEDTIME_LENGTH);
235 [ - + ]: 2 : if (res != SHISHI_OK)
236 : 0 : return res;
237 : :
238 : 2 : return SHISHI_OK;
239 : : }
240 : :
241 : : /**
242 : : * shishi_enckdcreppart_endtime_set:
243 : : * @handle: shishi handle as allocated by shishi_init().
244 : : * @enckdcreppart: input EncKDCRepPart variable.
245 : : * @endtime: character buffer containing a generalized time string.
246 : : *
247 : : * Set the EncTicketPart.endtime to supplied value.
248 : : *
249 : : * Return value: Returns %SHISHI_OK iff successful.
250 : : **/
251 : : int
252 : 2 : shishi_enckdcreppart_endtime_set (Shishi * handle,
253 : : Shishi_asn1 enckdcreppart,
254 : : const char *endtime)
255 : : {
256 : : int res;
257 : :
258 : 2 : res = shishi_asn1_write (handle, enckdcreppart, "endtime",
259 : : endtime, SHISHI_GENERALIZEDTIME_LENGTH);
260 [ - + ]: 2 : if (res != SHISHI_OK)
261 : 0 : return res;
262 : :
263 : 2 : return SHISHI_OK;
264 : : }
265 : :
266 : : /**
267 : : * shishi_enckdcreppart_renew_till_set:
268 : : * @handle: shishi handle as allocated by shishi_init().
269 : : * @enckdcreppart: input EncKDCRepPart variable.
270 : : * @renew_till: character buffer containing a generalized time string.
271 : : *
272 : : * Set the EncTicketPart.renew-till to supplied value. Use a NULL
273 : : * value for @renew_till to remove the field.
274 : : *
275 : : * Return value: Returns %SHISHI_OK iff successful.
276 : : **/
277 : : int
278 : 2 : shishi_enckdcreppart_renew_till_set (Shishi * handle,
279 : : Shishi_asn1 enckdcreppart,
280 : : const char *renew_till)
281 : : {
282 : : int res;
283 : :
284 [ + - ]: 2 : if (!renew_till)
285 : 2 : res = shishi_asn1_write (handle, enckdcreppart, "renew-till", NULL, 0);
286 : : else
287 : 0 : res = shishi_asn1_write (handle, enckdcreppart, "renew-till",
288 : : renew_till, SHISHI_GENERALIZEDTIME_LENGTH);
289 [ - + ]: 2 : if (res != SHISHI_OK)
290 : 0 : return res;
291 : :
292 : 2 : return SHISHI_OK;
293 : : }
294 : :
295 : : /**
296 : : * shishi_enckdcreppart_srealm_set:
297 : : * @handle: shishi handle as allocated by shishi_init().
298 : : * @enckdcreppart: EncKDCRepPart variable to set realm field in.
299 : : * @srealm: input array with name of realm.
300 : : *
301 : : * Set the server realm field in the EncKDCRepPart.
302 : : *
303 : : * Return value: Returns SHISHI_OK iff successful.
304 : : **/
305 : : int
306 : 2 : shishi_enckdcreppart_srealm_set (Shishi * handle,
307 : : Shishi_asn1 enckdcreppart,
308 : : const char *srealm)
309 : : {
310 : 2 : int res = SHISHI_OK;
311 : :
312 : 2 : res = shishi_asn1_write (handle, enckdcreppart, "srealm", srealm, 0);
313 [ - + ]: 2 : if (res != SHISHI_OK)
314 : 0 : return res;
315 : :
316 : 2 : return SHISHI_OK;
317 : : }
318 : :
319 : :
320 : : /**
321 : : * shishi_enckdcreppart_sname_set:
322 : : * @handle: shishi handle as allocated by shishi_init().
323 : : * @enckdcreppart: EncKDCRepPart variable to set server name field in.
324 : : * @name_type: type of principial, see Shishi_name_type, usually
325 : : * SHISHI_NT_UNKNOWN.
326 : : * @sname: input array with principal name.
327 : : *
328 : : * Set the server name field in the EncKDCRepPart.
329 : : *
330 : : * Return value: Returns SHISHI_OK iff successful.
331 : : **/
332 : : int
333 : 2 : shishi_enckdcreppart_sname_set (Shishi * handle,
334 : : Shishi_asn1 enckdcreppart,
335 : : Shishi_name_type name_type, char *sname[])
336 : : {
337 : 2 : int res = SHISHI_OK;
338 : : int i;
339 : : char *buf;
340 : :
341 : 2 : res = shishi_asn1_write_integer (handle, enckdcreppart,
342 : : "sname.name-type", name_type);
343 [ - + ]: 2 : if (res != SHISHI_OK)
344 : 0 : return res;
345 : :
346 : 2 : res = shishi_asn1_write (handle, enckdcreppart,
347 : : "sname.name-string", NULL, 0);
348 [ - + ]: 2 : if (res != SHISHI_OK)
349 : 0 : return res;
350 : :
351 : 2 : i = 1;
352 [ + + ]: 6 : while (sname[i - 1])
353 : : {
354 : 4 : res = shishi_asn1_write (handle, enckdcreppart, "sname.name-string",
355 : : "NEW", 1);
356 [ - + ]: 4 : if (res != SHISHI_OK)
357 : 0 : return res;
358 : :
359 : 4 : asprintf (&buf, "sname.name-string.?%d", i);
360 : 4 : res = shishi_asn1_write (handle, enckdcreppart, buf, sname[i - 1], 0);
361 : 4 : free (buf);
362 [ - + ]: 4 : if (res != SHISHI_OK)
363 : 0 : return res;
364 : :
365 : 4 : i++;
366 : : }
367 : :
368 : 2 : return SHISHI_OK;
369 : : }
370 : :
371 : : int
372 : 0 : shishi_enckdcreppart_server_set (Shishi * handle,
373 : : Shishi_asn1 enckdcreppart,
374 : : const char *server)
375 : : {
376 : : char *tmpserver;
377 : : char **serverbuf;
378 : 0 : char *tokptr = NULL;
379 : : int res;
380 : : int i;
381 : :
382 : 0 : tmpserver = xstrdup (server);
383 : :
384 : 0 : serverbuf = xmalloc (sizeof (*serverbuf));
385 [ # # ]: 0 : for (i = 0;
386 [ # # ]: 0 : (serverbuf[i] = strtok_r (i == 0 ? tmpserver : NULL, "/", &tokptr));
387 : 0 : i++)
388 : : {
389 : 0 : serverbuf = xrealloc (serverbuf, (i + 2) * sizeof (*serverbuf));
390 : : }
391 : :
392 : 0 : res = shishi_enckdcreppart_sname_set (handle, enckdcreppart,
393 : : SHISHI_NT_PRINCIPAL, serverbuf);
394 [ # # ]: 0 : if (res != SHISHI_OK)
395 : 0 : return res;
396 : :
397 : 0 : free (serverbuf);
398 : 0 : free (tmpserver);
399 : :
400 : 0 : return SHISHI_OK;
401 : : }
402 : :
403 : : int
404 : 0 : shishi_enckdcreppart_srealmserver_set (Shishi * handle,
405 : : Shishi_asn1 enckdcreppart,
406 : : const char *srealm, const char *server)
407 : : {
408 : : int res;
409 : :
410 : 0 : res = shishi_enckdcreppart_srealm_set (handle, enckdcreppart, srealm);
411 [ # # ]: 0 : if (res != SHISHI_OK)
412 : 0 : return res;
413 : :
414 : 0 : res = shishi_enckdcreppart_server_set (handle, enckdcreppart, server);
415 [ # # ]: 0 : if (res != SHISHI_OK)
416 : 0 : return res;
417 : :
418 : 0 : return SHISHI_OK;
419 : : }
420 : :
421 : : /**
422 : : * shishi_enckdcreppart_populate_encticketpart:
423 : : * @handle: shishi handle as allocated by shishi_init().
424 : : * @enckdcreppart: input EncKDCRepPart variable.
425 : : * @encticketpart: input EncTicketPart variable.
426 : : *
427 : : * Set the flags, authtime, starttime, endtime, renew-till and caddr
428 : : * fields of the EncKDCRepPart to the corresponding values in the
429 : : * EncTicketPart.
430 : : *
431 : : * Return value: Returns %SHISHI_OK iff successful.
432 : : **/
433 : : int
434 : 0 : shishi_enckdcreppart_populate_encticketpart (Shishi * handle,
435 : : Shishi_asn1 enckdcreppart,
436 : : Shishi_asn1 encticketpart)
437 : : {
438 : : char *buf;
439 : : size_t buflen;
440 : : int res;
441 : :
442 : 0 : res = shishi_asn1_read (handle, encticketpart, "flags", &buf, &buflen);
443 [ # # ]: 0 : if (res != SHISHI_OK)
444 : 0 : return SHISHI_ASN1_ERROR;
445 : :
446 : 0 : res = shishi_asn1_write (handle, enckdcreppart, "flags", buf, buflen);
447 : 0 : free (buf);
448 [ # # ]: 0 : if (res != SHISHI_OK)
449 : 0 : return SHISHI_ASN1_ERROR;
450 : :
451 : 0 : res = shishi_asn1_read (handle, encticketpart, "authtime", &buf, &buflen);
452 [ # # ]: 0 : if (res != SHISHI_OK)
453 : 0 : return SHISHI_ASN1_ERROR;
454 : :
455 : 0 : res = shishi_asn1_write (handle, enckdcreppart, "authtime", buf, buflen);
456 : 0 : free (buf);
457 [ # # ]: 0 : if (res != SHISHI_OK)
458 : 0 : return SHISHI_ASN1_ERROR;
459 : :
460 : 0 : res = shishi_asn1_read (handle, encticketpart, "starttime", &buf, &buflen);
461 [ # # # # ]: 0 : if (res != SHISHI_OK && res != SHISHI_ASN1_NO_ELEMENT)
462 : 0 : return SHISHI_ASN1_ERROR;
463 : :
464 [ # # ]: 0 : if (res == SHISHI_ASN1_NO_ELEMENT)
465 : 0 : res = shishi_asn1_write (handle, enckdcreppart, "starttime", NULL, 0);
466 : : else
467 : : {
468 : 0 : res = shishi_asn1_write (handle, enckdcreppart, "starttime",
469 : : buf, buflen);
470 : 0 : free (buf);
471 : : }
472 [ # # ]: 0 : if (res != SHISHI_OK)
473 : 0 : return SHISHI_ASN1_ERROR;
474 : :
475 : 0 : res = shishi_asn1_read (handle, encticketpart, "endtime", &buf, &buflen);
476 [ # # ]: 0 : if (res != SHISHI_OK)
477 : 0 : return SHISHI_ASN1_ERROR;
478 : :
479 : 0 : res = shishi_asn1_write (handle, enckdcreppart, "endtime", buf, buflen);
480 : 0 : free (buf);
481 [ # # ]: 0 : if (res != SHISHI_OK)
482 : 0 : return SHISHI_ASN1_ERROR;
483 : :
484 : 0 : res = shishi_asn1_read (handle, encticketpart, "renew-till", &buf, &buflen);
485 [ # # # # ]: 0 : if (res != SHISHI_OK && res != SHISHI_ASN1_NO_ELEMENT)
486 : 0 : return SHISHI_ASN1_ERROR;
487 : :
488 [ # # ]: 0 : if (res == SHISHI_ASN1_NO_ELEMENT)
489 : 0 : res = shishi_asn1_write (handle, enckdcreppart, "renew-till", NULL, 0);
490 : : else
491 : : {
492 : 0 : res = shishi_asn1_write (handle, enckdcreppart,
493 : : "renew-till", buf, buflen);
494 : 0 : free (buf);
495 : : }
496 [ # # ]: 0 : if (res != SHISHI_OK)
497 : 0 : return SHISHI_ASN1_ERROR;
498 : :
499 : : /* XXX copy caddr too */
500 : :
501 : 0 : return SHISHI_OK;
502 : : }
|
