CSPRNG - Historique des versions

Morel : /* Fortuna */

2018-11-24T23:26:56Z

Fortuna

← Version précédente		Version du 24 novembre 2018 à 23:26
Ligne 71 :		Ligne 71 :

	Une fois qu'une pool est utilisé, elle est vidée de ses bits d'entropies.		Une fois qu'une pool est utilisé, elle est vidée de ses bits d'entropies.


	== Sécurité ==		== Sécurité ==
Ligne 80 :		Ligne 79 :

	Indépendamment du nombre de faux événements généré par l’attaquant, ou combien d'événement il connaît, tant qu’il y a au moins une source d'événement aléatoire que l’attaquant ne peut pas prédire, il y aura toujours un accumulateur qui accueillera assez d’entropie pour le vaincre.		Indépendamment du nombre de faux événements généré par l’attaquant, ou combien d'événement il connaît, tant qu’il y a au moins une source d'événement aléatoire que l’attaquant ne peut pas prédire, il y aura toujours un accumulateur qui accueillera assez d’entropie pour le vaincre.



	== Divers ==		== Divers ==

Morel : /* Fortuna */

2018-11-24T23:26:24Z

Fortuna

← Version précédente		Version du 24 novembre 2018 à 23:26
Ligne 71 :		Ligne 71 :

	Une fois qu'une pool est utilisé, elle est vidée de ses bits d'entropies.		Une fois qu'une pool est utilisé, elle est vidée de ses bits d'entropies.


	== Sécurité ==		== Sécurité ==
Ligne 79 :		Ligne 80 :

	Indépendamment du nombre de faux événements généré par l’attaquant, ou combien d'événement il connaît, tant qu’il y a au moins une source d'événement aléatoire que l’attaquant ne peut pas prédire, il y aura toujours un accumulateur qui accueillera assez d’entropie pour le vaincre.		Indépendamment du nombre de faux événements généré par l’attaquant, ou combien d'événement il connaît, tant qu’il y a au moins une source d'événement aléatoire que l’attaquant ne peut pas prédire, il y aura toujours un accumulateur qui accueillera assez d’entropie pour le vaincre.



			== Divers ==


			Il a été nommé Fortuna en hommage à la déesse romaine du hasard.

	= Evolutions =		= Evolutions =

Morel : /* Sécurité */

2018-11-24T23:25:09Z

Sécurité

← Version précédente		Version du 24 novembre 2018 à 23:25
Ligne 75 :		Ligne 75 :


	Si l’attaquant ne connait pas les sources d'entropies, même s'il génère lui même beaucoup d'inputs, grâce au système circulaire, il ne serait pas en mesure de deviner P0 au prochain reseed.		Si l’attaquant ne connait pas les sources d'entropies, même s'il génère lui-même beaucoup d'inputs, grâce au système circulaire, il ne serait pas en mesure de deviner P0 au prochain reseed.
	Mais si il en connait suffisamment, alors il pourra déterminer P0 pour le prochain reseed. Mais comme P1 est utilisé 2 fois que P0, P2 quatre fois moins, etc. ils sont tous d'autant plus gros que P0, donc si le reseed nécessite plus que P0, il y aura trop de données imprévisibles pour l'attaquant.		Mais s'il en connait suffisamment, alors il pourra déterminer P0 pour le prochain reseed. Mais comme P1 est utilisé 2 fois moins que P0, P2 quatre fois moins, etc. ils sont tous d'autant plus gros que P0, donc si le reseed nécessite plus que P0, il y aura trop de données imprévisibles pour l'attaquant.

	Indépendamment du nombre de faux événements généré par l’attaquant, ou combien d'événement il connaît, tant qu’il y a au moins une source d'événement aléatoire que l’attaquant ne peut pas prédire, il y aura toujours un accumulateur qui accueillera assez d’entropie pour le vaincre.		Indépendamment du nombre de faux événements généré par l’attaquant, ou combien d'événement il connaît, tant qu’il y a au moins une source d'événement aléatoire que l’attaquant ne peut pas prédire, il y aura toujours un accumulateur qui accueillera assez d’entropie pour le vaincre.

Morel : /* Le mécansime de reseed */

2018-11-24T23:24:12Z

Le mécansime de reseed

← Version précédente		Version du 24 novembre 2018 à 23:24
Ligne 58 :		Ligne 58 :

	Dans Fortuna, nous avons deux conditions pour déclencher le mécanisme du reseed: il faut que la pool P0 fasse au moins 128 bits et qu'il se soit passé un temps t depuis le dernier reseed.		Dans Fortuna, nous avons deux conditions pour déclencher le mécanisme du reseed: il faut que la pool P0 fasse au moins 128 bits et qu'il se soit passé un temps t depuis le dernier reseed.
	La première ~~conditions~~ a pour but d'assurer un certain nombre de bit d'entropie à chaque reseed, la seconde est là pour défendre le générateur des attaques par génération d’événement, ainsi même si l'attaquant génère beaucoup d’événement (et donc beaucoup de bit d'entropie, la pool contiendra quand même des bits qu'il ne connait pas).		La première condition a pour but d'assurer un certain nombre de bit d'entropie à chaque reseed, la seconde est là pour défendre le générateur des attaques par génération d’événement, ainsi même si l'attaquant génère beaucoup d’événement (et donc beaucoup de bit d'entropie, la pool contiendra quand même des bits qu'il ne connait pas).

	Le mécanisme de reseed de Fortuna est très différent de celui de Yarrow, car il ne va pas ~~utilisé~~ une mais des pools.En effet, Fortuna va ~~utilisé~~ un compteur de reseed, qui va s’incrémente a chaque fois que l'on fait une opération de reseed.		Le mécanisme de reseed de Fortuna est très différent de celui de Yarrow, car il ne va pas utiliser une mais des pools. En effet, Fortuna va utiliser un compteur de reseed, qui va s’incrémente à chaque fois que l'on fait une opération de reseed.
	Pour chaque reseed, , nous allons vérifier les pools que nous allons utilisé. Pour qu'une pool soit utilisé, il faut que <math>2^i</math> (i étant le numéro de la pool) soit un diviseur du compteur de reseed.		Pour chaque reseed, nous allons vérifier les pools que nous allons utilisé. Pour qu'une pool soit utilisé, il faut que <math>2^i</math> (i étant le numéro de la pool) soit un diviseur du compteur de reseed.
	P0 est donc utilisé à chaque reseed, P1 ~~tout~~ les deux ~~reseed~~, P2 ~~tout~~ les 4 ~~reseed~~, etc.		P0 est donc utilisé à chaque reseed, P1 tous les deux reseeds, P2 tous les 4 reseeds, etc.

	Une fois que toutes les pools sont ~~selectionnées~~ pour le reseed, nous allons, pour toutes effectuer un XOR avec la seed, puis le ~~resultat~~ du XOR sera passé dans une fonction de hachage (pour Fortuna nous utilisons SHA-256).		Une fois que toutes les pools sont sélectionnées pour le reseed, nous allons pour toutes effectuer un XOR avec la seed, puis le résultat du XOR sera passé dans une fonction de hachage (pour Fortuna nous utilisons SHA-256).
	Le résultat de la fonction de hachage est ~~utilisé~~ comme nouvelle graine.		Le résultat de la fonction de hachage est utilisée comme nouvelle graine.

	[[Fichier:Reseed.PNG]]		[[Fichier:Reseed.PNG]]


	Une fois qu'une pool est utilisé, elle est ~~vidé~~ de ses bits d'entropies.		Une fois qu'une pool est utilisé, elle est vidée de ses bits d'entropies.


	== Sécurité ==		== Sécurité ==

Morel : /* L'accumulateur d'entropie */

2018-11-24T23:20:14Z

L'accumulateur d'entropie

← Version précédente		Version du 24 novembre 2018 à 23:20
Ligne 42 :		Ligne 42 :


	La ~~principal~~ différence entre Fortuna et Yarrow réside dans ses accumulateurs d'entropie.		La principale différence entre Fortuna et Yarrow réside dans ses accumulateurs d'entropie.

	Dans Yarrow, nous avions deux pools qui stockaient les bits d'entropies que générait le système. Dans Fortuna, nous avons 32 pools (numéroté de P0 à P31). Un pool étant une chaîne de bits de taille non borné.		Dans Yarrow, nous avions deux pools qui stockaient les bits d'entropies que générait le système. Dans Fortuna, nous avons 32 pools (numéroté de P0 à P31). Un pool étant une chaîne de bits de taille non borné.
	L'idée dans Fortuna est que les différentes sources d'entropies vont distribuer leurs bits d'entropie de façon circulaire entre les différentes pools. C'est à dire que prenons comme source d'entropie une saisie clavier, chaque touche va créer des bits d'entropie, les bits de la première touche iront dans la pool P0, puis ceux de la deuxième entrée iront dans P1, etc. De sorte que la 33ème entrée clavier créera des bits d'entropie stocké dans P0.		L'idée dans Fortuna est que les différentes sources d'entropies vont distribuer leurs bits d'entropie de façon circulaire entre les différentes pools. C'est-à-dire que prenons comme source d'entropie une saisie clavier, chaque touche va créer des bits d'entropie, les bits de la première touche iront dans la pool P0, puis ceux de la deuxième entrée iront dans P1, etc. De sorte que la 33ème entrée clavier créera des bits d'entropie stocké dans P0.

	Comme illustré ci dessous: Les différentes couleurs représentent les bits générés par les différentes sources d'entropies		Comme illustré ci-dessous : Les différentes couleurs représentent les bits générés par les différentes sources d'entropies.

	[[Fichier:EntropieCirculaire.PNG]]		[[Fichier:EntropieCirculaire.PNG]]
Ligne 53 :		Ligne 53 :

	Cela permet de répartir les bits générés par les sources d'entropie afin d'avoir des suites de bits plus aléatoires.		Cela permet de répartir les bits générés par les sources d'entropie afin d'avoir des suites de bits plus aléatoires.


	== Le mécansime de reseed ==		== Le mécansime de reseed ==

Morel : /* Evolutions */

2018-11-24T23:18:00Z

Evolutions

← Version précédente		Version du 24 novembre 2018 à 23:18
Ligne 83 :		Ligne 83 :

	= Evolutions =		= Evolutions =

			Même si Fortuna a été publié en 2003, le sujet est toujours ouvert car la problèmatique d'avoir des générateurs pseudo-aléatoires est omniprésente.
			En 2014, un article est paru sur une manière d'améliorer Fortuna, pour le rendre robuste a plus de type d'attaques.

	= Sources et Liens utiles =		= Sources et Liens utiles =

Morel : /* Fortuna */

2018-11-24T23:08:52Z

Fortuna

← Version précédente		Version du 24 novembre 2018 à 23:08
Ligne 35 :		Ligne 35 :
	= Fortuna =		= Fortuna =


	Fortuna est une évolution du générateur pseudo-aléatoire Yarrow. Il a été crée par Bruce SCHNEIER et Niels FERGUSON, et a été publié en 2003.		Fortuna est une évolution du générateur pseudo-aléatoire Yarrow. Il a été crée par Bruce SCHNEIER et Niels FERGUSON, et a été publié en 2003. Il a notamment été utilisé dans Windows 8.
	Il reprend plusieurs idées de Yarrow, notamment ses 3 trois composants principaux, qui sont: l'accumulateur d'entropie, la seed et un générateur de nombre.		Il reprend plusieurs idées de Yarrow, notamment ses 3 trois composants principaux, qui sont: l'accumulateur d'entropie, la seed et un générateur de nombre.

	== L'accumulateur d'entropie ==		== L'accumulateur d'entropie ==


	La principal différence entre Fortuna et Yarrow réside dans ses accumulateurs d'entropie.		La principal différence entre Fortuna et Yarrow réside dans ses accumulateurs d'entropie.
Ligne 54 :		Ligne 56 :

	== Le mécansime de reseed ==		== Le mécansime de reseed ==


	Dans Fortuna, nous avons deux conditions pour déclencher le mécanisme du reseed: il faut que la pool P0 fasse au moins 128 bits et qu'il se soit passé un temps t depuis le dernier reseed.		Dans Fortuna, nous avons deux conditions pour déclencher le mécanisme du reseed: il faut que la pool P0 fasse au moins 128 bits et qu'il se soit passé un temps t depuis le dernier reseed.
Ligne 69 :		Ligne 72 :

	Une fois qu'une pool est utilisé, elle est vidé de ses bits d'entropies.		Une fois qu'une pool est utilisé, elle est vidé de ses bits d'entropies.


	== Sécurité ==		== Sécurité ==


	Si l’attaquant ne connait pas les sources d'entropies, même s'il génère lui même beaucoup d'inputs, grâce au système circulaire, il ne serait pas en mesure de deviner P0 au prochain reseed.		Si l’attaquant ne connait pas les sources d'entropies, même s'il génère lui même beaucoup d'inputs, grâce au système circulaire, il ne serait pas en mesure de deviner P0 au prochain reseed.

Morel : /* Fortuna */

2018-11-24T23:07:36Z

Fortuna

← Version précédente		Version du 24 novembre 2018 à 23:07
Ligne 69 :		Ligne 69 :

	Une fois qu'une pool est utilisé, elle est vidé de ses bits d'entropies.		Une fois qu'une pool est utilisé, elle est vidé de ses bits d'entropies.

			== Sécurité ==

			Si l’attaquant ne connait pas les sources d'entropies, même s'il génère lui même beaucoup d'inputs, grâce au système circulaire, il ne serait pas en mesure de deviner P0 au prochain reseed.
			Mais si il en connait suffisamment, alors il pourra déterminer P0 pour le prochain reseed. Mais comme P1 est utilisé 2 fois que P0, P2 quatre fois moins, etc. ils sont tous d'autant plus gros que P0, donc si le reseed nécessite plus que P0, il y aura trop de données imprévisibles pour l'attaquant.

			Indépendamment du nombre de faux événements généré par l’attaquant, ou combien d'événement il connaît, tant qu’il y a au moins une source d'événement aléatoire que l’attaquant ne peut pas prédire, il y aura toujours un accumulateur qui accueillera assez d’entropie pour le vaincre.

	= Evolutions =		= Evolutions =

Morel : /* Fortuna */

2018-11-24T22:53:42Z

Fortuna

← Version précédente		Version du 24 novembre 2018 à 22:53
Ligne 64 :		Ligne 64 :
	Une fois que toutes les pools sont selectionnées pour le reseed, nous allons, pour toutes effectuer un XOR avec la seed, puis le resultat du XOR sera passé dans une fonction de hachage (pour Fortuna nous utilisons SHA-256).		Une fois que toutes les pools sont selectionnées pour le reseed, nous allons, pour toutes effectuer un XOR avec la seed, puis le resultat du XOR sera passé dans une fonction de hachage (pour Fortuna nous utilisons SHA-256).
	Le résultat de la fonction de hachage est utilisé comme nouvelle graine.		Le résultat de la fonction de hachage est utilisé comme nouvelle graine.

			[[Fichier:Reseed.PNG]]


			Une fois qu'une pool est utilisé, elle est vidé de ses bits d'entropies.

	= Evolutions =		= Evolutions =

Morel : /* Fortuna */

2018-11-24T22:48:56Z

Fortuna

← Version précédente		Version du 24 novembre 2018 à 22:48
Ligne 45 :		Ligne 45 :
	L'idée dans Fortuna est que les différentes sources d'entropies vont distribuer leurs bits d'entropie de façon circulaire entre les différentes pools. C'est à dire que prenons comme source d'entropie une saisie clavier, chaque touche va créer des bits d'entropie, les bits de la première touche iront dans la pool P0, puis ceux de la deuxième entrée iront dans P1, etc. De sorte que la 33ème entrée clavier créera des bits d'entropie stocké dans P0.		L'idée dans Fortuna est que les différentes sources d'entropies vont distribuer leurs bits d'entropie de façon circulaire entre les différentes pools. C'est à dire que prenons comme source d'entropie une saisie clavier, chaque touche va créer des bits d'entropie, les bits de la première touche iront dans la pool P0, puis ceux de la deuxième entrée iront dans P1, etc. De sorte que la 33ème entrée clavier créera des bits d'entropie stocké dans P0.

	~~Cela~~ ~~permet~~ de ~~répartir~~ les bits générés par les sources d'~~entropie afin d'avoir des suites de bits plus aléatoires.~~		Comme illustré ci dessous: Les différentes couleurs représentent les bits générés par les différentes sources d'entropies

			[[Fichier:EntropieCirculaire.PNG]]


			Cela permet de répartir les bits générés par les sources d'entropie afin d'avoir des suites de bits plus aléatoires.


	== Le mécansime de reseed ==		== Le mécansime de reseed ==

			Dans Fortuna, nous avons deux conditions pour déclencher le mécanisme du reseed: il faut que la pool P0 fasse au moins 128 bits et qu'il se soit passé un temps t depuis le dernier reseed.
			La première conditions a pour but d'assurer un certain nombre de bit d'entropie à chaque reseed, la seconde est là pour défendre le générateur des attaques par génération d’événement, ainsi même si l'attaquant génère beaucoup d’événement (et donc beaucoup de bit d'entropie, la pool contiendra quand même des bits qu'il ne connait pas).

			Le mécanisme de reseed de Fortuna est très différent de celui de Yarrow, car il ne va pas utilisé une mais des pools.En effet, Fortuna va utilisé un compteur de reseed, qui va s’incrémente a chaque fois que l'on fait une opération de reseed.
			Pour chaque reseed, , nous allons vérifier les pools que nous allons utilisé. Pour qu'une pool soit utilisé, il faut que <math>2^i</math> (i étant le numéro de la pool) soit un diviseur du compteur de reseed.
			P0 est donc utilisé à chaque reseed, P1 tout les deux reseed, P2 tout les 4 reseed, etc.

			Une fois que toutes les pools sont selectionnées pour le reseed, nous allons, pour toutes effectuer un XOR avec la seed, puis le resultat du XOR sera passé dans une fonction de hachage (pour Fortuna nous utilisons SHA-256).
			Le résultat de la fonction de hachage est utilisé comme nouvelle graine.

	= Evolutions =		= Evolutions =

CSPRNG - Historique des versions

Morel : /* Fortuna */

Morel : /* Fortuna */

Morel : /* Sécurité */

Morel : /* Le mécansime de reseed */

Morel : /* L'accumulateur d'entropie */

Morel : /* Evolutions */

Morel : /* Fortuna */

Morel : /* Fortuna */

Morel : /* Fortuna */

Morel : /* Fortuna */

Morel : /* Fortuna */

Morel : /* Fortuna */

Morel : /* Sécurité */

Morel : /* Le mécansime de reseed */

Morel : /* L'accumulateur d'entropie */

Morel : /* Evolutions */

Morel : /* Fortuna */

Morel : /* Fortuna */

Morel : /* Fortuna */

Morel : /* Fortuna */