src/trunnel/pwbox.c

   1 /* pwbox.c -- generated by Trunnel v1.5.3.
   2  * https://gitweb.torproject.org/trunnel.git
   3  * You probably shouldn't edit this file.
   4  */
   5 #include <stdlib.h>
   6 #include "trunnel-impl.h"
   7
   8 #include "pwbox.h"
   9
  10 #define TRUNNEL_SET_ERROR_CODE(obj) \
  11   do {                              \
  12     (obj)->trunnel_error_code_ = 1; \
  13   } while (0)
  14
  15 #if defined(__COVERITY__) || defined(__clang_analyzer__)
  16 /* If we're running a static analysis tool, we don't want it to complain
  17  * that some of our remaining-bytes checks are dead-code. */
  18 int pwbox_deadcode_dummy__ = 0;
  19 #define OR_DEADCODE_DUMMY || pwbox_deadcode_dummy__
  20 #else
  21 #define OR_DEADCODE_DUMMY
  22 #endif
  23
  24 #define CHECK_REMAINING(nbytes, label)                           \
  25   do {                                                           \
  26     if (remaining < (nbytes) OR_DEADCODE_DUMMY) {                \
  27       goto label;                                                \
  28     }                                                            \
  29   } while (0)
  30
  31 pwbox_encoded_t *
  32 pwbox_encoded_new(void)
  33 {
  34   pwbox_encoded_t *val = trunnel_calloc(1, sizeof(pwbox_encoded_t));
  35   if (NULL == val)
  36     return NULL;
  37   val->fixedbytes0 = PWBOX0_CONST0;
  38   val->fixedbytes1 = PWBOX0_CONST1;
  39   return val;
  40 }
  41
  42 /** Release all storage held inside 'obj', but do not free 'obj'.
  43  */
  44 static void
  45 pwbox_encoded_clear(pwbox_encoded_t *obj)
  46 {
  47   (void) obj;
  48   TRUNNEL_DYNARRAY_WIPE(&obj->skey_header);
  49   TRUNNEL_DYNARRAY_CLEAR(&obj->skey_header);
  50   TRUNNEL_DYNARRAY_WIPE(&obj->data);
  51   TRUNNEL_DYNARRAY_CLEAR(&obj->data);
  52 }
  53
  54 void
  55 pwbox_encoded_free(pwbox_encoded_t *obj)
  56 {
  57   if (obj == NULL)
  58     return;
  59   pwbox_encoded_clear(obj);
  60   trunnel_memwipe(obj, sizeof(pwbox_encoded_t));
  61   trunnel_free_(obj);
  62 }
  63
  64 uint32_t
  65 pwbox_encoded_get_fixedbytes0(const pwbox_encoded_t *inp)
  66 {
  67   return inp->fixedbytes0;
  68 }
  69 int
  70 pwbox_encoded_set_fixedbytes0(pwbox_encoded_t *inp, uint32_t val)
  71 {
  72   if (! ((val == PWBOX0_CONST0))) {
  73      TRUNNEL_SET_ERROR_CODE(inp);
  74      return -1;
  75   }
  76   inp->fixedbytes0 = val;
  77   return 0;
  78 }
  79 uint32_t
  80 pwbox_encoded_get_fixedbytes1(const pwbox_encoded_t *inp)
  81 {
  82   return inp->fixedbytes1;
  83 }
  84 int
  85 pwbox_encoded_set_fixedbytes1(pwbox_encoded_t *inp, uint32_t val)
  86 {
  87   if (! ((val == PWBOX0_CONST1))) {
  88      TRUNNEL_SET_ERROR_CODE(inp);
  89      return -1;
  90   }
  91   inp->fixedbytes1 = val;
  92   return 0;
  93 }
  94 uint8_t
  95 pwbox_encoded_get_header_len(const pwbox_encoded_t *inp)
  96 {
  97   return inp->header_len;
  98 }
  99 int
 100 pwbox_encoded_set_header_len(pwbox_encoded_t *inp, uint8_t val)
 101 {
 102   inp->header_len = val;
 103   return 0;
 104 }
 105 size_t
 106 pwbox_encoded_getlen_skey_header(const pwbox_encoded_t *inp)
 107 {
 108   return TRUNNEL_DYNARRAY_LEN(&inp->skey_header);
 109 }
 110
 111 uint8_t
 112 pwbox_encoded_get_skey_header(pwbox_encoded_t *inp, size_t idx)
 113 {
 114   return TRUNNEL_DYNARRAY_GET(&inp->skey_header, idx);
 115 }
 116
 117 uint8_t
 118 pwbox_encoded_getconst_skey_header(const pwbox_encoded_t *inp, size_t idx)
 119 {
 120   return pwbox_encoded_get_skey_header((pwbox_encoded_t*)inp, idx);
 121 }
 122 int
 123 pwbox_encoded_set_skey_header(pwbox_encoded_t *inp, size_t idx, uint8_t elt)
 124 {
 125   TRUNNEL_DYNARRAY_SET(&inp->skey_header, idx, elt);
 126   return 0;
 127 }
 128 int
 129 pwbox_encoded_add_skey_header(pwbox_encoded_t *inp, uint8_t elt)
 130 {
 131 #if SIZE_MAX >= UINT8_MAX
 132   if (inp->skey_header.n_ == UINT8_MAX)
 133     goto trunnel_alloc_failed;
 134 #endif
 135   TRUNNEL_DYNARRAY_ADD(uint8_t, &inp->skey_header, elt, {});
 136   return 0;
 137  trunnel_alloc_failed:
 138   TRUNNEL_SET_ERROR_CODE(inp);
 139   return -1;
 140 }
 141
 142 uint8_t *
 143 pwbox_encoded_getarray_skey_header(pwbox_encoded_t *inp)
 144 {
 145   return inp->skey_header.elts_;
 146 }
 147 const uint8_t  *
 148 pwbox_encoded_getconstarray_skey_header(const pwbox_encoded_t *inp)
 149 {
 150   return (const uint8_t  *)pwbox_encoded_getarray_skey_header((pwbox_encoded_t*)inp);
 151 }
 152 int
 153 pwbox_encoded_setlen_skey_header(pwbox_encoded_t *inp, size_t newlen)
 154 {
 155   uint8_t *newptr;
 156 #if UINT8_MAX < SIZE_MAX
 157   if (newlen > UINT8_MAX)
 158     goto trunnel_alloc_failed;
 159 #endif
 160   newptr = trunnel_dynarray_setlen(&inp->skey_header.allocated_,
 161                  &inp->skey_header.n_, inp->skey_header.elts_, newlen,
 162                  sizeof(inp->skey_header.elts_[0]), (trunnel_free_fn_t) NULL,
 163                  &inp->trunnel_error_code_);
 164   if (newlen != 0 && newptr == NULL)
 165     goto trunnel_alloc_failed;
 166   inp->skey_header.elts_ = newptr;
 167   return 0;
 168  trunnel_alloc_failed:
 169   TRUNNEL_SET_ERROR_CODE(inp);
 170   return -1;
 171 }
 172 size_t
 173 pwbox_encoded_getlen_iv(const pwbox_encoded_t *inp)
 174 {
 175   (void)inp;  return 16;
 176 }
 177
 178 uint8_t
 179 pwbox_encoded_get_iv(pwbox_encoded_t *inp, size_t idx)
 180 {
 181   trunnel_assert(idx < 16);
 182   return inp->iv[idx];
 183 }
 184
 185 uint8_t
 186 pwbox_encoded_getconst_iv(const pwbox_encoded_t *inp, size_t idx)
 187 {
 188   return pwbox_encoded_get_iv((pwbox_encoded_t*)inp, idx);
 189 }
 190 int
 191 pwbox_encoded_set_iv(pwbox_encoded_t *inp, size_t idx, uint8_t elt)
 192 {
 193   trunnel_assert(idx < 16);
 194   inp->iv[idx] = elt;
 195   return 0;
 196 }
 197
 198 uint8_t *
 199 pwbox_encoded_getarray_iv(pwbox_encoded_t *inp)
 200 {
 201   return inp->iv;
 202 }
 203 const uint8_t  *
 204 pwbox_encoded_getconstarray_iv(const pwbox_encoded_t *inp)
 205 {
 206   return (const uint8_t  *)pwbox_encoded_getarray_iv((pwbox_encoded_t*)inp);
 207 }
 208 size_t
 209 pwbox_encoded_getlen_data(const pwbox_encoded_t *inp)
 210 {
 211   return TRUNNEL_DYNARRAY_LEN(&inp->data);
 212 }
 213
 214 uint8_t
 215 pwbox_encoded_get_data(pwbox_encoded_t *inp, size_t idx)
 216 {
 217   return TRUNNEL_DYNARRAY_GET(&inp->data, idx);
 218 }
 219
 220 uint8_t
 221 pwbox_encoded_getconst_data(const pwbox_encoded_t *inp, size_t idx)
 222 {
 223   return pwbox_encoded_get_data((pwbox_encoded_t*)inp, idx);
 224 }
 225 int
 226 pwbox_encoded_set_data(pwbox_encoded_t *inp, size_t idx, uint8_t elt)
 227 {
 228   TRUNNEL_DYNARRAY_SET(&inp->data, idx, elt);
 229   return 0;
 230 }
 231 int
 232 pwbox_encoded_add_data(pwbox_encoded_t *inp, uint8_t elt)
 233 {
 234   TRUNNEL_DYNARRAY_ADD(uint8_t, &inp->data, elt, {});
 235   return 0;
 236  trunnel_alloc_failed:
 237   TRUNNEL_SET_ERROR_CODE(inp);
 238   return -1;
 239 }
 240
 241 uint8_t *
 242 pwbox_encoded_getarray_data(pwbox_encoded_t *inp)
 243 {
 244   return inp->data.elts_;
 245 }
 246 const uint8_t  *
 247 pwbox_encoded_getconstarray_data(const pwbox_encoded_t *inp)
 248 {
 249   return (const uint8_t  *)pwbox_encoded_getarray_data((pwbox_encoded_t*)inp);
 250 }
 251 int
 252 pwbox_encoded_setlen_data(pwbox_encoded_t *inp, size_t newlen)
 253 {
 254   uint8_t *newptr;
 255   newptr = trunnel_dynarray_setlen(&inp->data.allocated_,
 256                  &inp->data.n_, inp->data.elts_, newlen,
 257                  sizeof(inp->data.elts_[0]), (trunnel_free_fn_t) NULL,
 258                  &inp->trunnel_error_code_);
 259   if (newlen != 0 && newptr == NULL)
 260     goto trunnel_alloc_failed;
 261   inp->data.elts_ = newptr;
 262   return 0;
 263  trunnel_alloc_failed:
 264   TRUNNEL_SET_ERROR_CODE(inp);
 265   return -1;
 266 }
 267 size_t
 268 pwbox_encoded_getlen_hmac(const pwbox_encoded_t *inp)
 269 {
 270   (void)inp;  return 32;
 271 }
 272
 273 uint8_t
 274 pwbox_encoded_get_hmac(pwbox_encoded_t *inp, size_t idx)
 275 {
 276   trunnel_assert(idx < 32);
 277   return inp->hmac[idx];
 278 }
 279
 280 uint8_t
 281 pwbox_encoded_getconst_hmac(const pwbox_encoded_t *inp, size_t idx)
 282 {
 283   return pwbox_encoded_get_hmac((pwbox_encoded_t*)inp, idx);
 284 }
 285 int
 286 pwbox_encoded_set_hmac(pwbox_encoded_t *inp, size_t idx, uint8_t elt)
 287 {
 288   trunnel_assert(idx < 32);
 289   inp->hmac[idx] = elt;
 290   return 0;
 291 }
 292
 293 uint8_t *
 294 pwbox_encoded_getarray_hmac(pwbox_encoded_t *inp)
 295 {
 296   return inp->hmac;
 297 }
 298 const uint8_t  *
 299 pwbox_encoded_getconstarray_hmac(const pwbox_encoded_t *inp)
 300 {
 301   return (const uint8_t  *)pwbox_encoded_getarray_hmac((pwbox_encoded_t*)inp);
 302 }
 303 const char *
 304 pwbox_encoded_check(const pwbox_encoded_t *obj)
 305 {
 306   if (obj == NULL)
 307     return "Object was NULL";
 308   if (obj->trunnel_error_code_)
 309     return "A set function failed on this object";
 310   if (! (obj->fixedbytes0 == PWBOX0_CONST0))
 311     return "Integer out of bounds";
 312   if (! (obj->fixedbytes1 == PWBOX0_CONST1))
 313     return "Integer out of bounds";
 314   if (TRUNNEL_DYNARRAY_LEN(&obj->skey_header) != obj->header_len)
 315     return "Length mismatch for skey_header";
 316   return NULL;
 317 }
 318
 319 ssize_t
 320 pwbox_encoded_encoded_len(const pwbox_encoded_t *obj)
 321 {
 322   ssize_t result = 0;
 323
 324   if (NULL != pwbox_encoded_check(obj))
 325      return -1;
 326
 327
 328   /* Length of u32 fixedbytes0 IN [PWBOX0_CONST0] */
 329   result += 4;
 330
 331   /* Length of u32 fixedbytes1 IN [PWBOX0_CONST1] */
 332   result += 4;
 333
 334   /* Length of u8 header_len */
 335   result += 1;
 336
 337   /* Length of u8 skey_header[header_len] */
 338   result += TRUNNEL_DYNARRAY_LEN(&obj->skey_header);
 339
 340   /* Length of u8 iv[16] */
 341   result += 16;
 342
 343   /* Length of u8 data[] */
 344   result += TRUNNEL_DYNARRAY_LEN(&obj->data);
 345
 346   /* Length of u8 hmac[32] */
 347   result += 32;
 348   return result;
 349 }
 350 int
 351 pwbox_encoded_clear_errors(pwbox_encoded_t *obj)
 352 {
 353   int r = obj->trunnel_error_code_;
 354   obj->trunnel_error_code_ = 0;
 355   return r;
 356 }
 357 ssize_t
 358 pwbox_encoded_encode(uint8_t *output, size_t avail, const pwbox_encoded_t *obj)
 359 {
 360   ssize_t result = 0;
 361   size_t written = 0;
 362   uint8_t *ptr = output;
 363   const char *msg;
 364 #ifdef TRUNNEL_CHECK_ENCODED_LEN
 365   const ssize_t encoded_len = pwbox_encoded_encoded_len(obj);
 366 #endif
 367   int enforce_avail = 0;
 368   const size_t avail_orig = avail;
 369
 370   if (NULL != (msg = pwbox_encoded_check(obj)))
 371     goto check_failed;
 372
 373 #ifdef TRUNNEL_CHECK_ENCODED_LEN
 374   trunnel_assert(encoded_len >= 0);
 375 #endif
 376
 377   /* Encode u32 fixedbytes0 IN [PWBOX0_CONST0] */
 378   trunnel_assert(written <= avail);
 379   if (avail - written < 4)
 380     goto truncated;
 381   trunnel_set_uint32(ptr, trunnel_htonl(obj->fixedbytes0));
 382   written += 4; ptr += 4;
 383
 384   /* Encode u32 fixedbytes1 IN [PWBOX0_CONST1] */
 385   trunnel_assert(written <= avail);
 386   if (avail - written < 4)
 387     goto truncated;
 388   trunnel_set_uint32(ptr, trunnel_htonl(obj->fixedbytes1));
 389   written += 4; ptr += 4;
 390
 391   /* Encode u8 header_len */
 392   trunnel_assert(written <= avail);
 393   if (avail - written < 1)
 394     goto truncated;
 395   trunnel_set_uint8(ptr, (obj->header_len));
 396   written += 1; ptr += 1;
 397
 398   /* Encode u8 skey_header[header_len] */
 399   {
 400     size_t elt_len = TRUNNEL_DYNARRAY_LEN(&obj->skey_header);
 401     trunnel_assert(obj->header_len == elt_len);
 402     trunnel_assert(written <= avail);
 403     if (avail - written < elt_len)
 404       goto truncated;
 405     if (elt_len)
 406       memcpy(ptr, obj->skey_header.elts_, elt_len);
 407     written += elt_len; ptr += elt_len;
 408   }
 409
 410   /* Encode u8 iv[16] */
 411   trunnel_assert(written <= avail);
 412   if (avail - written < 16)
 413     goto truncated;
 414   memcpy(ptr, obj->iv, 16);
 415   written += 16; ptr += 16;
 416   {
 417
 418     /* Encode u8 data[] */
 419     {
 420       size_t elt_len = TRUNNEL_DYNARRAY_LEN(&obj->data);
 421       trunnel_assert(written <= avail);
 422       if (avail - written < elt_len)
 423         goto truncated;
 424       if (elt_len)
 425         memcpy(ptr, obj->data.elts_, elt_len);
 426       written += elt_len; ptr += elt_len;
 427     }
 428     trunnel_assert(written <= avail);
 429     if (avail - written < 32)
 430       goto truncated;
 431     avail = written + 32;
 432     enforce_avail = 1;
 433   }
 434
 435   /* Encode u8 hmac[32] */
 436   trunnel_assert(written <= avail);
 437   if (avail - written < 32) {
 438     if (avail_orig - written < 32)
 439       goto truncated;
 440     else
 441       goto check_failed;
 442   }
 443   memcpy(ptr, obj->hmac, 32);
 444   written += 32; ptr += 32;
 445
 446
 447   trunnel_assert(ptr == output + written);
 448   if (enforce_avail && avail != written)
 449     goto check_failed;
 450 #ifdef TRUNNEL_CHECK_ENCODED_LEN
 451   {
 452     trunnel_assert(encoded_len >= 0);
 453     trunnel_assert((size_t)encoded_len == written);
 454   }
 455
 456 #endif
 457
 458   return written;
 459
 460  truncated:
 461   result = -2;
 462   goto fail;
 463  check_failed:
 464   (void)msg;
 465   result = -1;
 466   goto fail;
 467  fail:
 468   trunnel_assert(result < 0);
 469   return result;
 470 }
 471
 472 /** As pwbox_encoded_parse(), but do not allocate the output object.
 473  */
 474 static ssize_t
 475 pwbox_encoded_parse_into(pwbox_encoded_t *obj, const uint8_t *input, const size_t len_in)
 476 {
 477   const uint8_t *ptr = input;
 478   size_t remaining = len_in;
 479   ssize_t result = 0;
 480   (void)result;
 481
 482   /* Parse u32 fixedbytes0 IN [PWBOX0_CONST0] */
 483   CHECK_REMAINING(4, truncated);
 484   obj->fixedbytes0 = trunnel_ntohl(trunnel_get_uint32(ptr));
 485   remaining -= 4; ptr += 4;
 486   if (! (obj->fixedbytes0 == PWBOX0_CONST0))
 487     goto fail;
 488
 489   /* Parse u32 fixedbytes1 IN [PWBOX0_CONST1] */
 490   CHECK_REMAINING(4, truncated);
 491   obj->fixedbytes1 = trunnel_ntohl(trunnel_get_uint32(ptr));
 492   remaining -= 4; ptr += 4;
 493   if (! (obj->fixedbytes1 == PWBOX0_CONST1))
 494     goto fail;
 495
 496   /* Parse u8 header_len */
 497   CHECK_REMAINING(1, truncated);
 498   obj->header_len = (trunnel_get_uint8(ptr));
 499   remaining -= 1; ptr += 1;
 500
 501   /* Parse u8 skey_header[header_len] */
 502   CHECK_REMAINING(obj->header_len, truncated);
 503   TRUNNEL_DYNARRAY_EXPAND(uint8_t, &obj->skey_header, obj->header_len, {});
 504   obj->skey_header.n_ = obj->header_len;
 505   if (obj->header_len)
 506     memcpy(obj->skey_header.elts_, ptr, obj->header_len);
 507   ptr += obj->header_len; remaining -= obj->header_len;
 508
 509   /* Parse u8 iv[16] */
 510   CHECK_REMAINING(16, truncated);
 511   memcpy(obj->iv, ptr, 16);
 512   remaining -= 16; ptr += 16;
 513   {
 514     size_t remaining_after;
 515     CHECK_REMAINING(32, truncated);
 516     remaining_after = 32;
 517     remaining = remaining - 32;
 518
 519     /* Parse u8 data[] */
 520     TRUNNEL_DYNARRAY_EXPAND(uint8_t, &obj->data, remaining, {});
 521     obj->data.n_ = remaining;
 522     if (remaining)
 523       memcpy(obj->data.elts_, ptr, remaining);
 524     ptr += remaining; remaining -= remaining;
 525     if (remaining != 0)
 526       goto fail;
 527     remaining = remaining_after;
 528   }
 529
 530   /* Parse u8 hmac[32] */
 531   CHECK_REMAINING(32, truncated);
 532   memcpy(obj->hmac, ptr, 32);
 533   remaining -= 32; ptr += 32;
 534   trunnel_assert(ptr + remaining == input + len_in);
 535   return len_in - remaining;
 536
 537  truncated:
 538   return -2;
 539  trunnel_alloc_failed:
 540   return -1;
 541  fail:
 542   result = -1;
 543   return result;
 544 }
 545
 546 ssize_t
 547 pwbox_encoded_parse(pwbox_encoded_t **output, const uint8_t *input, const size_t len_in)
 548 {
 549   ssize_t result;
 550   *output = pwbox_encoded_new();
 551   if (NULL == *output)
 552     return -1;
 553   result = pwbox_encoded_parse_into(*output, input, len_in);
 554   if (result < 0) {
 555     pwbox_encoded_free(*output);
 556     *output = NULL;
 557   }
 558   return result;
 559 }