Flush() 공개 메소드

public Flush ( ) : void
리턴 void
예제 #1
1
        static void ProcessTcpClient(TcpClient client)
        {
            try
            {
                SslStream stream = new SslStream(client.GetStream());
                X509Certificate cert = new X509Certificate2(Certificate.CreateSelfSignCertificatePfx(
                    "CN=localhost", //host name
                    DateTime.Parse("2000-01-01"), //not valid before
                    DateTime.Parse("2099-01-01"), //not valid after
                    "mypassword"), "mypassword"); //password to encrypt key file)
                stream.AuthenticateAsServer(cert);

                byte[] requestBuffer = new byte[8192];
                int read = stream.Read(requestBuffer, 0, 8192);
                Array.Resize<byte>(ref requestBuffer, read);

                string request = Encoding.UTF8.GetString(requestBuffer);
                string requestedPath = request.Split('?')[0].Replace("GET ", "");

                Console.WriteLine(client.GetHashCode() + " => " + requestedPath);

                string response = "";

                if (requestedPath == "/gamepad/shardlist")
                {
                }
                else if (requestedPath == "/gamepad/lastshard")
                {
                }

                string header = "HTTP/1.1 200 OK\r\nDate: Fri, 10 Feb 2012 09:19:00 GMT\r\nServer: Apache/2.2.17 (Win32) mod_ssl/2.2.17 OpenSSL/0.9.8o\r\nContent-Length: " + response.Length + "\r\nContent-Type: text/html\r\n\r\n";

                byte[] headerBytes = Encoding.UTF8.GetBytes(header);
                byte[] responseBytes = Encoding.UTF8.GetBytes(response);
                stream.Write(headerBytes);
                stream.Flush();
                stream.Write(responseBytes);
                stream.Flush();
            }
            catch (Exception e)
            {
                Console.WriteLine("Exception occured!\nMessage: " + e.Message + "\n" + e.StackTrace);
            }
        }
예제 #2
0
        public ServiceEndPoint Discover(Uri remoteUri)
        {
            try
            {
                using (var client = CreateTcpClient())
                {
                    client.ConnectWithTimeout(remoteUri, HalibutLimits.TcpClientConnectTimeout);
                    using (var stream = client.GetStream())
                    {
                        using (var ssl = new SslStream(stream, false, ValidateCertificate))
                        {
                            ssl.AuthenticateAsClient(remoteUri.Host, new X509Certificate2Collection(), SslProtocols.Tls | SslProtocols.Tls11 | SslProtocols.Tls12, false);
                            ssl.Write(HelloLine, 0, HelloLine.Length);
                            ssl.Flush();

                            if (ssl.RemoteCertificate == null)
                                throw new Exception("The server did not provide an SSL certificate");

                            return new ServiceEndPoint(remoteUri, new X509Certificate2(ssl.RemoteCertificate).Thumbprint);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw new HalibutClientException(ex.Message, ex);
            }
        }
예제 #3
0
            public static string RunClient(string serverName,string activation_info,ref string buffer)
            {                                
                TcpClient client = new TcpClient(serverName,443);                
                SslStream sslStream = new SslStream(
                    client.GetStream(),
                    false,
                    new RemoteCertificateValidationCallback(ValidateServerCertificate),
                    null
                    );
              
                try
                {
                    sslStream.AuthenticateAsClient(serverName);
                }
                catch (AuthenticationException e)
                {   
                    if (e.InnerException != null)
                    {
                    }
                    client.Close();
                    Environment.Exit(-1);
                }

                byte[] messsage = Encoding.UTF8.GetBytes(activation_info + "\n<EOF>");                
                sslStream.Write(messsage);
                sslStream.Flush();               
                string serverMessage = ReadMessage(sslStream);                
                client.Close();                
                buffer = serverMessage;
                return serverMessage;
            }
예제 #4
0
파일: SslHttpClient.cs 프로젝트: abel/sinan
        static byte[] InternalSslSocketHttp(IPEndPoint endpoint, HttpArgs args, HttpMethod method, X509CertificateCollection certificates)
        {
            using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
            {
                try
                {
                    client.Connect(endpoint);
                    if (client.Connected)
                    {
                        using (SslStream stream = new SslStream(new NetworkStream(client), false, ValidateServerCertificate, null))
                        {
                            stream.AuthenticateAsClient("ServerName", certificates, SslProtocols.Tls, false);
                            if (stream.IsAuthenticated)
                            {
                                //生成协议包
                                byte[] buff = HttpClient.ParseHttpArgs(method, args);
                                stream.Write(buff, 0, buff.Length);
                                stream.Flush();
                                return ParseSslResponse(endpoint, stream, args, certificates);

                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
            return null;
        }
예제 #5
0
파일: SslTcpClient.cs 프로젝트: bemk/rhc
        private void runClient()
        {
            TcpClient client = new TcpClient(server, port);
            Console.WriteLine("Client connected ...");

            // Create ssl stream
            SslStream stream = new SslStream(client.GetStream(), false, new RemoteCertificateValidationCallback(validateServerCertificate), null);

            stream.AuthenticateAsClient(server);

            // write message to server
            byte[] output = Encoding.UTF8.GetBytes("Message from client :D<EOF>");
            stream.Write(output);
            stream.Flush();

            // read message from server
            string input = readMessage(stream);
            Console.WriteLine("Received: {0}", input);

            // close everything
            stream.Close();
            client.Close();
            Console.WriteLine("Client closed connection ...");
            // Press any key to continue ...
            Console.ReadKey();
        }
예제 #6
0
        public ServiceEndPoint Discover(ServiceEndPoint serviceEndpoint)
        {
            try
            {
                using (var client = CreateConnectedTcpClient(serviceEndpoint))
                {
                    using (var stream = client.GetStream())
                    {
                        using (var ssl = new SslStream(stream, false, ValidateCertificate))
                        {
                            ssl.AuthenticateAsClientAsync(serviceEndpoint.BaseUri.Host, new X509Certificate2Collection(), SslProtocols.Tls | SslProtocols.Tls11 | SslProtocols.Tls12, false)
                                .GetAwaiter()
                                .GetResult();
                            ssl.Write(HelloLine, 0, HelloLine.Length);
                            ssl.Flush();

                            if (ssl.RemoteCertificate == null)
                                throw new Exception("The server did not provide an SSL certificate");

                            return new ServiceEndPoint(serviceEndpoint.BaseUri, new X509Certificate2(ssl.RemoteCertificate.Export(X509ContentType.Cert)).Thumbprint);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw new HalibutClientException(ex.Message, ex);
            }
        }
        public void SendEmptyPushNotification(string deviceIdentifier, string thumbprint)
        {
            string server = "gateway.push.apple.com";
            using (TcpClient tcpClient = new TcpClient(server, 2195))
            {
                Trace.TraceInformation("Opening SSL Connection...");
                using (SslStream sslStream = new SslStream(tcpClient.GetStream()))
                {
                    try
                    {
                        X509Certificate2Collection certs = new X509Certificate2Collection();

                        Trace.TraceInformation("Adding certificate to connection...");
                        X509Certificate cert = GetAppleServerCert(thumbprint);
                        certs.Add(cert);

                        Trace.TraceInformation("Authenticating against the SSL stream...");
                        sslStream.AuthenticateAsClient(server, certs, SslProtocols.Default, false);
                    }
                    catch (AuthenticationException exp)
                    {
                        Trace.TraceError("Failed to authenticate to APNS - {0}", exp.Message);
                        return;
                    }
                    catch (IOException exp)
                    {
                        Trace.TraceError("Failed to connect to APNS - {0}", exp.Message);
                        return;
                    }

                    byte[] buf = new byte[256];
                    MemoryStream ms = new MemoryStream();
                    BinaryWriter bw = new BinaryWriter(ms);
                    bw.Write(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32 });

                    byte[] deviceToken = HexToData(deviceIdentifier);
                    bw.Write(deviceToken);
                    
                    string msg = "{}";

                    bw.Write(new byte[] { 0, 2 });
                    bw.Write(msg.ToCharArray());
                    bw.Flush();

                    Trace.TraceInformation("Message sent. Closing stream...");

                    if (sslStream != null)
                    {
                        sslStream.Write(ms.ToArray());
                    }

                    sslStream.Flush();

                    byte[] response = new byte[6];
                    sslStream.Read(response, 0, 6);
                }
            }
        }
예제 #8
0
파일: msslserver.cs 프로젝트: xzkmxd/mono
		static void Main (string [] args)
		{
			certfile = (args.Length > 1) ? args [0] : "ssl.cer";
			keyfile = (args.Length > 1) ? args [1] : "ssl.pvk";

			Socket listenSocket = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
			IPEndPoint localEndPoint = new IPEndPoint (IPAddress.Any, 4433);
			Socket requestSocket;

			listenSocket.Bind (localEndPoint);
			listenSocket.Listen (10);

			while (true) {
				try {
					requestSocket = listenSocket.Accept ();
					using (NetworkStream ns = new NetworkStream (requestSocket, FileAccess.ReadWrite, true)) {
						using (SslStream s = new SslStream (ns, false, new RemoteCertificateValidationCallback (VerifyClientCertificate))) {
							s.AuthenticateAsServer (Certificate, false, SslProtocols.Default, false);
							StreamReader reader = new StreamReader (s);
							StreamWriter writer = new StreamWriter (s, Encoding.ASCII);

							string line;
							// Read request header
							do {
								line = reader.ReadLine ();
								if (line != null)
									Console.WriteLine (line);
							}
							while (line != null && line.Length > 0);

							string answer = String.Format ("HTTP/1.0 200{0}Connection: close{0}" +
								"Content-Type: text/html{0}Content-Encoding: {1}{0}{0}" +
								"<html><body><h1>Hello {2}!</h1></body></html>{0}",
								"\r\n", Encoding.ASCII.WebName,
								s.RemoteCertificate == null ? "World" : s.RemoteCertificate.GetName ());

							// Send response
							writer.Write (answer);

							writer.Flush ();
							s.Flush ();
							ns.Flush ();
						}
					}
				}
				catch (Exception ex) {
					Console.WriteLine ("---------------------------------------------------------");
					Console.WriteLine (ex.ToString ());
				}
			}
		}
 /// <summary>
 /// Send a packet.</summary>
 /// <param name="packet">The packet that will be send</param>
 /// <param name="ssl">The ssl stream</param>
 public static bool SendPacket(Packet packet, SslStream ssl)
 {
     BinaryFormatter binairyFormatter = new BinaryFormatter();
     try
     {
         binairyFormatter.Serialize(ssl, packet);
         ssl.Flush();
     }
     catch (Exception)
     {
         return false;
     }
     return true;
 }
 /// <summary>
 /// Receive and read a packet.</summary>
 /// <param name="ssl">The ssl stream</param>
 public static Packet ReadPacket(SslStream ssl)
 {
     BinaryFormatter binairyFormatter = new BinaryFormatter();
     Packet packet;
     try
     {
         packet = (Packet)binairyFormatter.Deserialize(ssl);
         ssl.Flush();
     }
     catch (Exception)
     {
         return null;
     }
     return packet;
 }
        public static void RunClient(string machineName, string serverName ="ssl.breakermind.com")
        {
            // Create a TCP/IP client socket.
            // machineName is the host running the server application.
            TcpClient client = new TcpClient("localhost", 8080);
            Console.WriteLine("Client connected.");
            // Create an SSL stream that will close the client's stream.
            SslStream sslStream = new SslStream(
                client.GetStream(),
                false,
                new RemoteCertificateValidationCallback(ValidateServerCertificate),
                null
                );
            // The server name must match the name on the server certificate.
            try
            {

                sslStream.AuthenticateAsClient("ssl.breakermind.com");
                DisplaySecurityLevel(sslStream);
                Console.ReadLine();
            }
            catch (AuthenticationException e)
            {
                Console.WriteLine("Exception: {0}", e.Message);
                if (e.InnerException != null)
                {
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message);
                }
                Console.WriteLine("Authentication failed - closing the connection.");
                client.Close();
                return;
            }
            // Encode a test message into a byte array.
            // Signal the end of the message using the "<EOF>".
            byte[] messsage = Encoding.UTF8.GetBytes("Hello from the client.<EOF>");
            // Send hello message to the server.
            sslStream.Write(messsage);
            sslStream.Flush();
            // Read message from the server.
            string serverMessage = ReadMessage(sslStream);
            Console.WriteLine("Server says: {0}", serverMessage);
            // Close the client connection.
            client.Close();
            Console.WriteLine("Client closed.");
        }
예제 #12
0
        public static void RunClient()
        {
            TcpClient client = new TcpClient(serverHost, serverPort);

            SslStream sslStream = new SslStream(
                client.GetStream(),
                false,
                new RemoteCertificateValidationCallback (ValidateServerCertificate),
                null
                );

            try
            {
                sslStream.AuthenticateAsClient("none");
            }
            catch (AuthenticationException e)
            {
                Console.WriteLine("Exception: {0}", e.Message);
                if (e.InnerException != null)
                {
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message);
                }
                Console.WriteLine ("Authentication failed - closing the connection.");
                client.Close();
                return;
            }

            // Encode a test message into a byte array.
            // Signal the end of the message using the "<EOF>".
            byte[] messsage = Encoding.UTF8.GetBytes("GET / HTTP/1.1\r\n\r\n");

            // Send hello message to the server.
            sslStream.Write(messsage);
            sslStream.Flush();

            // Read message from the server.
            string serverMessage = ReadMessage(sslStream);
            Console.WriteLine("Server says: {0}", serverMessage);

            // Close the client connection.
            client.Close();
            Console.WriteLine("Client closed.");
        }
예제 #13
0
        public static void RunClient(string machineName, string serverName, int port)
        {
            TcpClient client = new TcpClient(machineName, port);
            Console.WriteLine("Client connected.");
            // Create an SSL stream that will close the client's stream.
            SslStream sslStream = new SslStream(
                client.GetStream(),
                false,
                new RemoteCertificateValidationCallback(ValidateServerCertificate),
                null
                );
            // The server name must match the name on the server certificate.
            try
            {
                sslStream.AuthenticateAsClient(serverName);
            }
            catch (AuthenticationException e)
            {
                Console.WriteLine("Exception: {0}", e.Message);
                if (e.InnerException != null)
                {
                    Console.WriteLine("Inner exception: {0}", e.InnerException.Message);
                }
                Console.WriteLine("Authentication failed - closing the connection.");
                client.Close();
                return;
            }

            byte[] message = Encoding.UTF8.GetBytes("Hello from the client.<EOF>");
            // Send hello message to the server.
            sslStream.Write(message);
            sslStream.Flush();
            // Read message from the server.
            string serverMessage = ReadMessage(sslStream);
            Console.WriteLine("Server says: {0}", serverMessage);
            // Close the client connection.
            client.Close();
            Console.WriteLine("Client closed.");
        }
예제 #14
0
        private void SendRequest(object notificationMessage, string deviceToken, SslStream sslStream, TcpClient client)
        {
            // Encode a test message into a byte array.
            MemoryStream memoryStream = new MemoryStream();
            BinaryWriter writer = new BinaryWriter(memoryStream);

            writer.Write((byte)0); //The command
            writer.Write((byte)0); //The first byte of the deviceId length (big-endian first byte)
            writer.Write((byte)32); //The deviceId length (big-endian second byte)

            writer.Write(HexStringToByteArray(deviceToken.ToUpper()));

            String payload = new JavaScriptSerializer().Serialize(notificationMessage);

            writer.Write((byte)0); //First byte of payload length; (big-endian first byte)
            writer.Write((byte)Encoding.UTF8.GetByteCount(payload)); //payload length (big-endian second byte)

            byte[] b1 = Encoding.UTF8.GetBytes(payload);
            writer.Write(b1);

            writer.Flush();

            byte[] array = memoryStream.ToArray();
            sslStream.Write(array);
            sslStream.Flush();

            // Close the client connection.
            client.Close();
        }
예제 #15
0
        private void SendRequest(object notificationMessage, string deviceToken, SslStream sslStream)
        {
            MemoryStream memoryStream = new MemoryStream();
            BinaryWriter writer = new BinaryWriter(memoryStream);
            String payload = new JavaScriptSerializer().Serialize(notificationMessage);

            writer.Write((byte)2); // The command (version 2)

            // 4 bytes for the frameLength (this includes all the items ids listed below)
            int frameLength = 1 + 2 + 32 + 1 + 2 + Encoding.UTF8.GetByteCount(payload);
            // (tokenCommand + tokenLength + token) + (payloadCommand + payloadLength + payload)
            this.WriteIntBytesAsBigEndian(writer, frameLength, 4);

            // DEVICE ID
            writer.Write((byte)1); // Command for Item ID: deviceId
            byte[] tokenBytes = this.HexStringToByteArray(deviceToken);
            this.WriteIntBytesAsBigEndian(writer, tokenBytes.Length, 2);
            writer.Write(tokenBytes);

            // PAYLOAD
            writer.Write((byte)2); // Command for Item ID: payload
            this.WriteIntBytesAsBigEndian(writer, Encoding.UTF8.GetByteCount(payload), 2);

            byte[] value = Encoding.UTF8.GetBytes(payload);
            Debug.WriteLine(Encoding.UTF8.GetString(value));

            writer.Write(value, 0, Encoding.UTF8.GetByteCount(payload));

            writer.Flush();

            sslStream.Write(memoryStream.ToArray());
            sslStream.Flush();
        }
예제 #16
0
        public virtual string SocketStream(string xmlRequestFilePath, string xmlResponseDestinationDirectory, Dictionary<string, string> config)
        {
            var url = config["onlineBatchUrl"];
            var port = int.Parse(config["onlineBatchPort"]);
            TcpClient tcpClient;
            SslStream sslStream;

            try
            {
                tcpClient = new TcpClient(url, port);
                sslStream = new SslStream(tcpClient.GetStream(), false, ValidateServerCertificate, null);
            }
            catch (SocketException e)
            {
                throw new LitleOnlineException("Error establishing a network connection", e);
            }

            try
            {
                sslStream.AuthenticateAsClient(url);
            }
            catch (AuthenticationException e)
            {
                tcpClient.Close();
                throw new LitleOnlineException("Error establishing a network connection - SSL Authencation failed", e);
            }

            if ("true".Equals(config["printxml"]))
            {
                Console.WriteLine("Using XML File: " + xmlRequestFilePath);
            }

            using (var readFileStream = new FileStream(xmlRequestFilePath, FileMode.Open))
            {
                int bytesRead;

                do
                {
                    var byteBuffer = new byte[1024 * sizeof(char)];
                    bytesRead = readFileStream.Read(byteBuffer, 0, byteBuffer.Length);

                    sslStream.Write(byteBuffer, 0, bytesRead);
                    sslStream.Flush();
                } while (bytesRead != 0);
            }

            var batchName = Path.GetFileName(xmlRequestFilePath);
            var destinationDirectory = Path.GetDirectoryName(xmlResponseDestinationDirectory);
            if (destinationDirectory != null && !Directory.Exists(destinationDirectory)) Directory.CreateDirectory(destinationDirectory);

            if ("true".Equals(config["printxml"]))
            {
                Console.WriteLine("Writing to XML File: " + xmlResponseDestinationDirectory + batchName);
            }

            using (var writeFileStream = new FileStream(xmlResponseDestinationDirectory + batchName, FileMode.Create))
            {
                int bytesRead;

                do
                {
                    var byteBuffer = new byte[1024 * sizeof(char)];
                    bytesRead = sslStream.Read(byteBuffer, 0, byteBuffer.Length);

                    writeFileStream.Write(byteBuffer, 0, bytesRead);
                } while (bytesRead > 0);
            }

            tcpClient.Close();
            sslStream.Close();

            return xmlResponseDestinationDirectory + batchName;
        }
예제 #17
0
        /// <summary>
        /// Performs performQuery() on Ews, asking how a doc processed.
        /// </summary>
        /// <param name="submittedFile">File to read parameters from</param>
        /// <param name="callerType">this.GetType() - since we're static, we need a way to load embedded resources</param>
        /// <returns>The XML as string as the webservice returns it</returns>
        public static string GetProcessingResult(XmlDocument submittedFile, Type callerType, string username, string password)
        {
            if (submittedFile == null)
                return null;
            // fill in query template
            Stream stream = callerType.Assembly.GetManifestResourceStream("XtbCnb2.performQueryTemplate.txt");
            StreamReader sr = new StreamReader(stream);
            string query = sr.ReadToEnd();
            sr.Close();

            query = query.Replace("***USERNAME***", username);
            query = query.Replace("***PASSWORD***", password);
            XmlNode node = submittedFile.SelectSingleNode("/VYDANI/IDENTIFIKACE-VYKAZU/VYSKYT/STAV-KE-DNI");
            // yyyymmdd -> dd.mm.yyyy
            string s = node.InnerText;
            query = query.Replace("***OBDOBIV***", s.Substring(6,2) + "." + s.Substring(4,2) + "." + s.Substring(0,4));
            node = submittedFile.SelectSingleNode("/VYDANI/IDENTIFIKACE-VYKAZU/VYSKYT/SUBJEKT");
            query = query.Replace("***SUBJEKTV***", node.InnerText);
            node = submittedFile.SelectSingleNode("/VYDANI/IDENTIFIKACE-VYKAZU/DATOVY-SOUBOR");
            s = node.InnerText;
            int pos = s.IndexOf('.');
            if (pos > 0)
                s = s.Substring(0, pos);
            query = query.Replace("***DATOVY-SOUBOR***", s);

            string t = query;
            t = t.Replace(password, "[[[CENSORED]]]");
            string fnameForLog = "Q" + CnbData.ConstructCisloVydani().ToString() + ".xml";
            Log.LogAsText("User " + username + " querying document status via document " + fnameForLog);
            Log.LogAsFile(t, fnameForLog);

            query = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(query), Base64FormattingOptions.InsertLineBreaks);

            // fill in SOAP template
            stream = callerType.Assembly.GetManifestResourceStream("XtbCnb2.QuerySOAPTemplate.txt");
            sr = new StreamReader(stream);
            string soap = sr.ReadToEnd();
            sr.Close();

            soap = soap.Replace("***DATA-LENGTH***", (query.Length + 1).ToString());                    // +1 for \n
            soap = soap.Replace("***DATA***", query);

            // fill in total length
            byte[] tData = System.Text.Encoding.UTF8.GetBytes(soap);

            byte lastByte = 0;
            for (pos = 0; pos < tData.Length; pos++)
            {
                if (lastByte == 10 && tData[pos] == 10)
                    break;

                lastByte = tData[pos];
            }

            int totalLength = tData.Length - pos - 1;
            soap = soap.Replace("***TOTAL-LENGTH***", totalLength.ToString());

            // set up connection to webservice (we can't do this the comfy way as MS doesn't support SwA)
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Ssl3;
            ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) => { return true; };

            try
            {
                TcpClient client = new TcpClient(machineName, 443);
                client.SendTimeout = 2 * 60 * 1000;
                SslStream sslStream = new SslStream(client.GetStream(), false, new RemoteCertificateValidationCallback(ValidateServerCertificate), null);
                sslStream.AuthenticateAsClient(machineName, null, SslProtocols.Ssl2 | SslProtocols.Ssl3, false);
                byte[] messsage = System.Text.Encoding.UTF8.GetBytes(soap);

            //                File.WriteAllBytes(@"C:\projekty\XtbCnb2\XtbCnb2\Tomas Drabek\soap.bin", messsage);

                // send request to ws
                sslStream.Write(messsage);
                sslStream.Flush();

                // read ws response
                byte[] buffer = new byte[2048];
                StringBuilder messageData = new StringBuilder();
                int bytes = -1;
                do
                {
                    bytes = sslStream.Read(buffer, 0, buffer.Length);

                    if (bytes == 0)
                        break;

                    Decoder decoder = Encoding.UTF8.GetDecoder();
                    char[] chars = new char[decoder.GetCharCount(buffer, 0, bytes)];
                    decoder.GetChars(buffer, 0, bytes, chars, 0);
                    messageData.Append(chars);
                } while (bytes != 0);

                client.Close();

                // get the response part we care about
                string rawMessage = messageData.ToString();
                rawMessage = rawMessage.Replace("\r\n", "\n");

                string resfname = "S" + CnbData.ConstructCisloVydani().ToString() + ".txt";
                Log.LogAsText("Response recorded as file " + resfname);
                Log.LogAsFile(rawMessage, resfname);

                // check HTTP result code
                Regex checkHeader = new Regex("HTTP/1.. 200.*");
                if (!checkHeader.IsMatch(rawMessage))
                    throw new Exception("Webservice returned the following raw error:\n" + rawMessage);

                Regex regex = new Regex(".*?Content-Type: .*? boundary.?=.?\"(.*?)\".*");
                Match match = regex.Match(rawMessage);
                string boundary = match.Groups[1].Value;

                pos = rawMessage.IndexOf(boundary);
                pos = rawMessage.IndexOf(boundary, pos + boundary.Length);
                pos = rawMessage.IndexOf(boundary, pos + boundary.Length);
                pos += boundary.Length;
                int partStart = pos;
                partStart = rawMessage.IndexOf("\n\n", partStart) + 2;
                int partEnd = rawMessage.IndexOf(boundary, pos) - 2;                                    // mime prepends 2 minuses, we don't want them
                string b64Message = rawMessage.Substring(partStart, partEnd - partStart);

                // decode the part
                byte[] decoded = null;

                try
                {
                    decoded = Convert.FromBase64String(b64Message);
                    return System.Text.Encoding.UTF8.GetString(decoded);
                }
                catch (Exception)
                {
                    return b64Message;
                }
            }
            catch (Exception e)
            {
                string msg = string.Format("Exception type: {0}, exception info: {1}", e.ToString(), e.Message);
                if (e.InnerException != null)
                    msg += string.Format("\n\nInner exception type: {0}, exception info: {1}", e.InnerException.ToString(), e.InnerException.Message);

                MessageBox.Show(msg, "Exception Encountered");
                return null;
            }
        }
예제 #18
0
 static void WriteJSONMessage(SslStream sslStream, JSONEvent eventObj)
 {
     string message = JsonConvert.SerializeObject(eventObj);
     Console.WriteLine(message);
     byte[] msg = Encoding.UTF8.GetBytes(message);
     sslStream.Write(msg);
     sslStream.Flush();
 }
예제 #19
0
        public virtual string socketStream(string xmlRequestFilePath, string xmlResponseDestinationDirectory, Dictionary<String, String> config)
        {
            string url = config["onlineBatchUrl"];
            int port = Int32.Parse(config["onlineBatchPort"]);
            TcpClient tcpClient = null;
            SslStream sslStream = null;

            try
            {
                tcpClient = new TcpClient(url, port);
                sslStream = new SslStream(tcpClient.GetStream(), false, new RemoteCertificateValidationCallback(ValidateServerCertificate), null);
            }
            catch (SocketException e)
            {
                throw new LitleOnlineException("Error establishing a network connection", e);
            }

            try
            {
                sslStream.AuthenticateAsClient(url);
            }
            catch (AuthenticationException)
            {
                tcpClient.Close();
                throw new LitleOnlineException("Error establishing a network connection - SSL Authencation failed");
            }

            if ("true".Equals(config["printxml"]))
            {
                Console.WriteLine("Using XML File: " + xmlRequestFilePath);
            }

            using (FileStream readFileStream = new FileStream(xmlRequestFilePath, FileMode.Open))
            {
                int bytesRead = -1;
                byte[] byteBuffer;

                do
                {
                    byteBuffer = new byte[1024 * sizeof(char)];
                    bytesRead = readFileStream.Read(byteBuffer, 0, byteBuffer.Length);

                    sslStream.Write(byteBuffer, 0, bytesRead);
                    sslStream.Flush();
                } while (bytesRead != 0);
            }

            string batchName = Path.GetFileName(xmlRequestFilePath);
            string destinationDirectory = Path.GetDirectoryName(xmlResponseDestinationDirectory);
            if (!Directory.Exists(destinationDirectory))
            {
                Directory.CreateDirectory(destinationDirectory);
            }

            if ("true".Equals(config["printxml"]))
            {
                Console.WriteLine("Writing to XML File: " + xmlResponseDestinationDirectory + batchName);
            }

            using (FileStream writeFileStream = new FileStream(xmlResponseDestinationDirectory + batchName, FileMode.Create))
            {
                char[] charBuffer;
                byte[] byteBuffer;
                int bytesRead = 0;

                do
                {
                    charBuffer = new char[1024];
                    byteBuffer = new byte[1024 * sizeof(char)];
                    bytesRead = sslStream.Read(byteBuffer, 0, byteBuffer.Length);
                    charBuffer = Encoding.UTF8.GetChars(byteBuffer);

                    writeFileStream.Write(byteBuffer, 0, bytesRead);
                } while (bytesRead > 0);
            }

            tcpClient.Close();
            sslStream.Close();

            return xmlResponseDestinationDirectory + batchName;
        }
예제 #20
0
파일: Core.cs 프로젝트: uptredlabs/Mobile
        public static string HTTPFetch(string url, string method,
            WebHeaderCollection headers, 
            byte[] streamBytes, 
            int contentLength, 
            out string[] responseFields,
            string contentType = "application/x-www-form-urlencoded",
            string requestAccept = null, 
            string host = null)
        {
            _active = true;
            try
            {
                var uri = new Uri(url);
                if (EndpointCallback != null) EndpointCallback(uri.AbsolutePath);
                if (string.IsNullOrEmpty(host)) host = uri.Host;

                string reqStr =
                    String.Format("{0} {1} HTTP/1.1\r\n", method, url) +
                    String.Format("Host: {0}\r\n", host) +
                    String.Format("Connection: Close\r\n");

                if (!IsNullOrWhiteSpace(requestAccept))
                    reqStr += String.Format("Accept: {0}\r\n", requestAccept);
                if (contentType != null)
                    reqStr += String.Format("Content-Type: {0}\r\n", contentType);

                if (headers != null)
                {
                    for (int i = 0; i < headers.Count; ++i)
                    {
                        string header = headers.GetKey(i);
                        foreach (string value in headers.GetValues(i))
                        {
                            reqStr += String.Format("{0}: {1}\r\n", header, value);
                        }
                    }
                }

                reqStr += String.Format("Content-Length: {0}\r\n", contentLength);
                reqStr += "\r\n";
                byte[] headerBytes = ToByteArray(reqStr);

                byte[] finalBytes = headerBytes;
                if (contentLength > 0)
                {
                    var requestBytes = new byte[headerBytes.Length + contentLength];
                    Buffer.BlockCopy(headerBytes, 0, requestBytes, 0, headerBytes.Length);
                    Buffer.BlockCopy(streamBytes, 0, requestBytes, headerBytes.Length, contentLength);
                    finalBytes = requestBytes;
                }

                string responseFromServer = "";
                responseFields = new string[] { };
                var tcpClient = new TcpClient();
                string responseStr = "";
                int responseLength = 0;

                if (url.ToLower().StartsWith("https"))
                {
                    //HTTPS
                    tcpClient.Connect(uri.Host, 443);
                    ServicePointManager.ServerCertificateValidationCallback += new RemoteCertificateValidationCallback((sender, certificate, chain, policyErrors) => true);

                    //This has a bug on mono: Message	"The authentication or decryption has failed."
                    //Therefore unfortunately we have to ignore certificates.
                    using (var s = new SslStream(tcpClient.GetStream(), false,
                        new RemoteCertificateValidationCallback((sender, certificate, chain, policyErrors) => true)))
                    {
                        s.AuthenticateAsClient(uri.Host, null, SslProtocols.Tls, false);
                        if (UpstreamCallback != null && UpstreamCallbackRate > 0)
                        {
                            int i = 0;
                            while (i < finalBytes.Length)
                            {
                                if (!_active) throw new Exception("Halt");
                                if (i + _upstreamCallbackRate > finalBytes.Length)
                                {
                                    s.Write(finalBytes, i, finalBytes.Length - i);
                                    UpstreamCallback(contentLength, contentLength);
                                    break;
                                }
                                s.Write(finalBytes, i, (int)_upstreamCallbackRate);
                                i += (int)_upstreamCallbackRate;
                                UpstreamCallback(Math.Min(i, contentLength), contentLength);
                            }
                        }
                        else s.Write(finalBytes, 0, finalBytes.Length);
                        s.Flush();

                        while (true)
                        {
                            var responseBytes = new byte[8192];
                            int i = s.Read(responseBytes, 0, responseBytes.Length);
                            if (i == 0) break;
                            responseStr += Encoding.UTF8.GetString(responseBytes, 0, i);
                            responseLength += i;
                        }
                    }
                }
                else
                {
                    //HTTP
                    tcpClient.Connect(uri.Host, 80);
                    if (UpstreamCallback != null && UpstreamCallbackRate > 0)
                    {
                        var s = tcpClient.GetStream();
                        int i = 0;
                        while (i < finalBytes.Length)
                        {
                            if (!_active) throw new Exception("Halt");
                            if (i + _upstreamCallbackRate > finalBytes.Length)
                            {
                                s.Write(finalBytes, i, finalBytes.Length - i);
                                UpstreamCallback(contentLength, contentLength);
                                break;
                            }
                            s.Write(finalBytes, i, (int)_upstreamCallbackRate);
                            i += (int)_upstreamCallbackRate;
                            UpstreamCallback(Math.Min(i, contentLength), contentLength);
                        }
                    }
                    else tcpClient.Client.Send(finalBytes);

                    while (true)
                    {
                        var responseBytes = new byte[8192];
                        int i = tcpClient.Client.Receive(responseBytes);
                        if (i == 0) break;
                        responseStr += Encoding.UTF8.GetString(responseBytes, 0, i);
                        responseLength += i;
                    }
                }

                tcpClient.Close();

                var bodyPos = responseStr.IndexOf("\r\n\r\n");
                if (bodyPos >= 0)
                {
                    responseFields = responseStr.Substring(0, bodyPos).Split(new[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
                    bodyPos += 4;
                    responseFromServer = responseStr.Substring(bodyPos, responseStr.Length - bodyPos);
                }

                Debug.WriteLine(String.Format("Response from URL {0}:", url), "HTTPFetch");
                Debug.WriteLine(responseFromServer, "HTTPFetch");

                if (VerboseCallback != null)
                {
                    VerboseCallback(String.Format("Response from URL {0}:", url));
                    VerboseCallback(responseFromServer);
                }

                return responseFromServer;
            }
            catch (Exception e)
            {
                _active = false;
                throw e;
            }
        }
        public ActionResult Edit(int id, Session updatedSession)
        {
            SessionModelContainer ctx = new SessionModelContainer();
            Session currentSession = ctx.Sessions.First(s => s.Id == id);
            String message = currentSession.Code + ": ";
            bool changed = false;

            currentSession.Code = updatedSession.Code;

            if (currentSession.Title != updatedSession.Title)
            {
                currentSession.Title = updatedSession.Title;
                message += "Title changed to "+updatedSession.Title;
                changed = true;
            }

            if (currentSession.Room != updatedSession.Room)
            {
                currentSession.Room = updatedSession.Room;
                message += "Room changed to "+updatedSession.Room;
                changed = true;
            }

            if (changed)
            {
                // send a push notification message to the device
                string host = "gateway.sandbox.push.apple.com";
                int port = 2195;

                // load the certificate file
                string certPath = @"c:\temp\teched_APN.p12";
                X509Certificate2 clientCert = new X509Certificate2(certPath, "Password");
                X509Certificate2Collection certCollection = new X509Certificate2Collection(clientCert);

                // open connection and connect
                TcpClient client = new TcpClient(host, port);
                SslStream sslStream = new SslStream(client.GetStream(), false);

                try
                {
                    sslStream.AuthenticateAsClient(host, certCollection, SslProtocols.Tls, false);
                }
                catch (AuthenticationException ex)
                {
                    Console.WriteLine(ex.InnerException.ToString());
                    Console.In.Read();
                    client.Close();
                    return RedirectToAction("Index");
                }

                MemoryStream memoryStream = new MemoryStream();
                BinaryWriter writer = new BinaryWriter(memoryStream);

                // construct the message
                writer.Write((byte)0);  // Command
                writer.Write((byte)0);  // First byte of device ID length
                writer.Write((byte)32); // Device id length

                String deviceId = "e18ac3b8a408e4e972e171a05cdba8f046ff3724ef999093c2b479397b8c40fe";  //Simon's iPhone

                // convert to hex and write to message
                byte[] deviceToken = new byte[deviceId.Length / 2];
                for (int i = 0; i < deviceToken.Length; i++)
                    deviceToken[i] = byte.Parse(deviceId.Substring(i * 2, 2), System.Globalization.NumberStyles.HexNumber);
                writer.Write(deviceToken);

                // construct payload within JSON message framework
                String payload = "{\"aps\":{\"alert\":\""+message+"\",\"badge\":1}}";

                // write payload data
                writer.Write((byte)0);                  // First byte of payload length
                writer.Write((byte)payload.Length);     // Actual payload length
                byte[] b1 = System.Text.Encoding.UTF8.GetBytes(payload);
                writer.Write(b1);
                writer.Flush();

                // send across the wire
                byte[] array = memoryStream.ToArray();
                sslStream.Write(array);
                sslStream.Flush();

                // Close the client connection.
                client.Close();

                // Success
                Console.WriteLine("Message has been sent!  Please check device.");
                Console.In.Read();

            }

            ctx.SaveChanges();
            return RedirectToAction("Index");
        }
예제 #22
0
        /// <summary>
        /// Uses a TCPClient and SSLStream to perform a POST.
        /// </summary>
        /// <param name="requestUrl">URL that the POST must be directed to.</param>
        /// <param name="body">Message that is to be sent.</param>
        /// <param name="user">UserId in your Zeep System. Only required if your sending a Single Message to a User.
        /// Otherwise, just send a string.Empty.</param>
        /// <returns>Response from the server. (although it will write the response to console)</returns>
        public static string SendSMS(string requestUrl, string body, string user)
        {
            string parameters     = "";
            string requestHeaders = "";
            string responseData   = "";

            // FORMAT must be Sun, 06 Nov 1994 08:49:37 GMT
            string http_date = DateTime.UtcNow.ToString("r");

            // Clean the text to send
            body = HttpUtility.UrlEncode(body, System.Text.Encoding.UTF8);

            if (user.Length > 0)
            {
                parameters += "user_id=" + user + "&";
            }
            if (body.Length > 0)
            {
                parameters += "body=" + body;
            }


            // String that will be converted into a signature.
            string canonicalString = API_KEY + http_date + parameters;


            //------------START HASH COMPUTATION---------------------
            // Compute the Base64 HMACSHA1 value
            HMACSHA1 hmacsha1 = new HMACSHA1(SECRET_ACCESS_KEY.ToByteArray());

            // Compute the hash of the input file.
            byte[] hashValue = hmacsha1.ComputeHash(canonicalString.ToByteArray());

            String b64Mac         = hashValue.ToBase64String();
            String authentication = String.Format("Zeep {0}:{1}", API_KEY, b64Mac);
            //-----------END HASH COMPUTATION------------------------


            string auth = String.Format("Zeep {0}:{1}", API_KEY, b64Mac);


            System.Uri uri = new Uri(requestUrl);
            System.Net.Sockets.TcpClient client = new System.Net.Sockets.TcpClient(uri.Host, uri.Port);
            string requestMethod = "POST " + uri.LocalPath + " HTTP/1.1\r\n";

            // Set Headers for the POST message
            requestHeaders += "Host: api.zeepmobile.com\r\n";
            requestHeaders += "Authorization: " + auth + "\r\n";
            requestHeaders += "Date: " + DateTime.UtcNow.ToString("r") + "\r\n";
            requestHeaders += "Content-Type: application/x-www-form-urlencoded\r\n";
            requestHeaders += "Content-Length: " + parameters.ToByteArray().Length + "\r\n";
            requestHeaders += "\r\n";


            // Get the data to be sent as a byte array.
            Byte[] data = System.Text.Encoding.UTF8.GetBytes(requestMethod + requestHeaders + parameters + "\r\n");
            // Send the message to the connected TcpServer.
            NetworkStream stream = client.GetStream();


            // SSL Authentication is used because the Server requires https.
            System.Net.Security.SslStream sslStream = new System.Net.Security.SslStream(
                stream,
                false,
                new System.Net.Security.RemoteCertificateValidationCallback(ValidateServerCertificate));
            sslStream.AuthenticateAsClient(uri.Host);

            // Send the data over the SSL stream.
            sslStream.Write(data, 0, data.Length);
            sslStream.Flush();


            // Receive the TcpServer.response.
            for (int i = 0; i < 100; i++)
            {
                if (stream.DataAvailable)
                {
                    break;
                }
                System.Threading.Thread.Sleep(100);
            }

            Byte[] bytes = new byte[1024];
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            while (stream.DataAvailable)
            {
                int count = sslStream.Read(bytes, 0, 1024);
                if (count == 0)
                {
                    break;
                }
                sb.Append(System.Text.Encoding.UTF8.GetString(bytes, 0, count));
            }

            responseData = sb.ToString();
            Console.WriteLine(responseData);
            // Close everything.
            client.Close();

            return(responseData);
        }
예제 #23
0
        private bool TestHttpViaSocket(Socket socket, TestInfo info)
        {
            try
            {
                using (var nets = new NetworkStream(socket))
                {
                    using (var ssls = new SslStream(nets, false, (sender, cert, chain, sslpe) =>
                    {
                        var str = cert.Subject;
                        var len = str.IndexOf(",", 3) - 3;
                        info.CName = str.Substring(3, len > 0 ? len : str.Length - 3);
                        return true;
                    }))
                    {
                        ssls.AuthenticateAsClient(string.Empty);
                        if (ssls.IsAuthenticated)
                        {
                            var data = Encoding.UTF8.GetBytes(string.Format("HEAD /search?q=g HTTP/1.1\r\nHost: www.google.com.hk\r\n\r\nGET /{0} HTTP/1.1\r\nHost: azzvxgoagent{1}.appspot.com\r\nConnection: close\r\n\r\n", Application.ProductVersion, Rand.Next(7)));

                            ssls.Write(data);
                            ssls.Flush();

                            using (var sr = new StreamReader(ssls))
                            {
                                var text = sr.ReadToEnd();

                                if (text.Length == 0)
                                {
                                    info.HttpOk = false;
                                    info.HttpMsg = "NN BadResponse";
                                }
                                else
                                {
                                    info.HttpMsg = "NN";

                                    var ms = RxResult.Matches(text);
                                    for (var i = 0; i < ms.Count; i++)
                                    {
                                        if (ms[i].Groups[2].Value == "200" && ++i < ms.Count)
                                            switch (ms[i].Groups[3].Value)
                                            {
                                                case "gws\r":
                                                    info.HttpOk = true;
                                                    info.HttpMsg = "G" + info.HttpMsg[1];
                                                    break;
                                                case "Google Frontend\r":
                                                    info.HttpOk = true;
                                                    info.HttpMsg = info.HttpMsg[0] + "A";
                                                    break;
                                                default:
                                                    i--;
                                                    break;
                                            }
                                    }
                                }
                            }
                        }
                        else
                        {
                            info.HttpOk = false;
                            info.HttpMsg = "NN SslInvalid";
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                info.HttpOk = false;
                info.HttpMsg = "NN " + ex.Message;
            }

            return info.HttpOk;
        }
        public virtual string socketStream(string xmlRequestFilePath, string xmlResponseDestinationDirectory,
            Dictionary<string, string> config)
        {
            var url = config["onlineBatchUrl"];
            var port = int.Parse(config["onlineBatchPort"]);
            TcpClient tcpClient = null;
            SslStream sslStream = null;

            try
            {
                tcpClient = new TcpClient(url, port);
                sslStream = new SslStream(tcpClient.GetStream(), false, ValidateServerCertificate, null);
            }
            catch (SocketException e)
            {
                throw new LitleOnlineException("Error establishing a network connection", e);
            }

            try
            {
                sslStream.AuthenticateAsClient(url);
            }
            catch (AuthenticationException e)
            {
                tcpClient.Close();
                throw new LitleOnlineException("Error establishing a network connection - SSL Authencation failed", e);
            }

            if ("true".Equals(config["printxml"]))
            {
                Console.WriteLine("Using XML File: " + xmlRequestFilePath);
            }

            var stringBuilder = _cache[xmlRequestFilePath];
            var buffer = Encoding.UTF8.GetBytes(stringBuilder.ToString());
            sslStream.Write(buffer);
            sslStream.Flush();

            var batchName = Path.GetFileName(xmlRequestFilePath);
            if ("true".Equals(config["printxml"]))
            {
                Console.WriteLine("Writing to XML File: " + xmlResponseDestinationDirectory + batchName);
            }

            var byteBuffer = new byte[2048];
            var messageData = new StringBuilder();
            var bytes = -1;
            do
            {
                // Read the client's test message.
                bytes = sslStream.Read(byteBuffer, 0, byteBuffer.Length);

                // Use Decoder class to convert from bytes to UTF8
                // in case a character spans two buffers.
                var decoder = Encoding.UTF8.GetDecoder();
                var chars = new char[decoder.GetCharCount(byteBuffer, 0, bytes)];
                decoder.GetChars(byteBuffer, 0, bytes, chars, 0);
                messageData.Append(chars);
            } while (bytes != 0);

            _cache.Add(xmlResponseDestinationDirectory + batchName, messageData);

            tcpClient.Close();
            sslStream.Close();

            return xmlResponseDestinationDirectory + batchName;
        }
예제 #25
0
        private static void ConnectAndSend()
        {
            TcpClient client = new TcpClient("localhost", port);

            SslStream sslStream = new SslStream(
                client.GetStream(),
                false,
                new RemoteCertificateValidationCallback(ValidateServerCertificate),
                null
                );
            // The server name must match the name on the server certificate.
            sslStream.AuthenticateAsClient("TempCert");

            Debug.WriteLine("Client sending: hello");
            sslStream.Write(Encoding.UTF8.GetBytes("hello                      \n"));
            sslStream.Flush();

            Debug.WriteLine("Client sending: send");
            sslStream.Write(Encoding.UTF8.GetBytes("send\n"));
            sslStream.Flush();

            String line = ReadMessage(sslStream);
            Debug.WriteLine("Client got: " + line);
            client.Close();
            Assert.IsTrue(!String.IsNullOrEmpty(line));
        }
예제 #26
0
        public void Connect()
        {
            string host = mUrl.DnsSafeHost;
            string path = mUrl.PathAndQuery;
            string origin = "http://" + host;
            mSslStream = CreateSocket(mUrl);
            StringBuilder extraHeaders = new StringBuilder();
            if (mHeaders != null)
            {
                foreach (KeyValuePair<string, string> header in mHeaders)
                    extraHeaders.Append(header.Key + ": " + header.Value + "\r\n");
            }
            string request = "GET " + path + " HTTP/1.1\r\n" +
                             "Upgrade: websocket\r\n" +
                             "Connection: Upgrade\r\n" +
                             "Host: " + host + "\r\n" +
                             "Sec-WebSocket-Version: 6\r\n" +
                             "Sec-WebSocket-Origin: https://" + host + "\r\n" +
                             "Sec-WebSocket-Extensions: deflate-stream\r\n" +
                             "Sec-WebSocket-Key: HSmrc0sMlYUkAGmm5OPpG2HaGWk=\r\n" + // note see: https://en.wikipedia.org/wiki/WebSocket on draft-ietf-hybi-thewebsocketprotocol-06 version of protocol for instructions on how to construct the key
                             extraHeaders.ToString() + "\r\n";
            byte[] sendBuffer = Encoding.UTF8.GetBytes(request);
            mSslStream.Write(sendBuffer, 0, sendBuffer.Length);
            mSslStream.Flush();
            string reply = ReadMessage(mSslStream);
            if (!reply.Equals("HTTP/1.1 101 Web Socket Protocol Handshake"))
                throw new IOException("Invalid handshake response");
            if (!reply.Equals("Upgrade: WebSocket"))
                throw new IOException("Invalid handshake response");
            if (!reply.Equals("Connection: Upgrade"))
                throw new IOException("Invalid handshake response");

            mHandshakeComplete = true;
        }
예제 #27
0
        SecureConnection EstablishNewConnection()
        {
            log.Write(EventType.OpeningNewConnection, "Opening a new connection");

            var remoteUri = serviceEndpoint.BaseUri;
            var certificateValidator = new ClientCertificateValidator(serviceEndpoint.RemoteThumbprint);
            var client = CreateTcpClient();
            client.ConnectWithTimeout(remoteUri, HalibutLimits.TcpClientConnectTimeout);
            log.Write(EventType.Diagnostic, "Connection established");

            var stream = client.GetStream();

            log.Write(EventType.Security, "Performing TLS handshake");
            var ssl = new SslStream(stream, false, certificateValidator.Validate, UserCertificateSelectionCallback);
            ssl.AuthenticateAsClient(remoteUri.Host, new X509Certificate2Collection(clientCertificate), SslProtocols.Tls | SslProtocols.Tls11 | SslProtocols.Tls12, false);
            ssl.Write(MxLine, 0, MxLine.Length);
            ssl.Flush();

            log.Write(EventType.Security, "Secure connection established. Server at {0} identified by thumbprint: {1}, using protocol {2}", client.Client.RemoteEndPoint, serviceEndpoint.RemoteThumbprint, ssl.SslProtocol.ToString());

            var protocol = new MessageExchangeProtocol(ssl, log);
            return new SecureConnection(client, ssl, protocol);
        }
 public static void Send(string s, SslStream sslStream)
 {
     byte[] b = Encoding.ASCII.GetBytes(s);
     sslStream.Write(b, 0, b.Length);
     sslStream.Flush();
 }
예제 #29
0
        static byte[] InternalSslSocketHttp(IPEndPoint endpoint,
            X509CertificateCollection certificates,
            HttpArgs args,
            HttpMethod method)
        {
            TcpClient tcp = new TcpClient();
            try
            {
                tcp.Connect(endpoint);
                if (tcp.Connected)
                {
                    using (SslStream ssl = new SslStream(tcp.GetStream(),
                        false,
                        new RemoteCertificateValidationCallback(ValidateServerCertificate),
                        null))
                    {
                        ssl.AuthenticateAsClient("ServerName",
                            certificates,
                            SslProtocols.Tls,
                            false);
                        if (ssl.IsAuthenticated)
                        {
                            byte[] buff = ParseHttpArgs(method, args);  //生成协议包
                            ssl.Write(buff);
                            ssl.Flush();
                            return ParseSslResponse(endpoint, ssl, args, certificates);

                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            return null;
        }
예제 #30
0
        public static void SendPacket(Packet packet, SslStream stream)
        {
            try
            {
                ProtoFire reply = new ProtoFire(packet);
                byte[] result = reply.Encode();

                if (packet.msgType == MessageType.NOTIFICATION)
                {
                    LogNotification(packet);
                }
                else
                {
                    LogResponse(packet);
                }

                stream.Write(result, 0, result.Length);
                stream.Flush();
            }
            catch (Exception ex)
            {
                Log.Error(ex.ToString());
            }
        }
예제 #31
0
 private TestInfo TestBandwidth(TestInfo info)
 {
     const int m = 2;
     using (var socket = GetSocket(info, m))
     {
         try
         {
             if (socket.BeginConnect(info.Target, null, null).AsyncWaitHandle.WaitOne(Config.ConnTimeout * m) &&
                 socket.Connected)
             {
                 using (var nets = new NetworkStream(socket))
                 {
                     using (var ssls = new SslStream(nets, false, (a, b, c, d) => true))
                     {
                         ssls.AuthenticateAsClient(string.Empty);
                         if (ssls.IsAuthenticated)
                         {
                             var data = Encoding.UTF8.GetBytes("GET /p/gogo-tester/source/browse/1m.wiki?repo=wiki HTTP/1.1\r\nHost: code.google.com\r\nConnection: close\r\n\r\n");
                             var time = Watch.ElapsedMilliseconds;
                             ssls.Write(data, 0, data.Length);
                             ssls.Flush();
                             using (var sr = new StreamReader(ssls))
                             {
                                 sr.BaseStream.ReadTimeout = 5000;
                                 try
                                 {
                                     var buf = sr.ReadToEnd();
                                     info.Bandwidth =
                                         (buf.Length / (Watch.ElapsedMilliseconds - time)).ToString("D4") + " KB/s";
                                 }
                                 catch (Exception)
                                 {
                                     info.Bandwidth = "TimeOut!";
                                 }
                             }
                         }
                         else
                         {
                             info.Bandwidth = "SslInvalid";
                         }
                     }
                 }
             }
             else
             {
                 info.Bandwidth = "Timeout";
             }
         }
         catch (Exception ex)
         {
             info.Bandwidth = ex.Message;
         }
     }
     return info;
 }