private void SendClientX224ConnectionRequest( requestedProtocols_Values requestedProtocols, bool isRdpNegReqPresent = true, bool isRoutingTokenPresent = false, bool isCookiePresent = false, bool isRdpCorrelationInfoPresent = false) { Client_X_224_Connection_Request_Pdu x224ConnectReqPdu = rdpbcgrClient.CreateX224ConnectionRequestPdu(requestedProtocols); if (isRoutingTokenPresent) { // Present the routingToken x224ConnectReqPdu.routingToken = ASCIIEncoding.ASCII.GetBytes(RdpbcgrTestData.DefaultX224ConnectReqRoutingToken); x224ConnectReqPdu.tpktHeader.length += (ushort)x224ConnectReqPdu.routingToken.Length; x224ConnectReqPdu.x224Crq.lengthIndicator += (byte)x224ConnectReqPdu.routingToken.Length; } if (isCookiePresent) { // Present the cookie x224ConnectReqPdu.cookie = RdpbcgrTestData.DefaultX224ConnectReqCookie; x224ConnectReqPdu.tpktHeader.length += (ushort)x224ConnectReqPdu.cookie.Length; x224ConnectReqPdu.x224Crq.lengthIndicator += (byte)x224ConnectReqPdu.cookie.Length; } if (!isRdpNegReqPresent) { // RdpNegReq is already present, remove it if isRdpNegReqPresent is false x224ConnectReqPdu.rdpNegData = null; int rdpNegDataSize = sizeof(byte) + sizeof(byte) + sizeof(ushort) + sizeof(uint); x224ConnectReqPdu.tpktHeader.length -= (ushort)rdpNegDataSize; x224ConnectReqPdu.x224Crq.lengthIndicator -= (byte)rdpNegDataSize; } if (isRdpCorrelationInfoPresent) { // Present the RdpCorrelationInfo x224ConnectReqPdu.rdpCorrelationInfo = new RDP_NEG_CORRELATION_INFO(); x224ConnectReqPdu.rdpCorrelationInfo.type = RDP_NEG_CORRELATION_INFO_Type.TYPE_RDP_CORRELATION_INFO; x224ConnectReqPdu.rdpCorrelationInfo.flags = 0; x224ConnectReqPdu.rdpCorrelationInfo.length = 36; x224ConnectReqPdu.rdpCorrelationInfo.correlationId = RdpbcgrTestData.GetDefaultX224ConnectReqCorrelationId(); x224ConnectReqPdu.rdpCorrelationInfo.reserved = new byte[16]; x224ConnectReqPdu.tpktHeader.length += (ushort)x224ConnectReqPdu.rdpCorrelationInfo.length; x224ConnectReqPdu.x224Crq.lengthIndicator += (byte)x224ConnectReqPdu.rdpCorrelationInfo.length; } rdpbcgrClient.SendPdu(x224ConnectReqPdu); }
/// <summary> /// Return a reasonable failureCode according to the receving Client_X_224_Connection_Request_Pdu. /// </summary> /// <param name="pdu">the Client_X_224_Connection_Request_Pdu</param> /// <returns></returns> private failureCode_Values GetFailureCode_RDP_NEG_FAILURE(Client_X_224_Connection_Request_Pdu pdu) { failureCode_Values result = failureCode_Values.NO_FAILURE; if (pdu == null) { return(result); } bool has_PROTOCOL_RDP_FLAG = pdu.rdpNegData.requestedProtocols.HasFlag(requestedProtocols_Values.PROTOCOL_RDP_FLAG); bool has_PROTOCOL_SSL_FLAG = pdu.rdpNegData.requestedProtocols.HasFlag(requestedProtocols_Values.PROTOCOL_RDP_FLAG); bool has_PROTOCOL_HYBRID_FLAG = pdu.rdpNegData.requestedProtocols.HasFlag(requestedProtocols_Values.PROTOCOL_HYBRID_FLAG); bool has_PROTOCOL_HYBRID_EX = pdu.rdpNegData.requestedProtocols.HasFlag(requestedProtocols_Values.PROTOCOL_HYBRID_EX); if (!has_PROTOCOL_HYBRID_EX && !has_PROTOCOL_HYBRID_FLAG && has_PROTOCOL_SSL_FLAG) { // 0000 | 0001 result = failureCode_Values.SSL_REQUIRED_BY_SERVER; } else if (!has_PROTOCOL_HYBRID_EX && !has_PROTOCOL_HYBRID_FLAG) { // 0010 | 0011 result = failureCode_Values.HYBRID_REQUIRED_BY_SERVER; } else if (!has_PROTOCOL_SSL_FLAG) { // 1000 | 0100 | 1101 | 1100 | 1001 | 0101 | 1100 result = failureCode_Values.SSL_WITH_USER_AUTH_REQUIRED_BY_SERVER; } else if (!has_PROTOCOL_RDP_FLAG) { // 1010 | 0110 | 1110 result = failureCode_Values.SSL_CERT_NOT_ON_SERVER; } else { // 1011 | 0111 | 1111 result = failureCode_Values.INCONSISTENT_FLAGS; } return(result); }
/// <summary> /// Establish RDP Connection /// </summary> private void EstablishRDPConnection() { sessionContext = rdpbcgrServerStack.ExpectConnect(timeout); #region Connection Initial x224ConnectionRequest = ExpectPacket <Client_X_224_Connection_Request_Pdu>(sessionContext, timeout); Server_X_224_Connection_Confirm_Pdu confirmPdu = rdpbcgrServerStack.CreateX224ConnectionConfirmPdu(sessionContext, selectedProtocols_Values.PROTOCOL_RDP_FLAG, RDP_NEG_RSP_flags_Values.DYNVC_GFX_PROTOCOL_SUPPORTED | RDP_NEG_RSP_flags_Values.EXTENDED_CLIENT_DATA_SUPPORTED); SendPdu(confirmPdu); if (bool.Parse(detectInfo.IsWindowsImplementation)) { RdpbcgrServerSessionContext orgSession = sessionContext; sessionContext = rdpbcgrServerStack.ExpectConnect(timeout); if (sessionContext.Identity == orgSession.Identity) { sessionContext = rdpbcgrServerStack.ExpectConnect(timeout); } x224ConnectionRequest = ExpectPacket <Client_X_224_Connection_Request_Pdu>(sessionContext, timeout); confirmPdu = rdpbcgrServerStack.CreateX224ConnectionConfirmPdu(sessionContext, selectedProtocols_Values.PROTOCOL_RDP_FLAG, RDP_NEG_RSP_flags_Values.DYNVC_GFX_PROTOCOL_SUPPORTED | RDP_NEG_RSP_flags_Values.EXTENDED_CLIENT_DATA_SUPPORTED); SendPdu(confirmPdu); } #endregion Connection Initial #region Basic Setting Exchange mscConnectionInitialPDU = ExpectPacket <Client_MCS_Connect_Initial_Pdu_with_GCC_Conference_Create_Request>(sessionContext, timeout); SERVER_CERTIFICATE cert = null; int certLen = 0; int dwKeysize = 2048; byte[] privateExp, publicExp, modulus; cert = rdpbcgrServerStack.GenerateCertificate(dwKeysize, out privateExp, out publicExp, out modulus); certLen = 120 + dwKeysize / 8; Server_MCS_Connect_Response_Pdu_with_GCC_Conference_Create_Response connectRespPdu = rdpbcgrServerStack.CreateMCSConnectResponsePduWithGCCConferenceCreateResponsePdu( sessionContext, EncryptionMethods.ENCRYPTION_METHOD_128BIT, EncryptionLevel.ENCRYPTION_LEVEL_LOW, cert, certLen, MULTITRANSPORT_TYPE_FLAGS.TRANSPORTTYPE_UDPFECL | MULTITRANSPORT_TYPE_FLAGS.TRANSPORTTYPE_UDPFECR); SendPdu(connectRespPdu); sessionContext.ServerPrivateExponent = new byte[privateExp.Length]; Array.Copy(privateExp, sessionContext.ServerPrivateExponent, privateExp.Length); #endregion Basic Setting Exchange #region Channel Connection ExpectPacket <Client_MCS_Erect_Domain_Request>(sessionContext, timeout); ExpectPacket <Client_MCS_Attach_User_Request>(sessionContext, timeout); Server_MCS_Attach_User_Confirm_Pdu attachUserConfirmPdu = rdpbcgrServerStack.CreateMCSAttachUserConfirmPdu(sessionContext); SendPdu(attachUserConfirmPdu); //Join Channel int channelNum = 2; if (sessionContext.VirtualChannelIdStore != null) { channelNum += sessionContext.VirtualChannelIdStore.Length; } if (sessionContext.IsServerMessageChannelDataSend) { channelNum++; } for (int i = 0; i < channelNum; i++) { Client_MCS_Channel_Join_Request channelJoinPdu = ExpectPacket <Client_MCS_Channel_Join_Request>(sessionContext, timeout); Server_MCS_Channel_Join_Confirm_Pdu channelJoinResponse = rdpbcgrServerStack.CreateMCSChannelJoinConfirmPdu( sessionContext, channelJoinPdu.mcsChannelId); SendPdu(channelJoinResponse); } #endregion Channel Connection #region RDP Security Commencement securityExchangePDU = ExpectPacket <Client_Security_Exchange_Pdu>(sessionContext, timeout); #endregion RDP Security Commencement #region Secure Setting Exchange clientInfoPDU = ExpectPacket <Client_Info_Pdu>(sessionContext, timeout); #endregion Secure Setting Exchange #region Licensing Server_License_Error_Pdu_Valid_Client licensePdu = rdpbcgrServerStack.CreateLicenseErrorMessage(sessionContext); SendPdu(licensePdu); #endregion Licensing #region Capabilities Exchange RdpbcgrCapSet capSet = new RdpbcgrCapSet(); capSet.GenerateCapabilitySets(); Server_Demand_Active_Pdu demandActivePdu = rdpbcgrServerStack.CreateDemandActivePdu(sessionContext, capSet.CapabilitySets); SendPdu(demandActivePdu); confirmActivePDU = ExpectPacket <Client_Confirm_Active_Pdu>(sessionContext, timeout); clientCapSet = new RdpbcgrCapSet(); clientCapSet.CapabilitySets = confirmActivePDU.confirmActivePduData.capabilitySets; #endregion Capabilities Exchange #region Connection Finalization ExpectPacket <Client_Synchronize_Pdu>(sessionContext, timeout); Server_Synchronize_Pdu synchronizePdu = rdpbcgrServerStack.CreateSynchronizePdu(sessionContext); SendPdu(synchronizePdu); Server_Control_Pdu controlCooperatePdu = rdpbcgrServerStack.CreateControlCooperatePdu(sessionContext); SendPdu(controlCooperatePdu); ExpectPacket <Client_Control_Pdu_Cooperate>(sessionContext, timeout); ExpectPacket <Client_Control_Pdu_Request_Control>(sessionContext, timeout); Server_Control_Pdu controlGrantedPdu = rdpbcgrServerStack.CreateControlGrantedPdu(sessionContext); SendPdu(controlGrantedPdu); ITsCapsSet cap = this.clientCapSet.FindCapSet(capabilitySetType_Values.CAPSTYPE_BITMAPCACHE_REV2); if (cap != null) { TS_BITMAPCACHE_CAPABILITYSET_REV2 bitmapCacheV2 = (TS_BITMAPCACHE_CAPABILITYSET_REV2)cap; if ((bitmapCacheV2.CacheFlags & CacheFlags_Values.PERSISTENT_KEYS_EXPECTED_FLAG) != 0) { ExpectPacket <Client_Persistent_Key_List_Pdu>(sessionContext, timeout); } } ExpectPacket <Client_Font_List_Pdu>(sessionContext, timeout); Server_Font_Map_Pdu fontMapPdu = rdpbcgrServerStack.CreateFontMapPdu(sessionContext); SendPdu(fontMapPdu); #endregion Connection Finalization // Init for RDPEDYC try { rdpedycServer = new RdpedycServer(rdpbcgrServerStack, sessionContext); rdpedycServer.ExchangeCapabilities(timeout); } catch (Exception) { rdpedycServer = null; } }
private void S8_ServerRedirection_PositiveTest_WithRoutingToken_VerifyX224ConnectioRequest(Client_X_224_Connection_Request_Pdu x224Request) { string receivedRoutingToken = string.Empty; if (x224Request.routingToken != null) { receivedRoutingToken = ASCIIEncoding.ASCII.GetString(x224Request.routingToken); } this.TestSite.Assert.AreEqual <string>(RdpbcgrTestData.Test_Redirection_RoutingToken, receivedRoutingToken, "Verify if routingToken is present in X.224 Connection Request PDU and same as that sent in Server Redirection PDU."); }
private void S8_ServerRedirection_PositiveTest_WithoutRoutingToken_VerifyX224ConnectioRequest(Client_X_224_Connection_Request_Pdu x224Request) { this.TestSite.Assert.IsTrue(x224Request.routingToken == null || x224Request.routingToken.Length == 0, "Verify if routingToken is not present in X.224 Connection Request PDU for server redirection."); }
private void CheckNegotiationFlag(Client_X_224_Connection_Request_Pdu x224Request) { this.TestSite.Assert.AreEqual <bool>(true, x224Request.rdpNegData.requestedProtocols.HasFlag(requestedProtocols_Values.PROTOCOL_RDSTLS), @"The request protocol for redirected connection should include the RDSTLS protocol."); }