Debian Codegraph @

lib/kadm5/marshall.c

raw
1 /*
2 * Copyright (c) 1997 - 1999 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * 3. Neither the name of the Institute nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34 #include "kadm5_locl.h"
35
36 RCSID("$Id$");
37
38 int
39 kadm5_some_keys_are_bogus(size_t n_keys, krb5_key_data *keys)
40 {
41 size_t i;
42
43 for (i = 0; i < n_keys; i++) {
44 krb5_key_data *key = &keys[i];
45 if (key->key_data_length[0] == sizeof(KADM5_BOGUS_KEY_DATA) - 1 &&
46 ct_memcmp(key->key_data_contents[1], KADM5_BOGUS_KEY_DATA,
47 key->key_data_length[0]) == 0)
48 return 1;
49 }
50 return 0;
51 }
52
53 int
54 kadm5_all_keys_are_bogus(size_t n_keys, krb5_key_data *keys)
55 {
56 size_t i;
57
58 if (n_keys == 0)
59 return 0;
60
61 for (i = 0; i < n_keys; i++) {
62 krb5_key_data *key = &keys[i];
63 if (key->key_data_length[0] != sizeof(KADM5_BOGUS_KEY_DATA) - 1 ||
64 ct_memcmp(key->key_data_contents[1], KADM5_BOGUS_KEY_DATA,
65 key->key_data_length[0]) != 0)
66 return 0;
67 }
68 return 1;
69 }
70
71 kadm5_ret_t
72 kadm5_store_key_data(krb5_storage *sp,
73 krb5_key_data *key)
74 {
75 krb5_data c;
76 krb5_store_int32(sp, key->key_data_ver);
77 krb5_store_int32(sp, key->key_data_kvno);
78 krb5_store_int32(sp, key->key_data_type[0]);
79 c.length = key->key_data_length[0];
80 c.data = key->key_data_contents[0];
81 krb5_store_data(sp, c);
82 krb5_store_int32(sp, key->key_data_type[1]);
83 c.length = key->key_data_length[1];
84 c.data = key->key_data_contents[1];
85 krb5_store_data(sp, c);
86 return 0;
87 }
88
89 kadm5_ret_t
90 kadm5_store_fake_key_data(krb5_storage *sp,
91 krb5_key_data *key)
92 {
93 krb5_data c;
94
95 krb5_store_int32(sp, key->key_data_ver);
96 krb5_store_int32(sp, key->key_data_kvno);
97 krb5_store_int32(sp, key->key_data_type[0]);
98
99 /*
100 * This is the key contents. We want it to be obvious to the client
101 * (if it really did want the keys) that the key won't work.
102 * 32-bit keys are no good for any enctype, so that should do.
103 * Clients that didn't need keys will ignore this, and clients that
104 * did want keys will either fail or they'll, say, create bogus
105 * keytab entries that will subsequently fail to be useful.
106 */
107 c.length = sizeof (KADM5_BOGUS_KEY_DATA) - 1;
108 c.data = KADM5_BOGUS_KEY_DATA;
109 krb5_store_data(sp, c);
110
111 /* This is the salt -- no need to send garbage */
112 krb5_store_int32(sp, key->key_data_type[1]);
113 c.length = key->key_data_length[1];
114 c.data = key->key_data_contents[1];
115 krb5_store_data(sp, c);
116 return 0;
117 }
118
119 kadm5_ret_t
120 kadm5_ret_key_data(krb5_storage *sp,
121 krb5_key_data *key)
122 {
123 krb5_data c;
124 int32_t tmp;
125 krb5_ret_int32(sp, &tmp);
126 key->key_data_ver = tmp;
127 krb5_ret_int32(sp, &tmp);
128 key->key_data_kvno = tmp;
129 krb5_ret_int32(sp, &tmp);
130 key->key_data_type[0] = tmp;
131 krb5_ret_data(sp, &c);
132 key->key_data_length[0] = c.length;
133 key->key_data_contents[0] = c.data;
134 krb5_ret_int32(sp, &tmp);
135 key->key_data_type[1] = tmp;
136 krb5_ret_data(sp, &c);
137 key->key_data_length[1] = c.length;
138 key->key_data_contents[1] = c.data;
139 return 0;
140 }
141
142 kadm5_ret_t
143 kadm5_store_tl_data(krb5_storage *sp,
144 krb5_tl_data *tl)
145 {
146 krb5_data c;
147 krb5_store_int32(sp, tl->tl_data_type);
148 c.length = tl->tl_data_length;
149 c.data = tl->tl_data_contents;
150 krb5_store_data(sp, c);
151 return 0;
152 }
153
154 kadm5_ret_t
155 kadm5_ret_tl_data(krb5_storage *sp,
156 krb5_tl_data *tl)
157 {
158 krb5_data c;
159 int32_t tmp;
160 krb5_ret_int32(sp, &tmp);
161 tl->tl_data_type = tmp;
162 krb5_ret_data(sp, &c);
163 tl->tl_data_length = c.length;
164 tl->tl_data_contents = c.data;
165 return 0;
166 }
167
168 static kadm5_ret_t
169 store_principal_ent(krb5_storage *sp,
170 kadm5_principal_ent_t princ,
171 uint32_t mask, int wkeys)
172 {
173 int i;
174
175 if (mask & KADM5_PRINCIPAL)
176 krb5_store_principal(sp, princ->principal);
177 if (mask & KADM5_PRINC_EXPIRE_TIME)
178 krb5_store_int32(sp, princ->princ_expire_time);
179 if (mask & KADM5_PW_EXPIRATION)
180 krb5_store_int32(sp, princ->pw_expiration);
181 if (mask & KADM5_LAST_PWD_CHANGE)
182 krb5_store_int32(sp, princ->last_pwd_change);
183 if (mask & KADM5_MAX_LIFE)
184 krb5_store_int32(sp, princ->max_life);
185 if (mask & KADM5_MOD_NAME) {
186 krb5_store_int32(sp, princ->mod_name != NULL);
187 if(princ->mod_name)
188 krb5_store_principal(sp, princ->mod_name);
189 }
190 if (mask & KADM5_MOD_TIME)
191 krb5_store_int32(sp, princ->mod_date);
192 if (mask & KADM5_ATTRIBUTES)
193 krb5_store_int32(sp, princ->attributes);
194 if (mask & KADM5_KVNO)
195 krb5_store_int32(sp, princ->kvno);
196 if (mask & KADM5_MKVNO)
197 krb5_store_int32(sp, princ->mkvno);
198 if (mask & KADM5_POLICY) {
199 krb5_store_int32(sp, princ->policy != NULL);
200 if(princ->policy)
201 krb5_store_string(sp, princ->policy);
202 }
203 if (mask & KADM5_AUX_ATTRIBUTES)
204 krb5_store_int32(sp, princ->aux_attributes);
205 if (mask & KADM5_MAX_RLIFE)
206 krb5_store_int32(sp, princ->max_renewable_life);
207 if (mask & KADM5_LAST_SUCCESS)
208 krb5_store_int32(sp, princ->last_success);
209 if (mask & KADM5_LAST_FAILED)
210 krb5_store_int32(sp, princ->last_failed);
211 if (mask & KADM5_FAIL_AUTH_COUNT)
212 krb5_store_int32(sp, princ->fail_auth_count);
213 if (mask & KADM5_KEY_DATA) {
214 krb5_store_int32(sp, princ->n_key_data);
215 for(i = 0; i < princ->n_key_data; i++) {
216 if (wkeys)
217 kadm5_store_key_data(sp, &princ->key_data[i]);
218 else
219 kadm5_store_fake_key_data(sp, &princ->key_data[i]);
220 }
221 }
222 if (mask & KADM5_TL_DATA) {
223 krb5_tl_data *tp;
224
225 krb5_store_int32(sp, princ->n_tl_data);
226 for(tp = princ->tl_data; tp; tp = tp->tl_data_next)
227 kadm5_store_tl_data(sp, tp);
228 }
229 return 0;
230 }
231
232
233 kadm5_ret_t
234 kadm5_store_principal_ent(krb5_storage *sp,
235 kadm5_principal_ent_t princ)
236 {
237 return store_principal_ent (sp, princ, ~0, 1);
238 }
239
240 kadm5_ret_t
241 kadm5_store_principal_ent_nokeys(krb5_storage *sp,
242 kadm5_principal_ent_t princ)
243 {
244 return store_principal_ent (sp, princ, ~0, 0);
245 }
246
247 kadm5_ret_t
248 kadm5_store_principal_ent_mask(krb5_storage *sp,
249 kadm5_principal_ent_t princ,
250 uint32_t mask)
251 {
252 krb5_store_int32(sp, mask);
253 return store_principal_ent (sp, princ, mask, 1);
254 }
255
256 static kadm5_ret_t
257 ret_principal_ent(krb5_storage *sp,
258 kadm5_principal_ent_t princ,
259 uint32_t mask)
260 {
261 int i;
262 int32_t tmp;
263
264 if (mask & KADM5_PRINCIPAL)
265 krb5_ret_principal(sp, &princ->principal);
266
267 if (mask & KADM5_PRINC_EXPIRE_TIME) {
268 krb5_ret_int32(sp, &tmp);
269 princ->princ_expire_time = tmp;
270 }
271 if (mask & KADM5_PW_EXPIRATION) {
272 krb5_ret_int32(sp, &tmp);
273 princ->pw_expiration = tmp;
274 }
275 if (mask & KADM5_LAST_PWD_CHANGE) {
276 krb5_ret_int32(sp, &tmp);
277 princ->last_pwd_change = tmp;
278 }
279 if (mask & KADM5_MAX_LIFE) {
280 krb5_ret_int32(sp, &tmp);
281 princ->max_life = tmp;
282 }
283 if (mask & KADM5_MOD_NAME) {
284 krb5_ret_int32(sp, &tmp);
285 if(tmp)
286 krb5_ret_principal(sp, &princ->mod_name);
287 else
288 princ->mod_name = NULL;
289 }
290 if (mask & KADM5_MOD_TIME) {
291 krb5_ret_int32(sp, &tmp);
292 princ->mod_date = tmp;
293 }
294 if (mask & KADM5_ATTRIBUTES) {
295 krb5_ret_int32(sp, &tmp);
296 princ->attributes = tmp;
297 }
298 if (mask & KADM5_KVNO) {
299 krb5_ret_int32(sp, &tmp);
300 princ->kvno = tmp;
301 }
302 if (mask & KADM5_MKVNO) {
303 krb5_ret_int32(sp, &tmp);
304 princ->mkvno = tmp;
305 }
306 if (mask & KADM5_POLICY) {
307 krb5_ret_int32(sp, &tmp);
308 if(tmp)
309 krb5_ret_string(sp, &princ->policy);
310 else
311 princ->policy = NULL;
312 }
313 if (mask & KADM5_AUX_ATTRIBUTES) {
314 krb5_ret_int32(sp, &tmp);
315 princ->aux_attributes = tmp;
316 }
317 if (mask & KADM5_MAX_RLIFE) {
318 krb5_ret_int32(sp, &tmp);
319 princ->max_renewable_life = tmp;
320 }
321 if (mask & KADM5_LAST_SUCCESS) {
322 krb5_ret_int32(sp, &tmp);
323 princ->last_success = tmp;
324 }
325 if (mask & KADM5_LAST_FAILED) {
326 krb5_ret_int32(sp, &tmp);
327 princ->last_failed = tmp;
328 }
329 if (mask & KADM5_FAIL_AUTH_COUNT) {
330 krb5_ret_int32(sp, &tmp);
331 princ->fail_auth_count = tmp;
332 }
333 if (mask & KADM5_KEY_DATA) {
334 krb5_ret_int32(sp, &tmp);
335 princ->n_key_data = tmp;
336 princ->key_data = malloc(princ->n_key_data * sizeof(*princ->key_data));
337 if (princ->key_data == NULL && princ->n_key_data != 0)
338 return ENOMEM;
339 for(i = 0; i < princ->n_key_data; i++)
340 kadm5_ret_key_data(sp, &princ->key_data[i]);
341 }
342 if (mask & KADM5_TL_DATA) {
343 krb5_ret_int32(sp, &tmp);
344 princ->n_tl_data = tmp;
345 princ->tl_data = NULL;
346 for(i = 0; i < princ->n_tl_data; i++){
347 krb5_tl_data *tp = malloc(sizeof(*tp));
348 if (tp == NULL)
349 return ENOMEM;
350 kadm5_ret_tl_data(sp, tp);
351 tp->tl_data_next = princ->tl_data;
352 princ->tl_data = tp;
353 }
354 }
355 return 0;
356 }
357
358 kadm5_ret_t
359 kadm5_ret_principal_ent(krb5_storage *sp,
360 kadm5_principal_ent_t princ)
361 {
362 return ret_principal_ent (sp, princ, ~0);
363 }
364
365 kadm5_ret_t
366 kadm5_ret_principal_ent_mask(krb5_storage *sp,
367 kadm5_principal_ent_t princ,
368 uint32_t *mask)
369 {
370 int32_t tmp;
371
372 krb5_ret_int32 (sp, &tmp);
373 *mask = tmp;
374 return ret_principal_ent (sp, princ, *mask);
375 }
376
377 kadm5_ret_t
378 _kadm5_marshal_params(krb5_context context,
379 kadm5_config_params *params,
380 krb5_data *out)
381 {
382 krb5_storage *sp = krb5_storage_emem();
383
384 krb5_store_int32(sp, params->mask & (KADM5_CONFIG_REALM));
385
386 if(params->mask & KADM5_CONFIG_REALM)
387 krb5_store_string(sp, params->realm);
388 krb5_storage_to_data(sp, out);
389 krb5_storage_free(sp);
390
391 return 0;
392 }
393
394 kadm5_ret_t
395 _kadm5_unmarshal_params(krb5_context context,
396 krb5_data *in,
397 kadm5_config_params *params)
398 {
399 krb5_error_code ret;
400 krb5_storage *sp;
401 int32_t mask;
402
403 sp = krb5_storage_from_data(in);
404 if (sp == NULL)
405 return ENOMEM;
406
407 ret = krb5_ret_int32(sp, &mask);
408 if (ret)
409 goto out;
410 params->mask = mask;
411
412 if(params->mask & KADM5_CONFIG_REALM)
413 ret = krb5_ret_string(sp, &params->realm);
414 out:
415 krb5_storage_free(sp);
416
417 return ret;
418 }