public static async Task <string> ReadAsciiString(this Stream stream)
{
return(LittleEndianConverter.ConvertToAsciiString(await stream.ReadBytes(4)));
}
public QueryFileEaInfo(byte[] buffer, int offset)
{
EaSize = LittleEndianConverter.ToUInt32(buffer, offset);
}
public Transaction2QueryPathInformationResponse(byte[] parameters, byte[] data)
{
EaErrorOffset = LittleEndianConverter.ToUInt16(parameters, 0);
InformationBytes = data;
}
public override byte[] GetSetup()
{
return(LittleEndianConverter.GetBytes((ushort)SubcommandName));
}
public static ushort GetPDULength(byte[] buffer, int offset)
{
ushort fragmentLength = LittleEndianConverter.ToUInt16(buffer, offset + 8);
return(fragmentLength);
}
public TransactionCallNamedPipeRequest(byte[] setup, byte[] data) : base()
{
Priority = LittleEndianConverter.ToUInt16(setup, 2);
WriteData = data;
}
public NTTransactQuerySecurityDescriptorRequest(byte[] parameters)
{
FID = LittleEndianConverter.ToUInt16(parameters, 0);
Reserved = LittleEndianConverter.ToUInt16(parameters, 2);
SecurityInfoFields = (SecurityInformation)LittleEndianConverter.ToUInt32(parameters, 4);
}
public PtypObjectRecord(byte[] buffer)
{
Nid = new NodeID(buffer, 0x00);
ulSize = LittleEndianConverter.ToUInt32(buffer, 0x04);
}
public static SMB2Command ReadResponse(byte[] buffer, int offset)
{
SMB2CommandName commandName = (SMB2CommandName)LittleEndianConverter.ToUInt16(buffer, offset + 12);
ushort structureSize = LittleEndianConverter.ToUInt16(buffer, offset + SMB2Header.Length + 0);
switch (commandName)
{
case SMB2CommandName.Negotiate:
{
if (structureSize == NegotiateResponse.DeclaredSize)
{
return(new NegotiateResponse(buffer, offset));
}
else if (structureSize == ErrorResponse.DeclaredSize)
{
return(new ErrorResponse(buffer, offset));
}
else
{
throw new InvalidDataException();
}
}
case SMB2CommandName.SessionSetup:
{
// SESSION_SETUP Response and ERROR Response have the same declared StructureSize of 9.
if (structureSize == SessionSetupResponse.DeclaredSize)
{
NTStatus status = (NTStatus)LittleEndianConverter.ToUInt32(buffer, offset + 8);
if (status == NTStatus.STATUS_SUCCESS || status == NTStatus.STATUS_MORE_PROCESSING_REQUIRED)
{
return(new SessionSetupResponse(buffer, offset));
}
else
{
return(new ErrorResponse(buffer, offset));
}
}
else
{
throw new InvalidDataException();
}
}
case SMB2CommandName.Logoff:
{
if (structureSize == LogoffResponse.DeclaredSize)
{
return(new LogoffResponse(buffer, offset));
}
else if (structureSize == ErrorResponse.DeclaredSize)
{
return(new ErrorResponse(buffer, offset));
}
else
{
throw new InvalidDataException();
}
}
case SMB2CommandName.TreeConnect:
{
if (structureSize == TreeConnectResponse.DeclaredSize)
{
return(new TreeConnectResponse(buffer, offset));
}
else if (structureSize == ErrorResponse.DeclaredSize)
{
return(new ErrorResponse(buffer, offset));
}
else
{
throw new InvalidDataException();
}
}
case SMB2CommandName.TreeDisconnect:
{
if (structureSize == TreeDisconnectResponse.DeclaredSize)
{
return(new TreeDisconnectResponse(buffer, offset));
}
else if (structureSize == ErrorResponse.DeclaredSize)
{
return(new ErrorResponse(buffer, offset));
}
else
{
throw new InvalidDataException();
}
}
case SMB2CommandName.Create:
{
if (structureSize == CreateResponse.DeclaredSize)
{
return(new CreateResponse(buffer, offset));
}
else if (structureSize == ErrorResponse.DeclaredSize)
{
return(new ErrorResponse(buffer, offset));
}
else
{
throw new InvalidDataException();
}
}
case SMB2CommandName.Close:
{
if (structureSize == CloseResponse.DeclaredSize)
{
return(new CloseResponse(buffer, offset));
}
else if (structureSize == ErrorResponse.DeclaredSize)
{
return(new ErrorResponse(buffer, offset));
}
else
{
throw new InvalidDataException();
}
}
case SMB2CommandName.Flush:
{
if (structureSize == FlushResponse.DeclaredSize)
{
return(new FlushResponse(buffer, offset));
}
else if (structureSize == ErrorResponse.DeclaredSize)
{
return(new ErrorResponse(buffer, offset));
}
else
{
throw new InvalidDataException();
}
}
case SMB2CommandName.Read:
{
if (structureSize == SMB2.ReadResponse.DeclaredSize)
{
return(new ReadResponse(buffer, offset));
}
else if (structureSize == ErrorResponse.DeclaredSize)
{
return(new ErrorResponse(buffer, offset));
}
else
{
throw new InvalidDataException();
}
}
case SMB2CommandName.Write:
{
if (structureSize == WriteResponse.DeclaredSize)
{
return(new WriteResponse(buffer, offset));
}
else if (structureSize == ErrorResponse.DeclaredSize)
{
return(new ErrorResponse(buffer, offset));
}
else
{
throw new InvalidDataException();
}
}
case SMB2CommandName.Lock:
{
if (structureSize == LockResponse.DeclaredSize)
{
return(new LockResponse(buffer, offset));
}
else if (structureSize == ErrorResponse.DeclaredSize)
{
return(new ErrorResponse(buffer, offset));
}
else
{
throw new InvalidDataException();
}
}
case SMB2CommandName.IOCtl:
{
if (structureSize == IOCtlResponse.DeclaredSize)
{
return(new IOCtlResponse(buffer, offset));
}
else if (structureSize == ErrorResponse.DeclaredSize)
{
return(new ErrorResponse(buffer, offset));
}
else
{
throw new InvalidDataException();
}
}
case SMB2CommandName.Cancel:
{
if (structureSize == ErrorResponse.DeclaredSize)
{
return(new ErrorResponse(buffer, offset));
}
else
{
throw new InvalidDataException();
}
}
case SMB2CommandName.Echo:
{
if (structureSize == EchoResponse.DeclaredSize)
{
return(new EchoResponse(buffer, offset));
}
else if (structureSize == ErrorResponse.DeclaredSize)
{
return(new ErrorResponse(buffer, offset));
}
else
{
throw new InvalidDataException();
}
}
case SMB2CommandName.QueryDirectory:
{
// QUERY_DIRECTORY Response and ERROR Response have the same declared StructureSize of 9.
if (structureSize == QueryDirectoryResponse.DeclaredSize)
{
NTStatus status = (NTStatus)LittleEndianConverter.ToUInt32(buffer, offset + 8);
if (status == NTStatus.STATUS_SUCCESS)
{
return(new QueryDirectoryResponse(buffer, offset));
}
else
{
return(new ErrorResponse(buffer, offset));
}
}
else
{
throw new InvalidDataException();
}
}
case SMB2CommandName.ChangeNotify:
{
// CHANGE_NOTIFY Response and ERROR Response have the same declared StructureSize of 9.
if (structureSize == ChangeNotifyResponse.DeclaredSize)
{
NTStatus status = (NTStatus)LittleEndianConverter.ToUInt32(buffer, offset + 8);
if (status == NTStatus.STATUS_SUCCESS ||
status == NTStatus.STATUS_NOTIFY_CLEANUP ||
status == NTStatus.STATUS_NOTIFY_ENUM_DIR)
{
return(new ChangeNotifyResponse(buffer, offset));
}
else
{
return(new ErrorResponse(buffer, offset));
}
}
else
{
throw new InvalidDataException();
}
}
case SMB2CommandName.QueryInfo:
{
// QUERY_INFO Response and ERROR Response have the same declared StructureSize of 9.
if (structureSize == QueryInfoResponse.DeclaredSize)
{
NTStatus status = (NTStatus)LittleEndianConverter.ToUInt32(buffer, offset + 8);
if (status == NTStatus.STATUS_SUCCESS || status == NTStatus.STATUS_BUFFER_OVERFLOW)
{
return(new QueryInfoResponse(buffer, offset));
}
else
{
return(new ErrorResponse(buffer, offset));
}
}
else
{
throw new InvalidDataException();
}
}
case SMB2CommandName.SetInfo:
{
if (structureSize == SetInfoResponse.DeclaredSize)
{
return(new SetInfoResponse(buffer, offset));
}
else if (structureSize == ErrorResponse.DeclaredSize)
{
return(new ErrorResponse(buffer, offset));
}
else
{
throw new InvalidDataException();
}
}
default:
throw new InvalidDataException("Invalid SMB2 command 0x" + ((ushort)commandName).ToString("X4"));
}
}
public static DateTime ReadUTime(byte[] buffer, int offset)
{
uint span = LittleEndianConverter.ToUInt32(buffer, offset);
return(MinUTimeValue.AddSeconds(span));
}
public EchoResponse(byte[] buffer, int offset) : base(buffer, offset, false)
{
SequenceNumber = LittleEndianConverter.ToUInt16(this.SMBParameters, 0);
}
/// <summary>
/// When setting file attributes, a value of -1 indicates to the server that it MUST NOT change this attribute for all subsequent operations on the same file handle.
/// </summary>
public static SetFileTime ReadSetFileTime(byte[] buffer, int offset)
{
long span = LittleEndianConverter.ToInt64(buffer, offset);
return(SetFileTime.FromFileTimeUtc(span));
}
public static async Task <short> ReadInt16(this Stream stream)
{
return(LittleEndianConverter.ConvertToInt16(await stream.ReadBytes(2)));
}
public static async Task <string> ReadString(this Stream stream, int length)
{
return(LittleEndianConverter.ConvertToIso88591String(await stream.ReadBytes(length)));
}
public TransactionWriteNamedPipeResponse(byte[] parameters) : base()
{
BytesWritten = LittleEndianConverter.ToUInt16(parameters, 0);
}
public static SMB2Command ReadRequest(byte[] buffer, int offset)
{
SMB2CommandName commandName = (SMB2CommandName)LittleEndianConverter.ToUInt16(buffer, offset + 12);
switch (commandName)
{
case SMB2CommandName.Negotiate:
return(new NegotiateRequest(buffer, offset));
case SMB2CommandName.SessionSetup:
return(new SessionSetupRequest(buffer, offset));
case SMB2CommandName.Logoff:
return(new LogoffRequest(buffer, offset));
case SMB2CommandName.TreeConnect:
return(new TreeConnectRequest(buffer, offset));
case SMB2CommandName.TreeDisconnect:
return(new TreeDisconnectRequest(buffer, offset));
case SMB2CommandName.Create:
return(new CreateRequest(buffer, offset));
case SMB2CommandName.Close:
return(new CloseRequest(buffer, offset));
case SMB2CommandName.Flush:
return(new FlushRequest(buffer, offset));
case SMB2CommandName.Read:
return(new ReadRequest(buffer, offset));
case SMB2CommandName.Write:
return(new WriteRequest(buffer, offset));
case SMB2CommandName.Lock:
return(new LockRequest(buffer, offset));
case SMB2CommandName.IOCtl:
return(new IOCtlRequest(buffer, offset));
case SMB2CommandName.Cancel:
return(new CancelRequest(buffer, offset));
case SMB2CommandName.Echo:
return(new EchoRequest(buffer, offset));
case SMB2CommandName.QueryDirectory:
return(new QueryDirectoryRequest(buffer, offset));
case SMB2CommandName.ChangeNotify:
return(new ChangeNotifyRequest(buffer, offset));
case SMB2CommandName.QueryInfo:
return(new QueryInfoRequest(buffer, offset));
case SMB2CommandName.SetInfo:
return(new SetInfoRequest(buffer, offset));
default:
throw new InvalidDataException("Invalid SMB2 command 0x" + ((ushort)commandName).ToString("X4"));
}
}
public override byte[] GetParameters(bool isUnicode)
{
return(LittleEndianConverter.GetBytes(BytesWritten));
}
public TransactionRawWriteNamedPipeRequest(byte[] setup, byte[] data) : base()
{
FID = LittleEndianConverter.ToUInt16(setup, 2);
WriteData = data;
}
public static TransactionSubcommand GetSubcommandRequest(byte[] setup, byte[] parameters, byte[] data, bool isUnicode)
{
if (setup.Length == 4)
{
TransactionSubcommandName subcommandName = (TransactionSubcommandName)LittleEndianConverter.ToUInt16(setup, 0);
switch (subcommandName)
{
case TransactionSubcommandName.TRANS_SET_NMPIPE_STATE:
return(new TransactionSetNamedPipeStateRequest(setup, parameters));
case TransactionSubcommandName.TRANS_RAW_READ_NMPIPE:
return(new TransactionRawReadNamedPipeRequest(setup));
case TransactionSubcommandName.TRANS_QUERY_NMPIPE_STATE:
return(new TransactionQueryNamedPipeStateRequest(setup, parameters));
case TransactionSubcommandName.TRANS_QUERY_NMPIPE_INFO:
return(new TransactionQueryNamedPipeInfoRequest(setup, parameters));
case TransactionSubcommandName.TRANS_PEEK_NMPIPE:
return(new TransactionPeekNamedPipeRequest(setup));
case TransactionSubcommandName.TRANS_TRANSACT_NMPIPE:
return(new TransactionTransactNamedPipeRequest(setup, data));
case TransactionSubcommandName.TRANS_RAW_WRITE_NMPIPE:
return(new TransactionRawWriteNamedPipeRequest(setup, data));
case TransactionSubcommandName.TRANS_READ_NMPIPE:
return(new TransactionReadNamedPipeRequest(setup));
case TransactionSubcommandName.TRANS_WRITE_NMPIPE:
return(new TransactionWriteNamedPipeRequest(setup, data));
case TransactionSubcommandName.TRANS_WAIT_NMPIPE:
return(new TransactionWaitNamedPipeRequest(setup));
case TransactionSubcommandName.TRANS_CALL_NMPIPE:
return(new TransactionCallNamedPipeRequest(setup, data));
}
}
throw new InvalidDataException();
}
public WriteResponse(byte[] buffer, int offset) : base(buffer, offset)
{
CountOfBytesWritten = LittleEndianConverter.ToUInt16(SMBParameters, 0);
}
public Transaction2QueryFSInformationRequest(byte[] parameters, byte[] data, bool isUnicode) : base()
{
InformationLevel = (QueryFSInformationLevel)LittleEndianConverter.ToUInt16(parameters, 0);
}
public BitmapRange(byte[] buffer, int offset)
{
BitmapOffset = LittleEndianConverter.ToUInt32(buffer, offset + 0x00);
NumberOfBits = LittleEndianConverter.ToUInt32(buffer, offset + 0x04);
}
public Transaction2SetPathInformationResponse(byte[] parameters, byte[] data, bool isUnicode) : base()
{
EaErrorOffset = LittleEndianConverter.ToUInt16(parameters, 0);
}
public NTTransactIOCTLResponse(byte[] setup, byte[] data) : base()
{
TransactionDataSize = LittleEndianConverter.ToUInt16(setup, 0);
Data = data;
}
public VolumeInformationRecord(byte[] buffer, int offset) : base(buffer, offset)
{
MajorVersion = ByteReader.ReadByte(this.Data, 0x08);
MinorVersion = ByteReader.ReadByte(this.Data, 0x09);
VolumeFlags = (VolumeFlags)LittleEndianConverter.ToUInt16(this.Data, 0x0A);
}
public RequestGetDfsReferral(byte[] buffer)
{
MaxReferralLevel = LittleEndianConverter.ToUInt16(buffer, 0);
RequestFileName = ByteReader.ReadNullTerminatedUTF16String(buffer, 2);
}
public override byte[] GetBytes()
{
return(LittleEndianConverter.GetBytes(EaSize));
}
public FileEndOfFileInformation(byte[] buffer, int offset)
{
EndOfFile = LittleEndianConverter.ToInt64(buffer, offset);
}
public override byte[] GetParameters(bool isUnicode)
{
return(LittleEndianConverter.GetBytes(EaErrorOffset));
}
public static async Task WriteLittleEndianUInt32(this Stream stream, uint value)
{
await stream.WriteBytes(LittleEndianConverter.ConvertToBytes(value));
}
