public void S1_Connection_ConnectionInitiation_PositiveTest() { #region Test Steps // 1. Establish transport connection with RDP Server (SUT) // 2. Send a Client X.224 Connection Request PDU to SUT. // 3. Waite for Server X.224 Connection Confirm PDU with RDP_NEG_RSP structure from SUT. // 4. Verify the received Server X.224 Connection Confirm PDU. #endregion Test Steps #region Test Code this.Site.Log.Add(LogEntryKind.Comment, "Establish transport connection with RDP Server, encrypted protocol is {0}.", testConfig.transportProtocol.ToString()); rdpbcgrAdapter.ConnectToServer(testConfig.transportProtocol); this.Site.Log.Add(LogEntryKind.Comment, "Send a Client X.224 Connection Request PDU with all security protocols supported to SUT."); rdpbcgrAdapter.SendClientX224ConnectionRequest(NegativeType.None, testConfig.requestProtocol); this.Site.Log.Add(LogEntryKind.Comment, "Expecting SUT to send a Server X224 Connection Confirm with RDP Negotiation Response."); Server_X_224_Connection_Confirm_Pdu confirmPdu = rdpbcgrAdapter.ExpectPacket <Server_X_224_Connection_Confirm_Pdu>(testConfig.timeout); if (confirmPdu == null) { this.Site.Log.Add(LogEntryKind.Comment, "Timeout when receiving Server X224 Connection Confirm with RDP Negotiation Response, try to receive Server X.224 Connection Confirm PDU with RDP Negotiation Failure"); Server_X_224_Negotiate_Failure_Pdu negotiateFailurePdu = rdpbcgrAdapter.ExpectPacket <Server_X_224_Negotiate_Failure_Pdu>(testConfig.timeout); this.Site.Assert.IsNotNull(negotiateFailurePdu, "RDP Server MUST response a Server X224 Connection Confirm PDP after receiving a Client X224 Connection Request PDU."); if (negotiateFailurePdu.rdpNegFailure.failureCode == failureCode_Values.SSL_NOT_ALLOWED_BY_SERVER) { this.Site.Log.Add(LogEntryKind.Comment, "Received a Server X.224 Connection Confirm PDU with RDP Negotiation Failure, whose failureCode field is SSL_NOT_ALLOWED_BY_SERVER. Reconnect to the RDP Server and send Client X.224 Connection Request PDU only support RDP protocol."); rdpbcgrAdapter.Disconnect(); testConfig.transportProtocol = EncryptedProtocol.Rdp; rdpbcgrAdapter.ConnectToServer(testConfig.transportProtocol); testConfig.requestProtocol = requestedProtocols_Values.PROTOCOL_RDP_FLAG; rdpbcgrAdapter.SendClientX224ConnectionRequest(NegativeType.None, testConfig.requestProtocol); this.Site.Log.Add(LogEntryKind.Comment, "Expecting SUT to send a Server X224 Connection Confirm with RDP Negotiation Response."); confirmPdu = rdpbcgrAdapter.ExpectPacket <Server_X_224_Connection_Confirm_Pdu>(testConfig.timeout); this.Site.Assert.IsNotNull(confirmPdu, "RDP Server MUST response a Server X224 Connection Confirm PDP after receiving a Client X224 Connection Request PDU."); } else { Site.Assert.Fail("Received a Server X.224 Connection Confirm PDU with RDP Negotiation Failure, whose failureCode field is {0}.", negotiateFailurePdu.rdpNegFailure.failureCode); } } #endregion Test Code }
private bool EstablishRDPConnection( Configs config, requestedProtocols_Values requestedProtocols, string[] SVCNames, CompressionType highestCompressionTypeSupported, bool isReconnect = false, bool autoLogon = false, bool supportEGFX = false, bool supportAutoDetect = false, bool supportHeartbeatPDU = false, bool supportMultitransportReliable = false, bool supportMultitransportLossy = false, bool supportAutoReconnect = false, bool supportFastPathInput = false, bool supportFastPathOutput = false, bool supportSurfaceCommands = false, bool supportSVCCompression = false, bool supportRemoteFXCodec = false) { // Connection Initiation SendClientX224ConnectionRequest(requestedProtocols); Server_X_224_Connection_Confirm_Pdu connectionConfirmPdu = ExpectPacket <Server_X_224_Connection_Confirm_Pdu>(new TimeSpan(0, 0, 60)); if (connectionConfirmPdu == null) { TimeSpan waitTime = new TimeSpan(0, 0, 1); Server_X_224_Negotiate_Failure_Pdu failurePdu = ExpectPacket <Server_X_224_Negotiate_Failure_Pdu>(waitTime); if (failurePdu != null) { DetectorUtil.WriteLog("Received a Server X224 Connection confirm with RDP_NEG_FAILURE structure."); } DetectorUtil.WriteLog("Expecting a Server X224 Connection Confirm PDU."); return(false); } // Basic Settings Exchange SendClientMCSConnectInitialPDU( SVCNames, supportEGFX, supportAutoDetect, supportHeartbeatPDU, supportMultitransportReliable, supportMultitransportLossy, false); connectResponsePdu = ExpectPacket <Server_MCS_Connect_Response_Pdu_with_GCC_Conference_Create_Response>(timeout); if (connectResponsePdu == null) { return(false); } bool serverSupportUDPFECR = false; bool serverSupportUDPFECL = false; if (connectResponsePdu.mcsCrsp.gccPdu.serverMultitransportChannelData != null) { if (connectResponsePdu.mcsCrsp.gccPdu.serverMultitransportChannelData.flags.HasFlag(MULTITRANSPORT_TYPE_FLAGS.TRANSPORTTYPE_UDPFECR)) { serverSupportUDPFECR = true; } if (connectResponsePdu.mcsCrsp.gccPdu.serverMultitransportChannelData.flags.HasFlag(MULTITRANSPORT_TYPE_FLAGS.TRANSPORTTYPE_UDPFECL)) { serverSupportUDPFECL = true; } } detectInfo.IsSupportRDPEMT = serverSupportUDPFECR || serverSupportUDPFECL; // Channel Connection SendClientMCSErectDomainRequest(); SendClientMCSAttachUserRequest(); Server_MCS_Attach_User_Confirm_Pdu userConfirmPdu = ExpectPacket <Server_MCS_Attach_User_Confirm_Pdu>(timeout); if (userConfirmPdu == null) { return(false); } ChannelJoinRequestAndConfirm(); // RDP Security Commencement if (rdpbcgrClient.Context.ServerSelectedProtocol == (uint)selectedProtocols_Values.PROTOCOL_RDP_FLAG) { SendClientSecurityExchangePDU(); } // Secure Settings Exchange SendClientInfoPDU(config, highestCompressionTypeSupported, isReconnect, autoLogon); rdpeleClient = new RdpeleClient(rdpbcgrClient); try { detectInfo.IsSupportRDPELE = ProcessLicenseSequence(config, timeout); } catch { detectInfo.IsSupportRDPELE = false; } rdpeleClient.Dispose(); // Capabilities Exchange Server_Demand_Active_Pdu demandActivePdu = ExpectPacket <Server_Demand_Active_Pdu>(timeout); if (demandActivePdu == null) { return(false); } SendClientConfirmActivePDU( supportAutoReconnect, supportFastPathInput, supportFastPathOutput, supportSVCCompression); // Connection Finalization SendClientSynchronizePDU(); Server_Synchronize_Pdu syncPdu = ExpectPacket <Server_Synchronize_Pdu>(timeout); if (syncPdu == null) { return(false); } Server_Control_Pdu_Cooperate CoopControlPdu = ExpectPacket <Server_Control_Pdu_Cooperate>(timeout); if (CoopControlPdu == null) { return(false); } SendClientControlCooperatePDU(); SendClientControlRequestPDU(); Server_Control_Pdu_Granted_Control grantedControlPdu = ExpectPacket <Server_Control_Pdu_Granted_Control>(timeout); if (grantedControlPdu == null) { return(false); } SendClientFontListPDU(); Server_Font_Map_Pdu fontMapPdu = ExpectPacket <Server_Font_Map_Pdu>(timeout); if (fontMapPdu == null) { return(false); } return(true); }
/// <summary> /// Establish a RDP connection with RDP Server /// </summary> /// <param name="requestedProtocols">Flags indicate supported security protocols</param> /// <param name="SVCNames">Array of static virtual channels' name</param> /// <param name="highestCompressionTypeSupported">Indicate the highest compression type supported</param> /// <param name="isReconnect">Whether this is in a reconnection sequence</param> /// /// <param name="autoLogon">Whether auto logon using username and password in client info PDU</param> /// <param name="supportEGFX">Set the support of RDPEGFX</param> /// <param name="supportAutoDetect">Set the support of auto-detect</param> /// <param name="supportHeartbeatPDU">Set the support of Heartbeat PDU</param> /// <param name="supportMultitransportReliable">Set the support of reliable multitransport</param> /// <param name="supportMultitransportLossy">Set the support of lossy multitransport</param> /// <param name="supportAutoReconnect">Set the support of auto-reconnect</param> /// <param name="supportFastPathInput">Set the support of fast-path input</param> /// <param name="supportFastPathOutput">Set the support of fast-path output</param> /// <param name="supportSurfaceCommands">Set the support of surface commands</param> /// <param name="supportSVCCompression">Set the support of static virtual channel data compression</param> /// <param name="supportRemoteFXCodec">Set the support of RemoteFX codecs</param> public void EstablishRDPConnection(requestedProtocols_Values requestedProtocols, string[] SVCNames, CompressionType highestCompressionTypeSupported, bool isReconnect = false, bool autoLogon = false, bool supportEGFX = false, bool supportAutoDetect = false, bool supportHeartbeatPDU = false, bool supportMultitransportReliable = false, bool supportMultitransportLossy = false, bool supportAutoReconnect = false, bool supportFastPathInput = false, bool supportFastPathOutput = false, bool supportSurfaceCommands = false, bool supportSVCCompression = false, bool supportRemoteFXCodec = false) { #region logging string requestProtocolString = "PROTOCOL_RDP_FLAG"; if (requestedProtocols.HasFlag(requestedProtocols_Values.PROTOCOL_SSL_FLAG)) { requestProtocolString = requestProtocolString + "|PROTOCOL_SSL_FLAG"; } if (requestedProtocols.HasFlag(requestedProtocols_Values.PROTOCOL_HYBRID_FLAG)) { requestProtocolString = requestProtocolString + "|PROTOCOL_HYBRID_FLAG"; } if (requestedProtocols.HasFlag(requestedProtocols_Values.PROTOCOL_HYBRID_EX)) { requestProtocolString = requestProtocolString + "|PROTOCOL_HYBRID_EX"; } string svcNameString = ""; if (SVCNames != null && SVCNames.Length > 0) { foreach (string svcName in SVCNames) { svcNameString = svcNameString + svcName + ","; } } this.Site.Log.Add(LogEntryKind.Comment, @"EstablishRDPConnection: request Protocols = {0}, Name of static virtual channels = {1}, Highest compression type supported = {2}, Is Reconnect = {3} RDPEGFX supported = {4}, AutoDetect supported = {5}, HeartbeatPDU supported = {6}, Reliable Multitransport supported = {7}, Lossy Multitransport supported = {8}, AutoReconnect supported = {9}, FastPathInput supported= {10}, FastPathOutput supported = {11}, SurfaceCommands supported = {12}, SVCCompression supported = {13}, RemoteFXCodec supported = {14}.", requestProtocolString, svcNameString, highestCompressionTypeSupported.ToString(), isReconnect, supportEGFX, supportAutoDetect, supportHeartbeatPDU, supportMultitransportReliable, supportMultitransportLossy, supportAutoReconnect, supportFastPathInput, supportFastPathOutput, supportSurfaceCommands, supportSVCCompression, supportRemoteFXCodec); #endregion logging #region Connection Initiation SendClientX224ConnectionRequest(NegativeType.None, requestedProtocols); Server_X_224_Connection_Confirm_Pdu connectionConfirmPdu = ExpectPacket <Server_X_224_Connection_Confirm_Pdu>(pduWaitTimeSpan); if (connectionConfirmPdu == null) { TimeSpan waitTime = new TimeSpan(0, 0, 1); Server_X_224_Negotiate_Failure_Pdu failurePdu = ExpectPacket <Server_X_224_Negotiate_Failure_Pdu>(waitTime); if (failurePdu != null) { Site.Assert.Fail("Received a Server X224 Connection confirm with RDP_NEG_FAILURE structure, failureCode is {0}.", failurePdu.rdpNegFailure.failureCode); } Site.Assert.Fail("Expecting a Server X224 Connection Confirm PDU."); } if (supportEGFX) { // Verify support of EGFX on Server Site.Assert.IsTrue(connectionConfirmPdu.rdpNegData != null && connectionConfirmPdu.rdpNegData.flags.HasFlag(RDP_NEG_RSP_flags_Values.DYNVC_GFX_PROTOCOL_SUPPORTED), "The RDP Server should support RDPEGFX."); } #endregion Connection Initiation #region Basic Setting Exchange SendClientMCSConnectInitialPDU(NegativeType.None, SVCNames, supportEGFX, supportAutoDetect, supportHeartbeatPDU, supportMultitransportReliable, supportMultitransportLossy, false); Server_MCS_Connect_Response_Pdu_with_GCC_Conference_Create_Response connectResponsePdu = ExpectPacket <Server_MCS_Connect_Response_Pdu_with_GCC_Conference_Create_Response>(pduWaitTimeSpan); Site.Assert.IsNotNull(connectResponsePdu, "Expecting a Server MCS Connect Response PDU with GCC Conference Create Response."); if (connectResponsePdu.mcsCrsp.gccPdu.serverMultitransportChannelData != null) { if (connectResponsePdu.mcsCrsp.gccPdu.serverMultitransportChannelData.flags.HasFlag(MULTITRANSPORT_TYPE_FLAGS.TRANSPORTTYPE_UDPFECR)) { this.serverSupportUDPFECR = true; } if (connectResponsePdu.mcsCrsp.gccPdu.serverMultitransportChannelData.flags.HasFlag(MULTITRANSPORT_TYPE_FLAGS.TRANSPORTTYPE_UDPFECL)) { this.serverSupportUDPFECL = true; } if (connectResponsePdu.mcsCrsp.gccPdu.serverMultitransportChannelData.flags.HasFlag(MULTITRANSPORT_TYPE_FLAGS.TRANSPORTTYPE_UDP_PREFERRED)) { this.serverSupportUDPPrefferred = true; } } #endregion Basic Setting Exchange #region Channel Connection SendClientMCSErectDomainRequest(NegativeType.None); SendClientMCSAttachUserRequest(NegativeType.None); Server_MCS_Attach_User_Confirm_Pdu userConfirmPdu = ExpectPacket <Server_MCS_Attach_User_Confirm_Pdu>(pduWaitTimeSpan); Site.Assert.IsNotNull(userConfirmPdu, "Expecting a Server MCS Attach User Confirm PDU."); ChannelJoinRequestAndConfirm(); #endregion #region RDP Security Commencement if (rdpbcgrClientStack.Context.ServerSelectedProtocol == (uint)selectedProtocols_Values.PROTOCOL_RDP_FLAG) { SendClientSecurityExchangePDU(NegativeType.None); } #endregion #region Secure Setting Exchange SendClientInfoPDU(NegativeType.None, highestCompressionTypeSupported, isReconnect, autoLogon); #endregion #region Licensing Server_License_Error_Pdu_Valid_Client licenseErrorPdu = ExpectPacket <Server_License_Error_Pdu_Valid_Client>(pduWaitTimeSpan); Site.Assert.IsNotNull(licenseErrorPdu, "Expecting a Server License Error PDU."); #endregion #region Capabilities Exchange Server_Demand_Active_Pdu demandActivePdu = ExpectPacket <Server_Demand_Active_Pdu>(pduWaitTimeSpan); Site.Assert.IsNotNull(demandActivePdu, "Expecting a Server Demand Active PDU."); SendClientConfirmActivePDU(NegativeType.None, supportAutoReconnect, supportFastPathInput, supportFastPathOutput, supportSurfaceCommands, supportSVCCompression, supportRemoteFXCodec); #endregion #region Connection Finalization SendClientSynchronizePDU(); Server_Synchronize_Pdu syncPdu = ExpectPacket <Server_Synchronize_Pdu>(pduWaitTimeSpan); Site.Assert.IsNotNull(syncPdu, "Expecting a Server Synchronize PDU."); Server_Control_Pdu_Cooperate CoopControlPdu = ExpectPacket <Server_Control_Pdu_Cooperate>(pduWaitTimeSpan); Site.Assert.IsNotNull(CoopControlPdu, "Expecting a Server Control PDU - Cooperate."); SendClientControlCooperatePDU(); SendClientControlRequestPDU(); Server_Control_Pdu_Granted_Control grantedControlPdu = ExpectPacket <Server_Control_Pdu_Granted_Control>(pduWaitTimeSpan); Site.Assert.IsNotNull(grantedControlPdu, "Expecting a Server Control PDU - Granted Control."); if (IsBitmapCacheHostSupport) { SendClientPersistentKeyListPDU(); } SendClientFontListPDU(); Server_Font_Map_Pdu fontMapPdu = ExpectPacket <Server_Font_Map_Pdu>(pduWaitTimeSpan); Site.Assert.IsNotNull(fontMapPdu, "Expecting a Server Font Map PDU."); #endregion }