Changeset d888b3f in OpenSC


Ignore:
Timestamp:
06/05/11 15:46:25 (12 months ago)
Author:
vtarasov <vtarasov@…>
Branches:
master, staging
Children:
efc5760
Parents:
32d035a
git-author:
vtarasov <vtarasov@…> (06/05/11 15:46:25)
git-committer:
vtarasov <vtarasov@…> (06/05/11 15:46:25)
Message:

pkcs15: use general 'AuthenticationObject?' instead of 'PinObject?'

now the attributes of the previous 'pin-info' data type are included
as the sub-type attributes of the general 'auth-info' data .
It will allow to include support of the 'biometricTemplate' and 'authKey' authentication types.

 http://www.opensc-project.org/pipermail/opensc-devel/2011-May/016655.html

git-svn-id:  https://www.opensc-project.org/svnp/opensc/trunk@5550 c6295689-39f2-0310-b995-f0e70906c6a9

Location:
src
Files:
49 edited

Legend:

Unmodified
Added
Removed

  • src/libopensc/libopensc.exports

    rdce63c8 rd888b3f  
    181181sc_pkcs15_free_key_params 
    182182sc_pkcs15_free_object 
    183 sc_pkcs15_free_pin_info 
     183sc_pkcs15_free_auth_info 
    184184sc_pkcs15_free_prkey 
    185185sc_pkcs15_free_prkey_info 

  • src/libopensc/p15card-helper.c

    rd5679f5 rd888b3f  
    278278        if(!pins) return SC_SUCCESS; 
    279279        for (i = 0; pins[i].label; i++) { 
    280                 struct sc_pkcs15_pin_info pin_info; 
     280                struct sc_pkcs15_auth_info pin_info; 
    281281                struct sc_pkcs15_object   pin_obj; 
    282282 
    … …  
    284284                memset(&pin_obj,  0, sizeof(pin_obj)); 
    285285 
     286                pin_info.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
    286287                sc_pkcs15_format_id(pins[i].id, &pin_info.auth_id); 
    287                 pin_info.reference     = pins[i].ref; 
    288                 pin_info.flags         = pins[i].flags; 
    289                 pin_info.type          = pins[i].type; 
    290                 pin_info.min_length    = pins[i].minlen; 
    291                 pin_info.stored_length = pins[i].storedlen; 
    292                 pin_info.max_length    = pins[i].maxlen; 
    293                 pin_info.pad_char      = pins[i].pad_char; 
     288 
     289                pin_info.attrs.pin.reference     = pins[i].ref; 
     290                pin_info.attrs.pin.flags         = pins[i].flags; 
     291                pin_info.attrs.pin.type          = pins[i].type; 
     292                pin_info.attrs.pin.min_length    = pins[i].minlen; 
     293                pin_info.attrs.pin.stored_length = pins[i].storedlen; 
     294                pin_info.attrs.pin.max_length    = pins[i].maxlen; 
     295                pin_info.attrs.pin.pad_char      = pins[i].pad_char; 
     296 
    294297                sc_format_path(pins[i].path, &pin_info.path); 
    295298                pin_info.tries_left    = -1; 

  • src/libopensc/pkcs15-actalis.c

    r7124273 rd888b3f  
    7878                int flags, int tries_left, const char pad_char, int obj_flags) 
    7979{ 
    80         sc_pkcs15_pin_info_t info; 
     80        sc_pkcs15_auth_info_t info; 
    8181        sc_pkcs15_object_t   obj; 
    8282 
    … …  
    8585 
    8686        info.auth_id           = *id; 
    87         info.min_length        = min_length; 
    88         info.max_length        = max_length; 
    89         info.stored_length     = max_length; 
    90         info.type              = type; 
    91         info.reference         = ref; 
    92         info.flags             = flags; 
     87        info.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
     88        info.attrs.pin.min_length        = min_length; 
     89        info.attrs.pin.max_length        = max_length; 
     90        info.attrs.pin.stored_length     = max_length; 
     91        info.attrs.pin.type              = type; 
     92        info.attrs.pin.reference         = ref; 
     93        info.attrs.pin.flags             = flags; 
     94        info.attrs.pin.pad_char          = pad_char; 
    9395        info.tries_left        = tries_left; 
    94         info.magic             = SC_PKCS15_PIN_MAGIC; 
    95         info.pad_char          = pad_char; 
    9696 
    9797        if (path) 
    9898                info.path = *path; 
    9999        if (type == SC_PKCS15_PIN_TYPE_BCD) 
    100                 info.stored_length /= 2; 
     100                info.attrs.pin.stored_length /= 2; 
    101101 
    102102        strlcpy(obj.label, label, sizeof(obj.label)); 

  • src/libopensc/pkcs15-atrust-acos.c

    rf5a21e4 rd888b3f  
    221221        /* set pins */ 
    222222        for (i = 0; pins[i].label; i++) { 
    223                 struct sc_pkcs15_pin_info pin_info; 
     223                struct sc_pkcs15_auth_info pin_info; 
    224224                struct sc_pkcs15_object   pin_obj; 
    225225 
    … …  
    228228 
    229229                sc_pkcs15_format_id(pins[i].id, &pin_info.auth_id); 
    230                 pin_info.reference     = pins[i].ref; 
    231                 pin_info.flags         = pins[i].flags; 
    232                 pin_info.type          = pins[i].type; 
    233                 pin_info.min_length    = pins[i].minlen; 
    234                 pin_info.stored_length = pins[i].storedlen; 
    235                 pin_info.max_length    = pins[i].maxlen; 
    236                 pin_info.pad_char      = pins[i].pad_char; 
     230                pin_info.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
     231                pin_info.attrs.pin.reference     = pins[i].ref; 
     232                pin_info.attrs.pin.flags         = pins[i].flags; 
     233                pin_info.attrs.pin.type          = pins[i].type; 
     234                pin_info.attrs.pin.min_length    = pins[i].minlen; 
     235                pin_info.attrs.pin.stored_length = pins[i].storedlen; 
     236                pin_info.attrs.pin.max_length    = pins[i].maxlen; 
     237                pin_info.attrs.pin.pad_char      = pins[i].pad_char; 
    237238                sc_format_path(pins[i].path, &pin_info.path); 
    238239                pin_info.tries_left    = -1; 

  • src/libopensc/pkcs15-esteid.c

    r5f1b3a2 rd888b3f  
    174174                static const int esteid_pin_flags[3] = {0, 0, SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN}; 
    175175                 
    176                 struct sc_pkcs15_pin_info pin_info; 
     176                struct sc_pkcs15_auth_info pin_info; 
    177177                struct sc_pkcs15_object pin_obj; 
    178178 
    … …  
    188188                pin_info.auth_id.len = 1; 
    189189                pin_info.auth_id.value[0] = esteid_pin_authid[i]; 
    190                 pin_info.reference = esteid_pin_ref[i]; 
    191                 pin_info.flags = esteid_pin_flags[i]; 
    192                 pin_info.type = SC_PKCS15_PIN_TYPE_ASCII_NUMERIC; 
    193                 pin_info.min_length = esteid_pin_min[i]; 
    194                 pin_info.stored_length = 12; 
    195                 pin_info.max_length = 12; 
    196                 pin_info.pad_char = '\0'; 
     190                pin_info.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN;        
     191                pin_info.attrs.pin.reference = esteid_pin_ref[i]; 
     192                pin_info.attrs.pin.flags = esteid_pin_flags[i]; 
     193                pin_info.attrs.pin.type = SC_PKCS15_PIN_TYPE_ASCII_NUMERIC; 
     194                pin_info.attrs.pin.min_length = esteid_pin_min[i]; 
     195                pin_info.attrs.pin.stored_length = 12; 
     196                pin_info.attrs.pin.max_length = 12; 
     197                pin_info.attrs.pin.pad_char = '\0'; 
    197198                pin_info.tries_left = (int)tries_left; 
    198199                pin_info.max_tries = 3; 

  • src/libopensc/pkcs15-gemsafeGPK.c

    r0f2a44b rd888b3f  
    431431 
    432432        for (i = 0; pins[i].label; i++) { 
    433                 struct sc_pkcs15_pin_info pin_info; 
     433                struct sc_pkcs15_auth_info pin_info; 
    434434                struct sc_pkcs15_object   pin_obj; 
    435435 
    … …  
    438438 
    439439                sc_pkcs15_format_id(pins[i].id, &pin_info.auth_id); 
    440                 pin_info.reference     = pins[i].ref; 
    441                 pin_info.flags         = pins[i].flags; 
    442                 pin_info.type          = pins[i].type; 
    443                 pin_info.min_length    = pins[i].minlen; 
    444                 pin_info.stored_length = pins[i].storedlen; 
    445                 pin_info.max_length    = pins[i].maxlen; 
    446                 pin_info.pad_char      = pins[i].pad_char; 
     440                pin_info.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
     441                pin_info.attrs.pin.reference     = pins[i].ref; 
     442                pin_info.attrs.pin.flags         = pins[i].flags; 
     443                pin_info.attrs.pin.type          = pins[i].type; 
     444                pin_info.attrs.pin.min_length    = pins[i].minlen; 
     445                pin_info.attrs.pin.stored_length = pins[i].storedlen; 
     446                pin_info.attrs.pin.max_length    = pins[i].maxlen; 
     447                pin_info.attrs.pin.pad_char      = pins[i].pad_char; 
    447448                sc_format_path(pins[i].path, &pin_info.path); 
    448449                pin_info.path.value[2] = dfpath >> 8; 

  • src/libopensc/pkcs15-gemsafeV1.c

    r3169f14 rd888b3f  
    433433                int flags, int tries_left, const char pad_char, int obj_flags) 
    434434{ 
    435         sc_pkcs15_pin_info_t *info; 
     435        sc_pkcs15_auth_info_t *info; 
    436436 
    437437        info = calloc(1, sizeof(*info)); 
     438        info->auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
    438439        info->auth_id           = *id; 
    439         info->min_length        = min_length; 
    440         info->max_length        = max_length; 
    441         info->stored_length     = max_length; 
    442         info->type              = type; 
    443         info->reference         = ref; 
    444         info->flags             = flags; 
     440        info->attrs.pin.min_length        = min_length; 
     441        info->attrs.pin.max_length        = max_length; 
     442        info->attrs.pin.stored_length     = max_length; 
     443        info->attrs.pin.type              = type; 
     444        info->attrs.pin.reference         = ref; 
     445        info->attrs.pin.flags             = flags; 
     446        info->attrs.pin.pad_char          = pad_char; 
    445447        info->tries_left        = tries_left; 
    446         info->magic             = SC_PKCS15_PIN_MAGIC; 
    447         info->pad_char          = pad_char; 
    448448 
    449449        if (path) 

  • src/libopensc/pkcs15-infocamere.c

    ra576582 rd888b3f  
    7373                int flags, int tries_left, const char pad_char, int obj_flags) 
    7474{ 
    75         sc_pkcs15_pin_info_t info; 
     75        sc_pkcs15_auth_info_t info; 
    7676        sc_pkcs15_object_t   obj; 
    7777 
    … …  
    7979        memset(&obj,  0, sizeof(obj)); 
    8080 
     81        info.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
    8182        info.auth_id           = *id; 
    82         info.min_length        = min_length; 
    83         info.max_length        = max_length; 
    84         info.stored_length     = max_length; 
    85         info.type              = type; 
    86         info.reference         = ref; 
    87         info.flags             = flags; 
     83        info.attrs.pin.min_length        = min_length; 
     84        info.attrs.pin.max_length        = max_length; 
     85        info.attrs.pin.stored_length     = max_length; 
     86        info.attrs.pin.type              = type; 
     87        info.attrs.pin.reference         = ref; 
     88        info.attrs.pin.flags             = flags; 
     89        info.attrs.pin.pad_char          = pad_char; 
    8890        info.tries_left        = tries_left; 
    89         info.magic             = SC_PKCS15_PIN_MAGIC; 
    90         info.pad_char          = pad_char; 
    9191 
    9292        if (path) 
    9393                info.path = *path; 
    9494        if (type == SC_PKCS15_PIN_TYPE_BCD) 
    95                 info.stored_length /= 2; 
     95                info.attrs.pin.stored_length /= 2; 
    9696 
    9797        strlcpy(obj.label, label, sizeof(obj.label)); 

  • src/libopensc/pkcs15-itacns.c

    rb435f60 rd888b3f  
    345345        int flags) 
    346346{ 
    347         struct sc_pkcs15_pin_info pin_info; 
     347        struct sc_pkcs15_auth_info pin_info; 
    348348        struct sc_pkcs15_object pin_obj; 
    349349 
    … …  
    351351 
    352352        memset(&pin_info, 0, sizeof(pin_info)); 
     353        pin_info.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
    353354        pin_info.auth_id.len = 1; 
    354355        pin_info.auth_id.value[0] = id; 
    355         pin_info.reference = reference; 
    356         pin_info.flags = flags; 
    357         pin_info.type = SC_PKCS15_PIN_TYPE_ASCII_NUMERIC; 
    358         pin_info.min_length = 5; 
    359         pin_info.stored_length = 8; 
    360         pin_info.max_length = 8; 
    361         pin_info.pad_char = 0xff; 
     356        pin_info.attrs.pin.reference = reference; 
     357        pin_info.attrs.pin.flags = flags; 
     358        pin_info.attrs.pin.type = SC_PKCS15_PIN_TYPE_ASCII_NUMERIC; 
     359        pin_info.attrs.pin.min_length = 5; 
     360        pin_info.attrs.pin.stored_length = 8; 
     361        pin_info.attrs.pin.max_length = 8; 
     362        pin_info.attrs.pin.pad_char = 0xff; 
    362363        if(path) 
    363364        pin_info.path = *path; 

  • src/libopensc/pkcs15-oberthur.c

    rf026db6 rd888b3f  
    295295                struct sc_pkcs15_object *objs[0x10], *pin_obj = NULL; 
    296296                const struct sc_acl_entry *acl = sc_file_get_acl_entry(file, SC_AC_OP_READ); 
    297                 struct sc_pkcs15_pin_info *pinfo = NULL; 
    298297                int ii; 
    299298 
    … …  
    302301 
    303302                for (ii=0; ii<rv; ii++)   { 
    304                         pinfo = (struct sc_pkcs15_pin_info *) objs[ii]->data; 
     303                        struct sc_pkcs15_auth_info *auth_info = (struct sc_pkcs15_auth_info *) objs[ii]->data; 
    305304                        sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "compare PIN/ACL refs:%i/%i, method:%i/%i",  
    306                                         pinfo->reference, acl->key_ref, pinfo->auth_method, acl->method); 
    307                         if (pinfo->reference == (int)acl->key_ref && pinfo->auth_method == (unsigned)acl->method)   { 
     305                                        auth_info->attrs.pin.reference, acl->key_ref, auth_info->auth_method, acl->method); 
     306                        if (auth_info->attrs.pin.reference == (int)acl->key_ref && auth_info->auth_method == (unsigned)acl->method)   { 
    308307                                pin_obj = objs[ii]; 
    309308                                break; 
    … …  
    912911{ 
    913912        struct sc_context *ctx = p15card->card->ctx; 
    914         struct sc_pkcs15_pin_info info; 
     913        struct sc_pkcs15_auth_info auth_info; 
    915914        struct sc_pkcs15_object   obj; 
    916915        struct sc_card *card = p15card->card; 
    … …  
    943942 
    944943        /* add PIN */ 
    945         memset(&info, 0, sizeof(info)); 
     944        memset(&auth_info, 0, sizeof(auth_info)); 
    946945        memset(&obj,  0, sizeof(obj)); 
    947          
    948         info.auth_id.len = 1; 
    949         info.auth_id.value[0] = 0xFF; 
    950         info.min_length         = 4; 
    951         info.max_length         = 64; 
    952         info.stored_length      = 64; 
    953         info.type               = SC_PKCS15_PIN_TYPE_ASCII_NUMERIC; 
    954         info.reference          = sopin_reference; 
    955         info.tries_left         = tries_left; 
    956         info.auth_method        = SC_AC_CHV; 
    957         info.magic              = SC_PKCS15_PIN_MAGIC; 
    958         info.pad_char           = 0xFF; 
    959         info.flags              = SC_PKCS15_PIN_FLAG_CASE_SENSITIVE  
     946 
     947        auth_info.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN;       
     948        auth_info.auth_method   = SC_AC_CHV; 
     949        auth_info.auth_id.len = 1; 
     950        auth_info.auth_id.value[0] = 0xFF; 
     951        auth_info.attrs.pin.min_length          = 4; 
     952        auth_info.attrs.pin.max_length          = 64; 
     953        auth_info.attrs.pin.stored_length       = 64; 
     954        auth_info.attrs.pin.type                = SC_PKCS15_PIN_TYPE_ASCII_NUMERIC; 
     955        auth_info.attrs.pin.reference           = sopin_reference; 
     956        auth_info.attrs.pin.pad_char            = 0xFF; 
     957        auth_info.attrs.pin.flags               = SC_PKCS15_PIN_FLAG_CASE_SENSITIVE  
    960958                                | SC_PKCS15_PIN_FLAG_INITIALIZED  
    961959                                | SC_PKCS15_PIN_FLAG_NEEDS_PADDING 
    962960                                | SC_PKCS15_PIN_FLAG_SO_PIN; 
     961        auth_info.tries_left            = tries_left; 
    963962         
    964963        strncpy(obj.label, "SO PIN", SC_PKCS15_MAX_LABEL_SIZE-1); 
    … …  
    966965         
    967966        sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "Add PIN(%s,auth_id:%s,reference:%i)", obj.label,  
    968                         sc_pkcs15_print_id(&info.auth_id), info.reference); 
    969         rv = sc_pkcs15emu_add_pin_obj(p15card, &obj, &info); 
     967                        sc_pkcs15_print_id(&auth_info.auth_id), auth_info.attrs.pin.reference); 
     968        rv = sc_pkcs15emu_add_pin_obj(p15card, &obj, &auth_info); 
    970969        SC_TEST_RET(ctx, SC_LOG_DEBUG_NORMAL, rv, "Oberthur init failed: cannot add PIN object"); 
    971970 
    … …  
    974973        if (rv == SC_ERROR_PIN_CODE_INCORRECT)   { 
    975974                /* add PIN */ 
    976                 memset(&info, 0, sizeof(info)); 
     975                memset(&auth_info, 0, sizeof(auth_info)); 
    977976                memset(&obj,  0, sizeof(obj)); 
    978977         
    979                 info.auth_id.len = sizeof(PinDomainID) > sizeof(info.auth_id.value)  
    980                                 ? sizeof(info.auth_id.value) : sizeof(PinDomainID); 
    981                 memcpy(info.auth_id.value, PinDomainID, info.auth_id.len); 
    982  
    983                 info.min_length         = 4; 
    984                 info.max_length         = 64; 
    985                 info.stored_length      = 64; 
    986                 info.type               = SC_PKCS15_PIN_TYPE_ASCII_NUMERIC; 
    987                 info.reference          = 0x81; 
    988                 info.auth_method        = SC_AC_CHV; 
    989                 info.tries_left         = tries_left; 
    990                 info.magic              = SC_PKCS15_PIN_MAGIC; 
    991                 info.pad_char           = 0xFF; 
    992                 info.flags              = SC_PKCS15_PIN_FLAG_CASE_SENSITIVE  
     978                auth_info.auth_id.len = sizeof(PinDomainID) > sizeof(auth_info.auth_id.value)  
     979                                ? sizeof(auth_info.auth_id.value) : sizeof(PinDomainID); 
     980                memcpy(auth_info.auth_id.value, PinDomainID, auth_info.auth_id.len); 
     981                auth_info.auth_method   = SC_AC_CHV; 
     982 
     983                auth_info.attrs.pin.min_length          = 4; 
     984                auth_info.attrs.pin.max_length          = 64; 
     985                auth_info.attrs.pin.stored_length       = 64; 
     986                auth_info.attrs.pin.type                = SC_PKCS15_PIN_TYPE_ASCII_NUMERIC; 
     987                auth_info.attrs.pin.reference           = 0x81; 
     988                auth_info.attrs.pin.pad_char            = 0xFF; 
     989                auth_info.attrs.pin.flags               = SC_PKCS15_PIN_FLAG_CASE_SENSITIVE  
    993990                                        | SC_PKCS15_PIN_FLAG_INITIALIZED  
    994991                                        | SC_PKCS15_PIN_FLAG_NEEDS_PADDING 
    995992                                        | SC_PKCS15_PIN_FLAG_LOCAL; 
     993                auth_info.tries_left            = tries_left; 
    996994         
    997995                strncpy(obj.label, PIN_DOMAIN_LABEL, SC_PKCS15_MAX_LABEL_SIZE-1); 
    998996                obj.flags = SC_PKCS15_CO_FLAG_MODIFIABLE | SC_PKCS15_CO_FLAG_PRIVATE; 
    999997         
    1000                 sc_format_path(AWP_PIN_DF, &info.path);  
    1001                 info.path.type = SC_PATH_TYPE_PATH; 
     998                sc_format_path(AWP_PIN_DF, &auth_info.path);  
     999                auth_info.path.type = SC_PATH_TYPE_PATH; 
    10021000         
    10031001                sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "Add PIN(%s,auth_id:%s,reference:%i)", obj.label,  
    1004                                 sc_pkcs15_print_id(&info.auth_id), info.reference); 
    1005                 rv = sc_pkcs15emu_add_pin_obj(p15card, &obj, &info); 
     1002                                sc_pkcs15_print_id(&auth_info.auth_id), auth_info.attrs.pin.reference); 
     1003                rv = sc_pkcs15emu_add_pin_obj(p15card, &obj, &auth_info); 
    10061004                SC_TEST_RET(ctx, SC_LOG_DEBUG_NORMAL, rv, "Oberthur init failed: cannot add PIN object"); 
    10071005        } 

  • src/libopensc/pkcs15-openpgp.c

    rf8fc900 rd888b3f  
    127127                unsigned int    flags; 
    128128 
    129                 struct sc_pkcs15_pin_info pin_info; 
     129                struct sc_pkcs15_auth_info pin_info; 
    130130                struct sc_pkcs15_object   pin_obj; 
    131131 
    … …  
    141141                } 
    142142 
     143                pin_info.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
    143144                pin_info.auth_id.len   = 1; 
    144145                pin_info.auth_id.value[0] = i + 1; 
    145                 pin_info.reference     = i + 1; 
    146                 pin_info.flags         = flags; 
    147                 pin_info.type          = SC_PKCS15_PIN_TYPE_ASCII_NUMERIC; 
    148                 pin_info.min_length    = 0; 
    149                 pin_info.stored_length = buffer[1+i]; 
    150                 pin_info.max_length    = buffer[1+i]; 
    151                 pin_info.pad_char      = '\0'; 
     146                pin_info.attrs.pin.reference     = i + 1; 
     147                pin_info.attrs.pin.flags         = flags; 
     148                pin_info.attrs.pin.type          = SC_PKCS15_PIN_TYPE_ASCII_NUMERIC; 
     149                pin_info.attrs.pin.min_length    = 0; 
     150                pin_info.attrs.pin.stored_length = buffer[1+i]; 
     151                pin_info.attrs.pin.max_length    = buffer[1+i]; 
     152                pin_info.attrs.pin.pad_char      = '\0'; 
    152153                sc_format_path("3F00", &pin_info.path); 
    153154                pin_info.tries_left    = buffer[4+i]; 

  • src/libopensc/pkcs15-pin.c

    r3442649 rd888b3f  
    6060{ 
    6161        sc_context_t *ctx = p15card->card->ctx; 
    62         struct sc_pkcs15_pin_info info; 
     62        struct sc_pkcs15_auth_info info; 
    6363        int r; 
    64         size_t flags_len = sizeof(info.flags); 
     64        size_t flags_len = sizeof(info.attrs.pin.flags); 
    6565        size_t padchar_len = 1; 
    6666        struct sc_asn1_entry asn1_com_ao_attr[2], asn1_pin_attr[10], asn1_type_pin_attr[2]; 
    … …  
    7878        sc_format_asn1_entry(asn1_type_pin_attr + 0, asn1_pin_attr, NULL, 0); 
    7979 
    80         sc_format_asn1_entry(asn1_pin_attr + 0, &info.flags, &flags_len, 0); 
    81         sc_format_asn1_entry(asn1_pin_attr + 1, &info.type, NULL, 0); 
    82         sc_format_asn1_entry(asn1_pin_attr + 2, &info.min_length, NULL, 0); 
    83         sc_format_asn1_entry(asn1_pin_attr + 3, &info.stored_length, NULL, 0); 
    84         sc_format_asn1_entry(asn1_pin_attr + 4, &info.max_length, NULL, 0); 
    85         sc_format_asn1_entry(asn1_pin_attr + 5, &info.reference, NULL, 0); 
    86         sc_format_asn1_entry(asn1_pin_attr + 6, &info.pad_char, &padchar_len, 0); 
     80        sc_format_asn1_entry(asn1_pin_attr + 0, &info.attrs.pin.flags, &flags_len, 0); 
     81        sc_format_asn1_entry(asn1_pin_attr + 1, &info.attrs.pin.type, NULL, 0); 
     82        sc_format_asn1_entry(asn1_pin_attr + 2, &info.attrs.pin.min_length, NULL, 0); 
     83        sc_format_asn1_entry(asn1_pin_attr + 3, &info.attrs.pin.stored_length, NULL, 0); 
     84        sc_format_asn1_entry(asn1_pin_attr + 4, &info.attrs.pin.max_length, NULL, 0); 
     85        sc_format_asn1_entry(asn1_pin_attr + 5, &info.attrs.pin.reference, NULL, 0); 
     86        sc_format_asn1_entry(asn1_pin_attr + 6, &info.attrs.pin.pad_char, &padchar_len, 0); 
    8787        /* We don't support lastPinChange yet. */ 
    8888        sc_format_asn1_entry(asn1_pin_attr + 8, &info.path, NULL, 0); 
    … …  
    9292        /* Fill in defaults */ 
    9393        memset(&info, 0, sizeof(info)); 
    94         info.reference = 0; 
     94        info.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
    9595        info.tries_left = -1; 
    9696 
    … …  
    9999                return r; 
    100100        SC_TEST_RET(ctx, SC_LOG_DEBUG_NORMAL, r, "ASN.1 decoding failed"); 
    101         info.magic = SC_PKCS15_PIN_MAGIC; 
     101 
    102102        obj->type = SC_PKCS15_TYPE_AUTH_PIN; 
    103103        obj->data = malloc(sizeof(info)); 
    104104        if (obj->data == NULL) 
    105105                SC_FUNC_RETURN(ctx, SC_LOG_DEBUG_NORMAL, SC_ERROR_OUT_OF_MEMORY); 
    106         if (info.max_length == 0) { 
     106 
     107        if (info.attrs.pin.max_length == 0) { 
    107108                if (p15card->card->max_pin_len != 0) 
    108                         info.max_length = p15card->card->max_pin_len; 
    109                 else if (info.stored_length != 0) 
    110                         info.max_length = info.type != SC_PKCS15_PIN_TYPE_BCD ? 
    111                                 info.stored_length : 2 * info.stored_length; 
     109                        info.attrs.pin.max_length = p15card->card->max_pin_len; 
     110                else if (info.attrs.pin.stored_length != 0) 
     111                        info.attrs.pin.max_length = info.attrs.pin.type != SC_PKCS15_PIN_TYPE_BCD ? 
     112                                info.attrs.pin.stored_length : 2 * info.attrs.pin.stored_length; 
    112113                else 
    113                         info.max_length = 8; /* shouldn't happen */ 
     114                        info.attrs.pin.max_length = 8; /* shouldn't happen */ 
    114115        } 
    115116 
    … …  
    119120           The same invalid encoding has some models of the proprietary PKCS#15 cards. 
    120121        */ 
    121         if (info.reference < 0) 
    122                 info.reference += 256; 
     122        if (info.attrs.pin.reference < 0) 
     123                info.attrs.pin.reference += 256; 
    123124 
    124125        info.auth_method = SC_AC_CHV; 
    125126 
    126         if (info.flags & SC_PKCS15_PIN_FLAG_LOCAL)   { 
     127        if (info.attrs.pin.flags & SC_PKCS15_PIN_FLAG_LOCAL)   { 
    127128                /* In OpenSC pkcs#15 framework 'path' is mandatory for the 'Local' PINs.  
    128129                 * If 'path' do not present in PinAttributes,  
    … …  
    136137                } 
    137138        } 
    138         sc_debug(ctx, SC_LOG_DEBUG_ASN1, "decoded PIN(ref:%X,path:%s)", info.reference, sc_print_path(&info.path)); 
     139        sc_debug(ctx, SC_LOG_DEBUG_ASN1, "decoded PIN(ref:%X,path:%s)", info.attrs.pin.reference, sc_print_path(&info.path)); 
    139140 
    140141        memcpy(obj->data, &info, sizeof(info)); 
    … …  
    148149        struct sc_asn1_entry asn1_com_ao_attr[2], asn1_pin_attr[10], asn1_type_pin_attr[2]; 
    149150        struct sc_asn1_entry asn1_pin[2]; 
    150         struct sc_pkcs15_pin_info *pin = 
    151                 (struct sc_pkcs15_pin_info *) obj->data; 
     151        struct sc_pkcs15_auth_info *info = (struct sc_pkcs15_auth_info *) obj->data; 
    152152        struct sc_asn1_pkcs15_object pin_obj = { (struct sc_pkcs15_object *) obj, 
    153153                                                 asn1_com_ao_attr, NULL, asn1_type_pin_attr }; 
    … …  
    156156        size_t padchar_len = 1; 
    157157 
     158        if (info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     159                return SC_ERROR_NOT_SUPPORTED; 
     160 
    158161        sc_copy_asn1_entry(c_asn1_pin, asn1_pin); 
    159162        sc_copy_asn1_entry(c_asn1_type_pin_attr, asn1_type_pin_attr); 
    … …  
    165168        sc_format_asn1_entry(asn1_type_pin_attr + 0, asn1_pin_attr, NULL, 1); 
    166169 
    167         flags_len = sizeof(pin->flags); 
    168         sc_format_asn1_entry(asn1_pin_attr + 0, &pin->flags, &flags_len, 1); 
    169         sc_format_asn1_entry(asn1_pin_attr + 1, &pin->type, NULL, 1); 
    170         sc_format_asn1_entry(asn1_pin_attr + 2, &pin->min_length, NULL, 1); 
    171         sc_format_asn1_entry(asn1_pin_attr + 3, &pin->stored_length, NULL, 1); 
    172         if (pin->max_length > 0) 
    173                 sc_format_asn1_entry(asn1_pin_attr + 4, &pin->max_length, NULL, 1); 
    174         if (pin->reference >= 0) 
    175                 sc_format_asn1_entry(asn1_pin_attr + 5, &pin->reference, NULL, 1); 
     170        flags_len = sizeof(info->attrs.pin.flags); 
     171        sc_format_asn1_entry(asn1_pin_attr + 0, &info->attrs.pin.flags, &flags_len, 1); 
     172        sc_format_asn1_entry(asn1_pin_attr + 1, &info->attrs.pin.type, NULL, 1); 
     173        sc_format_asn1_entry(asn1_pin_attr + 2, &info->attrs.pin.min_length, NULL, 1); 
     174        sc_format_asn1_entry(asn1_pin_attr + 3, &info->attrs.pin.stored_length, NULL, 1); 
     175        if (info->attrs.pin.max_length > 0) 
     176                sc_format_asn1_entry(asn1_pin_attr + 4, &info->attrs.pin.max_length, NULL, 1); 
     177        if (info->attrs.pin.reference >= 0) 
     178                sc_format_asn1_entry(asn1_pin_attr + 5, &info->attrs.pin.reference, NULL, 1); 
    176179        /* FIXME: check if pad_char present */ 
    177         sc_format_asn1_entry(asn1_pin_attr + 6, &pin->pad_char, &padchar_len, 1); 
    178         sc_format_asn1_entry(asn1_pin_attr + 8, &pin->path, NULL, pin->path.len ? 1 : 0); 
    179  
    180         sc_format_asn1_entry(asn1_com_ao_attr + 0, &pin->auth_id, NULL, 1); 
    181  
    182         assert(pin->magic == SC_PKCS15_PIN_MAGIC); 
     180        sc_format_asn1_entry(asn1_pin_attr + 6, &info->attrs.pin.pad_char, &padchar_len, 1); 
     181        sc_format_asn1_entry(asn1_pin_attr + 8, &info->path, NULL, info->path.len ? 1 : 0); 
     182 
     183        sc_format_asn1_entry(asn1_com_ao_attr + 0, &info->auth_id, NULL, 1); 
     184 
    183185        r = sc_asn1_encode(ctx, asn1_pin, buf, buflen); 
    184186 
    … …  
    187189 
    188190static int _validate_pin(struct sc_pkcs15_card *p15card, 
    189                          struct sc_pkcs15_pin_info *pin, 
     191                         struct sc_pkcs15_auth_info *auth_info, 
    190192                         size_t pinlen) 
    191193{ 
    … …  
    193195        assert(p15card != NULL); 
    194196 
    195         if (pin->magic != SC_PKCS15_PIN_MAGIC) 
    196                 return SC_ERROR_OBJECT_NOT_VALID; 
    197                  
     197        /* Ignore validation of the non-PIN authentication objects */ 
     198        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     199                return SC_SUCCESS; 
     200 
    198201        /* prevent buffer overflow from hostile card */  
    199         if (pin->stored_length > SC_MAX_PIN_SIZE) 
     202        if (auth_info->attrs.pin.stored_length > SC_MAX_PIN_SIZE) 
    200203                return SC_ERROR_BUFFER_TOO_SMALL; 
    201204 
    … …  
    205208                 
    206209        /* If pin is given, make sure it is within limits */ 
    207         max_length = pin->max_length != 0 ? pin->max_length : SC_MAX_PIN_SIZE; 
    208         if (pinlen > max_length || pinlen < pin->min_length) 
     210        max_length = auth_info->attrs.pin.max_length != 0 ? auth_info->attrs.pin.max_length : SC_MAX_PIN_SIZE; 
     211        if (pinlen > max_length || pinlen < auth_info->attrs.pin.min_length) 
    209212                return SC_ERROR_INVALID_PIN_LENGTH; 
    210213 
    … …  
    224227{ 
    225228        struct sc_context *ctx = p15card->card->ctx; 
    226         struct sc_pkcs15_pin_info *pin_info = (struct sc_pkcs15_pin_info *)pin_obj->data; 
     229        struct sc_pkcs15_auth_info *auth_info = (struct sc_pkcs15_auth_info *)pin_obj->data; 
    227230        int r; 
    228231        sc_card_t *card; 
    … …  
    232235        sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "PIN(%p;len:%i)", pincode, pinlen); 
    233236 
    234         r = _validate_pin(p15card, pin_info, pinlen); 
     237        /* TODO: verify other authentication objects */ 
     238        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     239                return SC_ERROR_NOT_SUPPORTED; 
     240 
     241        r = _validate_pin(p15card, auth_info, pinlen); 
    235242        SC_TEST_RET(ctx, SC_LOG_DEBUG_NORMAL, r, "PIN value do not conforms the PIN policy"); 
    236243 
    … …  
    240247        SC_TEST_RET(ctx, SC_LOG_DEBUG_NORMAL, r, "sc_lock() failed"); 
    241248        /* the path in the pin object is optional */ 
    242         if (pin_info->path.len > 0) { 
    243                 r = sc_select_file(card, &pin_info->path, NULL); 
     249        if (auth_info->path.len > 0) { 
     250                r = sc_select_file(card, &auth_info->path, NULL); 
    244251                if (r) 
    245252                        goto out; 
    … …  
    249256        memset(&data, 0, sizeof(data)); 
    250257        data.cmd = SC_PIN_CMD_VERIFY; 
    251         data.pin_type = pin_info->auth_method; 
    252         data.pin_reference = pin_info->reference; 
    253         data.pin1.min_length = pin_info->min_length; 
    254         data.pin1.max_length = pin_info->max_length; 
    255         data.pin1.pad_length = pin_info->stored_length; 
    256         data.pin1.pad_char = pin_info->pad_char; 
     258        data.pin_type = auth_info->auth_method; 
     259        data.pin_reference = auth_info->attrs.pin.reference; 
     260        data.pin1.min_length = auth_info->attrs.pin.min_length; 
     261        data.pin1.max_length = auth_info->attrs.pin.max_length; 
     262        data.pin1.pad_length = auth_info->attrs.pin.stored_length; 
     263        data.pin1.pad_char = auth_info->attrs.pin.pad_char; 
    257264        data.pin1.data = pincode; 
    258265        data.pin1.len = pinlen; 
    259266 
    260         if (pin_info->flags & SC_PKCS15_PIN_FLAG_NEEDS_PADDING) 
     267        if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_NEEDS_PADDING) 
    261268                data.flags |= SC_PIN_CMD_NEED_PADDING; 
    262269 
    263         switch (pin_info->type) { 
     270        switch (auth_info->attrs.pin.type) { 
    264271        case SC_PKCS15_PIN_TYPE_BCD: 
    265272                data.pin1.encoding = SC_PIN_ENCODING_BCD; 
    … …  
    276283                if (!pincode && !pinlen) 
    277284                        data.flags |= SC_PIN_CMD_USE_PINPAD; 
    278                 if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     285                if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
    279286                        data.pin1.prompt = "Please enter SO PIN"; 
    280287                else 
    … …  
    282289        } 
    283290 
    284         r = sc_pin_cmd(card, &data, &pin_info->tries_left); 
     291        r = sc_pin_cmd(card, &data, &auth_info->tries_left); 
    285292        if (r == SC_SUCCESS) 
    286293                sc_pkcs15_pincache_add(p15card, pin_obj, pincode, pinlen); 
    … …  
    301308        sc_card_t *card; 
    302309        struct sc_pin_cmd_data data; 
    303         struct sc_pkcs15_pin_info *pin_info = (struct sc_pkcs15_pin_info *)pin_obj->data; 
     310        struct sc_pkcs15_auth_info *auth_info = (struct sc_pkcs15_auth_info *)pin_obj->data; 
    304311         
     312        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     313                return SC_ERROR_NOT_SUPPORTED; 
     314 
    305315        /* make sure the pins are in valid range */ 
    306         if ((r = _validate_pin(p15card, pin_info, oldpinlen)) != SC_SUCCESS) 
     316        if ((r = _validate_pin(p15card, auth_info, oldpinlen)) != SC_SUCCESS) 
    307317                return r; 
    308         if ((r = _validate_pin(p15card, pin_info, newpinlen)) != SC_SUCCESS) 
     318        if ((r = _validate_pin(p15card, auth_info, newpinlen)) != SC_SUCCESS) 
    309319                return r; 
    310320 
    … …  
    313323        SC_TEST_RET(card->ctx, SC_LOG_DEBUG_NORMAL, r, "sc_lock() failed"); 
    314324        /* the path in the pin object is optional */ 
    315         if (pin_info->path.len > 0) { 
    316                 r = sc_select_file(card, &pin_info->path, NULL); 
     325        if (auth_info->path.len > 0) { 
     326                r = sc_select_file(card, &auth_info->path, NULL); 
    317327                if (r) 
    318328                        goto out; 
    … …  
    323333        data.cmd             = SC_PIN_CMD_CHANGE; 
    324334        data.pin_type        = SC_AC_CHV; 
    325         data.pin_reference   = pin_info->reference; 
     335        data.pin_reference   = auth_info->attrs.pin.reference; 
    326336        data.pin1.data       = oldpin; 
    327337        data.pin1.len        = oldpinlen; 
    328         data.pin1.pad_char   = pin_info->pad_char; 
    329         data.pin1.min_length = pin_info->min_length; 
    330         data.pin1.max_length = pin_info->max_length; 
    331         data.pin1.pad_length = pin_info->stored_length; 
     338        data.pin1.pad_char   = auth_info->attrs.pin.pad_char; 
     339        data.pin1.min_length = auth_info->attrs.pin.min_length; 
     340        data.pin1.max_length = auth_info->attrs.pin.max_length; 
     341        data.pin1.pad_length = auth_info->attrs.pin.stored_length; 
    332342        data.pin2.data       = newpin; 
    333343        data.pin2.len        = newpinlen; 
    334         data.pin2.pad_char   = pin_info->pad_char; 
    335         data.pin2.min_length = pin_info->min_length; 
    336         data.pin2.max_length = pin_info->max_length; 
    337         data.pin2.pad_length = pin_info->stored_length; 
    338  
    339         if (pin_info->flags & SC_PKCS15_PIN_FLAG_NEEDS_PADDING) 
     344        data.pin2.pad_char   = auth_info->attrs.pin.pad_char; 
     345        data.pin2.min_length = auth_info->attrs.pin.min_length; 
     346        data.pin2.max_length = auth_info->attrs.pin.max_length; 
     347        data.pin2.pad_length = auth_info->attrs.pin.stored_length; 
     348 
     349        if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_NEEDS_PADDING) 
    340350                data.flags |= SC_PIN_CMD_NEED_PADDING; 
    341351 
    342         switch (pin_info->type) { 
     352        switch (auth_info->attrs.pin.type) { 
    343353        case SC_PKCS15_PIN_TYPE_BCD: 
    344354                data.pin1.encoding = SC_PIN_ENCODING_BCD; 
    … …  
    354364                        && p15card->card->reader->capabilities & SC_READER_CAP_PIN_PAD) { 
    355365                data.flags |= SC_PIN_CMD_USE_PINPAD; 
    356                 if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
     366                if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
    357367                        data.pin1.prompt = "Please enter SO PIN"; 
    358368                        data.pin2.prompt = "Please enter new SO PIN"; 
    … …  
    363373        } 
    364374 
    365         r = sc_pin_cmd(card, &data, &pin_info->tries_left); 
     375        r = sc_pin_cmd(card, &data, &auth_info->tries_left); 
    366376        if (r == SC_SUCCESS) 
    367377                sc_pkcs15_pincache_add(p15card, pin_obj, newpin, newpinlen); 
    … …  
    384394        struct sc_pin_cmd_data data; 
    385395        struct sc_pkcs15_object *puk_obj; 
    386         struct sc_pkcs15_pin_info *puk_info = NULL; 
    387         struct sc_pkcs15_pin_info *pin_info = (struct sc_pkcs15_pin_info *)pin_obj->data; 
     396        struct sc_pkcs15_auth_info *puk_info = NULL; 
     397        struct sc_pkcs15_auth_info *auth_info = (struct sc_pkcs15_auth_info *)pin_obj->data; 
     398 
     399        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     400                return SC_ERROR_NOT_SUPPORTED; 
    388401 
    389402        /* make sure the pins are in valid range */ 
    390         if ((r = _validate_pin(p15card, pin_info, newpinlen)) != SC_SUCCESS) 
     403        if ((r = _validate_pin(p15card, auth_info, newpinlen)) != SC_SUCCESS) 
    391404                return r; 
    392405 
    … …  
    400413        if (r >= 0 && puk_obj) { 
    401414                /* second step:  get the pkcs15 info object of the puk */ 
    402                 puk_info = (struct sc_pkcs15_pin_info *)puk_obj->data; 
     415                puk_info = (struct sc_pkcs15_auth_info *)puk_obj->data; 
    403416        } 
    404417        if (!puk_info) { 
    405418                sc_debug(card->ctx, SC_LOG_DEBUG_NORMAL, "Unable to get puk object, using pin object instead!"); 
    406                 puk_info = pin_info; 
     419                puk_info = auth_info; 
    407420        } 
    408421         
    … …  
    414427        SC_TEST_RET(card->ctx, SC_LOG_DEBUG_NORMAL, r, "sc_lock() failed"); 
    415428        /* the path in the pin object is optional */ 
    416         if (pin_info->path.len > 0) { 
    417                 r = sc_select_file(card, &pin_info->path, NULL); 
     429        if (auth_info->path.len > 0) { 
     430                r = sc_select_file(card, &auth_info->path, NULL); 
    418431                if (r) 
    419432                        goto out; 
    … …  
    424437        data.cmd             = SC_PIN_CMD_UNBLOCK; 
    425438        data.pin_type        = SC_AC_CHV; 
    426         data.pin_reference   = pin_info->reference; 
     439        data.pin_reference   = auth_info->attrs.pin.reference; 
    427440        data.pin1.data       = puk; 
    428441        data.pin1.len        = puklen; 
    429         data.pin1.pad_char   = pin_info->pad_char; 
    430         data.pin1.min_length = pin_info->min_length; 
    431         data.pin1.max_length = pin_info->max_length; 
    432         data.pin1.pad_length = pin_info->stored_length; 
     442        data.pin1.pad_char   = auth_info->attrs.pin.pad_char; 
     443        data.pin1.min_length = auth_info->attrs.pin.min_length; 
     444        data.pin1.max_length = auth_info->attrs.pin.max_length; 
     445        data.pin1.pad_length = auth_info->attrs.pin.stored_length; 
    433446        data.pin2.data       = newpin; 
    434447        data.pin2.len        = newpinlen; 
    435         data.pin2.pad_char   = puk_info->pad_char; 
    436         data.pin2.min_length = puk_info->min_length; 
    437         data.pin2.max_length = puk_info->max_length; 
    438         data.pin2.pad_length = puk_info->stored_length; 
    439  
    440         if (pin_info->flags & SC_PKCS15_PIN_FLAG_NEEDS_PADDING) 
     448        data.pin2.pad_char   = puk_info->attrs.pin.pad_char; 
     449        data.pin2.min_length = puk_info->attrs.pin.min_length; 
     450        data.pin2.max_length = puk_info->attrs.pin.max_length; 
     451        data.pin2.pad_length = puk_info->attrs.pin.stored_length; 
     452 
     453        if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_NEEDS_PADDING) 
    441454                data.flags |= SC_PIN_CMD_NEED_PADDING; 
    442455 
    443         switch (pin_info->type) { 
     456        switch (auth_info->attrs.pin.type) { 
    444457        case SC_PKCS15_PIN_TYPE_BCD: 
    445458                data.pin1.encoding = SC_PIN_ENCODING_BCD; 
    … …  
    450463        } 
    451464 
    452         switch (puk_info->type) { 
     465        switch (puk_info->attrs.pin.type) { 
    453466        case SC_PKCS15_PIN_TYPE_BCD: 
    454467                data.pin2.encoding = SC_PIN_ENCODING_BCD; 
    … …  
    461474        if(p15card->card->reader->capabilities & SC_READER_CAP_PIN_PAD) { 
    462475                data.flags |= SC_PIN_CMD_USE_PINPAD; 
    463                 if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
     476                if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
    464477                        data.pin1.prompt = "Please enter PUK"; 
    465478                        data.pin2.prompt = "Please enter new SO PIN"; 
    … …  
    470483        } 
    471484 
    472         r = sc_pin_cmd(card, &data, &pin_info->tries_left); 
     485        r = sc_pin_cmd(card, &data, &auth_info->tries_left); 
    473486        if (r == SC_SUCCESS) 
    474487                sc_pkcs15_pincache_add(p15card, pin_obj, newpin, newpinlen); 
    … …  
    479492} 
    480493 
    481 void sc_pkcs15_free_pin_info(sc_pkcs15_pin_info_t *pin) 
    482 { 
    483         free(pin); 
     494void sc_pkcs15_free_auth_info(sc_pkcs15_auth_info_t *auth_info) 
     495{ 
     496        free(auth_info); 
    484497} 
    485498 
    … …  
    490503{ 
    491504        struct sc_context *ctx = p15card->card->ctx; 
    492         struct sc_pkcs15_pin_info *pin_info = (struct sc_pkcs15_pin_info *)pin_obj->data; 
     505        struct sc_pkcs15_auth_info *auth_info = (struct sc_pkcs15_auth_info *)pin_obj->data; 
    493506        struct sc_pkcs15_object *obj = NULL; 
    494507        int r; 
    … …  
    510523                 * "CommonObjectAttributes.accessControlRules" are not taken into account. */ 
    511524 
    512                 if (sc_pkcs15_compare_id(&obj->auth_id, &pin_info->auth_id)) { 
     525                if (sc_pkcs15_compare_id(&obj->auth_id, &auth_info->auth_id)) { 
    513526                        /* Caching is refused, if the protected object requires user consent */ 
    514527                        if (obj->user_consent > 0) { 

  • src/libopensc/pkcs15-piv.c

    ra9eba2b rd888b3f  
    764764        sc_debug(card->ctx, SC_LOG_DEBUG_NORMAL, "PIV-II adding pins..."); 
    765765        for (i = 0; pins[i].label; i++) { 
    766                 struct sc_pkcs15_pin_info pin_info; 
     766                struct sc_pkcs15_auth_info pin_info; 
    767767                struct sc_pkcs15_object   pin_obj; 
    768768                const char * label; 
    … …  
    772772                memset(&pin_obj,  0, sizeof(pin_obj)); 
    773773 
     774                pin_info.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
    774775                sc_pkcs15_format_id(pins[i].id, &pin_info.auth_id); 
    775                 pin_info.reference     = pins[i].ref; 
    776                 pin_info.flags         = pins[i].flags; 
    777                 pin_info.type          = pins[i].type; 
    778                 pin_info.min_length    = pins[i].minlen; 
    779                 pin_info.stored_length = pins[i].storedlen; 
    780                 pin_info.max_length    = pins[i].maxlen; 
    781                 pin_info.pad_char      = pins[i].pad_char; 
     776                pin_info.attrs.pin.reference     = pins[i].ref; 
     777                pin_info.attrs.pin.flags         = pins[i].flags; 
     778                pin_info.attrs.pin.type          = pins[i].type; 
     779                pin_info.attrs.pin.min_length    = pins[i].minlen; 
     780                pin_info.attrs.pin.stored_length = pins[i].storedlen; 
     781                pin_info.attrs.pin.max_length    = pins[i].maxlen; 
     782                pin_info.attrs.pin.pad_char      = pins[i].pad_char; 
    782783                sc_format_path(pins[i].path, &pin_info.path); 
    783784                pin_info.tries_left    = -1; 
    … …  
    788789                                        &pin_ref) == 0 && 
    789790                                pin_ref == 0x00) { /* must be 80 for PIV pin, or 00 for Global PIN */ 
    790                         pin_info.reference = pin_ref; 
     791                        pin_info.attrs.pin.reference = pin_ref; 
    791792                        label = "Global PIN"; 
    792793                }  

  • src/libopensc/pkcs15-postecert.c

    r50f99a20 rd888b3f  
    6868                int flags, int tries_left, const char pad_char, int obj_flags) 
    6969{ 
    70         sc_pkcs15_pin_info_t info; 
     70        sc_pkcs15_auth_info_t info; 
    7171        sc_pkcs15_object_t   obj; 
    7272 
    … …  
    7575 
    7676        info.auth_id           = *id; 
    77         info.min_length        = min_length; 
    78         info.max_length        = max_length; 
    79         info.stored_length     = max_length; 
    80         info.type              = type; 
    81         info.reference         = ref; 
    82         info.flags             = flags; 
     77        info.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
     78        info.attrs.pin.min_length        = min_length; 
     79        info.attrs.pin.max_length        = max_length; 
     80        info.attrs.pin.stored_length     = max_length; 
     81        info.attrs.pin.type              = type; 
     82        info.attrs.pin.reference         = ref; 
     83        info.attrs.pin.flags             = flags; 
     84        info.attrs.pin.pad_char          = pad_char; 
    8385        info.tries_left        = tries_left; 
    84         info.magic             = SC_PKCS15_PIN_MAGIC; 
    85         info.pad_char          = pad_char; 
    8686 
    8787        if (path) 
    8888                info.path = *path; 
    8989        if (type == SC_PKCS15_PIN_TYPE_BCD) 
    90                 info.stored_length /= 2; 
     90                info.attrs.pin.stored_length /= 2; 
    9191 
    9292        strlcpy(obj.label, label, sizeof(obj.label)); 

  • src/libopensc/pkcs15-pteid.c

    r2a4cdd4 rd888b3f  
    152152                static const char *pteid_pin_paths[2][3] = { {NULL, "3f005f00", NULL}, 
    153153                                                                                                         {NULL, NULL, NULL} }; 
    154                 struct sc_pkcs15_pin_info pin_info; 
     154                struct sc_pkcs15_auth_info pin_info; 
    155155                struct sc_pkcs15_object pin_obj; 
    156156 
    … …  
    158158                memset(&pin_obj, 0, sizeof(pin_obj)); 
    159159 
     160                pin_info.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
    160161                pin_info.auth_id.len = 1; 
    161162                pin_info.auth_id.value[0] = pteid_pin_authid[i]; 
    162                 pin_info.reference = pteid_pin_ref[type][i]; 
    163                 pin_info.flags = SC_PKCS15_PIN_FLAG_NEEDS_PADDING 
     163                pin_info.attrs.pin.reference = pteid_pin_ref[type][i]; 
     164                pin_info.attrs.pin.flags = SC_PKCS15_PIN_FLAG_NEEDS_PADDING 
    164165                                                 | SC_PKCS15_PIN_FLAG_INITIALIZED 
    165166                                                 | SC_PKCS15_PIN_FLAG_CASE_SENSITIVE; 
    166                 pin_info.type = SC_PKCS15_PIN_TYPE_ASCII_NUMERIC; 
    167                 pin_info.min_length = 4; 
    168                 pin_info.stored_length = 8; 
    169                 pin_info.max_length = 8; 
    170                 pin_info.pad_char = type == IAS_CARD ? 0x2F : 0xFF; 
     167                pin_info.attrs.pin.type = SC_PKCS15_PIN_TYPE_ASCII_NUMERIC; 
     168                pin_info.attrs.pin.min_length = 4; 
     169                pin_info.attrs.pin.stored_length = 8; 
     170                pin_info.attrs.pin.max_length = 8; 
     171                pin_info.attrs.pin.pad_char = type == IAS_CARD ? 0x2F : 0xFF; 
    171172                pin_info.tries_left = -1; 
    172173                if (pteid_pin_paths[type][i] != NULL) 

  • src/libopensc/pkcs15-starcert.c

    rf5a21e4 rd888b3f  
    204204        /* set pins */ 
    205205        for (i = 0; pins[i].label; i++) { 
    206                 struct sc_pkcs15_pin_info pin_info; 
     206                struct sc_pkcs15_auth_info pin_info; 
    207207                struct sc_pkcs15_object   pin_obj; 
    208208 
    … …  
    210210                memset(&pin_obj,  0, sizeof(pin_obj)); 
    211211 
     212 
    212213                sc_pkcs15_format_id(pins[i].id, &pin_info.auth_id); 
    213                 pin_info.reference     = pins[i].ref; 
    214                 pin_info.flags         = pins[i].flags; 
    215                 pin_info.type          = pins[i].type; 
    216                 pin_info.min_length    = pins[i].minlen; 
    217                 pin_info.stored_length = pins[i].storedlen; 
    218                 pin_info.max_length    = pins[i].maxlen; 
    219                 pin_info.pad_char      = pins[i].pad_char; 
     214                pin_info.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
     215                pin_info.attrs.pin.reference     = pins[i].ref; 
     216                pin_info.attrs.pin.flags         = pins[i].flags; 
     217                pin_info.attrs.pin.type          = pins[i].type; 
     218                pin_info.attrs.pin.min_length    = pins[i].minlen; 
     219                pin_info.attrs.pin.stored_length = pins[i].storedlen; 
     220                pin_info.attrs.pin.max_length    = pins[i].maxlen; 
     221                pin_info.attrs.pin.pad_char      = pins[i].pad_char; 
    220222                sc_format_path(pins[i].path, &pin_info.path); 
    221223                pin_info.tries_left    = -1; 

  • src/libopensc/pkcs15-syn.c

    r3169f14 rd888b3f  
    325325 
    326326int sc_pkcs15emu_add_pin_obj(sc_pkcs15_card_t *p15card, 
    327         const sc_pkcs15_object_t *obj, const sc_pkcs15_pin_info_t *in_pin) 
    328 { 
    329         sc_pkcs15_pin_info_t pin = *in_pin; 
    330  
    331         pin.magic = SC_PKCS15_PIN_MAGIC; 
     327        const sc_pkcs15_object_t *obj, const sc_pkcs15_auth_info_t *in_pin) 
     328{ 
     329        sc_pkcs15_auth_info_t pin = *in_pin; 
     330 
     331        pin.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
    332332        if(!pin.auth_method) /* or SC_AC_NONE */ 
    333333                pin.auth_method = SC_AC_CHV; 
    … …  
    413413        case SC_PKCS15_TYPE_AUTH: 
    414414                df_type  = SC_PKCS15_AODF; 
    415                 data_len = sizeof(struct sc_pkcs15_pin_info); 
     415                data_len = sizeof(struct sc_pkcs15_auth_info); 
    416416                break; 
    417417        case SC_PKCS15_TYPE_PRKEY: 

  • src/libopensc/pkcs15-tccardos.c

    r7789948 rd888b3f  
    167167{ 
    168168        sc_pkcs15_object_t   p15obj; 
    169         sc_pkcs15_pin_info_t ainfo; 
     169        sc_pkcs15_auth_info_t ainfo; 
    170170 
    171171        /* init data objects */ 
    … …  
    175175        ainfo.auth_id.value[0] = (u8)pinId; 
    176176        ainfo.auth_id.len   = 1; 
    177         ainfo.reference = (u8)pinId; 
    178         ainfo.flags = SC_PKCS15_PIN_FLAG_EXCHANGE_REF_DATA; 
     177        ainfo.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
     178        ainfo.attrs.pin.reference = (u8)pinId; 
     179        ainfo.attrs.pin.flags = SC_PKCS15_PIN_FLAG_EXCHANGE_REF_DATA; 
    179180        if ((key_descr & TC_CARDOS_PIN_MASK) == TC_CARDOS_LOCALPIN) 
    180                 ainfo.flags |= SC_PKCS15_PIN_FLAG_LOCAL; 
    181         ainfo.type  = SC_PKCS15_PIN_TYPE_BCD; /* XXX */ 
    182         ainfo.min_length = 6;    /* XXX */ 
    183         ainfo.stored_length = 8; /* XXX */ 
    184         ainfo.max_length = 8; 
    185         ainfo.pad_char   = 0; 
     181                ainfo.attrs.pin.flags |= SC_PKCS15_PIN_FLAG_LOCAL; 
     182        ainfo.attrs.pin.type  = SC_PKCS15_PIN_TYPE_BCD; /* XXX */ 
     183        ainfo.attrs.pin.min_length = 6;    /* XXX */ 
     184        ainfo.attrs.pin.stored_length = 8; /* XXX */ 
     185        ainfo.attrs.pin.max_length = 8; 
     186        ainfo.attrs.pin.pad_char   = 0; 
    186187        ainfo.tries_left = 3;    /* XXX */ 
    187188        sc_format_path(TC_CARDOS_APP_DF, &ainfo.path); 

  • src/libopensc/pkcs15-tcos.c

    rc97fc2e rd888b3f  
    190190        sc_context_t *ctx=p15card->card->ctx; 
    191191        sc_file_t *f; 
    192         struct sc_pkcs15_pin_info pin_info; 
     192        struct sc_pkcs15_auth_info pin_info; 
    193193        struct sc_pkcs15_object pin_obj; 
    194194        int r; 
    … …  
    197197        pin_info.auth_id.len      = 1; 
    198198        pin_info.auth_id.value[0] = id; 
    199         pin_info.reference        = pin_reference; 
    200         pin_info.flags            = pin_flags; 
    201         pin_info.type             = SC_PKCS15_PIN_TYPE_ASCII_NUMERIC; 
    202         pin_info.min_length       = min_length; 
    203         pin_info.stored_length    = 16; 
    204         pin_info.max_length       = 16; 
    205         pin_info.pad_char         = '\0'; 
     199        pin_info.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
     200        pin_info.attrs.pin.reference        = pin_reference; 
     201        pin_info.attrs.pin.flags            = pin_flags; 
     202        pin_info.attrs.pin.type             = SC_PKCS15_PIN_TYPE_ASCII_NUMERIC; 
     203        pin_info.attrs.pin.min_length       = min_length; 
     204        pin_info.attrs.pin.stored_length    = 16; 
     205        pin_info.attrs.pin.max_length       = 16; 
     206        pin_info.attrs.pin.pad_char         = '\0'; 
    206207        sc_format_path(path, &pin_info.path); 
    207208 

  • src/libopensc/pkcs15-westcos.c

    rc9fae6f rd888b3f  
    7373                for (i = 0; i < 1; i++) { 
    7474                        unsigned int flags; 
    75                         struct sc_pkcs15_pin_info pin_info; 
     75                        struct sc_pkcs15_auth_info pin_info; 
    7676                        struct sc_pkcs15_object pin_obj; 
    7777                        memset(&pin_info, 0, sizeof(pin_info)); 
    … …  
    8383                                        SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN; 
    8484                        } 
     85                        pin_info.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
    8586                        pin_info.auth_id.len = 1; 
    8687                        pin_info.auth_id.value[0] = i + 1; 
    87                         pin_info.reference = i; 
    88                         pin_info.flags = flags; 
    89                         pin_info.type = SC_PKCS15_PIN_TYPE_BCD; 
    90                         pin_info.min_length = 4; 
    91                         pin_info.stored_length = 8; 
    92                         pin_info.max_length = 8; 
    93                         pin_info.pad_char = 0xff; 
     88                        pin_info.attrs.pin.reference = i; 
     89                        pin_info.attrs.pin.flags = flags; 
     90                        pin_info.attrs.pin.type = SC_PKCS15_PIN_TYPE_BCD; 
     91                        pin_info.attrs.pin.min_length = 4; 
     92                        pin_info.attrs.pin.stored_length = 8; 
     93                        pin_info.attrs.pin.max_length = 8; 
     94                        pin_info.attrs.pin.pad_char = 0xff; 
    9495                        pin_info.path = path; 
    9596                        pin_info.tries_left = -1; 

  • src/libopensc/pkcs15.c

    rf9b1a1e rd888b3f  
    10731073                return sc_pkcs15_compare_id(&((struct sc_pkcs15_pubkey_info *) data)->id, id); 
    10741074        case SC_PKCS15_TYPE_AUTH_PIN: 
    1075                 return sc_pkcs15_compare_id(&((struct sc_pkcs15_pin_info *) data)->auth_id, id); 
     1075                return sc_pkcs15_compare_id(&((struct sc_pkcs15_auth_info *) data)->auth_id, id); 
    10761076        case SC_PKCS15_TYPE_DATA_OBJECT: 
    10771077                return sc_pkcs15_compare_id(&((struct sc_pkcs15_data_info *) data)->id, id); 
    … …  
    11141114{ 
    11151115        void            *data = obj->data; 
     1116        struct sc_pkcs15_auth_info *auth_info; 
    11161117        unsigned int    flags; 
    11171118 
    11181119        switch (obj->type) { 
    11191120        case SC_PKCS15_TYPE_AUTH_PIN: 
    1120                 flags = ((struct sc_pkcs15_pin_info *) data)->flags; 
     1121                auth_info = (struct sc_pkcs15_auth_info *) obj->data; 
     1122                if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     1123                        return 0; 
     1124                flags = auth_info->attrs.pin.flags; 
    11211125                break; 
    11221126        default: 
    … …  
    11281132static int compare_obj_reference(sc_pkcs15_object_t *obj, int value) 
    11291133{ 
     1134        struct sc_pkcs15_auth_info *auth_info; 
    11301135        void            *data = obj->data; 
    11311136        int             reference; 
    … …  
    11331138        switch (obj->type) { 
    11341139        case SC_PKCS15_TYPE_AUTH_PIN: 
    1135                 reference = ((struct sc_pkcs15_pin_info *) data)->reference; 
     1140                auth_info = (struct sc_pkcs15_auth_info *) obj->data; 
     1141                if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     1142                        return 0; 
     1143                reference = auth_info->attrs.pin.reference; 
    11361144                break; 
    11371145        case SC_PKCS15_TYPE_PRKEY_RSA: 
    … …  
    11651173                return sc_compare_path(&((struct sc_pkcs15_pubkey_info *) data)->path, path); 
    11661174        case SC_PKCS15_TYPE_AUTH_PIN: 
    1167                 return sc_compare_path(&((struct sc_pkcs15_pin_info *) data)->path, path); 
     1175                return sc_compare_path(&((struct sc_pkcs15_auth_info *) data)->path, path); 
    11681176        case SC_PKCS15_TYPE_DATA_OBJECT: 
    11691177                return sc_compare_path(&((struct sc_pkcs15_data_info *) data)->path, path); 
    … …  
    13181326 
    13191327        for (ii=0; ii<nn_objs; ii++)   { 
    1320                 struct sc_pkcs15_pin_info *pin_info = (struct sc_pkcs15_pin_info *)auth_objs[ii]->data; 
    1321  
    1322                 if (pin_info->auth_method != auth_method) 
     1328                struct sc_pkcs15_auth_info *auth_info = (struct sc_pkcs15_auth_info *)auth_objs[ii]->data; 
     1329 
     1330                if (auth_info->auth_method != auth_method) 
    13231331                        continue; 
    1324                 if (pin_info->reference != reference) 
    1325                         continue; 
    1326  
    1327                 if (path && !sc_compare_path(&pin_info->path, path)) 
     1332                if (auth_info->auth_type == SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     1333                        if (auth_info->attrs.pin.reference != reference) 
     1334                                continue; 
     1335 
     1336                if (path && !sc_compare_path(&auth_info->path, path)) 
    13281337                        continue; 
    13291338 
    … …  
    14741483                break; 
    14751484        case SC_PKCS15_TYPE_AUTH: 
    1476                 sc_pkcs15_free_pin_info((sc_pkcs15_pin_info_t *)obj->data); 
     1485                sc_pkcs15_free_auth_info((sc_pkcs15_auth_info_t *)obj->data); 
    14771486                break; 
    14781487        default: 
    … …  
    21372146                break; 
    21382147        case SC_PKCS15_TYPE_AUTH_PIN: 
    2139                 *out = ((struct sc_pkcs15_pin_info *) obj->data)->auth_id; 
     2148                *out = ((struct sc_pkcs15_auth_info *) obj->data)->auth_id; 
    21402149                break; 
    21412150        case SC_PKCS15_TYPE_DATA_OBJECT: 

  • src/libopensc/pkcs15.h

    ra9eba2b rd888b3f  
    7474#define SC_PKCS15_PIN_AUTH_TYPE_SM_KEY                  2 
    7575 
    76 struct sc_pkcs15_pin_info { 
    77         struct sc_pkcs15_id auth_id; 
    78         int reference; 
    79         unsigned int flags, type; 
    80         unsigned int auth_method; 
    81         size_t min_length, stored_length, max_length; 
    82         u8 pad_char; 
    83         struct sc_path path; 
    84         int tries_left; 
    85         int max_tries; 
    86  
    87         unsigned int magic; 
    88 }; 
    89 typedef struct sc_pkcs15_pin_info sc_pkcs15_pin_info_t; 
     76struct sc_pkcs15_pin_attributes { 
     77        unsigned int  flags, type; 
     78        size_t  min_length, stored_length, max_length; 
     79        int  reference; 
     80        u8  pad_char; 
     81 }; 
     82struct sc_pkcs15_authkey_attributes { 
     83        int derived; 
     84        struct sc_pkcs15_id skey_id; 
     85 }; 
     86struct sc_pkcs15_biometric_attributes { 
     87 }; 
     88struct sc_pkcs15_auth_info { 
     89        struct sc_pkcs15_id  auth_id; 
     90        struct sc_path  path; 
     91        unsigned auth_type; 
     92        union { 
     93                struct sc_pkcs15_pin_attributes pin; 
     94                struct sc_pkcs15_biometric_attributes bio; 
     95                struct sc_pkcs15_authkey_attributes authkey; 
     96        } attrs; 
     97        unsigned int  auth_method; 
     98        int  tries_left, max_tries; 
     99 }; 
     100typedef struct sc_pkcs15_auth_info sc_pkcs15_auth_info_t; 
    90101 
    91102#define SC_PKCS15_ALGO_OP_COMPUTE_CHECKSUM      0x01 
    … …  
    753764void sc_pkcs15_free_cert_info(sc_pkcs15_cert_info_t *cert); 
    754765void sc_pkcs15_free_data_info(sc_pkcs15_data_info_t *data); 
    755 void sc_pkcs15_free_pin_info(sc_pkcs15_pin_info_t *pin); 
     766void sc_pkcs15_free_auth_info(sc_pkcs15_auth_info_t *auth_info); 
    756767void sc_pkcs15_free_object(sc_pkcs15_object_t *obj); 
    757768 
    … …  
    835846/* some wrapper functions for sc_pkcs15emu_object_add */ 
    836847int sc_pkcs15emu_add_pin_obj(sc_pkcs15_card_t *, 
    837         const sc_pkcs15_object_t *, const sc_pkcs15_pin_info_t *); 
     848        const sc_pkcs15_object_t *, const sc_pkcs15_auth_info_t *); 
    838849int sc_pkcs15emu_add_rsa_prkey(sc_pkcs15_card_t *, 
    839850        const sc_pkcs15_object_t *, const sc_pkcs15_prkey_info_t *); 

  • src/pkcs11/framework-pkcs15.c

    rd43e692e rd888b3f  
    3737#define slot_data(p)            ((struct pkcs15_slot_data *) (p)) 
    3838#define slot_data_auth(p)       (((p) && slot_data(p)) ? slot_data(p)->auth_obj : NULL) 
    39 #define slot_data_pin_info(p)   (((p) && slot_data_auth(p))? \ 
    40                 (struct sc_pkcs15_pin_info *) slot_data_auth(p)->data : NULL) 
     39#define slot_data_auth_info(p)  (((p) && slot_data_auth(p))? \ 
     40                (struct sc_pkcs15_auth_info *) slot_data_auth(p)->data : NULL) 
    4141 
    4242#define check_attribute_buffer(attr,size)       \ 
    … …  
    318318        struct sc_pkcs11_slot *slot; 
    319319        struct sc_pkcs15_object *auth; 
    320         struct sc_pkcs15_pin_info *pin_info; 
     320        struct sc_pkcs15_auth_info *pin_info; 
    321321        struct sc_pin_cmd_data data; 
    322322        int r; 
    … …  
    340340        auth = slot_data_auth(slot->fw_data); 
    341341        if (auth) { 
    342                 pin_info = (struct sc_pkcs15_pin_info*) auth->data; 
     342                pin_info = (struct sc_pkcs15_auth_info*) auth->data; 
     343 
     344                if (pin_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN)   { 
     345                        rv = CKR_FUNCTION_REJECTED; 
     346                        goto out; 
     347                } 
    343348 
    344349                /* Try to update PIN info from card */ 
    … …  
    346351                data.cmd = SC_PIN_CMD_GET_INFO; 
    347352                data.pin_type = SC_AC_CHV; 
    348                 data.pin_reference = pin_info->reference; 
     353                data.pin_reference = pin_info->attrs.pin.reference; 
    349354 
    350355                r = sc_pin_cmd(slot->card->card, &data, NULL); 
    … …  
    792797{ 
    793798        struct pkcs15_slot_data *fw_data; 
    794         struct sc_pkcs15_pin_info *pin_info = NULL; 
     799        struct sc_pkcs15_auth_info *pin_info = NULL; 
    795800        char tmp[64]; 
    796801 
    … …  
    810815 
    811816        if (auth != NULL) { 
    812                 pin_info = (struct sc_pkcs15_pin_info*) auth->data; 
    813  
    814                 if (auth->label[0]) { 
    815                         snprintf(tmp, sizeof(tmp), "%s (%s)", 
    816                                 p15card->tokeninfo->label, auth->label); 
    817                 } else { 
    818                         snprintf(tmp, sizeof(tmp), "%s", p15card->tokeninfo->label); 
    819                 } 
    820                 slot->token_info.flags |= CKF_LOGIN_REQUIRED; 
     817                pin_info = (struct sc_pkcs15_auth_info*) auth->data; 
     818 
     819                if (pin_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN)   { 
     820                        pin_info = NULL; 
     821                } 
     822                else   { 
     823                        if (auth->label[0]) 
     824                                snprintf(tmp, sizeof(tmp), "%s (%s)", p15card->tokeninfo->label, auth->label); 
     825                        else 
     826                                snprintf(tmp, sizeof(tmp), "%s", p15card->tokeninfo->label); 
     827                        slot->token_info.flags |= CKF_LOGIN_REQUIRED; 
     828                } 
    821829        } else 
    822830                snprintf(tmp, sizeof(tmp), "%s", p15card->tokeninfo->label); 
    823831        strcpy_bp(slot->token_info.label, tmp, 32); 
    824832 
    825         if (pin_info && pin_info->magic == SC_PKCS15_PIN_MAGIC) { 
    826                 slot->token_info.ulMaxPinLen = pin_info->max_length; 
    827                 slot->token_info.ulMinPinLen = pin_info->min_length; 
     833        if (pin_info) { 
     834                slot->token_info.ulMaxPinLen = pin_info->attrs.pin.max_length; 
     835                slot->token_info.ulMinPinLen = pin_info->attrs.pin.min_length; 
    828836        } else { 
    829837                /* choose reasonable defaults */ 
    … …  
    942950 
    943951        for (i = 0; i < auth_count; i++) { 
    944                 struct sc_pkcs15_pin_info *pin_info = NULL; 
    945  
    946                 pin_info = (struct sc_pkcs15_pin_info*) auths[i]->data; 
     952                struct sc_pkcs15_auth_info *pin_info = NULL; 
     953 
     954                pin_info = (struct sc_pkcs15_auth_info*) auths[i]->data; 
     955 
     956                /* Ignore all but PIN authentication objects */ 
     957                if (pin_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     958                        continue; 
    947959 
    948960                /* Ignore any non-authentication PINs */ 
    949                 if ((pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) != 0) 
     961                if ((pin_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) != 0) 
    950962                        continue; 
    951963 
    952964                /* Ignore unblocking pins for hacked module */ 
    953                 if (hack_enabled && (pin_info->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN) != 0) 
     965                if (hack_enabled && (pin_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN) != 0) 
    954966                        continue; 
    955967 
    956968                /* Ignore unblocking pins */ 
    957969                if (!sc_pkcs11_conf.create_puk_slot) 
    958                         if (pin_info->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN) 
     970                        if (pin_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN) 
    959971                                continue; 
    960972 
    … …  
    10531065        struct sc_pkcs15_card *p15card = fw_data->p15_card; 
    10541066        struct sc_pkcs15_object *auth_object; 
    1055         struct sc_pkcs15_pin_info *pin_info; 
     1067        struct sc_pkcs15_auth_info *pin_info; 
    10561068 
    10571069        switch (userType) { 
    … …  
    11261138                return CKR_USER_TYPE_INVALID; 
    11271139        } 
    1128         pin_info = (struct sc_pkcs15_pin_info *) auth_object->data; 
     1140        pin_info = (struct sc_pkcs15_auth_info *) auth_object->data; 
     1141        if (pin_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     1142                return CKR_FUNCTION_REJECTED; 
    11291143 
    11301144        if (p11card->card->reader->capabilities & SC_READER_CAP_PIN_PAD) { 
    … …  
    11471161                 * it cannot be correct. 
    11481162                 */ 
    1149                 if (ulPinLen < pin_info->min_length || 
    1150                     ulPinLen > pin_info->max_length) 
     1163                if (ulPinLen < pin_info->attrs.pin.min_length || 
     1164                    ulPinLen > pin_info->attrs.pin.max_length) 
    11511165                        return CKR_PIN_INCORRECT; 
    11521166        } 
    … …  
    12601274        int rc; 
    12611275        struct pkcs15_fw_data *fw_data = (struct pkcs15_fw_data *) p11card->fw_data; 
    1262         struct sc_pkcs15_pin_info *pin_info; 
     1276        struct sc_pkcs15_auth_info *auth_info; 
    12631277        struct sc_pkcs15_object *pin_obj; 
    12641278 
    … …  
    12661280                return CKR_USER_PIN_NOT_INITIALIZED; 
    12671281 
    1268         if (!(pin_info = slot_data_pin_info(fw_token))) 
     1282        if (!(auth_info = slot_data_auth_info(fw_token))) 
    12691283                return CKR_USER_PIN_NOT_INITIALIZED; 
    12701284 
    12711285        sc_debug(context, SC_LOG_DEBUG_NORMAL, "Change '%s', reference %i; login type %i",  
    1272                         pin_obj->label, pin_info->reference, login_user); 
     1286                        pin_obj->label, auth_info->attrs.pin.reference, login_user); 
    12731287        if (p11card->card->reader->capabilities & SC_READER_CAP_PIN_PAD) { 
    12741288                /* pPin should be NULL in case of a pin pad reader, but 
    … …  
    12811295                ulOldLen = ulNewLen = 0; 
    12821296        }  
    1283         else if (ulNewLen < pin_info->min_length || ulNewLen > pin_info->max_length)  { 
     1297        else if (ulNewLen < auth_info->attrs.pin.min_length || ulNewLen > auth_info->attrs.pin.max_length)  { 
    12841298                return CKR_PIN_LEN_RANGE; 
    12851299        } 
    … …  
    13111325                auth_count = rc; 
    13121326                for (i = 0; i < auth_count; i++)   { 
    1313                         pin_info = (struct sc_pkcs15_pin_info*) auths[i]->data; 
    1314                         if ((pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN)) 
     1327                        auth_info = (struct sc_pkcs15_auth_info*) auths[i]->data; 
     1328                        if ((auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN)) 
    13151329                                break; 
    13161330                } 
    … …  
    13401354        struct sc_profile       *profile; 
    13411355        struct sc_pkcs15_object *auth_obj; 
    1342         struct sc_pkcs15_pin_info *pin_info; 
     1356        struct sc_pkcs15_auth_info *auth_info; 
    13431357        int                     rc; 
    13441358 
    … …  
    13461360                        pPin, ulPinLen, sc_pkcs11_conf.pin_unblock_style); 
    13471361 
    1348         pin_info = slot_data_pin_info(slot->fw_data); 
    1349         if (pin_info && sc_pkcs11_conf.pin_unblock_style == SC_PKCS11_PIN_UNBLOCK_SO_LOGGED_INITPIN)   { 
     1362        auth_info = slot_data_auth_info(slot->fw_data); 
     1363        if (auth_info && sc_pkcs11_conf.pin_unblock_style == SC_PKCS11_PIN_UNBLOCK_SO_LOGGED_INITPIN)   { 
    13501364                /* C_InitPIN is used to unblock User PIN or set it in the SO session .*/ 
    13511365                auth_obj = slot_data_auth(slot->fw_data); 
    … …  
    13581372                         * Something like sc_pkcs15_set_pin() should be introduced. 
    13591373                         * For a while, use the 'libopensc' API to set PIN. */ 
    1360                         rc = sc_reset_retry_counter(fw_data->p15_card->card, SC_AC_CHV, pin_info->reference,  
     1374                        rc = sc_reset_retry_counter(fw_data->p15_card->card, SC_AC_CHV, auth_info->attrs.pin.reference,  
    13611375                                        NULL, 0, pPin, ulPinLen); 
    13621376                } 
    … …  
    13941408        pkcs15_init_slot(fw_data->p15_card, slot, auth_obj); 
    13951409 
    1396         pin_info = (sc_pkcs15_pin_info_t *) auth_obj->data; 
     1410        auth_info = (sc_pkcs15_auth_info_t *) auth_obj->data; 
    13971411        return CKR_OK; 
    13981412} 
    … …  
    14081422        struct pkcs15_any_object *key_any_obj; 
    14091423        struct sc_pkcs15_object *key_obj; 
    1410         struct sc_pkcs15_pin_info *pin; 
     1424        struct sc_pkcs15_auth_info *pin; 
    14111425        CK_KEY_TYPE             key_type; 
    14121426        struct sc_pkcs15_prkey_rsa *rsa; 
    … …  
    14201434        /* See if the "slot" is pin protected. If so, get the 
    14211435         * PIN id */ 
    1422         if ((pin = slot_data_pin_info(slot->fw_data)) != NULL) 
     1436        if ((pin = slot_data_auth_info(slot->fw_data)) != NULL) 
    14231437                args.auth_id = pin->auth_id; 
    14241438 
    … …  
    15401554        struct pkcs15_any_object *key_any_obj; 
    15411555        struct sc_pkcs15_object *key_obj; 
    1542         struct sc_pkcs15_pin_info *pin; 
     1556        struct sc_pkcs15_auth_info *pin; 
    15431557        CK_KEY_TYPE     key_type; 
    15441558        struct sc_pkcs15_pubkey_rsa *rsa; 
    … …  
    15501564        /* See if the "slot" is pin protected. If so, get the 
    15511565         * PIN id */ 
    1552         if ((pin = slot_data_pin_info(slot->fw_data)) != NULL) 
     1566        if ((pin = slot_data_auth_info(slot->fw_data)) != NULL) 
    15531567                args.auth_id = pin->auth_id; 
    15541568 
    … …  
    17151729        struct pkcs15_any_object *data_any_obj; 
    17161730        struct sc_pkcs15_object *data_obj; 
    1717         struct sc_pkcs15_pin_info *pin; 
     1731        struct sc_pkcs15_auth_info *pin; 
    17181732        CK_BBOOL                bValue; 
    17191733        int                     rc, rv; 
    … …  
    17341748                        rv = attr_extract(attr, &bValue, NULL); 
    17351749                        if (bValue) { 
    1736                                 pin = slot_data_pin_info(slot->fw_data); 
     1750                                pin = slot_data_auth_info(slot->fw_data); 
    17371751                                if (pin == NULL) { 
    17381752                                        rv = CKR_TEMPLATE_INCOMPLETE; 
    … …  
    19361950{ 
    19371951        struct sc_profile *profile = NULL; 
    1938         struct sc_pkcs15_pin_info *pin; 
     1952        struct sc_pkcs15_auth_info *pin; 
    19391953        struct pkcs15_fw_data *fw_data = (struct pkcs15_fw_data *) p11card->fw_data; 
    19401954        struct sc_pkcs15init_keygen_args keygen_args; 
    … …  
    19741988        /* 1. Convert the pkcs11 attributes to pkcs15init args */ 
    19751989 
    1976         if ((pin = slot_data_pin_info(slot->fw_data)) != NULL) 
     1990        if ((pin = slot_data_auth_info(slot->fw_data)) != NULL) 
    19771991                keygen_args.prkey_args.auth_id = pub_args.auth_id = pin->auth_id; 
    19781992 

  • src/pkcs15init/pkcs15-asepcos.c

    r65b65e5 rd888b3f  
    169169 */ 
    170170static int asepcos_select_pin_reference(sc_profile_t *profile,  
    171                 sc_pkcs15_card_t *p15card, sc_pkcs15_pin_info_t *pinfo) 
    172 { 
    173         if (pinfo->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     171                sc_pkcs15_card_t *p15card, sc_pkcs15_auth_info_t *auth_info) 
     172{ 
     173        if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
    174174                return SC_SUCCESS; 
    175         if (pinfo->reference <= 0) 
    176                 pinfo->reference = 1; 
     175        if (auth_info->attrs.pin.reference <= 0) 
     176                auth_info->attrs.pin.reference = 1; 
    177177        /* as we want to use <fileid of PIN> + 1 for the PUK we need to 
    178178         * ensure that all references are odd => if the reference is 
    179179         * even add one */ 
    180         if ((pinfo->reference & 1) == 0) 
    181                 pinfo->reference++; 
     180        if ((auth_info->attrs.pin.reference & 1) == 0) 
     181                auth_info->attrs.pin.reference++; 
    182182        return SC_SUCCESS; 
    183183} 
    … …  
    217217 
    218218static int asepcos_do_store_pin(sc_profile_t *profile, sc_card_t *card, 
    219         sc_pkcs15_pin_info_t *pinfo, const u8* pin, size_t pinlen, 
     219        sc_pkcs15_auth_info_t *auth_info, const u8* pin, size_t pinlen, 
    220220        int puk, int pinid) 
    221221{ 
    … …  
    223223        u8  buf[64], sbuf[64], *p = buf, *q = sbuf; 
    224224        int r, akn; 
     225 
     226        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     227                return SC_ERROR_OBJECT_NOT_VALID; 
    225228 
    226229        /* outter tag */ 
    … …  
    238241        *p++ = pinlen & 0xff; 
    239242        /* max tries */ 
    240         *p++ = pinfo->tries_left & 0xff; 
     243        *p++ = auth_info->tries_left & 0xff; 
    241244        /* algorithm id and key key usage and padding bytes */ 
    242245        *p++ = 0x00; 
    … …  
    306309                return r; 
    307310        /* use the AKN as reference */ 
    308         pinfo->reference = akn; 
     311        auth_info->attrs.pin.reference = akn; 
    309312        /* set the correct PIN length */ 
    310         pinfo->min_length    = 4; 
    311         pinfo->stored_length = pinlen; 
    312         pinfo->max_length    = 16; 
     313        auth_info->attrs.pin.min_length    = 4; 
     314        auth_info->attrs.pin.stored_length = pinlen; 
     315        auth_info->attrs.pin.max_length    = 16; 
    313316 
    314317        return r; 
    … …  
    320323static int have_onepin(sc_profile_t *profile) 
    321324{ 
    322         sc_pkcs15_pin_info_t sopin; 
     325        sc_pkcs15_auth_info_t sopin; 
     326 
    323327        sc_profile_get_pin_info(profile, SC_PKCS15INIT_SO_PIN, &sopin); 
    324         if (!(sopin.flags & SC_PKCS15_PIN_FLAG_SO_PIN)) 
     328 
     329        if (!(sopin.attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN)) 
    325330                return 1; 
    326331        else 
    … …  
    343348        const u8 *pin, size_t pin_len, const u8 *puk, size_t puk_len) 
    344349{ 
    345         sc_pkcs15_pin_info_t *pinfo = (sc_pkcs15_pin_info_t *) pin_obj->data; 
     350        sc_pkcs15_auth_info_t *auth_info = (sc_pkcs15_auth_info_t *) pin_obj->data; 
    346351        struct sc_card *card = p15card->card; 
    347352        int       r, pid, puk_id; 
    … …  
    354359                return SC_ERROR_INVALID_ARGUMENTS; 
    355360 
    356         pid = (pinfo->reference & 0xff) | (((tpath.len >> 1) - 1) << 16); 
     361        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     362                return SC_ERROR_OBJECT_NOT_VALID;        
     363 
     364        pid = (auth_info->attrs.pin.reference & 0xff) | (((tpath.len >> 1) - 1) << 16); 
    357365 
    358366        /* get the ACL of the application DF */ 
    … …  
    390398                 * the PIN as the PUK fileid is used in the PIN acl. 
    391399                 */ 
    392                 struct sc_pkcs15_pin_info puk_info; 
    393  
    394                 if (pinfo->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
    395                         sc_profile_get_pin_info(profile, SC_PKCS15INIT_SO_PUK, &puk_info); 
     400                struct sc_pkcs15_auth_info puk_ainfo; 
     401 
     402                if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     403                        sc_profile_get_pin_info(profile, SC_PKCS15INIT_SO_PUK, &puk_ainfo); 
    396404                else 
    397                         sc_profile_get_pin_info(profile, SC_PKCS15INIT_USER_PUK, &puk_info); 
     405                        sc_profile_get_pin_info(profile, SC_PKCS15INIT_USER_PUK, &puk_ainfo); 
    398406 
    399407                /* If a PUK we use "file id of the PIN" + 1  as the file id 
    … …  
    401409                 */ 
    402410                puk_id = pid + 1; 
    403                 r = asepcos_do_store_pin(profile, card, &puk_info, puk, puk_len, 0, puk_id); 
     411                r = asepcos_do_store_pin(profile, card, &puk_ainfo, puk, puk_len, 0, puk_id); 
    404412                if (r != SC_SUCCESS)  
    405413                        SC_FUNC_RETURN(ctx, SC_LOG_DEBUG_VERBOSE, r); 
    … …  
    407415                puk_id = 0; 
    408416 
    409         r = asepcos_do_store_pin(profile, card, pinfo, pin, pin_len, puk_id, pid); 
     417        r = asepcos_do_store_pin(profile, card, auth_info, pin, pin_len, puk_id, pid); 
    410418        if (r != SC_SUCCESS) 
    411419                SC_FUNC_RETURN(ctx, SC_LOG_DEBUG_VERBOSE, r); 
    412420 
    413421#if 1 
    414         if (pinfo->flags & SC_PKCS15_PIN_FLAG_SO_PIN ||  
     422        if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN ||  
    415423            (have_onepin(profile) && pid == 0x010001)) { 
    416424                sc_cardctl_asepcos_activate_file_t st; 
    … …  
    455463        if (r != SC_SUCCESS) 
    456464                return r; 
    457         pinfo->path = tpath; 
     465        auth_info->path = tpath; 
    458466#endif 
    459467        SC_FUNC_RETURN(ctx, SC_LOG_DEBUG_VERBOSE, r); 

  • src/pkcs15init/pkcs15-cardos.c

    rb21eeb46 rd888b3f  
    5151 */ 
    5252static int      cardos_store_pin(sc_profile_t *profile, sc_card_t *card, 
    53                         sc_pkcs15_pin_info_t *pin_info, int puk_id, 
     53                        sc_pkcs15_auth_info_t *auth_info, int puk_id, 
    5454                        const u8 *pin, size_t pin_len); 
    5555static int      cardos_create_sec_env(sc_profile_t *, sc_card_t *, 
    … …  
    153153static int 
    154154cardos_select_pin_reference(sc_profile_t *profile, sc_pkcs15_card_t *p15card, 
    155                 sc_pkcs15_pin_info_t *pin_info) 
     155                sc_pkcs15_auth_info_t *auth_info) 
    156156{ 
    157157        int     preferred, current; 
    158158 
    159         if ((current = pin_info->reference) < 0) 
     159        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     160                return SC_ERROR_OBJECT_NOT_VALID; 
     161 
     162        if ((current = auth_info->attrs.pin.reference) < 0) 
    160163                current = CARDOS_PIN_ID_MIN; 
    161164 
    162         if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
     165        if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
    163166                preferred = 1; 
    164167        } else { 
    … …  
    173176        if (current > preferred || preferred > CARDOS_PIN_ID_MAX) 
    174177                return SC_ERROR_TOO_MANY_OBJECTS; 
    175         pin_info->reference = preferred; 
     178        auth_info->attrs.pin.reference = preferred; 
    176179        return 0; 
    177180} 
    … …  
    186189                const u8 *puk, size_t puk_len) 
    187190{ 
    188         sc_pkcs15_pin_info_t *pin_info = (sc_pkcs15_pin_info_t *) pin_obj->data; 
     191        sc_pkcs15_auth_info_t *auth_info = (sc_pkcs15_auth_info_t *) pin_obj->data; 
    189192        struct sc_card *card = p15card->card; 
    190193        unsigned int    puk_id = CARDOS_AC_NEVER; 
    … …  
    194197                return SC_ERROR_INVALID_ARGUMENTS; 
    195198 
     199        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     200                return SC_ERROR_OBJECT_NOT_VALID; 
     201 
    196202        r = sc_select_file(card, &df->path, NULL); 
    197203        if (r < 0) 
    … …  
    199205 
    200206        if (puk && puk_len) { 
    201                 struct sc_pkcs15_pin_info puk_info; 
     207                struct sc_pkcs15_auth_info puk_ainfo; 
    202208 
    203209                sc_profile_get_pin_info(profile, 
    204                                 SC_PKCS15INIT_USER_PUK, &puk_info); 
    205                 puk_info.reference = puk_id = pin_info->reference + 1; 
     210                                SC_PKCS15INIT_USER_PUK, &puk_ainfo); 
     211                puk_ainfo.attrs.pin.reference = puk_id = auth_info->attrs.pin.reference + 1; 
    206212                r = cardos_store_pin(profile, card, 
    207                                 &puk_info, CARDOS_AC_NEVER, 
     213                                &puk_ainfo, CARDOS_AC_NEVER, 
    208214                                puk, puk_len); 
    209215        } 
    … …  
    211217        if (r >= 0) { 
    212218                r = cardos_store_pin(profile, card, 
    213                                 pin_info, puk_id, pin, pin_len); 
     219                                auth_info, puk_id, pin, pin_len); 
    214220        } 
    215221 
    … …  
    400406static int 
    401407cardos_store_pin(sc_profile_t *profile, sc_card_t *card, 
    402                 sc_pkcs15_pin_info_t *pin_info, int puk_id, 
     408                sc_pkcs15_auth_info_t *auth_info, int puk_id, 
    403409                const u8 *pin, size_t pin_len) 
    404410{ 
    … …  
    409415        unsigned int    attempts, minlen, maxlen; 
    410416        int             r; 
     417 
     418        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     419                return SC_ERROR_OBJECT_NOT_VALID; 
    411420 
    412421        /* We need to do padding because pkcs15-lib.c does it. 
    … …  
    424433        pin = pinpadded; 
    425434 
    426         attempts = pin_info->tries_left; 
    427         minlen = pin_info->min_length; 
     435        attempts = auth_info->tries_left; 
     436        minlen = auth_info->attrs.pin.min_length; 
    428437 
    429438        tlv_init(&tlv, buffer, sizeof(buffer)); 
    … …  
    432441        tlv_next(&tlv, 0x83); 
    433442        tlv_add(&tlv, 0x00);            /* class byte: usage TEST, k=0 */ 
    434         tlv_add(&tlv, pin_info->reference); 
     443        tlv_add(&tlv, auth_info->attrs.pin.reference); 
    435444 
    436445        /* parameters */ 
    … …  
    462471        tlv_next(&tlv, 0x86); 
    463472        tlv_add(&tlv, 0x00);                    /* use: always */ 
    464         tlv_add(&tlv, pin_info->reference);     /* change: PIN */ 
     473        tlv_add(&tlv, auth_info->attrs.pin.reference);  /* change: PIN */ 
    465474        tlv_add(&tlv, puk_id);                  /* unblock: PUK */ 
    466475 

  • src/pkcs15init/pkcs15-cflex.c

    r18c1446 rd888b3f  
    186186static int 
    187187cflex_select_pin_reference(sc_profile_t *profike, sc_pkcs15_card_t *p15card, 
    188                 sc_pkcs15_pin_info_t *pin_info) 
     188                sc_pkcs15_auth_info_t *auth_info) 
    189189{ 
    190190        int     preferred; 
    191191 
    192         if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
     192        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     193                return SC_ERROR_OBJECT_NOT_VALID; 
     194 
     195        if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
    193196                preferred = 2; 
    194197        } else { 
    195198                preferred = 1; 
    196199        } 
    197         if (pin_info->reference <= preferred) { 
    198                 pin_info->reference = preferred; 
     200        if (auth_info->attrs.pin.reference <= preferred) { 
     201                auth_info->attrs.pin.reference = preferred; 
    199202                return 0; 
    200203        } 
    201204 
    202         if (pin_info->reference > 2) 
     205        if (auth_info->attrs.pin.reference > 2) 
    203206                return SC_ERROR_INVALID_ARGUMENTS; 
    204207 
    … …  
    218221{ 
    219222        struct sc_context *ctx = p15card->card->ctx; 
    220         sc_pkcs15_pin_info_t *pin_info = (sc_pkcs15_pin_info_t *) pin_obj->data; 
     223        sc_pkcs15_auth_info_t *auth_info = (sc_pkcs15_auth_info_t *) pin_obj->data; 
     224        struct sc_pkcs15_pin_attributes *pin_attrs = &auth_info->attrs.pin; 
    221225        sc_file_t       *dummies[2]; 
    222226        int             ndummies, pin_type, puk_type, r; 
    … …  
    224228 
    225229        SC_FUNC_CALLED(ctx, SC_LOG_DEBUG_NORMAL); 
     230 
     231        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     232                return SC_ERROR_OBJECT_NOT_VALID; 
     233 
    226234        /* If the profile doesn't specify a reference for this PIN, guess */ 
    227         if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
     235        if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
    228236                pin_type = SC_PKCS15INIT_SO_PIN; 
    229237                puk_type = SC_PKCS15INIT_SO_PUK; 
    230                 if (pin_info->reference != 2) 
     238                if (pin_attrs->reference != 2) 
    231239                        return SC_ERROR_INVALID_ARGUMENTS; 
    232240        } else { 
    233241                pin_type = SC_PKCS15INIT_USER_PIN; 
    234242                puk_type = SC_PKCS15INIT_USER_PUK; 
    235                 if (pin_info->reference != 1) 
     243                if (pin_attrs->reference != 1) 
    236244                        return SC_ERROR_INVALID_ARGUMENTS; 
    237245        } 
    238246 
    239247        /* Get file definition from the profile */ 
    240         if (sc_profile_get_file(profile, (pin_info->reference == 1)? "CHV1" : "CHV2", &file) < 0 
     248        if (sc_profile_get_file(profile, (pin_attrs->reference == 1)? "CHV1" : "CHV2", &file) < 0 
    241249                        && sc_profile_get_file(profile, "CHV", &file) < 0) 
    242250                SC_TEST_RET(ctx, SC_LOG_DEBUG_NORMAL, SC_ERROR_FILE_NOT_FOUND, "profile does not define pin file ACLs"); 
    … …  
    245253        SC_TEST_RET(ctx, SC_LOG_DEBUG_NORMAL, ndummies, "Unable to create dummy CHV file"); 
    246254 
    247         r = cflex_create_pin_file(profile, p15card, &df->path, pin_info->reference, 
     255        r = cflex_create_pin_file(profile, p15card, &df->path, pin_attrs->reference, 
    248256                        pin, pin_len, sc_profile_get_pin_retries(profile, pin_type), 
    249257                        puk, puk_len, sc_profile_get_pin_retries(profile, puk_type), 

  • src/pkcs15init/pkcs15-entersafe.c

    r891f983 rd888b3f  
    247247 
    248248static int entersafe_pin_reference(sc_profile_t *profile, sc_pkcs15_card_t *p15card, 
    249                                                                    sc_pkcs15_pin_info_t *pin_info) 
     249                                                                   sc_pkcs15_auth_info_t *auth_info) 
    250250{ 
    251251        SC_FUNC_CALLED(p15card->card->ctx, SC_LOG_DEBUG_VERBOSE); 
    252252 
    253         if (pin_info->reference < ENTERSAFE_USER_PIN_ID) 
    254                  pin_info->reference = ENTERSAFE_USER_PIN_ID; 
    255         if(pin_info->reference>ENTERSAFE_USER_PIN_ID) 
     253        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     254                return SC_ERROR_OBJECT_NOT_VALID;        
     255 
     256        if (auth_info->attrs.pin.reference < ENTERSAFE_USER_PIN_ID) 
     257                 auth_info->attrs.pin.reference = ENTERSAFE_USER_PIN_ID; 
     258        if (auth_info->attrs.pin.reference > ENTERSAFE_USER_PIN_ID) 
    256259                 return SC_ERROR_TOO_MANY_OBJECTS; 
     260 
    257261        SC_FUNC_RETURN(p15card->card->ctx, SC_LOG_DEBUG_VERBOSE,SC_SUCCESS); 
    258262} 
    … …  
    265269        struct sc_card *card = p15card->card; 
    266270        int     r; 
    267         sc_pkcs15_pin_info_t *pin_info = (sc_pkcs15_pin_info_t *) pin_obj->data; 
     271        sc_pkcs15_auth_info_t *auth_info = (sc_pkcs15_auth_info_t *) pin_obj->data; 
    268272 
    269273        SC_FUNC_CALLED(card->ctx, SC_LOG_DEBUG_VERBOSE); 
     274 
     275        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     276                return SC_ERROR_OBJECT_NOT_VALID; 
    270277 
    271278        {/*pin*/ 
    … …  
    275282                          return SC_ERROR_INVALID_ARGUMENTS; 
    276283 
    277                  data.key_id=pin_info->reference; 
     284                 data.key_id = auth_info->attrs.pin.reference; 
    278285                 data.usage=0x0B; 
    279286                 data.key_data.symmetric.EC=0x33; 
    … …  
    297304                          return SC_ERROR_INVALID_ARGUMENTS; 
    298305 
    299                  data.key_id=pin_info->reference+1; 
     306                 data.key_id = auth_info->attrs.pin.reference+1; 
    300307                 data.usage=0x0B; 
    301308                 data.key_data.symmetric.EC=0x33; 
    … …  
    428435{ 
    429436        struct sc_context *ctx = p15card->card->ctx; 
    430         struct sc_pkcs15_pin_info profile_pin; 
     437        struct sc_pkcs15_auth_info profile_auth; 
    431438        struct sc_pkcs15_object *objs[32]; 
    432439        int rv, nn, ii, update_df = 0; 
    … …  
    439446        nn = rv; 
    440447 
    441         sc_profile_get_pin_info(profile, SC_PKCS15INIT_USER_PIN, &profile_pin); 
     448        sc_profile_get_pin_info(profile, SC_PKCS15INIT_USER_PIN, &profile_auth); 
    442449        SC_TEST_RET(ctx, SC_LOG_DEBUG_NORMAL, rv, "Failed to get PIN info"); 
    443450 
    444451        for (ii=0; ii<nn; ii++) { 
    445                 struct sc_pkcs15_pin_info *pinfo = (struct sc_pkcs15_pin_info *) objs[ii]->data; 
    446  
    447                 if (pinfo->reference == profile_pin.reference && pinfo->flags != profile_pin.flags)   { 
     452                struct sc_pkcs15_auth_info *ainfo = (struct sc_pkcs15_auth_info *) objs[ii]->data; 
     453                struct sc_pkcs15_pin_attributes *pin_attrs = &ainfo->attrs.pin; 
     454 
     455                if (ainfo->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     456                        continue; 
     457 
     458                if (pin_attrs->reference == profile_auth.attrs.pin.reference  
     459                                && pin_attrs->flags != profile_auth.attrs.pin.flags)   { 
    448460                        sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "Set flags of '%s'(flags:%X,ref:%i,id:%s) to %X", objs[ii]->label,  
    449                                         pinfo->flags, pinfo->reference, sc_pkcs15_print_id(&pinfo->auth_id),  
    450                                         profile_pin.flags); 
    451                         pinfo->flags = profile_pin.flags; 
     461                                        pin_attrs->flags, pin_attrs->reference, sc_pkcs15_print_id(&ainfo->auth_id),  
     462                                        profile_auth.attrs.pin.flags); 
     463                        pin_attrs->flags = profile_auth.attrs.pin.flags; 
    452464                        update_df = 1; 
    453465                } 

  • src/pkcs15init/pkcs15-gpk.c

    r9df8712 rd888b3f  
    163163static int 
    164164gpk_select_pin_reference(sc_profile_t *profile, sc_pkcs15_card_t *p15card, 
    165                 sc_pkcs15_pin_info_t *pin_info) 
     165                sc_pkcs15_auth_info_t *auth_info) 
    166166{ 
    167167        int     preferred, current; 
    168168 
    169169        SC_FUNC_CALLED(p15card->card->ctx, SC_LOG_DEBUG_VERBOSE); 
    170         if ((current = pin_info->reference) < 0) 
     170 
     171        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     172                return SC_ERROR_OBJECT_NOT_VALID; 
     173 
     174        if ((current = auth_info->attrs.pin.reference) < 0) 
    171175                current = 0; 
    172176 
    173         if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
     177        if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
    174178                preferred = GPK_PIN_SCOPE | 0; 
    175179        } else { 
    … …  
    186190        if (current > preferred) 
    187191                return SC_ERROR_TOO_MANY_OBJECTS; 
    188         pin_info->reference = preferred; 
     192        auth_info->attrs.pin.reference = preferred; 
    189193        SC_FUNC_RETURN(p15card->card->ctx, SC_LOG_DEBUG_NORMAL, 0); 
    190194} 
    … …  
    199203                const u8 *puk, size_t puk_len) 
    200204{ 
    201         sc_pkcs15_pin_info_t *pin_info = (sc_pkcs15_pin_info_t *) pin_obj->data; 
     205        sc_pkcs15_auth_info_t *auth_info = (sc_pkcs15_auth_info_t *) pin_obj->data; 
     206        struct sc_pkcs15_pin_attributes *pin_attrs = &auth_info->attrs.pin; 
    202207        u8      nulpin[8]; 
    203208        int     r; 
    204209 
    205210        SC_FUNC_CALLED(p15card->card->ctx, SC_LOG_DEBUG_VERBOSE); 
    206         if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
     211 
     212        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     213                return SC_ERROR_OBJECT_NOT_VALID; 
     214 
     215        if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
    207216                /* SO PIN reference must be 0 */ 
    208                 if (pin_info->reference != (GPK_PIN_SCOPE | 0)) 
     217                if (pin_attrs->reference != (GPK_PIN_SCOPE | 0)) 
    209218                        return SC_ERROR_INVALID_ARGUMENTS; 
    210219        } else { 
    … …  
    215224                 * tell the caller to pick a different value. 
    216225                 */ 
    217                 if ((pin_info->reference & 1) || !(pin_info->reference & GPK_PIN_SCOPE)) 
     226                if ((pin_attrs->reference & 1) || !(pin_attrs->reference & GPK_PIN_SCOPE)) 
    218227                        return SC_ERROR_INVALID_PIN_REFERENCE; 
    219                 if (pin_info->reference >= (GPK_PIN_SCOPE + GPK_MAX_PINS)) 
     228                if (pin_attrs->reference >= (GPK_PIN_SCOPE + GPK_MAX_PINS)) 
    220229                        return SC_ERROR_TOO_MANY_OBJECTS; 
    221230        } 
    … …  
    239248        memset(nulpin, 0, sizeof(nulpin)); 
    240249        r = sc_change_reference_data(p15card->card, SC_AC_CHV, 
    241                         pin_info->reference, 
     250                        pin_attrs->reference, 
    242251                        nulpin, sizeof(nulpin), 
    243252                        pin, pin_len, NULL); 
    … …  
    248257        /* Current PUK is 00:00:00:00:00:00:00:00 */ 
    249258        r = sc_change_reference_data(p15card->card, SC_AC_CHV, 
    250                         pin_info->reference + 1, 
     259                        pin_attrs->reference + 1, 
    251260                        nulpin, sizeof(nulpin), 
    252261                        puk, puk_len, NULL); 

  • src/pkcs15init/pkcs15-iasecc.c

    rf026db6 rd888b3f  
    649649        pin_ref = rv; 
    650650        for (ii=0; ii<nn_pins; ii++)   { 
    651                 const struct sc_pkcs15_pin_info *pin_info = (const struct sc_pkcs15_pin_info *) pin_objs[ii]->data; 
     651                const struct sc_pkcs15_auth_info *auth_info = (const struct sc_pkcs15_auth_info *) pin_objs[ii]->data; 
    652652                 
    653                 /* FIXME: make pin reference 'unsigned' */ 
    654                 sc_log(ctx, "PIN refs %i/%i", pin_ref, pin_info->reference); 
    655                 if (pin_ref == ((pin_info->reference + 0x100) % 0x100))   { 
    656                         *auth_id = pin_info->auth_id; 
     653                if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     654                        continue; 
     655                 
     656                sc_log(ctx, "PIN refs %i/%i", pin_ref, auth_info->attrs.pin.reference); 
     657                if (pin_ref == ((auth_info->attrs.pin.reference + 0x100) % 0x100))   { 
     658                        *auth_id = auth_info->auth_id; 
    657659                        break; 
    658660                } 

  • src/pkcs15init/pkcs15-incrypto34.c

    rb4bdb72 rd888b3f  
    5757 */ 
    5858static int      incrypto34_store_pin(sc_profile_t *profile, sc_card_t *card, 
    59                         sc_pkcs15_pin_info_t *pin_info, int puk_id, 
     59                        sc_pkcs15_auth_info_t *auth_info, int puk_id, 
    6060                        const u8 *pin, size_t pin_len); 
    6161static int      incrypto34_create_sec_env(sc_profile_t *, sc_card_t *, 
    … …  
    173173static int 
    174174incrypto34_select_pin_reference(sc_profile_t *profile, sc_pkcs15_card_t *p15card, 
    175                 sc_pkcs15_pin_info_t *pin_info) 
     175                sc_pkcs15_auth_info_t *auth_info) 
    176176{ 
    177177        int     preferred, current; 
    178178 
    179         if ((current = pin_info->reference) < 0) 
     179        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     180                return SC_ERROR_OBJECT_NOT_VALID; 
     181 
     182        if ((current = auth_info->attrs.pin.reference) < 0) 
    180183                current = INCRYPTO34_PIN_ID_MIN; 
    181184 
    182         if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
     185        if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
    183186                preferred = 1; 
    184187        } else { 
    … …  
    193196        if (current > preferred || preferred > INCRYPTO34_PIN_ID_MAX) 
    194197                return SC_ERROR_TOO_MANY_OBJECTS; 
    195         pin_info->reference = preferred; 
     198        auth_info->attrs.pin.reference = preferred; 
    196199        return 0; 
    197200} 
    … …  
    206209                const u8 *puk, size_t puk_len) 
    207210{ 
    208         sc_pkcs15_pin_info_t *pin_info = (sc_pkcs15_pin_info_t *) pin_obj->data; 
     211        sc_pkcs15_auth_info_t *auth_info = (sc_pkcs15_auth_info_t *) pin_obj->data; 
    209212        unsigned int    puk_id = INCRYPTO34_AC_NEVER; 
    210213        int             r; 
    … …  
    213216                return SC_ERROR_INVALID_ARGUMENTS; 
    214217 
     218        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     219                return SC_ERROR_OBJECT_NOT_VALID; 
     220 
    215221        r = sc_select_file(p15card->card, &df->path, NULL); 
    216222        if (r < 0) 
    … …  
    218224 
    219225        if (puk && puk_len) { 
    220                 struct sc_pkcs15_pin_info puk_info; 
     226                struct sc_pkcs15_auth_info puk_ainfo; 
    221227 
    222228                sc_profile_get_pin_info(profile, 
    223                                 SC_PKCS15INIT_USER_PUK, &puk_info); 
    224                 puk_info.reference = puk_id = pin_info->reference + 1; 
     229                                SC_PKCS15INIT_USER_PUK, &puk_ainfo); 
     230                puk_ainfo.attrs.pin.reference = puk_id = auth_info->attrs.pin.reference + 1; 
    225231                r = incrypto34_store_pin(profile, p15card->card, 
    226                                 &puk_info, INCRYPTO34_AC_NEVER, 
     232                                &puk_ainfo, INCRYPTO34_AC_NEVER, 
    227233                                puk, puk_len); 
    228234        } 
    … …  
    230236        if (r >= 0) { 
    231237                r = incrypto34_store_pin(profile, p15card->card, 
    232                                 pin_info, puk_id, 
     238                                auth_info, puk_id, 
    233239                                pin, pin_len); 
    234240        } 
    … …  
    384390static int 
    385391incrypto34_store_pin(sc_profile_t *profile, sc_card_t *card, 
    386                 sc_pkcs15_pin_info_t *pin_info, int puk_id, 
     392                sc_pkcs15_auth_info_t *auth_info, int puk_id, 
    387393                const u8 *pin, size_t pin_len) 
    388394{ 
    … …  
    392398        struct tlv      tlv; 
    393399        unsigned int    attempts, minlen, maxlen; 
     400 
     401        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     402                return SC_ERROR_OBJECT_NOT_VALID; 
    394403 
    395404        /* We need to do padding because pkcs15-lib.c does it. 
    … …  
    404413        pin = pinpadded; 
    405414 
    406         attempts = pin_info->tries_left; 
    407         minlen = pin_info->min_length; 
     415        attempts = auth_info->tries_left; 
     416        minlen = auth_info->attrs.pin.min_length; 
    408417 
    409418        tlv_init(&tlv, buffer, sizeof(buffer)); 
    … …  
    412421        tlv_next(&tlv, 0x83); 
    413422        tlv_add(&tlv, 0x00);            /* class byte: usage TEST, k=0 */ 
    414         tlv_add(&tlv, pin_info->reference); 
     423        tlv_add(&tlv, auth_info->attrs.pin.reference); 
    415424 
    416425        /* parameters */ 
    … …  
    440449        tlv_next(&tlv, 0x86); 
    441450        tlv_add(&tlv, 0x00);                    /* use: always */ 
    442         tlv_add(&tlv, pin_info->reference);     /* change: PIN */ 
     451        tlv_add(&tlv, auth_info->attrs.pin.reference);  /* change: PIN */ 
    443452        tlv_add(&tlv, puk_id);                  /* unblock: PUK */ 
    444453        tlv_add(&tlv, 0xFF);                    /*RFU*/ 

  • src/pkcs15init/pkcs15-init.h

    r2d43c60 rd888b3f  
    5858         */ 
    5959        int     (*select_pin_reference)(struct sc_profile *, struct sc_pkcs15_card *, 
    60                         struct sc_pkcs15_pin_info *); 
     60                        struct sc_pkcs15_auth_info *); 
    6161 
    6262        /* 
    … …  
    161161         * one of the SC_PKCS15INIT_XXX_PIN/PUK macros. 
    162162         */ 
    163         int     (*get_pin)(struct sc_profile *, int, const struct sc_pkcs15_pin_info *, 
     163        int     (*get_pin)(struct sc_profile *, int, const struct sc_pkcs15_auth_info *, 
    164164                                const char *, unsigned char *, size_t *); 
    165165 
    … …  
    341341extern int      sc_pkcs15init_fixup_file(struct sc_profile *, struct sc_pkcs15_card *,  
    342342                                struct sc_file *); 
    343 extern int      sc_pkcs15init_get_pin_info(struct sc_profile *, int, struct sc_pkcs15_pin_info *); 
     343extern int      sc_pkcs15init_get_pin_info(struct sc_profile *, int, struct sc_pkcs15_auth_info *); 
    344344extern int      sc_profile_get_pin_retries(struct sc_profile *, int); 
    345345extern int      sc_pkcs15init_get_manufacturer(struct sc_profile *, 

  • src/pkcs15init/pkcs15-jcop.c

    r98dd13f rd888b3f  
    7474static int 
    7575jcop_select_pin_reference(sc_profile_t *profile, sc_pkcs15_card_t *p15card, 
    76                 sc_pkcs15_pin_info_t *pin_info) { 
     76                sc_pkcs15_auth_info_t *auth_info) { 
    7777        int     preferred, current; 
    7878 
    79         if ((current = pin_info->reference) < 0) 
     79        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     80                return SC_ERROR_OBJECT_NOT_VALID; 
     81 
     82        if ((current = auth_info->attrs.pin.reference) < 0) 
    8083                current = 0; 
    8184 
    82         if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
     85        if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
    8386             preferred = 3; 
    8487        } else { 
    … …  
    9194        if (current > preferred) 
    9295             return SC_ERROR_TOO_MANY_OBJECTS; 
    93         pin_info->reference = preferred; 
     96        auth_info->attrs.pin.reference = preferred; 
    9497        return 0; 
    9598} 
    … …  
    104107                const unsigned char *puk, size_t puk_len) 
    105108{ 
    106         sc_pkcs15_pin_info_t *pin_info = (sc_pkcs15_pin_info_t *) pin_obj->data; 
     109        sc_pkcs15_auth_info_t *auth_info = (sc_pkcs15_auth_info_t *) pin_obj->data; 
     110        struct sc_pkcs15_pin_attributes *pin_attrs = &auth_info->attrs.pin; 
    107111        unsigned char   nulpin[16]; 
    108112        unsigned char   padpin[16]; 
    109113        int             r; 
    110114 
    111         if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
     115        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     116                return SC_ERROR_OBJECT_NOT_VALID; 
     117 
     118        if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
    112119                /* SO PIN reference must be 0 */ 
    113                 if (pin_info->reference != 3) 
     120                if (pin_attrs->reference != 3) 
    114121                        return SC_ERROR_INVALID_ARGUMENTS; 
    115122        } else { 
    116                 if (pin_info->reference >= 3) 
     123                if (pin_attrs->reference >= 3) 
    117124                        return SC_ERROR_TOO_MANY_OBJECTS; 
    118125        } 
    … …  
    129136        memcpy(padpin, pin, pin_len); 
    130137        r = sc_change_reference_data(p15card->card, SC_AC_CHV, 
    131                         pin_info->reference, 
     138                        pin_attrs->reference, 
    132139                        nulpin, sizeof(nulpin), 
    133140                        padpin, sizeof(padpin), NULL); 
    … …  
    135142                return r; 
    136143 
    137         pin_info->flags &= ~SC_PKCS15_PIN_FLAG_LOCAL; 
     144        pin_attrs->flags &= ~SC_PKCS15_PIN_FLAG_LOCAL; 
    138145        return r; 
    139146} 

  • src/pkcs15init/pkcs15-lib.c

    r2d43c60 rd888b3f  
    120120                        struct sc_pkcs15_id *, struct sc_path *); 
    121121static int      sc_pkcs15init_qualify_pin(struct sc_card *, const char *, 
    122                         unsigned int, struct sc_pkcs15_pin_info *); 
     122                        unsigned int, struct sc_pkcs15_auth_info *); 
    123123static struct sc_pkcs15_df * find_df_by_type(struct sc_pkcs15_card *, 
    124124                        unsigned int); 
    … …  
    411411        nn_objs = sc_pkcs15_get_objects(p15card, SC_PKCS15_TYPE_AUTH_PIN, p15objects, 10); 
    412412        for (i = 0; i < nn_objs; i++) { 
    413                 struct sc_pkcs15_pin_info *pininfo = (struct sc_pkcs15_pin_info *) p15objects[i]->data; 
     413                struct sc_pkcs15_auth_info *auth_info = (struct sc_pkcs15_auth_info *) p15objects[i]->data; 
     414                struct sc_pkcs15_pin_attributes *pin_attrs = &auth_info->attrs.pin; 
    414415                struct sc_file *file = NULL; 
    415416 
    416                 if (pininfo->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     417                if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
    417418                        continue; 
    418                 if (pininfo->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN) 
     419                if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN) 
    419420                        continue; 
    420                 if (!pininfo->path.len) 
     421                if (!auth_info->path.len) 
    421422                        continue; 
    422423 
    423                 r = sc_profile_get_file_by_path(profile, &pininfo->path, &file); 
     424                r = sc_profile_get_file_by_path(profile, &auth_info->path, &file); 
    424425                if (r == SC_ERROR_FILE_NOT_FOUND)   { 
    425                         if (!sc_select_file(p15card->card, &pininfo->path, &file))   { 
     426                        if (!sc_select_file(p15card->card, &auth_info->path, &file))   { 
    426427                                char pin_name[16]; 
    427428 
    … …  
    696697        struct sc_context *ctx = card->ctx; 
    697698        struct sc_pkcs15_card   *p15card = profile->p15_spec; 
    698         struct sc_pkcs15_pin_info       pin_info, puk_info; 
     699        struct sc_pkcs15_auth_info pin_ainfo, puk_ainfo; 
     700        struct sc_pkcs15_pin_attributes *pin_attrs = &pin_ainfo.attrs.pin; 
    699701        struct sc_pkcs15_object *pin_obj = NULL; 
    700702        struct sc_app_info      *app; 
    … …  
    718720                const char      *pin_label; 
    719721 
    720                 sc_profile_get_pin_info(profile, SC_PKCS15INIT_SO_PIN, &pin_info); 
    721                 r = sc_pkcs15init_qualify_pin(card, "SO PIN", args->so_pin_len, &pin_info); 
     722                sc_profile_get_pin_info(profile, SC_PKCS15INIT_SO_PIN, &pin_ainfo); 
     723                r = sc_pkcs15init_qualify_pin(card, "SO PIN", args->so_pin_len, &pin_ainfo); 
    722724                LOG_TEST_RET(ctx, r, "Failed to qualify SO PIN"); 
    723725 
    724726                /* Path encoded only for local SO PIN */ 
    725                 if (pin_info.flags & SC_PKCS15_PIN_FLAG_LOCAL) 
    726                         pin_info.path = df->path; 
     727                if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_LOCAL) 
     728                        pin_ainfo.path = df->path; 
    727729 
    728730                /* Select the PIN reference */ 
    729731                if (profile->ops->select_pin_reference) { 
    730                         r = profile->ops->select_pin_reference(profile, p15card, &pin_info); 
     732                        r = profile->ops->select_pin_reference(profile, p15card, &pin_ainfo); 
    731733                        LOG_TEST_RET(ctx, r, "Failed to select card specific PIN reference"); 
    732734                } 
    733735 
    734                 sc_profile_get_pin_info(profile, SC_PKCS15INIT_SO_PUK, &puk_info); 
    735                 r = sc_pkcs15init_qualify_pin(card, "SO PUK", args->so_puk_len, &puk_info); 
     736                sc_profile_get_pin_info(profile, SC_PKCS15INIT_SO_PUK, &puk_ainfo); 
     737                r = sc_pkcs15init_qualify_pin(card, "SO PUK", args->so_puk_len, &puk_ainfo); 
    736738                LOG_TEST_RET(ctx, r, "Failed to qulify SO PUK"); 
    737739 
    738740                if (!(pin_label = args->so_pin_label)) { 
    739                         if (pin_info.flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     741                        if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
    740742                                pin_label = "Security Officer PIN"; 
    741743                        else 
    … …  
    744746 
    745747                if (args->so_puk_len == 0) 
    746                         pin_info.flags |= SC_PKCS15_PIN_FLAG_UNBLOCK_DISABLED; 
    747  
    748                 pin_obj = sc_pkcs15init_new_object(SC_PKCS15_TYPE_AUTH_PIN,  
    749                                                 pin_label, NULL, &pin_info); 
     748                        pin_attrs->flags |= SC_PKCS15_PIN_FLAG_UNBLOCK_DISABLED; 
     749 
     750                pin_obj = sc_pkcs15init_new_object(SC_PKCS15_TYPE_AUTH_PIN, pin_label, NULL, &pin_ainfo); 
    750751 
    751752                if (pin_obj)   { 
    … …  
    755756                         * but not yet written into the on-card PKCS#15. 
    756757                         */ 
    757                         sc_log(ctx, "Add virtual SO_PIN('%s',flags:%X,reference:%i,path:'%s')",  
    758                                         pin_obj->label, pin_info.flags, pin_info.reference,  
    759                                         sc_print_path(&pin_info.path)); 
     758                        sc_log(ctx, "Add virtual SO_PIN('%s',flags:%X,reference:%i,path:'%s')", pin_obj->label,  
     759                                        pin_attrs->flags, pin_attrs->reference, sc_print_path(&pin_ainfo.path)); 
    760760                        r = sc_pkcs15_add_object(p15card, pin_obj); 
    761761                        LOG_TEST_RET(ctx, r, "Failed to add 'SOPIN' AUTH object"); 
    … …  
    861861        struct sc_context *ctx = p15card->card->ctx; 
    862862        struct sc_pkcs15_object *pin_obj; 
    863         struct sc_pkcs15_pin_info *pin_info; 
     863        struct sc_pkcs15_auth_info *auth_info; 
    864864        int                     r; 
    865865        char puk_label[0x30]; 
    … …  
    892892                LOG_TEST_RET(ctx, SC_ERROR_OUT_OF_MEMORY, "Cannot allocate PIN object"); 
    893893 
    894         pin_info = (struct sc_pkcs15_pin_info *) pin_obj->data; 
    895  
    896         sc_profile_get_pin_info(profile, SC_PKCS15INIT_USER_PUK, pin_info); 
    897         pin_info->auth_id = args->puk_id; 
     894        auth_info = (struct sc_pkcs15_auth_info *) pin_obj->data; 
     895 
     896        sc_profile_get_pin_info(profile, SC_PKCS15INIT_USER_PUK, auth_info); 
     897        auth_info->auth_id = args->puk_id; 
    898898 
    899899        /* Now store the PINs */ 
    … …  
    915915 
    916916int 
    917 sc_pkcs15init_store_pin(struct sc_pkcs15_card *p15card, 
    918                         struct sc_profile *profile, 
     917sc_pkcs15init_store_pin(struct sc_pkcs15_card *p15card, struct sc_profile *profile, 
    919918                        struct sc_pkcs15init_pinargs *args) 
    920919{ 
    921920        struct sc_context *ctx = p15card->card->ctx; 
    922921        struct sc_pkcs15_object *pin_obj; 
    923         struct sc_pkcs15_pin_info *pin_info; 
     922        struct sc_pkcs15_auth_info *auth_info; 
    924923        int                     r; 
    925924 
    … …  
    950949                LOG_TEST_RET(ctx, SC_ERROR_OUT_OF_MEMORY, "Cannot allocate PIN object"); 
    951950 
    952         pin_info = (struct sc_pkcs15_pin_info *) pin_obj->data; 
    953  
    954         sc_profile_get_pin_info(profile, SC_PKCS15INIT_USER_PIN, pin_info); 
    955         pin_info->auth_id = args->auth_id; 
     951        auth_info = (struct sc_pkcs15_auth_info *) pin_obj->data; 
     952 
     953        sc_profile_get_pin_info(profile, SC_PKCS15INIT_USER_PIN, auth_info); 
     954        auth_info->auth_id = args->auth_id; 
    956955 
    957956        /* Now store the PINs */ 
    958         sc_log(ctx, "Store PIN(%s,authID:%s)", pin_obj->label, sc_pkcs15_print_id(&pin_info->auth_id)); 
     957        sc_log(ctx, "Store PIN(%s,authID:%s)", pin_obj->label, sc_pkcs15_print_id(&auth_info->auth_id)); 
    959958        r = sc_pkcs15init_create_pin(p15card, profile, pin_obj, args); 
    960959        if (r < 0) 
    … …  
    983982{ 
    984983        struct sc_context *ctx = p15card->card->ctx; 
    985         struct sc_pkcs15_pin_info *pin_info = (struct sc_pkcs15_pin_info *) pin_obj->data; 
     984        struct sc_pkcs15_auth_info *auth_info = (struct sc_pkcs15_auth_info *) pin_obj->data; 
     985        struct sc_pkcs15_pin_attributes *pin_attrs = &auth_info->attrs.pin; 
    986986        struct sc_file  *df = profile->df_info->file; 
    987987        int             r, retry = 0; 
    … …  
    996996                        LOG_TEST_RET(ctx, SC_ERROR_NOT_SUPPORTED, "PIN domains not supported."); 
    997997 
    998                 r = profile->ops->create_domain(profile, p15card, &pin_info->auth_id, &df); 
     998                r = profile->ops->create_domain(profile, p15card, &auth_info->auth_id, &df); 
    999999                LOG_TEST_RET(ctx, r, "Card specific create domain failed"); 
    10001000        } 
    10011001 
    10021002        /* Path encoded only for local PINs */ 
    1003         if (pin_info->flags & SC_PKCS15_PIN_FLAG_LOCAL) 
    1004                 pin_info->path = df->path; 
     1003        if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_LOCAL) 
     1004                auth_info->path = df->path; 
    10051005 
    10061006        /* pin_info->reference = 0; */ 
    … …  
    10091009        while (1) { 
    10101010                if (profile->ops->select_pin_reference) { 
    1011                         r = profile->ops->select_pin_reference(profile, p15card, pin_info); 
     1011                        r = profile->ops->select_pin_reference(profile, p15card, auth_info); 
    10121012                        LOG_TEST_RET(ctx, r, "Card specific select PIN reference failed"); 
    10131013 
    … …  
    10151015                } 
    10161016 
    1017                 r = sc_pkcs15_find_pin_by_reference(p15card, &pin_info->path,  
    1018                                 pin_info->reference, NULL); 
     1017                r = sc_pkcs15_find_pin_by_reference(p15card, &auth_info->path, pin_attrs->reference, NULL); 
    10191018                if (r == SC_ERROR_OBJECT_NOT_FOUND) 
    10201019                        break; 
    … …  
    10241023                        LOG_TEST_RET(ctx, SC_ERROR_TOO_MANY_OBJECTS, "Failed to allocate PIN reference."); 
    10251024 
    1026                 pin_info->reference++; 
     1025                pin_attrs->reference++; 
    10271026        } 
    10281027 
    10291028        if (args->puk_len == 0) 
    1030                 pin_info->flags |= SC_PKCS15_PIN_FLAG_UNBLOCK_DISABLED; 
     1029                pin_attrs->flags |= SC_PKCS15_PIN_FLAG_UNBLOCK_DISABLED; 
    10311030 
    10321031        sc_log(ctx, "create PIN with reference:%X, flags:%X, path:%s",  
    1033                         pin_info->reference, pin_info->flags, sc_print_path(&pin_info->path)); 
     1032                        pin_attrs->reference, pin_attrs->flags, sc_print_path(&auth_info->path)); 
    10341033        r = profile->ops->create_pin(profile, p15card, 
    10351034                        df, pin_obj, 
    … …  
    16351634{ 
    16361635        struct sc_context *ctx = p15card->card->ctx; 
    1637         struct sc_pkcs15_pin_info pinfo; 
     1636        struct sc_pkcs15_auth_info auth_info; 
    16381637        struct sc_pkcs15_object *auth_objs[0x10]; 
    16391638        int r, ii, nn_objs; 
    … …  
    16511650                        nn_objs, auth_method, reference); 
    16521651        for (ii=0; ii<nn_objs; ii++)   { 
    1653                 struct sc_pkcs15_pin_info *pin_info = (struct sc_pkcs15_pin_info *)auth_objs[ii]->data; 
     1652                struct sc_pkcs15_auth_info *auth_info = (struct sc_pkcs15_auth_info *)auth_objs[ii]->data; 
     1653                struct sc_pkcs15_pin_attributes *pin_attrs = &auth_info->attrs.pin; 
    16541654 
    16551655                sc_log(ctx, "check PIN(%s,auth_method:%i,type:%i,reference:%i,flags:%X)",  
    1656                                 auth_objs[ii]->label, pin_info->auth_method, pin_info->type,  
    1657                                 pin_info->reference, pin_info->flags); 
     1656                                auth_objs[ii]->label, auth_info->auth_method, pin_attrs->type,  
     1657                                pin_attrs->reference, pin_attrs->flags); 
    16581658                /* Find out if there is AUTH pkcs15 object with given 'type' and 'reference' */ 
    1659                 if (pin_info->auth_method == auth_method && pin_info->reference == reference) 
    1660                         LOG_FUNC_RETURN(ctx, pin_info->reference); 
     1659                if (auth_info->auth_method == auth_method && pin_attrs->reference == reference) 
     1660                        LOG_FUNC_RETURN(ctx, pin_attrs->reference); 
    16611661 
    16621662                if (auth_method != SC_AC_SYMBOLIC) 
    … …  
    16671667                switch (reference)   { 
    16681668                case SC_PKCS15INIT_USER_PIN: 
    1669                         if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     1669                        if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
    16701670                                continue; 
    1671                         if (pin_info->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN) 
     1671                        if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN) 
    16721672                                continue; 
    16731673                        break; 
    16741674                case SC_PKCS15INIT_SO_PIN: 
    1675                         if (pin_info->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN) 
     1675                        if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN) 
    16761676                                continue; 
    1677                         if (!(pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN)) 
     1677                        if (!(pin_attrs->flags & SC_PKCS15_PIN_FLAG_SO_PIN)) 
    16781678                                continue; 
    16791679                        break; 
    16801680                case SC_PKCS15INIT_USER_PUK: 
    1681                         if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     1681                        if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
    16821682                                continue; 
    1683                         if (!(pin_info->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN)) 
     1683                        if (!(pin_attrs->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN)) 
    16841684                                continue; 
    16851685                        break; 
    16861686                case SC_PKCS15INIT_SO_PUK: 
    1687                         if (!(pin_info->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN)) 
     1687                        if (!(pin_attrs->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN)) 
    16881688                                continue; 
    1689                         if (!(pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN)) 
     1689                        if (!(pin_attrs->flags & SC_PKCS15_PIN_FLAG_SO_PIN)) 
    16901690                                continue; 
    16911691                        break; 
    … …  
    16941694                } 
    16951695 
    1696                 LOG_FUNC_RETURN(ctx, pin_info->reference); 
     1696                LOG_FUNC_RETURN(ctx, pin_attrs->reference); 
    16971697 
    16981698        } 
    … …  
    17001700        /* 2. No existing pkcs15 PIN object  
    17011701         *      -- check if profile defines some PIN with 'reference' as PIN reference. */ 
    1702         r = sc_profile_get_pin_id_by_reference(profile, auth_method, reference, &pinfo); 
     1702        r = sc_profile_get_pin_id_by_reference(profile, auth_method, reference, &auth_info); 
    17031703        if (r < 0) 
    17041704                LOG_TEST_RET(ctx, SC_ERROR_OBJECT_NOT_FOUND, "PIN template not found"); 
    17051705 
    1706         LOG_FUNC_RETURN(ctx, pinfo.reference); 
     1706        LOG_FUNC_RETURN(ctx, auth_info.attrs.pin.reference); 
    17071707} 
    17081708 
    … …  
    22522252                return SC_SUCCESS; 
    22532253        case SC_PKCS15_TYPE_AUTH: 
    2254                 *ret_path = ((struct sc_pkcs15_pin_info *)obj->data)->path; 
     2254                *ret_path = ((struct sc_pkcs15_auth_info *)obj->data)->path; 
    22552255                return SC_SUCCESS; 
    22562256        } 
    … …  
    26092609        case SC_PKCS15_TYPE_AUTH: 
    26102610                object->flags = DEFAULT_PIN_FLAGS; 
    2611                 data_size = sizeof(struct sc_pkcs15_pin_info); 
     2611                data_size = sizeof(struct sc_pkcs15_auth_info); 
    26122612                break; 
    26132613        case SC_PKCS15_TYPE_PRKEY: 
    … …  
    29502950        struct sc_context *ctx = p15card->card->ctx; 
    29512951        struct sc_pkcs15_object *pin_obj = NULL; 
    2952         struct sc_pkcs15_pin_info pin_info; 
     2952        struct sc_pkcs15_auth_info auth_info; 
    29532953        struct sc_cardctl_default_key data; 
    29542954        size_t          defsize = 0; 
    … …  
    29772977        } 
    29782978         
    2979         memset(&pin_info, 0, sizeof(pin_info)); 
    2980         pin_info.auth_method = type; 
    2981         pin_info.reference = reference; 
    2982         pin_info.stored_length = *pinsize; 
    2983         pin_info.max_length = *pinsize; 
    2984         pin_info.min_length = *pinsize; 
    2985         pin_info.magic = SC_PKCS15_PIN_MAGIC; 
    2986  
    2987         pin_obj = sc_pkcs15init_new_object(SC_PKCS15_TYPE_AUTH_PIN, "Default transport key", NULL, &pin_info); 
     2979        memset(&auth_info, 0, sizeof(auth_info)); 
     2980        auth_info.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
     2981        auth_info.auth_method = type; 
     2982        auth_info.attrs.pin.reference = reference; 
     2983        auth_info.attrs.pin.stored_length = *pinsize; 
     2984        auth_info.attrs.pin.max_length = *pinsize; 
     2985        auth_info.attrs.pin.min_length = *pinsize; 
     2986 
     2987        pin_obj = sc_pkcs15init_new_object(SC_PKCS15_TYPE_AUTH_PIN, "Default transport key", NULL, &auth_info); 
    29882988        if (!pin_obj) 
    29892989                LOG_TEST_RET(ctx, SC_ERROR_OUT_OF_MEMORY, "Cannot allocate AUTH object"); 
    … …  
    30073007        struct sc_context *ctx = p15card->card->ctx; 
    30083008        struct sc_pkcs15_object *pin_obj = NULL; 
    3009         struct sc_pkcs15_pin_info pin_info; 
     3009        struct sc_pkcs15_auth_info auth_info; 
    30103010        struct sc_path  *path; 
    30113011        int             r, use_pinpad = 0, pin_id = -1; 
    … …  
    30333033        } 
    30343034 
    3035         memset(&pin_info, 0, sizeof(pin_info)); 
    3036         pin_info.auth_method = type; 
    3037         pin_info.reference = reference; 
     3035        memset(&auth_info, 0, sizeof(auth_info)); 
     3036        auth_info.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
     3037        auth_info.auth_method = type; 
     3038        auth_info.attrs.pin.reference = reference; 
    30383039 
    30393040        pin_id = sc_pkcs15init_get_pin_reference(p15card, profile, type, reference); 
    … …  
    30633064 
    30643065                if (!r && pin_obj)   { 
    3065                         memcpy(&pin_info, pin_obj->data, sizeof(pin_info)); 
     3066                        memcpy(&auth_info, pin_obj->data, sizeof(auth_info)); 
    30663067                        sc_log(ctx, "found PIN object '%s'", pin_obj->label); 
    30673068                } 
    … …  
    30863087        case SC_AC_CHV: 
    30873088                if (callbacks.get_pin)   { 
    3088                         r = callbacks.get_pin(profile, pin_id, &pin_info, label, pinbuf, &pinsize); 
     3089                        r = callbacks.get_pin(profile, pin_id, &auth_info, label, pinbuf, &pinsize); 
    30893090                        sc_log(ctx, "'get_pin' callback returned %i; pinsize:%i", r, pinsize); 
    30903091                } 
    … …  
    34683469        if (r < 0) 
    34693470                return r; 
    3470         *path = ((struct sc_pkcs15_pin_info *) obj->data)->path; 
     3471        *path = ((struct sc_pkcs15_auth_info *) obj->data)->path; 
    34713472        return 0; 
    34723473} 
    … …  
    34743475 
    34753476int 
    3476 sc_pkcs15init_get_pin_info(struct sc_profile *profile, 
    3477                 int id, struct sc_pkcs15_pin_info *pin) 
     3477sc_pkcs15init_get_pin_info(struct sc_profile *profile, int id, struct sc_pkcs15_auth_info *pin) 
    34783478{ 
    34793479        sc_profile_get_pin_info(profile, id, pin); 
    … …  
    35273527static int 
    35283528sc_pkcs15init_qualify_pin(struct sc_card *card, const char *pin_name, 
    3529                 unsigned int pin_len, struct sc_pkcs15_pin_info *pin_info) 
    3530 { 
    3531         if (pin_len == 0) 
     3529                unsigned int pin_len, struct sc_pkcs15_auth_info *auth_info) 
     3530{ 
     3531        struct sc_context *ctx = card->ctx; 
     3532        struct sc_pkcs15_pin_attributes *pin_attrs; 
     3533 
     3534        if (pin_len == 0 || auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
    35323535                return 0; 
    3533         if (pin_len < pin_info->min_length) { 
    3534                 sc_log(card->ctx, "%s too short (min length %u)", pin_name, pin_info->min_length); 
     3536 
     3537        pin_attrs = &auth_info->attrs.pin; 
     3538 
     3539        if (pin_len < pin_attrs->min_length) { 
     3540                sc_log(ctx, "%s too short (min length %u)", pin_name, pin_attrs->min_length); 
    35353541                return SC_ERROR_WRONG_LENGTH; 
    35363542        } 
    3537         if (pin_len > pin_info->max_length) { 
    3538                 sc_log(card->ctx, "%s too long (max length %u)", pin_name, pin_info->max_length); 
     3543        if (pin_len > pin_attrs->max_length) { 
     3544                sc_log(ctx, "%s too long (max length %u)", pin_name, pin_attrs->max_length); 
    35393545                return SC_ERROR_WRONG_LENGTH; 
    35403546        } 
    … …  
    37053711        if (pin_obj != NULL) { 
    37063712                method = SC_AC_CHV; 
    3707                 key_ref = ((struct sc_pkcs15_pin_info *) pin_obj->data)->reference; 
     3713                key_ref = ((struct sc_pkcs15_auth_info *) pin_obj->data)->attrs.pin.reference; 
    37083714        } 
    37093715        else { 

  • src/pkcs15init/pkcs15-miocos.c

    r891f983 rd888b3f  
    137137static int 
    138138miocos_select_pin_reference(struct sc_profile *profile, sc_pkcs15_card_t *p15card, 
    139                 struct sc_pkcs15_pin_info *pin_info) 
    140 { 
    141  
    142         if (pin_info->reference < MIOCOS_PIN_ID_MIN) 
    143                 pin_info->reference = MIOCOS_PIN_ID_MIN;  
     139                struct sc_pkcs15_auth_info *auth_info) 
     140{ 
     141        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     142                return SC_ERROR_OBJECT_NOT_VALID; 
     143 
     144        if (auth_info->attrs.pin.reference < MIOCOS_PIN_ID_MIN) 
     145                auth_info->attrs.pin.reference = MIOCOS_PIN_ID_MIN;  
    144146 
    145147        return SC_SUCCESS; 
    … …  
    156158{ 
    157159        struct sc_context *ctx = p15card->card->ctx; 
    158         struct sc_pkcs15_pin_info *pin_info = (struct sc_pkcs15_pin_info *)pin_obj->data; 
    159         struct sc_pkcs15_pin_info tmpinfo; 
     160        struct sc_pkcs15_auth_info *auth_info = (struct sc_pkcs15_auth_info *)pin_obj->data; 
     161        struct sc_pkcs15_pin_attributes *pin_attrs = &auth_info->attrs.pin; 
     162        struct sc_pkcs15_auth_info tmpinfo; 
    160163        struct sc_cardctl_miocos_ac_info ac_info; 
    161164        int r; 
    … …  
    163166        SC_FUNC_CALLED(ctx, SC_LOG_DEBUG_VERBOSE); 
    164167        /* Ignore SOPIN */ 
    165         if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN)         
     168        if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_SO_PIN)        
    166169                return SC_SUCCESS; 
    167170 
    168         pin_info->path = profile->df_info->file->path; 
    169         r = sc_select_file(p15card->card, &pin_info->path, NULL); 
     171        auth_info->path = profile->df_info->file->path; 
     172        r = sc_select_file(p15card->card, &auth_info->path, NULL); 
    170173        if (r) 
    171174                return r; 
    172175        memset(&ac_info, 0, sizeof(ac_info)); 
    173         ac_info.ref = pin_info->reference; 
     176        ac_info.ref = pin_attrs->reference; 
    174177        sc_profile_get_pin_info(profile, SC_PKCS15INIT_USER_PIN, &tmpinfo); 
    175178        ac_info.max_tries = tmpinfo.tries_left; 

  • src/pkcs15init/pkcs15-muscle.c

    rd3a5a13 rd888b3f  
    9393{ 
    9494        sc_file_t *file; 
    95         sc_pkcs15_pin_info_t *pin_info = (sc_pkcs15_pin_info_t *) pin_obj->data; 
     95        sc_pkcs15_auth_info_t *auth_info = (sc_pkcs15_auth_info_t *) pin_obj->data; 
    9696        int r; 
     97 
    9798        if ((r = sc_select_file(p15card->card, &df->path, &file)) < 0) 
    9899                return r; 
    99100        if ((r = sc_pkcs15init_authenticate(profile, p15card, file, SC_AC_OP_WRITE)) < 0) 
    100101                return r; 
    101         pin_info->flags &= ~SC_PKCS15_PIN_FLAG_LOCAL; 
     102 
     103        auth_info->attrs.pin.flags &= ~SC_PKCS15_PIN_FLAG_LOCAL; 
    102104        return 0; 
    103105} 
    … …  
    105107static int 
    106108muscle_select_pin_reference(sc_profile_t *profike, sc_pkcs15_card_t *p15card, 
    107                 sc_pkcs15_pin_info_t *pin_info) 
     109                sc_pkcs15_auth_info_t *auth_info) 
    108110{ 
    109111        int     preferred; 
    110112 
    111         if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
     113        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     114                return SC_ERROR_OBJECT_NOT_VALID; 
     115 
     116        if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
    112117                preferred = 0; 
    113118        } else { 
    114119                preferred = 1; 
    115120        } 
    116         if (pin_info->reference <= preferred) { 
    117                 pin_info->reference = preferred; 
     121        if (auth_info->attrs.pin.reference <= preferred) { 
     122                auth_info->attrs.pin.reference = preferred; 
    118123                return 0; 
    119124        } 
    120125 
    121         if (pin_info->reference > 2) 
     126        if (auth_info->attrs.pin.reference > 2) 
    122127                return SC_ERROR_INVALID_ARGUMENTS; 
    123128 

  • src/pkcs15init/pkcs15-myeid.c

    rd673e5f1 rd888b3f  
    247247static int  
    248248myeid_select_pin_reference(sc_profile_t *profile, sc_pkcs15_card_t *p15card, 
    249                 sc_pkcs15_pin_info_t *pin_info) 
     249                sc_pkcs15_auth_info_t *auth_info) 
    250250{ 
    251251        SC_FUNC_CALLED(p15card->card->ctx, SC_LOG_DEBUG_VERBOSE); 
    252         if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     252 
     253        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     254                return SC_ERROR_OBJECT_NOT_VALID; 
     255 
     256        if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
    253257        { 
    254258          sc_debug(p15card->card->ctx, SC_LOG_DEBUG_NORMAL, 
    255259                          "PIN_FLAG_SO_PIN, ref (%d), tries_left (%d)", 
    256                           pin_info->reference,pin_info->tries_left);     
     260                          auth_info->attrs.pin.reference, auth_info->tries_left);        
    257261        } 
    258262        else     
    … …  
    260264          sc_debug(p15card->card->ctx, SC_LOG_DEBUG_NORMAL,  
    261265                          "PIN_FLAG_PIN, ref (%d), tries_left (%d)", 
    262                           pin_info->reference, pin_info->tries_left); 
    263  
    264         } 
    265  
    266         if (pin_info->reference <= 0 || pin_info->reference > MYEID_MAX_PINS) 
    267                 pin_info->reference = 1; 
     266                          auth_info->attrs.pin.reference, auth_info->tries_left); 
     267 
     268        } 
     269 
     270        if (auth_info->attrs.pin.reference <= 0 || auth_info->attrs.pin.reference > MYEID_MAX_PINS) 
     271                auth_info->attrs.pin.reference = 1; 
    268272                 
    269273        SC_FUNC_RETURN(p15card->card->ctx, SC_LOG_DEBUG_NORMAL, 0); 
    … …  
    282286        unsigned char  data[20]; 
    283287        struct sc_cardctl_myeid_data_obj data_obj; 
    284         struct sc_pkcs15_pin_info *pin_info = (struct sc_pkcs15_pin_info *)pin_obj->data; 
    285         struct sc_pkcs15_pin_info puk_info; 
     288        struct sc_pkcs15_auth_info *auth_info = (struct sc_pkcs15_auth_info *)pin_obj->data; 
     289        struct sc_pkcs15_auth_info puk_ainfo; 
    286290        int     r; 
    287291 
    288292        SC_FUNC_CALLED(ctx, SC_LOG_DEBUG_VERBOSE); 
    289293        sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "PIN('%s',ref:%i,flags:0x%X,pin_len:%d,puk_len:%d)\n", 
    290                             pin_obj->label, pin_info->reference, pin_info->flags, pin_len, puk_len); 
    291  
    292         if (pin_info->reference >= MYEID_MAX_PINS) 
     294                            pin_obj->label, auth_info->attrs.pin.reference, auth_info->attrs.pin.flags, pin_len, puk_len); 
     295 
     296        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     297                return SC_ERROR_OBJECT_NOT_VALID; 
     298        if (auth_info->attrs.pin.reference >= MYEID_MAX_PINS) 
    293299                return SC_ERROR_INVALID_ARGUMENTS; 
    294300        if (pin == NULL || puk == NULL || pin_len < 4 || puk_len < 4) 
    295301                return SC_ERROR_INVALID_PIN_LENGTH; 
    296302 
    297         sc_profile_get_pin_info(profile, (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN)  
     303        sc_profile_get_pin_info(profile, (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN)  
    298304                        ? SC_PKCS15INIT_SO_PUK : SC_PKCS15INIT_USER_PUK,  
    299                         &puk_info); 
     305                        &puk_ainfo); 
    300306 
    301307        memset(data, 0, sizeof(data)); 
    302308        /* Make command to add a pin-record */ 
    303309        data_obj.P1 = 0x01; 
    304         data_obj.P2 = pin_info->reference;      /* myeid pin number */ 
    305          
    306         memset(data, pin_info->pad_char, 8); 
     310        data_obj.P2 = auth_info->attrs.pin.reference;   /* myeid pin number */ 
     311         
     312        memset(data, auth_info->attrs.pin.pad_char, 8); 
    307313        memcpy(&data[0], (u8 *)pin, pin_len);   /* copy pin */ 
    308314 
    309         memset(&data[8], puk_info.pad_char, 8); 
     315        memset(&data[8], puk_ainfo.attrs.pin.pad_char, 8); 
    310316        memcpy(&data[8], (u8 *)puk, puk_len);   /* copy puk */ 
    311317 
    312         if(pin_info->tries_left > 0 && pin_info->tries_left < 15) 
    313                 data[16] = pin_info->tries_left; 
     318        if(auth_info->tries_left > 0 && auth_info->tries_left < 15) 
     319                data[16] = auth_info->tries_left; 
    314320        else 
    315321                data[16] = 5;   /* default value */ 
    316322 
    317         if(puk_info.tries_left > 0 && puk_info.tries_left < 15) 
    318                 data[17] = puk_info.tries_left; 
     323        if(puk_ainfo.tries_left > 0 && puk_ainfo.tries_left < 15) 
     324                data[17] = puk_ainfo.tries_left; 
    319325        else 
    320326                data[17] = 5;   /* default value */ 

  • src/pkcs15init/pkcs15-oberthur.c

    r12a0613 rd888b3f  
    5454 
    5555static int cosm_create_reference_data(struct sc_profile *, struct sc_pkcs15_card *, 
    56                 struct sc_pkcs15_pin_info *, const unsigned char *, size_t, 
     56                struct sc_pkcs15_auth_info *, const unsigned char *, size_t, 
    5757                const unsigned char *, size_t); 
    5858static int cosm_update_pin(struct sc_profile *, struct sc_pkcs15_card *, 
    59                 struct sc_pkcs15_pin_info *, const unsigned char *, size_t, 
     59                struct sc_pkcs15_auth_info *, const unsigned char *, size_t, 
    6060                const unsigned char *, size_t); 
    6161 
    … …  
    270270static int  
    271271cosm_create_reference_data(struct sc_profile *profile, struct sc_pkcs15_card *p15card, 
    272                 struct sc_pkcs15_pin_info *pinfo,  
     272                struct sc_pkcs15_auth_info *ainfo,  
    273273                const unsigned char *pin, size_t pin_len,        
    274274                const unsigned char *puk, size_t puk_len ) 
    … …  
    276276        struct sc_context *ctx = p15card->card->ctx; 
    277277        struct sc_card *card = p15card->card; 
    278         struct sc_pkcs15_pin_info profile_pin; 
    279         struct sc_pkcs15_pin_info profile_puk; 
     278        struct sc_pkcs15_auth_info profile_auth_pin, profile_auth_puk; 
    280279        struct sc_cardctl_oberthur_createpin_info args; 
    281280        unsigned char *puk_buff = NULL; 
    … …  
    292291        if (puk && !puk_len) 
    293292                return SC_ERROR_INVALID_ARGUMENTS; 
    294  
    295         rv = sc_select_file(card, &pinfo->path, NULL); 
     293        if (ainfo->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     294                return SC_ERROR_OBJECT_NOT_VALID;        
     295 
     296        rv = sc_select_file(card, &ainfo->path, NULL); 
    296297        SC_TEST_RET(ctx, SC_LOG_DEBUG_NORMAL, rv, "Cannot select file"); 
    297298 
    298         sc_profile_get_pin_info(profile, SC_PKCS15INIT_USER_PIN, &profile_pin); 
    299         sc_profile_get_pin_info(profile, SC_PKCS15INIT_USER_PUK, &profile_puk); 
     299        sc_profile_get_pin_info(profile, SC_PKCS15INIT_USER_PIN, &profile_auth_pin); 
     300        sc_profile_get_pin_info(profile, SC_PKCS15INIT_USER_PUK, &profile_auth_puk); 
    300301 
    301302        memset(&args, 0, sizeof(args)); 
    302303        args.type = SC_AC_CHV; 
    303         args.ref = pinfo->reference; 
     304        args.ref = ainfo->attrs.pin.reference; 
    304305        args.pin = pin; 
    305306        args.pin_len = pin_len; 
    306307 
    307         if (!(pinfo->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN))   { 
    308                 args.pin_tries = profile_pin.tries_left; 
    309                 if (profile_puk.tries_left > 0)   { 
     308        if (!(ainfo->attrs.pin.flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN))   { 
     309                args.pin_tries = profile_auth_pin.tries_left; 
     310                if (profile_auth_puk.tries_left > 0)   { 
    310311                        args.puk = oberthur_puk; 
    311312                        args.puk_len = sizeof(oberthur_puk); 
    … …  
    314315        } 
    315316        else   { 
    316                 args.pin_tries = profile_puk.tries_left; 
     317                args.pin_tries = profile_auth_puk.tries_left; 
    317318        } 
    318319 
    … …  
    320321        SC_TEST_RET(ctx, SC_LOG_DEBUG_NORMAL, rv, "'CREATE_PIN' card specific command failed"); 
    321322 
    322         if (!(pinfo->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN) && (profile_puk.tries_left > 0))   { 
     323        if (!(ainfo->attrs.pin.flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN)  
     324                        && (profile_auth_puk.tries_left > 0))   { 
    323325                struct sc_file *file = NULL; 
    324326 
    … …  
    345347static int  
    346348cosm_update_pin(struct sc_profile *profile, struct sc_pkcs15_card *p15card, 
    347                 struct sc_pkcs15_pin_info *pinfo, const unsigned char *pin, size_t pin_len, 
     349                struct sc_pkcs15_auth_info *ainfo, const unsigned char *pin, size_t pin_len, 
    348350                const unsigned char *puk, size_t puk_len ) 
    349351{ 
    … …  
    352354         
    353355        SC_FUNC_CALLED(ctx, SC_LOG_DEBUG_VERBOSE); 
    354         sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "ref %i; flags 0x%X", pinfo->reference, pinfo->flags); 
    355  
    356         if (pinfo->flags & SC_PKCS15_PIN_FLAG_SO_PIN)   { 
    357                 if (pinfo->reference != 4) 
     356        if (ainfo->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     357                return SC_ERROR_OBJECT_NOT_VALID;        
     358 
     359        sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "ref %i; flags 0x%X", ainfo->attrs.pin.reference, ainfo->attrs.pin.flags); 
     360 
     361        if (ainfo->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN)   { 
     362                if (ainfo->attrs.pin.reference != 4) 
    358363                        SC_TEST_RET(ctx, SC_LOG_DEBUG_NORMAL, SC_ERROR_INVALID_PIN_REFERENCE, "cosm_update_pin() invalid SOPIN reference"); 
    359364                sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "Update SOPIN ignored"); 
    … …  
    361366        } 
    362367        else   { 
    363                 rv = cosm_create_reference_data(profile, p15card, pinfo,  
    364                                 pin, pin_len, puk, puk_len); 
     368                rv = cosm_create_reference_data(profile, p15card, ainfo, pin, pin_len, puk, puk_len); 
    365369                SC_TEST_RET(ctx, SC_LOG_DEBUG_NORMAL, rv, "cosm_update_pin() failed to change PIN"); 
    366370 
    … …  
    379383static int 
    380384cosm_select_pin_reference(struct sc_profile *profile, struct sc_pkcs15_card *p15card, 
    381                 struct sc_pkcs15_pin_info *pin_info)  
    382 { 
    383         struct sc_context *ctx = p15card->card->ctx; 
     385                struct sc_pkcs15_auth_info *auth_info)  
     386{ 
     387        struct sc_context *ctx = p15card->card->ctx; 
     388        struct sc_pkcs15_pin_attributes *pin_attrs; 
    384389        struct sc_file *pinfile; 
    385390 
    386391        SC_FUNC_CALLED(ctx, SC_LOG_DEBUG_VERBOSE); 
    387         sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "ref %i; flags %X", pin_info->reference, pin_info->flags); 
     392        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     393                return SC_ERROR_OBJECT_NOT_VALID; 
     394 
     395        pin_attrs = &auth_info->attrs.pin; 
     396 
     397        sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "ref %i; flags %X", pin_attrs->reference, pin_attrs->flags); 
    388398        if (sc_profile_get_file(profile, COSM_TITLE "-AppDF", &pinfile) < 0) { 
    389399                sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "Profile doesn't define \"%s\"", COSM_TITLE "-AppDF"); 
    … …  
    391401        } 
    392402 
    393         if (pin_info->flags & SC_PKCS15_PIN_FLAG_LOCAL) 
    394                 pin_info->path = pinfile->path; 
     403        if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_LOCAL) 
     404                auth_info->path = pinfile->path; 
    395405 
    396406        sc_file_free(pinfile); 
    397407         
    398         if (pin_info->reference <= 0)   { 
    399                 if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN)    
    400                         pin_info->reference = 4; 
    401                 else if (pin_info->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN) 
    402                         pin_info->reference = 4;         
     408        if (pin_attrs->reference <= 0)   { 
     409                if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_SO_PIN)    
     410                        pin_attrs->reference = 4; 
     411                else if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN) 
     412                        pin_attrs->reference = 4;        
    403413                else   
    404                         pin_info->reference = 1; 
    405  
    406                 if (pin_info->flags & SC_PKCS15_PIN_FLAG_LOCAL) 
    407                         pin_info->reference |= 0x80; 
     414                        pin_attrs->reference = 1; 
     415 
     416                if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_LOCAL) 
     417                        pin_attrs->reference |= 0x80; 
    408418        } 
    409419 
    … …  
    422432{ 
    423433        struct sc_context *ctx = p15card->card->ctx; 
    424         struct sc_pkcs15_pin_info *pin_info = (struct sc_pkcs15_pin_info *) pin_obj->data; 
     434        struct sc_pkcs15_auth_info *auth_info = (struct sc_pkcs15_auth_info *) pin_obj->data; 
     435        struct sc_pkcs15_pin_attributes *pin_attrs; 
    425436        struct sc_file *pin_file; 
    426437        int rv = 0; 
    427438 
    428439        SC_FUNC_CALLED(ctx, SC_LOG_DEBUG_VERBOSE); 
    429         sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "create '%s'; ref 0x%X; flags %X", pin_obj->label, pin_info->reference, pin_info->flags); 
     440        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     441                return SC_ERROR_OBJECT_NOT_VALID; 
     442 
     443        pin_attrs = &auth_info->attrs.pin; 
     444 
     445        sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "create '%s'; ref 0x%X; flags %X", pin_obj->label, pin_attrs->reference, pin_attrs->flags); 
    430446        if (sc_profile_get_file(profile, COSM_TITLE "-AppDF", &pin_file) < 0) 
    431447                SC_TEST_RET(ctx, SC_LOG_DEBUG_NORMAL, SC_ERROR_INCONSISTENT_PROFILE, "\""COSM_TITLE"-AppDF\" not defined"); 
    432448 
    433         if (pin_info->flags & SC_PKCS15_PIN_FLAG_LOCAL) 
    434                 pin_info->path = pin_file->path; 
     449        if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_LOCAL) 
     450                auth_info->path = pin_file->path; 
    435451 
    436452        sc_file_free(pin_file); 
    437453         
    438         if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN)   { 
    439                 if (pin_info->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN)   { 
     454        if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_SO_PIN)   { 
     455                if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN)   { 
    440456                        SC_TEST_RET(ctx, SC_LOG_DEBUG_NORMAL, SC_ERROR_NOT_SUPPORTED, "SOPIN unblocking is not supported"); 
    441457                } 
    442458                else   { 
    443                         if (pin_info->reference != 4)   
     459                        if (pin_attrs->reference != 4)   
    444460                                SC_TEST_RET(ctx, SC_LOG_DEBUG_NORMAL, SC_ERROR_INVALID_PIN_REFERENCE, "Invalid SOPIN reference"); 
    445461                } 
    446462        }  
    447463        else { 
    448                 if (pin_info->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN)   { 
    449                         if (pin_info->reference != 0x84)   
     464                if (pin_attrs->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN)   { 
     465                        if (pin_attrs->reference != 0x84)   
    450466                                SC_TEST_RET(ctx, SC_LOG_DEBUG_NORMAL, SC_ERROR_INVALID_PIN_REFERENCE, "Invalid User PUK reference"); 
    451467                } 
    452468                else   { 
    453                         if (pin_info->reference != 0x81) 
     469                        if (pin_attrs->reference != 0x81) 
    454470                                SC_TEST_RET(ctx, SC_LOG_DEBUG_NORMAL, SC_ERROR_INVALID_PIN_REFERENCE, "Invalid User PIN reference"); 
    455471                } 
    … …  
    457473 
    458474        if (pin && pin_len)   { 
    459                 rv = cosm_update_pin(profile, p15card, pin_info, pin, pin_len,  puk, puk_len); 
     475                rv = cosm_update_pin(profile, p15card, auth_info, pin, pin_len,  puk, puk_len); 
    460476                SC_TEST_RET(ctx, SC_LOG_DEBUG_NORMAL, rv, "Update PIN failed"); 
    461477        } 

  • src/pkcs15init/pkcs15-rtecp.c

    r438cf4b rd888b3f  
    142142 */ 
    143143static int rtecp_select_pin_reference(sc_profile_t *profile, sc_pkcs15_card_t *p15card, 
    144                 sc_pkcs15_pin_info_t *pin_info) 
     144                sc_pkcs15_auth_info_t *auth_info) 
    145145{ 
    146146        int pin_ref; 
    147147 
    148         if (!profile || !p15card || !p15card->card || !p15card->card->ctx || !pin_info) 
    149                 return SC_ERROR_INVALID_ARGUMENTS; 
    150  
    151         if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     148        if (!profile || !p15card || !p15card->card || !p15card->card->ctx || !auth_info) 
     149                return SC_ERROR_INVALID_ARGUMENTS; 
     150 
     151        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     152                        return SC_ERROR_OBJECT_NOT_VALID; 
     153 
     154        if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
    152155                pin_ref = RTECP_SO_PIN_REF; 
    153156        else 
    154157                pin_ref = RTECP_USER_PIN_REF; 
    155         if (pin_info->reference != pin_ref) 
     158        if (auth_info->attrs.pin.reference != pin_ref) 
    156159                SC_FUNC_RETURN(p15card->card->ctx, SC_LOG_DEBUG_NORMAL, SC_ERROR_NOT_SUPPORTED); 
    157160 
    … …  
    168171{ 
    169172        sc_context_t *ctx; 
    170         sc_pkcs15_pin_info_t *pin_info; 
     173        sc_pkcs15_auth_info_t *auth_info; 
    171174        sc_file_t *file = NULL; 
    172175        /*                        GCHV min-length Flags Attempts  Reserve */ 
    … …  
    191194                return SC_ERROR_NOT_SUPPORTED; 
    192195        } 
    193         pin_info = (sc_pkcs15_pin_info_t *)pin_obj->data; 
    194         if (pin_info->reference != RTECP_SO_PIN_REF 
    195                         && pin_info->reference != RTECP_USER_PIN_REF) 
     196 
     197        auth_info = (sc_pkcs15_auth_info_t *)pin_obj->data; 
     198        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     199                return SC_ERROR_OBJECT_NOT_VALID; 
     200 
     201        if (auth_info->attrs.pin.reference != RTECP_SO_PIN_REF 
     202                        && auth_info->attrs.pin.reference != RTECP_USER_PIN_REF) 
    196203        { 
    197204                sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "PIN reference %i not found in standard" 
    198                                 " (Rutoken ECP) PINs\n", pin_info->reference); 
     205                                " (Rutoken ECP) PINs\n", auth_info->attrs.pin.reference); 
    199206                return SC_ERROR_NOT_SUPPORTED; 
    200207        } 
    201208 
    202         snprintf(pin_sname, sizeof(pin_sname), "CHV%i", pin_info->reference); 
    203         if (pin_info->reference == RTECP_USER_PIN_REF)   { 
     209        snprintf(pin_sname, sizeof(pin_sname), "CHV%i", auth_info->attrs.pin.reference); 
     210        if (auth_info->attrs.pin.reference == RTECP_USER_PIN_REF)   { 
    204211                r = sc_profile_get_file(profile, pin_sname, &file); 
    205212                if (!r)   { 
    … …  
    221228        if (!file) 
    222229                SC_FUNC_RETURN(ctx, SC_LOG_DEBUG_NORMAL, SC_ERROR_OUT_OF_MEMORY); 
    223         file->id = pin_info->reference; 
     230        file->id = auth_info->attrs.pin.reference; 
    224231        file->size = pin_len; 
    225232        assert(sizeof(sec)/sizeof(sec[0]) > 2); 
    226         sec[1] = (pin_info->reference == RTECP_SO_PIN_REF) ? 0xFF : RTECP_SO_PIN_REF; 
    227         sec[2] = (unsigned char)pin_info->reference | (reset_by_sopin ? RTECP_SO_PIN_REF : 0); 
     233        sec[1] = (auth_info->attrs.pin.reference == RTECP_SO_PIN_REF) ? 0xFF : RTECP_SO_PIN_REF; 
     234        sec[2] = (unsigned char)auth_info->attrs.pin.reference | (reset_by_sopin ? RTECP_SO_PIN_REF : 0); 
    228235        r = sc_file_set_sec_attr(file, sec, sizeof(sec)); 
    229236        if (r == SC_SUCCESS) 
    230237        { 
    231238                assert(sizeof(prop)/sizeof(prop[0]) > 3); 
    232                 prop[1] = (unsigned char)pin_info->min_length; 
    233                 prop[3] = 0x11 * (unsigned char)(pin_info->tries_left & 0x0F); 
     239                prop[1] = (unsigned char)auth_info->attrs.pin.min_length; 
     240                prop[3] = 0x11 * (unsigned char)(auth_info->tries_left & 0x0F); 
    234241                r = sc_file_set_prop_attr(file, prop, sizeof(prop)); 
    235242        } 
    … …  
    242249        if (r == SC_SUCCESS) 
    243250                r = sc_change_reference_data(p15card->card, SC_AC_CHV, 
    244                                 pin_info->reference, NULL, 0, pin, pin_len, NULL); 
     251                                auth_info->attrs.pin.reference, NULL, 0, pin, pin_len, NULL); 
    245252        SC_FUNC_RETURN(ctx, SC_LOG_DEBUG_NORMAL, r); 
    246253} 

  • src/pkcs15init/pkcs15-rutoken.c

    r891f983 rd888b3f  
    9595static int 
    9696rutoken_select_pin_reference(sc_profile_t *profile, sc_pkcs15_card_t *p15card, 
    97                         sc_pkcs15_pin_info_t *pin_info) 
     97                        sc_pkcs15_auth_info_t *auth_info) 
    9898{ 
    9999        int pin_ref; 
    100100        unsigned int so_pin_flag; 
    101101 
    102         if (!profile || !p15card || !p15card->card || !p15card->card->ctx || !pin_info) 
     102        if (!profile || !p15card || !p15card->card || !p15card->card->ctx || !auth_info) 
    103103                return SC_ERROR_INVALID_ARGUMENTS; 
    104104 
    105105        SC_FUNC_CALLED(p15card->card->ctx, SC_LOG_DEBUG_VERBOSE); 
    106106 
    107         pin_ref = pin_info->reference; 
    108         so_pin_flag = pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN; 
     107        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     108                return SC_ERROR_OBJECT_NOT_VALID; 
     109 
     110        pin_ref = auth_info->attrs.pin.reference; 
     111        so_pin_flag = auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN; 
    109112 
    110113        sc_debug(p15card->card->ctx, SC_LOG_DEBUG_NORMAL, "PIN reference %i%s\n", 
    … …  
    129132{ 
    130133        sc_context_t *ctx; 
    131         sc_pkcs15_pin_info_t *pin_info; 
     134        sc_pkcs15_auth_info_t *auth_info; 
    132135        size_t i; 
    133136 
    … …  
    147150                return SC_ERROR_NOT_SUPPORTED; 
    148151        } 
    149         pin_info = (sc_pkcs15_pin_info_t *)pin_obj->data; 
     152 
     153        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     154                return SC_ERROR_OBJECT_NOT_VALID; 
     155 
     156        auth_info = (sc_pkcs15_auth_info_t *)pin_obj->data; 
    150157        for (i = 0; i < sizeof(do_pins)/sizeof(do_pins[0]); ++i) 
    151                 if (pin_info->reference == do_pins[i].id) 
     158                if (auth_info->attrs.pin.reference == do_pins[i].id) 
    152159                { 
    153160                        if (pin_len == sizeof(do_pins[i].pass) 
    … …  
    163170        sc_debug(ctx, SC_LOG_DEBUG_NORMAL, 
    164171                        "PIN reference %i not found in standard (Rutoken) PINs\n", 
    165                         pin_info->reference); 
     172                        auth_info->attrs.pin.reference); 
    166173        return SC_ERROR_NOT_SUPPORTED; 
    167174} 

  • src/pkcs15init/pkcs15-setcos.c

    r2202614 rd888b3f  
    3737 
    3838static int setcos_create_pin_internal(sc_profile_t *, sc_pkcs15_card_t *, 
    39         int, sc_pkcs15_pin_info_t *, const u8 *, size_t, const u8 *, size_t); 
     39        int, sc_pkcs15_auth_info_t *, const u8 *, size_t, const u8 *, size_t); 
    4040 
    4141 
    … …  
    4343setcos_puk_retries(sc_profile_t *profile, int pin_ref) 
    4444{ 
    45         sc_pkcs15_pin_info_t pin_info; 
    46  
    47         pin_info.reference = 1; /* Default SO PIN ref. */ 
    48         sc_profile_get_pin_info(profile, SC_PKCS15INIT_SO_PIN, &pin_info); 
     45        sc_pkcs15_auth_info_t auth_info; 
     46 
     47        auth_info.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
     48        auth_info.attrs.pin.reference = 1; /* Default SO PIN ref. */ 
     49        sc_profile_get_pin_info(profile, SC_PKCS15INIT_SO_PIN, &auth_info); 
    4950 
    5051        /* If pin_ref is the SO PIN, get the SO PUK info, otherwise the User PUK info */ 
    5152        sc_profile_get_pin_info(profile, 
    52                 pin_ref == pin_info.reference ? SC_PKCS15INIT_SO_PUK : SC_PKCS15INIT_USER_PUK, 
    53                 &pin_info); 
     53                pin_ref == auth_info.attrs.pin.reference ? SC_PKCS15INIT_SO_PUK : SC_PKCS15INIT_USER_PUK, 
     54                &auth_info); 
    5455         
    55         if ((pin_info.tries_left < 0) || (pin_info.tries_left > 15)) 
     56        if ((auth_info.tries_left < 0) || (auth_info.tries_left > 15)) 
    5657                return 3; /* Little extra safety */ 
    57         return pin_info.tries_left; 
     58        return auth_info.tries_left; 
    5859} 
    5960 
    … …  
    163164static int 
    164165setcos_select_pin_reference(sc_profile_t *profile, sc_pkcs15_card_t *p15card, 
    165         sc_pkcs15_pin_info_t *pin_info) 
    166 { 
    167         sc_pkcs15_pin_info_t pin_info_prof; 
    168  
    169         pin_info_prof.reference = 1; /* Default SO PIN ref. */ 
    170         sc_profile_get_pin_info(profile, SC_PKCS15INIT_SO_PIN, &pin_info_prof); 
     166        sc_pkcs15_auth_info_t *auth_info) 
     167{ 
     168        sc_pkcs15_auth_info_t auth_info_prof; 
     169 
     170        auth_info_prof.attrs.pin.reference = 1; /* Default SO PIN ref. */ 
     171        auth_info_prof.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
     172        sc_profile_get_pin_info(profile, SC_PKCS15INIT_SO_PIN, &auth_info_prof); 
    171173 
    172174        /* For the SO pin, we take the first available pin reference = 1 */ 
    173         if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
    174                 pin_info->reference = pin_info_prof.reference; 
     175        if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     176                auth_info->attrs.pin.reference = auth_info_prof.attrs.pin.reference; 
    175177        /* sc_pkcs15init_create_pin() starts checking if -1 is an acceptable 
    176178         * pin reference, which isn't for the SetCOS cards. And since the 
    177179         * value 1 has been assigned to the SO pin, we'll jump to 2. */ 
    178         else if (pin_info->reference <= 0) 
    179                 pin_info->reference = pin_info_prof.reference + 1; 
     180        else if (auth_info->attrs.pin.reference <= 0) 
     181                auth_info->attrs.pin.reference = auth_info_prof.attrs.pin.reference + 1; 
    180182 
    181183        return 0; 
    … …  
    193195{ 
    194196        struct sc_context *ctx = p15card->card->ctx; 
    195         sc_pkcs15_pin_info_t *pin_info = (sc_pkcs15_pin_info_t *) pin_obj->data; 
     197        sc_pkcs15_auth_info_t *auth_info = (sc_pkcs15_auth_info_t *) pin_obj->data; 
    196198        sc_file_t *pinfile = NULL; 
    197199        int r, ignore_ac = 0; 
    198200 
    199201        SC_FUNC_CALLED(ctx, SC_LOG_DEBUG_VERBOSE); 
     202 
     203        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     204                return SC_ERROR_OBJECT_NOT_VALID; 
    200205 
    201206        /* Create the global pin file if it doesn't exist yet */ 
    … …  
    208213        sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "pinfile->status:%X", pinfile->status); 
    209214        sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "create PIN with reference:%X, flags:%X, path:%s", 
    210                         pin_info->reference, pin_info->flags, sc_print_path(&pin_info->path)); 
     215                        auth_info->attrs.pin.reference, auth_info->attrs.pin.flags, sc_print_path(&auth_info->path)); 
    211216 
    212217        if (pinfile->status == SC_FILE_STATUS_CREATION) 
    213218                ignore_ac = 1; 
    214219 
    215         r = setcos_create_pin_internal(profile, p15card, ignore_ac, pin_info,  
     220        r = setcos_create_pin_internal(profile, p15card, ignore_ac, auth_info,  
    216221                        pin, pin_len, puk, puk_len); 
    217222 
    … …  
    219224         * change status of MF and 'pinfile' to 'Operational:Activated' 
    220225         */ 
    221         if (ignore_ac && (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN))   { 
     226        if (ignore_ac && (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN))   { 
    222227                sc_file_t *mf = profile->mf_info->file; 
    223228 
    … …  
    497502static int 
    498503setcos_create_pin_internal(sc_profile_t *profile, sc_pkcs15_card_t *p15card, 
    499         int ignore_ac, sc_pkcs15_pin_info_t *pin_info, 
     504        int ignore_ac, sc_pkcs15_auth_info_t *auth_info, 
    500505        const u8 *pin, size_t pin_len, 
    501506        const u8 *puk, size_t puk_len) 
    … …  
    508513 
    509514        SC_FUNC_CALLED(ctx, SC_LOG_DEBUG_VERBOSE); 
    510         if (pin_info->reference >= SETCOS_MAX_PINS) 
     515        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     516                return SC_ERROR_OBJECT_NOT_VALID; 
     517 
     518        if (auth_info->attrs.pin.reference >= SETCOS_MAX_PINS) 
    511519                return SC_ERROR_INVALID_ARGUMENTS; 
    512520        if (pin == NULL || puk == NULL || pin_len < 4 || puk_len < 4) 
    … …  
    530538 
    531539        /* setcos pin number */ 
    532         data[0] = pin_info->reference; 
    533  
    534         memset(&data[1], pin_info->pad_char, 16); /* padding */          
     540        data[0] = auth_info->attrs.pin.reference; 
     541 
     542        memset(&data[1], auth_info->attrs.pin.pad_char, 16); /* padding */               
    535543        memcpy(&data[1], (u8 *)pin, pin_len);     /* copy pin*/ 
    536544        memcpy(&data[9], (u8 *)puk, puk_len);     /* copy puk */ 
    537545 
    538         data[17] = pin_info->tries_left & 0x0F; 
    539         data[18] = pin_info->tries_left & 0x0F; 
     546        data[17] = auth_info->tries_left & 0x0F; 
     547        data[18] = auth_info->tries_left & 0x0F; 
    540548        /* 0xF0: unlimited unblock tries */ 
    541         data[19] = 0xF0 | setcos_puk_retries(profile, pin_info->reference); 
     549        data[19] = 0xF0 | setcos_puk_retries(profile, auth_info->attrs.pin.reference); 
    542550 
    543551        /* Allow an unlimited number of signatures after a pin verification. 
    … …  
    545553        data[20] = 0x00; 
    546554 
    547         if (pin_info->type == 0) 
     555        if (auth_info->attrs.pin.type == 0) 
    548556                data[21] = 0x01; /* BCD */ 
    549557        else 
    550558                data[21] = 0x00; /* ASCII */ 
    551         if ((pin_info->flags & 0x010) == 0) /* test for initial pin */ 
     559        if ((auth_info->attrs.pin.flags & 0x010) == 0) /* test for initial pin */ 
    552560                data[21] |= 0x80; 
    553561 

  • src/pkcs15init/pkcs15-starcos.c

    r80ed46d rd888b3f  
    5050 
    5151static u8 get_so_ac(const sc_file_t *file, unsigned int op, 
    52         const sc_pkcs15_pin_info_t *pin, unsigned int def, 
     52        const sc_pkcs15_auth_info_t *auth, unsigned int def, 
    5353        unsigned int need_global) 
    5454{ 
    … …  
    5656        const sc_acl_entry_t *acl; 
    5757 
    58         if (pin->flags & SC_PKCS15_PIN_FLAG_LOCAL) 
     58        if (auth->attrs.pin.flags & SC_PKCS15_PIN_FLAG_LOCAL) 
    5959                is_global = 0; 
    6060        if (!is_global && need_global) 
    … …  
    8484        sc_path_t       tpath; 
    8585        u8              *p = mf_data.data.mf.header, tmp = 0; 
    86         sc_pkcs15_pin_info_t sopin; 
     86        sc_pkcs15_auth_info_t sopin; 
    8787 
    8888        /* test if we already have a MF */ 
    … …  
    181181        sc_file_t       *isf_file, *ipf_file; 
    182182        u8              *p = df_data.data.df.header, tmp = 0; 
    183         sc_pkcs15_pin_info_t sopin; 
     183        sc_pkcs15_auth_info_t sopin; 
    184184 
    185185        sc_profile_get_pin_info(profile, SC_PKCS15INIT_SO_PIN, &sopin); 
    … …  
    256256static int have_onepin(sc_profile_t *profile) 
    257257{ 
    258         sc_pkcs15_pin_info_t sopin; 
     258        sc_pkcs15_auth_info_t sopin; 
    259259 
    260260        sc_profile_get_pin_info(profile, SC_PKCS15INIT_SO_PIN, &sopin); 
    261         if (!(sopin.flags & SC_PKCS15_PIN_FLAG_SO_PIN)) 
     261 
     262        if (!(sopin.attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN)) 
    262263                return 1; 
    263264        else 
    … …  
    273274#define STARCOS_MAX_GPIN_ID     0x0f 
    274275static int starcos_pin_reference(sc_profile_t *profile, sc_pkcs15_card_t *p15card, 
    275         sc_pkcs15_pin_info_t *pin_info) 
    276 { 
    277         int                  tmp = pin_info->reference; 
     276        sc_pkcs15_auth_info_t *auth_info) 
     277{ 
     278        int tmp; 
     279 
     280        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     281                return SC_ERROR_OBJECT_NOT_VALID; 
     282 
     283        tmp = auth_info->attrs.pin.reference; 
    278284 
    279285        if (have_onepin(profile)) { 
    280286                /* we have the onepin profile */ 
    281                 pin_info->reference = STARCOS_SOPIN_GID; 
     287                auth_info->attrs.pin.reference = STARCOS_SOPIN_GID; 
    282288                return SC_SUCCESS; 
    283289        } 
    284290 
    285         if (pin_info->flags & SC_PKCS15_PIN_FLAG_LOCAL) { 
     291        if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_LOCAL) { 
    286292                /* use local KID */ 
    287293                /* SO-pin */ 
    288                 if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     294                if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
    289295                        tmp = STARCOS_SOPIN_LID; 
    290296                else { 
    … …  
    300306                /* use global KID */ 
    301307                /* SO-pin */ 
    302                 if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     308                if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
    303309                        tmp = STARCOS_SOPIN_GID; 
    304310                else { 
    … …  
    312318                } 
    313319        } 
    314         pin_info->reference = tmp; 
     320        auth_info->attrs.pin.reference = tmp; 
    315321 
    316322        return SC_SUCCESS; 
    … …  
    350356        sc_file_t            *tfile; 
    351357        const sc_acl_entry_t *acl_entry; 
    352         sc_pkcs15_pin_info_t *pin_info = (sc_pkcs15_pin_info_t *) pin_obj->data; 
     358        sc_pkcs15_auth_info_t *auth_info = (sc_pkcs15_auth_info_t *) pin_obj->data; 
    353359        sc_starcos_wkey_data  pin_d, puk_d; 
    354360        u8                    tpin[8]; 
    … …  
    357363                return SC_ERROR_INVALID_ARGUMENTS; 
    358364 
    359         is_local = 0x80 & pin_info->reference; 
     365        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     366                return SC_ERROR_OBJECT_NOT_VALID; 
     367 
     368        is_local = 0x80 & auth_info->attrs.pin.reference; 
    360369        if (is_local) 
    361370                r = sc_select_file(card, &df->path, NULL); 
    … …  
    370379        acl_entry = sc_file_get_acl_entry(tfile, SC_AC_OP_WRITE); 
    371380        if (acl_entry->method != SC_AC_NONE) { 
    372                 if ((pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) || have_onepin(profile)) 
     381                if ((auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) || have_onepin(profile)) 
    373382                        need_finalize = 1; 
    374383                else 
    … …  
    384393 
    385394        /* write PIN */ 
    386         tmp    = pin_info->tries_left; 
    387         pin_id = pin_info->reference; 
     395        tmp    = auth_info->tries_left; 
     396        pin_id = auth_info->attrs.pin.reference; 
    388397 
    389398        pin_d.mode    = 0;      /* install */ 
    … …  
    395404        pin_d.key_header[2]  = 8; 
    396405        pin_d.key_header[3]  = STARCOS_AC_ALWAYS; 
    397         if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     406        if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
    398407                pin_d.key_header[4] = STARCOS_SOPIN_STATE; 
    399408        else 
    … …  
    403412        pin_d.key_header[7]  = 0x00; 
    404413        pin_d.key_header[8]  = 0x00; 
    405         akd = pin_info->min_length; 
     414        akd = auth_info->attrs.pin.min_length; 
    406415        if (akd < 4) 
    407416                akd = 4; 
    … …  
    420429 
    421430        if (puk && puk_len) { 
    422                 sc_pkcs15_pin_info_t puk_info; 
     431                sc_pkcs15_auth_info_t puk_info; 
    423432 
    424433                if (puk_len > 8) 

  • src/pkcs15init/pkcs15-westcos.c

    r891f983 rd888b3f  
    7272static int westcos_pkcs15_select_pin_reference(sc_profile_t *profile,  
    7373                                        sc_pkcs15_card_t *p15card, 
    74                                         sc_pkcs15_pin_info_t *pin_info) 
    75 { 
    76  
    77         if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
    78                 pin_info->reference = 1; 
     74                                        sc_pkcs15_auth_info_t *auth_info) 
     75{ 
     76 
     77        if (auth_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     78                return SC_ERROR_OBJECT_NOT_VALID; 
     79 
     80        if (auth_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
     81                auth_info->attrs.pin.reference = 1; 
    7982        } else { 
    80                 pin_info->reference = 0; 
     83                auth_info->attrs.pin.reference = 0; 
    8184        } 
    8285 

  • src/pkcs15init/profile.c

    rff7bb8f rd888b3f  
    489489void 
    490490sc_profile_get_pin_info(struct sc_profile *profile, 
    491                 int id, struct sc_pkcs15_pin_info *info) 
     491                int id, struct sc_pkcs15_auth_info *info) 
    492492{ 
    493493        struct pin_info *pi; 
    … …  
    517517 
    518518        for (pi = profile->pin_list; pi; pi = pi->next) { 
    519                 if (pi->pin.reference == (int)reference) { 
     519                if (pi->pin.auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     520                        continue; 
     521                if (pi->pin.attrs.pin.reference == (int)reference) { 
    520522                        *id = pi->id; 
    521523                        return 0; 
    … …  
    779781sc_profile_get_pin_id_by_reference(struct sc_profile *profile,  
    780782                unsigned auth_method, int reference,  
    781                 struct sc_pkcs15_pin_info *pin_info) 
     783                struct sc_pkcs15_auth_info *auth_info) 
    782784{ 
    783785        struct pin_info *pinfo; 
    … …  
    789791                } 
    790792                else   { 
     793                        if (pinfo->pin.auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     794                                continue; 
    791795                        if (pinfo->pin.auth_method != auth_method) 
    792796                                continue; 
    793                         if (pinfo->pin.reference != reference) 
     797                        if (pinfo->pin.attrs.pin.reference != reference) 
    794798                                continue; 
    795799                } 
    796800 
    797                 if (pin_info) 
    798                         *pin_info = pinfo->pin; 
     801                if (auth_info) 
     802                        *auth_info = pinfo->pin; 
    799803                return pinfo->id; 
    800804        } 
    … …  
    14911495                return NULL; 
    14921496        pi->id = id; 
     1497        pi->pin.auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
    14931498        pi->pin.auth_method = SC_AC_CHV; 
    1494         pi->pin.type = (unsigned int)-1; 
    1495         pi->pin.flags = 0x32; 
    1496         pi->pin.max_length = 0; 
    1497         pi->pin.min_length = 0; 
    1498         pi->pin.stored_length = 0; 
    1499         pi->pin.pad_char = 0xA5; 
    1500         pi->pin.magic = SC_PKCS15_PIN_MAGIC; 
    1501         pi->pin.reference = -1; 
     1499        pi->pin.attrs.pin.type = (unsigned int)-1; 
     1500        pi->pin.attrs.pin.flags = 0x32; 
     1501        pi->pin.attrs.pin.max_length = 0; 
     1502        pi->pin.attrs.pin.min_length = 0; 
     1503        pi->pin.attrs.pin.stored_length = 0; 
     1504        pi->pin.attrs.pin.pad_char = 0xA5; 
     1505        pi->pin.attrs.pin.reference = -1; 
    15021506        pi->pin.tries_left = 3; 
    15031507 
    … …  
    15081512static void set_pin_defaults(struct sc_profile *profile, struct pin_info *pi) 
    15091513{ 
    1510         struct sc_pkcs15_pin_info *info = &pi->pin; 
    1511  
    1512         if (info->type == (unsigned int) -1) 
    1513                 info->type = profile->pin_encoding; 
    1514         if (info->max_length == 0) 
    1515                 info->max_length = profile->pin_maxlen; 
    1516         if (info->min_length == 0) 
    1517                 info->min_length = profile->pin_minlen; 
    1518         if (info->stored_length == 0) { 
    1519                 info->stored_length = profile->pin_maxlen; 
     1514        struct sc_pkcs15_auth_info *info = &pi->pin; 
     1515        struct sc_pkcs15_pin_attributes *pin_attrs = &info->attrs.pin; 
     1516 
     1517        info->auth_type = SC_PKCS15_PIN_AUTH_TYPE_PIN; 
     1518 
     1519        if (pin_attrs->type == (unsigned int) -1) 
     1520                pin_attrs->type = profile->pin_encoding; 
     1521        if (pin_attrs->max_length == 0) 
     1522                pin_attrs->max_length = profile->pin_maxlen; 
     1523        if (pin_attrs->min_length == 0) 
     1524                pin_attrs->min_length = profile->pin_minlen; 
     1525        if (pin_attrs->stored_length == 0) { 
     1526                pin_attrs->stored_length = profile->pin_maxlen; 
    15201527                /* BCD encoded PIN takes half the space */ 
    1521                 if (info->type == SC_PKCS15_PIN_TYPE_BCD) 
    1522                         info->stored_length = (info->stored_length + 1) / 2; 
    1523         } 
    1524         if (info->pad_char == 0xA5) 
    1525                 info->pad_char = profile->pin_pad_char; 
     1528                if (pin_attrs->type == SC_PKCS15_PIN_TYPE_BCD) 
     1529                        pin_attrs->stored_length = (pin_attrs->stored_length + 1) / 2; 
     1530        } 
     1531        if (pin_attrs->pad_char == 0xA5) 
     1532                pin_attrs->pad_char = profile->pin_pad_char; 
    15261533} 
    15271534 
    … …  
    15581565        if (map_str2int(cur, argv[0], &type, pinTypeNames)) 
    15591566                return 1; 
    1560         cur->pin->pin.type = type; 
     1567        if (cur->pin->pin.auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     1568                return 1; 
     1569        cur->pin->pin.attrs.pin.type = type; 
    15611570        return 0; 
    15621571} 
    … …  
    15691578        if (get_uint(cur, argv[0], &reference)) 
    15701579                return 1; 
    1571         cur->pin->pin.reference = reference; 
     1580        if (cur->pin->pin.auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     1581                return 1; 
     1582        cur->pin->pin.attrs.pin.reference = reference; 
    15721583        return 0; 
    15731584} 
    … …  
    15871598        if (get_uint(cur, argv[0], &len)) 
    15881599                return 1; 
    1589         cur->pin->pin.min_length = len; 
     1600        if (cur->pin->pin.auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     1601                return 1; 
     1602        cur->pin->pin.attrs.pin.min_length = len; 
    15901603        return 0; 
    15911604} 
    … …  
    15981611        if (get_uint(cur, argv[0], &len)) 
    15991612                return 1; 
    1600         cur->pin->pin.max_length = len; 
     1613        if (cur->pin->pin.auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     1614                return 1; 
     1615        cur->pin->pin.attrs.pin.max_length = len; 
    16011616        return 0; 
    16021617} 
    … …  
    16091624        if (get_uint(cur, argv[0], &len)) 
    16101625                return 1; 
    1611         cur->pin->pin.stored_length = len; 
     1626        if (cur->pin->pin.auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     1627                return 1; 
     1628        cur->pin->pin.attrs.pin.stored_length = len; 
    16121629        return 0; 
    16131630} 
    … …  
    16191636        int             i, r; 
    16201637 
    1621         cur->pin->pin.flags = 0; 
     1638        if (cur->pin->pin.auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     1639                return -1; 
     1640 
     1641        cur->pin->pin.attrs.pin.flags = 0; 
    16221642        for (i = 0; i < argc; i++) { 
    16231643                if ((r = map_str2int(cur, argv[i], &flags, pinFlagNames)) < 0) 
    16241644                        return r; 
    1625                 cur->pin->pin.flags |= flags; 
     1645                cur->pin->pin.attrs.pin.flags |= flags; 
    16261646        } 
    16271647 

  • src/pkcs15init/profile.h

    r7ab9b7f rd888b3f  
    5656        struct file_info *      file;           /* obsolete */ 
    5757 
    58         sc_pkcs15_pin_info_t    pin; 
     58        struct sc_pkcs15_auth_info      pin; 
    5959}; 
    6060 
    … …  
    132132void    sc_profile_free(struct sc_profile *); 
    133133int     sc_profile_build_pkcs15(struct sc_profile *); 
    134 void    sc_profile_get_pin_info(struct sc_profile *, int, struct sc_pkcs15_pin_info *); 
     134void    sc_profile_get_pin_info(struct sc_profile *, int, struct sc_pkcs15_auth_info *); 
    135135int     sc_profile_get_pin_id(struct sc_profile *, unsigned int, int *); 
    136136int     sc_profile_get_file(struct sc_profile *, const char *, struct sc_file **); 
    … …  
    143143int     sc_profile_get_file_instance(struct sc_profile *, const char *, int, sc_file_t **); 
    144144int     sc_profile_get_pin_id_by_reference(struct sc_profile *, unsigned, int,  
    145                         struct sc_pkcs15_pin_info *); 
     145                        struct sc_pkcs15_auth_info *); 
    146146int    sc_profile_get_parent(struct sc_profile *profile, const char *, sc_file_t **); 
    147147 

  • src/tests/pintest.c

    rf292467 rd888b3f  
    4747static int ask_and_verify_pin(struct sc_pkcs15_object *pin_obj) 
    4848{ 
    49         struct sc_pkcs15_pin_info *pin_info = (struct sc_pkcs15_pin_info *) pin_obj->data; 
     49        struct sc_pkcs15_auth_info *pin_info = (struct sc_pkcs15_auth_info *) pin_obj->data; 
    5050        int i = 0; 
    5151        char prompt[80]; 
    5252        u8 *pass; 
    5353 
    54         if (pin_info->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN) { 
     54        if (pin_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN) { 
    5555                printf("Skipping unblocking pin [%s]\n", pin_obj->label); 
    5656                return 0; 

  • src/tests/print.c

    r50f99a20 rd888b3f  
    5454                "exchangeRefData" 
    5555        }; 
    56         struct sc_pkcs15_pin_info *pin; 
     56        struct sc_pkcs15_auth_info *pin; 
    5757        const int pf_count = sizeof(pin_flags) / sizeof(pin_flags[0]); 
    5858        int i; 
    5959 
    60         pin = (struct sc_pkcs15_pin_info *) obj->data; 
     60        pin = (struct sc_pkcs15_auth_info *) obj->data; 
    6161        printf("\tAuth ID     : %s\n", sc_pkcs15_print_id(&pin->auth_id)); 
    62         printf("\tFlags       : [0x%02X]", pin->flags); 
    63         for (i = 0; i < pf_count; i++) 
    64                 if (pin->flags & (1 << i)) { 
    65                         printf(", %s", pin_flags[i]); 
    66                 } 
    67         printf("\n"); 
    68         printf("\tLength      : min_len:%lu, max_len:%lu, stored_len:%lu\n", 
    69                 (unsigned long) pin->min_length, 
    70                 (unsigned long) pin->max_length, 
    71                 (unsigned long) pin->stored_length); 
    72         printf("\tPad char    : 0x%02X\n", pin->pad_char); 
    73         printf("\tReference   : %d\n", pin->reference); 
    74         printf("\tEncoding    : "); 
    75         switch (pin->type) { 
    76         case SC_PKCS15_PIN_TYPE_BCD: 
    77                 printf("BCD\n"); break; 
    78         case SC_PKCS15_PIN_TYPE_ASCII_NUMERIC: 
    79                 printf("ASCII-numeric\n"); break; 
    80         case SC_PKCS15_PIN_TYPE_UTF8: 
    81                 printf("UTF8\n"); break; 
    82         case SC_PKCS15_PIN_TYPE_HALFNIBBLE_BCD: 
    83                 printf("half-nibble BCD\n"); break; 
    84         case SC_PKCS15_PIN_TYPE_ISO9564_1: 
    85                 printf("ISO 9564-1\n"); break; 
    86         default: 
    87                 printf("[encoding %d]\n", pin->type); 
     62        if (pin->auth_type == SC_PKCS15_PIN_AUTH_TYPE_PIN)   { 
     63                printf("\tFlags       : [0x%02X]", pin->attrs.pin.flags); 
     64                for (i = 0; i < pf_count; i++) 
     65                        if (pin->attrs.pin.flags & (1 << i)) { 
     66                                printf(", %s", pin_flags[i]); 
     67                        } 
     68                printf("\n"); 
     69                printf("\tLength      : min_len:%lu, max_len:%lu, stored_len:%lu\n", 
     70                        (unsigned long) pin->attrs.pin.min_length, 
     71                        (unsigned long) pin->attrs.pin.max_length, 
     72                        (unsigned long) pin->attrs.pin.stored_length); 
     73                printf("\tPad char    : 0x%02X\n", pin->attrs.pin.pad_char); 
     74                printf("\tReference   : %d\n", pin->attrs.pin.reference); 
     75                printf("\tEncoding    : "); 
     76                switch (pin->attrs.pin.type) { 
     77                case SC_PKCS15_PIN_TYPE_BCD: 
     78                        printf("BCD\n"); break; 
     79                case SC_PKCS15_PIN_TYPE_ASCII_NUMERIC: 
     80                        printf("ASCII-numeric\n"); break; 
     81                case SC_PKCS15_PIN_TYPE_UTF8: 
     82                        printf("UTF8\n"); break; 
     83                case SC_PKCS15_PIN_TYPE_HALFNIBBLE_BCD: 
     84                        printf("half-nibble BCD\n"); break; 
     85                case SC_PKCS15_PIN_TYPE_ISO9564_1: 
     86                        printf("ISO 9564-1\n"); break; 
     87                default: 
     88                        printf("[encoding %d]\n", pin->attrs.pin.type); 
     89                } 
    8890        } 
    8991        if (pin->path.len) 

  • src/tools/pkcs15-crypt.c

    rc74d33d rd888b3f  
    125125        char buf[80]; 
    126126        char *pincode; 
    127         struct sc_pkcs15_pin_info *pinfo = (struct sc_pkcs15_pin_info *) obj->data; 
    128          
     127        struct sc_pkcs15_auth_info *pinfo = (struct sc_pkcs15_auth_info *) obj->data; 
     128 
     129        if (pinfo->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     130                return NULL; 
     131 
    129132        if (opt_pincode != NULL) { 
    130133                if (strcmp(opt_pincode, "-") == 0) 
    … …  
    139142                if (strlen(pincode) == 0) 
    140143                        return NULL; 
    141                 if (strlen(pincode) < pinfo->min_length || 
    142                     strlen(pincode) > pinfo->max_length) 
     144                if (strlen(pincode) < pinfo->attrs.pin.min_length || 
     145                    strlen(pincode) > pinfo->attrs.pin.max_length) 
    143146                        continue; 
    144147                return strdup(pincode); 

  • src/tools/pkcs15-init.c

    r71b1f55 rd888b3f  
    101101static void     init_gost_params(struct sc_pkcs15init_keyarg_gost_params *, EVP_PKEY *); 
    102102static int      get_pin_callback(struct sc_profile *profile, 
    103                         int id, const struct sc_pkcs15_pin_info *info, 
     103                        int id, const struct sc_pkcs15_auth_info *info, 
    104104                        const char *label, 
    105105                        u8 *pinbuf, size_t *pinsize); 
    … …  
    389389        const char *            obj_label;      /* O: object (PIN) label */ 
    390390        union { 
    391             struct sc_pkcs15_pin_info *pin; 
     391            struct sc_pkcs15_auth_info *pin; 
    392392        } info; 
    393393} sc_ui_hints_t; 
    … …  
    684684{ 
    685685        struct sc_pkcs15init_initargs args; 
    686         sc_pkcs15_pin_info_t    info; 
     686        sc_pkcs15_auth_info_t   info; 
    687687        sc_ui_hints_t           hints; 
    688688        const char              *role = "so"; 
    … …  
    690690 
    691691        memset(&hints, 0, sizeof(hints)); 
     692        memset(&info, 0, sizeof(info)); 
    692693        hints.usage     = SC_UI_USAGE_NEW_PIN; 
    693694        hints.flags     = SC_UI_PIN_RETYPE 
    … …  
    710711        sc_pkcs15init_get_pin_info(profile, SC_PKCS15INIT_SO_PIN, &info); 
    711712 
    712         if (!(info.flags & SC_PKCS15_PIN_FLAG_SO_PIN)) 
     713        if (!(info.attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN)) 
    713714                role = "user"; 
    714715        else 
    … …  
    716717                         
    717718 
    718         if ((info.flags & SC_PKCS15_PIN_FLAG_UNBLOCK_DISABLED)  
    719                         && (info.flags & SC_PKCS15_PIN_FLAG_SO_PIN)) 
     719        if ((info.attrs.pin.flags & SC_PKCS15_PIN_FLAG_UNBLOCK_DISABLED)  
     720                        && (info.attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN)) 
    720721                so_puk_disabled = 1; 
    721722 
    … …  
    730731                sc_pkcs15init_get_pin_info(profile, SC_PKCS15INIT_SO_PUK, &info); 
    731732 
    732                 if (!(info.flags & SC_PKCS15_PIN_FLAG_SO_PIN)) 
     733                if (!(info.attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN)) 
    733734                        role = "user"; 
    734735 
    … …  
    765766{ 
    766767        struct sc_pkcs15init_pinargs args; 
    767         sc_pkcs15_pin_info_t    info; 
     768        sc_pkcs15_auth_info_t   info; 
    768769        sc_ui_hints_t           hints; 
    769770        int                     r; 
    … …  
    802803        args.label = opt_label; 
    803804 
    804         if (!(info.flags & SC_PKCS15_PIN_FLAG_UNBLOCK_DISABLED)  
     805        if (!(info.attrs.pin.flags & SC_PKCS15_PIN_FLAG_UNBLOCK_DISABLED)  
    805806                        && opt_pins[1] == NULL) { 
    806807                sc_pkcs15init_get_pin_info(profile, SC_PKCS15INIT_USER_PUK, &info); 
    … …  
    16271628static int 
    16281629get_pin_callback(struct sc_profile *profile, 
    1629                 int id, const struct sc_pkcs15_pin_info *info, 
     1630                int id, const struct sc_pkcs15_auth_info *info, 
    16301631                const char *label, 
    16311632                u8 *pinbuf, size_t *pinsize) 
    … …  
    16371638        int     allocated = 0; 
    16381639 
    1639         if (label) { 
     1640        if (info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     1641                return SC_ERROR_NOT_SUPPORTED;  
     1642 
     1643        if (label) 
    16401644                snprintf(namebuf, sizeof(namebuf), "PIN [%s]", label); 
    1641         } else { 
    1642                 snprintf(namebuf, sizeof(namebuf), 
    1643                         "Unspecified PIN [reference %u]", 
    1644                         info->reference); 
    1645         } 
     1645        else 
     1646                snprintf(namebuf, sizeof(namebuf), "Unspecified PIN [reference %u]", info->attrs.pin.reference); 
    16461647 
    16471648        if (!ignore_cmdline_pins) { 
    … …  
    16671668                } 
    16681669                else if (info->auth_method == SC_AC_CHV)   { 
    1669                         if (!(info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
    1670                                         && !(info->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN))    { 
     1670                        if (!(info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     1671                                        && !(info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN))    { 
    16711672                                name = "User PIN"; 
    16721673                                secret = opt_pins[OPT_PIN1 & 3]; 
    16731674                        } 
    1674                         else if (!(info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
    1675                                         && (info->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN))    { 
     1675                        else if (!(info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     1676                                        && (info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN))    { 
    16761677                                name = "User PUK"; 
    16771678                                secret = opt_pins[OPT_PUK1 & 3]; 
    16781679                        } 
    1679                         else if ((info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
    1680                                         && !(info->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN))    { 
     1680                        else if ((info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     1681                                        && !(info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN))    { 
    16811682                                name = "Security officer PIN"; 
    16821683                                secret = opt_pins[OPT_PIN2 & 3]; 
    16831684                        } 
    1684                         else if ((info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
    1685                                         && (info->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN))    { 
     1685                        else if ((info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     1686                                        && (info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN))    { 
    16861687                                name = "Security officer PIN unlock key"; 
    16871688                                secret = opt_pins[OPT_PUK2 & 3]; 
    … …  
    27182719int get_pin(sc_ui_hints_t *hints, char **out) 
    27192720{ 
    2720         sc_pkcs15_pin_info_t *pin_info; 
     2721        sc_pkcs15_auth_info_t *pin_info; 
    27212722        const char      *label; 
    27222723        int             flags = hints->flags; 
    27232724 
    27242725        pin_info = hints->info.pin; 
     2726        if (pin_info && pin_info->auth_type == SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     2727                return SC_ERROR_NOT_SUPPORTED; 
     2728 
    27252729        if (!(label = hints->obj_label)) { 
    27262730                if (pin_info == NULL) { 
    27272731                        label = "PIN"; 
    2728                 } else if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
     2732                } else if (pin_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) { 
    27292733                        label = "Security Officer PIN"; 
    27302734                } else { 
    … …  
    27592763 
    27602764                if (pin_info && (flags & SC_UI_PIN_CHECK_LENGTH)) { 
    2761                         if (strlen(pin) < pin_info->min_length) { 
     2765                        if (strlen(pin) < pin_info->attrs.pin.min_length) { 
    27622766                                fprintf(stderr, 
    27632767                                        "PIN too short (min %lu characters)\n", 
    2764                                         (unsigned long) pin_info->min_length); 
     2768                                        (unsigned long) pin_info->attrs.pin.min_length); 
    27652769                                continue; 
    27662770                        } 
    2767                         if (pin_info->max_length 
    2768                          && strlen(pin) > pin_info->max_length) { 
     2771                        if (pin_info->attrs.pin.max_length 
     2772                         && strlen(pin) > pin_info->attrs.pin.max_length) { 
    27692773                                fprintf(stderr, 
    27702774                                        "PIN too long (max %lu characters)\n", 
    2771                                         (unsigned long) pin_info->max_length); 
     2775                                        (unsigned long) pin_info->attrs.pin.max_length); 
    27722776                                continue; 
    27732777                        } 
    … …  
    28282832 
    28292833                for (ii=0;ii<r;ii++)   { 
    2830                         struct sc_pkcs15_pin_info *pin_info = (struct sc_pkcs15_pin_info *) objs[ii]->data; 
    2831  
    2832                         if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     2834                        struct sc_pkcs15_auth_info *pin_info = (struct sc_pkcs15_auth_info *) objs[ii]->data; 
     2835 
     2836                        if (pin_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
    28332837                                continue; 
    2834                         if (pin_info->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN) 
     2838                        if (pin_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     2839                                continue; 
     2840                        if (pin_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN) 
    28352841                                continue; 
    28362842 

  • src/tools/pkcs15-tool.c

    re81c174 rd888b3f  
    963963static u8 * get_pin(const char *prompt, sc_pkcs15_object_t *pin_obj) 
    964964{ 
    965         sc_pkcs15_pin_info_t *pinfo = (sc_pkcs15_pin_info_t *) pin_obj->data; 
     965        sc_pkcs15_auth_info_t *pinfo = (sc_pkcs15_auth_info_t *) pin_obj->data; 
    966966        char *pincode = NULL; 
    967967        size_t len = 0; 
    … …  
    969969         
    970970        printf("%s [%s]: ", prompt, pin_obj->label); 
     971        if (pinfo->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
     972                return NULL; 
     973 
    971974        while (1) { 
    972975                r = util_getpass(&pincode, &len, stdin); 
    … …  
    975978                if (!pincode || strlen(pincode) == 0) 
    976979                        return NULL; 
    977                 if (strlen(pincode) < pinfo->min_length) { 
     980                if (strlen(pincode) < pinfo->attrs.pin.min_length) { 
    978981                        printf("PIN code too short, try again.\n"); 
    979982                        continue; 
    980983                } 
    981                 if (strlen(pincode) > pinfo->max_length) { 
     984                if (strlen(pincode) > pinfo->attrs.pin.max_length) { 
    982985                        printf("PIN code too long, try again.\n"); 
    983986                        continue; 
    … …  
    10041007 
    10051008                for (ii=0;ii<r;ii++)   { 
    1006                         struct sc_pkcs15_pin_info *pin_info = (struct sc_pkcs15_pin_info *) objs[ii]->data; 
    1007  
    1008                         if (pin_info->flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     1009                        struct sc_pkcs15_auth_info *pin_info = (struct sc_pkcs15_auth_info *) objs[ii]->data; 
     1010 
     1011                        if (pin_info->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN) 
    10091012                                continue; 
    1010                         if (pin_info->flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN) 
     1013                        if (pin_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_SO_PIN) 
     1014                                continue; 
     1015                        if (pin_info->attrs.pin.flags & SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN) 
    10111016                                continue; 
    10121017 
    … …  
    10691074        const char *pin_types[] = {"bcd", "ascii-numeric", "UTF-8", 
    10701075                "halfnibble bcd", "iso 9664-1"};  
    1071         const struct sc_pkcs15_pin_info *pin = (const struct sc_pkcs15_pin_info *) obj->data; 
     1076        const struct sc_pkcs15_auth_info *pin = (const struct sc_pkcs15_auth_info *) obj->data; 
    10721077        const size_t pf_count = NELEMENTS(pin_flags); 
    10731078        size_t i; 
    … …  
    10781083                printf("\tAuth ID        : %s\n", sc_pkcs15_print_id(&obj->auth_id)); 
    10791084        printf("\tID             : %s\n", sc_pkcs15_print_id(&pin->auth_id)); 
    1080         printf("\tFlags          : [0x%02X]", pin->flags); 
    1081         for (i = 0; i < pf_count; i++) 
    1082                 if (pin->flags & (1 << i)) { 
    1083                         printf(", %s", pin_flags[i]); 
    1084                 } 
    1085         printf("\n"); 
    1086         printf("\tLength         : min_len:%lu, max_len:%lu, stored_len:%lu\n", 
    1087                 (unsigned long)pin->min_length, (unsigned long)pin->max_length, 
    1088                 (unsigned long)pin->stored_length); 
    1089         printf("\tPad char       : 0x%02X\n", pin->pad_char); 
    1090         printf("\tReference      : %d\n", pin->reference); 
    1091         if (pin->type < NELEMENTS(pin_types)) 
    1092                 printf("\tType           : %s\n", pin_types[pin->type]); 
    1093         else 
    1094                 printf("\tType           : [encoding %d]\n", pin->type); 
     1085        if (pin->auth_type == SC_PKCS15_PIN_AUTH_TYPE_PIN)   { 
     1086                printf("\tFlags          : [0x%02X]", pin->attrs.pin.flags); 
     1087                for (i = 0; i < pf_count; i++) 
     1088                        if (pin->attrs.pin.flags & (1 << i)) { 
     1089                                printf(", %s", pin_flags[i]); 
     1090                        } 
     1091                printf("\n"); 
     1092                printf("\tLength         : min_len:%lu, max_len:%lu, stored_len:%lu\n", 
     1093                        (unsigned long)pin->attrs.pin.min_length, (unsigned long)pin->attrs.pin.max_length, 
     1094                        (unsigned long)pin->attrs.pin.stored_length); 
     1095                printf("\tPad char       : 0x%02X\n", pin->attrs.pin.pad_char); 
     1096                printf("\tReference      : %d\n", pin->attrs.pin.reference); 
     1097                if (pin->attrs.pin.type < NELEMENTS(pin_types)) 
     1098                        printf("\tType           : %s\n", pin_types[pin->attrs.pin.type]); 
     1099                else 
     1100                        printf("\tType           : [encoding %d]\n", pin->attrs.pin.type); 
     1101        } 
    10951102        if (pin->path.len || pin->path.aid.len) 
    10961103                printf("\tPath           : %s\n", sc_print_path(&pin->path)); 
    … …  
    11851192static int unblock_pin(void) 
    11861193{ 
    1187         struct sc_pkcs15_pin_info *pinfo = NULL; 
     1194        struct sc_pkcs15_auth_info *pinfo = NULL; 
    11881195        sc_pkcs15_object_t *pin_obj; 
    11891196        u8 *pin, *puk; 
    … …  
    11941201        if (!(pin_obj = get_pin_info())) 
    11951202                return 2; 
    1196         pinfo = (sc_pkcs15_pin_info_t *) pin_obj->data; 
     1203        pinfo = (sc_pkcs15_auth_info_t *) pin_obj->data; 
     1204 
     1205        if (pinfo->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN)  
     1206                return 1; 
    11971207 
    11981208        puk = opt_puk; 
    … …  
    12491259{ 
    12501260        sc_pkcs15_object_t *pin_obj; 
    1251         sc_pkcs15_pin_info_t *pinfo = NULL; 
     1261        sc_pkcs15_auth_info_t *pinfo = NULL; 
    12521262        u8 *pincode, *newpin; 
    12531263        int r, pinpad_present = 0; 
    … …  
    12571267        if (!(pin_obj = get_pin_info())) 
    12581268                return 2; 
    1259         pinfo = (sc_pkcs15_pin_info_t *) pin_obj->data; 
     1269 
     1270        pinfo = (sc_pkcs15_auth_info_t *) pin_obj->data; 
     1271        if (pinfo->auth_type != SC_PKCS15_PIN_AUTH_TYPE_PIN)  
     1272                return 1; 
    12601273 
    12611274        if (pinfo->tries_left != -1) { 
Note: See TracChangeset for help on using the changeset viewer.