Commit 3590b27c authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/berrange/tags/autofree-pull-request' into staging 



require newer glib2 to enable autofree'ing of stack variables exiting scope

* Bump minium glib2 version to 2.48
* Convert much of the crypto code to use automatic memory free functions

# gpg: Signature made Thu 22 Aug 2019 11:51:59 BST
# gpg:                using RSA key DAF3A6FDB26B62912D0E8E3FBE86EBB415104FDF
# gpg: Good signature from "Daniel P. Berrange <dan@berrange.com>" [full]
# gpg:                 aka "Daniel P. Berrange <berrange@redhat.com>" [full]
# Primary key fingerprint: DAF3 A6FD B26B 6291 2D0E  8E3F BE86 EBB4 1510 4FDF

* remotes/berrange/tags/autofree-pull-request:
  crypto: use auto cleanup for many stack variables
  crypto: define cleanup functions for use with g_autoptr
  glib: bump min required glib library version to 2.48

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents d013d220 57b9f113

configure

+1 −1
Original line number Diff line number Diff line
@@ -3636,7 +3636,7 @@ fi 
##########################################

# glib support probe



glib_req_ver=2.40

glib_req_ver=2.48

glib_modules=gthread-2.0

if test "$modules" = yes; then

    glib_modules="$glib_modules gmodule-export-2.0"

crypto/afsplit.c

+8 −20
Original line number Diff line number Diff line
@@ -58,7 +58,7 @@ static int qcrypto_afsplit_hash(QCryptoHashAlgorithm hash, 
    }



    for (i = 0; i < hashcount; i++) {

        uint8_t *out = NULL;

        g_autofree uint8_t *out = NULL;

        size_t outlen = 0;

        uint32_t iv = cpu_to_be32(i);

        struct iovec in[] = {
@@ -79,7 +79,6 @@ static int qcrypto_afsplit_hash(QCryptoHashAlgorithm hash, 
        assert(outlen == digestlen);

        memcpy(block + (i * digestlen), out,

               (i == (hashcount - 1)) ? finallen : digestlen);

        g_free(out);

    }



    return 0;
@@ -93,13 +92,12 @@ int qcrypto_afsplit_encode(QCryptoHashAlgorithm hash, 
                           uint8_t *out,

                           Error **errp)

{

    uint8_t *block = g_new0(uint8_t, blocklen);

    g_autofree uint8_t *block = g_new0(uint8_t, blocklen);

    size_t i;

    int ret = -1;



    for (i = 0; i < (stripes - 1); i++) {

        if (qcrypto_random_bytes(out + (i * blocklen), blocklen, errp) < 0) {

            goto cleanup;

            return -1;

        }



        qcrypto_afsplit_xor(blocklen,
@@ -108,18 +106,14 @@ int qcrypto_afsplit_encode(QCryptoHashAlgorithm hash, 
                            block);

        if (qcrypto_afsplit_hash(hash, blocklen, block,

                                 errp) < 0) {

            goto cleanup;

            return -1;

        }

    }

    qcrypto_afsplit_xor(blocklen,

                        in,

                        block,

                        out + (i * blocklen));

    ret = 0;



 cleanup:

    g_free(block);

    return ret;

    return 0;

}
@@ -130,9 +124,8 @@ int qcrypto_afsplit_decode(QCryptoHashAlgorithm hash, 
                           uint8_t *out,

                           Error **errp)

{

    uint8_t *block = g_new0(uint8_t, blocklen);

    g_autofree uint8_t *block = g_new0(uint8_t, blocklen);

    size_t i;

    int ret = -1;



    for (i = 0; i < (stripes - 1); i++) {

        qcrypto_afsplit_xor(blocklen,
@@ -141,7 +134,7 @@ int qcrypto_afsplit_decode(QCryptoHashAlgorithm hash, 
                            block);

        if (qcrypto_afsplit_hash(hash, blocklen, block,

                                 errp) < 0) {

            goto cleanup;

            return -1;

        }

    }
@@ -149,10 +142,5 @@ int qcrypto_afsplit_decode(QCryptoHashAlgorithm hash, 
                        in + (i * blocklen),

                        block,

                        out);



    ret = 0;



 cleanup:

    g_free(block);

    return ret;

    return 0;

}

crypto/block-luks.c

+22 −52
Original line number Diff line number Diff line
@@ -425,14 +425,13 @@ qcrypto_block_luks_load_key(QCryptoBlock *block, 
                            Error **errp)

{

    QCryptoBlockLUKS *luks = block->opaque;

    uint8_t *splitkey;

    g_autofree uint8_t *splitkey = NULL;

    size_t splitkeylen;

    uint8_t *possiblekey;

    int ret = -1;

    g_autofree uint8_t *possiblekey = NULL;

    ssize_t rv;

    QCryptoCipher *cipher = NULL;

    g_autoptr(QCryptoCipher) cipher = NULL;

    uint8_t keydigest[QCRYPTO_BLOCK_LUKS_DIGEST_LEN];

    QCryptoIVGen *ivgen = NULL;

    g_autoptr(QCryptoIVGen) ivgen = NULL;

    size_t niv;



    if (slot->active != QCRYPTO_BLOCK_LUKS_KEY_SLOT_ENABLED) {
@@ -456,7 +455,7 @@ qcrypto_block_luks_load_key(QCryptoBlock *block, 
                       slot->iterations,

                       possiblekey, masterkeylen,

                       errp) < 0) {

        goto cleanup;

        return -1;

    }



    /*
@@ -472,7 +471,7 @@ qcrypto_block_luks_load_key(QCryptoBlock *block, 
                  opaque,

                  errp);

    if (rv < 0) {

        goto cleanup;

        return -1;

    }
@@ -482,7 +481,7 @@ qcrypto_block_luks_load_key(QCryptoBlock *block, 
                                possiblekey, masterkeylen,

                                errp);

    if (!cipher) {

        goto cleanup;

        return -1;

    }



    niv = qcrypto_cipher_get_iv_len(cipheralg,
@@ -493,7 +492,7 @@ qcrypto_block_luks_load_key(QCryptoBlock *block, 
                              possiblekey, masterkeylen,

                              errp);

    if (!ivgen) {

        goto cleanup;

        return -1;

    }
@@ -512,7 +511,7 @@ qcrypto_block_luks_load_key(QCryptoBlock *block, 
                                            splitkey,

                                            splitkeylen,

                                            errp) < 0) {

        goto cleanup;

        return -1;

    }



    /*
@@ -525,7 +524,7 @@ qcrypto_block_luks_load_key(QCryptoBlock *block, 
                               splitkey,

                               masterkey,

                               errp) < 0) {

        goto cleanup;

        return -1;

    }
@@ -544,26 +543,18 @@ qcrypto_block_luks_load_key(QCryptoBlock *block, 
                       luks->header.master_key_iterations,

                       keydigest, G_N_ELEMENTS(keydigest),

                       errp) < 0) {

        goto cleanup;

        return -1;

    }



    if (memcmp(keydigest, luks->header.master_key_digest,

               QCRYPTO_BLOCK_LUKS_DIGEST_LEN) == 0) {

        /* Success, we got the right master key */

        ret = 1;

        goto cleanup;

        return 1;

    }



    /* Fail, user's password was not valid for this key slot,

     * tell caller to try another slot */

    ret = 0;



 cleanup:

    qcrypto_ivgen_free(ivgen);

    qcrypto_cipher_free(cipher);

    g_free(splitkey);

    g_free(possiblekey);

    return ret;

    return 0;

}
@@ -644,7 +635,7 @@ qcrypto_block_luks_open(QCryptoBlock *block, 
    int ret = 0;

    size_t i;

    ssize_t rv;

    uint8_t *masterkey = NULL;

    g_autofree uint8_t *masterkey = NULL;

    size_t masterkeylen;

    char *ivgen_name, *ivhash_name;

    QCryptoCipherMode ciphermode;
@@ -653,7 +644,7 @@ qcrypto_block_luks_open(QCryptoBlock *block, 
    QCryptoCipherAlgorithm ivcipheralg;

    QCryptoHashAlgorithm hash;

    QCryptoHashAlgorithm ivhash;

    char *password = NULL;

    g_autofree char *password = NULL;



    if (!(flags & QCRYPTO_BLOCK_OPEN_NO_IO)) {

        if (!options->u.luks.key_secret) {
@@ -856,17 +847,12 @@ qcrypto_block_luks_open(QCryptoBlock *block, 
    luks->ivgen_hash_alg = ivhash;

    luks->hash_alg = hash;



    g_free(masterkey);

    g_free(password);



    return 0;



 fail:

    g_free(masterkey);

    qcrypto_block_free_cipher(block);

    qcrypto_ivgen_free(block->ivgen);

    g_free(luks);

    g_free(password);

    return ret;

}
@@ -891,20 +877,20 @@ qcrypto_block_luks_create(QCryptoBlock *block, 
    QCryptoBlockLUKS *luks;

    QCryptoBlockCreateOptionsLUKS luks_opts;

    Error *local_err = NULL;

    uint8_t *masterkey = NULL;

    uint8_t *slotkey = NULL;

    uint8_t *splitkey = NULL;

    g_autofree uint8_t *masterkey = NULL;

    g_autofree uint8_t *slotkey = NULL;

    g_autofree uint8_t *splitkey = NULL;

    size_t splitkeylen = 0;

    size_t i;

    QCryptoCipher *cipher = NULL;

    QCryptoIVGen *ivgen = NULL;

    char *password;

    g_autoptr(QCryptoCipher) cipher = NULL;

    g_autoptr(QCryptoIVGen) ivgen = NULL;

    g_autofree char *password = NULL;

    const char *cipher_alg;

    const char *cipher_mode;

    const char *ivgen_alg;

    const char *ivgen_hash_alg = NULL;

    const char *hash_alg;

    char *cipher_mode_spec = NULL;

    g_autofree char *cipher_mode_spec = NULL;

    QCryptoCipherAlgorithm ivcipheralg = 0;

    uint64_t iters;
@@ -1311,15 +1297,7 @@ qcrypto_block_luks_create(QCryptoBlock *block, 
    luks->hash_alg = luks_opts.hash_alg;



    memset(masterkey, 0, luks->header.key_bytes);

    g_free(masterkey);

    memset(slotkey, 0, luks->header.key_bytes);

    g_free(slotkey);

    g_free(splitkey);

    g_free(password);

    g_free(cipher_mode_spec);



    qcrypto_ivgen_free(ivgen);

    qcrypto_cipher_free(cipher);



    return 0;
@@ -1327,17 +1305,9 @@ qcrypto_block_luks_create(QCryptoBlock *block, 
    if (masterkey) {

        memset(masterkey, 0, luks->header.key_bytes);

    }

    g_free(masterkey);

    if (slotkey) {

        memset(slotkey, 0, luks->header.key_bytes);

    }

    g_free(slotkey);

    g_free(splitkey);

    g_free(password);

    g_free(cipher_mode_spec);



    qcrypto_ivgen_free(ivgen);

    qcrypto_cipher_free(cipher);



    qcrypto_block_free_cipher(block);

    qcrypto_ivgen_free(block->ivgen);

crypto/block.c

+5 −10
Original line number Diff line number Diff line
@@ -299,15 +299,13 @@ static int do_qcrypto_block_cipher_encdec(QCryptoCipher *cipher, 
                                          QCryptoCipherEncDecFunc func,

                                          Error **errp)

{

    uint8_t *iv;

    g_autofree uint8_t *iv = niv ? g_new0(uint8_t, niv) : NULL;

    int ret = -1;

    uint64_t startsector = offset / sectorsize;



    assert(QEMU_IS_ALIGNED(offset, sectorsize));

    assert(QEMU_IS_ALIGNED(len, sectorsize));



    iv = niv ? g_new0(uint8_t, niv) : NULL;



    while (len > 0) {

        size_t nbytes;

        if (niv) {
@@ -320,19 +318,19 @@ static int do_qcrypto_block_cipher_encdec(QCryptoCipher *cipher, 
            }



            if (ret < 0) {

                goto cleanup;

                return -1;

            }



            if (qcrypto_cipher_setiv(cipher,

                                     iv, niv,

                                     errp) < 0) {

                goto cleanup;

                return -1;

            }

        }



        nbytes = len > sectorsize ? sectorsize : len;

        if (func(cipher, buf, buf, nbytes, errp) < 0) {

            goto cleanup;

            return -1;

        }



        startsector++;
@@ -340,10 +338,7 @@ static int do_qcrypto_block_cipher_encdec(QCryptoCipher *cipher, 
        len -= nbytes;

    }



    ret = 0;

 cleanup:

    g_free(iv);

    return ret;

    return 0;

}

crypto/hmac-glib.c

+0 −5
Original line number Diff line number Diff line
@@ -21,12 +21,7 @@ static int qcrypto_hmac_alg_map[QCRYPTO_HASH_ALG__MAX] = { 
    [QCRYPTO_HASH_ALG_MD5] = G_CHECKSUM_MD5,

    [QCRYPTO_HASH_ALG_SHA1] = G_CHECKSUM_SHA1,

    [QCRYPTO_HASH_ALG_SHA256] = G_CHECKSUM_SHA256,

/* Support for HMAC SHA-512 in GLib 2.42 */

#if GLIB_CHECK_VERSION(2, 42, 0)

    [QCRYPTO_HASH_ALG_SHA512] = G_CHECKSUM_SHA512,

#else

    [QCRYPTO_HASH_ALG_SHA512] = -1,

#endif

    [QCRYPTO_HASH_ALG_SHA224] = -1,

    [QCRYPTO_HASH_ALG_SHA384] = -1,

    [QCRYPTO_HASH_ALG_RIPEMD160] = -1,