/// <summary>
/// Deep copy constructor.
/// </summary>
public SmbNegotiateRequestPacket(SmbNegotiateRequestPacket packet)
: base(packet)
{
}
/// <summary>
/// update the context with request packet
/// </summary>
/// <param name="connection">the connection of endpoint</param>
/// <param name="packet">the packet to update the context</param>
private void RequestPacketUpdateRoleContext(SmbServerConnection connection, SmbPacket packet)
{
connection.AddRequestPacket(packet);
// update the message id
connection.MessageId = packet.SmbHeader.Mid;
// update the process id
connection.ProcessId = (uint)(packet.SmbHeader.PidHigh << 16);
connection.ProcessId += packet.SmbHeader.PidLow;
// update the message sign sequence number
if (packet.SmbHeader.SecurityFeatures != 0 &&
connection.GssApi != null && connection.GssApi.SessionKey != null)
{
if (packet.SmbHeader.Command == SmbCommand.SMB_COM_NT_CANCEL)
{
connection.ServerNextReceiveSequenceNumber++;
}
else
{
ServerSendSequenceNumberKey key = new ServerSendSequenceNumberKey();
key.PidHigh = packet.SmbHeader.PidHigh;
key.PidLow = packet.SmbHeader.PidLow;
key.Mid = packet.SmbHeader.Mid;
connection.ServerSendSequenceNumber[key] = connection.ServerNextReceiveSequenceNumber + 1;
connection.ServerNextReceiveSequenceNumber += 2;
}
}
// process each special command
switch (packet.SmbHeader.Command)
{
case SmbCommand.SMB_COM_NEGOTIATE:
SmbNegotiateRequestPacket request = packet as SmbNegotiateRequestPacket;
byte[] dialects = request.SmbData.Dialects;
List <string> negotiateDialects = new List <string>();
for (int i = 0; i < dialects.Length; i++)
{
if (dialects[i] == 0x02)
{
continue;
}
string dialect = "";
for (; i < dialects.Length && dialects[i] != 0x00; i++)
{
dialect += (char)dialects[i];
}
negotiateDialects.Add(dialect);
}
connection.NegotiatedDialects = negotiateDialects.ToArray();
break;
case SmbCommand.SMB_COM_TREE_CONNECT_ANDX:
// down-case the packet
Cifs.SmbTreeConnectAndxRequestPacket treeconnect = packet as Cifs.SmbTreeConnectAndxRequestPacket;
// get the specified session.
SmbServerSession treeconnectSession = connection.GetSession((ushort)treeconnect.SmbHeader.Uid);
if (treeconnectSession == null)
{
return;
}
// Calculate the one-way hash
byte[] sessionKey = FileServiceUtils.ProtectSessionKey(treeconnectSession.SessionKey);
// update the session key state.
treeconnectSession.SessionKeyState = SessionKeyStateValue.Available;
// if server does not support SMB_EXTENDED_SIGNATURES, return.
if (SmbClientTreeConnect.TreeConnectAndxExtendedSignatures !=
(treeconnect.SmbParameters.Flags & SmbClientTreeConnect.TreeConnectAndxExtendedSignatures))
{
return;
}
treeconnectSession.SessionKey = sessionKey;
break;
default:
return;
}
return;
}
/// <summary>
/// find the target packet.
/// </summary>
/// <param name="smbHeader">the header of smb packet</param>
/// <param name="channel">the channel to access bytes</param>
/// <returns>the target packet</returns>
private static SmbPacket FindTheTargetPacket(SmbHeader smbHeader, Channel channel)
{
SmbPacket smbPacket = null;
switch (smbHeader.Command)
{
case SmbCommand.SMB_COM_NEGOTIATE:
smbPacket = new SmbNegotiateRequestPacket();
break;
case SmbCommand.SMB_COM_SESSION_SETUP_ANDX:
SmbHeader_Flags2_Values flags2 = (SmbHeader_Flags2_Values)smbHeader.Flags2;
if ((flags2 & SmbHeader_Flags2_Values.SMB_FLAGS2_EXTENDED_SECURITY)
== SmbHeader_Flags2_Values.SMB_FLAGS2_EXTENDED_SECURITY)
{
smbPacket = new Smb.SmbSessionSetupAndxRequestPacket();
}
else
{
smbPacket = new Cifs.SmbSessionSetupAndxRequestPacket();
}
break;
case SmbCommand.SMB_COM_TREE_CONNECT_ANDX:
smbPacket = new SmbTreeConnectAndxRequestPacket();
break;
case SmbCommand.SMB_COM_NT_CREATE_ANDX:
smbPacket = new SmbNtCreateAndxRequestPacket();
break;
case SmbCommand.SMB_COM_OPEN_ANDX:
smbPacket = new SmbOpenAndxRequestPacket();
break;
case SmbCommand.SMB_COM_WRITE_ANDX:
smbPacket = new SmbWriteAndxRequestPacket();
break;
case SmbCommand.SMB_COM_READ_ANDX:
smbPacket = new SmbReadAndxRequestPacket();
break;
case SmbCommand.SMB_COM_CLOSE:
smbPacket = new SmbCloseRequestPacket();
break;
case SmbCommand.SMB_COM_TREE_DISCONNECT:
smbPacket = new SmbTreeDisconnectRequestPacket();
break;
case SmbCommand.SMB_COM_LOGOFF_ANDX:
smbPacket = new SmbLogoffAndxRequestPacket();
break;
case SmbCommand.SMB_COM_TRANSACTION:
SMB_COM_TRANSACTION_Request_SMB_Parameters transaction =
channel.Read <SMB_COM_TRANSACTION_Request_SMB_Parameters>();
if (transaction.SetupCount == 0)
{
smbPacket = new SmbTransRapRequestPacket();
}
else
{
smbPacket = FindTheTransactionPacket(
transaction.SetupCount, (TransSubCommand)transaction.Setup[0]);
}
break;
case SmbCommand.SMB_COM_TRANSACTION2:
SMB_COM_TRANSACTION2_Request_SMB_Parameters transaction2 =
channel.Read <SMB_COM_TRANSACTION2_Request_SMB_Parameters>();
smbPacket = FindTheTrans2Packet((Trans2SubCommand)transaction2.Subcommand);
break;
case SmbCommand.SMB_COM_NT_TRANSACT:
SMB_COM_NT_TRANSACT_Request_SMB_Parameters ntTransactoin =
channel.Read <SMB_COM_NT_TRANSACT_Request_SMB_Parameters>();
smbPacket = FindTheNtTransPacket(ntTransactoin.Function, CifsMessageUtils.ToBytesArray <ushort>(ntTransactoin.Setup));
break;
default:
break;
}
return(smbPacket);
}
/// <summary>
/// Deep copy constructor.
/// </summary>
public SmbNegotiateRequestPacket(SmbNegotiateRequestPacket packet)
: base(packet)
{
}
