Squashed 'Sources/OpenVPNAdapter/Libraries/Vendors/openvpn/' content from commit 554d8b888

git-subtree-dir: Sources/OpenVPNAdapter/Libraries/Vendors/openvpn git-subtree-split: 554d8b88817d3a7b836e78940ed61bb11ed2bd9b
2026-04-24 00:00:05 +08:00 · 2018-07-27 18:08:58 +03:00
commit e2ad2ab5d5
585 changed files with 101725 additions and 0 deletions
@@ -0,0 +1,116 @@
+//    OpenVPN -- An application to securely tunnel IP networks
+//               over a single port, with support for SSL/TLS-based
+//               session authentication and key exchange,
+//               packet encryption, packet authentication, and
+//               packet compression.
+//
+//    Copyright (C) 2012-2017 OpenVPN Inc.
+//
+//    This program is free software: you can redistribute it and/or modify
+//    it under the terms of the GNU Affero General Public License Version 3
+//    as published by the Free Software Foundation.
+//
+//    This program is distributed in the hope that it will be useful,
+//    but WITHOUT ANY WARRANTY; without even the implied warranty of
+//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//    GNU Affero General Public License for more details.
+//
+//    You should have received a copy of the GNU Affero General Public License
+//    along with this program in the COPYING file.
+//    If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef OPENVPN_COMMON_MEMNEQ_H
+#define OPENVPN_COMMON_MEMNEQ_H
+
+#include <openvpn/common/arch.hpp>
+#include <openvpn/common/size.hpp>
+
+// Does this architecture allow efficient unaligned access?
+
+#if defined(OPENVPN_ARCH_x86_64) || defined(OPENVPN_ARCH_i386)
+#define OPENVPN_HAVE_EFFICIENT_UNALIGNED_ACCESS
+#endif
+
+// Define a portable compiler memory access fence (from Boost).
+
+#if defined(__INTEL_COMPILER)
+
+#define OPENVPN_COMPILER_FENCE __memory_barrier();
+
+#elif defined( _MSC_VER ) && _MSC_VER >= 1310
+
+extern "C" void _ReadWriteBarrier();
+#pragma intrinsic( _ReadWriteBarrier )
+
+#define OPENVPN_COMPILER_FENCE _ReadWriteBarrier();
+
+#elif defined(__GNUC__)
+
+#define OPENVPN_COMPILER_FENCE __asm__ __volatile__( "" : : : "memory" );
+
+#else
+
+#error need memory fence definition for this compiler
+
+#endif
+
+// C++ doesn't allow increment of void *
+
+#define OPENVPN_INCR_VOID_PTR(var, incr) (var) = static_cast<const unsigned char*>(var) + (incr)
+
+namespace openvpn {
+  namespace crypto {
+
+#ifdef OPENVPN_HAVE_EFFICIENT_UNALIGNED_ACCESS
+    enum { memneq_unaligned_ok = 1 };
+    typedef size_t memneq_t;
+#else
+    enum { memneq_unaligned_ok = 0 };
+    typedef unsigned int memneq_t;
+#endif
+
+    // Is value of type T aligned on A boundary?
+    // NOTE: requires that sizeof(A) is a power of 2
+    template <typename T, typename A>
+    inline bool is_aligned(const T value)
+    {
+      return (size_t(value) & (sizeof(A)-1)) == 0;
+    }
+
+    // Returns true if we are allowed to dereference a and b that
+    // point to objects of type memneq_t.
+    inline bool memneq_deref_ok(const void *a, const void *b)
+    {
+      return memneq_unaligned_ok || (is_aligned<const void *, memneq_t>(a)|is_aligned<const void *, memneq_t>(b));
+    }
+
+    // Constant-time memory equality method.  Can be used in
+    // security-sensitive contexts to inhibit timing attacks.
+    inline bool memneq(const void *a, const void *b, size_t size)
+    {
+      memneq_t neq = 0;
+
+      if (memneq_deref_ok(a, b))
+	{
+	  while (size >= sizeof(memneq_t))
+	    {
+	      neq |= *(memneq_t *)a ^ *(memneq_t *)b;
+	      OPENVPN_INCR_VOID_PTR(a, sizeof(memneq_t));
+	      OPENVPN_INCR_VOID_PTR(b, sizeof(memneq_t));
+	      size -= sizeof(memneq_t);
+	    }
+	}
+      while (size > 0)
+	{
+	  neq |= *(unsigned char *)a ^ *(unsigned char *)b;
+	  OPENVPN_INCR_VOID_PTR(a, 1);
+	  OPENVPN_INCR_VOID_PTR(b, 1);
+	  size -= 1;
+	}
+      OPENVPN_COMPILER_FENCE
+      return bool(neq);
+    }
+  }
+}
+
+#endif