using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Security.Cryptography;
using System.Threading;

namespace MS_CHAPv2_Emulator
{
    public partial class MainForm : Form
    {
        public MainForm()
        {
            InitializeComponent();
        }

        private void tbxLog_TextChanged(object sender, EventArgs e)
        {
            tbxLog.SelectionStart = tbxLog.Text.Length;
            tbxLog.ScrollToCaret();
        }

        private void btnLogin_Click(object sender, EventArgs e)
        {
            Thread thr = new Thread(sendHello);
            thr.Start();
        }

        void sendHello()
        {
            //
            Append("Sende \"HELLO\" an Server");
            StartChallenge();
        }

        void Append(string s)
        {
            this.Invoke((MethodInvoker)delegate
            {
                tbxLog.AppendText(s + Environment.NewLine);
            });
            Thread.Sleep(500);
        }

        int SessionID = 0;
        string ServerPeerChallengeString;
        string ClientPeerChallengeString;
        void StartChallenge()
        {
            /*1. Der Server fordert den Client zur Authentifizierung auf (Challenge).
                 Die Aufforderung besteht aus einer Sitzungs-ID (Session Identifier) und einem zufälligen Wert,
                 dem Peer Challenge String.*/

            //
            Append("Generiere Server-Peer-Challenge-String");
            ServerPeerChallengeString = new Random(DateTime.Now.Millisecond).Next(int.MinValue, int.MaxValue).ToString();
            //
            Append("Generiere Serverseitige SessionID");
            SessionID++;
            //
            Append("Sende Challenge an Client");
            BuildClientAuthentication(ServerPeerChallengeString, SessionID.ToString());
        }

        void BuildClientAuthentication(string ServerPeerChallengeString, string SessionID)
        {
            /*2. Der Client bildet aus dem Peer Challenge String,
                 der Sitzungs-ID und seinem Passwort einen Hashwert (z. B. mit SHA-1).
                 Dann schickt er Benutzername,
                 einen eigenen zufälligen Wert und den gebildeten Hashwert an den Server zurück.*/

            //
            Append("Sammle Informationen");
            string PCS = ServerPeerChallengeString;
            string CSessionID = SessionID;
            string Password = tbxPassC.Text;
            string UserName = tbxNameC.Text;

            //
            Append("Erstelle Client-Sitzungs-Hash");
            string StringToHash = PCS + CSessionID + Password;
            byte[] data = Encoding.Default.GetBytes(StringToHash);
            byte[] result;
            SHA1 sha = new SHA1CryptoServiceProvider();
            result = sha.ComputeHash(data);
            string HashedString = Encoding.Default.GetString(result);

            //
            Append("Generiere Client-Peer-Challenge-String");
            ClientPeerChallengeString = new Random(DateTime.Now.Millisecond).Next(int.MinValue, int.MaxValue).ToString();

            //
            Append("Erstelle Client-Authentifizierungs-String");
            string ClientAuthenticationString = UserName + "\0" + ClientPeerChallengeString + "\0" + HashedString;

            //
            Append("Sende Client-Authentifizierung");
            CheckClientAuthentication(ClientAuthenticationString);
        }

        void CheckClientAuthentication(string ClientAuthenticationString)
        {
            /*3. Der Server prüft die Antwort und sendet eine Annahmebestätigung oder die Ablehnung.
                 Die Annahme enthält die authentifizierte Antwort der gesendeten Challenge,
                 den Peer Challenge String, die verschlüsselte Antwort des Clients und das MD4-gehashte Passwort.*/

            //
            Append("Prüfe Client-Authentifizierung");
            string StringToHash = ServerPeerChallengeString + SessionID + tbxPassS.Text;
            byte[] data = Encoding.Default.GetBytes(StringToHash);
            byte[] result;
            SHA1 sha = new SHA1CryptoServiceProvider();
            result = sha.ComputeHash(data);
            string HashedString = Encoding.Default.GetString(result);

            //
            string[] authCredentials = ClientAuthenticationString.Split('\0');
            if (!(HashedString == authCredentials[2]))
            {
                Append("Authentifizierung fehlgeschlagen");
                return;
            }
            Append("Authentifizierung erfolgreich");


            //
            Append("Sammle Daten");
            string PCS = authCredentials[1];

            //
            Append("Erstelle Server Authentifizierung");
            BuildServerAuthentication(PCS, authCredentials[0]);
        }
        void BuildServerAuthentication(string PCS, string UserName)
        {
            if (UserName != tbxNameS.Text)
            {
                Append("Authentifizierung fehlgeschlagen - Username nicht vorhanden");
                return;
            }

            //
            string ok = "OK";

            //
            Append("Erstelle MD4-Hash des Passwortes");
            MD4Hash.MD4 md4 = new MD4Hash.MD4();
            string HashedPassword = Encoding.Default.GetString(md4.GetByteHashFromString(tbxPassS.Text));

            //
            Append("Erstelle Server-Sitzungs-Hash");
            string StringToHash = PCS + SessionID + tbxPassS.Text + UserName;
            byte[] data = Encoding.Default.GetBytes(StringToHash);
            byte[] result;
            SHA1 sha = new SHA1CryptoServiceProvider();
            result = sha.ComputeHash(data);
            string HashedString = Encoding.Default.GetString(result);

            //
            Append("Sende Server-Authentifizierung");
            string answer = ok + "\0" + ServerPeerChallengeString + "\0" + HashedString + "\0" + HashedPassword;
            CheckServerAuthentication(answer);
        }
        void CheckServerAuthentication(string answer)
        {
            /*4. Der Client prüft die Antwort. Ist die Antwort fehlerfrei wird die Verbindung genutzt.
                 Wenn nicht, dann bricht der Client die Verbindung ab.*/

            //
            Append("Prüfe Server-Authentifizierung");
            string[] authCredentials = answer.Split('\0');
            if (authCredentials[0] == "OK")
                if (authCredentials[1] == ServerPeerChallengeString)
                {
                    string StringToHash = ClientPeerChallengeString + SessionID + tbxPassC.Text + tbxNameC.Text;
                    byte[] data = Encoding.Default.GetBytes(StringToHash);
                    byte[] result;
                    SHA1 sha = new SHA1CryptoServiceProvider();
                    result = sha.ComputeHash(data);
                    string HashedString = Encoding.Default.GetString(result);
                    if (HashedString == authCredentials[2])
                    {
                        MD4Hash.MD4 md4 = new MD4Hash.MD4();
                        string HashedPassword = Encoding.Default.GetString(md4.GetByteHashFromString(tbxPassC.Text));
                        if (HashedPassword == authCredentials[3])
                        {
                            MessageBox.Show("Authentication Success");
                            return;
                        }
                    }
                }
            MessageBox.Show("Server-Authentication Failed");


        }


    }
}