int
auth1_set_u1_sid_ed(auth1_t *inp, size_t idx, uint8_t elt)
{
trunnel_assert(idx < 32);
inp->u1_sid_ed[idx] = elt;
return 0;
}
int
auth1_set_rand(auth1_t *inp, size_t idx, uint8_t elt)
{
trunnel_assert(idx < 24);
inp->rand[idx] = elt;
return 0;
}
int
auth1_set_tlssecrets(auth1_t *inp, size_t idx, uint8_t elt)
{
trunnel_assert(idx < 32);
inp->tlssecrets[idx] = elt;
return 0;
}
int
auth1_set_scert(auth1_t *inp, size_t idx, uint8_t elt)
{
trunnel_assert(idx < 32);
inp->scert[idx] = elt;
return 0;
}
int
auth1_set_type(auth1_t *inp, size_t idx, uint8_t elt)
{
trunnel_assert(idx < 8);
inp->type[idx] = elt;
return 0;
}
ssize_t
trn_cell_rendezvous1_encode(uint8_t *output, const size_t avail, const trn_cell_rendezvous1_t *obj)
{
ssize_t result = 0;
size_t written = 0;
uint8_t *ptr = output;
const char *msg;
#ifdef TRUNNEL_CHECK_ENCODED_LEN
const ssize_t encoded_len = trn_cell_rendezvous1_encoded_len(obj);
#endif
if (NULL != (msg = trn_cell_rendezvous1_check(obj)))
goto check_failed;
#ifdef TRUNNEL_CHECK_ENCODED_LEN
trunnel_assert(encoded_len >= 0);
#endif
/* Encode u8 rendezvous_cookie[TRUNNEL_REND_COOKIE_LEN] */
trunnel_assert(written <= avail);
if (avail - written < TRUNNEL_REND_COOKIE_LEN)
goto truncated;
memcpy(ptr, obj->rendezvous_cookie, TRUNNEL_REND_COOKIE_LEN);
written += TRUNNEL_REND_COOKIE_LEN; ptr += TRUNNEL_REND_COOKIE_LEN;
/* Encode u8 handshake_info[] */
{
size_t elt_len = TRUNNEL_DYNARRAY_LEN(&obj->handshake_info);
trunnel_assert(written <= avail);
if (avail - written < elt_len)
goto truncated;
if (elt_len)
memcpy(ptr, obj->handshake_info.elts_, elt_len);
written += elt_len; ptr += elt_len;
}
trunnel_assert(ptr == output + written);
#ifdef TRUNNEL_CHECK_ENCODED_LEN
{
trunnel_assert(encoded_len >= 0);
trunnel_assert((size_t)encoded_len == written);
}
#endif
return written;
truncated:
result = -2;
goto fail;
check_failed:
(void)msg;
result = -1;
goto fail;
fail:
trunnel_assert(result < 0);
return result;
}
ssize_t
auth1_encoded_len(const auth1_t *obj, const auth_ctx_t *auth_ctx_ctx)
{
ssize_t result = 0;
if (NULL != auth1_check(obj, auth_ctx_ctx))
return -1;
/* Length of u8 type[8] */
result += 8;
/* Length of u8 cid[32] */
result += 32;
/* Length of u8 sid[32] */
result += 32;
switch (auth_ctx_ctx->is_ed) {
case 0:
break;
case 1:
/* Length of u8 u1_cid_ed[32] */
result += 32;
/* Length of u8 u1_sid_ed[32] */
result += 32;
break;
default:
trunnel_assert(0);
break;
}
/* Length of u8 slog[32] */
result += 32;
/* Length of u8 clog[32] */
result += 32;
/* Length of u8 scert[32] */
result += 32;
/* Length of u8 tlssecrets[32] */
result += 32;
/* Length of u8 rand[24] */
result += 24;
/* Length of u8 sig[] */
result += TRUNNEL_DYNARRAY_LEN(&obj->sig);
return result;
}
ssize_t
trn_cell_introduce_ack_encode(uint8_t *output, const size_t avail, const trn_cell_introduce_ack_t *obj)
{
ssize_t result = 0;
size_t written = 0;
uint8_t *ptr = output;
const char *msg;
#ifdef TRUNNEL_CHECK_ENCODED_LEN
const ssize_t encoded_len = trn_cell_introduce_ack_encoded_len(obj);
#endif
if (NULL != (msg = trn_cell_introduce_ack_check(obj)))
goto check_failed;
#ifdef TRUNNEL_CHECK_ENCODED_LEN
trunnel_assert(encoded_len >= 0);
#endif
/* Encode u16 status IN [0, 1, 2] */
trunnel_assert(written <= avail);
if (avail - written < 2)
goto truncated;
trunnel_set_uint16(ptr, trunnel_htons(obj->status));
written += 2; ptr += 2;
/* Encode struct trn_cell_extension extensions */
trunnel_assert(written <= avail);
result = trn_cell_extension_encode(ptr, avail - written, obj->extensions);
if (result < 0)
goto fail; /* XXXXXXX !*/
written += result; ptr += result;
trunnel_assert(ptr == output + written);
#ifdef TRUNNEL_CHECK_ENCODED_LEN
{
trunnel_assert(encoded_len >= 0);
trunnel_assert((size_t)encoded_len == written);
}
#endif
return written;
truncated:
result = -2;
goto fail;
check_failed:
(void)msg;
result = -1;
goto fail;
fail:
trunnel_assert(result < 0);
return result;
}
/** As trn_cell_rendezvous2_parse(), but do not allocate the output
* object.
*/
static ssize_t
trn_cell_rendezvous2_parse_into(trn_cell_rendezvous2_t *obj, const uint8_t *input, const size_t len_in)
{
const uint8_t *ptr = input;
size_t remaining = len_in;
ssize_t result = 0;
(void)result;
/* Parse u8 handshake_info[TRUNNEL_HANDSHAKE_INFO_LEN] */
CHECK_REMAINING(TRUNNEL_HANDSHAKE_INFO_LEN, truncated);
memcpy(obj->handshake_info, ptr, TRUNNEL_HANDSHAKE_INFO_LEN);
remaining -= TRUNNEL_HANDSHAKE_INFO_LEN; ptr += TRUNNEL_HANDSHAKE_INFO_LEN;
trunnel_assert(ptr + remaining == input + len_in);
return len_in - remaining;
truncated:
return -2;
}
ssize_t
trn_cell_rendezvous2_encode(uint8_t *output, const size_t avail, const trn_cell_rendezvous2_t *obj)
{
ssize_t result = 0;
size_t written = 0;
uint8_t *ptr = output;
const char *msg;
#ifdef TRUNNEL_CHECK_ENCODED_LEN
const ssize_t encoded_len = trn_cell_rendezvous2_encoded_len(obj);
#endif
if (NULL != (msg = trn_cell_rendezvous2_check(obj)))
goto check_failed;
#ifdef TRUNNEL_CHECK_ENCODED_LEN
trunnel_assert(encoded_len >= 0);
#endif
/* Encode u8 handshake_info[TRUNNEL_HANDSHAKE_INFO_LEN] */
trunnel_assert(written <= avail);
if (avail - written < TRUNNEL_HANDSHAKE_INFO_LEN)
goto truncated;
memcpy(ptr, obj->handshake_info, TRUNNEL_HANDSHAKE_INFO_LEN);
written += TRUNNEL_HANDSHAKE_INFO_LEN; ptr += TRUNNEL_HANDSHAKE_INFO_LEN;
trunnel_assert(ptr == output + written);
#ifdef TRUNNEL_CHECK_ENCODED_LEN
{
trunnel_assert(encoded_len >= 0);
trunnel_assert((size_t)encoded_len == written);
}
#endif
return written;
truncated:
result = -2;
goto fail;
check_failed:
(void)msg;
result = -1;
goto fail;
fail:
trunnel_assert(result < 0);
return result;
}
/** As rsa_ed_crosscert_parse(), but do not allocate the output
* object.
*/
static ssize_t
rsa_ed_crosscert_parse_into(rsa_ed_crosscert_t *obj, const uint8_t *input, const size_t len_in)
{
const uint8_t *ptr = input;
size_t remaining = len_in;
ssize_t result = 0;
(void)result;
/* Parse u8 ed_key[32] */
CHECK_REMAINING(32, truncated);
memcpy(obj->ed_key, ptr, 32);
remaining -= 32; ptr += 32;
/* Parse u32 expiration */
CHECK_REMAINING(4, truncated);
obj->expiration = trunnel_ntohl(trunnel_get_uint32(ptr));
remaining -= 4; ptr += 4;
obj->end_of_signed = ptr;
/* Parse u8 sig_len */
CHECK_REMAINING(1, truncated);
obj->sig_len = (trunnel_get_uint8(ptr));
remaining -= 1; ptr += 1;
/* Parse u8 sig[sig_len] */
CHECK_REMAINING(obj->sig_len, truncated);
TRUNNEL_DYNARRAY_EXPAND(uint8_t, &obj->sig, obj->sig_len, {});
obj->sig.n_ = obj->sig_len;
if (obj->sig_len)
memcpy(obj->sig.elts_, ptr, obj->sig_len);
ptr += obj->sig_len; remaining -= obj->sig_len;
trunnel_assert(ptr + remaining == input + len_in);
return len_in - remaining;
truncated:
return -2;
trunnel_alloc_failed:
return -1;
}
/** As auth_challenge_cell_parse(), but do not allocate the output
* object.
*/
static ssize_t
auth_challenge_cell_parse_into(auth_challenge_cell_t *obj, const uint8_t *input, const size_t len_in)
{
const uint8_t *ptr = input;
size_t remaining = len_in;
ssize_t result = 0;
(void)result;
/* Parse u8 challenge[32] */
CHECK_REMAINING(32, truncated);
memcpy(obj->challenge, ptr, 32);
remaining -= 32; ptr += 32;
/* Parse u16 n_methods */
CHECK_REMAINING(2, truncated);
obj->n_methods = trunnel_ntohs(trunnel_get_uint16(ptr));
remaining -= 2; ptr += 2;
/* Parse u16 methods[n_methods] */
TRUNNEL_DYNARRAY_EXPAND(uint16_t, &obj->methods, obj->n_methods, {});
{
uint16_t elt;
unsigned idx;
for (idx = 0; idx < obj->n_methods; ++idx) {
CHECK_REMAINING(2, truncated);
elt = trunnel_ntohs(trunnel_get_uint16(ptr));
remaining -= 2; ptr += 2;
TRUNNEL_DYNARRAY_ADD(uint16_t, &obj->methods, elt, {});
}
}
trunnel_assert(ptr + remaining == input + len_in);
return len_in - remaining;
truncated:
return -2;
trunnel_alloc_failed:
return -1;
}
ssize_t
rsa_ed_crosscert_encode(uint8_t *output, const size_t avail, const rsa_ed_crosscert_t *obj)
{
ssize_t result = 0;
size_t written = 0;
uint8_t *ptr = output;
const char *msg;
#ifdef TRUNNEL_CHECK_ENCODED_LEN
const ssize_t encoded_len = rsa_ed_crosscert_encoded_len(obj);
#endif
if (NULL != (msg = rsa_ed_crosscert_check(obj)))
goto check_failed;
#ifdef TRUNNEL_CHECK_ENCODED_LEN
trunnel_assert(encoded_len >= 0);
#endif
/* Encode u8 ed_key[32] */
trunnel_assert(written <= avail);
if (avail - written < 32)
goto truncated;
memcpy(ptr, obj->ed_key, 32);
written += 32; ptr += 32;
/* Encode u32 expiration */
trunnel_assert(written <= avail);
if (avail - written < 4)
goto truncated;
trunnel_set_uint32(ptr, trunnel_htonl(obj->expiration));
written += 4; ptr += 4;
/* Encode u8 sig_len */
trunnel_assert(written <= avail);
if (avail - written < 1)
goto truncated;
trunnel_set_uint8(ptr, (obj->sig_len));
written += 1; ptr += 1;
/* Encode u8 sig[sig_len] */
{
size_t elt_len = TRUNNEL_DYNARRAY_LEN(&obj->sig);
trunnel_assert(obj->sig_len == elt_len);
trunnel_assert(written <= avail);
if (avail - written < elt_len)
goto truncated;
memcpy(ptr, obj->sig.elts_, elt_len);
written += elt_len; ptr += elt_len;
}
trunnel_assert(ptr == output + written);
#ifdef TRUNNEL_CHECK_ENCODED_LEN
{
trunnel_assert(encoded_len >= 0);
trunnel_assert((size_t)encoded_len == written);
}
#endif
return written;
truncated:
result = -2;
goto fail;
check_failed:
(void)msg;
result = -1;
goto fail;
fail:
trunnel_assert(result < 0);
return result;
}
uint8_t
rsa_ed_crosscert_get_ed_key(const rsa_ed_crosscert_t *inp, size_t idx)
{
trunnel_assert(idx < 32);
return inp->ed_key[idx];
}
uint8_t
auth_challenge_cell_get_challenge(const auth_challenge_cell_t *inp, size_t idx)
{
trunnel_assert(idx < 32);
return inp->challenge[idx];
}
ssize_t
certs_cell_cert_encode(uint8_t *output, const size_t avail, const certs_cell_cert_t *obj)
{
ssize_t result = 0;
size_t written = 0;
uint8_t *ptr = output;
const char *msg;
#ifdef TRUNNEL_CHECK_ENCODED_LEN
const ssize_t encoded_len = certs_cell_cert_encoded_len(obj);
#endif
if (NULL != (msg = certs_cell_cert_check(obj)))
goto check_failed;
#ifdef TRUNNEL_CHECK_ENCODED_LEN
trunnel_assert(encoded_len >= 0);
#endif
/* Encode u8 cert_type */
trunnel_assert(written <= avail);
if (avail - written < 1)
goto truncated;
trunnel_set_uint8(ptr, (obj->cert_type));
written += 1; ptr += 1;
/* Encode u16 cert_len */
trunnel_assert(written <= avail);
if (avail - written < 2)
goto truncated;
trunnel_set_uint16(ptr, trunnel_htons(obj->cert_len));
written += 2; ptr += 2;
/* Encode u8 body[cert_len] */
{
size_t elt_len = TRUNNEL_DYNARRAY_LEN(&obj->body);
trunnel_assert(obj->cert_len == elt_len);
trunnel_assert(written <= avail);
if (avail - written < elt_len)
goto truncated;
memcpy(ptr, obj->body.elts_, elt_len);
written += elt_len; ptr += elt_len;
}
trunnel_assert(ptr == output + written);
#ifdef TRUNNEL_CHECK_ENCODED_LEN
{
trunnel_assert(encoded_len >= 0);
trunnel_assert((size_t)encoded_len == written);
}
#endif
return written;
truncated:
result = -2;
goto fail;
check_failed:
(void)msg;
result = -1;
goto fail;
fail:
trunnel_assert(result < 0);
return result;
}
uint8_t
trn_cell_rendezvous1_get_rendezvous_cookie(trn_cell_rendezvous1_t *inp, size_t idx)
{
trunnel_assert(idx < TRUNNEL_REND_COOKIE_LEN);
return inp->rendezvous_cookie[idx];
}
ssize_t
trn_cell_introduce1_encode(uint8_t *output, const size_t avail, const trn_cell_introduce1_t *obj)
{
ssize_t result = 0;
size_t written = 0;
uint8_t *ptr = output;
const char *msg;
#ifdef TRUNNEL_CHECK_ENCODED_LEN
const ssize_t encoded_len = trn_cell_introduce1_encoded_len(obj);
#endif
if (NULL != (msg = trn_cell_introduce1_check(obj)))
goto check_failed;
#ifdef TRUNNEL_CHECK_ENCODED_LEN
trunnel_assert(encoded_len >= 0);
#endif
/* Encode u8 legacy_key_id[TRUNNEL_SHA1_LEN] */
trunnel_assert(written <= avail);
if (avail - written < TRUNNEL_SHA1_LEN)
goto truncated;
memcpy(ptr, obj->legacy_key_id, TRUNNEL_SHA1_LEN);
written += TRUNNEL_SHA1_LEN; ptr += TRUNNEL_SHA1_LEN;
/* Encode u8 auth_key_type IN [0, 1, 2] */
trunnel_assert(written <= avail);
if (avail - written < 1)
goto truncated;
trunnel_set_uint8(ptr, (obj->auth_key_type));
written += 1; ptr += 1;
/* Encode u16 auth_key_len */
trunnel_assert(written <= avail);
if (avail - written < 2)
goto truncated;
trunnel_set_uint16(ptr, trunnel_htons(obj->auth_key_len));
written += 2; ptr += 2;
/* Encode u8 auth_key[auth_key_len] */
{
size_t elt_len = TRUNNEL_DYNARRAY_LEN(&obj->auth_key);
trunnel_assert(obj->auth_key_len == elt_len);
trunnel_assert(written <= avail);
if (avail - written < elt_len)
goto truncated;
if (elt_len)
memcpy(ptr, obj->auth_key.elts_, elt_len);
written += elt_len; ptr += elt_len;
}
/* Encode struct trn_cell_extension extensions */
trunnel_assert(written <= avail);
result = trn_cell_extension_encode(ptr, avail - written, obj->extensions);
if (result < 0)
goto fail; /* XXXXXXX !*/
written += result; ptr += result;
/* Encode u8 encrypted[] */
{
size_t elt_len = TRUNNEL_DYNARRAY_LEN(&obj->encrypted);
trunnel_assert(written <= avail);
if (avail - written < elt_len)
goto truncated;
if (elt_len)
memcpy(ptr, obj->encrypted.elts_, elt_len);
written += elt_len; ptr += elt_len;
}
trunnel_assert(ptr == output + written);
#ifdef TRUNNEL_CHECK_ENCODED_LEN
{
trunnel_assert(encoded_len >= 0);
trunnel_assert((size_t)encoded_len == written);
}
#endif
return written;
truncated:
result = -2;
goto fail;
check_failed:
(void)msg;
result = -1;
goto fail;
fail:
trunnel_assert(result < 0);
return result;
}
uint8_t
trn_cell_introduce_encrypted_get_rend_cookie(trn_cell_introduce_encrypted_t *inp, size_t idx)
{
trunnel_assert(idx < TRUNNEL_REND_COOKIE_LEN);
return inp->rend_cookie[idx];
}
uint8_t
auth1_get_type(const auth1_t *inp, size_t idx)
{
trunnel_assert(idx < 8);
return inp->type[idx];
}
uint8_t
auth1_get_rand(const auth1_t *inp, size_t idx)
{
trunnel_assert(idx < 24);
return inp->rand[idx];
}
uint8_t
auth1_get_tlssecrets(const auth1_t *inp, size_t idx)
{
trunnel_assert(idx < 32);
return inp->tlssecrets[idx];
}
uint8_t
auth1_get_slog(const auth1_t *inp, size_t idx)
{
trunnel_assert(idx < 32);
return inp->slog[idx];
}
uint8_t
auth1_get_u1_sid_ed(const auth1_t *inp, size_t idx)
{
trunnel_assert(idx < 32);
return inp->u1_sid_ed[idx];
}
uint8_t
auth1_get_cid(const auth1_t *inp, size_t idx)
{
trunnel_assert(idx < 32);
return inp->cid[idx];
}
ssize_t
auth1_encode(uint8_t *output, const size_t avail, const auth1_t *obj, const auth_ctx_t *auth_ctx_ctx)
{
ssize_t result = 0;
size_t written = 0;
uint8_t *ptr = output;
const char *msg;
#ifdef TRUNNEL_CHECK_ENCODED_LEN
const ssize_t encoded_len = auth1_encoded_len(obj, auth_ctx_ctx);
#endif
if (NULL != (msg = auth1_check(obj, auth_ctx_ctx)))
goto check_failed;
#ifdef TRUNNEL_CHECK_ENCODED_LEN
trunnel_assert(encoded_len >= 0);
#endif
/* Encode u8 type[8] */
trunnel_assert(written <= avail);
if (avail - written < 8)
goto truncated;
memcpy(ptr, obj->type, 8);
written += 8; ptr += 8;
/* Encode u8 cid[32] */
trunnel_assert(written <= avail);
if (avail - written < 32)
goto truncated;
memcpy(ptr, obj->cid, 32);
written += 32; ptr += 32;
/* Encode u8 sid[32] */
trunnel_assert(written <= avail);
if (avail - written < 32)
goto truncated;
memcpy(ptr, obj->sid, 32);
written += 32; ptr += 32;
/* Encode union u1[auth_ctx.is_ed] */
trunnel_assert(written <= avail);
switch (auth_ctx_ctx->is_ed) {
case 0:
break;
case 1:
/* Encode u8 u1_cid_ed[32] */
trunnel_assert(written <= avail);
if (avail - written < 32)
goto truncated;
memcpy(ptr, obj->u1_cid_ed, 32);
written += 32; ptr += 32;
/* Encode u8 u1_sid_ed[32] */
trunnel_assert(written <= avail);
if (avail - written < 32)
goto truncated;
memcpy(ptr, obj->u1_sid_ed, 32);
written += 32; ptr += 32;
break;
default:
trunnel_assert(0);
break;
}
/* Encode u8 slog[32] */
trunnel_assert(written <= avail);
if (avail - written < 32)
goto truncated;
memcpy(ptr, obj->slog, 32);
written += 32; ptr += 32;
/* Encode u8 clog[32] */
trunnel_assert(written <= avail);
if (avail - written < 32)
goto truncated;
memcpy(ptr, obj->clog, 32);
written += 32; ptr += 32;
/* Encode u8 scert[32] */
trunnel_assert(written <= avail);
if (avail - written < 32)
goto truncated;
memcpy(ptr, obj->scert, 32);
written += 32; ptr += 32;
/* Encode u8 tlssecrets[32] */
trunnel_assert(written <= avail);
if (avail - written < 32)
goto truncated;
memcpy(ptr, obj->tlssecrets, 32);
written += 32; ptr += 32;
/* Encode u8 rand[24] */
trunnel_assert(written <= avail);
if (avail - written < 24)
goto truncated;
memcpy(ptr, obj->rand, 24);
written += 24; ptr += 24;
/* Encode u8 sig[] */
{
size_t elt_len = TRUNNEL_DYNARRAY_LEN(&obj->sig);
trunnel_assert(written <= avail);
if (avail - written < elt_len)
goto truncated;
memcpy(ptr, obj->sig.elts_, elt_len);
written += elt_len; ptr += elt_len;
}
trunnel_assert(ptr == output + written);
#ifdef TRUNNEL_CHECK_ENCODED_LEN
{
trunnel_assert(encoded_len >= 0);
trunnel_assert((size_t)encoded_len == written);
}
#endif
return written;
truncated:
result = -2;
goto fail;
check_failed:
(void)msg;
result = -1;
goto fail;
fail:
trunnel_assert(result < 0);
return result;
}
/** As auth1_parse(), but do not allocate the output object.
*/
static ssize_t
auth1_parse_into(auth1_t *obj, const uint8_t *input, const size_t len_in, const auth_ctx_t *auth_ctx_ctx)
{
const uint8_t *ptr = input;
size_t remaining = len_in;
ssize_t result = 0;
(void)result;
if (auth_ctx_ctx == NULL)
return -1;
/* Parse u8 type[8] */
CHECK_REMAINING(8, truncated);
memcpy(obj->type, ptr, 8);
remaining -= 8; ptr += 8;
/* Parse u8 cid[32] */
CHECK_REMAINING(32, truncated);
memcpy(obj->cid, ptr, 32);
remaining -= 32; ptr += 32;
/* Parse u8 sid[32] */
CHECK_REMAINING(32, truncated);
memcpy(obj->sid, ptr, 32);
remaining -= 32; ptr += 32;
/* Parse union u1[auth_ctx.is_ed] */
switch (auth_ctx_ctx->is_ed) {
case 0:
break;
case 1:
/* Parse u8 u1_cid_ed[32] */
CHECK_REMAINING(32, truncated);
memcpy(obj->u1_cid_ed, ptr, 32);
remaining -= 32; ptr += 32;
/* Parse u8 u1_sid_ed[32] */
CHECK_REMAINING(32, truncated);
memcpy(obj->u1_sid_ed, ptr, 32);
remaining -= 32; ptr += 32;
break;
default:
goto fail;
break;
}
/* Parse u8 slog[32] */
CHECK_REMAINING(32, truncated);
memcpy(obj->slog, ptr, 32);
remaining -= 32; ptr += 32;
/* Parse u8 clog[32] */
CHECK_REMAINING(32, truncated);
memcpy(obj->clog, ptr, 32);
remaining -= 32; ptr += 32;
/* Parse u8 scert[32] */
CHECK_REMAINING(32, truncated);
memcpy(obj->scert, ptr, 32);
remaining -= 32; ptr += 32;
/* Parse u8 tlssecrets[32] */
CHECK_REMAINING(32, truncated);
memcpy(obj->tlssecrets, ptr, 32);
remaining -= 32; ptr += 32;
obj->end_of_fixed_part = ptr;
/* Parse u8 rand[24] */
CHECK_REMAINING(24, truncated);
memcpy(obj->rand, ptr, 24);
remaining -= 24; ptr += 24;
obj->end_of_signed = ptr;
/* Parse u8 sig[] */
TRUNNEL_DYNARRAY_EXPAND(uint8_t, &obj->sig, remaining, {});
obj->sig.n_ = remaining;
memcpy(obj->sig.elts_, ptr, remaining);
ptr += remaining; remaining -= remaining;
trunnel_assert(ptr + remaining == input + len_in);
return len_in - remaining;
truncated:
return -2;
trunnel_alloc_failed:
return -1;
fail:
result = -1;
return result;
}
ssize_t
auth_challenge_cell_encode(uint8_t *output, const size_t avail, const auth_challenge_cell_t *obj)
{
ssize_t result = 0;
size_t written = 0;
uint8_t *ptr = output;
const char *msg;
#ifdef TRUNNEL_CHECK_ENCODED_LEN
const ssize_t encoded_len = auth_challenge_cell_encoded_len(obj);
#endif
if (NULL != (msg = auth_challenge_cell_check(obj)))
goto check_failed;
#ifdef TRUNNEL_CHECK_ENCODED_LEN
trunnel_assert(encoded_len >= 0);
#endif
/* Encode u8 challenge[32] */
trunnel_assert(written <= avail);
if (avail - written < 32)
goto truncated;
memcpy(ptr, obj->challenge, 32);
written += 32; ptr += 32;
/* Encode u16 n_methods */
trunnel_assert(written <= avail);
if (avail - written < 2)
goto truncated;
trunnel_set_uint16(ptr, trunnel_htons(obj->n_methods));
written += 2; ptr += 2;
/* Encode u16 methods[n_methods] */
{
unsigned idx;
for (idx = 0; idx < TRUNNEL_DYNARRAY_LEN(&obj->methods); ++idx) {
trunnel_assert(written <= avail);
if (avail - written < 2)
goto truncated;
trunnel_set_uint16(ptr, trunnel_htons(TRUNNEL_DYNARRAY_GET(&obj->methods, idx)));
written += 2; ptr += 2;
}
}
trunnel_assert(ptr == output + written);
#ifdef TRUNNEL_CHECK_ENCODED_LEN
{
trunnel_assert(encoded_len >= 0);
trunnel_assert((size_t)encoded_len == written);
}
#endif
return written;
truncated:
result = -2;
goto fail;
check_failed:
(void)msg;
result = -1;
goto fail;
fail:
trunnel_assert(result < 0);
return result;
}
uint8_t
trn_cell_introduce1_get_legacy_key_id(trn_cell_introduce1_t *inp, size_t idx)
{
trunnel_assert(idx < TRUNNEL_SHA1_LEN);
return inp->legacy_key_id[idx];
}
uint8_t
trn_cell_rendezvous2_get_handshake_info(trn_cell_rendezvous2_t *inp, size_t idx)
{
trunnel_assert(idx < TRUNNEL_HANDSHAKE_INFO_LEN);
return inp->handshake_info[idx];
}
