public void Start() { // create a new ManualResetEvent. This will be used to make the main application // thread wait until the full server reply has been received. m_ResetEvent = new ManualResetEvent(false); // initialize the security options SecurityOptions options = new SecurityOptions( SecureProtocol.Ssl3 | SecureProtocol.Tls1, // use SSL3 or TLS1 null, // do not use client authentication ConnectionEnd.Client, // this is the client side CredentialVerification.None, // do not check the certificate -- this should not be used in a real-life application :-) null, // not used with automatic certificate verification "www.microsoft.com", // this is the common name of the Microsoft web server SecurityFlags.Default, // use the default security flags SslAlgorithms.SECURE_CIPHERS, // only use secure ciphers null); // do not process certificate requests. try { // create the securesocket with the specified security options m_Socket = new SecureSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp, options); // resolve www.microsoft.com IPEndPoint endpoint = new IPEndPoint(Dns.GetHostEntry("www.microsoft.com").AddressList[0], 443); // start connecting to www.microsoft.com m_Socket.BeginConnect(endpoint, new AsyncCallback(this.OnConnect), null); // wait until the entire web page has been received m_ResetEvent.WaitOne(); // close the SecureSocket m_Socket.Close(); } catch { OnError("Could not connect to the website"); } }
/// <summary> /// Closes the stream and optionally closes the underlying <see cref="SecureSocket"/>. /// </summary> /// <remarks> /// The Close method frees resources used by the SecureNetworkStream instance and, if the SecureNetworkStream owns the underlying socket, closes the underlying socket. /// </remarks> public override void Close() { if (m_OwnsSocket) { try { Socket.Shutdown(SocketShutdown.Both); } catch { } finally { Socket.Close(); } } }
private void DownloadFile(Url url, int choice) { SecurityOptions options = new SecurityOptions(SecureProtocol.None);; m_Socket = new SecureSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp, options); // connect to the FTP server using a normal TCP connection m_Socket.Connect(new IPEndPoint(Dns.GetHostEntry(url.Host).AddressList[0], url.Port)); // wait for the server hello ReceiveReply(); // if the user selected to use the AUTH command.. if (choice == 2) { // ..send the command to the server and start the SSL handshake DoAuthCommand(url.Host); } // log on and quit if (!SendCommand("USER " + url.Username)) return; if (!SendCommand("PASS " + url.Password)) return; if (!SendCommand("QUIT")) return; // clean up m_Socket.Shutdown(SocketShutdown.Both); m_Socket.Close(); }
private void HandleAcceptedClient(SecureSocket incomingClient, ALPNExtensionMonitor monitor) { bool backToHttp11 = false; string selectedProtocol = Protocols.Http1; if (_useHandshake) { try { if (_options.Protocol != SecureProtocol.None) { incomingClient.MakeSecureHandshake(_options); selectedProtocol = incomingClient.SelectedProtocol; } } catch (SecureHandshakeException ex) { switch (ex.Reason) { case SecureHandshakeFailureReason.HandshakeInternalError: backToHttp11 = true; break; case SecureHandshakeFailureReason.HandshakeTimeout: incomingClient.Close(); Http2Logger.LogError("Handshake timeout. Client was disconnected."); return; default: incomingClient.Close(); Http2Logger.LogError("Unknown error occurred during secure handshake"); return; } } catch (Exception e) { Http2Logger.LogError("Exception occurred. Closing client's socket. " + e.Message); incomingClient.Close(); return; } } var clientStream = new DuplexStream(incomingClient, true); var transportInfo = GetTransportInfo(incomingClient); monitor.Dispose(); try { HandleRequest(clientStream, selectedProtocol, transportInfo, backToHttp11); } catch (Exception e) { Http2Logger.LogError("Exception occurred. Closing client's socket. " + e.Message); incomingClient.Close(); } }
//sendraw SSL public string sendraw (string ipRaw, string portRaw, string payloadRaw, int size, int TimeOut, int retry, bool useSSL) { IPHostEntry IPHost = Dns.Resolve(ipRaw); string []aliases = IPHost.Aliases; IPAddress[] addr = IPHost.AddressList; IPEndPoint iep ; SecureProtocol sp; sp=SecureProtocol.Ssl3; SecureSocket s=null; SecurityOptions options = new SecurityOptions(sp); options.Certificate = null; options.Protocol=SecureProtocol.Ssl3; options.Entity = ConnectionEnd.Client; options.CommonName = ipRaw; options.VerificationType = CredentialVerification.None; options.Flags = SecurityFlags.IgnoreMaxProtocol; options.AllowedAlgorithms = SslAlgorithms.ALL; while (retry>0){ try { s = new SecureSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp, options); s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.SendTimeout, 4000); s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, 4000); iep = new IPEndPoint(addr[0],Convert.ToInt32(portRaw)); s.Connect(iep); ASCIIEncoding asen= new ASCIIEncoding(); byte[] ba=asen.GetBytes(payloadRaw); s.Send(ba,ba.Length,System.Net.Sockets.SocketFlags.None); byte[] bb=new byte[size]; int k=1; string response=""; while (k>0){ k=s.Receive(bb,size,System.Net.Sockets.SocketFlags.None); response+=Encoding.Default.GetString(bb,0,k); } s.Close(); GC.Collect(); GC.WaitForPendingFinalizers(); return response; } catch(Exception ex) { retry--; Thread.Sleep(1000); } } return "Timeout or retry count exceeded"; }
public static void Http11SendResponse(SecureSocket socket) { string[] headers = GetHttp11Headers(socket); string filename = GetFileName(headers); if (headers.Length == 0) { Http2Logger.LogError("Request headers empty!"); } string path = Path.GetFullPath(AssemblyPath + @"\root" + filename); string contentType = ContentTypes.GetTypeFromFileName(filename); if (!File.Exists(path)) { Http2Logger.LogError("File " + filename + " not found"); SendResponse(socket, new byte[0], StatusCode.Code404NotFound, contentType); socket.Close(); return; } try { using (var sr = new StreamReader(path)) { string file = sr.ReadToEnd(); var fileBytes = Encoding.UTF8.GetBytes(file); int sent = SendResponse(socket, fileBytes, StatusCode.Code200Ok, contentType); Http2Logger.LogDebug(string.Format("Sent: {0} bytes", sent)); Http2Logger.LogInfo("File sent: " + filename); socket.Close(); if (OnSocketClosed != null) { OnSocketClosed(null, new SocketCloseEventArgs()); } } } catch (Exception ex) { var msgBytes = Encoding.UTF8.GetBytes(ex.Message); SendResponse(socket, msgBytes, StatusCode.Code500InternalServerError, contentType); Http2Logger.LogError(ex.Message); } }
public static void Http11DownloadResource(SecureSocket socket, Uri requestUri) { byte[] headersBytes = Encoding.UTF8.GetBytes(ConstructHeaders(requestUri)); int sent = socket.Send(headersBytes); string[] responseHeaders = ReadHeaders(socket); var buffer = new byte[128 * 1024]; //128 kb using (var stream = new MemoryStream(128 * 1024)) { while (true) { int received = socket.Receive(buffer, 0, buffer.Length, SocketFlags.None); if (received == 0) break; stream.Write(buffer, 0, received); } var fileBuffer = new byte[stream.Position]; Buffer.BlockCopy(stream.GetBuffer(), 0, fileBuffer, 0, fileBuffer.Length); int fileNameIndex = requestUri.AbsolutePath.LastIndexOf("/"); string fileName = requestUri.AbsolutePath.Substring(fileNameIndex); string directory = AssemblyPath; SaveFile(directory, fileName, fileBuffer); if (OnDownloadSuccessful != null) { OnDownloadSuccessful(null, new Http11ResourceDownloadedEventArgs(fileBuffer.Length, fileName)); } socket.Close(); if (OnSocketClosed != null) { OnSocketClosed(null, new SocketCloseEventArgs()); } } }
private void HandleAcceptedClient(SecureSocket incomingClient) { bool backToHttp11 = false; string alpnSelectedProtocol = "http/2.0"; var handshakeEnvironment = MakeHandshakeEnvironment(incomingClient); IDictionary<string, object> handshakeResult = null; //Think out smarter way to get handshake result. //DO NOT change Middleware function. If you will do so, server will not even launch. (It's owin's problem) Func<Task> handshakeAction = () => { var handshakeTask = new Task(() => { handshakeResult = HandshakeManager.GetHandshakeAction(handshakeEnvironment).Invoke(); }); return handshakeTask; }; if (_useHandshake) { var environment = new Dictionary<string, object> { //Sets the handshake action depends on port. {"HandshakeAction", handshakeAction}, }; try { var handshakeTask = _next(environment); handshakeTask.Start(); if (!handshakeTask.Wait(6000)) { incomingClient.Close(); Console.WriteLine("Handshake timeout. Connection dropped."); return; } alpnSelectedProtocol = incomingClient.SelectedProtocol; } catch (Http2HandshakeFailed ex) { if (ex.Reason == HandshakeFailureReason.InternalError) { backToHttp11 = true; } else { incomingClient.Close(); Console.WriteLine("Handshake timeout. Client was disconnected."); return; } } catch (Exception e) { Console.WriteLine("Exception occured. Closing client's socket. " + e.Message); incomingClient.Close(); return; } } try { HandleRequest(incomingClient, alpnSelectedProtocol, backToHttp11, handshakeResult); } catch (Exception e) { Console.WriteLine("Exception occured. Closing client's socket. " + e.Message); incomingClient.Close(); } }
private void HandleRequest(SecureSocket incomingClient, string alpnSelectedProtocol, bool backToHttp11, IDictionary<string, object> handshakeResult) { if (backToHttp11 || alpnSelectedProtocol == "http/1.1") { Console.WriteLine("Sending with http11"); Http11Manager.Http11SendResponse(incomingClient); return; } if (GetSessionHeaderAndVerifyIt(incomingClient)) { OpenHttp2Session(incomingClient, handshakeResult); } else { Console.WriteLine("Client has wrong session header. It was disconnected"); incomingClient.Close(); } }
private void HandleRequest(SecureSocket incomingClient, string alpnSelectedProtocol, bool backToHttp11, IDictionary<string, object> environment) { if (backToHttp11 || alpnSelectedProtocol == Protocols.Http1) { Http2Logger.LogDebug("Sending with http11"); Http11Manager.Http11SendResponse(incomingClient); return; } if (GetSessionHeaderAndVerifyIt(incomingClient)) { OpenHttp2Session(incomingClient, environment); } else { Http2Logger.LogError("Client has wrong session header. It was disconnected"); incomingClient.Close(); } }
public string sendraw(string ipRaw, string portRaw, string payloadRaw, int size, int TimeOut, bool useSSL) { int retry = (int)updownRetryTCP.Value; IPHostEntry IPHost = Dns.GetHostEntry(ipRaw); //IPHostEntry IPHost = Dns.Resolve(ipRaw); string[] aliases = IPHost.Aliases; IPAddress[] addr = IPHost.AddressList; IPEndPoint iep; SecureProtocol sp; sp = SecureProtocol.Ssl3; SecureSocket s = null; SecurityOptions options = new SecurityOptions(sp); options.Certificate = null; options.Protocol = SecureProtocol.Ssl3; options.Entity = ConnectionEnd.Client; options.CommonName = ipRaw; options.VerificationType = CredentialVerification.None; options.Flags = SecurityFlags.IgnoreMaxProtocol; options.AllowedAlgorithms = SslAlgorithms.ALL; while (retry > 0) { try { s = new SecureSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp, options); s.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, 4000); s.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, 4000); iep = new IPEndPoint(addr[0], Convert.ToInt32(portRaw)); s.Connect(iep); ASCIIEncoding asen = new ASCIIEncoding(); byte[] ba = asen.GetBytes(payloadRaw); s.Send(ba, ba.Length, System.Net.Sockets.SocketFlags.None); byte[] bb = new byte[size]; string response = ""; int k = 1; while (k > 0) { k = s.Receive(bb, size, System.Net.Sockets.SocketFlags.None); for (int i = 0; i < k; i++) { response += Convert.ToChar(bb[i]); } } s.Close(); GC.Collect(); GC.WaitForPendingFinalizers(); return response; } catch { retry--; lblStatus.Text = "Network problem - retrying\r\n"; lblNiktoAI.Text = "Network problem - retrying\r\n"; Thread.Sleep(1000); } } return "Retry count (" + updownRetryTCP.Value.ToString() + ") exceeded"; }
private void HandleAcceptedClient(SecureSocket incomingClient) { bool backToHttp11 = false; string selectedProtocol = Protocols.Http2; var handshakeEnv = MakeHandshakeEnvironment(incomingClient); var environmentCopy = new Dictionary<string, object>(_environment); if (_useHandshake) { try { //_next(environmentCopy); bool wasHandshakeFinished = true; var handshakeTask = Task.Factory.StartNew(HandshakeManager.GetHandshakeAction(handshakeEnv)); if (!handshakeTask.Wait(6000)) { wasHandshakeFinished = false; } if (!wasHandshakeFinished) { throw new Http2HandshakeFailed(HandshakeFailureReason.Timeout); } environmentCopy.Add("HandshakeResult", handshakeTask.Result); selectedProtocol = incomingClient.SelectedProtocol; } catch (Http2HandshakeFailed ex) { if (ex.Reason == HandshakeFailureReason.InternalError) { backToHttp11 = true; } else { incomingClient.Close(); Http2Logger.LogError("Handshake timeout. Client was disconnected."); return; } } catch (Exception e) { Http2Logger.LogError("Exception occurred. Closing client's socket. " + e.Message); incomingClient.Close(); return; } } try { HandleRequest(incomingClient, selectedProtocol, backToHttp11, environmentCopy); } catch (Exception e) { Http2Logger.LogError("Exception occurred. Closing client's socket. " + e.Message); incomingClient.Close(); } }
private SecureSocket CreateSocketByUri(Uri uri) { if (!String.Equals(uri.Scheme, "http", StringComparison.OrdinalIgnoreCase) && !String.Equals(uri.Scheme, "https", StringComparison.OrdinalIgnoreCase)) throw new InvalidOperationException("Unrecognized scheme: " + uri.Scheme); SecurityOptions options; var extensions = new ExtensionType[] { ExtensionType.Renegotiation, ExtensionType.ALPN }; if (!String.Equals(uri.Scheme, "https", StringComparison.OrdinalIgnoreCase)) { options = new SecurityOptions(SecureProtocol.None, null, ConnectionEnd.Client); } else { options = new SecurityOptions(SecureProtocol.Tls1, extensions, ConnectionEnd.Client); } options.Entity = ConnectionEnd.Client; options.CommonName = uri.Host; options.VerificationType = CredentialVerification.None; options.Certificate = Org.Mentalis.Security.Certificates.Certificate.CreateFromCerFile(@"certificate.pfx"); options.Flags = SecurityFlags.Default; options.AllowedAlgorithms = SslAlgorithms.RSA_AES_128_SHA | SslAlgorithms.NULL_COMPRESSION; var s = new SecureSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp, options); s.OnClose += SocketOnClose; try { if (String.Equals(uri.Scheme, "https", StringComparison.OrdinalIgnoreCase)) { s.OnHandshakeFinish += this.HandshakeFinishedHandler; } s.Connect(new Net.DnsEndPoint(uri.Host, uri.Port)); if (String.Equals(uri.Scheme, "https", StringComparison.OrdinalIgnoreCase)) { this.handshakeFinishedEventRaised.WaitOne(60000); if (!s.IsNegotiationCompleted) { throw new Exception("Handshake failed"); } if (!s.Connected) { throw new Exception("Connection was lost!"); } s.OnHandshakeFinish -= this.HandshakeFinishedHandler; this.ApplyProtocolSelectionResults(options.GetSelectedProtocol()); } } catch (Exception ex) { s.Close(); // Emitting protocol error. It will emit session OnError if (OnError != null) this.OnError(this, new ProtocolErrorEventArgs(ex)); throw; } return s; }
public static void Http11SendResponse(SecureSocket socket) { string[] headers = GetHttp11Headers(socket); string filename = GetFileName(headers); //No headers where received if (headers.Length == 0) { socket.Close(); } string path = Path.GetFullPath(AssemblyPath + @"\root" + filename); if (!File.Exists(path)) { Console.WriteLine("File " + filename + " not found"); return; } try { using (var sr = new StreamReader(path)) { string file = sr.ReadToEnd(); SendHeaders(socket, null, file.Length); var fileBytes = Encoding.UTF8.GetBytes(file); int sent = socket.Send(fileBytes); Console.WriteLine("Sent: " + sent); Console.WriteLine("File sent: " + filename); socket.Close(); if (OnSocketClosed != null) { OnSocketClosed(null, new SocketCloseEventArgs()); } } } catch (Exception ex) { var msgBytes = Encoding.UTF8.GetBytes(ex.Message); socket.Send(msgBytes); Console.WriteLine(ex.Message); } }
public void Start() { try { // ask the user for SMTP server, port and the type of connection Console.Write("Host to connect to: "); string server = Console.ReadLine().Trim(); Console.Write("Port: "); string port = Console.ReadLine().Trim(); Console.Write("Connection type [0 = normal connection, 1 = direct TLS connection, 2 = indirect TLS connection (using STARTTLS command)]: "); string type = Console.ReadLine().Trim(); if (Array.IndexOf(new string[]{"0", "1", "2"}, type) == -1) { Console.WriteLine("Invalid connection type."); return; } Console.WriteLine("Please enter the email address you wish to send an email to:"); string address = Console.ReadLine().Trim(); // create a new SecurityOptions instance SecurityOptions options = new SecurityOptions(SecureProtocol.None); // allow only secure ciphers to be used. Currently, the seure ciphers are: // the AES algorithm [128 or 256 bit keys], the RC4 algorithm [128 bit keys] // or TipleDES [168 bit keys] options.AllowedAlgorithms = SslAlgorithms.SECURE_CIPHERS; // the SecureSocket should be a client socket options.Entity = ConnectionEnd.Client; // we will use manual verification of the server certificate options.VerificationType = CredentialVerification.Manual; // when the server certificate is receives, the SecureSocket should call // the OnVerify method options.Verifier = new CertVerifyEventHandler(OnVerify); // use the default flags options.Flags = SecurityFlags.Default; // the common name is the domain name or IP address of the server options.CommonName = server; // if the user chose a direct TLS connection, set the protocol to TLS1 if (type == "1") { options.Protocol = SecureProtocol.Tls1; } // create the new secure socket Connection = new SecureSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp, options); // connect to the SMTP server Connection.Connect(new IPEndPoint(Dns.GetHostEntry(server).AddressList[0], int.Parse(port))); // wait for the server hello message if (!IsReplyOK(Receive())) { Console.WriteLine("Server disallowed connection."); return; } // if the user selected an indirect TLS connection, issue // a EHLO command. Otherwise, stick to the standard HELO command. if (type == "2") // STARTTLS connection Send("EHLO SmtpClient.Mentalis.org\r\n"); else Send("HELO SmtpClient.Mentalis.org\r\n"); if (!IsReplyOK(Receive())) { Console.WriteLine("HELLO failed."); return; } // if the user selected an indirect TLS connection, issue // the STARTTLS command if (type == "2") { // send the STARTTLS command to the server Send("STARTTLS\r\n"); // make sure the server supports the STARTTLS command if (!IsReplyOK(Receive())) { Console.WriteLine("STARTTLS failed."); return; } // change the protocol from SecureProtocol.None // to SecureProtocol.Tls1 options.Protocol = SecureProtocol.Tls1; // start the TLS handshake Connection.ChangeSecurityProtocol(options); // after this line, we're using an encrypted TLS connection } // from here on, act as if the SecureSocket is a normal Socket Send("MAIL FROM: [email protected]\r\n"); // [email protected] is not a real email address if (!IsReplyOK(Receive())) { Console.WriteLine("MAIL FROM failed."); return; } Send("RCPT TO:" + address + "\r\n"); if (!IsReplyOK(Receive())) { Console.WriteLine("RCPT TO failed."); return; } Send("DATA\r\n"); if (!IsReplyOK(Receive())) { Console.WriteLine("DATA failed."); return; } Send(TestMail.Replace("#ADDRESS#", address) + "\r\n.\r\n"); if (!IsReplyOK(Receive())) { Console.WriteLine("Sending of e-mail failed."); return; } Send("QUIT\r\n"); if (!IsReplyOK(Receive())) { Console.WriteLine("QUIT failed."); } Connection.Shutdown(SocketShutdown.Both); } catch (Exception e) { Console.WriteLine("An error occurred [" + e.Message + "]"); Console.WriteLine(e); } finally { if (Connection != null) { Connection.Close(); } } }
/// <summary> /// Download a file using the synchronous Socket methods. /// </summary> /// <param name="url">The URL to download. /// </param> /// <param name="sp">The protocol to use.</param> protected void DownloadFile(Url url, SecureProtocol sp) { string request = GetHttpRequest(url); // holds the HTTP request for the given URL SecureSocket s; try { // First we create a new SecurityOptions instance // SecurityOptions objects hold information about the security // protocols the SecureSocket should use and how the SecureSocket // should react in certain situations. SecurityOptions options = new SecurityOptions(sp); // The Certificate field holds a certificate associated with // a client [you, for instance]. Because client certificates // are not often used for HTTP over SSL or TLS, we'll simply // set this field to a null reference. options.Certificate = null; // The Entity specifies whether the SecureSocket should act // as a client socket or as a server socket. In this case, // it should act as a client socket. options.Entity = ConnectionEnd.Client; // The CommonName field specifies the name of the remote // party we're connecting to. This is usually the domain name // of the remote host. options.CommonName = url.Host; // The VerificationType field specifies how we intend to verify // the certificate. In this case, we tell the SecureSocket that // we will manually verify the certificate. Look in the documentation // for other options. options.VerificationType = CredentialVerification.Manual; // When specifying the CredentialVerification.Manual option, we // must also specify a CertVerifyEventHandler delegate that will // be called when the SecureSocket receives the remote certificate. // The Verifier field holds this delegate. If no manual verification // is done, this field can be set to a null reference. options.Verifier = new CertVerifyEventHandler(OnVerify); // The Flags field specifies which flags should be used for the // connection. In this case, we will simply use the default behavior. options.Flags = SecurityFlags.Default; // Allow only secure ciphers to be used. If the server only supports // weak encryption, the connections will be shut down. options.AllowedAlgorithms = SslAlgorithms.SECURE_CIPHERS; // create a new SecureSocket instance and initialize it with // the security options we specified above. s = new SecureSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp, options); // connect to the remote host s.Connect(new IPEndPoint(Dns.GetHostEntry(url.Host).AddressList[0], url.Port)); } catch (Exception e) { Console.WriteLine("Exception occurred while connecting: " + e.ToString()); return; } // send the HTTP request to the remote host Console.Write("HTTP Query string:\r\n------------------\r\n" + request); try { byte[] reqBytes = Encoding.ASCII.GetBytes(request); int sent = s.Send(reqBytes, 0, reqBytes.Length, SocketFlags.None); while(sent != reqBytes.Length) { sent += s.Send(reqBytes, sent, reqBytes.Length - sent, SocketFlags.None); } } catch (Exception e) { Console.WriteLine("Exception occurred while sending: " + e.ToString()); return; } // receive the reply Console.WriteLine("HTTP Server reply:\r\n------------------"); try { byte[] buffer = new byte[4096]; int ret = s.Receive(buffer); while(ret != 0) { Console.Write(Encoding.ASCII.GetString(buffer, 0, ret)); ret = s.Receive(buffer); } } catch (Exception e) { Console.WriteLine("Exception occurred while receiving: " + e.ToString()); return; } try { s.Shutdown(SocketShutdown.Both); // shut down the TCP connection } catch (Exception e) { Console.WriteLine("Exception occurred while shutting the connection down: " + e.ToString()); return; } s.Close(); }