Quelle serait la taille de la clé pour une image utilisée comme clé?
Je travaille sur un cryptosystème qui utilise des images en couleur comme clés de cryptage. J'essaie de deviner quelle est la taille de clé de mon cryptosystème afin de trouver la faisabilité d'une attaque par force brute. Mon cryptosystème utilise des images RVB de toute taille M x N.
L'image est également générée par un attracteur chaotique qui est sensible aux valeurs initiales, de sorte que chaque image générée est différente. Ces images en sont un exemple:
Je n'ai pas encore trouvé d'article qui essaie de faire le même calcul. Une idée de la taille de la clé?
Votre dernière modification indique que vos images sont générées de manière procédurale, donc la taille de votre clé sera donc limitée par la quantité d'état requise pour générer une image. Le vôtre semble être paramétré par quatre flotteurs pour les conditions initiales (et la taille d'image de sortie fixe, l'emplacement de la caméra, l'emplacement de la lumière ponctuelle, les conditions de convergence, etc.).
Ces 128 bits d'état seront ensuite transformés en image par un algorithme qui dépend uniquement de votre état fourni, de sorte que votre "clé" d'image ne peut pas contenir plus de 128 bits d'informations. En fait, je pense que des classes entières de valeurs initiales produisent des sorties identiques (par exemple lorsque les quatre flottants sont extrêmement petits), donc la taille de votre "clé" d'image sera strictement inférieure à 128 bits.
Il n'y a vraiment aucun avantage à toucher les 128 bits d'état en les transformant en image (puis en quelque sorte en arrière) si vous ne réduisez que la taille de la clé en le faisant.
Une image est beaucoup trop volumineuse pour être utilisée directement comme clé de cryptage, vous voudrez l'exécuter d'abord via KDF .
Cela dépend aussi entièrement de l'image si elle aura suffisamment d'entropie pour être utile. Vous pourriez avoir une image 1000x1000 qui est d'un blanc uni, mais elle serait inutile comme clé car elle ne contient pas d'entropie. Les images provenant des caméras ont tendance à avoir une bonne quantité d'entropie dans les bits inférieurs, ce qui pourrait être correct, mais vos utilisateurs devraient comprendre que n'importe quelle image n'est pas une bonne clé.
Les images comme clés ne sont généralement pas une bonne idée. Les photos sont généralement prises pour être partagées, et les clés sont quelque chose que vous ne voulez pas montrer à tout le monde. L'utilisation d'une image comme clé me semble également pouvoir s'appuyer sur la sécurité par l'obscurité (c'est-à-dire que vous utilisez simplement une image parmi les milliers que vous avez sur votre ordinateur, mais c'est effectivement une entropie très faible, probablement moins de 20 bits, sauf si vous avez un nombre fou de photos).
N'hésitez pas à continuer à développer cela pour le plaisir d'apprendre, mais jusqu'à ce que vous ayez une bien meilleure compréhension de la cryptographie, il est préférable de laisser ce genre de choses aux experts (voir Pourquoi ne devrions-nous pas rouler les nôtres? =).
Tout cryptosystème devrait avoir des clés avec des tailles de clé aux niveaux de sécurité 128, 192 et 256 bit-d'entropie .
La question vous revient donc: d'où viennent ces images et combien d'entropie contiennent-elles? Si ce sont des flux binaires complètement aléatoires qui sont interprétés comme une image, alors (en ignorant la perte d'entropie des codecs de compression avec perte), vous obtenez log_base2(256x256x256) = 24 bits of entropy per pixel, vous aurez donc besoin de 6/8/11 pixels respectivement pour le Forces de sécurité 128/192/256 bits.
Si vous ne générez pas d'images complètement aléatoires et autorisez plutôt les gens à utiliser, comme des photos, alors je ne sais pas comment vous pourriez même commencer à estimer la quantité d'entropie dans l'une d'entre elles.
Conclusion: l'utilisation d'images comme matériel clé semble être une chose vraiment étrange à faire et est en contradiction avec la pratique courante selon laquelle le matériel clé doit être des données complètement aléatoires provenant d'une cryptographie -RNG de force.
De plus, d'après les informations contenues dans votre question, je ne suis pas convaincu que la force brute soit l'attaque dont vous devez vous inquiéter; Je serais plus préoccupé par l'attaque "avoir accès à leur ordinateur portable et essayer chaque image sur leur disque dur".
Je peux dire à partir des images que votre taille de clé est nettement inférieure à la taille des images (car sinon la plupart d'entre elles ressembleraient à de la statique de couleur aléatoire).
La taille de votre clé est inférieure ou égale au logarithme de base 2 du nombre total d'images différentes que votre programme d'attracteur chaotique peut générer. *
C'est une autre façon de dire que la taille de votre clé est inférieure ou égale (probablement inférieure à) à la quantité de bits nécessaire pour spécifier toutes les entrées de votre programme d'attracteur chaotique.
Si vous hachez l'image et utilisez le hachage comme clé de chiffrement, la taille de votre clé est égale ou inférieure à la taille du hachage.
* C'est la taille exacte de votre clé si votre algorithme de chiffrement est quelque chose comme "XOR chaque bit de l'image avec le bit correspondant du texte en clair" (n'utilisez pas cet algorithme pour des secrets importants, BTW, car certaines parties du message sont couvertes par le gris les zones de vos images pourraient être très faciles à déchiffrer).
tl; dr - Vous proposez un algorithme d'étirement des touches qui tourne à 128 bits d'entrée dans une clé beaucoup plus grande. Ce n'est pas aussi bon que d'utiliser simplement une clé beaucoup plus grande de la même taille, bien que ce ne soit pas nécessairement aussi faible que les 128 bits d'entrée. Cela dit, votre bitmap semble très ordonné, ce qui suggère fortement qu'il est beaucoup plus faible qu'un bitmap généré de manière aléatoire.
Selon @ réponse de Blender , vous utilisez simplement 128 bits pour générer l'image. Je suppose que vous voulez que l'image elle-même compte comme une clé plus grande que les 128 bits que vous avez mis dans l'algorithme qui l'a générée. Et c'est pourrait.
Plus précisément, ce que vous essayez de faire est de créer un algorithme d'étirement des clés qui tente d'étirer 128 bits d'entrée en une clé beaucoup plus grande. Ce n'est pas nécessairement inutile, mais il y a des choses à savoir:
Un algorithme d'étirement des clés peut être vulnérable à la force brute de l'entrée. Par exemple, même si quelqu'un ne pouvait pas effectuer de rétro-ingénierie de l'algorithme de génération d'image, il pourrait essayer toutes les entrées possibles à $ 2 ^ {128} $ pour générer toutes les images possibles à $ 2 ^ {128} $ possibles, puis essayer chacune. Pour éviter cela, vous devez vous assurer que l'algorithme de génération d'image est trop cher pour qu'une telle attaque soit réalisable.
Votre image semble loin d'être aléatoire à l'échelle locale. Autrement dit, quiconque en regardant quelques pixels peut probablement deviner les pixels voisins avec des chances de succès meilleures que aléatoires. Cela signifie que l'algorithme n'est pas pseudo-aléatoire, même contre un attaquant qui ne peut pas rétroconcevoir l'algorithme de génération d'image.
Votre image semble loin d'être aléatoire à l'échelle mondiale. C'est-à-dire que les formes affichées ont une géométrie globale, plus les images perdent des pixels sur un fond bien élevé. Cela affaiblit de nouveau considérablement le pseudo-aléatoire, ce qui suggère potentiellement qu'il pourrait être facile de se casser complètement.
Il n'y a aucun avantage réel dans un algorithme d'étirement des clés produisant une image par rapport à toute autre représentation des mêmes données. Certes, la clé étirée ressemble à une image, mais cette beauté reflète simplement sa faiblesse par rapport à un bitmap généré de manière aléatoire.
Ce site Web semble générer des bitmaps aléatoires en noir et blanc avec des dimensions spécifiées. Par exemple, voici un bitmap $ 250\times 250 $ -pixel:
.
Ce bitmap est (censé être) aléatoire dans la mesure où un attaquant regardant n'importe quelle combinaison de ses pixels ne devrait pas avoir une chance meilleure que de deviner ce que pourrait être un autre pixel.
Combien d'entropie?
Malheureusement, MathJax n'est pas activé sur ce site, il est donc difficile de répondre directement à votre question sans qu'elle soit bizarre. Ici, je vais écrire une réponse comme si MathJax était disponible.
L'ensemble d'images RVB générées aléatoirement d'une longueur et d'une largeur données contient $$ {\ left (n_\text {Red} \, n_\text {Green} \, n_\text {Blue}\right)} ^ { n_\text {width} \, n_\text {height}} \,\text {members}\, $$ où:
$ n_\text {Red} $ est le nombre de valeurs possibles pour la dimension " rouge" d'un pixel;
$ n_\text {Green} $ est le nombre de valeurs possibles pour la dimension " verte" d'un pixel;
$ n_\text {Blue} $ est le nombre de valeurs possibles pour la dimension " bleu" d'un pixel;
$ n_\text {width} $ est le nombre de pixels dans la largeur; et
$ n_\text {length} $ est le nombre de pixels de la longueur.
Puis, comme l'entropie est $\log_2 {\ left (n_\text {members}\right)}, $ ce serait $$\begin {align}\left [\ text {entropy}\right] & ~ = ~\log_2 {\ left ({\ left (n_\text {Red} \, n_\text {Green} \, n_\text {Blue}\right)} ^ {n_\text {width} \, n_\text { hauteur}}\droite)}\[5px] & ~ = ~ {n_\text {width} \, n_\text {height}} \,\log_2 {\ left (n_\text {Red} \, n_\text {Vert} \, n_\text {Bleu}\right)} \,.\End {align} $$
Dans le cas d'une image en noir et blanc:
$ n_\text {Red} = 2, $ car il y a deux valeurs possibles pour le canal rouge;
$ n_\text {Green} = n_\text {Blue} = 1, $ puisque les valeurs des canaux vert et bleu sont définies pour égaler le canal rouge (de telle sorte que tous les pixels soient noirs ou blancs;
donc l'entropie serait $$\left [\ text {entropy}\right] ~ = ~ {n_\text {width} \, n_\text {height}} \,\log_2 {\ left (2\times 1\times 1\right)} ~ = ~ {n_\text {width} \, n_\text {height}}\,. $$
Donc, si vous parvenez à surmonter les problèmes initiaux liés à une taille de clé trop petite et à trop de pertes, et à utiliser KDF après, il y a un avantage à utiliser ces clés pour l'authentification après tout.
La génération de ces éléments doit prendre une éternité par rapport à un hachage traditionnel, donc si les paramètres initiaux sont traités comme un mot de passe, les temps d'attaque des mots de passe seront lents.
Mais il existe des moyens plus faciles d'obtenir cela. bcrypt() et les amis évoluent bien.