diff --git a/src/test/fuzz/deserialize.cpp b/src/test/fuzz/deserialize.cpp
index 06d5e36cd..9e8fce13b 100644
--- a/src/test/fuzz/deserialize.cpp
+++ b/src/test/fuzz/deserialize.cpp
@@ -1,184 +1,184 @@
 // Copyright (c) 2009-2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <addrdb.h>
 #include <addrman.h>
 #include <blockencodings.h>
 #include <chain.h>
 #include <coins.h>
 #include <compressor.h>
 #include <consensus/merkle.h>
 #include <net.h>
 #include <primitives/block.h>
 #include <protocol.h>
 #include <streams.h>
 #include <undo.h>
 #include <version.h>
 
 #include <test/fuzz/fuzz.h>
 
 #include <cstdint>
 #include <unistd.h>
 #include <vector>
 
-void test_one_input(std::vector<uint8_t> buffer) {
+void test_one_input(const std::vector<uint8_t> &buffer) {
     CDataStream ds(buffer, SER_NETWORK, INIT_PROTO_VERSION);
     try {
         int nVersion;
         ds >> nVersion;
         ds.SetVersion(nVersion);
     } catch (const std::ios_base::failure &e) {
         return;
     }
 
 #if BLOCK_DESERIALIZE
     try {
         CBlock block;
         ds >> block;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif TRANSACTION_DESERIALIZE
     try {
         CTransaction tx(deserialize, ds);
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif BLOCKLOCATOR_DESERIALIZE
     try {
         CBlockLocator bl;
         ds >> bl;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif BLOCKMERKLEROOT
     try {
         CBlock block;
         ds >> block;
         bool mutated;
         BlockMerkleRoot(block, &mutated);
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif ADDRMAN_DESERIALIZE
     try {
         CAddrMan am;
         ds >> am;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif BLOCKHEADER_DESERIALIZE
     try {
         CBlockHeader bh;
         ds >> bh;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif BANENTRY_DESERIALIZE
     try {
         CBanEntry be;
         ds >> be;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif TXUNDO_DESERIALIZE
     try {
         CTxUndo tu;
         ds >> tu;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif BLOCKUNDO_DESERIALIZE
     try {
         CBlockUndo bu;
         ds >> bu;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif COINS_DESERIALIZE
     try {
         Coin coin;
         ds >> coin;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif NETADDR_DESERIALIZE
     try {
         CNetAddr na;
         ds >> na;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif SERVICE_DESERIALIZE
     try {
         CService s;
         ds >> s;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif MESSAGEHEADER_DESERIALIZE
     CMessageHeader::MessageMagic pchMessageStart = {{0x00, 0x00, 0x00, 0x00}};
     try {
         CMessageHeader mh(pchMessageStart);
         ds >> mh;
         if (!mh.IsValidWithoutConfig(pchMessageStart)) {
             return;
         }
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif ADDRESS_DESERIALIZE
     try {
         CAddress a;
         ds >> a;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif INV_DESERIALIZE
     try {
         CInv i;
         ds >> i;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif BLOOMFILTER_DESERIALIZE
     try {
         CBloomFilter bf;
         ds >> bf;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif DISKBLOCKINDEX_DESERIALIZE
     try {
         CDiskBlockIndex dbi;
         ds >> dbi;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif TXOUTCOMPRESSOR_DESERIALIZE
     CTxOut to;
     CTxOutCompressor toc(to);
     try {
         ds >> toc;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif BLOCKTRANSACTIONS_DESERIALIZE
     try {
         BlockTransactions bt;
         ds >> bt;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #elif BLOCKTRANSACTIONSREQUEST_DESERIALIZE
     try {
         BlockTransactionsRequest btr;
         ds >> btr;
     } catch (const std::ios_base::failure &e) {
         return;
     }
 #else
 #error Need at least one fuzz target to compile
 #endif
 }
diff --git a/src/test/fuzz/fuzz.cpp b/src/test/fuzz/fuzz.cpp
index 9cf1dc05e..66d58cc81 100644
--- a/src/test/fuzz/fuzz.cpp
+++ b/src/test/fuzz/fuzz.cpp
@@ -1,73 +1,74 @@
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <test/fuzz/fuzz.h>
 
 #include <pubkey.h>
 
 #include <memory>
 #include <unistd.h>
 
 static bool read_stdin(std::vector<uint8_t> &data) {
     uint8_t buffer[1024];
     ssize_t length = 0;
     while ((length = read(STDIN_FILENO, buffer, 1024)) > 0) {
         data.insert(data.end(), buffer, buffer + length);
 
         if (data.size() > (1 << 20)) {
             return false;
         }
     }
     return length == 0;
 }
 
 static void initialize() {
     const static auto verify_handle = std::make_unique<ECCVerifyHandle>();
 }
 
 // This function is used by libFuzzer
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
-    test_one_input(std::vector<uint8_t>(data, data + size));
+    const std::vector<uint8_t> input(data, data + size);
+    test_one_input(input);
     return 0;
 }
 
 // This function is used by libFuzzer
 extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv) {
     initialize();
     return 0;
 }
 
 // Disabled under WIN32 due to clash with Cygwin's WinMain.
 #ifndef WIN32
 // Declare main(...) "weak" to allow for libFuzzer linking. libFuzzer provides
 // the main(...) function.
 __attribute__((weak))
 #endif
 int main(int argc, char **argv) {
     initialize();
 #ifdef __AFL_INIT
     // Enable AFL deferred forkserver mode. Requires compilation using
     // afl-clang-fast++. See fuzzing.md for details.
     __AFL_INIT();
 #endif
 
 #ifdef __AFL_LOOP
     // Enable AFL persistent mode. Requires compilation using afl-clang-fast++.
     // See fuzzing.md for details.
     while (__AFL_LOOP(1000)) {
         std::vector<uint8_t> buffer;
         if (!read_stdin(buffer)) {
             continue;
         }
         test_one_input(buffer);
     }
 #else
     std::vector<uint8_t> buffer;
     if (!read_stdin(buffer)) {
         return 0;
     }
     test_one_input(buffer);
 #endif
     return 0;
 }
diff --git a/src/test/fuzz/fuzz.h b/src/test/fuzz/fuzz.h
index ac50c102f..34e49b35e 100644
--- a/src/test/fuzz/fuzz.h
+++ b/src/test/fuzz/fuzz.h
@@ -1,13 +1,13 @@
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_TEST_FUZZ_FUZZ_H
 #define BITCOIN_TEST_FUZZ_FUZZ_H
 
 #include <cstdint>
 #include <vector>
 
-void test_one_input(std::vector<uint8_t> buffer);
+void test_one_input(const std::vector<uint8_t> &buffer);
 
 #endif // BITCOIN_TEST_FUZZ_FUZZ_H
diff --git a/src/test/fuzz/script_flags.cpp b/src/test/fuzz/script_flags.cpp
index c092c32b5..823ab5ff8 100644
--- a/src/test/fuzz/script_flags.cpp
+++ b/src/test/fuzz/script_flags.cpp
@@ -1,78 +1,78 @@
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <script/interpreter.h>
 #include <streams.h>
 #include <version.h>
 
 #include <test/fuzz/fuzz.h>
 
 /** Flags that are not forbidden by an assert */
 static bool IsValidFlagCombination(uint32_t flags);
 
-void test_one_input(std::vector<uint8_t> buffer) {
+void test_one_input(const std::vector<uint8_t> &buffer) {
     CDataStream ds(buffer, SER_NETWORK, INIT_PROTO_VERSION);
     try {
         int nVersion;
         ds >> nVersion;
         ds.SetVersion(nVersion);
     } catch (const std::ios_base::failure &) {
         return;
     }
 
     try {
         const CTransaction tx(deserialize, ds);
         const PrecomputedTransactionData txdata(tx);
 
         uint32_t verify_flags;
         ds >> verify_flags;
 
         if (!IsValidFlagCombination(verify_flags)) {
             return;
         }
 
         uint32_t fuzzed_flags;
         ds >> fuzzed_flags;
 
         for (unsigned int i = 0; i < tx.vin.size(); ++i) {
             CTxOut prevout;
             ds >> prevout;
 
             const TransactionSignatureChecker checker{&tx, i, prevout.nValue,
                                                       txdata};
 
             ScriptError serror;
             const bool ret =
                 VerifyScript(tx.vin.at(i).scriptSig, prevout.scriptPubKey,
                              verify_flags, checker, &serror);
             assert(ret == (serror == ScriptError::OK));
 
             // Verify that removing flags from a passing test or adding flags to
             // a failing test does not change the result
             if (ret) {
                 verify_flags &= ~fuzzed_flags;
             } else {
                 verify_flags |= fuzzed_flags;
             }
             if (!IsValidFlagCombination(verify_flags)) {
                 return;
             }
 
             ScriptError serror_fuzzed;
             const bool ret_fuzzed =
                 VerifyScript(tx.vin.at(i).scriptSig, prevout.scriptPubKey,
                              verify_flags, checker, &serror_fuzzed);
             assert(ret_fuzzed == (serror_fuzzed == ScriptError::OK));
 
             assert(ret_fuzzed == ret);
         }
     } catch (const std::ios_base::failure &) {
         return;
     }
 }
 
 static bool IsValidFlagCombination(uint32_t flags) {
     // If the CLEANSTACK flag is set, then P2SH should also be set
     return (~flags & SCRIPT_VERIFY_CLEANSTACK) || (flags & SCRIPT_VERIFY_P2SH);
 }