web-dev-qa-db-fra.com

Pourquoi Git n'utilise-t-il pas SHA plus moderne?

J'ai lu que Git utilise SHA-1 digest comme ID pour une révision. Pourquoi n'utilise-t-il pas une version plus moderne de SHA?

gitcryptographysha
74
qazwsx

Pourquoi n'utilise-t-il pas une version plus moderne de SHA?

Décembre 2017: Ce sera le cas. Et Git 2.16 (Q1 2018) est la première version à illustrer et à mettre en œuvre cette intention.

Remarque: voir Git 2.19 ci-dessous: ce sera SHA-256 .

Git 2.16 proposera une infrastructure pour définir quelle fonction de hachage est utilisée dans Git, et commencera à s'efforcer de l'explorer à travers différents chemins de code.

Voir commit c250e02 (28 novembre 2017) par Ramsay Jones (``) .
Voir commit eb0ccfd , commit 78a6766 , commit f50e766 , commit abade65 (12 novembre 2017) par brian m. carlson (bk2204) .
(Fusionné par Junio ​​C Hamano - gitster - in commit 721cc4 , 13 décembre 2017)

Ajouter une structure représentant l'algorithme de hachage

Puisqu'à l'avenir, nous voulons prendre en charge un algorithme de hachage supplémentaire, ajoutez ne structure qui représente un algorithme de hachage et toutes les données qui doivent l'accompagner.
Ajoutez une constante pour permettre une énumération facile des algorithmes de hachage .
Implémentez fonction typedefs pour créer une API abstraite qui peut être utilisée par n'importe quel algorithme de hachage et des wrappers pour les fonctions SHA1 existantes conformes à cette API.

Exposer un valeur pour la taille hexadécimale ainsi que la taille binaire .
Alors que l'une sera toujours le double de l'autre, les deux valeurs sont toutes deux utilisées très fréquemment dans la base de code et fournissent les deux pour une meilleure lisibilité.

N'incluez pas d'entrée dans la structure de l'algorithme de hachage pour l'ID d'objet nul.
Comme cette valeur est entièrement composée de zéros, tout ID d'objet de taille appropriée peut être utilisé, et il n'est pas nécessaire d'en stocker un donné par hachage.

Le plan de transition de la fonction de hachage actuelle prévoit un moment où nous accepterons les entrées de l'utilisateur qui pourraient être au format SHA-1 ou au format NewHash.
Puisque nous ne pouvons pas savoir ce que l'utilisateur a fourni, ajoutez une constante représentant l'algorithme inconn pour nous permettre pour indiquer que nous devons rechercher la valeur correcte.

Intégrer la prise en charge de l'algorithme de hachage avec la configuration du référentiel

Dans les futures versions de Git, nous prévoyons de prendre en charge un algorithme de hachage supplémentaire.
Intégrez l'énumération des algorithmes de hachage à la configuration du référentiel et stockez un pointeur vers les données énumérées dans le référentiel struct .
Bien sûr, nous ne prenons actuellement en charge que SHA-1, donc codez en dur cette valeur dans read_repository_format.
À l'avenir, nous énumérerons cette valeur dans la configuration.

Ajouter ne constante, the_hash_algo , qui pointe vers le hash_algo pointeur de structure dans le référentiel global.
Notez que c'est le hachage qui est utilisé pour sérialiser les données sur le disque, pas le hachage qui est utilisé pour afficher les éléments à l'utilisateur.
Le plan de transition prévoit que ceux-ci pourraient être différents.
Nous pouvons ajouter un élément supplémentaire à l'avenir (disons, ui_hash_algo) pour prévoir ce cas.

Mise à jour d'août 2018, pour Git 2.19 (Q3 2018), Git semble choisir SHA-256 comme NewHash.

Voir commit 0ed8d8d (04 août 2018) par Jonathan Nieder (artagnon) .
Voir commit 13f5e09 (25 juillet 2018) par Ævar Arnfjörð Bjarmason (avar) .
(Fusionné par Junio ​​C Hamano - gitster - in commit 34f2297 , 20 août 2018)

doc hash-function-transition : choisissez SHA-256 comme NewHash

Du point de vue de la sécurité, il semble que SHA-256, BLAKE2, SHA3-256, K12, etc., auraient tous des propriétés de sécurité similaires.
Ce sont toutes de bonnes options du point de vue de la sécurité.

SHA-256 présente un certain nombre d'avantages:

  • Il existe depuis un certain temps, est largement utilisé et est pris en charge par à peu près toutes les bibliothèques de chiffrement (OpenSSL, mbedTLS, CryptoNG, SecureTransport, etc.).

  • Lorsque vous comparez avec SHA1DC, la plupart des implémentations SHA-256 vectorisées sont en effet plus rapides, même sans accélération.

  • Si nous faisons des signatures avec OpenPGP (ou même, je suppose, CMS), nous allons utiliser SHA-2, donc cela n'a pas de sens que notre sécurité dépende de deux algorithmes distincts lorsque l'un d'eux seul pouvait briser la sécurité alors que nous pouvions en dépendre.

Donc SHA-256 c'est .
Mettez à jour le document de conception de transition de fonction de hachage pour le dire.

Après ce correctif, il ne reste plus d'instances de la chaîne "NewHash", à l'exception d'une utilisation indépendante de 2008 comme n nom de variable dans t/t9700/test.pl .

Vous pouvez voir cette transition vers SHA 256 en cours avec Git 2.20 (Q4 2018):

Voir commit 0d7c419 , commit dda6346 , commit eccb5a5 , commit 93eb00f , commit d8a3a69 , commit fbd0e37 , commit f690b6b , commit 49d166 , commit 268babd , commit fa1308 , commit 7b5e614 , commit 58ce21b , commit 2f0c9e9 , commit 825544a (15 octobre 2018) par brian m. carlson (bk2204) .
Voir commit 6afedba (15 octobre 2018) par SZEDER Gábor (szeder) .
(Fusionné par Junio ​​C Hamano - gitster - in commit d829d49 , 30 octobre 2018)

remplacer les constantes codées en dur

Remplacez plusieurs constantes basées sur 40 par des références à GIT_MAX_HEXSZ ou the_hash_algo, selon le cas.
Convertissez toutes les utilisations de GIT_SHA1_HEXSZ utiliser the_hash_algo afin qu'ils conviennent à toute longueur de hachage donnée.
Au lieu d'utiliser une constante codée en dur pour la taille d'un ID d'objet hexadécimal, basculez pour utiliser le pointeur calculé à partir de parse_oid_hex qui pointe après l'ID de l'objet analysé.

GIT_SHA1_HEXSZ est en outre supprimé/remplacé par Git 2.22 (Q2 2019) et commit d4e568b .

Cette transition se poursuit avec Git 2.21 (Q1 2019), qui ajoute le hachage sha-256 et le branche via le code pour permettre la construction de Git avec le "NewHash".

Voir commit 4b4e291 , commit 27dc04c , commit 13eeedb , commit c166599 , commit 37649b7 , commit a2ce0a7 , commit 50c817e , commit 9a3a0ff , commit 0dab712 , commit 47edb64 (14 novembre 2018), et commit 2f90b9d , commit 1ccf07c (22 octobre 2018) par brian m. Carlson (bk2204) .
(Fusionné par Junio ​​C Hamano - gitster - in commit 33e4ae9 , 29 janvier 2019)

Ajouter une implémentation de base du support SHA-256 (février 2019)

SHA-1 est faible et nous devons passer à une nouvelle fonction de hachage.
Depuis quelque temps, nous appelons cette nouvelle fonction NewHash.
Récemment, nous avons décidé de choisir SHA-256 comme NewHash.
Les raisons du choix de SHA-256 sont décrites dans ce fil et dans l'historique de validation du document de transition de fonction de hachage.

Ajoutez une implémentation de base de SHA-256 basée sur libtomcrypt, qui est dans le domaine public.
Optimisez-le et restructurez-le pour répondre à nos normes de codage.
Extrayez les fonctions de mise à jour et finales de l'implémentation du bloc SHA-1, car nous connaissons ces fonctions correctement avec tous les compilateurs. Cette implémentation est plus lente que SHA-1, mais des implémentations plus performantes seront introduites dans les futures validations.

Câblez SHA-256 dans la liste des algorithmes de hachage et ajoutez un test que l'algorithme fonctionne correctement.

Notez qu'avec ce patch, il n'est toujours pas possible de passer à l'utilisation de SHA-256 dans Git.
Des correctifs supplémentaires sont nécessaires pour préparer le code à gérer un algorithme de hachage plus important et des correctifs de test supplémentaires sont nécessaires.

hash: ajoutez une implémentation SHA-256 à l'aide d'OpenSSL

Nous avons déjà des routines OpenSSL disponibles pour SHA-1, alors ajoutez également des routines pour SHA-256.

Sur un Core i7-6600U, cette implémentation SHA-256 se compare favorablement à l'implémentation SHA1DC SHA-1:

SHA-1: 157 MiB/s (64 byte chunks); 337 MiB/s (16 KiB chunks)
SHA-256: 165 MiB/s (64 byte chunks); 408 MiB/s (16 KiB chunks)

sha256: ajoutez une implémentation SHA-256 en utilisant libgcrypt

Généralement, on obtient de meilleures performances des routines cryptographiques écrites dans Assembly que C, et cela est également vrai pour SHA-256.
De plus, la plupart des distributions Linux ne peuvent pas distribuer Git lié à OpenSSL pour des raisons de licence.

La plupart des systèmes avec GnuPG auront également libgcrypt, car il s'agit d'une dépendance de GnuPG.
libgcrypt est également plus rapide que l'implémentation SHA1DC pour les messages de quelques Ko et plus.

À titre de comparaison, sur un Core i7-6600U, cette implémentation traite 16 segments de Kio à 355 Mio/s tandis que SHA1DC traite des segments équivalents à 337 Mio/s.

De plus, libgcrypt est sous licence LGPL 2.1, compatible avec la GPL. Ajoutez une implémentation de SHA-256 qui utilise libgcrypt.

39
VonC

[~ # ~] mise à jour [~ # ~] : La question ci-dessus et cette réponse datent de 2015. Depuis lors, Google a annoncé le premier SHA-1 collision: https://security.googleblog.com/2017/02/announcing-first-sha1-collision.html

Évidemment, je ne peux que spéculer de l'extérieur pour savoir pourquoi Git continue d'utiliser SHA-1, mais cela peut être l'une des raisons:

  1. Git était la création de Linus Torvald, et Linus ne veut apparemment pas remplacer SHA-1 par un autre algorithme de hachage pour le moment.
  2. Il affirme de manière plausible que les attaques réussies basées sur les collisions SHA-1 contre Git sont beaucoup plus difficiles que la réalisation des collisions elles-mêmes, et considérant que SHA-1 est plus faible qu'il ne devrait l'être, pas complètement rompu, ce qui le rend sensiblement loin d'un attaque réalisable au moins aujourd'hui. De plus, il note qu'une attaque "réussie" n'obtiendrait pas grand-chose si l'objet entrant en collision arrivait plus tard que celui existant, car le dernier serait simplement supposé être le même que celui valide et ignoré (bien que d'autres aient souligné que l'inverse pourrait se produire).
  3. Le changement de logiciel prend du temps et est source d'erreurs, en particulier lorsqu'il existe une infrastructure existante et des données basées sur les protocoles existants qui devront être migrées. Même ceux qui produisent des produits logiciels et matériels où la sécurité cryptographique est le seul point du système sont toujours en train de migrer de SHA-1 et d'autres algorithmes faibles par endroits. Imaginez simplement tous ces codés en dur unsigned char[20] tampons un peu partout ;-), il est beaucoup plus facile de programmer l'agilité cryptographique au début, plutôt que de la moderniser plus tard.
  4. Les performances de SHA-1 sont meilleures que celles des différents hachages SHA-2 (probablement pas au point d'être un facteur de rupture maintenant, mais c'était peut-être un point critique il y a 10 ans), et la taille de stockage de SHA-2 est plus grande .

Quelques liens:

Mon point de vue personnel serait que, même si les attaques pratiques sont probablement interrompues, et même lorsqu'elles se produisent, les gens s'attaqueront probablement initialement à eux par d'autres moyens que de changer l'algorithme de hachage lui-même, que si vous vous souciez de la sécurité, vous devriez vous tromper. par prudence avec vos choix d'algorithmes, et en révisant constamment à la hausse vos forces de sécurité, car les capacités des attaquants ne vont également que dans une seule direction, il serait donc imprudent de prendre Git comme modèle, en particulier en tant que but dans l'utilisation de SHA-1 ne prétend pas être une sécurité cryptographique.

50
softwariness

Il s'agit d'une discussion sur l'urgence de migrer loin de SHA1 pour Mercurial, mais cela s'applique également à Git: https://www.Mercurial-scm.org/wiki/mpm/SHA1

En bref: si vous n'êtes pas extrêmement diligent aujourd'hui, vous avez des vulnérabilités bien pires que sha1. Mais malgré cela, Mercurial a commencé il y a plus de 10 ans à se préparer à migrer loin de sha1.

des travaux sont en cours depuis des années pour moderniser les structures de données et les protocoles de Mercurial pour les successeurs de SHA1. L'espace de stockage a été alloué pour des hachages plus importants dans notre structure de revlog il y a plus de 10 ans dans Mercurial 0.9 avec l'introduction de RevlogNG. Le format bundle2 introduit plus récemment prend en charge l'échange de différents types de hachage sur le réseau. Les seules pièces restantes sont le choix d'une fonction de remplacement et le choix d'une stratégie de rétrocompatibilité.

Si git ne migre pas de sha1 avant Mercurial, vous pouvez toujours ajouter un autre niveau de sécurité en gardant un miroir Mercurial local avec hg-git .

5
Arne Babenhauserheide

Il y a maintenant un plan de transition vers un hachage plus fort, il semble donc qu'à l'avenir, il utilisera un hachage plus moderne que SHA-1. À partir du plan de transition actuel :

Certains hachages à l'étude sont SHA-256, SHA-512/256, SHA-256x16, K12 et BLAKE2bp-256

3
Paul Wagland