स्क्रैप के खिलाफ कोई चाल नहीं: OpenJDK हैक बनाम कक्षा एन्क्रिप्शन

इस लेख का उद्देश्य डेवलपर्स को अपने अनुप्रयोगों की रक्षा के लिए क्लास फ़ाइलों को एन्क्रिप्ट करने के फ़ंक्शन के साथ पर्यवेक्षकों का उपयोग करने और उन पर पैसे की संवेदनहीन बर्बादी से आगाह करना है।
रिवर्स इंजीनियरिंग से बाइट कोड की सुरक्षा और इस संरक्षण की परिधि पर दिमित्री लेसकोव के मूल काम में विस्तार से चर्चा की गई है - अपने जावा कोड को सुरक्षित रखें - ऑब्सफ्यूटर्स एंड बियॉन्ड के माध्यम से ।
वर्ग फ़ाइलों के लिए एन्क्रिप्शन तंत्र मानता है कि कक्षाओं की सामग्री एन्क्रिप्ट की गई है, और जब आप किसी विशेष ClassLoader या JVMTI इंटरफ़ेस के माध्यम से अनुप्रयोग शुरू करते हैं, तो डिक्रिप्टेड बाइट कोड को जावा वर्चुअल मशीन में लोड किया जाता है।

उपरोक्त लेख में इस तरह के संरक्षण के बाईपास तरीकों का विस्तार से उल्लेख किया गया है, सौभाग्य से या दुर्भाग्य से, ऐसे कई उत्पाद हैं जिनमें एक देशी घटक शामिल है जो जेवीएम के साथ इंटरैक्ट करता है और डीबग मोड या एक्सट्रूज़न एजेंटों की उपस्थिति पर नज़र रखता है। लेकिन यह, इस तरह के उत्पादों के डेवलपर्स के सभी आश्वासन के बावजूद, अपने बायोटेक की रक्षा बिल्कुल नहीं करता है।

क्लास की फ़ाइलों को एन्क्रिप्ट करने वाले सभी ऑबफ्यूज़ेटर्स की भेद्यता को प्रदर्शित करने के लिए, बस उस एप्लिकेशन को चलाएं जिसे वे -XX के साथ सुरक्षित करते हैं: + TraceClassLoading विकल्प और सुनिश्चित करें कि सभी एन्क्रिप्टेड क्लास फाइलें इस JVM ट्रेस स्तर पर सुरक्षित रूप से दिखाई देती हैं। हम आगे बढ़ेंगे, OpenJDK स्रोत कोड लेंगे और लोड किए गए क्लास फ़ाइलों के बायोटेक अपलोड डालें।

प्रयोग के लिए, हम डेबियन लिनक्स 6.0.5 (स्थिर) और OpenJDK7 स्रोत बंडल का उपयोग करेंगे। अन्य प्लेटफार्मों पर स्रोत से JDK स्थापित करने के निर्देश यहां उपलब्ध हैं: OpenJDK Build README ।

OpenJDK स्रोत कोड में परिवर्तन की संख्या को कम करने के लिए, हम जब -XX: + TraceClassLoading सक्षम होता है, तब वर्किंग डायरेक्टरी के सापेक्ष classes.dump फ़ाइल में सभी भरी हुई कक्षाओं के बाईटेकोड को बचाएगा। फ़ाइल संरचना इस प्रकार है:

{ int lengthClassName, byte[] className, int lengthByteCode, byte[] bytecode }, { next record … }, … 

विधानसभा के लिए वातावरण तैयार करें:

 # apt-get install openjdk-6-jdk # apt-get build-dep openjdk-6 

इसके बाद, आपको OpenJDK स्रोत कोड और हमारे पैच को डाउनलोड करने की आवश्यकता है, जो निम्न कोड को ClassFileParser :: parseClassFile फ़ंक्शन से हॉटस्पॉट / src / share / vm / classfile / classFileParser.cpp में जोड़ेगा:

       // dumping class bytecode      // dump file format:      // length of the class name - 4 bytes      // class name      // length of the class bytecode - 4 bytes      // byte code      // ... next class ...  ClassFileStream* cfs = stream();  FILE * pFile;  int length = cfs->length();  int nameLength = strlen(this_klass->external_name());  pFile = fopen("classes.dump","ab");  // size of the class name  fputc((int)((nameLength >> 24) & 0XFF), pFile );  fputc((int)((nameLength >> 16) & 0XFF), pFile );  fputc((int)((nameLength >> 8) & 0XFF), pFile );  fputc((int)(nameLength & 0XFF), pFile );      // class name  fwrite (this_klass->external_name() , 1, nameLength, pFile );  // size of the class bytecode  fputc((int)((length >> 24) & 0XFF), pFile );  fputc((int)((length >> 16) & 0XFF), pFile );  fputc((int)((length >> 8) & 0XFF), pFile );  fputc((int)(length & 0XFF), pFile );      // class bytecode  fwrite (cfs->buffer() , 1 , length, pFile );  fclose(pFile); 

सुनिश्चित करें कि JDK ठीक चल रहा है:

 # export LANG=C ALT_BOOTDIR=/usr/lib/jvm/java-6-openjdk ALLOW_DOWNLOADS=true # make sanity && make 

पैच लागू करें और बिल्ड को चलाएं

 # cd $OPENJDK_SRC # patch -p1 < $PATH_TO_PATCH_FILE # make 

अगला, संकलित JRE की बिन निर्देशिका पर जाएँ: $ OPENJDK_SRC / build / linux-i586 / j2re-image / bin /
स्वास्थ्य का परीक्षण करने के लिए, जावा को एक एकल पैरामीटर -XX के साथ चलाएं: + TraceClassLoading:

 # ./java -XX:+TraceClassLoading 

और classes.dump को देखें, इसमें सभी क्लास फाइलें होंगी जो JRE स्टार्टअप पर लोड होती हैं।

और अब सबसे दिलचस्प बात, एन्क्रिप्टेड बायटेकोड के साथ एक जावा एप्लिकेशन लें, उदाहरण के लिए, आप इस फ़ंक्शन के साथ कुछ ओबफ्यूज़ेटर के परीक्षण का उपयोग कर सकते हैं। मैं स्पष्ट कारणों के लिए, विशिष्ट नामों का उल्लेख नहीं करूंगा, यह कुंजी "बाइट-कोड एन्क्रिप्शन" द्वारा Google में खोज करने के लिए पर्याप्त है। SomeClassGuard.jar के अंदर, hierarchy com / **** / someclassguard / इंजन में एन्क्रिप्टेड क्लास फाइलें होती हैं, आप किसी भी डिकंपाइलर को सेट करके खुद को सत्यापित कर सकते हैं या HEX दर्शक में फ़ाइल हेडर को देख सकते हैं।

अब SomeClassGuard.jar चलाएं:

 # ./java -XX:+TraceClassLoading -jar SomeClassGuard.jar 

इसके बाद, हमें SomeClassGuard.jar को चलाने के बाद प्राप्त किए गए classes.dump फ़ाइल को अनज़िप करना होगा, इसके लिए हम एक छोटा जावा प्रोग्राम लिखेंगे:

 package openjdkmod; import java.io.DataInputStream; import java.io.EOFException; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; /** * Classes dump format extractor class. * Author Ivan Kinash kinash@licel.ru */ public class ClassesDumpExractor {   /**    * Extract contents classes.dump to specified dir    */   public static void main(String[] args) throws FileNotFoundException, IOException {       if (args.length != 2) {           System.err.println("Usage openjdkmod.ClassesDumpExtractor <classes.dump file> <out dir>");           System.exit(-1);       }       File classesDumpFile = new File(args[0]);       if (!classesDumpFile.exists()) {           System.err.println("Source file: " + args[0] + " not found!");           System.exit(-1);       }       File outDir = new File(args[1]);       if (!outDir.exists()) {           outDir.mkdirs();       }       DataInputStream din = new DataInputStream(new FileInputStream(classesDumpFile));       while (true) {           try {               int classNameLength = din.readInt();               byte[] classNameBytes = new byte[classNameLength];               din.readFully(classNameBytes);               String className = new String(classNameBytes);               System.out.println("className:" + className);               int classLength = din.readInt();               byte[] classBytes = new byte[classLength];               din.readFully(classBytes);               File parentDir = className.indexOf(".")>0?new File(outDir, className.substring(0,className.lastIndexOf(".")).replace(".", File.separator)):outDir;               if(!parentDir.exists()) parentDir.mkdirs();               File outFile = new File(parentDir, (className.indexOf(".")>0?className.substring(className.lastIndexOf(".")+1):className)+".class");               FileOutputStream outFos = new FileOutputStream(outFile);               outFos.write(classBytes);               outFos.close();           } catch (EOFException e) {               din.close();               return;           }       }   } } 

और इसे मापदंडों के साथ चलाएं:

 # java openjdkmod.ClassesDumpExractor classes.dump dump_directory 

आउटपुट पर, हमें डिक्रिप्टेड क्लास-फाइलों के साथ एक निर्देशिका मिलती है।

निष्कर्ष।
एन्क्रिप्शन के साथ वर्ग फ़ाइलों की सुरक्षा पूरी तरह से व्यर्थ, खतरनाक, महंगी (कम से कम मुक्त नहीं) है।
यदि आपको अपने बायोटेक की रक्षा करने की आवश्यकता है:
1) देशी कोड में बायटेकोड संकलक का उपयोग करें।
2) स्ट्रिंग एन्क्रिप्शन फ़ंक्शन के साथ ओफ़्स्कुसेटर के साथ क्लासिक ओफ़्यूसैक्टर का संयोजन।
सुपर-प्रोटेक्शन के लिए: बाहरी उपकरणों का उपयोग करें जो अपने अंदर सुरक्षित भंडारण और बायोटेक निष्पादन का समर्थन करते हैं।
उपरोक्त पद्धति का उपयोग विभिन्न अनुप्रयोगों को डिबग करने के लिए किया जा सकता है जब आपको यह देखने की आवश्यकता होती है कि ऑपरेशन के दौरान कौन सा बाइट कोड लोड किया गया है।

Note1:
आप JDK स्रोत कोड को संशोधित किए बिना समान परिणाम प्राप्त कर सकते हैं - sun.misc.Unsafe वर्ग का उपयोग करते हुए, हालांकि आपको JVM के अंदर कक्षाओं के भंडारण प्रारूप में थोड़ा खुदाई करने की आवश्यकता है।

टिप्पणी 2:
ठीक है, निश्चित रूप से, इस लेख में निहित डेटा के आपके उपयोग के लिए लेखक जिम्मेदार नहीं है।

नोट 3 : यहां से ली गई मूल छवि: it.wikipedia.org/wiki/File : नेटबीन-ड्यूक। पीएनजी