} // end xorMultiCrypto_andata // una specifica implementazione di una funzione di questa categoria internal static CryptoEngine.theReturnType xorMultiCrypto_ritorno( CryptoEngine.theReturnType input) { try { // solo ritorno: viene richiesta una decription, quindi uso il valore indicato int sequenceLength = input.cryptedSequence.Length; System.Text.StringBuilder sequence_temp = new System.Text.StringBuilder(sequenceLength); for (int c = 0, acc = 0; c < sequenceLength; c++, acc += 3) { // BEGIN solo ritorno string scalar_key_str = ""; scalar_key_str += ((string)input.kkey)[acc]; scalar_key_str += ((string)input.kkey)[acc + 1]; scalar_key_str += ((string)input.kkey)[acc + 2]; int scalar_key = int.Parse(scalar_key_str); // END solo ritorno sequence_temp.Append((char)(input.cryptedSequence[c] ^ scalar_key)); } input.cryptedSequence = sequence_temp.ToString(); // pwd // NB la kkey e' di sola lettura nel ritorno: non va sovrascritta } catch (System.Exception ex) { string s = ex.Message; // dbg input.cryptedSequence = "The sequence is not crypted with this algorithm. Unable to decrypt."; // NB la kkey e' di sola lettura nel ritorno: non va sovrascritta } // no finally // ready return(input); } // end xorMultiCrypto_ritorno
} // functor class // La segnatura dell'attuale delegate va bene anche per questo algo: // struct della coppia( pwd, kkey) sia in ingresso che in uscita. // Ciascun passo del loop avra' la chiave dinamica aggiornata. // Nel giro di andata verra' randomizzata dal MonteCarlo ciascuna figura // della stringa-chiave. Nel giro di ritorno la stringa-chiave verra' letta // da db e ad ogni passo verra' scandita la figura successiva e, conseguentemente // invocato il core. // La stringa-chiave va in un campo object della struct-coppia( pwd, kkey). // Su db va messo in un varchar o text, che deve essere NOT NULL e DEFAULT '0'. /// <summary> /// operazione bitwise: /// ---------------------------------------------------------- /// dove sono UGUALI i bit, il risultato ha il bit ZERO /// dove sono DIVERSI i bit, il risultato ha il bit UNO /// schema: /// UGUALI -> ZERO /// DIVERSI -> UNO /// /// La sequenza di bit zero e' l'elemento neutro dell'operatore xor: /// i bit zero dell'altro operando vanno in zero perche' uguali /// i bit uno dell'altro operando vanno in uno perche' diversi /// /// La sequenza di bit uno e' l'operando che scambia i valori di ciascun bit: /// i bit zero dell'altro operando vanno in uno perche' diversi /// i bit uno dell'altro operando vanno in zero perche' uguali /// /// /// xor /// ----- /// L'uso di un operando "alpha" su un operando "x" produce un risultato /// "y". L'applicazione dell'operatore xor agli operandi "alpha" e "y" /// porta in "x". Questa ciclicita' dell'operatore e' utilizzata nel /// presente algoritmo. /// /// /// and /// ----- /// Considero ora l'operatore "and". L'uso di un operando "alpha" /// su un operando "x" produce un risultato "y". Tale risultato e' /// la "saturazione" verso il basso di "x" mediante "alpha". Quindi /// "y" minore o uguale a "x" e le successive applicazioni di /// "alpha" ad "y" mediante "and" portano ancora a "y". /// /// or /// ------ /// Considero ora l'operatore "or". L'uso di un operando "alpha" /// su un operando "x" produce un risultato "y". Tale risultato e' /// la "saturazione" verso l'alto di "x" mediante "alpha". Quindi /// "y" maggiore o uguale a "x" e le successive applicazioni di /// "alpha" ad "y" mediante "or" portano ancora a "y". /// /// /// 1110001 AND /// 0010100 /// --------------------- /// bin 0010000 /// dec 16 /// /// 0010100 AND /// 0010000 /// ---------------- /// 0010000 == 16 dec quindi il risultato e' saturo in AND /// /// /// 1110001 OR /// 0010100 /// --------------------- /// bin 1110101 /// dec 117 /// /// 1110101 OR /// 0010100 /// --------------------- /// 1110101 == 117 dec quindi il risultato e' saturo in OR /// /// /// 113 XOR /// 020 /// ------- /// 101 /// /// 1110001 XOR uguali a 0, diversi a 1 /// 0010100 /// --------------------- /// bin 1100101 /// dec 101 /// /// /// /// /// /// /// </summary> // una specifica implementazione di una funzione di questa categoria internal static CryptoEngine.theReturnType xorMultiCrypto_andata( CryptoEngine.theReturnType input) { int sequenceLength = input.cryptedSequence.Length; MonteCarlo mc = new MonteCarlo();// seme dipendente dall'orario System.Text.StringBuilder kkey_accumulator = new System.Text.StringBuilder(sequenceLength); System.Text.StringBuilder sequence_temp = new System.Text.StringBuilder(sequenceLength); for (int c = 0; c < sequenceLength; c++) { // BEGIN solo andata int scalar_key = mc.next_integer(32, 125); string scalar_key_str = ""; if (100 > scalar_key) { scalar_key_str += "0"; } // else e' gia' di tre cifre scalar_key_str += scalar_key.ToString(); kkey_accumulator.Append(scalar_key_str); // END solo andata sequence_temp.Append((char)(input.cryptedSequence[c] ^ scalar_key)); } input.cryptedSequence = sequence_temp.ToString(); // pwd input.kkey = kkey_accumulator.ToString(); // kkey multi // ready return(input); } // end xorMultiCrypto_andata
public char mode;//{'s', 'm', 'o'} public bool Insert() { bool result = false; char mode; CryptoEngine.theReturnType combinazioneCriptata = Common.CryptoStore.Callers.Criptazione.CriptazioneSequenza( this.password, out mode ); // -insert service: gets{ web_username, web_pwd, kkey}, returns a status int. int insertionStatus = usp_utente_INSERT_SERVICE.usp_utente_INSERT( this.username, combinazioneCriptata.cryptedSequence, (string)(combinazioneCriptata.kkey), new string(mode, 1) ); // -return a status bool, based on the service status int. if (0 == insertionStatus) { result = true; } else { result = false; } // ready return(result); }
} // end commonCore // una specifica implementazione di una funzione di questa categoria internal static CryptoEngine.theReturnType xorCrypto_andata( CryptoEngine.theReturnType input) { // solo in andata: preparo la chiave di criptazione MonteCarlo mc = new MonteCarlo(); // seme dipendente dall'orario input.kkey = mc.next_integer(32, 125).ToString(); // il commonCore lo vuole stringa per compatibilita' col db (quindi col ritorno) // end solo in andata return(commonCore(input)); } // end xorCryptoService
public static string DecriptazioneSequenza( string sequenza, // crypted string kkey_str, char mode ) { // ramoRitorno della criptazione CryptoEngine cs = new CryptoEngine(); CryptoEngine.GenericAlgoPointer specificaFunzione = null; // puntatore al servizio di criptazione /* * La BPL chiamante fornisce {sequenza, kkey, mode}. * Il par 'mode' prende valori in {'s', 'm', 'o'}, che significano rispettivamente {simple, multi, off}. * Il default e' 'multi'. * Qualora fosse mal configurato il campo 'mode', l'adozione del default 'multi' provochera' un'eccezione * in Common.CryptoStore.Micro.Multi. */ switch (mode) { case 's': { specificaFunzione = new CryptoEngine.GenericAlgoPointer( CryptoStore.Micro.SimpleXor.xorCrypto_ritorno ); break; } default: case 'm': { specificaFunzione = new CryptoEngine.GenericAlgoPointer( CryptoStore.Micro.MultiXor.xorMultiCrypto_ritorno ); break; } case 'o': { specificaFunzione = null; break; } } // la chiave l'ho letta sul db (kkey_str) CryptoEngine.theReturnType loginResult = cs.Decriptazione( sequenza, kkey_str, specificaFunzione ); // ready return(loginResult.cryptedSequence); } // end
/// <summary> /// operazione bitwise: /// dove sono UGUALI i bit, il risultato ha il bit ZERO /// dove sono DIVERSI i bit, il risultato ha il bit UNO /// schema: /// UGUALI -> ZERO /// DIVERSI -> UNO /// /// La sequenza di bit zero e' l'elemento neutro dell'operatore xor: /// i bit zero dell'altro operando vanno in zero perche' uguali /// i bit uno dell'altro operando vanno in uno perche' diversi /// /// La sequenza di bit uno e' l'operando che scambia i valori di ciascun bit: /// i bit zero dell'altro operando vanno in uno perche' diversi /// i bit uno dell'altro operando vanno in zero perche' uguali /// /// Il core deve essere chiamato da un ciclo, che sara' posto sia nel /// giro di andata, che in quello di ritorno. /// /// /// xor /// ----- /// L'uso di un operando "alpha" su un operando "x" produce un risultato /// "y". L'applicazione dell'operatore xor agli operandi "alpha" e "y" /// porta in "x". Questa ciclicita' dell'operatore e' utilizzata nel /// presente algoritmo. /// /// /// and /// ----- /// Considero ora l'operatore "and". L'uso di un operando "alpha" /// su un operando "x" produce un risultato "y". Tale risultato e' /// la "saturazione" verso il basso di "x" mediante "alpha". Quindi /// "y" minore o uguale a "x" e le successive applicazioni di /// "alpha" ad "y" mediante "and" portano ancora a "y". /// /// or /// ------ /// Considero ora l'operatore "or". L'uso di un operando "alpha" /// su un operando "x" produce un risultato "y". Tale risultato e' /// la "saturazione" verso l'alto di "x" mediante "alpha". Quindi /// "y" maggiore o uguale a "x" e le successive applicazioni di /// "alpha" ad "y" mediante "or" portano ancora a "y". /// /// /// </summary> /// <param name="input">la coppia "pwd" e "kkey" </param> /// <returns>la coppia di ingresso, con la "pwd" rivisitata</returns> internal static CryptoEngine.theReturnType commonCore( CryptoEngine.theReturnType input) { CryptoEngine.theReturnType result = input; int sequenceLength = input.cryptedSequence.Length; System.Text.StringBuilder temp = new System.Text.StringBuilder(sequenceLength); string input_kkey_str = (string)input.kkey; int input_kkey_int = int.Parse(input_kkey_str); for (int c = 0; c < sequenceLength; c++) { temp.Append((char)(input.cryptedSequence[c] ^ input_kkey_int)); } result.cryptedSequence = temp.ToString(); // scopo del commonCore // ready return(result); } // end commonCore
} // end xorCryptoService // una specifica implementazione di una funzione di questa categoria internal static CryptoEngine.theReturnType xorCrypto_ritorno( CryptoEngine.theReturnType input) { // solo ritorno: viene richiesta una decription, quindi uso il valore indicato return(commonCore(input)); } // end xorCryptoService