Client-Server Data Encryption Protocol e design

Question

Sto scrivendo un'applicazione client-server per essere utilizzato in un laboratorio informatico e di agire come un servizio (senza correre come un servizio). Ho un'applicazione console chiamando la funzione nativa "ShowWindow" / SW_HIDE utilizzando oggetto HWND della console - questo dà quello che sto volendo qui. Il server / client sta lavorando, ho inviato il messaggio "Ciao mondo!" dal client al server molte volte e mi fa piacere. (Sto usando UDP per il protocollo presa perché il reparto IT vuole un approccio senza connessione.)

La mia domanda si trova in un 'protocollo' per la comunicazione tra client-server.

Gli obiettivi alla base del server sono i seguenti:

• Dare accesso, a livello di codice, a determinate abilità che il nostro dipartimento IT ha bloccato per la sicurezza (ad esempio "net.exe")
• Dare accesso al mio programma per monitorare ciò che gli studenti stanno guardando nel laboratorio di informatica.

Alcune cose che voglio comprendere sono domande semplici di essere inviati avanti e indietro:

• Un comando di "REQUSER" sarebbe tornato il nome utente e fullname (come consentito dalla "net user" in precedenza)
• Un comando di "REQPROCS" restituirebbe una lista dei processi attualmente in corso correva sotto il nome utente dell'utente corrente.

Non ho dubbi sono in grado di fare questo. La cosa di cui sono scettico di in questo momento è la sicurezza dei dati. Abbiamo alcuni "hacker" qui al mio college che possono sanno packet sniff ed essere in grado di inviare nuovamente i pacchetti ai server specifici per entrambi fare le cose malintenzionati o ottenere informazioni su un nemico o quant'altro.

Il mio pensiero era quello di fornire uno schema di crittografia su tutti i dati inviati e decodificarlo in ricezione.

Un amico che ho parlato mi ha detto di usare un po 'imballatore e ho iniziato il porting sua classe BitPacker da C ++ a C #, che mi sono confuso con ed è venuto qui per vedere cosa pensava StackOverflow.

namespace Atlantis.Net.Sockets
{
    using System;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Linq;
    using System.Net;
    using System.Net.Sockets;
    using System.Text;
    using System.Windows.Forms;

    public class UdpServer : System.Net.Sockets.UdpClient
    {

        #region Constructor(s)

        public UdpServer(Int32 port)
            : base(port)
        {
        }

        public UdpServer(IPEndPoint endPoint)
            : base(endPoint)
        {
        }

        #endregion

        #region Properties

        private Int32 m_Backlog = 32;
        /// <summary>
        ///     Sets how many active connections the socket can support
        /// </summary>
        public Int32 Backlog
        {
            private get
            {
                return m_Backlog;
            }
            set
            {
                m_Backlog = value;
            }
        }

        private Boolean m_IsInitialized = false;
        /// <summary>
        ///     Gets a value indicating whether the server has been initialized
        /// </summary>
        public Boolean IsInitialized
        {
            get
            {
                return m_IsInitialized;
            }
            private set
            {
                m_IsInitialized = value;
            }
        }

        private Int32 m_Port = 1337;
        /// <summary>
        ///     Sets the port number for listening for incoming connections
        /// </summary>
        public Int32 Port
        {
            private get
            {
                return m_Port;
            }
            set
            {
                m_Port = value;
            }
        }

        private Encoding m_Encoding = Encoding.ASCII;
        /// <summary>
        ///     Gets or sets the text encoding for data being transferred to/from the server
        /// </summary>
        public Encoding Encoding
        {
            get
            {
                return m_Encoding;
            }
            set
            {
                m_Encoding = value;
            }
        }

        #endregion

        #region Events

        public event EventHandler<UdpReceiveEventArgs> DataReceive;

        #endregion

        #region Methods

        protected virtual void OnDataRecieve(String data, object state)
        {
            if (DataReceive != null)
            {
                DataReceive(this, new UdpReceiveEventArgs(data, ((UdpState)state)));
            }
        }

        private void DataReceiveCallback(IAsyncResult ar)
        {
            UdpClient u = (UdpClient)((UdpState)ar.AsyncState).host;
            IPEndPoint e = (IPEndPoint)((UdpState)ar.AsyncState).endPoint;

            Byte[] data = u.EndReceive(ar, ref e);

            OnDataRecieve(Encoding.GetString(data), ((UdpState)ar.AsyncState));

            UdpState state = new UdpState();
            state.endPoint = new IPEndPoint(IPAddress.Any, Port);
            state.host = u;
            u.BeginReceive(new AsyncCallback(DataReceiveCallback), ((UdpState)ar.AsyncState));
        }

        /// <summary>
        ///     .
        /// </summary>
        public void Initialize()
        {
            if (IsInitialized)
            {
                return;
            }
            //Debug.WriteLine(String.Format("Local address and port : {0}", Client.RemoteEndPoint.ToString()));

            UdpState state = new UdpState();
            state.endPoint = new IPEndPoint(IPAddress.Any, Port);
            state.host = this;
            BeginReceive(new AsyncCallback(DataReceiveCallback), state);

            IsInitialized = true;
        }

        #endregion

    }
}

P.S. Spero che la questione è chiara? Ho notato la maggior parte delle mie domande che scrivo non sono chiare. : /

Answer 1

SslStream classe da System.Net.Security potrebbe fare ciò che è necessario

  

(SslStream) fornisce un flusso utilizzato per   comunicazione client-server che utilizza   Secure Socket Layer (SSL)   protocollo per autenticare il server   e facoltativamente il client.

...

  

protocolli SSL contribuiscono a fornire   la riservatezza e il controllo dell'integrità   per i messaggi trasmessi mediante un   SslStream. Una connessione SSL, come ad esempio   quella fornita da SslStream, dovrebbe essere   utilizzare nella comunicazione sensibile   informazioni tra un client e un   server. L'utilizzo di uno SslStream aiuta a   impedire a chiunque di leggere e   manomissione informazioni mentre è   in transito sulla rete

maggiori dettagli ed esempi qui: SslStream Classe