crypto/property/property_parse.c

   1 /*
   2  * Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
   3  * Copyright (c) 2019, Oracle and/or its affiliates.  All rights reserved.
   4  *
   5  * Licensed under the Apache License 2.0 (the "License").  You may not use
   6  * this file except in compliance with the License.  You can obtain a copy
   7  * in the file LICENSE in the source distribution or at
   8  * https://www.openssl.org/source/license.html
   9  */
  10
  11 #include <string.h>
  12 #include <stdio.h>
  13 #include <stdarg.h>
  14 #include <openssl/err.h>
  15 #include "internal/propertyerr.h"
  16 #include "internal/property.h"
  17 #include "internal/ctype.h"
  18 #include "internal/nelem.h"
  19 #include "property_lcl.h"
  20 #include "e_os.h"
  21
  22 typedef enum {
  23     PROPERTY_TYPE_STRING, PROPERTY_TYPE_NUMBER,
  24     PROPERTY_TYPE_VALUE_UNDEFINED
  25 } PROPERTY_TYPE;
  26
  27 typedef enum {
  28     PROPERTY_OPER_EQ, PROPERTY_OPER_NE, PROPERTY_OVERRIDE
  29 } PROPERTY_OPER;
  30
  31 typedef struct {
  32     OSSL_PROPERTY_IDX name_idx;
  33     PROPERTY_TYPE type;
  34     PROPERTY_OPER oper;
  35     union {
  36         int64_t             int_val;     /* Signed integer */
  37         OSSL_PROPERTY_IDX   str_val;     /* String */
  38     } v;
  39 } PROPERTY_DEFINITION;
  40
  41 struct ossl_property_list_st {
  42     int n;
  43     PROPERTY_DEFINITION properties[1];
  44 };
  45
  46 static OSSL_PROPERTY_IDX ossl_property_true, ossl_property_false;
  47
  48 DEFINE_STACK_OF(PROPERTY_DEFINITION)
  49
  50 static const char *skip_space(const char *s)
  51 {
  52     while (ossl_isspace(*s))
  53         s++;
  54     return s;
  55 }
  56
  57 static int match_ch(const char *t[], char m)
  58 {
  59     const char *s = *t;
  60
  61     if (*s == m) {
  62         *t = skip_space(s + 1);
  63         return 1;
  64     }
  65     return 0;
  66 }
  67
  68 #define MATCH(s, m) match(s, m, sizeof(m) - 1)
  69
  70 static int match(const char *t[], const char m[], size_t m_len)
  71 {
  72     const char *s = *t;
  73
  74     if (strncasecmp(s, m, m_len) == 0) {
  75         *t = skip_space(s + m_len);
  76         return 1;
  77     }
  78     return 0;
  79 }
  80
  81 static int parse_name(OPENSSL_CTX *ctx, const char *t[], int create,
  82                       OSSL_PROPERTY_IDX *idx)
  83 {
  84     char name[100];
  85     int err = 0;
  86     size_t i = 0;
  87     const char *s = *t;
  88     int user_name = 0;
  89
  90     for (;;) {
  91         if (!ossl_isalpha(*s)) {
  92             PROPerr(PROP_F_PARSE_NAME, PROP_R_NOT_AN_IDENTIFIER);
  93             return 0;
  94         }
  95         do {
  96             if (i < sizeof(name) - 1)
  97                 name[i++] = ossl_tolower(*s);
  98             else
  99                 err = 1;
 100         } while (*++s == '_' || ossl_isalnum(*s));
 101         if (*s != '.')
 102             break;
 103         user_name = 1;
 104         if (i < sizeof(name) - 1)
 105             name[i++] = *s;
 106         else
 107             err = 1;
 108         s++;
 109     }
 110     name[i] = '\0';
 111     *t = skip_space(s);
 112     if (!err) {
 113         *idx = ossl_property_name(ctx, name, user_name && create);
 114         return 1;
 115     }
 116     PROPerr(PROP_F_PARSE_NAME, PROP_R_NAME_TOO_LONG);
 117     return 0;
 118 }
 119
 120 static int parse_number(const char *t[], PROPERTY_DEFINITION *res)
 121 {
 122     const char *s = *t;
 123     int64_t v = 0;
 124
 125     if (!ossl_isdigit(*s))
 126         return 0;
 127     do {
 128         v = v * 10 + (*s++ - '0');
 129     } while (ossl_isdigit(*s));
 130     if (!ossl_isspace(*s) && *s != '\0' && *s != ',') {
 131         PROPerr(PROP_F_PARSE_NUMBER, PROP_R_NOT_A_DECIMAL_DIGIT);
 132         return 0;
 133     }
 134     *t = skip_space(s);
 135     res->type = PROPERTY_TYPE_NUMBER;
 136     res->v.int_val = v;
 137     return 1;
 138 }
 139
 140 static int parse_hex(const char *t[], PROPERTY_DEFINITION *res)
 141 {
 142     const char *s = *t;
 143     int64_t v = 0;
 144
 145     if (!ossl_isxdigit(*s))
 146         return 0;
 147     do {
 148         v <<= 4;
 149         if (ossl_isdigit(*s))
 150             v += *s - '0';
 151         else
 152             v += ossl_tolower(*s) - 'a';
 153     } while (ossl_isxdigit(*++s));
 154     if (!ossl_isspace(*s) && *s != '\0' && *s != ',') {
 155         PROPerr(PROP_F_PARSE_HEX, PROP_R_NOT_AN_HEXADECIMAL_DIGIT);
 156         return 0;
 157     }
 158     *t = skip_space(s);
 159     res->type = PROPERTY_TYPE_NUMBER;
 160     res->v.int_val = v;
 161     return 1;
 162 }
 163
 164 static int parse_oct(const char *t[], PROPERTY_DEFINITION *res)
 165 {
 166     const char *s = *t;
 167     int64_t v = 0;
 168
 169     if (*s == '9' || *s == '8' || !ossl_isdigit(*s))
 170         return 0;
 171     do {
 172         v = (v << 3) + (*s - '0');
 173     } while (ossl_isdigit(*++s) && *s != '9' && *s != '8');
 174     if (!ossl_isspace(*s) && *s != '\0' && *s != ',') {
 175         PROPerr(PROP_F_PARSE_OCT, PROP_R_NOT_AN_OCTAL_DIGIT);
 176         return 0;
 177     }
 178     *t = skip_space(s);
 179     res->type = PROPERTY_TYPE_NUMBER;
 180     res->v.int_val = v;
 181     return 1;
 182 }
 183
 184 static int parse_string(OPENSSL_CTX *ctx, const char *t[], char delim,
 185                         PROPERTY_DEFINITION *res, const int create)
 186 {
 187     char v[1000];
 188     const char *s = *t;
 189     size_t i = 0;
 190     int err = 0;
 191
 192     while (*s != '\0' && *s != delim) {
 193         if (i < sizeof(v) - 1)
 194             v[i++] = *s;
 195         else
 196             err = 1;
 197         s++;
 198     }
 199     if (*s == '\0') {
 200         PROPerr(PROP_F_PARSE_STRING,
 201                 PROP_R_NO_MATCHING_STRING_DELIMETER);
 202         return 0;
 203     }
 204     v[i] = '\0';
 205     *t = skip_space(s + 1);
 206     if (err)
 207         PROPerr(PROP_F_PARSE_STRING, PROP_R_STRING_TOO_LONG);
 208     else
 209         res->v.str_val = ossl_property_value(ctx, v, create);
 210     res->type = PROPERTY_TYPE_STRING;
 211     return !err;
 212 }
 213
 214 static int parse_unquoted(OPENSSL_CTX *ctx, const char *t[],
 215                           PROPERTY_DEFINITION *res, const int create)
 216 {
 217     char v[1000];
 218     const char *s = *t;
 219     size_t i = 0;
 220     int err = 0;
 221
 222     if (*s == '\0' || *s == ',')
 223         return 0;
 224     while (ossl_isprint(*s) && !ossl_isspace(*s) && *s != ',') {
 225         if (i < sizeof(v) - 1)
 226             v[i++] = ossl_tolower(*s);
 227         else
 228             err = 1;
 229         s++;
 230     }
 231     if (!ossl_isspace(*s) && *s != '\0' && *s != ',') {
 232         PROPerr(PROP_F_PARSE_UNQUOTED, PROP_R_NOT_AN_ASCII_CHARACTER);
 233         return 0;
 234     }
 235     v[i] = 0;
 236     *t = skip_space(s);
 237     if (err)
 238         PROPerr(PROP_F_PARSE_UNQUOTED, PROP_R_STRING_TOO_LONG);
 239     else
 240         res->v.str_val = ossl_property_value(ctx, v, create);
 241     res->type = PROPERTY_TYPE_STRING;
 242     return !err;
 243 }
 244
 245 static int parse_value(OPENSSL_CTX *ctx, const char *t[],
 246                        PROPERTY_DEFINITION *res, int create)
 247 {
 248     const char *s = *t;
 249     int r = 0;
 250
 251     if (*s == '"' || *s == '\'') {
 252         s++;
 253         r = parse_string(ctx, &s, s[-1], res, create);
 254     } else if (*s == '+') {
 255         s++;
 256         r = parse_number(&s, res);
 257     } else if (*s == '-') {
 258         s++;
 259         r = parse_number(&s, res);
 260         res->v.int_val = -res->v.int_val;
 261     } else if (*s == '0' && s[1] == 'x') {
 262         s += 2;
 263         r = parse_hex(&s, res);
 264     } else if (*s == '0' && ossl_isdigit(s[1])) {
 265         s++;
 266         r = parse_oct(&s, res);
 267     } else if (ossl_isdigit(*s)) {
 268         return parse_number(t, res);
 269     } else if (ossl_isalpha(*s))
 270         return parse_unquoted(ctx, t, res, create);
 271     if (r)
 272         *t = s;
 273     return r;
 274 }
 275
 276 static int pd_compare(const PROPERTY_DEFINITION *const *p1,
 277                       const PROPERTY_DEFINITION *const *p2)
 278 {
 279     const PROPERTY_DEFINITION *pd1 = *p1;
 280     const PROPERTY_DEFINITION *pd2 = *p2;
 281
 282     if (pd1->name_idx < pd2->name_idx)
 283         return -1;
 284     if (pd1->name_idx > pd2->name_idx)
 285         return 1;
 286     return 0;
 287 }
 288
 289 static void pd_free(PROPERTY_DEFINITION *pd)
 290 {
 291     OPENSSL_free(pd);
 292 }
 293
 294 /*
 295  * Convert a stack of property definitions and queries into a fixed array.
 296  * The items are sorted for efficient query.  The stack is not freed.
 297  */
 298 static OSSL_PROPERTY_LIST *stack_to_property_list(STACK_OF(PROPERTY_DEFINITION)
 299                                                   *sk)
 300 {
 301     const int n = sk_PROPERTY_DEFINITION_num(sk);
 302     OSSL_PROPERTY_LIST *r;
 303     int i;
 304
 305     r = OPENSSL_malloc(sizeof(*r)
 306                        + (n <= 0 ? 0 : n - 1) * sizeof(r->properties[0]));
 307     if (r != NULL) {
 308         sk_PROPERTY_DEFINITION_sort(sk);
 309
 310         for (i = 0; i < n; i++)
 311             r->properties[i] = *sk_PROPERTY_DEFINITION_value(sk, i);
 312         r->n = n;
 313     }
 314     return r;
 315 }
 316
 317 OSSL_PROPERTY_LIST *ossl_parse_property(OPENSSL_CTX *ctx, const char *defn)
 318 {
 319     PROPERTY_DEFINITION *prop = NULL;
 320     OSSL_PROPERTY_LIST *res = NULL;
 321     STACK_OF(PROPERTY_DEFINITION) *sk;
 322     const char *s = defn;
 323     int done;
 324
 325     if (s == NULL || (sk = sk_PROPERTY_DEFINITION_new(&pd_compare)) == NULL)
 326         return NULL;
 327
 328     s = skip_space(s);
 329     done = *s == '\0';
 330     while (!done) {
 331         prop = OPENSSL_malloc(sizeof(*prop));
 332         if (prop == NULL)
 333             goto err;
 334         memset(&prop->v, 0, sizeof(prop->v));
 335         if (!parse_name(ctx, &s, 1, &prop->name_idx))
 336             goto err;
 337         prop->oper = PROPERTY_OPER_EQ;
 338         if (prop->name_idx == 0) {
 339             PROPerr(PROP_F_OSSL_PARSE_PROPERTY, PROP_R_PARSE_FAILED);
 340             goto err;
 341         }
 342         if (match_ch(&s, '=')) {
 343             if (!parse_value(ctx, &s, prop, 1)) {
 344                 PROPerr(PROP_F_OSSL_PARSE_PROPERTY, PROP_R_NO_VALUE);
 345                 goto err;
 346             }
 347         } else {
 348             /* A name alone means a true Boolean */
 349             prop->type = PROPERTY_TYPE_STRING;
 350             prop->v.str_val = ossl_property_true;
 351         }
 352
 353         if (!sk_PROPERTY_DEFINITION_push(sk, prop))
 354             goto err;
 355         prop = NULL;
 356         done = !match_ch(&s, ',');
 357     }
 358     if (*s != '\0') {
 359         PROPerr(PROP_F_OSSL_PARSE_PROPERTY, PROP_R_TRAILING_CHARACTERS);
 360         goto err;
 361     }
 362     res = stack_to_property_list(sk);
 363
 364 err:
 365     OPENSSL_free(prop);
 366     sk_PROPERTY_DEFINITION_pop_free(sk, &pd_free);
 367     return res;
 368 }
 369
 370 OSSL_PROPERTY_LIST *ossl_parse_query(OPENSSL_CTX *ctx, const char *s)
 371 {
 372     STACK_OF(PROPERTY_DEFINITION) *sk;
 373     OSSL_PROPERTY_LIST *res = NULL;
 374     PROPERTY_DEFINITION *prop = NULL;
 375     int done;
 376
 377     if (s == NULL || (sk = sk_PROPERTY_DEFINITION_new(&pd_compare)) == NULL)
 378         return NULL;
 379
 380     s = skip_space(s);
 381     done = *s == '\0';
 382     while (!done) {
 383         prop = OPENSSL_malloc(sizeof(*prop));
 384         if (prop == NULL)
 385             goto err;
 386         memset(&prop->v, 0, sizeof(prop->v));
 387
 388         if (match_ch(&s, '-')) {
 389             prop->oper = PROPERTY_OVERRIDE;
 390             if (!parse_name(ctx, &s, 0, &prop->name_idx))
 391                 goto err;
 392             goto skip_value;
 393         }
 394         if (!parse_name(ctx, &s, 0, &prop->name_idx))
 395             goto err;
 396
 397         if (match_ch(&s, '=')) {
 398             prop->oper = PROPERTY_OPER_EQ;
 399         } else if (MATCH(&s, "!=")) {
 400             prop->oper = PROPERTY_OPER_NE;
 401         } else {
 402             /* A name alone is a Boolean comparison for true */
 403             prop->oper = PROPERTY_OPER_EQ;
 404             prop->type = PROPERTY_TYPE_STRING;
 405             prop->v.str_val = ossl_property_true;
 406             goto skip_value;
 407         }
 408         if (!parse_value(ctx, &s, prop, 0))
 409             prop->type = PROPERTY_TYPE_VALUE_UNDEFINED;
 410
 411 skip_value:
 412         if (!sk_PROPERTY_DEFINITION_push(sk, prop))
 413             goto err;
 414         prop = NULL;
 415         done = !match_ch(&s, ',');
 416     }
 417     if (*s != '\0') {
 418         PROPerr(PROP_F_OSSL_PARSE_QUERY, PROP_R_TRAILING_CHARACTERS);
 419         goto err;
 420     }
 421     res = stack_to_property_list(sk);
 422
 423 err:
 424     OPENSSL_free(prop);
 425     sk_PROPERTY_DEFINITION_pop_free(sk, &pd_free);
 426     return res;
 427 }
 428
 429 int ossl_property_match(const OSSL_PROPERTY_LIST *query,
 430                         const OSSL_PROPERTY_LIST *defn)
 431 {
 432     const PROPERTY_DEFINITION *const q = query->properties;
 433     const PROPERTY_DEFINITION *const d = defn->properties;
 434     int i = 0, j = 0;
 435     PROPERTY_OPER oper;
 436
 437     while (i < query->n) {
 438         if ((oper = q[i].oper) == PROPERTY_OVERRIDE) {
 439             i++;
 440             continue;
 441         }
 442         if (j < defn->n) {
 443             if (q[i].name_idx > d[j].name_idx) {  /* skip defn, not in query */
 444                 j++;
 445                 continue;
 446             }
 447             if (q[i].name_idx == d[j].name_idx) { /* both in defn and query */
 448                 const int eq = q[i].type == d[j].type
 449                                && memcmp(&q[i].v, &d[j].v, sizeof(q[i].v)) == 0;
 450
 451                 if ((eq && oper != PROPERTY_OPER_EQ)
 452                     || (!eq && oper != PROPERTY_OPER_NE))
 453                     return 0;
 454                 i++;
 455                 j++;
 456                 continue;
 457             }
 458         }
 459
 460         /*
 461          * Handle the cases of a missing value and a query with no corresponding
 462          * definition.  The former fails for any comparision except inequality,
 463          * the latter is treated as a comparison against the Boolean false.
 464          */
 465         if (q[i].type == PROPERTY_TYPE_VALUE_UNDEFINED) {
 466             if (oper != PROPERTY_OPER_NE)
 467                 return 0;
 468         } else if (q[i].type != PROPERTY_TYPE_STRING
 469                    || (oper == PROPERTY_OPER_EQ
 470                        && q[i].v.str_val != ossl_property_false)
 471                    || (oper == PROPERTY_OPER_NE
 472                        && q[i].v.str_val == ossl_property_false)) {
 473             return 0;
 474         }
 475         i++;
 476     }
 477     return 1;
 478 }
 479
 480 void ossl_property_free(OSSL_PROPERTY_LIST *p)
 481 {
 482     OPENSSL_free(p);
 483 }
 484
 485 /*
 486  * Merge two property lists.
 487  * If there is a common name, the one from the first list is used.
 488  */
 489 OSSL_PROPERTY_LIST *ossl_property_merge(const OSSL_PROPERTY_LIST *a,
 490                                         const OSSL_PROPERTY_LIST *b)
 491 {
 492     const PROPERTY_DEFINITION *const ap = a->properties;
 493     const PROPERTY_DEFINITION *const bp = b->properties;
 494     const PROPERTY_DEFINITION *copy;
 495     OSSL_PROPERTY_LIST *r;
 496     int i, j, n;
 497     const int t = a->n + b->n;
 498
 499     r = OPENSSL_malloc(sizeof(*r)
 500                        + (t == 0 ? 0 : t - 1) * sizeof(r->properties[0]));
 501     if (r == NULL)
 502         return NULL;
 503
 504     for (i = j = n = 0; i < a->n || j < b->n; n++) {
 505         if (i >= a->n) {
 506             copy = &bp[j++];
 507         } else if (j >= b->n) {
 508             copy = &ap[i++];
 509         } else if (ap[i].name_idx <= bp[j].name_idx) {
 510             if (ap[i].name_idx == bp[j].name_idx)
 511                 j++;
 512             copy = &ap[i++];
 513         } else {
 514             copy = &bp[j++];
 515         }
 516         memcpy(r->properties + n, copy, sizeof(r->properties[0]));
 517     }
 518     r->n = n;
 519     if (n != t)
 520         r = OPENSSL_realloc(r, sizeof(*r) + (n - 1) * sizeof(r->properties[0]));
 521     return r;
 522 }
 523
 524 int ossl_property_parse_init(OPENSSL_CTX *ctx)
 525 {
 526     static const char *const predefined_names[] = {
 527         "default",      /* Being provided by the default built-in provider */
 528         "legacy",       /* Provided by the legacy provider */
 529         "provider",     /* Name of provider (default, fips) */
 530         "version",      /* Version number of this provider */
 531         "fips",         /* FIPS supporting provider */
 532         "engine",       /* An old style engine masquerading as a provider */
 533     };
 534     size_t i;
 535
 536     for (i = 0; i < OSSL_NELEM(predefined_names); i++)
 537         if (ossl_property_name(ctx, predefined_names[i], 1) == 0)
 538             goto err;
 539
 540     /* Pre-populate the two Boolean values */
 541     if ((ossl_property_true = ossl_property_value(ctx, "yes", 1)) == 0
 542         || (ossl_property_false = ossl_property_value(ctx, "no", 1)) == 0)
 543         goto err;
 544
 545     return 1;
 546 err:
 547     return 0;
 548 }