eddsa 0.8.0__tar.gz

eddsa-0.8.0/CMakeLists.txt

@@ -0,0 +1,65 @@
+include(CheckCCompilerFlag)
+include(CheckPrototypeDefinition)
+
+cmake_minimum_required(VERSION 3.0.0)
+
+project(eddsa C)
+
+set(EDDSA_VERSION_MAJOR 0)
+set(EDDSA_VERSION_MINOR 8)
+
+
+option(USE_STACKCLEAN "clean all secret variables from stack" ON)
+option(BUILD_STATIC "build static version of library" ON)
+option(BUILD_TESTING "build test" ON)
+
+
+if (UNIX)
+	set(CMAKE_C_FLAGS "-std=c99 -fwrapv -Wall -Wextra -pedantic -O3")
+endif ()
+
+# check for memset_s and co
+#
+check_prototype_definition(memset_s
+	"errno_t memset_s( void *dest, rsize_t destsz, int ch, rsize_t count )"
+	"0"
+	"string.h"
+	HAVE_MEMSET_S)
+
+check_prototype_definition(explicit_bzero
+	"void explicit_bzero(void *b, size_t len)"
+	""
+	"string.h"
+	HAVE_EXPLICIT_BZERO)
+
+
+# does our compiler have hidden-visibility feature?
+#
+if (NOT (CMAKE_COMPILER_IS_GNUCC AND CMAKE_C_COMPILER_VERSION VERSION_LESS "4.2")
+    AND NOT WIN32 
+    AND NOT CYGWIN)
+  check_c_compiler_flag("-fvisibility=hidden" HAVE_VISIBILITY)
+endif ()
+
+
+
+# add library source code
+#
+add_subdirectory(lib)
+
+
+# add test source if requested
+#
+if (BUILD_TESTING)
+  enable_testing()
+  add_subdirectory(test)
+endif ()
+
+if (NOT BITNESS)
+  set(BITNESS autodetect)
+endif ()
+
+
+MESSAGE("bitness: " ${BITNESS})
+MESSAGE("cleanup stack: " ${USE_STACKCLEAN})
+MESSAGE("build test: " ${BUILD_TESTING})

eddsa-0.8.0/LICENSE

@@ -0,0 +1,25 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org>
+

eddsa-0.8.0/MANIFEST.in

@@ -0,0 +1,11 @@
+include pyproject.toml
+include setup.py
+include MANIFEST.in
+include CMakeLists.txt
+recursive-include build_tools *.py
+include eddsa/__init__.py
+include eddsa/_eddsa.c
+include eddsa/_eddsa.map
+include eddsa/_eddsa.exports
+recursive-include tools *.py
+recursive-include tests *.py

eddsa-0.8.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: eddsa
+Version: 0.8.0
+Summary: CPython wrapper for libeddsa Ed25519 and X25519 primitives
+Home-page: https://github.com/sippy/py-eddsa.git
+Author: Maksym Sobolyev
+Author-email: sobomax@gmail.com
+License: Unlicense
+Classifier: Development Status :: 4 - Beta
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-python
+Dynamic: summary
+
+# libeddsa
+
+This is a small cryptographic library for signatures with [ed25519](http://ed25519.cr.yp.to/ed25519-20110705.pdf) and diffie-hellman key exchange with [x25519](http://cr.yp.to/ecdh/curve25519-20060209.pdf).
+
+My goal is to give a fast, but still readable, C implemantation of these two crypto primitives without any complex framework. (If you need a full and easy to use framework with symmetric cipher and MAC included, please have a look at [libnacl](http://nacl.cr.yp.to) or [libsodium](https://github.com/jedisct1/libsodium) which are both great.)
+
+If you need just ed25519-signatures or x25519-key-exchange with a simple API, however, libeddsa may be for you: It is small (under 90kb) and quite fast.
+
+
+### Features:
+- written in C
+- fast and small
+- cmake build system
+- protection against timing attacks as far as possible in C
+- static and dynamic link support
+- easy to use (see wiki)
+- public domain license
+
+### Python bindings
+
+The CPython module is packaged from `python/` and exposes the public libeddsa
+API as byte-oriented functions:
+
+- `ed25519_genpub(sec) -> bytes`
+- `ed25519_sign(sec, pub, data) -> bytes`
+- `ed25519_verify(sig, pub, data) -> bool`
+- `x25519_base(scalar) -> bytes`
+- `x25519(scalar, point) -> bytes`
+- `pk_ed25519_to_x25519(pub) -> bytes`
+- `sk_ed25519_to_x25519(sec) -> bytes`
+
+The obsolete C API names are also provided as compatibility aliases.

eddsa-0.8.0/README.md

@@ -0,0 +1,32 @@
+# libeddsa
+
+This is a small cryptographic library for signatures with [ed25519](http://ed25519.cr.yp.to/ed25519-20110705.pdf) and diffie-hellman key exchange with [x25519](http://cr.yp.to/ecdh/curve25519-20060209.pdf).
+
+My goal is to give a fast, but still readable, C implemantation of these two crypto primitives without any complex framework. (If you need a full and easy to use framework with symmetric cipher and MAC included, please have a look at [libnacl](http://nacl.cr.yp.to) or [libsodium](https://github.com/jedisct1/libsodium) which are both great.)
+
+If you need just ed25519-signatures or x25519-key-exchange with a simple API, however, libeddsa may be for you: It is small (under 90kb) and quite fast.
+
+
+### Features:
+- written in C
+- fast and small
+- cmake build system
+- protection against timing attacks as far as possible in C
+- static and dynamic link support
+- easy to use (see wiki)
+- public domain license
+
+### Python bindings
+
+The CPython module is packaged from `python/` and exposes the public libeddsa
+API as byte-oriented functions:
+
+- `ed25519_genpub(sec) -> bytes`
+- `ed25519_sign(sec, pub, data) -> bytes`
+- `ed25519_verify(sig, pub, data) -> bool`
+- `x25519_base(scalar) -> bytes`
+- `x25519(scalar, point) -> bytes`
+- `pk_ed25519_to_x25519(pub) -> bytes`
+- `sk_ed25519_to_x25519(sec) -> bytes`
+
+The obsolete C API names are also provided as compatibility aliases.

eddsa-0.8.0/build_tools/CheckVersion.py

@@ -0,0 +1,28 @@
+import sys
+from distutils.errors import DistutilsOptionError
+
+from setuptools import Command
+
+
+class CheckVersion(Command):
+    description = "Check package version against a git tag"
+    user_options = [
+        ("tag=", "t", "git tag to compare against package version"),
+    ]
+
+    def initialize_options(self):
+        self.tag = None
+
+    def finalize_options(self):
+        if not self.tag:
+            raise DistutilsOptionError("You must specify --tag")
+
+    def run(self):
+        pkg_version = self.distribution.get_version()
+        accepted_tags = {f"v{pkg_version}"}
+        if pkg_version.endswith(".0"):
+            accepted_tags.add(f"v{pkg_version[:-2]}")
+        if self.tag in accepted_tags:
+            return
+        sys.stderr.write(f"version {pkg_version} does not match tag {self.tag}\n")
+        sys.exit(1)

eddsa-0.8.0/build_tools/RunCTest.py

@@ -0,0 +1,51 @@
+import os
+import shutil
+import subprocess
+from pathlib import Path
+
+from setuptools import Command
+
+
+class RunCTest(Command):
+    description = "Build and run the C self-tests"
+    user_options = []
+    root_dir = Path(__file__).resolve().parents[2]
+
+    def initialize_options(self):
+        pass
+
+    def finalize_options(self):
+        pass
+
+    def run(self):
+        build_dir = self.root_dir / "build" / "python-ctest"
+        if build_dir.exists():
+            shutil.rmtree(build_dir)
+        build_dir.mkdir(parents=True)
+
+        env = os.environ.copy()
+        subprocess.run(
+            [
+                "cmake",
+                "-S",
+                str(self.root_dir),
+                "-B",
+                str(build_dir),
+                "-DBUILD_STATIC=ON",
+                "-DBUILD_TESTING=ON",
+                "-DCMAKE_BUILD_TYPE=Release",
+                "-DCMAKE_POLICY_VERSION_MINIMUM=3.5",
+            ],
+            check=True,
+            env=env,
+        )
+        subprocess.run(
+            ["cmake", "--build", str(build_dir), "--config", "Release"],
+            check=True,
+            env=env,
+        )
+        subprocess.run(
+            ["ctest", "--test-dir", str(build_dir), "--output-on-failure", "-C", "Release"],
+            check=True,
+            env=env,
+        )

eddsa-0.8.0/build_tools/__init__.py

@@ -0,0 +1 @@
+

eddsa-0.8.0/eddsa/__init__.py

@@ -0,0 +1,37 @@
+from ._eddsa import (
+    DH,
+    ED25519_KEY_LEN,
+    ED25519_SIG_LEN,
+    X25519_KEY_LEN,
+    ed25519_genpub,
+    ed25519_sign,
+    ed25519_verify,
+    eddsa_genpub,
+    eddsa_pk_eddsa_to_dh,
+    eddsa_sign,
+    eddsa_sk_eddsa_to_dh,
+    eddsa_verify,
+    pk_ed25519_to_x25519,
+    sk_ed25519_to_x25519,
+    x25519,
+    x25519_base,
+)
+
+__all__ = [
+    "ED25519_KEY_LEN",
+    "ED25519_SIG_LEN",
+    "X25519_KEY_LEN",
+    "ed25519_genpub",
+    "ed25519_sign",
+    "ed25519_verify",
+    "x25519_base",
+    "x25519",
+    "pk_ed25519_to_x25519",
+    "sk_ed25519_to_x25519",
+    "eddsa_genpub",
+    "eddsa_sign",
+    "eddsa_verify",
+    "DH",
+    "eddsa_pk_eddsa_to_dh",
+    "eddsa_sk_eddsa_to_dh",
+]

eddsa-0.8.0/eddsa/_eddsa.c

@@ -0,0 +1,251 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include <stdint.h>
+
+#include "eddsa.h"
+
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+#define PYEDDSA_MODINIT_FUNC __declspec(dllexport) PyObject *
+#elif defined(__GNUC__) || defined(__clang__)
+#define PYEDDSA_MODINIT_FUNC __attribute__((visibility("default"))) PyObject *
+#else
+#define PYEDDSA_MODINIT_FUNC PyObject *
+#endif
+
+
+static int
+expect_len(const Py_buffer *buffer, Py_ssize_t expected, const char *name)
+{
+    if (buffer->len == expected) {
+        return 0;
+    }
+    PyErr_Format(PyExc_ValueError, "%s must be exactly %zd bytes", name, expected);
+    return -1;
+}
+
+static PyObject *
+py_ed25519_genpub(PyObject *self, PyObject *args)
+{
+    Py_buffer sec;
+    PyObject *result;
+
+    (void)self;
+    if (!PyArg_ParseTuple(args, "y*:ed25519_genpub", &sec)) {
+        return NULL;
+    }
+    if (expect_len(&sec, ED25519_KEY_LEN, "sec") < 0) {
+        PyBuffer_Release(&sec);
+        return NULL;
+    }
+
+    result = PyBytes_FromStringAndSize(NULL, ED25519_KEY_LEN);
+    if (result != NULL) {
+        ed25519_genpub((uint8_t *)PyBytes_AS_STRING(result), (const uint8_t *)sec.buf);
+    }
+    PyBuffer_Release(&sec);
+    return result;
+}
+
+static PyObject *
+py_ed25519_sign(PyObject *self, PyObject *args)
+{
+    Py_buffer sec;
+    Py_buffer pub;
+    Py_buffer data;
+    PyObject *result;
+
+    (void)self;
+    if (!PyArg_ParseTuple(args, "y*y*y*:ed25519_sign", &sec, &pub, &data)) {
+        return NULL;
+    }
+    if (expect_len(&sec, ED25519_KEY_LEN, "sec") < 0 ||
+        expect_len(&pub, ED25519_KEY_LEN, "pub") < 0) {
+        PyBuffer_Release(&data);
+        PyBuffer_Release(&pub);
+        PyBuffer_Release(&sec);
+        return NULL;
+    }
+
+    result = PyBytes_FromStringAndSize(NULL, ED25519_SIG_LEN);
+    if (result != NULL) {
+        ed25519_sign((uint8_t *)PyBytes_AS_STRING(result),
+            (const uint8_t *)sec.buf, (const uint8_t *)pub.buf,
+            (const uint8_t *)data.buf, (size_t)data.len);
+    }
+    PyBuffer_Release(&data);
+    PyBuffer_Release(&pub);
+    PyBuffer_Release(&sec);
+    return result;
+}
+
+static PyObject *
+py_ed25519_verify(PyObject *self, PyObject *args)
+{
+    Py_buffer sig;
+    Py_buffer pub;
+    Py_buffer data;
+    bool ok;
+
+    (void)self;
+    if (!PyArg_ParseTuple(args, "y*y*y*:ed25519_verify", &sig, &pub, &data)) {
+        return NULL;
+    }
+    if (expect_len(&sig, ED25519_SIG_LEN, "sig") < 0 ||
+        expect_len(&pub, ED25519_KEY_LEN, "pub") < 0) {
+        PyBuffer_Release(&data);
+        PyBuffer_Release(&pub);
+        PyBuffer_Release(&sig);
+        return NULL;
+    }
+
+    ok = ed25519_verify((const uint8_t *)sig.buf, (const uint8_t *)pub.buf,
+        (const uint8_t *)data.buf, (size_t)data.len);
+    PyBuffer_Release(&data);
+    PyBuffer_Release(&pub);
+    PyBuffer_Release(&sig);
+    return PyBool_FromLong(ok);
+}
+
+static PyObject *
+py_x25519_base(PyObject *self, PyObject *args)
+{
+    Py_buffer scalar;
+    PyObject *result;
+
+    (void)self;
+    if (!PyArg_ParseTuple(args, "y*:x25519_base", &scalar)) {
+        return NULL;
+    }
+    if (expect_len(&scalar, X25519_KEY_LEN, "scalar") < 0) {
+        PyBuffer_Release(&scalar);
+        return NULL;
+    }
+
+    result = PyBytes_FromStringAndSize(NULL, X25519_KEY_LEN);
+    if (result != NULL) {
+        x25519_base((uint8_t *)PyBytes_AS_STRING(result), (const uint8_t *)scalar.buf);
+    }
+    PyBuffer_Release(&scalar);
+    return result;
+}
+
+static PyObject *
+py_x25519(PyObject *self, PyObject *args)
+{
+    Py_buffer scalar;
+    Py_buffer point;
+    PyObject *result;
+
+    (void)self;
+    if (!PyArg_ParseTuple(args, "y*y*:x25519", &scalar, &point)) {
+        return NULL;
+    }
+    if (expect_len(&scalar, X25519_KEY_LEN, "scalar") < 0 ||
+        expect_len(&point, X25519_KEY_LEN, "point") < 0) {
+        PyBuffer_Release(&point);
+        PyBuffer_Release(&scalar);
+        return NULL;
+    }
+
+    result = PyBytes_FromStringAndSize(NULL, X25519_KEY_LEN);
+    if (result != NULL) {
+        x25519((uint8_t *)PyBytes_AS_STRING(result), (const uint8_t *)scalar.buf,
+            (const uint8_t *)point.buf);
+    }
+    PyBuffer_Release(&point);
+    PyBuffer_Release(&scalar);
+    return result;
+}
+
+static PyObject *
+py_pk_ed25519_to_x25519(PyObject *self, PyObject *args)
+{
+    Py_buffer in;
+    PyObject *result;
+
+    (void)self;
+    if (!PyArg_ParseTuple(args, "y*:pk_ed25519_to_x25519", &in)) {
+        return NULL;
+    }
+    if (expect_len(&in, ED25519_KEY_LEN, "in") < 0) {
+        PyBuffer_Release(&in);
+        return NULL;
+    }
+
+    result = PyBytes_FromStringAndSize(NULL, X25519_KEY_LEN);
+    if (result != NULL) {
+        pk_ed25519_to_x25519((uint8_t *)PyBytes_AS_STRING(result), (const uint8_t *)in.buf);
+    }
+    PyBuffer_Release(&in);
+    return result;
+}
+
+static PyObject *
+py_sk_ed25519_to_x25519(PyObject *self, PyObject *args)
+{
+    Py_buffer in;
+    PyObject *result;
+
+    (void)self;
+    if (!PyArg_ParseTuple(args, "y*:sk_ed25519_to_x25519", &in)) {
+        return NULL;
+    }
+    if (expect_len(&in, ED25519_KEY_LEN, "in") < 0) {
+        PyBuffer_Release(&in);
+        return NULL;
+    }
+
+    result = PyBytes_FromStringAndSize(NULL, X25519_KEY_LEN);
+    if (result != NULL) {
+        sk_ed25519_to_x25519((uint8_t *)PyBytes_AS_STRING(result), (const uint8_t *)in.buf);
+    }
+    PyBuffer_Release(&in);
+    return result;
+}
+
+static PyMethodDef module_methods[] = {
+    {"ed25519_genpub", py_ed25519_genpub, METH_VARARGS, PyDoc_STR("Return an Ed25519 public key for a 32-byte secret key.")},
+    {"ed25519_sign", py_ed25519_sign, METH_VARARGS, PyDoc_STR("Return a 64-byte Ed25519 signature for sec, pub, and data.")},
+    {"ed25519_verify", py_ed25519_verify, METH_VARARGS, PyDoc_STR("Return True if sig verifies for pub and data.")},
+    {"x25519_base", py_x25519_base, METH_VARARGS, PyDoc_STR("Return the X25519 public value for a 32-byte scalar.")},
+    {"x25519", py_x25519, METH_VARARGS, PyDoc_STR("Return the X25519 shared value for scalar and point.")},
+    {"pk_ed25519_to_x25519", py_pk_ed25519_to_x25519, METH_VARARGS, PyDoc_STR("Convert an Ed25519 public key to an X25519 public key.")},
+    {"sk_ed25519_to_x25519", py_sk_ed25519_to_x25519, METH_VARARGS, PyDoc_STR("Convert an Ed25519 secret key to an X25519 secret key.")},
+    {"eddsa_genpub", py_ed25519_genpub, METH_VARARGS, PyDoc_STR("Obsolete alias for ed25519_genpub.")},
+    {"eddsa_sign", py_ed25519_sign, METH_VARARGS, PyDoc_STR("Obsolete alias for ed25519_sign.")},
+    {"eddsa_verify", py_ed25519_verify, METH_VARARGS, PyDoc_STR("Obsolete alias for ed25519_verify.")},
+    {"DH", py_x25519, METH_VARARGS, PyDoc_STR("Obsolete alias for x25519.")},
+    {"eddsa_pk_eddsa_to_dh", py_pk_ed25519_to_x25519, METH_VARARGS, PyDoc_STR("Obsolete alias for pk_ed25519_to_x25519.")},
+    {"eddsa_sk_eddsa_to_dh", py_sk_ed25519_to_x25519, METH_VARARGS, PyDoc_STR("Obsolete alias for sk_ed25519_to_x25519.")},
+    {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef moduledef = {
+    PyModuleDef_HEAD_INIT,
+    "_eddsa",
+    PyDoc_STR("CPython bindings for libeddsa."),
+    -1,
+    module_methods,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+PYEDDSA_MODINIT_FUNC
+PyInit__eddsa(void)
+{
+    PyObject *module = PyModule_Create(&moduledef);
+    if (module == NULL) {
+        return NULL;
+    }
+    if (PyModule_AddIntConstant(module, "ED25519_KEY_LEN", ED25519_KEY_LEN) < 0 ||
+        PyModule_AddIntConstant(module, "ED25519_SIG_LEN", ED25519_SIG_LEN) < 0 ||
+        PyModule_AddIntConstant(module, "X25519_KEY_LEN", X25519_KEY_LEN) < 0) {
+        Py_DECREF(module);
+        return NULL;
+    }
+    return module;
+}

eddsa-0.8.0/eddsa/_eddsa.exports

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

eddsa-0.8.0/eddsa/_eddsa.map

@@ -0,0 +1,6 @@
+PYEDDSA_0.8 {
+    global:
+        PyInit__eddsa;
+    local:
+        *;
+};

eddsa-0.8.0/eddsa/_vendor/lib/bitness.h

@@ -0,0 +1,12 @@
+#ifndef BITNESS_H
+#define BITNESS_H
+
+#ifndef NO_AUTO_BITNESS
+  #ifdef __LP64__
+    #define USE_64BIT	1
+  #else
+    #undef USE_64BIT
+  #endif
+#endif
+
+#endif

eddsa-0.8.0/eddsa/_vendor/lib/burn.c

@@ -0,0 +1,14 @@
+#include <stdint.h>
+#include <stddef.h>
+
+/*
+ * burn - simple function to zero a buffer, used to cover our tracks
+ */
+void
+burn(void *dest, size_t len)
+{
+	volatile uint8_t *p = (uint8_t *)dest;
+	const uint8_t *end = (uint8_t *)dest+len;
+
+	while (p < end) *p++ = 0;
+}

eddsa-0.8.0/eddsa/_vendor/lib/burn.h

@@ -0,0 +1,26 @@
+#ifndef BURN_H
+#define BURN_H
+
+#include <stddef.h>
+
+#include "compat.h"
+
+
+#if defined(HAVE_MEMSET_S)
+
+#include <string.h>
+static INLINE void burn(void *dest, size_t len) { memset_s(dest, len, 0, len); }
+
+#elif defined(HAVE_EXPLICIT_BZERO)
+
+#include <string.h>
+static INLINE void burn(void *dest, size_t len) { explicit_bzero(dest, len); }
+
+#else
+
+void	burn(void *dest, size_t len);
+
+#endif
+
+
+#endif

eddsa-0.8.0/eddsa/_vendor/lib/burnstack.c

@@ -0,0 +1,21 @@
+#include <stdint.h>
+
+#include "burn.h"
+#include "burnstack.h"
+
+
+#ifdef USE_STACKCLEAN
+
+/*
+ * burnstack - cleanup our stack
+ */
+void
+burnstack(int len)
+{
+	uint8_t stack[1024];
+	burn(stack, 1024);
+	if (len > 0)
+		burnstack(len-1024);
+}
+
+#endif

eddsa-0.8.0/eddsa/_vendor/lib/burnstack.h

@@ -0,0 +1,16 @@
+#ifndef BURNSTACK_H
+#define BURNSTACK_H
+
+#include "compat.h"
+
+#ifdef USE_STACKCLEAN
+
+void burnstack(int len);
+
+#else
+
+static INLINE void burnstack(int len) { (void)len; }
+
+#endif
+
+#endif

eddsa-0.8.0/eddsa/_vendor/lib/compat.h

@@ -0,0 +1,14 @@
+#ifndef COMPAT_H
+#define COMPAT_H
+
+/*
+ * macro for inline-functions to make visual c happy :-\
+ */
+
+#ifdef _MSC_VER
+#define INLINE __inline
+#else
+#define INLINE inline
+#endif
+
+#endif