ring-native 0.0.0 → 0.1.0

data/vendor/ring/crypto/test/test_util.cc

@@ -1,46 +0,0 @@
-/* Copyright (c) 2015, Google Inc.
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
-
-#include "test_util.h"
-
-#include <stdint.h>
-#include <stdio.h>
-
-#include "openssl/rand.h"
-
-
-void hexdump(FILE *fp, const char *msg, const void *in, size_t len) {
-  const uint8_t *data = reinterpret_cast<const uint8_t*>(in);
-  size_t i;
-
-  fputs(msg, fp);
-  for (i = 0; i < len; i++) {
-    fprintf(fp, "%02x", data[i]);
-  }
-  fputs("\n", fp);
-}
-
-// XXX: In *ring*, we implement |BN_generate_dsa_nonce_digest| in Rust so that
-// we can use |ring::digest|. But, the tests don't link against any Rust code.
-// Fortunately, we don't need secure nonces in the tests, so we can do the
-// thing you're not supposed to do in this implementation. This will likely
-// throw off the ECDSA_sign performance measurements in |bssl speed| though.
-extern "C" int BN_generate_dsa_nonce_digest(uint8_t *out, size_t out_len,
-                                            const uint8_t *, size_t,
-                                            const uint8_t *, size_t,
-                                            const uint8_t *, size_t,
-                                            const uint8_t *, size_t,
-                                            const uint8_t *, size_t) {
-  return RAND_bytes(out, out_len);
-}

data/vendor/ring/crypto/test/test_util.h

@@ -1,41 +0,0 @@
-/* Copyright (c) 2015, Google Inc.
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
-
-#ifndef OPENSSL_HEADER_CRYPTO_TEST_TEST_UTIL_H
-#define OPENSSL_HEADER_CRYPTO_TEST_TEST_UTIL_H
-
-#include <stddef.h>
-#include <stdio.h>
-
-#if defined(_MSC_VER) && _MSC_VER < 1900
-#define OPENSSL_PR_SIZE_T "Iu" /* MSVC doesn't support %zu until MSVC 2015. */
-#else
-#define OPENSSL_PR_SIZE_T "zu" /* "%zu" is the C99 standard format specifier. */
-#endif
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-
-/* hexdump writes |msg| to |fp| followed by the hex encoding of |len| bytes
- * from |in|. */
-void hexdump(FILE *fp, const char *msg, const void *in, size_t len);
-
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif /* OPENSSL_HEADER_CRYPTO_TEST_TEST_UTIL_H */

data/vendor/ring/crypto/thread_none.c

@@ -1,55 +0,0 @@
-/* Copyright (c) 2015, Google Inc.
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
-
-#include "internal.h"
-
-#if defined(OPENSSL_NO_THREADS)
-
-void CRYPTO_MUTEX_init(CRYPTO_MUTEX *lock) {}
-
-void CRYPTO_MUTEX_lock_read(CRYPTO_MUTEX *lock) {}
-
-void CRYPTO_MUTEX_lock_write(CRYPTO_MUTEX *lock) {}
-
-void CRYPTO_MUTEX_unlock(CRYPTO_MUTEX *lock) {}
-
-void CRYPTO_MUTEX_cleanup(CRYPTO_MUTEX *lock) {}
-
-void CRYPTO_STATIC_MUTEX_lock_read(struct CRYPTO_STATIC_MUTEX *lock) {}
-
-void CRYPTO_STATIC_MUTEX_lock_write(struct CRYPTO_STATIC_MUTEX *lock) {}
-
-void CRYPTO_STATIC_MUTEX_unlock(struct CRYPTO_STATIC_MUTEX *lock) {}
-
-void CRYPTO_once(CRYPTO_once_t *once, void (*init)(void)) {
-  if (*once) {
-    return;
-  }
-  *once = 1;
-  init();
-}
-
-static void *g_thread_locals[NUM_OPENSSL_THREAD_LOCALS];
-
-void *CRYPTO_get_thread_local(thread_local_data_t index) {
-  return g_thread_locals[index];
-}
-
-int CRYPTO_set_thread_local(thread_local_data_t index, void *value,
-                            thread_local_destructor_t destructor) {
-  g_thread_locals[index] = value;
-  return 1;
-}
-
-#endif  /* OPENSSL_NO_THREADS */

data/vendor/ring/crypto/thread_pthread.c

@@ -1,165 +0,0 @@
-/* Copyright (c) 2015, Google Inc.
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
-
-#include "internal.h"
-
-#if !defined(OPENSSL_WINDOWS) && !defined(OPENSSL_NO_THREADS)
-
-#include <pthread.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <openssl/mem.h>
-#include <openssl/type_check.h>
-
-
-OPENSSL_COMPILE_ASSERT(sizeof(CRYPTO_MUTEX) >= sizeof(pthread_rwlock_t),
-                       CRYPTO_MUTEX_too_small);
-
-void CRYPTO_MUTEX_init(CRYPTO_MUTEX *lock) {
-  if (pthread_rwlock_init((pthread_rwlock_t *) lock, NULL) != 0) {
-    abort();
-  }
-}
-
-void CRYPTO_MUTEX_lock_read(CRYPTO_MUTEX *lock) {
-  if (pthread_rwlock_rdlock((pthread_rwlock_t *) lock) != 0) {
-    abort();
-  }
-}
-
-void CRYPTO_MUTEX_lock_write(CRYPTO_MUTEX *lock) {
-  if (pthread_rwlock_wrlock((pthread_rwlock_t *) lock) != 0) {
-    abort();
-  }
-}
-
-void CRYPTO_MUTEX_unlock(CRYPTO_MUTEX *lock) {
-  if (pthread_rwlock_unlock((pthread_rwlock_t *) lock) != 0) {
-    abort();
-  }
-}
-
-void CRYPTO_MUTEX_cleanup(CRYPTO_MUTEX *lock) {
-  pthread_rwlock_destroy((pthread_rwlock_t *) lock);
-}
-
-void CRYPTO_STATIC_MUTEX_lock_read(struct CRYPTO_STATIC_MUTEX *lock) {
-  if (pthread_rwlock_rdlock(&lock->lock) != 0) {
-    abort();
-  }
-}
-
-void CRYPTO_STATIC_MUTEX_lock_write(struct CRYPTO_STATIC_MUTEX *lock) {
-  if (pthread_rwlock_wrlock(&lock->lock) != 0) {
-    abort();
-  }
-}
-
-void CRYPTO_STATIC_MUTEX_unlock(struct CRYPTO_STATIC_MUTEX *lock) {
-  if (pthread_rwlock_unlock(&lock->lock) != 0) {
-    abort();
-  }
-}
-
-void CRYPTO_once(CRYPTO_once_t *once, void (*init)(void)) {
-  if (pthread_once(once, init) != 0) {
-    abort();
-  }
-}
-
-static pthread_mutex_t g_destructors_lock = PTHREAD_MUTEX_INITIALIZER;
-static thread_local_destructor_t g_destructors[NUM_OPENSSL_THREAD_LOCALS];
-
-static void thread_local_destructor(void *arg) {
-  if (arg == NULL) {
-    return;
-  }
-
-  thread_local_destructor_t destructors[NUM_OPENSSL_THREAD_LOCALS];
-  if (pthread_mutex_lock(&g_destructors_lock) != 0) {
-    return;
-  }
-  memcpy(destructors, g_destructors, sizeof(destructors));
-  pthread_mutex_unlock(&g_destructors_lock);
-
-  unsigned i;
-  void **pointers = arg;
-  for (i = 0; i < NUM_OPENSSL_THREAD_LOCALS; i++) {
-    if (destructors[i] != NULL) {
-      destructors[i](pointers[i]);
-    }
-  }
-
-  OPENSSL_free(pointers);
-}
-
-static pthread_once_t g_thread_local_init_once = PTHREAD_ONCE_INIT;
-static pthread_key_t g_thread_local_key;
-static int g_thread_local_failed = 0;
-
-static void thread_local_init(void) {
-  g_thread_local_failed =
-      pthread_key_create(&g_thread_local_key, thread_local_destructor) != 0;
-}
-
-void *CRYPTO_get_thread_local(thread_local_data_t index) {
-  CRYPTO_once(&g_thread_local_init_once, thread_local_init);
-  if (g_thread_local_failed) {
-    return NULL;
-  }
-
-  void **pointers = pthread_getspecific(g_thread_local_key);
-  if (pointers == NULL) {
-    return NULL;
-  }
-  return pointers[index];
-}
-
-int CRYPTO_set_thread_local(thread_local_data_t index, void *value,
-                            thread_local_destructor_t destructor) {
-  CRYPTO_once(&g_thread_local_init_once, thread_local_init);
-  if (g_thread_local_failed) {
-    destructor(value);
-    return 0;
-  }
-
-  void **pointers = pthread_getspecific(g_thread_local_key);
-  if (pointers == NULL) {
-    pointers = OPENSSL_malloc(sizeof(void *) * NUM_OPENSSL_THREAD_LOCALS);
-    if (pointers == NULL) {
-      destructor(value);
-      return 0;
-    }
-    memset(pointers, 0, sizeof(void *) * NUM_OPENSSL_THREAD_LOCALS);
-    if (pthread_setspecific(g_thread_local_key, pointers) != 0) {
-      OPENSSL_free(pointers);
-      destructor(value);
-      return 0;
-    }
-  }
-
-  if (pthread_mutex_lock(&g_destructors_lock) != 0) {
-    destructor(value);
-    return 0;
-  }
-  g_destructors[index] = destructor;
-  pthread_mutex_unlock(&g_destructors_lock);
-
-  pointers[index] = value;
-  return 1;
-}
-
-#endif  /* !OPENSSL_WINDOWS && !OPENSSL_NO_THREADS */

data/vendor/ring/crypto/thread_test.Windows.vcxproj

@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{52C6E909-4E56-4329-8B99-E1B5C2E1FB19}</ProjectGuid>
-    <TargetName>thread_test</TargetName>
-  </PropertyGroup>
-  <ImportGroup Label="PropertySheets">
-    <Import Project="..\mk\WindowsTest.props" />
-  </ImportGroup>
-  <PropertyGroup Label="Configuration">
-    <OutDir>$(OutRootDir)\test\ring\crypto\</OutDir>
-  </PropertyGroup>
-  <ItemGroup>
-    <ClCompile Include="thread_test.c" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="libring.Windows.vcxproj">
-      <Project>{f4c0a1b6-5e09-41c8-8242-3e1f6762fb18}</Project>
-    </ProjectReference>
-    <ProjectReference Include="test\test.Windows.vcxproj">
-      <Project>{1dace503-6498-492d-b1ff-f9ee18624443}</Project>
-    </ProjectReference>
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-</Project>

data/vendor/ring/crypto/thread_test.c

@@ -1,200 +0,0 @@
-/* Copyright (c) 2015, Google Inc.
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
-
-#include "internal.h"
-
-#include <stdio.h>
-
-
-#if !defined(OPENSSL_NO_THREADS)
-
-#if defined(OPENSSL_WINDOWS)
-
-#pragma warning(push, 3)
-#include <windows.h>
-#pragma warning(pop)
-
-typedef HANDLE thread_t;
-
-static DWORD WINAPI thread_run(LPVOID arg) {
-  void (*thread_func)(void);
-  /* VC really doesn't like casting between data and function pointers. */
-  memcpy(&thread_func, &arg, sizeof(thread_func));
-  thread_func();
-  return 0;
-}
-
-static int run_thread(thread_t *out_thread, void (*thread_func)(void)) {
-  void *arg;
-  /* VC really doesn't like casting between data and function pointers. */
-  memcpy(&arg, &thread_func, sizeof(arg));
-
-  *out_thread = CreateThread(NULL /* security attributes */,
-                             0 /* default stack size */, thread_run, arg,
-                             0 /* run immediately */, NULL /* ignore id */);
-  return *out_thread != NULL;
-}
-
-static int wait_for_thread(thread_t thread) {
-  return WaitForSingleObject(thread, INFINITE) == 0;
-}
-
-#else
-
-#include <pthread.h>
-
-typedef pthread_t thread_t;
-
-static void *thread_run(void *arg) {
-  void (*thread_func)(void) = arg;
-  thread_func();
-  return NULL;
-}
-
-static int run_thread(thread_t *out_thread, void (*thread_func)(void)) {
-  return pthread_create(out_thread, NULL /* default attributes */, thread_run,
-                        thread_func) == 0;
-}
-
-static int wait_for_thread(thread_t thread) {
-  return pthread_join(thread, NULL) == 0;
-}
-
-#endif  /* OPENSSL_WINDOWS */
-
-static unsigned g_once_init_called = 0;
-
-static void once_init(void) {
-  g_once_init_called++;
-}
-
-static CRYPTO_once_t g_test_once = CRYPTO_ONCE_INIT;
-
-static void call_once_thread(void) {
-  CRYPTO_once(&g_test_once, once_init);
-}
-
-static int test_once(void) {
-  if (g_once_init_called != 0) {
-    fprintf(stderr, "g_once_init_called was non-zero at start.\n");
-    return 0;
-  }
-
-  thread_t thread;
-  if (!run_thread(&thread, call_once_thread) ||
-      !wait_for_thread(thread)) {
-    fprintf(stderr, "thread failed.\n");
-    return 0;
-  }
-
-  CRYPTO_once(&g_test_once, once_init);
-
-  if (g_once_init_called != 1) {
-    fprintf(stderr, "Expected init function to be called once, but found %u.\n",
-            g_once_init_called);
-    return 0;
-  }
-
-  return 1;
-}
-
-
-static int g_test_thread_ok = 0;
-static unsigned g_destructor_called_count = 0;
-
-static void thread_local_destructor(void *arg) {
-  if (arg == NULL) {
-    return;
-  }
-
-  unsigned *count = arg;
-  (*count)++;
-}
-
-static void thread_local_test_thread(void) {
-  void *ptr = CRYPTO_get_thread_local(OPENSSL_THREAD_LOCAL_TEST);
-  if (ptr != NULL) {
-    return;
-  }
-
-  if (!CRYPTO_set_thread_local(OPENSSL_THREAD_LOCAL_TEST,
-                               &g_destructor_called_count,
-                               thread_local_destructor)) {
-    return;
-  }
-
-  if (CRYPTO_get_thread_local(OPENSSL_THREAD_LOCAL_TEST) !=
-      &g_destructor_called_count) {
-    return;
-  }
-
-  g_test_thread_ok = 1;
-}
-
-static void thread_local_test2_thread(void) {}
-
-static int test_thread_local(void) {
-  void *ptr = CRYPTO_get_thread_local(OPENSSL_THREAD_LOCAL_TEST);
-  if (ptr != NULL) {
-    fprintf(stderr, "Thread-local data was non-NULL at start.\n");
-  }
-
-  thread_t thread;
-  if (!run_thread(&thread, thread_local_test_thread) ||
-      !wait_for_thread(thread)) {
-    fprintf(stderr, "thread failed.\n");
-    return 0;
-  }
-
-  if (!g_test_thread_ok) {
-    fprintf(stderr, "Thread-local data didn't work in thread.\n");
-    return 0;
-  }
-
-  if (g_destructor_called_count != 1) {
-    fprintf(stderr,
-            "Destructor should have been called once, but actually called %u "
-            "times.\n",
-            g_destructor_called_count);
-    return 0;
-  }
-
-  /* thread_local_test2_thread doesn't do anything, but it tests that the
-   * thread destructor function works even if thread-local storage wasn't used
-   * for a thread. */
-  if (!run_thread(&thread, thread_local_test2_thread) ||
-      !wait_for_thread(thread)) {
-    fprintf(stderr, "thread failed.\n");
-    return 0;
-  }
-
-  return 1;
-}
-
-int main(int argc, char **argv) {
-  if (!test_once() ||
-      !test_thread_local()) {
-    return 1;
-  }
-
-  return 0;
-}
-
-#else  /* OPENSSL_NO_THREADS */
-
-int main(int argc, char **argv) {
-  return 0;
-}
-
-#endif