test/property_test.c:310: error: BUFFER_OVERRUN_L3
  Offset: [2, +oo] (⇐ [1, +oo] + 1) Size: [1, 37] by call to `ossl_method_store_add`.
Showing all 23 steps of the trace


test/property_test.c:276:9: Array declaration
274.           char *impl;
275.       } impls[] = {
276.           { 1, "fast=no, colour=green", "a" },
               ^
277.           { 1, "fast, colour=blue", "b" },
278.           { 1, "", "-" },

test/property_test.c:310:14: Call
308.   
309.       for (i = 0; i < OSSL_NELEM(impls); i++)
310.           if (!TEST_true(ossl_method_store_add(store, impls[i].nid, impls[i].prop,
                    ^
311.                                                impls[i].impl, NULL))) {
312.               TEST_note("iteration %zd", i + 1);

crypto/property/property.c:176:1: Parameter `*properties`
  174.   }
  175.   
  176. > int ossl_method_store_add(OSSL_METHOD_STORE *store,
  177.                             int nid, const char *properties,
  178.                             void *method, void (*method_destruct)(void *))

crypto/property/property.c:205:28: Call
  203.       ossl_method_cache_flush(store, nid);
  204.       if ((impl->properties = ossl_prop_defn_get(store->ctx, properties)) == NULL) {
  205.           impl->properties = ossl_parse_property(store->ctx, properties);
                                    ^
  206.           if (impl->properties == NULL)
  207.               goto err;

crypto/property/property_parse.c:322:1: Parameter `*defn`
    320.   }
    321.   
    322. > OSSL_PROPERTY_LIST *ossl_parse_property(OPENSSL_CTX *ctx, const char *defn)
    323.   {
    324.       PROPERTY_DEFINITION *prop = NULL;

crypto/property/property_parse.c:327:5: Assignment
    325.       OSSL_PROPERTY_LIST *res = NULL;
    326.       STACK_OF(PROPERTY_DEFINITION) *sk;
    327.       const char *s = defn;
               ^
    328.       int done;
    329.   

crypto/property/property_parse.c:333:9: Call
    331.           return NULL;
    332.   
    333.       s = skip_space(s);
                   ^
    334.       done = *s == '\0';
    335.       while (!done) {

crypto/property/property_parse.c:52:1: Parameter `*s`
      50.   DEFINE_STACK_OF(PROPERTY_DEFINITION)
      51.   
      52. > static const char *skip_space(const char *s)
      53.   {
      54.       while (ossl_isspace(*s))

crypto/property/property_parse.c:56:5: Assignment
      54.       while (ossl_isspace(*s))
      55.           s++;
      56.       return s;
                ^
      57.   }
      58.   

crypto/property/property_parse.c:333:5: Assignment
    331.           return NULL;
    332.   
    333.       s = skip_space(s);
               ^
    334.       done = *s == '\0';
    335.       while (!done) {

crypto/property/property_parse.c:341:14: Call
    339.           memset(&prop->v, 0, sizeof(prop->v));
    340.           prop->optional = 0;
    341.           if (!parse_name(ctx, &s, 1, &prop->name_idx))
                        ^
    342.               goto err;
    343.           prop->oper = PROPERTY_OPER_EQ;

crypto/property/property_parse.c:83:1: Parameter `**t`
      81.   }
      82.   
      83. > static int parse_name(OPENSSL_CTX *ctx, const char *t[], int create,
      84.                         OSSL_PROPERTY_IDX *idx)
      85.   {

crypto/property/property_parse.c:348:13: Call
    346.               goto err;
    347.           }
    348.           if (match_ch(&s, '=')) {
                       ^
    349.               if (!parse_value(ctx, &s, prop, 1)) {
    350.                   PROPerr(PROP_F_OSSL_PARSE_PROPERTY, PROP_R_NO_VALUE);

crypto/property/property_parse.c:59:1: Parameter `**t`
      57.   }
      58.   
      59. > static int match_ch(const char *t[], char m)
      60.   {
      61.       const char *s = *t;

crypto/property/property_parse.c:349:18: Call
    347.           }
    348.           if (match_ch(&s, '=')) {
    349.               if (!parse_value(ctx, &s, prop, 1)) {
                            ^
    350.                   PROPerr(PROP_F_OSSL_PARSE_PROPERTY, PROP_R_NO_VALUE);
    351.                   goto err;

crypto/property/property_parse.c:247:1: Parameter `**t`
      245.   }
      246.   
      247. > static int parse_value(OPENSSL_CTX *ctx, const char *t[],
      248.                          PROPERTY_DEFINITION *res, int create)
      249.   {

crypto/property/property_parse.c:250:5: Assignment
      248.                          PROPERTY_DEFINITION *res, int create)
      249.   {
      250.       const char *s = *t;
                 ^
      251.       int r = 0;
      252.   

crypto/property/property_parse.c:267:9: Assignment
      265.           r = parse_hex(&s, res);
      266.       } else if (*s == '0' && ossl_isdigit(s[1])) {
      267.           s++;
                     ^
      268.           r = parse_oct(&s, res);
      269.       } else if (ossl_isdigit(*s)) {

crypto/property/property_parse.c:268:13: Call
      266.       } else if (*s == '0' && ossl_isdigit(s[1])) {
      267.           s++;
      268.           r = parse_oct(&s, res);
                         ^
      269.       } else if (ossl_isdigit(*s)) {
      270.           return parse_number(t, res);

crypto/property/property_parse.c:166:1: <Length trace>
164.   }
165.   
166. > static int parse_oct(const char *t[], PROPERTY_DEFINITION *res)
167.   {
168.       const char *s = *t;

crypto/property/property_parse.c:166:1: Parameter `**t`
        164.   }
        165.   
        166. > static int parse_oct(const char *t[], PROPERTY_DEFINITION *res)
        167.   {
        168.       const char *s = *t;

crypto/property/property_parse.c:168:5: Assignment
        166.   static int parse_oct(const char *t[], PROPERTY_DEFINITION *res)
        167.   {
        168.       const char *s = *t;
                   ^
        169.       int64_t v = 0;
        170.   

crypto/property/property_parse.c:175:14: Array access: Offset: [2, +oo] (⇐ [1, +oo] + 1) Size: [1, 37] by call to `ossl_method_store_add` 
        173.       do {
        174.           v = (v << 3) + (*s - '0');
        175.       } while (ossl_isdigit(*++s) && *s != '9' && *s != '8');
                            ^
        176.       if (!ossl_isspace(*s) && *s != '\0' && *s != ',') {
        177.           PROPerr(PROP_F_PARSE_OCT, PROP_R_NOT_AN_OCTAL_DIGIT);
