/// <summary>
/// Verify FSCTL_SRV_COPYCHUNK Server Response.
/// </summary>
/// <param name="response">The FSCTL_SRV_COPYCHUNK Server Response.</param>
private void VerifyMessageSyntaxFsctlSrvCopychunkResponse(
SmbNtTransFsctlSrvCopyChunkResponsePacket response)
{
//
// The following statement code will be run only when debugging.
//
Site.Log.Add(LogEntryKind.Debug,
@"Verify MS-SMB_R9424");
//
// Verify MS-SMB requirement: MS-SMB_R9424.
//
// The latter half of the requirement is explaining the content of ChunksWritten field and is informative.
Site.CaptureRequirementIfAreEqual<int>(
4,
Marshal.SizeOf(response.NtTransData.ChunksWritten),
9424,
@"[In FSCTL_SRV_COPYCHUNK Response]ChunksWritten (4 bytes): This field MUST represent the number of
copychunk operations successfully processed by the server.");
//
// The following statement code will be run only when debugging.
//
Site.Log.Add(LogEntryKind.Debug,
@"Verify MS-SMB_R9426");
//
// Verify MS-SMB requirement: MS-SMB_R9426.
//
Site.CaptureRequirementIfAreEqual<uint>(
0,
response.NtTransData.ChunkBytesWritten,
9426,
@"[In FSCTL_SRV_COPYCHUNK Response]ChunkBytesWritten (4 bytes): This field MUST be set to zero by the
server.");
//
// The following statement code will be run only when debugging.
//
Site.Log.Add(LogEntryKind.Debug,
@"Verify MS-SMB_R3415");
//
// Verify MS-SMB requirement: MS-SMB_R3415.
//
// The latter half of the requirement is explaining the content of TotalBytesWritten field and is
// informative.
Site.CaptureRequirementIfAreEqual<int>(
4,
Marshal.SizeOf(response.NtTransData.ChunkBytesWritten),
3415,
@"[In FSCTL_SRV_COPYCHUNK Response]TotalBytesWritten (4 bytes): This field MUST represent the total
number of bytes written to the destination file across all copychunk operations.");
//
// The following statement code will be run only when debugging.
//
Site.Log.Add(LogEntryKind.Debug,
@"Verify MS-SMB_R5008");
// The requirement about FSCTL_SRV_COPYCHUNK request have been verified in R9424, R9426, R3415, this
// requirement can be verified directly.
Site.CaptureRequirement(
5008,
@"[In Receiving an FSCTL_SRV_COPYCHUNK Request]If the timeout restriction is not enforced, then the
server MUST process all of the chunks that are described by the request, as specified in section
2.2.7.2.2.<127>");
}
/// <summary>
/// Create FSCTL_SRV_COPYCHUNK Response
/// </summary>
/// <param name="connection">the connection identified the client</param>
/// <param name = "chucksWritten">
/// This value MUST be the number of chunks successfully processed by the server
/// </param>
/// <param name = "chuckBytesWritten">
/// This value MUST be the number of bytes written to the target file
/// </param>
/// <param name = "totalBytesWritten">
/// This value MUST be the total number of bytes written to the target file
/// </param>
/// <returns>The SmbNtTransFsctlSrvCopyChunkResponsePacket </returns>
/// <exception cref="ArgumentNullException">connection must not be null</exception>
public virtual SmbNtTransFsctlSrvCopyChunkResponsePacket CreateFsctlSrvCopyChunkResponse(
SmbServerConnection connection,
uint chucksWritten,
uint chuckBytesWritten,
uint totalBytesWritten)
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
SmbNtTransFsctlSrvCopyChunkResponsePacket packet = new SmbNtTransFsctlSrvCopyChunkResponsePacket();
// get the request packet
SmbPacket request = connection.GetRequestPacket(connection.MessageId);
// create smb packet header
packet.SmbHeader = CifsMessageUtils.CreateSmbHeader(
SmbCommand.SMB_COM_NT_TRANSACT,
connection.ProcessId, connection.MessageId, request.SmbHeader.Uid, request.SmbHeader.Tid,
(SmbFlags)connection.Capability.Flag, (SmbFlags2)connection.Capability.Flags2);
// update smb parameters
SMB_COM_NT_TRANSACT_SuccessResponse_SMB_Parameters smbParameters = packet.SmbParameters;
// reserved 3 bytes.
smbParameters.Reserved1 = new byte[3];
smbParameters.Setup = new ushort[0];
smbParameters.WordCount = (byte)(CifsMessageUtils.GetSize<SMB_COM_NT_TRANSACT_SuccessResponse_SMB_Parameters>(
smbParameters) / SmbCapability.NUM_BYTES_OF_WORD);
// update smb data
SMB_COM_NT_TRANSACT_SuccessResponse_SMB_Data smbData = packet.SmbData;
// update trans2 data
NT_TRANSACT_COPY_CHUNK_Response_NT_Trans_Data ntTransData = packet.NtTransData;
ntTransData.ChunksWritten = chucksWritten;
ntTransData.ChunkBytesWritten = chuckBytesWritten;
ntTransData.TotalBytesWritten = totalBytesWritten;
// store the parameters and data to packet.
packet.NtTransData = ntTransData;
packet.SmbParameters = smbParameters;
packet.SmbData = smbData;
packet.UpdateCountAndOffset();
return packet;
}
/// <summary>
/// create the nt transaction packet
/// </summary>
/// <param name="request">the request packet</param>
/// <param name="smbHeader">the smb header of response packet</param>
/// <param name="channel">the channel contains the packet bytes</param>
/// <returns>the response packet</returns>
private SmbPacket CreateNtTransactionResponsePacket(SmbPacket request, SmbHeader smbHeader, Channel channel)
{
SmbPacket smbPacket = null;
if (smbHeader.Status == 0 && channel.Peek<byte>(0) == 0 && channel.Peek<ushort>(1) == 0)
{
return smbPacket;
}
SmbNtTransactRequestPacket ntTransactRequest = request as SmbNtTransactRequestPacket;
if (ntTransactRequest == null)
{
return smbPacket;
}
// find regular packet
switch ((uint)ntTransactRequest.SmbParameters.Function)
{
case (uint)NtTransSubCommand.NT_TRANSACT_RENAME:
smbPacket = new SmbNtTransRenameResponsePacket();
break;
case (uint)NtTransSubCommand.NT_TRANSACT_CREATE:
smbPacket = new SmbNtTransactCreateResponsePacket();
break;
case (uint)NtTransSubCommand.NT_TRANSACT_IOCTL:
NT_TRANSACT_IOCTL_SETUP setup =
CifsMessageUtils.ToStuct<NT_TRANSACT_IOCTL_SETUP>(
CifsMessageUtils.ToBytesArray<ushort>(ntTransactRequest.SmbParameters.Setup));
switch ((NtTransFunctionCode)setup.FunctionCode)
{
case NtTransFunctionCode.FSCTL_SRV_ENUMERATE_SNAPSHOTS:
smbPacket = new SmbNtTransFsctlSrvEnumerateSnapshotsResponsePacket();
break;
case NtTransFunctionCode.FSCTL_SRV_REQUEST_RESUME_KEY:
smbPacket = new SmbNtTransFsctlSrvRequestResumeKeyResponsePacket();
break;
case NtTransFunctionCode.FSCTL_SRV_COPYCHUNK:
smbPacket = new SmbNtTransFsctlSrvCopyChunkResponsePacket();
break;
default:
smbPacket = new SmbNtTransactIoctlResponsePacket();
break;
}
break;
case (uint)SmbNtTransSubCommand.NT_TRANSACT_QUERY_QUOTA:
smbPacket = new SmbNtTransQueryQuotaResponsePacket();
break;
case (uint)SmbNtTransSubCommand.NT_TRANSACT_SET_QUOTA:
smbPacket = new SmbNtTransSetQuotaResponsePacket();
break;
default:
break;
}
return smbPacket;
}
/// <summary>
/// Deep copy constructor.
/// </summary>
public SmbNtTransFsctlSrvCopyChunkResponsePacket(
SmbNtTransFsctlSrvCopyChunkResponsePacket packet)
: base(packet)
{
}
/// <summary>
/// create the nt transaction packet
/// </summary>
/// <param name="request">the request packet</param>
/// <param name="smbHeader">the smb header of response packet</param>
/// <param name="channel">the channel contains the packet bytes</param>
/// <returns>the response packet</returns>
private SmbPacket CreateNtTransactionResponsePacket(SmbPacket request, SmbHeader smbHeader, Channel channel)
{
SmbPacket smbPacket = null;
if (smbHeader.Status == 0 && channel.Peek <byte>(0) == 0 && channel.Peek <ushort>(1) == 0)
{
return(smbPacket);
}
SmbNtTransactRequestPacket ntTransactRequest = request as SmbNtTransactRequestPacket;
if (ntTransactRequest == null)
{
return(smbPacket);
}
// find regular packet
switch ((uint)ntTransactRequest.SmbParameters.Function)
{
case (uint)NtTransSubCommand.NT_TRANSACT_RENAME:
smbPacket = new SmbNtTransRenameResponsePacket();
break;
case (uint)NtTransSubCommand.NT_TRANSACT_CREATE:
smbPacket = new SmbNtTransactCreateResponsePacket();
break;
case (uint)NtTransSubCommand.NT_TRANSACT_IOCTL:
NT_TRANSACT_IOCTL_SETUP setup =
CifsMessageUtils.ToStuct <NT_TRANSACT_IOCTL_SETUP>(
CifsMessageUtils.ToBytesArray <ushort>(ntTransactRequest.SmbParameters.Setup));
switch ((NtTransFunctionCode)setup.FunctionCode)
{
case NtTransFunctionCode.FSCTL_SRV_ENUMERATE_SNAPSHOTS:
smbPacket = new SmbNtTransFsctlSrvEnumerateSnapshotsResponsePacket();
break;
case NtTransFunctionCode.FSCTL_SRV_REQUEST_RESUME_KEY:
smbPacket = new SmbNtTransFsctlSrvRequestResumeKeyResponsePacket();
break;
case NtTransFunctionCode.FSCTL_SRV_COPYCHUNK:
smbPacket = new SmbNtTransFsctlSrvCopyChunkResponsePacket();
break;
default:
smbPacket = new SmbNtTransactIoctlResponsePacket();
break;
}
break;
case (uint)SmbNtTransSubCommand.NT_TRANSACT_QUERY_QUOTA:
smbPacket = new SmbNtTransQueryQuotaResponsePacket();
break;
case (uint)SmbNtTransSubCommand.NT_TRANSACT_SET_QUOTA:
smbPacket = new SmbNtTransSetQuotaResponsePacket();
break;
default:
break;
}
return(smbPacket);
}
/// <summary>
/// Verify whether the two response are equal or not
/// </summary>
/// <param name="smbFsctlSrvCopyChunkPacket1"> The SmbNtTransFsctlSrvCopyChunkResponsePacket Response For First</param>
/// <param name="smbFsctlSrvCopyChunkPacket2"> The SmbNtTransFsctlSrvCopyChunkResponsePacket Response For Second</param>
private bool VerifyResponse(
SmbNtTransFsctlSrvCopyChunkResponsePacket smbFsctlSrvCopyChunkPacket1,
SmbNtTransFsctlSrvCopyChunkResponsePacket smbFsctlSrvCopyChunkPacket2)
{
return (smbFsctlSrvCopyChunkPacket1.IsSignRequired == smbFsctlSrvCopyChunkPacket2.IsSignRequired)
&& (smbFsctlSrvCopyChunkPacket1.NtTransData.ChunkBytesWritten ==
smbFsctlSrvCopyChunkPacket2.NtTransData.ChunkBytesWritten)
&& (smbFsctlSrvCopyChunkPacket1.NtTransData.ChunksWritten ==
smbFsctlSrvCopyChunkPacket2.NtTransData.ChunksWritten)
&& (smbFsctlSrvCopyChunkPacket1.NtTransData.TotalBytesWritten ==
smbFsctlSrvCopyChunkPacket2.NtTransData.TotalBytesWritten)
&& (smbFsctlSrvCopyChunkPacket1.PacketType == smbFsctlSrvCopyChunkPacket2.PacketType)
&& (smbFsctlSrvCopyChunkPacket1.SmbData.ByteCount == smbFsctlSrvCopyChunkPacket2.SmbData.ByteCount)
&& CompareArrayEquals(
smbFsctlSrvCopyChunkPacket1.SmbData.Data,
smbFsctlSrvCopyChunkPacket2.SmbData.Data)
&& CompareArrayEquals(
smbFsctlSrvCopyChunkPacket1.SmbData.Pad1,
smbFsctlSrvCopyChunkPacket2.SmbData.Pad1)
&& CompareArrayEquals(
smbFsctlSrvCopyChunkPacket1.SmbData.Pad2,
smbFsctlSrvCopyChunkPacket2.SmbData.Pad2)
&& CompareArrayEquals(
smbFsctlSrvCopyChunkPacket1.SmbData.Parameters,
smbFsctlSrvCopyChunkPacket2.SmbData.Parameters)
&& (smbFsctlSrvCopyChunkPacket1.SmbParameters.DataCount ==
smbFsctlSrvCopyChunkPacket2.SmbParameters.DataCount)
&& (smbFsctlSrvCopyChunkPacket1.SmbParameters.DataDisplacement ==
smbFsctlSrvCopyChunkPacket2.SmbParameters.DataDisplacement)
&& (smbFsctlSrvCopyChunkPacket1.SmbParameters.DataOffset ==
smbFsctlSrvCopyChunkPacket2.SmbParameters.DataOffset)
&& (smbFsctlSrvCopyChunkPacket1.SmbParameters.ParameterCount ==
smbFsctlSrvCopyChunkPacket2.SmbParameters.ParameterCount)
&& (smbFsctlSrvCopyChunkPacket1.SmbParameters.ParameterDisplacement ==
smbFsctlSrvCopyChunkPacket2.SmbParameters.ParameterDisplacement)
&& (smbFsctlSrvCopyChunkPacket1.SmbParameters.ParameterOffset ==
smbFsctlSrvCopyChunkPacket2.SmbParameters.ParameterOffset)
&& CompareArrayEquals(
smbFsctlSrvCopyChunkPacket1.SmbParameters.Reserved1,
smbFsctlSrvCopyChunkPacket2.SmbParameters.Reserved1)
&& CompareArrayEquals(
smbFsctlSrvCopyChunkPacket1.SmbParameters.Setup,
smbFsctlSrvCopyChunkPacket2.SmbParameters.Setup)
&& (smbFsctlSrvCopyChunkPacket1.SmbParameters.SetupCount ==
smbFsctlSrvCopyChunkPacket2.SmbParameters.SetupCount)
&& (smbFsctlSrvCopyChunkPacket1.SmbParameters.TotalDataCount ==
smbFsctlSrvCopyChunkPacket2.SmbParameters.TotalDataCount)
&& (smbFsctlSrvCopyChunkPacket1.SmbParameters.TotalParameterCount ==
smbFsctlSrvCopyChunkPacket2.SmbParameters.TotalParameterCount)
&& (smbFsctlSrvCopyChunkPacket1.SmbParameters.WordCount ==
smbFsctlSrvCopyChunkPacket2.SmbParameters.WordCount);
}
/// <summary>
/// Deep copy constructor.
/// </summary>
public SmbNtTransFsctlSrvCopyChunkResponsePacket(
SmbNtTransFsctlSrvCopyChunkResponsePacket packet)
: base(packet)
{
}
