Concetto per programma crittografia

[^NeXsUs^]

Linguaggio : nessuno di specifico mi serve solamente il concetto

L'algoritmo che devo replicare fa questo:


----> testo
----> chiave ( generata casualmente , stessa lunghezza del testo)

a b c d e f g h i j k l m n o p q r s t u v w x y z

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

Testo

c ---> 3
i ---> 9
a ---> 1
o ---> 15

Chiave

t ---> 20
u ---> 21
j ---> 10
c ---> 3

Testo criptato

c + t = 3 + 20 ---> 23 = w
i + u = 9 + 21 ---> 30 = d
a + j = 1 + 10 ---> 11 = k
o + c = 15 + 3 ---> 18 = r

testo criptato = "wdkr"


Quindi io ho fatto questo:

in un 'array è contenute le lettere

Array("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z")


avviene questo:

viene immesso il testo
viene generata la chiave

-----------------------------

viene formato il testo criptato

nell'array ci sono 25 elementi ( contando il primo come 0)

avviene però un inconveniente

che talvolta sommando gli elementi si va al di fuori del 25
( esempio: testo = z (pos = 25) chiave = y (pos = 24) risultato ==> y
( pos 49)

quindi io ripercorro , mettiamo che venga 27 ( la z è 25 ) allora il valore è logicamente b e assegno al testo criptato il valore 1


il fatto è che quando si fa Chiave meno Testo criptato ( per tornare al valore in chiaro ) otteniamo un valore diverso per via del cambio di valore effettuato.

esempio:


Testo in chiaro:


c --------> 2
i --------> 8
a --------> 0
o --------> 14

chiave

i --------> 8
u --------> 20
b --------> 1
u --------> 20


Testo criptato

10
28 --------> (28 -26) (si ripercorre l'array) --> 2
1
34 --------> (34 -26) --------------------------> 8



Ma come ora vedrete questo cambio si rivela infelice:

posizione chiave

8
20
1
20

posizione testo_criptato

10
2
1
8

Testo chiaro

8 - 10 => -2 -> c
20 - 2 => 18 -> s
1 - 1 => 0 -> i
20 - 8 => 12 -> m


( il negativo viene trasformato in positivo tanto è uguale)

csim ---> non è ciao (!)

consiglio su come fare ?

se sei arrivato a leggere fino a qua sei 1 eroe -.-

[Lucis]

sbagli l'ultimo conto:

Testo chiaro

8 - 10 => -2 -> c
2-20 => -18 (negativo, quindi devi fare 26-18) -> 8 -> i
1 - 1 => 0 -> a
8-20 => -12 (negativo, quindi devi fare 26-12) -> 14 -> o

[^NeXsUs^]

il fatto è che con un programma si cripta
e con uno si decripta , come faccio a sapere quando devo invertire?

di solito faccio
chiave - testo_crypt


te invece fai

testo_crypt - chiave ( che come posso vedere è esatto)

Come faccio a capire quando devo eseguire quest'inversione ??

iL programma genere la chiave ed il testo criptato.

Spero che tu abbia capito.

Grazie e bye

[^NeXsUs^]

8 - 10 => -2 -> c
2-20 => -18 (negativo, quindi devi fare 26-18) -> 8 -> i
1 - 1 => 0 -> a
8-20 => -12 (negativo, quindi devi fare 26-12) -> 14 -> o

Poi 1 altra domanda anche il -2 è negativo , come mai non fai
26 -2??

[^NeXsUs^]

penso di aver trovato ...

a fare testo - chiave funziona

e inoltre a fare 26 + ( - negativi )

-.-

Chi mi da un saggio di matematica ??

[^NeXsUs^]

volevo fare in modo ke dalla testo generato fossero esclusi gli spazi e gli invii

(linguaggio visual basic) cosa c' è di sbagliato second voi ??

For x = 1 To lunghezza

' testo criptato = testoinchiaro + chiave

crypt(x) = CInt(text(x)) + CInt(chiave(x))


' se maggiore di 27 ( ho aggiunto lo spazio e l'invio) si applica il discorso di prima


If crypt(x) > 27 Then
crypt(x) = crypt(x) - 28
End If

' se è uguale a 27 o 26 ( la posizione dello spazio o dell'inzio) si
'esegue un for fino a che non viene assegnato il giusto valore

If crypt(x) = 27 or crypt(x) = 26 Then

For i = 0 To 1000

If crypt(x) = 27 Or crypt(x) > 27 or crypt(x) = 26 Then

chiave(x) = Int((25 * Rnd) + 1)
crypt(x) = CInt(text(x)) + CInt(chiave(x))
Else

Exit For

End If

Next

End If







Next x