Notebook di Enrico Fiorani!!!

CIFRARIO A FLUSSO DI BLUM - GOLDWASSER

Inserisci il valore di p primo (t . c .  p mod 4 = 
          3)

p = 4;
n1 = 2;
While[! PrimeQ[p], n1 = Random[Integer, {100, 2300}]; 
      p = n1*4 + 3]
p
PrimeQ[p]

Inserisci il valore di q primo (t . c .  q mod 4 = 
          3)

q = 4;
n2 = 2;
While[! PrimeQ[q], n2 = Random[Integer, {100, 2300}]; 
      q = n2*4 + 3]
q
PrimeQ[q]
Check[q != p, n]

Valore di n da inviare

n = p*q

Valori di a e b (t . c .  ap + bq = 1)  usando l' 
      estensione dell' algoritmo di Euclide

{uno, {a, b}} = ExtendedGCD[p, q];
a
b

Mi scelgo s coprimo con n e mi calcolo x0

s = n;
While[GCD[s, n] ≠ 1, 
      s = Random[Integer, {11, n - 1}]]
GCD[s, n]
s

x0 = PowerMod[s, 2, n]; x0

Itero il passo precedente per ottenere tutti i vari xi che voglio ottenere!!

Array[x, 5];
x[0] = x0;
t = 5;
For[i = 1, i < t + 1, i++, 
      x[i] = PowerMod[x[i - 1], 2, n]]
x[t]
x[t + 1] = PowerMod[x[t], 2, n]

Per ogni blocco Mi di log (n) parte intera bit Faccio la somma modulo due con il blocco di bit associato al corrispondente xi;
Ottengo così per ogni blocco Mi il suo criptato Ci . 
Invio il dato X (t + 
          1) esimo al destinatario; sarà l' unico ingrado di estrarre da esso la radice quadrata modulo n e quindi ottenere il valore di x0

x[t]

Calcolo il seed corrispondente a x0 , 
                    cioè il valore di u, 
                    v     come x0d = aup + bvq

                        1) 
                  Mi calcolo il valore di d1 e d2       

                            d1 = ((p + 1)/4)^t + 
                      1    mod (p - 1);

                            d2 = ((q + 1)/4)^t + 
                    1     mod (q  - 
                            1) . 
2) 
              Con questi mi ricavo il valore di u e v

                             u = (Xt + 1 )^
                    d1    mod p;

                             v = (Xt + 1 )^
                  d2    mod q . 
       3) Ora ho tutto per calcolarmi x0

                             x0d = 
            aup + bvq;

                           4) Partendo da x0 posso ricalcolarmi tutti gli xi del mittente

dp = (p + 1)/4;

     dq = (q + 1)/4;

    d1 = PowerMod[dp, t + 1, p - 1]

    d2 = PowerMod[dq, t + 1, q - 1]

u = PowerMod[x[t + 1], d1, p]
v = PowerMod[x[t + 1], d2, q]

x0d2 = (a*v*p) + (b*u*q);
x0d = Mod[x0d2, n]

Per ogni blocco Ci di log (n) parte intera bit faccio nuovamente la somma modulo due con il blocco di bit associato al corrispondente xi appena calcolato ottenuto x0 e avendo n;
Ottengo così blocco per blocco tutto il messaggio M  originale decriptato.