एएस 3

Question

का उपयोग कर आरडीपी में लॉगिन करने का प्रयास कर रहा हूं मैं एएस 3 (वायु) का उपयोग कर आरडीपी में लॉगिन करने की कोशिश कर रहा हूं। मैं वास्तविक प्रक्रिया को समझने के लिए संसाधनों की कमी पर विचार कर ठीक कर रहा हूं।

मुझे प्रारंभिक प्रेषण उपयोगकर्ता नाम से पहले मिल गया है, सर्वर से प्रतिक्रिया प्राप्त हुई है, और अब मैं प्रारंभिक अनुरोध कनेक्शन पर हूं।

मैं अपना पूरा डेटा भेज रहा हूं और यातायात को सूँघते समय, मुझे लगता है कि नेटमोन सही ढंग से पहचान रहा है कि मैं किस प्रकार का पैकेट भेज रहा हूं (टी 125)। मैं नहीं आरडीपी द्वारा डिस्कनेक्ट किया जा रहा है और वे ack पैकेट भेजते हैं - लेकिन मुझे वह प्रतिक्रिया प्राप्त नहीं होती है जिसकी मुझे उम्मीद है।

मैं connectoid के साथ संदर्भ संदर्भ रहा हूं, जो एक ओपन सोर्स आरडीपी क्लाइंट है। कनेक्शन कोड में, मैं अटक गया हूं जहां वे छोटे और बड़े-एंडियन पूर्णांक का मिश्रण लिखते हैं।

जब मैं वहाँ बाहर सीमित उदाहरणों पर गौर (अधिक पैकेट उदासीनता की तरह), मुझे लगता है कि इस प्रक्रिया के लिए कनेक्शन की लंबाई 412 है, लेकिन मेरे bytearray अधिक की तरह 470.

मैं करने के लिए connectoid तरीकों परिवर्तित कर दिया है क्या मेरा मानना ​​है कि सही है, लेकिन एंडियन प्रकार के मिश्रण के साथ, मैं अभी भी अनिश्चित हूं।

मुझे खेद है कि यह खराब है, लेकिन मैं आपकी मदद करने में आपकी सहायता करने के लिए अपनी पूरी कोशिश कर रहा हूं। मैं कुछ कोड संलग्न करूंगा जो दिखा रहा हूं कि मैंने रूपांतरण में क्या करने की कोशिश की है।

public function sendMcsData(): void { 
    trace("Secure.sendMcsData"); 
    var num_channels: int = 2; 
    //RdpPacket_Localised dataBuffer = new RdpPacket_Localised(512); 
    var hostlen: int = 2 * "myhostaddress.ath.cx".length; 
    if (hostlen > 30) { 
     hostlen = 30; 
    } 
    var length: int = 158; 
    length += 76 + 12 + 4; 
    length += num_channels * 12 + 8; 
    dataBuffer.writeShort(5); /* unknown */ 
    dataBuffer.writeShort(0x14); 
    dataBuffer.writeByte(0x7c); //set 8 is write byte //write short is setbigendian 16 // 
    dataBuffer.writeShort(1); 
    dataBuffer.writeShort(length | 0x8000); // remaining length 
    dataBuffer.writeShort(8); // length? 
    dataBuffer.writeShort(16); 
    dataBuffer.writeByte(0); 
    var b1: ByteArray = new ByteArray(); 
    b1.endian = Endian.LITTLE_ENDIAN; 
    b1.writeShort(0xc001); 
    dataBuffer.writeBytes(b1); 
    dataBuffer.writeByte(0); 
    var b2: ByteArray = new ByteArray(); 
    b2.endian = Endian.LITTLE_ENDIAN; 
    b2.writeInt(0x61637544); 
    dataBuffer.writeBytes(b2); 
    //dataBuffer.setLittleEndian32(0x61637544); // "Duca" ?! 
    dataBuffer.writeShort(length - 14 | 0x8000); // remaining length 
    var b3: ByteArray = new ByteArray(); 
    b3.endian = Endian.LITTLE_ENDIAN; 
    // Client information 
    b3.writeShort(SEC_TAG_CLI_INFO); 
    b3.writeShort(true ? 212 : 136); // length 
    b3.writeShort(true ? 4 : 1); 
    b3.writeShort(8); 
    b3.writeShort(600); 
    b3.writeShort(1024); 
    b3.writeShort(0xca01); 
    b3.writeShort(0xaa03); 
    b3.writeInt(0x809); //should be option.keybaortd layout just guessed 1 
    b3.writeInt(true ? 2600 : 419); // or 0ece 
    dataBuffer.writeBytes(b3); 
    // // client 
    // build? we 
    // are 2600 
    // compatible 
    // :-) 
    /* Unicode name of client, padded to 32 bytes */ 
    dataBuffer.writeMultiByte("myhost.ath.cx".toLocaleUpperCase(), "ISO"); 
    dataBuffer.position = dataBuffer.position + (30 - "myhost.ath.cx".toLocaleUpperCase() 
     .length); 
    var b4: ByteArray = new ByteArray(); 
    b4.endian = Endian.LITTLE_ENDIAN; 
    b4.writeInt(4); 
    b4.writeInt(0); 
    b4.writeInt(12); 
    dataBuffer.writeBytes(b4); 
    dataBuffer.position = dataBuffer.position + 64; /* reserved? 4 + 12 doublewords */ 
    var b5: ByteArray = new ByteArray(); 
    b5.endian = Endian.LITTLE_ENDIAN; 
    b5.writeShort(0xca01); // out_uint16_le(s, 0xca01); 
    b5.writeShort(true ? 1 : 0); 
    if (true) //Options.use_rdp5) 
    { 
     b5.writeInt(0); // out_uint32(s, 0); 
     b5.writeByte(24); // out_uint8(s, g_server_bpp); 
     b5.writeShort(0x0700); // out_uint16_le(s, 0x0700); 
     b5.writeByte(0); // out_uint8(s, 0); 
     b5.writeInt(1); // out_uint32_le(s, 1); 
     b5.position = b5.position + 64; 
     b5.writeShort(SEC_TAG_CLI_4); // out_uint16_le(s, 
     // SEC_TAG_CLI_4); 
     b5.writeShort(12); // out_uint16_le(s, 12); 
     b5.writeInt(false ? 0xb : 0xd); // out_uint32_le(s, 
     // g_console_session 
     // ? 
     // 0xb 
     // : 
     // 9); 
     b5.writeInt(0); // out_uint32(s, 0); 
    } 
    // Client encryption settings // 
    b5.writeShort(SEC_TAG_CLI_CRYPT); 
    b5.writeShort(true ? 12 : 8); // length 
    // if(Options.use_rdp5) dataBuffer.setLittleEndian32(Options.encryption ? 
    // 0x1b : 0); // 128-bit encryption supported 
    // else 
    b5.writeInt(true ? (false ? 0xb : 0x3) : 0); 
    if (true) b5.writeInt(0); // unknown 
    if (true && (num_channels > 0)) { 
     trace(("num_channels is " + num_channels)); 
     b5.writeShort(SEC_TAG_CLI_CHANNELS); // out_uint16_le(s, 
     // SEC_TAG_CLI_CHANNELS); 
     b5.writeShort(num_channels * 12 + 8); // out_uint16_le(s, 
     // g_num_channels 
     // * 12 
     // + 8); 
     // // 
     // length 
     b5.writeInt(num_channels); // out_uint32_le(s, 
     // g_num_channels); 
     // // number of 
     // virtual 
     // channels 
     dataBuffer.writeBytes(b5); 
     trace("b5 is bigendin" + (b5.endian == Endian.BIG_ENDIAN)); 
     for (var i: int = 0; i < num_channels; i++) { 
      dataBuffer.writeMultiByte("testtes" + i, "ascii"); //, 8); // out_uint8a(s, 
      // g_channels[i].name, 
      // 8); 
      dataBuffer.writeInt(0x40000000); // out_uint32_be(s, 
      // g_channels[i].flags); 
     } 
    } 
    //socket. 
    //buffer.markEnd(); 
    //return buffer; 
} 

Answer 1

जाहिर बफर के बहुमत थोड़ा endian है, लेकिन इसके शुरू में कई बाइट्स 16 बिट (छोटी) के बड़े endian संख्या होने की उम्मीद है। इसका मतलब है, आपको थोड़ा एंडियन में डेटा लिखना है जैसे कि इसे बड़े एंडियन के रूप में व्याख्या किया जाएगा। बड़े एंडियन से छोटे एंडियन तक डेटा को कन्वर्ट करने के लिए, आप एक अस्थायी ByteArray का उपयोग कर सकते हैं जिसमें इसका एंडियन सेट बड़ा हो, इसमें डेटा लिखें, फिर अपने मुख्य बफर सरणी पर writeBytes() पर कॉल करें, फिर अस्थायी बड़े एंडियन सरणी को साफ़ करें। लेखन स्थिरांक मैन्युअल रूप से किया जा सकता है, क्योंकि आप बाइट ऑर्डर को स्वयं स्थानांतरित कर सकते हैं, कहें कि जब आप छोटे एंडियन में 0x0005 लिख रहे हैं, तो आप केवल 0x0500 को छोटे एंडियन के रूप में लिखते हैं। आपने प्रतीत होता है कि एंड्रियन dataBuffer के साथ कोड को एंडियन के साथ बड़ा लिखा गया है, इसलिए आप इस तकनीक को जानते हैं। फिर भी, यह बेहतर है कि आप फ़ंक्शन में उचित dataBuffer तैयार करेंगे। मैं आपके द्वारा डाउनलोड किए गए connectoid कोड पर आधारित नीचे दिए गए कोड को ठीक करने का प्रयास कर रहा हूं, ताकि यह ठीक से बने ByteArray को एंडियन के साथ वापस कर देगा - यह केवल तभी महत्वपूर्ण होगा जब आप इसके द्वारा ऑर्डर किए गए डेटा को पढ़ लेंगे, न कि जब आप बाइट्स पढ़ते हैं ।

public function sendMcsData(): ByteArray { 
    trace("Secure.sendMcsData"); 
    var num_channels: int = 2; 
    var dataBuffer:ByteArray=new ByteArray(); //RdpPacket_Localised dataBuffer = new RdpPacket_Localised(512); 
    // it's better to build the data buffer in the function, as in java, otherwise you can receive interference 
    dataBuffer.endian=Endian.LITTLE_ENDIAN; // for clarity 
    var hostlen: int = 2 * "myhost.ath.cx".length; // hardcoded? TODO FIX 
    if (hostlen > 30) { 
     hostlen = 30; 
    } 
    var length: int = 158; 
    length += 76 + 12 + 4; // Options.use_rdp5 is true, apparently 
    length += num_channels * 12 + 8; 
    dataBuffer.writeShort(0x0500); // writing big-endian 0x5 *unknown* 
    dataBuffer.writeShort(0x1400); // writing big-endian 0x14 
    dataBuffer.writeByte(0x7c); //set 8 is write byte 
    //write short is setbigendian 16 // 
    dataBuffer.writeShort(0x0100); // writing big-endian 0x01 
    var be:ByteArray=new ByteArray(); 
    be.endian=Endian.BIG_ENDIAN; // create big-endian array for the data that's not static 
    be.writeShort(length | 0x8000); // remaining length 
    dataBuffer.writeBytes(be); 
    be.clear(); // so that extra writing will not spoil the array 
    dataBuffer.writeShort(0x0800); // writing big-endian 0x08 (length?) 
    dataBuffer.writeShort(0x1000); // writing big-endian 16 (0x10) 
    dataBuffer.writeByte(0); 
    dataBuffer.writeShort(0xc001); // this one is little endian by default 
    dataBuffer.writeByte(0); 
    dataBuffer.writeUnsignedInt(0x61637544); 
    //dataBuffer.setLittleEndian32(0x61637544); // "Duca" ?! 
    be.writeShort((length - 14) | 0x8000); // remaining length 
    dataBuffer.writeBytes(be); 
    be.clear(); 
    dataBuffer.writeShort(SEC_TAG_CLI_INFO); 
    dataBuffer.writeShort(212); // length 
    dataBuffer.writeShort(4); 
    dataBuffer.writeShort(8); 
    dataBuffer.writeShort(600); // Options.width 
    dataBuffer.writeShort(1024); // Options.height 
    dataBuffer.writeShort(0xca01); 
    dataBuffer.writeShort(0xaa03); 
    dataBuffer.writeInt(0x0409); //Options.keylayout, default English/US - fixed 
    dataBuffer.writeInt(2600); // or 0ece 
    dataBuffer.writeBytes(b3); 
    // // client 
    // build? we 
    // are 2600 
    // compatible 
    // :-) 
    /* Unicode name of client, padded to 32 bytes */ 
    var targetPos:int=dataBuffer.position+32; // to account for padding 
    dataBuffer.writeMultiByte("myhost.ath.cx".toLocaleUpperCase(), "UTF-16"); 
    // buffer.outUnicodeString(Options.hostname.toUpperCase(), hostlen); 
    // apparently encoding is used "Unicode" that is UTF-16. If that will not work, set UTF-8 here 
    // and by all means check what is on the wire when you connect via conventional RDP 

    dataBuffer.position = targetPos; 
    // this seems to be your mistake in converting position truncate, 
    // as position after writing already accounts for the writing been processed. 
    // This line alone can be the source of size discrepancy you observe. 
    dataBuffer.writeInt(4); 
    dataBuffer.writeInt(0); 
    dataBuffer.writeInt(12); 
    dataBuffer.position = dataBuffer.position + 64; // /* reserved? 4 + 12 doublewords */ 
    // note, if the position wouldn't shift forward, write zeroes manually 
    dataBuffer.writeShort(0xca01); // out_uint16_le(s, 0xca01); 
    dataBuffer.writeShort(1); 
    if (true) //Options.use_rdp5) 
    { 
     dataBuffer.writeInt(0); // out_uint32(s, 0); 
     dataBuffer.writeByte(24); // out_uint8(s, g_server_bpp); 
     dataBuffer.writeShort(0x0700); // out_uint16_le(s, 0x0700); 
     dataBuffer.writeByte(0); // out_uint8(s, 0); 
     dataBuffer.writeInt(1); // out_uint32_le(s, 1); 
     dataBuffer.position = dataBuffer.position + 64; 
     dataBuffer.writeShort(SEC_TAG_CLI_4); // out_uint16_le(s, 
     // SEC_TAG_CLI_4); 
     dataBuffer.writeShort(12); // out_uint16_le(s, 12); 
     dataBuffer.writeInt(0xd); // out_uint32_le(s, 
     // g_console_session 
     // ? 
     // 0xb 
     // : 
     // 9); 
     // the comments say 9, but the code says 0xd - leaving 0xd in place 
     // Options.console_session is hardcoded false 
     dataBuffer.writeInt(0); // out_uint32(s, 0); 
    } 
    // Client encryption settings // 
    dataBuffer.writeShort(SEC_TAG_CLI_CRYPT); 
    dataBuffer.writeShort(12); // length 
    // if(Options.use_rdp5) dataBuffer.setLittleEndian32(Options.encryption ? 
    // 0x1b : 0); // 128-bit encryption supported 
    // else 
    dataBuffer.writeInt(true ? (false ? 0xb : 0x3) : 0); 
    dataBuffer.writeInt(0); // unknown 
    if (true && (num_channels > 0)) { 
     trace(("num_channels is", num_channels)); 
     dataBuffer.writeShort(SEC_TAG_CLI_CHANNELS); // out_uint16_le(s, 
     // SEC_TAG_CLI_CHANNELS); 
     dataBuffer.writeShort(num_channels * 12 + 8); // out_uint16_le(s, 
     // g_num_channels 
     // * 12 
     // + 8); 
     // // 
     // length 
     dataBuffer.writeInt(num_channels); // out_uint32_le(s, 
     // g_num_channels); 
     // // number of 
     // virtual 
     // channels 
     for (var i: int = 0; i < num_channels; i++) { 
      targetPos=dataBuffer.position+8; // account for padding/truncation 
      dataBuffer.writeMultiByte("testtes" + i, "ascii"); //, 8); // out_uint8a(s, 
      // g_channels[i].name, 
      // 8); 
      dataBuffer.position=targetPos; 
      dataBuffer.writeInt(0x00000040); // out_uint32_be(s, 
      // g_channels[i].flags); 
      // writing big-endian 0x40000000 
     } 
    } 
    trace("sendMCSData: Data buffer length is",dataBuffer.length); // debug 
    return dataBuffer; 
} 

उम्मीद है कि इससे मदद मिलती है।