X-Git-Url: https://git.openssl.org/?p=openssl.git;a=blobdiff_plain;f=ssl%2Fpacket_locl.h;h=0ff4cccf3b071dd214fe5f4734eab18934f3013c;hp=7a72f8e658b8b9c1208adf2b1afee370501b073d;hb=d70a562714199c9a4eb835efe7b22c9a7017e7e5;hpb=4bd16463b84efb13ce5fb35add284e284b0fd819;ds=sidebyside diff --git a/ssl/packet_locl.h b/ssl/packet_locl.h index 7a72f8e658..0ff4cccf3b 100644 --- a/ssl/packet_locl.h +++ b/ssl/packet_locl.h @@ -1,59 +1,10 @@ -/* ssl/packet_locl.h */ /* - * Written by Matt Caswell for the OpenSSL project. - */ -/* ==================================================================== - * Copyright (c) 2015 The OpenSSL Project. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in - * the documentation and/or other materials provided with the - * distribution. - * - * 3. All advertising materials mentioning features or use of this - * software must display the following acknowledgment: - * "This product includes software developed by the OpenSSL Project - * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" - * - * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to - * endorse or promote products derived from this software without - * prior written permission. For written permission, please contact - * openssl-core@openssl.org. - * - * 5. Products derived from this software may not be called "OpenSSL" - * nor may "OpenSSL" appear in their names without prior written - * permission of the OpenSSL Project. - * - * 6. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by the OpenSSL Project - * for use in the OpenSSL Toolkit (http://www.openssl.org/)" - * - * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY - * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR - * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, - * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED - * OF THE POSSIBILITY OF SUCH DAMAGE. - * ==================================================================== - * - * This product includes cryptographic software written by Eric Young - * (eay@cryptsoft.com). This product includes software written by Tim - * Hudson (tjh@cryptsoft.com). + * Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved. * + * Licensed under the OpenSSL license (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html */ #ifndef HEADER_PACKET_LOCL_H @@ -62,38 +13,52 @@ # include # include # include -# include "e_os.h" +# include +# include + +# include "internal/numbers.h" # ifdef __cplusplus extern "C" { # endif typedef struct { - /* Pointer to the start of the buffer data */ - unsigned char *start; - - /* Pointer to the first byte after the end of the buffer data */ - unsigned char *end; - /* Pointer to where we are currently reading from */ - unsigned char *curr; + const unsigned char *curr; + /* Number of bytes remaining */ + size_t remaining; } PACKET; +/* Internal unchecked shorthand; don't use outside this file. */ +static ossl_inline void packet_forward(PACKET *pkt, size_t len) +{ + pkt->curr += len; + pkt->remaining -= len; +} + /* * Returns the number of bytes remaining to be read in the PACKET */ -__owur static inline size_t PACKET_remaining(const PACKET *pkt) +static ossl_inline size_t PACKET_remaining(const PACKET *pkt) { - return (size_t)(pkt->end - pkt->curr); + return pkt->remaining; } +/* + * Returns a pointer to the first byte after the packet data. + * Useful for integrating with non-PACKET parsing code. + * Specifically, we use PACKET_end() to verify that a d2i_... call + * has consumed the entire packet contents. + */ +static ossl_inline const unsigned char *PACKET_end(const PACKET *pkt) +{ + return pkt->curr + pkt->remaining; +} /* * Returns a pointer to the PACKET's current position. * For use in non-PACKETized APIs. - * TODO(openssl-team): this should return 'const unsigned char*' but can't - * currently because legacy code passes 'unsigned char*'s around. */ -static inline unsigned char *PACKET_data(const PACKET *pkt) +static ossl_inline const unsigned char *PACKET_data(const PACKET *pkt) { return pkt->curr; } @@ -103,36 +68,52 @@ static inline unsigned char *PACKET_data(const PACKET *pkt) * copy of the data so |buf| must be present for the whole time that the PACKET * is being used. */ -static inline int PACKET_buf_init(PACKET *pkt, unsigned char *buf, size_t len) +__owur static ossl_inline int PACKET_buf_init(PACKET *pkt, + const unsigned char *buf, + size_t len) { - pkt->start = pkt->curr = buf; - pkt->end = pkt->start + len; - - /* Sanity checks */ - if (pkt->start > pkt->end - || pkt->curr < pkt->start - || pkt->curr > pkt->end - || len != (size_t)(pkt->end - pkt->start)) { + /* Sanity check for negative values. */ + if (len > (size_t)(SIZE_MAX / 2)) return 0; - } + pkt->curr = buf; + pkt->remaining = len; return 1; } +/* Initialize a PACKET to hold zero bytes. */ +static ossl_inline void PACKET_null_init(PACKET *pkt) +{ + pkt->curr = NULL; + pkt->remaining = 0; +} + +/* + * Returns 1 if the packet has length |num| and its contents equal the |num| + * bytes read from |ptr|. Returns 0 otherwise (lengths or contents not equal). + * If lengths are equal, performs the comparison in constant time. + */ +__owur static ossl_inline int PACKET_equal(const PACKET *pkt, const void *ptr, + size_t num) +{ + if (PACKET_remaining(pkt) != num) + return 0; + return CRYPTO_memcmp(pkt->curr, ptr, num) == 0; +} + /* * Peek ahead and initialize |subpkt| with the next |len| bytes read from |pkt|. * Data is not copied: the |subpkt| packet will share its underlying buffer with * the original |pkt|, so data wrapped by |pkt| must outlive the |subpkt|. */ -__owur static inline int PACKET_peek_sub_packet(const PACKET *pkt, - PACKET *subpkt, size_t len) +__owur static ossl_inline int PACKET_peek_sub_packet(const PACKET *pkt, + PACKET *subpkt, + size_t len) { if (PACKET_remaining(pkt) < len) return 0; - PACKET_buf_init(subpkt, pkt->curr, len); - - return 1; + return PACKET_buf_init(subpkt, pkt->curr, len); } /* @@ -140,27 +121,29 @@ __owur static inline int PACKET_peek_sub_packet(const PACKET *pkt, * copied: the |subpkt| packet will share its underlying buffer with the * original |pkt|, so data wrapped by |pkt| must outlive the |subpkt|. */ -__owur static inline int PACKET_get_sub_packet(PACKET *pkt, PACKET *subpkt, - size_t len) +__owur static ossl_inline int PACKET_get_sub_packet(PACKET *pkt, + PACKET *subpkt, + size_t len) { if (!PACKET_peek_sub_packet(pkt, subpkt, len)) return 0; - pkt->curr += len; + packet_forward(pkt, len); return 1; } -/* Peek ahead at 2 bytes in network order from |pkt| and store the value in +/* + * Peek ahead at 2 bytes in network order from |pkt| and store the value in * |*data| */ -__owur static inline int PACKET_peek_net_2(const PACKET *pkt, - unsigned int *data) +__owur static ossl_inline int PACKET_peek_net_2(const PACKET *pkt, + unsigned int *data) { if (PACKET_remaining(pkt) < 2) return 0; - *data = ((unsigned int)(*pkt->curr)) << 8; + *data = ((unsigned int)(*pkt->curr)) << 8; *data |= *(pkt->curr + 1); return 1; @@ -168,27 +151,29 @@ __owur static inline int PACKET_peek_net_2(const PACKET *pkt, /* Equivalent of n2s */ /* Get 2 bytes in network order from |pkt| and store the value in |*data| */ -__owur static inline int PACKET_get_net_2(PACKET *pkt, unsigned int *data) +__owur static ossl_inline int PACKET_get_net_2(PACKET *pkt, + unsigned int *data) { if (!PACKET_peek_net_2(pkt, data)) return 0; - pkt->curr += 2; + packet_forward(pkt, 2); return 1; } -/* Peek ahead at 3 bytes in network order from |pkt| and store the value in +/* + * Peek ahead at 3 bytes in network order from |pkt| and store the value in * |*data| */ -__owur static inline int PACKET_peek_net_3(const PACKET *pkt, - unsigned long *data) +__owur static ossl_inline int PACKET_peek_net_3(const PACKET *pkt, + unsigned long *data) { if (PACKET_remaining(pkt) < 3) return 0; - *data = ((unsigned long)(*pkt->curr)) << 16; - *data |= ((unsigned long)(*(pkt->curr + 1))) << 8; + *data = ((unsigned long)(*pkt->curr)) << 16; + *data |= ((unsigned long)(*(pkt->curr + 1))) << 8; *data |= *(pkt->curr + 2); return 1; @@ -196,47 +181,51 @@ __owur static inline int PACKET_peek_net_3(const PACKET *pkt, /* Equivalent of n2l3 */ /* Get 3 bytes in network order from |pkt| and store the value in |*data| */ -__owur static inline int PACKET_get_net_3(PACKET *pkt, unsigned long *data) +__owur static ossl_inline int PACKET_get_net_3(PACKET *pkt, + unsigned long *data) { if (!PACKET_peek_net_3(pkt, data)) return 0; - pkt->curr += 3; + packet_forward(pkt, 3); return 1; } -/* Peek ahead at 4 bytes in network order from |pkt| and store the value in +/* + * Peek ahead at 4 bytes in network order from |pkt| and store the value in * |*data| */ -__owur static inline int PACKET_peek_net_4(const PACKET *pkt, - unsigned long *data) +__owur static ossl_inline int PACKET_peek_net_4(const PACKET *pkt, + unsigned long *data) { if (PACKET_remaining(pkt) < 4) return 0; - *data = ((unsigned long)(*pkt->curr)) << 24; + *data = ((unsigned long)(*pkt->curr)) << 24; *data |= ((unsigned long)(*(pkt->curr + 1))) << 16; - *data |= ((unsigned long)(*(pkt->curr + 2))) << 8; - *data |= *(pkt->curr+3); + *data |= ((unsigned long)(*(pkt->curr + 2))) << 8; + *data |= *(pkt->curr + 3); return 1; } /* Equivalent of n2l */ /* Get 4 bytes in network order from |pkt| and store the value in |*data| */ -__owur static inline int PACKET_get_net_4(PACKET *pkt, unsigned long *data) +__owur static ossl_inline int PACKET_get_net_4(PACKET *pkt, + unsigned long *data) { if (!PACKET_peek_net_4(pkt, data)) return 0; - pkt->curr += 4; + packet_forward(pkt, 4); return 1; } /* Peek ahead at 1 byte from |pkt| and store the value in |*data| */ -__owur static inline int PACKET_peek_1(const PACKET *pkt, unsigned int *data) +__owur static ossl_inline int PACKET_peek_1(const PACKET *pkt, + unsigned int *data) { if (!PACKET_remaining(pkt)) return 0; @@ -247,12 +236,12 @@ __owur static inline int PACKET_peek_1(const PACKET *pkt, unsigned int *data) } /* Get 1 byte from |pkt| and store the value in |*data| */ -__owur static inline int PACKET_get_1(PACKET *pkt, unsigned int *data) +__owur static ossl_inline int PACKET_get_1(PACKET *pkt, unsigned int *data) { if (!PACKET_peek_1(pkt, data)) return 0; - pkt->curr++; + packet_forward(pkt, 1); return 1; } @@ -261,13 +250,14 @@ __owur static inline int PACKET_get_1(PACKET *pkt, unsigned int *data) * Peek ahead at 4 bytes in reverse network order from |pkt| and store the value * in |*data| */ -__owur static inline int PACKET_peek_4(const PACKET *pkt, unsigned long *data) +__owur static ossl_inline int PACKET_peek_4(const PACKET *pkt, + unsigned long *data) { if (PACKET_remaining(pkt) < 4) return 0; - *data = *pkt->curr; - *data |= ((unsigned long)(*(pkt->curr + 1))) << 8; + *data = *pkt->curr; + *data |= ((unsigned long)(*(pkt->curr + 1))) << 8; *data |= ((unsigned long)(*(pkt->curr + 2))) << 16; *data |= ((unsigned long)(*(pkt->curr + 3))) << 24; @@ -279,12 +269,12 @@ __owur static inline int PACKET_peek_4(const PACKET *pkt, unsigned long *data) * Get 4 bytes in reverse network order from |pkt| and store the value in * |*data| */ -__owur static inline int PACKET_get_4(PACKET *pkt, unsigned long *data) +__owur static ossl_inline int PACKET_get_4(PACKET *pkt, unsigned long *data) { if (!PACKET_peek_4(pkt, data)) return 0; - pkt->curr += 4; + packet_forward(pkt, 4); return 1; } @@ -295,8 +285,9 @@ __owur static inline int PACKET_get_4(PACKET *pkt, unsigned long *data) * caller should not free this data directly (it will be freed when the * underlying buffer gets freed */ -__owur static inline int PACKET_peek_bytes(const PACKET *pkt, unsigned char **data, - size_t len) +__owur static ossl_inline int PACKET_peek_bytes(const PACKET *pkt, + const unsigned char **data, + size_t len) { if (PACKET_remaining(pkt) < len) return 0; @@ -312,20 +303,22 @@ __owur static inline int PACKET_peek_bytes(const PACKET *pkt, unsigned char **da * not free this data directly (it will be freed when the underlying buffer gets * freed */ -__owur static inline int PACKET_get_bytes(PACKET *pkt, unsigned char **data, - size_t len) +__owur static ossl_inline int PACKET_get_bytes(PACKET *pkt, + const unsigned char **data, + size_t len) { if (!PACKET_peek_bytes(pkt, data, len)) return 0; - pkt->curr += len; + packet_forward(pkt, len); return 1; } /* Peek ahead at |len| bytes from |pkt| and copy them to |data| */ -__owur static inline int PACKET_peek_copy_bytes(const PACKET *pkt, - unsigned char *data, size_t len) +__owur static ossl_inline int PACKET_peek_copy_bytes(const PACKET *pkt, + unsigned char *data, + size_t len) { if (PACKET_remaining(pkt) < len) return 0; @@ -339,17 +332,38 @@ __owur static inline int PACKET_peek_copy_bytes(const PACKET *pkt, * Read |len| bytes from |pkt| and copy them to |data|. * The caller is responsible for ensuring that |data| can hold |len| bytes. */ -__owur static inline int PACKET_copy_bytes(PACKET *pkt, unsigned char *data, - size_t len) +__owur static ossl_inline int PACKET_copy_bytes(PACKET *pkt, + unsigned char *data, + size_t len) { if (!PACKET_peek_copy_bytes(pkt, data, len)) return 0; - pkt->curr += len; + packet_forward(pkt, len); return 1; } +/* + * Copy packet data to |dest|, and set |len| to the number of copied bytes. + * If the packet has more than |dest_len| bytes, nothing is copied. + * Returns 1 if the packet data fits in |dest_len| bytes, 0 otherwise. + * Does not forward PACKET position (because it is typically the last thing + * done with a given PACKET). + */ +__owur static ossl_inline int PACKET_copy_all(const PACKET *pkt, + unsigned char *dest, + size_t dest_len, size_t *len) +{ + if (PACKET_remaining(pkt) > dest_len) { + *len = 0; + return 0; + } + *len = pkt->remaining; + memcpy(dest, pkt->curr, pkt->remaining); + return 1; +} + /* * Copy |pkt| bytes to a newly allocated buffer and store a pointer to the * result in |*data|, and the length in |len|. @@ -359,8 +373,8 @@ __owur static inline int PACKET_copy_bytes(PACKET *pkt, unsigned char *data, * Does not forward PACKET position (because it is typically the last thing * done with a given PACKET). */ -__owur static inline int PACKET_memdup(const PACKET *pkt, unsigned char **data, - size_t *len) +__owur static ossl_inline int PACKET_memdup(const PACKET *pkt, + unsigned char **data, size_t *len) { size_t length; @@ -373,8 +387,7 @@ __owur static inline int PACKET_memdup(const PACKET *pkt, unsigned char **data, if (length == 0) return 1; - *data = BUF_memdup(pkt->curr, length); - + *data = OPENSSL_memdup(pkt->curr, length); if (*data == NULL) return 0; @@ -392,66 +405,75 @@ __owur static inline int PACKET_memdup(const PACKET *pkt, unsigned char **data, * Does not forward PACKET position (because it is typically the last thing done * with a given PACKET). */ -__owur static inline int PACKET_strndup(const PACKET *pkt, char **data) +__owur static ossl_inline int PACKET_strndup(const PACKET *pkt, char **data) { OPENSSL_free(*data); - *data = BUF_strndup((const char*)pkt->curr, PACKET_remaining(pkt)); + + /* This will succeed on an empty packet, unless pkt->curr == NULL. */ + *data = OPENSSL_strndup((const char *)pkt->curr, PACKET_remaining(pkt)); return (*data != NULL); } -/* Move the current reading position back |len| bytes */ -__owur static inline int PACKET_back(PACKET *pkt, size_t len) +/* Returns 1 if |pkt| contains at least one 0-byte, 0 otherwise. */ +static ossl_inline int PACKET_contains_zero_byte(const PACKET *pkt) { - if (len > (size_t)(pkt->curr - pkt->start)) - return 0; - - pkt->curr -= len; - - return 1; + return memchr(pkt->curr, 0, pkt->remaining) != NULL; } /* Move the current reading position forward |len| bytes */ -__owur static inline int PACKET_forward(PACKET *pkt, size_t len) +__owur static ossl_inline int PACKET_forward(PACKET *pkt, size_t len) { if (PACKET_remaining(pkt) < len) return 0; - pkt->curr += len; + packet_forward(pkt, len); return 1; } /* - * Stores the total length of the packet we have in the underlying buffer in - * |*len| + * Reads a variable-length vector prefixed with a one-byte length, and stores + * the contents in |subpkt|. |pkt| can equal |subpkt|. + * Data is not copied: the |subpkt| packet will share its underlying buffer with + * the original |pkt|, so data wrapped by |pkt| must outlive the |subpkt|. + * Upon failure, the original |pkt| and |subpkt| are not modified. */ -__owur static inline int PACKET_length(const PACKET *pkt, size_t *len) +__owur static ossl_inline int PACKET_get_length_prefixed_1(PACKET *pkt, + PACKET *subpkt) { - *len = pkt->end - pkt->start; + unsigned int length; + const unsigned char *data; + PACKET tmp = *pkt; + if (!PACKET_get_1(&tmp, &length) || + !PACKET_get_bytes(&tmp, &data, (size_t)length)) { + return 0; + } + + *pkt = tmp; + subpkt->curr = data; + subpkt->remaining = length; return 1; } /* - * Reads a variable-length vector prefixed with a one-byte length, and stores - * the contents in |subpkt|. |pkt| can equal |subpkt|. - * Data is not copied: the |subpkt| packet will share its underlying buffer with - * the original |pkt|, so data wrapped by |pkt| must outlive the |subpkt|. - * Upon failure, the original |pkt| and |subpkt| are not modified. + * Like PACKET_get_length_prefixed_1, but additionally, fails when there are + * leftover bytes in |pkt|. */ -__owur static inline int PACKET_get_length_prefixed_1(PACKET *pkt, PACKET *subpkt) +__owur static ossl_inline int PACKET_as_length_prefixed_1(PACKET *pkt, PACKET *subpkt) { unsigned int length; - unsigned char *data; + const unsigned char *data; PACKET tmp = *pkt; if (!PACKET_get_1(&tmp, &length) || - !PACKET_get_bytes(&tmp, &data, (size_t)length)) { + !PACKET_get_bytes(&tmp, &data, (size_t)length) || + PACKET_remaining(&tmp) != 0) { return 0; } *pkt = tmp; - subpkt->start = subpkt->curr = data; - subpkt->end = subpkt->start + length; + subpkt->curr = data; + subpkt->remaining = length; return 1; } @@ -463,19 +485,45 @@ __owur static inline int PACKET_get_length_prefixed_1(PACKET *pkt, PACKET *subpk * the original |pkt|, so data wrapped by |pkt| must outlive the |subpkt|. * Upon failure, the original |pkt| and |subpkt| are not modified. */ -__owur static inline int PACKET_get_length_prefixed_2(PACKET *pkt, PACKET *subpkt) +__owur static ossl_inline int PACKET_get_length_prefixed_2(PACKET *pkt, + PACKET *subpkt) +{ + unsigned int length; + const unsigned char *data; + PACKET tmp = *pkt; + + if (!PACKET_get_net_2(&tmp, &length) || + !PACKET_get_bytes(&tmp, &data, (size_t)length)) { + return 0; + } + + *pkt = tmp; + subpkt->curr = data; + subpkt->remaining = length; + + return 1; +} + +/* + * Like PACKET_get_length_prefixed_2, but additionally, fails when there are + * leftover bytes in |pkt|. + */ +__owur static ossl_inline int PACKET_as_length_prefixed_2(PACKET *pkt, + PACKET *subpkt) { unsigned int length; - unsigned char *data; + const unsigned char *data; PACKET tmp = *pkt; + if (!PACKET_get_net_2(&tmp, &length) || - !PACKET_get_bytes(&tmp, &data, (size_t)length)) { + !PACKET_get_bytes(&tmp, &data, (size_t)length) || + PACKET_remaining(&tmp) != 0) { return 0; } *pkt = tmp; - subpkt->start = subpkt->curr = data; - subpkt->end = subpkt->start + length; + subpkt->curr = data; + subpkt->remaining = length; return 1; } @@ -487,24 +535,25 @@ __owur static inline int PACKET_get_length_prefixed_2(PACKET *pkt, PACKET *subpk * the original |pkt|, so data wrapped by |pkt| must outlive the |subpkt|. * Upon failure, the original |pkt| and |subpkt| are not modified. */ -__owur static inline int PACKET_get_length_prefixed_3(PACKET *pkt, PACKET *subpkt) +__owur static ossl_inline int PACKET_get_length_prefixed_3(PACKET *pkt, + PACKET *subpkt) { - unsigned long length; - unsigned char *data; - PACKET tmp = *pkt; - if (!PACKET_get_net_3(&tmp, &length) || - !PACKET_get_bytes(&tmp, &data, (size_t)length)) { - return 0; - } + unsigned long length; + const unsigned char *data; + PACKET tmp = *pkt; + if (!PACKET_get_net_3(&tmp, &length) || + !PACKET_get_bytes(&tmp, &data, (size_t)length)) { + return 0; + } - *pkt = tmp; - subpkt->start = subpkt->curr = data; - subpkt->end = subpkt->start + length; + *pkt = tmp; + subpkt->curr = data; + subpkt->remaining = length; - return 1; + return 1; } # ifdef __cplusplus } # endif -#endif /* HEADER_PACKET_LOCL_H */ +#endif /* HEADER_PACKET_LOCL_H */