public void BeginSign(Sign nextSign)
{
currentSign = nextSign;
signSentence = currentSign.GetSentence();
signState = SignState.Started;
DisplaySignText();
}
private async Task TrySignOutAsync()
=> await TryAsync(async() =>
{
SignState = SignState.SigningOut;
await _hubProxy.Invoke("SignOut");
SignState = SignState.SignedOut;
}, () => SignState = SignState.SignedIn);
public SmbConnection()
{
isClientSupportExtSecurity = false;
sutSignState = SignState.Disabled;
sutCapabilities = new List <Capabilities>();
isNegotiateSent = false;
sessionList = new Dictionary <int, SmbSession>();
treeConnectList = new Dictionary <int, SmbTree>();
SutNextReceiveSequenceNumber = 1;
SutSendSequenceNumber = new List <int>();
clientCapabilities = new List <Capabilities>();
openedFiles = new Dictionary <int, SmbFile>();
openedPipes = new Dictionary <int, SmbPipe>();
openedMailslots = new Dictionary <int, SmbMailslot>();
sentRequest = new Dictionary <int, SmbRequest>();
sessionId = 0;
treeId = 0;
fId = 0;
searchHandlerContainer = new Dictionary <int, int>();
clientSignState = SignState.Disabled;
isSigningActive = false;
accountType = AccountType.Admin;
}
public void setValue(String value, int precision, SignState sign, bool pad, Align align)
{
this.value = value;
this.precision = precision;
this.signState = sign;
this.pad = pad;
this.align = align;
this.Invalidate();
}
/// <summary>
/// Update SMB_COM_NEGOTIATE response.
/// </summary>
/// <param name="connection">It represents the SMB connection.</param>
/// <param name="messageId">This is used to associate a response with a request.</param>
/// <param name="signState">It indicates whether the System Under Test (the SUT) has message signing enabled or required </param>
/// <param name="serverCapabilities">
/// It is used by the SUT to notify the client as to which features are supported by the SUT.
/// </param>
public static void UpdateNegotiateResponse(
SmbConnection connection,
int messageId,
SignState signState,
List <Capabilities> serverCapabilities)
{
connection.sutSignState = signState;
connection.SutSendSequenceNumber.Remove(messageId);
connection.sentRequest.Remove(messageId);
connection.SutNextReceiveSequenceNumber++;
connection.sutCapabilities = serverCapabilities;
}
public virtual async Task SignInAsync(string name)
{
if (SignState != SignState.SignedOut)
{
OnSigningError();
return;
}
await TryAsync(async() =>
{
SignState = SignState.SigningIn;
await _hubProxy.Invoke("SignIn", name);
SignState = SignState.SignedIn;
}, () => SignState = SignState.SignedOut);
}
/// <summary>
/// It is used to indicate whether sign is enable in this connection.
/// </summary>
/// <param name="clientConnectionSignState">It indicates signstate for client.</param>
/// <param name="sutConnectionSignState">It indicates the signstate for the SUT.</param>
/// <returns>Client sign state.</returns>
public bool isSignEnable(SignState clientConnectionSignState, SignState sutConnectionSignState)
{
if ((clientConnectionSignState == SignState.Required && sutConnectionSignState != SignState.Disabled) ||
(clientConnectionSignState == SignState.Enabled &&
sutConnectionSignState != SignState.Disabled &&
sutConnectionSignState != SignState.DisabledUnlessRequired) ||
(clientConnectionSignState == SignState.DisabledUnlessRequired &&
sutConnectionSignState == SignState.Required))
{
return(true);
}
else
{
return(false);
}
}
void Gameover()
{
ClearText();
currentFullWord = 0;
currentInputWord = 0;
currentSentenceInBattle = 0;
gameoverScript.gameObject.SetActive(true);
timer.StopAndGetTime();
score.Restart();
gameinfo.normalMusic();
gameinfo.ResetAll();
battleState = BattleState.Gameovered;
signState = SignState.Initialized;
currentEncounter.enemySprite.gameObject.SetActive(false);
}
public void ChangeState(SignState _state)
{
if (!(m_signAnimator == null))
{
switch (_state)
{
case SignState.SHOWING_YELLOW:
m_signAnimator.SetBool("On", value: true);
break;
case SignState.SHOWING_RED:
m_signAnimator.SetBool("Red", value: true);
break;
case SignState.INACTIVE:
m_signAnimator.SetBool("On", value: false);
m_signAnimator.SetBool("Red", value: false);
break;
default:
Assert.IsTrue(condition: false, "Not a valid sign state to switch to");
break;
}
}
}
public static void ServerSetup(
FileSystemType fsType,
SignState sutSignState,
bool isSupportDfs,
bool isSupportPreviousVersion,
bool isMessageModePipe)
{
Condition.IsTrue(smbState == SmbState.ConnectionSuccess);
if (Parameter.sutPlatform != Platform.NonWindows)
{
if (Parameter.sutPlatform == Platform.Win2K3)
{
// It is not possible to disable the DFS capability from the WS03 the SUT.
Condition.IsTrue(isSupportDfs);
}
}
if (Parameter.sutPlatform != Platform.NonWindows)
{
if (fsType == FileSystemType.Fat)
{
Parameter.isSupportQuota = false;
// In Windows, the Generic file system (FAT) does not support File IDs.
Parameter.isSupportUniqueFileId = false;
// FAT does not support streams.
Parameter.isSupportStream = false;
// FAT does not support the previous version.
Condition.IsTrue(!isSupportPreviousVersion);
Requirement.AssumeCaptured("Server doesn't support stream");
}
else
{
Parameter.isSupportQuota = true;
// In Windows, the Generic file system (NTFS) file system supports File IDs.
Parameter.isSupportUniqueFileId = true;
// NTFS supports streams.
Parameter.isSupportStream = true;
// NTFS supports the previous version.
Condition.IsTrue(isSupportPreviousVersion);
Requirement.AssumeCaptured("Server doesn't support stream");
}
}
Parameter.isSupportPreviousVersion = isSupportPreviousVersion;
Parameter.fsType = fsType;
Parameter.isSupportDfs = isSupportDfs;
Parameter.sutSignState = sutSignState;
Parameter.isMessageModePipe = isMessageModePipe;
smbState = SmbState.ServerSetupRequest;
}
/// <summary>
/// Config the SUT.
/// </summary>
/// <param name="fileSystemType">The file system type of the server.</param>
/// <param name="serverSignState">Indicate what the message signing policy of server.</param>
/// <param name="isSupportDfs">Indicate whether the server supports DFS.</param>
/// <param name="isSupportPreviousVersion">Indicate whether the server will support previous version.</param>
/// <param name="isMessageModePipe">Indicate the adapter to setup a message mode pipe or byte mode pipe</param>
public void ServerSetup(
FileSystemType fileSystemType,
SignState serverSignState,
bool isSupportDfs,
bool isSupportPreviousVersion,
bool isMessageModePipe)
{
bool isInteractiveAdapterUsed = bool.Parse(Site.Properties.Get("SutInteractiveAdapterIsUsed"));
if (isInteractiveAdapterUsed)
{
IDeleteFilesInteractiveAdapter deleteFileAdapter = Site.GetAdapter<ISutInteractiveAdapter>();
deleteFileAdapter.DeleteFiles();
IConfigSignStateInteractiveAdapter configSignStateAdapter
= Site.GetAdapter<ISutInteractiveAdapter>();
string sutName = Site.Properties["SutMachineName"];
switch (serverSignState)
{
case SignState.Disabled:
configSignStateAdapter.ConfigSignState(sutName, "Disabled");
break;
case SignState.Enabled:
configSignStateAdapter.ConfigSignState(sutName, "Enabled");
break;
case SignState.Required:
configSignStateAdapter.ConfigSignState(sutName, "Required");
break;
case SignState.DisabledUnlessRequired:
configSignStateAdapter.ConfigSignState(sutName, "DisabledUnlessRequired");
break;
}
}
else
{
IDeleteFilesAdapter deleteFileAdapter = Site.GetAdapter<IDeleteFilesAdapter>();
deleteFileAdapter.DeleteFiles();
IConfigSignStateAdapter configSignStateAdapter = Site.GetAdapter<IConfigSignStateAdapter>();
string sutName = Site.Properties["SutMachineName"];
switch (serverSignState)
{
case SignState.Disabled:
configSignStateAdapter.ConfigSignState(sutName, "Disabled");
break;
case SignState.Enabled:
configSignStateAdapter.ConfigSignState(sutName, "Enabled");
break;
case SignState.Required:
configSignStateAdapter.ConfigSignState(sutName, "Required");
break;
case SignState.DisabledUnlessRequired:
configSignStateAdapter.ConfigSignState(sutName, "DisabledUnlessRequired");
break;
}
}
int totalByteWritten = 1;
bool isSupportResumeKey = true;
bool isSupportCopyChunk = true;
if (fileSystemType == FileSystemType.Ntfs)
{
SmbAdapter.FsType = "Ntfs";
}
else
{
SmbAdapter.FsType = "Fat";
}
SmbAdapter.state = serverSignState;
SmbAdapter.fileSystemType = fileSystemType;
SmbAdapter.isSupportDfs = isSupportDfs;
SmbAdapter.isMessageModePipe = isMessageModePipe;
SmbAdapter.isPreviousVersion = isSupportPreviousVersion;
SmbAdapter.isSupportStream = true;
SmbAdapter.isSupportInfoLevelPassThru = true;
SmbAdapter.isSupportNtSmb = true;
SmbAdapter.isRapServerActive = true;
this.ServerSetupResponse(
totalByteWritten,
SmbAdapter.isSupportInfoLevelPassThru,
SmbAdapter.isSupportNtSmb,
SmbAdapter.isRapServerActive,
isSupportResumeKey,
isSupportCopyChunk);
}
/// <summary>
/// constructor
/// </summary>
internal SmbServerCapability()
: base()
{
this.serverSignState = SignState.DISABLED;
this.IsFromServer = true;
}
public void SignState(int id, SignState state)
{
signMap[id].SetState(state);
}
public static void NegotiateRequest(
int messageId,
bool isSupportExtSecurity,
SignState clientSignState,
Sequence<Dialect> dialectName)
{
Checker.CheckNegotiateRequest(smbConnection, messageId, smbState, clientSignState, dialectName);
smbRequest = new NegotiateRequest(messageId, isSupportExtSecurity, clientSignState, dialectName);
Update.UpdateNegotiateRequest(smbConnection, smbRequest);
smbState = SmbState.NegotiateSent;
}
/// <summary>
/// Update SMB_COM_NEGOTIATE response.
/// </summary>
/// <param name="connection">It represents the SMB connection.</param>
/// <param name="messageId">This is used to associate a response with a request.</param>
/// <param name="signState">It indicates whether the System Under Test (the SUT) has message signing enabled or required </param>
/// <param name="serverCapabilities">
/// It is used by the SUT to notify the client as to which features are supported by the SUT.
/// </param>
public static void UpdateNegotiateResponse(
SmbConnection connection,
int messageId,
SignState signState,
Set<Capabilities> serverCapabilities)
{
connection.sutSignState = signState;
connection.SutSendSequenceNumber.Remove(messageId);
connection.sentRequest.Remove(messageId);
connection.SutNextReceiveSequenceNumber++;
connection.sutCapabilities = serverCapabilities;
}
/// <summary>
/// Config the SUT.
/// </summary>
/// <param name="fileSystemType">The file system type of the server.</param>
/// <param name="serverSignState">Indicate what the message signing policy of server.</param>
/// <param name="isSupportDfs">Indicate whether the server supports DFS.</param>
/// <param name="isSupportPreviousVersion">Indicate whether the server will support previous version.</param>
/// <param name="isMessageModePipe">Indicate the adapter to setup a message mode pipe or byte mode pipe</param>
public void ServerSetup(
FileSystemType fileSystemType,
SignState serverSignState,
bool isSupportDfs,
bool isSupportPreviousVersion,
bool isMessageModePipe)
{
bool isInteractiveAdapterUsed = bool.Parse(Site.Properties.Get("SutInteractiveAdapterIsUsed"));
if (isInteractiveAdapterUsed)
{
IDeleteFilesInteractiveAdapter deleteFileAdapter = Site.GetAdapter <ISutInteractiveAdapter>();
deleteFileAdapter.DeleteFiles();
IConfigSignStateInteractiveAdapter configSignStateAdapter
= Site.GetAdapter <ISutInteractiveAdapter>();
string sutName = Site.Properties["SutMachineName"];
switch (serverSignState)
{
case SignState.Disabled:
configSignStateAdapter.ConfigSignState(sutName, "Disabled");
break;
case SignState.Enabled:
configSignStateAdapter.ConfigSignState(sutName, "Enabled");
break;
case SignState.Required:
configSignStateAdapter.ConfigSignState(sutName, "Required");
break;
case SignState.DisabledUnlessRequired:
configSignStateAdapter.ConfigSignState(sutName, "DisabledUnlessRequired");
break;
}
}
else
{
IDeleteFilesAdapter deleteFileAdapter = Site.GetAdapter <IDeleteFilesAdapter>();
deleteFileAdapter.DeleteFiles();
IConfigSignStateAdapter configSignStateAdapter = Site.GetAdapter <IConfigSignStateAdapter>();
string sutName = Site.Properties["SutMachineName"];
switch (serverSignState)
{
case SignState.Disabled:
configSignStateAdapter.ConfigSignState(sutName, "Disabled");
break;
case SignState.Enabled:
configSignStateAdapter.ConfigSignState(sutName, "Enabled");
break;
case SignState.Required:
configSignStateAdapter.ConfigSignState(sutName, "Required");
break;
case SignState.DisabledUnlessRequired:
configSignStateAdapter.ConfigSignState(sutName, "DisabledUnlessRequired");
break;
}
}
int totalByteWritten = 1;
bool isSupportResumeKey = true;
bool isSupportCopyChunk = true;
if (fileSystemType == FileSystemType.Ntfs)
{
SmbAdapter.FsType = "Ntfs";
}
else
{
SmbAdapter.FsType = "Fat";
}
SmbAdapter.state = serverSignState;
SmbAdapter.fileSystemType = fileSystemType;
SmbAdapter.isSupportDfs = isSupportDfs;
SmbAdapter.isMessageModePipe = isMessageModePipe;
SmbAdapter.isPreviousVersion = isSupportPreviousVersion;
SmbAdapter.isSupportStream = true;
SmbAdapter.isSupportInfoLevelPassThru = true;
SmbAdapter.isSupportNtSmb = true;
SmbAdapter.isRapServerActive = true;
this.ServerSetupResponse(
totalByteWritten,
SmbAdapter.isSupportInfoLevelPassThru,
SmbAdapter.isSupportNtSmb,
SmbAdapter.isRapServerActive,
isSupportResumeKey,
isSupportCopyChunk);
}
public void NegotiateRequest(
int messageId,
bool isSupportExtSecurity,
SignState clientSignState,
Sequence<Dialect> dialectName)
{
#region Create SMB Connection
TestStarted();
#endregion
#region Create Packet
SmbNegotiateRequestPacket smbPacket = new SmbNegotiateRequestPacket();
string[] dialectNameArray = new string[dialectName.Count];
int i = (int)UInt16.MinValue;
//fsccIsSupportExtSecurity = isSupportExtSecurity;
foreach (Dialect name in dialectName)
{
switch (name)
{
case Dialect.PcNet1:
dialectNameArray[i++] = DialectNameString.PCNET1;
break;
case Dialect.XenixCore:
dialectNameArray[i++] = DialectNameString.XENIXCORE;
break;
case Dialect.PcLan1:
dialectNameArray[i++] = DialectNameString.PCLAN1;
break;
case Dialect.MsNet103:
dialectNameArray[i++] = DialectNameString.MSNET103;
break;
case Dialect.MsNet30:
dialectNameArray[i++] = DialectNameString.MSNET30;
break;
case Dialect.LanMan10:
dialectNameArray[i++] = DialectNameString.LANMAN10;
break;
case Dialect.Wfw10:
dialectNameArray[i++] = DialectNameString.WFW10;
break;
case Dialect.DosLanMan12:
dialectNameArray[i++] = DialectNameString.DOSLANMAN12;
break;
case Dialect.DosLanMan21:
dialectNameArray[i++] = DialectNameString.DOSLANMAN21;
break;
case Dialect.LanMan12:
dialectNameArray[i++] = DialectNameString.LANMAN12;
break;
case Dialect.LanMan21:
dialectNameArray[i++] = DialectNameString.LANMAN21;
break;
case Dialect.NtLanMan:
dialectNameArray[i++] = DialectNameString.NTLANMAN;
break;
default:
dialectNameArray[i++] = string.Empty;
break;
}
}
this.smbClientStack.Capability.IsSupportsExtendedSecurity = isSupportExtSecurity;
NamespaceSmb.SignState signState =
(NamespaceSmb.SignState)Enum.Parse(
typeof(NamespaceSmb.SignState),
clientSignState.ToString(),
true);
smbPacket = this.smbClientStack.CreateNegotiateRequest(signState, dialectNameArray);
#endregion
#region Send and Receive ExpectPacket
this.smbClientStack.SendPacket(smbPacket);
StackPacket response = this.smbClientStack.ExpectPacket(this.timeout);
NamespaceCifs.SmbPacket smbPacketResponse = (NamespaceCifs.SmbPacket)response;
this.QueryUidTable(smbPacketResponse);
this.QueryTidTable(smbPacketResponse);
VerifyTransport(smbPacketResponse);
VerifyCommonMessageSyntax(smbPacketResponse);
if (response.GetType() == typeof(SmbErrorResponsePacket))
{
SmbErrorResponsePacket smbErrorResponsePacket = response as SmbErrorResponsePacket;
NamespaceCifs.SmbHeader smbErrorHeader = smbErrorResponsePacket.SmbHeader;
this.ErrorResponse(smbErrorHeader.Mid + this.addMidMark, (MessageStatus)smbErrorHeader.Status);
}
else
{
if (this.smbClientStack.Capability.IsSupportsExtendedSecurity)
{
SmbNegotiateResponsePacket smbNegotiateResponse = (SmbNegotiateResponsePacket)response;
NamespaceCifs.SmbHeader negotiateResponseHeader = smbNegotiateResponse.SmbHeader;
SMB_COM_NEGOTIATE_NtLanManagerResponse_SMB_Parameters negotiateResponsePayload =
smbNegotiateResponse.SmbParameters;
if (negotiateResponsePayload.DialectIndex == ServerNotSupportDialectIndex)
{
this.NegotiateResponse(
negotiateResponseHeader.Mid + this.addMidMark,
false,
false,
int.MinValue,
new Microsoft.Modeling.Set<Capabilities>(Capabilities.None),
(MessageStatus)negotiateResponseHeader.Status);
}
else
{
byte securityMode = (byte)negotiateResponsePayload.SecurityMode;
bool isSignEnabled = false;
bool isSignRequired = false;
if ((securityMode & SecurityModeNegotiateSecuritySignatureEnabled) ==
SecurityModeNegotiateSecuritySignatureEnabled)
{
isSignEnabled = true;
}
if ((securityMode & SecurityModeNegotiateSecuritySignatureRequired) ==
SecurityModeNegotiateSecuritySignatureRequired)
{
isSignRequired = true;
}
#region Get and Store Capabilities
uint capabilities = (uint)negotiateResponsePayload.Capabilities;
if ((capabilities & Convert.ToUInt32(Capabilities.CapUnicode.ToString("D"))) ==
Convert.ToUInt32(Capabilities.CapUnicode.ToString("D")))
{
this.negReturnedCap = this.negReturnedCap.Add(Capabilities.CapUnicode);
}
if ((capabilities & Convert.ToUInt32(Capabilities.CapStatus32.ToString("D"))) ==
Convert.ToUInt32(Capabilities.CapStatus32.ToString("D")))
{
this.negReturnedCap = this.negReturnedCap.Add(Capabilities.CapStatus32);
}
if ((capabilities & Convert.ToUInt32(Capabilities.CapDynamicReauth.ToString("D"))) ==
Convert.ToUInt32(Capabilities.CapDynamicReauth.ToString("D")))
{
this.negReturnedCap = this.negReturnedCap.Add(Capabilities.CapDynamicReauth);
}
if ((capabilities & Convert.ToUInt32(Capabilities.CapLevelIIOplocks.ToString("D"))) ==
Convert.ToUInt32(Capabilities.CapLevelIIOplocks.ToString("D")))
{
this.negReturnedCap = this.negReturnedCap.Add(Capabilities.CapLevelIIOplocks);
}
if ((capabilities & Convert.ToUInt32(Capabilities.CapNtSmbs.ToString("D"))) ==
Convert.ToUInt32(Capabilities.CapNtSmbs.ToString("D")))
{
this.negResponseCap = this.negResponseCap.Add(Capabilities.CapNtSmbs);
}
if ((capabilities & Convert.ToUInt32(Capabilities.CapDfs.ToString("D"))) ==
Convert.ToUInt32(Capabilities.CapDfs.ToString("D")))
{
this.negResponseCap = this.negResponseCap.Add(Capabilities.CapDfs);
}
if ((capabilities & Convert.ToUInt32(Capabilities.CapInfoLevelPassThru.ToString("D"))) ==
Convert.ToUInt32(Capabilities.CapInfoLevelPassThru.ToString("D")))
{
this.negResponseCap = this.negResponseCap.Add(Capabilities.CapInfoLevelPassThru);
}
if ((capabilities & Convert.ToUInt32(Capabilities.CapExtendedSecurity.ToString("D"))) ==
Convert.ToUInt32(Capabilities.CapExtendedSecurity.ToString("D")))
{
this.negResponseCap = this.negResponseCap.Add(Capabilities.CapExtendedSecurity);
}
#endregion
bool isTokenConfiguredToUsed = Boolean.Parse(Site.Properties["IsTokenConfiguredToUsed"]);
bool isReAuthentSupported = Boolean.Parse(Site.Properties["IsReAuthentSupported"]);
VerifyMessageSyntaxSmbComNegotiateExtendedSecurityServerResponse(
smbNegotiateResponse,
isTokenConfiguredToUsed,
isReAuthentSupported);
bool isNTManagerNegotiated = false;
if (smbNegotiateResponse.SmbParameters.DialectIndex == NtManagerNegotiated)
{
isNTManagerNegotiated = true;
}
bool isExtendedSecuritySupported = false;
if (((int)negotiateResponseHeader.Flags2
& (int)SmbHeader_Flags2_Values.SMB_FLAGS2_EXTENDED_SECURITY) ==
(int)SmbHeader_Flags2_Values.SMB_FLAGS2_EXTENDED_SECURITY)
{
isExtendedSecuritySupported = true;
}
bool isPathContainsLongNames = Boolean.Parse(Site.Properties["IsPathContainsLongNames"]);
VerifyMessageSyntaxSMBHeaderExtension(
negotiateResponseHeader,
isNTManagerNegotiated,
isExtendedSecuritySupported,
isPathContainsLongNames);
this.NegotiateResponse(
negotiateResponseHeader.Mid + this.addMidMark,
isSignRequired,
isSignEnabled,
negotiateResponsePayload.DialectIndex,
this.negResponseCap,
(MessageStatus)negotiateResponseHeader.Status);
}
}
else
{
SmbNegotiateImplicitNtlmResponsePacket smbNegotiateImplicitNtlmPacket =
response as SmbNegotiateImplicitNtlmResponsePacket;
NamespaceCifs.SmbHeader negotiateImplicitNtlmResponseHeader =
smbNegotiateImplicitNtlmPacket.SmbHeader;
NamespaceCifs.SMB_COM_NEGOTIATE_NtLanManagerResponse_SMB_Parameters
negotiateImplicitNtlmResponsePayload =
smbNegotiateImplicitNtlmPacket.SmbParameters;
if (negotiateImplicitNtlmResponsePayload.DialectIndex == ServerNotSupportDialectIndex)
{
this.NonExtendedNegotiateResponse(
negotiateImplicitNtlmResponseHeader.Mid + this.addMidMark,
false,
false,
int.MinValue,
new Microsoft.Modeling.Set<Capabilities>(Capabilities.None),
(MessageStatus)negotiateImplicitNtlmResponseHeader.Status);
}
else
{
byte securityMode = (byte)negotiateImplicitNtlmResponsePayload.SecurityMode;
bool isSignEnabled = false;
bool isSignRequired = false;
if ((securityMode & SecurityModeNegotiateSecuritySignatureEnabled) ==
SecurityModeNegotiateSecuritySignatureEnabled)
{
isSignEnabled = true;
}
if ((securityMode & SecurityModeNegotiateSecuritySignatureRequired) ==
SecurityModeNegotiateSecuritySignatureRequired)
{
isSignRequired = true;
}
this.dialectIndex = negotiateImplicitNtlmResponsePayload.DialectIndex;
uint capabilities = (uint)negotiateImplicitNtlmResponsePayload.Capabilities;
if ((capabilities & Convert.ToUInt32(Capabilities.CapUnicode.ToString("D"))) ==
Convert.ToUInt32(Capabilities.CapUnicode.ToString("D")))
{
this.negReturnedCap = this.negReturnedCap.Add(Capabilities.CapUnicode);
}
if ((capabilities & Convert.ToUInt32(Capabilities.CapStatus32.ToString("D"))) ==
Convert.ToUInt32(Capabilities.CapStatus32.ToString("D")))
{
this.negReturnedCap = this.negReturnedCap.Add(Capabilities.CapStatus32);
}
if ((capabilities & Convert.ToUInt32(Capabilities.CapDynamicReauth.ToString("D"))) ==
Convert.ToUInt32(Capabilities.CapDynamicReauth.ToString("D")))
{
this.negReturnedCap = this.negReturnedCap.Add(Capabilities.CapDynamicReauth);
}
if ((capabilities & Convert.ToUInt32(Capabilities.CapLevelIIOplocks.ToString("D"))) ==
Convert.ToUInt32(Capabilities.CapLevelIIOplocks.ToString("D")))
{
this.negReturnedCap = this.negReturnedCap.Add(Capabilities.CapLevelIIOplocks);
}
if ((capabilities & Convert.ToUInt32(Capabilities.CapNtSmbs.ToString("D"))) ==
Convert.ToUInt32(Capabilities.CapNtSmbs.ToString("D")))
{
this.negResponseCap = this.negResponseCap.Add(Capabilities.CapNtSmbs);
}
if ((capabilities & Convert.ToUInt32(Capabilities.CapDfs.ToString("D"))) ==
Convert.ToUInt32(Capabilities.CapDfs.ToString("D")))
{
this.negResponseCap = this.negResponseCap.Add(Capabilities.CapDfs);
}
if ((capabilities & Convert.ToUInt32(Capabilities.CapInfoLevelPassThru.ToString("D"))) ==
Convert.ToUInt32(Capabilities.CapInfoLevelPassThru.ToString("D")))
{
this.negResponseCap = this.negResponseCap.Add(Capabilities.CapInfoLevelPassThru);
}
bool isAuthenticationSupported = Boolean.Parse(Site.Properties["IsAuthenticationSupported"]);
VerifyMessageSyntaxSmbComNegotiateNonExtendedSecurityServerResponse(
smbNegotiateImplicitNtlmPacket,
isAuthenticationSupported);
this.NonExtendedNegotiateResponse(
negotiateImplicitNtlmResponseHeader.Mid + this.addMidMark,
isSignRequired,
isSignEnabled,
this.dialectIndex,
this.negResponseCap,
(MessageStatus)negotiateImplicitNtlmResponseHeader.Status);
}
}
}
#endregion
}
/// <summary>
/// constructor
/// </summary>
internal SmbServerCapability()
: base()
{
this.serverSignState = SignState.DISABLED;
this.IsFromServer = true;
}
/// <summary>
/// constructor
/// </summary>
internal SmbClientCapability()
: base()
{
this.clientSignState = SignState.DISABLED;
}
/// <summary>
/// constructor
/// </summary>
internal SmbClientCapability()
: base()
{
this.clientSignState = SignState.DISABLED;
}
void FinishSign()
{
currentSign.Finish();
signState = SignState.Initialized;
}
public void setValue(String value, int precision, SignState sign)
{
setValue(value, precision, sign, true, Align.RIGHT);
}
public SmbConnection()
{
isClientSupportExtSecurity = false;
sutSignState = SignState.Disabled;
sutCapabilities = new Set<Capabilities>();
isNegotiateSent = false;
sessionList = new MapContainer<int, SmbSession>();
treeConnectList = new MapContainer<int, SmbTree>();
SutNextReceiveSequenceNumber = 1;
SutSendSequenceNumber = new SetContainer<int>();
clientCapabilities = new Set<Capabilities>();
openedFiles = new MapContainer<int, SmbFile>();
openedPipes = new MapContainer<int, SmbPipe>();
openedMailslots = new MapContainer<int, SmbMailslot>();
sentRequest = new MapContainer<int, SmbRequest>();
sessionId = 0;
treeId = 0;
fId = 0;
searchHandlerContainer = new MapContainer<int, int>();
clientSignState = SignState.Disabled;
isSigningActive = false;
accountType = AccountType.Admin;
}
/// <summary>
/// create negotiate request packet. client sends this packet to server to negotiate the dialects.
/// </summary>
/// <param name = "clientSignState">A state that determines whether this node signs messages. </param>
/// <param name = "dialectName">
/// Array of null-terminated ASCII strings that indicate the SMB dialects supported by the client.<para/>
/// the dialects are defined as const strings in the class DialectNameString.
/// </param>
/// <returns>a smb negotiate packet. </returns>
/// <remarks>the SmbMessageUtils.isMessageSigned will be set, when server response. </remarks>
/// <exception cref="ArgumentNullException">the dialectName can not be null</exception>
public virtual SmbNegotiateRequestPacket CreateNegotiateRequest(SignState clientSignState, string[] dialectName)
{
if (dialectName == null)
{
throw new ArgumentNullException("dialectName");
}
// save sign state to context
this.capability.ClientSignState = clientSignState;
SmbHeader_Flags2_Values flag2 = this.capability.Flags2;
if ((clientSignState & SignState.ENABLED) == SignState.ENABLED)
{
flag2 |= SmbHeader_Flags2_Values.SMB_FLAGS2_SMB_SECURITY_SIGNATURE;
}
else if ((clientSignState & SignState.REQUIRED) == SignState.REQUIRED)
{
flag2 |= SmbHeader_Flags2_Values.SMB_FLAGS2_SMB_SECURITY_SIGNATURE_REQUIRED;
}
return CreateNegotiateRequest(
this.MessageId, this.capability.Flag, flag2, dialectName);
}
/// <summary>
/// SMB_COM_NEGOTIATE request.
/// </summary>
/// <param name="dialectNames">The input array of dialects.</param>
/// <param name="messageId">This is used to associate a response with a request.</param>
/// <param name="isSupportExtSecurity">It indicates whether the SUT supports the extended security.</param>
/// <param name="signState">State of the SUT has message signing enabled or required.</param>
public NegotiateRequest(
int messageId,
bool isSupportExtSecurity,
SignState signState,
Sequence<Dialect> dialectNames)
: base(messageId, Command.SmbComNegotiate)
{
this.isSupportExtSecurity = isSupportExtSecurity;
this.signState = signState;
this.dialectNames = dialectNames;
}
/// <summary>
/// It is used to indicate whether sign is enable in this connection.
/// </summary>
/// <param name="clientConnectionSignState">It indicates signstate for client.</param>
/// <param name="sutConnectionSignState">It indicates the signstate for the SUT.</param>
/// <returns>Client sign state.</returns>
public bool isSignEnable(SignState clientConnectionSignState, SignState sutConnectionSignState)
{
if ((clientConnectionSignState == SignState.Required && sutConnectionSignState != SignState.Disabled)
|| (clientConnectionSignState == SignState.Enabled
&& sutConnectionSignState != SignState.Disabled
&& sutConnectionSignState != SignState.DisabledUnlessRequired)
|| (clientConnectionSignState == SignState.DisabledUnlessRequired
&& sutConnectionSignState == SignState.Required))
{
return true;
}
else
{
return false;
}
}
public void SetState(SignState s)
{
state = s;
backgroundObject.SetActive(state != SignState.Normal);
SetTintColor();
}
