Cifrado de datos cliente-servidor y el Protocolo de Diseño

Question

Estoy escribiendo una aplicación cliente-servidor para ser utilizado en un laboratorio de computación y actuar como un servicio (sin correr como un servicio). Tengo una aplicación de consola llamando a la función nativa "ShowWindow" / SW_HIDE usando el objeto HWND de la consola - esto le da lo que estoy queriendo aquí. El servidor / cliente está trabajando, he enviado el mensaje "Hola mundo!" desde el cliente al servidor muchas veces y estoy satisfecho. (Estoy usando UDP para el protocolo de toma debido a que el departamento de TI quiere un enfoque sin conexión.)

Mi pregunta se encuentra en un 'protocolo' para la comunicación entre cliente-servidor.

Los objetivos detrás del servidor son los siguientes:

• Dar acceso, mediante programación, a ciertas habilidades que nuestro departamento de TI ha bloqueado para la seguridad (por ejemplo, "net.exe")
• Dar acceso a mi programa para monitorear lo que los estudiantes están viendo en el laboratorio de computación.

Algunas cosas que quiero incluir son preguntas sencillas que se envían de ida y vuelta:

• Un comando de "REQUSER" devolvería el nombre de usuario y nombre completo (como lo permite la "net user" anteriormente)
• Un comando de "REQPROCS" se obtendrá una lista de los procesos que actualmente se corrió bajo el nombre de usuario del usuario actual.

No tengo duda de que soy capaz de hacer esto. Lo que soy escéptica de en este momento es la seguridad de los datos. Tenemos algunos "hackers" aquí en mi colegio que conozca cómo packet sniff y ser capaz de volver a enviar los paquetes a servidores específicos o bien a hacer cosas maliciosas o conseguir información sobre un enemigo o lo que sea.

Mi idea era proporcionar un esquema de cifrado de todos los datos enviados y decodificarlo en recibir.

Un amigo que hablé con dijo que debería utilizar un empacador poco y empecé a portar su clase BitPacker de C ++ a C #, que se confundió con I y vino aquí para ver lo que pensaba 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. Espero que la pregunta es clara? Me he dado cuenta de la mayoría de mis preguntas que escribo no son claros. : /

Answer 1

SslStream Clase de System.Net.Security podría hacer lo que tiene

  

(SslStream) proporciona una corriente utilizada para   la comunicación cliente-servidor que utiliza   la seguridad Secure Socket Layer (SSL)   protocolo para autenticar el servidor   y opcionalmente el cliente.

...

  

protocolos SSL ayudan a proporcionar   la confidencialidad y la comprobación de la integridad   para los mensajes transmitidos mediante una   SslStream. Una conexión SSL, tales como   la proporcionada por SslStream, debe ser   utilizado en la comunicación sensible   información entre un cliente y un   servidor. El uso de una ayuda a SslStream   evitar que alguien la lectura y   la manipulación de la información mientras que es   en tránsito en la red

más detalles y ejemplos aquí: SslStream Clase