kris/boringssl
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
0abd6f2eb6
boringssl/crypto/ecdsa/ecdsa_asn1.c

241 lines
6.7 KiB
C
Raw Normal View History

Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
/* ====================================================================
* Copyright (c) 1998-2005 The OpenSSL Project. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. All advertising materials mentioning features or use of this
* software must display the following acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
*
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
* endorse or promote products derived from this software without
* prior written permission. For written permission, please contact
* openssl-core@OpenSSL.org.
*
* 5. Products derived from this software may not be called "OpenSSL"
* nor may "OpenSSL" appear in their names without prior written
* permission of the OpenSSL Project.
*
* 6. Redistributions of any form whatsoever must retain the following
* acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
*
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
* ====================================================================
*
* This product includes cryptographic software written by Eric Young
* (eay@cryptsoft.com). This product includes software written by Tim
* Hudson (tjh@cryptsoft.com). */
#include <openssl/ecdsa.h>
Implement ECDSA_SIG_{parse,marshal} with crypto/bytestring. This is the first structure to be implemented with the new BIGNUM ASN.1 routines. Object reuse in the legacy d2i/i2d functions is implemented by releasing whatever was in *out before and setting it to the newly-allocated object. As with the new d2i_SSL_SESSION, this is a weaker form of object reuse, but should suffice for reasonable callers. As ECDSA_SIG is more likely to be parsed alone than as part of another structure (and using CBB is slightly tedious), add convenient functions which take byte arrays. For consistency with SSL_SESSION, they are named to/from_bytes. from_bytes, unlike the CBS variant, rejects trailing data. Note this changes some test expectations: BER signatures now push an error code. That they didn't do this was probably a mistake. BUG=499653 Change-Id: I9ec74db53e70d9a989412cc9e2b599be0454caec Reviewed-on: https://boringssl-review.googlesource.com/5269 Reviewed-by: Adam Langley <agl@google.com>
2015-06-12 04:30:53 +01:00
#include <limits.h>
#include <string.h>
#include <openssl/bn.h>
#include <openssl/bytestring.h>
#include <openssl/err.h>
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
#include <openssl/ec_key.h>
Implement ECDSA_SIG_new and ECDSA_SIG_free manually. Implement ECDSA_SIG_new and ECDSA_SIG_free manually in preparation for removing all crypto/asn1 dependencies from ECDSA signature verification. Change-Id: I0e84d74fa8e757af0cfb09daef03d59f428143cc Reviewed-on: https://boringssl-review.googlesource.com/4153 Reviewed-by: Adam Langley <agl@google.com>
2015-03-19 08:34:57 +00:00
#include <openssl/mem.h>
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
#include "../ec/internal.h"
size_t ECDSA_size(const EC_KEY *key) {
Expose ECDSA_SIG_max_len to size a DER ECDSA-Sig-Value. Also implement it without reference to crypto/asn1 or fake ASN1_INTEGERs and add a test. Some platform crypto APIs only give back the key size, and not the encoded signature length. No sense in implementing it twice. BUG=347404,499653 Change-Id: I9aa27d52674375f8b036e57bb5850f091c9b25dd Reviewed-on: https://boringssl-review.googlesource.com/5080 Reviewed-by: Adam Langley <agl@google.com>
2015-06-10 21:52:59 +01:00
if (key == NULL) {
return 0;
}
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
Expose ECDSA_SIG_max_len to size a DER ECDSA-Sig-Value. Also implement it without reference to crypto/asn1 or fake ASN1_INTEGERs and add a test. Some platform crypto APIs only give back the key size, and not the encoded signature length. No sense in implementing it twice. BUG=347404,499653 Change-Id: I9aa27d52674375f8b036e57bb5850f091c9b25dd Reviewed-on: https://boringssl-review.googlesource.com/5080 Reviewed-by: Adam Langley <agl@google.com>
2015-06-10 21:52:59 +01:00
size_t group_order_size;
Change ECDSA_METHOD's size() to group_order_size() The |size| method was documented to return the same as |ECDSA_size| - the max size of an ECDSA signature. However, this involves some ASN.1 calculations which is best done once. What custom implementations want to give is the size of the group order on which the ASN.1 computations are based. This change switches the |size| method to allow that. Change-Id: I95b6e0c2b52bfcd0d74850c2c4e9bc01269255e2 Reviewed-on: https://boringssl-review.googlesource.com/1200 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-15 23:15:09 +01:00
if (key->ecdsa_meth && key->ecdsa_meth->group_order_size) {
group_order_size = key->ecdsa_meth->group_order_size(key);
} else {
Expose ECDSA_SIG_max_len to size a DER ECDSA-Sig-Value. Also implement it without reference to crypto/asn1 or fake ASN1_INTEGERs and add a test. Some platform crypto APIs only give back the key size, and not the encoded signature length. No sense in implementing it twice. BUG=347404,499653 Change-Id: I9aa27d52674375f8b036e57bb5850f091c9b25dd Reviewed-on: https://boringssl-review.googlesource.com/5080 Reviewed-by: Adam Langley <agl@google.com>
2015-06-10 21:52:59 +01:00
const EC_GROUP *group = EC_KEY_get0_group(key);
Change ECDSA_METHOD's size() to group_order_size() The |size| method was documented to return the same as |ECDSA_size| - the max size of an ECDSA signature. However, this involves some ASN.1 calculations which is best done once. What custom implementations want to give is the size of the group order on which the ASN.1 computations are based. This change switches the |size| method to allow that. Change-Id: I95b6e0c2b52bfcd0d74850c2c4e9bc01269255e2 Reviewed-on: https://boringssl-review.googlesource.com/1200 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-15 23:15:09 +01:00
if (group == NULL) {
return 0;
}
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
Add |EC_GROUP_get0_order| to replace |EC_GROUP_get_order|. |EC_GROUP_get0_order| doesn't require any heap allocations and never fails, so it is much more convenient and more efficient for callers to call. Change-Id: Ic60f768875e7bc8e74362dacdb5cbbc6957b05a6 Reviewed-on: https://boringssl-review.googlesource.com/6532 Reviewed-by: Adam Langley <agl@google.com>
2015-11-19 03:07:14 +00:00
group_order_size = BN_num_bytes(EC_GROUP_get0_order(group));
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
}
Expose ECDSA_SIG_max_len to size a DER ECDSA-Sig-Value. Also implement it without reference to crypto/asn1 or fake ASN1_INTEGERs and add a test. Some platform crypto APIs only give back the key size, and not the encoded signature length. No sense in implementing it twice. BUG=347404,499653 Change-Id: I9aa27d52674375f8b036e57bb5850f091c9b25dd Reviewed-on: https://boringssl-review.googlesource.com/5080 Reviewed-by: Adam Langley <agl@google.com>
2015-06-10 21:52:59 +01:00
return ECDSA_SIG_max_len(group_order_size);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
}
Implement ECDSA_SIG_new and ECDSA_SIG_free manually. Implement ECDSA_SIG_new and ECDSA_SIG_free manually in preparation for removing all crypto/asn1 dependencies from ECDSA signature verification. Change-Id: I0e84d74fa8e757af0cfb09daef03d59f428143cc Reviewed-on: https://boringssl-review.googlesource.com/4153 Reviewed-by: Adam Langley <agl@google.com>
2015-03-19 08:34:57 +00:00
ECDSA_SIG *ECDSA_SIG_new(void) {
ECDSA_SIG *sig = OPENSSL_malloc(sizeof(ECDSA_SIG));
if (sig == NULL) {
return NULL;
}
sig->r = BN_new();
sig->s = BN_new();
if (sig->r == NULL || sig->s == NULL) {
ECDSA_SIG_free(sig);
return NULL;
}
return sig;
}
void ECDSA_SIG_free(ECDSA_SIG *sig) {
if (sig == NULL) {
return;
}
BN_free(sig->r);
BN_free(sig->s);
OPENSSL_free(sig);
}
Expose ECDSA_SIG_max_len to size a DER ECDSA-Sig-Value. Also implement it without reference to crypto/asn1 or fake ASN1_INTEGERs and add a test. Some platform crypto APIs only give back the key size, and not the encoded signature length. No sense in implementing it twice. BUG=347404,499653 Change-Id: I9aa27d52674375f8b036e57bb5850f091c9b25dd Reviewed-on: https://boringssl-review.googlesource.com/5080 Reviewed-by: Adam Langley <agl@google.com>
2015-06-10 21:52:59 +01:00
Implement ECDSA_SIG_{parse,marshal} with crypto/bytestring. This is the first structure to be implemented with the new BIGNUM ASN.1 routines. Object reuse in the legacy d2i/i2d functions is implemented by releasing whatever was in *out before and setting it to the newly-allocated object. As with the new d2i_SSL_SESSION, this is a weaker form of object reuse, but should suffice for reasonable callers. As ECDSA_SIG is more likely to be parsed alone than as part of another structure (and using CBB is slightly tedious), add convenient functions which take byte arrays. For consistency with SSL_SESSION, they are named to/from_bytes. from_bytes, unlike the CBS variant, rejects trailing data. Note this changes some test expectations: BER signatures now push an error code. That they didn't do this was probably a mistake. BUG=499653 Change-Id: I9ec74db53e70d9a989412cc9e2b599be0454caec Reviewed-on: https://boringssl-review.googlesource.com/5269 Reviewed-by: Adam Langley <agl@google.com>
2015-06-12 04:30:53 +01:00
ECDSA_SIG *ECDSA_SIG_parse(CBS *cbs) {
ECDSA_SIG *ret = ECDSA_SIG_new();
if (ret == NULL) {
return NULL;
}
CBS child;
if (!CBS_get_asn1(cbs, &child, CBS_ASN1_SEQUENCE) ||
!BN_cbs2unsigned(&child, ret->r) ||
!BN_cbs2unsigned(&child, ret->s) ||
CBS_len(&child) != 0) {
Remove the func parameter to OPENSSL_PUT_ERROR. Much of this was done automatically with find . -name '*.c' | xargs sed -E -i '' -e 's/(OPENSSL_PUT_ERROR\([a-zA-Z_0-9]+, )[a-zA-Z_0-9]+, ([a-zA-Z_0-9]+\);)/\1\2/' find . -name '*.c' | xargs sed -E -i '' -e 's/(OPENSSL_PUT_ERROR\([a-zA-Z_0-9]+, )[a-zA-Z_0-9]+, ([a-zA-Z_0-9]+\);)/\1\2/' BUG=468039 Change-Id: I4c75fd95dff85ab1d4a546b05e6aed1aeeb499d8 Reviewed-on: https://boringssl-review.googlesource.com/5276 Reviewed-by: Adam Langley <agl@google.com>
2015-06-29 05:28:17 +01:00
OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_BAD_SIGNATURE);
Implement ECDSA_SIG_{parse,marshal} with crypto/bytestring. This is the first structure to be implemented with the new BIGNUM ASN.1 routines. Object reuse in the legacy d2i/i2d functions is implemented by releasing whatever was in *out before and setting it to the newly-allocated object. As with the new d2i_SSL_SESSION, this is a weaker form of object reuse, but should suffice for reasonable callers. As ECDSA_SIG is more likely to be parsed alone than as part of another structure (and using CBB is slightly tedious), add convenient functions which take byte arrays. For consistency with SSL_SESSION, they are named to/from_bytes. from_bytes, unlike the CBS variant, rejects trailing data. Note this changes some test expectations: BER signatures now push an error code. That they didn't do this was probably a mistake. BUG=499653 Change-Id: I9ec74db53e70d9a989412cc9e2b599be0454caec Reviewed-on: https://boringssl-review.googlesource.com/5269 Reviewed-by: Adam Langley <agl@google.com>
2015-06-12 04:30:53 +01:00
ECDSA_SIG_free(ret);
return NULL;
}
return ret;
}
ECDSA_SIG *ECDSA_SIG_from_bytes(const uint8_t *in, size_t in_len) {
CBS cbs;
CBS_init(&cbs, in, in_len);
ECDSA_SIG *ret = ECDSA_SIG_parse(&cbs);
if (ret == NULL || CBS_len(&cbs) != 0) {
Remove the func parameter to OPENSSL_PUT_ERROR. Much of this was done automatically with find . -name '*.c' | xargs sed -E -i '' -e 's/(OPENSSL_PUT_ERROR\([a-zA-Z_0-9]+, )[a-zA-Z_0-9]+, ([a-zA-Z_0-9]+\);)/\1\2/' find . -name '*.c' | xargs sed -E -i '' -e 's/(OPENSSL_PUT_ERROR\([a-zA-Z_0-9]+, )[a-zA-Z_0-9]+, ([a-zA-Z_0-9]+\);)/\1\2/' BUG=468039 Change-Id: I4c75fd95dff85ab1d4a546b05e6aed1aeeb499d8 Reviewed-on: https://boringssl-review.googlesource.com/5276 Reviewed-by: Adam Langley <agl@google.com>
2015-06-29 05:28:17 +01:00
OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_BAD_SIGNATURE);
Implement ECDSA_SIG_{parse,marshal} with crypto/bytestring. This is the first structure to be implemented with the new BIGNUM ASN.1 routines. Object reuse in the legacy d2i/i2d functions is implemented by releasing whatever was in *out before and setting it to the newly-allocated object. As with the new d2i_SSL_SESSION, this is a weaker form of object reuse, but should suffice for reasonable callers. As ECDSA_SIG is more likely to be parsed alone than as part of another structure (and using CBB is slightly tedious), add convenient functions which take byte arrays. For consistency with SSL_SESSION, they are named to/from_bytes. from_bytes, unlike the CBS variant, rejects trailing data. Note this changes some test expectations: BER signatures now push an error code. That they didn't do this was probably a mistake. BUG=499653 Change-Id: I9ec74db53e70d9a989412cc9e2b599be0454caec Reviewed-on: https://boringssl-review.googlesource.com/5269 Reviewed-by: Adam Langley <agl@google.com>
2015-06-12 04:30:53 +01:00
ECDSA_SIG_free(ret);
return NULL;
}
return ret;
}
int ECDSA_SIG_marshal(CBB *cbb, const ECDSA_SIG *sig) {
CBB child;
if (!CBB_add_asn1(cbb, &child, CBS_ASN1_SEQUENCE) ||
!BN_bn2cbb(&child, sig->r) ||
!BN_bn2cbb(&child, sig->s) ||
!CBB_flush(cbb)) {
Remove the func parameter to OPENSSL_PUT_ERROR. Much of this was done automatically with find . -name '*.c' | xargs sed -E -i '' -e 's/(OPENSSL_PUT_ERROR\([a-zA-Z_0-9]+, )[a-zA-Z_0-9]+, ([a-zA-Z_0-9]+\);)/\1\2/' find . -name '*.c' | xargs sed -E -i '' -e 's/(OPENSSL_PUT_ERROR\([a-zA-Z_0-9]+, )[a-zA-Z_0-9]+, ([a-zA-Z_0-9]+\);)/\1\2/' BUG=468039 Change-Id: I4c75fd95dff85ab1d4a546b05e6aed1aeeb499d8 Reviewed-on: https://boringssl-review.googlesource.com/5276 Reviewed-by: Adam Langley <agl@google.com>
2015-06-29 05:28:17 +01:00
OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_ENCODE_ERROR);
Implement ECDSA_SIG_{parse,marshal} with crypto/bytestring. This is the first structure to be implemented with the new BIGNUM ASN.1 routines. Object reuse in the legacy d2i/i2d functions is implemented by releasing whatever was in *out before and setting it to the newly-allocated object. As with the new d2i_SSL_SESSION, this is a weaker form of object reuse, but should suffice for reasonable callers. As ECDSA_SIG is more likely to be parsed alone than as part of another structure (and using CBB is slightly tedious), add convenient functions which take byte arrays. For consistency with SSL_SESSION, they are named to/from_bytes. from_bytes, unlike the CBS variant, rejects trailing data. Note this changes some test expectations: BER signatures now push an error code. That they didn't do this was probably a mistake. BUG=499653 Change-Id: I9ec74db53e70d9a989412cc9e2b599be0454caec Reviewed-on: https://boringssl-review.googlesource.com/5269 Reviewed-by: Adam Langley <agl@google.com>
2015-06-12 04:30:53 +01:00
return 0;
}
return 1;
}
int ECDSA_SIG_to_bytes(uint8_t **out_bytes, size_t *out_len,
const ECDSA_SIG *sig) {
CBB cbb;
CBB_zero(&cbb);
if (!CBB_init(&cbb, 0) ||
!ECDSA_SIG_marshal(&cbb, sig) ||
!CBB_finish(&cbb, out_bytes, out_len)) {
Remove the func parameter to OPENSSL_PUT_ERROR. Much of this was done automatically with find . -name '*.c' | xargs sed -E -i '' -e 's/(OPENSSL_PUT_ERROR\([a-zA-Z_0-9]+, )[a-zA-Z_0-9]+, ([a-zA-Z_0-9]+\);)/\1\2/' find . -name '*.c' | xargs sed -E -i '' -e 's/(OPENSSL_PUT_ERROR\([a-zA-Z_0-9]+, )[a-zA-Z_0-9]+, ([a-zA-Z_0-9]+\);)/\1\2/' BUG=468039 Change-Id: I4c75fd95dff85ab1d4a546b05e6aed1aeeb499d8 Reviewed-on: https://boringssl-review.googlesource.com/5276 Reviewed-by: Adam Langley <agl@google.com>
2015-06-29 05:28:17 +01:00
OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_ENCODE_ERROR);
Implement ECDSA_SIG_{parse,marshal} with crypto/bytestring. This is the first structure to be implemented with the new BIGNUM ASN.1 routines. Object reuse in the legacy d2i/i2d functions is implemented by releasing whatever was in *out before and setting it to the newly-allocated object. As with the new d2i_SSL_SESSION, this is a weaker form of object reuse, but should suffice for reasonable callers. As ECDSA_SIG is more likely to be parsed alone than as part of another structure (and using CBB is slightly tedious), add convenient functions which take byte arrays. For consistency with SSL_SESSION, they are named to/from_bytes. from_bytes, unlike the CBS variant, rejects trailing data. Note this changes some test expectations: BER signatures now push an error code. That they didn't do this was probably a mistake. BUG=499653 Change-Id: I9ec74db53e70d9a989412cc9e2b599be0454caec Reviewed-on: https://boringssl-review.googlesource.com/5269 Reviewed-by: Adam Langley <agl@google.com>
2015-06-12 04:30:53 +01:00
CBB_cleanup(&cbb);
return 0;
}
return 1;
}
Expose ECDSA_SIG_max_len to size a DER ECDSA-Sig-Value. Also implement it without reference to crypto/asn1 or fake ASN1_INTEGERs and add a test. Some platform crypto APIs only give back the key size, and not the encoded signature length. No sense in implementing it twice. BUG=347404,499653 Change-Id: I9aa27d52674375f8b036e57bb5850f091c9b25dd Reviewed-on: https://boringssl-review.googlesource.com/5080 Reviewed-by: Adam Langley <agl@google.com>
2015-06-10 21:52:59 +01:00
/* der_len_len returns the number of bytes needed to represent a length of |len|
* in DER. */
static size_t der_len_len(size_t len) {
if (len < 0x80) {
return 1;
}
size_t ret = 1;
while (len > 0) {
ret++;
len >>= 8;
}
return ret;
}
size_t ECDSA_SIG_max_len(size_t order_len) {
/* Compute the maximum length of an |order_len| byte integer. Defensively
* assume that the leading 0x00 is included. */
size_t integer_len = 1 /* tag */ + der_len_len(order_len + 1) + 1 + order_len;
if (integer_len < order_len) {
return 0;
}
/* An ECDSA signature is two INTEGERs. */
size_t value_len = 2 * integer_len;
if (value_len < integer_len) {
return 0;
}
/* Add the header. */
size_t ret = 1 /* tag */ + der_len_len(value_len) + value_len;
if (ret < value_len) {
return 0;
}
return ret;
}
Implement ECDSA_SIG_{parse,marshal} with crypto/bytestring. This is the first structure to be implemented with the new BIGNUM ASN.1 routines. Object reuse in the legacy d2i/i2d functions is implemented by releasing whatever was in *out before and setting it to the newly-allocated object. As with the new d2i_SSL_SESSION, this is a weaker form of object reuse, but should suffice for reasonable callers. As ECDSA_SIG is more likely to be parsed alone than as part of another structure (and using CBB is slightly tedious), add convenient functions which take byte arrays. For consistency with SSL_SESSION, they are named to/from_bytes. from_bytes, unlike the CBS variant, rejects trailing data. Note this changes some test expectations: BER signatures now push an error code. That they didn't do this was probably a mistake. BUG=499653 Change-Id: I9ec74db53e70d9a989412cc9e2b599be0454caec Reviewed-on: https://boringssl-review.googlesource.com/5269 Reviewed-by: Adam Langley <agl@google.com>
2015-06-12 04:30:53 +01:00
ECDSA_SIG *d2i_ECDSA_SIG(ECDSA_SIG **out, const uint8_t **inp, long len) {
if (len < 0) {
return NULL;
}
CBS cbs;
CBS_init(&cbs, *inp, (size_t)len);
ECDSA_SIG *ret = ECDSA_SIG_parse(&cbs);
if (ret == NULL) {
return NULL;
}
if (out != NULL) {
ECDSA_SIG_free(*out);
*out = ret;
}
*inp += (size_t)len - CBS_len(&cbs);
return ret;
}
int i2d_ECDSA_SIG(const ECDSA_SIG *sig, uint8_t **outp) {
uint8_t *der;
size_t der_len;
if (!ECDSA_SIG_to_bytes(&der, &der_len, sig)) {
return -1;
}
if (der_len > INT_MAX) {
Remove the func parameter to OPENSSL_PUT_ERROR. Much of this was done automatically with find . -name '*.c' | xargs sed -E -i '' -e 's/(OPENSSL_PUT_ERROR\([a-zA-Z_0-9]+, )[a-zA-Z_0-9]+, ([a-zA-Z_0-9]+\);)/\1\2/' find . -name '*.c' | xargs sed -E -i '' -e 's/(OPENSSL_PUT_ERROR\([a-zA-Z_0-9]+, )[a-zA-Z_0-9]+, ([a-zA-Z_0-9]+\);)/\1\2/' BUG=468039 Change-Id: I4c75fd95dff85ab1d4a546b05e6aed1aeeb499d8 Reviewed-on: https://boringssl-review.googlesource.com/5276 Reviewed-by: Adam Langley <agl@google.com>
2015-06-29 05:28:17 +01:00
OPENSSL_PUT_ERROR(ECDSA, ERR_R_OVERFLOW);
Implement ECDSA_SIG_{parse,marshal} with crypto/bytestring. This is the first structure to be implemented with the new BIGNUM ASN.1 routines. Object reuse in the legacy d2i/i2d functions is implemented by releasing whatever was in *out before and setting it to the newly-allocated object. As with the new d2i_SSL_SESSION, this is a weaker form of object reuse, but should suffice for reasonable callers. As ECDSA_SIG is more likely to be parsed alone than as part of another structure (and using CBB is slightly tedious), add convenient functions which take byte arrays. For consistency with SSL_SESSION, they are named to/from_bytes. from_bytes, unlike the CBS variant, rejects trailing data. Note this changes some test expectations: BER signatures now push an error code. That they didn't do this was probably a mistake. BUG=499653 Change-Id: I9ec74db53e70d9a989412cc9e2b599be0454caec Reviewed-on: https://boringssl-review.googlesource.com/5269 Reviewed-by: Adam Langley <agl@google.com>
2015-06-12 04:30:53 +01:00
OPENSSL_free(der);
return -1;
}
if (outp != NULL) {
if (*outp == NULL) {
*outp = der;
der = NULL;
} else {
memcpy(*outp, der, der_len);
*outp += der_len;
}
}
OPENSSL_free(der);
return (int)der_len;
}
Reference in New Issue Copy Permalink