public override byte[] GetBytes(bool isUnicode)
{
SecurityBlobLength = (ushort)SecurityBlob.Length;
this.SMBParameters = new byte[ParametersLength];
LittleEndianWriter.WriteUInt16(this.SMBParameters, 4, MaxBufferSize);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 6, MaxMpxCount);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 8, VcNumber);
LittleEndianWriter.WriteUInt32(this.SMBParameters, 10, SessionKey);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 14, SecurityBlobLength);
LittleEndianWriter.WriteUInt32(this.SMBParameters, 16, Reserved);
int padding = 0;
if (isUnicode)
{
// A Unicode string MUST be aligned to a 16-bit boundary with respect to the beginning of the SMB Header.
// Note: SMBData starts at an odd offset.
padding = (SecurityBlobLength + 1) % 2;
this.SMBData = new byte[SecurityBlob.Length + (NativeOS.Length + 1) * 2 + (NativeLanMan.Length + 1) * 2];
}
else
{
this.SMBData = new byte[SecurityBlob.Length + NativeOS.Length + 1 + NativeLanMan.Length + 1];
}
int offset = 0;
ByteWriter.WriteBytes(this.SMBData, ref offset, SecurityBlob);
offset += padding;
SMB1Helper.WriteSMBString(this.SMBData, ref offset, isUnicode, NativeOS);
SMB1Helper.WriteSMBString(this.SMBData, ref offset, isUnicode, NativeLanMan);
return(base.GetBytes(isUnicode));
}
public override byte[] GetParameters(bool isUnicode)
{
int length = 28;
if (isUnicode)
{
length += FileName.Length * 2 + 2;
}
else
{
length += FileName.Length + 1;
}
byte[] parameters = new byte[length];
LittleEndianWriter.WriteUInt16(parameters, 0, (ushort)Flags);
AccessMode.WriteBytes(parameters, 2);
LittleEndianWriter.WriteUInt16(parameters, 4, Reserved1);
LittleEndianWriter.WriteUInt16(parameters, 6, (ushort)FileAttributes);
UTimeHelper.WriteUTime(parameters, 8, CreationTime);
OpenMode.WriteBytes(parameters, 12);
LittleEndianWriter.WriteUInt32(parameters, 14, AllocationSize);
ByteWriter.WriteBytes(parameters, 18, Reserved, 10);
SMB1Helper.WriteSMBString(parameters, 28, isUnicode, FileName);
return(parameters);
}
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);
SMB1Helper.WriteSMBString(this.SMBData, ref dataOffset, isUnicode, OldFileName);
ByteWriter.WriteByte(this.SMBData, ref dataOffset, BufferFormat2);
if (isUnicode)
{
dataOffset++; // padding
}
SMB1Helper.WriteSMBString(this.SMBData, ref dataOffset, isUnicode, NewFileName);
return(base.GetBytes(isUnicode));
}
public override byte[] GetBytes(bool isUnicode)
{
this.SMBParameters = new byte[ParametersLength];
LittleEndianWriter.WriteUInt16(this.SMBParameters, 4, (ushort)Action);
int offset = 0;
if (isUnicode)
{
// A Unicode string MUST be aligned to a 16-bit boundary with respect to the beginning of the SMB Header.
// Note: SMBData starts at an odd offset.
int padding = 1;
this.SMBData = new byte[padding + NativeOS.Length * 2 + NativeLanMan.Length * 2 + PrimaryDomain.Length * 2 + 6];
offset = padding;
}
else
{
this.SMBData = new byte[NativeOS.Length + NativeLanMan.Length + PrimaryDomain.Length + 3];
}
SMB1Helper.WriteSMBString(this.SMBData, ref offset, isUnicode, NativeOS);
SMB1Helper.WriteSMBString(this.SMBData, ref offset, isUnicode, NativeLanMan);
SMB1Helper.WriteSMBString(this.SMBData, ref offset, isUnicode, PrimaryDomain);
return(base.GetBytes(isUnicode));
}
public override byte[] GetBytes(bool isUnicode)
{
SMBParameters = new byte[ParametersLength];
int parametersOffset = 4;
LittleEndianWriter.WriteUInt16(SMBParameters, ref parametersOffset, (ushort)Flags);
AccessMode.WriteBytes(SMBParameters, ref parametersOffset);
LittleEndianWriter.WriteUInt16(SMBParameters, ref parametersOffset, (ushort)SearchAttrs);
LittleEndianWriter.WriteUInt16(SMBParameters, ref parametersOffset, (ushort)FileAttrs);
UTimeHelper.WriteUTime(SMBParameters, ref parametersOffset, CreationTime);
OpenMode.WriteBytes(SMBParameters, ref parametersOffset);
LittleEndianWriter.WriteUInt32(SMBParameters, ref parametersOffset, AllocationSize);
LittleEndianWriter.WriteUInt32(SMBParameters, ref parametersOffset, Timeout);
LittleEndianWriter.WriteUInt32(SMBParameters, ref parametersOffset, Reserved);
int padding = 0;
if (isUnicode)
{
padding = 1;
SMBData = new byte[padding + FileName.Length * 2 + 2];
}
else
{
SMBData = new byte[FileName.Length + 1];
}
SMB1Helper.WriteSMBString(SMBData, padding, isUnicode, FileName);
return(base.GetBytes(isUnicode));
}
public override byte[] GetBytes(bool isUnicode)
{
ushort securityBlobLength = (ushort)SecurityBlob.Length;
SMBParameters = new byte[ParametersLength];
LittleEndianWriter.WriteUInt16(SMBParameters, 4, (ushort)Action);
LittleEndianWriter.WriteUInt16(SMBParameters, 6, securityBlobLength);
int padding = 0;
if (isUnicode)
{
// A Unicode string MUST be aligned to a 16-bit boundary with respect to the beginning of the SMB Header.
// Note: SMBData starts at an odd offset.
padding = (1 + securityBlobLength) % 2;
SMBData = new byte[SecurityBlob.Length + padding + NativeOS.Length * 2 + NativeLanMan.Length * 2 + 4];
}
else
{
SMBData = new byte[SecurityBlob.Length + NativeOS.Length + NativeLanMan.Length + 2];
}
int offset = 0;
ByteWriter.WriteBytes(SMBData, ref offset, SecurityBlob);
offset += padding;
SMB1Helper.WriteSMBString(SMBData, ref offset, isUnicode, NativeOS);
SMB1Helper.WriteSMBString(SMBData, ref offset, isUnicode, NativeLanMan);
return(base.GetBytes(isUnicode));
}
public override byte[] GetBytes(bool isUnicode)
{
ChallengeLength = (byte)Challenge.Length;
SMBParameters = new byte[ParametersLength];
LittleEndianWriter.WriteUInt16(SMBParameters, 0, DialectIndex);
ByteWriter.WriteByte(SMBParameters, 2, (byte)SecurityMode);
LittleEndianWriter.WriteUInt16(SMBParameters, 3, MaxMpxCount);
LittleEndianWriter.WriteUInt16(SMBParameters, 5, MaxNumberVcs);
LittleEndianWriter.WriteUInt32(SMBParameters, 7, MaxBufferSize);
LittleEndianWriter.WriteUInt32(SMBParameters, 11, MaxRawSize);
LittleEndianWriter.WriteUInt32(SMBParameters, 15, SessionKey);
LittleEndianWriter.WriteUInt32(SMBParameters, 19, (uint)Capabilities);
FileTimeHelper.WriteFileTime(SMBParameters, 23, SystemTime);
LittleEndianWriter.WriteInt16(SMBParameters, 31, ServerTimeZone);
ByteWriter.WriteByte(SMBParameters, 33, ChallengeLength);
// [MS-CIFS] <90> Padding is not added before DomainName
// DomainName and ServerName are always in Unicode
SMBData = new byte[Challenge.Length + (DomainName.Length + 1) * 2 + (ServerName.Length + 1) * 2];
int offset = 0;
ByteWriter.WriteBytes(SMBData, ref offset, Challenge);
SMB1Helper.WriteSMBString(SMBData, ref offset, true, DomainName);
SMB1Helper.WriteSMBString(SMBData, ref offset, true, ServerName);
return(base.GetBytes(isUnicode));
}
public override byte[] GetBytes(bool isUnicode)
{
NameLength = (ushort)FileName.Length;
this.SMBParameters = new byte[ParametersLength];
ByteWriter.WriteByte(this.SMBParameters, 0, (byte)AndXCommand);
ByteWriter.WriteByte(this.SMBParameters, 1, AndXReserved);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 2, AndXOffset);
ByteWriter.WriteByte(this.SMBParameters, 4, Reserved);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 5, NameLength);
LittleEndianWriter.WriteUInt32(this.SMBParameters, 7, (uint)Flags);
LittleEndianWriter.WriteUInt32(this.SMBParameters, 11, RootDirectoryFID);
LittleEndianWriter.WriteUInt32(this.SMBParameters, 15, (uint)DesiredAccess);
LittleEndianWriter.WriteInt64(this.SMBParameters, 19, AllocationSize);
LittleEndianWriter.WriteUInt32(this.SMBParameters, 27, (uint)ExtFileAttributes);
LittleEndianWriter.WriteUInt32(this.SMBParameters, 31, (uint)ShareAccess);
LittleEndianWriter.WriteUInt32(this.SMBParameters, 35, (uint)CreateDisposition);
LittleEndianWriter.WriteUInt32(this.SMBParameters, 39, (uint)CreateOptions);
LittleEndianWriter.WriteUInt32(this.SMBParameters, 43, (uint)ImpersonationLevel);
ByteWriter.WriteByte(this.SMBParameters, 47, (byte)SecurityFlags);
int padding = 0;
if (isUnicode)
{
padding = 1;
this.SMBData = new byte[padding + FileName.Length * 2 + 2];
}
else
{
this.SMBData = new byte[FileName.Length + 1];
}
SMB1Helper.WriteSMBString(this.SMBData, padding, isUnicode, FileName);
return(base.GetBytes(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 = ServiceNameHelper.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);
SMB1Helper.WriteSMBString(this.SMBData, ref offset, isUnicode, NativeFileSystem);
return(base.GetBytes(isUnicode));
}
public override byte[] GetData(bool isUnicode)
{
if (PipeName == null)
{
return(new byte[0]);
}
int length = 8;
if (isUnicode)
{
length += PipeName.Length * 2 + 2;
}
else
{
length += PipeName.Length + 1;
}
byte[] data = new byte[length];
LittleEndianWriter.WriteUInt16(data, 0, OutputBufferSize);
LittleEndianWriter.WriteUInt16(data, 2, InputBufferSize);
ByteWriter.WriteByte(data, 4, MaximumInstances);
ByteWriter.WriteByte(data, 5, CurrentInstances);
ByteWriter.WriteByte(data, 6, PipeNameLength);
SMB1Helper.WriteSMBString(data, 8, isUnicode, PipeName);
return(data);
}
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);
SMB1Helper.WriteSMBString(buffer, ref offset, isUnicode, FileName);
}
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);
SMB1Helper.WriteSMBString(parameters, 4, isUnicode, DirectoryName);
return(parameters);
}
public override void WriteBytes(byte[] buffer, ref int offset, bool isUnicode)
{
uint fileNameLength = (byte)(isUnicode ? FileName.Length * 2 : FileName.Length);
LittleEndianWriter.WriteUInt32(buffer, ref offset, NextEntryOffset);
LittleEndianWriter.WriteUInt32(buffer, ref offset, FileIndex);
FileTimeHelper.WriteFileTime(buffer, ref offset, CreationTime);
FileTimeHelper.WriteFileTime(buffer, ref offset, LastAccessTime);
FileTimeHelper.WriteFileTime(buffer, ref offset, LastWriteTime);
FileTimeHelper.WriteFileTime(buffer, ref offset, LastAttrChangeTime);
LittleEndianWriter.WriteInt64(buffer, ref offset, EndOfFile);
LittleEndianWriter.WriteInt64(buffer, ref offset, AllocationSize);
LittleEndianWriter.WriteUInt32(buffer, ref offset, (uint)ExtFileAttributes);
LittleEndianWriter.WriteUInt32(buffer, ref offset, fileNameLength);
SMB1Helper.WriteSMBString(buffer, ref offset, isUnicode, FileName);
}
public override byte[] GetBytes(bool isUnicode)
{
int length = 1;
if (isUnicode)
{
length += DirectoryName.Length * 2 + 2;
}
else
{
length += DirectoryName.Length + 1;
}
this.SMBData = new byte[length];
ByteWriter.WriteByte(this.SMBData, 0, BufferFormat);
SMB1Helper.WriteSMBString(this.SMBData, 1, isUnicode, DirectoryName);
return(base.GetBytes(isUnicode));
}
public override byte[] GetParameters(bool isUnicode)
{
int length = 6;
if (isUnicode)
{
length += FileName.Length * 2 + 2;
}
else
{
length += FileName.Length + 1;
}
byte[] parameters = new byte[length];
LittleEndianWriter.WriteUInt16(parameters, 0, (ushort)InformationLevel);
LittleEndianWriter.WriteUInt32(parameters, 2, Reserved);
SMB1Helper.WriteSMBString(parameters, 6, isUnicode, FileName);
return(parameters);
}
public override byte[] GetBytes(bool isUnicode)
{
Capabilities &= ~Capabilities.ExtendedSecurity;
OEMPasswordLength = (ushort)OEMPassword.Length;
UnicodePasswordLength = (ushort)UnicodePassword.Length;
this.SMBParameters = new byte[ParametersLength];
LittleEndianWriter.WriteUInt16(this.SMBParameters, 4, MaxBufferSize);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 6, MaxMpxCount);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 8, VcNumber);
LittleEndianWriter.WriteUInt32(this.SMBParameters, 10, SessionKey);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 14, OEMPasswordLength);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 16, UnicodePasswordLength);
LittleEndianWriter.WriteUInt32(this.SMBParameters, 18, Reserved);
LittleEndianWriter.WriteUInt32(this.SMBParameters, 22, (uint)Capabilities);
int padding = 0;
if (isUnicode)
{
// A Unicode string MUST be aligned to a 16-bit boundary with respect to the beginning of the SMB Header.
// Note: SMBData starts at an odd offset.
padding = (1 + OEMPasswordLength + UnicodePasswordLength) % 2;
this.SMBData = new byte[OEMPassword.Length + UnicodePassword.Length + padding + (AccountName.Length + 1) * 2 + (PrimaryDomain.Length + 1) * 2 + (NativeOS.Length + 1) * 2 + (NativeLanMan.Length + 1) * 2];
}
else
{
this.SMBData = new byte[OEMPassword.Length + UnicodePassword.Length + AccountName.Length + 1 + PrimaryDomain.Length + 1 + NativeOS.Length + 1 + NativeLanMan.Length + 1];
}
int offset = 0;
ByteWriter.WriteBytes(this.SMBData, ref offset, OEMPassword);
ByteWriter.WriteBytes(this.SMBData, ref offset, UnicodePassword);
offset += padding;
SMB1Helper.WriteSMBString(this.SMBData, ref offset, isUnicode, AccountName);
SMB1Helper.WriteSMBString(this.SMBData, ref offset, isUnicode, PrimaryDomain);
SMB1Helper.WriteSMBString(this.SMBData, ref offset, isUnicode, NativeOS);
SMB1Helper.WriteSMBString(this.SMBData, ref offset, isUnicode, NativeLanMan);
return(base.GetBytes(isUnicode));
}
public override byte[] GetParameters(bool isUnicode)
{
int length = 8;
if (isUnicode)
{
length += PipeName.Length * 2 + 2;
}
else
{
length += PipeName.Length + 1;
}
byte[] parameters = new byte[length];
LittleEndianWriter.WriteUInt16(parameters, 0, OutputBufferSize);
LittleEndianWriter.WriteUInt16(parameters, 2, InputBufferSize);
ByteWriter.WriteByte(parameters, 4, MaximumInstances);
ByteWriter.WriteByte(parameters, 5, CurrentInstances);
ByteWriter.WriteByte(parameters, 6, PipeNameLength);
SMB1Helper.WriteSMBString(parameters, 8, isUnicode, PipeName);
return(parameters);;
}
public override byte[] GetBytes(bool isUnicode)
{
this.SMBParameters = new byte[ParametersLength];
LittleEndianWriter.WriteUInt16(this.SMBParameters, 0, (ushort)FileAttributes);
UTimeHelper.WriteUTime(this.SMBParameters, 2, LastWriteTime);
ByteWriter.WriteBytes(this.SMBParameters, 6, Reserved, 10);
int length = 1;
if (isUnicode)
{
length += FileName.Length * 2 + 2;
}
else
{
length += FileName.Length + 1;
}
this.SMBData = new byte[length];
ByteWriter.WriteByte(this.SMBData, 0, BufferFormat);
SMB1Helper.WriteSMBString(this.SMBData, 1, isUnicode, FileName);
return(base.GetBytes(isUnicode));
}
public override byte[] GetParameters(bool isUnicode)
{
int length = 12;
if (isUnicode)
{
length += FileName.Length * 2 + 2;
}
else
{
length += FileName.Length + 1;
}
byte[] parameters = new byte[length];
LittleEndianWriter.WriteUInt16(parameters, 0, (ushort)SearchAttributes);
LittleEndianWriter.WriteUInt16(parameters, 2, SearchCount);
LittleEndianWriter.WriteUInt16(parameters, 4, (ushort)Flags);
LittleEndianWriter.WriteUInt16(parameters, 6, (ushort)InformationLevel);
LittleEndianWriter.WriteUInt32(parameters, 8, (uint)SearchStorageType);
SMB1Helper.WriteSMBString(parameters, 12, isUnicode, FileName);
return(parameters);
}
public override byte[] GetParameters(bool isUnicode)
{
int length = 12;
if (isUnicode)
{
length += FileName?.Length * 2 + 2 ?? 0;
}
else
{
length += FileName?.Length + 1 ?? 0;
}
byte[] parameters = new byte[length];
LittleEndianWriter.WriteUInt16(parameters, 0, SID);
LittleEndianWriter.WriteUInt16(parameters, 2, SearchCount);
LittleEndianWriter.WriteUInt16(parameters, 4, (ushort)InformationLevel);
LittleEndianWriter.WriteUInt32(parameters, 6, ResumeKey);
LittleEndianWriter.WriteUInt16(parameters, 10, (ushort)Flags);
SMB1Helper.WriteSMBString(parameters, 12, isUnicode, FileName !);
return(parameters);
}
public override byte[] GetBytes(bool isUnicode)
{
ushort passwordLength = (ushort)Password.Length;
SMBParameters = new byte[ParametersLength];
int parametersOffset = 4;
LittleEndianWriter.WriteUInt16(SMBParameters, ref parametersOffset, (ushort)Flags);
LittleEndianWriter.WriteUInt16(SMBParameters, ref parametersOffset, passwordLength);
string serviceString = ServiceNameHelper.GetServiceString(Service);
int dataLength = Password.Length + serviceString.Length + 1;
if (isUnicode)
{
int padding = (1 + passwordLength) % 2;
dataLength += Path.Length * 2 + 2 + padding;
}
else
{
dataLength += Path.Length + 1;
}
SMBData = new byte[dataLength];
int dataOffset = 0;
ByteWriter.WriteBytes(SMBData, ref dataOffset, Password);
if (isUnicode)
{
// wordCount is 1 byte
int padding = (1 + passwordLength) % 2;
dataOffset += padding;
}
SMB1Helper.WriteSMBString(SMBData, ref dataOffset, isUnicode, Path);
ByteWriter.WriteNullTerminatedAnsiString(SMBData, ref dataOffset, serviceString);
return(base.GetBytes(isUnicode));
}
public override byte[] GetBytes(bool isUnicode)
{
byte SetupCount = (byte)(Setup.Length / 2);
ushort ParameterCount = (ushort)TransParameters.Length;
ushort DataCount = (ushort)TransData.Length;
// WordCount + ByteCount are additional 3 bytes
ushort ParameterOffset = (ushort)(SMB1Header.Length + 3 + (FixedSMBParametersLength + Setup.Length));
if (this is Transaction2Request)
{
ParameterOffset += 1;
}
else
{
if (isUnicode)
{
ParameterOffset += (ushort)(Name.Length * 2 + 2);
}
else
{
ParameterOffset += (ushort)(Name.Length + 1);
}
}
int padding1 = (4 - (ParameterOffset % 4)) % 4;
ParameterOffset += (ushort)padding1;
ushort DataOffset = (ushort)(ParameterOffset + ParameterCount);
int padding2 = (4 - (DataOffset % 4)) % 4;
DataOffset += (ushort)padding2;
this.SMBParameters = new byte[FixedSMBParametersLength + Setup.Length];
LittleEndianWriter.WriteUInt16(this.SMBParameters, 0, TotalParameterCount);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 2, TotalDataCount);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 4, MaxParameterCount);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 6, MaxDataCount);
ByteWriter.WriteByte(this.SMBParameters, 8, MaxSetupCount);
ByteWriter.WriteByte(this.SMBParameters, 9, Reserved1);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 10, (ushort)Flags);
LittleEndianWriter.WriteUInt32(this.SMBParameters, 12, Timeout);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 16, Reserved2);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 18, ParameterCount);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 20, ParameterOffset);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 22, DataCount);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 24, DataOffset);
ByteWriter.WriteByte(this.SMBParameters, 26, SetupCount);
ByteWriter.WriteByte(this.SMBParameters, 27, Reserved3);
ByteWriter.WriteBytes(this.SMBParameters, 28, Setup);
int offset;
if (this is Transaction2Request)
{
int nameLength = 1;
this.SMBData = new byte[nameLength + padding1 + ParameterCount + padding2 + DataCount];
offset = nameLength;
}
else
{
if (isUnicode)
{
int namePadding = 1;
this.SMBData = new byte[namePadding + Name.Length * 2 + 2 + padding1 + ParameterCount + padding2 + DataCount];
offset = namePadding;
}
else
{
this.SMBData = new byte[Name.Length + 1 + padding1 + ParameterCount + padding2 + DataCount];
offset = 0;
}
SMB1Helper.WriteSMBString(this.SMBData, ref offset, isUnicode, Name);
}
ByteWriter.WriteBytes(this.SMBData, offset + padding1, TransParameters);
ByteWriter.WriteBytes(this.SMBData, offset + padding1 + ParameterCount + padding2, TransData);
return(base.GetBytes(isUnicode));
}
public override byte[] GetBytes(bool isUnicode)
{
if (Setup.Length % 2 > 0)
{
throw new Exception("Setup length must be a multiple of 2");
}
byte setupCount = (byte)(Setup.Length / 2);
ushort transParameterCount = (ushort)TransParameters.Length;
ushort transDataCount = (ushort)TransData.Length;
// WordCount + ByteCount are additional 3 bytes
int nameLength;
int namePadding;
if (this is Transaction2Request)
{
namePadding = 0;
nameLength = 1;
}
else
{
if (isUnicode)
{
namePadding = 1;
nameLength = Name.Length * 2 + 2;
}
else
{
namePadding = 0;
nameLength = Name.Length + 1;
}
}
ushort transParameterOffset = (ushort)(SMB1Header.Length + 3 + (FixedSMBParametersLength + Setup.Length + namePadding + nameLength));
int padding1 = (4 - (transParameterOffset % 4)) % 4;
transParameterOffset += (ushort)padding1;
ushort transDataOffset = (ushort)(transParameterOffset + transParameterCount);
int padding2 = (4 - (transDataOffset % 4)) % 4;
transDataOffset += (ushort)padding2;
this.SMBParameters = new byte[FixedSMBParametersLength + Setup.Length];
LittleEndianWriter.WriteUInt16(this.SMBParameters, 0, TotalParameterCount);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 2, TotalDataCount);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 4, MaxParameterCount);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 6, MaxDataCount);
ByteWriter.WriteByte(this.SMBParameters, 8, MaxSetupCount);
ByteWriter.WriteByte(this.SMBParameters, 9, Reserved1);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 10, (ushort)Flags);
LittleEndianWriter.WriteUInt32(this.SMBParameters, 12, Timeout);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 16, Reserved2);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 18, transParameterCount);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 20, transParameterOffset);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 22, transDataCount);
LittleEndianWriter.WriteUInt16(this.SMBParameters, 24, transDataOffset);
ByteWriter.WriteByte(this.SMBParameters, 26, setupCount);
ByteWriter.WriteByte(this.SMBParameters, 27, Reserved3);
ByteWriter.WriteBytes(this.SMBParameters, 28, Setup);
int offset;
this.SMBData = new byte[namePadding + nameLength + padding1 + transParameterCount + padding2 + transDataCount];
offset = namePadding;
if (this is Transaction2Request)
{
offset += nameLength;
}
else
{
SMB1Helper.WriteSMBString(this.SMBData, ref offset, isUnicode, Name);
}
ByteWriter.WriteBytes(this.SMBData, offset + padding1, TransParameters);
ByteWriter.WriteBytes(this.SMBData, offset + padding1 + transParameterCount + padding2, TransData);
return(base.GetBytes(isUnicode));
}