crypto/blake2/blake2b.c:103: error: BUFFER_OVERRUN_L2
  Offset added: [8, 64] (⇐ [0, 56] + 8) Size: 8 by call to `blake2b_init_param`.
Showing all 7 steps of the trace


crypto/blake2/blake2b.c:89:1: Array declaration
87.   
88.   /* Initialize the hashing context.  Always returns 1. */
89. > int BLAKE2b_Init(BLAKE2B_CTX *c)
90.   {
91.       BLAKE2B_PARAM P[1];

crypto/blake2/blake2b.c:103:5: Call
101.       memset(P->salt,     0, sizeof(P->salt));
102.       memset(P->personal, 0, sizeof(P->personal));
103.       blake2b_init_param(c, P);
           ^
104.       return 1;
105.   }

crypto/blake2/blake2b.c:83:10: Assignment
  81.       assert(sizeof(BLAKE2B_PARAM) == 64);
  82.       /* IV XOR ParamBlock */
  83.       for (i = 0; i < 8; ++i) {
                 ^
  84.           S->h[i] ^= load64(p + sizeof(S->h[i]) * i);
  85.       }

crypto/blake2/blake2b.c:84:20: Call
  82.       /* IV XOR ParamBlock */
  83.       for (i = 0; i < 8; ++i) {
  84.           S->h[i] ^= load64(p + sizeof(S->h[i]) * i);
                           ^
  85.       }
  86.   }

crypto/blake2/blake2_impl.h:41:1: <Length trace>
39.   }
40.   
41. > static ossl_inline uint64_t load64(const uint8_t *src)
42.   {
43.       const union {

crypto/blake2/blake2_impl.h:41:1: Parameter `*src`
    39.   }
    40.   
    41. > static ossl_inline uint64_t load64(const uint8_t *src)
    42.   {
    43.       const union {

crypto/blake2/blake2_impl.h:50:9: Array access: Offset added: [8, 64] (⇐ [0, 56] + 8) Size: 8 by call to `blake2b_init_param` 
    48.       if (is_endian.little) {
    49.           uint64_t w;
    50.           memcpy(&w, src, sizeof(w));
                  ^
    51.           return w;
    52.       } else {

static ossl_inline uint64_t load64(const uint8_t *src)
{
    const union {
        long one;
        char little;
    } is_endian = { 1 };
    if (is_endian.little) {
        uint64_t w;
        memcpy(&w, src, sizeof(w));
        return w;
    } else {
        uint64_t w = ((uint64_t)src[0])
                   | ((uint64_t)src[1] <<  8)
                   | ((uint64_t)src[2] << 16)
                   | ((uint64_t)src[3] << 24)
                   | ((uint64_t)src[4] << 32)
                   | ((uint64_t)src[5] << 40)
                   | ((uint64_t)src[6] << 48)
                   | ((uint64_t)src[7] << 56);
        return w;
    }
}
['int BLAKE2b_Init(BLAKE2B_CTX *c)\n{\n    BLAKE2B_PARAM P[1];\n    P->digest_length = BLAKE2B_DIGEST_LENGTH;\n    P->key_length    = 0;\n    P->fanout        = 1;\n    P->depth         = 1;\n    store32(P->leaf_length, 0);\n    store64(P->node_offset, 0);\n    P->node_depth    = 0;\n    P->inner_length  = 0;\n    memset(P->reserved, 0, sizeof(P->reserved));\n    memset(P->salt,     0, sizeof(P->salt));\n    memset(P->personal, 0, sizeof(P->personal));\n    blake2b_init_param(c, P);\n    return 1;\n}', 'static void blake2b_init_param(BLAKE2B_CTX *S, const BLAKE2B_PARAM *P)\n{\n    size_t i;\n    const uint8_t *p = (const uint8_t *)(P);\n    blake2b_init0(S);\n    assert(sizeof(BLAKE2B_PARAM) == 64);\n    for (i = 0; i < 8; ++i) {\n        S->h[i] ^= load64(p + sizeof(S->h[i]) * i);\n    }\n}', 'static ossl_inline uint64_t load64(const uint8_t *src)\n{\n    const union {\n        long one;\n        char little;\n    } is_endian = { 1 };\n    if (is_endian.little) {\n        uint64_t w;\n        memcpy(&w, src, sizeof(w));\n        return w;\n    } else {\n        uint64_t w = ((uint64_t)src[0])\n                   | ((uint64_t)src[1] <<  8)\n                   | ((uint64_t)src[2] << 16)\n                   | ((uint64_t)src[3] << 24)\n                   | ((uint64_t)src[4] << 32)\n                   | ((uint64_t)src[5] << 40)\n                   | ((uint64_t)src[6] << 48)\n                   | ((uint64_t)src[7] << 56);\n        return w;\n    }\n}']