[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]
[tor-commits] [tor/master] Unify functions for reading/writing PEM keys, to avoid duplication.
commit 3b5d6ef15bec26c3bda22057ba09e1301613ee71
Author: Nick Mathewson <nickm@xxxxxxxxxxxxxx>
Date: Wed Aug 29 16:43:54 2018 -0400
Unify functions for reading/writing PEM keys, to avoid duplication.
---
src/lib/crypt_ops/crypto_rsa.c | 145 ++++++++++++++++++++---------------------
1 file changed, 71 insertions(+), 74 deletions(-)
diff --git a/src/lib/crypt_ops/crypto_rsa.c b/src/lib/crypt_ops/crypto_rsa.c
index 31497e650..6a9e2948f 100644
--- a/src/lib/crypt_ops/crypto_rsa.c
+++ b/src/lib/crypt_ops/crypto_rsa.c
@@ -398,29 +398,43 @@ crypto_pk_get_common_digests(crypto_pk_t *pk, common_digests_t *digests_out)
static const char RSA_PUBLIC_TAG[] = "RSA PUBLIC KEY";
static const char RSA_PRIVATE_TAG[] = "RSA PRIVATE KEY";
-/** PEM-encode the public key portion of <b>env</b> and write it to a
- * newly allocated string. On success, set *<b>dest</b> to the new
- * string, *<b>len</b> to the string's length, and return 0. On
- * failure, return -1.
+/* These are overestimates for how many extra bytes we might need to encode
+ * a key in DER */
+#define PRIVATE_ASN_MAX_OVERHEAD_FACTOR 16
+#define PUBLIC_ASN_MAX_OVERHEAD_FACTOR 3
+
+/** Helper: PEM-encode <b>env</b> and write it to a newly allocated string.
+ * If <b>private_key</b>, write the private part of <b>env</b>; otherwise
+ * write only the public portion. On success, set *<b>dest</b> to the new
+ * string, *<b>len</b> to the string's length, and return 0. On failure,
+ * return -1.
*/
-int
-crypto_pk_write_public_key_to_string(crypto_pk_t *env,
- char **dest, size_t *len)
+static int
+crypto_pk_write_to_string_generic(crypto_pk_t *env,
+ char **dest, size_t *len,
+ bool private_key)
{
- size_t buflen = crypto_pk_keysize(env) * 3;
+ const int factor =
+ private_key ? PRIVATE_ASN_MAX_OVERHEAD_FACTOR
+ : PUBLIC_ASN_MAX_OVERHEAD_FACTOR;
+ size_t buflen = crypto_pk_keysize(env) * factor;
+ const char *tag =
+ private_key ? RSA_PRIVATE_TAG : RSA_PUBLIC_TAG;
char *buf = tor_malloc(buflen);
char *result = NULL;
size_t resultlen = 0;
int rv = -1;
- int n = crypto_pk_asn1_encode(env, buf, buflen);
+ int n = private_key
+ ? crypto_pk_asn1_encode_private(env, buf, buflen)
+ : crypto_pk_asn1_encode(env, buf, buflen);
if (n < 0)
goto done;
- resultlen = pem_encoded_size(n, RSA_PUBLIC_TAG);
+ resultlen = pem_encoded_size(n, tag);
result = tor_malloc(resultlen);
if (pem_encode(result, resultlen,
- (const unsigned char *)buf, n, RSA_PUBLIC_TAG) < 0) {
+ (const unsigned char *)buf, n, tag) < 0) {
goto done;
}
@@ -438,6 +452,18 @@ crypto_pk_write_public_key_to_string(crypto_pk_t *env,
return rv;
}
+/** PEM-encode the public key portion of <b>env</b> and write it to a
+ * newly allocated string. On success, set *<b>dest</b> to the new
+ * string, *<b>len</b> to the string's length, and return 0. On
+ * failure, return -1.
+ */
+int
+crypto_pk_write_public_key_to_string(crypto_pk_t *env,
+ char **dest, size_t *len)
+{
+ return crypto_pk_write_to_string_generic(env, dest, len, false);
+}
+
/** PEM-encode the private key portion of <b>env</b> and write it to a
* newly allocated string. On success, set *<b>dest</b> to the new
* string, *<b>len</b> to the string's length, and return 0. On
@@ -447,59 +473,42 @@ int
crypto_pk_write_private_key_to_string(crypto_pk_t *env,
char **dest, size_t *len)
{
- size_t buflen = crypto_pk_keysize(env) * 16;
- char *buf = tor_malloc(buflen);
- char *result = NULL;
- size_t resultlen = 0;
- int rv = -1;
-
- int n = crypto_pk_asn1_encode_private(env, buf, buflen);
- if (n < 0)
- goto done;
-
- resultlen = pem_encoded_size(n, RSA_PRIVATE_TAG);
- result = tor_malloc(resultlen);
- if (pem_encode(result, resultlen,
- (const unsigned char *)buf, n, RSA_PRIVATE_TAG) < 0)
- goto done;
-
- *dest = result;
- *len = resultlen;
- rv = 0;
- done:
- if (rv < 0 && result) {
- memwipe(result, 0, resultlen);
- tor_free(result);
- }
- memwipe(buf, 0, buflen);
- tor_free(buf);
- return rv;
+ return crypto_pk_write_to_string_generic(env, dest, len, true);
}
-/** Read a PEM-encoded public key from the first <b>len</b> characters of
- * <b>src</b>, and store the result in <b>env</b>. Return 0 on success, -1 on
- * failure.
+/**
+ * Helper. Read a PEM-encoded RSA from the first <b>len</b> characters of
+ * <b>src</b>, and store the result in <b>env</b>. If <b>private_key</b>,
+ * expect a private key; otherwise expect a public key. Return 0 on success,
+ * -1 on failure. If len is -1, the string is nul-terminated.
*/
-int
-crypto_pk_read_public_key_from_string(crypto_pk_t *env,
- const char *src, size_t len)
+static int
+crypto_pk_read_from_string_generic(crypto_pk_t *env, const char *src,
+ size_t len, bool private_key)
{
- if (len == (size_t)-1)
+ if (len == (size_t)-1) // "-1" indicates "use the length of the string."
len = strlen(src);
+ const char *tag =
+ private_key ? RSA_PRIVATE_TAG : RSA_PUBLIC_TAG;
size_t buflen = len;
uint8_t *buf = tor_malloc(buflen);
int rv = -1;
- int n = pem_decode(buf, buflen, src, len, RSA_PUBLIC_TAG);
+ int n = pem_decode(buf, buflen, src, len, tag);
if (n < 0)
goto done;
- crypto_pk_t *pk = crypto_pk_asn1_decode((const char*)buf, n);
+ crypto_pk_t *pk = private_key
+ ? crypto_pk_asn1_decode_private((const char*)buf, n)
+ : crypto_pk_asn1_decode((const char*)buf, n);
if (! pk)
goto done;
- crypto_pk_assign_public(env, pk);
+ if (private_key)
+ crypto_pk_assign_private(env, pk);
+ else
+ crypto_pk_assign_public(env, pk);
crypto_pk_free(pk);
rv = 0;
@@ -509,38 +518,26 @@ crypto_pk_read_public_key_from_string(crypto_pk_t *env,
return rv;
}
-/** Read a PEM-encoded private key from the <b>len</b>-byte string <b>s</b>
+/** Read a PEM-encoded public key from the first <b>len</b> characters of
+ * <b>src</b>, and store the result in <b>env</b>. Return 0 on success, -1 on
+ * failure. If len is -1, the string is nul-terminated.
+ */
+int
+crypto_pk_read_public_key_from_string(crypto_pk_t *env,
+ const char *src, size_t len)
+{
+ return crypto_pk_read_from_string_generic(env, src, len, false);
+}
+
+/** Read a PEM-encoded private key from the <b>len</b>-byte string <b>src</b>
* into <b>env</b>. Return 0 on success, -1 on failure. If len is -1,
* the string is nul-terminated.
*/
int
crypto_pk_read_private_key_from_string(crypto_pk_t *env,
- const char *s, ssize_t len)
+ const char *src, ssize_t len)
{
- if (len == -1)
- len = strlen(s);
-
- size_t buflen = len;
- uint8_t *buf = tor_malloc(buflen);
- int rv = -1;
-
- int n = pem_decode(buf, buflen, s, len, RSA_PRIVATE_TAG);
- if (n < 0) {
- goto done;
- }
-
- crypto_pk_t *pk = crypto_pk_asn1_decode_private((const char *)buf, n);
- if (! pk)
- goto done;
-
- crypto_pk_assign_private(env, pk);
- crypto_pk_free(pk);
- rv = 0;
-
- done:
- memwipe(buf, 0, buflen);
- tor_free(buf);
- return rv;
+ return crypto_pk_read_from_string_generic(env, src, len, true);
}
/** Read a PEM-encoded private key from the file named by
_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits