X-Git-Url: https://git.openssl.org/gitweb/?p=openssl.git;a=blobdiff_plain;f=ssl%2Fpacket_locl.h;h=fd1f9f4ecf8bad9dee4e6c338d1ad9efbb0db81a;hp=7a72f8e658b8b9c1208adf2b1afee370501b073d;hb=f8c3f2b4eda697a35b213d44df627190d03c694f;hpb=4bd16463b84efb13ce5fb35add284e284b0fd819

diff --git a/ssl/packet_locl.h b/ssl/packet_locl.h
index 7a72f8e658..fd1f9f4ecf 100644
--- a/ssl/packet_locl.h
+++ b/ssl/packet_locl.h
@@ -1,4 +1,3 @@
-/* ssl/packet_locl.h */
 /*
  * Written by Matt Caswell for the OpenSSL project.
  */
@@ -62,38 +61,52 @@
 # include <string.h>
 # include <openssl/bn.h>
 # include <openssl/buffer.h>
-# include "e_os.h"
+# include <openssl/crypto.h>
+# include <openssl/e_os2.h>
+
+# 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 +116,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 +169,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 +199,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 +229,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 +284,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 +298,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 +317,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 +333,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 +351,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 +380,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 +421,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 +435,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 +453,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 +533,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 +583,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 */