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: 1b26283970 ("block: Keyslot Manager for Inline Encryption")
Cc: stable@vger.kernel.org
Signed-off-by: Eric Biggers <ebiggers@google.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Link: https://lore.kernel.org/r/20230315183907.53675-2-ebiggers@kernel.org
Signed-off-by: Jens Axboe <axboe@kernel.dk>
This commit is contained in:
Eric Biggers 2023-03-15 11:39:04 -07:00 committed by Jens Axboe
parent 70493a63ba
commit 5c7cb94452
2 changed files with 41 additions and 33 deletions

View File

@ -354,28 +354,16 @@ bool __blk_crypto_cfg_supported(struct blk_crypto_profile *profile,
return true; return true;
} }
/** /*
* __blk_crypto_evict_key() - Evict a key from a device. * This is an internal function that evicts a key from an inline encryption
* @profile: the crypto profile of the device * device that can be either a real device or the blk-crypto-fallback "device".
* @key: the key to evict. It must not still be used in any I/O. * It is used only by blk_crypto_evict_key(); see that function for details.
*
* 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.
*/ */
int __blk_crypto_evict_key(struct blk_crypto_profile *profile, int __blk_crypto_evict_key(struct blk_crypto_profile *profile,
const struct blk_crypto_key *key) const struct blk_crypto_key *key)
{ {
struct blk_crypto_keyslot *slot; struct blk_crypto_keyslot *slot;
int err = 0; int err;
if (profile->num_slots == 0) { if (profile->num_slots == 0) {
if (profile->ll_ops.keyslot_evict) { 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); blk_crypto_hw_enter(profile);
slot = blk_crypto_find_keyslot(profile, key); slot = blk_crypto_find_keyslot(profile, key);
if (!slot) if (!slot) {
goto out_unlock; /*
* 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)) { if (WARN_ON_ONCE(atomic_read(&slot->slot_refs) != 0)) {
/* BUG: key is still in use by I/O */
err = -EBUSY; err = -EBUSY;
goto out_unlock; goto out_remove;
} }
err = profile->ll_ops.keyslot_evict(profile, key, err = profile->ll_ops.keyslot_evict(profile, key,
blk_crypto_keyslot_index(slot)); blk_crypto_keyslot_index(slot));
if (err) out_remove:
goto out_unlock; /*
* 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); hlist_del(&slot->hash_node);
slot->key = NULL; slot->key = NULL;
err = 0; out:
out_unlock:
blk_crypto_hw_exit(profile); blk_crypto_hw_exit(profile);
return err; return err;
} }

View File

@ -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 * blk_crypto_evict_key() - Evict a blk_crypto_key from a block_device
* it may have been programmed into * @bdev: a block_device on which I/O using the key may have been done
* @bdev: The block_device who's associated inline encryption hardware this key * @key: the key to evict
* might have been programmed into
* @key: The key to evict
* *
* Upper layers (filesystems) must call this function to ensure that a key is * For a given block_device, this function removes the given blk_crypto_key from
* evicted from any hardware that it might have been programmed into. The key * the keyslot management structures and evicts it from any underlying hardware
* must not be in use by any in-flight IO when this function is called. * 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, void blk_crypto_evict_key(struct block_device *bdev,
const struct blk_crypto_key *key) 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); err = __blk_crypto_evict_key(q->crypto_profile, key);
else else
err = blk_crypto_fallback_evict_key(key); 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) if (err)
pr_warn_ratelimited("%pg: error %d evicting key\n", bdev, err); pr_warn_ratelimited("%pg: error %d evicting key\n", bdev, err);
} }