Je suis en train d'apprendre la protection dm-verity d'Android et j'essaie de comprendre comment le dm-verity d'Android utilise l'arbre de hachage pour la validation du "single block".
https://source.Android.com/security/verifiedboot/dm-verity dit :
Au lieu de cela, dm-verity vérifie les blocs individuellement et seulement lorsque chacun d'eux est accédé. Lorsqu'il est lu en mémoire, le bloc est haché en parallèle. Le hachage est ensuite vérifié dans l'arbre. Et puisque la lecture du bloc est une opération si coûteuse, la latence introduite par cette vérification au niveau du bloc est comparativement nominale.
Une fois le bloc lu et haché, il est vérifié en haut de l'arbre. Mais comment puis-je vérifier le hachage de Root, alors que je n'ai pas lu tous les blocs ? Je peux vérifier uniquement la partie de l'arbre que j'ai lue, et cela signifie que je n'ai pas besoin d'aller jusqu'au hachage des racines.
Je ne comprends pas pourquoi nous utilisons un arbre de hachage. Fil de discussion StackOverflow dit que la principale raison d'utiliser les arbres de hachage est que le hachage est calculé pour chaque bloc et ensuite pour tout le fichier à nouveau, je ne comprends pas pourquoi il est utilisé ici.
Comment cela est-il mis en œuvre ? Mon hypothèse est que lorsque le bloc est chargé en mémoire, Android vérifie seulement la branche particulière et le reste des valeurs sont prises dans l'arbre de hachage pré-calculé. Mais je ne vois pas la raison d'utiliser l'arbre. Je voudrais juste stocker les valeurs de hachage du bloc et après avoir lu le bloc et le hachage comparer juste le hachage.
Edit : Supposons cette implémentation :
- diviser l'ensemble du dispositif de blocs en blocs de taille 4K.
- hacher chaque bloc particulier et concaténer les hachages (créer la couche 0 de dm-verity)
- stocker les hachages (couche 0) à la fin du dispositif de bloc Maintenant, lorsque je veux vérifier le bloc 4K chargé dans la mémoire, je trouve la position du bloc et je compare le hachage du bloc chargé avec le hachage stocké.
Dans la situation telle que ce L'utilisation d'un arbre a du sens, car vous n'avez que la racine de Merkle disponible, mais dans Android, nous avons l'arbre entier, alors pourquoi ne pas utiliser la couche 0 (implémentation ci-dessus) et jeter le reste.
Et en écrivant, je pense avoir trouvé une réponse. Android stocke l'arbre de hachage complet à la fin. Mais l'arbre n'est pas signé, seulement la table dm-verity (métadonnées) qui contient le hash Root. Donc, dans mon implémentation, je devrais signer toute la couche 0. Et c'est probablement un gaspillage de ressources, donc il est préférable d'utiliser l'arbre.
