[C#] Crittografia e scambio di chiavi

[X_Gold*]

salve,dovrei comunicare da un client attraverso la rete con un server (un webservice senza possibilità di ssl).
Ora il mio problema è decisamente la sicurezza, vorrei comunicare con la crittografia a chiave simmetrica, e fin qui tutto bene, ovviamente ho il problema dello scambio della chiave iniziale, quindi ho pensato una cosa del genere :

il client richiede una chiave pubblica al server, ad esempio con un metodo sul webservice.
a questo punto ad esempio sul server faccio :

...
static SortedList<string,TestCrittografia> sessioni {get;set;}
...
public string[] RichiestaKeyServer()
{
      //creo le nuove info per questa sessione
      TestCrittografia t = 
           new TestCrittografia(DateTime.Now.Millisecond.GetHashCode().ToString());
      sessioni.Add(t.publicToken,t);//memorizzo le info della sessione
      return new string[]{t.ID, t.PublicKeyServer,  t.PublicIV };//invio al client l'ID e la key pubblica del server
}


public class TestCrittografia
        {
            public string ID { get; private set; }
            public string publicToken { get; private set; }
            public string PublicKeyServer { get; private set; }
            public string PublicIV { get; private set; }
            private string sharedKey { get; set; }

            public TestCrittografia(string publicKeyClient)
            {
                this.ID = publicKeyClient;
                RijndaelManaged rij = new RijndaelManaged();
                rij.BlockSize = 128;
                rij.KeySize = 128;
                rij.GenerateKey();
                rij.GenerateIV();
                this.PublicKeyServer = Convert.ToBase64String(rij.Key);
                this.PublicIV = "1234567891234567";
                this.publicToken = this.ID + this.PublicKeyServer + this.PublicIV;

                Encoder enc = System.Text.Encoding.ASCII.GetEncoder();
                byte[] data = new byte[publicToken.Length];
                enc.GetBytes(publicToken.ToCharArray(), 0, publicToken.Length, data, 0, true);
                MD5 md5 = new MD5CryptoServiceProvider();
                byte[] result = md5.ComputeHash(data);
                this.publicToken = BitConverter.ToString(result).Replace("-", "").ToLower();
            }
        }

ora quando il client riceve l'ID con Key e IV pubbliche le unisce per creare un hash da inviare successivamente al server insieme alla key scelta per la sessione crittografata con la key ricevuta dal server (della sessione sul server, quindi unica per sessione).

una cosa del genere :

string keyClient = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
// il client codifica la sua key privata con la key pubblica ricevuta dal server
            string keyClientCript = Encode(keyClient, t.PublicKeyServer, t.PublicIV);
// crea un token md5 in maniera identica a come viene creata sul server            
string tokenClient = t.ID + t.PublicKeyServer + t.PublicIV;

            Encoder enc = System.Text.Encoding.ASCII.GetEncoder();
            byte[] data = new byte[tokenClient.Length];
            enc.GetBytes(tokenClient.ToCharArray(), 0, tokenClient.Length, data, 0, true);
            MD5 md5 = new MD5CryptoServiceProvider();
            byte[] resultTest = md5.ComputeHash(data);
            tokenClient = BitConverter.ToString(resultTest).Replace("-", "").ToLower();
//poi invia al server solo il token md5 + la key crittografata con key del server.

il server riceve i dati e confronta i token delle sessioni che contiene per decriptare la key da utilizzare con il client :

public void riceviChiave(string token, string key)
        {
            TestCrittografia sessioneClient = sessioni[token];
            string keyDecriptata = Decode(key, sessioneClient.PublicKeyServer, sessioneClient.PublicIV);
        }

in questo modo il client viene riconosciuto dalla giunzione di ID+key+iv ma senza che essi siano trasmessi in chiaro da lui (solo il loro hash corrispondente) quindi in teoria non è riconducibile ad un client specifico (salvo dal suo ip che pero' forse ho già un modo per evitare ciò...) e quindi, agli occhi di uno sniffer non è riconoscibile quale key (del server) usa per crittografare la sua inviata al server.

ora il problema è a monte, ovvero : se uno sniffer capta la prima richiesta del client e la risposta del server che invia (la prima volta) l'ID e la key, questo può tranquillamente ricreare l'hash md5 del client e in questo modo riconoscerlo (e quindi conoscere anche la key del server con il quale viene criptata la key inviata dal client) e di conseguenza decriptare la nuova chiave.

la domanda è :

partendo dal presupposto che di crittografia ne so veramente poco, come posso fare a scambiare le chiavi simmetriche in maniera "sicura"?

[albgen]

Sostanzialmente, non puoi avere un sistema sicuro senza utilizzare un entità di certificazione al di sopra delle parti(quelli che ti vendono il certificato).
C'è però una buona notizia, ovvero puoi benissimo farlo tu il compito di questa entità.
Come sicuramente avrai intuito il sistema diventa complesso. Ogni client poi deve avere una chiave privata e una pubblica.
Mettere in piedi il sistema ci vuole pazienza e devi conoscere bene le basi della crittografia asimmetrica, come si fa lo scambio delle chiavi(diffie-hellman key exchange) e dove entra in gioco l'entità di certificazione.

http://it.wikipedia.org/wiki/Crittografia_asimmetrica
http://en.wikipedia.org/wiki/Diffie%...n_key_exchange
http://en.wikipedia.org/wiki/RSA
http://it.wikipedia.org/wiki/Man_in_the_middle

[X_Gold*]

Grazie albgen, adesso mi leggo un po di link e vedo di approfondire.

[X_Gold*]

non so se dovrei riaprire un altro 3d, ma vorrei un consiglio per cercare di capire come sia meglio archiviare una chiave.

ad esempio :

se io uso una costante sarebbe facile avendo l'assembly a disposizione leggerla. e su questo ok, se invece non scrivo la key direttamente ma la faccio costruire a partire da ad esempio da delle costanti di int e successivamente elaborate in memoria, con un metodo che restitusce dei byte che creeranno la key in base ad un algoritmo fisso, un hacker dovrebbe leggere direttamente la memoria in esecuzione per poter risalire alla key, dico bene? oppure riesce a risalire anche con solo l'assembly senza farlo "girare"?

oltre ad eventuali consigli (tra quelli classici) per archiviare la key, vorrei avere anche una risposta alle domande sopra.

grazie ciao.