Ultima modifica:
Ciao a tutti, eccomi di nuovo
Proseguo il mio discorso sulla sicurezza informatica e le nuove sfide del futuro. Probabilmente sono un po' presuntuoso ma diciamo che mi piace aprire a nuove idee e poterle discutere. Comunque, a parte tutto vorrei farvi conoscere questo tipo di codifica costruita apposta sulla capacità dell'algoritmo GC57 di fattorizzare grandi semiprimi a tempo zero.
Nel precedente post ho mostrato l'algoritmo GC57 abbinato alla codifica SHA e AES, ma il mio vero obbiettivo è quello di creare una codifica personalizzata adatta alla capacità di fattorizzazione del mio algoritmo.
Probabilmente spiegarlo sarà un po' complesso ma allegherò lo script in Python così chi ne ha voglia lo può eseguire direttamente sul proprio computer, questa volta senza la parte grafica.
Iniziamo:
PRIMA FASE:
Spero la cosa vi piaccia, e accetto qualsiasi critica costruttiva
Grazie
Proseguo il mio discorso sulla sicurezza informatica e le nuove sfide del futuro. Probabilmente sono un po' presuntuoso ma diciamo che mi piace aprire a nuove idee e poterle discutere. Comunque, a parte tutto vorrei farvi conoscere questo tipo di codifica costruita apposta sulla capacità dell'algoritmo GC57 di fattorizzare grandi semiprimi a tempo zero.
Nel precedente post ho mostrato l'algoritmo GC57 abbinato alla codifica SHA e AES, ma il mio vero obbiettivo è quello di creare una codifica personalizzata adatta alla capacità di fattorizzazione del mio algoritmo.
Probabilmente spiegarlo sarà un po' complesso ma allegherò lo script in Python così chi ne ha voglia lo può eseguire direttamente sul proprio computer, questa volta senza la parte grafica.
Iniziamo:
PRIMA FASE:
- Fattorizzazione del numero con l'algoritmo GC57: Ottenere due fattori primi molto grandi da questo processo, che chiameremo p e q.
- Trasformazione di p in una lista di pacchetti di due cifre: Ogni cifra di p viene divisa in pacchetti di due cifre.
- Trasformazione del testo in codice ASCII UTF-8: Il testo da codificare viene trasformato in codice ASCII UTF-8.
- Creazione di variabili m1, m2, m3, m4, m5: Cinque variabili composte da numeri a tre cifre selezionate casualmente da 100 a 400.
- Selezione casuale di una posizione di partenza per la codifica: Questa posizione determina da quale pacchetto di due cifre iniziare ad estrarre i pacchetti.
- Codifica del testo: Ogni carattere del testo viene codificato in base alle regole riportate nello script
- Estrazione di due serie di numeri dal fattore primo q: Le serie vengono divise in pacchetti di tre cifre.
- Gestione automatica della lunghezza del fattore primo q: Le serie vengono create automaticamente in base alla lunghezza di q.
- Scelta casuale di due tipi di partenza per le serie: Queste due serie vengono create a partire da due numeri di partenza selezionati casualmente.
- Trasformazione dei pacchetti in binario a 11 bit: Ogni pacchetto di tre cifre viene trasformato in un numero binario a 11 bit.
- Esecuzione di uno XOR tra le due serie binarie: Ottenendo così un'altra lista binaria che è il risultato di questa operazione.
- Trasformazione della lista di codifica del testo in binario a 11 bit: Ogni pacchetto di tre cifre della lista di codifica del testo viene trasformato in un numero binario a 11 bit.
- Esecuzione di uno XOR tra la lista binaria del testo e la lista ottenuta dall'operazione XOR precedente: Ciò produce una serie di caratteri indecifrabili.
- Salvataggio dei caratteri indecifrabili in un file con il semiprimo: Questi caratteri indecifrabili vengono salvati in un file insieme al semiprimo utilizzato per la codifica.
Spero la cosa vi piaccia, e accetto qualsiasi critica costruttiva
Grazie
Python:
import time
from sympy import nextprime
from random import randint, seed
from math import gcd
from tkinter import messagebox
import pickle
T = int(time.time())
seed(T)
#############################################################
# Cripta il Testo #
# #
#############################################################
def cripta():
global start
f1 = "Questa prova viene fatta sulla chiave creata in base alla capacità del GC57 di fattorizzare a tempo zero"
lc = p
if f1 == "" or lc == "":
messagebox.showerror("Attenzione", "Testo assente\no codice non creato")
return
# start=randint(10, 99)
start1 = str(p)
start2 = len(start1)
start = int(start1[start2 - 5] + start1[start2 - 4])
ln = list(str(p))
if len(ln) % 2 == 0:
pass
else:
ln.append("0")
divln = []
for i in range(0, len(ln), 2):
c1 = int(ln[i])
c2 = int(ln[i + 1])
c3 = c1 * 10 + c2
divln.append(c3)
# **********************************************
m1 = randint(100, 400)
m2 = randint(100, 400)
m3 = randint(100, 400)
m4 = randint(100, 400)
m5 = randint(100, 400)
# **********************************************
text = f1
te = list(text)
cont = start
tcript = ""
#*************************
#*regole di codifica testo
#*************************
for i in range(len(text)):
if cont == len(divln):
cont = 0
if ord(te[i]) > 700:
pass
else:
x = int(divln[cont])
if x >= 0 and x < 25:
x = x + m1 + ord(te[i])
if x >= 25 and x < 40:
x = x + m2 + ord(te[i])
if x >= 40 and x < 50:
x = x + m3 + ord(te[i])
if x >= 50 and x < 75:
x = x + m4 + ord(te[i])
if x >= 75 and x < 100:
x = x + m5 + ord(te[i])
tcript = tcript + str(x)
cont = cont + 1
tcript = tcript + str(m1)
tcript = tcript + str(m2)
tcript = tcript + str(m3)
tcript = tcript + str(m4)
tcript = tcript + str(m5)
return tcript
# *questa sezione è stata inserita solo a scopo dimostrativo in quanto questi dati
# *si trovano su un file esterno con la chiave depositata su una chiavetta usb e i semiprimi
# *depositati su un file sul computer
p = 24964972716179047651923503587642737203496975848468454149742484589578883959776102415987057830879902101559923045226592975382315619483225807675186841965247444805939755771860933765897903505211618196684178843309478132310067314962580632915843266403636514182700202888802870583515643063571043029234602161812325995750704457487178377087517648150292019444494132649129587608968337851293913406885609041518844558698948829050332455826025982339981
q = 855993746605259098212990754575248117605462381501198780862662133065766977660360319681431278598560926942347435625907731344718725850249642008564092324010489916258668374060754822896159267626577561700562627621592972505053506877503522610087555859905189033956696052386213412114705640019491011296007975942456669005472148659600119423585179783111805803460334573340545431952809263901220385354627637588942726860672609932207170073138197425481553868585145666451834571647955543658580781774728440778301
chiave = 146184337496259067184180925429750531804780253333913615143779765650617637412151635266654413674040737151817895730292854740211007744430411496899996025130289255875153395065363436021836304374263122352171779805688399258984487671446514644302244718440103055813861467192486142441315216874494273225062416128065466667043611321470149531917506714291973544689561765425468011854994268794060135693802523397641309626888941787009484059009581093591443717613820410404222097398341
nd = nextprime(p + randint(1, 1000000 * 2**75))
nd2 = nextprime(q + randint(1, 1000000 * 2**75))
# *******************************************************************************************
n = nd * nd2
a = n % chiave
b = n - a
for i in range(10):
r = gcd(a, b)
if r != 1:
p = r
q = n // p
break
a = a + chiave
b = b - chiave
if r == 1:
quit()
testo_cript = cripta()
lista_tc = list(testo_cript)
lista_tc3 = []
for i in range(0, len(lista_tc), 3):
lista_tc3.append(lista_tc[i] + lista_tc[i + 1] + lista_tc[i + 2])
# print('testo scostamento',lista_tc3)
# *calcola la serie di numeri in pacchetti di 3 che si può estrarre
lista_q = list(str(q))
n_round = ((len(lista_q) - 100)) // 3 * 3
# *creo due punti di partenza differenti
start1 = str(q)
start2 = len(start1)
c_round1 = int(start1[start2 - 9] + start1[start2 - 3])
c_round2 = int(start1[start2 - 7] + start1[start2 - 4])
# *creo due liste contenenti un numero divisibile per 3
div_round1 = []
div_round2 = []
for ii in range(c_round1, c_round1 + n_round, 3):
# print(lista_q[c_round]+lista_q[c_round+1]+lista_q[c_round+2])
div_round1.append((lista_q[ii] + lista_q[ii + 1] + lista_q[ii + 2]))
for ii in range(c_round2, c_round2 + n_round, 3):
# print(lista_q[c_round]+lista_q[c_round+1]+lista_q[c_round+2])
div_round2.append((lista_q[ii] + lista_q[ii + 1] + lista_q[ii + 2]))
# ************************************************************
chiave_xor = ""
chiave_bin1 = ""
rip_chiave_bin1 = ""
for i in range(len(div_round1)):
num_int = int(div_round1[i])
bin1 = bin(num_int)[2:].zfill(11)
chiave_bin1 = chiave_bin1 + chr(int(bin1, 2))
num_int = int(div_round2[i])
bin2 = bin(num_int)[2:].zfill(11)
int_bin1 = int(bin1, 2)
int_bin2 = int(bin2, 2)
bin_x = int_bin1 ^ int_bin2
xor_bin = bin(bin_x)[2:].zfill(11)
chiave_xor = chiave_xor + chr(int(xor_bin, 2))
c_xor = list(chiave_xor)
ii = 0
testo_criptato = ""
for i in range(len(lista_tc3)):
if ii > len(c_xor):
ii = 0
p_asci = ord(c_xor[ii])
codifica1 = p_asci
codifica2 = int(lista_tc3[i])
crea_codifica = codifica1 ^ codifica2
xor_testo = bin(crea_codifica)[2:].zfill(11)
testo_criptato = testo_criptato + chr(int(xor_testo, 2))
ii += 1
dati_da_salvare = {"testo_criptato": testo_criptato, "semiprimo": n}
# Salva i dati in un file binario usando pickle
with open("file_binario", "wb") as file_binario:
pickle.dump(dati_da_salvare, file_binario)
# ****************************************************
# ****************************************************
# ****************************************************
# ****************************************************
def decripta():
start1 = str(p)
start2 = len(start1)
start = int(start1[start2 - 5] + start1[start2 - 4])
ln = list(str(p))
if len(ln) % 2 == 0:
pass
else:
ln.append("0")
divln = []
for i in range(0, len(ln), 2):
c1 = int(ln[i])
c2 = int(ln[i + 1])
c3 = c1 * 10 + c2
divln.append(c3)
# **********************************************
m1 = int(lista_m[0])
m2 = int(lista_m[1])
m3 = int(lista_m[2])
m4 = int(lista_m[3])
m5 = int(lista_m[4])
# **********************************************
cont = start
tdecript = ""
for i in range(len(lista_testo)):
if cont == len(divln):
cont = 0
x = int(divln[cont])
if x >= 0 and x < 25:
y = int(lista_testo[i])
tdecript = tdecript + (chr(y - x - m1))
if x >= 25 and x < 40:
y = int(lista_testo[i])
tdecript = tdecript + (chr(y - x - m2))
if x >= 40 and x < 50:
y = int(lista_testo[i])
tdecript = tdecript + (chr(y - x - m3))
if x >= 50 and x < 75:
y = int(lista_testo[i])
tdecript = tdecript + (chr(y - x - m4))
if x >= 75 and x < 100:
y = int(lista_testo[i])
tdecript = tdecript + (chr(y - x - m5))
cont = cont + 1
return tdecript
# *riconposizione testo originale
with open("file_binario", "rb") as file_binario:
dati_caricati = pickle.load(file_binario)
testo_criptato = dati_caricati["testo_criptato"]
n = dati_caricati["semiprimo"]
carica_tc = list(testo_criptato)
n = nd * nd2
a = n % chiave
b = n - a
for i in range(10):
r = gcd(a, b)
if r != 1:
p = r
q = n // p
break
a = a + chiave
b = b - chiave
if r == 1:
quit()
# *calcola la serie di numeri in pacchetti di 3 che si può estrarre
lista_q = list(str(q))
n_round = ((len(lista_q) - 100)) // 3 * 3
# *creo due punti di partenza differenti
start1 = str(q)
start2 = len(start1)
c_round1 = int(start1[start2 - 9] + start1[start2 - 3])
c_round2 = int(start1[start2 - 7] + start1[start2 - 4])
# *creo due liste contenenti un numero divisibile per 3
div_round1 = []
div_round2 = []
for ii in range(c_round1, c_round1 + n_round, 3):
div_round1.append((lista_q[ii] + lista_q[ii + 1] + lista_q[ii + 2]))
for ii in range(c_round2, c_round2 + n_round, 3):
div_round2.append((lista_q[ii] + lista_q[ii + 1] + lista_q[ii + 2]))
# ************************************************************
chiave_xor = ""
chiave_bin1 = ""
for i in range(len(div_round1)):
num_int = int(div_round1[i])
bin1 = bin(num_int)[2:].zfill(11)
chiave_bin1 = chiave_bin1 + chr(int(bin1, 2))
num_int = int(div_round2[i])
bin2 = bin(num_int)[2:].zfill(11)
int_bin1 = int(bin1, 2)
int_bin2 = int(bin2, 2)
bin_x = int_bin1 ^ int_bin2
xor_bin = bin(bin_x)[2:].zfill(11)
chiave_xor = chiave_xor + chr(int(xor_bin, 2))
c_xor = list(chiave_xor)
ii = 0
testo_decriptato = ""
for i in range(len(carica_tc)):
if ii > len(c_xor):
ii = 0
p_asci = ord(c_xor[ii])
p_asci2 = ord(carica_tc[i])
codifica1 = int(p_asci)
codifica2 = int(p_asci2)
crea_codifica = codifica1 ^ codifica2
xor_testo = bin(crea_codifica)[2:].zfill(11)
testo_decriptato = testo_decriptato + str(int(xor_testo, 2))
ii += 1
lista_dec = list(testo_decriptato)
lista_dec3 = []
for i in range(0, len(lista_dec), 3):
lista_dec3.append(lista_dec[i] + lista_dec[i + 1] + lista_dec[i + 2])
lista_testo = lista_dec3[:-5]
lista_m = lista_dec3[-5:]
tdec = decripta()
print(tdec)