[apple/xnu.git] / EXTERNAL_HEADERS / corecrypto / ccder.h

/*
 *  ccder.h
 *  corecrypto
 *
 *  Created on 03/14/2012
 *
 *  Copyright (c) 2012,2013,2014,2015 Apple Inc. All rights reserved.
 *
 */

#ifndef _CORECRYPTO_CCDER_H_
#define _CORECRYPTO_CCDER_H_

#include <corecrypto/ccasn1.h>
#include <corecrypto/ccn.h>

#define CCDER_MULTIBYTE_TAGS  1

#ifdef CCDER_MULTIBYTE_TAGS
typedef unsigned long ccder_tag;
#else
typedef uint8_t ccder_tag;
#endif

/* DER types to be used with ccder_decode and ccder_encode functions. */
enum {
    CCDER_EOL               = CCASN1_EOL,
    CCDER_BOOLEAN           = CCASN1_BOOLEAN,
    CCDER_INTEGER           = CCASN1_INTEGER,
    CCDER_BIT_STRING        = CCASN1_BIT_STRING,
    CCDER_OCTET_STRING      = CCASN1_OCTET_STRING,
    CCDER_NULL              = CCASN1_NULL,
    CCDER_OBJECT_IDENTIFIER = CCASN1_OBJECT_IDENTIFIER,
    CCDER_OBJECT_DESCRIPTOR = CCASN1_OBJECT_DESCRIPTOR,
    /* External or instance-of 0x08 */
    CCDER_REAL              = CCASN1_REAL,
    CCDER_ENUMERATED        = CCASN1_ENUMERATED,
    CCDER_EMBEDDED_PDV      = CCASN1_EMBEDDED_PDV,
    CCDER_UTF8_STRING       = CCASN1_UTF8_STRING,
    /*                         0x0d */
    /*                         0x0e */
    /*                         0x0f */
    CCDER_SEQUENCE          = CCASN1_SEQUENCE,
    CCDER_SET               = CCASN1_SET,
    CCDER_NUMERIC_STRING    = CCASN1_NUMERIC_STRING,
    CCDER_PRINTABLE_STRING  = CCASN1_PRINTABLE_STRING,
    CCDER_T61_STRING        = CCASN1_T61_STRING,
    CCDER_VIDEOTEX_STRING   = CCASN1_VIDEOTEX_STRING,
    CCDER_IA5_STRING        = CCASN1_IA5_STRING,
    CCDER_UTC_TIME          = CCASN1_UTC_TIME,
    CCDER_GENERALIZED_TIME  = CCASN1_GENERALIZED_TIME,
    CCDER_GRAPHIC_STRING    = CCASN1_GRAPHIC_STRING,
    CCDER_VISIBLE_STRING    = CCASN1_VISIBLE_STRING,
    CCDER_GENERAL_STRING    = CCASN1_GENERAL_STRING,
    CCDER_UNIVERSAL_STRING  = CCASN1_UNIVERSAL_STRING,
    /*                         0x1d */
    CCDER_BMP_STRING        = CCASN1_BMP_STRING,
    CCDER_HIGH_TAG_NUMBER   = CCASN1_HIGH_TAG_NUMBER,
    CCDER_TELETEX_STRING    = CCDER_T61_STRING,

#ifdef CCDER_MULTIBYTE_TAGS
    CCDER_TAG_MASK          = ((ccder_tag)~0),
    CCDER_TAGNUM_MASK       = ((ccder_tag)~((ccder_tag)7 << (sizeof(ccder_tag) * 8 - 3))),

    CCDER_METHOD_MASK       = ((ccder_tag)1 << (sizeof(ccder_tag) * 8 - 3)),
    CCDER_PRIMITIVE         = ((ccder_tag)0 << (sizeof(ccder_tag) * 8 - 3)),
    CCDER_CONSTRUCTED       = ((ccder_tag)1 << (sizeof(ccder_tag) * 8 - 3)),

    CCDER_CLASS_MASK        = ((ccder_tag)3 << (sizeof(ccder_tag) * 8 - 2)),
    CCDER_UNIVERSAL         = ((ccder_tag)0 << (sizeof(ccder_tag) * 8 - 2)),
    CCDER_APPLICATION       = ((ccder_tag)1 << (sizeof(ccder_tag) * 8 - 2)),
    CCDER_CONTEXT_SPECIFIC  = ((ccder_tag)2 << (sizeof(ccder_tag) * 8 - 2)),
    CCDER_PRIVATE           = ((ccder_tag)3 << (sizeof(ccder_tag) * 8 - 2)),
#else
    CCDER_TAG_MASK			= CCASN1_TAG_MASK,
    CCDER_TAGNUM_MASK		= CCASN1_TAGNUM_MASK,

    CCDER_METHOD_MASK		= CCASN1_METHOD_MASK,
    CCDER_PRIMITIVE         = CCASN1_PRIMITIVE,
    CCDER_CONSTRUCTED		= CCASN1_CONSTRUCTED,

    CCDER_CLASS_MASK		= CCASN1_CLASS_MASK,
    CCDER_UNIVERSAL         = CCASN1_UNIVERSAL,
    CCDER_APPLICATION		= CCASN1_APPLICATION,
    CCDER_CONTEXT_SPECIFIC	= CCASN1_CONTEXT_SPECIFIC,
    CCDER_PRIVATE			= CCASN1_PRIVATE,
#endif
    CCDER_CONSTRUCTED_SET   = CCDER_SET | CCDER_CONSTRUCTED,
    CCDER_CONSTRUCTED_SEQUENCE = CCDER_SEQUENCE | CCDER_CONSTRUCTED,
};


#define CC_NO_INLINE
// MARK: ccder_sizeof_ functions

/* Returns the size of an asn1 encoded item of length l in bytes. */
CC_NO_INLINE CC_CONST
size_t ccder_sizeof(ccder_tag tag, size_t len);

CC_NO_INLINE CC_PURE
size_t ccder_sizeof_implicit_integer(ccder_tag implicit_tag,
                                     cc_size n, const cc_unit *s);

CC_NO_INLINE CC_PURE
size_t ccder_sizeof_implicit_octet_string(ccder_tag implicit_tag,
                                          cc_size n, const cc_unit *s);

CC_NO_INLINE CC_CONST
size_t ccder_sizeof_implicit_raw_octet_string(ccder_tag implicit_tag,
                                              size_t s_size);
CC_NO_INLINE CC_CONST
size_t ccder_sizeof_implicit_uint64(ccder_tag implicit_tag, uint64_t value);

CC_NO_INLINE CC_PURE
size_t ccder_sizeof_integer(cc_size n, const cc_unit *s);

CC_NO_INLINE CC_CONST
size_t ccder_sizeof_len(size_t len);

CC_NO_INLINE CC_PURE
size_t ccder_sizeof_octet_string(cc_size n, const cc_unit *s);

CC_NO_INLINE CC_PURE
size_t ccder_sizeof_oid(ccoid_t oid);

CC_NO_INLINE CC_CONST
size_t ccder_sizeof_raw_octet_string(size_t s_size);

CC_NO_INLINE CC_CONST
size_t ccder_sizeof_tag(ccder_tag tag);

CC_NO_INLINE CC_CONST
size_t ccder_sizeof_uint64(uint64_t value);


// MARK: ccder_encode_ functions.

/* Encode a tag backwards, der_end should point to one byte past the end of
   destination for the tag, returns a pointer to the first byte of the tag.
   Returns NULL if there is an encoding error. */
CC_NO_INLINE CC_NONNULL2
uint8_t *ccder_encode_tag(ccder_tag tag, const uint8_t *der, uint8_t *der_end);

/* Returns a pointer to the start of the len field.  returns NULL if there
 is an encoding error. */
CC_NO_INLINE CC_NONNULL2
uint8_t *
ccder_encode_len(size_t len, const uint8_t *der, uint8_t *der_end);

/* der_end should point to the first byte of the content of this der item. */
CC_NO_INLINE CC_NONNULL3
uint8_t *
ccder_encode_tl(ccder_tag tag, size_t len, const uint8_t *der, uint8_t *der_end);

CC_NO_INLINE CC_PURE CC_NONNULL2
uint8_t *
ccder_encode_body_nocopy(size_t size, const uint8_t *der, uint8_t *der_end);

/* Encode the tag and length of a constructed object.  der is the lower
   bound, der_end is one byte paste where we want to write the length and
   body_end is one byte past the end of the body of the der object we are
   encoding the tag and length of. */
CC_NO_INLINE CC_NONNULL((2, 3))
uint8_t *
ccder_encode_constructed_tl(ccder_tag tag, const uint8_t *body_end,
                            const uint8_t *der, uint8_t *der_end);

/* Encodes oid into der and returns
 der + ccder_sizeof_oid(oid). */
CC_NO_INLINE CC_NONNULL_TU((1)) CC_NONNULL2
uint8_t *ccder_encode_oid(ccoid_t oid, const uint8_t *der, uint8_t *der_end);

CC_NO_INLINE CC_NONNULL((3, 4))
uint8_t *ccder_encode_implicit_integer(ccder_tag implicit_tag,
                                       cc_size n, const cc_unit *s,
                                       const uint8_t *der, uint8_t *der_end);

CC_NO_INLINE CC_NONNULL((2, 3))
uint8_t *ccder_encode_integer(cc_size n, const cc_unit *s,
                              const uint8_t *der, uint8_t *der_end);

CC_NO_INLINE CC_NONNULL3
uint8_t *ccder_encode_implicit_uint64(ccder_tag implicit_tag,
                                      uint64_t value,
                                      const uint8_t *der, uint8_t *der_end);

CC_NO_INLINE CC_NONNULL2
uint8_t *ccder_encode_uint64(uint64_t value,
                             const uint8_t *der, uint8_t *der_end);

CC_NO_INLINE CC_NONNULL((3, 4))
uint8_t *ccder_encode_implicit_octet_string(ccder_tag implicit_tag,
                                            cc_size n, const cc_unit *s,
                                            const uint8_t *der,
                                            uint8_t *der_end);

CC_NO_INLINE CC_NONNULL((2, 3))
uint8_t *ccder_encode_octet_string(cc_size n, const cc_unit *s,
                                   const uint8_t *der, uint8_t *der_end);

CC_NO_INLINE CC_NONNULL((3, 4))
uint8_t *ccder_encode_implicit_raw_octet_string(ccder_tag implicit_tag,
                                                size_t s_size, const uint8_t *s,
                                                const uint8_t *der,
                                                uint8_t *der_end);

CC_NO_INLINE CC_NONNULL((2, 3))
uint8_t *ccder_encode_raw_octet_string(size_t s_size, const uint8_t *s,
                                       const uint8_t *der, uint8_t *der_end);

/* ccder_encode_body COPIES the body into the der.
   It's inefficient – especially when you already have to convert to get to
   the form for the body.
   see encode integer for the right way to unify conversion and insertion */
CC_NO_INLINE CC_NONNULL3
uint8_t *
ccder_encode_body(size_t size, const uint8_t* body,
                  const uint8_t *der, uint8_t *der_end);

// MARK: ccder_decode_ functions.

/* Returns a pointer to the start of the length field, and returns the decoded tag in tag.
 returns NULL if there is a decoding error. */
CC_NO_INLINE CC_NONNULL((1, 3))
const uint8_t *ccder_decode_tag(ccder_tag *tagp, const uint8_t *der, const uint8_t *der_end);

CC_NO_INLINE CC_NONNULL((1, 3))
const uint8_t *ccder_decode_len(size_t *lenp, const uint8_t *der, const uint8_t *der_end);

/* Returns a pointer to the start of the der object, and returns the length in len.
 returns NULL if there is a decoding error. */
CC_NO_INLINE CC_NONNULL((2, 4))
const uint8_t *ccder_decode_tl(ccder_tag expected_tag, size_t *lenp,
                               const uint8_t *der, const uint8_t *der_end);

CC_NO_INLINE CC_NONNULL((2, 4))
const uint8_t *
ccder_decode_constructed_tl(ccder_tag expected_tag, const uint8_t **body_end,
                            const uint8_t *der, const uint8_t *der_end);

CC_NO_INLINE CC_NONNULL((1, 3))
const uint8_t *
ccder_decode_sequence_tl(const uint8_t **body_end,
                         const uint8_t *der, const uint8_t *der_end);

CC_NO_INLINE CC_NONNULL((2, 4))
const uint8_t *ccder_decode_uint(cc_size n, cc_unit *r,
                                 const uint8_t *der, const uint8_t *der_end);

CC_NO_INLINE CC_NONNULL((3))
const uint8_t *ccder_decode_uint64(uint64_t* r,
                                   const uint8_t *der, const uint8_t *der_end);

/* Decode SEQUENCE { r, s -- (unsigned)integer } in der into r and s.
   Returns NULL on decode errors, returns pointer just past the end of the
   sequence of integers otherwise. */
CC_NO_INLINE CC_NONNULL((2, 3, 5))
const uint8_t *ccder_decode_seqii(cc_size n, cc_unit *r, cc_unit *s,
                                  const uint8_t *der, const uint8_t *der_end);
CC_NO_INLINE CC_NONNULL_TU((1)) CC_NONNULL((3))
const uint8_t *ccder_decode_oid(ccoid_t *oidp,
                                const uint8_t *der, const uint8_t *der_end);

CC_NO_INLINE CC_NONNULL((1,2,4))
const uint8_t *ccder_decode_bitstring(const uint8_t **bit_string,
                                size_t *bit_length,
                                const uint8_t *der, const uint8_t *der_end);

CC_NO_INLINE CC_NONNULL_TU((4)) CC_NONNULL((1,2,3,5,6,8))
const uint8_t *ccder_decode_eckey(uint64_t *version,
                                  size_t *priv_size, const uint8_t **priv_key,
                                  ccoid_t *oid,
                                  size_t *pub_size, const uint8_t **pub_key,
                                  const uint8_t *der, const uint8_t *der_end);

#ifndef CCDER_MULTIBYTE_TAGS
#include <corecrypto/ccder_decode_constructed_tl.h>
#include <corecrypto/ccder_decode_len.h>
#include <corecrypto/ccder_decode_oid.h>
#include <corecrypto/ccder_decode_seqii.h>
#include <corecrypto/ccder_decode_sequence_tl.h>
#include <corecrypto/ccder_decode_tag.h>
#include <corecrypto/ccder_decode_tl.h>
#include <corecrypto/ccder_decode_uint.h>
#include <corecrypto/ccder_decode_bitstring.h>
#include <corecrypto/ccder_decode_eckey.h>
#include <corecrypto/ccder_encode_body_nocopy.h>
#include <corecrypto/ccder_encode_constructed_tl.h>
#include <corecrypto/ccder_encode_implicit_integer.h>
#include <corecrypto/ccder_encode_implicit_octet_string.h>
#include <corecrypto/ccder_encode_implicit_uint64.h>
#include <corecrypto/ccder_encode_integer.h>
#include <corecrypto/ccder_encode_len.h>
#include <corecrypto/ccder_encode_octet_string.h>
#include <corecrypto/ccder_encode_oid.h>
#include <corecrypto/ccder_encode_tag.h>
#include <corecrypto/ccder_encode_tl.h>
#include <corecrypto/ccder_encode_uint64.h>
#include <corecrypto/ccder_sizeof.h>
#include <corecrypto/ccder_sizeof_integer.h>
#include <corecrypto/ccder_sizeof_len.h>
#include <corecrypto/ccder_sizeof_oid.h>
#include <corecrypto/ccder_sizeof_tag.h>
#endif

#endif /* _CORECRYPTO_CCDER_H_ */
Commit	Line	Data
316670eb A	1	/*
	2	* ccder.h
	3	* corecrypto
	4	*
3e170ce0 A	5	* Created on 03/14/2012
	6	*
	7	* Copyright (c) 2012,2013,2014,2015 Apple Inc. All rights reserved.
316670eb A	8	*
	9	*/
	10
	11	#ifndef _CORECRYPTO_CCDER_H_
	12	#define _CORECRYPTO_CCDER_H_
	13
	14	#include <corecrypto/ccasn1.h>
	15	#include <corecrypto/ccn.h>
	16
	17	#define CCDER_MULTIBYTE_TAGS 1
	18
	19	#ifdef CCDER_MULTIBYTE_TAGS
	20	typedef unsigned long ccder_tag;
	21	#else
	22	typedef uint8_t ccder_tag;
	23	#endif
	24
	25	/* DER types to be used with ccder_decode and ccder_encode functions. */
	26	enum {
	27	CCDER_EOL = CCASN1_EOL,
	28	CCDER_BOOLEAN = CCASN1_BOOLEAN,
	29	CCDER_INTEGER = CCASN1_INTEGER,
	30	CCDER_BIT_STRING = CCASN1_BIT_STRING,
	31	CCDER_OCTET_STRING = CCASN1_OCTET_STRING,
	32	CCDER_NULL = CCASN1_NULL,
	33	CCDER_OBJECT_IDENTIFIER = CCASN1_OBJECT_IDENTIFIER,
	34	CCDER_OBJECT_DESCRIPTOR = CCASN1_OBJECT_DESCRIPTOR,
	35	/* External or instance-of 0x08 */
	36	CCDER_REAL = CCASN1_REAL,
	37	CCDER_ENUMERATED = CCASN1_ENUMERATED,
	38	CCDER_EMBEDDED_PDV = CCASN1_EMBEDDED_PDV,
	39	CCDER_UTF8_STRING = CCASN1_UTF8_STRING,
	40	/* 0x0d */
	41	/* 0x0e */
	42	/* 0x0f */
	43	CCDER_SEQUENCE = CCASN1_SEQUENCE,
	44	CCDER_SET = CCASN1_SET,
	45	CCDER_NUMERIC_STRING = CCASN1_NUMERIC_STRING,
	46	CCDER_PRINTABLE_STRING = CCASN1_PRINTABLE_STRING,
	47	CCDER_T61_STRING = CCASN1_T61_STRING,
	48	CCDER_VIDEOTEX_STRING = CCASN1_VIDEOTEX_STRING,
	49	CCDER_IA5_STRING = CCASN1_IA5_STRING,
	50	CCDER_UTC_TIME = CCASN1_UTC_TIME,
	51	CCDER_GENERALIZED_TIME = CCASN1_GENERALIZED_TIME,
	52	CCDER_GRAPHIC_STRING = CCASN1_GRAPHIC_STRING,
	53	CCDER_VISIBLE_STRING = CCASN1_VISIBLE_STRING,
	54	CCDER_GENERAL_STRING = CCASN1_GENERAL_STRING,
	55	CCDER_UNIVERSAL_STRING = CCASN1_UNIVERSAL_STRING,
	56	/* 0x1d */
	57	CCDER_BMP_STRING = CCASN1_BMP_STRING,
	58	CCDER_HIGH_TAG_NUMBER = CCASN1_HIGH_TAG_NUMBER,
	59	CCDER_TELETEX_STRING = CCDER_T61_STRING,
	60
	61	#ifdef CCDER_MULTIBYTE_TAGS
	62	CCDER_TAG_MASK = ((ccder_tag)~0),
	63	CCDER_TAGNUM_MASK = ((ccder_tag)~((ccder_tag)7 << (sizeof(ccder_tag) * 8 - 3))),
	64
	65	CCDER_METHOD_MASK = ((ccder_tag)1 << (sizeof(ccder_tag) * 8 - 3)),
	66	CCDER_PRIMITIVE = ((ccder_tag)0 << (sizeof(ccder_tag) * 8 - 3)),
	67	CCDER_CONSTRUCTED = ((ccder_tag)1 << (sizeof(ccder_tag) * 8 - 3)),
	68
	69	CCDER_CLASS_MASK = ((ccder_tag)3 << (sizeof(ccder_tag) * 8 - 2)),
	70	CCDER_UNIVERSAL = ((ccder_tag)0 << (sizeof(ccder_tag) * 8 - 2)),
	71	CCDER_APPLICATION = ((ccder_tag)1 << (sizeof(ccder_tag) * 8 - 2)),
72	CCDER_CONTEXT_SPECIFIC = ((ccder_tag)2 << (sizeof(ccder_tag) * 8 - 2)),
73	CCDER_PRIVATE = ((ccder_tag)3 << (sizeof(ccder_tag) * 8 - 2)),
74	#else
75	CCDER_TAG_MASK = CCASN1_TAG_MASK,
76	CCDER_TAGNUM_MASK = CCASN1_TAGNUM_MASK,
77
78	CCDER_METHOD_MASK = CCASN1_METHOD_MASK,
79	CCDER_PRIMITIVE = CCASN1_PRIMITIVE,
80	CCDER_CONSTRUCTED = CCASN1_CONSTRUCTED,
81
82	CCDER_CLASS_MASK = CCASN1_CLASS_MASK,
83	CCDER_UNIVERSAL = CCASN1_UNIVERSAL,
84	CCDER_APPLICATION = CCASN1_APPLICATION,
85	CCDER_CONTEXT_SPECIFIC = CCASN1_CONTEXT_SPECIFIC,
86	CCDER_PRIVATE = CCASN1_PRIVATE,
87	#endif
88	CCDER_CONSTRUCTED_SET = CCDER_SET \| CCDER_CONSTRUCTED,
89	CCDER_CONSTRUCTED_SEQUENCE = CCDER_SEQUENCE \| CCDER_CONSTRUCTED,
90	};
91
92
fe8ab488 A	93	#define CC_NO_INLINE
fe8ab488 A	94	// MARK: ccder_sizeof_ functions
316670eb	95
fe8ab488 A	96	/* Returns the size of an asn1 encoded item of length l in bytes. */
	97	CC_NO_INLINE CC_CONST
	98	size_t ccder_sizeof(ccder_tag tag, size_t len);
	99
	100	CC_NO_INLINE CC_PURE
	101	size_t ccder_sizeof_implicit_integer(ccder_tag implicit_tag,
	102	cc_size n, const cc_unit *s);
	103
	104	CC_NO_INLINE CC_PURE
	105	size_t ccder_sizeof_implicit_octet_string(ccder_tag implicit_tag,
	106	cc_size n, const cc_unit *s);
316670eb	107
fe8ab488 A	108	CC_NO_INLINE CC_CONST
	109	size_t ccder_sizeof_implicit_raw_octet_string(ccder_tag implicit_tag,
	110	size_t s_size);
	111	CC_NO_INLINE CC_CONST
	112	size_t ccder_sizeof_implicit_uint64(ccder_tag implicit_tag, uint64_t value);
	113
	114	CC_NO_INLINE CC_PURE
	115	size_t ccder_sizeof_integer(cc_size n, const cc_unit *s);
	116
	117	CC_NO_INLINE CC_CONST
316670eb A	118	size_t ccder_sizeof_len(size_t len);
316670eb A	119
fe8ab488 A	120	CC_NO_INLINE CC_PURE
fe8ab488 A	121	size_t ccder_sizeof_octet_string(cc_size n, const cc_unit *s);
316670eb	122
fe8ab488	123	CC_NO_INLINE CC_PURE
316670eb A	124	size_t ccder_sizeof_oid(ccoid_t oid);
316670eb A	125
fe8ab488 A	126	CC_NO_INLINE CC_CONST
	127	size_t ccder_sizeof_raw_octet_string(size_t s_size);
	128
	129	CC_NO_INLINE CC_CONST
	130	size_t ccder_sizeof_tag(ccder_tag tag);
	131
	132	CC_NO_INLINE CC_CONST
	133	size_t ccder_sizeof_uint64(uint64_t value);
	134
	135
	136	// MARK: ccder_encode_ functions.
316670eb A	137
	138	/* Encode a tag backwards, der_end should point to one byte past the end of
	139	destination for the tag, returns a pointer to the first byte of the tag.
	140	Returns NULL if there is an encoding error. */
fe8ab488	141	CC_NO_INLINE CC_NONNULL2
316670eb A	142	uint8_t ccder_encode_tag(ccder_tag tag, const uint8_t der, uint8_t *der_end);
	143
	144	/* Returns a pointer to the start of the len field. returns NULL if there
	145	is an encoding error. */
fe8ab488	146	CC_NO_INLINE CC_NONNULL2
316670eb A	147	uint8_t *
	148	ccder_encode_len(size_t len, const uint8_t der, uint8_t der_end);
	149
	150	/* der_end should point to the first byte of the content of this der item. */
fe8ab488	151	CC_NO_INLINE CC_NONNULL3
316670eb A	152	uint8_t *
	153	ccder_encode_tl(ccder_tag tag, size_t len, const uint8_t der, uint8_t der_end);
	154
fe8ab488	155	CC_NO_INLINE CC_PURE CC_NONNULL2
316670eb A	156	uint8_t *
	157	ccder_encode_body_nocopy(size_t size, const uint8_t der, uint8_t der_end);
	158
	159	/* Encode the tag and length of a constructed object. der is the lower
	160	bound, der_end is one byte paste where we want to write the length and
	161	body_end is one byte past the end of the body of the der object we are
	162	encoding the tag and length of. */
fe8ab488	163	CC_NO_INLINE CC_NONNULL((2, 3))
316670eb A	164	uint8_t *
	165	ccder_encode_constructed_tl(ccder_tag tag, const uint8_t *body_end,
	166	const uint8_t der, uint8_t der_end);
	167
	168	/* Encodes oid into der and returns
	169	der + ccder_sizeof_oid(oid). */
fe8ab488	170	CC_NO_INLINE CC_NONNULL_TU((1)) CC_NONNULL2
316670eb A	171	uint8_t ccder_encode_oid(ccoid_t oid, const uint8_t der, uint8_t *der_end);
316670eb A	172
fe8ab488	173	CC_NO_INLINE CC_NONNULL((3, 4))
316670eb A	174	uint8_t *ccder_encode_implicit_integer(ccder_tag implicit_tag,
	175	cc_size n, const cc_unit *s,
	176	const uint8_t der, uint8_t der_end);
	177
fe8ab488	178	CC_NO_INLINE CC_NONNULL((2, 3))
316670eb A	179	uint8_t ccder_encode_integer(cc_size n, const cc_unit s,
	180	const uint8_t der, uint8_t der_end);
	181
fe8ab488	182	CC_NO_INLINE CC_NONNULL3
316670eb A	183	uint8_t *ccder_encode_implicit_uint64(ccder_tag implicit_tag,
	184	uint64_t value,
	185	const uint8_t der, uint8_t der_end);
	186
fe8ab488	187	CC_NO_INLINE CC_NONNULL2
316670eb A	188	uint8_t *ccder_encode_uint64(uint64_t value,
	189	const uint8_t der, uint8_t der_end);
	190
fe8ab488	191	CC_NO_INLINE CC_NONNULL((3, 4))
316670eb A	192	uint8_t *ccder_encode_implicit_octet_string(ccder_tag implicit_tag,
	193	cc_size n, const cc_unit *s,
	194	const uint8_t *der,
	195	uint8_t *der_end);
	196
fe8ab488	197	CC_NO_INLINE CC_NONNULL((2, 3))
316670eb A	198	uint8_t ccder_encode_octet_string(cc_size n, const cc_unit s,
	199	const uint8_t der, uint8_t der_end);
	200
fe8ab488	201	CC_NO_INLINE CC_NONNULL((3, 4))
316670eb A	202	uint8_t *ccder_encode_implicit_raw_octet_string(ccder_tag implicit_tag,
	203	size_t s_size, const uint8_t *s,
	204	const uint8_t *der,
	205	uint8_t *der_end);
	206
fe8ab488	207	CC_NO_INLINE CC_NONNULL((2, 3))
316670eb A	208	uint8_t ccder_encode_raw_octet_string(size_t s_size, const uint8_t s,
	209	const uint8_t der, uint8_t der_end);
	210
	211	/* ccder_encode_body COPIES the body into the der.
	212	It's inefficient – especially when you already have to convert to get to
	213	the form for the body.
	214	see encode integer for the right way to unify conversion and insertion */
fe8ab488	215	CC_NO_INLINE CC_NONNULL3
316670eb A	216	uint8_t *
	217	ccder_encode_body(size_t size, const uint8_t* body,
	218	const uint8_t der, uint8_t der_end);
	219
fe8ab488	220	// MARK: ccder_decode_ functions.
316670eb A	221
	222	/* Returns a pointer to the start of the length field, and returns the decoded tag in tag.
	223	returns NULL if there is a decoding error. */
fe8ab488	224	CC_NO_INLINE CC_NONNULL((1, 3))
316670eb A	225	const uint8_t ccder_decode_tag(ccder_tag tagp, const uint8_t der, const uint8_t der_end);
316670eb A	226
fe8ab488	227	CC_NO_INLINE CC_NONNULL((1, 3))
316670eb A	228	const uint8_t ccder_decode_len(size_t lenp, const uint8_t der, const uint8_t der_end);
	229
	230	/* Returns a pointer to the start of the der object, and returns the length in len.
	231	returns NULL if there is a decoding error. */
fe8ab488	232	CC_NO_INLINE CC_NONNULL((2, 4))
316670eb A	233	const uint8_t ccder_decode_tl(ccder_tag expected_tag, size_t lenp,
	234	const uint8_t der, const uint8_t der_end);
	235
fe8ab488	236	CC_NO_INLINE CC_NONNULL((2, 4))
316670eb A	237	const uint8_t *
	238	ccder_decode_constructed_tl(ccder_tag expected_tag, const uint8_t **body_end,
	239	const uint8_t der, const uint8_t der_end);
	240
fe8ab488	241	CC_NO_INLINE CC_NONNULL((1, 3))
316670eb A	242	const uint8_t *
	243	ccder_decode_sequence_tl(const uint8_t **body_end,
	244	const uint8_t der, const uint8_t der_end);
	245
fe8ab488	246	CC_NO_INLINE CC_NONNULL((2, 4))
316670eb A	247	const uint8_t ccder_decode_uint(cc_size n, cc_unit r,
	248	const uint8_t der, const uint8_t der_end);
	249
3e170ce0	250	CC_NO_INLINE CC_NONNULL((3))
316670eb A	251	const uint8_t ccder_decode_uint64(uint64_t r,
	252	const uint8_t der, const uint8_t der_end);
	253
	254	/* Decode SEQUENCE { r, s -- (unsigned)integer } in der into r and s.
	255	Returns NULL on decode errors, returns pointer just past the end of the
	256	sequence of integers otherwise. */
fe8ab488	257	CC_NO_INLINE CC_NONNULL((2, 3, 5))
316670eb A	258	const uint8_t ccder_decode_seqii(cc_size n, cc_unit r, cc_unit *s,
316670eb A	259	const uint8_t der, const uint8_t der_end);
fe8ab488	260	CC_NO_INLINE CC_NONNULL_TU((1)) CC_NONNULL((3))
316670eb A	261	const uint8_t ccder_decode_oid(ccoid_t oidp,
	262	const uint8_t der, const uint8_t der_end);
	263
3e170ce0	264	CC_NO_INLINE CC_NONNULL((1,2,4))
fe8ab488 A	265	const uint8_t ccder_decode_bitstring(const uint8_t *bit_string,
	266	size_t *bit_length,
	267	const uint8_t der, const uint8_t der_end);
	268
3e170ce0	269	CC_NO_INLINE CC_NONNULL_TU((4)) CC_NONNULL((1,2,3,5,6,8))
fe8ab488 A	270	const uint8_t ccder_decode_eckey(uint64_t version,
	271	size_t priv_size, const uint8_t *priv_key,
	272	ccoid_t *oid,
	273	size_t pub_size, const uint8_t *pub_key,
	274	const uint8_t der, const uint8_t der_end);
	275
316670eb A	276	#ifndef CCDER_MULTIBYTE_TAGS
	277	#include <corecrypto/ccder_decode_constructed_tl.h>
	278	#include <corecrypto/ccder_decode_len.h>
	279	#include <corecrypto/ccder_decode_oid.h>
	280	#include <corecrypto/ccder_decode_seqii.h>
	281	#include <corecrypto/ccder_decode_sequence_tl.h>
	282	#include <corecrypto/ccder_decode_tag.h>
	283	#include <corecrypto/ccder_decode_tl.h>
	284	#include <corecrypto/ccder_decode_uint.h>
fe8ab488 A	285	#include <corecrypto/ccder_decode_bitstring.h>
fe8ab488 A	286	#include <corecrypto/ccder_decode_eckey.h>
316670eb A	287	#include <corecrypto/ccder_encode_body_nocopy.h>
	288	#include <corecrypto/ccder_encode_constructed_tl.h>
	289	#include <corecrypto/ccder_encode_implicit_integer.h>
	290	#include <corecrypto/ccder_encode_implicit_octet_string.h>
	291	#include <corecrypto/ccder_encode_implicit_uint64.h>
	292	#include <corecrypto/ccder_encode_integer.h>
	293	#include <corecrypto/ccder_encode_len.h>
	294	#include <corecrypto/ccder_encode_octet_string.h>
	295	#include <corecrypto/ccder_encode_oid.h>
	296	#include <corecrypto/ccder_encode_tag.h>
	297	#include <corecrypto/ccder_encode_tl.h>
	298	#include <corecrypto/ccder_encode_uint64.h>
	299	#include <corecrypto/ccder_sizeof.h>
fe8ab488	300	#include <corecrypto/ccder_sizeof_integer.h>
316670eb A	301	#include <corecrypto/ccder_sizeof_len.h>
	302	#include <corecrypto/ccder_sizeof_oid.h>
	303	#include <corecrypto/ccder_sizeof_tag.h>
	304	#endif
	305
	306	#endif /* _CORECRYPTO_CCDER_H_ */