我怎么能发送到服务器时加密我的信息？可以约1加在我的代码，因为我不熟悉的加密？/什么帮助？ [英] how can i encrypt my message when sending to the server? can some 1 add in the code for me, as i am unfamiliar with encryption?/ any help?

问题描述

我想发送给从客户端服务器时加密我的消息，我该怎么办呢？

客户端

 使用系统; 
使用System.Collections.Generic; 
使用System.ComponentModel; 
使用System.Data这; 
使用System.Drawing中; 
使用System.Linq的; 
使用System.Text;使用System.Windows.Forms的
;使用的System.Net.Sockets 
; 
使用的System.Threading; 
 
命名空间SocketClient 
 {
 
公共部分类SocketClient：表
 {
 System.Net.Sockets.TcpClient ClientSocket的=新系统。 Net.Sockets.TcpClient（）; 
的NetworkStream serverStream =默认（的NetworkStream）; 
字符串READDATA = NULL; 
 
 
公共SocketClient（）
 {
的InitializeComponent（）; 
} 
 
 
私人无效的getMessage（）
 {
，而（真）
 {
 serverStream = clientSocket.GetStream（ ）; 
 INT BUFFSIZE = 0; 
字节[] = inStream中新的字节[10025] 
 BUFFSIZE = clientSocket.ReceiveBufferSize; 
 serverStream.Read（插播广告，0，BUFFSIZE）; 
串returndata = System.Text.Encoding.ASCII.GetString（插播广告）; 
 READDATA =+ returndata; 
 MSG（）; 
} 
} 
 
 
私人无效MSG（）
 {
如果（this.InvokeRequired）
 this.Invoke（新MethodInvoker（MSG））; 
，否则
 textDisplay.Text = textDisplay.Text + Environment.NewLine +>>中+ READDATA; 
} 
 
 
私人无效buttonConnect_Click（对象发件人，EventArgs五）
 {
 READDATA =Conected到NYP聊天服务器...; 
 MSG（）; 
 //clientSocket.Connect(\"127.0.0.1，8888）; 
 clientSocket.Connect（textIP.Text，Convert.ToInt32（textPort.Text））; 
 serverStream = clientSocket.GetStream（）; 
 
字节[] = outStream System.Text.Encoding.ASCII.GetBytes（textName.Text +$）; 
 serverStream.Write（outStream，0，outStream.Length）; 
 serverStream.Flush（）; 
 
螺纹ctThread =新主题（的getMessage）; 
 ctThread.Start（）; 
} 
 
私人无效buttonSend_Click（对象发件人，EventArgs五）
 {
 //显示味精如果没有服务器连接
如果箱（serverStream = = NULL）
 {
 MessageBox.Show（请连接到服务器第一！）; 
的回报; 
} 
 
 //发送文本
字节[] = outStream System.Text.Encoding.ASCII.GetBytes（textSend.Text +$）; 
 serverStream.Write（outStream，0，outStream.Length）; 
 serverStream.Flush（）; 
 
 //明文
 textSend.Text =; 
 
} 
 
私人无效textDisplay_TextChanged（对象发件人，EventArgs五）
 {
 textDisplay.SelectionStart = textDisplay.Text.Length; 
 textDisplay.ScrollToCaret（）; 
 textDisplay.Refresh（）; 
} 
 
私人无效textSend_TextChanged（对象发件人，EventArgs五）
 {
 buttonSend.Enabled = string.IsNullOrEmpty（textSend.Text）！; 
} 
} 
  

}

服务器

 使用系统; 
使用的System.Threading;使用的System.Net.Sockets 
; 
使用System.Text; System.Collections中使用
; 
 
命名ConsoleApplication1 
 {
类节目
 {
公共静态Hashtable的clientsList =新的Hashtable（）; 
 
静态无效的主要（字串[] args）
 {
 //的TcpListener的ServerSocket =新的TcpListener（portFromAppConfig）; 
 
的TcpListener的ServerSocket =新的TcpListener（9999）; 
 TcpClient的ClientSocket的=默认值（TcpClient的）; 
 INT计数器= 0; 
 
 serverSocket.Start（）; 
 Console.WriteLine（欢迎来到NYP聊天服务器）; 
计数器= 0; 
，而（（真））
 {
计数器+ = 1; 
 ClientSocket的= serverSocket.AcceptTcpClient（）; 
 
字节[] = bytesFrom新的字节[10025] 
字符串dataFromClient = NULL; 
 
的NetworkStream的NetworkStream = clientSocket.GetStream（）; 
 networkStream.Read（bytesFrom，0，（int）的clientSocket.ReceiveBufferSize）; 
 dataFromClient = System.Text.Encoding.ASCII.GetString（bytesFrom）; 
 dataFromClient = dataFromClient.Substring（0，dataFromClient.IndexOf（$））; 
 
 clientsList.Add（dataFromClient，ClientSocket的）; 
 
广播（dataFromClient +连接，dataFromClient，FALSE）; 
 
 Console.WriteLine（dataFromClient +已经加入聊天室）; 
 handleClinet客户端=新handleClinet（）; 
 client.startClient（ClientSocket的，dataFromClient，clientsList）; 
} 
 
 clientSocket.Close（）; 
 serverSocket.Stop（）; 
 Console.WriteLine（退出）; 
到Console.ReadLine（）; 
} 
 
公共静态无效广播（string信息，字符串的uname，布尔标志）
 {
的foreach（在clientsList的DictionaryEntry项目）
 {
的TcpClient broadcastSocket; 
 broadcastSocket =（TcpClient的）Item.Value; 
的NetworkStream broadcastStream = broadcastSocket.GetStream（）; 
字节[] broadcastBytes = NULL; 
 
如果（标志==真）
 {
 broadcastBytes = Encoding.ASCII.GetBytes（UNAME +云：+味精）; 
} 
，否则
 {
 broadcastBytes = Encoding.ASCII.GetBytes（MSG）; 
} 
 
 broadcastStream.Write（broadcastBytes，0，broadcastBytes.Length）; 
 broadcastStream.Flush（）; 
} 
} //结束播放功能
} //结束Main类
 
 
公共类handleClinet 
 {
的TcpClient ClientSocket的; 
串clNo; 
 Hashtable的clientsList; 
 
公共无效startClient（TcpClient的inClientSocket，串clineNo，Hashtable的CLIST）
 {
 this.clientSocket = inClientSocket; 
 this.clNo = clineNo; 
 this.clientsList = CLIST; 
螺纹ctThread =新主题（doChat）; 
 ctThread.Start（）; 
} 
 
私人无效doChat（）
 {
 INT requestCount = 0; 
字节[] = bytesFrom新的字节[10025] 
字符串dataFromClient = NULL; 
字节[] sendBytes = NULL; 
字符串serverResponse = NULL; 
字符串RCOUNT = NULL; 
 requestCount = 0; 
 
，而（（真））
 {
试
 {
 requestCount = requestCount + 1; 
的NetworkStream的NetworkStream = clientSocket.GetStream（）; 
 networkStream.Read（bytesFrom，0，（int）的clientSocket.ReceiveBufferSize）; 
 dataFromClient = System.Text.Encoding.ASCII.GetString（bytesFrom）; 
 dataFromClient = dataFromClient.Substring（0，dataFromClient.IndexOf（$））; 
 Console.WriteLine（从客户端 - + clNo +：+ dataFromClient）; 
 RCOUNT = Convert.ToString（requestCount）; 
 
 Program.broadcast（dataFromClient，clNo，真正的）; 
} 
赶上（异常前）
 {
 Console.WriteLine（ex.ToString（））; 
} 
} //结束，而
} //结束doChat 
} //结束类handleClinet 
} //结束的命名空间
  

解决方案

绝对简单的方法是撕裂你写的代码，只需使用WCF。

接下来最简单的方法是使用一个安全的流，而不是原始的网络流的，如 SslStream 或的 NegotiateStream 。有在安全流样品一个完全成熟的样本，显示客户端和在服务器上为NTLM / Kerberos和SChannel中的协议（即SSL / TLS）。

有一件事你绝对应该的不可以做的是写自己的加密。加密消息是微不足道的，你会发现在网络上无数的样品。但是，创造一个密钥交换协议，这样你确实有一些加密用的是加密中最困难的任务之一。用一位业内人士公认的密钥交换机制如Kerberos或SSL / TLS，并且这些在我连接的两个流类已经实现了。

i would like to encrypt my message when sending to the server from client, how can i do it?

Client

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.Net.Sockets;
using System.Threading;

namespace SocketClient
{

public partial class SocketClient : Form
{
    System.Net.Sockets.TcpClient clientSocket = new System.Net.Sockets.TcpClient();
    NetworkStream serverStream = default(NetworkStream);
    string readData = null;


    public SocketClient()
    {
        InitializeComponent();
    }


    private void getMessage()
    {
        while (true)
        {
            serverStream = clientSocket.GetStream();
            int buffSize = 0;
            byte[] inStream = new byte[10025];
            buffSize = clientSocket.ReceiveBufferSize;
            serverStream.Read(inStream, 0, buffSize);
            string returndata = System.Text.Encoding.ASCII.GetString(inStream);
            readData = "" + returndata;
            msg();
        }
    }


    private void msg()
    {
        if (this.InvokeRequired)
            this.Invoke(new MethodInvoker(msg));
        else
            textDisplay.Text = textDisplay.Text + Environment.NewLine + " >> " + readData;
    }


    private void buttonConnect_Click(object sender, EventArgs e)
    {
        readData = "Conected to NYP Chat Server ...";
        msg();
        //clientSocket.Connect("127.0.0.1", 8888);
        clientSocket.Connect(textIP.Text, Convert.ToInt32(textPort.Text));
        serverStream = clientSocket.GetStream();

        byte[] outStream = System.Text.Encoding.ASCII.GetBytes(textName.Text + "$");
        serverStream.Write(outStream, 0, outStream.Length);
        serverStream.Flush();

        Thread ctThread = new Thread(getMessage);
        ctThread.Start();
    }

    private void buttonSend_Click(object sender, EventArgs e)
    {
        // Show msg box if no server is connected
        if (serverStream == null)
        {
            MessageBox.Show("Please connect to a server first!");
            return;
        }

        // Send text
        byte[] outStream = System.Text.Encoding.ASCII.GetBytes(textSend.Text + "$");
        serverStream.Write(outStream, 0, outStream.Length);
        serverStream.Flush();

        // Clear text
        textSend.Text = "";

    }

    private void textDisplay_TextChanged(object sender, EventArgs e)
    {
        textDisplay.SelectionStart = textDisplay.Text.Length;
        textDisplay.ScrollToCaret();
        textDisplay.Refresh();
    }

    private void textSend_TextChanged(object sender, EventArgs e)
    {
        buttonSend.Enabled = !string.IsNullOrEmpty(textSend.Text);
    }
}

}

server

using System;
using System.Threading;
using System.Net.Sockets;
using System.Text;
using System.Collections;

namespace ConsoleApplication1
{
class Program
{
    public static Hashtable clientsList = new Hashtable();

    static void Main(string[] args)
    {
        //TcpListener serverSocket = new TcpListener(portFromAppConfig);

        TcpListener serverSocket = new TcpListener(9999);
        TcpClient clientSocket = default(TcpClient);
        int counter = 0;

        serverSocket.Start();
        Console.WriteLine("Welcome to NYP Chat Server ");
        counter = 0;
        while ((true))
        {
            counter += 1;
            clientSocket = serverSocket.AcceptTcpClient();

            byte[] bytesFrom = new byte[10025];
            string dataFromClient = null;

            NetworkStream networkStream = clientSocket.GetStream();
            networkStream.Read(bytesFrom, 0, (int)clientSocket.ReceiveBufferSize);
            dataFromClient = System.Text.Encoding.ASCII.GetString(bytesFrom);
            dataFromClient = dataFromClient.Substring(0, dataFromClient.IndexOf("$"));

            clientsList.Add(dataFromClient, clientSocket);

            broadcast(dataFromClient + " Connected ", dataFromClient, false);

            Console.WriteLine(dataFromClient + " has join the chat room ");
            handleClinet client = new handleClinet();
            client.startClient(clientSocket, dataFromClient, clientsList);
        }

        clientSocket.Close();
        serverSocket.Stop();
        Console.WriteLine("exit");
        Console.ReadLine();
    }

    public static void broadcast(string msg, string uName, bool flag)
    {
        foreach (DictionaryEntry Item in clientsList)
        {
            TcpClient broadcastSocket;
            broadcastSocket = (TcpClient)Item.Value;
            NetworkStream broadcastStream = broadcastSocket.GetStream();
            Byte[] broadcastBytes = null;

            if (flag == true)
            {
                broadcastBytes = Encoding.ASCII.GetBytes(uName + " says : " + msg);
            }
            else
            {
                broadcastBytes = Encoding.ASCII.GetBytes(msg);
            }

            broadcastStream.Write(broadcastBytes, 0, broadcastBytes.Length);
            broadcastStream.Flush();
        }
    }  //end broadcast function
}//end Main class


public class handleClinet
{
    TcpClient clientSocket;
    string clNo;
    Hashtable clientsList;

    public void startClient(TcpClient inClientSocket, string clineNo, Hashtable cList)
    {
        this.clientSocket = inClientSocket;
        this.clNo = clineNo;
        this.clientsList = cList;
        Thread ctThread = new Thread(doChat);
        ctThread.Start();
    }

    private void doChat()
    {
        int requestCount = 0;
        byte[] bytesFrom = new byte[10025];
        string dataFromClient = null;
        Byte[] sendBytes = null;
        string serverResponse = null;
        string rCount = null;
        requestCount = 0;

        while ((true))
        {
            try
            {
                requestCount = requestCount + 1;
                NetworkStream networkStream = clientSocket.GetStream();
                networkStream.Read(bytesFrom, 0, (int)clientSocket.ReceiveBufferSize);
                dataFromClient = System.Text.Encoding.ASCII.GetString(bytesFrom);
                dataFromClient = dataFromClient.Substring(0, dataFromClient.IndexOf("$"));
                Console.WriteLine("From client - " + clNo + " : " + dataFromClient);
                rCount = Convert.ToString(requestCount);

                Program.broadcast(dataFromClient, clNo, true);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }//end while
    }//end doChat
} //end class handleClinet
}//end namespace

解决方案

Absolute simplest way is to rip all the code you wrote and just use WCF.

Next simplest way is to use a secure stream instead of the raw Network Stream, like SslStream or NegotiateStream. There a full blown sample at Secure Streams Sample that shows both the client and the server for NTLM/Kerberos and SChannel protocols (aka SSL/TLS).

One thing you should absolutely not do is write your own encryption. Encrypting messages is trivial and you'll find a myriad samples on the web. But creating a key exchange protocol so you actually have something to encrypt with is one of the hardest tasks in crypto. Use one of the industry acknowledged key exchange schemes like Kerberos or SSL/TLS, and these are already implemented in the two stream classes I linked.

这篇关于我怎么能发送到服务器时加密我的信息？可以约1加在我的代码，因为我不熟悉的加密？/什么帮助？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！