Commit 5c7cb944 authored by Eric Biggers's avatar Eric Biggers Committed by Jens Axboe
Browse files

blk-crypto: make blk_crypto_evict_key() more robust 



If blk_crypto_evict_key() sees that the key is still in-use (due to a
bug) or that ->keyslot_evict failed, it currently just returns while
leaving the key linked into the keyslot management structures.

However, blk_crypto_evict_key() is only called in contexts such as inode
eviction where failure is not an option.  So actually the caller
proceeds with freeing the blk_crypto_key regardless of the return value
of blk_crypto_evict_key().

These two assumptions don't match, and the result is that there can be a
use-after-free in blk_crypto_reprogram_all_keys() after one of these
errors occurs.  (Note, these errors *shouldn't* happen; we're just
talking about what happens if they do anyway.)

Fix this by making blk_crypto_evict_key() unlink the key from the
keyslot management structures even on failure.

Also improve some comments.

Fixes: 1b262839 ("block: Keyslot Manager for Inline Encryption")
Cc: stable@vger.kernel.org
Signed-off-by: default avatarEric Biggers <ebiggers@google.com>
Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
Link: https://lore.kernel.org/r/20230315183907.53675-2-ebiggers@kernel.org


Signed-off-by: default avatarJens Axboe <axboe@kernel.dk>
parent 70493a63

block/blk-crypto-profile.c

+21 −25
Original line number Diff line number Diff line
@@ -354,28 +354,16 @@ bool __blk_crypto_cfg_supported(struct blk_crypto_profile *profile, 
	return true;

}



/**

 * __blk_crypto_evict_key() - Evict a key from a device.

 * @profile: the crypto profile of the device

 * @key: the key to evict.  It must not still be used in any I/O.

 *

 * If the device has keyslots, this finds the keyslot (if any) that contains the

 * specified key and calls the driver's keyslot_evict function to evict it.

 *

 * Otherwise, this just calls the driver's keyslot_evict function if it is

 * implemented, passing just the key (without any particular keyslot).  This

 * allows layered devices to evict the key from their underlying devices.

 *

 * Context: Process context. Takes and releases profile->lock.

 * Return: 0 on success or if there's no keyslot with the specified key, -EBUSY

 *	   if the keyslot is still in use, or another -errno value on other

 *	   error.

/*

 * This is an internal function that evicts a key from an inline encryption

 * device that can be either a real device or the blk-crypto-fallback "device".

 * It is used only by blk_crypto_evict_key(); see that function for details.

 */

int __blk_crypto_evict_key(struct blk_crypto_profile *profile,

			   const struct blk_crypto_key *key)

{

	struct blk_crypto_keyslot *slot;

	int err = 0;

	int err;



	if (profile->num_slots == 0) {

		if (profile->ll_ops.keyslot_evict) {
@@ -389,22 +377,30 @@ int __blk_crypto_evict_key(struct blk_crypto_profile *profile, 


	blk_crypto_hw_enter(profile);

	slot = blk_crypto_find_keyslot(profile, key);

	if (!slot)

		goto out_unlock;

	if (!slot) {

		/*

		 * Not an error, since a key not in use by I/O is not guaranteed

		 * to be in a keyslot.  There can be more keys than keyslots.

		 */

		err = 0;

		goto out;

	}



	if (WARN_ON_ONCE(atomic_read(&slot->slot_refs) != 0)) {

		/* BUG: key is still in use by I/O */

		err = -EBUSY;

		goto out_unlock;

		goto out_remove;

	}

	err = profile->ll_ops.keyslot_evict(profile, key,

					    blk_crypto_keyslot_index(slot));

	if (err)

		goto out_unlock;



out_remove:

	/*

	 * Callers free the key even on error, so unlink the key from the hash

	 * table and clear slot->key even on error.

	 */

	hlist_del(&slot->hash_node);

	slot->key = NULL;

	err = 0;

out_unlock:

out:

	blk_crypto_hw_exit(profile);

	return err;

}

block/blk-crypto.c

+20 −8
Original line number Diff line number Diff line
@@ -400,15 +400,19 @@ int blk_crypto_start_using_key(struct block_device *bdev, 
}



/**

 * blk_crypto_evict_key() - Evict a key from any inline encryption hardware

 *			    it may have been programmed into

 * @bdev: The block_device who's associated inline encryption hardware this key

 *     might have been programmed into

 * @key: The key to evict

 * blk_crypto_evict_key() - Evict a blk_crypto_key from a block_device

 * @bdev: a block_device on which I/O using the key may have been done

 * @key: the key to evict

 *

 * Upper layers (filesystems) must call this function to ensure that a key is

 * evicted from any hardware that it might have been programmed into.  The key

 * must not be in use by any in-flight IO when this function is called.

 * For a given block_device, this function removes the given blk_crypto_key from

 * the keyslot management structures and evicts it from any underlying hardware

 * keyslot(s) or blk-crypto-fallback keyslot it may have been programmed into.

 *

 * Upper layers must call this before freeing the blk_crypto_key.  It must be

 * called for every block_device the key may have been used on.  The key must no

 * longer be in use by any I/O when this function is called.

 *

 * Context: May sleep.

 */

void blk_crypto_evict_key(struct block_device *bdev,

			  const struct blk_crypto_key *key)
@@ -420,6 +424,14 @@ void blk_crypto_evict_key(struct block_device *bdev, 
		err = __blk_crypto_evict_key(q->crypto_profile, key);

	else

		err = blk_crypto_fallback_evict_key(key);

	/*

	 * An error can only occur here if the key failed to be evicted from a

	 * keyslot (due to a hardware or driver issue) or is allegedly still in

	 * use by I/O (due to a kernel bug).  Even in these cases, the key is

	 * still unlinked from the keyslot management structures, and the caller

	 * is allowed and expected to free it right away.  There's nothing

	 * callers can do to handle errors, so just log them and return void.

	 */

	if (err)

		pr_warn_ratelimited("%pg: error %d evicting key\n", bdev, err);

}