SMBServer.cs 9.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258
  1. /* Copyright (C) 2014-2017 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
  2. *
  3. * You can redistribute this program and/or modify it under the terms of
  4. * the GNU Lesser Public License as published by the Free Software Foundation,
  5. * either version 3 of the License, or (at your option) any later version.
  6. */
  7. using System;
  8. using System.Collections.Generic;
  9. using System.Net;
  10. using System.Net.Sockets;
  11. using SMBLibrary.NetBios;
  12. using SMBLibrary.Services;
  13. using SMBLibrary.SMB1;
  14. using Utilities;
  15. namespace SMBLibrary.Server
  16. {
  17. public partial class SMBServer
  18. {
  19. public const int NetBiosOverTCPPort = 139;
  20. public const int DirectTCPPort = 445;
  21. public const string NTLanManagerDialect = "NT LM 0.12";
  22. public const bool EnableExtendedSecurity = true;
  23. private ShareCollection m_shares; // e.g. Shared folders
  24. private INTLMAuthenticationProvider m_users;
  25. private NamedPipeShare m_services; // Named pipes
  26. private IPAddress m_serverAddress;
  27. private SMBTransportType m_transport;
  28. private Socket m_listenerSocket;
  29. private bool m_listening;
  30. private Guid m_serverGuid;
  31. public event EventHandler<LogEntry> OnLogEntry;
  32. public SMBServer(ShareCollection shares, INTLMAuthenticationProvider users, IPAddress serverAddress, SMBTransportType transport)
  33. {
  34. m_shares = shares;
  35. m_users = users;
  36. m_serverAddress = serverAddress;
  37. m_serverGuid = Guid.NewGuid();
  38. m_transport = transport;
  39. m_services = new NamedPipeShare(shares.ListShares());
  40. }
  41. public void Start()
  42. {
  43. if (!m_listening)
  44. {
  45. m_listening = true;
  46. m_listenerSocket = new Socket(m_serverAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
  47. int port = (m_transport == SMBTransportType.DirectTCPTransport ? DirectTCPPort : NetBiosOverTCPPort);
  48. m_listenerSocket.Bind(new IPEndPoint(m_serverAddress, port));
  49. m_listenerSocket.Listen((int)SocketOptionName.MaxConnections);
  50. m_listenerSocket.BeginAccept(ConnectRequestCallback, m_listenerSocket);
  51. }
  52. }
  53. public void Stop()
  54. {
  55. m_listening = false;
  56. SocketUtils.ReleaseSocket(m_listenerSocket);
  57. }
  58. // This method Accepts new connections
  59. private void ConnectRequestCallback(IAsyncResult ar)
  60. {
  61. Socket listenerSocket = (Socket)ar.AsyncState;
  62. Socket clientSocket;
  63. try
  64. {
  65. clientSocket = listenerSocket.EndAccept(ar);
  66. }
  67. catch (ObjectDisposedException)
  68. {
  69. return;
  70. }
  71. catch (SocketException ex)
  72. {
  73. const int WSAECONNRESET = 10054;
  74. // Client may have closed the connection before we start to process the connection request.
  75. // When we get this error, we have to continue to accept other requests.
  76. // See http://stackoverflow.com/questions/7704417/socket-endaccept-error-10054
  77. if (ex.ErrorCode == WSAECONNRESET)
  78. {
  79. m_listenerSocket.BeginAccept(ConnectRequestCallback, m_listenerSocket);
  80. }
  81. Log(Severity.Debug, "Connection request error {0}", ex.ErrorCode);
  82. return;
  83. }
  84. SMB1ConnectionState state = new SMB1ConnectionState(new ConnectionState(Log));
  85. // Disable the Nagle Algorithm for this tcp socket:
  86. clientSocket.NoDelay = true;
  87. state.ClientSocket = clientSocket;
  88. state.ClientEndPoint = clientSocket.RemoteEndPoint as IPEndPoint;
  89. state.LogToServer(Severity.Verbose, "New connection request");
  90. try
  91. {
  92. // Direct TCP transport packet is actually an NBT Session Message Packet,
  93. // So in either case (NetBios over TCP or Direct TCP Transport) we will receive an NBT packet.
  94. clientSocket.BeginReceive(state.ReceiveBuffer.Buffer, state.ReceiveBuffer.WriteOffset, state.ReceiveBuffer.AvailableLength, 0, ReceiveCallback, state);
  95. }
  96. catch (ObjectDisposedException)
  97. {
  98. }
  99. catch (SocketException)
  100. {
  101. }
  102. m_listenerSocket.BeginAccept(ConnectRequestCallback, m_listenerSocket);
  103. }
  104. private void ReceiveCallback(IAsyncResult result)
  105. {
  106. SMB1ConnectionState state = (SMB1ConnectionState)result.AsyncState;
  107. Socket clientSocket = state.ClientSocket;
  108. if (!m_listening)
  109. {
  110. clientSocket.Close();
  111. return;
  112. }
  113. int numberOfBytesReceived;
  114. try
  115. {
  116. numberOfBytesReceived = clientSocket.EndReceive(result);
  117. }
  118. catch (ObjectDisposedException)
  119. {
  120. return;
  121. }
  122. catch (SocketException)
  123. {
  124. return;
  125. }
  126. if (numberOfBytesReceived == 0)
  127. {
  128. // The other side has closed the connection
  129. state.LogToServer(Severity.Debug, "The other side closed the connection");
  130. clientSocket.Close();
  131. return;
  132. }
  133. NBTConnectionReceiveBuffer receiveBuffer = state.ReceiveBuffer;
  134. receiveBuffer.SetNumberOfBytesReceived(numberOfBytesReceived);
  135. ProcessConnectionBuffer(state);
  136. if (clientSocket.Connected)
  137. {
  138. try
  139. {
  140. clientSocket.BeginReceive(state.ReceiveBuffer.Buffer, state.ReceiveBuffer.WriteOffset, state.ReceiveBuffer.AvailableLength, 0, ReceiveCallback, state);
  141. }
  142. catch (ObjectDisposedException)
  143. {
  144. }
  145. catch (SocketException)
  146. {
  147. }
  148. }
  149. }
  150. public void ProcessConnectionBuffer(SMB1ConnectionState state)
  151. {
  152. Socket clientSocket = state.ClientSocket;
  153. NBTConnectionReceiveBuffer receiveBuffer = state.ReceiveBuffer;
  154. while (receiveBuffer.HasCompletePacket())
  155. {
  156. SessionPacket packet = null;
  157. try
  158. {
  159. packet = receiveBuffer.DequeuePacket();
  160. }
  161. catch (Exception)
  162. {
  163. state.ClientSocket.Close();
  164. }
  165. if (packet != null)
  166. {
  167. ProcessPacket(packet, state);
  168. }
  169. }
  170. }
  171. public void ProcessPacket(SessionPacket packet, SMB1ConnectionState state)
  172. {
  173. if (packet is SessionRequestPacket && m_transport == SMBTransportType.NetBiosOverTCP)
  174. {
  175. PositiveSessionResponsePacket response = new PositiveSessionResponsePacket();
  176. TrySendPacket(state, response);
  177. }
  178. else if (packet is SessionKeepAlivePacket && m_transport == SMBTransportType.NetBiosOverTCP)
  179. {
  180. // [RFC 1001] NetBIOS session keep alives do not require a response from the NetBIOS peer
  181. }
  182. else if (packet is SessionMessagePacket)
  183. {
  184. SMB1Message message = null;
  185. try
  186. {
  187. message = SMB1Message.GetSMB1Message(packet.Trailer);
  188. }
  189. catch (Exception ex)
  190. {
  191. state.LogToServer(Severity.Warning, "Invalid SMB1 message: " + ex.Message);
  192. state.ClientSocket.Close();
  193. return;
  194. }
  195. state.LogToServer(Severity.Verbose, "Message Received: {0} Commands, First Command: {1}, Packet length: {2}", message.Commands.Count, message.Commands[0].CommandName.ToString(), packet.Length);
  196. ProcessSMB1Message(message, state);
  197. }
  198. else
  199. {
  200. state.LogToServer(Severity.Warning, "Invalid NetBIOS packet");
  201. state.ClientSocket.Close();
  202. return;
  203. }
  204. }
  205. public static void TrySendPacket(SMB1ConnectionState state, SessionPacket response)
  206. {
  207. Socket clientSocket = state.ClientSocket;
  208. try
  209. {
  210. clientSocket.Send(response.GetBytes());
  211. }
  212. catch (SocketException)
  213. {
  214. }
  215. catch (ObjectDisposedException)
  216. {
  217. }
  218. }
  219. public void Log(Severity severity, string message)
  220. {
  221. // To be thread-safe we must capture the delegate reference first
  222. EventHandler<LogEntry> handler = OnLogEntry;
  223. if (handler != null)
  224. {
  225. handler(this, new LogEntry(DateTime.Now, severity, "SMB Server", message));
  226. }
  227. }
  228. public void Log(Severity severity, string message, params object[] args)
  229. {
  230. Log(severity, String.Format(message, args));
  231. }
  232. }
  233. }