4 files changed, 61 insertions, 20 deletions
diff --git a/src/Platform/Buffer.cpp b/src/Platform/Buffer.cpp
index 4948a875..a53fd3da 100644
--- a/src/Platform/Buffer.cpp
+++ b/src/Platform/Buffer.cpp
@@ -15,13 +15,13 @@
 
 namespace VeraCrypt
 {
-	Buffer::Buffer () : DataPtr (nullptr), DataSize (0)
+	Buffer::Buffer () : DataPtr (nullptr), DataSize (0), DataAlignment (0)
 	{
 	}
 
-	Buffer::Buffer (size_t size) : DataPtr (nullptr), DataSize (0)
+	Buffer::Buffer (size_t size, size_t alignment) : DataPtr (nullptr), DataSize (0), DataAlignment (0)
 	{
-		Allocate (size);
+		Allocate (size, alignment);
 	}
 
 	Buffer::~Buffer ()
@@ -30,37 +30,42 @@ namespace VeraCrypt
 			Free ();
 	}
 
-	void Buffer::Allocate (size_t size)
+	void Buffer::Allocate (size_t size, size_t alignment)
 	{
 		if (size < 1)
 			throw ParameterIncorrect (SRC_POS);
 
 		if (DataPtr != nullptr)
 		{
-			if (DataSize == size)
+			if ((DataSize == size) && (DataAlignment == alignment))
 				return;
 			Free();
 		}
 
 		try
 		{
-			DataPtr = static_cast<byte *> (Memory::Allocate (size));
+			DataPtr = static_cast<byte *> ((alignment > 0)? Memory::AllocateAligned (size, alignment) : Memory::Allocate (size));
 			DataSize = size;
+			DataAlignment = alignment;
 		}
 		catch (...)
 		{
 			DataPtr = nullptr;
 			DataSize = 0;
+			DataAlignment = 0;
 			throw;
 		}
 	}
 
-	void Buffer::CopyFrom (const ConstBufferPtr &bufferPtr)
+	void Buffer::CopyFrom (const ConstBufferPtr &bufferPtr, size_t alignment)
 	{
-		if (!IsAllocated ())
+		if (!IsAllocated () || ((bufferPtr.Size()) && (DataAlignment != alignment)))
 		{
+			if (IsAllocated ())
+				Free ();
+
 			if (bufferPtr.Size())
-				Allocate (bufferPtr.Size());
+				Allocate (bufferPtr.Size(), alignment);
 		}
 		else if (bufferPtr.Size() > DataSize)
 			throw ParameterTooLarge (SRC_POS);
@@ -80,9 +85,13 @@ namespace VeraCrypt
 		if (DataPtr == nullptr)
 			throw NotInitialized (SRC_POS);
 
-		Memory::Free (DataPtr);
+		if (DataAlignment > 0)
+			Memory::FreeAligned (DataPtr);
+		else
+			Memory::Free (DataPtr);
 		DataPtr = nullptr;
 		DataSize = 0;
+		DataAlignment = 0;
 	}
 
 	BufferPtr Buffer::GetRange (size_t offset, size_t size) const
@@ -99,9 +108,9 @@ namespace VeraCrypt
 			Memory::Zero (DataPtr, DataSize);
 	}
 
-	SecureBuffer::SecureBuffer (size_t size)
+	SecureBuffer::SecureBuffer (size_t size, size_t alignment)
 	{
-		Allocate (size);
+		Allocate (size, alignment);
 	}
 
 	SecureBuffer::~SecureBuffer ()
@@ -110,9 +119,9 @@ namespace VeraCrypt
 			Free ();
 	}
 
-	void SecureBuffer::Allocate (size_t size)
+	void SecureBuffer::Allocate (size_t size, size_t alignment)
 	{
-		Buffer::Allocate (size);
+		Buffer::Allocate (size, alignment);
 	}
 
 	void SecureBuffer::Free ()
diff --git a/src/Platform/Buffer.h b/src/Platform/Buffer.h
index b47907b3..797cd7ff 100644
--- a/src/Platform/Buffer.h
+++ b/src/Platform/Buffer.h
@@ -71,17 +71,18 @@ namespace VeraCrypt
 	{
 	public:
 		Buffer ();
-		Buffer (size_t size);
-		Buffer (const ConstBufferPtr &bufferPtr) { CopyFrom (bufferPtr); }
+		Buffer (size_t size, size_t alignment = 0);
+		Buffer (const ConstBufferPtr &bufferPtr, size_t alignment = 0) { CopyFrom (bufferPtr, alignment); }
 		virtual ~Buffer ();
 
-		virtual void Allocate (size_t size);
-		virtual void CopyFrom (const ConstBufferPtr &bufferPtr);
+		virtual void Allocate (size_t size, size_t alignment = 0);
+		virtual void CopyFrom (const ConstBufferPtr &bufferPtr, size_t alignment = 0);
 		virtual byte *Ptr () const { return DataPtr; }
 		virtual void Erase ();
 		virtual void Free ();
 		virtual BufferPtr GetRange (size_t offset, size_t size) const;
 		virtual size_t Size () const { return DataSize; }
+		virtual size_t Alignment () const { return DataAlignment; }
 		virtual bool IsAllocated () const { return DataSize != 0; }
 		virtual void Zero ();
 
@@ -92,6 +93,7 @@ namespace VeraCrypt
 	protected:
 		byte *DataPtr;
 		size_t DataSize;
+		size_t DataAlignment;
 
 	private:
 		Buffer (const Buffer &);
@@ -102,11 +104,11 @@ namespace VeraCrypt
 	{
 	public:
 		SecureBuffer () { }
-		SecureBuffer (size_t size);
+		SecureBuffer (size_t size, size_t alignment = 0);
 		SecureBuffer (const ConstBufferPtr &bufferPtr) { CopyFrom (bufferPtr); }
 		virtual ~SecureBuffer ();
 
-		virtual void Allocate (size_t size);
+		virtual void Allocate (size_t size, size_t alignment = 0);
 		virtual void Free ();
 
 	private:
diff --git a/src/Platform/Memory.cpp b/src/Platform/Memory.cpp
index c8c04766..1184d466 100644
--- a/src/Platform/Memory.cpp
+++ b/src/Platform/Memory.cpp
@@ -13,6 +13,7 @@
 #include "Common/Tcdefs.h"
 #include "Memory.h"
 #include "Exception.h"
+#include <stdlib.h>
 
 namespace VeraCrypt
 {
@@ -27,6 +28,23 @@ namespace VeraCrypt
 
 		return bufPtr;
 	}
+	
+	void *Memory::AllocateAligned (std::size_t size, std::size_t alignment)
+	{
+		if (size < 1)
+			throw ParameterIncorrect (SRC_POS);
+#ifdef TC_WINDOWS
+		void *bufPtr = _aligned_malloc (size, alignment);
+#else
+		void *bufPtr = NULL;
+		if (0 != posix_memalign (&bufPtr, alignment, size))
+			bufPtr = NULL;
+#endif
+		if (!bufPtr)
+			throw bad_alloc();
+
+		return bufPtr;
+	}
 
 	int Memory::Compare (const void *memory1, size_t size1, const void *memory2, size_t size2)
 	{
@@ -59,4 +77,14 @@ namespace VeraCrypt
 		assert (memory != nullptr);
 		free (memory);
 	}
+	
+	void Memory::FreeAligned (void *memory)
+	{
+		assert (memory != nullptr);
+#ifdef TC_WINDOWS
+		_aligned_free (memory);
+#else
+		free (memory);
+#endif
+	}
 }
diff --git a/src/Platform/Memory.h b/src/Platform/Memory.h
index 69ce2211..d303c23e 100644
--- a/src/Platform/Memory.h
+++ b/src/Platform/Memory.h
@@ -73,10 +73,12 @@ namespace VeraCrypt
 	{
 	public:
 		static void *Allocate (size_t size);
+		static void *AllocateAligned (size_t size, size_t alignment);
 		static int Compare (const void *memory1, size_t size1, const void *memory2, size_t size2);
 		static void Copy (void *memoryDestination, const void *memorySource, size_t size);
 		static void Erase (void *memory, size_t size);
 		static void Free (void *memory);
+		static void FreeAligned (void *memory);
 		static void Zero (void *memory, size_t size);
 	};