cert_util.c

vc环境下的pgp源码

    x = b->val;

    for (i=0; i < b->len; i++) {
        val <<= 8;
        val += x[i];
    }

    return val;
} /* PKIGetIntVal */

/************************************************************************
*  PKIPutIntVal
*
*  Pack an integer value into a byte string
*************************************************************************/

int PKIPutIntVal(
    PKICONTEXT *ctx,
    PKIINTEGER *b, /* the block to take that value */
    long v        /* the value */ )
{
    long i ;
    unsigned char *x ;

    if (ctx == NULL)
        return PKIErrBadContext;

    if (b == NULL)
        return (-1);
    if ((b->val) != NULL)
        PKIFree(ctx->memMgr, b->val);
    memset (b, 0, sizeof (PKIINTEGER));
    b->val = x = (unsigned char *)PKIAlloc(ctx->memMgr, 4);
    if (b->val == NULL)
        return (-1);
    b->len = 4 ;
    for (i=3; i >= 0; i-- ) {
        x[i] = v & 0xff ;
        v >>= 8 ;
    }
    normalize( b ) ;
    return 0;
} /* PKIPutIntVal */

/************************************************************************
*  PKIPutUIntBytes
*
*  Packs a large (greater than a C integer) unsigned integer value
*  into a PKIINTEGER type.  This routine adds a leading zero byte if
*  the provided data's leading bit is set.
*************************************************************************/

int PKIPutUIntBytes(
    PKICONTEXT *ctx,
    PKIINTEGER *block, /* the block for the value */
    const unsigned char *value, /* the value */
    size_t lth) /* the length */
{
    size_t newLen = lth;

    if (ctx == NULL)
        return PKIErrBadContext;
    if (block == NULL)
        return (-1);

    if (block->val != NULL)
        PKIFree(ctx->memMgr, block->val);
    memset (block, 0, sizeof(PKIINTEGER));

    if ( (value[0] & 0x80) == 0x80 )
        newLen++;
    block->val = (unsigned char *)PKIAlloc(ctx->memMgr, newLen);
    if (block->val == NULL)
        return (-1);
    memset (block->val, 0, newLen);

    if ( (value[0] & 0x80) == 0x80 )
        memcpy( block->val+1, value, lth);
    else
        memcpy( block->val, value, lth);
    block->len = newLen;
    return (0);
} /* PKIPutOctVal */

/************************************************************************
* Routines for PKINumericString
*************************************************************************/

size_t PKIPackNumericString(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKINumericString *numblock,
    int *erret )
{
    return(PKIPackNumericStringInternal(ctx, buf, buflen, numblock,
                                    PKIID_NumericString, erret));
} /* PKIPackNumericString */

size_t PKIPackNumericStringInternal(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKINumericString *numblock,
    unsigned char tag,
    int *erret )
{
    size_t bytesused;
    size_t i;

    bytesused = PackVariableBlock(ctx, tag, PKIFALSE,
                             0, buf, buflen, numblock, erret);
    if (bytesused == 0 || *erret != 0)
        return(bytesused);

    /* after the pack since then we know numblock is okay */
    for ( i = 0; i < numblock->len; i++ ) {
        if (isdigit(numblock->val[i]))
            continue;

        if (numblock->val[i] == (unsigned char)' ' /* space */ )
            continue;

        PKIERR(PKIErrBadNumericString);
        bytesused = 0;
        break;
    }

    return(bytesused);

} /* PKIPackNumericStringInternal */

size_t PKIUnpkInPlaceNumericString(
    PKICONTEXT *ctx,
    PKINumericString *numstruct,    /* output block */
    const unsigned char *buf,      /* loc of input pointer */
    size_t buflen,        /* max end of my region */
    unsigned char tag,
    int *erret)          /* error return location */
{
    size_t bytesused;
    size_t i;

    bytesused = UnpkInPlaceVariableBlock(ctx, tag, "NumericString", 0x12, numstruct,
                            buf, buflen, erret);
    if (bytesused == 0 || *erret != 0)
       return bytesused;

    for ( i = 0; i < numstruct->len; i++ ) {
        if (isdigit(numstruct->val[i]))
            continue;

        if (numstruct->val[i] == (unsigned char)' ' /* space */ )
            continue;

        PKIERR(PKIErrBadNumericString);
        bytesused = 0;
        break;
    }

   return bytesused;
} /* PKIUnpkInPlaceNumericString */

size_t PKIUnpackNumericString(
    PKICONTEXT *ctx,
    PKINumericString **numstruct,
    const unsigned char *buf,
    size_t buflen,
    int       *erret)
{
    return(PKIUnpackNumericStringInternal(ctx, numstruct, buf, buflen,
                PKIID_NumericString, erret));
}

size_t PKIUnpackNumericStringInternal(
    PKICONTEXT *ctx,
    PKINumericString **numstruct,
    const unsigned char *buf,
    size_t buflen,
    unsigned char  tag,
    int       *erret)  /* error return */
{
    size_t bytesused;
    PKINumericString *local = NULL;

    if (erret == NULL) return 0;
    *erret = 0;

    if (ctx == NULL) {
        PKIERR(PKIErrBadContext);
        return 0;
    }

    if (numstruct == NULL) {
        PKIERR(PKIErrUnpackNoStructure);
        return 0;
    }
    *numstruct = NULL;

    if (buflen <= 0) return 0;

    /* see note in UnpkInPlaceVariableBlock */
    if ( (*buf & 0xDF) != (tag & 0xDF) ) return 0;

    local = PKINewNumericString(ctx);    /* carve a block for it */
    bytesused = PKIUnpkInPlaceNumericString(ctx, local, buf, buflen, tag, erret);
    if (*erret != 0) {
        if (local != NULL) PKIFreeNumericString(ctx, local);
        return 0;
    }

    *numstruct = local;
    return bytesused;
} /* PKIUnpackNumericStringInternal */

/************************************************************************
* Routines for PKIOBJECT_ID
*************************************************************************/

size_t PKIPackOBJECT_ID(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIOBJECT_ID *oidblock,
    int *erret)
{
  return(PackVariableBlock(ctx, PKIID_OBJECT_ID, PKIFALSE, 0, buf, buflen,
                     oidblock, erret));

} 

size_t PKIPackOBJECT_IDInternal(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIOBJECT_ID *oidblock,
    unsigned char tag,
    int *erret)
{
  return(PackVariableBlock(ctx, tag, PKIFALSE, 0, buf, buflen, oidblock, erret));

} /* PKIPackOBJECT_IDInternal */

int PKIUnpkInPlaceOBJECT_ID(
    PKICONTEXT *ctx,
    PKIOBJECT_ID *oidstruct,    /* output block */
    const unsigned char *buf,  /* loc of input pointer */
    size_t buflen,        /* max end of my region */
    unsigned char tag,
    int *erret) 
{
  return (UnpkInPlaceVariableBlock(ctx, tag, "OBJECT IDENTIFIER", 0x06, oidstruct,
                      buf, buflen, erret));
} /* PKIUnpkInPlaceOBJECT_ID */

size_t PKIUnpackOBJECT_ID(
    PKICONTEXT *ctx,
    PKIOBJECT_ID **oidstruct,
    const unsigned char *buf,
    size_t buflen, 
    int        *erret)
{
    return(PKIUnpackOBJECT_IDInternal(ctx, oidstruct, buf, buflen,
            PKIID_OBJECT_ID, erret));
}

size_t PKIUnpackOBJECT_IDInternal(
    PKICONTEXT *ctx,
    PKIOBJECT_ID **oidstruct,
    const unsigned char *buf,
    size_t buflen,
    unsigned char tag,
    int        *erret)  /* error return */
{
    size_t bytesused;
    PKIOBJECT_ID  *local = NULL;

    if (erret == NULL) return 0;
    *erret = 0;

    if (ctx == NULL) {
        PKIERR(PKIErrBadContext);
        return 0;
    }

    if (oidstruct == NULL) {
        PKIERR(PKIErrUnpackNoStructure);
        return 0;
    }
    *oidstruct = NULL;

    if (buflen <= 0) return 0;

    if (*buf != tag) return 0;

    local = PKINewOBJECT_ID(ctx);    /* carve a block for it */
    bytesused = PKIUnpkInPlaceOBJECT_ID(ctx, local, buf, buflen, tag, erret);
    if (*erret != 0) {
        if (local != NULL) PKIFreeOBJECT_ID(ctx, local);
        return 0;
    }

    *oidstruct = local;
    return bytesused;
} /* PKIUnpackOBJECT_IDInternal */

/************************************************************************
* Routines for PKIOCTET_STRING
*************************************************************************/

size_t PKIPackOCTET_STRING(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIOCTET_STRING *octblock,
    int *erret)
{
  return(PackVariableBlock(ctx, PKIID_OCTET_STRING, PKIFALSE, 0, buf, buflen,
                      octblock, erret));
}

size_t PKIPackOCTET_STRINGInternal(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIOCTET_STRING *octblock,
    unsigned char tag,
    int *erret)
{
  return(PackVariableBlock(ctx, tag, PKIFALSE, 0, buf, buflen, octblock, erret));
} /* PKIPackOCTET_STRINGInternal */

size_t PKIUnpkInPlaceOCTET_STRING(
    PKICONTEXT *ctx,
    PKIOCTET_STRING *octstruct,        /* output block */
    const unsigned char *buf,        /* loc of input pointer */
    size_t buflen,        /* max end of my region */
    unsigned char tag,
    int *erret)     
{
  return (UnpkInPlaceVariableBlock(ctx, tag, "OCTET STRING", 0x04, octstruct,
                      buf, buflen, erret));
} /* PKIUnpkInPlaceOCTET_STRING */

size_t PKIUnpackOCTET_STRING(
    PKICONTEXT *ctx,
    PKIOCTET_STRING **octstruct,
    const unsigned char *buf,
    size_t buflen, 
    int        *erret)
{
    return(PKIUnpackOCTET_STRINGInternal(ctx, octstruct, buf, buflen,
            PKIID_OCTET_STRING, erret));
}

size_t PKIUnpackOCTET_STRINGInternal(
    PKICONTEXT *ctx,
    PKIOCTET_STRING **octstruct,
    const unsigned char *buf,
    size_t buflen,
    unsigned char tag,
    int        *erret)  /* error return */
{
    size_t bytesused;
    PKIOCTET_STRING *local = NULL;

    if (erret == NULL) return 0;
    *erret = 0;

    if (ctx == NULL) {
        PKIERR(PKIErrBadContext);
        return 0;
    }

    if (octstruct == NULL) {
        PKIERR(PKIErrUnpackNoStructure);
        return 0;
    }
    *octstruct = NULL;

    if (buflen <= 0) return 0;

    /* see note in UnpkInPlaceVariableBlock */
    if ( (*buf & 0xDF) != (tag & 0xDF) ) return 0;

    local = PKINewOCTET_STRING(ctx);    /* carve a block for it */
    bytesused = PKIUnpkInPlaceOCTET_STRING(ctx, local, buf, buflen, tag, erret);
    if (*erret != 0) {
        if (local != NULL) PKIFreeOCTET_STRING(ctx, local);
        return 0;
    }

    *octstruct = local;
    return bytesused;
} /* PKIUnpackOCTET_STRINGInternal */

/************************************************************************
* Routines for PKIPrintableString
*************************************************************************/

size_t PKIPackPrintableString(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIPrintableString *strblock,
    int *erret )
{
    return(PKIPackPrintableStringInternal(ctx, buf, buflen, strblock,
                 PKIID_PrintableString, erret));
} 

size_t PKIPackPrintableStringInternal(
    PKICONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PKIPrintableString *strblock,
    unsigned char tag,
    int *erret )
{
    size_t bytesused;
    size_t i;

    bytesused = PackVariableBlock(ctx, tag, PKIFALSE, 0,
                     buf, buflen, strblock, erret);
    if (bytesused == 0 || *erret != 0)
        return(bytesused);

    for ( i = 0; i < strblock->len; i++ ) {
        if ( isdigit( strblock->val[i] ) )
            continue;

        if ( isalpha( strblock->val[i] ) )
            continue;

        if ( strchr( "'\"()+,-./:=? ", strblock->val[i] ) != 0 )
            continue;

        PKIERR(PKIErrBadPrintableString);
        bytesused = 0;
        break;
    }

    return(bytesused);

} /* PKIPackPrintableStringInternal */

int PKIUnpkInPlacePrintableString(
    PKICONTEXT *ctx,
    PKIPrintableString *printstruct,    /* output block */
    const unsigned char *buf,        /* loc of input pointer */
    size_t buflen,        /* max end of my region */
    unsigned char tag,
    int *erret)     
{
    size_t bytesused;
    size_t i;

    bytesused = UnpkInPlaceVariableBlock(ctx, tag, "PrintableString", 0x13, printstruct,
                            buf, buflen, erret);
    if (bytesused == 0 || *erret != 0)
        return(bytesused);

    for ( i = 0; i < printstruct->len; i++ ) {
        if ( isdigit( printstruct->val[i] ) )
            continue;

        if ( isalpha( printstruct->val[i] ) )
            continue;

        if ( strchr( "'\"()+,-./:=? ", printstruct->val[i] ) != 0 )
            continue;

        PKIERR(PKIErrBadPrintableString);
        bytesused = 0;
        break;