Changeset f2622ee


Ignore:
Timestamp:
Sep 25, 2013 5:27:41 PM (6 years ago)
Author:
Mei-Hui Su <mei@…>
Branches:
abac0-leak, master
Children:
7764378, 91a6b20
Parents:
c0fe894
Message:

1) ran with valgrind and did some leak patching

Files:
13 edited

Legend:

Unmodified
Added
Removed
  • libabac/abac.c

    r3613ab8 rf2622ee  
    111111    return abac_verifier_load_id_chunk(ctx->id_certs,cert_chunk, ctx->keymap);
    112112}
     113
     114/**
     115 * Load an ID cert from a id.
     116 */
     117/*
     118int abac_context_load_id_chunk(abac_context_t *ctx, abac_id_t *id) {
     119    assert(ctx != NULL);
     120    return abac_verifier_load_id_id(ctx->id_certs,id, ctx->keymap);
     121}
     122*/
     123
    113124
    114125/**
  • libabac/abac.h

    r4f79997 rf2622ee  
    1515typedef struct _abac_list_t ABAC_LIST_T;
    1616
     17#ifndef __ABAC_CHUNK_T__
     18#define __ABAC_CHUNK_T__
    1719typedef struct _abac_chunk_t {
    1820    unsigned char *ptr;
    1921    int len;
    2022} abac_chunk_t;
    21 
     23#endif /* __ABAC_CHUNK_T__ */
    2224
    2325typedef struct abac_keyid_mapping_t abac_keyid_mapping_t;
  • libabac/abac_attribute.c

    r3613ab8 rf2622ee  
    146146}
    147147
     148/* string is a malloc copy */
    148149int abac_attribute_add_tail(abac_attribute_t *attr, char *string) {
    149150    assert(attr);
     
    156157        return 0;
    157158    }
    158     attr->tail_strings[attr->ntails++] = abac_xstrdup(string);
     159    attr->tail_strings[attr->ntails++] = string;
    159160    return 1;
    160161}
     
    195196char *abac_attribute_get_principal(abac_attribute_t *attr)
    196197{
    197     char *role_string=abac_attribute_role_string(attr);
    198     /* make an copy */
    199     char *tmp=strdup(role_string);
     198    /* already a copy */
     199    char *tmp=abac_attribute_role_string(attr);
    200200    char *head_tail[2];
    201201    int ret = 2;
     
    275275            (char *)id_chunk.ptr, id_chunk.len);
    276276
     277    /*MEI, free id_chunk */
     278    abac_chunk_free(id_chunk);
     279
    277280    if (attr_cert == NULL)
    278281        return 0;
     
    281284    attr->cert.len = strlen(attr_cert);
    282285
    283     /* free(role_string); */
    284286    return 1;
    285287}
     
    289291}
    290292
    291 // make an explicit copy
     293/*
     294 * caller is responsible to free up the chunk after use
     295*/
    292296abac_chunk_t abac_attribute_cert_chunk(abac_attribute_t *attr) {
    293297    abac_chunk_t chunk= {NULL,0};
     
    353357    attr->output_format = NULL;
    354358
     359    free(keyid);
     360    free(role_string);
    355361    return attr;
    356362}
     
    475481    if ( attr->keymap ) abac_keyid_map_free(attr->keymap);
    476482
    477 /* XXX this can not be free as if it is a char string
     483/* MEI???, this can not be free as if it is a char string */
    478484    free(attr->cert.ptr);
    479 */
    480485
    481486    free(attr);
  • libabac/abac_graph.c

    rc0fe894 rf2622ee  
    5252// ugghhhghhhghh need this for intersections
    5353abac_list_t *abac_role_prereqs(abac_role_t *);
     54
     55static abac_vertex_t *_dup_vertex(abac_vertex_t *v);
    5456
    5557/**
     
    101103    if (vertex == NULL) {
    102104        vertex = abac_xmalloc(sizeof(abac_vertex_t));
    103         vertex->refcount = 0;
     105        vertex->refcount = 1;
    104106        vertex->role = abac_role_dup(role);
    105107        vertex->name = abac_role_string(vertex->role);
     
    127129        // add it to the vertices
    128130        HASH_ADD_KEYPTR(hh, graph->vertices, vertex->name, strlen(vertex->name), vertex);
     131
     132        } else {
     133            _dup_vertex(vertex);
     134
    129135    }
    130     vertex->refcount++;
    131136
    132137    return vertex;
     
    143148
    144149    --vertex->refcount;
    145 
    146150    if ( vertex->refcount > 0) return;
    147151
     
    268272        if (abac_role_is_principal(vertex->role))
    269273            abac_set_add(principals, abac_role_string(vertex->role));
     274        /* ???  _free_vertex(vertex); */
    270275    );
    271276
     
    479484    abac_set_free(seen);
    480485
     486/*??? _free_vertex(start_vertex); */
     487
    481488    return stack;
    482489}
     
    513520
    514521    abac_set_free(seen);
     522
     523/* ???  _free_vertex(start_vertex); */
    515524
    516525    return stack;
     
    539548                abac_list_add(credentials, abac_credential_dup(incoming->credential));
    540549        );
     550        /* ???  _free_vertex(vertex); */ 
    541551    );
    542552
     
    570580                abac_list_add(credentials, abac_credential_dup(outgoing->credential));
    571581        );
     582        /* ???  _free_vertex(vertex); */
    572583    );
    573584
     
    587598    // give up on bogus roles
    588599    if (role == NULL || prin_role == NULL) {
    589         free(role);
    590         free(prin_role);
     600        abac_role_free(role);
     601        abac_role_free(prin_role);
    591602        return;
    592603    }
     
    627638                abac_graph_add_credential(return_graph, incoming->credential);
    628639        );
     640        /* ???  _free_vertex(vertex); */
    629641    );
    630642
  • libabac/abac_id.c

    r4f79997 rf2622ee  
    4141    id->key = NULL;
    4242
    43     id->keyid = abac_xstrdup(abac_get_keyid(cert));
    44     id->cn = abac_xstrdup(abac_get_cn(cert));
    45 
     43    id->keyid = abac_get_keyid(cert);
     44    id->cn = NULL;
     45    char *tmp=abac_get_cn(cert);
     46    if(tmp)  id->cn = abac_xstrdup(tmp);
    4647    id->refcount = 1;
    4748    return id;
     
    135136    *sha1=NULL;
    136137    if(cert) {
    137         *sha1 = abac_xstrdup(abac_get_keyid(cert));
     138        *sha1 = abac_get_keyid(cert);
    138139        if(debug) fprintf(stderr,"sha1 found is %s\n", *sha1);
    139140        } else {
     
    191192    }
    192193
     194    /* free up the extracted pukey */
     195    EVP_PKEY_free(pubkey);
     196
    193197    id->key = key;
    194198    return ABAC_SUCCESS;
     
    210214        return ABAC_FAILURE;
    211215    }
     216
     217    /* free up the extracted pukey */
     218    EVP_PKEY_free(pubkey);
     219
    212220    id->key = key;
    213221    return ABAC_SUCCESS;
     
    232240        return ABAC_FAILURE;
    233241    }
     242
     243    /* free up the extracted pukey */
     244    EVP_PKEY_free(pubkey);
     245
    234246    to_id->key = key;
    235247    return ABAC_SUCCESS;
     
    254266    id->key = abac_generate_key();
    255267    id->cert = abac_generate_cert(id->key, cn, validity);
    256     id->keyid = abac_xstrdup(abac_get_keyid(id->cert));
     268    id->keyid = abac_get_keyid(id->cert);
    257269
    258270    id->refcount = 1;
     
    280292    id->key = _load_privkey_from_file(keyfile);
    281293    id->cert = abac_generate_cert(id->key, cn, validity);
    282     id->keyid = abac_xstrdup(abac_get_keyid(id->cert));
     294    id->keyid = abac_get_keyid(id->cert);
    283295    id->refcount = 1;
    284296
     
    460472/**
    461473 * Get a abac_chunk representing the id cert.
     474 * caller is responsible to free up the chunk after use
    462475 */
    463476abac_chunk_t abac_id_cert_chunk(abac_id_t *id) {
     
    509522
    510523    free(id->keyid);
     524    if(id->cn) free(id->cn);
     525
    511526    free(id);
    512527}
  • libabac/abac_openssl.c

    r1bf0f03 rf2622ee  
    198198    BIO_flush(mbio);
    199199
    200     PEM_read_bio_X509(mbio,&n509,NULL,NULL);
     200    if( !PEM_read_bio_X509(mbio,&n509,0,NULL)) {
     201        if(debug) ERR_print_errors_fp (stderr);
     202        return NULL;
     203    }
    201204
    202205    BIO_free_all(mbio);
    203206
    204     if (n509 == NULL) {
    205         if(debug) ERR_print_errors_fp (stderr);
    206         return NULL;
    207     }
    208207    return n509;
    209208}
  • libabac/abac_role.c

    r94605f2 rf2622ee  
    197197
    198198    // no dots: easy case, principal
    199     if (num_dots == 0)
     199    if (num_dots == 0) {
    200200        ret = abac_role_principal_new(string);
     201    }
    201202
    202203    // a role has exactly 1 dot
     
    242243 * Create a role from a string. Handles intersecting and normal roles.
    243244 */
    244 abac_role_t *abac_role_from_string(char *string) {
     245abac_role_t *abac_role_from_string(char *istring) {
    245246    abac_list_t *prereqs = NULL;
    246247    abac_role_t *ret = NULL, *role;
    247248    char *roles[256];
    248249    int num_roles, i;
    249 
    250     char *original = string;
     250    char *string;
     251
     252    char *original = istring;
    251253
    252254    // make a copy so we can mess with it
    253     string = abac_xstrdup(string);
     255    string = abac_xstrdup(istring);
    254256
    255257    // split the string (in case of an intersection num_roles > 1)
     
    258260
    259261    // normal role:
    260     if (num_roles == 1)
     262    if (num_roles == 1) {
    261263        ret = _abac_single_role_from_string(string);
    262264
    263     else {
     265    } else {
    264266        prereqs = abac_list_new();
    265267
  • libabac/abac_util.c

    r1bf0f03 rf2622ee  
    77#include <assert.h>
    88#include <ctype.h>
     9
     10#include <abac_util.h>
    911
    1012/**
     
    1921
    2022    return ret;
     23}
     24
     25void abac_chunk_free(abac_chunk_t chunk)
     26{
     27   if(chunk.len)
     28       free(chunk.ptr);
     29   chunk.len=0;
     30   chunk.ptr=NULL;
    2131}
    2232
  • libabac/abac_util.h

    r461541a rf2622ee  
    11#ifndef __UTIL_H__
    2 #define __UTTL_H__
     2#define __UTIL_H__
    33
    44#include <sys/types.h>
    55#include <stdlib.h>
    66
     7#ifndef __ABAC_CHUNK_T__
     8#define __ABAC_CHUNK_T__
     9typedef struct _abac_chunk_t {
     10    unsigned char *ptr;
     11    int len;
     12} abac_chunk_t;
     13#endif /* __ABAC_CHUNK_T__ */
     14
    715void *abac_xmalloc(size_t);
     16void abac_chunk_free(abac_chunk_t);
    817char *abac_xstrdup(char *);
    918void *abac_xrealloc(void *, size_t);
  • libabac/abac_verifier.c

    rf43e42c rf2622ee  
    8585 * Load an ID certificate.
    8686 */
    87 static int _load_id(abac_list_t *id_certs, abac_id_t *cert,
     87static int _load_id(abac_list_t *id_certs, abac_id_t **cert,
    8888        abac_keyid_map_t *km) {
    8989    abac_id_cert_t *id_cert = NULL;
     
    9292    int ret;
    9393
    94     assert(cert);
     94    assert(*cert);
    9595
    9696    // get the key ID
    97     keyid = abac_id_keyid(cert);
     97    keyid = abac_id_keyid(*cert);
    9898
    9999    // if we already have this cert 'error' with success
     
    105105           incoming does, then need to bring that bit of
    106106           information in */
    107            if(abac_id_has_privkey(cert) &&
     107           if(abac_id_has_privkey(*cert) &&
    108108                       !abac_id_has_privkey(id_cert->cert)) {
    109                abac_id_pass_privkey_from_id(id_cert->cert, cert);
     109               abac_id_pass_privkey_from_id(id_cert->cert, *cert);
    110110           }
    111         ret = ABAC_CERT_SUCCESS;
    112         goto error;
    113     }
    114 
    115     ret = abac_id_still_valid(cert);
     111        /* free the new one and set the ptr to dup of old */
     112        abac_id_free(*cert);
     113        *cert=abac_id_dup(id_cert->cert);
     114        ret = ABAC_CERT_SUCCESS;
     115        goto error;
     116    }
     117
     118    ret = abac_id_still_valid(*cert);
    116119    if (!ret) {
    117120        ret = ABAC_CERT_INVALID;
     
    122125    id_cert = abac_xmalloc(sizeof(abac_id_cert_t));
    123126    id_cert->keyid = abac_xstrdup(keyid);
    124     id_cert->cert = cert;
     127    id_cert->cert = *cert;
    125128    abac_list_add(id_certs, id_cert);
    126129    /* Add the new id and issuer to the keyid <-> name map */
    127     if ( km && keyid && cert ) {
    128         if ( (nick= abac_id_issuer(cert)) ) {
     130    if ( km && keyid && *cert ) {
     131        if ( (nick= abac_id_issuer(*cert)) ) {
    129132            /* If the issuer starts with /CN=, as many do,
    130133             * trim the /CN= off */
     
    142145error:
    143146    // No one owns cert, so delete it.
    144     if (cert != NULL) free(cert);
    145     if (keyid != NULL) free(keyid);
     147    if (*cert != NULL) abac_id_free(*cert);
     148
    146149    return ret;
    147150}
     
    165168        return ABAC_CERT_INVALID;
    166169
    167     return _load_id(id_certs,cert, km);
     170    return _load_id(id_certs,&cert, km);
    168171}
    169172
     
    179182    if (cert == NULL)
    180183        return ABAC_CERT_INVALID;
    181     return _load_id(id_certs,cert, km);
     184
     185    return _load_id(id_certs,&cert, km);
    182186}
    183187
    184188/**
    185189 * Load an ID cert from a char ptr of a X509 pem data
    186  * this is called from parse_privilege(..)
     190 * this is called from parse_privilege/parse_abac
    187191 */
    188192int abac_verifier_load_id_chars(abac_list_t *id_certs,char *naked_pem,
     
    194198    char *pem=make_pem_from_naked_pem(new_naked_pem);
    195199    int len=strlen(pem);
     200    free(new_naked_pem);
     201
    196202    abac_chunk_t chunk = { pem, len };
    197     free(new_naked_pem);
    198     return abac_verifier_load_id_chunk(id_certs,chunk, km);
     203    int rc=abac_verifier_load_id_chunk(id_certs,chunk, km);
     204/* ??? MEI */
     205    abac_chunk_free(chunk);
     206    return rc;
     207   
    199208}
    200209/**
     
    269278    cred->tail = tail_role;
    270279    cred->cert = cert;
     280
    271281    /* acme's cert */
    272282    cred->issuer = abac_id_dup(issuer->cert);
     
    274284    *cred_ret = cred;
    275285
     286    free(attr_string);
     287
    276288    return ABAC_CERT_SUCCESS;
    277289
    278290error:
     291    free(attr_string);
    279292    if (head_role != NULL) abac_role_free(head_role);
    280293    if (tail_role != NULL) abac_role_free(tail_role);
     
    291304    if(sz) {
    292305        abac_list_foreach(attr_list, attr,
     306            /* attr is being used to build cred_ret, so, don't remove it */
    293307            int ret=_load_attribute_cert(id_certs, attr, &cred_ret, km);
    294308            if(ret==ABAC_CERT_SUCCESS) {
     
    297311        );
    298312    }
     313/* ??? MEI, attr is being reused, just free the list ptr */
     314    abac_list_free(attr_list);
    299315    return sz;
    300316}
  • libabac/abac_xml.c

    rf43e42c rf2622ee  
    435435        goto fail;
    436436
     437/*???? */
     438    if ( keyMan) xmlSecKeysMngrDestroy(keyMan);
     439    if ( keyCtx ) xmlSecKeyInfoCtxDestroy(keyCtx);
     440    if ( dsigCtx) xmlSecDSigCtxDestroy(dsigCtx);
     441
    437442    return 1;
    438443fail:
    439444    if ( keyMan) xmlSecKeysMngrDestroy(keyMan);
     445    if ( keyCtx ) xmlSecKeyInfoCtxDestroy(keyCtx);
    440446    if ( key ) xmlSecKeyDestroy(key);
    441     if ( keyCtx ) xmlSecKeyInfoCtxDestroy(keyCtx);
    442447    if ( dsigCtx) xmlSecDSigCtxDestroy(dsigCtx);
    443448    return 0;
     
    957962 * which the new certificate is added.
    958963 */
    959 xmlChar **parse_abac(xmlDocPtr doc, abac_list_t*ctxt_id_certs, abac_keyid_map_t *km) {
     964xmlChar **parse_abac(xmlDocPtr doc, abac_list_t *ctxt_id_certs, abac_keyid_map_t *km) {
    960965    xmlNodePtr root = NULL;     /* XML root node */
    961966    xmlNodePtr node = NULL;     /* XML credential node */
     
    13131318    }
    13141319
     1320    /* MEI, done with the copy */
     1321    free(copy);
     1322
     1323    char *tail;
    13151324    for ( i = 0 ; i < ntails; i++) {
    13161325        /* Make a role for each tail and use those functions to write out the
    13171326         * structures for the different kinds of role. */
    1318         abac_role_t *r = abac_role_from_string(abac_attribute_get_tail_n(a,i));
     1327        tail=abac_attribute_get_tail_n(a,i);
     1328        abac_role_t *r = abac_role_from_string(tail);
    13191329        int ts;
    13201330
     
    13291339            ts = encode_linking_role(r, tmp, sz, km);
    13301340
    1331         free(r);
     1341        abac_role_free(r);
    13321342        if ( ts < 0 )
    13331343            goto fail;
     
    15351545
    15361546
    1537 /* parse the xml blob and extract keyid */
     1547/* parse the xml blob and extract keyid,
     1548   caller should be freeing this if not
     1549   needed anymore */
    15381550char *get_keyid_from_xml(char *xml) {
    15391551    xmlDocPtr doc=xmlParseMemory(xml,strlen(xml));
  • tests/example_scripts/c/Makefile.am

    rcd0ef61 rf2622ee  
    2727        ./tchunk 1 IceCream_ID.pem IceCream_private.pem
    2828
    29 tleak: tleak.c
     29tleak: abac_attr.c
     30        gcc -g -O1 $(MY_INCLUDES_VAL) -c abac_attr.c -o leak_attr.o
     31        gcc -g -O1 -o tleak leak_attr.o $(MY_LDFLAGS_VAL) 
     32        valgrind -v --leak-check=full ./tleak IceCream_ID.pem  IceCream_private.pem IceCream_attr.xml Chocolate_ID.pem
     33
    3034
    3135tt: tbasic.c
  • tests/example_scripts/c/abac_attr.c

    rec550f7 rf2622ee  
    2424#include <stdio.h>
    2525#include <assert.h>
     26#include <stdlib.h>
    2627
    2728#include <abac.h>
     
    4344    int rc=abac_id_privkey_from_file(id,argv[2]);
    4445
    45     rc=abac_context_load_id_chunk(ctx, abac_id_cert_chunk(id));
     46    abac_chunk_t a_chunk=abac_id_cert_chunk(id);
     47    rc=abac_context_load_id_chunk(ctx, a_chunk);
     48    abac_chunk_free(a_chunk);
    4649
    4750    abac_id_t *chocolate_id = abac_id_from_file(argv[4]);
    48     rc=abac_context_load_id_chunk(ctx, abac_id_cert_chunk(chocolate_id));
     51    abac_chunk_t b_chunk=abac_id_cert_chunk(chocolate_id);
     52    rc=abac_context_load_id_chunk(ctx, b_chunk);
     53    abac_chunk_free(b_chunk);
    4954
    5055    abac_attribute_t *attr;
     
    5358    rc=abac_attribute_bake(attr);
    5459
    55     printf(" attribute being made : %s\n",abac_attribute_role_string(attr));
     60    char *string=abac_attribute_role_string(attr);
     61    printf(" attribute being made : %s\n",string);
     62    free(string);
    5663
    5764    abac_attribute_write_file(attr,argv[3]);
    58     abac_context_load_attribute_chunk(ctx,abac_attribute_cert_chunk(attr));
     65    abac_chunk_t c_chunk=abac_attribute_cert_chunk(attr);
     66    abac_context_load_attribute_chunk(ctx,c_chunk);
     67    abac_chunk_free(c_chunk);
    5968
    6069    char *tmp=NULL;
     
    6675        &success
    6776    );
     77
     78
    6879    fprintf(stderr,"query with %s\n",tmp);
    6980    fprintf(stderr,"      for %s\n",abac_id_keyid(chocolate_id));
     
    8394                  );
    8495        }
     96
    8597    abac_context_credentials_free(credentials);
     98
     99    free(tmp);
     100    abac_id_free(id);
     101    abac_id_free(chocolate_id);
     102    abac_attribute_free(attr);
    86103    abac_context_free(ctx);
     104
    87105    return 0;
    88106}
Note: See TracChangeset for help on using the changeset viewer.