when the function finishes i get this error:
HEAP CORRUPTION DETECTED: after Normal block (#5963) at 0x000001AB99D54B60.
CRT detected that the application wrote to memory after end of heap buffer.

whats wrong?

inline bool weakEncrypt2(QByteArray& data)
{  
    VM_S_START // C898

    if (data.isEmpty())
        return false;

    // Generate the password
    unsigned char random_byte;
    RAND_bytes(&random_byte, 1);
    int passwordSize = 9; // +(random_byte % 3) * 3; // Random size of 9, 12, or 15
    std::vector<unsigned char> password(passwordSize);
    RAND_bytes(password.data(), passwordSize);
    
	// Generate a random salt  
    RAND_bytes(&random_byte, 1);
    int saltSize = 9; // +(random_byte % 3) * 3; // Random size of 9, 12, or 15
    std::vector<unsigned char> salt(saltSize);
    RAND_bytes(salt.data(), saltSize);

    int b64SaltSize = 4 * ((saltSize + 2) / 3);
    std::vector<unsigned char> b64Salt(b64SaltSize);
    EVP_EncodeBlock(b64Salt.data(), salt.data(), saltSize);

    // SHA256 the password and salt without Base64 encoding
    unsigned char keyHash[SHA256_DIGEST_LENGTH];
    unsigned char ivHash[SHA256_DIGEST_LENGTH];
    SHA256(password.data(), passwordSize, keyHash);
    SHA256(b64Salt.data(),  b64SaltSize,  ivHash);

    // Derive the AES key and IV by taking the first 16 bytes of the hash
    unsigned char hashedKey[16];
    unsigned char hashedIv[16];
    std::memcpy(hashedKey, keyHash, 16);
    std::memcpy(hashedIv, ivHash, 16);

    OPENSSL_cleanse(keyHash, sizeof(keyHash));
    OPENSSL_cleanse(ivHash, sizeof(ivHash));

    std::vector<unsigned char> cipherBuf(data.size() + EVP_MAX_BLOCK_LENGTH);
    const EVP_CIPHER* cipherType = EVP_aes_128_cbc();
    EVP_CIPHER_CTX* ctx          = EVP_CIPHER_CTX_new();
    
    if (!ctx)
        return false;

    if (EVP_EncryptInit_ex(ctx, cipherType, NULL, hashedKey, hashedIv) != 1) 
    {
		OPENSSL_cleanse(data.data(), data.size());
        data.clear();
        EVP_CIPHER_CTX_free(ctx);
        return false;
    }

    // Clean up key and IV after use
    OPENSSL_cleanse(hashedKey, sizeof(hashedKey));
    OPENSSL_cleanse(hashedIv, sizeof(hashedIv));

    int outLength1 = 0;
    if (EVP_EncryptUpdate(ctx, cipherBuf.data(), &outLength1, 
                          reinterpret_cast<unsigned char*>(data.data()), data.size()) != 1)
    {
        OPENSSL_cleanse(data.data(), data.size());
        data.clear();
        EVP_CIPHER_CTX_free(ctx);
        return false;
    }

    int outLength2 = 0;
    if (EVP_EncryptFinal_ex(ctx, cipherBuf.data() + outLength1, &outLength2) != 1)
    {
        OPENSSL_cleanse(data.data(), data.size());
        data.clear();
        EVP_CIPHER_CTX_free(ctx);
        return false;
    }

    EVP_CIPHER_CTX_free(ctx);

	cipherBuf.resize(outLength1 + outLength2);

	OPENSSL_cleanse(data.data(), data.size());
	data.clear();

    // Generate random string to prepend
    unsigned char randomByte;
    RAND_bytes(&randomByte, 1);
    int prependStrSize = 4; // 4 + (randomByte % 7); // Random size between 4 and 10
    std::vector<unsigned char> prependStr(prependStrSize);
    RAND_bytes(prependStr.data(), prependStrSize);

    data.append(prependStr);
    data.append(password);
    data.append(salt);
    data.append(cipherBuf);

    VM_S_END // C898

    return true;
}