private void ReplacePacketByStructureSize(Smb2Packet packet)
        {
            Smb2CreateRequestPacket request = packet as Smb2CreateRequestPacket;

            if (request == null)
            {
                return;
            }
            request.PayLoad.StructureSize += 1;
        }
        private void Compound_RelatedRequests(string fileName, bool isEncrypted)
        {
            BaseTestSite.Log.Add(LogEntryKind.TestStep, "Initialize the test client.");
            Smb2FunctionalClient client = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
            uint treeId;

            BaseTestSite.Log.Add(LogEntryKind.TestStep, "Connect to the SMB2 basic share by sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT.");
            ConnectToShare(client, out treeId);

            BaseTestSite.Log.Add(LogEntryKind.TestStep, "Construct Create packet.");
            Smb2CreateRequestPacket createPacket = ConstructCreatePacket(client.SessionId, treeId, fileName);

            BaseTestSite.Log.Add(LogEntryKind.TestStep, "Construct Write packet, flag FLAGS_RELATED_OPERATIONS is set.");
            Smb2WriteRequestPacket writePacket = ConstructRelatedWritePacket();

            BaseTestSite.Log.Add(LogEntryKind.TestStep, "Construct Close packet, flag FLAGS_RELATED_OPERATIONS is set.");
            Smb2CloseRequestPacket closePacket = ConstructRelatedClosePacket();

            BaseTestSite.Log.Add(LogEntryKind.TestStep, "Send {0}compounded Create, Write and Close requests to SUT.", isEncrypted ? "encrypted " : "");
            List <Smb2SinglePacket> requestPackets = new List <Smb2SinglePacket>();

            requestPackets.Add(createPacket);
            requestPackets.Add(writePacket);
            requestPackets.Add(closePacket);

            if (isEncrypted)
            {
                // Enable encryption
                client.EnableSessionSigningAndEncryption(enableSigning: testConfig.SendSignedRequest, enableEncryption: true);
            }
            List <Smb2SinglePacket> responsePackets = client.SendAndReceiveCompoundPacket(requestPackets);

            BaseTestSite.Log.Add(LogEntryKind.TestStep, "Verify responses to the compounded request.");
            foreach (var responsePacket in responsePackets)
            {
                if (TestConfig.Platform == Platform.WindowsServer2016 && responsePacket.Header.Status != Smb2Status.STATUS_SUCCESS)
                {
                }
                else
                {
                    BaseTestSite.Assert.AreEqual(
                        Smb2Status.STATUS_SUCCESS,
                        responsePacket.Header.Status,
                        "{0} should succeed, actual status is {1}", responsePacket.Header.Command, Smb2Status.GetStatusCode(responsePacket.Header.Status));
                }
            }

            client.TreeDisconnect(treeId);
            client.LogOff();
            client.Disconnect();
        }
        /// <summary>
        /// Construct a Create packet which is the first or an unrelated packet in the chain
        /// </summary>
        private Smb2CreateRequestPacket ConstructCreatePacket(ulong sessionId, uint treeId, string fileName)
        {
            Smb2CreateRequestPacket createPacket = new Smb2CreateRequestPacket();

            createPacket.Header.Command             = Smb2Command.CREATE;
            createPacket.Header.SessionId           = sessionId;
            createPacket.Header.TreeId              = treeId;
            createPacket.PayLoad.CreateDisposition  = CreateDisposition_Values.FILE_OPEN_IF;
            createPacket.PayLoad.CreateOptions      = CreateOptions_Values.FILE_NON_DIRECTORY_FILE;
            createPacket.PayLoad.ImpersonationLevel = ImpersonationLevel_Values.Impersonation;
            createPacket.PayLoad.DesiredAccess      = AccessMask.GENERIC_READ | AccessMask.GENERIC_WRITE | AccessMask.DELETE;
            createPacket.PayLoad.ShareAccess        = ShareAccess_Values.FILE_SHARE_READ | ShareAccess_Values.FILE_SHARE_WRITE | ShareAccess_Values.FILE_SHARE_DELETE;
            byte[] nameBuffer = Encoding.Unicode.GetBytes(fileName);
            createPacket.PayLoad.NameOffset = createPacket.BufferOffset;
            createPacket.PayLoad.NameLength = (ushort)nameBuffer.Length;
            createPacket.Buffer             = nameBuffer;
            return(createPacket);
        }
Beispiel #4
0
        private void Compound_UnrelatedRequests(string firstFileName, string secondFileName, bool isEncrypted)
        {
            BaseTestSite.Log.Add(LogEntryKind.TestStep, "Initialize the test client.");
            Smb2FunctionalClient client = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
            uint treeId;

            BaseTestSite.Log.Add(LogEntryKind.TestStep, "Connect to the SMB2 basic share by sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT.");
            ConnectToShare(client, out treeId);

            BaseTestSite.Log.Add(LogEntryKind.TestStep, "Construct the first Create packet.");
            Smb2CreateRequestPacket firstCreatePacket = ConstructCreatePacket(client.SessionId, treeId, firstFileName);

            BaseTestSite.Log.Add(LogEntryKind.TestStep, "Construct the second Create packet.");
            Smb2CreateRequestPacket secondCreatePacket = ConstructCreatePacket(client.SessionId, treeId, secondFileName);

            BaseTestSite.Log.Add(LogEntryKind.TestStep, "Send the two {0}compounded Create packets to SUT.", isEncrypted ? "encrypted " : "");
            List <Smb2SinglePacket> requestPackets = new List <Smb2SinglePacket>();

            requestPackets.Add(firstCreatePacket);
            requestPackets.Add(secondCreatePacket);

            if (isEncrypted)
            {
                // Enable encryption
                client.EnableSessionSigningAndEncryption(enableSigning: testConfig.SendSignedRequest, enableEncryption: true);
            }
            List <Smb2SinglePacket> responsePackets = client.SendAndReceiveCompoundPacket(false, requestPackets);

            BaseTestSite.Log.Add(LogEntryKind.TestStep, "Verify responses to the compounded request.");
            foreach (var responsePacket in responsePackets)
            {
                BaseTestSite.Assert.AreEqual(
                    Smb2Status.STATUS_SUCCESS,
                    responsePacket.Header.Status,
                    "{0} should succeed, actual status is {1}", responsePacket.Header.Command, Smb2Status.GetStatusCode(responsePacket.Header.Status));
            }

            client.TreeDisconnect(treeId);
            client.LogOff();
            client.Disconnect();
        }
Beispiel #5
0
        private void ReplacePacketByInvalidCreateContext(Smb2Packet packet)
        {
            Smb2CreateRequestPacket request = packet as Smb2CreateRequestPacket;

            if (request == null)
            {
                return;
            }

            string name = null;

            byte[] dataBuffer = null;
            if (Create_ContextType == CreateContextType.InvalidCreateContext)
            {
                // <235> Section 3.3.5.9: Windows Vista, Windows Server 2008, Windows 7, Windows Server 2008 R2, Windows 8, and Windows Server 2012 ignore create contexts having a NameLength
                // greater than 4 and ignores create contexts with length of 4 that are not specified in section 2.2.13.2.
                // So use three characters' name here
                name = "Inv";
            }
            else if (Create_ContextType == CreateContextType.InvalidCreateContextSize)
            {
                // Use SMB2_CREATE_QUERY_MAXIMAL_ACCESS_REQUEST to test InvalidCreateContextSize since it contains a data buffer.
                name = CreateContextNames.SMB2_CREATE_QUERY_MAXIMAL_ACCESS_REQUEST;
                var createQueryMaximalAccessRequestStruct = new CREATE_QUERY_MAXIMAL_ACCESS_REQUEST
                {
                    Timestamp = new _FILETIME()
                };
                dataBuffer = TypeMarshal.ToBytes(createQueryMaximalAccessRequestStruct);
            }
            else
            {
                throw new ArgumentException("contextType");
            }

            var nameBuffer = Encoding.ASCII.GetBytes(name);

            var createContextStruct = new CREATE_CONTEXT();

            createContextStruct.Buffer = new byte[0];

            createContextStruct.NameOffset = 16;
            createContextStruct.NameLength = (ushort)nameBuffer.Length;
            createContextStruct.Buffer     = createContextStruct.Buffer.Concat(nameBuffer).ToArray();

            if (dataBuffer != null && dataBuffer.Length > 0)
            {
                Smb2Utility.Align8(ref createContextStruct.Buffer);
                createContextStruct.DataOffset = (ushort)(16 + createContextStruct.Buffer.Length);
                createContextStruct.DataLength = (uint)dataBuffer.Length;
                createContextStruct.Buffer     = createContextStruct.Buffer.Concat(dataBuffer).ToArray();
            }

            byte[] createContextValuesBuffer = new byte[0];
            Smb2Utility.Align8(ref createContextValuesBuffer);
            createContextValuesBuffer = createContextValuesBuffer.Concat(TypeMarshal.ToBytes(createContextStruct)).ToArray();

            if (Create_ContextType == CreateContextType.InvalidCreateContextSize)
            {
                // Change DataLength to invalid here, after marshalling.
                createContextValuesBuffer[12] += 1;
            }

            Smb2Utility.Align8(ref request.Buffer);
            request.PayLoad.CreateContextsOffset = (uint)(request.BufferOffset + request.Buffer.Length);
            request.PayLoad.CreateContextsLength = (uint)createContextValuesBuffer.Length;
            request.Buffer = request.Buffer.Concat(createContextValuesBuffer).ToArray();
        }
 /// <summary>
 /// Construct a Create packet which is the first or an unrelated packet in the chain
 /// </summary>
 private Smb2CreateRequestPacket ConstructCreatePacket(ulong sessionId, uint treeId, string fileName)
 {
     Smb2CreateRequestPacket createPacket = new Smb2CreateRequestPacket();
     createPacket.Header.Command = Smb2Command.CREATE;
     createPacket.Header.SessionId = sessionId;
     createPacket.Header.TreeId = treeId;
     createPacket.PayLoad.CreateDisposition = CreateDisposition_Values.FILE_OPEN_IF;
     createPacket.PayLoad.CreateOptions = CreateOptions_Values.FILE_NON_DIRECTORY_FILE;
     createPacket.PayLoad.ImpersonationLevel = ImpersonationLevel_Values.Impersonation;
     createPacket.PayLoad.DesiredAccess = AccessMask.GENERIC_READ | AccessMask.GENERIC_WRITE | AccessMask.DELETE;
     createPacket.PayLoad.ShareAccess = ShareAccess_Values.FILE_SHARE_READ | ShareAccess_Values.FILE_SHARE_WRITE | ShareAccess_Values.FILE_SHARE_DELETE;
     byte[] nameBuffer = Encoding.Unicode.GetBytes(fileName);
     createPacket.PayLoad.NameOffset = createPacket.BufferOffset;
     createPacket.PayLoad.NameLength = (ushort)nameBuffer.Length;
     createPacket.Buffer = nameBuffer;
     return createPacket;
 }