pineapple-src/externals/libressl/ssl/bs_cbs.c

616 lines
11 KiB
C
Raw Normal View History

2022-04-24 20:29:35 +00:00
/* $OpenBSD: bs_cbs.c,v 1.24 2021/12/15 17:36:49 jsing Exp $ */
2020-12-28 15:15:37 +00:00
/*
* Copyright (c) 2014, Google Inc.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
2022-04-24 20:29:35 +00:00
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
2020-12-28 15:15:37 +00:00
#include <stdlib.h>
#include <string.h>
#include "bytestring.h"
void
CBS_init(CBS *cbs, const uint8_t *data, size_t len)
{
cbs->data = data;
cbs->initial_len = len;
cbs->len = len;
}
void
CBS_dup(const CBS *cbs, CBS *out)
{
CBS_init(out, CBS_data(cbs), CBS_len(cbs));
out->initial_len = cbs->initial_len;
}
static int
cbs_get(CBS *cbs, const uint8_t **p, size_t n)
{
if (cbs->len < n)
return 0;
*p = cbs->data;
cbs->data += n;
cbs->len -= n;
return 1;
}
2022-04-24 20:29:35 +00:00
static int
cbs_peek(CBS *cbs, const uint8_t **p, size_t n)
{
if (cbs->len < n)
return 0;
*p = cbs->data;
return 1;
}
2020-12-28 15:15:37 +00:00
size_t
CBS_offset(const CBS *cbs)
{
return cbs->initial_len - cbs->len;
}
int
CBS_skip(CBS *cbs, size_t len)
{
const uint8_t *dummy;
return cbs_get(cbs, &dummy, len);
}
const uint8_t *
CBS_data(const CBS *cbs)
{
return cbs->data;
}
size_t
CBS_len(const CBS *cbs)
{
return cbs->len;
}
int
CBS_stow(const CBS *cbs, uint8_t **out_ptr, size_t *out_len)
{
free(*out_ptr);
*out_ptr = NULL;
*out_len = 0;
if (cbs->len == 0)
return 1;
if ((*out_ptr = malloc(cbs->len)) == NULL)
return 0;
memcpy(*out_ptr, cbs->data, cbs->len);
*out_len = cbs->len;
return 1;
}
int
CBS_strdup(const CBS *cbs, char **out_ptr)
{
free(*out_ptr);
2022-04-24 20:29:35 +00:00
*out_ptr = NULL;
if (CBS_contains_zero_byte(cbs))
return 0;
2020-12-28 15:15:37 +00:00
*out_ptr = strndup((const char *)cbs->data, cbs->len);
return (*out_ptr != NULL);
}
int
CBS_write_bytes(const CBS *cbs, uint8_t *dst, size_t dst_len, size_t *copied)
{
if (dst_len < cbs->len)
return 0;
memmove(dst, cbs->data, cbs->len);
if (copied != NULL)
*copied = cbs->len;
return 1;
}
int
CBS_contains_zero_byte(const CBS *cbs)
{
return memchr(cbs->data, 0, cbs->len) != NULL;
}
int
CBS_mem_equal(const CBS *cbs, const uint8_t *data, size_t len)
{
if (len != cbs->len)
return 0;
return timingsafe_memcmp(cbs->data, data, len) == 0;
}
static int
cbs_get_u(CBS *cbs, uint32_t *out, size_t len)
{
uint32_t result = 0;
size_t i;
const uint8_t *data;
if (len < 1 || len > 4)
return 0;
if (!cbs_get(cbs, &data, len))
return 0;
for (i = 0; i < len; i++) {
result <<= 8;
result |= data[i];
}
*out = result;
return 1;
}
int
CBS_get_u8(CBS *cbs, uint8_t *out)
{
const uint8_t *v;
if (!cbs_get(cbs, &v, 1))
return 0;
*out = *v;
return 1;
}
int
CBS_get_u16(CBS *cbs, uint16_t *out)
{
uint32_t v;
if (!cbs_get_u(cbs, &v, 2))
return 0;
*out = v;
return 1;
}
int
CBS_get_u24(CBS *cbs, uint32_t *out)
{
return cbs_get_u(cbs, out, 3);
}
int
CBS_get_u32(CBS *cbs, uint32_t *out)
{
return cbs_get_u(cbs, out, 4);
}
2022-04-24 20:29:35 +00:00
int
CBS_get_u64(CBS *cbs, uint64_t *out)
{
uint32_t a, b;
if (cbs->len < 8)
return 0;
if (!CBS_get_u32(cbs, &a))
return 0;
if (!CBS_get_u32(cbs, &b))
return 0;
*out = (uint64_t)a << 32 | b;
return 1;
}
int
CBS_get_last_u8(CBS *cbs, uint8_t *out)
{
if (cbs->len == 0)
return 0;
*out = cbs->data[cbs->len - 1];
cbs->len--;
return 1;
}
2020-12-28 15:15:37 +00:00
int
CBS_get_bytes(CBS *cbs, CBS *out, size_t len)
{
const uint8_t *v;
if (!cbs_get(cbs, &v, len))
return 0;
CBS_init(out, v, len);
return 1;
}
static int
cbs_get_length_prefixed(CBS *cbs, CBS *out, size_t len_len)
{
uint32_t len;
if (!cbs_get_u(cbs, &len, len_len))
return 0;
return CBS_get_bytes(cbs, out, len);
}
int
CBS_get_u8_length_prefixed(CBS *cbs, CBS *out)
{
return cbs_get_length_prefixed(cbs, out, 1);
}
int
CBS_get_u16_length_prefixed(CBS *cbs, CBS *out)
{
return cbs_get_length_prefixed(cbs, out, 2);
}
int
CBS_get_u24_length_prefixed(CBS *cbs, CBS *out)
{
return cbs_get_length_prefixed(cbs, out, 3);
}
2022-04-24 20:29:35 +00:00
static int
cbs_peek_u(CBS *cbs, uint32_t *out, size_t len)
{
uint32_t result = 0;
size_t i;
const uint8_t *data;
if (len < 1 || len > 4)
return 0;
if (!cbs_peek(cbs, &data, len))
return 0;
for (i = 0; i < len; i++) {
result <<= 8;
result |= data[i];
}
*out = result;
return 1;
}
int
CBS_peek_u8(CBS *cbs, uint8_t *out)
{
const uint8_t *v;
if (!cbs_peek(cbs, &v, 1))
return 0;
*out = *v;
return 1;
}
int
CBS_peek_u16(CBS *cbs, uint16_t *out)
{
uint32_t v;
if (!cbs_peek_u(cbs, &v, 2))
return 0;
*out = v;
return 1;
}
int
CBS_peek_u24(CBS *cbs, uint32_t *out)
{
return cbs_peek_u(cbs, out, 3);
}
int
CBS_peek_u32(CBS *cbs, uint32_t *out)
{
return cbs_peek_u(cbs, out, 4);
}
int
CBS_peek_last_u8(CBS *cbs, uint8_t *out)
{
if (cbs->len == 0)
return 0;
*out = cbs->data[cbs->len - 1];
return 1;
}
2020-12-28 15:15:37 +00:00
int
CBS_get_any_asn1_element(CBS *cbs, CBS *out, unsigned int *out_tag,
size_t *out_header_len)
{
return cbs_get_any_asn1_element_internal(cbs, out, out_tag,
out_header_len, 1);
}
/*
* Review X.690 for details on ASN.1 DER encoding.
*
* If non-strict mode is enabled, then DER rules are relaxed
* for indefinite constructs (violates DER but a little closer to BER).
* Non-strict mode should only be used by bs_ber.c
*
* Sections 8, 10 and 11 for DER encoding
*/
int
cbs_get_any_asn1_element_internal(CBS *cbs, CBS *out, unsigned int *out_tag,
size_t *out_header_len, int strict)
{
uint8_t tag, length_byte;
CBS header = *cbs;
CBS throwaway;
size_t len;
if (out == NULL)
out = &throwaway;
/*
* Get identifier octet and length octet. Only 1 octet for each
* is a CBS limitation.
*/
if (!CBS_get_u8(&header, &tag) || !CBS_get_u8(&header, &length_byte))
return 0;
/* CBS limitation: long form tags are not supported. */
if ((tag & 0x1f) == 0x1f)
return 0;
if (out_tag != NULL)
*out_tag = tag;
if ((length_byte & 0x80) == 0) {
/* Short form length. */
len = ((size_t) length_byte) + 2;
if (out_header_len != NULL)
*out_header_len = 2;
} else {
/* Long form length. */
const size_t num_bytes = length_byte & 0x7f;
uint32_t len32;
/* ASN.1 reserved value for future extensions */
if (num_bytes == 0x7f)
return 0;
/* Handle indefinite form length */
if (num_bytes == 0) {
/* DER encoding doesn't allow for indefinite form. */
if (strict)
return 0;
/* Primitive cannot use indefinite in BER or DER. */
if ((tag & CBS_ASN1_CONSTRUCTED) == 0)
return 0;
/* Constructed, indefinite length allowed in BER. */
if (out_header_len != NULL)
*out_header_len = 2;
return CBS_get_bytes(cbs, out, 2);
}
/* CBS limitation. */
if (num_bytes > 4)
return 0;
if (!cbs_get_u(&header, &len32, num_bytes))
return 0;
/* DER has a minimum length octet requirement. */
if (len32 < 128)
/* Should have used short form instead */
return 0;
if ((len32 >> ((num_bytes - 1) * 8)) == 0)
/* Length should have been at least one byte shorter. */
return 0;
len = len32;
if (len + 2 + num_bytes < len)
/* Overflow. */
return 0;
len += 2 + num_bytes;
if (out_header_len != NULL)
*out_header_len = 2 + num_bytes;
}
return CBS_get_bytes(cbs, out, len);
}
static int
cbs_get_asn1(CBS *cbs, CBS *out, unsigned int tag_value, int skip_header)
{
size_t header_len;
unsigned int tag;
CBS throwaway;
if (out == NULL)
out = &throwaway;
if (!CBS_get_any_asn1_element(cbs, out, &tag, &header_len) ||
tag != tag_value)
return 0;
if (skip_header && !CBS_skip(out, header_len))
return 0;
return 1;
}
int
CBS_get_asn1(CBS *cbs, CBS *out, unsigned int tag_value)
{
return cbs_get_asn1(cbs, out, tag_value, 1 /* skip header */);
}
int
CBS_get_asn1_element(CBS *cbs, CBS *out, unsigned int tag_value)
{
return cbs_get_asn1(cbs, out, tag_value, 0 /* include header */);
}
int
CBS_peek_asn1_tag(const CBS *cbs, unsigned int tag_value)
{
if (CBS_len(cbs) < 1)
return 0;
/*
* Tag number 31 indicates the start of a long form number.
* This is valid in ASN.1, but CBS only supports short form.
*/
if ((tag_value & 0x1f) == 0x1f)
return 0;
return CBS_data(cbs)[0] == tag_value;
}
/* Encoding details are in ASN.1: X.690 section 8.3 */
int
CBS_get_asn1_uint64(CBS *cbs, uint64_t *out)
{
CBS bytes;
const uint8_t *data;
size_t i, len;
if (!CBS_get_asn1(cbs, &bytes, CBS_ASN1_INTEGER))
return 0;
*out = 0;
data = CBS_data(&bytes);
len = CBS_len(&bytes);
if (len == 0)
/* An INTEGER is encoded with at least one content octet. */
return 0;
if ((data[0] & 0x80) != 0)
/* Negative number. */
return 0;
if (data[0] == 0 && len > 1 && (data[1] & 0x80) == 0)
/* Violates smallest encoding rule: excessive leading zeros. */
return 0;
for (i = 0; i < len; i++) {
if ((*out >> 56) != 0)
/* Too large to represent as a uint64_t. */
return 0;
*out <<= 8;
*out |= data[i];
}
return 1;
}
int
CBS_get_optional_asn1(CBS *cbs, CBS *out, int *out_present, unsigned int tag)
{
if (CBS_peek_asn1_tag(cbs, tag)) {
if (!CBS_get_asn1(cbs, out, tag))
return 0;
*out_present = 1;
} else {
*out_present = 0;
}
return 1;
}
int
CBS_get_optional_asn1_octet_string(CBS *cbs, CBS *out, int *out_present,
unsigned int tag)
{
CBS child;
int present;
if (!CBS_get_optional_asn1(cbs, &child, &present, tag))
return 0;
if (present) {
if (!CBS_get_asn1(&child, out, CBS_ASN1_OCTETSTRING) ||
CBS_len(&child) != 0)
return 0;
} else {
CBS_init(out, NULL, 0);
}
if (out_present)
*out_present = present;
return 1;
}
int
CBS_get_optional_asn1_uint64(CBS *cbs, uint64_t *out, unsigned int tag,
uint64_t default_value)
{
CBS child;
int present;
if (!CBS_get_optional_asn1(cbs, &child, &present, tag))
return 0;
if (present) {
if (!CBS_get_asn1_uint64(&child, out) ||
CBS_len(&child) != 0)
return 0;
} else {
*out = default_value;
}
return 1;
}
int
CBS_get_optional_asn1_bool(CBS *cbs, int *out, unsigned int tag,
int default_value)
{
CBS child, child2;
int present;
if (!CBS_get_optional_asn1(cbs, &child, &present, tag))
return 0;
if (present) {
uint8_t boolean;
if (!CBS_get_asn1(&child, &child2, CBS_ASN1_BOOLEAN) ||
CBS_len(&child2) != 1 || CBS_len(&child) != 0)
return 0;
boolean = CBS_data(&child2)[0];
if (boolean == 0)
*out = 0;
else if (boolean == 0xff)
*out = 1;
else
return 0;
} else {
*out = default_value;
}
return 1;
}