pgpx509cert_util.c

vc环境下的pgp源码

    return(PackVariableBlock(ctx, tag, PGPASN_FALSE, 0, buf, buflen, intblock, erret));

}

size_t pgpasn_UnpkInPlaceINTEGER(
    PGPASN_CONTEXT *ctx,
    PGPASN_INTEGER *intstruct,        /* 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 */
{
    return (UnpkInPlaceVariableBlock(ctx, tag, "INTEGER", 0x02, intstruct, buf, buflen, erret));
} /* pgpasn_UnpkInPlaceINTEGER */

size_t pgpasn_UnpackINTEGER( 
    PGPASN_CONTEXT *ctx,
    PGPASN_INTEGER **intstruct,
    const unsigned char *buf,
    size_t buflen,
    int        *erret)
{
    return(pgpasn_UnpackINTEGERInternal(ctx, intstruct, buf, buflen, PGPASN_ID_INTEGER, erret));
}

size_t pgpasn_UnpackINTEGERInternal( 
    PGPASN_CONTEXT *ctx,
    PGPASN_INTEGER **intstruct,
    const unsigned char *buf,
    size_t buflen,
    unsigned char tag,
    int        *erret)  /* error return */
{
    size_t bytesused;
    PGPASN_INTEGER *local = NULL;

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

    if (ctx == NULL) {
        PGPASN_ERR(kPGPASNError_ErrBadContext);
        return 0;
    }

    if (intstruct == NULL) {
        PGPASN_ERR(kPGPASNError_ErrUnpackNoStructure);
        return 0;
    }
    *intstruct = NULL;

    if (buflen <= 0) return 0;

    if (*buf != tag) return 0;

    local = pgpasn_NewINTEGER(ctx);    /* carve a block for it */
    bytesused = pgpasn_UnpkInPlaceINTEGER(ctx, local, buf, buflen, tag, erret);
    if (*erret != 0) {
        if (local != NULL) pgpasn_FreeINTEGER(ctx, local);
        return 0;
    }
  
    *intstruct = local;
    return bytesused;
} /* pgpasn_UnpackINTEGERInternal */

/************************************************************************
* pgpasn_GetIntVal
*
*  Extract a long from the PGPASN_INTEGER b.
*************************************************************************/

long pgpasn_GetIntVal(
    PGPASN_CONTEXT *ctx,
    PGPASN_INTEGER *b,
    int *error)
{
    long val = 0;
    size_t i;
    unsigned char *x;

    (void)ctx; /* for future use */

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

    if ( b == NULL || b->len > 4 || b->val == NULL ) {
        *error = -1;
        return 0;
    }

    x = b->val;

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

    return val;
} /* pgpasn_GetIntVal */

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

int pgpasn_PutIntVal(
    PGPASN_CONTEXT *ctx,
    PGPASN_INTEGER *b, /* the block to take that value */
    long v        /* the value */ )
{
    long i ;
    unsigned char *x ;

    if (ctx == NULL)
        return kPGPASNError_ErrBadContext;

    if (b == NULL)
        return (-1);
    if ((b->val) != NULL)
        PGPASN_Free(ctx->memMgr, b->val);
    memset (b, 0, sizeof (PGPASN_INTEGER));
    b->val = x = (unsigned char *)PGPASN_Alloc(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;
} /* pgpasn_PutIntVal */

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

int pgpasn_PutUIntBytes(
    PGPASN_CONTEXT *ctx,
    PGPASN_INTEGER *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 kPGPASNError_ErrBadContext;
    if (block == NULL)
        return (-1);

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

    if ( (value[0] & 0x80) == 0x80 )
        newLen++;
    block->val = (unsigned char *)PGPASN_Alloc(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);
} /* pgpasn_PutOctVal */

/************************************************************************
* Routines for PGPASN_NumericString
*************************************************************************/

size_t pgpasn_PackNumericString(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_NumericString *numblock,
    int *erret )
{
    return(pgpasn_PackNumericStringInternal(ctx, buf, buflen, numblock,
                                    PGPASN_ID_NumericString, erret));
} /* pgpasn_PackNumericString */

size_t pgpasn_PackNumericStringInternal(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_NumericString *numblock,
    unsigned char tag,
    int *erret )
{
    size_t bytesused;
    size_t i;

    bytesused = PackVariableBlock(ctx, tag, PGPASN_FALSE,
                             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;

        PGPASN_ERR(kPGPASNError_ErrBadNumericString);
        bytesused = 0;
        break;
    }

    return(bytesused);

} /* pgpasn_PackNumericStringInternal */

size_t pgpasn_UnpkInPlaceNumericString(
    PGPASN_CONTEXT *ctx,
    PGPASN_NumericString *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;

        PGPASN_ERR(kPGPASNError_ErrBadNumericString);
        bytesused = 0;
        break;
    }

   return bytesused;
} /* pgpasn_UnpkInPlaceNumericString */

size_t pgpasn_UnpackNumericString(
    PGPASN_CONTEXT *ctx,
    PGPASN_NumericString **numstruct,
    const unsigned char *buf,
    size_t buflen,
    int       *erret)
{
    return(pgpasn_UnpackNumericStringInternal(ctx, numstruct, buf, buflen,
                PGPASN_ID_NumericString, erret));
}

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

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

    if (ctx == NULL) {
        PGPASN_ERR(kPGPASNError_ErrBadContext);
        return 0;
    }

    if (numstruct == NULL) {
        PGPASN_ERR(kPGPASNError_ErrUnpackNoStructure);
        return 0;
    }
    *numstruct = NULL;

    if (buflen <= 0) return 0;

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

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

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

/************************************************************************
* Routines for PGPASN_OBJECT_ID
*************************************************************************/

size_t pgpasn_PackOBJECT_ID(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_OBJECT_ID *oidblock,
    int *erret)
{
  return(PackVariableBlock(ctx, PGPASN_ID_OBJECT_ID, PGPASN_FALSE, 0, buf, buflen,
                     oidblock, erret));

} 

size_t pgpasn_PackOBJECT_IDInternal(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_OBJECT_ID *oidblock,
    unsigned char tag,
    int *erret)
{
  return(PackVariableBlock(ctx, tag, PGPASN_FALSE, 0, buf, buflen, oidblock, erret));

} /* pgpasn_PackOBJECT_IDInternal */

int pgpasn_UnpkInPlaceOBJECT_ID(
    PGPASN_CONTEXT *ctx,
    PGPASN_OBJECT_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));
} /* pgpasn_UnpkInPlaceOBJECT_ID */

size_t pgpasn_UnpackOBJECT_ID(
    PGPASN_CONTEXT *ctx,
    PGPASN_OBJECT_ID **oidstruct,
    const unsigned char *buf,
    size_t buflen, 
    int        *erret)
{
    return(pgpasn_UnpackOBJECT_IDInternal(ctx, oidstruct, buf, buflen,
            PGPASN_ID_OBJECT_ID, erret));
}

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

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

    if (ctx == NULL) {
        PGPASN_ERR(kPGPASNError_ErrBadContext);
        return 0;
    }

    if (oidstruct == NULL) {
        PGPASN_ERR(kPGPASNError_ErrUnpackNoStructure);
        return 0;
    }
    *oidstruct = NULL;

    if (buflen <= 0) return 0;

    if (*buf != tag) return 0;

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

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

/************************************************************************
* Routines for PGPASN_OCTET_STRING
*************************************************************************/

size_t pgpasn_PackOCTET_STRING(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_OCTET_STRING *octblock,
    int *erret)
{
  return(PackVariableBlock(ctx, PGPASN_ID_OCTET_STRING, PGPASN_FALSE, 0, buf, buflen,
                      octblock, erret));
}

size_t pgpasn_PackOCTET_STRINGInternal(
    PGPASN_CONTEXT *ctx,
    unsigned char *buf,
    size_t buflen,
    PGPASN_OCTET_STRING *octblock,
    unsigned char tag,
    int *erret)
{
  return(PackVariableBlock(ctx, tag, PGPASN_FALSE, 0, buf, buflen, octblock, erret));
} /* pgpasn_PackOCTET_STRINGInternal */

size_t pgpasn_UnpkInPlaceOCTET_STRING(
    PGPASN_CONTEXT *ctx,
    PGPASN_OCTET_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));
} /* pgpasn_UnpkInPlaceOCTET_STRING */

size_t pgpasn_UnpackOCTET_STRING(
    PGPASN_CONTEXT *ctx,
    PGPASN_OCTET_STRING **octstruct,
    const unsigned char *buf,
    size_t buflen, 
    int        *erret)
{
    return(pgpasn_UnpackOCTET_STRINGInternal(ctx, octstruct, buf, buflen,
            PGPASN_ID_OCTET_STRING, erret));
}

size_t pgpasn_UnpackOCTET_STRINGInternal(
    PGPASN_CONTEXT *ctx,
    PGPASN_OCTET_STRING **octstruct,
    const unsigned char *buf,
    size_t buflen,
    unsigned char tag,
    int        *erret)  /* error return */
{