Commit 26e789fb authored by Nick Mathewson's avatar Nick Mathewson 🥄
Browse files

Rename nonconformant identifiers.

Fixes bug 4893.

These changes are pure mechanical, and were generated with this
perl script:

  /usr/bin/perl -w -i.bak -p

  s/crypto_pk_env_t/crypto_pk_t/g;
  s/crypto_dh_env_t/crypto_dh_t/g;
  s/crypto_cipher_env_t/crypto_cipher_t/g;
  s/crypto_digest_env_t/crypto_digest_t/g;

  s/aes_free_cipher/aes_cipher_free/g;
  s/crypto_free_cipher_env/crypto_cipher_free/g;
  s/crypto_free_digest_env/crypto_digest_free/g;
  s/crypto_free_pk_env/crypto_pk_free/g;

  s/_crypto_dh_env_get_dh/_crypto_dh_get_dh/g;
  s/_crypto_new_pk_env_rsa/_crypto_new_pk_from_rsa/g;
  s/_crypto_pk_env_get_evp_pkey/_crypto_pk_get_evp_pkey/g;
  s/_crypto_pk_env_get_rsa/_crypto_pk_get_rsa/g;

  s/crypto_new_cipher_env/crypto_cipher_new/g;
  s/crypto_new_digest_env/crypto_digest_new/g;
  s/crypto_new_digest256_env/crypto_digest256_new/g;
  s/crypto_new_pk_env/crypto_pk_new/g;

  s/crypto_create_crypto_env/crypto_cipher_new/g;

  s/connection_create_listener/connection_listener_new/g;
  s/smartlist_create/smartlist_new/g;
  s/transport_create/transport_new/g;
parent d1b40cf2
o Code simplifications and refactorings:
- Rename a handful of old identifiers, mostly related to crypto
structures and crypto functions. By convention, our "create an
object" functions are called "type_new()", our "free an object"
functions are called "type_free()", and our types indicate that
they are types only with a final "_t". But a handful of older
types and functions broke these rules, with function names like
"type_create" or "subsystem_op_type", or with type names like
type_env_t.
...@@ -1125,7 +1125,7 @@ get_interface_addresses_raw(int severity) ...@@ -1125,7 +1125,7 @@ get_interface_addresses_raw(int severity)
return NULL; return NULL;
} }
result = smartlist_create(); result = smartlist_new();
for (i = ifa; i; i = i->ifa_next) { for (i = ifa; i; i = i->ifa_next) {
tor_addr_t tmp; tor_addr_t tmp;
if (!i->ifa_addr) if (!i->ifa_addr)
...@@ -1184,7 +1184,7 @@ get_interface_addresses_raw(int severity) ...@@ -1184,7 +1184,7 @@ get_interface_addresses_raw(int severity)
goto done; goto done;
} }
result = smartlist_create(); result = smartlist_new();
for (address = addresses; address; address = address->Next) { for (address = addresses; address; address = address->Next) {
IP_ADAPTER_UNICAST_ADDRESS *a; IP_ADAPTER_UNICAST_ADDRESS *a;
for (a = address->FirstUnicastAddress; a; a = a->Next) { for (a = address->FirstUnicastAddress; a; a = a->Next) {
...@@ -1224,7 +1224,7 @@ get_interface_addresses_raw(int severity) ...@@ -1224,7 +1224,7 @@ get_interface_addresses_raw(int severity)
goto done; goto done;
} }
close(fd); close(fd);
result = smartlist_create(); result = smartlist_new();
if (ifc.ifc_len < sz) if (ifc.ifc_len < sz)
sz = ifc.ifc_len; sz = ifc.ifc_len;
n = sz / sizeof(struct ifreq); n = sz / sizeof(struct ifreq);
......
...@@ -264,7 +264,7 @@ aes_set_key(aes_cnt_cipher_t *cipher, const char *key, int key_bits) ...@@ -264,7 +264,7 @@ aes_set_key(aes_cnt_cipher_t *cipher, const char *key, int key_bits)
/** Release storage held by <b>cipher</b> /** Release storage held by <b>cipher</b>
*/ */
void void
aes_free_cipher(aes_cnt_cipher_t *cipher) aes_cipher_free(aes_cnt_cipher_t *cipher)
{ {
if (!cipher) if (!cipher)
return; return;
......
...@@ -17,7 +17,7 @@ struct aes_cnt_cipher; ...@@ -17,7 +17,7 @@ struct aes_cnt_cipher;
typedef struct aes_cnt_cipher aes_cnt_cipher_t; typedef struct aes_cnt_cipher aes_cnt_cipher_t;
aes_cnt_cipher_t* aes_new_cipher(void); aes_cnt_cipher_t* aes_new_cipher(void);
void aes_free_cipher(aes_cnt_cipher_t *cipher); void aes_cipher_free(aes_cnt_cipher_t *cipher);
void aes_set_key(aes_cnt_cipher_t *cipher, const char *key, int key_bits); void aes_set_key(aes_cnt_cipher_t *cipher, const char *key, int key_bits);
void aes_crypt(aes_cnt_cipher_t *cipher, const char *input, size_t len, void aes_crypt(aes_cnt_cipher_t *cipher, const char *input, size_t len,
char *output); char *output);
......
...@@ -1352,7 +1352,7 @@ log_credential_status(void) ...@@ -1352,7 +1352,7 @@ log_credential_status(void)
} else { } else {
int i, retval = 0; int i, retval = 0;
char *s = NULL; char *s = NULL;
smartlist_t *elts = smartlist_create(); smartlist_t *elts = smartlist_new();
for (i = 0; i<ngids; i++) { for (i = 0; i<ngids; i++) {
smartlist_add_asprintf(elts, "%u", (unsigned)sup_gids[i]); smartlist_add_asprintf(elts, "%u", (unsigned)sup_gids[i]);
...@@ -2587,7 +2587,7 @@ tor_cond_new(void) ...@@ -2587,7 +2587,7 @@ tor_cond_new(void)
{ {
tor_cond_t *cond = tor_malloc_zero(sizeof(tor_cond_t)); tor_cond_t *cond = tor_malloc_zero(sizeof(tor_cond_t));
InitializeCriticalSection(&cond->mutex); InitializeCriticalSection(&cond->mutex);
cond->events = smartlist_create(); cond->events = smartlist_new();
return cond; return cond;
} }
void void
......
...@@ -29,7 +29,7 @@ ...@@ -29,7 +29,7 @@
/** Allocate and return an empty smartlist. /** Allocate and return an empty smartlist.
*/ */
smartlist_t * smartlist_t *
smartlist_create(void) smartlist_new(void)
{ {
smartlist_t *sl = tor_malloc(sizeof(smartlist_t)); smartlist_t *sl = tor_malloc(sizeof(smartlist_t));
sl->num_used = 0; sl->num_used = 0;
......
...@@ -26,7 +26,7 @@ typedef struct smartlist_t { ...@@ -26,7 +26,7 @@ typedef struct smartlist_t {
/** @} */ /** @} */
} smartlist_t; } smartlist_t;
smartlist_t *smartlist_create(void); smartlist_t *smartlist_new(void);
void smartlist_free(smartlist_t *sl); void smartlist_free(smartlist_t *sl);
void smartlist_clear(smartlist_t *sl); void smartlist_clear(smartlist_t *sl);
void smartlist_add(smartlist_t *sl, void *element); void smartlist_add(smartlist_t *sl, void *element);
......
This diff is collapsed.
...@@ -107,10 +107,10 @@ typedef struct { ...@@ -107,10 +107,10 @@ typedef struct {
char d[N_DIGEST_ALGORITHMS][DIGEST256_LEN]; char d[N_DIGEST_ALGORITHMS][DIGEST256_LEN];
} digests_t; } digests_t;
typedef struct crypto_pk_env_t crypto_pk_env_t; typedef struct crypto_pk_t crypto_pk_t;
typedef struct crypto_cipher_env_t crypto_cipher_env_t; typedef struct crypto_cipher_t crypto_cipher_t;
typedef struct crypto_digest_env_t crypto_digest_env_t; typedef struct crypto_digest_t crypto_digest_t;
typedef struct crypto_dh_env_t crypto_dh_env_t; typedef struct crypto_dh_t crypto_dh_t;
/* global state */ /* global state */
int crypto_global_init(int hardwareAccel, int crypto_global_init(int hardwareAccel,
...@@ -120,93 +120,93 @@ void crypto_thread_cleanup(void); ...@@ -120,93 +120,93 @@ void crypto_thread_cleanup(void);
int crypto_global_cleanup(void); int crypto_global_cleanup(void);
/* environment setup */ /* environment setup */
crypto_pk_env_t *crypto_new_pk_env(void); crypto_pk_t *crypto_pk_new(void);
void crypto_free_pk_env(crypto_pk_env_t *env); void crypto_pk_free(crypto_pk_t *env);
void crypto_set_tls_dh_prime(const char *dynamic_dh_modulus_fname); void crypto_set_tls_dh_prime(const char *dynamic_dh_modulus_fname);
/* convenience function: wraps crypto_create_crypto_env, set_key, and init. */ /* convenience function: wraps crypto_cipher_new, set_key, and init. */
crypto_cipher_env_t *crypto_create_init_cipher(const char *key, crypto_cipher_t *crypto_create_init_cipher(const char *key,
int encrypt_mode); int encrypt_mode);
crypto_cipher_env_t *crypto_new_cipher_env(void); crypto_cipher_t *crypto_cipher_new(void);
void crypto_free_cipher_env(crypto_cipher_env_t *env); void crypto_cipher_free(crypto_cipher_t *env);
/* public key crypto */ /* public key crypto */
int crypto_pk_generate_key_with_bits(crypto_pk_env_t *env, int bits); int crypto_pk_generate_key_with_bits(crypto_pk_t *env, int bits);
#define crypto_pk_generate_key(env) \ #define crypto_pk_generate_key(env) \
crypto_pk_generate_key_with_bits((env), (PK_BYTES*8)) crypto_pk_generate_key_with_bits((env), (PK_BYTES*8))
int crypto_pk_read_private_key_from_filename(crypto_pk_env_t *env, int crypto_pk_read_private_key_from_filename(crypto_pk_t *env,
const char *keyfile); const char *keyfile);
int crypto_pk_write_public_key_to_string(crypto_pk_env_t *env, int crypto_pk_write_public_key_to_string(crypto_pk_t *env,
char **dest, size_t *len); char **dest, size_t *len);
int crypto_pk_write_private_key_to_string(crypto_pk_env_t *env, int crypto_pk_write_private_key_to_string(crypto_pk_t *env,
char **dest, size_t *len); char **dest, size_t *len);
int crypto_pk_read_public_key_from_string(crypto_pk_env_t *env, int crypto_pk_read_public_key_from_string(crypto_pk_t *env,
const char *src, size_t len); const char *src, size_t len);
int crypto_pk_read_private_key_from_string(crypto_pk_env_t *env, int crypto_pk_read_private_key_from_string(crypto_pk_t *env,
const char *s, ssize_t len); const char *s, ssize_t len);
int crypto_pk_write_private_key_to_filename(crypto_pk_env_t *env, int crypto_pk_write_private_key_to_filename(crypto_pk_t *env,
const char *fname); const char *fname);
int crypto_pk_check_key(crypto_pk_env_t *env); int crypto_pk_check_key(crypto_pk_t *env);
int crypto_pk_cmp_keys(crypto_pk_env_t *a, crypto_pk_env_t *b); int crypto_pk_cmp_keys(crypto_pk_t *a, crypto_pk_t *b);
size_t crypto_pk_keysize(crypto_pk_env_t *env); size_t crypto_pk_keysize(crypto_pk_t *env);
int crypto_pk_num_bits(crypto_pk_env_t *env); int crypto_pk_num_bits(crypto_pk_t *env);
crypto_pk_env_t *crypto_pk_dup_key(crypto_pk_env_t *orig); crypto_pk_t *crypto_pk_dup_key(crypto_pk_t *orig);
crypto_pk_env_t *crypto_pk_copy_full(crypto_pk_env_t *orig); crypto_pk_t *crypto_pk_copy_full(crypto_pk_t *orig);
int crypto_pk_key_is_private(const crypto_pk_env_t *key); int crypto_pk_key_is_private(const crypto_pk_t *key);
int crypto_pk_public_exponent_ok(crypto_pk_env_t *env); int crypto_pk_public_exponent_ok(crypto_pk_t *env);
int crypto_pk_public_encrypt(crypto_pk_env_t *env, char *to, size_t tolen, int crypto_pk_public_encrypt(crypto_pk_t *env, char *to, size_t tolen,
const char *from, size_t fromlen, int padding); const char *from, size_t fromlen, int padding);
int crypto_pk_private_decrypt(crypto_pk_env_t *env, char *to, size_t tolen, int crypto_pk_private_decrypt(crypto_pk_t *env, char *to, size_t tolen,
const char *from, size_t fromlen, const char *from, size_t fromlen,
int padding, int warnOnFailure); int padding, int warnOnFailure);
int crypto_pk_public_checksig(crypto_pk_env_t *env, char *to, size_t tolen, int crypto_pk_public_checksig(crypto_pk_t *env, char *to, size_t tolen,
const char *from, size_t fromlen); const char *from, size_t fromlen);
int crypto_pk_public_checksig_digest(crypto_pk_env_t *env, const char *data, int crypto_pk_public_checksig_digest(crypto_pk_t *env, const char *data,
size_t datalen, const char *sig, size_t siglen); size_t datalen, const char *sig, size_t siglen);
int crypto_pk_private_sign(crypto_pk_env_t *env, char *to, size_t tolen, int crypto_pk_private_sign(crypto_pk_t *env, char *to, size_t tolen,
const char *from, size_t fromlen); const char *from, size_t fromlen);
int crypto_pk_private_sign_digest(crypto_pk_env_t *env, char *to, size_t tolen, int crypto_pk_private_sign_digest(crypto_pk_t *env, char *to, size_t tolen,
const char *from, size_t fromlen); const char *from, size_t fromlen);
int crypto_pk_public_hybrid_encrypt(crypto_pk_env_t *env, char *to, int crypto_pk_public_hybrid_encrypt(crypto_pk_t *env, char *to,
size_t tolen, size_t tolen,
const char *from, size_t fromlen, const char *from, size_t fromlen,
int padding, int force); int padding, int force);
int crypto_pk_private_hybrid_decrypt(crypto_pk_env_t *env, char *to, int crypto_pk_private_hybrid_decrypt(crypto_pk_t *env, char *to,
size_t tolen, size_t tolen,
const char *from, size_t fromlen, const char *from, size_t fromlen,
int padding, int warnOnFailure); int padding, int warnOnFailure);
int crypto_pk_asn1_encode(crypto_pk_env_t *pk, char *dest, size_t dest_len); int crypto_pk_asn1_encode(crypto_pk_t *pk, char *dest, size_t dest_len);
crypto_pk_env_t *crypto_pk_asn1_decode(const char *str, size_t len); crypto_pk_t *crypto_pk_asn1_decode(const char *str, size_t len);
int crypto_pk_get_digest(crypto_pk_env_t *pk, char *digest_out); int crypto_pk_get_digest(crypto_pk_t *pk, char *digest_out);
int crypto_pk_get_all_digests(crypto_pk_env_t *pk, digests_t *digests_out); int crypto_pk_get_all_digests(crypto_pk_t *pk, digests_t *digests_out);
int crypto_pk_get_fingerprint(crypto_pk_env_t *pk, char *fp_out,int add_space); int crypto_pk_get_fingerprint(crypto_pk_t *pk, char *fp_out,int add_space);
int crypto_pk_check_fingerprint_syntax(const char *s); int crypto_pk_check_fingerprint_syntax(const char *s);
/* symmetric crypto */ /* symmetric crypto */
int crypto_cipher_generate_key(crypto_cipher_env_t *env); int crypto_cipher_generate_key(crypto_cipher_t *env);
void crypto_cipher_set_key(crypto_cipher_env_t *env, const char *key); void crypto_cipher_set_key(crypto_cipher_t *env, const char *key);
void crypto_cipher_generate_iv(char *iv_out); void crypto_cipher_generate_iv(char *iv_out);
int crypto_cipher_set_iv(crypto_cipher_env_t *env, const char *iv); int crypto_cipher_set_iv(crypto_cipher_t *env, const char *iv);
const char *crypto_cipher_get_key(crypto_cipher_env_t *env); const char *crypto_cipher_get_key(crypto_cipher_t *env);
int crypto_cipher_encrypt_init_cipher(crypto_cipher_env_t *env); int crypto_cipher_encrypt_init_cipher(crypto_cipher_t *env);
int crypto_cipher_decrypt_init_cipher(crypto_cipher_env_t *env); int crypto_cipher_decrypt_init_cipher(crypto_cipher_t *env);
int crypto_cipher_encrypt(crypto_cipher_env_t *env, char *to, int crypto_cipher_encrypt(crypto_cipher_t *env, char *to,
const char *from, size_t fromlen); const char *from, size_t fromlen);
int crypto_cipher_decrypt(crypto_cipher_env_t *env, char *to, int crypto_cipher_decrypt(crypto_cipher_t *env, char *to,
const char *from, size_t fromlen); const char *from, size_t fromlen);
int crypto_cipher_crypt_inplace(crypto_cipher_env_t *env, char *d, size_t len); int crypto_cipher_crypt_inplace(crypto_cipher_t *env, char *d, size_t len);
int crypto_cipher_encrypt_with_iv(crypto_cipher_env_t *env, int crypto_cipher_encrypt_with_iv(crypto_cipher_t *env,
char *to, size_t tolen, char *to, size_t tolen,
const char *from, size_t fromlen); const char *from, size_t fromlen);
int crypto_cipher_decrypt_with_iv(crypto_cipher_env_t *env, int crypto_cipher_decrypt_with_iv(crypto_cipher_t *env,
char *to, size_t tolen, char *to, size_t tolen,
const char *from, size_t fromlen); const char *from, size_t fromlen);
...@@ -217,16 +217,16 @@ int crypto_digest256(char *digest, const char *m, size_t len, ...@@ -217,16 +217,16 @@ int crypto_digest256(char *digest, const char *m, size_t len,
int crypto_digest_all(digests_t *ds_out, const char *m, size_t len); int crypto_digest_all(digests_t *ds_out, const char *m, size_t len);
const char *crypto_digest_algorithm_get_name(digest_algorithm_t alg); const char *crypto_digest_algorithm_get_name(digest_algorithm_t alg);
int crypto_digest_algorithm_parse_name(const char *name); int crypto_digest_algorithm_parse_name(const char *name);
crypto_digest_env_t *crypto_new_digest_env(void); crypto_digest_t *crypto_digest_new(void);
crypto_digest_env_t *crypto_new_digest256_env(digest_algorithm_t algorithm); crypto_digest_t *crypto_digest256_new(digest_algorithm_t algorithm);
void crypto_free_digest_env(crypto_digest_env_t *digest); void crypto_digest_free(crypto_digest_t *digest);
void crypto_digest_add_bytes(crypto_digest_env_t *digest, const char *data, void crypto_digest_add_bytes(crypto_digest_t *digest, const char *data,
size_t len); size_t len);
void crypto_digest_get_digest(crypto_digest_env_t *digest, void crypto_digest_get_digest(crypto_digest_t *digest,
char *out, size_t out_len); char *out, size_t out_len);
crypto_digest_env_t *crypto_digest_dup(const crypto_digest_env_t *digest); crypto_digest_t *crypto_digest_dup(const crypto_digest_t *digest);
void crypto_digest_assign(crypto_digest_env_t *into, void crypto_digest_assign(crypto_digest_t *into,
const crypto_digest_env_t *from); const crypto_digest_t *from);
void crypto_hmac_sha1(char *hmac_out, void crypto_hmac_sha1(char *hmac_out,
const char *key, size_t key_len, const char *key, size_t key_len,
const char *msg, size_t msg_len); const char *msg, size_t msg_len);
...@@ -238,15 +238,15 @@ void crypto_hmac_sha256(char *hmac_out, ...@@ -238,15 +238,15 @@ void crypto_hmac_sha256(char *hmac_out,
#define DH_TYPE_CIRCUIT 1 #define DH_TYPE_CIRCUIT 1
#define DH_TYPE_REND 2 #define DH_TYPE_REND 2
#define DH_TYPE_TLS 3 #define DH_TYPE_TLS 3
crypto_dh_env_t *crypto_dh_new(int dh_type); crypto_dh_t *crypto_dh_new(int dh_type);
int crypto_dh_get_bytes(crypto_dh_env_t *dh); int crypto_dh_get_bytes(crypto_dh_t *dh);
int crypto_dh_generate_public(crypto_dh_env_t *dh); int crypto_dh_generate_public(crypto_dh_t *dh);
int crypto_dh_get_public(crypto_dh_env_t *dh, char *pubkey_out, int crypto_dh_get_public(crypto_dh_t *dh, char *pubkey_out,
size_t pubkey_out_len); size_t pubkey_out_len);
ssize_t crypto_dh_compute_secret(int severity, crypto_dh_env_t *dh, ssize_t crypto_dh_compute_secret(int severity, crypto_dh_t *dh,
const char *pubkey, size_t pubkey_len, const char *pubkey, size_t pubkey_len,
char *secret_out, size_t secret_out_len); char *secret_out, size_t secret_out_len);
void crypto_dh_free(crypto_dh_env_t *dh); void crypto_dh_free(crypto_dh_t *dh);
int crypto_expand_key_material(const char *key_in, size_t in_len, int crypto_expand_key_material(const char *key_in, size_t in_len,
char *key_out, size_t key_out_len); char *key_out, size_t key_out_len);
...@@ -288,11 +288,11 @@ void secret_to_key(char *key_out, size_t key_out_len, const char *secret, ...@@ -288,11 +288,11 @@ void secret_to_key(char *key_out, size_t key_out_len, const char *secret,
struct rsa_st; struct rsa_st;
struct evp_pkey_st; struct evp_pkey_st;
struct dh_st; struct dh_st;
struct rsa_st *_crypto_pk_env_get_rsa(crypto_pk_env_t *env); struct rsa_st *_crypto_pk_get_rsa(crypto_pk_t *env);
crypto_pk_env_t *_crypto_new_pk_env_rsa(struct rsa_st *rsa); crypto_pk_t *_crypto_new_pk_from_rsa(struct rsa_st *rsa);
struct evp_pkey_st *_crypto_pk_env_get_evp_pkey(crypto_pk_env_t *env, struct evp_pkey_st *_crypto_pk_get_evp_pkey(crypto_pk_t *env,
int private); int private);
struct dh_st *_crypto_dh_env_get_dh(crypto_dh_env_t *dh); struct dh_st *_crypto_dh_get_dh(crypto_dh_t *dh);
/* Prototypes for private functions only used by crypto.c and test.c*/ /* Prototypes for private functions only used by crypto.c and test.c*/
void add_spaces_to_fp(char *out, size_t outlen, const char *in); void add_spaces_to_fp(char *out, size_t outlen, const char *in);
#endif #endif
......
...@@ -653,7 +653,7 @@ init_logging(void) ...@@ -653,7 +653,7 @@ init_logging(void)
log_mutex_initialized = 1; log_mutex_initialized = 1;
} }
if (pending_cb_messages == NULL) if (pending_cb_messages == NULL)
pending_cb_messages = smartlist_create(); pending_cb_messages = smartlist_new();
} }
/** Set whether we report logging domains as a part of our log messages. /** Set whether we report logging domains as a part of our log messages.
...@@ -737,7 +737,7 @@ flush_pending_log_callbacks(void) ...@@ -737,7 +737,7 @@ flush_pending_log_callbacks(void)
} }
messages = pending_cb_messages; messages = pending_cb_messages;
pending_cb_messages = smartlist_create(); pending_cb_messages = smartlist_new();
do { do {
SMARTLIST_FOREACH_BEGIN(messages, pending_cb_message_t *, msg) { SMARTLIST_FOREACH_BEGIN(messages, pending_cb_message_t *, msg) {
const int severity = msg->severity; const int severity = msg->severity;
...@@ -993,7 +993,7 @@ parse_log_severity_config(const char **cfg_ptr, ...@@ -993,7 +993,7 @@ parse_log_severity_config(const char **cfg_ptr,
return -1; return -1;
domains = 0; domains = 0;
domains_str = tor_strndup(cfg+1, closebracket-cfg-1); domains_str = tor_strndup(cfg+1, closebracket-cfg-1);
domains_list = smartlist_create(); domains_list = smartlist_new();
smartlist_split_string(domains_list, domains_str, ",", SPLIT_SKIP_SPACE, smartlist_split_string(domains_list, domains_str, ",", SPLIT_SKIP_SPACE,
-1); -1);
tor_free(domains_str); tor_free(domains_str);
......
...@@ -126,8 +126,8 @@ typedef struct tor_tls_context_t { ...@@ -126,8 +126,8 @@ typedef struct tor_tls_context_t {
tor_cert_t *my_link_cert; tor_cert_t *my_link_cert;
tor_cert_t *my_id_cert; tor_cert_t *my_id_cert;
tor_cert_t *my_auth_cert; tor_cert_t *my_auth_cert;
crypto_pk_env_t *link_key; crypto_pk_t *link_key;
crypto_pk_env_t *auth_key; crypto_pk_t *auth_key;
} tor_tls_context_t; } tor_tls_context_t;
#define TOR_TLS_MAGIC 0x71571571 #define TOR_TLS_MAGIC 0x71571571
...@@ -209,17 +209,17 @@ tor_tls_get_by_ssl(const SSL *ssl) ...@@ -209,17 +209,17 @@ tor_tls_get_by_ssl(const SSL *ssl)
static void tor_tls_context_decref(tor_tls_context_t *ctx); static void tor_tls_context_decref(tor_tls_context_t *ctx);
static void tor_tls_context_incref(tor_tls_context_t *ctx); static void tor_tls_context_incref(tor_tls_context_t *ctx);
static X509* tor_tls_create_certificate(crypto_pk_env_t *rsa, static X509* tor_tls_create_certificate(crypto_pk_t *rsa,
crypto_pk_env_t *rsa_sign, crypto_pk_t *rsa_sign,
const char *cname, const char *cname,
const char *cname_sign, const char *cname_sign,
unsigned int lifetime); unsigned int lifetime);
static int tor_tls_context_init_one(tor_tls_context_t **ppcontext, static int tor_tls_context_init_one(tor_tls_context_t **ppcontext,
crypto_pk_env_t *identity, crypto_pk_t *identity,
unsigned int key_lifetime, unsigned int key_lifetime,
int is_client); int is_client);
static tor_tls_context_t *tor_tls_context_new(crypto_pk_env_t *identity, static tor_tls_context_t *tor_tls_context_new(crypto_pk_t *identity,
unsigned int key_lifetime, unsigned int key_lifetime,
int is_client); int is_client);
static int check_cert_lifetime_internal(int severity, const X509 *cert, static int check_cert_lifetime_internal(int severity, const X509 *cert,
...@@ -569,8 +569,8 @@ tor_x509_name_new(const char *cname) ...@@ -569,8 +569,8 @@ tor_x509_name_new(const char *cname)
* failure. * failure.
*/ */
static X509 * static X509 *
tor_tls_create_certificate(crypto_pk_env_t *rsa, tor_tls_create_certificate(crypto_pk_t *rsa,
crypto_pk_env_t *rsa_sign, crypto_pk_t *rsa_sign,
const char *cname, const char *cname,
const char *cname_sign, const char *cname_sign,
unsigned int cert_lifetime) unsigned int cert_lifetime)
...@@ -594,9 +594,9 @@ tor_tls_create_certificate(crypto_pk_env_t *rsa, ...@@ -594,9 +594,9 @@ tor_tls_create_certificate(crypto_pk_env_t *rsa,
tor_assert(cname); tor_assert(cname);
tor_assert(rsa_sign); tor_assert(rsa_sign);
tor_assert(cname_sign); tor_assert(cname_sign);
if (!(sign_pkey = _crypto_pk_env_get_evp_pkey(rsa_sign,1))) if (!(sign_pkey = _crypto_pk_get_evp_pkey(rsa_sign,1)))
goto error; goto error;
if (!(pkey = _crypto_pk_env_get_evp_pkey(rsa,0))) if (!(pkey = _crypto_pk_get_evp_pkey(rsa,0)))
goto error; goto error;
if (!(x509 = X509_new())) if (!(x509 = X509_new()))
goto error; goto error;
...@@ -748,10 +748,10 @@ tor_cert_new(X509 *x509_cert) ...@@ -748,10 +748,10 @@ tor_cert_new(X509 *x509_cert)
if ((pkey = X509_get_pubkey(x509_cert)) && if ((pkey = X509_get_pubkey(x509_cert)) &&
(rsa = EVP_PKEY_get1_RSA(pkey))) { (rsa = EVP_PKEY_get1_RSA(pkey))) {
crypto_pk_env_t *pk = _crypto_new_pk_env_rsa(rsa); crypto_pk_t *pk = _crypto_new_pk_from_rsa(rsa);
crypto_pk_get_all_digests(pk, &cert->pkey_digests); crypto_pk_get_all_digests(pk, &cert->pkey_digests);
cert->pkey_digests_set = 1; cert->pkey_digests_set = 1;
crypto_free_pk_env(pk); crypto_pk_free(pk);
EVP_PKEY_free(pkey); EVP_PKEY_free(pkey);
} }
...@@ -840,8 +840,8 @@ tor_tls_context_decref(tor_tls_context_t *ctx) ...@@ -840,8 +840,8 @@ tor_tls_context_decref(tor_tls_context_t *ctx)
tor_cert_free(ctx->my_link_cert); tor_cert_free(ctx->my_link_cert);
tor_cert_free(ctx->my_id_cert); tor_cert_free(ctx->my_id_cert);
tor_cert_free(ctx->my_auth_cert); tor_cert_free(ctx->my_auth_cert);
crypto_free_pk_env(ctx->link_key); crypto_pk_free(ctx->link_key);
crypto_free_pk_env(ctx->auth_key); crypto_pk_free(ctx->auth_key);
tor_free(ctx); tor_free(ctx);
} }
} }
...@@ -870,7 +870,7 @@ tor_tls_get_my_certs(int server, ...@@ -870,7 +870,7 @@ tor_tls_get_my_certs(int server,
* Return the authentication key that we use to authenticate ourselves as a * Return the authentication key that we use to authenticate ourselves as a
* client in the V3 in-protocol handshake. * client in the V3 in-protocol handshake.
*/ */
crypto_pk_env_t * crypto_pk_t *
tor_tls_get_my_client_auth_key(void) tor_tls_get_my_client_auth_key(void)
{ {
if (! client_tls_context) if (! client_tls_context)
...@@ -882,10 +882,10 @@ tor_tls_get_my_client_auth_key(void) ...@@ -882,10 +882,10 @@ tor_tls_get_my_client_auth_key(void)
* Return a newly allocated copy of the public key that a certificate * Return a newly allocated copy of the public key that a certificate
* certifies. Return NULL if the cert's key is not RSA. * certifies. Return NULL if the cert's key is not RSA.
*/ */
crypto_pk_env_t * crypto_pk_t *
tor_tls_cert_get_key(tor_cert_t *cert) tor_tls_cert_get_key(tor_cert_t *cert)
{ {
crypto_pk_env_t *result = NULL; crypto_pk_t *result = NULL;
EVP_PKEY *pkey = X509_get_pubkey(cert->cert); EVP_PKEY *pkey = X509_get_pubkey(cert->cert);
RSA *rsa; RSA *rsa;
if (!pkey) if (!pkey)
...@@ -895,7 +895,7 @@ tor_tls_cert_get_key(tor_cert_t *cert) ...@@ -895,7 +895,7 @@ tor_tls_cert_get_key(tor_cert_t *cert)
EVP_PKEY_free(pkey); EVP_PKEY_free(pkey);
return NULL; return NULL;
} }
result = _crypto_new_pk_env_rsa(rsa); result = _crypto_new_pk_from_rsa(rsa);
EVP_PKEY_free(pkey); EVP_PKEY_free(pkey);
return result; return result;