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.");
}
