Mojo cpp bindings: validation logic for incoming messages

mojo/public/cpp/bindings/lib/array_internal.h

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_INTERNAL_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_INTERNAL_H_
 
 #include <new>
 
 #include "mojo/public/cpp/bindings/buffer.h"
 #include "mojo/public/cpp/bindings/lib/bindings_internal.h"
 #include "mojo/public/cpp/bindings/lib/bindings_serialization.h"
+#include "mojo/public/cpp/bindings/lib/bounds_checker.h"
 #include "mojo/public/cpp/bindings/passable.h"
 
 namespace mojo {
 template <typename T> class Array;
 
 namespace internal {
 
 template <typename T>
 struct ArrayDataTraits {
   typedef T StorageType;
@@ skipping 99 matching lines @@
   static void EncodePointersAndHandles(const ArrayHeader* header,
                                        ElementType* elements,
                                        std::vector<Handle>* handles) {
   }
 
   static bool DecodePointersAndHandles(const ArrayHeader* header,
                                        ElementType* elements,
                                        Message* message) {
     return true;
   }
+
+  static bool ValidateElements(const ArrayHeader* header,
+                               const ElementType* elements,
+                               BoundsChecker* bounds_checker) {
+    return true;
+  }
 };
 
 template <>
 struct ArraySerializationHelper<Handle, true> {
   typedef ArrayDataTraits<Handle>::StorageType ElementType;
 
   static size_t ComputeSizeOfElements(const ArrayHeader* header,
                                       const ElementType* elements) {
     return 0;
   }
 
   static void CloneElements(const ArrayHeader* header,
                             ElementType* elements,
                             Buffer* buf) {
   }
 
   static void ClearHandles(const ArrayHeader* header, ElementType* elements);
 
   static void CloseHandles(const ArrayHeader* header, ElementType* elements);
 
   static void EncodePointersAndHandles(const ArrayHeader* header,
                                        ElementType* elements,
                                        std::vector<Handle>* handles);
 
   static bool DecodePointersAndHandles(const ArrayHeader* header,
                                        ElementType* elements,
                                        Message* message);
+
+  static bool ValidateElements(const ArrayHeader* header,
+                               const ElementType* elements,
+                               BoundsChecker* bounds_checker);
 };
 
 template <typename H>
 struct ArraySerializationHelper<H, true> {
   typedef typename ArrayDataTraits<H>::StorageType ElementType;
 
   static size_t ComputeSizeOfElements(const ArrayHeader* header,
                                       const ElementType* elements) {
     return 0;
   }
@@ skipping 17 matching lines @@
     ArraySerializationHelper<Handle, true>::EncodePointersAndHandles(
         header, elements, handles);
   }
 
   static bool DecodePointersAndHandles(const ArrayHeader* header,
                                        ElementType* elements,
                                        Message* message) {
     return ArraySerializationHelper<Handle, true>::DecodePointersAndHandles(
         header, elements, message);
   }
+
+  static bool ValidateElements(const ArrayHeader* header,
+                               const ElementType* elements,
+                               BoundsChecker* bounds_checker) {
+    return ArraySerializationHelper<Handle, true>::ValidateElements(
+        header, elements, bounds_checker);
+  }
 };
 
 template <typename P>
 struct ArraySerializationHelper<P*, false> {
   typedef typename ArrayDataTraits<P*>::StorageType ElementType;
 
   static size_t ComputeSizeOfElements(const ArrayHeader* header,
                                       const ElementType* elements) {
     size_t result = 0;
     for (uint32_t i = 0; i < header->num_elements; ++i) {
@@ skipping 32 matching lines @@
 
   static bool DecodePointersAndHandles(const ArrayHeader* header,
                                        ElementType* elements,
                                        Message* message) {
     for (uint32_t i = 0; i < header->num_elements; ++i) {
       if (!Decode(&elements[i], message))
         return false;
     }
     return true;
   }
+
+  static bool ValidateElements(const ArrayHeader* header,
+                               const ElementType* elements,
+                               BoundsChecker* bounds_checker) {
+    for (uint32_t i = 0; i < header->num_elements; ++i) {
+      if (!ValidateEncodedPointer(&elements[i].offset) ||
+          !P::Validate(DecodePointerRaw(&elements[i].offset), bounds_checker)) {
+        return false;
+      }
+    }
+    return true;
+  }
 };
 
 template <typename T>
 class Array_Data {
  public:
   typedef ArrayDataTraits<T> Traits;
   typedef typename Traits::StorageType StorageType;
   typedef typename Traits::Wrapper Wrapper;
   typedef typename Traits::Ref Ref;
   typedef typename Traits::ConstRef ConstRef;
   typedef ArraySerializationHelper<T, TypeTraits<T>::kIsHandle> Helper;
 
   static Array_Data<T>* New(size_t num_elements, Buffer* buf,
                             Buffer::Destructor dtor = NULL) {
     size_t num_bytes = sizeof(Array_Data<T>) +
                        Traits::GetStorageSize(num_elements);
     return new (buf->Allocate(num_bytes, dtor)) Array_Data<T>(num_bytes,
                                                               num_elements);
   }
 
   static void Destructor(void* address) {
     static_cast<Array_Data*>(address)->CloseHandles();
   }
 
+  static bool Validate(const void* data, BoundsChecker* bounds_checker) {
+    if (!data)
+      return true;
+    if (!IsAligned(data))
+      return false;
+    if (!bounds_checker->IsWithinBounds(data, sizeof(ArrayHeader)))
+      return false;
+    const ArrayHeader* header = static_cast<const ArrayHeader*>(data);
+    if (header->num_bytes < (sizeof(Array_Data<T>) +
+                             Traits::GetStorageSize(header->num_elements))) {
+      return false;
+    }
+    if (!bounds_checker->ClaimMemory(data, header->num_bytes))
+      return false;
+
+    const Array_Data<T>* object = static_cast<const Array_Data<T>*>(data);
+    return Helper::ValidateElements(&object->header_, object->storage(),
+                                    bounds_checker);
+  }
+
   size_t size() const { return header_.num_elements; }
 
   Ref at(size_t offset) {
     assert(offset < static_cast<size_t>(header_.num_elements));
     return Traits::ToRef(storage(), offset);
   }
 
   ConstRef at(size_t offset) const {
     assert(offset < static_cast<size_t>(header_.num_elements));
     return Traits::ToConstRef(storage(), offset);
@@ skipping 121 matching lines @@
   static Ref ToRef(H& data) { return Ref(&data); }
   static ConstRef ToConstRef(const H& data) {
     return ConstRef(const_cast<H*>(&data));
   }
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_INTERNAL_H_