ssl/packet.c

   1 /*
   2  * Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <assert.h>
  11 #include "packet_locl.h"
  12
  13 #define DEFAULT_BUF_SIZE    256
  14
  15 int WPACKET_allocate_bytes(WPACKET *pkt, size_t len, unsigned char **allocbytes)
  16 {
  17     /* Internal API, so should not fail */
  18     assert(pkt->subs != NULL && len != 0);
  19     if (pkt->subs == NULL || len == 0)
  20         return 0;
  21
  22     if (pkt->maxsize - pkt->written < len)
  23         return 0;
  24
  25     if (pkt->buf->length - pkt->written < len) {
  26         size_t newlen;
  27
  28         if (pkt->buf->length > SIZE_MAX / 2) {
  29             newlen = SIZE_MAX;
  30         } else {
  31             newlen = (pkt->buf->length == 0) ? DEFAULT_BUF_SIZE
  32                                              : pkt->buf->length * 2;
  33         }
  34         if (BUF_MEM_grow(pkt->buf, newlen) == 0)
  35             return 0;
  36     }
  37     *allocbytes = (unsigned char *)pkt->buf->data + pkt->curr;
  38     pkt->written += len;
  39     pkt->curr += len;
  40
  41     return 1;
  42 }
  43
  44 int WPACKET_sub_allocate_bytes(WPACKET *pkt, size_t len,
  45                                unsigned char **allocbytes, size_t lenbytes)
  46 {
  47     if (!WPACKET_start_sub_packet_len(pkt, lenbytes)
  48             || !WPACKET_allocate_bytes(pkt, len, allocbytes)
  49             || !WPACKET_close(pkt))
  50         return 0;
  51
  52     return 1;
  53 }
  54
  55 static size_t maxmaxsize(size_t lenbytes)
  56 {
  57     if (lenbytes >= sizeof(size_t) || lenbytes == 0)
  58         return SIZE_MAX;
  59
  60     return ((size_t)1 << (lenbytes * 8)) - 1 + lenbytes;
  61 }
  62
  63 int WPACKET_init_len(WPACKET *pkt, BUF_MEM *buf, size_t lenbytes)
  64 {
  65     unsigned char *lenchars;
  66
  67     /* Internal API, so should not fail */
  68     assert(buf != NULL);
  69     if (buf == NULL)
  70         return 0;
  71
  72     pkt->buf = buf;
  73     pkt->curr = 0;
  74     pkt->written = 0;
  75     pkt->maxsize = maxmaxsize(lenbytes);
  76
  77     pkt->subs = OPENSSL_zalloc(sizeof(*pkt->subs));
  78     if (pkt->subs == NULL)
  79         return 0;
  80
  81     if (lenbytes == 0)
  82         return 1;
  83
  84     pkt->subs->pwritten = lenbytes;
  85     pkt->subs->lenbytes = lenbytes;
  86
  87     if (!WPACKET_allocate_bytes(pkt, lenbytes, &lenchars)) {
  88         OPENSSL_free(pkt->subs);
  89         pkt->subs = NULL;
  90         return 0;
  91     }
  92     pkt->subs->packet_len = lenchars - (unsigned char *)pkt->buf->data;
  93
  94     return 1;
  95 }
  96
  97 int WPACKET_init(WPACKET *pkt, BUF_MEM *buf)
  98 {
  99     return WPACKET_init_len(pkt, buf, 0);
 100 }
 101
 102 int WPACKET_set_flags(WPACKET *pkt, unsigned int flags)
 103 {
 104     /* Internal API, so should not fail */
 105     assert(pkt->subs != NULL);
 106     if (pkt->subs == NULL)
 107         return 0;
 108
 109     pkt->subs->flags = flags;
 110
 111     return 1;
 112 }
 113
 114 /* Store the |value| of length |len| at location |data| */
 115 static int put_value(unsigned char *data, size_t value, size_t len)
 116 {
 117     for (data += len - 1; len > 0; len--) {
 118         *data = (unsigned char)(value & 0xff);
 119         data--;
 120         value >>= 8;
 121     }
 122
 123     /* Check whether we could fit the value in the assigned number of bytes */
 124     if (value > 0)
 125         return 0;
 126
 127     return 1;
 128 }
 129
 130
 131 /*
 132  * Internal helper function used by WPACKET_close() and WPACKET_finish() to
 133  * close a sub-packet and write out its length if necessary.
 134  */
 135 static int wpacket_intern_close(WPACKET *pkt)
 136 {
 137     WPACKET_SUB *sub = pkt->subs;
 138     size_t packlen = pkt->written - sub->pwritten;
 139
 140     if (packlen == 0
 141             && (sub->flags & WPACKET_FLAGS_NON_ZERO_LENGTH) != 0)
 142         return 0;
 143
 144     if (packlen == 0
 145             && sub->flags & WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH) {
 146         /* Deallocate any bytes allocated for the length of the WPACKET */
 147         if ((pkt->curr - sub->lenbytes) == sub->packet_len) {
 148             pkt->written -= sub->lenbytes;
 149             pkt->curr -= sub->lenbytes;
 150         }
 151
 152         /* Don't write out the packet length */
 153         sub->packet_len = 0;
 154         sub->lenbytes = 0;
 155     }
 156
 157     /* Write out the WPACKET length if needed */
 158     if (sub->lenbytes > 0
 159                 && !put_value((unsigned char *)&pkt->buf->data[sub->packet_len],
 160                               packlen, sub->lenbytes))
 161             return 0;
 162
 163     pkt->subs = sub->parent;
 164     OPENSSL_free(sub);
 165
 166     return 1;
 167 }
 168
 169 int WPACKET_close(WPACKET *pkt)
 170 {
 171     /*
 172      * Internal API, so should not fail - but we do negative testing of this
 173      * so no assert (otherwise the tests fail)
 174      */
 175     if (pkt->subs == NULL || pkt->subs->parent == NULL)
 176         return 0;
 177
 178     return wpacket_intern_close(pkt);
 179 }
 180
 181 int WPACKET_finish(WPACKET *pkt)
 182 {
 183     int ret;
 184
 185     /*
 186      * Internal API, so should not fail - but we do negative testing of this
 187      * so no assert (otherwise the tests fail)
 188      */
 189     if (pkt->subs == NULL || pkt->subs->parent != NULL)
 190         return 0;
 191
 192     ret = wpacket_intern_close(pkt);
 193     if (ret) {
 194         OPENSSL_free(pkt->subs);
 195         pkt->subs = NULL;
 196     }
 197
 198     return ret;
 199 }
 200
 201 int WPACKET_start_sub_packet_len(WPACKET *pkt, size_t lenbytes)
 202 {
 203     WPACKET_SUB *sub;
 204     unsigned char *lenchars;
 205
 206     /* Internal API, so should not fail */
 207     assert(pkt->subs != NULL);
 208     if (pkt->subs == NULL)
 209         return 0;
 210
 211     sub = OPENSSL_zalloc(sizeof(*sub));
 212     if (sub == NULL)
 213         return 0;
 214
 215     sub->parent = pkt->subs;
 216     pkt->subs = sub;
 217     sub->pwritten = pkt->written + lenbytes;
 218     sub->lenbytes = lenbytes;
 219
 220     if (lenbytes == 0) {
 221         sub->packet_len = 0;
 222         return 1;
 223     }
 224
 225     if (!WPACKET_allocate_bytes(pkt, lenbytes, &lenchars))
 226         return 0;
 227     sub->packet_len = lenchars - (unsigned char *)pkt->buf->data;
 228
 229     return 1;
 230 }
 231
 232 int WPACKET_start_sub_packet(WPACKET *pkt)
 233 {
 234     return WPACKET_start_sub_packet_len(pkt, 0);
 235 }
 236
 237 int WPACKET_put_bytes(WPACKET *pkt, unsigned int val, size_t size)
 238 {
 239     unsigned char *data;
 240
 241     /* Internal API, so should not fail */
 242     assert(size <= sizeof(unsigned int));
 243
 244     if (size > sizeof(unsigned int)
 245             || !WPACKET_allocate_bytes(pkt, size, &data)
 246             || !put_value(data, val, size))
 247         return 0;
 248
 249     return 1;
 250 }
 251
 252 int WPACKET_set_max_size(WPACKET *pkt, size_t maxsize)
 253 {
 254     WPACKET_SUB *sub;
 255     size_t lenbytes;
 256
 257     /* Internal API, so should not fail */
 258     assert(pkt->subs != NULL);
 259     if (pkt->subs == NULL)
 260         return 0;
 261
 262     /* Find the WPACKET_SUB for the top level */
 263     for (sub = pkt->subs; sub->parent != NULL; sub = sub->parent)
 264         continue;
 265
 266     lenbytes = sub->lenbytes;
 267     if (lenbytes == 0)
 268         lenbytes = sizeof(pkt->maxsize);
 269
 270     if (maxmaxsize(lenbytes) < maxsize || maxsize < pkt->written)
 271         return 0;
 272
 273     pkt->maxsize = maxsize;
 274
 275     return 1;
 276 }
 277
 278 int WPACKET_memcpy(WPACKET *pkt, const void *src, size_t len)
 279 {
 280     unsigned char *dest;
 281
 282     if (len == 0)
 283         return 1;
 284
 285     if (!WPACKET_allocate_bytes(pkt, len, &dest))
 286         return 0;
 287
 288     memcpy(dest, src, len);
 289
 290     return 1;
 291 }
 292
 293 int WPACKET_sub_memcpy(WPACKET *pkt, const void *src, size_t len, size_t lenbytes)
 294 {
 295     if (!WPACKET_start_sub_packet_len(pkt, lenbytes)
 296             || !WPACKET_memcpy(pkt, src, len)
 297             || !WPACKET_close(pkt))
 298         return 0;
 299
 300     return 1;
 301 }
 302
 303 int WPACKET_get_total_written(WPACKET *pkt, size_t *written)
 304 {
 305     /* Internal API, so should not fail */
 306     assert(written != NULL);
 307     if (written == NULL)
 308         return 0;
 309
 310     *written = pkt->written;
 311
 312     return 1;
 313 }
 314
 315 int WPACKET_get_length(WPACKET *pkt, size_t *len)
 316 {
 317     /* Internal API, so should not fail */
 318     assert(pkt->subs != NULL && len != NULL);
 319     if (pkt->subs == NULL || len == NULL)
 320         return 0;
 321
 322     *len = pkt->written - pkt->subs->pwritten;
 323
 324     return 1;
 325 }
 326
 327 void WPACKET_cleanup(WPACKET *pkt)
 328 {
 329     WPACKET_SUB *sub, *parent;
 330
 331     for (sub = pkt->subs; sub != NULL; sub = parent) {
 332         parent = sub->parent;
 333         OPENSSL_free(sub);
 334     }
 335     pkt->subs = NULL;
 336 }