Programma di criptazione/decriptazione (Parte 2)

[crimescene]

e non mi sembra che finora io abbia ricevuto una risposta soddisfacente nel merito.

Perdonami ma in cosa non la ritieni soddisfacente, ti ha spiegato le criticità dell'algoritmo, ti ha detto le ragioni per cui non è sicuro e ti ha fatto un esempio di come andrebbe costruito un algoritmo sicuro.
@Skills07 fa il programmatore di mestiere non capisco che tipo di risposta ti aspetti
Premesso che io non sono del mestiere e di programmazione capisco 0 ma a me pare chiaro che al livello di sicurezza ci sono delle criticità come è stato spiegato.

 

[M1n021]

Perdonami ma in cosa non la ritieni soddisfacente, ti ha spiegato le criticità dell'algoritmo, ti ha detto le ragioni per cui non è sicuro e ti ha fatto un esempio di come andrebbe costruito un algoritmo sicuro.

Non la ritengo soddisfacente semplicemente perché non è proprio entrato nel merito di quello che ho chiesto, ossia

Il file contiene l'elenco dei semiprimi, tutti fattorizzabili con la chiave c ; quest'ultima viene scambiata in modo sicuro tra i due utenti che vogliono stabilire una comunicazione. A questo punto, se uno degli utenti vuole inviare un messaggio all'altro, viene prelevato uno dei tanti semiprimi, il quale viene fattorizzato con la chiave c , e in seguito il messaggio viene criptato col maggiore A dei due primi che costituiscono il suddetto semiprimo. A questo punto il destinatario del messaggio, una volta noto il semiprimo utilizzato, potrà fattorizzarlo anche lui ed utilizzare lo stesso primo A per decriptare il messaggio.
Dove si preconfigura il problema di sicurezza nello scenario appena descritto? Cioè anche se il file coi semiprimi fosse pubblico, come potrebbe essere utilizzato per bucare la sicurezza? Non sto dicendo che non sia possibile farlo, chiedo semplicemente come praticamente potrebbe essere fatto.

Tu ritieni che i post di @Skills07 abbiano effettivamente risposto alle mie domande o lo dici solo per una questione di fiducia che riponi nel suddetto utente?
Nello specifico @Skills07 parla di "calcoli finti", ma quali sarebbero questi "calcoli finti" nella mia descrizione sopra riportata? Parla poi anche di "chiavi HARDCODED", ma la mia domanda su quale sarebbe il problema se anche il file coi semiprimi fosse pubblico (visto che le chiavi di criptazione/decriptazione non sono i semiprimi, ma i primi che li costituiscono) non ha avuto ancora risposta.
Tutto qui...

 

[crimescene]

Non la ritengo soddisfacente semplicemente perché non è proprio entrato nel merito di quello che ho chiesto, ossia

Tu ritieni che i post di @Skills07 abbiano effettivamente risposto alle mie domande o lo dici solo per una questione di fiducia che riponi nel suddetto utente?
Nello specifico @Skills07 parla di "calcoli finti", ma quali sarebbero questi "calcoli finti" nella mia descrizione sopra riportata? Parla poi anche di "chiavi HARDCODED", ma la mia domanda su quale sarebbe il problema se anche il file coi semiprimi fosse pubblico (visto che le chiavi di criptazione/decriptazione non sono i semiprimi, ma i primi che li costituiscono) non ha avuto ancora risposta.
Tutto qui...

io non ritengo nulla come ho detto di programmazione ne capisco meno di 0, tendo però a fidarmi di più di un laureato che lavora tutti i giorni nel settore che altro

Se ritieni che la risposta che ti ha dato non sia per te soddisfacente aspetta che ti risponda lui nel merito

 

[M1n021]

io non ritengo nulla come ho detto di programmazione ne capisco meno di 0, tendo però a fidarmi di più di un laureato che lavora tutti i giorni nel settore che altro

Sì, ma questo non significa che la gente ti deve credere sulla parola, e comunque il pezzo di carta non ti esonera dal fornire argomentazioni logiche nel merito. Dico in generale eh, non mi riferisco al caso specifico.

Se ritieni che la risposta che ti ha dato non sia per te soddisfacente aspetta che ti risponda lui nel merito

Aspetto...

 

[Skills07]

E continua ad aspettare, perché intanto ti ho dato del materiale verificato da studiare.
Poi appena ho tempo come ho smontato l’algoritmo smonto anche la teoria matematica di un algoritmo che usa chiavi hardcoded.
Ti ho spiegato sopra:
Che numeri primi semi primi o qualsivoglia non possono essere stoccati da nessuna parte. Un algoritmo deve essere calcolato runtime il che vuol dire in esecuzione e dinamicamente.
Quindi poteva starci che un numero semiprimo possa essere pubblico quindi hardcoded ma gli altri devono essere calcolati runtime.
Se tu possiedi un file con numeri primi e un file con la chiave per calcolarli lo capisci che l’algoritmo non è sicuro? In quanto con tutte le vulnerabilità che ho citato sopra permette di bypassare o eludere quanto dichiarato?
ti ripeto studia RSA dal punto di vista matematico e poi informatico e vedrai che capirai cosa intendo. Come funzionano le permutazioni etc etc

oi, nonostante non sia né un "informatico" né un "matematico", ho la presunzione che ragionando e utilizzando la logica si possa dire la propria in qualsiasi campo, senza alcun complesso di inferiorità verso gli "esperti" o presunti tali.

Tra l’altro ho trovato questo messaggio rileggendo il tutto.
Mi verrebbe da dire perché non vai a fare il chirurgo allora? Tanto con la logica posso capire come operare un paziente.
Perdonami, ma l’informatica e la matematica vanno studiate capite e apprese. Non si arriva dall’ oggi al domani a dire ho inventato un teorema/ algoritmo senza prima aver studiato teoremi ed algoritmi di altri.
Ed è per questo che non capisci i concetti citati precedentemente.
Studia un algoritmo serio funzionante e certificato e poi riparliamo di questo algoritmo hardcoded

 

[M1n021]

Tra l’altro ho trovato questo messaggio rileggendo il tutto.
Mi verrebbe da dire perché non vai a fare il chirurgo allora? Tanto con la logica posso capire come operare un paziente.

Premesso che non ritratto assolutamente quello che ho detto, se si considera il contesto in cui ho fatto quell'affermazione, ossia:

Che sia vera in tutti i casi in cui "prelevi" primi da quei 2 intervalli, tu dici di averlo dimostrato... mah! qualche teorico dei numeri te l'ha validata?

Da dove deriva quel "mah" se la parte sotto spoiler non l'hai nemmeno letta?
Poi, nonostante non sia né un "informatico" né un "matematico", ho la presunzione che ragionando e utilizzando la logica si possa dire la propria in qualsiasi campo, senza alcun complesso di inferiorità verso gli "esperti" o presunti tali.

la tua battuta risulta piuttosto stupidotta e fuori luogo, IMHO!

E continua ad aspettare, perché intanto ti ho dato del materiale verificato da studiare.

Già che ci sei dimmi anche cosa mangiare e come vestirmi!
Che poi da un punto di vista prettamente logico non capisco come e perché eventuali differenze tra RSA e questo metodo implicherebbero di conseguenza l'invalidità di quest'ultimo.

Poi appena ho tempo come ho smontato l’algoritmo smonto anche la teoria matematica di un algoritmo che usa chiavi hardcoded.

A scanso di equivoci, la parte matematica che dovresti smontare è la dimostrazione sotto spoiler nel post iniziale, così eviti di sprecare il tuo prezioso tempo soffermandoti sulle cose sbagliate. Io sono abbastanza sicuro di quello che ho scritto, ma se trovi qualche errore fammelo sapere che correggo; poi se si rivela tutto da buttare, pazienza...
Per quanto riguarda il resto ho già detto di essere un profano nel campo della crittografia e di non essere il difensore del metodo dell'autore, su cui io stesso ho espresso dei dubbi nei precedenti post:

va detto che la proprietà matematica di cui si è discusso finora consente di individuare due intervalli (la cui estensione si attesta sui 10^d , dove d è la differenza tra il numero di cifre dei valori iniziali dei due intervalli)

non saprei se sia più facile fattorizzare un unico semiprimo (utilizzato per esempio come chiave pubblica nel metodo RSA e costituito da due primi con più o meno lo stesso numero di cifre) o individuare il valore c del suddetto metodo (che come abbiamo detto è in comune a tutti i semiprimi S , ognuno dei quali è costituito in questo caso da due primi con un numero di cifre abbastanza diverso tra loro).
Ovviamente va sempre tenuto in conto che i primi A e B sono ottenuti mediante test di primalità probabilistici, e non so se ciò vale anche per i primi che costituiscono i semiprimi RSA.

Qui nessuno sta dicendo che il metodo crittografico in questione sia perfetto e migliore di quelli ufficiali, voglio solo capirne esattamente i limiti... e infatti mi sono limitato a fare delle semplici domande, come le seguenti:

Il file contiene l'elenco dei semiprimi, tutti fattorizzabili con la chiave c ; quest'ultima viene scambiata in modo sicuro tra i due utenti che vogliono stabilire una comunicazione. A questo punto, se uno degli utenti vuole inviare un messaggio all'altro, viene prelevato uno dei tanti semiprimi, il quale viene fattorizzato con la chiave c , e in seguito il messaggio viene criptato col maggiore A dei due primi che costituiscono il suddetto semiprimo. A questo punto il destinatario del messaggio, una volta noto il semiprimo utilizzato, potrà fattorizzarlo anche lui ed utilizzare lo stesso primo A per decriptare il messaggio.
Dove si preconfigura il problema di sicurezza nello scenario appena descritto? Cioè anche se il file coi semiprimi fosse pubblico, come potrebbe essere utilizzato per bucare la sicurezza? Non sto dicendo che non sia possibile farlo, chiedo semplicemente come praticamente potrebbe essere fatto.

Nello specifico @Skills07 parla di "calcoli finti", ma quali sarebbero questi "calcoli finti" nella mia descrizione sopra riportata? Parla poi anche di "chiavi HARDCODED", ma la mia domanda su quale sarebbe il problema se anche il file coi semiprimi fosse pubblico (visto che le chiavi di criptazione/decriptazione non sono i semiprimi, ma i primi che li costituiscono) non ha avuto ancora risposta.

Se questo metodo è così palesemente sbagliato, e non escludo che lo sia, perché semplicemente non rispondi alle mie suddette domande e non illustri come possa esserne bucata la sicurezza in modo concreto e senza tirare in ballo inutili paragoni con RSA e altri metodi ufficiali?!

 

[Skills07]

La sicurezza viene bucata dai seguenti punti:

Messaggio nella discussione 'Programma di criptazione/decriptazione (Parte 2)'

12 Ottobre 2024

Non sono entrato a capofitto mi sono però, preso la briga di analizzare il codice scritto da @piergiac-1 che si ostiene a dire di aver trovato soluzione di fattorizzazione e bla bla bla.
Io faccio il developer sono un senior, lavoro da 13 anni nel settore, ho studiato all'università, ho preso 2 lauree, e non parlo tanto per dare fiato.
Voglio dare un suggerimento reale e formativo valido per tutti.

Parto con l'analisi del codice python fornito dove elenco tutte le criticità, mi sono preso un paio di ore, penso che con un altro paio di ore questo algoritmo lo cracco e ne faccio...

• Skills07

• 

 

[piergiac-1]

La sicurezza viene bucata dai seguenti punti:

Messaggio nella discussione 'Programma di criptazione/decriptazione (Parte 2)'

12 Ottobre 2024

Non sono entrato a capofitto mi sono però, preso la briga di analizzare il codice scritto da @piergiac-1 che si ostiene a dire di aver trovato soluzione di fattorizzazione e bla bla bla.
Io faccio il developer sono un senior, lavoro da 13 anni nel settore, ho studiato all'università, ho preso 2 lauree, e non parlo tanto per dare fiato.
Voglio dare un suggerimento reale e formativo valido per tutti.

Parto con l'analisi del codice python fornito dove elenco tutte le criticità, mi sono preso un paio di ore, penso che con un altro paio di ore questo algoritmo lo cracco e ne faccio...

• Skills07

• 

Mi fa piacere che un professionista del tuo calibro possa dimostrare di poter craccare il mio programma. Ti mando il programma di cui parla Mino che non è quello postato nel mio precedente topic. Quello del precedente mio topic è una cassaforte e non un programma di messaggistica. Tra l'altro il programma cassaforte genera le chiavi di criptazione run time proprio come dici tu. Questo invece usa una chiave pubblica (semiprimo), che contiene le chiavi di criptazione/decriptazione, memorizzate in file, ma che come è noto sono molto difficili da fattorizzare. Dopo che sei riuscito a craccare il programma ti mando il file criptato, che naturalmente, avendo craccato il mio programma, riuscirai a leggerlo. Ti chiedo solo un favore: Non commentare lo script Python nella sua stesura, so di non essere un professionista, concentrati sul tema della sicurezza ed evita commenti su, è scritto male, non usa questo, non usa quello, ecc...

ah per la cronaca.... il programma è basato su chiave simmetrica e non asimmetrica

Grazie, apprezzo molto tuo aito

# GC57eAL Invio dati Crisptati Esteso con Allegato-configurazione Cartelle
import tkinter as tk
from tkinter import messagebox, filedialog,simpledialog
import os
import pickle
from math import gcd
import hashlib
import time
from random import randint, seed

# *******************************************************
# * Inserimento password
# *******************************************************


def hash_password(password):
    # Genera un salt casuale per aggiungere casualità all'hashing
    salt = os.urandom(32)

    # Combina la password con il salt e calcola l'hash
    hashed_password = hashlib.pbkdf2_hmac(
        "sha256", password.encode("utf-8"), salt, 100000
    )

    # Combina il salt e l'hash in un unico valore da memorizzare nel database
    hashed_password_hex = salt.hex() + hashed_password.hex()

    return hashed_password_hex


def verify_password(input_password, stored_password):
    # Estrae il salt dal valore memorizzato
    salt = bytes.fromhex(stored_password[:64])

    # Calcola l'hash della password di input con lo stesso salt
    hashed_input_password = hashlib.pbkdf2_hmac(
        "sha256", input_password.encode("utf-8"), salt, 100000
    )

    # Confronta il salt e l'hash con il valore memorizzato
    return stored_password[64:] == hashed_input_password.hex()


def get_password_from_user():
    def toggle_password():
        if show_password_var.get():
            entry.config(show="")
        else:
            entry.config(show="*")

    def submit():
        nonlocal password
        password = entry.get()
        password_dialog.destroy()
        dialog.quit()

    password = None
    dialog = tk.Tk()
    dialog.withdraw()

    password_dialog = tk.Toplevel(dialog)
    password_dialog.title("Password")

    # Configura colore di sfondo e dimensioni
    password_dialog.configure(bg="#2F4F4F")
    password_dialog.geometry("200x130")

    tk.Label(password_dialog, text="Inserisci la password:", bg="#2F4F4F").pack(pady=5)

    entry = tk.Entry(password_dialog, show="*", width=30)
    entry.pack(pady=5)

    show_password_var = tk.BooleanVar()
    show_password_checkbox = tk.Checkbutton(
        password_dialog,
        text="Mostra password",
        variable=show_password_var,
        bg="#2F4F4F",
        command=toggle_password,
    )
    show_password_checkbox.pack()

    submit_button = tk.Button(password_dialog, text="OK", bg="#228B22", command=submit)
    submit_button.pack(pady=5)

    dialog.mainloop()

    return password


# Esempio di utilizzo
password = "12345"
hashed_password = hash_password(password)

# Verifica della password
input_password = get_password_from_user()

if verify_password(input_password, hashed_password):
    pass
else:
    messagebox.showerror("Errore", "La password inserita è errata.")
    quit()

# *******************************************************
# * controllo file CFG
# *******************************************************

filecfg = "GC57cfg"
if os.path.exists(filecfg):
    pass
else:

    def chiudi_programma():
        risposta = messagebox.askquestion("Attenzione:", "uscire dal programma?")
        if risposta == "yes":
            rootcfg.destroy()
            quit()
        else:
            return

    def salva_esci():
        controllo1 = e2_cfg.get()
        if controllo1 == "":
            messagebox.showerror("Attenzione:", "Tutti i campi devono essere compilati")
            return
        elif os.path.exists(f"{controllo1}"):
            pass
        else:
            messagebox.showerror("Attenzione:", "La cartella INVIO non esiste")
            return

        controllo2 = e3_cfg.get()
        if controllo2 == "":
            messagebox.showerror("Attenzione:", "Tutti i campi devono essere compilati")
            return
        elif os.path.exists(f"{controllo2}"):
            pass
        else:
            messagebox.showerror("Attenzione:", "La cartella RICEVE non esiste")
            return

        controllo3 = e4_cfg.get()
        if controllo3 == "":
            messagebox.showerror("Attenzione:", "Tutti i campi devono essere compilati")
            return
        elif os.path.exists(f"{controllo3}"):
            pass
        else:
            messagebox.showerror("Attenzione:", "La cartella ALLEGATI non esiste")
            return

        controllo4 = e5_cfg.get()
        if controllo4 == "":
            messagebox.showerror("Attenzione:", "Tutti i campi devono essere compilati")
            return
        elif os.path.exists(f"{controllo4}"):
            pass
        else:
            messagebox.showerror("Attenzione:", "La cartella SEMIPRIMI non esiste")
            return

        scrivi = open("GC57cfg", "w")
        scrivi.write(controllo1 + "\n")
        scrivi.write(controllo2 + "\n")
        scrivi.write(controllo3 + "\n")
        scrivi.write(controllo4 + "\n")
        scrivi.close()
        messagebox.showinfo("Salvataggi CFG:", "Configurazione Salvata")
        rootcfg.destroy()

    rootcfg = tk.Tk()

    # Imposta le dimensioni della finestra
    window_width = 415
    window_height = 410

    # Ottieni le dimensioni dello schermo
    screen_width = rootcfg.winfo_screenwidth()
    screen_height = rootcfg.winfo_screenheight()

    # Calcola la posizione x e y per centrare la finestra
    x = (screen_width - window_width) // 2
    y = (screen_height - window_height) // 2

    # Imposta la posizione e le dimensioni della finestra
    rootcfg.geometry(f"{window_width}x{window_height}+{x}+{y}")
    rootcfg.title("Configurazione Cartelle GC57")
    rootcfg.configure(bg="#458B74")
    colore_testo_entry = "#104E8B"
    testo = (
        "Se appare questa finestra è perchè il programma viene eseguito per la prima volta in questa posizione, \
oppure il file 'GC57cfg' è stato cancellato\n\
Copiare e incollare con CTR-V la posizione delle cartelle:",
    )

    l1_cfg = tk.Label(
        rootcfg, text=testo, justify=tk.LEFT, font="arial 12 bold", wraplength=400
    )
    l1_cfg.place(x=10, y=20)

    px = 10
    py = 150
    l2_cfg = tk.Label(
        rootcfg,
        text="Incollare Indirizzo Cartella INVIO",
        bg="#458B74",
        font="arial 12 bold",
    )
    l2_cfg.place(x=px, y=py)
    py = py + 20
    e2_cfg = tk.Entry(rootcfg, width=40, fg=colore_testo_entry, font="arial 12")
    e2_cfg.place(x=px, y=py)

    py = py + 30
    l3_cfg = tk.Label(
        rootcfg,
        text="Incollare Indirizzo Cartella RICEVE",
        bg="#458B74",
        font="arial 12 bold",
    )
    l3_cfg.place(x=px, y=py)
    py = py + 20
    e3_cfg = tk.Entry(rootcfg, width=40, fg=colore_testo_entry, font="arial 12")
    e3_cfg.place(x=px, y=py)

    py = py + 30
    l4_cfg = tk.Label(
        rootcfg,
        text="Incollare Indirizzo Cartella ALLEGATI",
        bg="#458B74",
        font="arial 12 bold",
    )
    l4_cfg.place(x=px, y=py)
    py = py + 20
    e4_cfg = tk.Entry(rootcfg, width=40, fg=colore_testo_entry, font="arial 12")
    e4_cfg.place(x=px, y=py)

    py = py + 30
    l5_cfg = tk.Label(
        rootcfg,
        text="Incollare Indirizzo Cartella SEMIPRIMI",
        bg="#458B74",
        font="arial 12 bold",
    )
    l5_cfg.place(x=px, y=py)
    py = py + 20
    e5_cfg = tk.Entry(rootcfg, width=40, fg=colore_testo_entry, font="arial 12")
    e5_cfg.place(x=px, y=py)

    px = px + 150
    py = py + 50
    b1 = tk.Button(
        rootcfg,
        text="Salva ed Esci",
        font="arial 12 bold",
        cursor="hand1",
        bg="green",
        command=salva_esci,
    )
    b1.place(x=px, y=py)
    rootcfg.protocol("WM_DELETE_WINDOW", chiudi_programma)

    rootcfg.mainloop()

# *******************************************************
# * Carica CFG
# *******************************************************
filename = ""
apricfg = open("GC57cfg", "r")
programma_invia_a = apricfg.readline().strip()
programma_riceve_a = apricfg.readline().strip()
programma_allegati = apricfg.readline().strip()
programma_semiprimi = apricfg.readline().strip()
apricfg.close()

# *******************************************************
# * Controllo porta USB
# *******************************************************
apri_dati = simpledialog.askstring("USB", "Inserisci la porta USB se diversa da D")
if apri_dati == None:
    quit()

if not apri_dati:
    apri_dati = "d"
usb_path = apri_dati + ":\\"

if os.path.exists(usb_path):
    try:
        storage_devices = os.listdir(usb_path)
    except FileNotFoundError:
        pass
else:
    messagebox.showwarning(
        "Attenzione", "Chiavetta USB non trovata nella lettera di unità " + apri_dati
    )
    quit()

def prefin_close():
    pre_fin.destroy()
    quit()


# *************************************************
#          finestra programma invia
# *************************************************

def apri_invia():

    def invia_close():
        root_invia.destroy()
        pre_fin.deiconify()
        return

    # *codifica allegato
    def encode_byte(byte, conta,chi_list):
        # key = 0xC4  # Chiave XOR
        seed(int(chi_list[conta]))
        ran = randint(32, 256)
        bin_ran = bin(ran)[2:].zfill(8)

        key = int(bin_ran, 2)
        encoded_byte = byte ^ key
        return encoded_byte

    # *******************************************************
    # * cripta file di testo con scostamento GC57
    # *******************************************************

    def cripta(p):
        # global start
        f1 = tw1_invia.get("1.0", tk.END)
        f1 = f1.strip()

        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)
        # **********************************************
        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]) > 70000:
                pass
            else:
                x = int(divln[cont])
                seed(x)
                m1 = randint(10000, 30000)
                x = x + m1 + ord(te[i])
                tcript = tcript + str(x)
                cont = cont + 1
        return tcript

    # *******************************************************
    # * Chiama lo scostamento e mescola la criptazione con XOR
    # *******************************************************

    def codifica():
        if filename == "":
            messagebox.showerror("Attenzione", "Non è stata selezionata nessuna codifica")
            return
        testo = tw1_invia.get("1.0", tk.END)
        if testo == "" or len(testo) < 12:
            messagebox.showerror("Attenzione", "Messaggio mancante o Troppo corto")
            return

        T = int(time.time())
        seed(T)

        with open(filename, "r") as file:
            righe = file.readlines()
            codice_random = randint(0, len(righe) - 1)  # Genera un indice casuale
            nn = righe[codice_random]
            n = int(nn.strip())
            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:
                messagebox.showerror("Attenzione", "Codifica non Superata")
                return

            testo_cript = cripta(p)

            lista_tc = list(testo_cript)
            lista_tc3 = []

            for i in range(0, len(lista_tc), 5):
                lista_tc3.append(
                    lista_tc[i]
                    + lista_tc[i + 1]
                    + lista_tc[i + 2]
                    + lista_tc[i + 3]
                    + lista_tc[i + 4]
                )

            # *controllo quanti pacchetti di 3 riesco a estrarre dal fattore primo q
            lista_q = list(str(q))

            n_round = ((len(lista_q) - 100)) // 5 * 5

            # *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 5
            div_round1 = []
            div_round2 = []

            for ii in range(c_round1, c_round1 + n_round, 5):
                div_round1.append(
                    (
                        lista_q[ii]
                        + lista_q[ii + 1]
                        + lista_q[ii + 2]
                        + lista_q[ii + 3]
                        + lista_q[ii + 4]
                    )
                )

            for ii in range(c_round2, c_round2 + n_round, 5):
                div_round2.append(
                    (
                        lista_q[ii]
                        + lista_q[ii + 1]
                        + lista_q[ii + 2]
                        + lista_q[ii + 3]
                        + lista_q[ii + 4]
                    )
                )

            # ************************************************************
            chiave_xor = ""
            chiave_bin1 = ""

            for i in range(len(div_round1)):
                num_int = int(div_round1[i])
                bin1 = bin(num_int)[2:].zfill(17)

                chiave_bin1 = chiave_bin1 + chr(int(bin1, 2))

                num_int = int(div_round2[i])
                bin2 = bin(num_int)[2:].zfill(17)

                int_bin1 = int(bin1, 2)
                int_bin2 = int(bin2, 2)
                bin_x = int_bin1 ^ int_bin2
                xor_bin = bin(bin_x)[2:].zfill(17)
                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(17)
                testo_criptato = testo_criptato + chr(int(xor_testo, 2))
                ii += 1
            allegato_invia=e1_invia.get()

            if not allegato_invia or len(allegato_invia) < 6:
                dati_da_salvare = {"testo_criptato": testo_criptato, "semiprimo": n}

                # Salva i dati in un file binario usando pickle senza allegato
                with open(f"{programma_invia_a}/GC57eAL_mess_{codice_selezionato}", "wb") as file_binario:
                    pickle.dump(dati_da_salvare, file_binario)

                messagebox.showinfo("Salvataggio", "File Codificato Creato")
                return
            else:
                # Cripta l'allegato se è stato fornito

                start1 = str(q)
                start2 = len(start1)
                start = int(start1[start2 - 8] + start1[start2 - 5])

                chi_list=[]
                fatq=str(q)
                if len(fatq)%2==0:
                    pass
                else:
                    fatq=fatq+'0'

                for i in range(0,len(fatq),2):
                    chi_list.append(fatq[i:i+2])
                # print(chi_list)

                conta=start
                allegato_criptato=[]
                with open(filename_allegato, "rb") as encoded_file:
                    byte = encoded_file.read(1)
                    while byte:
                        if conta>=len(chi_list):
                            conta=0
                        encoded_byte = encode_byte(byte[0],conta,chi_list)
                        allegato_criptato.append(
                            encoded_byte
                        )  # Memorizza il byte processato nella lista
                        byte = encoded_file.read(1)
                        conta=conta+1

                # allegato_criptato = cripta_allegato(allegato_invia)

                dati_da_salvare = {
                    "testo_criptato": testo_criptato,
                    "semiprimo": n,
                    "allegato_nome": allegato_invia,
                    "allegato_criptato": allegato_criptato
                }
                # Salva i dati in un file binario usando pickle con allegato
                with open(f"{programma_invia_a}/GC57eAL_mess_{codice_selezionato}", "wb") as file_binario:
                    file_binario.write(b"ALLEGATO_MARCATORE")  # Marcatore per indicare la presenza di un allegato
                    pickle.dump(dati_da_salvare, file_binario)

                messagebox.showinfo("Salvataggio", "File Codificato con Allegato Creato")
                return

    # *******************************************************
    # * Apre file semiprimi scelta tipo di codifica (INVIA)
    # *******************************************************
    def apri_codifica():
        global codice_selezionato, chiave, filename
        filename = filedialog.askopenfilename(
            title="Apri file",
            initialdir=f"{programma_semiprimi}",  # Cartella iniziale predefinita
        )

        if filename == "":
            messagebox.showwarning("Attenzione", "Nessuna codifica selezionata" + apri_dati)
            return
        semipsel = filename.split("/")
        codice_selezionato = semipsel[2]
        chiave_usb = apri_dati + ":\\chiave_" + codice_selezionato
        if os.path.exists(chiave_usb):
            with open(chiave_usb, "r") as leggif:
                leggi1 = int(leggif.readline())
                leggi2 = int(leggif.readline())
                leggi3 = int(leggif.readline())
                chiave = leggi1**leggi2

        else:
            messagebox.showerror("Errore", "Dati su USB non trovati")
            return

        e2_invia.delete(0, tk.END)
        e2_invia.insert(0, codice_selezionato)

    # *******************************************************
    # *             Carica allegato (INVIA)
    # *******************************************************
    def apri_allegato():
        global filename_allegato
        if e2_invia.get()=='':
            messagebox.showerror('Attenzione','Selezionare prima tipo di codifica')
            return
        filename_allegato = filedialog.askopenfilename(
            title="Apri file",
            #initialdir="C:\\Users/Claugo/OneDrive/Documenti",
            initialdir="f:\\DCP",
            filetypes=(
                ("Tutti i File", "*.*"),
                ("File di testo", "*.txt"),
                ("File PDF", "*.pdf"),
            ),
        )
        if filename_allegato=='':
            return
        else:
            cartella,allegato=os.path.split(filename_allegato)
            e1_invia.delete(0,tk.END)
            e1_invia.insert(0,allegato)

    # *******************************************************
    # *               Interfaccia (INVIA)
    # *******************************************************
    fondo_finestra = "#2F4F4F"
    colore_testo = "#E6E6FA"
    fondo_text = "#00688B"
    root_invia = tk.Toplevel()
    root_invia.title("Programma di Criptazione Dati - INVIA")
    root_invia.geometry("700x600")
    root_invia.config(bg=fondo_finestra)
    root_invia.protocol("WM_DELETE_WINDOW", invia_close)
    l1_invia = tk.Label(
        root_invia,
        text="INVIA CryptoGC57",
        bg=fondo_finestra,
        font="arial 18 bold",
        fg=colore_testo,
    )
    l1_invia.place(x=210, y=20)

    tw1_invia = tk.Text(
        root_invia,
        width=75,
        height=20,
        bg=fondo_text,
        font="helvetica, 12",
        cursor="left_ptr",
        wrap=tk.WORD,
    )
    tw1_invia.place(x=10,y=70)
    b1_invia = tk.Button(
        root_invia,
        text="Invia File",
        fg="#006400",
        width=15,
        font="arial 12 bold",
        cursor="hand2",
        command=codifica,
    )
    b1_invia.place(x=500, y=450)

    b2_invia = tk.Button(
        root_invia,
        text="Carica Allegato",
        fg="#006400",
        width=15,
        font="arial 12 bold",
        cursor="hand2",
        command=apri_allegato
    )
    b2_invia.place(x=10, y=490)

    b3_invia = tk.Button(
        root_invia,
        text="Seleziona Codifica",
        fg="#006400",
        width=15,
        font="arial 12 bold",
        cursor="hand2",
        command=apri_codifica,
    )
    b3_invia.place(x=10, y=530)

    e1_invia = tk.Entry(
        root_invia,
        width=25,
        font="arial 12 bold",
        bg=fondo_finestra,
        borderwidth=2,
        relief=tk.SUNKEN,
    )
    e1_invia.place(x=180,y=495)

    e2_invia = tk.Entry(
        root_invia,
        width=25,
        font="arial 12 bold",
        bg=fondo_finestra,
        borderwidth=2,
        relief=tk.SUNKEN,
    )
    e2_invia.place(x=180, y=535)

    pre_fin.withdraw()


# *************************************************
#  finestra programma riceve
# *************************************************

def apri_riceve():
    def riceve_close():
        root_riceve.destroy()
        pre_fin.deiconify()
        return

    def decode_byte(decoded_byte, conta,chi_list):
        # key = 0xC4  # Chiave XOR
        seed(int(chi_list[conta]))
        ran = randint(32, 256)
        bin_ran = bin(ran)[2:].zfill(8)

        key = int(bin_ran, 2)
        decoded_byte = decoded_byte ^ key
        return decoded_byte

    # *******************************************************
    # * decripta file ricevuto
    # *******************************************************
    def decripta(lista_dec5, p):

        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)

        cont = start
        tdecript = ""
        for i in range(len(lista_dec5)):
            if cont == len(divln):
                cont = 0
            x = int(divln[cont])
            seed(x)
            m1 = randint(10000, 30000)
            y = int(lista_dec5[i])
            tdecript = tdecript + chr(y - x - m1)
            cont = cont + 1
        return tdecript

    def apri_filer():
        global codice_selezionato, chiave, filename
        filename = filedialog.askopenfilename(
            title="Apri file",
            initialdir=f"{programma_riceve_a}",  # Cartella iniziale predefinita
            # filetypes=(("Tutti i File", "*.*"),("File di testo", "*.txt")),
        )

        if filename == "":
            messagebox.showerror("Attenzione", "File non selezionato")
            return

        if "\\" in filename:
            # Se il percorso utilizza '\', usa split('\\')
            semipsel = filename.split("\\")
        else:
            # Altrimenti, usa split('/')
            semipsel = filename.split("/")

        files = semipsel[-1].split("_")
        codice_selezionato = files[2]
        chiave_usb = os.path.join(apri_dati + ":", "chiave_" + codice_selezionato)
        if os.path.exists(chiave_usb):
            with open(chiave_usb, "r") as leggif:
                leggi1 = int(leggif.readline())
                leggi2 = int(leggif.readline())
                leggi3 = int(leggif.readline())
                chiave = leggi1**leggi2
                # l2.config(text=files[0] + "/" + codice_selezionato)

        else:
            messagebox.showerror("Errore", "Dati su USB non trovati")
            return

        with open(filename, "rb") as file_binario:
            # Controlla se il marcatore di allegato è presente
            if file_binario.read(len(b"ALLEGATO_MARCATORE")) == b"ALLEGATO_MARCATORE":
                allegato_presente = True
            else:
                allegato_presente = False

            # Riposiziona il puntatore del file all'inizio dopo la lettura del marcatore
            file_binario.seek(0)

            # Se è presente un allegato, leggi i dati come prima del marcatore
            if allegato_presente:
                file_binario.read(len(b"ALLEGATO_MARCATORE"))

            dati = pickle.load(file_binario)
            testo_criptato = dati.get("testo_criptato")
            semiprimo = dati.get("semiprimo")

            n = int(semiprimo)
            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:
                messagebox.showerror("Attenzione", "Codifica non Superata")
                return
            carica_tc = list(testo_criptato)
            lista_q = list(str(q))

            n_round = ((len(lista_q) - 100)) // 5 * 5

            # *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, 5):
                div_round1.append(
                        (
                            lista_q[ii]
                            + lista_q[ii + 1]
                            + lista_q[ii + 2]
                            + lista_q[ii + 3]
                            + lista_q[ii + 4]
                        )
                    )

            for ii in range(c_round2, c_round2 + n_round, 5):
                div_round2.append(
                        (
                            lista_q[ii]
                            + lista_q[ii + 1]
                            + lista_q[ii + 2]
                            + lista_q[ii + 3]
                            + lista_q[ii + 4]
                        )
                    )

            # ************************************************************
            chiave_xor = ""
            chiave_bin1 = ""
            for i in range(len(div_round1)):
                num_int = int(div_round1[i])
                bin1 = bin(num_int)[2:].zfill(17)

                chiave_bin1 = chiave_bin1 + chr(int(bin1, 2))

                num_int = int(div_round2[i])
                bin2 = bin(num_int)[2:].zfill(17)

                int_bin1 = int(bin1, 2)
                int_bin2 = int(bin2, 2)
                bin_x = int_bin1 ^ int_bin2
                xor_bin = bin(bin_x)[2:].zfill(17)
                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(17)
                testo_decriptato = testo_decriptato + str(int(xor_testo, 2))
                ii += 1
            lista_dec = list(testo_decriptato)
            lista_dec5 = []
            for i in range(0, len(lista_dec), 5):
                lista_dec5.append(
                        lista_dec[i]
                        + lista_dec[i + 1]
                        + lista_dec[i + 2]
                        + lista_dec[i + 3]
                        + lista_dec[i + 4]
                    )   
            tdec = decripta(lista_dec5, p)
            tw1_riceve.delete("1.0", tk.END)
            tw1_riceve.insert("1.0", tdec)

            if allegato_presente:
                allegato_criptato = dati.get("allegato_criptato")
                allegato_inviato = dati.get("allegato_nome")
                e1_riceve.delete(0,tk.END)
                e1_riceve.insert(0,allegato_inviato)
            else:
                return
            
            
            start1 = str(q)
            start2 = len(start1)
            start = int(start1[start2 - 8] + start1[start2 - 5])
            chi_list=[]
            fatq=str(q)
            if len(fatq)%2==0:
                pass
            else:
                fatq=fatq+'0'

            for i in range(0,len(fatq),2):
                chi_list.append(fatq[i:i+2])
            conta=start   

            with open(f"{programma_allegati}/{allegato_inviato}", "wb") as decoded_file:
                for byte in allegato_criptato:
                    if conta >= len(chi_list):
                        conta = 0
                    decoded_byte = decode_byte(byte, conta,chi_list)
                    decoded_file.write(decoded_byte.to_bytes(1, "little"))
                    conta +=1
    # *******************************************************
    # *               Interfaccia (Riceve)
    # *******************************************************

    fondo_finestra = "#292421"
    colore_testo='#E6E6FA'
    fondo_text = "#00688B"

    root_riceve = tk.Toplevel()
    root_riceve.title("Programma di Criptazione Dati - RICEVE")
    root_riceve.geometry("700x550")
    root_riceve.config(bg=fondo_finestra)
    l1_riceve = tk.Label(
        root_riceve,
        text="LEGGI CryptoGC57",
        bg=fondo_finestra,
        font="arial 18 bold",
        fg=colore_testo,
    )
    l1_riceve.place(x=210,y=20)

    tw1_riceve = tk.Text(
        root_riceve,
        width=75,
        height=20,
        bg=fondo_text,
        cursor="left_ptr",
        font="helvetica, 12",
        wrap=tk.WORD,
    )
    tw1_riceve.place(x=10,y=70)

    b1_riceve = tk.Button(
        root_riceve,
        text="Carica File",
        fg="#228B22",
        width=15,
        font="arial 12 bold",
        cursor="hand2",
        command=apri_filer,
    )
    b1_riceve.place(x=10, y=450)

    px=450
    py=475
    l1_riceve = tk.Label(
        root_riceve,
        text="Allegato",
        bg=fondo_finestra,
        font="arial 12 bold",
        fg=colore_testo,
    )
    l1_riceve.place(x=px, y=py)
    py=py+30
    e1_riceve = tk.Entry(
        root_riceve,
        width=23,
        font="arial 12 bold",
        fg='#66CD00',
        justify='center',
        bg=fondo_finestra,
        borderwidth=2,
        relief=tk.SUNKEN,
    )
    e1_riceve.place(x=px, y=py)

    root_riceve.protocol("WM_DELETE_WINDOW", riceve_close)

    pre_fin.withdraw()


# *************************************************
#  finestra principale
# *************************************************

pre_fin = tk.Tk()
pre_fin.title("********  Programma di Criptazione Dati con Allegati ***********")
pre_fin.geometry("500x210")
pre_fin.config(bg="#104E8B")

l1_pre = tk.Label(
    pre_fin,
    text="Crypto GC57eAL",
    bg="#104E8B",
    fg="#87CEFA",
    font="arial 20 bold",
)
l1_pre.place(x=130, y=30)

l2_pre = tk.Label(
    pre_fin,
    text="Condividi i tuoi File in totale sicurezza",
    bg="#104E8B",
    font="helvetica 14 bold",
)
l2_pre.place(x=53, y=80)

b1_pre = tk.Button(
    pre_fin,
    text="Invia File",
    fg="#228B22",
    width=15,
    font="arial 12 bold",
    cursor="hand2",
    command=apri_invia,
)
b1_pre.place(x=10, y=170)

b2_pre = tk.Button(
    pre_fin,
    text="Leggi File",
    fg="#228B22",
    width=15,
    font="arial 12 bold",
    cursor="hand2",
    command=apri_riceve,
)
b2_pre.place(x=330, y=170)

pre_fin.protocol("WM_DELETE_WINDOW", prefin_close)
pre_fin.mainloop()

Scusa dimenticavo la chiave pubblica. Ti mando il file di chiavi pubbliche che andrei a usare per mandarti il messaggio.

 

[Skills07]

Il concetto sicurezza fa già pena dal fatto che nel tuo script PYTHON come ho scritto in precedenza hai dei Path assoluti, che a me possono permettere di accedere ad altre parti del sistema. Evidentemente il mio messaggio non è stato letto.
Se riuscissi a ritagliarmi del tempo sicuramente provo a violare il tuo algoritmo, devo solo avere tempo cosa che non ho tra lavoro e famiglia

 

[piergiac-1]

Il concetto sicurezza fa già pena dal fatto che nel tuo script PYTHON come ho scritto in precedenza hai dei Path assoluti, che a me possono permettere di accedere ad altre parti del sistema. Evidentemente il mio messaggio non è stato letto.
Se riuscissi a ritagliarmi del tempo sicuramente provo a violare il tuo algoritmo, devo solo avere tempo cosa che non ho tra lavoro e famiglia

I tuoi messaggi vengono letti attentamente al contrario di quanto pensi. Che tu voglia dedicare del tempo alla tua famiglia e al tuo lavoro piuttosto che a queste piccole schermaglie, è giusto e sacro. Ma qui il punto è un altro. Voi, e dicendo voi intendo tutti quelli che continuano a girare attorno alle domande poste con rigore e precisione su un sistema, si limitano a dire che non è sicuro senza dimostrare nei fatti uno straccio di prova. Ripasso la palla alla domanda posta da Mino che è il tema principale di questa seconda parte del suo topic.

M1n021 ha detto:

Il file contiene l'elenco dei semiprimi, tutti fattorizzabili con la chiave c ; quest'ultima viene scambiata in modo sicuro tra i due utenti che vogliono stabilire una comunicazione. A questo punto, se uno degli utenti vuole inviare un messaggio all'altro, viene prelevato uno dei tanti semiprimi, il quale viene fattorizzato con la chiave c , e in seguito il messaggio viene criptato col maggiore A dei due primi che costituiscono il suddetto semiprimo. A questo punto il destinatario del messaggio, una volta noto il semiprimo utilizzato, potrà fattorizzarlo anche lui ed utilizzare lo stesso primo A per decriptare il messaggio.
Dove si preconfigura il problema di sicurezza nello scenario appena descritto? Cioè anche se il file coi semiprimi fosse pubblico, come potrebbe essere utilizzato per bucare la sicurezza? Non sto dicendo che non sia possibile farlo, chiedo semplicemente come praticamente potrebbe essere fatto.

Il programma comunque rimane a tua disposizione e anche i semiprimi che verranno utilizzati per criptare il messaggi. Quando sei pronto me lo dici che ti mando il file criptato.

 

[r3dl4nce]

Con algoritmi crittografici nuovi e ottimizzati quali ChaCha20 e Curve25519 che non richiedono elenchi di chiavi da memorizzare e inoltre si basano su algoritmi già ampiamente testati e verificati da esperti di crittografia e matematici, personalmente non veoi alcun utilizzo nel perdere tempo dietro a un algoritmo non approvato da nessun esperto del settore e che ha troppi prerequisiti abbastanza fumosi.

Chi andrebbe a implementare un algoritmo sconosciuto quando ci sono implementazioni funzionanti di algoritmi già stabili e verificati?

Per cui, che il metodo di calcolo sia valido, che l'algoritmo sia valido, a questo punto vi vedo solo una perdita di tempo e un inutile accanimento. Poi ognuno spreca il proprio tempo come meglio crede, ma questo non deve forzare altri a dire "si fai bene" quando così non è

 

[piergiac-1]

Con algoritmi crittografici nuovi e ottimizzati quali ChaCha20 e Curve25519 che non richiedono elenchi di chiavi da memorizzare e inoltre si basano su algoritmi già ampiamente testati e verificati da esperti di crittografia e matematici, personalmente non veoi alcun utilizzo nel perdere tempo dietro a un algoritmo non approvato da nessun esperto del settore e che ha troppi prerequisiti abbastanza fumosi.

Chi andrebbe a implementare un algoritmo sconosciuto quando ci sono implementazioni funzionanti di algoritmi già stabili e verificati?

Per cui, che il metodo di calcolo sia valido, che l'algoritmo sia valido, a questo punto vi vedo solo una perdita di tempo e un inutile accanimento. Poi ognuno spreca il proprio tempo come meglio crede, ma questo non deve forzare altri a dire "si fai bene" quando così non è

Non posso contestare questa affermazione è corretta quanto diffusa. Perchè pensare a cose nuove quando quelle esistenti vanno bene?
Non voglio però impossessarmi di questo topic e per tanto vi chiedo di non rispondere a me. Sono solo intervenuto per evidenziare che state girando intorno a una specifica domanda senza produrre niente di concreto. Se poi non vi interessa o pensate di perdere tempo sono fatti vostri. Ma vi ricordo che vi siete messi in gioco voi con le vostre affermazioni. A questo punto, se siete coerenti, presentate le prove di fallibilità di questo sistema.

 

[r3dl4nce]

Prove di fattibilità? Se il tuo algoritmo di fattorizzazione è valido, se la valutazione e la sua implementazione di @M1n021 è valida, allora li presentate agli esperti matematici e crittografi e verrete riconosciuti, dando la paternità ai vostri algoritmi e quindi verranno implementati in soluzioni universalmente utilizzate.
Gli algoritmi che ho nominato in precedenza, utilizzati da uno dei più recenti e validi sistemi di VPN cifrata, sono stati pubblicati, revisionati, e infine accettati come validi.
Se lo sono anche i vostri, non sta al forum di tom's hardware deciderlo, nè sta a noi produrre prove di fattibilità, quanto sta a voi sottoporli a chi li studia per far verificare la validità.
Altrimenti, rimangono idee nelle vostre teste che nessuno nel mondo utilizzerà mai, quindi inutili se non per voi stessi

 

[piergiac-1]

Prove di fattibilità? Se il tuo algoritmo di fattorizzazione è valido, se la valutazione e la sua implementazione di @M1n021 è valida, allora li presentate agli esperti matematici e crittografi e verrete riconosciuti, dando la paternità ai vostri algoritmi e quindi verranno implementati in soluzioni universalmente utilizzate.
Gli algoritmi che ho nominato in precedenza, utilizzati da uno dei più recenti e validi sistemi di VPN cifrata, sono stati pubblicati, revisionati, e infine accettati come validi.
Se lo sono anche i vostri, non sta al forum di tom's hardware deciderlo, nè sta a noi produrre prove di fattibilità, quanto sta a voi sottoporli a chi li studia per far verificare la validità.
Altrimenti, rimangono idee nelle vostre teste che nessuno nel mondo utilizzerà mai, quindi inutili se non per voi stessi

Hai letto male, FALLIBILITA' che è quello che state sostendo voi, la fattibilità la sostengo io

 

[r3dl4nce]

Hai letto male, FALLIBILITA' che è quello che state sostendo voi, la fattibilità la sostengo io

Ok.
Te sostieni la fattibilità.
Per me, utilizzatore di strumenti che implementano algorismi di cifratura (vpn, password manager, password cifrate, ecc), questa cosa che te sostieni vale ZERO finché la comunità non controlla, valida e accetta il tuo algoritmo.
Fino ad allora, è un tuo algoritmo e un tuo programma a tuo uso e consumo, può essere valido e funzionale, ma è inutile quindi per le altre persone finché non viene analizzato e riconosciuto valido da altri esperti del settore che non siano l'autore e basta