keyring.c

NIST推荐的素域上的椭圆曲线

   if ((errno = kr_init(pk)) != CRYPT_OK) { 
      return errno; 
   }

   /* read in magic bytes */
   if (_read(buf, 6, in, ctr) != 6)           { goto done2; }

   if (memcmp(buf, file_magic, 4)) {
      return CRYPT_INVALID_PACKET;
   }

   len = (unsigned long)buf[4] | ((unsigned long)buf[5] << 8);
   if (len > CRYPT) {
      return CRYPT_INVALID_PACKET;
   }

   /* while there are lengths to read... */
   while (_read(blen, 4, in, ctr) == 4) {
      /* get length */
      LOAD32L(len, blen);

      if (len > sizeof(buf)) {
         return CRYPT_INVALID_PACKET;
      }

      if (_read(buf, len, in, ctr) != len)           { goto done2; }
      if ((errno = kr_import(*pk, buf)) != CRYPT_OK) { 
         return errno; 
      }
   }

   res = CRYPT_OK;
   goto done;
done2:
   res = CRYPT_ERROR;
done:
#ifdef CLEAN_STACK
   zeromem(buf, sizeof(buf));
#endif
   return res;
}

int kr_save(pk_key *pk, FILE *out, symmetric_CTR *ctr)
{
   unsigned char buf[8192], blen[4];
   unsigned long len;
   int res, errno;

   _ARGCHK(pk != NULL);
   _ARGCHK(out != NULL);

   /* write out magic bytes */
   memcpy(buf, file_magic, 4);
   buf[4] = CRYPT&255;
   buf[5] = (CRYPT>>8)&255;
   if (_write(buf, 6, out, ctr) != 6)           { goto done2; }

   while (pk->system != NON_KEY) {
         len = sizeof(buf);
         if ((errno = kr_export(pk, pk->ID, pk->key_type, buf, &len)) != CRYPT_OK) { 
            return errno;
         }
          
         STORE32L(len, blen);
         if (_write(blen, 4, out, ctr) != 4)    { goto done2; }
         if (_write(buf, len, out, ctr) != len) { goto done2; }

         pk = pk->next;
   }
         
   res = CRYPT_OK;
   goto done;
done2:
   res = CRYPT_ERROR;
done:
#ifdef CLEAN_STACK
   zeromem(buf, sizeof(buf));
#endif
   return res;
}

int kr_make_key(pk_key *pk, prng_state *prng, int wprng, 
                int system, int keysize, const unsigned char *name,
                const unsigned char *email, const unsigned char *description)
{
   _pk_key key;
   int key_type, errno;

   _ARGCHK(pk != NULL);
   _ARGCHK(name != NULL);
   _ARGCHK(email != NULL);
   _ARGCHK(description != NULL);

   /* valid PRNG? */
   if ((errno = prng_is_valid(wprng)) != CRYPT_OK) {
      return errno;
   }

   /* make the key first */
   zeromem(&key, sizeof(key));
   switch (system) {
      case RSA_KEY: 
          if ((errno = rsa_make_key(prng, wprng, keysize, 65537, &(key.rsa))) != CRYPT_OK) {
             return errno;
          }
          key_type = key.rsa.type;
          break;
      case DH_KEY: 
          if ((errno = dh_make_key(prng, wprng, keysize, &(key.dh))) != CRYPT_OK) {
             return errno;
          }
          key_type = key.dh.type;
          break;
      case ECC_KEY: 
          if ((errno = ecc_make_key(prng, wprng, keysize, &(key.ecc))) != CRYPT_OK) {
             return errno;
          }
          key_type = key.ecc.type;
          break;
      default:
          return CRYPT_PK_INVALID_SYSTEM;
   }

   /* now add the key */
   if ((errno = kr_add(pk, key_type, system, name, email, description, &key)) != CRYPT_OK) {
      return errno;
   }

#ifdef CLEAN_STACK
   zeromem(&key, sizeof(key));
#endif
   return CRYPT_OK;
}

int kr_encrypt_key(pk_key *pk, unsigned long ID, 
                   const unsigned char *in, unsigned long inlen,
                   unsigned char *out, unsigned long *outlen,
                   prng_state *prng, int wprng, int hash)
{
   unsigned char buf[8192];
   unsigned long len;
   pk_key *kr;
   int errno;

   _ARGCHK(pk != NULL);
   _ARGCHK(in != NULL);
   _ARGCHK(out != NULL);
   _ARGCHK(outlen != NULL);

   /* find the key */
   kr = kr_find(pk, ID);
   if (kr == NULL) {
      return CRYPT_PK_NOT_FOUND;
   }

   /* store the header */
   memcpy(buf, enc_magic, 4);

   /* now store the ID */
   STORE32L(kr->ID,buf+4);

   /* now encrypt it */
   len = sizeof(buf)-8;
   switch (kr->system) {
        case RSA_KEY:
            if ((errno = rsa_encrypt_key(in, inlen, buf+8, &len, prng, wprng, &(kr->key.rsa))) != CRYPT_OK) {
               return errno;
            }
            break;
        case DH_KEY:
            if ((errno = dh_encrypt_key(in, inlen, buf+8, &len, prng, wprng, hash, &(kr->key.dh))) != CRYPT_OK) {
               return errno;
            }
            break;
        case ECC_KEY:
            if ((errno = ecc_encrypt_key(in, inlen, buf+8, &len, prng, wprng, hash, &(kr->key.ecc))) != CRYPT_OK) {
               return errno;
            }
            break;
    }
    len += 8;

    if (len > *outlen) {
       #ifdef CLEAN_STACK
           zeromem(buf, sizeof(buf));
       #endif
       return CRYPT_BUFFER_OVERFLOW;
    } else {
       memcpy(out, buf, len);
       #ifdef CLEAN_STACK
           zeromem(buf, sizeof(buf));
       #endif
       *outlen = len;
       return CRYPT_OK;
    }
}

int kr_decrypt_key(pk_key *pk, const unsigned char *in,
                   unsigned char *out, unsigned long *outlen)
{
   unsigned char buf[8192];
   unsigned long len, ID;
   pk_key *kr;
   int errno;

   _ARGCHK(pk != NULL);
   _ARGCHK(in != NULL);
   _ARGCHK(out != NULL);
   _ARGCHK(outlen != NULL);

   /* check magic header */
   if (memcmp(in, enc_magic, 4)) {
      return CRYPT_INVALID_PACKET;
   }

   /* now try to find key */
   LOAD32L(ID,in+4);
   kr = kr_find(pk, ID);
   if (kr == NULL) {
      return CRYPT_PK_NOT_FOUND;
   }

   /* is it public? */
   if (kr->key_type == PK_PUBLIC) {
      return CRYPT_PK_NOT_PRIVATE;
   }

   /* now try and decrypt it */
   len = sizeof(buf);
   switch (kr->system) {
       case RSA_KEY:
           if ((errno = rsa_decrypt_key(in+8, buf, &len, &(kr->key.rsa))) != CRYPT_OK) {
              return errno;
           }
           break;
       case DH_KEY:
           if ((errno = dh_decrypt_key(in+8, buf, &len, &(kr->key.dh))) != CRYPT_OK) {
              return errno;
           }
           break;
       case ECC_KEY:
           if ((errno = ecc_decrypt_key(in+8, buf, &len, &(kr->key.ecc))) != CRYPT_OK) {
              return errno;
           }
           break;
   }

    if (len > *outlen) {
       #ifdef CLEAN_STACK
           zeromem(buf, sizeof(buf));
       #endif
       return CRYPT_BUFFER_OVERFLOW;
    } else {
       memcpy(out, buf, len);
       #ifdef CLEAN_STACK
           zeromem(buf, sizeof(buf));
       #endif
       *outlen = len;
       return CRYPT_OK;
    }
}

int kr_sign_hash(pk_key *pk, unsigned long ID, 
                 const unsigned char *in, unsigned long inlen,
                 unsigned char *out, unsigned long *outlen,
                 prng_state *prng, int wprng)
{
   unsigned char buf[8192];
   unsigned long len;
   pk_key *kr;
   int errno;

   _ARGCHK(pk != NULL);
   _ARGCHK(in != NULL);
   _ARGCHK(out != NULL);
   _ARGCHK(outlen != NULL);

   /* find the key */
   kr = kr_find(pk, ID);
   if (kr == NULL) {
      return CRYPT_PK_NOT_FOUND;
   }

   /* is it public? */
   if (kr->key_type == PK_PUBLIC) {
      return CRYPT_PK_NOT_PRIVATE;
   }

   /* store the header */
   memcpy(buf, sign_magic, 4);

   /* now store the ID */
   STORE32L(kr->ID,buf+4);

   /* now sign it */
   len = sizeof(buf)-12;
   switch (kr->system) {
        case RSA_KEY:
            if ((errno = rsa_sign_hash(in, inlen, buf+12, &len, &(kr->key.rsa))) != CRYPT_OK) {
               return errno;
            }
            break;
        case DH_KEY:
            if ((errno = dh_sign_hash(in, inlen, buf+12, &len, prng, wprng, &(kr->key.dh))) != CRYPT_OK) {
               return errno;
            }
            break;
        case ECC_KEY:
            if ((errno = ecc_sign_hash(in, inlen, buf+12, &len, prng, wprng, &(kr->key.ecc))) != CRYPT_OK) {
               return errno;
            }
            break;
    }
    STORE32L(inlen,buf+8);
    len += 12;

    if (len > *outlen) {
       #ifdef CLEAN_STACK
           zeromem(buf, sizeof(buf));
       #endif
       return CRYPT_BUFFER_OVERFLOW;
    } else {
       memcpy(out, buf, len);
       #ifdef CLEAN_STACK
           zeromem(buf, sizeof(buf));
       #endif
       *outlen = len;
       return CRYPT_OK;
    }
}

int kr_verify_hash(pk_key *pk, const unsigned char *in, const unsigned char *hash, 
                   unsigned long hashlen, int *stat)
{
   unsigned long inlen, ID;
   pk_key *kr;
   int errno;

   _ARGCHK(pk != NULL);
   _ARGCHK(in != NULL);
   _ARGCHK(hash != NULL);
   _ARGCHK(stat != NULL);

   /* default to not match */
   *stat = 0;

   /* check magic header */
   if (memcmp(in, sign_magic, 4)) {
      return CRYPT_INVALID_PACKET;
   }

   /* now try to find key */
   LOAD32L(ID,in+4);
   kr = kr_find(pk, ID);
   if (kr == NULL) {
      return CRYPT_PK_NOT_FOUND;
   }

   /* now try and verify it */
   LOAD32L(inlen,in+8);         /* this is the length of the original inlen */
   if (inlen != hashlen) {      /* size doesn't match means the signature is invalid */
      return CRYPT_OK;
   }

   switch (kr->system) {
       case RSA_KEY:
           if ((errno = rsa_verify_hash(in+12, hash, stat, &(kr->key.rsa))) != CRYPT_OK) {
              return errno;
           }
           break;
       case DH_KEY:
           if ((errno = dh_verify_hash(in+12, hash, inlen, stat, &(kr->key.dh))) != CRYPT_OK) {
              return errno;
           }
           break;
       case ECC_KEY:
           if ((errno = ecc_verify_hash(in+12, hash, inlen, stat, &(kr->key.ecc))) != CRYPT_OK) {
              return errno;
           }
           break;
   }
   return CRYPT_OK;
}

int kr_fingerprint(pk_key *pk, unsigned long ID, int hash,
                   unsigned char *out, unsigned long *outlen)
{
   unsigned char buf[8192];
   unsigned long len;
   int errno;

   _ARGCHK(pk != NULL);
   _ARGCHK(out != NULL);
   _ARGCHK(outlen != NULL);

   /* valid hash? */
   if ((errno = hash_is_valid(hash)) != CRYPT_OK) {
      return errno;
   }

   len = sizeof(buf);
   if ((errno = kr_export(pk, ID, PK_PUBLIC, buf, &len)) != CRYPT_OK) {
      return errno;
   }
   
   /* now hash it */
   if ((errno = hash_memory(hash, buf, len, out, outlen)) != CRYPT_OK) {
      return errno;
   }

#ifdef CLEAN_STACK
   zeromem(buf, sizeof(buf));
#endif
   return CRYPT_OK;
}

#endif