एक डेलीमीटर

Question

पर एक बाइट सरणी विभाजित करें मुझे कुछ समस्याएं आ रही हैं और, अन्य प्रश्नों ने मुझे बहुत मदद नहीं की है।

मैं एक सुरक्षा छात्र हूं और मैं एक परियोजना के लिए एक क्रिप्टर लिखने की कोशिश कर रहा हूं। उन लोगों के लिए जो नहीं जानते कि यह क्या है आप यहां पढ़ सकते हैं। http://www.gamekiller.net/tutorials-guides/17187-tut-making-crypter-vb6-using-rc4.html

फिर भी, एक त्वरित विवरण, crypters एक कार्यक्रम को एनक्रिप्ट और फिर एक "ठूंठ" जो एक प्रोग्राम है जो यह decrypts, मोर्चे पर है affixing द्वारा antiviruses बायपास करने के लिए होती कार्यक्रम हैं। मुझे अपनी फाइल को विभाजित करने के साथ बहुत परेशान करने वाला मुद्दा है।

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

ठूंठ के मूल विचार है करने के लिए:

• जाओ मौजूदा exe पथ
• File.ReadAllytes
• स्प्लिट सीमांकक पर फ़ाइल, "EVILDELIMITER"
के माध्यम से सभी बाइट्स पढ़ें
• अंतिम फ़ील्ड प्राप्त करें (चूंकि वह क्रिप्टेड EXE)
• आरसी 4
• का उपयोग करके इसे डीक्रिप्ट करें रनपीई का उपयोग करके चलाएं।

मेरे पास विभाजन भाग को छोड़कर सबकुछ काम कर रहा है, जो सबसे कष्टप्रद है। मैं डिलीमीटर पर एक बाइट सरणी कैसे विभाजित करूं? क्या इसे करने का कोई आसान रास्ता है?

यहां तक ​​कि अब तक के स्टब के लिए कोड है।

public void main() 
{ 
    string outpath = RandomString(8) + ".exe"; 
    byte[] key = { 33, 44, 55, 66, 77 }; 
    string apppath = Assembly.GetEntryAssembly(); 
    byte[] exe = File.ReadAllBytes(apppath); 
    string strseperate = "EVILSEPERATOREVIL"; 
    System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); 
    byte[] seperator = encoding.GetBytes(strseperate); 
    //Split code should go here 

    exe = Decrypt(key, encrypted); 
    Process.Start(outpath); 
} 

किसी भी मदद के लिए धन्यवाद।

Answer 1

byte[] SeparateAndGetLast(byte[] source, byte[] separator) 
{ 
    for (var i = 0; i < source.Length; ++i) 
    { 
    if(Equals(source, separator, i)) 
    { 
     var index = i + separator.Length; 
     var part = new byte[source.Length - index]; 
     Array.Copy(source, index, part, 0, part.Length); 
     return part; 
    } 
    } 
    throw new Exception("not found"); 
} 

public static byte[][] Separate(byte[] source, byte[] separator) 
{ 
    var Parts = new List<byte[]>(); 
    var Index = 0; 
    byte[] Part; 
    for (var I = 0; I < source.Length; ++I) 
    { 
     if (Equals(source, separator, I)) 
     { 
      Part = new byte[I - Index]; 
      Array.Copy(source, Index, Part, 0, Part.Length); 
      Parts.Add(Part); 
      Index = I + separator.Length; 
      I += separator.Length - 1; 
     } 
    } 
    Part = new byte[source.Length - Index]; 
    Array.Copy(source, Index, Part, 0, Part.Length); 
    Parts.Add(Part); 
    return Parts.ToArray(); 
} 

bool Equals(byte[] source, byte[] separator, int index) 
{ 
    for (int i = 0; i < separator.Length; ++i) 
    if (index + i >= source.Length || source[index + i] != separator[i]) 
     return false; 
    return true; 
} 

Answer 2

आपका दृष्टिकोण खामियों की एक संख्या है - आप स्मृति में एक पूरे बाइट [] पढ़ रहे हैं, लेकिन डिक्रिप्शन स्ट्रीम करने की प्रक्रिया है, तो आप बेकार में स्मृति बर्बाद कर रहे हैं। दूसरा, आप सीएलआर में एक सरणी (या उस स्ट्रिंग के लिए एक स्ट्रिंग) को "विभाजित" नहीं कर सकते हैं। जब आप एक सीएलआर स्ट्रिंग को विभाजित करते हैं तो यह प्रतियां बनाता है, जो स्मृति को बर्बाद करता है।

इस प्रयास करें: वहाँ

public static void Main(String[] args) { 

    using(FileStream fs = new FileStream(@"path\to\fileName.exe", FileMode.Read)) { 

     BinaryReader rdr = new BinaryReader(fs); 
     SeekToEndOfDelimiter(rdr); 

     // Use an implementation of RC4 decryption that accepts Streams as arguments, then pass fs directly as an argument: 
     using(FileStream output = new FileStream(@"path\to\out.exe", FileMode.Write)) { 
      // Providing the key arguments is an exercise for the reader 
      MyRc4Implementation.DecryptStream(fs, output, key); 
     } 
    } 

} 

private static void SeekToEndOfDelimiter(BinaryReader rdr) { 
    // Implementing this code is an exercise left up to the reader. 
    // But just iterate through each byte (assuming ASCII-compatible encoding) until you encounter the end of the delimiter 
} 

, कोई गंदा बाइट [] सरणियों :)

Answer 3

मैं जानता हूँ कि मैं वास्तव में हूँ, वास्तव में पार्टी के लिए देर हो चुकी है, लेकिन ... आप निश्चित रूप से कर सकते हैं संशोधित यदि पसंदीदा हो तो आसानी से एक सूची वापस करने के लिए। अगर यह मददगार होगा तो मैंने टिप्पणियां/लेखसूची छोड़ी ... यह सबसे इष्टतम/अनुकूलित कोड नहीं हो सकता है लेकिन मेरे विशिष्ट उपयोग मामले के लिए अच्छा काम करता है और मैंने सोचा कि मैं साझा करूंगा।

public static byte[][] SplitBytesByDelimiter(byte[] data, byte delimiter) 
    { 
     if (data == null) throw new ArgumentNullException(nameof(data)); 
     if (data.Length < 1) return null; 

     List<byte[]> retList = new List<byte[]>(); 

     int start = 0; 
     int pos = 0; 
     byte[] remainder = null; // in case data found at end without terminating delimiter 

     while (true) 
     { 
      // Console.WriteLine("pos " + pos + " start " + start); 
      if (pos >= data.Length) break; 

      if (data[pos] == delimiter) 
      { 
       // Console.WriteLine("delimiter found at pos " + pos + " start " + start); 

       // separator found 
       if (pos == start) 
       { 
        // Console.WriteLine("first char is delimiter, skipping"); 
        // skip if first character is delimiter 
        pos++; 
        start++; 
        if (pos >= data.Length) 
        { 
         // last character is a delimiter, yay! 
         remainder = null; 
         break; 
        } 
        else 
        { 
         // remainder exists 
         remainder = new byte[data.Length - start]; 
         Buffer.BlockCopy(data, start, remainder, 0, (data.Length - start)); 
         continue; 
        } 
       } 
       else 
       { 
        // Console.WriteLine("creating new byte[] at pos " + pos + " start " + start); 
        byte[] ba = new byte[(pos - start)]; 
        Buffer.BlockCopy(data, start, ba, 0, (pos - start)); 
        retList.Add(ba); 

        start = pos + 1; 
        pos = start; 

        if (pos >= data.Length) 
        { 
         // last character is a delimiter, yay! 
         remainder = null; 
         break; 
        } 
        else 
        { 
         // remainder exists 
         remainder = new byte[data.Length - start]; 
         Buffer.BlockCopy(data, start, remainder, 0, (data.Length - start)); 
        } 
       } 
      } 
      else 
      { 
       // payload character, continue; 
       pos++; 
      } 
     } 

     if (remainder != null) 
     { 
      // Console.WriteLine("adding remainder"); 
      retList.Add(remainder); 
     } 

     return retList.ToArray(); 
    }