whats wrong the decryption function is failing

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);

	// Encode the salt as base64
	BIO* bio = BIO_push(BIO_new(BIO_f_base64()), BIO_new(BIO_s_mem()));
	BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
	BIO_write(bio, salt.data(), saltSize);
    BIO_flush(bio);
    BUF_MEM* bptr;
	BIO_get_mem_ptr(bio, &bptr);
	std::vector<unsigned char> b64Salt(bptr->length);
	memcpy(b64Salt.data(), bptr->data, bptr->length);	
	OPENSSL_cleanse(salt.data(), saltSize);
    OPENSSL_cleanse(bptr->data, bptr->length);
	OPENSSL_cleanse(bptr, sizeof(*bptr));
	BIO_free_all(bio);

	// SHA256 the salt and password
	int b64SaltSize = b64Salt.size();
    unsigned char keyHash[SHA256_DIGEST_LENGTH];
    unsigned char ivHash[SHA256_DIGEST_LENGTH];
    SHA256(password.data(), passwordSize, keyHash);
    SHA256(b64Salt.data(),  b64SaltSize,  ivHash);

    std::vector<unsigned char> hashedKey(16);
    std::vector<unsigned char> hashedIv(16);

    bio = BIO_push(BIO_new(BIO_f_base64()), BIO_new(BIO_s_mem()));    
    BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
    if (BIO_write(bio, keyHash, SHA256_DIGEST_LENGTH) != SHA256_DIGEST_LENGTH ||
        BIO_flush(bio) != 1) 
    {
        BIO_free_all(bio);
        return false;
    }

    BIO_get_mem_ptr(bio, &bptr);
    std::memcpy(hashedKey.data(), bptr->data, 16);

    BIO_reset(bio);
    if (BIO_write(bio, ivHash, SHA256_DIGEST_LENGTH) != SHA256_DIGEST_LENGTH ||
        BIO_flush(bio) != 1)
    {
        BIO_free_all(bio);
        return false;
    }

    BIO_get_mem_ptr(bio, &bptr);
    std::memcpy(hashedIv.data(), bptr->data, 16);

    BIO_free_all(bio);

    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.data(), hashedIv.data()) != 1) 
    {
		OPENSSL_cleanse(data.data(), data.size());
        data.clear();
        EVP_CIPHER_CTX_free(ctx);
        return false;
    }

    OPENSSL_cleanse(hashedKey.data(), hashedKey.size());
    OPENSSL_cleanse(hashedIv.data(), hashedIv.size());

    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);

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

    // Generate random string to prepend
    unsigned char randomByte;
    RAND_bytes(&randomByte, 1);
    int prependStrSize = 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;
}



inline bool weakDecrypt2(QByteArray& data)
{
    if (data.isEmpty())
        return false;

    std::vector<unsigned char> decodedData(data.begin(), data.end());
	int decodedSize = decodedData.size();

    // Try different combinations of prepend string, password, and salt sizes
    const int possibleSizes[] = { 9, 12, 15 };

    for (int prependSize = 4; prependSize <= 10; ++prependSize)
    {
        for (int passwordSize : possibleSizes)
        {
            for (int saltSize : possibleSizes)
            {
                if (decodedSize < prependSize + passwordSize + saltSize)
                    continue;

                std::vector<unsigned char> password(passwordSize);
                std::vector<unsigned char> salt(saltSize);

                std::memcpy(password.data(), decodedData.data() + prependSize, passwordSize);
                std::memcpy(salt.data(),     decodedData.data() + prependSize + passwordSize, saltSize);

                // Encode the salt as base64
                std::vector<unsigned char> b64Salt(((saltSize + 3) / 4) * 3);
				BIO* bio = BIO_push(BIO_new(BIO_f_base64()), BIO_new(BIO_s_mem()));
				BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
				BIO_write(bio, salt.data(), saltSize);
				BIO_flush(bio);
				BUF_MEM* bptr;
				BIO_get_mem_ptr(bio, &bptr);
				std::memcpy(b64Salt.data(), bptr->data, bptr->length);
				OPENSSL_cleanse(bptr->data, bptr->length);
				OPENSSL_cleanse(bptr, sizeof(*bptr));
				BIO_free_all(bio);

                // SHA256 the password and salt (salt is used as base64)
                unsigned char keyHash[SHA256_DIGEST_LENGTH];
                unsigned char ivHash[SHA256_DIGEST_LENGTH];
                SHA256(password.data(), passwordSize,   keyHash);
                SHA256(b64Salt.data(),  b64Salt.size(), ivHash);

                std::vector<unsigned char> hashedKey(16);
                std::vector<unsigned char> hashedIv(16);

                bio = BIO_new(BIO_f_base64());
                BIO* mem = BIO_new(BIO_s_mem());
                BIO_push(bio, mem);
                BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);

                BIO_write(bio, keyHash, SHA256_DIGEST_LENGTH);
                BIO_flush(bio);
                BIO_get_mem_ptr(bio, &bptr);
                std::memcpy(hashedKey.data(), bptr->data, 16);

                BIO_reset(bio);
                BIO_write(bio, ivHash, SHA256_DIGEST_LENGTH);
                BIO_flush(bio);
                BIO_get_mem_ptr(bio, &bptr);
                std::memcpy(hashedIv.data(), bptr->data, 16);

                BIO_free_all(bio);

                // Attempt decryption
                const EVP_CIPHER* cipherType = EVP_aes_128_cbc();
                EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();

                if (!ctx)
                    continue;

                if (EVP_DecryptInit_ex(ctx, cipherType, NULL, hashedKey.data(), hashedIv.data()) != 1)
                {
                    EVP_CIPHER_CTX_free(ctx);
                    continue;
                }

                std::vector<unsigned char> decryptedData(decodedSize);
                int outLen1 = 0;
                if (EVP_DecryptUpdate(ctx, decryptedData.data(), &outLen1,
                    decodedData.data() + prependSize + passwordSize + saltSize,
                    decodedSize - prependSize - passwordSize - saltSize) != 1)
                {
                    EVP_CIPHER_CTX_free(ctx);
                    continue;
                }

                int outLen2 = 0;
                if (EVP_DecryptFinal_ex(ctx, decryptedData.data() + outLen1, &outLen2) != 1)
                {
                    EVP_CIPHER_CTX_free(ctx);
                    continue;
                }

                OPENSSL_cleanse(password.data(), password.size());
                OPENSSL_cleanse(b64Salt.data(),  b64Salt.size());
                EVP_CIPHER_CTX_free(ctx);

                // Decryption successful
                decryptedData.resize(outLen1 + outLen2);

                OPENSSL_cleanse(data.data(), data.size());
                data = QByteArray(reinterpret_cast<char*>(decryptedData.data()), decryptedData.size());

				OPENSSL_cleanse(decryptedData.data(), decryptedData.size());
                return true;
            }
        }
    }

    // Decryption failed
    return false;
}