public bool Connect(IPAddress serverAddress, SMBTransportType transport, bool forceExtendedSecurity, string serverName = null)
{
m_transport = transport;
if (!m_isConnected)
{
m_forceExtendedSecurity = forceExtendedSecurity;
int port;
port = transport == SMBTransportType.NetBiosOverTCP ? NetBiosOverTCPPort : DirectTCPPort;
if (!ConnectSocket(serverAddress, port))
{
return(false);
}
if (transport == SMBTransportType.NetBiosOverTCP)
{
SessionRequestPacket sessionRequest = new SessionRequestPacket();
sessionRequest.CalledName = NetBiosUtils.GetMSNetBiosName(serverName ?? "*SMBSERVER", NetBiosSuffix.FileServiceService);
sessionRequest.CallingName = NetBiosUtils.GetMSNetBiosName(Environment.MachineName, NetBiosSuffix.WorkstationService);
TrySendPacket(m_clientSocket, sessionRequest);
SessionPacket sessionResponsePacket = WaitForSessionResponsePacket();
if (!(sessionResponsePacket is PositiveSessionResponsePacket))
{
m_clientSocket.Disconnect(false);
if (!ConnectSocket(serverAddress, port))
{
return(false);
}
NameServiceClient nameServiceClient = new NameServiceClient(serverAddress);
serverName = nameServiceClient.GetServerName();
if (serverName == null)
{
return(false);
}
sessionRequest.CalledName = serverName;
TrySendPacket(m_clientSocket, sessionRequest);
sessionResponsePacket = WaitForSessionResponsePacket();
if (!(sessionResponsePacket is PositiveSessionResponsePacket))
{
return(false);
}
}
}
bool supportsDialect = NegotiateDialect(m_forceExtendedSecurity);
if (!supportsDialect)
{
m_clientSocket.Close();
}
else
{
m_isConnected = true;
}
}
return(m_isConnected);
}
public static SMBConnection CreateSMBConnection(ISMBClientFactory smbClientFactory,
IPAddress address, SMBTransportType transport, ISMBCredential credential, uint maxBufferSize)
{
var threadId = Thread.CurrentThread.ManagedThreadId;
if (credential == null)
{
throw new ArgumentNullException(nameof(credential));
}
lock (_connectionLock)
{
if (!instances.ContainsKey(threadId))
{
instances.Add(threadId, new Dictionary <IPAddress, SMBConnection>());
}
if (instances[threadId].ContainsKey(address))
{
var instance = instances[threadId][address];
instance._referenceCount += 1;
return(instance);
}
else
{
var instance = new SMBConnection(smbClientFactory, address, transport, credential, threadId, maxBufferSize);
instance.Connect();
instances[threadId].Add(address, instance);
return(instance);
}
}
}
/// <param name="connectionInactivityTimeout">
/// The duration after which an unsolicited ECHO response will be sent if no data has been sent or received.
/// Some broken NATs will reply to TCP KeepAlive even after the client initiating the connection has long gone,
/// to prevent such connections from hanging around indefinitely, this parameter can be used.
/// </param>
/// <exception cref="System.Net.Sockets.SocketException"></exception>
public void Start(IPAddress serverAddress, SMBTransportType transport, bool enableSMB1, bool enableSMB2, TimeSpan?connectionInactivityTimeout)
{
if (!m_listening)
{
Log(Severity.Information, "Starting server");
m_serverAddress = serverAddress;
m_transport = transport;
m_enableSMB1 = enableSMB1;
m_enableSMB2 = enableSMB2;
m_listening = true;
m_serverStartTime = DateTime.Now;
m_listenerSocket = new Socket(m_serverAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
int port = (m_transport == SMBTransportType.DirectTCPTransport ? DirectTCPPort : NetBiosOverTCPPort);
m_listenerSocket.Bind(new IPEndPoint(m_serverAddress, port));
m_listenerSocket.Listen((int)SocketOptionName.MaxConnections);
m_listenerSocket.BeginAccept(ConnectRequestCallback, m_listenerSocket);
if (connectionInactivityTimeout.HasValue)
{
m_sendSMBKeepAliveThread = new Thread(delegate()
{
while (m_listening)
{
Thread.Sleep(InactivityMonitoringInterval);
m_connectionManager.SendSMBKeepAlive(connectionInactivityTimeout.Value);
}
});
m_sendSMBKeepAliveThread.IsBackground = true;
m_sendSMBKeepAliveThread.Start();
}
}
}
public void Start()
{
IPAddress serverAddress = IPAddress.Parse(IpAddress);
SMBTransportType transportType = SMBTransportType.DirectTCPTransport;
UserCollection users = new UserCollection();
users.Add(UserName, UserPassword);
NTLMAuthenticationProviderBase authenticationMechanism = new IndependentNTLMAuthenticationProvider(users.GetUserPassword);
SMBShareCollection shares = new SMBShareCollection();
FileSystemShare share = new FileSystemShare("documents", new NTDirectoryFileSystem("/storage/emulated/0/Documents"));
share.AccessRequested += delegate(object sender, AccessRequestArgs args)
{
// allow read and write on share
args.Allow = true;
};
shares.Add(share);
GSSProvider securityProvider = new GSSProvider(authenticationMechanism);
server = new SmbServer2(shares, securityProvider);
try
{
server.Start(serverAddress, transportType, true, true);
}
catch (Exception ex)
{
}
}
public SMBDirectoryInfoFactory(IFileSystem fileSystem, ISMBCredentialProvider credentialProvider,
ISMBClientFactory smbClientFactory, uint maxBufferSize)
{
_fileSystem = fileSystem;
_credentialProvider = credentialProvider;
_smbClientFactory = smbClientFactory;
_maxBufferSize = maxBufferSize;
transport = SMBTransportType.DirectTCPTransport;
}
public SMBServer(ShareCollection shares, IPAddress serverAddress, SMBTransportType transport)
{
m_shares = shares;
m_serverAddress = serverAddress;
m_serverGuid = Guid.NewGuid();
m_transport = transport;
m_services = new NamedPipeShare(shares.ListShares());
}
private void StartService()
{
IPAddress serverAddress = IPAddress.Any;
SMBTransportType transportType = SMBTransportType.DirectTCPTransport;
UserCollection users = null;
List <ShareSettings> sharesSettings = null;
int port = SettingsHelper.DefaultPort;
try
{
users = SettingsHelper.ReadUserSettings();
sharesSettings = SettingsHelper.ReadSharesSettings();
port = SettingsHelper.ReadServerPort();
}
catch
{
m_logWriter.WriteLine("Fail to load Settings.xml");
return;
}
NTLMAuthenticationProviderBase authenticationMechanism = new IndependentNTLMAuthenticationProvider(users.GetUserPassword);
SMBShareCollection shares = new SMBShareCollection();
foreach (ShareSettings shareSettings in sharesSettings)
{
FileSystemShare share = shareSettings.InitializeShare();
shares.Add(share);
}
GSSProvider securityProvider = new GSSProvider(authenticationMechanism);
m_server = new SMBLibrary.Server.SMBServer(shares, securityProvider);
// The provided logging mechanism will synchronously write to the disk during server activity.
// To maximize server performance, you can disable logging by commenting out the following line.
m_server.LogEntryAdded += new EventHandler <LogEntry>(m_logWriter.OnLogEntryAdded);
try
{
SMBServer.DirectTCPPort = port;
m_server.Start(serverAddress, transportType);
if (transportType == SMBTransportType.NetBiosOverTCP)
{
if (serverAddress.AddressFamily == AddressFamily.InterNetwork && !IPAddress.Equals(serverAddress, IPAddress.Any))
{
IPAddress subnetMask = NetworkInterfaceHelper.GetSubnetMask(serverAddress);
m_nameServer = new NameServer(serverAddress, subnetMask);
m_nameServer.Start();
}
}
}
catch (Exception ex)
{
m_logWriter.WriteLine(ex.Message);
}
}
public SMBDirectory(ISMBClientFactory smbclientFactory, ISMBCredentialProvider credentialProvider,
IFileSystem fileSystem, uint maxBufferSize) : base(new FileSystem())
{
_smbClientFactory = smbclientFactory;
_credentialProvider = credentialProvider;
_fileSystem = fileSystem;
_maxBufferSize = maxBufferSize;
transport = SMBTransportType.DirectTCPTransport;
}
private SMBConnection(ISMBClientFactory smbClientFactory, IPAddress address, SMBTransportType transport,
ISMBCredential credential, int threadId, uint maxBufferSize)
{
SMBClient = smbClientFactory.CreateClient(maxBufferSize);
_address = address;
_transport = transport;
_credential = credential;
_referenceCount = 1;
_threadId = threadId;
}
public SMBDirectoryInfoFactory(IFileSystem fileSystem, ISMBCredentialProvider credentialProvider,
ISMBClientFactory smbClientFactory, uint maxBufferSize, ILoggerFactory loggerFactory = null)
{
_logger = loggerFactory?.CreateLogger <SMBDirectoryInfoFactory>();
_fileSystem = fileSystem;
_credentialProvider = credentialProvider;
_smbClientFactory = smbClientFactory;
_maxBufferSize = maxBufferSize;
transport = SMBTransportType.DirectTCPTransport;
}
public SMBFile(ISMBClientFactory smbclientFactory, ISMBCredentialProvider credentialProvider,
IFileSystem fileSystem, uint maxBufferSize = 65536,
ISmbFileSystemSettings smbFileSystemSettings = null, ILoggerFactory loggerFactory = null) : base(new FileSystem())
{
_logger = loggerFactory?.CreateLogger <SMBFile>();
_smbFileSystemSettings = smbFileSystemSettings ?? new SmbFileSystemSettings();
_smbClientFactory = smbclientFactory;
_credentialProvider = credentialProvider;
_fileSystem = fileSystem;
_maxBufferSize = maxBufferSize;
transport = SMBTransportType.DirectTCPTransport;
}
public bool Connect(string serverName, SMBTransportType transport)
{
IPHostEntry hostEntry = Dns.GetHostEntry(serverName);
if (hostEntry.AddressList.Length == 0)
{
throw new Exception(String.Format("Cannot resolve host name {0} to an IP address", serverName));
}
IPAddress serverAddress = hostEntry.AddressList[0];
return(Connect(serverAddress, transport));
}
public static SMBConnection CreateSMBConnectionForStream(ISMBClientFactory smbClientFactory,
IPAddress address, SMBTransportType transport, ISMBCredential credential, uint maxBufferSize)
{
if (credential == null)
{
throw new ArgumentNullException(nameof(credential));
}
// Create new connection
var instance = new SMBConnection(smbClientFactory, address, transport, credential, -1,
maxBufferSize);
instance.Connect();
return(instance);
}
public bool Connect(IPAddress serverAddress, SMBTransportType transport, bool forceExtendedSecurity)
{
m_transport = transport;
if (!m_isConnected)
{
m_forceExtendedSecurity = forceExtendedSecurity;
m_clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
int port;
if (transport == SMBTransportType.DirectTCPTransport)
{
port = DirectTCPPort;
}
else
{
port = NetBiosOverTCPPort;
}
try
{
m_clientSocket.Connect(serverAddress, port);
}
catch (SocketException)
{
return(false);
}
ConnectionState state = new ConnectionState();
NBTConnectionReceiveBuffer buffer = state.ReceiveBuffer;
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.SetBuffer(buffer.Buffer, buffer.WriteOffset, buffer.AvailableLength);
args.Completed += OnClientSocketReceive;
args.UserToken = state;
if (!m_clientSocket.ReceiveAsync(args))
{
OnClientSocketReceive(m_clientSocket, args);
}
bool supportsDialect = NegotiateDialect(m_forceExtendedSecurity);
if (!supportsDialect)
{
m_clientSocket.Dispose();
}
else
{
m_isConnected = true;
}
}
return(m_isConnected);
}
public async Task <bool> ConnectAsync(string server, SMBTransportType transport, CancellationToken cancellationToken)
{
if (IPAddress.TryParse(server, out var ipAddress) == false)
{
var ips = await Dns.GetHostEntryAsync(server);
ipAddress = ips.AddressList.FirstOrDefault(ip => ip.AddressFamily == AddressFamily.InterNetwork);
if (ipAddress is null)
{
throw new Exception("Unable to resolve address for host");
}
}
return(await ConnectAsync(ipAddress, transport, cancellationToken));
}
public SMBClient(IPAddress serverAddress, SMBTransportType transport)
{
NegotiateRequest request = new NegotiateRequest();
request.Dialects.Add(NTLanManagerDialect);
Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
if (transport == SMBTransportType.DirectTCPTransport)
{
serverSocket.Connect(serverAddress, DirectTCPPort);
}
else
{
serverSocket.Connect(serverAddress, NetBiosOverTCPPort);
}
TrySendMessage(serverSocket, request);
}
/// <exception cref="System.Net.Sockets.SocketException"></exception>
public void Start(IPAddress serverAddress, SMBTransportType transport, bool enableSMB1, bool enableSMB2)
{
if (!m_listening)
{
Log(Severity.Information, "Starting server");
m_serverAddress = serverAddress;
m_transport = transport;
m_enableSMB1 = enableSMB1;
m_enableSMB2 = enableSMB2;
m_listening = true;
m_serverStartTime = DateTime.Now;
m_listenerSocket = new Socket(m_serverAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
int port = (m_transport == SMBTransportType.DirectTCPTransport ? DirectTCPPort : NetBiosOverTCPPort);
m_listenerSocket.Bind(new IPEndPoint(m_serverAddress, port));
m_listenerSocket.Listen((int)SocketOptionName.MaxConnections);
m_listenerSocket.BeginAccept(ConnectRequestCallback, m_listenerSocket);
}
}
public bool Connect(IPAddress serverAddress, SMBTransportType transport, bool forceExtendedSecurity)
{
m_transport = transport;
if (!m_isConnected)
{
m_forceExtendedSecurity = forceExtendedSecurity;
m_clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
int port;
if (transport == SMBTransportType.DirectTCPTransport)
{
port = DirectTCPPort;
}
else
{
port = NetBiosOverTCPPort;
}
try
{
m_clientSocket.Connect(serverAddress, port);
}
catch (SocketException)
{
return(false);
}
ConnectionState state = new ConnectionState();
NBTConnectionReceiveBuffer buffer = state.ReceiveBuffer;
m_currentAsyncResult = m_clientSocket.BeginReceive(buffer.Buffer, buffer.WriteOffset, buffer.AvailableLength, SocketFlags.None, new AsyncCallback(OnClientSocketReceive), state);
bool supportsDialect = NegotiateDialect(m_forceExtendedSecurity);
if (!supportsDialect)
{
m_clientSocket.Close();
}
else
{
m_isConnected = true;
}
}
return(m_isConnected);
}
public Server()
{
IPAddress serverAddress = IPAddress.Any;
//Dns.GetHostAddresses(Dns.GetHostName())
SMBTransportType transportType = SMBTransportType.DirectTCPTransport;
ShareCollection shares;
try
{
shares = ReadShareSettings();
}
catch (Exception ex)
{
Console.WriteLine("Cannot read {0}: {1}", SettingsFileName, ex.Message);
return;
}
m_server = new SMBLibrary.Server.SMBServer(shares, serverAddress, transportType);
m_server.Start();
}
public bool Connect(IPAddress serverAddress, SMBTransportType transport)
{
// Sometimes underline socket is disconnected, but m_isConnected flag is still true.
// This cause the caller try to reuse the client and fail on all calls.
if (m_clientSocket is { Connected : false })
public bool Connect(IPAddress serverAddress, SMBTransportType transport)
{
// Sometimes underline socket is disconnected, but m_isConnected flag is still true.
// This cause the caller try to reuse the client and fail on all calls.
if (m_clientSocket != null && !m_clientSocket.Connected)
{
// Since reconnect doesn't work for now, return false directly make response faster
return(false);
}
m_transport = transport;
if (!m_isConnected)
{
int port;
if (transport == SMBTransportType.NetBiosOverTCP)
{
port = NetBiosOverTCPPort;
}
else
{
port = DirectTCPPort;
}
if (!ConnectSocket(serverAddress, port))
{
return(false);
}
if (transport == SMBTransportType.NetBiosOverTCP)
{
SessionRequestPacket sessionRequest = new SessionRequestPacket();
sessionRequest.CalledName = NetBiosUtils.GetMSNetBiosName("*SMBSERVER", NetBiosSuffix.FileServiceService);
sessionRequest.CallingName = NetBiosUtils.GetMSNetBiosName(Environment.MachineName, NetBiosSuffix.WorkstationService);
TrySendPacket(m_clientSocket, sessionRequest);
SessionPacket sessionResponsePacket = WaitForSessionResponsePacket();
if (!(sessionResponsePacket is PositiveSessionResponsePacket))
{
m_clientSocket.Disconnect(false);
if (!ConnectSocket(serverAddress, port))
{
return(false);
}
NameServiceClient nameServiceClient = new NameServiceClient(serverAddress);
string serverName = nameServiceClient.GetServerName();
if (serverName == null)
{
return(false);
}
sessionRequest.CalledName = serverName;
TrySendPacket(m_clientSocket, sessionRequest);
sessionResponsePacket = WaitForSessionResponsePacket();
if (!(sessionResponsePacket is PositiveSessionResponsePacket))
{
return(false);
}
}
}
bool supportsDialect = NegotiateDialect();
if (!supportsDialect)
{
m_clientSocket.Close();
}
else
{
m_isConnected = true;
}
}
return(m_isConnected);
}
public bool Connect(IPAddress serverAddress, SMBTransportType transport)
{
return(Connect(serverAddress, transport, true));
}
public bool Connect(IPAddress serverAddress, SMBTransportType transport, bool forceExtendedSecurity)
{
int port = (transport == SMBTransportType.DirectTCPTransport ? DirectTCPPort : NetBiosOverTCPPort);
return(Connect(serverAddress, transport, port, forceExtendedSecurity));
}
public void Start(IPAddress serverAddress, SMBTransportType transport, bool enableSMB1, bool enableSMB2, bool enableSMB3)
{
Start(serverAddress, transport, enableSMB1, enableSMB2, enableSMB3, null);
}
/// <param name="connectionInactivityTimeout">
/// The duration after which an unsolicited ECHO response will be sent if no data has been sent or received.
/// Some broken NATs will reply to TCP KeepAlive even after the client initiating the connection has long gone,
/// to prevent such connections from hanging around indefinitely, this parameter can be used.
/// </param>
/// <exception cref="System.Net.Sockets.SocketException"></exception>
public void Start(IPAddress serverAddress, SMBTransportType transport, bool enableSMB1, bool enableSMB2, bool enableSMB3, TimeSpan?connectionInactivityTimeout)
{
int port = (transport == SMBTransportType.DirectTCPTransport ? DirectTCPPort : NetBiosOverTCPPort);
Start(serverAddress, transport, port, enableSMB1, enableSMB2, enableSMB3, connectionInactivityTimeout);
}
public void Start(IPAddress serverAddress, SMBTransportType transport, bool enableSMB1, bool enableSMB2)
{
Start(serverAddress, transport, enableSMB1, enableSMB2, false);
}
public void Start(IPAddress serverAddress, SMBTransportType transport)
{
Start(serverAddress, transport, true, true);
}
// Special case - SMB2 client initially connecting using SMB1
internal static SMB2Command GetNegotiateResponse(List <string> smb2Dialects, GSSProvider securityProvider, ConnectionState state, SMBTransportType transportType, Guid serverGuid, DateTime serverStartTime)
{
NegotiateResponse response = new NegotiateResponse();
response.Header.Credits = 1;
if (smb2Dialects.Contains(SMB2xxxDialect))
{
response.DialectRevision = SMB2Dialect.SMB2xx;
}
else if (smb2Dialects.Contains(SMB2002Dialect))
{
state.Dialect = SMBDialect.SMB202;
response.DialectRevision = SMB2Dialect.SMB202;
}
else
{
throw new ArgumentException("SMB2 dialect is not present");
}
response.SecurityMode = SecurityMode.SigningEnabled;
response.ServerGuid = serverGuid;
if (state.Dialect != SMBDialect.SMB202 && transportType == SMBTransportType.DirectTCPTransport)
{
response.Capabilities = Capabilities.LargeMTU;
response.MaxTransactSize = ServerMaxTransactSizeLargeMTU;
response.MaxReadSize = ServerMaxReadSizeLargeMTU;
response.MaxWriteSize = ServerMaxWriteSizeLargeMTU;
// [MS-SMB2] 3.3.5.2 Receiving Any Message - If the length of the message exceeds Connection.MaxTransactSize + 256, the server MUST disconnect the connection.
int maxPacketSize = SessionPacket.HeaderLength + (int)ServerMaxTransactSizeLargeMTU + 256;
if (maxPacketSize > state.ReceiveBuffer.Buffer.Length)
{
state.ReceiveBuffer.IncreaseBufferSize(maxPacketSize);
}
}
else
{
response.MaxTransactSize = ServerMaxTransactSize;
response.MaxReadSize = ServerMaxReadSize;
response.MaxWriteSize = ServerMaxWriteSize;
}
response.SystemTime = DateTime.Now;
response.ServerStartTime = serverStartTime;
response.SecurityBuffer = securityProvider.GetSPNEGOTokenInitBytes();
return(response);
}
internal static SMB2Command GetNegotiateResponse(NegotiateRequest request, GSSProvider securityProvider, ConnectionState state, SMBTransportType transportType, Guid serverGuid, DateTime serverStartTime, bool enableSMB3)
{
NegotiateResponse response = new NegotiateResponse();
if (enableSMB3 && request.Dialects.Contains(SMB2Dialect.SMB300))
{
state.Dialect = SMBDialect.SMB300;
response.DialectRevision = SMB2Dialect.SMB300;
}
else if (request.Dialects.Contains(SMB2Dialect.SMB210))
{
state.Dialect = SMBDialect.SMB210;
response.DialectRevision = SMB2Dialect.SMB210;
}
else if (request.Dialects.Contains(SMB2Dialect.SMB202))
{
state.Dialect = SMBDialect.SMB202;
response.DialectRevision = SMB2Dialect.SMB202;
}
else
{
state.LogToServer(Severity.Verbose, "Negotiate failure: None of the requested SMB2 dialects is supported");
return(new ErrorResponse(request.CommandName, NTStatus.STATUS_NOT_SUPPORTED));
}
response.SecurityMode = SecurityMode.SigningEnabled;
response.ServerGuid = serverGuid;
if (state.Dialect != SMBDialect.SMB202 && transportType == SMBTransportType.DirectTCPTransport)
{
response.Capabilities = Capabilities.LargeMTU;
response.MaxTransactSize = ServerMaxTransactSizeLargeMTU;
response.MaxReadSize = ServerMaxReadSizeLargeMTU;
response.MaxWriteSize = ServerMaxWriteSizeLargeMTU;
// [MS-SMB2] 3.3.5.2 Receiving Any Message - If the length of the message exceeds Connection.MaxTransactSize + 256, the server MUST disconnect the connection.
int maxPacketSize = SessionPacket.HeaderLength + (int)ServerMaxTransactSizeLargeMTU + 256;
if (maxPacketSize > state.ReceiveBuffer.Buffer.Length)
{
state.ReceiveBuffer.IncreaseBufferSize(maxPacketSize);
}
}
else
{
response.MaxTransactSize = ServerMaxTransactSize;
response.MaxReadSize = ServerMaxReadSize;
response.MaxWriteSize = ServerMaxWriteSize;
}
response.SystemTime = DateTime.Now;
response.ServerStartTime = serverStartTime;
response.SecurityBuffer = securityProvider.GetSPNEGOTokenInitBytes();
return(response);
}
public bool Connect(IPAddress serverAddress, SMBTransportType transport)
{
int port = (transport == SMBTransportType.DirectTCPTransport ? DirectTCPPort : NetBiosOverTCPPort);
return(Connect(serverAddress, transport, port));
}
