Comment calculer une graine aléatoire?

Question

Comment calculer une graine aléatoire?

- 6
- 81 2019-05-08
Parexemple,nous avons 126/128non desnon-faciles,révélé au cycle 99. /chaînes/principales/Blocs/409599/Contexte/RAW/JSON/CYCLE/98/NONFESSE? Profondeur=1

Sije comprendsbien,utilisez cesnon -ces,nouspouvons calculer lagraine aléatoire.Quelqu'unpeut-ilexpliquer commentfaire cela?

For example, we have 126/128 nonces, revealed in cycle 99. /chains/main/blocks/409599/context/raw/json/cycle/98/nonces?depth=1

If I understand correctly, using these nonces we can calculate the random seed. Can anybody explain how to do this?

protocol consensus cryptography

1 réponses

votes

Tom · Accepted Answer · 2019-05-16

7

2019-05-16

Nous auronsbesoin de ces opérations:

blake2b :taille 32
concat : Concaténation destableaux d'octets

Aussi,laisse zero_bytes 32 zéro octets.

Ma réponseestbasée sur Seed_storage.ml et Seed_repr.ml ,avec une certaineexpérimentation.

Grainesinitiales

Commençons au début.

Lespremierspréservés_cycles + 2=7graines ont été déterminés à l'avance,comme suit. Lapremièregraineest le hachage dumessage vide:

 graine [0]=Blake2b ([])=0E5751C026E543B2E8AB2EB06099DAA1D1E5DF47778F7787FAAB45CDF12FE3A8

Les 6grainesinitiales restantes sont chacune calculées de laprécédente:

 graines [n]=blake2b (Concat (graine [N-1],zéro_bytes))

Cela donne lesgrainesinitiales suivantes:

 | Cycle| semences|
| ------- + ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ---------------------------|
| 0| 0E5751C026E543B2E8AB2EB06099DAA1D1E5DF47778F7787FAAB45CDF12FE3A8|
| 1| C8DB55740733852AA18AA82E108E4475B1ABCF3F1F077AC966E9CECCA86612EC|
| 2| 270DA140DE63850F631D09A95EB26DC39CC92F8FEAE73875C7CF9AAA3BF4CAC|
| 3| 97D50852C159ADA8E9F107E98F693B059BA28336C723E6CD0F6353EB3C0CB415|
| 4| 0C7EA5EE0B25B7105F934C6511756EC20ABCF5C6EA4D45721C138C3E751469B|
| 5| beb4d79B65FAA3E902E73D031AD6466299F01AAB517D303151A99605A259A11E|
| 6| 5E695AE038C2BDC54706547FC743EB3564CA5A0B4B5D8E9DE2CA4780157CA61E|

Lagraine du cycle suivant

Àpartir d'ici,nous utilisons les seuils révéléespour calculer laprochainegraine de lagraineprécédente:

 graine [n]=graine [n-1]
# Commencezpar un «zérononce»:
graine [n]=blake2b (Concat (graine [n],zéro_bytes))
# Ensuite,utilisez lesnon-ances révélées:
Pour lanonce dans Nonces_for [N]:
 graine [N]=Blake2b (Concat (graine [n],nonce))

Lesnon -ces sontprises dans décroissant la commande deniveau .

Parexemple,pour calculer lagraine aléatoirepour le cycle 7,nouspouvons saisir lesnon -es révélés au cours du cycle 0:

  # Lemeilleurniveau semble être ((N-5) * 4096) -1?
# Avertissement,cen'estpas complet,voir ci-dessous.
# 8191=((7-5) * 4096) -1
# 0=7-7
Curl -s http://localhost: 18732/Chaînes/Main/Blocs/8191/Contexte/RAW/JSON/CYCLE/0/NONCES? PROFONCED=1 \
 | JQ -R '. []| "\ (. [0]) \t \t \ (. [1])" '|trier -rnk1| Couper -f2

Lapremièrenonce (en ordre décroissant de la commande)est "1EE95FE66B ...",et le dernierest "D1012E79AB ...",doncnous calculons:

  #graine=="5E695AE038C2BDC5470654FCC743EB3564CA5A0B4B5D8E9DE2CA4780157CA61E"

# zérononce
Seed=Blake2b (Concat (graine,"000000000000000000000000000000000000000000000000"))
#graine=="9B7328E5393A466FC47EF16EB74121939B06E6EC4C17295EB25611F1B76D6A33"

#premièrenonce
Seed=Blake2b (Concat (graine,"1ee95fe66BB3DC2A62195DD41A07A30835E63B91DB395A64150DA3Decc3be1C"))
# Semences=="F9B94526A502A1D8E4042EBA2DEB682DD752627EA6E4472187AD1C1E465BE0F4")

# ... les autresnon-ances ...
#graine=="469A48304FC415870289AC8BD875B04107381A2471A878A2A8DA16E43DFC5880"

# Derniernonce
Seed=Blake2b (Concat (graine,"D1012E79ABC75FFC4228F69ACE060E1003C8FF0A9D58A2D78816713B72C278"))
# Seed=="1BCD1D832AFF2D72A8D16A9F9E5F994E177E29EAC789138B019F0C4A30C4E5EC"

jusqu'àprésent sibon:

  $ CURL http://localhost: 18732/Chaînes/Main/Blocs/24575/Contexte/Raw/Json/Cycle/7/Random_seed
"1bcd1d832aff2D72A8D16A9F9E5F994E177E29EAC789138B019F0C4A30C4E5EC"

Comment obtenir lesnon -ces?

Cependant,si vous continuez,vous rencontrez unproblème.

Jene croispas qu'il soitpossible d'utiliser Context/RAW/JSON/CYCLE/& LT; CYCLE & GT;/NONFES Pour obtenir tous lesnon-ances révélées. Si unenonceest révéléejuste au cycle Dawn,je pense que cela sera supprimépar leprotocoleimmédiatement après utilisation,avant qu'il soitmis à disposition via le contextebrut RPC.

Lepremierproblème semble être la révélation dans lebloc auniveau 200704.

Bien sûr,si vous construisez une coquille Alt-shell,vous acquérireznaturellement lesnon-ances,et si,commemoi,vous êtesjuste curieux,celan'apas d'importance.

We will need these operations:

blake2b: size 32
concat: concatenation of byte arrays

Also, let zero_bytes be 32 zero bytes.

My answer is based on seed_storage.ml and seed_repr.ml, with some experimentation.

Initial seeds

Let's start at the beginning.

The initial preserved_cycles+2 = 7 seeds were determined ahead of time, as follows. The first seed is the hash of the empty message:

seed[0] = blake2b([]) = 0e5751c026e543b2e8ab2eb06099daa1d1e5df47778f7787faab45cdf12fe3a8

The remaining 6 initial seeds are each computed from the previous:

seed[n] = blake2b(concat(seed[n-1], zero_bytes))

This gives the following initial seeds:

| cycle | seed                                                             |
|-------+------------------------------------------------------------------|
|     0 | 0e5751c026e543b2e8ab2eb06099daa1d1e5df47778f7787faab45cdf12fe3a8 |
|     1 | c8db55740733852aa18aa82e108e4475b1abcf3f1f077ac966e9cecca86612ec |
|     2 | 270da140de63850f631d09a95eab26dc39cc92f8feae73875c7cf9aaa3bf4cac |
|     3 | 97d50852c159ada8e9f107e98f693b059ba28336c723e6cd0f6353eb3c0cb415 |
|     4 | 0c7ea5ee0b25b7105f934c6511756ec20abcf5c6eea4d45721c138c3e751469b |
|     5 | beb4d79b65faa3e902e73d031ad6466299f01aab517d303151a99605a259a11e |
|     6 | 5e695ae038c2bdc54706547fc743eb3564ca5a0b4b5d8e9de2ca4780157ca61e |

The next cycle's seed

From here, we use the revealed nonces to compute the next seed from the previous seed:

seed[n] = seed[n-1]
# start with a 'zero nonce':
seed[n] = blake2b(concat(seed[n], zero_bytes))
# then use the revealed nonces:
for nonce in nonces_for[n]:
  seed[n] = blake2b(concat(seed[n], nonce))

The nonces are taken in decreasing level order.

For example, to calculate the random seed for cycle 7, we can grab the nonces revealed over the course of cycle 0:

# The best level seems to be ((n-5)*4096)-1?
# Warning, this is not complete, see below.
# 8191 = ((7-5)*4096)-1
# 0 = 7-7
curl -s http://localhost:18732/chains/main/blocks/8191/context/raw/json/cycle/0/nonces?depth=1 \
   | jq -r '.[] | "\(.[0])\t\(.[1])"' | sort -rnk1 | cut -f2

The first nonce (in decreasing level order) is "1ee95fe66b...", and the last is "d1012e79ab...", so we compute:

# seed == "5e695ae038c2bdc54706547fc743eb3564ca5a0b4b5d8e9de2ca4780157ca61e"

# zero nonce
seed = blake2b(concat(seed, "0000000000000000000000000000000000000000000000000000000000000000"))
# seed == "9b7328e5393a466fc47ef16eb74121939b06e6ec4c17295eb25611f1b76d6a33"

# first nonce
seed = blake2b(concat(seed, "1ee95fe66bb3dc2a62195dd41a07a30835e63b91db395aa64150da3decc3be1c"))
# seed == "f9b94526a502a1d8e4042eba2deb682dd752627ea6e4472187ad1c1e465be0f4")

# ... the other nonces ...
# seed == "469a48304fc415870289ac8bd875b04107381a2471a878a2a8da16e43dfc5880"

# last nonce
seed = blake2b(concat(seed, "d1012e79abc75ffc4228f69ace060e1003c8fff0aa9d58a2d78816713b72c278"))
# seed == "1bcd1d832aff2d72a8d16a9f9e5f994e177e29eac789138b019f0c4a30c4e5ec"

So far so good:

$ curl http://localhost:18732/chains/main/blocks/24575/context/raw/json/cycle/7/random_seed
"1bcd1d832aff2d72a8d16a9f9e5f994e177e29eac789138b019f0c4a30c4e5ec"

How to get the nonces?

However, if you keep going, you will run into a problem.

I don't believe it is possible to use context/raw/json/cycle/<cycle>/nonces to get all the revealed nonces. If a nonce is revealed just at cycle dawn, I believe it will be deleted by the protocol immediately upon use, before it is made available via the raw context RPC.

The first problem seems to be the revelation in the block at level 200704.

Of course, if you are building an alt-shell, you will naturally acquire the nonces, and if, like me, you are just curious, this doesn't matter.

Explication soignée,merci!Vous avezfait unefaute defrappeici `graine [n]=blake2b (Concat (graine (n-1],nonce))` -il devrait être `concat (graine [n],nonce)`;) BTW,j'ai créé ungist surC # avec lagénération d'unegraine aléatoire,peut-être que quelqu'un letrouverait utile.https://gist.github.com/groxan/c0f11A896BCF9A43E0FFF9BA2E46223B

Neat explanation, thanks! You made a typo here `seed[n] = blake2b(concat(seed[n-1], nonce))` - it should be `concat(seed[n], nonce)` ;) Btw, I created a gist on C# with generation of a random seed, maybe someone would find it useful. https://gist.github.com/Groxan/c0f11a896bcf9a43e0fff9ba2e46223b
- 1
- 2019-05-16
- Groxan
En ce qui concerne la révélation dans lebloc auniveau 200704 - c'était une surprisepourmoi=) J'aiessayé d'obtenir lagraine de lagraine,elle étaitincorrectejusqu'à ce quej'ai annoncé la dernièrenonce.Malheureusement,il y atellement depièges quine sontpas décrits dans les documents.

As for the revelation in the block at level 200704 - it was a surprise for me =) I tried to get the seed an it was incorrect until I appended the last nonce. Sadly, there are so many pitfalls that are not described in the docs.
- 1
- 2019-05-16
- Groxan
Whoops,merci,c'est ce queje reçoispouressayer d'écrirepseudocodeimpératif.;)

Whoops, thanks, that is what I get for trying to write imperative pseudocode. ;)
- 1
- 2019-05-16
- Tom