src/vine-security.cpp

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdbool.h>
  18
  19 #include "vine-security.h"
  20 #include "vine-log.h"
  21 #include "vine-utils.h"
  22
  23 typedef struct {
  24         vine_security_type_e type;
  25         int flags;
  26         vine_security_tls_version_e tls_version;
  27         char *ca_path;
  28         char *cert_path;
  29         char *key_path;
  30         char *psk;
  31 } vine_security_s;
  32
  33 int _vine_security_create(vine_security_h *security)
  34 {
  35         RET_VAL_IF(security == NULL, VINE_ERROR_INVALID_PARAMETER, "security is NULL");
  36
  37         vine_security_s *s =
  38                 (vine_security_s *)calloc(1, sizeof(vine_security_s));
  39         RET_VAL_IF(s == NULL, VINE_ERROR_OUT_OF_MEMORY, "Out of memory");
  40
  41         s->type = VINE_SECURITY_TYPE_NONE;
  42         s->flags = 0;
  43         s->tls_version = VINE_SECURITY_TLS_VERSION_DEFAULT;
  44         s->cert_path = NULL;
  45         s->key_path = NULL;
  46         s->psk = NULL;
  47
  48         *security = s;
  49
  50         return VINE_ERROR_NONE;
  51 }
  52
  53 int _vine_security_clone(vine_security_h *cloned, vine_security_h origin)
  54 {
  55         RET_VAL_IF(cloned == NULL, VINE_ERROR_INVALID_PARAMETER, "cloned is NULL");
  56         if (origin == NULL) {
  57                 VINE_LOGD("origin is NULL");
  58                 *cloned = NULL;
  59                 return VINE_ERROR_NONE;
  60         }
  61         RET_VAL_IF(origin == NULL, VINE_ERROR_INVALID_PARAMETER, "origin is NULL");
  62
  63         vine_security_s *src = (vine_security_s *)origin;
  64         vine_security_s *dest =
  65                 (vine_security_s *)calloc(1, sizeof(vine_security_s));
  66         RET_VAL_IF(dest == NULL, VINE_ERROR_OUT_OF_MEMORY, "Out of memory");
  67
  68         dest->type = src->type;
  69         dest->flags = src->flags;
  70         dest->tls_version = src->tls_version;
  71         dest->ca_path = STRDUP(src->ca_path);
  72         dest->cert_path = STRDUP(src->cert_path);
  73         dest->key_path = STRDUP(src->key_path);
  74         dest->psk = STRDUP(src->psk);
  75
  76         *cloned = dest;
  77         return VINE_ERROR_NONE;
  78 }
  79
  80 int _vine_security_destroy(vine_security_h security)
  81 {
  82         RET_VAL_IF(security == NULL, VINE_ERROR_INVALID_PARAMETER, "security is NULL");
  83
  84         vine_security_s *s = (vine_security_s *)security;
  85
  86         free(s->cert_path);
  87         free(s->key_path);
  88         free(s->psk);
  89         free(s);
  90
  91         return VINE_ERROR_NONE;
  92 }
  93
  94 int _vine_security_set_type(vine_security_h security, vine_security_type_e type)
  95 {
  96         RET_VAL_IF(security == NULL, VINE_ERROR_INVALID_PARAMETER, "security is NULL");
  97         RET_VAL_IF(type < VINE_SECURITY_TYPE_NONE || type > VINE_SECURITY_TYPE_PSK_OVER_TLS,
  98                         VINE_ERROR_INVALID_PARAMETER, "type is invalid.");
  99
 100         vine_security_s *s = (vine_security_s *)security;
 101         s->type = type;
 102
 103         return VINE_ERROR_NONE;
 104 }
 105
 106 int _vine_security_get_type(vine_security_h security, vine_security_type_e *type)
 107 {
 108         RET_VAL_IF(security == NULL, VINE_ERROR_INVALID_PARAMETER, "security is NULL");
 109         RET_VAL_IF(type == NULL, VINE_ERROR_INVALID_PARAMETER, "type is NULL");
 110
 111         vine_security_s *s = (vine_security_s *)security;
 112         *type = s->type;
 113
 114         return VINE_ERROR_NONE;
 115 }
 116
 117 int _vine_security_set_tls_version(vine_security_h security,
 118                 vine_security_tls_version_e version)
 119 {
 120         RET_VAL_IF(security == NULL, VINE_ERROR_INVALID_PARAMETER, "security is NULL");
 121         RET_VAL_IF(version < VINE_SECURITY_TLS_VERSION_DEFAULT
 122                         || version > VINE_SECURITY_TLS_VERSION_1_3,
 123                         VINE_ERROR_INVALID_PARAMETER, "version is invalid.");
 124
 125         vine_security_s *s = (vine_security_s *)security;
 126         s->tls_version = version;
 127
 128         return VINE_ERROR_NONE;
 129 }
 130
 131 int _vine_security_get_tls_version(vine_security_h security,
 132                 vine_security_tls_version_e *version)
 133 {
 134         RET_VAL_IF(security == NULL, VINE_ERROR_INVALID_PARAMETER, "security is NULL");
 135         RET_VAL_IF(version == NULL, VINE_ERROR_INVALID_PARAMETER, "version is invalid.");
 136
 137         vine_security_s *s = (vine_security_s *)security;
 138         *version = s->tls_version;
 139
 140         return VINE_ERROR_NONE;
 141 }
 142
 143 int _vine_security_set_verification_flags(vine_security_h security, int flags)
 144 {
 145         RET_VAL_IF(security == NULL, VINE_ERROR_INVALID_PARAMETER, "security is NULL");
 146         RET_VAL_IF(flags < 0
 147                         || flags > (VINE_SECURITY_VERIFICATION_FLAG_ALLOW_SELF_SIGNED
 148                                 | VINE_SECURITY_VERIFICATION_FLAG_SKIP_HOST_NAME_CHECK),
 149                         VINE_ERROR_INVALID_PARAMETER, "flags are invalid.");
 150
 151         vine_security_s *s = (vine_security_s *)security;
 152         s->flags = flags;
 153
 154         return VINE_ERROR_NONE;
 155 }
 156
 157 int _vine_security_get_verification_flags(vine_security_h security, int *flags)
 158 {
 159         RET_VAL_IF(security == NULL, VINE_ERROR_INVALID_PARAMETER, "security is NULL");
 160         RET_VAL_IF(flags == NULL, VINE_ERROR_INVALID_PARAMETER, "flags is NULL");
 161
 162         vine_security_s *s = (vine_security_s *)security;
 163         *flags = s->flags;
 164
 165         return VINE_ERROR_NONE;
 166 }
 167
 168 int _vine_security_set_ca_path(vine_security_h security, const char *ca_path)
 169 {
 170         RET_VAL_IF(security == NULL, VINE_ERROR_INVALID_PARAMETER, "security is NULL");
 171         RET_VAL_IF(ca_path == NULL, VINE_ERROR_INVALID_PARAMETER, "ca_path is NULL");
 172
 173         vine_security_s *s = (vine_security_s *)security;
 174         if (s->ca_path)
 175                 free(s->ca_path);
 176         s->ca_path = STRDUP(ca_path);
 177
 178         return VINE_ERROR_NONE;
 179 }
 180
 181 int _vine_security_get_ca_path(vine_security_h security, char **ca_path)
 182 {
 183         RET_VAL_IF(security == NULL, VINE_ERROR_INVALID_PARAMETER, "security is NULL");
 184         RET_VAL_IF(ca_path == NULL, VINE_ERROR_INVALID_PARAMETER, "ca_path is NULL");
 185
 186         vine_security_s *s = (vine_security_s *)security;
 187         *ca_path = STRDUP(s->ca_path);
 188
 189         return VINE_ERROR_NONE;
 190 }
 191
 192 int _vine_security_set_cert_path(vine_security_h security, const char *cert_path)
 193 {
 194         RET_VAL_IF(security == NULL, VINE_ERROR_INVALID_PARAMETER, "security is NULL");
 195         RET_VAL_IF(cert_path == NULL, VINE_ERROR_INVALID_PARAMETER, "cert_path is NULL");
 196
 197         vine_security_s *s = (vine_security_s *)security;
 198         if (s->cert_path)
 199                 free(s->cert_path);
 200         s->cert_path = STRDUP(cert_path);
 201
 202         return VINE_ERROR_NONE;
 203 }
 204
 205 int _vine_security_get_cert_path(vine_security_h security, char **cert_path)
 206 {
 207         RET_VAL_IF(security == NULL, VINE_ERROR_INVALID_PARAMETER, "security is NULL");
 208         RET_VAL_IF(cert_path == NULL, VINE_ERROR_INVALID_PARAMETER, "cert_path is NULL");
 209
 210         vine_security_s *s = (vine_security_s *)security;
 211         *cert_path = STRDUP(s->cert_path);
 212
 213         return VINE_ERROR_NONE;
 214 }
 215
 216 int _vine_security_set_private_key(vine_security_h security, const char *key_path)
 217 {
 218         RET_VAL_IF(security == NULL, VINE_ERROR_INVALID_PARAMETER, "security is NULL");
 219         RET_VAL_IF(key_path == NULL, VINE_ERROR_INVALID_PARAMETER, "key_path is NULL");
 220
 221         vine_security_s *s = (vine_security_s *)security;
 222         if (s->key_path)
 223                 free(s->key_path);
 224         s->key_path = STRDUP(key_path);
 225
 226         return VINE_ERROR_NONE;
 227 }
 228
 229 int _vine_security_get_private_key(vine_security_h security, char **key_path)
 230 {
 231         RET_VAL_IF(security == NULL, VINE_ERROR_INVALID_PARAMETER, "security is NULL");
 232         RET_VAL_IF(key_path == NULL, VINE_ERROR_INVALID_PARAMETER, "key_path is NULL");
 233
 234         vine_security_s *s = (vine_security_s *)security;
 235         *key_path = STRDUP(s->key_path);
 236
 237         return VINE_ERROR_NONE;
 238 }
 239
 240 int _vine_security_set_psk(vine_security_h security, const char *psk)
 241 {
 242         RET_VAL_IF(security == NULL, VINE_ERROR_INVALID_PARAMETER, "security is NULL");
 243         RET_VAL_IF(psk == NULL, VINE_ERROR_INVALID_PARAMETER, "psk is NULL");
 244
 245         vine_security_s *s = (vine_security_s *)security;
 246         if (s->psk)
 247                 free(s->psk);
 248         s->psk = STRDUP(psk);
 249
 250         return VINE_ERROR_NONE;
 251 }
 252
 253 int _vine_security_get_psk(vine_security_h security, char **psk)
 254 {
 255         RET_VAL_IF(security == NULL, VINE_ERROR_INVALID_PARAMETER, "security is NULL");
 256         RET_VAL_IF(psk == NULL, VINE_ERROR_INVALID_PARAMETER, "psk is NULL");
 257
 258         vine_security_s *s = (vine_security_s *)security;
 259         *psk = STRDUP(s->psk);
 260         return VINE_ERROR_NONE;
 261 }