source: libabac/abac_attribute.c @ d2b198c

abac0-leakabac0-meitvf-new-xml
Last change on this file since d2b198c was d2b198c, checked in by Ted Faber <faber@…>, 11 years ago

Another checkpoint. We can now read mnemonics from credentials.

  • Property mode set to 100644
File size: 13.5 KB
Line 
1
2/* abac_attribute.c */
3
4#define _GNU_SOURCE
5#include <stdio.h>
6#include <assert.h>
7#include <ctype.h>
8#include <string.h>
9#include <time.h>
10
11#include "libabac_common.h"
12#include "abac_list.h"
13#include "abac_util.h"
14#include "abac_xml.h"
15
16#define ROLE_SEPARATOR " <- "
17#define INTERSECTION_SEP " & "
18#define SHA1_LENGTH 40
19
20#define DEFAULT_OUTPUT_FORMAT "GENIv1.1"
21
22static int debug=0;
23
24// a GENI XML attribute chunk might contain multiple
25// attribute rules. It will be translate into multiple
26// abac_attribute structures but with cert ptr pointing
27// to the same xml chunk
28// issuer can be missing but then it won't be bakable
29// unless it is baked just for creddy's roles call
30struct _abac_attribute_t {
31    abac_id_t *issuer_id; 
32    char *role;
33    long validity;
34    int ntails;
35
36    char *head_string;
37    char **tail_strings;
38    char *output_format;
39    abac_keyid_map_t *keymap;
40
41    abac_chunk_t cert; // the XML chunk
42};
43
44char *abac_attribute_role_string(abac_attribute_t *attr);
45extern abac_id_t *abac_verifier_lookup_id(abac_list_t*, char *keyid);
46static char *_validate_principal(char *keyid);
47
48/************************************************************/
49abac_chunk_t abac_attribute_cert(abac_attribute_t *ptr)
50{
51    assert(ptr);
52    return ptr->cert;
53}
54
55abac_id_t *abac_attribute_issuer_id(abac_attribute_t *ptr)
56{
57    assert(ptr);
58    return ptr->issuer_id;
59}
60
61/* Get the format for this attribute to be output in.  This is NULL if the
62 * attribute has been read from a file. */
63char *abac_attribute_get_output_format(abac_attribute_t *a) {
64    return a->output_format;
65}
66
67/* Set the format for this attribute to be output in.  Valid formats are:
68 * GENIv1.0
69 * GENIv1.1
70 */
71void abac_attribute_set_output_format(abac_attribute_t *a, char *fmt) {
72    if (a->output_format) 
73        free(a->output_format);
74    a->output_format = abac_xstrdup(fmt);
75}
76
77
78// validity is measured in seconds (as of 0.2.0)
79// Acme.customer
80int abac_attribute_create(abac_attribute_t **ret, abac_id_t *issuer_id, char *role, long validity) {
81    libabac_init();
82    if (!abac_id_has_privkey(issuer_id))
83        return ABAC_ATTRIBUTE_ISSUER_NOKEY;
84    if (!abac_clean_name(role))
85        return ABAC_ATTRIBUTE_INVALID_ROLE;
86    if (validity < 0)
87        return ABAC_ATTRIBUTE_INVALID_VALIDITY;
88    if (!abac_id_still_valid(issuer_id))
89        return ABAC_ATTRIBUTE_INVALID_ISSUER;
90
91    if(validity == 0) validity = (long)(60*60*24*(365));
92
93    abac_attribute_t *attr = abac_xmalloc(sizeof(abac_attribute_t));
94    if(issuer_id) attr->issuer_id = abac_id_dup(issuer_id);
95        else attr->issuer_id = NULL;
96    attr->role = abac_xstrdup(role);
97    attr->validity = validity;
98
99    attr->head_string = NULL;
100    asprintf(&attr->head_string,"%s.%s",abac_id_keyid(issuer_id),role);
101    attr->ntails = 0;
102    attr->tail_strings = NULL;
103    attr->keymap = NULL;
104
105    attr->output_format = abac_xstrdup(DEFAULT_OUTPUT_FORMAT);
106
107    // NULL until baked
108    attr->cert.ptr=NULL;
109    attr->cert.len=0;
110
111    *ret = attr;
112    return ABAC_SUCCESS;
113}
114
115/**
116 * Get the validity period.(xml module returns the diff from expire time - now()
117 */
118int abac_attribute_validity(abac_attribute_t *attr,struct tm *not_before,struct tm *not_after) {
119    assert(attr);
120    memset(not_before, 0, sizeof(struct tm));
121    memset(not_after, 0, sizeof(struct tm));
122
123    time_t now;
124    time(&now);
125    gmtime_r(&now, not_before);
126    char *xml=(char *)attr->cert.ptr;
127    long validity=get_validity_from_xml(xml);
128
129    time_t etime = now + validity;
130    gmtime_r(&etime, not_after);
131
132    if(debug) fprintf(stderr,"validity from the xml blob is %ld\n",validity);
133    if(validity == 0)
134        return ABAC_FAILURE;
135    return ABAC_SUCCESS;
136}
137
138int abac_attribute_still_valid(abac_attribute_t *attr)
139{
140    assert(attr);
141    assert(attr->cert.ptr);
142    long v=get_validity_from_xml((char *)attr->cert.ptr);
143    if (v > 0.0)
144        return 1;
145    else return 0;
146}
147
148int abac_attribute_add_tail(abac_attribute_t *attr, char *string) {
149    assert(attr);
150
151    char **old_tail = attr->tail_strings;
152    int newsize = (attr->ntails+1)*sizeof(char *);
153
154    if ( !(attr->tail_strings = realloc(attr->tail_strings, newsize))) {
155        attr->tail_strings = old_tail;
156        return 0;
157    }
158    attr->tail_strings[attr->ntails++] = abac_xstrdup(string);
159    return 1;
160}
161
162
163void abac_attribute_set_head(abac_attribute_t *attr, char *string)
164{
165    assert(attr);
166    attr->head_string=string;
167}
168
169char *abac_attribute_get_head(abac_attribute_t *attr)
170{
171    assert(attr);
172    return attr->head_string;
173}
174
175/*
176 * Return the number of tail strings
177 */
178int abac_attribute_get_ntails(abac_attribute_t *attr) {
179    assert(attr);
180    return attr->ntails;
181}
182
183/*
184 * Return the nth tail string or NULL if it is undefined
185 */
186
187char *abac_attribute_get_tail_n(abac_attribute_t *attr, int n) {
188    assert(attr);
189    if ( n < 0 || n > attr->ntails) return NULL;
190    return attr->tail_strings[n];
191}
192
193
194/* A.b->C, return copy of a A */
195char *abac_attribute_get_principal(abac_attribute_t *attr)
196{
197    char *role_string=abac_attribute_role_string(attr);
198    /* make an copy */
199    char *tmp=strdup(role_string);
200    char *head_tail[2];
201    int ret = 2;
202    abac_split(tmp, "<-", head_tail, &ret);
203    if (ret != 2) goto err;
204    abac_split(head_tail[0], ".", head_tail, &ret);
205    if (ret != 2) goto err;
206    char *prin=strdup(head_tail[0]);
207    free(tmp);
208    return prin;
209
210err:     
211     free(tmp);
212     return NULL;
213}
214
215int abac_attribute_principal(abac_attribute_t *attr, char *keyid) {
216    char *copy = _validate_principal(keyid);
217    if (copy == NULL)
218        return 0;
219
220    return abac_attribute_add_tail(attr,copy);
221}
222
223int abac_attribute_role(abac_attribute_t *attr, char *keyid, char *role) {
224    if (!abac_clean_name(role))
225        return 0;
226
227    char *copy = _validate_principal(keyid);
228    char *newcopy=NULL;
229    if (copy == NULL)
230        return 0;
231
232    asprintf(&newcopy,"%s.%s", copy,role);
233    free(copy);
234    return abac_attribute_add_tail(attr, newcopy);
235}
236
237int abac_attribute_linking_role(abac_attribute_t *attr, char *keyid, char *role, char *linked) {
238    if (!abac_clean_name(role) || !abac_clean_name(linked))
239        return 0;
240
241    char *copy = _validate_principal(keyid);
242    if (copy == NULL)
243        return 0;
244
245    char *newcopy=NULL;
246    asprintf(&newcopy,"%s.%s.%s", copy,role,linked);
247    free(copy);
248    return abac_attribute_add_tail(attr, newcopy);
249}
250
251
252
253// 0 for fail to bake, 1 is baked okay
254int abac_attribute_bake(abac_attribute_t *attr) {
255    assert(attr);
256    assert(attr->head_string);
257    assert(attr->tail_strings);
258
259    abac_chunk_t id_chunk = { NULL, 0 };
260    int ret=abac_id_PEM(attr->issuer_id, &id_chunk);
261    if(ret != ABAC_CERT_SUCCESS)
262        return 0; 
263
264/* Make an new GENI abac credential with the rt0 rule that expires secs from
265 * now.  cert is the PEM encoded X.509 of the issuer's certificate as a string.
266 * certlen is the length of cert.  Returns the XML. Caller is responsible for
267 * freeing it. */
268    char *attr_cert=make_credential(attr, attr->validity, (char *)id_chunk.ptr, id_chunk.len);
269
270    if (attr_cert == NULL)
271        return 0;
272
273    attr->cert.ptr = (unsigned char *)attr_cert;
274    attr->cert.len = strlen(attr_cert);
275
276    /* free(role_string); */
277    return 1;
278}
279
280// make an explicit copy
281abac_chunk_t abac_attribute_cert_chunk(abac_attribute_t *attr) {
282    abac_chunk_t chunk= {NULL,0};
283
284    if (attr->cert.ptr == NULL)
285        return chunk;
286
287    /* return the xml chunk */
288    chunk.ptr= (unsigned char *)abac_xstrdup((char *)attr->cert.ptr);
289    chunk.len=attr->cert.len;
290    return chunk;
291}
292
293int abac_attribute_baked(abac_attribute_t *attr) {
294    return (attr->cert.ptr != NULL);
295}
296
297
298static abac_attribute_t *_load_attr(abac_list_t *id_certs,char *rstring, char *xml, abac_keyid_map_t *km)
299{
300    /* make a copy of rle_string */
301    char *role_string=abac_xstrdup(rstring);
302
303    if(debug) fprintf(stderr,"loading -> %s \n", role_string);
304
305    char *head_tail[2];
306    char *role_rest[2];
307    int ret = 2;
308    abac_split(role_string, "<-", head_tail, &ret);
309    if (ret != 2) return NULL; 
310
311    char *keyid=get_keyid_from_xml(xml);
312    abac_id_t *issuer_id=abac_verifier_lookup_id(id_certs,keyid);
313
314    long validity=get_validity_from_xml(xml);
315   
316    abac_attribute_t *attr = abac_xmalloc(sizeof(abac_attribute_t));
317    if(issuer_id)
318        attr->issuer_id = abac_id_dup(issuer_id);
319    else attr->issuer_id=NULL;
320    attr->validity = validity;
321    attr->ntails = 0;
322    attr->tail_strings = NULL;
323
324    /* If there is a keymap, make a reference to it. */
325    if ( km ) attr->keymap = abac_keyid_map_dup(km);
326    else attr->keymap = NULL;
327
328
329    attr->head_string = abac_xstrdup(head_tail[0]);
330    do {
331        ret = 2;
332        abac_split(head_tail[1], " & ", role_rest, &ret);
333        abac_attribute_add_tail(attr, abac_xstrdup(role_rest[0]));
334        head_tail[1] =role_rest[1];
335    } while (ret == 2);
336
337    char *tmp=strstr(attr->head_string,".");
338    attr->role =abac_xstrdup(tmp+1);
339
340    attr->cert.ptr=(unsigned char *)abac_xstrdup(xml);
341    attr->cert.len=strlen(xml);
342    attr->output_format = NULL;
343
344    return attr;
345}
346
347abac_list_t *abac_attribute_certs_from_file(abac_list_t *id_certs,char *filename)
348{
349    libabac_init();
350    abac_list_t *alist=abac_list_new();
351    char *xml=NULL;
352    char *rt0=NULL;
353    abac_keyid_map_t *km = abac_keyid_map_new();
354
355    char **rt0s=read_credential((void *)id_certs,filename, &xml, km);
356    if(rt0s == NULL) return alist;
357    if(xml == NULL || strlen(xml)==0) return alist;
358
359    abac_attribute_t *attr;
360
361    int i=0;
362    do {
363        rt0 = rt0s[i]; 
364        if(rt0 == NULL) break;
365        attr=_load_attr(id_certs,rt0, xml, km);
366        if(attr)
367            abac_list_add(alist, attr);
368        free(rt0);
369        i++;
370    } while (rt0s[i] !=NULL);
371    abac_keyid_map_free(km);
372
373    free(rt0s);
374    free(xml);
375
376    return alist;
377}
378
379abac_list_t *abac_attribute_certs_from_chunk(abac_list_t *id_certs,abac_chunk_t chunk) {
380    libabac_init();
381
382    abac_list_t *alist=abac_list_new();
383    char *xml=(char *)chunk.ptr;
384    abac_keyid_map_t *km = abac_keyid_map_new();
385
386    if(chunk.len==0) return alist;
387
388    char **rt0s=get_rt0_from_xml((void *) id_certs, xml, km);
389    char *rt0=NULL;
390    if(rt0s==NULL) return alist;
391
392    abac_attribute_t *attr;
393    int i=0;
394    do {
395        rt0 = rt0s[i]; 
396        if(rt0 == NULL) break;
397        attr=_load_attr(id_certs,rt0, xml, km);
398        if(attr)
399            abac_list_add(alist, attr);
400        free(rt0);
401        i++;
402    } while (rt0s[i] !=NULL);
403    abac_keyid_map_free(km);
404
405    free(rt0s);
406    return alist;
407}
408
409// returns ABAC_FAILURE if the cert hasn't been baked
410int abac_attribute_write(abac_attribute_t *attr, FILE *out) {
411    assert(attr != NULL);
412
413    if (attr->cert.ptr == NULL)
414        return ABAC_FAILURE;
415
416    // write to file
417    fwrite(attr->cert.ptr, attr->cert.len, 1, out);
418
419    return ABAC_SUCCESS;
420}
421
422// returns ABAC_FAILURE if the cert hasn't been baked
423int abac_attribute_write_file(abac_attribute_t *attr, const char *fname) {
424    if (attr->cert.ptr == NULL)
425        return ABAC_FAILURE;
426
427    FILE *fp=fopen(fname,"w+");
428    if(fp) {
429         // write to file
430         fwrite(attr->cert.ptr, attr->cert.len, 1, fp);
431    } else return ABAC_FAILURE;
432    fclose(fp);
433
434    return ABAC_SUCCESS;
435}
436
437/* return a copy of the local name mappings, if any.  The returned value is not
438 * reference counted, so callers will need to call abac_keyid_map_dup on it if
439 * they need to keep a copy of the pointer.
440 */
441abac_keyid_map_t *abac_attribute_get_keyid_map(abac_attribute_t *attr) {
442    return attr->keymap;
443}
444
445
446void abac_attribute_free(abac_attribute_t *attr) {
447
448if(debug) fprintf(stderr,"calling abac_attribute_free on %s\n", attr->head_string);
449    int i = 0;
450
451    if (attr == NULL)
452        return;
453
454    if(attr->issuer_id) abac_id_free(attr->issuer_id);
455
456    free(attr->role);
457    free(attr->head_string);
458    for (i=0; i < attr->ntails; i++) 
459        free(attr->tail_strings[i]);
460    free(attr->tail_strings);
461    if ( attr->output_format ) 
462        free(attr->output_format);
463
464    if ( attr->keymap ) abac_keyid_map_free(attr->keymap);
465
466/* XXX this can not be free as if it is a char string
467    free(attr->cert.ptr);
468*/
469
470    free(attr);
471}
472
473//
474// Helper functions below
475//
476
477// validate a princpal's name
478// makes sure it's a valid SHA1 identifier
479// return values:
480//  success: malloc'd copy with all hex digits lowercase
481//  fail: NULL
482static char *_validate_principal(char *keyid) {
483    int i;
484    char *copy = NULL;
485
486    if (strlen(keyid) != SHA1_LENGTH)
487        return NULL;
488
489    copy = abac_xstrdup(keyid);
490    for (i = 0; i < SHA1_LENGTH; ++i) {
491        copy[i] = tolower(copy[i]);
492        if (!isxdigit(copy[i]))
493            goto error;
494    }
495
496    return copy;
497
498error:
499    free(copy);
500    return NULL;
501}
502
503static int abac_attribute_role_string_size(abac_attribute_t *attr) {
504    int sz = 3; /* Start with the end of string character and <-*/
505    int i;      /* Scratch */
506
507    if ( !attr) return sz;
508    if ( attr->head_string) 
509        sz += strlen(attr->head_string);
510    for (i = 0; i < attr->ntails; i++) 
511        if ( attr->tail_strings[i]) 
512            sz += strlen(attr->tail_strings[i]);
513    /* " & " between each pair of tails */
514    sz += 3 * (attr->ntails-1);
515    return sz;
516}
517
518// combine up the attribute's rule string, explicit copy
519char *abac_attribute_role_string(abac_attribute_t *attr) {
520    assert(attr);
521
522    int sz = abac_attribute_role_string_size(attr);
523    char *role_string=abac_xmalloc(sz);
524    int i;
525
526    if ( !role_string) return NULL;
527
528    sz -= snprintf(role_string, sz, "%s<-", attr->head_string);
529    for ( i = 0 ; i < attr->ntails; i++ ) {
530        if ( i > 0 ) {
531            strncat(role_string, " & ", 3);
532            sz -= 3;
533        }
534        strncat(role_string,attr->tail_strings[i], sz); 
535
536        sz -= strlen(attr->tail_strings[i]);
537        if (sz < 0 ) return NULL;
538    }
539    return role_string;
540}
Note: See TracBrowser for help on using the repository browser.