diff --git a/dist/audit.h b/dist/audit.h deleted file mode 100644 index 314282f..0000000 --- a/dist/audit.h +++ /dev/null @@ -1,91 +0,0 @@ -/* SPDX-License-Identifier: MIT */ -/* Copyright (C) 2022-2023 The crypto-auditing developers. */ - -/* This file defines probe points used by crypto-auditing. */ - -#ifdef ENABLE_CRYPTO_AUDITING - -# ifdef HAVE_SYS_SDT_H -# include -# endif - -/* Introduce a new context CONTEXT, derived from PARENT */ -# define CRYPTO_AUDITING_NEW_CONTEXT(context, parent) \ - DTRACE_PROBE2(crypto_auditing, new_context, context, parent) - -/* Assert an event with KEY and VALUE. The key is treated as a - * NUL-terminated string, while the value is in the size of machine - * word - */ -# define CRYPTO_AUDITING_WORD_DATA(context, key_ptr, value_ptr) \ - DTRACE_PROBE3(crypto_auditing, word_data, context, key_ptr, value_ptr) - -/* Assert an event with KEY and VALUE. Both the key and value are - * treated as a NUL-terminated string - */ -# define CRYPTO_AUDITING_STRING_DATA(context, key_ptr, value_ptr) \ - DTRACE_PROBE3(crypto_auditing, string_data, context, key_ptr, value_ptr) - -/* Assert an event with KEY and VALUE. The key is treated as a - * NUL-terminated string, while the value is explicitly sized with - * VALUE_SIZE - */ -# define CRYPTO_AUDITING_BLOB_DATA(context, key_ptr, value_ptr, value_size) \ - DTRACE_PROBE4(crypto_auditing, blob_data, context, key_ptr, value_ptr, value_size) - -struct crypto_auditing_data { - char *key_ptr; - void *value_ptr; - unsigned long value_size; -}; - -# define CRYPTO_AUDITING_WORD(key_ptr, value_ptr) \ - { (char *)(key_ptr), (void *)(intptr_t)(value_ptr), (unsigned long)-2 } -# define CRYPTO_AUDITING_STRING(key_ptr, value_ptr) \ - { (char *)(key_ptr), (void *)(value_ptr), (unsigned long)-1 } -# define CRYPTO_AUDITING_BLOB(key_ptr, value_ptr, value_size) \ - { (char *)(key_ptr), (void *)(value_ptr), value_size } - -/* Assert multiple events (16 at maxiumum) at once as a typed - * array. The VALUE_SIZE field of each element indicates the type of - * event: -2 means a word, -1 means a NUL-terminated string, and any - * other value means a blob with the length of VALUE_SIZE. - */ -# define CRYPTO_AUDITING_DATA(context, array_ptr, array_size) \ - DTRACE_PROBE3(crypto_auditing, data, context, array_ptr, array_size) - -# define CRYPTO_AUDITING_DATAV(context, ...) ({ \ - struct crypto_auditing_data __crypto_auditing_events[] = { __VA_ARGS__ }; \ - CRYPTO_AUDITING_DATA(context, \ - __crypto_auditing_events, \ - sizeof (__crypto_auditing_events) / sizeof (__crypto_auditing_events[0])); \ -}) - -/* Introduce a new context CONTEXT, derived from PARENT, as well as - * assert multiple events. - */ -# define CRYPTO_AUDITING_NEW_CONTEXT_WITH_DATA(context, parent, array_ptr, array_size) \ - DTRACE_PROBE4(crypto_auditing, new_context_with_data, context, parent, array_ptr, array_size) - -# define CRYPTO_AUDITING_NEW_CONTEXT_WITH_DATAV(context, parent, ...) ({ \ - struct crypto_auditing_data __crypto_auditing_events[] = { __VA_ARGS__ }; \ - CRYPTO_AUDITING_NEW_CONTEXT_WITH_DATA(context, parent, \ - __crypto_auditing_events, \ - sizeof (__crypto_auditing_events) / sizeof (__crypto_auditing_events[0])); \ -}) - -#else - -# define CRYPTO_AUDITING_NEW_CONTEXT(context, parent) -# define CRYPTO_AUDITING_WORD_DATA(context, key_ptr, value_ptr) -# define CRYPTO_AUDITING_STRING_DATA(context, key_ptr, value_ptr) -# define CRYPTO_AUDITING_BLOB_DATA(context, key_ptr, value_ptr, value_size) -# define CRYPTO_AUDITING_WORD(key_ptr, value_ptr) -# define CRYPTO_AUDITING_STRING(key_ptr, value_ptr) -# define CRYPTO_AUDITING_BLOB(key_ptr, value_ptr, value_size) -# define CRYPTO_AUDITING_DATA(context, array_ptr, array_size) -# define CRYPTO_AUDITING_DATAV(context, ...) -# define CRYPTO_AUDITING_NEW_CONTEXT_WITH_DATA(context, parent, array_ptr, array_size) -# define CRYPTO_AUDITING_NEW_CONTEXT_WITH_DATAV(context, parent, ...) - -#endif /* ENABLE_CRYPTO_AUDITING */ diff --git a/dist/crau/.dir-locals.el b/dist/crau/.dir-locals.el new file mode 100644 index 0000000..042381f --- /dev/null +++ b/dist/crau/.dir-locals.el @@ -0,0 +1 @@ +((c-mode . ((c-file-style . "linux")))) diff --git a/dist/crau/LICENSE b/dist/crau/LICENSE new file mode 100644 index 0000000..46fae13 --- /dev/null +++ b/dist/crau/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2025 Daiki Ueno + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/dist/crau/README.md b/dist/crau/README.md new file mode 100644 index 0000000..1b4a660 --- /dev/null +++ b/dist/crau/README.md @@ -0,0 +1,76 @@ +# crau + +`crau` is a header-only library to help define +[crypto-auditing][crypto-auditing] probes in C applications. + +## Getting started + +1. Define `ENABLE_CRYPTO_AUDITING` to 1, e.g., through + ``. Also check if `` is installed and + `DTRACE_PROBE*` macros are defined there. + +1. Include ``. One of the C files should define + `CRAU_IMPLEMENTATION` to get the functions defined. Also decide + where to manage the context stack: if it is part of another struct, + add field with type `struct crau_context_stack_st`; if it is + maintained globally as thread-local, define a thread-local + variable. + +1. (Optional) Customize the implementation with configuration macros, + e.g., `CRAU_CONTEXT_STACK_DEPTH` for your needs. See + `` for the details. + +1. Instrument the code as follows. See `` and + `` for the documentation: + +```c +/* Public key signing operation starts (but the algorithm is not known yet) */ +crau_new_context_with_data( + &stack, + "name", CRAU_STRING, "pk::sign", + NULL) +... +/* Signing algorithm and bits are known at this point */ +crau_data( + &stack, + "pk::algorithm", CRAU_STRING, "mldsa", + "pk::bits", CRAU_WORD, 1952 * 8, + NULL) + +/* Do the operation */ +sig = mldsa_sign(...); + +/* Pop the operation context */ +crau_pop_context(&stack); +``` + +## Low level macros + +Instead of using those helper functions (`crau_*`), it is also +possible to directly instrument the library with `CRAU_` macros +defined in `macros.h`: + +```c +/* Public key signing operation starts (but the algorithm is not known yet) */ +CRAU_NEW_CONTEXT_WITH_DATAV( + (long)this_function, + (long)parent_function, + CRAU_STRING_DATA("name", "pk::sign")); +... +/* Signing algorithm and bits are known at this point */ +CRAU_DATAV( + (long)this_function, + CRAU_STRING_DATA("pk::algorithm", "mldsa"), + CRAU_WORD_DATA("pk::bits", 1952 * 8)) + +/* Do the operation */ +sig = mldsa_sign(...); +``` + +Note that those macros don't do context management. + +## License + +MIT or Unlicense + +[crypto-auditing]: https://github.com/latchset/crypto-auditing diff --git a/dist/crau/UNLICENSE b/dist/crau/UNLICENSE new file mode 100644 index 0000000..efb9808 --- /dev/null +++ b/dist/crau/UNLICENSE @@ -0,0 +1,24 @@ +This is free and unencumbered software released into the public domain. + +Anyone is free to copy, modify, publish, use, compile, sell, or +distribute this software, either in source code form or as a compiled +binary, for any purpose, commercial or non-commercial, and by any +means. + +In jurisdictions that recognize copyright laws, the author or authors +of this software dedicate any and all copyright interest in the +software to the public domain. We make this dedication for the benefit +of the public at large and to the detriment of our heirs and +successors. We intend this dedication to be an overt act of +relinquishment in perpetuity of all present and future rights to this +software under copyright law. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +For more information, please refer to diff --git a/dist/crau/crau.h b/dist/crau/crau.h new file mode 100644 index 0000000..53d3355 --- /dev/null +++ b/dist/crau/crau.h @@ -0,0 +1,304 @@ +/* SPDX-License-Identifier: MIT OR Unlicense */ +/* Copyright (C) 2022-2025 The crypto-auditing developers. */ + +/* This file declares a set of high-level functions to insert probe + * points used for crypto-auditing into the application programs. See + * for the low-level interface. + * + * As this is a header-only library, one of C files that includes + * this file should do: + * + * #define CRAU_IMPLEMENTATION + * #include "crau/crau.h" + * + * to get the necessary functions are defined. + * + * The following configuration macros can also be set to override the + * behavior of the implementation: + * + * * CRAU_CONTEXT_STACK_DEPTH: depth of the thread-local context stack + * (default: 3) + * + * * CRAU_RETURN_ADDRESS: return address of the current function + * (default: auto-detected) + * + * * CRAU_THREAD_LOCAL: thread-local modifier of the C language + * (default: auto-detected) + * + * * CRAU_MAYBE_UNUSED: an attribute to suppress warnings when a + * function argument is not used in the function body (default: + * auto-detected) + * + * Unless ENABLE_CRYPTO_AUDITING is defined, all functions turn to + * no-op. + */ + +#ifndef CRAU_CRAU_H +#define CRAU_CRAU_H + +#include +#include +#include + +/* A special context value used to represent a context which is + * automatically assigned based on the current call frame. + */ +#ifndef CRAU_AUTO_CONTEXT +# ifdef __GNUC__ +# define CRAU_AUTO_CONTEXT (long)(intptr_t)(char *)__builtin_return_address(0) +# elif defined(__CC_ARM) +# define CRAU_AUTO_CONTEXT (long)(intptr_t)(char *)__return_address() +# else +# define CRAU_AUTO_CONTEXT CRAU_ORPHANED_CONTEXT +# endif +#endif /* CRAU_AUTO_CONTEXT */ + +/* A special context value used to represent a context which is not + * associated with any parent nor children. + */ +#define CRAU_ORPHANED_CONTEXT ((long)-1) + +#ifndef CRAU_CONTEXT_STACK_DEPTH +# define CRAU_CONTEXT_STACK_DEPTH 3 +#endif /* CRAU_CONTEXT_STACK_DEPTH */ + +struct crau_context_stack_st { + long stack[CRAU_CONTEXT_STACK_DEPTH]; + size_t top; +}; + +/* Types of crypto-auditing event data. CRAU_WORD means an integer in + * a machine word, CRAU_STRING means a NUL-terminated + * string. CRAU_BLOB means an explicitly sized binary blob. + */ +enum crau_data_type_t { + CRAU_WORD, + CRAU_STRING, + CRAU_BLOB, +}; + +/* Push a context CONTEXT onto the given context stack STACK. If the depth of + * the stack exceeds CRAU_CONTEXT_STACK_DEPTH, the older element will be + * removed. + * + * This call shall be followed by a `crau_pop_context`. + */ +void crau_push_context(struct crau_context_stack_st *stack, + long context); + +/* Pop a context from the given context stack STACK. If the stack is empty, it + * returns a CRAU_ORPHANED_CONTEXT. + */ +long crau_pop_context(struct crau_context_stack_st *stack); + +/* Return the context currently active in the given context stack STACK. If + * there is no active context, it returns a CRAU_ORPHANED_CONTEXT. + */ +long crau_current_context(struct crau_context_stack_st *stack); + +/* Push a context CONTEXT onto the given context stack STACK, + * optionally emitting events through varargs. + * + * If the depth of the stack exceeds CRAU_CONTEXT_STACK_DEPTH, the + * older element will be removed. This call shall be followed by a + * `crau_pop_context`. + */ +void crau_push_context_with_data(struct crau_context_stack_st *stack, + long context, ...); + +void crau_push_context_with_datav(struct crau_context_stack_st *stack, + long context, va_list ap); + +/* Push a new context (inferred from the current call stack) onto the given + * context stack STACK, optionally emitting events through varargs. + * + * Typical usage example is as follows: + * + * crau_new_context_with_data( + * stack, + * "name", CRAU_STRING, "pk::sign", + * "pk::algorithm", CRAU_STRING, "mldsa", + * "pk::bits", CRAU_WORD, 1952 * 8, + * NULL); + * + * If the depth of the stack exceeds CRAU_CONTEXT_STACK_DEPTH, the + * older element will be removed. This call shall be followed by a + * `crau_pop_context`. + */ +#define crau_new_context_with_data(stack, ...) \ + crau_push_context_with_data((stack), CRAU_AUTO_CONTEXT, __VA_ARGS__) + +#define crau_new_context_with_datav(stack, ap) \ + crau_push_context_with_datav((stack), CRAU_AUTO_CONTEXT, (ap)) + +/* Emit events through varargs, under the currently active context in the given + * context stack STACK. Unlike `crau_new_context_with_data`, this does not push + * a new context. + */ +void crau_data(struct crau_context_stack_st *stack, ...); + +void crau_datav(struct crau_context_stack_st *stack, va_list ap); + +#ifdef CRAU_IMPLEMENTATION + +#include "macros.h" + +/* Avoid name clash with crau_data_type_t */ +#undef CRAU_WORD +#undef CRAU_STRING +#undef CRAU_BLOB + +# ifdef ENABLE_CRYPTO_AUDITING + +static inline void push_context(struct crau_context_stack_st *stack, + long context) +{ + stack->stack[stack->top++ % CRAU_CONTEXT_STACK_DEPTH] = context; +} + +void crau_push_context(struct crau_context_stack_st *stack, + long context) +{ + CRAU_NEW_CONTEXT(context, crau_current_context(stack)); + push_context(stack, context); +} + +long crau_pop_context(struct crau_context_stack_st *stack) +{ + return stack->top == 0 ? CRAU_ORPHANED_CONTEXT : + stack->stack[--stack->top]; +} + +long crau_current_context(struct crau_context_stack_st *stack) +{ + return stack->top == 0 ? CRAU_ORPHANED_CONTEXT : + stack->stack[stack->top - 1]; +} + +static inline unsigned long +crau_accumulate_datav(struct crypto_auditing_data data[CRAU_MAX_DATA_ELEMS], + va_list ap) +{ + unsigned long count = 0; + char *key_ptr; + + for (key_ptr = va_arg(ap, char *); + key_ptr != NULL && count < CRAU_MAX_DATA_ELEMS; + key_ptr = va_arg(ap, char *), count++) { + data[count].key_ptr = key_ptr; + + switch (va_arg(ap, enum crau_data_type_t)) { + case CRAU_WORD: + data[count].value_ptr = (void *)va_arg(ap, intptr_t); + data[count].value_size = (unsigned long)-2; + break; + case CRAU_STRING: + data[count].value_ptr = (void *)va_arg(ap, char *); + data[count].value_size = (unsigned long)-1; + break; + case CRAU_BLOB: + data[count].value_ptr = va_arg(ap, void *); + data[count].value_size = va_arg(ap, unsigned long); + break; + } + } + + return count; +} + +void crau_push_context_with_datav(struct crau_context_stack_st *stack, + long context, va_list ap) +{ + struct crypto_auditing_data data[CRAU_MAX_DATA_ELEMS]; + unsigned long count; + + count = crau_accumulate_datav(data, ap); + + CRAU_NEW_CONTEXT_WITH_DATA(context, crau_current_context(stack), data, + count); + push_context(stack, context); +} + +void crau_push_context_with_data(struct crau_context_stack_st *stack, + long context, ...) +{ + va_list ap; + + va_start(ap, context); + crau_push_context_with_datav(stack, context, ap); + va_end(ap); +} + +void crau_datav(struct crau_context_stack_st *stack, va_list ap) +{ + struct crypto_auditing_data data[CRAU_MAX_DATA_ELEMS]; + size_t count; + + count = crau_accumulate_datav(data, ap); + + CRAU_DATA(crau_current_context(stack), data, count); +} + +void crau_data(struct crau_context_stack_st *stack, ...) +{ + va_list ap; + + va_start(ap, stack); + crau_datav(stack, ap); + va_end(ap); +} + +# else + +# ifndef CRAU_MAYBE_UNUSED +# if defined(__has_c_attribute) +# if __has_c_attribute (__maybe_unused__) +# define CRAU_MAYBE_UNUSED [[__maybe_unused__]] +# endif +# elif defined(__GNUC__) +# define CRAU_MAYBE_UNUSED __attribute__((__unused__)) +# endif +# endif /* CRAU_MAYBE_UNUSED */ + +void crau_push_context(struct crau_context_stack_st *stack CRAU_MAYBE_UNUSED, + long context CRAU_MAYBE_UNUSED) +{ +} + +long +crau_pop_context(struct crau_context_stack_st *stack CRAU_MAYBE_UNUSED) +{ + return CRAU_ORPHANED_CONTEXT; +} + +long +crau_current_context(struct crau_context_stack_st *stack CRAU_MAYBE_UNUSED) +{ + return CRAU_ORPHANED_CONTEXT; +} + +void crau_push_context_with_datav(struct crau_context_stack_st *stack CRAU_MAYBE_UNUSED, + long context CRAU_MAYBE_UNUSED, + va_list ap CRAU_MAYBE_UNUSED) +{ +} + +void crau_push_context_with_data(struct crau_context_stack_st *stack CRAU_MAYBE_UNUSED, + long context CRAU_MAYBE_UNUSED, ...) +{ +} + +void crau_datav(struct crau_context_stack_st *stack CRAU_MAYBE_UNUSED, + va_list ap CRAU_MAYBE_UNUSED) +{ +} + +void crau_data(struct crau_context_stack_st *stack CRAU_MAYBE_UNUSED, ...) +{ +} + +# endif /* ENABLE_CRYPTO_AUDITING */ + +#endif /* CRAU_IMPLEMENTATION */ + +#endif /* CRAU_CRAU_H */ diff --git a/dist/crau/macros.h b/dist/crau/macros.h new file mode 100644 index 0000000..0398c7e --- /dev/null +++ b/dist/crau/macros.h @@ -0,0 +1,120 @@ +/* SPDX-License-Identifier: MIT OR Unlicense */ +/* Copyright (C) 2022-2025 The crypto-auditing developers. */ + +/* This file defines a set of low-level macros to insert probe points + * used for crypto-auditing into the application programs. See + * for a higher-level and more ergonomic interface. + * + * Unless ENABLE_CRYPTO_AUDITING is defined, all macros turn to no-op. + */ + +#ifndef CRAU_MACROS_H +#define CRAU_MACROS_H + +#ifdef ENABLE_CRYPTO_AUDITING + +#include +#ifndef DTRACE_PROBE +# error "no DTrace compatibile macros defined in " +#endif + +/* Introduce a new context CONTEXT, derived from the parent context PARENT. + */ +#define CRAU_NEW_CONTEXT(context, parent) \ + DTRACE_PROBE2(crypto_auditing, new_context, context, parent) + +/* Emit an event with KEY and VALUE. The key is a NUL-terminated + * string, while the value is an integer in the size of a machine + * word. + */ +#define CRAU_WORD_DATA(context, key_ptr, value_ptr) \ + DTRACE_PROBE3(crypto_auditing, word_data, context, key_ptr, value_ptr) + +/* Emit an event with KEY and VALUE. The key is a NUL-terminated + * string, while the value is also a NUL-terminated string. + */ +#define CRAU_STRING_DATA(context, key_ptr, value_ptr) \ + DTRACE_PROBE3(crypto_auditing, string_data, context, key_ptr, value_ptr) + +/* Emit an event with KEY and VALUE. The key is a NUL-terminated + * string, while the value is explicitly sized binary blob of the + * VALUE_SIZE size. + */ +#define CRAU_BLOB_DATA(context, key_ptr, value_ptr, value_size) \ + DTRACE_PROBE4(crypto_auditing, blob_data, context, key_ptr, value_ptr, \ + value_size) + +/* Generic data structure that represents an event. The KEY_PTR field + * points to the name of the event key, and the VALUE_PTR field points + * to the value. + * + * The VALUE_SIZE field is set depending on the type of the value. If + * the value is a machine word, it is set to 0xfffffffe (= -2). If + * the value is a NUL-terminated string, it is set to 0xffffffff (= + * -1). Otherwise, it is set to the actual size of the value. + */ +struct crypto_auditing_data { + char *key_ptr; + void *value_ptr; + unsigned long value_size; +}; + +#define CRAU_WORD(key_ptr, value_ptr) \ + { (char *)(key_ptr), (void *)(intptr_t)(value_ptr), (unsigned long)-2 } +#define CRAU_STRING(key_ptr, value_ptr) \ + { (char *)(key_ptr), (void *)(value_ptr), (unsigned long)-1 } +#define CRAU_BLOB(key_ptr, value_ptr, value_size) \ + { (char *)(key_ptr), (void *)(value_ptr), value_size } + +/* The maximum number of events which can be emitted at once. */ +#define CRAU_MAX_DATA_ELEMS 16 + +/* Emit multiple events at once. + */ +#define CRAU_DATA(context, array_ptr, array_size) \ + DTRACE_PROBE3(crypto_auditing, data, context, array_ptr, array_size) + +/* Emit multiple events at once through varargs. + */ +#define CRAU_DATAV(context, ...) \ + ({ \ + struct crypto_auditing_data __crau_data[] = { __VA_ARGS__ }; \ + CRAU_DATA(context, __crau_data, \ + sizeof(__crau_data) / sizeof(__crau_data[0])); \ + }) + +/* Introduce a new context CONTEXT, derived from PARENT, with optional + * events to be emitted. + */ +#define CRAU_NEW_CONTEXT_WITH_DATA(context, parent, array_ptr, array_size) \ + DTRACE_PROBE4(crypto_auditing, new_context_with_data, context, parent, \ + array_ptr, array_size) + +/* Introduce a new context CONTEXT, derived from PARENT, with optional + * events to be emitted, through varargs. + */ +#define CRAU_NEW_CONTEXT_WITH_DATAV(context, parent, ...) \ + ({ \ + struct crypto_auditing_data __crau_data[] = { __VA_ARGS__ }; \ + CRAU_NEW_CONTEXT_WITH_DATA(context, parent, __crau_data, \ + sizeof(__crau_data) / \ + sizeof(__crau_data[0])); \ + }) + +#else + +#define CRAU_NEW_CONTEXT(context, parent) +#define CRAU_WORD_DATA(context, key_ptr, value_ptr) +#define CRAU_STRING_DATA(context, key_ptr, value_ptr) +#define CRAU_BLOB_DATA(context, key_ptr, value_ptr, value_size) +#define CRAU_WORD(key_ptr, value_ptr) +#define CRAU_STRING(key_ptr, value_ptr) +#define CRAU_BLOB(key_ptr, value_ptr, value_size) +#define CRAU_DATA(context, array_ptr, array_size) +#define CRAU_DATAV(context, ...) +#define CRAU_NEW_CONTEXT_WITH_DATA(context, parent, array_ptr, array_size) +#define CRAU_NEW_CONTEXT_WITH_DATAV(context, parent, ...) + +#endif /* ENABLE_CRYPTO_AUDITING */ + +#endif /* CRAU_MACROS_H */