public Smb2IOCtlResponsePacket CreateSnapshotIOCtlResponseAsync( Smb2Endpoint endpoint, ulong asyncId, ulong messageId, SRV_SNAPSHOT_ARRAY snapshots ) { Smb2IOCtlResponsePacket packet = CreateSnapshotIOCtlResponse(endpoint, messageId, snapshots); ModifyAsyncHeader(packet, endpoint, asyncId); packet.Sign(); return packet; }
public Smb2LeaseBreakResponsePacket CreateLeaseBreakResponse( Smb2Endpoint endpoint, ulong messageId, LeaseStateValues leaseState ) { Smb2LeaseBreakResponsePacket packet = new Smb2LeaseBreakResponsePacket(); SetHeader(packet, endpoint, messageId); Smb2LeaseBreakAckPacket leaseBreakAck = context.FindRequestPacket(endpoint.EndpointId, messageId) as Smb2LeaseBreakAckPacket; packet.PayLoad.Flags = LEASE_BREAK_Response_Packet_Flags_Values.V1; packet.PayLoad.LeaseDuration = LEASE_BREAK_Response_Packet_LeaseDuration_Values.V1; packet.PayLoad.LeaseKey = leaseBreakAck.PayLoad.LeaseKey; packet.PayLoad.LeaseState = leaseState; packet.PayLoad.Reserved = LEASE_BREAK_Response_Reserved_Values.V1; packet.PayLoad.StructureSize = LEASE_BREAK_Response_StructureSize_Values.V1; packet.Sign(); return packet; }
public Smb2LogOffResponsePacket CreateLogoffResponse( Smb2Endpoint endpoint, ulong messageId ) { Smb2LogOffResponsePacket packet = new Smb2LogOffResponsePacket(); SetHeader(packet, endpoint, messageId); packet.PayLoad.Reserved = LOGOFF_Response_Reserved_Values.V1; packet.PayLoad.StructureSize = LOGOFF_Response_StructureSize_Values.V1; packet.Sign(); return packet; }
public Smb2ErrorResponsePacket CreateErrorResponseAsync( Smb2Endpoint endpoint, ulong asyncId, uint status, ulong messageId, byte[] errorData ) { Smb2ErrorResponsePacket packet = CreateErrorResponse(endpoint, status, messageId, errorData); packet.Header.Flags |= Packet_Header_Flags_Values.FLAGS_ASYNC_COMMAND; packet.Header.ProcessId = (uint)asyncId; packet.Header.TreeId = (uint)(asyncId >> 32); packet.Sign(); return packet; }
public Smb2IOCtlResponsePacket CreateIOCtlResponseAsync( Smb2Endpoint endpoint, ulong asyncId, ulong messageId, byte[] input, byte[] output ) { Smb2IOCtlResponsePacket packet = CreateIOCtlResponse(endpoint, messageId, input, output); ModifyAsyncHeader(packet, endpoint, asyncId); packet.Sign(); return packet; }
public Smb2IOCtlResponsePacket CreateCopyChunkIOCtlResponseAsync( Smb2Endpoint endpoint, ulong asyncId, ulong messageId, SRV_COPYCHUNK_RESPONSE copyChunk ) { Smb2IOCtlResponsePacket packet = CreateCopyChunkIOCtlResponse(endpoint, messageId, copyChunk); ModifyAsyncHeader(packet, endpoint, asyncId); packet.Sign(); return packet; }
public Smb2CreateResponsePacket CreateCreateResponseAsync( Smb2Endpoint endpoint, ulong asyncId, ulong messageId, OplockLevel_Values oplockLevel, CreateAction_Values createAction, _FILETIME creationTime, _FILETIME lastAccessTime, _FILETIME lastWriteTime, _FILETIME changeTime, ulong allocationSize, ulong endofFile, File_Attributes fileAttributes, FILEID fileId, params CREATE_CONTEXT_Values[] contexts ) { Smb2CreateResponsePacket packet = CreateCreateResponse(endpoint, messageId, oplockLevel, createAction, creationTime, lastAccessTime, lastWriteTime, changeTime, allocationSize, endofFile, fileAttributes, fileId, contexts); ModifyAsyncHeader(packet, endpoint, asyncId); packet.Sign(); return packet; }
/// <summary> /// Expect a packet from a client specified by the endpoint. /// </summary> /// <param name="endpoint">The endpoint of the client</param> /// <param name="timeout">The waiting time</param> /// <returns>A Smb2Packet</returns> /// <exception cref="System.InvalidOperationException">throw when receive a packet which does not pass signature check</exception> /// <exception cref="System.InvalidOperationException">Receive unexpected packet</exception> public Smb2Packet ExpectPacket(out Smb2Endpoint endpoint, TimeSpan timeout) { TransportEvent transEvent = transport.ExpectTransportEvent(timeout); if (transEvent.EventType == EventType.Exception) { throw new InvalidOperationException("Received un-expected packet, packet type is not correct", (Exception)transEvent.EventObject); } if (transEvent.EventType != EventType.ReceivedPacket) { throw new InvalidOperationException("Received un-expected packet, packet type is not correct"); } Smb2Event smb2Event = new Smb2Event(); smb2Event.Type = Smb2EventType.PacketReceived; foreach (Smb2Endpoint smb2endpoint in clientEndpoints) { if (smb2endpoint.TransportType == Smb2TransportType.NetBios) { if ((object)smb2endpoint.SessionId == transEvent.EndPoint) { endpoint = smb2endpoint; smb2Event.Packet = (Smb2Packet)transEvent.EventObject; smb2Event.ConnectionId = smb2endpoint.EndpointId; context.UpdateContext(smb2Event); return (Smb2Packet)transEvent.EventObject; } } else if (smb2endpoint.TransportType == Smb2TransportType.Tcp) { if ((object)smb2endpoint.RemoteEndpoint == transEvent.EndPoint) { endpoint = smb2endpoint; smb2Event.Packet = (Smb2Packet)transEvent.EventObject; smb2Event.ConnectionId = smb2endpoint.EndpointId; context.UpdateContext(smb2Event); return (Smb2Packet)transEvent.EventObject; } } } throw new InvalidOperationException("Received an un-expected packet, endpoint is not correct"); }
/// <summary> /// Send packet to a client specified by the endpoint, this method is for negative test, for normal use, please use /// SendPacket(Smb2Packet packet) /// </summary> /// <param name="endpoint">The client endpoint</param> /// <param name="packet">The packet</param> public void SendPacket(Smb2Endpoint endpoint, Smb2Packet packet) { Smb2Event smb2Event = new Smb2Event(); smb2Event.ConnectionId = endpoint.EndpointId; smb2Event.Packet = packet; smb2Event.Type = Smb2EventType.PacketSent; context.UpdateContext(smb2Event); SendPacket(endpoint, packet.ToBytes()); }
/// <summary> /// Disconnect the client /// </summary> /// <param name="endpoint">The endpoint of the client</param> public void Disconnect(Smb2Endpoint endpoint) { Disconnect(endpoint, true); }
/// <summary> /// Expect a client connection /// </summary> /// <param name="timeOut">The waiting time</param> /// <returns>The endpoint of the client</returns> public Smb2Endpoint ExpectConnection(TimeSpan timeOut) { TransportEvent transEvent = transport.ExpectTransportEvent(timeOut); if (transEvent.EventType != EventType.Connected) { throw new InvalidOperationException("Reveived an un-expected transport event"); } Smb2Endpoint endpoint; if (transportType == Smb2TransportType.NetBios) { endpoint = new Smb2Endpoint(Smb2TransportType.NetBios, null, (byte)transEvent.EndPoint, endpointId++); } else { endpoint = new Smb2Endpoint(Smb2TransportType.Tcp, (IPEndPoint)transEvent.EndPoint, 0, endpointId++); } Smb2Event smb2Event = new Smb2Event(); smb2Event.Type = Smb2EventType.Connected; smb2Event.Packet = null; smb2Event.ConnectionId = endpoint.EndpointId; context.UpdateContext(smb2Event); clientEndpoints.Add(endpoint); return endpoint; }
public Smb2WriteResponsePacket CreateWriteResponse( Smb2Endpoint endpoint, ulong messageId, uint count ) { Smb2WriteResponsePacket packet = new Smb2WriteResponsePacket(); SetHeader(packet, endpoint, messageId); packet.PayLoad.Count = count; packet.PayLoad.Remaining = Remaining_Values.V1; packet.PayLoad.Reserved = WRITE_Response_Reserved_Values.V1; packet.PayLoad.StructureSize = WRITE_Response_StructureSize_Values.V1; packet.PayLoad.WriteChannelInfoLength = WRITE_Response_WriteChannelInfoLength_Values.V1; packet.PayLoad.WriteChannelInfoOffset = WRITE_Response_WriteChannelInfoOffset_Values.V1; packet.Sign(); return packet; }
public Smb2TreeDisconnectResponsePacket CreateTreeDisconnectResponse( Smb2Endpoint endpoint, ulong messageId ) { Smb2TreeDisconnectResponsePacket packet = new Smb2TreeDisconnectResponsePacket(); SetHeader(packet, endpoint, messageId); packet.PayLoad.Reserved = TREE_DISCONNECT_Response_Reserved_Values.V1; packet.PayLoad.StructureSize = TREE_DISCONNECT_Response_StructureSize_Values.CorrectValue; packet.Sign(); return packet; }
public Smb2TreeConnectResponsePacket CreateTreeConnectResponse( Smb2Endpoint endpoint, ulong messageId, uint treeId, ShareType_Values shareType, ShareFlags_Values shareFlags, Capabilities_Values capabilities, _ACCESS_MASK maximalAccess ) { Smb2TreeConnectResponsePacket packet = new Smb2TreeConnectResponsePacket(); SetHeader(packet, endpoint, messageId); packet.Header.TreeId = treeId; packet.PayLoad.Capabilities = capabilities; packet.PayLoad.MaximalAccess = maximalAccess; packet.PayLoad.Reserved = Reserved_Values.V1; packet.PayLoad.ShareFlags = shareFlags; packet.PayLoad.ShareType = shareType; packet.PayLoad.StructureSize = StructureSize_Values.V1; packet.Sign(); return packet; }
/// <summary> /// Create Smb2CompoundPacket /// </summary> /// <param name="endpoint">represents where this packet will be sent</param> /// <param name="packets">Variable number of Single packets</param> /// <returns>A Smb2CompoundPacket</returns> public Smb2CompoundPacket CreateCompoundResponse( Smb2Endpoint endpoint, params Smb2SinglePacket[] packets ) { if (packets == null) { throw new ArgumentNullException("packets"); } if (packets.Length < 2) { throw new ArgumentException("The number of packet should be larger than 1", "packets"); } Smb2CompoundPacket packet = new Smb2CompoundPacket(); packet.Packets = new List<Smb2SinglePacket>(); //The endpoint of the compoundpacket comes from innerPacket. packet.Endpoint = packets[0].Endpoint; for (int i = 0; i < packets.Length; i++) { if (((packets[0].Header.Flags & Packet_Header_Flags_Values.FLAGS_RELATED_OPERATIONS) == Packet_Header_Flags_Values.FLAGS_RELATED_OPERATIONS)) { packets[i].OuterCompoundPacket = packet; } if (i != (packets.Length - 1)) { packets[i].Header.NextCommand = (uint)Smb2Utility.AlignBy8Bytes(packets[i].ToBytes().Length); } else { packets[i].IsLast = true; } packets[i].IsInCompoundPacket = true; packet.Packets.Add(packets[i]); } packet.Sign(); return packet; }
/// <summary> /// Send packet data to client /// </summary> /// <param name="endpoint">The client endpoint</param> /// <param name="packet">The packet data</param> public void SendPacket(Smb2Endpoint endpoint, byte[] packet) { if (transportType == Smb2TransportType.NetBios) { transport.SendBytes(endpoint.SessionId, packet); } else { transport.SendBytes(endpoint.RemoteEndpoint, Smb2Utility.GenerateTcpTransportPayLoad(packet)); } }
public Smb2IOCtlResponsePacket CreateCopyChunkIOCtlResponse( Smb2Endpoint endpoint, ulong messageId, SRV_COPYCHUNK_RESPONSE copyChunk ) { byte[] output = TypeMarshal.ToBytes(copyChunk); return CreateIOCtlResponse(endpoint, messageId, null, output); }
/// <summary> /// Disconnect the client /// </summary> /// <param name="endpoint">The endpoint of the client</param> /// <param name="removeEndpoint">Indicate whether the endpoint should be removed from endpointList</param> private void Disconnect(Smb2Endpoint endpoint, bool removeEndpoint) { if (!clientEndpoints.Contains(endpoint)) { throw new ArgumentException("The endpoint is not in the server's client endpoint list.", "endpoint"); } if (removeEndpoint) { clientEndpoints.Remove(endpoint); } Smb2Event smb2Event = new Smb2Event(); smb2Event.Type = Smb2EventType.Disconnected; smb2Event.Packet = null; smb2Event.ConnectionId = endpoint.EndpointId; context.UpdateContext(smb2Event); if (transportType == Smb2TransportType.NetBios) { transport.Disconnect(endpoint.SessionId); } else { transport.Disconnect(endpoint.RemoteEndpoint); } }
public Smb2CreateResponsePacket CreateCreateResponse( Smb2Endpoint endpoint, ulong messageId, OplockLevel_Values oplockLevel, CreateAction_Values createAction, _FILETIME creationTime, _FILETIME lastAccessTime, _FILETIME lastWriteTime, _FILETIME changeTime, ulong allocationSize, ulong endofFile, File_Attributes fileAttributes, FILEID fileId, params CREATE_CONTEXT_Values[] createContexts ) { Smb2CreateResponsePacket packet = new Smb2CreateResponsePacket(); SetHeader(packet, endpoint, messageId); packet.PayLoad.StructureSize = CREATE_Response_StructureSize_Values.V1; packet.PayLoad.OplockLevel = oplockLevel; packet.PayLoad.Reserved = 0; packet.PayLoad.CreateAction = createAction; packet.PayLoad.CreationTime = creationTime; packet.PayLoad.LastAccessTime = lastAccessTime; packet.PayLoad.LastWriteTime = lastWriteTime; packet.PayLoad.ChangeTime = changeTime; packet.PayLoad.AllocationSize = allocationSize; packet.PayLoad.EndofFile = endofFile; packet.PayLoad.FileAttributes = fileAttributes; packet.PayLoad.Reserved2 = 0; packet.PayLoad.FileId = fileId; if (createContexts == null) { packet.PayLoad.CreateContextsOffset = 0; packet.PayLoad.CreateContextsLength = 0; packet.PayLoad.Buffer = new byte[0]; } else { packet.PayLoad.CreateContextsOffset = Smb2Consts.CreateContextOffsetInCreateResponse; using (MemoryStream ms = new MemoryStream()) { for (int i = 0; i < createContexts.Length; i++) { byte[] createContext = TypeMarshal.ToBytes(createContexts[i]); if (i != (createContexts.Length - 1)) { int alignedLen = Smb2Utility.AlignBy8Bytes(createContext.Length); byte[] nextValue = BitConverter.GetBytes(alignedLen); Array.Copy(nextValue, createContext, nextValue.Length); ms.Write(createContext, 0, createContext.Length); //write the padding 0; for (int j = 0; j < (alignedLen - createContext.Length); j++) { ms.WriteByte(0); } } else { ms.Write(createContext, 0, createContext.Length); } } packet.PayLoad.Buffer = ms.ToArray(); packet.PayLoad.CreateContextsLength = (uint)packet.PayLoad.Buffer.Length; } } packet.Sign(); return packet; }
/// <summary> /// modify the header of packet because it is a async packet /// </summary> /// <param name="packet">The packet</param> /// <param name="endpoint">The endpoint of client</param> /// <param name="asyncId">The asyncId</param> private void ModifyAsyncHeader(Smb2SinglePacket packet, Smb2Endpoint endpoint, ulong asyncId) { packet.Header.Flags |= Packet_Header_Flags_Values.FLAGS_ASYNC_COMMAND; packet.Header.ProcessId = (uint)asyncId; packet.Header.TreeId = (uint)(asyncId >> 32); //for finnal async response, if Interim Response has been send, it does not grand //any credits because credits has been granded in Interim Response if (context.connectionList[endpoint.EndpointId].asyncCommandList.ContainsKey(asyncId)) { packet.Header.CreditRequest_47_Response = 0; } else { //grand credits as normal } }
public Smb2ErrorResponsePacket CreateErrorResponse( Smb2Endpoint endpoint, uint status, ulong messageId, byte[] errorData ) { Smb2ErrorResponsePacket packet = new Smb2ErrorResponsePacket(); SetHeader(packet, status, endpoint, messageId); packet.PayLoad.StructureSize = ERROR_Response_packet_StructureSize_Values.V1; packet.PayLoad.Reserved = ERROR_Response_packet_Reserved_Values.V1; if (errorData == null) { packet.PayLoad.ByteCount = 0; //If the ByteCount field is zero then the server MUST supply an ErrorData //field that is one byte in length packet.PayLoad.ErrorData = new byte[1]; } else { packet.PayLoad.ErrorData = errorData; packet.PayLoad.ByteCount = (uint)errorData.Length; } packet.Header.Flags = packet.Header.Flags & ~Packet_Header_Flags_Values.FLAGS_SIGNED; packet.Sign(); return packet; }
/// <summary> /// Set packet header field /// </summary> /// <param name="packet">The packet</param> /// <param name="endpoint">The client endpoint</param> /// <param name="messageId">The messageId of request packet</param> private void SetHeader(Smb2SinglePacket packet, Smb2Endpoint endpoint, ulong messageId) { SetHeader(packet, 0, endpoint, messageId); }
public Smb2IOCtlResponsePacket CreateIOCtlResponse( Smb2Endpoint endpoint, ulong messageId, byte[] input, byte[] output ) { Smb2IOCtlResponsePacket packet = new Smb2IOCtlResponsePacket(); Smb2IOCtlRequestPacket requestPacket = context.FindRequestPacket(endpoint.EndpointId, messageId) as Smb2IOCtlRequestPacket; SetHeader(packet, endpoint, messageId); packet.PayLoad.CtlCode = (uint)requestPacket.PayLoad.CtlCode; packet.PayLoad.FileId = requestPacket.PayLoad.FileId; packet.PayLoad.Flags = IOCTL_Response_Flags_Values.V1; int bufferLen = 0; if (input != null) { packet.PayLoad.InputCount = (uint)input.Length; packet.PayLoad.InputOffset = Smb2Consts.InputOffsetInIOCtlResponse; bufferLen += Smb2Utility.AlignBy8Bytes(input.Length); } if (output != null) { packet.PayLoad.OutputCount = (uint)output.Length; packet.PayLoad.OutputOffset = (uint)(Smb2Consts.InputOffsetInIOCtlResponse + bufferLen); bufferLen += output.Length; } byte[] buffer = new byte[bufferLen]; if (input != null) { Array.Copy(input, buffer, input.Length); } if (output != null) { Array.Copy(output, 0, buffer, packet.PayLoad.OutputOffset - Smb2Consts.InputOffsetInIOCtlResponse, output.Length); } packet.PayLoad.Reserved = IOCTL_Response_Reserved_Values.V1; packet.PayLoad.Reserved2 = IOCTL_Response_Reserved2_Values.V1; packet.PayLoad.StructureSize = IOCTL_Response_StructureSize_Values.V1; packet.PayLoad.Buffer = buffer; packet.Sign(); return packet; }
private void SetHeader(Smb2SinglePacket packet, uint status, Smb2Endpoint endpoint, ulong messageId) { packet.Endpoint = endpoint; Smb2SinglePacket singleRequestPacket = context.FindRequestPacket(endpoint.EndpointId, messageId) as Smb2SinglePacket; bool isRequestSigned = false; ushort clientRequestCredits = 0; if (singleRequestPacket == null) { packet.Header.MessageId = 0; packet.Header.Command = Smb2Command.NEGOTIATE; } else { packet.Header.MessageId = singleRequestPacket.Header.MessageId; packet.Header.SessionId = singleRequestPacket.Header.SessionId; packet.Header.TreeId = singleRequestPacket.Header.TreeId; packet.Header.ProcessId = singleRequestPacket.Header.ProcessId; packet.Header.Command = singleRequestPacket.Header.Command; if (((singleRequestPacket).Header.Flags & Packet_Header_Flags_Values.FLAGS_SIGNED) == Packet_Header_Flags_Values.FLAGS_SIGNED) { isRequestSigned = true; } clientRequestCredits = singleRequestPacket.Header.CreditRequest_47_Response; } packet.Header.CreditRequest_47_Response = Smb2Utility.CaculateResponseCredits(clientRequestCredits, context.connectionList[endpoint.EndpointId].commandSequenceWindow.Count); packet.Header.ProtocolId = Smb2Consts.Smb2ProtocolId; packet.Header.Signature = new byte[Smb2Consts.SignatureSize]; packet.Header.StructureSize = Packet_Header_StructureSize_Values.V1; packet.Header.Status = status; packet.Header.Flags |= Packet_Header_Flags_Values.FLAGS_SERVER_TO_REDIR; if (packet.Header.SessionId != 0 && (isRequestSigned || context.ShouldPacketBeSigned(singleRequestPacket.GetSessionId()))) { packet.Header.Flags |= Packet_Header_Flags_Values.FLAGS_SIGNED; (packet as Smb2SinglePacket).SessionKey = context.globalSessionTable[singleRequestPacket.GetSessionId()].sessionKey; } }
public Smb2LeaseBreakNotificationPacket CreateLeaseBreakNotificationResponse( Smb2Endpoint endpoint, LEASE_BREAK_Notification_Packet_Flags_Values flags, byte[] leaseKey, LeaseStateValues currentLeaseState, LeaseStateValues newLeaseState ) { Smb2LeaseBreakNotificationPacket packet = new Smb2LeaseBreakNotificationPacket(); packet.Header.Flags = Packet_Header_Flags_Values.FLAGS_SERVER_TO_REDIR; packet.Header.Command = Smb2Command.OPLOCK_BREAK; packet.Header.MessageId = ulong.MaxValue; packet.Header.ProtocolId = Smb2Consts.Smb2ProtocolId; packet.Header.Signature = new byte[Smb2Consts.SignatureSize]; packet.Header.StructureSize = Packet_Header_StructureSize_Values.V1; packet.Endpoint = endpoint; packet.PayLoad.AccessMaskHint = LEASE_BREAK_Notification_Packet_AccessMaskHint_Values.V1; packet.PayLoad.BreakReason = LEASE_BREAK_Notification_Packet_BreakReason_Values.V1; packet.PayLoad.CurrentLeaseState = currentLeaseState; packet.PayLoad.Flags = LEASE_BREAK_Notification_Packet_Flags_Values.SMB2_NOTIFY_BREAK_LEASE_FLAG_ACK_REQUIRED; packet.PayLoad.LeaseKey = leaseKey; packet.PayLoad.NewLeaseState = newLeaseState; packet.PayLoad.Reserved = LEASE_BREAK_Notification_Packet_Reserved_Values.V1; packet.PayLoad.ShareMaskHint = LEASE_BREAK_Notification_Packet_ShareMaskHint_Values.V1; packet.PayLoad.StructureSize = LEASE_BREAK_Notification_Packet_StructureSize_Values.V1; packet.Sign(); return packet; }
public Smb2ChangeNotifyResponsePacket CreateChangeNotifyResponseAsync( Smb2Endpoint endpoint, ulong asyncId, uint status, ulong messageId, params FILE_NOTIFY_INFORMATION[] notifyInfo ) { Smb2ChangeNotifyResponsePacket packet = CreateChangeNotifyResponse(endpoint, status, messageId, notifyInfo); ModifyAsyncHeader(packet, endpoint, asyncId); packet.Sign(); return packet; }
public Smb2LockResponsePacket CreateLockResponseAsync( Smb2Endpoint endpoint, ulong asyncId, ulong messageId ) { Smb2LockResponsePacket packet = CreateLockResponse(endpoint, messageId); ModifyAsyncHeader(packet, endpoint, asyncId); packet.Sign(); return packet; }
public Smb2CloseResponsePacket CreateCloseResponse( Smb2Endpoint endpoint, ulong messageId, CLOSE_Response_Flags_Values flags, _FILETIME creationTime, _FILETIME lastAccessTime, _FILETIME lastWriteTime, _FILETIME changeTime, ulong allocationSize, ulong endofFile, File_Attributes fileAttributes ) { Smb2CloseResponsePacket packet = new Smb2CloseResponsePacket(); SetHeader(packet, endpoint, messageId); packet.PayLoad.AllocationSize = allocationSize; packet.PayLoad.ChangeTime = changeTime; packet.PayLoad.CreationTime = creationTime; packet.PayLoad.EndofFile = endofFile; packet.PayLoad.FileAttributes = fileAttributes; if (fileAttributes == File_Attributes.NONE) { packet.PayLoad.Flags = CLOSE_Response_Flags_Values.NONE; } else { packet.PayLoad.Flags = CLOSE_Response_Flags_Values.V1; } packet.PayLoad.LastAccessTime = lastAccessTime; packet.PayLoad.LastWriteTime = lastWriteTime; packet.PayLoad.Reserved = CLOSE_Response_Reserved_Values.V1; packet.PayLoad.StructureSize = CLOSE_Response_StructureSize_Values.V1; packet.Sign(); return packet; }
public Smb2NegotiateResponsePacket CreateNegotiateResponse( Smb2Endpoint endpoint, DialectRevision_Values dialectRevision, SecurityPackage securityPackage, ServerContextAttribute contextAttribute ) { Smb2NegotiateResponsePacket packet = new Smb2NegotiateResponsePacket(); SetHeader(packet, endpoint, 0); packet.PayLoad.SecurityMode |= NEGOTIATE_Response_SecurityMode_Values.NEGOTIATE_SIGNING_ENABLED; if (context.requireMessageSigning) { packet.PayLoad.SecurityMode |= NEGOTIATE_Response_SecurityMode_Values.NEGOTIATE_SIGNING_REQUIRED; } packet.PayLoad.StructureSize = NEGOTIATE_Response_StructureSize_Values.V1; packet.PayLoad.DialectRevision = dialectRevision; packet.PayLoad.ServerGuid = context.serverGuid; if (context.isDfsCapable) { packet.PayLoad.Capabilities |= NEGOTIATE_Response_Capabilities_Values.GLOBAL_CAP_DFS; } packet.PayLoad.MaxTransactSize = uint.MaxValue; packet.PayLoad.MaxWriteSize = uint.MaxValue; packet.PayLoad.MaxReadSize = uint.MaxValue; packet.PayLoad.SystemTime = Smb2Utility.DateTimeToFileTime(DateTime.Now); packet.PayLoad.ServerStartTime = Smb2Utility.DateTimeToFileTime(context.serverStartTime); SecurityPackageType package = SecurityPackageType.Negotiate; if (securityPackage == SecurityPackage.Kerberos) { package = SecurityPackageType.Kerberos; } else if (securityPackage == SecurityPackage.Nlmp) { package = SecurityPackageType.Ntlm; } AccountCredential credential = new AccountCredential(null, null, null); context.connectionList[endpoint.EndpointId].credential = credential; context.connectionList[endpoint.EndpointId].packageType = package; context.connectionList[endpoint.EndpointId].contextAttribute = (ServerSecurityContextAttribute)contextAttribute; if (package == SecurityPackageType.Negotiate) { context.connectionList[endpoint.EndpointId].gss = new SspiServerSecurityContext( package, credential, null, context.connectionList[endpoint.EndpointId].contextAttribute, SecurityTargetDataRepresentation.SecurityNativeDrep); //Generate the first token context.connectionList[endpoint.EndpointId].gss.Accept(null); packet.PayLoad.Buffer = context.connectionList[endpoint.EndpointId].gss.Token; packet.PayLoad.SecurityBufferOffset = Smb2Consts.SecurityBufferOffsetInNegotiateResponse; } else { packet.PayLoad.Buffer = new byte[0]; } packet.PayLoad.SecurityBufferLength = (ushort)packet.PayLoad.Buffer.Length; packet.Sign(); return packet; }
public Smb2ChangeNotifyResponsePacket CreateChangeNotifyResponse( Smb2Endpoint endpoint, uint status, ulong messageId, params FILE_NOTIFY_INFORMATION[] notifyInfo ) { Smb2ChangeNotifyResponsePacket packet = new Smb2ChangeNotifyResponsePacket(); SetHeader(packet, status, endpoint, messageId); if (notifyInfo == null) { packet.PayLoad.Buffer = new byte[0]; } else { using (MemoryStream ms = new MemoryStream()) { foreach (FILE_NOTIFY_INFORMATION oneNotifyInfo in notifyInfo) { byte[] oneNotifyInfoArray = TypeMarshal.ToBytes(oneNotifyInfo); ms.Write(oneNotifyInfoArray, 0, oneNotifyInfoArray.Length); } packet.PayLoad.Buffer = ms.ToArray(); packet.PayLoad.OutputBufferLength = (uint)packet.PayLoad.Buffer.Length; packet.PayLoad.OutputBufferOffset = Smb2Consts.OutputBufferOffsetInChangeNotifyResponse; } } packet.Sign(); return packet; }