Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - Cifrare
Forum - C/C++ - Cifrare

Pagine: [ 1 2 ] Precedente | Prossimo
Avatar
Thejuster (Admin)
Guru^2


Messaggi: 2331
Iscritto: 04/05/2008

Segnala al moderatore
Postato alle 17:44
Venerdì, 17/05/2024
Salve ragazzi qualcuno ha già realizzato un cifrario in passato?

Io sto facendo un tentativo per criptare alcune informazioni per un mio programma.

fin quando uso questa formula esempio

Codice sorgente - presumibilmente VB.NET

  1. string EncodeString(const string& s)
  2. {
  3.     int16_t hash = 0x33FA;  //hash iniziale
  4.     ostringstream encodedString;
  5.  
  6.     for (size_t i = 0; i < s.length(); ++i)
  7.     {
  8.         char c = s[i];
  9.         char encodedChar = c ^ hash;  // XOR con il valore hash
  10.         encodedString << encodedChar;
  11.     }
  12.  
  13.     return encodedString.str();
  14. }



Ed uso il metodo inverso per recupere i valori funziona.
Ma se provo ad aggiungere all'econdedChar ulteriori parametri del tipo

(c ^ hash) * 2 esempio, non riesco più a risalire alla stringa originale. Nonostante sia che l'encode / decode siano uguali.

Che metodo utilizzate solitamente per questo tipo di cifrari?

Ultima modifica effettuata da Thejuster il 17/05/2024 alle 17:45


https://mire.forumfree.it/ - Mire Engine
C# UI Designer
PM Quote
Avatar
Carlo (Member)
Guru


Messaggi: 1388
Iscritto: 29/01/2018

Segnala al moderatore
Postato alle 21:03
Venerdì, 17/05/2024
Testo quotato

Postato originariamente da Thejuster:
Che metodo utilizzate solitamente per questo tipo di cifrari?



Niente di sofisticato, cripto e decripto con una chiave, questo è il metodo che avevo usato nel progetto 2048, scriito insieme ad Ultimo e Mikelius è in C# ma il concetto è valido.

La chiave la puoi allungare o accorciare a piacere:
Codice sorgente - presumibilmente C#

  1. public string Cripta(string Stringa)
  2. {
  3.     string _criptata = "";
  4.     byte[] ChiaveArray = { 10, 1, 12, 8, 7, 4, 9, 11, 2, 6, 5 };
  5.     for (var i = 0; i < Stringa.Length; i++)
  6.     {
  7.         _criptata += Convert.ToChar(Convert.ToInt32(Stringa[i]) + ChiaveArray[i % ChiaveArray.Length]).ToString();
  8.     }
  9.     return _criptata;
  10. }
  11.  
  12. public string DeCripta(string Stringa)
  13. {
  14.     string _decriptata = "";
  15.     byte[] ChiaveArray = { 10, 1, 12, 8, 7, 4, 9, 11, 2, 6, 5 };
  16.     for (var i = 0; i < Stringa.Length; i++)
  17.     {
  18.         _decriptata += Convert.ToChar(Convert.ToInt32(Stringa[i]) - ChiaveArray[i % ChiaveArray.Length]).ToString();
  19.     }
  20.     return _decriptata;
  21. }



i % ChiaveArray.Length // fa si che la chiave sia ciclicamente applicata.

Con una chiave random lunga come il testo da criptare la decodifica non è più possibibile senza conoscere la chiave, ma già con una chiave lunga una decina di caratteri la decodifica è fuori portata ai più.

Non ci sono controlli di overflow.

Ultima modifica effettuata da Carlo il 17/05/2024 alle 21:37


in programmazione tutto è permesso
PM Quote
Avatar
AldoBaldo (Member)
Guru


Messaggi: 708
Iscritto: 08/01/2015

Segnala al moderatore
Postato alle 22:12
Venerdì, 17/05/2024
A me intriga un metodo che usa come chiave un file qualsiasi, purché di grandi dimensioni e contenente byte con valori che coprano l'intera gamma 0x00-0xFF (un brano musicale, un filmato, un'immagine…), seguendo questi passi:

1) considera un byte alla volta i dati che si intende criptare
2) estrae a sorte una posizione qualsiasi nel file della chiave
3) scorre il file della chiave dal punto estratto fino a incontrare un byte identico a quello considerato in 1) (se il byte non viene trovato a partire dalla posizione estratta, continua la ricerca dall'inizio)
4) memorizza l'indice al byte trovato nella versione codificata dei dati
5) ripete il tutto col byte successivo dei dati che si intende criptare, finché se ne raggiunge la fine

In questo modo si ottiene una serie di valori che sono assolutamente privi di senso se non si dispone del file della chiave.

È vero che in fase di codifica può capitare che un certo byte non sia presente nella chiave, ma in quel caso basta cambiare chiave. Comunque sia, con i file di grandi dimensioni si tratta di un caso molto raro (in genere contengono ogni particolare byte una quantità di volte).
Per evitare che un certo valore possa essere legato in modo univoco a una singola posizione (può capitare che il byte della chiave presenti un certo byte in una ed una sola posizione), si può prevedere una funzione che verifichi preventivamente che la chiave contenga almeno una quantità minima a piacere di occorrenze per ogni byte.

Per decodificare:

1) considera un valore alla volta i valori contenuti nel file codificato
2) rileva dal file della chiave il byte che si trova nella posizione appena letta dal file codificato
3) ripete il tutto col valore successivo tra quelli contenuti nel file codificato, finché se ne raggiunge la fine

Il difetto più evidente di questo metodo è che ogni byte da codificare richiede una quantità maggiore di byte nel file codificato. Ad esempio, se si usano indici a 32 bit, ogni byte da codificare richiederà quattro byte nel file codificato.

Non ho idea del grado di affidabilità della codifica in termini di "inviolabilità", ma credo possa essere molto alto. Ovvio che se un "pirata" si intromette nel meccanismo e si impossessa del file della chiave, salta tutto e i contenuti in chiaro finiscono per essere facilmente esposti.

Che ne dici?


ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.
PM Quote
Avatar
Carlo (Member)
Guru


Messaggi: 1388
Iscritto: 29/01/2018

Segnala al moderatore
Postato alle 22:53
Venerdì, 17/05/2024
Testo quotato

Postato originariamente da Thejuster:
Ma se provo ad aggiungere all'econdedChar ulteriori parametri del tipo

(c ^ hash) * 2 esempio, non riesco più a risalire alla stringa originale. Nonostante sia che l'encode / decode siano uguali.



Ritengo che moltiplicando per 2 in alcuni casi il valore ecceda 255, in questo caso in C non hai errori ma viene memorizzato il valore x-256.
Quando fai l'inverso il valore restituito non sarà lo stesso dell'originale.
Non ho fatto prove vado a naso.

Ultima modifica effettuata da Carlo il 17/05/2024 alle 23:28


in programmazione tutto è permesso
PM Quote
Avatar
Nippolo (Normal User)
Newbie


Messaggi: 4
Iscritto: 28/05/2022

Segnala al moderatore
Postato alle 12:23
Sabato, 18/05/2024
Ciao, premetto che non so nulla di questi argomenti e che le seguenti osservazioni si basano sul ragionamento e sulle mie basi di C/C++:

- ha senso utilizzare per la chiave una variabile a 16 bit dal momento che i singoli char di cui è costituita la stringa ne hanno solo 8?

Testo quotato

Postato originariamente da Thejuster:
Ma se provo ad aggiungere all'econdedChar ulteriori parametri del tipo

(c ^ hash) * 2 esempio, non riesco più a risalire alla stringa originale. Nonostante sia che l'encode / decode siano uguali.


Moltiplicare per 2 equivale ad uno scorrimento a sinistra di un posto, il che si traduce nel perdere ogni informazione sul primo bit (a sinistra) del carattere da criptare.


La pecora è vissuta per tutta la vita con la paura del lupo, ma alla fine se l'è mangiata il pastore!

Forse sarebbe meglio se l'Occidente la smettesse di essere così "generoso"... a furia di esportare democrazia, ne rimane sempre meno per noi!
PM Quote
Avatar
Carlo (Member)
Guru


Messaggi: 1388
Iscritto: 29/01/2018

Segnala al moderatore
Postato alle 12:25
Sabato, 18/05/2024
Ciao Nippolo ben risentito. Grazie per il contributo.

AldoBaldo è sceso nei meandri scherzosi della paranoia funzionale... :D:D:D

Thejuster invece si è tenuto nel criptaggio decodificabile dai software che contano statisticamente la ripetizione dei caratteri.
Con l'xor statico, per uno stesso carattere in chiaro hai sempre lo stesso carattere criptato.
In un testo lungo il conteggio delle ripetizioni porta statisticamente a trovare l'dentità dei caratteri, con il ricavo facile dello spiazzamento (fisso).
In un testo corto, la prova di tutti i possibili spiazzamenti (256) porta alla decodifica facile del testo originale.
Nel caso che il testo criptato non contenga parole con senso compiuto, il metodo è valido.

Di seguito il codice di Thejuster modificato per la codifica tramite chiave che non da lo stesso carattere criptato per lo stesso carattere in ingresso, tale metodo inficia il conteggio statistico dei caratteri:
Codice sorgente - presumibilmente C++

  1. #include <iostream>
  2. #include <sstream>
  3.  
  4. // chiave allungabile/accorciabile, attenzione a valori troppo alti, testare
  5. unsigned char key[] = {21, 33, 45, 28, 95, 76, 23, 76, 43, 58, 87, 62, 34, 12};
  6.  
  7. using namespace std;
  8.  
  9. string EncodeString(const string& s)
  10. {
  11.     ostringstream encodedString;
  12.  
  13.     for (size_t i = 0; i < s.length(); ++i)
  14.     {
  15.         char c = s[i];
  16.         char encodedChar = c + key[i % sizeof(key)];
  17.         encodedString << encodedChar;
  18.     }
  19.     return encodedString.str();
  20. }
  21.  
  22. string DecodeString(const string& s)
  23. {
  24.     ostringstream decodedString;
  25.  
  26.     for (size_t i = 0; i < s.length(); ++i)
  27.     {
  28.         char c = s[i];
  29.         char decodedChar = c - key[i % sizeof(key)];
  30.         decodedString << decodedChar;
  31.     }
  32.     return decodedString.str();
  33. }
  34.  
  35. int main()
  36. {
  37.     // attenzione a caratteri con codice ascii troppo alto, testare
  38.     string original = "nel mezzo del cammin di nostra vita mi ritrovai in una selva oscura, poiche' la retta via era smarrita";
  39.     string encoded = EncodeString(original);
  40.     string decoded = DecodeString(encoded);
  41.  
  42.     cout << original << endl << endl;
  43.     cout << encoded << endl << endl;
  44.     cout << decoded << endl;
  45.  
  46.     return 0;
  47. }



Quanta sicurezza abbiamo?
La sicurezza è molto elevata per l'invio di un messaggio criptato intercettabile da un malintenzionato.
Come nessuno ci ha ripetutamente insegnato, è inutile adottare un criptaggio se nel pc è installato un software che internamente decodifica, il malintenzionato capace andrà a leggere i registri della CPU mentre avviene la decodifica, ricavando in un attimo la chiave.
In questo caso l'approcio di AldoBaldo potrebbe mettere in difficoltà il malintenzionato se la chiave è lunga megabyte ed usata in modo arzigogolato. :rotfl:

Ultima modifica effettuata da Carlo il 18/05/2024 alle 13:05


in programmazione tutto è permesso
PM Quote
Avatar
Thejuster (Admin)
Guru^2


Messaggi: 2331
Iscritto: 04/05/2008

Segnala al moderatore
Postato alle 14:28
Sabato, 18/05/2024
non sono molto ferrato su questi argomenti.
(Cerco oltre di imparare anche un pò di inventare :D)

Pensavo di ottenere una lista di hash che vengono applicati consecutivamente.
e un'altra lista che mi ricordi l'ordine.

esempio

Codice sorgente - presumibilmente C#

  1. vector<int16_t> generateHashList(int16_t initialHash, size_t length, int16_t increment) {
  2.     std::vector<int16_t> hashList;
  3.     int16_t currentHash = initialHash;
  4.     for (size_t i = 0; i < length; ++i) {
  5.         hashList.push_back(currentHash);
  6.         currentHash += increment;  // Incrementa l'hash corrente
  7.     }
  8.     return hashList;
  9. }
  10.  
  11.  
  12. void printHex(const std::vector<int16_t>& vec) {
  13.     for (int16_t val : vec) {
  14.         cout << "0x" << hex << setw(4) << setfill('0') << val << " ";
  15.     }
  16.     cout << std::dec << endl;
  17. }
  18.  
  19.  
  20.  
  21. string EncodeString(const std::string& s, const vector<int16_t>& hashList) {
  22.     ostringstream encodedString;
  23.  
  24.     for (size_t i = 0; i < s.length(); ++i) {
  25.         char c = s[i];
  26.         int16_t hash = hashList[i];
  27.         char encodedChar = c ^ hash;  // XOR con il valore hash
  28.         encodedString << encodedChar;
  29.     }
  30.  
  31.     return encodedString.str();
  32. }
  33.  
  34.  
  35. //esempio
  36.  
  37. int16_t initialHash = 0x33FA;  // Hash iniziale
  38. size_t length = 10;            // Lunghezza della lista di hash
  39. int16_t increment = 0x0105;    // Incremento da applicare ad ogni ciclo
  40.  
  41.  // lista di hash generata
  42. vector<int16_t> hashList = generateHashList(initialHash, length, increment);
  43.  
  44. string data = "PieroTofy!";
  45.  
  46. string encodedString = EncodeString(data, hashList);
  47. cout << "Encoded String: " << encodedString << std::endl;



Quello che volevo ottenere è una lista di hash generati a runtime, ovviamente impossibile da saperli.
perché nell'esempio l'ho settato manualmente.

int16_t increment = 0x0105;

Ma intendevo fare un generatore in quella posizione.
una lista che tiene conto quali hash sono stati utilizzati, usata a ritroso per riconvertire il valore.
non è un file che và salvato, ma semplicemente una stringa contenente dei valori che deve essere scambiata online.
ovviamente dati sensibili che devono essere nascosti.

nel mio esempio avrò tipo

Testo quotato



Generated Hash List: 0x33fa 0x34fb 0x35fc 0x36fd 0x37fe 0x38ff 0x3a00 0x3b01 0x3c02 0x3d03




ma speravo nell'implementare un generatore random su increment.
Anche il metodo di carlo sembra efficiente.


@Nippolo
Si infatti era questo il problema.
I char diventano illeggibili e quindi si perde il valore del char.
Cercavo un esempio o un qualche sistema per poter ulteriormente modulare una hash per codificare del testo.

Presumo che si, da debugger possa riuscire a risalire che calcolo esegue. Ma senza conoscere il corrispondente hash usato penso sia impossibile risalire al valore esatto.

Ultima modifica effettuata da Thejuster il 18/05/2024 alle 18:40


https://mire.forumfree.it/ - Mire Engine
C# UI Designer
PM Quote
Avatar
Anonymous (Member)
Guru


Messaggi: 1060
Iscritto: 30/07/2006

Segnala al moderatore
Postato alle 18:55
Domenica, 19/05/2024
Testo quotato

Postato originariamente da Thejuster:

Salve ragazzi qualcuno ha già realizzato un cifrario in passato?




ciao, anni e anni fa feci alcune implementazioni di vecchi cifrari esistiti nella storia... in particolare, in c++ avevo fatto il cifrario di playfair... sicuramente non serve al tuo scopo, perché è un cifrario superato, ma per mera curiosità eccolo qui:

http://www.pierotofy.it/pages/sorgenti/dettagli/18013-Cifr ...

qui il sorgente:

http://www.pierotofy.it/pages/sorgenti/browse/18013/3688/

PM Quote
Avatar
AldoBaldo (Member)
Guru


Messaggi: 708
Iscritto: 08/01/2015

Segnala al moderatore
Postato alle 22:03
Domenica, 19/05/2024
Allora... visto che mi si dà del paranoico (non senza qualche ragione), pongo una questione "seria": tramite il mezzo informatico, presumere l'inviolabilità è un assurdo. In una situazione "media" si può ipotizzare di procurare agli spioni qualche addebito sulla bolletta dell'ENEL, necessario per tenere acceso il sistema addetto alla decrittazione per quel po' di tempo in più che serve per trovare la quadra. Se si è particolarmente attenti si può costringere lo spione a metodi di intrusione più complessi, tali da procurare qualche mal di testa, ma difficilmente si potrà andare oltre. Se lo spione è lo Stato, basta un mandato e una pattuglia per ingabbiare il criptatore e forzarne la loquacità con metodi leciti e/o illeciti. A volte non serve neppure un mandato.

Scusate il pessimismo.
Resta comunque il divertimento del baloccarsi con questo genere di passatempo (io stesso lo faccio di quando in quando).

P.S. per Carlo: ho capito benissimo (e apprezzato) l'intento scherzoso della tua citazione.

Ultima modifica effettuata da AldoBaldo il 19/05/2024 alle 22:05


ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.
PM Quote
Pagine: [ 1 2 ] Precedente | Prossimo