Le chiffrement et la conception de protocole de données client-serveur

Question

J'écris une application client-serveur à utiliser dans un laboratoire informatique et d'agir en tant que service (sans courir en tant que service). J'ai une application console appelant la fonction native « ShowWindow » / SW_HIDE en utilisant l'objet HWND de la console - ce qui lui donne ce que je suis ici envie. Le serveur / client travaille, je l'ai envoyé le message « Bonjour tout le monde! » du client vers le serveur plusieurs fois et je suis heureux. (J'utilise UDP pour le protocole de prise parce que le service informatique veut une approche sans connexion.)

Ma question réside dans un 'protocole' pour la communication entre le client-serveur.

Les objectifs derrière le serveur sont les suivants:

• Donner accès, programme, à certaines capacités que notre département de TI a bloqué pour la sécurité (par exemple « net.exe »)
• Donner accès à mon programme pour surveiller ce que les élèves sont affichés dans le laboratoire informatique.

Certaines choses que je veux inclure des questions simples qui sont envoyées dans les deux sens:

• Une commande de "REQUSER" retournerait le nom d'utilisateur et fullname (comme autorisé par "net user" précédemment)
• Une commande de « REQPROCS » retournerait une liste des processus en cours ont paru sous le nom d'utilisateur de l'utilisateur actuel.

Je ne doute pas que je suis en mesure de le faire. La chose que je suis sceptique à l'idée d'en ce moment est la sécurité des données. Nous avons des « hackers » ici à mon collège qui savent peut par paquets sniff et être en mesure de renvoyer des paquets vers des serveurs spécifiques soit faire des choses malveillantes ou obtenir des informations sur un ennemi ou tout le reste.

Ma pensée était de fournir un système de cryptage de toutes les données envoyées et décoder sur réception.

Un ami qui je parlé m'a dit que je devrais utiliser un logiciel de compression peu et je commencé à porter sa classe BitPacker de C ++ C # que je me suis embrouillé avec et est venu ici pour voir ce que pensait 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. J'espère que la question est claire? Je l'ai remarqué la plupart de mes questions que j'écris ne sont pas claires. : /

Answer 1

SslStream classe de System.Net.Security pourrait faire ce que vous avez besoin

  

(SslStream) Fournit un flux utilisé pour   communication client-serveur qui utilise   la sécurité Secure Socket Layer (SSL)   protocole pour authentifier le serveur   et éventuellement le client.

...

  

protocoles SSL aident à fournir   la confidentialité et le contrôle d'intégrité   pour les messages transmis au moyen d'un   SslStream. Une connexion SSL, tels que   celle fournie par SslStream, devrait être   utilisés lors des communications sensibles   informations entre un client et un   serveur. L'utilisation d'un SslStream aide à   empêcher quiconque de lire et   la falsification des informations alors qu'il est   en transit sur le réseau

plus de détails et d'exemples ici: SslStream classe