/external/libder/Makefile

	external/liblua external/yxml scripts external/libcurl external/libder \

	external/libecc] {

DIRS=	blake2 picosat linenoise sqlite libucl liblua yxml libcurl libder libecc

.*.swp

.depend*

*.a

*.so

*.so.*

*.o

*.pico

*.debug

*.full

build/

cmake_minimum_required(VERSION 3.18)

project(libder)

if(CMAKE_BUILD_TYPE STREQUAL "Debug" AND NOT CMAKE_SYSTEM_NAME STREQUAL "OpenBSD")

	add_compile_options(-fsanitize=address,undefined -fstrict-aliasing)

	add_link_options(-fsanitize=address,undefined -fstrict-aliasing)

endif()

# AppleClang is excluded for the time being; the version used in GitHub Action

# runners doesn't seem to have that part of libclang_rt installed, though the

# -fsanitize=fuzzer-no-link instrumentation seems to be fine.  Maybe re-evaluate

# this for MATCHES as a possibility later.

if(CMAKE_C_COMPILER_ID STREQUAL "Clang" AND NOT CMAKE_SYSTEM_NAME STREQUAL "OpenBSD")

	set(BUILD_FUZZERS TRUE

		CACHE BOOL "Build the libFuzzer fuzzers (needs llvm)")

else()

	set(BUILD_FUZZERS FALSE

		CACHE BOOL "Build the libFuzzer fuzzers (needs llvm)")

endif()

add_subdirectory(libder)

add_subdirectory(derdump)

add_subdirectory(tests)

Copyright (c) 2024 Kyle Evans <kevans@FreeBSD.org>

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.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND

ANY EXPRESS 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 AUTHOR OR 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.

include @builddir@/mk/defs.mk

LIB=	der

VPATH=	$(top_srcdir)/external/libder/libder

.PATH:	$(top_srcdir)/external/libder/libder

SRCS=	libder.c \

	libder_error.c \

	libder_obj.c \

	libder_read.c \

	libder_type.c \

	libder_write.c

include $(MK)/static-lib.mk

# libder

## What is libder?

libder is a small library for encoding/decoding DER-encoded objects.  It is

expected to be able to decode any BER-encoded buffer, and an attempt to

re-encode the resulting tree would apply any normalization expected by a DER

decoder.  The author's use is primarily to decode/encode ECC keys for

interoperability with OpenSSL.

## What is libder not?

libder is not intended to be a general-purpose library for working with DER/BER

specified objects.  It may provide some helpers for building more primitive

data types, but libder will quickly punt on anything even remotely complex and

require the library consumer to supply it as a type/payload/size triple that it

will treat as relatively opaque (modulo some encoding normalization rules that

can be applied without deeply understanding the data contained within).

libder also doesn't do strict validation of what it reads in today, for better

or worse.  e.g., a boolean may occupy more than one byte and libder will happily

present it to the application in that way.  It would be normalized on

re-encoding to 0xff or 0x00 depending on whether any bits are set or not.

derdump

file(GLOB derdump_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/*.c)

add_executable(derdump ${derdump_SOURCES})

target_include_directories(derdump PRIVATE "${CMAKE_SOURCE_DIR}/libder")

target_link_libraries(derdump der_static)

.\"

.\" SPDX-Copyright-Identifier: BSD-2-Clause

.\"

.\" Copyright (C) 2024 Kyle Evans <kevans@FreeBSD.org>

.\"

.Dd March 4, 2024

.Dt DERDUMP 1

.Os

.Sh NAME

.Nm derdump

.Nd dumping contents of DER encoded files

.Sh SYNOPSIS

.Nm

.Ar file1

.Oo Ar fileN ... Oc

.Sh DESCRIPTION

The

.Nm

utility dumps the contents of one or more DER encoded

Ar file

in a more human readable format.

This is similar to the

.Xr asn1parse 1

utility distributed with OpenSSL when used with the

.Fl inform

.Ar DER

option.

.Pp

A representation of the object will be output to

.Em stdout ,

with indentation to denote objects that are encoded within other constructed

objects.

Note that

.Nm

does not make much attempt to interpret the contents of any particular object.

If an object uses one of the universal types, then a friendly name will be

displayed for that object.

If an object uses any other type, then

.Nm

will display the raw hex value of the type used.

Values of primitive objects are output as raw hex, and no effort is made to

try and print a friendly representation.

.Sh SEE ALSO

.Xr asn1parse 1 ,

.Xr libder 3

.Sh BUGS

.Nm

does not currently make any attempt to render a type that uses the long encoded

format.

Instead, it will render as

.Dq { ... } .

/*-

 * Copyright (c) 2024 Kyle Evans <kevans@FreeBSD.org>

 *

 * SPDX-License-Identifier: BSD-2-Clause

 */

#include <err.h>

#include <stdio.h>

#include <libder.h>

int

main(int argc, char *argv[])

{

	FILE *fp;

	struct libder_ctx *ctx;

	struct libder_object *root;

	size_t rootsz;

	bool first = true;

	if (argc < 2) {

		fprintf(stderr, "usage: %s file [file...]\n", argv[0]);

		return (1);

	}

	ctx = libder_open();

	libder_set_verbose(ctx, 2);

	for (int i = 1; i < argc; i++) {

		fp = fopen(argv[i], "rb");

		if (fp == NULL) {

			warn("%s", argv[i]);

			continue;

		}

		if (!first)

			fprintf(stderr, "\n");

		fprintf(stdout, "[%s]\n", argv[i]);

		root = libder_read_file(ctx, fp, &rootsz);

		if (root != NULL) {

			libder_obj_dump(root, stdout);

			libder_obj_free(root);

			root = NULL;

		}

		first = false;

		fclose(fp);

	}

	libder_close(ctx);

	return (0);

}

file(GLOB libder_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/*.c)

add_library(der SHARED ${libder_SOURCES})

add_library(der_static STATIC ${libder_SOURCES})

if(BUILD_FUZZERS AND CMAKE_BUILD_TYPE STREQUAL "Debug")

	target_compile_options(der PUBLIC -fsanitize=fuzzer-no-link)

	target_link_options(der PUBLIC -fsanitize=fuzzer-no-link)

	target_compile_options(der_static PUBLIC -fsanitize=fuzzer-no-link)

	target_link_options(der_static PUBLIC -fsanitize=fuzzer-no-link)

endif()

.\"

.\" SPDX-Copyright-Identifier: BSD-2-Clause

.\"

.\" Copyright (C) 2024 Kyle Evans <kevans@FreeBSD.org>

.\"

.Dd March 2, 2024

.Dt LIBDER 3

.Os

.Sh NAME

.Nm libder ,

.Nm libder_open ,

.Nm libder_close ,

.Nm libder_abort ,

.Nm libder_get_error ,

.Nm libder_has_error ,

.Nm libder_get_normalize ,

.Nm libder_set_normalize ,

.Nm libder_get_strict ,

.Nm libder_set_strict ,

.Nm libder_get_verbose ,

.Nm libder_set_verbose

.Nd DER encoding and decoding library

.Sh LIBRARY

.Lb libder

.Sh SYNOPSIS

.In libder.h

.Ft struct libder_ctx *

.Fn libder_open "void"

.Ft void

.Fn libder_close "struct libder_ctx *ctx"

.Ft void

.Fn libder_abort "struct libder_ctx *ctx"

.Ft const char *

.Fn libder_get_error "struct libder_ctx *ctx"

.Ft bool

.Fn libder_has_error "struct libder_ctx *ctx"

.Ft uint64_t

.Fn libder_get_normalize "struct libder_ctx *ctx"

.Ft uint64_t

.Fn libder_set_normalize "struct libder_ctx *ctx" "uint64_t normalize"

.Ft bool

.Fn libder_get_strict "struct libder_ctx *ctx"

.Ft bool

.Fn libder_set_strict "struct libder_ctx *ctx" "bool strict"

.Ft int

.Fn libder_get_verbose "struct libder_ctx *ctx"

.Ft int

.Fn libder_set_verbose "struct libder_ctx *ctx" "int verbose"

.Sh DESCRIPTION

The

.Nm

library provides functionality for decoding BER and DER encoded data, and

DER encoding data subjected to constraints outline in ITU-T

Recommendation X.690.

.Nm

will apply relevant normalization rules on write, unless they've been disabled

with

.Ft libder_set_normalize ,

under the assumption that it may not be reading strictly DER encoded data.

.Pp

Note that not all of the DER rules are currently implemented.

.Nm

will coalesce constructed types that DER specifies should be primitive.

.Nm

will primarily normalize bitstrings, booleans, and integers.

This library was primarily written to be able to provide interoperability with

OpenSSL keys and signatures, so the library was written with that in mind.

Eventually it is intended that

.Nm

will support the full set of rules, but currently some responsibility is left

to the library user.

.Pp

Also note that

.Nm

does not necessarily provide

.Dq neat

ways to construct primitives.

For example, even booleans and integers currently work just by providing a

buffer that is expected to be formatted in a sane fashion.

The library user is expected to build the object tree and generally provide the

object data in a format reasonably encoded as the data for that type should be,

then

.Nm

will provide the proper framing on write and do any transformations that may

need to be done for strict conformance.

.Pp

The

.Fn libder_open

function allocates a new

.Nm

context.

The context does not hold any state about any particular structure.

All of the state held in the context is generally described in this manpage.

The

.Fn libder_close

function will free the context.

.Pp

The

.Fn libder_abort

function will abort an in-progress

.Xr libder_read_fd 3

operation on the existing

.Fa ctx

if it is interrupted by a signal in the middle of a

.Xr read 2

syscall.

See

.Xr libder_read_fd 3

for further discussion.

.Pp

The

.Fn libder_get_error

function will return an error string appropriate for the current error, if any.

The

.Fn libder_has_error

function can be used to check if an error was raised in a previous operation.

.Pp

The

.Fn libder_get_normalize

and

.Fn libder_set_normalize

functions retrieve and manipulate any number of flags that detail how

functions may be used to check or set the normalization flags given

.Nm context ,

which dictates how

.Nm

will normalize data on write.

The following normalization flags may be specified:

.Bl -column "LIBDER_NORMALIZE_CONSTRUCTED"

.It LIBDER_NORMALIZE_CONSTRUCTED Ta Coalesce types that may be primitive or constructed

.It LIBDER_NORMALIZE_TAGS Ta Pack tags into the lowest possible encoded value

.El

.Pp

The

.Fn LIBDER_NORMALIZE_TYPE_FLAG "enum libder_ber_type"

macaro may also be used to specify normalization of the given universal type.

By default, every valid normalization flag is enabled.

.Pp

The

.Fn libder_get_strict

and

.Fn libder_set_strict

functions may used to check or set the strict read state of the given

.Nm

context.

By default,

.Nm

operates in strict mode and rejects various methods of expressing data that are

valid looking but not strictly conformant.

The

.Va LDE_STRICT_*

constants in

.In libder.h

describe the various scenarios that strict mode may reject.

.Pp

The

.Fn libder_get_verbose

and

.Fn libder_set_verbose

functions may be used to check or set the verbosity of the given

.Nm

context.

This primarily controls how

.Nm

behaves when an error is encountered.

By default, the library will silently set the error state and return.

With a verbosity level of 1, an error will be printed when the error state is

set that contains the string that would be returned by

.Fn libder_get_error .

With a verbosity level of 2, the filename and line within

.Nm

that the error occurred in will be printed, which is primarily intended for

debugging

.Nm .

.Sh SEE ALSO

.Xr libder_obj 3 ,

.Xr libder_read 3 ,

.Xr libder_type 3 ,

.Xr libder_write 3

/*-

 * Copyright (c) 2024 Kyle Evans <kevans@FreeBSD.org>

 *

 * SPDX-License-Identifier: BSD-2-Clause

 */

#include "libder_private.h"

#include <stdlib.h>

#include <unistd.h>

/*

 * Sets up the context, returns NULL on error.

 */

struct libder_ctx *

libder_open(void)

{

	struct libder_ctx *ctx;

	ctx = malloc(sizeof(*ctx));

	if (ctx == NULL)

		return (NULL);

	/* Initialize */

	ctx->error = LDE_NONE;

	ctx->buffer_size = 0;

	ctx->verbose = 0;

	ctx->normalize = LIBDER_NORMALIZE_ALL;

	ctx->strict = true;

	ctx->abort = 0;

	return (ctx);

}

void

libder_abort(struct libder_ctx *ctx)

{

	ctx->abort = 1;

}

LIBDER_PRIVATE size_t

libder_get_buffer_size(struct libder_ctx *ctx)

{

	if (ctx->buffer_size == 0) {

		long psize;

		psize = sysconf(_SC_PAGESIZE);

		if (psize <= 0)

			psize = 4096;

		ctx->buffer_size = psize;

	}

	return (ctx->buffer_size);

}

uint64_t

libder_get_normalize(struct libder_ctx *ctx)

{

	return (ctx->normalize);

}

/*

 * Set the normalization flags; returns the previous value.

 */

uint64_t

libder_set_normalize(struct libder_ctx *ctx, uint64_t nmask)

{

	uint64_t old = ctx->normalize;

	ctx->normalize = (nmask & LIBDER_NORMALIZE_ALL);

	return (old);

}

bool

libder_get_strict(struct libder_ctx *ctx)

{

	return (ctx->strict);

}

bool

libder_set_strict(struct libder_ctx *ctx, bool strict)

{

	bool oval = ctx->strict;

	ctx->strict = strict;

	return (oval);

}

int

libder_get_verbose(struct libder_ctx *ctx)

{

	return (ctx->verbose);

}

int

libder_set_verbose(struct libder_ctx *ctx, int verbose)

{

	int oval = ctx->verbose;

	ctx->verbose = verbose;

	return (oval);

}

void

libder_close(struct libder_ctx *ctx)

{

	if (ctx == NULL)

		return;

	free(ctx);

}

/*-

 * Copyright (c) 2024 Kyle Evans <kevans@FreeBSD.org>

 *

 * SPDX-License-Identifier: BSD-2-Clause

 */

#pragma once

#include <stdbool.h>

#include <stdio.h>

#include <stdint.h>

#include <stddef.h>

enum libder_ber_class {

	BC_UNIVERSAL = 0,

	BC_APPLICATION = 1,

	BC_CONTEXT = 2,

	BC_PRIVATE = 3,

};

enum libder_ber_type {

	BT_RESERVED = 0x00,

	BT_BOOLEAN = 0x01,

	BT_INTEGER = 0x02,

	BT_BITSTRING = 0x03,

	BT_OCTETSTRING = 0x04,

	BT_NULL = 0x05,

	BT_OID = 0x06,

	BT_OBJDESC = 0x07,

	BT_EXTERNAL = 0x08,

	BT_REAL = 0x09,

	BT_ENUMERATED = 0x0a,

	BT_PDV = 0x0b,

	BT_UTF8STRING =  0x0c,

	BT_RELOID = 0x0d,

	/* 0x10, 011 not usable */

	BT_NUMERICSTRING = 0x012,

	BT_STRING = 0x13,

	BT_TELEXSTRING = 0x14,

	BT_VIDEOTEXSTRING = 0x15,

	BT_IA5STRING = 0x16,

	BT_UTCTIME = 0x17,

	BT_GENTIME = 0x18,

	BT_GFXSTRING = 0x19,

	BT_VISSTRING = 0x1a,

	BT_GENSTRING = 0x1b,

	BT_UNIVSTRING = 0x1c,

	BT_CHARSTRING = 0x1d,

	BT_BMPSTRING = 0x1e,

	BT_SEQUENCE = 0x30,

	BT_SET = 0x31,

};

#define	BER_TYPE_CONSTRUCTED_MASK	0x20	/* Bit 6 */

#define	BER_TYPE_CLASS_MASK		0xc0	/* Bits 7 and 8 */

/*

 * The difference between the type and the full type is just that the full type

 * will indicate the class of type, so it may be more useful for some operations.

 */

#define	BER_FULL_TYPE(tval)		\

    ((tval) & ~(BER_TYPE_CONSTRUCTED_MASK))

#define	BER_TYPE(tval)			\

    ((tval) & ~(BER_TYPE_CLASS_MASK | BER_TYPE_CONSTRUCTED_MASK))

#define	BER_TYPE_CLASS(tval)		\

    (((tval) & BER_TYPE_CLASS_MASK) >> 6)

#define BER_TYPE_CONSTRUCTED(tval)	\

    (((tval) & BER_TYPE_CONSTRUCTED_MASK) != 0)

enum libder_error {

	LDE_NONE = 0x00,

	LDE_NOMEM,		/* Out of memory */

	LDE_INVAL,		/* Invalid parameter */

	LDE_SHORTHDR,		/* Header too short */

	LDE_BADVARLEN,		/* Bad variable length encoding */

	LDE_LONGLEN,		/* Encoded length too large (8 byte max) */

	LDE_SHORTDATA,		/* Payload not available */

	LDE_GARBAGE,		/* Garbage after encoded data */

	LDE_STREAMERR,		/* Stream error */

	LDE_TRUNCVARLEN,	/* Variable length object truncated */

	LDE_COALESCE_BADCHILD,	/* Bad child encountered when coalescing */

	LDE_BADOBJECT,		/* Payload not valid for object type */

	/* Strict violations */

	LDE_STRICT_EOC,		/* Strict: end-of-content violation */

	LDE_STRICT_TAG,		/* Strict: tag violation */

	LDE_STRICT_PVARLEN,	/* Strict: primitive using indefinite length */

	LDE_STRICT_BOOLEAN,	/* Strict: boolean encoded incorrectly */

	LDE_STRICT_NULL,	/* Strict: null encoded incorrectly */

	LDE_STRICT_PRIMITIVE,	/* Strict: type must be primitive */

	LDE_STRICT_CONSTRUCTED,	/* Strict: type must be constructed */

	LDE_STRICT_BITSTRING,	/* Strict: malformed constructed bitstring */

};

struct libder_ctx;

struct libder_tag;

struct libder_object;

/*

 * By default we normalize everything, but we allow some subset of the

 * functionality to be disabled.  Lengths are non-optional and will always be

 * normalized to a fixed short or long length.  The upper 32-bits of

 * ctx->normalize are reserved for universal types so that we can quickly map

 * those without assigning them names.

 */

/* Normalize constructed types that should be coalesced (e.g., strings, time). */

#define	LIBDER_NORMALIZE_CONSTRUCTED	0x0000000000000001ULL

/*

 * Normalize tags on read.  This is mostly a measure to ensure that

 * normalization on write doesn't get thwarted; there's no reason anybody should

 * be encoding low tags with the long form, but the spec doesn't appear to

 * forbid it.

 */

#define	LIBDER_NORMALIZE_TAGS		0x0000000000000002ULL

/* Universal types (reserved) */

#define	LIBDER_NORMALIZE_TYPE_MASK	0xffffffff00000000ULL

#define	LIBDER_NORMALIZE_TYPE_FLAG(val)	((1ULL << val) << 32ULL)

/* All valid bits. */

#define	LIBDER_NORMALIZE_ALL		\

    (LIBDER_NORMALIZE_TYPE_MASK | LIBDER_NORMALIZE_CONSTRUCTED |	\

    LIBDER_NORMALIZE_TAGS)

struct libder_ctx *		 libder_open(void);

void			 libder_close(struct libder_ctx *);

void			 libder_abort(struct libder_ctx *);

const char		*libder_get_error(struct libder_ctx *);

bool			 libder_has_error(struct libder_ctx *);

uint64_t		 libder_get_normalize(struct libder_ctx *);

uint64_t		 libder_set_normalize(struct libder_ctx *, uint64_t);

bool			 libder_get_strict(struct libder_ctx *);

bool			 libder_set_strict(struct libder_ctx *, bool);

int			 libder_get_verbose(struct libder_ctx *);

int			 libder_set_verbose(struct libder_ctx *, int);

struct libder_object	*libder_read(struct libder_ctx *, const uint8_t *, size_t *);

struct libder_object	*libder_read_fd(struct libder_ctx *, int, size_t *);

struct libder_object	*libder_read_file(struct libder_ctx *, FILE *, size_t *);

uint8_t			*libder_write(struct libder_ctx *, struct libder_object *, uint8_t *,

			    size_t *);

#define	DER_CHILDREN(obj)	libder_obj_children(obj)

#define	DER_NEXT(obj)		libder_obj_next(obj)

#define	DER_FOREACH_CHILD(var, obj)	\

	for ((var) = DER_CHILDREN((obj));	\

	    (var);				\

	    (var) = DER_NEXT((var)))

#define	DER_FOREACH_CHILD_SAFE(var, obj, tvar)		\

	for ((var) = DER_CHILDREN((obj));		\

	    (var) && ((tvar) = DER_NEXT((var)), 1);	\

	    (var) = (tvar))

struct libder_object	*libder_obj_alloc(struct libder_ctx *, struct libder_tag *, const uint8_t *, size_t);

struct libder_object	*libder_obj_alloc_simple(struct libder_ctx *, uint8_t, const uint8_t *,

		    size_t);

void		 libder_obj_free(struct libder_object *);

bool		 libder_obj_append(struct libder_object *, struct libder_object *);

struct libder_object	*libder_obj_child(const struct libder_object *, size_t);

struct libder_object	*libder_obj_children(const struct libder_object *);

struct libder_object	*libder_obj_next(const struct libder_object *);

struct libder_tag	*libder_obj_type(const struct libder_object *);

uint8_t		 libder_obj_type_simple(const struct libder_object *);

const uint8_t	*libder_obj_data(const struct libder_object *, size_t *);

/* Debugging aide -- probably shouldn't use. */

void		 libder_obj_dump(const struct libder_object *, FILE *);

struct libder_tag	*libder_type_alloc_simple(struct libder_ctx *, uint8_t);

struct libder_tag	*libder_type_dup(struct libder_ctx *, const struct libder_tag *);

void		 libder_type_free(struct libder_tag *);

#define	libder_type_simple	libder_type_simple_abi

uint8_t		 libder_type_simple(const struct libder_tag *);

/*-

 * Copyright (c) 2024 Kyle Evans <kevans@FreeBSD.org>

 *

 * SPDX-License-Identifier: BSD-2-Clause

 */

#include <stdio.h>

#include "libder_private.h"

#undef libder_set_error

static const char libder_error_nodesc[] = "[Description not available]";

#define	DESCRIBE(err, msg)	{ LDE_ ## err, msg }

static const struct libder_error_desc {

	enum libder_error	 desc_error;

	const char		*desc_str;

} libder_error_descr[] = {

	DESCRIBE(NONE,		"No error"),

	DESCRIBE(NOMEM,		"Out of memory"),

	DESCRIBE(INVAL,		"Invalid parameter"),

	DESCRIBE(SHORTHDR,	"Header too short"),

	DESCRIBE(BADVARLEN,	"Bad variable length encoding"),

	DESCRIBE(LONGLEN,	"Encoded length too large (8 byte max)"),

	DESCRIBE(SHORTDATA,	"Payload not available (too short)"),

	DESCRIBE(GARBAGE,	"Garbage after encoded data"),

	DESCRIBE(STREAMERR,	"Stream error"),

	DESCRIBE(TRUNCVARLEN,	"Variable length object truncated"),

	DESCRIBE(COALESCE_BADCHILD,	"Bad child encountered when coalescing"),

	DESCRIBE(BADOBJECT,	"Payload not valid for object type"),

	DESCRIBE(STRICT_EOC,		"Strict: end-of-content violation"),

	DESCRIBE(STRICT_TAG,		"Strict: tag violation"),

	DESCRIBE(STRICT_PVARLEN,	"Strict: primitive using indefinite length"),

	DESCRIBE(STRICT_BOOLEAN,	"Strict: boolean encoded incorrectly"),

	DESCRIBE(STRICT_NULL,		"Strict: null encoded incorrectly"),

	DESCRIBE(STRICT_PRIMITIVE,	"Strict: type must be primitive"),

	DESCRIBE(STRICT_CONSTRUCTED,	"Strict: type must be constructed"),

	DESCRIBE(STRICT_BITSTRING,	"Strict: malformed constructed bitstring"),

};

const char *

libder_get_error(struct libder_ctx *ctx)

{

	const struct libder_error_desc *desc;

	for (size_t i = 0; i < nitems(libder_error_descr); i++) {

		desc = &libder_error_descr[i];

		if (desc->desc_error == ctx->error)

			return (desc->desc_str);

	}

	return (libder_error_nodesc);

}

bool

libder_has_error(struct libder_ctx *ctx)

{

	return (ctx->error != 0);

}

LIBDER_PRIVATE void

libder_set_error(struct libder_ctx *ctx, int error, const char *file, int line)

{

	ctx->error = error;

	if (ctx->verbose >= 2) {

		fprintf(stderr, "%s: [%s:%d]: %s (error %d)\n",

		    __func__, file, line, libder_get_error(ctx), error);

	} else if (ctx->verbose >= 1) {

		fprintf(stderr, "%s: %s (error %d)\n", __func__,

		    libder_get_error(ctx), error);

	}

}

.\"

.\" SPDX-Copyright-Identifier: BSD-2-Clause

.\"

.\" Copyright (C) 2024 Kyle Evans <kevans@FreeBSD.org>

.\"

.Dd March 2, 2024

.Dt LIBDER_OBJ 3

.Os

.Sh NAME

.Nm libder_obj ,

.Nm libder_obj_alloc ,

.Nm libder_obj_alloc_simple ,

.Nm libder_obj_free ,

.Nm libder_obj_append ,

.Nm libder_obj_child ,

.Nm libder_obj_next ,

.Nm libder_obj_type ,

.Nm libder_obj_type_simple ,

.Nm libder_obj_data ,

.Nm libder_obj_dump

.Nd inspecting and creating libder objects

.Sh LIBRARY

.Lb libder

.Sh SYNOPSIS

.In libder.h

.Ft struct libder_object *

.Fn libder_obj_alloc "struct libder_ctx *ctx" "struct libder_tag *type" "const uint8_t *data" "size_t datasz"

.Ft struct libder_object *

.Fn libder_obj_alloc_simple "struct libder_ctx *ctx" "uint8_t type" "const uint8_t *data" "size_t datasz"

.Ft void

.Fn libder_obj_free "struct libder_object *ctx"

.Ft bool

.Fn libder_obj_append "struct libder_object *parent" "struct libder_object *child"

.Ft struct libder_object *

.Fn libder_obj_child "const struct libder_object *obj" "size_t which"

.Ft struct libder_object *

.Fn libder_obj_next "const struct libder_object *obj"

.Fn "DER_FOREACH_CHILD" "struct libder_obj *iter" "struct libder_obj *obj"

.Fn "DER_FOREACH_CHILD_SAFE" "struct libder_obj *iter" "struct libder_obj *obj" "struct libder_obj *tmp"

.Ft struct libder_tag *

.Fn libder_obj_type "const struct libder_object *obj"

.Ft uint8_t

.Fn libder_obj_type_simple "const struct libder_object *obj"

.Ft const uint8_t *

.Fn libder_obj_data "const struct libder_object *obj" "size_t *sz"

.Ft void

.Fn libder_obj_dump "const struct libder_object *obj" "FILE *fp"

.Sh DESCRIPTION

The

.Nm

family of functions may be used by the application to create its own objects and

object hierarchy, rather than reading them from an existing stream.

.Pp

The

.Fn libder_obj_alloc

and

.Fn libder_obj_alloc_simple

functions allocate a new object with the specified

.Fa type

and

.Fa data .

Most applications will likely prefer to use the

.Dq simple

variant to avoid having to manage a

.Xr libder_type 3

lifecycle and associated boilerplate.

The base variant remains around for when

.Xr libder_type 3

grows the necessary API to create arbitrarily large tags.

.Pp

The

.Fn libder_obj_append

function is used to append

.Fa obj

to the

.Fa parent

object's children.

For example, to add an object to a sequence.

.Pp

The

.Fn libder_obj_child

and

.Fn libder_obj_next

functions are used to iterate through the children of

.Fa obj .

The

.Fa which

argument to

.Fn libder_obj_child

specifies the index of the child requested, starting at

.Dv 0 .

The

.Fn DER_FOREACH_CHILD

and

.Fn DER_FOREACH_CHILD_SAFE

macros are provided for convenience.

The difference between these two is that it is safe to free the iterator in the

.Fn DER_FOREACH_CHILD_SAFE

loop body.

.Pp

The

.Fn libder_obj_type

and

.Fn libder_obj_type_simple

functions are used to get the type information about an

.Fa obj .

As usual, the

.Dq simple

variant will return the one-byte encoding of a tag between 0 and 30.

If the tag is actually larger than 30, then all of the lower 5 bits will be set

to indicate that it's a long tag, and that the application should have used

.Fn libder_obj_type

instead.

.Pp

The

.Fn libder_obj_data

function returns a pointer to the

.Fa data

from

.Fa obj ,

and updates

.Fa *sz

with the data's size.

Note that the data is not copied out here, the application is responsible for

making its own copy of the returned buffer.

.Pp

The

.Fn libder_obj_dump

function is a debugging function that likely shouldn't be used.

A human readable representation of the provided

.Fa obj

will be written to the stream

.Fa fp .

.Sh SEE ALSO

.Xr libder 3 ,

.Xr libder_read 3 ,

.Xr libder_type 3 ,

.Xr libder_write 3

/*-

 * Copyright (c) 2024 Kyle Evans <kevans@FreeBSD.org>

 *

 * SPDX-License-Identifier: BSD-2-Clause

 */

#include <assert.h>

#include <stdlib.h>

#include <string.h>

#include "libder_private.h"

#undef	DER_CHILDREN

#undef	DER_NEXT

#define	DER_CHILDREN(obj)	((obj)->children)

#define	DER_NEXT(obj)		((obj)->next)

static uint8_t *

libder_obj_alloc_copy_payload(struct libder_ctx *ctx, const uint8_t *payload_in,

    size_t length)

{

	uint8_t *payload;

	if ((length == 0 && payload_in != NULL) ||

	    (length != 0 && payload_in == NULL)) {

		libder_set_error(ctx, LDE_INVAL);

		return (NULL);

	}

	if (length > 0) {

		payload = malloc(length);

		if (payload == NULL) {

			libder_set_error(ctx, LDE_NOMEM);

			return (NULL);

		}

		memcpy(payload, payload_in, length);

	} else {

		payload = NULL;

	}

	return (payload);

}

static bool

libder_obj_alloc_check(struct libder_ctx *ctx, struct libder_tag *type,

    const uint8_t *payload_in, size_t length)

{

	/*

	 * In addition to our normal constraints, constructed objects coming in

	 * from lib users should not have payloads.

	 */

	if (!libder_is_valid_obj(ctx, type, payload_in, length, false) ||

	    (type->tag_constructed && length != 0)) {

		libder_set_error(ctx, LDE_BADOBJECT);

		return (false);

	}

	return (true);

}

struct libder_object *

libder_obj_alloc(struct libder_ctx *ctx, struct libder_tag *type,

    const uint8_t *payload_in, size_t length)

{

	struct libder_object *obj;

	uint8_t *payload;

	if (!libder_obj_alloc_check(ctx, type, payload_in, length))

		return (NULL);

	payload = libder_obj_alloc_copy_payload(ctx, payload_in, length);

	obj = libder_obj_alloc_internal(ctx, type, payload, length, 0);

	if (obj == NULL) {

		free(payload);

		libder_set_error(ctx, LDE_NOMEM);

	}

	return (obj);

}

struct libder_object *

libder_obj_alloc_simple(struct libder_ctx *ctx, uint8_t stype,

    const uint8_t *payload_in, size_t length)

{

	struct libder_object *obj;

	struct libder_tag *type;

	uint8_t *payload;

	type = libder_type_alloc_simple(ctx, stype);

	if (type == NULL)

		return (NULL);

	if (!libder_obj_alloc_check(ctx, type, payload_in, length)) {

		libder_type_free(type);

		return (NULL);

	}

	payload = libder_obj_alloc_copy_payload(ctx, payload_in, length);

	obj = libder_obj_alloc_internal(ctx, type, payload, length, LDO_OWNTAG);

	if (obj == NULL) {

		free(payload);

		libder_type_free(type);

		libder_set_error(ctx, LDE_NOMEM);

	}

	return (obj);

}

/*

 * Returns an obj on success, NULL if out of memory.  `obj` takes ownership of

 * the payload on success.

 */

LIBDER_PRIVATE struct libder_object *

libder_obj_alloc_internal(struct libder_ctx *ctx, struct libder_tag *type,

    uint8_t *payload, size_t length, uint32_t flags)

{

	struct libder_object *obj;

	assert((flags & ~(LDO_OWNTAG)) == 0);

	if (length != 0)

		assert(payload != NULL);

	else

		assert(payload == NULL);

	obj = malloc(sizeof(*obj));

	if (obj == NULL)

		return (NULL);

	if ((flags & LDO_OWNTAG) != 0) {

		obj->type = type;

	} else {

		/*

		 * Deep copies the tag data, so that the caller can predict what

		 * it can do with the buffer.

		 */

		obj->type = libder_type_dup(ctx, type);

		if (obj->type == NULL) {

			free(obj);

			return (NULL);

		}

	}

	obj->length = length;

	obj->payload = payload;

	obj->children = obj->next = obj->parent = NULL;

	obj->nchildren = 0;

	return (obj);

}

LIBDER_PRIVATE size_t

libder_size_length(size_t sz)

{

	size_t nbytes;

	/*

	 * With DER, we use the smallest encoding necessary: less than 0x80

	 * can be encoded in one byte.

	 */

	if (sz < 0x80)

		return (1);

	/*

	 * We can support up to 0x7f size bytes, but we don't really have a way

	 * to represent that right now.  It's a good thing this function only

	 * takes a size_t, otherwise this would be a bit wrong.

	 */

	for (nbytes = 1; nbytes < sizeof(size_t); nbytes++) {

		if ((sz & ~((1ULL << 8 * nbytes) - 1)) == 0)

			break;

	}

	/* Add one for the lead byte describing the length of the length. */

	return (nbytes + 1);

}

/*

 * Returns the size on-disk.  If an object has children, we encode the size as

 * the sum of their lengths recursively.  Otherwise, we use the object's size.

 *

 * Returns 0 if the object size would overflow a size_t... perhaps we could

 * lift this restriction later.

 *

 * Note that the size of the object will be set/updated to simplify later write

 * calculations.

 */

LIBDER_PRIVATE size_t

libder_obj_disk_size(struct libder_object *obj, bool include_header)

{

	struct libder_object *walker;

	size_t disk_size, header_size;

	disk_size = obj->length;

	if (obj->children != NULL) {

		/* We should have rejected these. */

		assert(obj->length == 0);

		DER_FOREACH_CHILD(walker, obj) {

			size_t child_size;

			child_size = libder_obj_disk_size(walker, true);

			if (SIZE_MAX - child_size < disk_size)

				return (0);	/* Overflow */

			disk_size += child_size;

		}

	}

	obj->disk_size = disk_size;

	/*

	 * Children always include the header above, we only include the header

	 * at the root if we're calculating how much space we need in total.

	 */

	if (include_header) {

		/* Size of the length + the tag (arbitrary length) */

		header_size = libder_size_length(disk_size) + obj->type->tag_size;

		if (obj->type->tag_encoded)

			header_size++;	/* Lead byte */

		if (SIZE_MAX - header_size < disk_size)

			return (0);

		disk_size += header_size;

	}

	return (disk_size);

}

void

libder_obj_free(struct libder_object *obj)

{

	struct libder_object *child, *tmp;

	if (obj == NULL)

		return;

	DER_FOREACH_CHILD_SAFE(child, obj, tmp)

		libder_obj_free(child);

	free(obj->payload);

	libder_type_free(obj->type);

	free(obj);

}

static void

libder_obj_unlink(struct libder_object *obj)

{

	struct libder_object *child, *parent, *prev;

	parent = obj->parent;

	if (parent == NULL)

		return;

	prev = NULL;

	assert(parent->nchildren > 0);

	DER_FOREACH_CHILD(child, parent) {

		if (child == obj) {

			if (prev == NULL)

				parent->children = child->next;

			else

				prev->next = child->next;

			parent->nchildren--;

			child->parent = NULL;

			return;

		}

		prev = child;

	}

	assert(0 && "Internal inconsistency: parent set, but child not found");

}

bool

libder_obj_append(struct libder_object *parent, struct libder_object *child)

{

	struct libder_object *end, *walker;

	if (!parent->type->tag_constructed)

		return (false);

	/* XXX Type check */

	if (child->parent != NULL)

		libder_obj_unlink(child);

	if (parent->nchildren == 0) {

		parent->children = child;

		parent->nchildren++;

		return (true);

	}

	/* Walk the chain */

	DER_FOREACH_CHILD(walker, parent) {

		end = walker;

	}

	assert(end != NULL);

	end->next = child;

	parent->nchildren++;

	child->parent = parent;

	return (true);

}

struct libder_object *

libder_obj_child(const struct libder_object *obj, size_t idx)

{

	struct libder_object *cur;

	DER_FOREACH_CHILD(cur, obj) {

		if (idx-- == 0)

			return (cur);

	}

	return (NULL);

}

struct libder_object *

libder_obj_children(const struct libder_object *obj)

{

	return (obj->children);

}

struct libder_object *

libder_obj_next(const struct libder_object *obj)

{

	return (obj->next);

}

struct libder_tag *

libder_obj_type(const struct libder_object *obj)

{

	return (obj->type);

}

uint8_t

libder_obj_type_simple(const struct libder_object *obj)

{

	struct libder_tag *type = obj->type;

	uint8_t simple = type->tag_class << 6;

	if (type->tag_constructed)

		simple |= BER_TYPE_CONSTRUCTED_MASK;

	if (type->tag_encoded)

		simple |= 0x1f;	/* Encode the "long tag" tag. */

	else

		simple |= type->tag_short;

	return (simple);

}

const uint8_t *

libder_obj_data(const struct libder_object *obj, size_t *osz)

{

	if (obj->type->tag_constructed)

		return (NULL);

	*osz = obj->length;

	return (obj->payload);

}

static const char *

libder_type_name(const struct libder_tag *type)

{

	static char namebuf[128];

	if (type->tag_encoded) {

		return ("{ ... }");

	}

	if (type->tag_class != BC_UNIVERSAL)

		goto fallback;

#define	UTYPE(val)	case val: return (&(#val)[3])

	switch (type->tag_short) {

	UTYPE(BT_RESERVED);

	UTYPE(BT_BOOLEAN);

	UTYPE(BT_INTEGER);

	UTYPE(BT_BITSTRING);

	UTYPE(BT_OCTETSTRING);

	UTYPE(BT_NULL);

	UTYPE(BT_OID);

	UTYPE(BT_OBJDESC);

	UTYPE(BT_EXTERNAL);

	UTYPE(BT_REAL);

	UTYPE(BT_ENUMERATED);

	UTYPE(BT_PDV);

	UTYPE(BT_UTF8STRING);

	UTYPE(BT_RELOID);

	UTYPE(BT_NUMERICSTRING);

	UTYPE(BT_STRING);

	UTYPE(BT_TELEXSTRING);

	UTYPE(BT_VIDEOTEXSTRING);

	UTYPE(BT_IA5STRING);

	UTYPE(BT_UTCTIME);

	UTYPE(BT_GENTIME);

	UTYPE(BT_GFXSTRING);

	UTYPE(BT_VISSTRING);

	UTYPE(BT_GENSTRING);

	UTYPE(BT_UNIVSTRING);

	UTYPE(BT_CHARSTRING);

	UTYPE(BT_BMPSTRING);

	case BT_SEQUENCE & ~BER_TYPE_CONSTRUCTED_MASK:

	case BT_SEQUENCE: return "SEQUENCE";

	case BT_SET & ~BER_TYPE_CONSTRUCTED_MASK:

	case BT_SET: return "SET";

	}

fallback:

	snprintf(namebuf, sizeof(namebuf), "%.02x", libder_type_simple(type));

	return (&namebuf[0]);

}

static void

libder_obj_dump_internal(const struct libder_object *obj, FILE *fp, int lvl)

{

	static char spacer[4096];

	const struct libder_object *child;

	/* Primitive, goofy, but functional. */

	if (spacer[0] == '\0')

		memset(spacer, '\t', sizeof(spacer));

	if (lvl >= (int)sizeof(spacer)) {

		/* Too large, truncate the display. */

		fprintf(fp, "%.*s...\n", (int)sizeof(spacer), spacer);

		return;

	}

	if (obj->children == NULL) {

		size_t col = lvl * 8;

		col += fprintf(fp, "%.*sOBJECT[type=%s, size=%zx]%s",

		    lvl, spacer, libder_type_name(obj->type),

		    obj->length, obj->length != 0 ? ": " : "");

		if (obj->length != 0) {

			uint8_t printb;

#define	LIBDER_CONTENTS_WRAP	80

			for (size_t i = 0; i < obj->length; i++) {

				if (col + 3 >= LIBDER_CONTENTS_WRAP) {

					fprintf(fp, "\n%.*s    ", lvl, spacer);

					col = (lvl * 8) + 4;

				}

				if (obj->payload == NULL)

					printb = 0;

				else

					printb = obj->payload[i];

				col += fprintf(fp, "%.02x ", printb);

			}

		}

		fprintf(fp, "\n");

		return;

	}

	fprintf(fp, "%.*sOBJECT[type=%s]\n", lvl, spacer,

	    libder_type_name(obj->type));

	DER_FOREACH_CHILD(child, obj)

		libder_obj_dump_internal(child, fp, lvl + 1);

}

void

libder_obj_dump(const struct libder_object *root, FILE *fp)

{

	libder_obj_dump_internal(root, fp, 0);

}

LIBDER_PRIVATE bool

libder_is_valid_obj(struct libder_ctx *ctx, const struct libder_tag *type,

    const uint8_t *payload, size_t payloadsz, bool varlen)

{

	if (payload != NULL) {

		assert(payloadsz > 0);

		assert(!varlen);

	} else {

		assert(payloadsz == 0);

	}

	/* No rules for non-universal types. */

	if (type->tag_class != BC_UNIVERSAL || type->tag_encoded)

		return (true);

	if (ctx->strict && type->tag_constructed) {

		/* Types that don't allow constructed */

		switch (libder_type_simple(type) & ~BER_TYPE_CONSTRUCTED_MASK) {

		case BT_BOOLEAN:

		case BT_INTEGER:

		case BT_REAL:

		case BT_NULL:

			libder_set_error(ctx, LDE_STRICT_PRIMITIVE);

			return (false);

		default:

			break;

		}

	} else if (ctx->strict) {

		/* Types that cannot be primitive */

		switch (libder_type_simple(type) | BER_TYPE_CONSTRUCTED_MASK) {

		case BT_SEQUENCE:

		case BT_SET:

			libder_set_error(ctx, LDE_STRICT_CONSTRUCTED);

			return (false);

		default:

			break;

		}

	}

	/* Further validation */

	switch (libder_type_simple(type)) {

	case BT_BOOLEAN:

		if (ctx->strict && payloadsz != 1) {

			libder_set_error(ctx, LDE_STRICT_BOOLEAN);

			return (false);

		}

		break;

	case BT_NULL:

		if (ctx->strict && (payloadsz != 0 || varlen)) {

			libder_set_error(ctx, LDE_STRICT_NULL);

			return (false);

		}

		break;

	case BT_BITSTRING:	/* Primitive */

		/*

		 * Bit strings require more invasive parsing later during child

		 * coalescing or normalization, so we alway strictly enforce

		 * their form.

		 */

		if (payloadsz == 1 && payload[0] != 0)

			return (false);

		/* We can't have more than seven unused bits. */

		return (payloadsz < 2 || payload[0] < 8);

	case BT_RESERVED:

		if (payloadsz != 0) {

			libder_set_error(ctx, LDE_STRICT_EOC);

			return (false);

		}

		break;

	default:

		break;

	}

	return (true);

}

LIBDER_PRIVATE bool

libder_obj_may_coalesce_children(const struct libder_object *obj)

{

	/* No clue about non-universal types. */

	if (obj->type->tag_class != BC_UNIVERSAL || obj->type->tag_encoded)

		return (false);

	/* Constructed types don't have children. */

	if (!obj->type->tag_constructed)

		return (false);

	/* Strip the constructed bit off. */

	switch (libder_type_simple(obj->type)) {

	case BT_OCTETSTRING:	/* Raw data types */

	case BT_BITSTRING:

		return (true);

	case BT_UTF8STRING:	/* String types */

	case BT_NUMERICSTRING:

	case BT_STRING:

	case BT_TELEXSTRING:

	case BT_VIDEOTEXSTRING:

	case BT_IA5STRING:

	case BT_GFXSTRING:

	case BT_VISSTRING:

	case BT_GENSTRING:

	case BT_UNIVSTRING:

	case BT_CHARSTRING:

	case BT_BMPSTRING:

		return (true);

	case BT_UTCTIME:	/* Time types */

	case BT_GENTIME:

		return (true);

	default:

		return (false);

	}

}

static size_t

libder_merge_bitstrings(uint8_t *buf, size_t offset, size_t bufsz,

    const struct libder_object *child)

{

	const uint8_t *rhs = child->payload;

	size_t rsz = child->disk_size, startoff = offset;

	uint8_t rhsunused, unused;

	rhsunused = (rhs != NULL ? rhs[0] : 0);

	/* We have no unused bits if the buffer's empty as of yet. */

	if (offset == 0)

		unused = 0;

	else

		unused = buf[0];

	/* Shave the lead byte off if we have one. */

	if (rsz > 1) {

		if (rhs != NULL)

			rhs++;

		rsz--;

	}

	if (unused == 0) {

		size_t extra = 0;

		/*

		 * In all cases we'll just write the unused byte separately,

		 * since we're copying way past it in the common case and can't