ckfw/builtins/bfind.c

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef BUILTINS_H
#include "builtins.h"
#endif /* BUILTINS_H */

/*
 * builtins/find.c
 *
 * This file implements the NSSCKMDFindObjects object for the
 * "builtin objects" cryptoki module.
 */

struct builtinsFOStr {
    NSSArena *arena;
    CK_ULONG n;
    CK_ULONG i;
    builtinsInternalObject **objs;
};

static void
builtins_mdFindObjects_Final(
    NSSCKMDFindObjects *mdFindObjects,
    NSSCKFWFindObjects *fwFindObjects,
    NSSCKMDSession *mdSession,
    NSSCKFWSession *fwSession,
    NSSCKMDToken *mdToken,
    NSSCKFWToken *fwToken,
    NSSCKMDInstance *mdInstance,
    NSSCKFWInstance *fwInstance)
{
    struct builtinsFOStr *fo = (struct builtinsFOStr *)mdFindObjects->etc;
    NSSArena *arena = fo->arena;

    nss_ZFreeIf(fo->objs);
    nss_ZFreeIf(fo);
    nss_ZFreeIf(mdFindObjects);
    if ((NSSArena *)NULL != arena) {
        NSSArena_Destroy(arena);
    }

    return;
}

static NSSCKMDObject *
builtins_mdFindObjects_Next(
    NSSCKMDFindObjects *mdFindObjects,
    NSSCKFWFindObjects *fwFindObjects,
    NSSCKMDSession *mdSession,
    NSSCKFWSession *fwSession,
    NSSCKMDToken *mdToken,
    NSSCKFWToken *fwToken,
    NSSCKMDInstance *mdInstance,
    NSSCKFWInstance *fwInstance,
    NSSArena *arena,
    CK_RV *pError)
{
    struct builtinsFOStr *fo = (struct builtinsFOStr *)mdFindObjects->etc;
    builtinsInternalObject *io;

    if (fo->i == fo->n) {
        *pError = CKR_OK;
        return (NSSCKMDObject *)NULL;
    }

    io = fo->objs[fo->i];
    fo->i++;

    return nss_builtins_CreateMDObject(arena, io, pError);
}

static int
builtins_derUnwrapInt(unsigned char *src, int size, unsigned char **dest)
{
    unsigned char *start = src;
    int len = 0;

    if (*src++ != 2) {
        return 0;
    }
    len = *src++;
    if (len & 0x80) {
        int count = len & 0x7f;
        len = 0;

        if (count + 2 > size) {
            return 0;
        }
        while (count-- > 0) {
            len = (len << 8) | *src++;
        }
    }
    if (len + (src - start) != size) {
        return 0;
    }
    *dest = src;
    return len;
}

static CK_BBOOL
builtins_attrmatch(
    CK_ATTRIBUTE_PTR a,
    const NSSItem *b)
{
    PRBool prb;

    if (a->ulValueLen != b->size) {
        /* match a decoded serial number */
        if ((a->type == CKA_SERIAL_NUMBER) && (a->ulValueLen < b->size)) {
            int len;
            unsigned char *data = NULL;

            len = builtins_derUnwrapInt(b->data, b->size, &data);
            if (data &&
                (len == a->ulValueLen) &&
                nsslibc_memequal(a->pValue, data, len, (PRStatus *)NULL)) {
                return CK_TRUE;
            }
        }
        return CK_FALSE;
    }

    prb = nsslibc_memequal(a->pValue, b->data, b->size, (PRStatus *)NULL);

    if (PR_TRUE == prb) {
        return CK_TRUE;
    } else {
        return CK_FALSE;
    }
}

static CK_BBOOL
builtins_match(
    CK_ATTRIBUTE_PTR pTemplate,
    CK_ULONG ulAttributeCount,
    builtinsInternalObject *o)
{
    CK_ULONG i;

    for (i = 0; i < ulAttributeCount; i++) {
        CK_ULONG j;

        for (j = 0; j < o->n; j++) {
            if (o->types[j] == pTemplate[i].type) {
                if (CK_FALSE == builtins_attrmatch(&pTemplate[i], &o->items[j])) {
                    return CK_FALSE;
                } else {
                    break;
                }
            }
        }

        if (j == o->n) {
            /* Loop ran to the end: no matching attribute */
            return CK_FALSE;
        }
    }

    /* Every attribute passed */
    return CK_TRUE;
}

NSS_IMPLEMENT NSSCKMDFindObjects *
nss_builtins_FindObjectsInit(
    NSSCKFWSession *fwSession,
    CK_ATTRIBUTE_PTR pTemplate,
    CK_ULONG ulAttributeCount,
    CK_RV *pError)
{
    /* This could be made more efficient.  I'm rather rushed. */
    NSSArena *arena;
    NSSCKMDFindObjects *rv = (NSSCKMDFindObjects *)NULL;
    struct builtinsFOStr *fo = (struct builtinsFOStr *)NULL;

/*
   * 99% of the time we get 0 or 1 matches. So we start with a small
   * stack-allocated array to hold the matches and switch to a heap-allocated
   * array later if the number of matches exceeds STACK_BUF_LENGTH.
   */
#define STACK_BUF_LENGTH 1
    builtinsInternalObject *stackTemp[STACK_BUF_LENGTH];
    builtinsInternalObject **temp = stackTemp;
    PRBool tempIsHeapAllocated = PR_FALSE;
    PRUint32 i;

    arena = NSSArena_Create();
    if ((NSSArena *)NULL == arena) {
        goto loser;
    }

    rv = nss_ZNEW(arena, NSSCKMDFindObjects);
    if ((NSSCKMDFindObjects *)NULL == rv) {
        *pError = CKR_HOST_MEMORY;
        goto loser;
    }

    fo = nss_ZNEW(arena, struct builtinsFOStr);
    if ((struct builtinsFOStr *)NULL == fo) {
        *pError = CKR_HOST_MEMORY;
        goto loser;
    }

    fo->arena = arena;
    /* fo->n and fo->i are already zero */

    rv->etc = (void *)fo;
    rv->Final = builtins_mdFindObjects_Final;
    rv->Next = builtins_mdFindObjects_Next;
    rv->null = (void *)NULL;

    for (i = 0; i < nss_builtins_nObjects; i++) {
        builtinsInternalObject *o = (builtinsInternalObject *)&nss_builtins_data[i];

        if (CK_TRUE == builtins_match(pTemplate, ulAttributeCount, o)) {
            if (fo->n == STACK_BUF_LENGTH) {
                /* Switch from the small stack array to a heap-allocated array large
         * enough to handle matches in all remaining cases. */
                temp = nss_ZNEWARRAY((NSSArena *)NULL, builtinsInternalObject *,
                                     fo->n + nss_builtins_nObjects - i);
                if ((builtinsInternalObject **)NULL == temp) {
                    *pError =
                        CKR_HOST_MEMORY;
                    goto loser;
                }
                tempIsHeapAllocated = PR_TRUE;
                (void)nsslibc_memcpy(temp, stackTemp,
                                     sizeof(builtinsInternalObject *) * fo->n);
            }

            temp[fo->n] = o;
            fo->n++;
        }
    }

    fo->objs = nss_ZNEWARRAY(arena, builtinsInternalObject *, fo->n);
    if ((builtinsInternalObject **)NULL == fo->objs) {
        *pError = CKR_HOST_MEMORY;
        goto loser;
    }

    (void)nsslibc_memcpy(fo->objs, temp, sizeof(builtinsInternalObject *) * fo->n);
    if (tempIsHeapAllocated) {
        nss_ZFreeIf(temp);
        temp = (builtinsInternalObject **)NULL;
    }

    return rv;

loser:
    if (tempIsHeapAllocated) {
        nss_ZFreeIf(temp);
    }
    nss_ZFreeIf(fo);
    nss_ZFreeIf(rv);
    if ((NSSArena *)NULL != arena) {
        NSSArena_Destroy(arena);
    }
    return (NSSCKMDFindObjects *)NULL;
}