Stai usando un browser non aggiornato. Potresti non visualizzare correttamente questo o altri siti web. Dovreste aggiornare o usare un browser alternativo.
Partiamo dal fatto che l'esempio numerico era finalizzato a mostrare praticamente come si ottengono chiavi ed intervalli a partire da due generici numeri a e b , che poi nel caso specifico uno degli intervalli non contenesse numeri primi non mi sembra certo la fine del mondo, basta cambiare a e b . Sul fatto che sono stato superficiale nel non controllare i due intervalli l'ho già ammesso nel precedente messaggio, ma di certo non lo considererei un ERRORE né vedo il motivo per cui dovrei accampare delle scuse per una sciocchezza del genere, più che altro la cosa qualifica chi invece si aggrappa a futilità di questo tipo...
I tuoi invece sì che sono stati ERRORI veri e propri, poi se dovuti al fatto che leggi con superficialità quello che scrivo e/o al fatto che non lo capisci, non è un mio problema... in particolare la seguente parte
Ma facciamo finta di niente, diciamo che hai sbagliato a calcolare m, così invece di m=23, per farti contento prendiamo m=24, in modo da includere il numero primo che viene dopo 15858 che è 15859. Facciamo i conti moltiplicandolo per i primi dell'intervallo più piccolo:
s = 15859 * 631 = 10007029 è il semiprimo di test per cui, con tutte le chiavi "buone" finiremo per avere il fattore primo 631:
per la chiave "massima" c=15834 -> s mod c -> 10007029 mod 15834 = 15775 -> MCD(10007029, 15775) = 631 -> funziona
testiamo gli altri valori "chiave" calcolati dalla tua "infallibile e dimostrata formula"
conclusione: del tuo arzigogolato meccanismo non funziona una mazza, a partire dalla "formula" per determinare gli insiemi alle "chiavi" -> la dimostrazione è sbagliata
giusto per la cronaca: se invece del 631 prendi il 641 nessuna delle chiavi che hai citato funziona
è, per i motivi spiegati nel mio precedente post, completamente senza senso, e mostra davvero che non hai capito nulla di quello hai letto.
Passiamo poi a
In matematica discreta si usano solo gli interi, non si usano equazioni di secondo grado ordinarie e/o approssimazioni prese come ti fa più comodo. Te lo avevo già detto e te lo aveva ribadito @Skills07
cosa dovrebbe significare? Che quella formulazione di m è sbagliata? Ok, non voglio escluderlo , ma dimostratemelo. O vi devo credere sulla parola? E poi quali sarebbero queste "approssimazioni prese come mi fanno più comodo"?
E alla luce di ciò ci vuole davvero una bella faccia tosta per mettere sullo stesso piano i miei "errori" con i tuoi...
non ho nessuna euforia e nessuna rivalsa, ma tu mi hai insultato pubblicamente e per dimostrarlo hai postato dei dati inutili, quindi se hai fatto una figuraccia la colpa è solo tua
Se la mia sarebbe una figuraccia allora meglio non definire quella che hai fatto tu con tutti quegli sberleffi mal riposti, dato che tutte le obiezioni che hai mosso si sono rivelate profondamente infondate.
Non sono un esperto di aritmetica modulare, ma conosco la notazione, la definizione e il concetto di congruenza modulo n, però sinceramente non capisco dove tu voglia andare a parare con quel discorso...
mi fa piacere che posti nuovi esempi, cerca di farlo con numeri che si possano controllare a mano, nel primo post lo avevi fatto mostrando i 2 intervalli più piccoli [8361; 8361+33] e [207 ; 207+33].
Questa volta farai tutti gli opportuni controlli (anche numerici) e posterai un esempio con intervalli "buoni" (sia con la chiave massima che quelle più piccole ottenute per divisione).
Prima di farlo ti faccio una domanda: per intervalli "buoni" cosa intendi? Che contengano numeri primi? O altro?
Inoltre, facendo riferimento alla versione aggiornata della dimostrazione, ti faccio notare che il cuore della stessa, ossia la tesi vera e propria, è la 9), mentre la 10) (ossia la formula che riguarda il MCD) è solo un corollario.
A prescindere dagli esempi che farai, spiegherò anche perché come metodo di crittografia non va bene, e non perché abbia qualcosa contro l'autore, ma perché sono i numeri stessi che lo dicono.
#include <iostream>
#include <cmath>
#include <vector>
using namespace std;
bool is_prime(const unsigned int n)
{
if(!(n % 2))
{
return false;
}
for(unsigned int i = 3; i <= n / i; i += 2)
{
if(!(n % i))
{
return false;
}
}
return true;
}
unsigned int mcd_euclide(unsigned int a, unsigned int b)
{
while(b)
{
unsigned int r = a % b;
a = b;
b = r;
}
return a;
}
int main()
{
unsigned int a = 72609;
unsigned int b = 1289;
if(b && a > b)
{
vector<unsigned int> v_c;
vector<unsigned int> v_m;
for(unsigned int i = a - 1; i > b; --i)
{
if(a % i == 1)
{
v_c.push_back(i);
v_m.push_back(ceil((sqrt((b - 1) * (b - 1) + 4 * i) - b - 1) / 2 - 1));
}
}
vector<unsigned int> v_A;
vector<unsigned int> v_B;
for(unsigned int i = 0; i <= v_m[0]; ++i)
{
if(is_prime(a + i))
{
v_A.push_back(a + i);
}
if(is_prime(b + i))
{
v_B.push_back(b + i);
}
}
cout << "\n a = " << a << "\n b = " << b << "\n";
for(unsigned int i = 0, j_A, j_B; i < v_c.size(); ++i)
{
cout << "\n " << i + 1 << ")\n c = " << v_c[i] << " => m = " << v_m[i];
cout << "\n [" << a << ";" << a + v_m[i] << "] => A =";
for(j_A = 0; j_A < v_A.size() && v_A[j_A] <= a + v_m[i]; cout << " " << v_A[j_A++]);
cout << "\n [" << b << ";" << b + v_m[i] << "] => B =";
for(j_B = 0; j_B < v_B.size() && v_B[j_B] <= b + v_m[i]; cout << " " << v_B[j_B++]);
if(j_A && j_B)
{
for(unsigned k_A = 0; k_A < j_A; ++k_A)
{
for(unsigned k_B = 0; k_B < j_B; ++k_B)
{
if(mcd_euclide(v_A[k_A] * v_B[k_B], v_A[k_A] * v_B[k_B] % v_c[i]) != v_B[k_B])
{
return -1;
}
}
}
cout << "\n MCD(A*B ,(A*B) mod c) = B -> OK";
}
cout << "\n";
}
}
}
Per due generici valori di a e b (con a>b>0 ) il programma calcola tutti i possibili valori di c, e per ogni c calcola l'estensione m degli intervalli, definisce gli intervalli stessi e mostra l'elenco dei primi A e B appartenenti ai suddetti intervalli. Inoltre se per un dato valore di c entrambi gli intervalli comprendono almeno un numero primo, allora viene testata la formula
MCD(A*B ,(A*B) mod c) = B
per ogni possibile combinazione di numeri primi prelevati dai due intervalli, e nel caso in cui non fosse verificata il programma si interrompe ritornando -1.
Il codice l'ho scritto velocemente, quindi non mi sono soffermato più di tanto sull'ottimizzazione, inoltre se riscontrate qualche bug fatemelo sapere.
Di seguito l'output per a=72609 e b=1289 :
Codice:
a = 72609
b = 1289
1)
c = 72608 => m = 53
[72609;72662] => A = 72613 72617 72623 72643 72647 72649 72661
[1289;1342] => B = 1289 1291 1297 1301 1303 1307 1319 1321 1327
MCD(A*B ,(A*B) mod c) = B -> OK
2)
c = 36304 => m = 26
[72609;72635] => A = 72613 72617 72623
[1289;1315] => B = 1289 1291 1297 1301 1303 1307
MCD(A*B ,(A*B) mod c) = B -> OK
3)
c = 18152 => m = 12
[72609;72621] => A = 72613 72617
[1289;1301] => B = 1289 1291 1297 1301
MCD(A*B ,(A*B) mod c) = B -> OK
4)
c = 9076 => m = 6
[72609;72615] => A = 72613
[1289;1295] => B = 1289 1291
MCD(A*B ,(A*B) mod c) = B -> OK
5)
c = 4538 => m = 2
[72609;72611] => A =
[1289;1291] => B = 1289 1291
6)
c = 2269 => m = 0
[72609;72609] => A =
[1289;1289] => B = 1289
Process returned 0 (0x0) execution time : 0.038 s
Volevo rispondere direttamente oggi pomeriggio anche senza i nuovi intervalli, ma purtroppo è capitato un imprevisto, sono rientrato da un'ora e sono stanco morto, spero che domani vada meglio
P.S.
avevo chiesto intervalli piccoli e "buoni" (= che contengano primi) per comodità di post dei risultati, in ogni caso ciò è irrilevante, per spiegare tutto non mi servono (i conti li ho già fatti senza intervalli o su intervalli piccoli), ed è irrilevante la seconda versione della dimostrazione, da una rapida occhiata non mi serve nemmeno quella: la questione di fondo è un'altra.
P.P.S.
vedo ora sul forum matematico (Premetto che mod è inteso come operatore binario, dove a mod b restituisce il resto della divisione intera tra a e b col quoziente arrotondato verso l'infinito negativo).
qua si parla di interi positivi, mod restituisce il resto della divisione di interi positivi quindi il quoziente può essere solo positivo, il resto in rosso non serve
P.P.S.
vedo ora sul forum matematico (Premetto che mod è inteso come operatore binario, dove a mod b restituisce il resto della divisione intera tra a e b col quoziente arrotondato verso l'infinito negativo).
qua si parla di interi positivi, mod restituisce il resto della divisione di interi positivi quindi il quoziente può essere solo positivo, il resto in rosso non serve
Sto definendo in generale cosa rappresenta mod , e la parte in rosso serve per distinguerlo da rem (dove il quoziente viene arrotondato verso lo zero).
Comunque proprio non capisco perché impuntarsi su questioni marginali del genere... anche se forse un'idea me la sono fatta.
Volevo rispondere direttamente oggi pomeriggio anche senza i nuovi intervalli, ma purtroppo è capitato un imprevisto, sono rientrato da un'ora e sono stanco morto, spero che domani vada meglio
conclusione: del tuo arzigogolato meccanismo non funziona una mazza, a partire dalla "formula" per determinare gli insiemi alle "chiavi" -> la dimostrazione è sbagliata
s = 15859 * 631 = 10007029
[...]
la "chiave massima" non è affatto quella che pensi tu: tanto per prenderne un paio a caso c=19561 e c=23347 ritornano 631 se usate in MCD(s , s mod c)
Il concetto di "chiave massima" di cui parlo è legato agli intervalli, non ai singoli valori... infatti se provi con semiprimi s=A*B costituiti da altri primi appartenenti ai suddetti intervalli quelle chiavi non funzioneranno.
Relativamente ai singoli valori è ovvio che il discorso cambia, e le "chiavi" valide saranno quelle del tipo B(A-k) (e tutti i relativi divisori maggiori di kB ) con k<[A/2]. Infatti, tornando a quello che hai scritto, abbiamo che:
- c=19561 corrisponde al caso k=18 , infatti 19561 è un divisore di 631(15859-18)=9995671 maggiore di 18*631=11358 ;
- c=23347 corrisponde al caso k=23 , infatti 23347 è un divisore di 631(15859-23)=9992516 maggiore di 23*631=14513 .
in effetti ho sempre considerato c come singolo valore da calcolare a prescindere da intervalli numerici, questo spiega parecchie incomprensioni che unite alla mia cronica mancanza di tempo hanno creato confusione
una delle primissime oservazioni che ti avevo fatto riguardava proprio c quando dissi "ma questo non massimizza, semmai minimizza"... io mi riferivo ai valori di c da sostituire nell'espressione con MCD, anche se rileggendo il mio vecchio post mi rendo conto che non si capisce cosa volessi dire, l'ho scritto male, avrei dovuto metterci un esempio coi numeri
ti chiedo una cortesia: non scrivere altri post dopo questo mio post
l'unica ragione della richiesta è che così posso presentarti il mio ragionamento senza che pensi che lo abbia copiato!
ho in mano la spiegazione di tutto da un po', comprese formulette, valori, esempi numerici (+un paio di programmi in C che mi sono fatto per controllare i numeri). Solo che dato che il forum non permette una formattazione del testo delle espressioni matematiche, devo scrivere su un foglio le 2-3 formulette che, anche se sono semplici, sono poco comprensibili quando scritte su singola riga, quindi devo scriverle su fogli e scansionarle per ricavarne immagini da postare qui. Devo solo avere il tempo di farlo.
Io spero di poterlo fare oggi pomeriggio tra le 16-20
se non ci riesco dovrei sicuramente avere tempo libero per questo ponte di ognissanti per cui, se non muoio prima per infarto o incidente stradale, avremo la conclusione e la spiegazione di tutto
Solo che dato che il forum non permette una formattazione del testo delle espressioni matematiche, devo scrivere su un foglio le 2-3 formulette che, anche se sono semplici, sono poco comprensibili quando scritte su singola riga, quindi devo scriverle su fogli e scansionarle per ricavarne immagini da postare qui. Devo solo avere il tempo di farlo.
Con solito imperdonabile ritardo rispondo, non so se riesco a dire tutto, se necessario aggiungo nei prossimi giorni.
Potrei aver fatto qualche errore di copia-incolla, nel caso segnalatemeli.
Alla base del tuo ragionamento iniziale c'era un'affermazione palesemente falsa, precisamente questa
Non starò qui a tediarvi con tutti i passaggi, mi limito quindi a dire che, ragionando matematicamente su quanto appena scritto, ho dedotto che il suddetto MCD non può restituire il maggiore dei due numeri primi (ossia p1), quindi qualora il metodo fosse corretto dovrà per forza essere
a)MCD(s , s mod z) = MCD(p1*p2 , p1*p2 mod z) = p2
bastavano carta, penna e 3 secondi per verificare che se hai 15=3*5=5*3 li fattorizzi con MCD(15, 15 mod c) in almeno 2 modi:
15 mod 10 = 5 -> MCD(15,5) = 5 -> 15 = 5 * 3
15 mod 4 = 3 -> MCD(15,3) = 3 -> 15 = 3 * 5
oltre a c=10 e 4 si fattorizza anche con c=12, 6, 9,;
ovvio che ti ho bollato come sbagliata la dimostrazione, con una simile premessa mi sembrava una perdita di tempo inutile controllare il resto.
L'errore ti ha fatto ragionare su mezza verità, un mesetto buono per arrivare alla conclusione che la fattorizzazione esiste, facendo 15 passaggi di calcoli laboriosi nella prima versione e 10 nella seconda. Ti ha infatti obbligato ad imporre la condizione a mod c = 1, l'unico modo per arrivare ad ottenere il numero primo più piccolo, e da lì tutti i calcoli.
Ho pensato di sfruttare il resto della divisione tra interi: consideriamo solo i numeri primi; per fissare le idee p<q con p, q primi dispari (quindi eccetto il 2), s=p*q ed infine l'espressione MCD(s, s mod c). Queste sono le condizioni effettivamente usate nell'applicazione dell'autore.
Come faccio a trovare c in modo che MCD(s, s mod c)=p oppure MCD(s, s mod c)=q?
Per MCD(s, s mod c)=p è sufficiente che s mod c=p e quindi MCD(s, p)=MCD(p*q, p)=p e quindi fattorizzo in p*q ,
Per MCD(s, s mod c)=q è sufficiente che s mod c=q e quindi MCD(s, q)=MCD(p*q, q)=q e quindi fattorizzo in q*p
Ma s mod c è il resto della divisione di s per c
-> per avere un resto p deve essere s : c = k con resto p -> s=k*c+p -> s-p = k*c ; dividendo s per s-p -> s : (s-p) = 1 con resto p, infatti 1*(s-p)+p=s. -> ho trovato la fattorizzazione p*q per mezzo di c=s-p
simmetricamente per l'altro valore s : (s-q) = 1 con resto q -> ho trovato la fattorizzazione q*p per mezzo di c=s-q
In sintesi, dati p e q, con le ipotesi fatte, si hanno 2 valori per c che ritornano la fattorizzazione sostituite in MCD(s, s mod c):
c(1)=s-p che fattorizza in p*q (ulteriori valori di c si potrebbero ottenere con c=s-k*p per qualche intero k>1, tuttavia ciò non è vero in generale);
c(2)=s-q che fattorizza in q*p (simmetricamente al caso precedente, valori di c si potrebbero ottenere da c=s-h*q, con h intero e h>1);
[NOTA-EDIT] a differenza di quanto scritto in precedenza, ho indebolito la condizione sui numeri p, q restrigendo la tesi ai numeri primi dispari e in modo che p e q siano differenti tra loro per rispecchiare lo scenario di applicazione dell'espressione nel metodo usato dall'autore.
NOTA BENE: c(1) e c(2) ed i valori da esse eventualmente derivati da sottrazioni della forma s-k*p o s-h*q, in generale non sono tutti i possibili valori di c minori di p*q che producono la fattorizzazione. Tali valori vanno invece cercati risolvendo equazioni con congruenza: per p sono tutti i valori che verificano l'equazione s mod x = p, per q tutti quelli che verificano s mod x = q. In teoria dei numeri ci sono i metodi di risoluzione di queste equazioni, che lascio a chi ha le competenze per farlo.
Esempio (su numeri primi):
p=7, q=13 -> s=7*13=91
c(1) = 91-7 = 84 -> MCD(91, 91 mod 84)= MCD(91,7) = 7 -> 91 = 7*(91:7)=7*13
c(2) = 91-13 = 78 -> MCD(91, 91 mod 78) = MCD(91,13) = 13 -> 91 = 13*(91:13)=13*7
Tutto molto semplice, ovvio e soprattutto generale, infatti su s, p, q non è stata fatta nessuna ipotesi né posto alcun vincolo eccetto che siano primi maggiori di 2 diversi tra loro (che è il caso della discussione). Inoltre non c'è bisogno di calcolare intervalli (essendo la proprietà valida su coppie): il risultato si ottiene per costruzione, la dimostrazione ti dice direttamente come calcolare i valori che mostrano come fattorizzare.
Non è neanche una dimostrazione ma una semplice proprietà dei numeri naturali.
Penso che su matematicamente non ti hanno risposto perché hai presentato male la questione, le premesse iniziali
sembrano scollegate dalle 2 dimostrazioni che esponi, non si capisce dove vuoi andare a parare. Invece a me quelle premesse piacevano perché dal poco che si capisce di quello che fa @piergiac-1 le elevazioni a potenza di numeri primi sono pane quotidiano.
I valori di c<p*q sono molti ma non abbastanza: l'autore si imbatte in un valore di c che chiama "chiave" che esiste e quindi fattorizza, ma è una risposta che NON mi soddisfa. Dato che procede praticamente a caso è improbabile che si imbatta proprio in quelle eventualmente trovate per sottrazione; lui eleva sempre numeri primi a potenza, io voglio vedere "chiavi" che siano potenze di numero primi, ossia numeri nella forma c=u^k (u elevato alla k) con u primo e k>=1.
p=631, q=15859 -> s=10007029 -> MCD(10007029, 10007029 mod 881) = MCD(10007029, 631) = 631 -> trovata, 881 è un numero primo (elevato a 1, come esempio mi basta quindi ci sono).
Ma a questo punto basta ripetere il ragionamento precedente: MCD(p*q, p)=p ma anche MCD(p*q, z*p)=p a patto che la decomposizione in fattori primi di z NON CONTENGA q (altrimenti il massimo comun divisore sarebbe p*q).
Simmetricamente MCD(p*q, w*q)=q a patto che la decomposizione in fattori primi di w NON CONTENGA p (altrimenti il massimo comun divisore sarebbe p*q).
Ci sono infiniti valori z*p (rispettivamente w*q) che soddisfino l'uguaglianza MCD(p*q, z*p)=p (rispettivamente MCD(p*q, w*q)=q), ecco perché alla fine ci sbatte contro, compresi numeri primi elevati a potenza, proprio quello che volevo trovare.
Invece la cattiva notizia per l'autore del presunto metodo di cifratura è che non esiste nessuna "scoperta sensazionale mai osservata prima" si tratta di una semplice proprietà tra numeri naturali. La cosa paradossale è per calcolare la "miracolosa chiave" bastava fare una sottrazione, è l'unica operazione veramente O(1), invece lui va quasi a caso!
Sulla crittografia mi esprimo in un prossimo post, ora sono esausto
Questo è il programma C che ho usato per le prove sui numeri:
C:
#include <stdio.h>
#include <stdlib.h>
#define MAX_INPUT 99999L // limitazione dati input
char *titolo = "espressione MCD(s, s mod c), s=p*q";
// MCD con algoritmo di Euclide
long euclideMCD(long a, long b){
long resto;
while(b > 0){
resto = a % b;
a = b;
b = resto;
}
return a;
}
// prototipi di funzione per stampa cosmetica
void stampaInizio(char *titolo); // prototipo
void stampaFineAspettaINVIO(char *titolo); // prototipo
void stampaIntento();
void stampaDati(long p, long q, long s);
void stampaRiepilogo(int contaDispariP, int contaDispariQ, int contaPariP, int contaPariQ);
int main(void) {
stampaInizio(titolo);
int ripeti = 1;
// dati di test
long p; // il primo fattore
long q; // il secondo fattore
long s; // sarà s=p*q
// valori minimi e massimo del modulo (della divisione) da testare
long min;
long max; // massimo valore da testare nell'espressione MCD(s, s mod c)
do{ // INSERIRE QUI CORPO PROGRAMMA
stampaIntento();
// lettura input
printf("\n\n1)Inserisci input in [2 - %lu] --> ", MAX_INPUT);
scanf("%lu", &p);
while(getchar() != '\n'); // consuma eventuale input in eccesso
printf("2)Inserisci input in [2 - %lu] --> ", MAX_INPUT);
scanf("%lu", &q);
while(getchar() != '\n'); // consuma eventuale input in eccesso
// aggiusto e riordino l'input
if(p<2 || p > MAX_INPUT) p = 2; // input fuori dai limiti
if(q<2 || q > MAX_INPUT) q = 3; // input fuori dai limiti
if(p>q){ // scambia i valori se necessario per riordinarli
long temp = p;
p = q;
q = temp;
}
s = p*q;
stampaDati(p, q, s);
min = p + 1;
max = s - p; // massimo valore per c
long resto; // s mod c --> resto della divisioe tra s e c
long ris; // risultato di MCD(s, s mod c)
// variabili per statistica di riepilogo
int contaDispariP = 0; // totale soluzioni c dispari che ritornano p = il fattore minore
int contaDispariQ = 0; // totale soluzioni c dispari che ritornano q = il fattore maggiore
int contaPariP = 0; // totale soluzioni c pari che ritornano p = il fattore minore
int contaPariQ = 0; // totale soluzioni c pari che ritornano q = il fattore maggiore
printf("Valore di c -> s mod c = r -> MCD(s,r) = p oppure q -> s = p*q oppure s=q*p\n");
printf("________________________________________________________________________________\n");
for (long c = min; c <= max; c++) {
resto = s % c;
ris = euclideMCD(s, resto);
if(ris==q || ris == p){
if(c % 2){ // soluzione dispari
ris==q ? contaDispariQ++ : contaDispariP++;
}
else{ // soluzione pari
ris==q ? contaPariQ++ : contaPariP++;
}
printf("c = %-10lu -> ", c);
printf("%lu mod %lu = %lu -> ", s, c, resto);
printf("MCD(%lu,%lu) = %lu -> ", s, resto, ris);
printf("%lu = %lu * %lu", s, ris, s/ris);
printf("\n");
}
}
stampaRiepilogo(contaDispariP, contaDispariQ, contaPariP, contaPariQ);
//CALCOLO ESEGUITO, CHIEDE RIPETIZIONE
printf("\nNuova esecuzione? (0=NO, diverso da 0 = SI) --> ");
scanf("%d", &ripeti);
while(getchar() != '\n'); // consuma input e aspetta INVIO
printf("\n");
} while(ripeti != 0);
stampaFineAspettaINVIO(titolo);
return 0;
}
// riga orizzontale da 40 trattini
char *rigaHR =
"--------------------------------------------------\n";
// riga orizzontale da 80 trattini di sottolineatura
char *rigaHR2 =
"________________________________________________________________________________\n";
void stampaIntento(){
printf("Scopo del calcolo:");
printf("\ndati in input 2 interi positivi p e q e, calcolato il prodotto s = p*q, trovare");
printf("\ngli interi positivi c per cui l'espressione MCD(s, s mod c) ritorna p oppure q;");
printf("\nLa fattorizzazione risultante di s sara':");
printf("\n1) se MCD(s, s mod c) = p, allora s = p * q");
printf("\n2) se MCD(s, s mod c) = q, allora s = q * p");
printf("\nInput: 2 interi positivi p e q nell'intervallo [2 - %lu];", MAX_INPUT);
printf("\nfuori da tale limite i valori p e q verranno stabiliti dal programma.");
}
// stampa dati
void stampaDati(long p, long q, long s){
printf("\nInseriti p = %lu, q = %lu --> s = p * q = %lu\n", p, q, s);
printf("\nFattorizzazione di s con espressione MCD(s, s mod c)\n");
printf(rigaHR2);
}
/** Stampa un riepilogo delle soluzioni trovate.
*
* @param contaDispariP = totale soluzioni c dispari che ritornano p = il fattore minore
* @param contaDispariQ = totale soluzioni c dispari che ritornano q = il fattore maggiore
* @param contaPariP = totale soluzioni c pari che ritornano p = il fattore minore
* @param contaPariQ = totale soluzioni c pari che ritornano q = il fattore maggiore
*/
void stampaRiepilogo(int contaDispariP, int contaDispariQ, int contaPariP, int contaPariQ){
// totale soluzioni c dispari
int contaDispari = contaDispariP + contaDispariQ;
// totale soluzioni c pari
int contaPari = contaPariP + contaPariQ;
// totale soluzioni c
int conta = contaDispari + contaPari;
// totale soluzioni c che ritornano p = il fattore minore
int contaP = contaDispariP + contaPariP;
// totale soluzioni c che ritornano q = il fattore maggiore
int contaQ = contaDispariQ + contaPariQ;
printf(rigaHR2);
printf("N.soluzioni c trovate: %d (pari-dispari = %d-%d)\n", conta, contaPari, contaDispari);
printf("N.soluzioni c trovate che ritornano p: %d (pari-dispari = %d-%d)\n", contaP, contaPariP, contaDispariP);
printf("N.soluzioni c trovate che ritornano q: %d (pari-dispari = %d-%d)\n", contaQ, contaPariQ, contaDispariQ);
printf(rigaHR2);
}
void stampaInizio(char *titolo){
printf(rigaHR);
printf("IN ESECUZIONE : ");
printf(titolo);
printf("\n");
printf(rigaHR);
}
void stampaFineAspettaINVIO(char *titolo){
printf("\n");
printf(rigaHR);
printf("TERMINATO : ");
printf(titolo);
printf("\n");
printf(rigaHR);
printf("Premi un tasto per terminare ");
while(getchar() != '\n');
printf("\n");
}
Con solito imperdonabile ritardo rispondo, non so se riesco a dire tutto, se necessario aggiungo nei prossimi giorni.
Potrei aver fatto qualche errore di copia-incolla, nel caso segnalatemeli.
Alla base del tuo ragionamento iniziale c'era un'affermazione palesemente falsa, precisamente questa
bastavano carta, penna e 3 secondi per verificare che se hai 15=3*5=5*3 li fattorizzi con MCD(15, 15 mod c) in almeno 2 modi:
15 mod 10 = 5 -> MCD(15,5) = 5 -> 15 = 5 * 3
15 mod 4 = 3 -> MCD(15,3) = 3 -> 15 = 3 * 5
oltre a c=10 e 4 si fattorizza anche con c=12, 6, 9,;
ovvio che ti ho bollato come sbagliata la dimostrazione, con una simile premessa mi sembrava una perdita di tempo inutile controllare il resto.
L'errore ti ha fatto ragionare su mezza verità, un mesetto buono per arrivare alla conclusione che la fattorizzazione esiste, facendo 15 passaggi di calcoli laboriosi nella prima versione e 10 nella seconda. Ti ha infatti obbligato ad imporre la condizione a mod c = 1, l'unico modo per arrivare ad ottenere il numero primo più piccolo, e da lì tutti i calcoli.
Invece io ho ragionato sul resto della divisione tra interi: consideriamo i naturali (>1 per togliere di mezzo i casi banali/non-permessi della divisione); per fissare le idee p<q (ma in realtà vale anche per p=q che è un caso banale), s=p*q e l'espressione MCD(s, s mod c).
Come faccio a trovare c in modo che MCD(s, s mod c)=p oppure MCD(s, s mod c)=q?
Per MCD(s, s mod c)=p è sufficiente che s mod c=p e quindi MCD(s, p)=MCD(p*q, p)=p e quindi fattorizzo in p*q ,
Per MCD(s, s mod c)=q è sufficiente che s mod c=q e quindi MCD(s, q)=MCD(p*q, q)=q e quindi fattorizzo in q*p
Ma s mod c è il resto della divisione di s per c
-> per avere un resto p deve essere s : c = k con resto p -> s=k*c+p -> s-p = k*c ; dividendo s per s-p -> s : (s-p) = 1 con resto p, infatti 1*(s-p)+p=s. -> ho trovato la fattorizzazione p*q per mezzo di c=s-p
simmetricamente per l'altro valore s : (s-q) = 1 con resto q -> ho trovato la fattorizzazione q*p per mezzo di c=s-q
In sintesi, dati p,q trovi immediatamente le "chiavi" che ritornano la fattorizzazione sostituite in MCD(s, s mod c):
c(1)=s-p -> è la c più grande <p*q che fattorizza in p*q
c(2)=s-q -> è la c più grande <p*q che fattorizza in q*p
Esempio (su numeri primi):
p=7, q=13 -> s=7*13=91
c(1) = 91-7 = 84 -> MCD(91, 91 mod 84)= MCD(91,7) = 7 -> 91 = 7*(91:7)=7*13
c(2) = 91-13 = 78 -> MCD(91, 91 mod 78) = MCD(91,13) = 13 -> 91 = 13*(91:13)=13*7
Tutto molto semplice, ovvio e soprattutto generale, infatti su s, p, q non è stata fatta nessuna ipotesi né posto alcun vincolo, trovi la fattorizzazione per qualunque coppia di numeri (entrambi primi, entrambi composti, un primo e un composto, possono anche essere uguali). Inoltre non c'è bisogno di calcolare intervalli (essendo la proprietà valida su coppie): il risultato si ottiene per costruzione, la dimostrazione ti dice direttamente come calcolare 2 valori che mostrano come fattorizzare.
Con questa in mano la tua dimostrazione non serve, per "inutile" intendevo che non dici nulla di nuovo, sicuramente è cosa nota da secoli perché è un problema di fattorizzazione molto banale, se ci sono arrivato io in una mezz'oretta, figuriamoci un matematico professionista anche di 3-4 secoli fa, quando c'era Fermat che mangiava teoria dei numeri a colazione, a maggior ragione i grandi matematici che hanno continuato la sua opera.
Tuttavia i passaggi che ho fatto dicono anche altro:
in entrambe le versioni della tua dimostrazione (nella prima il punto 4, nella seconda il punto 6) appare l'espressione a*b mod c = b -> corrisponde esattamente a quello che io nella mia indico con s mod c=p perché c'è solo un cambio di lettera: q=a, p=b e quindi a*b=s -> se lo interpreto correttamente la tua dimostrazione è un sottocaso particolare di quella più generale, deve essere giusta.
Inoltre penso che si possa dimostrare anche in un altro modo, sempre partendo da quella più generale usando le sottrazioni ripetute: c=s-p è una "chiave", e lo sono anche quelle ottenute continuando a sottrarre p, ossia s-2p, s-3p... s-kp fin quando è ragionevole farlo, infatti a furia di sottrarre si dovrebbe arrivare a coprire i valori che trova la tua. Non sono riuscito a dimostrarlo in simboli ma penso che si possa fare, le prove sono incoraggianti
Inserisci p --> 7
Inserisci q --> 13
Inseriti p = 7 | q = 13 --> s = 91
Fattorizzazione s = p * q con espressione MCD(s, s mod c)
___________________________________________________________________________
Valore di c -> s mod c = r -> MCD(s,r) = p oppure q -> s = p*q oppure s=q*p
__________________________________________________
c = 12 -> 91 mod 12 = 7 -> MCD(91,7) = 7 -> 91 = 7 * 13
c = 14 -> 91 mod 14 = 7 -> MCD(91,7) = 7 -> 91 = 7 * 13
c = 21 -> 91 mod 21 = 7 -> MCD(91,7) = 7 -> 91 = 7 * 13
c = 26 -> 91 mod 26 = 13 -> MCD(91,13) = 13 -> 91 = 13 * 7
c = 28 -> 91 mod 28 = 7 -> MCD(91,7) = 7 -> 91 = 7 * 13
c = 35 -> 91 mod 35 = 21 -> MCD(91,21) = 7 -> 91 = 7 * 13
c = 39 -> 91 mod 39 = 13 -> MCD(91,13) = 13 -> 91 = 13 * 7
c = 42 -> 91 mod 42 = 7 -> MCD(91,7) = 7 -> 91 = 7 * 13
c = 49 -> 91 mod 49 = 42 -> MCD(91,42) = 7 -> 91 = 7 * 13
c = 52 -> 91 mod 52 = 39 -> MCD(91,39) = 13 -> 91 = 13 * 7
c = 56 -> 91 mod 56 = 35 -> MCD(91,35) = 7 -> 91 = 7 * 13
c = 63 -> 91 mod 63 = 28 -> MCD(91,28) = 7 -> 91 = 7 * 13
c = 65 -> 91 mod 65 = 26 -> MCD(91,26) = 13 -> 91 = 13 * 7
c = 70 -> 91 mod 70 = 21 -> MCD(91,21) = 7 -> 91 = 7 * 13
c = 77 -> 91 mod 77 = 14 -> MCD(91,14) = 7 -> 91 = 7 * 13
c = 78 -> 91 mod 78 = 13 -> MCD(91,13) = 13 -> 91 = 13 * 7
c = 84 -> 91 mod 84 = 7 -> MCD(91,7) = 7 -> 91 = 7 * 13
___________________________________________________________________________
N.soluzioni c trovate: 17 (pari-dispari = 10-7)
N.soluzioni c trovate che ritornano p: 12 (pari-dispari = 7-5)
se parti dagli ultimi valori e risali (saltando quelli per q come il 78) dovresti ritrovare le chiavi al di sotto di quella che chiami c_max;
la stessa cosa vale per s-q, s-2q, s-3q, ma quelle non le puoi usare perchè hai imposto a mod c = 1.
Quindi, dal punto di vista formale, abbiamo 2 dimostrazioni che dimostrano che la fattorizzazione esiste. Mi piace di più quella che ho fatta io, non perché l'ho fatta io, ma perché è innegabilmente molto più semplice, generale e "racconta di più": con la tua si individuano poche "chiavi" di fattorizzazione a causa della limitazione a mod c = 1, con la mia, partendo dai 2 valori di c sicuri, si individuano 2 serie di "chiavi" piuttosto lunghe.
Penso che su matematicamente non ti hanno risposto perché hai presentato male la questione, le premesse iniziali
sembrano scollegate dalle 2 dimostrazioni che esponi, non si capisce dove vuoi andare a parare. Invece a me quelle premesse piacevano perché dal poco che si capisce di quello che fa @piergiac-1 le elevazioni a potenza di numeri primi sono pane quotidiano.
2 serie di chiavi sono tante chiavi ma non abbastanza: l'autore si imbatte in una "chiave" che abbiamo dimostrato esistere e quindi fattorizza, ma è una risposta che NON mi soddisfa. Dato che procede praticamente a caso è improbabile che si imbatta proprio in quelle trovate per sottrazione; lui eleva sempre numeri primi a potenza, io voglio vedere chiavi che siano potenze di numero primi, ossia chiavi nella forma c=u^k (u elevato alla k) con u primo e k>=1.
p=631, q=15859 -> s=10007029 -> MCD(10007029, 10007029 mod 881) = MCD(10007029, 631) = 631 -> trovata, 881 è un numero primo (elevato a 1, come esempio mi basta quindi ci sono).
Ma a questo punto basta ripetere il ragionamento precedente: MCD(p*q, p)=p ma anche MCD(p*q, z*p)=p a patto che la decomposizione in fattori primi di z NON CONTENGA q (altrimenti il massimo comun divisore sarebbe p*q).
Simmetricamente MCD(p*q, w*q)=q a patto che la decomposizione in fattori primi di w NON CONTENGA p (altrimenti il massimo comun divisore sarebbe p*q).
Ci sono infinite chiavi, ecco perché alla fine ci sbatte contro, e ci sono numeri primi elevati a potenza, proprio quello che volevo trovare.
Invece la cattiva notizia per l'autore del presunto metodo di cifratura è che non esiste nessuna "scoperta sensazionale mai osservata prima" si tratta di una semplice proprietà tra numeri naturali. La cosa paradossale è per calcolare la "miracolosa chiave" bastava fare una sottrazione, è l'unica operazione veramente O(1), invece lui va quasi a caso!
Sulla crittografia mi esprimo in un prossimo post, ora sono esausto
Questo è il programma C che ho usato per le prove sui numeri:
C:
#include <stdio.h>
#include <stdlib.h>
char *titolo = "espressione MCD(s, s mod c), s=p*q";
// MCD con algoritmo di Euclide
long euclideMCD(long a, long b){
long resto;
while(b > 0){
resto = a % b;
a = b;
b = resto;
}
return a;
}
// prototipi di funzione per stampa cosmetica
void stampaInizio(char *titolo); // prototipo
void stampaFineAspettaINVIO(char *titolo); // prototipo
void stampaIntento();
void stampaDati(long p, long q, long s);
void stampaRiepilogo(int contaDispariP, int contaDispariQ, int contaPariP, int contaPariQ);
int main(void) {
stampaInizio(titolo);
int ripeti = 1;
// dati di test
long p; // il primo fattore
long q; // il secondo fattore
long s; // sarà s=p*q
// valori minimi e massimo del modulo (della divisione) da testare
long min;
long max; // massimo valore da testare nell'espressione MCD(s, s mod c)
do{ // INSERIRE QUI CORPO PROGRAMMA
stampaIntento();
// lettura input
printf("\n\nInserisci p --> ");
scanf("%lu", &p);
while(getchar() != '\n'); // consuma eventuale input in eccesso
if(p<0) p = 2;
printf("\nInserisci q --> ");
scanf("%lu", &q);
while(getchar() != '\n'); // consuma eventuale input in eccesso
if(q<0) q = 3;
// scambia i valori se necessario
if(p>q){
long temp = p;
p = q;
q = temp;
}
s = p*q;
stampaDati(p, q, s);
min = p + 1;
max = s - p; // massimo valore per c
long resto; // s mod c --> resto della divisioe tra s e c
long ris; // risultato di MCD(s, s mod c)
// variabili per statistica di riepilogo
int contaDispariP = 0; // totale soluzioni c dispari che ritornano p = il fattore minore
int contaDispariQ = 0; // totale soluzioni c dispari che ritornano q = il fattore maggiore
int contaPariP = 0; // totale soluzioni c pari che ritornano p = il fattore minore
int contaPariQ = 0; // totale soluzioni c pari che ritornano q = il fattore maggiore
printf("Valore di c -> s mod c = r -> MCD(s,r) = p oppure q -> s = p*q oppure s=q*p\n");
printf("__________________________________________________\n");
for (long c = min; c <= max; c++) {
resto = s % c;
ris = euclideMCD(s, resto);
if(ris==q || ris == p){
if(c % 2){ // soluzione dispari
ris==q ? contaDispariQ++ : contaDispariP++;
}
else{ // soluzione pari
ris==q ? contaPariQ++ : contaPariP++;
}
printf("c = %-7lu -> ", c);
printf("%lu mod %lu = %lu -> ", s, c, resto);
printf("MCD(%lu,%lu) = %lu -> ", s, resto, ris);
printf("%lu = %lu * %lu", s, ris, s/ris);
printf("\n");
}
}
stampaRiepilogo(contaDispariP, contaDispariQ, contaPariP, contaPariQ);
//CALCOLO ESEGUITO, CHIEDE RIPETIZIONE
printf("\nNuova esecuzione? (0=NO, diverso da 0 = SI) --> ");
scanf("%d", &ripeti);
while(getchar() != '\n'); // consuma input e aspetta INVIO
printf("\n");
} while(ripeti != 0);
stampaFineAspettaINVIO(titolo);
return 0;
}
// riga orizzontale da 40 trattini
char *rigaHR =
"--------------------------------------------------\n";
// riga orizzontale da 75 trattini di sottolineatura
char *rigaHR2 =
"___________________________________________________________________________\n";
void stampaIntento(){
printf("Scopo del calcolo:");
printf("\ndati in input 2 interi positivi p e q e, calcolato il prodotto s = p*q, trovare");
printf("\ngli interi positivi c per cui l'espressione MCD(s, s mod c) ritorna p oppure q;");
printf("\nLa fattorizzazione risultante di s sara':");
printf("\n1) se MCD(s, s mod c) = p, allora s = p * q");
printf("\n2) se MCD(s, s mod c) = q, allora s = q * p");
}
// stampa dati
void stampaDati(long p, long q, long s){
printf("\nInseriti p = %lu | q = %lu --> s = %lu\n", p, q, s);
printf("\nFattorizzazione s = p * q con espressione MCD(s, s mod c)\n");
printf(rigaHR2);
}
/** Stampa un riepilogo delle soluzioni trovate.
*
* @param contaDispariP = totale soluzioni c dispari che ritornano p = il fattore minore
* @param contaDispariQ = totale soluzioni c dispari che ritornano q = il fattore maggiore
* @param contaPariP = totale soluzioni c pari che ritornano p = il fattore minore
* @param contaPariQ = totale soluzioni c pari che ritornano q = il fattore maggiore
*/
void stampaRiepilogo(int contaDispariP, int contaDispariQ, int contaPariP, int contaPariQ){
// totale soluzioni c dispari
int contaDispari = contaDispariP + contaDispariQ;
// totale soluzioni c pari
int contaPari = contaPariP + contaPariQ;
// totale soluzioni c
int conta = contaDispari + contaPari;
// totale soluzioni c che ritornano p = il fattore minore
int contaP = contaDispariP + contaPariP;
// totale soluzioni c che ritornano q = il fattore maggiore
int contaQ = contaDispariQ + contaPariQ;
printf(rigaHR2);
printf("N.soluzioni c trovate: %d (pari-dispari = %d-%d)\n", conta, contaPari, contaDispari);
printf("N.soluzioni c trovate che ritornano p: %d (pari-dispari = %d-%d)\n", contaP, contaPariP, contaDispariP);
printf("N.soluzioni c trovate che ritornano q: %d (pari-dispari = %d-%d)\n", contaQ, contaPariQ, contaDispariQ);
printf(rigaHR2);
}
void stampaInizio(char *titolo){
printf(rigaHR);
printf("IN ESECUZIONE : ");
printf(titolo);
printf("\n");
printf(rigaHR);
}
void stampaFineAspettaINVIO(char *titolo){
printf("\n");
printf(rigaHR);
printf("TERMINATO : ");
printf(titolo);
printf("\n");
printf(rigaHR);
printf("Premi un tasto per terminare ");
while(getchar() != '\n');
printf("\n");
}
deve essere veramente magica se ne basta una, sempre quella, sempre la stessa, per domarli tutti, manco fosse il Signore degli Anelli.
Assurdo no? Questa non è matematica, è fantascienza
Per non parlare di tutte le cose infondate e assurde che sono state dette nel tentativo di ridicolizzare questo metodo, e non solo da te.
a:
Invece la cattiva notizia per l'autore del presunto metodo di cifratura è che non esiste nessuna "scoperta sensazionale mai osservata prima" si tratta di una semplice proprietà tra numeri naturali. La cosa paradossale è per calcolare la "miracolosa chiave" bastava fare una sottrazione, è l'unica operazione veramente O(1), invece lui va quasi a caso!
Con questa in mano la tua dimostrazione non serve, per "inutile" intendevo che non dici nulla di nuovo, sicuramente è cosa nota da secoli perché è un problema di fattorizzazione molto banale, se ci sono arrivato io in una mezz'oretta, figuriamoci un matematico professionista anche di 3-4 secoli fa, quando c'era Fermat che mangiava teoria dei numeri a colazione, a maggior ragione i grandi matematici che hanno continuato la sua opera.
Se hai qualche articolo scientifico che mette in evidenza questa proprietà mi piacerebbe conoscerlo perchè in tutte le mie ricerche a riguardo si sono rivelate inutili.
L'unica cosa che mi fa piacere è il cambio di rotta della discussione, anche se questo non toglie o cancella la vostra superficialità nel elargire gratuitamente giudizi negativi.
Per tanto il mio consiglio è: Non banalizzare il sistema utilizzato da me, perchè, nonostante tu abbia finalmente analizzato e verificato che la proprietà è valida, non stai dimostrando che a partire dal semiprimo, senza conoscere i numeri primi coinvolti, si possa in qualche modo arrivare a questi con estrema facilità.
Aspetto il tuo commento sul programma di criptazione, ma ti avviso, se critichi il programma per come è scritto come ha fatto Skill, non farai altro che tornare ai tuoi livelli precedenti di critica senza dimostrazione. Ti rammento anche che il programma usa una chiave simmetrica perchè per troppo tempo hai sostenuto che usa una chiave asimmetrica. Questo ci tengo a sottolinearlo.
Mi aspetto una risposta sulla validità di sicurezza del procedimento: C'è una chiave pubblica (semiprimo) , C'è una chiave simmetrica (c), C'è un messaggio criptato.
NB: il messaggio lo puoi criptare come ti pare, ma solo il fattore primo estratto dalla chiave pubblica(semiprimo) ti darà l'accesso alla descriptazione. Tenendo ben presente che parliamo comunque di fattori primi di 6000/7000bit e un semiprimo di oltre 13000bit, che attualmente non vengono usati nella crittografia perchè troppo grandi e difficili da gestire in modo efficiente. Cosa che io invece ho trovato il modo di sfruttarli in modo molto efficiente
Io non mi permetto perché sono ignorante, ma perché se è una scoperta così sensazionale siamo ancora a parlarne su Tom's Hardware e invece non c'è un riconoscimento dalla comunità matematica mondiale? Con tanto di notizie sulle maggiori testate ecc?
Mistero
Io non mi permetto perché sono ignorante, ma perché se è una scoperta così sensazionale siamo ancora a parlarne su Tom's Hardware e invece non c'è un riconoscimento dalla comunità matematica mondiale? Con tanto di notizie sulle maggiori testate ecc?
Mistero
Pensi che la comunità scientifica sia una comunità aperta a tutti?
A me sembra ovvio che non sia così e che non puoi presentarti alla comunità scientifica senza averne tittolo. Ciò non toglie che questo sistema funziona e chiunque può sperimentarlo.
Possiamo parlare di tutto ma per favore siamo seri. Se vuoi dimostrare anche tu che questo sistema è banale, prendi uno dei semiprimi che ho postato e svelane i numeri primi che lo compongono
Pensi che la comunità scientifica sia una comunità aperta a tutti?
A me sembra ovvio che non sia così e che non puoi presentarti alla comunità scientifica senza averne tittolo. Ciò non toglie che questo sistema funziona e chiunque può sperimentarlo.
Possiamo parlare di tutto ma per favore siamo seri. Se vuoi dimostrare anche tu che questo sistema è banale, prendi uno dei semiprimi che ho postato e svelane i numeri primi che lo compongono
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...
Quanto ho scritto io corrisponde a verità. E tra l’altro io ti ho scritto quanto sono le basi della programmazione. Uno non può dir di aver scritto un algoritmo se perdonami il temine lo ha scritto coi piedi. Bella l’idea. Ma invece di elargisi da guru. Perché non imparare a scrivere codice pulito che è lo scopo di un programmatore? Alla base di tutto c’è sempre il CLEAN CODE!
Devi innanzitutto scriverlo meglio per renderlo più logico. È più comprensibile per tutti.
Così diventa più facile per un matematico leggerlo e capirlo e sua volta anche per altri programmatori.
Poi l’analisi che ti ho fatto dimostra che il tuo algoritmo non è sicuro.
Ora sono concentrato su un progetto di AI. Appena trovo il tempo ti dimostro come posso bucare il tuo algoritmo e accedere alla prima chiave.
Se hai qualche articolo scientifico che mette in evidenza questa proprietà mi piacerebbe conoscerlo perchè in tutte le mie ricerche a riguardo si sono rivelate inutili.
purtroppo non hai capito neanche una sillaba di quanto ho scritto nel precedente post
ho mostrato formula che comunque prendi due interi positivi per la fattorizzazione con MCD(s, s mod c) basta fare una sottrazione; paradossalmente ti ho aiutato, visto che fai tanta fatica a trovare le "chiavi": ti ho dato l'algoritmo per scrivere una funzione che non hai! (ma risparmiati la fatica, tanto è inutile). Secondo te si scrive un articolo scientifico per una simile stupidata?
Basta che fai così:
apri Python
in una variabile p, poni p =un numero primo dispari
in una variabile q, poni q =un altro numero primo dispari differente dal precedente
in una variabile s, calcola il semiprimo s = p*q
in una variabile c1, poni c1 = s - p e otterrai un intero c1 che tu chiami chiave
in una variabile c2, poni c2 = s - q e otterrai un intero c2 che tu chiami chiave
calcola MCD(s, s mod c1) e vedrai che otterrai p (quindi la fattorizzazione p*q)
calcola MCD(s, s mod c1) e vedrai che otterrai q (quindi la fattorizzazione q*p)
la sicurezza di un programma sta MOLTO in come è scritto e implementato: se programmi da schifo un modo per bucarti qualcuno del mestiere lo trova. Io non cracko nenanche l'algoritmo di Cesare ma c'è gente che vive per quello, ne sanno una più del diavolo.
Inoltre hai fatto un pappone postando parti con funzioni hash crittografia simmetrica non è roba fatta da te e che comunque non c'entra nulla con questa discussione. Sono totalmente d'accordo con @Skills07
solo il fattore primo estratto dalla chiave pubblica(semiprimo) ti darà l'accesso alla descriptazione. Tenendo ben presente che parliamo comunque di fattori primi di 6000/7000bit e un semiprimo di oltre 13000bit, che attualmente non vengono usati nella crittografia perchè troppo grandi e difficili da gestire in modo efficiente. Cosa che io invece ho trovato il modo di sfruttarli in modo molto efficiente
ti limiti a mettere la "chiave" segreta (che precalcoli) in un file, ma non è questo il punto.
Quello che non riesci a capire è che la sicurezza NON STA SOLO nell'enorme dimensione del numero, ma proprio nei numeri stessi.
A parte la dimensione, una caratteristica che si cerca è la massima casualità della rappresentazione binaria del numero: in teoria dei codici si chiama entropia dell'informazione: anche se generi numeri da 13000 bit, non è per niente scontato che siano sicuri perché le sottosequenze di 0-1 che li compongono potrebbero contenere delle regolarità che possono essere sfruttate da un attacco.
I numeri RSA avevano tali caratteristiche, ma poi la crittografia si è evoluta e ormai non si usa più RSA o sue derivate basate sulla fattorizzazione di semiprimi.
ma secondo i tuoi infallibili calcoli doveva fare 631...
chi è che parla a vanvera adesso?
