public string NativeLanMan; // SMB_STRING (this field WILL be aligned to start on a 2-byte boundary from the start of the SMB header)
public SessionSetupAndXRequest(byte[] buffer, int offset, bool isUnicode) : base(buffer, offset, isUnicode)
{
MaxBufferSize = LittleEndianConverter.ToUInt16(this.SMBParameters, 4);
MaxMpxCount = LittleEndianConverter.ToUInt16(this.SMBParameters, 6);
VcNumber = LittleEndianConverter.ToUInt16(this.SMBParameters, 8);
SessionKey = LittleEndianConverter.ToUInt32(this.SMBParameters, 10);
ushort OEMPasswordLength = LittleEndianConverter.ToUInt16(this.SMBParameters, 14);
ushort UnicodePasswordLength = LittleEndianConverter.ToUInt16(this.SMBParameters, 16);
Reserved = LittleEndianConverter.ToUInt32(this.SMBParameters, 18);
Capabilities = (ServerCapabilities)LittleEndianConverter.ToUInt32(this.SMBParameters, 22);
OEMPassword = ByteReader.ReadBytes(this.SMBData, 0, OEMPasswordLength);
UnicodePassword = ByteReader.ReadBytes(this.SMBData, OEMPasswordLength, UnicodePasswordLength);
int dataOffset = OEMPasswordLength + UnicodePasswordLength;
if (isUnicode)
{
// wordCount is 1 byte
int padding = (1 + OEMPasswordLength + UnicodePasswordLength) % 2;
dataOffset += padding;
}
AccountName = SMBHelper.ReadSMBString(this.SMBData, ref dataOffset, isUnicode);
PrimaryDomain = SMBHelper.ReadSMBString(this.SMBData, ref dataOffset, isUnicode);
NativeOS = SMBHelper.ReadSMBString(this.SMBData, ref dataOffset, isUnicode);
NativeLanMan = SMBHelper.ReadSMBString(this.SMBData, ref dataOffset, isUnicode);
}
public NTTransactCreateRequest(byte[] parameters, byte[] data, bool isUnicode)
{
int parametersOffset = 0;
Flags = (NTCreateFlags)LittleEndianReader.ReadUInt32(parameters, ref parametersOffset);
RootDirectoryFID = LittleEndianReader.ReadUInt32(parameters, ref parametersOffset);
DesiredAccess = (DesiredAccess)LittleEndianReader.ReadUInt32(parameters, ref parametersOffset);
AllocationSize = LittleEndianReader.ReadUInt64(parameters, ref parametersOffset);
ExtFileAttributes = (ExtendedFileAttributes)LittleEndianReader.ReadUInt32(parameters, ref parametersOffset);
ShareAccess = (ShareAccess)LittleEndianReader.ReadUInt32(parameters, ref parametersOffset);
CreateDisposition = (CreateDisposition)LittleEndianReader.ReadUInt32(parameters, ref parametersOffset);
CreateOptions = (CreateOptions)LittleEndianReader.ReadUInt32(parameters, ref parametersOffset);
uint securityDescriptiorLength = LittleEndianReader.ReadUInt32(parameters, ref parametersOffset);
uint eaLength = LittleEndianReader.ReadUInt32(parameters, ref parametersOffset);
uint nameLength = LittleEndianReader.ReadUInt32(parameters, ref parametersOffset);
ImpersonationLevel = (ImpersonationLevel)LittleEndianReader.ReadUInt32(parameters, ref parametersOffset);
SecurityFlags = (SecurityFlags)ByteReader.ReadByte(parameters, ref parametersOffset);
if (isUnicode)
{
parametersOffset++;
}
Name = SMBHelper.ReadFixedLengthString(parameters, ref parametersOffset, isUnicode, (int)nameLength);
if (securityDescriptiorLength > 0)
{
SecurityDescriptor = new SecurityDescriptor(data, 0);
}
ExtendedAttributes = new FileFullEAInformationList(data, (int)securityDescriptiorLength);
}
public static void WriteSetSMBDateTime(byte[] buffer, int offset, DateTime?datetime)
{
if (datetime.HasValue)
{
SMBHelper.WriteSMBDateTime(buffer, offset, datetime.Value);
}
}
public QueryInformationResponse(byte[] buffer, int offset) : base(buffer, offset, false)
{
FileAttributes = (FileAttributes)LittleEndianConverter.ToUInt16(this.SMBParameters, 0);
LastWriteTime = SMBHelper.ReadSMBDateTime(this.SMBParameters, 2);
FileSize = LittleEndianConverter.ToUInt32(this.SMBParameters, 6);
Reserved = ByteReader.ReadBytes(this.SMBParameters, 10, 10);
}
public SetInfoStandard(byte[] buffer, int offset)
{
CreationDateTime = SMBHelper.ReadSMBDateTime(buffer, offset + 0);
LastAccessDateTime = SMBHelper.ReadSMBDateTime(buffer, offset + 4);
LastWriteDateTime = SMBHelper.ReadSMBDateTime(buffer, offset + 8);
Reserved = ByteReader.ReadBytes(buffer, offset + 12, 10);
}
public override byte[] GetBytes(bool isUnicode)
{
this.SMBParameters = new byte[ParametersLength];
LittleEndianWriter.WriteUInt16(this.SMBParameters, 0, FID);
SMBHelper.WriteUTime(this.SMBParameters, 2, LastTimeModified);
return(base.GetBytes(isUnicode));
}
public override byte[] GetBytes(bool isUnicode)
{
ushort securityBlobLength = (ushort)SecurityBlob.Length;
this.SMBParameters = new byte[ParametersLength];
LittleEndianWriter.WriteUInt16(this.SMBParameters, 4, (ushort)Action);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 6, securityBlobLength);
int padding = 0;
if (isUnicode)
{
// wordCount is 1 byte
padding = (1 + securityBlobLength) % 2;
this.SMBData = new byte[SecurityBlob.Length + padding + NativeOS.Length * 2 + NativeLanMan.Length * 2 + 4];
}
else
{
this.SMBData = new byte[SecurityBlob.Length + NativeOS.Length + NativeLanMan.Length + 2];
}
int offset = 0;
ByteWriter.WriteBytes(this.SMBData, ref offset, SecurityBlob);
offset += padding;
SMBHelper.WriteSMBString(this.SMBData, ref offset, isUnicode, NativeOS);
SMBHelper.WriteSMBString(this.SMBData, ref offset, isUnicode, NativeLanMan);
return(base.GetBytes(isUnicode));
}
public override byte[] GetBytes(bool isUnicode)
{
this.SMBParameters = new byte[ParametersLength];
LittleEndianWriter.WriteUInt16(this.SMBParameters, 0, (ushort)SearchAttributes);
if (isUnicode)
{
int padding = 1;
this.SMBData = new byte[2 + OldFileName.Length * 2 + NewFileName.Length * 2 + 4 + padding];
}
else
{
this.SMBData = new byte[2 + OldFileName.Length + NewFileName.Length + 2];
}
int dataOffset = 0;
ByteWriter.WriteByte(this.SMBData, ref dataOffset, BufferFormat1);
SMBHelper.WriteSMBString(this.SMBData, ref dataOffset, isUnicode, OldFileName);
ByteWriter.WriteByte(this.SMBData, ref dataOffset, BufferFormat2);
if (isUnicode)
{
dataOffset++; // padding
}
SMBHelper.WriteSMBString(this.SMBData, ref dataOffset, isUnicode, NewFileName);
return(base.GetBytes(isUnicode));
}
public QueryFSInfoVolume(bool isUnicode, byte[] buffer, int offset)
{
VolumeSerialNumber = LittleEndianConverter.ToUInt32(buffer, offset + 0);
byte charCount = ByteReader.ReadByte(buffer, offset + 4);
VolumeLabel = SMBHelper.ReadSMBString(buffer, offset + 5, isUnicode);
}
public override byte[] GetBytes(bool isUnicode)
{
this.SMBParameters = new byte[ParametersLength];
int parametersOffset = 4;
LittleEndianWriter.WriteUInt16(this.SMBParameters, ref parametersOffset, (ushort)OptionalSupport);
MaximalShareAccessRights.WriteBytes(this.SMBParameters, ref parametersOffset);
GuestMaximalShareAccessRights.WriteBytes(this.SMBParameters, ref parametersOffset);
// Should be written as OEM string but it doesn't really matter
string serviceString = TreeConnectHelper.GetServiceString(Service);
if (isUnicode)
{
this.SMBData = new byte[serviceString.Length + NativeFileSystem.Length * 2 + 3];
}
else
{
this.SMBData = new byte[serviceString.Length + NativeFileSystem.Length + 2];
}
int offset = 0;
ByteWriter.WriteNullTerminatedAnsiString(this.SMBData, ref offset, serviceString);
SMBHelper.WriteSMBString(this.SMBData, ref offset, isUnicode, NativeFileSystem);
return(base.GetBytes(isUnicode));
}
public FindFileNamesInfo(byte[] buffer, ref int offset, bool isUnicode) : base(false)
{
NextEntryOffset = LittleEndianReader.ReadUInt32(buffer, ref offset);
FileIndex = LittleEndianReader.ReadUInt32(buffer, ref offset);
uint fileNameLength = LittleEndianReader.ReadUInt32(buffer, ref offset);
FileName = SMBHelper.ReadFixedLengthString(buffer, ref offset, isUnicode, (int)fileNameLength);
}
public override void WriteBytes(byte[] buffer, ref int offset, bool isUnicode)
{
uint fileNameLength = (uint)(isUnicode ? FileName.Length * 2 : FileName.Length);
LittleEndianWriter.WriteUInt32(buffer, ref offset, NextEntryOffset);
LittleEndianWriter.WriteUInt32(buffer, ref offset, FileIndex);
LittleEndianWriter.WriteUInt32(buffer, ref offset, fileNameLength);
SMBHelper.WriteSMBString(buffer, ref offset, isUnicode, FileName);
}
public QueryFileBasicInfo(byte[] buffer, int offset)
{
CreationDateTime = SMBHelper.ReadFileTime(buffer, ref offset);
LastAccessDateTime = SMBHelper.ReadFileTime(buffer, ref offset);
LastWriteDateTime = SMBHelper.ReadFileTime(buffer, ref offset);
LastChangeTime = SMBHelper.ReadFileTime(buffer, ref offset);
ExtFileAttributes = (ExtendedFileAttributes)LittleEndianReader.ReadUInt32(buffer, ref offset);
Reserved = LittleEndianReader.ReadUInt32(buffer, ref offset);
}
public Transaction2FindNext2Request(byte[] parameters, byte[] data, bool isUnicode) : base()
{
SID = LittleEndianConverter.ToUInt16(parameters, 0);
SearchCount = LittleEndianConverter.ToUInt16(parameters, 2);
InformationLevel = (FindInformationLevel)LittleEndianConverter.ToUInt16(parameters, 4);
ResumeKey = LittleEndianConverter.ToUInt32(parameters, 6);
Flags = (FindFlags)LittleEndianConverter.ToUInt16(parameters, 10);
FileName = SMBHelper.ReadSMBString(parameters, 12, isUnicode);
}
public QueryFSVolumeInfo(byte[] buffer, int offset)
{
VolumeCreationTime = SMBHelper.ReadFileTime(buffer, offset + 0);
SerialNumber = LittleEndianConverter.ToUInt32(buffer, offset + 8);
uint volumeLabelSize = LittleEndianConverter.ToUInt32(buffer, offset + 12);
Reserved = LittleEndianConverter.ToUInt16(buffer, offset + 16);
VolumeLabel = ByteReader.ReadUnicodeString(buffer, offset + 18, (int)volumeLabelSize);
}
public QueryInfoStandard(byte[] buffer, int offset)
{
CreationDateTime = SMBHelper.ReadSMBDateTime(buffer, ref offset);
LastAccessDateTime = SMBHelper.ReadSMBDateTime(buffer, ref offset);
LastWriteDateTime = SMBHelper.ReadSMBDateTime(buffer, ref offset);
FileDataSize = LittleEndianReader.ReadUInt32(buffer, ref offset);
AllocationSize = LittleEndianReader.ReadUInt32(buffer, ref offset);
Attributes = (FileAttributes)LittleEndianReader.ReadUInt16(buffer, ref offset);
}
public override byte[] GetBytes()
{
byte[] buffer = new byte[Length];
SMBHelper.WriteSMBDateTime(buffer, 0, CreationDateTime);
SMBHelper.WriteSMBDateTime(buffer, 4, LastAccessDateTime);
SMBHelper.WriteSMBDateTime(buffer, 8, LastWriteDateTime);
ByteWriter.WriteBytes(buffer, 12, Reserved);
return(buffer);
}
public CreateDirectoryRequest(byte[] buffer, int offset, bool isUnicode) : base(buffer, offset, isUnicode)
{
BufferFormat = ByteReader.ReadByte(this.SMBData, 0);
if (BufferFormat != SupportedBufferFormat)
{
throw new InvalidRequestException("Unsupported Buffer Format");
}
DirectoryName = SMBHelper.ReadSMBString(this.SMBData, 1, isUnicode);
}
public SetFileBasicInfo(byte[] buffer, int offset)
{
CreationTime = SMBHelper.ReadSetFileTime(buffer, offset + 0);
LastAccessTime = SMBHelper.ReadSetFileTime(buffer, offset + 8);
LastWriteTime = SMBHelper.ReadSetFileTime(buffer, offset + 16);
LastChangeTime = SMBHelper.ReadSetFileTime(buffer, offset + 24);
ExtFileAttributes = (ExtendedFileAttributes)LittleEndianConverter.ToUInt32(buffer, offset + 32);
Reserved = LittleEndianConverter.ToUInt32(buffer, offset + 36);
}
public override byte[] GetBytes(bool isUnicode)
{
this.SMBParameters = new byte[ParameterLength];
LittleEndianWriter.WriteUInt16(this.SMBParameters, 0, (ushort)FileAttributes);
SMBHelper.WriteSMBDateTime(this.SMBParameters, 2, LastWriteTime);
LittleEndianWriter.WriteUInt32(this.SMBParameters, 6, FileSize);
ByteWriter.WriteBytes(this.SMBParameters, 10, Reserved, 10);
return(base.GetBytes(isUnicode));
}
public TransactionQueryNamedPipeInfoResponse(byte[] parameters, bool isUnicode) : base()
{
OutputBufferSize = LittleEndianConverter.ToUInt16(parameters, 0);
InputBufferSize = LittleEndianConverter.ToUInt16(parameters, 2);
MaximumInstances = ByteReader.ReadByte(parameters, 4);
CurrentInstances = ByteReader.ReadByte(parameters, 5);
PipeNameLength = ByteReader.ReadByte(parameters, 6);
// Note: Trans_Parameters is aligned to 4 byte boundary
PipeName = SMBHelper.ReadSMBString(parameters, 8, isUnicode);
}
public static DateTime?ReadSetSMBDateTime(byte[] buffer, int offset)
{
uint value = LittleEndianConverter.ToUInt32(buffer, offset);
if (value > 0)
{
return(SMBHelper.ReadSMBDateTime(buffer, offset));
}
return(null);
}
public override byte[] GetParameters(bool isUnicode)
{
int length = 4;
length += isUnicode ? DirectoryName.Length * 2 + 2 : DirectoryName.Length + 1 + 1;
byte[] parameters = new byte[length];
LittleEndianWriter.WriteUInt32(parameters, 0, Reserved);
SMBHelper.WriteSMBString(parameters, 4, isUnicode, DirectoryName);
return(parameters);
}
public Transaction2QueryPathInformationRequest(byte[] parameters, byte[] data, bool isUnicode) : base()
{
InformationLevel = (QueryInformationLevel)LittleEndianConverter.ToUInt16(parameters, 0);
Reserved = LittleEndianConverter.ToUInt32(parameters, 4);
FileName = SMBHelper.ReadSMBString(parameters, 6, isUnicode);
if (InformationLevel == QueryInformationLevel.SMB_INFO_QUERY_EAS_FROM_LIST)
{
GetExtendedAttributeList = new FullExtendedAttributeList(data, 0);
}
}
public TreeConnectAndXResponse(byte[] buffer, int offset, bool isUnicode) : base(buffer, offset, isUnicode)
{
OptionalSupport = (OptionalSupportFlags)LittleEndianConverter.ToUInt16(this.SMBParameters, 4);
int dataOffset = 0;
string serviceString = ByteReader.ReadNullTerminatedAnsiString(this.SMBData, ref dataOffset);
NativeFileSystem = SMBHelper.ReadSMBString(this.SMBData, ref dataOffset, isUnicode);
Service = TreeConnectHelper.GetServiceName(serviceString);
}
public override byte[] GetBytes()
{
byte[] buffer = new byte[Length];
SMBHelper.WriteFileTime(buffer, 0, CreationTime);
SMBHelper.WriteFileTime(buffer, 8, LastAccessTime);
SMBHelper.WriteFileTime(buffer, 16, LastWriteTime);
SMBHelper.WriteFileTime(buffer, 24, LastChangeTime);
LittleEndianWriter.WriteUInt32(buffer, 32, (uint)ExtFileAttributes);
LittleEndianWriter.WriteUInt32(buffer, 36, Reserved);
return(buffer);
}
public DeleteRequest(byte[] buffer, int offset, bool isUnicode) : base(buffer, offset, isUnicode)
{
SearchAttributes = (FileAttributes)LittleEndianConverter.ToUInt16(this.SMBParameters, 0);
BufferFormat = ByteReader.ReadByte(this.SMBData, 0);
if (BufferFormat != SupportedBufferFormat)
{
throw new InvalidRequestException("Unsupported Buffer Format");
}
FileName = SMBHelper.ReadSMBString(this.SMBData, 1, isUnicode);
}
public override byte[] GetBytes(bool isUnicode)
{
byte charCount = (byte)VolumeLabel.Length;
int length = GetLength(isUnicode);
byte[] buffer = new byte[length];
LittleEndianWriter.WriteUInt32(buffer, 0, VolumeSerialNumber);
ByteWriter.WriteByte(buffer, 4, charCount);
SMBHelper.WriteSMBString(buffer, 5, isUnicode, VolumeLabel);
return(buffer);
}
public override byte[] GetBytes(bool isUnicode)
{
uint volumeLabelSize = (uint)(VolumeLabel.Length * 2);
byte[] buffer = new byte[FixedLength + volumeLabelSize];
SMBHelper.WriteFileTime(buffer, 0, VolumeCreationTime);
LittleEndianWriter.WriteUInt32(buffer, 8, SerialNumber);
LittleEndianWriter.WriteUInt32(buffer, 12, volumeLabelSize);
LittleEndianWriter.WriteUInt16(buffer, 16, Reserved);
ByteWriter.WriteUnicodeString(buffer, 18, VolumeLabel);
return(buffer);
}
public override byte[] GetBytes()
{
byte[] buffer = new byte[Length];
int offset = 0;
SMBHelper.WriteSMBDateTime(buffer, ref offset, CreationDateTime);
SMBHelper.WriteSMBDateTime(buffer, ref offset, LastAccessDateTime);
SMBHelper.WriteSMBDateTime(buffer, ref offset, LastWriteDateTime);
LittleEndianWriter.WriteUInt32(buffer, ref offset, FileDataSize);
LittleEndianWriter.WriteUInt32(buffer, ref offset, AllocationSize);
LittleEndianWriter.WriteUInt16(buffer, ref offset, (ushort)Attributes);
return(buffer);
}
