Cherry-pick TLS transfer serialization changes to FIPS 3.x branch

fuzz/CMakeLists.txt

@@ -36,5 +36,6 @@ fuzzer(read_pem)
 fuzzer(server ssl)
 fuzzer(session ssl)
 fuzzer(spki)
+fuzzer(ssl_buffer ssl)
 fuzzer(ssl_ctx_api ssl)
 fuzzer(ssl_serialization ssl)

fuzz/ssl_buffer.cc

@@ -0,0 +1,158 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0 OR ISC
+
+#include <openssl/bytestring.h>
+#include <openssl/err.h>
+#include <openssl/mem.h>
+#include <openssl/span.h>
+#include "../ssl/internal.h"
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *buf, size_t len) {
+  CBS cbs;
+  CBS_init(&cbs, buf, len);
+
+  bssl::SSLBuffer buffer;
+
+  if (!buffer.DoDeserialization(cbs)) {
+    return 0;
+  }
+
+  // See if we can serialize it back
+  bssl::ScopedCBB cbb;
+  CBB_init(cbb.get(), len);
+  if (!buffer.DoSerialization(*cbb.get())) {
+    return 1;
+  }
+  cbb.Reset();
+
+  // If the restore buffer is not empty lets use it
+  if (!buffer.empty()) {
+    // Get a view to the written but not discarded data and verify
+    // we can safely read it all.
+    auto span = buffer.span();
+    {
+      volatile const uint8_t *vp = span.data();
+      for (size_t i = 0; i < span.size(); i++) {
+        uint8_t v = vp[i];
+        (void)v;
+      }
+    }
+    // Now "consume" the content we read which moves offset_ forward and reduces size_ and cap_.
+    buffer.Consume(span.size());
+
+    // Serialize the read span we were using. This is valid and allowed use case
+    // as the data is still kept until we call discard.
+    bssl::ScopedCBB spanCBB;
+    CBB_init(spanCBB.get(), span.size());
+    if (!buffer.SerializeBufferView(*spanCBB.get(), span)) {
+      return 1;
+    }
+
+    // Serialize the current buffer state, we should be able to restore it
+    // and restore the span and use it safely.
+    CBB_init(cbb.get(), len);
+    if (!buffer.DoSerialization(*cbb.get())) {
+      return 1;
+    }
+
+    // Now let's try to fill the rest of the buffer's remaining space
+    {
+      // Fill the remaining capacity with 1's
+      auto remaining = buffer.remaining();
+      memset(remaining.data(), 1, remaining.size());
+      buffer.DidWrite(remaining.size());
+
+      // Since we told the buffer we wrote remaining.size(), then the
+      // buffer.span() should now point to that content.
+      auto remSpan = buffer.span();
+      if (remSpan.size() != remaining.size()) {
+        return 1;
+      }
+
+      // Validate we read all 1's
+      for (size_t i = 0; i < remSpan.size(); i++) {
+        uint8_t v = remSpan.data()[i];
+        if (v != 1) {
+          return 1;
+        }
+      }
+
+      // Inform that we have now consumed the data
+      buffer.Consume(remSpan.size());
+      remaining = buffer.remaining();
+
+      // There should be no space left...
+      if (remaining.size() != 0) {
+        return 1;
+      }
+
+      // This should cause the buffer to be free'd
+      buffer.DiscardConsumed();
+      if (buffer.buf_ptr() != nullptr) {
+        return 1;
+      }
+    }
+
+    // Reset to the serialized version before the above writes
+    CBS_init(&cbs, CBB_data(cbb.get()), CBB_len(cbb.get()));
+    if (!buffer.DoDeserialization(cbs)) {
+      return 1;
+    }
+
+    // Restore the span to the earlier data we consumed
+    CBS_init(&cbs, CBB_data(spanCBB.get()), CBB_len(spanCBB.get()));
+    if (!buffer.DeserializeBufferView(cbs, span)) {
+      return 1;
+    }
+
+    // We should still be able to safely read the data the span referred to.
+    {
+      volatile const uint8_t *vp = span.data();
+      for (size_t i = 0; i < span.size(); i++) {
+        uint8_t v = vp[i];
+        (void)v;
+      }
+    }
+  }
+
+  // let's try to fill the rest of the buffer's remaining space.
+  // We did this earlier if the buffer was not empty as well.
+  {
+    // Fill the remaining capacity with 1's
+    auto remaining = buffer.remaining();
+    memset(remaining.data(), 1, remaining.size());
+    buffer.DidWrite(remaining.size());
+
+    // Since we told the buffer we wrote remaining.size(), then the
+    // buffer.span() should now point to that content.
+    auto span = buffer.span();
+    if (span.size() != remaining.size()) {
+      return 1;
+    }
+
+    // Validate we read all 1's
+    for (size_t i = 0; i < span.size(); i++) {
+      uint8_t v = span.data()[i];
+      if (v != 1) {
+        return 1;
+      }
+    }
+
+    // Inform that we have now consumed the data
+    buffer.Consume(span.size());
+    remaining = buffer.remaining();
+
+    // There should be no space left...
+    if (remaining.size() != 0) {
+      return 1;
+    }
+
+    // This should cause the buffer to be free'd
+    buffer.DiscardConsumed();
+    if (buffer.buf_ptr() != nullptr) {
+      return 1;
+    }
+  }
+
+  return 0;
+}

fuzz/ssl_buffer_corpus/25a7f46dab03f7d63c0d92ce87053132a53093b5

@@ -0,0 +1 @@
+X€

fuzz/ssl_buffer_corpus/57dfc4e288a8913e01c4455690535b525cf36d46

@@ -0,0 +1 @@
+€

fuzz/ssl_buffer_corpus/5e977b47f557d2778e9d9bb00ceddbda18e459eb

@@ -0,0 +1 @@
+€

fuzz/ssl_buffer_corpus/606be05f1885f1275a89e6c5148fe1ad47e55762

@@ -0,0 +1 @@
+ÿÿÿÿ¨

fuzz/ssl_buffer_corpus/6be4ad656833c62e10ee5d02dd60edffc22c97e6

@@ -0,0 +1 @@
+0


ÿ
,



ÿ

fuzz/ssl_buffer_corpus/7121121267bc9ee67703d9018f2f1d145e86ebe4

@@ -0,0 +1 @@
+ßÿÿ

fuzz/ssl_buffer_corpus/71853c6197a6a7f222db0f1978c7cb232b87c5ee

@@ -0,0 +1,2 @@
+
+

fuzz/ssl_buffer_corpus/7bac215ab5ae730609fcecc54182cbfd30bcfd30

@@ -0,0 +1 @@
+ÿÿÿÿÿÿÿÿÿ…¾

fuzz/ssl_buffer_corpus/7dbdbdc20e4b2c1cf46d04c72b4ef7740b49f306

@@ -0,0 +1 @@
+0F

fuzz/ssl_buffer_corpus/7ec00f99e8cd481be99afc1767079c51d0b13a52

@@ -0,0 +1 @@
+0:”

fuzz/ssl_buffer_corpus/850865be6952c4b4679444ff39f31509fe6ccf8b

@@ -0,0 +1 @@
+0
ƒ

fuzz/ssl_buffer_corpus/85e53271e14006f0265921d02d4d736cdc580b0b

@@ -0,0 +1 @@
+ÿ

fuzz/ssl_buffer_corpus/8d6e7faf4d1d4c4ec72ac30ec2ae2686eba94226

@@ -0,0 +1 @@
+0


fuzz/ssl_buffer_corpus/90d80b0214715c2117f1db310cc56f1e87dc4775

@@ -0,0 +1 @@
+0

fuzz/ssl_buffer_corpus/91f0941a4fea10ecc020f2e88cc541b5b799b5be

@@ -0,0 +1 @@
+

fuzz/ssl_buffer_corpus/93180e17879ddf1b62782b1313dedbdc101492de

@@ -0,0 +1 @@
+„

fuzz/ssl_buffer_corpus/94115a03e72587ffa15bc457576e46c75ae51483

@@ -0,0 +1 @@
+ÿÿÿðÿ?

fuzz/ssl_buffer_corpus/95120d53a6b9cabbe8c71ba250c8f0dfc53cdc35

@@ -0,0 +1 @@
+0


ÿ






ÿ

fuzz/ssl_buffer_corpus/adcb2457c772915bd43683b37d912237b50f998c

@@ -0,0 +1 @@
+

fuzz/ssl_buffer_corpus/b0e2da251ea353bc6242c1be179c882aa8ee4721

@@ -0,0 +1 @@
+ÿÿÿÿ 

fuzz/ssl_buffer_corpus/ba7c084ca2e77be198b423522375d07293493368

@@ -0,0 +1 @@
+0


Í

fuzz/ssl_buffer_corpus/bbab0b76d3e6126e90ee2f56e87e7e211894c40b

@@ -0,0 +1 @@
+0


ÿ
,





fuzz/ssl_buffer_corpus/bc30cad6ea29132eace78b8470805505d4062fb4

@@ -0,0 +1 @@
+ÿÿÿÿÿÿÿÿÿ`

fuzz/ssl_buffer_corpus/be737f522ca9e10e4429339ca3576a0afbee55b4

@@ -0,0 +1 @@
+0
ÿ

fuzz/ssl_buffer_corpus/bfe29ddd2eb7f6ff7d713a4a33e5e10694ab35d1

@@ -0,0 +1,2 @@
+
+Š

fuzz/ssl_buffer_corpus/c4b48906f911f8bff63a2fe44fffc65465652d30

@@ -0,0 +1 @@
+ÿÿÿÿ¨

fuzz/ssl_buffer_corpus/c9735b3c8b4d936374f6d7543cd6fd3af0f84760

@@ -0,0 +1 @@
+0
#

fuzz/ssl_buffer_corpus/c9c225027a0d3ba02890011e5238e0c210930df1

@@ -0,0 +1 @@
+0


ÿ0



fuzz/ssl_buffer_corpus/ccf16d28124a3fe0bcdde7122f8ed70f5b514a09

@@ -0,0 +1 @@
+0



ÿ

2
ÿ

fuzz/ssl_buffer_corpus/d392583f92c3fc1f83e97aa47ad20415f28b0f93

@@ -0,0 +1 @@
+0


ÿ
,


ÿ

fuzz/ssl_buffer_corpus/d719ca0670243de5d440431c752b7d9afc29fe3b

@@ -0,0 +1 @@
+0


ÿ






fuzz/ssl_buffer_corpus/dc70f08f6d89ae414a6fd1b8da59a11ba1aa044c

@@ -0,0 +1 @@
+?ÿ½ÿ

fuzz/ssl_buffer_corpus/de8b393d2d22914df5991814e0db530b9adb33c1

@@ -0,0 +1 @@
+0


ÿ



ÿ

fuzz/ssl_buffer_corpus/e65ce1c83294a2386c2b5fadec714f203e4994bf

@@ -0,0 +1 @@
+0
¢

fuzz/ssl_buffer_corpus/e7064f0b80f61dbc65915311032d27baa569ae2a

@@ -0,0 +1 @@
+)

fuzz/ssl_buffer_corpus/ea9611a6436abfa835153697a67f958a864ab0fc

@@ -0,0 +1 @@
+D„

fuzz/ssl_buffer_corpus/eb0a15f377fd713933499dfdb2644c055673f299

@@ -0,0 +1 @@
+0
0

fuzz/ssl_buffer_corpus/efcf075bf52d2652a54197f66e46857ae3f92426

@@ -0,0 +1 @@
+0


ÿ0
ÿ^

fuzz/ssl_buffer_corpus/f3aee3b8e93348c918cd5b5498dbe4126971cda5

@@ -0,0 +1 @@
+0


ÿ

fuzz/ssl_buffer_corpus/f876dd9b719cc6f0036e9d3c047963a1453398f5

@@ -0,0 +1 @@
+ÿªªªªªªªª

fuzz/ssl_buffer_corpus/f8a770061e7401e29397fc55763a08ea60c744b0

@@ -0,0 +1 @@
+0



ÿ

ssl/internal.h

@@ -1312,9 +1312,16 @@ void ssl_do_msg_callback(const SSL *ssl, int is_write, int content_type,
 
 // Transport buffers.
 
+enum SSL_BUFFER_SERDE_VERSION {
+  SSL_BUFFER_SERDE_VERSION_ONE = 1,
+  SSL_BUFFER_SERDE_VERSION_TWO = 2
+};
+
+const unsigned kSSLBufferMaxSerDeVersion = SSL_BUFFER_SERDE_VERSION_TWO;
+
 #define SSLBUFFER_READ_AHEAD_MIN_CAPACITY 512
-#define SSLBUFFER_MAX_CAPACITY UINT16_MAX
-class SSLBuffer {
+#define SSLBUFFER_MAX_CAPACITY INT_MAX
+class OPENSSL_EXPORT SSLBuffer {
  public:
   SSLBuffer() {}
   ~SSLBuffer() { Clear(); }
@@ -1358,28 +1365,48 @@ class SSLBuffer {
   void DiscardConsumed();
 
   // DoSerialization writes all fields into |cbb|.
-  bool DoSerialization(CBB *cbb);
+  bool DoSerialization(CBB &cbb);
 
   // DoDeserialization recovers the states encoded via |DoSerialization|.
-  bool DoDeserialization(CBS *in);
+  bool DoDeserialization(CBS &in);
+
+  bool SerializeBufferView(CBB &cbb, Span<uint8_t> &view);
+  bool DeserializeBufferView(CBS &cbb, Span<uint8_t> &view);
 
  private:
   // buf_ is the memory allocated for this buffer.
   uint8_t *buf_ = nullptr;
-  // offset_ is the offset into |buf_| which the buffer contents start at.
-  uint16_t offset_ = 0;
-  // size_ is the size of the buffer contents from |buf_| + |offset_|.
-  uint16_t size_ = 0;
-  // cap_ is how much memory beyond |buf_| + |offset_| is available.
-  uint16_t cap_ = 0;
-  // inline_buf_ is a static buffer for short reads.
-  uint8_t inline_buf_[SSL3_RT_HEADER_LENGTH];
   // buf_allocated_ is true if |buf_| points to allocated data and must be freed
   // or false if it points into |inline_buf_|.
   bool buf_allocated_ = false;
+  // The total capacity requested for this buffer by |EnsureCap|.
+  size_t buf_cap_ = 0;
   // buf_size_ is how much memory allocated for |buf_|. This is needed by
-  // |DoSerialization|.
+  // |DoSerializationV1|. This is the total size of the buffer with the requested capacity + padding.
   size_t buf_size_ = 0;
+  // header length used to calculate initial offset
+  size_t header_len_ = 0;
+  // offset_ is the offset into |buf_| which the buffer contents start at, and is moved as contents are consumed
+  int offset_ = 0;
+  // size_ is the size of the buffer contents from |buf_| + |offset_|.
+  int size_ = 0;
+  // cap_ is how much memory beyond |buf_| + |offset_| is available.
+  int cap_ = 0;
+  // inline_buf_ is a static buffer for short reads.
+  uint8_t inline_buf_[SSL3_RT_HEADER_LENGTH];
+
+  // The V1 version has some intricacies were solved in later serialization versions.
+  // This is mainly to capture if a V1 version was restored and whether it needs to be
+  // re-serialized as that version.
+  uint32_t max_serialization_version_ = SSL_BUFFER_SERDE_VERSION_TWO;
+
+  bool DoSerializationV1(CBB &cbb);
+  bool DoSerializationV2(CBB &cbb);
+
+  bool DoDeserializationV1(CBS &in);
+  bool DoDeserializationV2(CBS &in);
+
+  bool ValidateBuffersState();
 };
 
 // ssl_read_buffer_extend_to extends the read buffer to the desired length. For
@@ -4136,6 +4163,10 @@ struct ssl_st {
   // as will fit in the SSLBuffer from the BIO, or just enough to read the record
   // header and then the length of the body
   bool enable_read_ahead : 1;
+
+  // is_suspended_state indicates that the |SSL| object has been serialized and
+  // operations should not be performed on the connection.
+  bool is_suspended_state : 1;
 };
 
 struct ssl_session_st {