Criptografia de dados do servidor do servidor e design de protocolo

Question

Estou escrevendo um aplicativo cliente-servidor para ser usado em um laboratório de informática e atuar como um serviço (sem executar como serviço). Eu tenho um aplicativo de console chamando a função nativa de "showwindow"/sw_hide usando o objeto HWND do console - isso dá o que estou querendo aqui. O servidor/cliente está funcionando, enviei a mensagem "Hello World!" Do cliente ao servidor muitas vezes e estou satisfeito. (Estou usando o UDP para o protocolo de soquete porque o departamento de TI deseja uma abordagem sem conexão.)

Minha pergunta está em um 'protocolo' para comunicação entre o cliente-servidor.

Os objetivos por trás do servidor incluem o seguinte:

• Dê acesso, programaticamente, a certas habilidades que nosso departamento de TI bloqueou para segurança (por exemplo, "net.exe")
• Dê acesso ao meu programa para monitorar o que os alunos estão visualizando no laboratório de informática.

Algumas coisas que quero incluir são perguntas simples que estão sendo enviadas de um lado para o outro:

• Um comando de "requser" retornaria o nome de usuário e o nome completo (conforme permitido pelo "usuário da rede" anteriormente)
• Um comando de "reqprocs" retornaria uma lista de processos atualmente sendo executados sob o nome de usuário do usuário atual.

Não tenho dúvida de que sou capaz de fazer isso. O que eu sou lendo no momento é a segurança dos dados. Temos alguns "hackers" aqui na minha faculdade, que podem saber como embalá -lo e poder reenviar os pacotes a servidores específicos para fazer coisas maliciosas ou obter informações sobre um inimigo ou outros enfeites.

Meu pensamento era fornecer um esquema de criptografia em todos os dados enviados e decodificá -los no recebimento.

Um amigo com quem eu conversei disse que deveria usar um pouco de empacotador e comecei a portar sua classe Bitpacker de C ++ para C#, com o qual me confundi e vim aqui para ver o que o Stackoverflow pensava.

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

    }
}

PS Espero que a pergunta seja clara? Percebi que a maioria das minhas perguntas que escrevo não é clara. :/

Answer 1

Classe SSLStream do System.net.security pode fazer o que você precisa

(SSLStream) fornece um fluxo usado para a comunicação cliente-servidor que usa o protocolo de segurança da camada de soquete segura (SSL) para autenticar o servidor e, opcionalmente, o cliente.

...

Os protocolos SSL ajudam a fornecer confidencialidade e verificação de integridade para mensagens transmitidas usando um SSLStream. Uma conexão SSL, como a fornecida pelo SSLStream, deve ser usada ao comunicar informações confidenciais entre um cliente e um servidor. O uso de um SSLStream ajuda a impedir que alguém leia e adultere informações enquanto está em trânsito na rede

Mais detalhes e exemplos aqui: Classe SSLStream