SMBServer.cs 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336
  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 SMBLibrary.SMB2;
  15. using Utilities;
  16. namespace SMBLibrary.Server
  17. {
  18. public partial class SMBServer
  19. {
  20. public const int NetBiosOverTCPPort = 139;
  21. public const int DirectTCPPort = 445;
  22. public const string NTLanManagerDialect = "NT LM 0.12";
  23. public const bool EnableExtendedSecurity = true;
  24. private ShareCollection m_shares; // e.g. Shared folders
  25. private INTLMAuthenticationProvider m_users;
  26. private NamedPipeShare m_services; // Named pipes
  27. private IPAddress m_serverAddress;
  28. private SMBTransportType m_transport;
  29. private bool m_enableSMB1;
  30. private bool m_enableSMB2;
  31. private Socket m_listenerSocket;
  32. private bool m_listening;
  33. private Guid m_serverGuid;
  34. public event EventHandler<LogEntry> OnLogEntry;
  35. public SMBServer(ShareCollection shares, INTLMAuthenticationProvider users, IPAddress serverAddress, SMBTransportType transport) : this(shares, users, serverAddress, transport, true, true)
  36. {
  37. }
  38. public SMBServer(ShareCollection shares, INTLMAuthenticationProvider users, IPAddress serverAddress, SMBTransportType transport, bool enableSMB1, bool enableSMB2)
  39. {
  40. m_shares = shares;
  41. m_users = users;
  42. m_serverAddress = serverAddress;
  43. m_serverGuid = Guid.NewGuid();
  44. m_transport = transport;
  45. m_enableSMB1 = enableSMB1;
  46. m_enableSMB2 = enableSMB2;
  47. m_services = new NamedPipeShare(shares.ListShares());
  48. }
  49. public void Start()
  50. {
  51. if (!m_listening)
  52. {
  53. m_listening = true;
  54. m_listenerSocket = new Socket(m_serverAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
  55. int port = (m_transport == SMBTransportType.DirectTCPTransport ? DirectTCPPort : NetBiosOverTCPPort);
  56. m_listenerSocket.Bind(new IPEndPoint(m_serverAddress, port));
  57. m_listenerSocket.Listen((int)SocketOptionName.MaxConnections);
  58. m_listenerSocket.BeginAccept(ConnectRequestCallback, m_listenerSocket);
  59. }
  60. }
  61. public void Stop()
  62. {
  63. m_listening = false;
  64. SocketUtils.ReleaseSocket(m_listenerSocket);
  65. }
  66. // This method Accepts new connections
  67. private void ConnectRequestCallback(IAsyncResult ar)
  68. {
  69. Socket listenerSocket = (Socket)ar.AsyncState;
  70. Socket clientSocket;
  71. try
  72. {
  73. clientSocket = listenerSocket.EndAccept(ar);
  74. }
  75. catch (ObjectDisposedException)
  76. {
  77. return;
  78. }
  79. catch (SocketException ex)
  80. {
  81. const int WSAECONNRESET = 10054;
  82. // Client may have closed the connection before we start to process the connection request.
  83. // When we get this error, we have to continue to accept other requests.
  84. // See http://stackoverflow.com/questions/7704417/socket-endaccept-error-10054
  85. if (ex.ErrorCode == WSAECONNRESET)
  86. {
  87. m_listenerSocket.BeginAccept(ConnectRequestCallback, m_listenerSocket);
  88. }
  89. Log(Severity.Debug, "Connection request error {0}", ex.ErrorCode);
  90. return;
  91. }
  92. ConnectionState state = new ConnectionState(Log);
  93. // Disable the Nagle Algorithm for this tcp socket:
  94. clientSocket.NoDelay = true;
  95. state.ClientSocket = clientSocket;
  96. state.ClientEndPoint = clientSocket.RemoteEndPoint as IPEndPoint;
  97. state.LogToServer(Severity.Verbose, "New connection request");
  98. try
  99. {
  100. // Direct TCP transport packet is actually an NBT Session Message Packet,
  101. // So in either case (NetBios over TCP or Direct TCP Transport) we will receive an NBT packet.
  102. clientSocket.BeginReceive(state.ReceiveBuffer.Buffer, state.ReceiveBuffer.WriteOffset, state.ReceiveBuffer.AvailableLength, 0, ReceiveCallback, state);
  103. }
  104. catch (ObjectDisposedException)
  105. {
  106. }
  107. catch (SocketException)
  108. {
  109. }
  110. m_listenerSocket.BeginAccept(ConnectRequestCallback, m_listenerSocket);
  111. }
  112. private void ReceiveCallback(IAsyncResult result)
  113. {
  114. ConnectionState state = (ConnectionState)result.AsyncState;
  115. Socket clientSocket = state.ClientSocket;
  116. if (!m_listening)
  117. {
  118. clientSocket.Close();
  119. return;
  120. }
  121. int numberOfBytesReceived;
  122. try
  123. {
  124. numberOfBytesReceived = clientSocket.EndReceive(result);
  125. }
  126. catch (ObjectDisposedException)
  127. {
  128. return;
  129. }
  130. catch (SocketException)
  131. {
  132. return;
  133. }
  134. if (numberOfBytesReceived == 0)
  135. {
  136. // The other side has closed the connection
  137. state.LogToServer(Severity.Debug, "The other side closed the connection");
  138. clientSocket.Close();
  139. return;
  140. }
  141. NBTConnectionReceiveBuffer receiveBuffer = state.ReceiveBuffer;
  142. receiveBuffer.SetNumberOfBytesReceived(numberOfBytesReceived);
  143. ProcessConnectionBuffer(ref state);
  144. if (clientSocket.Connected)
  145. {
  146. try
  147. {
  148. clientSocket.BeginReceive(state.ReceiveBuffer.Buffer, state.ReceiveBuffer.WriteOffset, state.ReceiveBuffer.AvailableLength, 0, ReceiveCallback, state);
  149. }
  150. catch (ObjectDisposedException)
  151. {
  152. }
  153. catch (SocketException)
  154. {
  155. }
  156. }
  157. }
  158. public void ProcessConnectionBuffer(ref ConnectionState state)
  159. {
  160. Socket clientSocket = state.ClientSocket;
  161. NBTConnectionReceiveBuffer receiveBuffer = state.ReceiveBuffer;
  162. while (receiveBuffer.HasCompletePacket())
  163. {
  164. SessionPacket packet = null;
  165. try
  166. {
  167. packet = receiveBuffer.DequeuePacket();
  168. }
  169. catch (Exception)
  170. {
  171. state.ClientSocket.Close();
  172. }
  173. if (packet != null)
  174. {
  175. ProcessPacket(packet, ref state);
  176. }
  177. }
  178. }
  179. public void ProcessPacket(SessionPacket packet, ref ConnectionState state)
  180. {
  181. if (packet is SessionRequestPacket && m_transport == SMBTransportType.NetBiosOverTCP)
  182. {
  183. PositiveSessionResponsePacket response = new PositiveSessionResponsePacket();
  184. TrySendPacket(state, response);
  185. }
  186. else if (packet is SessionKeepAlivePacket && m_transport == SMBTransportType.NetBiosOverTCP)
  187. {
  188. // [RFC 1001] NetBIOS session keep alives do not require a response from the NetBIOS peer
  189. }
  190. else if (packet is SessionMessagePacket)
  191. {
  192. // Note: To be compatible with SMB2 specifications, we must accept SMB_COM_NEGOTIATE.
  193. // We will disconnect the connection if m_enableSMB1 == false and the client does not support SMB2.
  194. bool acceptSMB1 = (state.ServerDialect == SMBDialect.NotSet || state.ServerDialect == SMBDialect.NTLM012);
  195. bool acceptSMB2 = (m_enableSMB2 && (state.ServerDialect == SMBDialect.NotSet || state.ServerDialect == SMBDialect.SMB202 || state.ServerDialect == SMBDialect.SMB210));
  196. if (SMB1Header.IsValidSMB1Header(packet.Trailer))
  197. {
  198. if (!acceptSMB1)
  199. {
  200. state.LogToServer(Severity.Verbose, "Rejected SMB1 message");
  201. state.ClientSocket.Close();
  202. return;
  203. }
  204. SMB1Message message = null;
  205. try
  206. {
  207. message = SMB1Message.GetSMB1Message(packet.Trailer);
  208. }
  209. catch (Exception ex)
  210. {
  211. state.LogToServer(Severity.Warning, "Invalid SMB1 message: " + ex.Message);
  212. state.ClientSocket.Close();
  213. return;
  214. }
  215. state.LogToServer(Severity.Verbose, "SMB1 message received: {0} requests, First request: {1}, Packet length: {2}", message.Commands.Count, message.Commands[0].CommandName.ToString(), packet.Length);
  216. if (state.ServerDialect == SMBDialect.NotSet && m_enableSMB2)
  217. {
  218. // Check if the client supports SMB 2
  219. List<string> smb2Dialects = SMB2.NegotiateHelper.FindSMB2Dialects(message);
  220. if (smb2Dialects.Count > 0)
  221. {
  222. SMB2Command response = SMB2.NegotiateHelper.GetNegotiateResponse(smb2Dialects, state, m_serverGuid);
  223. if (state.ServerDialect != SMBDialect.NotSet)
  224. {
  225. state = new SMB2ConnectionState(state, AllocatePersistentFileID);
  226. }
  227. TrySendResponse(state, response);
  228. return;
  229. }
  230. }
  231. if (m_enableSMB1)
  232. {
  233. ProcessSMB1Message(message, ref state);
  234. }
  235. else
  236. {
  237. // [MS-SMB2] 3.3.5.3.2 If the string is not present in the dialect list and the server does not implement SMB,
  238. // the server MUST disconnect the connection [..] without sending a response.
  239. state.LogToServer(Severity.Verbose, "Rejected SMB1 message");
  240. state.ClientSocket.Close();
  241. }
  242. }
  243. else if (SMB2Header.IsValidSMB2Header(packet.Trailer))
  244. {
  245. if (!acceptSMB2)
  246. {
  247. state.LogToServer(Severity.Verbose, "Rejected SMB2 message");
  248. state.ClientSocket.Close();
  249. return;
  250. }
  251. List<SMB2Command> requestChain;
  252. try
  253. {
  254. requestChain = SMB2Command.ReadRequestChain(packet.Trailer, 0);
  255. }
  256. catch (Exception ex)
  257. {
  258. state.LogToServer(Severity.Warning, "Invalid SMB2 request chain: " + ex.Message);
  259. state.ClientSocket.Close();
  260. return;
  261. }
  262. state.LogToServer(Severity.Verbose, "SMB2 request chain received: {0} requests, First request: {1}, Packet length: {2}", requestChain.Count, requestChain[0].CommandName.ToString(), packet.Length);
  263. ProcessSMB2RequestChain(requestChain, ref state);
  264. }
  265. else
  266. {
  267. state.LogToServer(Severity.Warning, "Invalid SMB message");
  268. state.ClientSocket.Close();
  269. }
  270. }
  271. else
  272. {
  273. state.LogToServer(Severity.Warning, "Invalid NetBIOS packet");
  274. state.ClientSocket.Close();
  275. return;
  276. }
  277. }
  278. public static void TrySendPacket(ConnectionState state, SessionPacket response)
  279. {
  280. Socket clientSocket = state.ClientSocket;
  281. try
  282. {
  283. clientSocket.Send(response.GetBytes());
  284. }
  285. catch (SocketException)
  286. {
  287. }
  288. catch (ObjectDisposedException)
  289. {
  290. }
  291. }
  292. public void Log(Severity severity, string message)
  293. {
  294. // To be thread-safe we must capture the delegate reference first
  295. EventHandler<LogEntry> handler = OnLogEntry;
  296. if (handler != null)
  297. {
  298. handler(this, new LogEntry(DateTime.Now, severity, "SMB Server", message));
  299. }
  300. }
  301. public void Log(Severity severity, string message, params object[] args)
  302. {
  303. Log(severity, String.Format(message, args));
  304. }
  305. }
  306. }