asn1.c

IBM的Linux上的PKCS#11实现

   }

   if (length_octets == 2) {
      len = ber_int[2];
      len = len << 8;
      len |= ber_int[3];

      *data      = &ber_int[4];
      *data_len  = len;
      *field_len = 1 + (1 + 2) + len;
      return CKR_OK;
   }

   if (length_octets == 3) {
      len = ber_int[2];
      len = len << 8;
      len |= ber_int[3];
      len = len << 8;
      len |= ber_int[4];

      *data      = &ber_int[5];
      *data_len  = len;
      *field_len = 1 + (1 + 3) + len;
      return CKR_OK;
   }

   // > 3 length octets implies a length > 16MB which isn't possible for
   // the coprocessor
   //
   st_err_log(4, __FILE__, __LINE__, __FUNCTION__);
   return CKR_FUNCTION_FAILED;
}


//
//
CK_RV
ber_encode_OCTET_STRING( CK_BBOOL    length_only,
                         CK_BYTE  ** str,
                         CK_ULONG  * str_len,
                         CK_BYTE   * data,
                         CK_ULONG    data_len )
{
   CK_BYTE   *buf = NULL;
   CK_ULONG   len;

   // I only support Primitive encoding for OCTET STRINGS
   //

   // if data_len < 128 use short-form length id
   // if data_len < 256 use long-form length id with 1-byte length field
   // if data_len < 65536 use long-form length id with 2-byte length field
   //

   if (data_len < 128)
      len = 1 + 1 + data_len;
   else if (data_len < 256)
      len = 1 + (1 + 1) + data_len;
   else if (data_len < (1 << 16))
      len = 1 + (1 + 2) + data_len;
   else if (data_len < (1 << 24))
      len = 1 + (1 + 3) + data_len;
   else{
      st_err_log(4, __FILE__, __LINE__, __FUNCTION__);
      return CKR_FUNCTION_FAILED;
   }
   if (length_only == TRUE) {
      *str_len = len;
      return CKR_OK;
   }

   buf = (CK_BYTE *)malloc( len );
   if (!buf){
      st_err_log(1, __FILE__, __LINE__);
      return CKR_HOST_MEMORY;
   }

   if (data_len < 128) {
      buf[0] = 0x04;       // primitive, OCTET STRING
      buf[1] = data_len;
      memcpy( &buf[2], data, data_len );

      *str_len = len;
      *str = buf;
      return CKR_OK;
   }

   if (data_len < 256) {
      buf[0] = 0x04;       // primitive, OCTET STRING
      buf[1] = 0x81;       // length header -- 1 length octets
      buf[2] = data_len;

      memcpy( &buf[3], data, data_len );

      *str_len = len;
      *str = buf;
      return CKR_OK;
   }

   if (data_len < (1 << 16)) {
      buf[0] = 0x04;       // primitive, OCTET STRING
      buf[1] = 0x82;       // length header -- 2 length octets
      buf[2] = (data_len >> 8) & 0xFF;
      buf[3] = (data_len     ) & 0xFF;

      memcpy( &buf[4], data, data_len );

      *str_len = len;
      *str = buf;
      return CKR_OK;
   }

   if (data_len < (1 << 24)) {
      buf[0] = 0x04;       // primitive, OCTET STRING
      buf[1] = 0x83;       // length header -- 3 length octets
      buf[2] = (data_len >> 16) & 0xFF;
      buf[3] = (data_len >>  8) & 0xFF;
      buf[4] = (data_len      ) & 0xFF;

      memcpy( &buf[5], data, data_len );

      *str_len = len;
      *str = buf;
      return CKR_OK;
   }

   // we should never reach this
   //
   free( buf );
   st_err_log(4, __FILE__, __LINE__, __FUNCTION__);
   return CKR_FUNCTION_FAILED;
}


//
//
CK_RV
ber_decode_OCTET_STRING( CK_BYTE  * str,
                         CK_BYTE ** data,
                         CK_ULONG * data_len,
                         CK_ULONG * field_len )
{
   CK_ULONG  len, length_octets;

   // I only support decoding primitive OCTET STRINGS
   //

   if (!str){
      st_err_log(4, __FILE__, __LINE__, __FUNCTION__);
      return CKR_FUNCTION_FAILED;
   }
   if (str[0] != 0x04){
      st_err_log(4, __FILE__, __LINE__, __FUNCTION__);
      return CKR_FUNCTION_FAILED;
   }
   // short form lengths are easy
   //
   if ((str[1] & 0x80) == 0) {
      len = str[1] & 0x7F;

      *data = &str[2];
      *data_len  = len;
      *field_len = 1 + (1) + len;
      return CKR_OK;
   }

   length_octets = str[1] & 0x7F;

   if (length_octets == 1) {
      len = str[2];

      *data = &str[3];
      *data_len  = len;
      *field_len = 1 + (1 + 1) + len;
      return CKR_OK;
   }

   if (length_octets == 2) {
      len = str[2];
      len = len << 8;
      len |= str[3];

      *data = &str[4];
      *data_len  = len;
      *field_len = 1 + (1 + 2) + len;
      return CKR_OK;
   }

   if (length_octets == 3) {
      len = str[2];
      len = len << 8;
      len |= str[3];
      len = len << 8;
      len |= str[4];

      *data = &str[5];
      *data_len  = len;
      *field_len = 1 + (1 + 3) + len;
      return CKR_OK;
   }

   // > 3 length octets implies a length > 16MB
   //
   st_err_log(4, __FILE__, __LINE__, __FUNCTION__);
   return CKR_FUNCTION_FAILED;
}


//
//
CK_RV
ber_encode_SEQUENCE( CK_BBOOL    length_only,
                     CK_BYTE  ** seq,
                     CK_ULONG  * seq_len,
                     CK_BYTE   * data,
                     CK_ULONG    data_len )
{
   CK_BYTE   *buf = NULL;
   CK_ULONG   len;

   // if data_len < 127 use short-form length id
   // if data_len < 65536 use long-form length id with 2-byte length field
   //

   if (data_len < 128)
      len = 1 + 1 + data_len;
   else if (data_len < 256)
      len = 1 + (1 + 1) + data_len;
   else if (data_len < (1 << 16))
      len = 1 + (1 + 2) + data_len;
   else if (data_len < (1 << 24))
      len = 1 + (1 + 3) + data_len;
   else{
      st_err_log(4, __FILE__, __LINE__, __FUNCTION__);
      return CKR_FUNCTION_FAILED;
   }
   if (length_only == TRUE) {
      *seq_len = len;
      return CKR_OK;
   }

   buf = (CK_BYTE *)malloc( len );
   if (!buf){
      st_err_log(1, __FILE__, __LINE__);
      return CKR_HOST_MEMORY;
   }

   if (data_len < 128) {
      buf[0] = 0x30;       // constructed, SEQUENCE
      buf[1] = data_len;
      memcpy( &buf[2], data, data_len );

      *seq_len = len;
      *seq = buf;
      return CKR_OK;
   }

   if (data_len < 256) {
      buf[0] = 0x30;       // constructed, SEQUENCE
      buf[1] = 0x81;       // length header -- 1 length octets
      buf[2] = data_len;

      memcpy( &buf[3], data, data_len );

      *seq_len = len;
      *seq = buf;
      return CKR_OK;
   }

   if (data_len < (1 << 16)) {
      buf[0] = 0x30;       // constructed, SEQUENCE
      buf[1] = 0x82;       // length header -- 2 length octets
      buf[2] = (data_len >> 8) & 0xFF;
      buf[3] = (data_len     ) & 0xFF;

      memcpy( &buf[4], data, data_len );

      *seq_len = len;
      *seq = buf;
      return CKR_OK;
   }

   if (data_len < (1 << 24)) {
      buf[0] = 0x30;       // constructed, SEQUENCE
      buf[1] = 0x83;       // length header -- 3 length octets
      buf[2] = (data_len >> 16) & 0xFF;
      buf[3] = (data_len >>  8) & 0xFF;
      buf[4] = (data_len      ) & 0xFF;

      memcpy( &buf[5], data, data_len );

      *seq_len = len;
      *seq = buf;
      return CKR_OK;
   }

   st_err_log(4, __FILE__, __LINE__, __FUNCTION__);
   return CKR_FUNCTION_FAILED;
}


//
//
CK_RV
ber_decode_SEQUENCE( CK_BYTE  * seq,
                     CK_BYTE ** data,
                     CK_ULONG * data_len,
                     CK_ULONG * field_len )
{
   CK_ULONG  len, length_octets;


   if (!seq){ 
      st_err_log(4, __FILE__, __LINE__, __FUNCTION__);
      return CKR_FUNCTION_FAILED;
   }
   if (seq[0] != 0x30){
      st_err_log(4, __FILE__, __LINE__, __FUNCTION__);
      return CKR_FUNCTION_FAILED;
   }
   // short form lengths are easy
   //
   if ((seq[1] & 0x80) == 0) {
      len = seq[1] & 0x7F;

      *data = &seq[2];
      *data_len  = len;
      *field_len = 1 + (1) + len;
      return CKR_OK;
   }

   length_octets = seq[1] & 0x7F;

   if (length_octets == 1) {
      len = seq[2];

      *data = &seq[3];
      *data_len  = len;
      *field_len = 1 + (1 + 1) + len;
      return CKR_OK;
   }

   if (length_octets == 2) {
      len = seq[2];
      len = len << 8;
      len |= seq[3];

      *data = &seq[4];
      *data_len  = len;
      *field_len = 1 + (1 + 2) + len;
      return CKR_OK;
   }

   if (length_octets == 3) {
      len = seq[2];
      len = len << 8;
      len |= seq[3];
      len = len << 8;
      len |= seq[4];

      *data = &seq[5];
      *data_len  = len;
      *field_len = 1 + (1 + 3) + len;
      return CKR_OK;
   }

   // > 3 length octets implies a length > 16MB
   //
   st_err_log(4, __FILE__, __LINE__, __FUNCTION__);
   return CKR_FUNCTION_FAILED;
}



// PrivateKeyInfo ::= SEQUENCE {
//    version  Version  -- always '0' for now
//    privateKeyAlgorithm PrivateKeyAlgorithmIdentifier
//    privateKey  PrivateKey
//    attributes
// }
//
CK_RV
ber_encode_PrivateKeyInfo( CK_BBOOL    length_only,
                           CK_BYTE  ** data,
                           CK_ULONG  * data_len,
                           CK_BYTE   * algorithm_id,
                           CK_ULONG    algorithm_id_len,
                           CK_BYTE   * priv_key,
                           CK_ULONG    priv_key_len )
{
   CK_BYTE  * buf = NULL;
   CK_BYTE  * tmp = NULL;
   CK_BYTE    version[] = { 0 };
   CK_BYTE    attrib[]  = {0x05, 0x00};
   CK_ULONG   len, total;
   CK_RV      rc;

   len = 0;

   rc = ber_encode_INTEGER( TRUE, NULL, &total, version, sizeof(version) );
   if (rc != CKR_OK){
      st_err_log(76, __FILE__, __LINE__);
      return rc;
   }
   else
      len += total;

   len += algorithm_id_len;

   rc = ber_encode_OCTET_STRING( TRUE, NULL, &total, priv_key, priv_key_len );
   if (rc != CKR_OK){
      st_err_log(77, __FILE__, __LINE__);
      return rc;
   }
   else
      len += total;

   // for this stuff, attributes are always NULL == 05 00
   //
   len += sizeof(attrib);

   if (length_only == TRUE) {
      rc = ber_encode_SEQUENCE( TRUE, NULL, &total, NULL, len );

      if (rc == CKR_OK)
         *data_len = total;
      if (rc != CKR_OK)
         st_err_log(78, __FILE__, __LINE__);
      return rc;
   }

   buf = (CK_BYTE *)malloc(len);
   if (!buf){
      st_err_log(1, __FILE__, __LINE__);
      return CKR_HOST_MEMORY;
   }
   len = 0;
   rc = ber_encode_INTEGER( FALSE, &tmp, &total, version, sizeof(version) );
   if (rc != CKR_OK){
      st_err_log(76, __FILE__, __LINE__);
      goto error;
   }
   memcpy( buf+len, tmp, total );