src/crypto.c

   1 /*
   2  *  Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Contact: Krzysztof Jackiewicz <k.jackiewicz@samsung.com>
   5  *
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License
  17  */
  18
  19 /**
  20  * @file crypto.c
  21  * @brief
  22  */
  23
  24 #include <assert.h>
  25 #include <string.h>
  26 #include <pthread.h>
  27
  28 #include <openssl/crypto.h>
  29 #include <openssl/evp.h>
  30 #include <openssl/rand.h>
  31 #include <openssl/err.h>
  32
  33 #include <yaca_crypto.h>
  34 #include <yaca_error.h>
  35
  36 #include "internal.h"
  37
  38 static pthread_mutex_t *mutexes = NULL;
  39
  40 static void locking_callback(int mode, int type, const char *file, int line)
  41 {
  42         /* Ignore NULL mutexes and lock/unlock error codes as we can't do anything
  43          * about them. */
  44
  45         if (mutexes == NULL)
  46                 return;
  47
  48         if (mode & CRYPTO_LOCK)
  49                 pthread_mutex_lock(&mutexes[type]);
  50         else if (mode & CRYPTO_UNLOCK)
  51                 pthread_mutex_unlock(&mutexes[type]);
  52 }
  53
  54 static unsigned long thread_id_callback()
  55 {
  56         return pthread_self();
  57 }
  58
  59 static void destroy_mutexes(int count)
  60 {
  61         if (mutexes != NULL) {
  62                 for (int i = 0; i < count; i++) {
  63                         /* Ignore returned value as we can't do anything about it */
  64                         pthread_mutex_destroy(&mutexes[i]);
  65                 }
  66                 yaca_free(mutexes);
  67                 mutexes = NULL;
  68         }
  69 }
  70
  71 API int yaca_init(void)
  72 {
  73         int ret;
  74         if (mutexes != NULL)
  75                 return YACA_ERROR_INTERNAL; // TODO introduce new one?
  76
  77         OPENSSL_init();
  78
  79         /* This should never fail on a /dev/random equipped system. If it does it
  80          * means we might need to figure out another way of a truly random seed.
  81          * https://wiki.openssl.org/index.php/Random_Numbers
  82          *
  83          * Another things to maybe consider for the future:
  84          * - entropy on a mobile device (no mouse/keyboard)
  85          * - fork safety: https://wiki.openssl.org/index.php/Random_fork-safety
  86          * - hardware random generator (RdRand on new Intels, Samsung hardware?)
  87          */
  88         if (RAND_status() != 1) {
  89                 ERROR_DUMP(YACA_ERROR_INTERNAL);
  90                 return YACA_ERROR_INTERNAL;
  91         }
  92
  93         OpenSSL_add_all_digests();
  94         OpenSSL_add_all_ciphers();
  95
  96         /* enable threads support */
  97         ret = yaca_malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t), (void**)&mutexes);
  98         if (ret != YACA_ERROR_NONE)
  99                 return ret;
 100
 101         for (int i = 0; i < CRYPTO_num_locks(); i++) {
 102                 if (pthread_mutex_init(&mutexes[i], NULL) != 0) {
 103                         int ret = YACA_ERROR_NONE;
 104                         switch (errno) {
 105                         case ENOMEM:
 106                                 ret = YACA_ERROR_OUT_OF_MEMORY;
 107                                 break;
 108                         case EAGAIN:
 109                         case EPERM:
 110                         case EBUSY:
 111                         case EINVAL:
 112                         default:
 113                                 ret = YACA_ERROR_INTERNAL;
 114                         }
 115                         destroy_mutexes(i);
 116
 117                         return ret;
 118                 }
 119         }
 120
 121         CRYPTO_set_id_callback(thread_id_callback);
 122         CRYPTO_set_locking_callback(locking_callback);
 123
 124         /*
 125           TODO:
 126                 We should also decide on Openssl config.
 127                 Here's a good tutorial for initalization and cleanup: https://wiki.openssl.org/index.php/Library_Initialization
 128                 We should also initialize the entropy for random number generator: https://wiki.openssl.org/index.php/Random_Numbers#Initialization
 129         */
 130
 131         return YACA_ERROR_NONE;
 132 }
 133
 134 API int yaca_exit(void)
 135 {
 136         ERR_free_strings();
 137         ERR_remove_thread_state(NULL);
 138         EVP_cleanup();
 139         RAND_cleanup();
 140         CRYPTO_cleanup_all_ex_data();
 141
 142         /* threads support cleanup */
 143         CRYPTO_set_id_callback(NULL);
 144         CRYPTO_set_locking_callback(NULL);
 145
 146         destroy_mutexes(CRYPTO_num_locks());
 147
 148         return YACA_ERROR_NONE;
 149 }
 150
 151 API int yaca_malloc(size_t size, void **memory)
 152 {
 153         if (size == 0 || memory == NULL)
 154                 return YACA_ERROR_INVALID_ARGUMENT;
 155
 156         *memory = OPENSSL_malloc(size);
 157         if (*memory == NULL) {
 158                 ERROR_DUMP(YACA_ERROR_OUT_OF_MEMORY);
 159                 return YACA_ERROR_OUT_OF_MEMORY;
 160         }
 161
 162         return YACA_ERROR_NONE;
 163 }
 164
 165 API int yaca_zalloc(size_t size, void **memory)
 166 {
 167         int ret = yaca_malloc(size, memory);
 168         if (ret != YACA_ERROR_NONE)
 169                 return ret;
 170
 171         memset(*memory, 0, size);
 172
 173         return YACA_ERROR_NONE;
 174 }
 175
 176 API int yaca_realloc(size_t size, void **memory)
 177 {
 178         if (size == 0 || memory == NULL)
 179                 return YACA_ERROR_INVALID_ARGUMENT;
 180
 181         void *tmp = OPENSSL_realloc(*memory, size);
 182         if (tmp == NULL) {
 183                 ERROR_DUMP(YACA_ERROR_OUT_OF_MEMORY);
 184                 return YACA_ERROR_OUT_OF_MEMORY;
 185         }
 186
 187         *memory = tmp;
 188
 189         return YACA_ERROR_NONE;
 190 }
 191
 192 API int yaca_free(void *ptr)
 193 {
 194         OPENSSL_free(ptr);
 195
 196         return YACA_ERROR_NONE;
 197 }
 198
 199 API int yaca_rand_bytes(char *data, size_t data_len)
 200 {
 201         int ret;
 202
 203         if (data == NULL || data_len == 0)
 204                 return YACA_ERROR_INVALID_ARGUMENT;
 205
 206         ret = RAND_bytes((unsigned char *)data, data_len);
 207         if (ret != 1) {
 208                 ret = YACA_ERROR_INTERNAL;
 209                 ERROR_DUMP(ret);
 210                 return ret;
 211         }
 212
 213         return YACA_ERROR_NONE;
 214 }
 215
 216 API int yaca_ctx_set_param(yaca_ctx_h ctx, yaca_ex_param_e param,
 217                            const void *value, size_t value_len)
 218 {
 219         if (ctx == YACA_CTX_NULL || ctx->set_param == NULL)
 220                 return YACA_ERROR_INVALID_ARGUMENT;
 221
 222         return ctx->set_param(ctx, param, value, value_len);
 223 }
 224
 225 API int yaca_ctx_get_param(const yaca_ctx_h ctx, yaca_ex_param_e param,
 226                            void **value, size_t *value_len)
 227 {
 228         if (ctx == YACA_CTX_NULL || ctx->get_param == NULL)
 229                 return YACA_ERROR_INVALID_ARGUMENT;
 230
 231         return ctx->get_param(ctx, param, value, value_len);
 232 }
 233
 234 API int yaca_ctx_free(yaca_ctx_h ctx)
 235 {
 236         if (ctx != YACA_CTX_NULL) {
 237                 assert(ctx->ctx_destroy != NULL);
 238                 ctx->ctx_destroy(ctx);
 239                 yaca_free(ctx);
 240         }
 241
 242         return YACA_ERROR_NONE;
 243 }
 244
 245 API int yaca_get_output_length(const yaca_ctx_h ctx, size_t input_len, size_t *output_len)
 246 {
 247         if (ctx == YACA_CTX_NULL)
 248                 return YACA_ERROR_INVALID_ARGUMENT;
 249
 250         return ctx->get_output_length(ctx, input_len, output_len);
 251 }
 252
 253 API int yaca_memcmp(const void *first, const void *second, size_t len)
 254 {
 255         if (CRYPTO_memcmp(first, second, len) == 0)
 256                 return YACA_ERROR_NONE;
 257
 258         return YACA_ERROR_DATA_MISMATCH;
 259 }