Secure allocator

.gitignore

@@ -28,6 +28,11 @@
 *.tlog/
 *.pdb
 
+# eclipse project files
+.project
+.cproject
+/.settings/
+
 # CMake-generated files:
 CMakeFiles/
 CTestTestFile.cmake

include/json/allocator.h

@@ -0,0 +1,92 @@
+// Copyright 2015 Baptiste Lepilleur
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at https://raw.githubusercontent.com/open-source-parsers/jsoncpp/master/LICENSE
+#ifndef CPPTL_JSON_ALLOCATOR_H_INCLUDED
+#define CPPTL_JSON_ALLOCATOR_H_INCLUDED
+
+#include <algorithm> //std::filln
+#include <cstring> // std::memset
+#include <cstddef> // std::size_t, std::ptrdiff_t
+#include <utility> // std::forward
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "config.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+
+/**
+ * This class is used for de-allocating memory securely, allocation happens
+ * in the normal manner however it's important that de-allocation explicitly
+ * overwrites the memory with 0s to ensure the memory cannot be "sniffed"
+ */
+template<typename T>
+class JSON_API SecureAllocator {
+  public:
+    // Type definitions
+    using value_type      = T;
+    using pointer         = T*;
+    using const_pointer   = const T*;
+    using reference       = T&;
+    using const_reference = const T&;
+    using size_type       = std::size_t;
+    using difference_type = std::ptrdiff_t;
+
+    /**
+	 * Allocate memory for N items using the standard allocator.
+	 */
+	pointer allocate(size_type n) {
+		// allocate using "global operator new"
+		return static_cast<pointer>(::operator new(n * sizeof(T)));
+	}
+
+	/**
+	 * Release memory which was allocated for N items at pointer P.
+	 *
+	 * The memory block is filled with zeroes before being released.
+	 * The pointer argument is tagged as "volatile" to prevent the
+	 * compiler optimizing out this critical step.
+	 */
+	void deallocate(volatile pointer p, size_type n) {
+		std::fill_n((volatile char*)p, n * sizeof(value_type), 0);
+		// free using "global operator delete"
+		::operator delete(p);
+	}
+
+	/**
+	 * Construct an item in-place at pointer P.
+	 */
+	template<typename... Args>
+	void construct(pointer p, Args&&... args) {
+		// construct using "placement new" and "perfect forwarding"
+		::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);
+	}
+
+	/**
+	 * Destroy an item in-place at pointer P.
+	 */
+	void destroy(pointer p) {
+		// destroy using "explicit destructor"
+		p->~T();
+	}
+
+	// Boilerplate
+	SecureAllocator() {}
+	template<typename U> SecureAllocator(const SecureAllocator<U>&) {}
+	template<typename U> struct rebind { using other = SecureAllocator<U>; };
+};
+
+template<typename T, typename U>
+bool operator==(const SecureAllocator<T>&, const SecureAllocator<U>&) {
+  return true;
+}
+
+template<typename T, typename U>
+bool operator!=(const SecureAllocator<T>&, const SecureAllocator<U>&) {
+  return false;
+}
+
+} //end namespace Json
+
+#endif // CPPTL_JSON_ALLOCATOR_H_INCLUDED

include/json/config.h

@@ -113,6 +113,13 @@
 #define JSONCPP_DEPRECATED(message)
 #endif // if !defined(JSONCPP_DEPRECATED)
 
+//We may want to have different presets for the default allocator and
+//string
+//#define JSONCPP_DEFAULT_CHAR_TRAITS = std::char_traits<char>
+//#define JSONCPP_DEFAULT_ALLOCATOR = std::allocator<char>
+#define JSONCPP_DEFAULT_CHAR_TRAITS
+#define JSONCPP_DEFAULT_ALLOCATOR
+
 namespace Json {
 typedef int Int;
 typedef unsigned int UInt;

include/json/forwards.h

@@ -13,10 +13,13 @@
 namespace Json {
 
 // writer.h
+template<typename _Traits, typename _Alloc>
 class FastWriter;
+template<typename _Traits, typename _Alloc>
 class StyledWriter;
 
-// reader.h
+// reader_declaration.h
+template<typename _Traits, typename _Alloc>
 class Reader;
 
 // features.h
@@ -25,11 +28,17 @@ class Features;
 // value.h
 typedef unsigned int ArrayIndex;
 class StaticString;
+template<typename _Traits, typename _Alloc>
 class Path;
+template<typename _Traits, typename _Alloc>
 class PathArgument;
+template<typename _Traits, typename _Alloc>
 class Value;
+template<typename _Traits, typename _Alloc>
 class ValueIteratorBase;
+template<typename _Traits, typename _Alloc>
 class ValueIterator;
+template<typename _Traits, typename _Alloc>
 class ValueConstIterator;
 
 } // namespace Json

include/json/json.h

@@ -6,6 +6,7 @@
 #ifndef JSON_JSON_H_INCLUDED
 #define JSON_JSON_H_INCLUDED
 
+#include "allocator.h"
 #include "autolink.h"
 #include "value.h"
 #include "reader.h"