rename ecc_set_dp (+related) to ecc_set_curve

src/headers/tomcrypt_pk.h

@@ -252,7 +252,7 @@ void ecc_sizes(int *low, int *high);
 int  ecc_get_size(const ecc_key *key);
 
 int  ecc_get_curve(const char* name_or_oid, const ltc_ecc_curve** cu);
-int  ecc_set_dp(const ltc_ecc_curve *cu, ecc_key *key);
+int  ecc_set_curve(const ltc_ecc_curve *cu, ecc_key *key);
 int  ecc_generate_key(prng_state *prng, int wprng, ecc_key *key);
 int  ecc_set_key(const unsigned char *in, unsigned long inlen, int type, ecc_key *key);
 int  ecc_get_key(unsigned char *out, unsigned long *outlen, int type, const ecc_key *key);

src/headers/tomcrypt_private.h

@@ -192,9 +192,9 @@ int dh_check_pubkey(const dh_key *key);
 
 /* ---- ECC Routines ---- */
 #ifdef LTC_MECC
-int ecc_set_dp_from_mpis(void *a, void *b, void *prime, void *order, void *gx, void *gy, unsigned long cofactor, ecc_key *key);
-int ecc_copy_dp(const ecc_key *srckey, ecc_key *key);
-int ecc_set_dp_by_size(int size, ecc_key *key);
+int ecc_set_curve_from_mpis(void *a, void *b, void *prime, void *order, void *gx, void *gy, unsigned long cofactor, ecc_key *key);
+int ecc_copy_curve(const ecc_key *srckey, ecc_key *key);
+int ecc_set_curve_by_size(int size, ecc_key *key);
 int ecc_import_subject_public_key_info(const unsigned char *in, unsigned long inlen, ecc_key *key);
 
 /* low level functions */

src/pk/ecc/ecc_ansi_x963_import.c

@@ -41,11 +41,11 @@ int ecc_ansi_x963_import_ex(const unsigned char *in, unsigned long inlen, ecc_ke
    /* initialize key->dp */
    if (cu == NULL) {
       /* this case works only for uncompressed public keys  */
-      if ((err = ecc_set_dp_by_size((inlen-1)>>1, key)) != CRYPT_OK)                { return err; }
+      if ((err = ecc_set_curve_by_size((inlen-1)>>1, key)) != CRYPT_OK)             { return err; }
    }
    else {
       /* this one works for both compressed / uncompressed pubkeys */
-      if ((err = ecc_set_dp(cu, key)) != CRYPT_OK)                                  { return err; }
+      if ((err = ecc_set_curve(cu, key)) != CRYPT_OK)                               { return err; }
    }
 
    /* load public key */

src/pk/ecc/ecc_decrypt_key.c

@@ -85,7 +85,7 @@ int ecc_decrypt_key(const unsigned char *in,  unsigned long  inlen,
    }
 
    /* import ECC key from packet */
-   if ((err = ecc_copy_dp(key, &pubkey)) != CRYPT_OK) { goto LBL_ERR; }
+   if ((err = ecc_copy_curve(key, &pubkey)) != CRYPT_OK) { goto LBL_ERR; }
    if ((err = ecc_set_key(decode[1].data, decode[1].size, PK_PUBLIC, &pubkey)) != CRYPT_OK) { goto LBL_ERR; }
 
    /* make shared key */

src/pk/ecc/ecc_encrypt_key.c

@@ -52,7 +52,7 @@ int ecc_encrypt_key(const unsigned char *in,   unsigned long inlen,
     }
 
     /* make a random key and export the public copy */
-    if ((err = ecc_copy_dp(key, &pubkey)) != CRYPT_OK) { return err; }
+    if ((err = ecc_copy_curve(key, &pubkey)) != CRYPT_OK) { return err; }
     if ((err = ecc_generate_key(prng, wprng, &pubkey)) != CRYPT_OK) { return err; }
 
     pub_expt   = XMALLOC(ECC_BUF_SIZE);

src/pk/ecc/ecc_import.c

@@ -56,9 +56,9 @@ int ecc_import_ex(const unsigned char *in, unsigned long inlen, ecc_key *key, co
 
    /* allocate & initialize the key */
    if (cu == NULL) {
-      if ((err = ecc_set_dp_by_size(key_size, key)) != CRYPT_OK) { goto done; }
+      if ((err = ecc_set_curve_by_size(key_size, key)) != CRYPT_OK) { goto done; }
    } else {
-      if ((err = ecc_set_dp(cu, key)) != CRYPT_OK)               { goto done; }
+      if ((err = ecc_set_curve(cu, key)) != CRYPT_OK)               { goto done; }
    }
 
    if (flags[0] == 1) {

src/pk/ecc/ecc_import_openssl.c

@@ -37,7 +37,7 @@ static int _ecc_import_private_with_oid(const unsigned char *in, unsigned long i
       len = sizeof(OID);
       if ((err = pk_oid_num_to_str(curveoid, custom[0].size, OID, &len)) != CRYPT_OK) { goto error; }
       if ((err = ecc_get_curve(OID, &curve)) != CRYPT_OK)                             { goto error; }
-      if ((err = ecc_set_dp(curve, key)) != CRYPT_OK)                                 { goto error; }
+      if ((err = ecc_set_curve(curve, key)) != CRYPT_OK)                              { goto error; }
       /* load private+public key */
       err = ecc_set_key(bin_k, seq_priv[1].size, PK_PRIVATE, key);
    }
@@ -96,7 +96,7 @@ static int _ecc_import_private_with_curve(const unsigned char *in, unsigned long
       if ((err = mp_read_unsigned_bin(b, bin_b, len_b)) != CRYPT_OK)                           { goto error; }
       if ((err = ltc_ecc_import_point(bin_g, len_g, prime, a, b, gx, gy)) != CRYPT_OK)         { goto error; }
       /* load curve parameters */
-      if ((err = ecc_set_dp_from_mpis(a, b, prime, order, gx, gy, cofactor, key)) != CRYPT_OK) { goto error; }
+      if ((err = ecc_set_curve_from_mpis(a, b, prime, order, gx, gy, cofactor, key)) != CRYPT_OK) { goto error; }
       /* load private+public key */
       err = ecc_set_key(bin_k, len_k, PK_PRIVATE, key);
    }

src/pk/ecc/ecc_import_x509.c

@@ -28,7 +28,7 @@ static int _ecc_import_x509_with_oid(const unsigned char *in, unsigned long inle
       len = sizeof(OID);
       if ((err = pk_oid_num_to_str(curveoid, len_oid, OID, &len)) != CRYPT_OK) { goto error; }
       if ((err = ecc_get_curve(OID, &curve)) != CRYPT_OK)                      { goto error; }
-      if ((err = ecc_set_dp(curve, key)) != CRYPT_OK)                          { goto error; }
+      if ((err = ecc_set_curve(curve, key)) != CRYPT_OK)                       { goto error; }
       /* load public key */
       err = ecc_set_key(bin_xy, len_xy, PK_PUBLIC, key);
    }
@@ -80,7 +80,7 @@ static int _ecc_import_x509_with_curve(const unsigned char *in, unsigned long in
       if ((err = mp_read_unsigned_bin(b, bin_b, len_b)) != CRYPT_OK)                           { goto error; }
       if ((err = ltc_ecc_import_point(bin_g, len_g, prime, a, b, gx, gy)) != CRYPT_OK)         { goto error; }
       /* load curve parameters */
-      if ((err = ecc_set_dp_from_mpis(a, b, prime, order, gx, gy, cofactor, key)) != CRYPT_OK) { goto error; }
+      if ((err = ecc_set_curve_from_mpis(a, b, prime, order, gx, gy, cofactor, key)) != CRYPT_OK) { goto error; }
       /* load public key */
       err = ecc_set_key(bin_xy, len_xy, PK_PUBLIC, key);
    }

src/pk/ecc/ecc_make_key.c

@@ -28,15 +28,15 @@ int ecc_make_key(prng_state *prng, int wprng, int keysize, ecc_key *key)
 {
    int err;
 
-   if ((err = ecc_set_dp_by_size(keysize, key)) != CRYPT_OK)   { return err; }
-   if ((err = ecc_generate_key(prng, wprng, key)) != CRYPT_OK) { return err; }
+   if ((err = ecc_set_curve_by_size(keysize, key)) != CRYPT_OK) { return err; }
+   if ((err = ecc_generate_key(prng, wprng, key)) != CRYPT_OK)  { return err; }
    return CRYPT_OK;
 }
 
 int ecc_make_key_ex(prng_state *prng, int wprng, ecc_key *key, const ltc_ecc_curve *cu)
 {
    int err;
-   if ((err = ecc_set_dp(cu, key)) != CRYPT_OK)                { return err; }
+   if ((err = ecc_set_curve(cu, key)) != CRYPT_OK)             { return err; }
    if ((err = ecc_generate_key(prng, wprng, key)) != CRYPT_OK) { return err; }
    return CRYPT_OK;
 }

src/pk/ecc/ecc_set_dp.c → src/pk/ecc/ecc_set_curve.c

@@ -11,7 +11,7 @@
 
 #ifdef LTC_MECC
 
-int ecc_set_dp(const ltc_ecc_curve *cu, ecc_key *key)
+int ecc_set_curve(const ltc_ecc_curve *cu, ecc_key *key)
 {
    int err;
 
@@ -47,7 +47,7 @@ error:
    return err;
 }
 
-int ecc_set_dp_by_size(int size, ecc_key *key)
+int ecc_set_curve_by_size(int size, ecc_key *key)
 {
    const ltc_ecc_curve *cu = NULL;
    int err = CRYPT_ERROR;
@@ -78,7 +78,7 @@ int ecc_set_dp_by_size(int size, ecc_key *key)
       err = ecc_get_curve("SECP521R1", &cu);
    }
 
-   if (err == CRYPT_OK && cu != NULL) return ecc_set_dp(cu, key);
+   if (err == CRYPT_OK && cu != NULL) return ecc_set_curve(cu, key);
 
    return CRYPT_INVALID_ARG;
 }

src/pk/ecc/ecc_set_dp_internal.c → src/pk/ecc/ecc_set_curve_internal.c

@@ -42,7 +42,7 @@ static void _ecc_oid_lookup(ecc_key *key)
    }
 }
 
-int ecc_copy_dp(const ecc_key *srckey, ecc_key *key)
+int ecc_copy_curve(const ecc_key *srckey, ecc_key *key)
 {
    unsigned long i;
    int err;
@@ -82,7 +82,7 @@ error:
    return err;
 }
 
-int ecc_set_dp_from_mpis(void *a, void *b, void *prime, void *order, void *gx, void *gy, unsigned long cofactor, ecc_key *key)
+int ecc_set_curve_from_mpis(void *a, void *b, void *prime, void *order, void *gx, void *gy, unsigned long cofactor, ecc_key *key)
 {
    int err;
 

src/pk/ecc/ecc_sign_hash.c

@@ -63,7 +63,7 @@ static int _ecc_sign_hash(const unsigned char *in,  unsigned long inlen,
 
    /* make up a key and export the public copy */
    do {
-      if ((err = ecc_copy_dp(key, &pubkey)) != CRYPT_OK)                   { goto errnokey; }
+      if ((err = ecc_copy_curve(key, &pubkey)) != CRYPT_OK)                { goto errnokey; }
       if ((err = ecc_generate_key(prng, wprng, &pubkey)) != CRYPT_OK)      { goto errnokey; }
 
       /* find r = x1 mod n */

tests/ecc_test.c

@@ -464,14 +464,14 @@ int _ecc_new_api(void)
       ecc_free(&pubkey);
 
       /* generate new key */
-      DO(ecc_set_dp(dp, &key));
+      DO(ecc_set_curve(dp, &key));
       DO(ecc_generate_key(&yarrow_prng, find_prng ("yarrow"), &key));
       len = sizeof(buf);
       DO(ecc_get_key(buf, &len, PK_PRIVATE, &key));
       ecc_free(&key);
 
       /* load exported private key */
-      DO(ecc_set_dp(dp, &privkey));
+      DO(ecc_set_curve(dp, &privkey));
       DO(ecc_set_key(buf, len, PK_PRIVATE, &privkey));
 
 #ifndef USE_TFM
@@ -481,7 +481,7 @@ int _ecc_new_api(void)
       DO(ecc_get_key(buf, &len, PK_PUBLIC|PK_COMPRESSED, &privkey));
       if (len != 1 + (unsigned)ecc_get_size(&privkey)) return CRYPT_FAIL_TESTVECTOR;
       /* load exported public+compressed key */
-      DO(ecc_set_dp(dp, &pubkey));
+      DO(ecc_set_curve(dp, &pubkey));
       DO(ecc_set_key(buf, len, PK_PUBLIC, &pubkey));
       ecc_free(&pubkey);
 #endif
@@ -491,7 +491,7 @@ int _ecc_new_api(void)
       DO(ecc_get_key(buf, &len, PK_PUBLIC, &privkey));
       if (len != 1 + 2 * (unsigned)ecc_get_size(&privkey)) return CRYPT_FAIL_TESTVECTOR;
       /* load exported public key */
-      DO(ecc_set_dp(dp, &pubkey));
+      DO(ecc_set_curve(dp, &pubkey));
       DO(ecc_set_key(buf, len, PK_PUBLIC, &pubkey));
 
       /* test signature */
@@ -801,15 +801,15 @@ int _ecc_import_export(void) {
    DO(ecc_get_curve("SECP256K1", &cu));
 
    /* import - raw keys */
-   DO(ecc_set_dp(cu, &key));
+   DO(ecc_set_curve(cu, &key));
    DO(ecc_set_key(raw_pri, sizeof(raw_pri),  PK_PRIVATE, &key));
    DO(_ecc_key_cmp(PK_PRIVATE, &pri, &key));
    ecc_free(&key);
-   DO(ecc_set_dp(cu, &key));
+   DO(ecc_set_curve(cu, &key));
    DO(ecc_set_key(raw_pub, sizeof(raw_pub),  PK_PUBLIC,  &key));
    DO(_ecc_key_cmp(PK_PUBLIC, &pub, &key));
    ecc_free(&key);
-   DO(ecc_set_dp(cu, &key));
+   DO(ecc_set_curve(cu, &key));
    DO(ecc_set_key(raw_pubc, sizeof(raw_pubc), PK_PUBLIC,  &key));
    DO(_ecc_key_cmp(PK_PUBLIC, &pub, &key));
    ecc_free(&key);