#include "coap3/coap_libcoap_build.h"

#if COAP_OSCORE_SUPPORT

#include <ctype.h>

#define AAD_BUF_LEN 200 /* length of aad_buffer */

static oscore_ctx_t *coap_oscore_init(coap_context_t *c_context,

coap_oscore_conf_t *oscore_conf);

#if COAP_CLIENT_SUPPORT

coap_oscore_initiate(coap_session_t *session, coap_oscore_conf_t *oscore_conf) {

if (oscore_conf) {

oscore_ctx_t *osc_ctx;

if (oscore_conf->recipient_chain == NULL) {

coap_log_warn("OSCORE: Recipient ID must be defined for a client\n");

coap_delete_oscore_conf(oscore_conf);

return 0;

}

if (oscore_conf->rfc8613_b_2) {

/* Need to replace id_context with random value */

coap_binary_t *id_context = coap_new_binary(8);

if (id_context == NULL) {

coap_delete_oscore_conf(oscore_conf);

return 0;

}

coap_delete_bin_const(oscore_conf->id_context);

coap_prng_lkd(id_context->s, id_context->length);

oscore_conf->id_context = (coap_bin_const_t *)id_context;

session->b_2_step = COAP_OSCORE_B_2_STEP_1;

coap_log_oscore("Appendix B.2 client step 1 (Generated ID1)\n");

}

osc_ctx = coap_oscore_init(session->context, oscore_conf);

if (osc_ctx == NULL) {

return 0;

}

coap_oscore_session_set_recipient_ctx(session, osc_ctx->recipient_chain);

session->oscore_encryption = 1;

}

return 1;

}

COAP_API coap_session_t *

coap_new_client_session_oscore(coap_context_t *ctx,

coap_oscore_conf_t *oscore_conf) {

coap_session_t *session;

coap_lock_lock(return NULL);

session = coap_new_client_session_oscore3_lkd(ctx, local_if, server, proto, oscore_conf, NULL,

NULL, NULL);

coap_lock_unlock();

return session;

}

COAP_API coap_session_t *

coap_new_client_session_oscore3(coap_context_t *ctx,

coap_str_const_t *ws_host) {

coap_session_t *session;

coap_lock_lock(return NULL);

session = coap_new_client_session_oscore3_lkd(ctx, local_if, server, proto, oscore_conf, app_data,

callback, ws_host);

coap_lock_unlock();

return session;

}

coap_session_t *

coap_new_client_session_oscore3_lkd(coap_context_t *ctx,

coap_str_const_t *ws_host) {

coap_session_t *session =

coap_new_client_session3_lkd(ctx, local_if, server, proto, app_data, callback, ws_host);

if (!session)

return NULL;

if (coap_oscore_initiate(session, oscore_conf) == 0) {

coap_session_release_lkd(session);

return NULL;

}

return session;

}

COAP_API coap_session_t *

coap_new_client_session_oscore_psk(coap_context_t *ctx,

coap_oscore_conf_t *oscore_conf) {

coap_session_t *session;

coap_lock_lock(return NULL);

session = coap_new_client_session_oscore_psk3_lkd(ctx, local_if, server, proto, psk_data,

oscore_conf, NULL, NULL, NULL);

coap_lock_unlock();

return session;

}

COAP_API coap_session_t *

coap_new_client_session_oscore_psk3(coap_context_t *ctx,

coap_str_const_t *ws_host) {

coap_session_t *session;

coap_lock_lock(return NULL);

session = coap_new_client_session_oscore_psk3_lkd(ctx, local_if, server, proto, psk_data,

oscore_conf, app_data, callback, ws_host);

coap_lock_unlock();

return session;

}

coap_session_t *

coap_new_client_session_oscore_psk3_lkd(coap_context_t *ctx,

coap_str_const_t *ws_host) {

coap_session_t *session;

coap_lock_check_locked();

session = coap_new_client_session_psk3_lkd(ctx, local_if, server, proto, psk_data,

app_data, callback, ws_host);

if (!session)

return NULL;

if (coap_oscore_initiate(session, oscore_conf) == 0) {

coap_session_release_lkd(session);

return NULL;

}

return session;

}

COAP_API coap_session_t *

coap_new_client_session_oscore_pki(coap_context_t *ctx,

coap_oscore_conf_t *oscore_conf) {

coap_session_t *session;

coap_lock_lock(return NULL);

session = coap_new_client_session_oscore_pki3_lkd(ctx, local_if, server, proto, pki_data,

oscore_conf, NULL, NULL, NULL);

coap_lock_unlock();

return session;

}

COAP_API coap_session_t *

coap_new_client_session_oscore_pki3(coap_context_t *ctx,

coap_str_const_t *ws_host) {

coap_session_t *session;

coap_lock_lock(return NULL);

session = coap_new_client_session_oscore_pki3_lkd(ctx, local_if, server, proto, pki_data,

oscore_conf, app_data, callback, ws_host);

coap_lock_unlock();

return session;

}

coap_session_t *

coap_new_client_session_oscore_pki3_lkd(coap_context_t *ctx,

coap_str_const_t *ws_host) {

coap_session_t *session;

coap_lock_check_locked();

session = coap_new_client_session_pki3_lkd(ctx, local_if, server, proto, pki_data,

app_data, callback, ws_host);

if (!session)

return NULL;

if (coap_oscore_initiate(session, oscore_conf) == 0) {

coap_session_release_lkd(session);

return NULL;

}

return session;

}

#endif /* COAP_CLIENT_SUPPORT */

#if COAP_SERVER_SUPPORT

COAP_API int

coap_context_oscore_server(coap_context_t *context,

coap_oscore_conf_t *oscore_conf) {

int ret;

coap_lock_lock(return 0);

ret = coap_context_oscore_server_lkd(context, oscore_conf);

coap_lock_unlock();

return ret;

}

coap_context_oscore_server_lkd(coap_context_t *context,

coap_oscore_conf_t *oscore_conf) {

oscore_ctx_t *osc_ctx;

coap_lock_check_locked();

osc_ctx = coap_oscore_init(context, oscore_conf);

/* osc_ctx already added to context->osc_ctx */

if (osc_ctx)

return 1;

return 0;

}

#endif /* COAP_SERVER_SUPPORT */

coap_rebuild_pdu_for_proxy(coap_pdu_t *pdu) {

coap_uri_t uri;

coap_opt_iterator_t opt_iter;

coap_opt_t *option;

uint8_t option_value_buffer[15];

coap_optlist_t *optlist_chain = NULL;

if ((option =

coap_check_option(pdu, COAP_OPTION_PROXY_URI, &opt_iter)) == NULL)

return 1;

/* Need to break down into the component parts, but keep data safe */

memset(&uri, 0, sizeof(uri));

if (coap_split_proxy_uri(coap_opt_value(option),

coap_opt_length(option),

&uri) < 0 || uri.scheme >= COAP_URI_SCHEME_LAST) {

coap_log_warn("Proxy URI '%.*s' not decodable\n",

coap_opt_length(option),

(const char *)coap_opt_value(option));

goto error;

}

if (!coap_remove_option(pdu, COAP_OPTION_PROXY_URI))

goto error;

if (!coap_insert_option(pdu,

COAP_OPTION_URI_HOST,

uri.host.length,

uri.host.s))

goto error;

if (uri.port != (coap_uri_scheme_is_secure(&uri) ? COAPS_DEFAULT_PORT : COAP_DEFAULT_PORT) &&

!coap_insert_option(pdu,

COAP_OPTION_URI_PORT,

coap_encode_var_safe(option_value_buffer,

sizeof(option_value_buffer),

uri.port & 0xffff),

option_value_buffer))

goto error;

if (uri.path.length) {

/* Add in the Uri-Path options */

if (!coap_path_into_optlist(uri.path.s, uri.path.length, COAP_OPTION_URI_PATH,

&optlist_chain))

goto error;

}

if (uri.query.length) {

/* Add in the Uri-Query options */

if (!coap_query_into_optlist(uri.query.s, uri.query.length, COAP_OPTION_URI_QUERY,

&optlist_chain))

goto error;

}

if (!coap_add_optlist_pdu(pdu, &optlist_chain))

goto error;

if (!coap_insert_option(pdu,

COAP_OPTION_PROXY_SCHEME,

strlen(coap_uri_scheme[uri.scheme].name),

(const uint8_t *)coap_uri_scheme[uri.scheme].name))

goto error;

coap_delete_optlist(optlist_chain);

return 1;

error:

coap_delete_optlist(optlist_chain);

return 0;

}

static void

dump_cose(cose_encrypt0_t *cose, const char *message) {

#if COAP_MAX_LOGGING_LEVEL < _COAP_LOG_OSCORE

(void)cose;

(void)message;

#else /* COAP_MAX_LOGGING_LEVEL >= _COAP_LOG_OSCORE */

if (coap_get_log_level() >= COAP_LOG_OSCORE) {

char buffer[30];

coap_log_oscore("%s COSE information\n", message);

oscore_log_char_value(COAP_LOG_OSCORE, "alg",

cose_get_alg_name(cose->alg, buffer, sizeof(buffer)));

oscore_log_hex_value(COAP_LOG_OSCORE, "key", &cose->key);

oscore_log_hex_value(COAP_LOG_OSCORE, "partial_iv", &cose->partial_iv);

oscore_log_hex_value(COAP_LOG_OSCORE, "key_id", &cose->key_id);

oscore_log_hex_value(COAP_LOG_OSCORE, "kid_context", &cose->kid_context);

oscore_log_hex_value(COAP_LOG_OSCORE,

"oscore_option",

&cose->oscore_option);

oscore_log_hex_value(COAP_LOG_OSCORE, "nonce", &cose->nonce);

oscore_log_hex_value(COAP_LOG_OSCORE, "external_aad", &cose->external_aad);

oscore_log_hex_value(COAP_LOG_OSCORE, "aad", &cose->aad);

}

#endif /* COAP_MAX_LOGGING_LEVEL >= _COAP_LOG_OSCORE */

}

COAP_API coap_pdu_t *

coap_oscore_new_pdu_encrypted(coap_session_t *session,

coap_pdu_t *pdu,

coap_bin_const_t *kid_context,

oscore_partial_iv_t send_partial_iv) {

coap_pdu_t *ret_pdu;

coap_lock_lock(return NULL);

ret_pdu = coap_oscore_new_pdu_encrypted_lkd(session, pdu, kid_context, send_partial_iv);

coap_lock_unlock();

return ret_pdu;

}

coap_pdu_t *

coap_oscore_new_pdu_encrypted_lkd(coap_session_t *session,

coap_pdu_t *pdu,

coap_bin_const_t *kid_context,

oscore_partial_iv_t send_partial_iv) {

uint8_t coap_request = COAP_PDU_IS_REQUEST(pdu) || COAP_PDU_IS_PING(pdu);

coap_pdu_code_t code =

coap_request ? COAP_REQUEST_CODE_POST : COAP_RESPONSE_CODE(204);

coap_pdu_t *osc_pdu;

coap_pdu_t *plain_pdu = NULL;

coap_bin_const_t pdu_token;

coap_opt_iterator_t opt_iter;

coap_opt_t *option;

uint8_t pdu_code = pdu->code;

size_t length;

const uint8_t *data;

uint8_t *ciphertext_buffer = NULL;

size_t ciphertext_len = 0;

uint8_t aad_buffer[AAD_BUF_LEN];

uint8_t nonce_buffer[13];

coap_bin_const_t aad;

coap_bin_const_t nonce;

oscore_recipient_ctx_t *rcp_ctx;

oscore_ctx_t *osc_ctx;

cose_encrypt0_t cose[1];

uint8_t group_flag = 0;

int show_pdu = 0;

int doing_observe = 0;

uint32_t observe_value = 0;

oscore_association_t *association = NULL;

oscore_sender_ctx_t *snd_ctx;

uint8_t external_aad_buffer[200];

coap_bin_const_t external_aad;

uint8_t oscore_option[255];

ssize_t oscore_option_len;

/* Check that OSCORE has not already been done */

if (coap_check_option(pdu, COAP_OPTION_OSCORE, &opt_iter))

return NULL;

if (coap_check_option(pdu, COAP_OPTION_OBSERVE, &opt_iter))

doing_observe = 1;

coap_log_debug("PDU to encrypt\n");

coap_show_pdu(COAP_LOG_DEBUG, pdu);

osc_pdu = coap_pdu_init(pdu->type == COAP_MESSAGE_NON &&

session->b_2_step != COAP_OSCORE_B_2_NONE ?

COAP_MESSAGE_CON : pdu->type,

code,

pdu->mid,

pdu->used_size + coap_oscore_overhead(session, pdu));

if (osc_pdu == NULL)

return NULL;

cose_encrypt0_init(cose); /* clears cose memory */

pdu_token = coap_pdu_get_token(pdu);

if (coap_request) {

/*

rcp_ctx = session->recipient_ctx;

if (rcp_ctx == NULL)

goto error;

osc_ctx = rcp_ctx->osc_ctx;

assert(osc_ctx);

snd_ctx = osc_ctx->sender_context;

} else {

/*

association = oscore_find_association(session, &pdu_token);

if (association == NULL)

goto error;

rcp_ctx = association->recipient_ctx;

osc_ctx = rcp_ctx->osc_ctx;

snd_ctx = osc_ctx->sender_context;

cose_encrypt0_set_partial_iv(cose, association->partial_iv);

cose_encrypt0_set_aad(cose, association->aad);

}

cose_encrypt0_set_alg(cose, osc_ctx->aead_alg);

if (coap_request || doing_observe ||

send_partial_iv == OSCORE_SEND_PARTIAL_IV) {

uint8_t partial_iv_buffer[8];

size_t partial_iv_len;

coap_bin_const_t partial_iv;

partial_iv_len = coap_encode_var_safe8(partial_iv_buffer,

sizeof(partial_iv_buffer),

snd_ctx->seq);

if (snd_ctx->seq == 0) {

/* Need to special case */

partial_iv_buffer[0] = '\000';

partial_iv_len = 1;

}

partial_iv.s = partial_iv_buffer;

partial_iv.length = partial_iv_len;

cose_encrypt0_set_partial_iv(cose, &partial_iv);

}

if (coap_request)

cose_encrypt0_set_kid_context(cose, osc_ctx->id_context);

cose_encrypt0_set_key_id(cose, snd_ctx->sender_id);

/* nonce (needs to have sender information correctly set up) */

if (coap_request || doing_observe ||

send_partial_iv == OSCORE_SEND_PARTIAL_IV) {

/*

nonce.s = nonce_buffer;

nonce.length = 13;

oscore_generate_nonce(cose, osc_ctx, nonce_buffer, 13);

cose_encrypt0_set_nonce(cose, &nonce);

if (!oscore_increment_sender_seq(osc_ctx))

goto error;

if (osc_ctx->save_seq_num_func) {

if (osc_ctx->sender_context->seq > osc_ctx->sender_context->next_seq) {

/* Only update at ssn_freq rate */

osc_ctx->sender_context->next_seq += osc_ctx->ssn_freq;

osc_ctx->save_seq_num_func(osc_ctx->sender_context->next_seq,

osc_ctx->save_seq_num_func_param);

}

}

} else {

/*

cose_encrypt0_set_nonce(cose, association->nonce);

}

/* OSCORE_option (needs to be before AAD as included in AAD if group) */

/* cose is modified for encode option in response message */

if (!coap_request) {

/* no kid on response */

cose_encrypt0_set_key_id(cose, NULL);

if (!doing_observe && send_partial_iv == OSCORE_SEND_NO_IV)

cose_encrypt0_set_partial_iv(cose, NULL);

}

if (kid_context) {

cose_encrypt0_set_kid_context(cose, kid_context);

}

oscore_option_len =

oscore_encode_option_value(oscore_option, sizeof(oscore_option), cose,

group_flag,

session->b_2_step != COAP_OSCORE_B_2_NONE);

if (oscore_option_len < 0) {

coap_log_oscore("Invalid parameters for creating OSCORE option\n");

goto error;

}

if (!coap_request) {

/* Reset what was just unset as appropriate for AAD */

cose_encrypt0_set_key_id(cose, rcp_ctx->recipient_id);

cose_encrypt0_set_partial_iv(cose, association->partial_iv);

}

if (kid_context)

cose_encrypt0_set_kid_context(cose, osc_ctx->id_context);

/*

if (coap_request || send_partial_iv == OSCORE_SEND_PARTIAL_IV) {

/* External AAD */

external_aad.s = external_aad_buffer;

external_aad.length = oscore_prepare_e_aad(osc_ctx,

cose,

NULL,

0,

NULL,

external_aad_buffer,

sizeof(external_aad_buffer));

if (external_aad.length == 0)

goto error;

cose_encrypt0_set_external_aad(cose, &external_aad);

/* AAD */

aad.s = aad_buffer;

aad.length = oscore_prepare_aad(external_aad_buffer,

external_aad.length,

aad_buffer,

sizeof(aad_buffer));

if (aad.length == 0)

goto error;

assert(aad.length < AAD_BUF_LEN);

cose_encrypt0_set_aad(cose, &aad);

}

/*

plain_pdu = coap_pdu_init(pdu->type,

pdu->code,

pdu->mid,

pdu->used_size + 1 /* pseudo-token with actual code */);

if (plain_pdu == NULL)

goto error;

coap_add_token(osc_pdu, pdu_token.length, pdu_token.s);

/* First byte of plain is real CoAP code. Pretend it is token */

coap_add_token(plain_pdu, 1, &pdu_code);

/* Copy across the Outer/Inner Options to respective PDUs */

coap_option_iterator_init(pdu, &opt_iter, COAP_OPT_ALL);

while ((option = coap_option_next(&opt_iter))) {

switch ((coap_code_opt_num_t)opt_iter.number) {

case COAP_OPTION_URI_HOST:

case COAP_OPTION_URI_PORT:

case COAP_OPTION_PROXY_SCHEME:

case COAP_OPTION_HOP_LIMIT:

case COAP_OPTION_EDHOC:

/* Outer only */

if (!coap_insert_option(osc_pdu,

opt_iter.number,

coap_opt_length(option),

coap_opt_value(option)))

goto error;

break;

case COAP_OPTION_OBSERVE:

/* Make as Outer option as-is */

if (!coap_insert_option(osc_pdu,

opt_iter.number,

coap_opt_length(option),

coap_opt_value(option)))

goto error;

if (coap_request) {

/* Make as Inner option (unchanged) */

if (!coap_insert_option(plain_pdu,

opt_iter.number,

coap_opt_length(option),

coap_opt_value(option)))

goto error;

osc_pdu->code = COAP_REQUEST_CODE_FETCH;

} else {

/* Make as Inner option but empty */

if (!coap_insert_option(plain_pdu, opt_iter.number, 0, NULL))

goto error;

osc_pdu->code = COAP_RESPONSE_CODE(205);

}

show_pdu = 1;

doing_observe = 1;

observe_value = coap_decode_var_bytes(coap_opt_value(option),

coap_opt_length(option));

break;

case COAP_OPTION_PROXY_URI:

/*

assert(0);

break;

case COAP_OPTION_OSCORE:

/* Dealt with separately */

break;

case COAP_OPTION_IF_MATCH:

case COAP_OPTION_ETAG:

case COAP_OPTION_IF_NONE_MATCH:

case COAP_OPTION_LOCATION_PATH:

case COAP_OPTION_URI_PATH:

case COAP_OPTION_URI_PATH_ABB:

case COAP_OPTION_CONTENT_FORMAT:

case COAP_OPTION_MAXAGE:

case COAP_OPTION_URI_QUERY:

case COAP_OPTION_ACCEPT:

case COAP_OPTION_Q_BLOCK1:

case COAP_OPTION_LOCATION_QUERY:

case COAP_OPTION_BLOCK2:

case COAP_OPTION_BLOCK1:

case COAP_OPTION_SIZE2:

case COAP_OPTION_Q_BLOCK2:

case COAP_OPTION_SIZE1:

case COAP_OPTION_NORESPONSE:

case COAP_OPTION_ECHO:

case COAP_OPTION_RTAG:

default:

/* Make as Inner option */

if (!coap_insert_option(plain_pdu,

opt_iter.number,

coap_opt_length(option),

coap_opt_value(option)))

goto error;

break;

}

}

/* Add in data to plain */

if (coap_get_data(pdu, &length, &data)) {

if (!coap_add_data(plain_pdu, length, data))

goto error;

}

if (show_pdu) {

coap_log_oscore("OSCORE payload\n");

coap_show_pdu(COAP_LOG_OSCORE, plain_pdu);

}

/*

cose_encrypt0_set_key(cose, snd_ctx->sender_key);

cose_encrypt0_set_plaintext(cose, plain_pdu->token, plain_pdu->used_size);

dump_cose(cose, "Pre encrypt");

ciphertext_buffer =

coap_malloc_type(COAP_OSCORE_BUF, OSCORE_CRYPTO_BUFFER_SIZE);

if (ciphertext_buffer == NULL)

goto error;

ciphertext_len = cose_encrypt0_encrypt(cose,

ciphertext_buffer,

plain_pdu->used_size + AES_CCM_TAG);

if ((int)ciphertext_len <= 0) {

coap_log_warn("OSCORE: Encryption Failure, result code: %d \n",

(int)ciphertext_len);

goto error;

}

assert(ciphertext_len < OSCORE_CRYPTO_BUFFER_SIZE);

/* Add in OSCORE option (previously computed) */

if (!coap_insert_option(osc_pdu,

COAP_OPTION_OSCORE,

oscore_option_len,

oscore_option))

goto error;

/* Add now encrypted payload */

if (!coap_add_data(osc_pdu, ciphertext_len, ciphertext_buffer))

goto error;

coap_free_type(COAP_OSCORE_BUF, ciphertext_buffer);

ciphertext_buffer = NULL;

coap_delete_pdu_lkd(plain_pdu);

plain_pdu = NULL;

if (association && (association->is_observe == 0 || (COAP_RESPONSE_CLASS(pdu->code) != 2 &&

pdu->code != COAP_RESPONSE_CODE(401))))

oscore_delete_association(session, association);

association = NULL;

if (!coap_pdu_encode_header(osc_pdu, session->proto)) {

goto error;

}

/*

if (coap_request) {

association = oscore_find_association(session, &pdu_token);

if (association) {

/* Refresh the association */

coap_delete_bin_const(association->nonce);

association->nonce =

coap_new_bin_const(cose->nonce.s, cose->nonce.length);

if (association->nonce == NULL)

goto error;

coap_delete_bin_const(association->aad);

association->aad = coap_new_bin_const(cose->aad.s, cose->aad.length);

if (association->aad == NULL)

goto error;

if (doing_observe && observe_value == 1) {

coap_delete_bin_const(association->obs_partial_iv);

association->obs_partial_iv = association->partial_iv;

} else {

coap_delete_bin_const(association->partial_iv);

}

association->partial_iv =

coap_new_bin_const(cose->partial_iv.s, cose->partial_iv.length);

if (association->partial_iv == NULL)

goto error;

coap_oscore_association_set_recipient_ctx(association, rcp_ctx);

coap_delete_pdu_lkd(association->sent_pdu);

if (session->b_2_step != COAP_OSCORE_B_2_NONE || association->just_set_up) {

size_t size;

association->sent_pdu = coap_pdu_duplicate_lkd(pdu, session,

pdu_token.length,

pdu_token.s, NULL,

COAP_BOOL_FALSE);

if (association->sent_pdu == NULL)

goto error;

if (coap_get_data(pdu, &size, &data)) {

coap_add_data(association->sent_pdu, size, data);

}

association->just_set_up = 0;

} else {

association->sent_pdu = NULL;

}

} else if (!oscore_new_association(session,

pdu,

&pdu_token,

rcp_ctx,

&cose->aad,

&cose->nonce,

&cose->partial_iv,

doing_observe)) {

goto error;

}

}

return osc_pdu;

error:

if (association && (association->is_observe == 0 || (COAP_RESPONSE_CLASS(pdu->code) != 2 &&

pdu->code != COAP_RESPONSE_CODE(401))))

oscore_delete_association(session, association);

if (ciphertext_buffer)

coap_free_type(COAP_OSCORE_BUF, ciphertext_buffer);

coap_delete_pdu_lkd(osc_pdu);

coap_delete_pdu_lkd(plain_pdu);

return NULL;

}

static void

build_and_send_error_pdu(coap_session_t *session,

int encrypt_oscore) {

coap_pdu_t *err_pdu = NULL;

coap_bin_const_t token;

int oscore_encryption = session->oscore_encryption;

unsigned char buf[4];

token = coap_pdu_get_token(rcvd);

err_pdu = coap_pdu_init(rcvd->type == COAP_MESSAGE_NON ? COAP_MESSAGE_NON :

COAP_MESSAGE_ACK,

code,

rcvd->mid,

token.length + 2 + 8 +

(diagnostic ? strlen(diagnostic) : 0));

if (!err_pdu)

return;

coap_add_token(err_pdu, token.length, token.s);

if (echo_data) {

coap_add_option_internal(err_pdu, COAP_OPTION_ECHO, 8, echo_data);

} else if (kid_context == NULL) {

coap_add_option_internal(err_pdu,

COAP_OPTION_MAXAGE,

coap_encode_var_safe(buf, sizeof(buf), 0),

buf);

}

if (diagnostic)

coap_add_data(err_pdu, strlen(diagnostic), (const uint8_t *)diagnostic);

session->oscore_encryption = encrypt_oscore;

if ((echo_data || kid_context) && encrypt_oscore) {

coap_pdu_t *osc_pdu;

osc_pdu =

coap_oscore_new_pdu_encrypted_lkd(session, err_pdu, kid_context,

echo_data ? 1 : 0);

if (!osc_pdu)

goto fail_resp;

session->oscore_encryption = 0;

coap_send_internal(session, osc_pdu, NULL);

coap_delete_pdu_lkd(err_pdu);

err_pdu = NULL;

} else {

coap_send_internal(session, err_pdu, NULL);

err_pdu = NULL;

}

fail_resp:

session->oscore_encryption = oscore_encryption;

coap_delete_pdu_lkd(err_pdu);

return;

}

oscore_ctx_t *

coap_init_oscore_context_from_conf(coap_oscore_conf_t *oscore_conf) {

oscore_ctx_t *oscore_ctx = oscore_derive_ctx_from_conf(oscore_conf);

if (oscore_ctx == NULL) {

goto error;

}

/* As all is stored in osc_ctx, oscore_conf is no longer needed */

coap_free_type(COAP_STRING, oscore_conf);

return oscore_ctx;

error:

coap_delete_oscore_conf(oscore_conf);

return NULL;

}

coap_pdu_t *

coap_oscore_decrypt_pdu(coap_session_t *session,

coap_pdu_t *pdu) {

coap_pdu_t *decrypt_pdu = NULL;

coap_pdu_t *plain_pdu = NULL;

const uint8_t *osc_value; /* value of OSCORE option */

uint8_t osc_size; /* size of OSCORE OPTION */

coap_opt_iterator_t opt_iter;

coap_opt_t *opt = NULL;

cose_encrypt0_t cose[1];

oscore_ctx_t *osc_ctx = NULL;

uint8_t aad_buffer[AAD_BUF_LEN];

uint8_t nonce_buffer[13];

coap_bin_const_t aad;

coap_bin_const_t nonce;

int pltxt_size = 0;

int got_resp_piv = 0;

int doing_resp_observe = 0;

uint8_t coap_request = COAP_PDU_IS_REQUEST(pdu);

coap_bin_const_t pdu_token;

uint8_t *st_encrypt;

size_t encrypt_len;

size_t tag_len;

oscore_recipient_ctx_t *rcp_ctx = NULL;

oscore_association_t *association = NULL;

uint8_t external_aad_buffer[100];

coap_bin_const_t external_aad;

oscore_sender_ctx_t *snd_ctx = NULL;

#if COAP_CLIENT_SUPPORT

coap_pdu_t *sent_pdu = NULL;

#endif /* COAP_CLIENT_SUPPORT */

opt = coap_check_option(pdu, COAP_OPTION_OSCORE, &opt_iter);

assert(opt);

if (opt == NULL)

return NULL;

if (session->context->p_osc_ctx == NULL && session->context->oscore_find_cb == NULL) {

coap_log_warn("OSCORE: Not enabled\n");

if (!coap_request)

coap_handle_event_lkd(session->context,

COAP_EVENT_OSCORE_NOT_ENABLED,

session);

return NULL;

}

if (pdu->data == NULL) {

coap_log_warn("OSCORE: No protected payload\n");

if (!coap_request)

coap_handle_event_lkd(session->context,

COAP_EVENT_OSCORE_NO_PROTECTED_PAYLOAD,

session);

return NULL;

}

osc_size = coap_opt_length(opt);

osc_value = coap_opt_value(opt);

cose_encrypt0_init(cose); /* clear cose memory */

/* PDU code will be filled in after decryption */

decrypt_pdu =

coap_pdu_init(pdu->type, 0, pdu->mid, pdu->used_size);

if (decrypt_pdu == NULL) {

if (!coap_request)

coap_handle_event_lkd(session->context,

COAP_EVENT_OSCORE_INTERNAL_ERROR,

session);

goto error;

}

/* Copy across the Token */

pdu_token = coap_pdu_get_token(pdu);

coap_add_token(decrypt_pdu, pdu_token.length, pdu_token.s);

/*

coap_option_iterator_init(pdu, &opt_iter, COAP_OPT_ALL);

while ((opt = coap_option_next(&opt_iter))) {

switch ((coap_code_opt_num_t)opt_iter.number) {

/* 'E' options skipped */

case COAP_OPTION_IF_MATCH:

case COAP_OPTION_ETAG: