/// <summary> /// Create File, named pipe, directory. One transport can only create one file. /// </summary> /// <param name="fileName">The file, namedpipe, directory name</param> /// <param name="desiredAccess">The desired access</param> /// <param name="impersonationLevel">The impersonation level</param> /// <param name="fileAttribute">The file attribute, this field is only valid when create file. /// </param> /// <param name="createDisposition">Defines the action the server MUST take if the file that is /// specified in the name field already exists</param> /// <param name="createOption">Specifies the options to be applied when creating or opening the file</param> private void InternalCreate(string fileName, NtTransactDesiredAccess desiredAccess, NtTransactImpersonationLevel impersonationLevel, SMB_EXT_FILE_ATTR fileAttribute, NtTransactCreateDisposition createDisposition, NtTransactCreateOptions createOption) { SmbNtCreateAndxRequestPacket request = smbClient.CreateCreateRequest( this.treeId, fileName, desiredAccess, fileAttribute, NtTransactShareAccess.NONE, createDisposition, createOption, impersonationLevel, CreateFlags.NT_CREATE_REQUEST_EXTENDED_RESPONSE); if (this.isSignRequired) { request.Sign(this.NextSequenceNumber, this.sessionKey); } uint status = 0; SmbNtCreateAndxResponsePacket response = this.SendAndExpectSmbPacket(request, internalTimeout, out status) as SmbNtCreateAndxResponsePacket; if (status != 0) { throw new InvalidOperationException("Create Failed. ErrorCode: " + status); } this.fid = response.SmbParameters.FID; }
protected override SmbPacket CreateSmbResponsePacket( SmbPacket request, SmbHeader smbHeader, Channel channel) { SmbPacket smbPacket = null; // error packet SmbStatus packetStatus = (SmbStatus)smbHeader.Status; // error packet if (packetStatus != SmbStatus.STATUS_SUCCESS && packetStatus != SmbStatus.STATUS_MORE_PROCESSING_REQUIRED && packetStatus != SmbStatus.STATUS_BUFFER_OVERFLOW) { smbPacket = new SmbErrorResponsePacket(); smbPacket.SmbHeader = smbHeader; return(smbPacket); } // success packet switch (smbHeader.Command) { case SmbCommand.SMB_COM_NEGOTIATE: if (smbClient.Capability.IsSupportsExtendedSecurity) { smbPacket = new SmbNegotiateResponsePacket(); } else { smbPacket = new SmbNegotiateImplicitNtlmResponsePacket(); } break; case SmbCommand.SMB_COM_SESSION_SETUP_ANDX: if (smbClient.Capability.IsSupportsExtendedSecurity) { smbPacket = new SmbSessionSetupAndxResponsePacket(); } else { smbPacket = new SmbSessionSetupImplicitNtlmAndxResponsePacket(); } break; case SmbCommand.SMB_COM_TREE_CONNECT_ANDX: smbPacket = new SmbTreeConnectAndxResponsePacket(); break; case SmbCommand.SMB_COM_TREE_DISCONNECT: smbPacket = new SmbTreeDisconnectResponsePacket(); break; case SmbCommand.SMB_COM_LOGOFF_ANDX: smbPacket = new SmbLogoffAndxResponsePacket(); break; case SmbCommand.SMB_COM_NT_CREATE_ANDX: smbPacket = new SmbNtCreateAndxResponsePacket(); break; case SmbCommand.SMB_COM_CLOSE: smbPacket = new SmbCloseResponsePacket(); break; case SmbCommand.SMB_COM_OPEN_ANDX: smbPacket = new SmbOpenAndxResponsePacket(); break; case SmbCommand.SMB_COM_WRITE_ANDX: smbPacket = new SmbWriteAndxResponsePacket(); break; case SmbCommand.SMB_COM_READ_ANDX: smbPacket = new SmbReadAndxResponsePacket(); break; case SmbCommand.SMB_COM_TRANSACTION: smbPacket = this.CreateTransactionResponsePacket(request, smbHeader, channel); break; case SmbCommand.SMB_COM_TRANSACTION2: smbPacket = this.CreateTransaction2ResponsePacket(request, smbHeader, channel); break; case SmbCommand.SMB_COM_NT_TRANSACT: smbPacket = this.CreateNtTransactionResponsePacket(request, smbHeader, channel); break; default: break; } if (smbPacket != null) { smbPacket.SmbHeader = smbHeader; return(smbPacket); } return(base.CreateSmbResponsePacket(request, smbHeader, channel)); }
/// <summary> /// Verify whether the two response are equal or not /// </summary> /// <param name="response"> The SmbNtCreateAndxResponsePacketResponse For First</param> /// <param name="response2"> The SmbNtCreateAndxResponsePacket Response For Second</param> private bool VerifyCreateResponse( SmbNtCreateAndxResponsePacket response, SmbNtCreateAndxResponsePacket response2) { return (response.IsSignRequired == response2.IsSignRequired) && (response.PacketType == response2.PacketType) && (response.SmbData.ByteCount == response2.SmbData.ByteCount) && (response.SmbParameters.AllocationSize == response2.SmbParameters.AllocationSize) && (response.SmbParameters.AndXCommand == response2.SmbParameters.AndXCommand) && (response.SmbParameters.AndXOffset == response2.SmbParameters.AndXOffset) && (response.SmbParameters.AndXReserved == response2.SmbParameters.AndXReserved) && (response.SmbParameters.CreateTime.Time == response2.SmbParameters.CreateTime.Time) && (response.SmbParameters.NMPipeStatus_or_FileStatusFlags == response2.SmbParameters.NMPipeStatus_or_FileStatusFlags) && (response.SmbParameters.Directory == response2.SmbParameters.Directory) && (response.SmbParameters.EndOfFile == response2.SmbParameters.EndOfFile) && (response.SmbParameters.ExtFileAttributes == response2.SmbParameters.ExtFileAttributes) && CompareArrayEquals(response.SmbParameters.FileId, response2.SmbParameters.FileId) && (response.SmbParameters.ResourceType == response2.SmbParameters.ResourceType) && CompareArrayEquals( response.SmbParameters.GuestMaximalAccessRights, response2.SmbParameters.GuestMaximalAccessRights) && (response.SmbParameters.LastAccessTime.Time == response2.SmbParameters.LastAccessTime.Time) && (response.SmbParameters.LastChangeTime.Time == response2.SmbParameters.LastChangeTime.Time) && (response.SmbParameters.LastWriteTime.Time == response2.SmbParameters.LastWriteTime.Time) && CompareArrayEquals( response.SmbParameters.MaximalAccessRights, response2.SmbParameters.MaximalAccessRights) && (response.SmbParameters.OplockLevel == response2.SmbParameters.OplockLevel) && CompareArrayEquals(response.SmbParameters.VolumeGUID, response2.SmbParameters.VolumeGUID) && (response.SmbParameters.WordCount == response2.SmbParameters.WordCount); }
/// <summary> /// update the context with response packet /// </summary> /// <param name="connection">the connection of endpoint</param> /// <param name="packet">the packet to update the context</param> private void ResponsePacketUpdateRoleContext(SmbServerConnection connection, SmbPacket packet) { SmbHeader smbHeader = packet.SmbHeader; SmbPacket requestPacket = connection.GetRequestPacket(smbHeader.Mid); if (requestPacket == null) { return; } switch (smbHeader.Command) { case SmbCommand.SMB_COM_SESSION_SETUP_ANDX: if (smbHeader.Uid == 0) { break; } else { SmbServerSession session = new SmbServerSession(); session.Uid = smbHeader.Uid; session.AuthenticationState = SessionState.Complete; session.Connection = connection; session.SessionKey = connection.GssApi.SessionKey; connection.AddSession(session); } break; case SmbCommand.SMB_COM_LOGOFF_ANDX: if (requestPacket.SmbHeader.Uid == 0) { break; } else { connection.RemoveSession(connection.GetSession(requestPacket.SmbHeader.Uid)); } break; case SmbCommand.SMB_COM_TREE_CONNECT_ANDX: { SmbTreeConnectAndxRequestPacket request = requestPacket as SmbTreeConnectAndxRequestPacket; SmbServerTreeConnect treeconnect = new SmbServerTreeConnect(); treeconnect.TreeId = smbHeader.Tid; treeconnect.Session = connection.GetSession(smbHeader.Uid); if (treeconnect.Session == null) { break; } if ((request.SmbHeader.Flags2 & SmbFlags2.SMB_FLAGS2_UNICODE) != 0) { treeconnect.Path = Encoding.Unicode.GetString(request.SmbData.Path); } else { treeconnect.Path = Encoding.ASCII.GetString(request.SmbData.Path); } treeconnect.Path = treeconnect.Path.TrimEnd('\0'); treeconnect.Session.AddTreeConnect(treeconnect); } break; case SmbCommand.SMB_COM_TREE_DISCONNECT: if (requestPacket.SmbHeader.Uid != 0) { SmbServerSession session = connection.GetSession(requestPacket.SmbHeader.Uid); if (session == null) { break; } session.RemoveTreeConnect(session.GetTreeConnect(requestPacket.SmbHeader.Tid)); } break; case SmbCommand.SMB_COM_NT_CREATE_ANDX: { SmbNtCreateAndxResponsePacket response = packet as SmbNtCreateAndxResponsePacket; SmbNtCreateAndxRequestPacket request = requestPacket as SmbNtCreateAndxRequestPacket; SmbServerOpen open = new SmbServerOpen(); open.SmbFid = response.SmbParameters.FID; open.PathName = SmbMessageUtils.GetString(request.SmbData.FileName, SmbFlags2.SMB_FLAGS2_UNICODE == (request.SmbHeader.Flags2 & SmbFlags2.SMB_FLAGS2_UNICODE)); open.PathName = open.PathName.TrimEnd('\0'); open.Session = connection.GetSession(smbHeader.Uid); open.TreeConnect = connection.GetTreeConnect(smbHeader.Tid); if (open.TreeConnect == null) { break; } open.TreeConnect.AddOpen(open); } break; case SmbCommand.SMB_COM_OPEN_ANDX: { SmbOpenAndxResponsePacket response = packet as SmbOpenAndxResponsePacket; SmbOpenAndxRequestPacket request = requestPacket as SmbOpenAndxRequestPacket; SmbServerOpen open = new SmbServerOpen(); open.SmbFid = response.SmbParameters.FID; open.PathName = SmbMessageUtils.GetString(request.SmbData.FileName, SmbFlags2.SMB_FLAGS2_UNICODE == (request.SmbHeader.Flags2 & SmbFlags2.SMB_FLAGS2_UNICODE)); open.Session = connection.GetSession(smbHeader.Uid); open.TreeConnect = connection.GetTreeConnect(smbHeader.Tid); if (open.TreeConnect == null) { break; } open.TreeConnect.AddOpen(open); } break; case SmbCommand.SMB_COM_CLOSE: { SmbCloseRequestPacket closeRequest = requestPacket as SmbCloseRequestPacket; SmbServerTreeConnect treeconnect = connection.GetTreeConnect(requestPacket.SmbHeader.Tid); if (treeconnect == null) { break; } treeconnect.RemoveOpen(treeconnect.GetOpen(closeRequest.SmbParameters.FID)); } break; default: break; } connection.RemoveRequestPacket(packet); }
/// <summary> /// Deep copy constructor. /// </summary> public SmbNtCreateAndxResponsePacket(SmbNtCreateAndxResponsePacket packet) : base(packet) { }