Come analizzare il file AndroidManifest.xml all'interno di un pacchetto .apk

Questo file sembra essere in un formato XML binario. Che cosa è questo formato e come può essere analizzato in modo programmato (a differenza dell'utilizzo dello strumento aapt dump nell' SDK)?

Questo formato binario non è descritto nella documentazione qui .

  • Errore durante l'innalzamento della class android.support.design.widget.CoordinatorLayout
  • Libreria Android Import cancella R
  • Xamarin.Forms: l'allineamento del text sbagliato dopo il click (Android)
  • disegnabile == disegnabile?
  • Utilizza il codice Android NDK
  • Chiarire le connessioni Firebase
  • Nota : desidero accedere a queste informazioni dall'esterno dell'ambiente Android, preferibilmente da Java.

  • Android SurfaceView / Canvas tremolava dopo aver cercato di rimuoverlo
  • Esempio di come scaricare JSON dal server?
  • Come passare i parametri a OnClickListener?
  • Come cambiare la libreria di supporto di progettazione di android FAB Button border color?
  • android: come modificare lo stile del text di modifica?
  • smoothScrollToPositionFromTop () non funziona sempre come dovrebbe
  • 12 Solutions collect form web for “Come analizzare il file AndroidManifest.xml all'interno di un pacchetto .apk”

    Usa android-apktool

    Esiste un'applicazione che legge i file APK e decodifica XML in forma quasi originale.

    Uso:

     apktool d Gmail.apk && cat Gmail/AndroidManifest.xml 

    Controlla android-apktool per ulteriori informazioni

    Questo metodo Java, che viene eseguito su un Android, documenta (quello che ho potuto interpretare circa) il formato binario del file AndroidManifest.xml nel pacchetto .apk. La seconda casella di codice mostra come call decompressXML e come caricare il byte [] dal file del pacchetto app sul dispositivo. (Ci sono campi il cui scopo non capisco, se sai cosa intendono, dimmi, aggiornerò le informazioni.)

     // decompressXML -- Parse the 'compressed' binary form of Android XML docs // such as for AndroidManifest.xml in .apk files public static int endDocTag = 0x00100101; public static int startTag = 0x00100102; public static int endTag = 0x00100103; public void decompressXML(byte[] xml) { // Compressed XML file/bytes starts with 24x bytes of data, // 9 32 bit words in little endian order (LSB first): // 0th word is 03 00 08 00 // 3rd word SEEMS TO BE: Offset at then of StringTable // 4th word is: Number of strings in string table // WARNING: Sometime I indiscriminently display or refer to word in // little endian storage format, or in integer format (ie MSB first). int numbStrings = LEW(xml, 4*4); // StringIndexTable starts at offset 24x, an arrays of 32 bit LE offsets // of the length/string data in the StringTable. int sitOff = 0x24; // Offset of start of StringIndexTable // StringTable, each string is represented with a 16 bit little endian // character count, followed by that number of 16 bit (LE) (Unicode) chars. int stOff = sitOff + numbStrings*4; // StringTable follows StrIndexTable // XMLTags, The XML tag tree starts after some unknown content after the // StringTable. There is some unknown data after the StringTable, scan // forward from this point to the flag for the start of an XML start tag. int xmlTagOff = LEW(xml, 3*4); // Start from the offset in the 3rd word. // Scan forward until we find the bytes: 0x02011000(x00100102 in normal int) for (int ii=xmlTagOff; ii<xml.length-4; ii+=4) { if (LEW(xml, ii) == startTag) { xmlTagOff = ii; break; } } // end of hack, scanning for start of first start tag // XML tags and attributes: // Every XML start and end tag consists of 6 32 bit words: // 0th word: 02011000 for startTag and 03011000 for endTag // 1st word: a flag?, like 38000000 // 2nd word: Line of where this tag appeared in the original source file // 3rd word: FFFFFFFF ?? // 4th word: StringIndex of NameSpace name, or FFFFFFFF for default NS // 5th word: StringIndex of Element Name // (Note: 01011000 in 0th word means end of XML document, endDocTag) // Start tags (not end tags) contain 3 more words: // 6th word: 14001400 meaning?? // 7th word: Number of Attributes that follow this tag(follow word 8th) // 8th word: 00000000 meaning?? // Attributes consist of 5 words: // 0th word: StringIndex of Attribute Name's Namespace, or FFFFFFFF // 1st word: StringIndex of Attribute Name // 2nd word: StringIndex of Attribute Value, or FFFFFFF if ResourceId used // 3rd word: Flags? // 4th word: str ind of attr value again, or ResourceId of value // TMP, dump string table to tr for debugging //tr.addSelect("strings", null); //for (int ii=0; ii<numbStrings; ii++) { // // Length of string starts at StringTable plus offset in StrIndTable // String str = compXmlString(xml, sitOff, stOff, ii); // tr.add(String.valueOf(ii), str); //} //tr.parent(); // Step through the XML tree element tags and attributes int off = xmlTagOff; int indent = 0; int startTagLineNo = -2; while (off < xml.length) { int tag0 = LEW(xml, off); //int tag1 = LEW(xml, off+1*4); int lineNo = LEW(xml, off+2*4); //int tag3 = LEW(xml, off+3*4); int nameNsSi = LEW(xml, off+4*4); int nameSi = LEW(xml, off+5*4); if (tag0 == startTag) { // XML START TAG int tag6 = LEW(xml, off+6*4); // Expected to be 14001400 int numbAttrs = LEW(xml, off+7*4); // Number of Attributes to follow //int tag8 = LEW(xml, off+8*4); // Expected to be 00000000 off += 9*4; // Skip over 6+3 words of startTag data String name = compXmlString(xml, sitOff, stOff, nameSi); //tr.addSelect(name, null); startTagLineNo = lineNo; // Look for the Attributes StringBuffer sb = new StringBuffer(); for (int ii=0; ii<numbAttrs; ii++) { int attrNameNsSi = LEW(xml, off); // AttrName Namespace Str Ind, or FFFFFFFF int attrNameSi = LEW(xml, off+1*4); // AttrName String Index int attrValueSi = LEW(xml, off+2*4); // AttrValue Str Ind, or FFFFFFFF int attrFlags = LEW(xml, off+3*4); int attrResId = LEW(xml, off+4*4); // AttrValue ResourceId or dup AttrValue StrInd off += 5*4; // Skip over the 5 words of an attribute String attrName = compXmlString(xml, sitOff, stOff, attrNameSi); String attrValue = attrValueSi!=-1 ? compXmlString(xml, sitOff, stOff, attrValueSi) : "resourceID 0x"+Integer.toHexString(attrResId); sb.append(" "+attrName+"=\""+attrValue+"\""); //tr.add(attrName, attrValue); } prtIndent(indent, "<"+name+sb+">"); indent++; } else if (tag0 == endTag) { // XML END TAG indent--; off += 6*4; // Skip over 6 words of endTag data String name = compXmlString(xml, sitOff, stOff, nameSi); prtIndent(indent, "</"+name+"> (line "+startTagLineNo+"-"+lineNo+")"); //tr.parent(); // Step back up the NobTree } else if (tag0 == endDocTag) { // END OF XML DOC TAG break; } else { prt(" Unreceachzed tag code '"+Integer.toHexString(tag0) +"' at offset "+off); break; } } // end of while loop scanning tags and attributes of XML tree prt(" end at offset "+off); } // end of decompressXML public String compXmlString(byte[] xml, int sitOff, int stOff, int strInd) { if (strInd < 0) return null; int strOff = stOff + LEW(xml, sitOff+strInd*4); return compXmlStringAt(xml, strOff); } public static String spaces = " "; public void prtIndent(int indent, String str) { prt(spaces.substring(0, Math.min(indent*2, spaces.length()))+str); } // compXmlStringAt -- Return the string stored in StringTable format at // offset strOff. This offset points to the 16 bit string length, which // is followed by that number of 16 bit (Unicode) chars. public String compXmlStringAt(byte[] arr, int strOff) { int strLen = arr[strOff+1]<<8&0xff00 | arr[strOff]&0xff; byte[] chars = new byte[strLen]; for (int ii=0; ii<strLen; ii++) { chars[ii] = arr[strOff+2+ii*2]; } return new String(chars); // Hack, just use 8 byte chars } // end of compXmlStringAt // LEW -- Return value of a Little Endian 32 bit word from the byte arrays // at offset off. public int LEW(byte[] arr, int off) { return arr[off+3]<<24&0xff000000 | arr[off+2]<<16&0xff0000 | arr[off+1]<<8&0xff00 | arr[off]&0xFF; } // end of LEW 

    Questo metodo legge l'AndroidManifest in un byte [] per l'elaborazione:

     public void getIntents(String path) { try { JarFile jf = new JarFile(path); InputStream is = jf.getInputStream(jf.getEntry("AndroidManifest.xml")); byte[] xml = new byte[is.available()]; int br = is.read(xml); //Tree tr = TrunkFactory.newTree(); decompressXML(xml); //prt("XML\n"+tr.list()); } catch (Exception ex) { console.log("getIntents, ex: "+ex); ex.printStackTrace(); } } // end of getIntents 

    La maggior parte delle applicazioni sono memorizzate in / system / app che è leggibile senza radice il mio Evo, altre applicazioni sono in / data / app che ho bisogno di root per vedere. L'argomento "path" sopra sarebbe qualcosa come: "/system/app/Weather.apk"

    Che cosa circa l'utilizzo di Android Asset Packaging Tool (aapt), da Android SDK, in uno script Python (o qualsiasi altra cosa)?

    Attraverso il aapt ( http://elinux.org/Android_aapt ), infatti, è ansible recuperare informazioni sul pacchetto .apk e sul relativo file AndroidManifest.xml . In particolare, è ansible estrarre i valori di singoli elementi di un pacchetto .apk attraverso il sottoprogramma 'dump' . Ad esempio, è ansible estrarre le autorizzazioni utente nel file AndroidManifest.xml all'interno di un pacchetto .apk in questo modo:

     $ aapt dump permissions package.apk 

    Dove package.apk è il tuo pacchetto .apk .

    Inoltre, è ansible utilizzare il command pipe Unix per cancellare l'output. Per esempio:

     $ aapt dump permissions package.apk | sed 1d | awk '{ print $NF }' 

    Ecco uno script Python che a quello in modo programmato:

     import os import subprocess #Current directory and file name: curpath = os.path.dirname( os.path.realpath(__file__) ) filepath = os.path.join(curpath, "package.apk") #Extract the AndroidManifest.xml permissions: command = "aapt dump permissions " + filepath + " | sed 1d | awk '{ print $NF }'" process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=None, shell=True) permissions = process.communicate()[0] print permissions 

    In modo analogo è ansible estrarre altre informazioni (ad es. Pacchetto , nome app , ecc …) di AndroidManifest.xml :

     #Extract the APK package info: shellcommand = "aapt dump badging " + filepath process = subprocess.Popen(shellcommand, stdout=subprocess.PIPE, stderr=None, shell=True) apkInfo = process.communicate()[0].splitlines() for info in apkInfo: #Package info: if string.find(info, "package:", 0) != -1: print "App Package: " + findBetween(info, "name='", "'") print "App Version: " + findBetween(info, "versionName='", "'") continue #App name: if string.find(info, "application:", 0) != -1: print "App Name: " + findBetween(info, "label='", "'") continue def findBetween(s, prefix, suffix): try: start = s.index(prefix) + len(prefix) end = s.index(suffix, start) return s[start:end] except ValueError: return "" 

    Se invece si desidera analizzare l'integer tree XML di AndroidManifest, è ansible farlo in modo analogo utilizzando il command xmltree :

     aapt dump xmltree package.apk AndroidManifest.xml 

    Utilizzo di Python come prima:

     #Extract the AndroidManifest XML tree: shellcommand = "aapt dump xmltree " + filepath + " AndroidManifest.xml" process = subprocess.Popen(shellcommand, stdout=subprocess.PIPE, stderr=None, shell=True) xmlTree = process.communicate()[0] print "Number of Activities: " + str(xmlTree.count("activity")) print "Number of Services: " + str(xmlTree.count("service")) print "Number of BroadcastReceivers: " + str(xmlTree.count("receiver")) 

    È ansible utilizzare lo strumento axml2xml.pl sviluppato qualche tempo fa all'interno di un progetto android-random . Genera il file manifesto testuale (AndroidManifest.xml) dal binario.

    Sto dicendo " testuale " e non " originale " perché come molti strumenti di ingegneria inversa questo non è perfetto e il risultato non sarà completo . Presumo che non sia mai stato completo o semplicemente non compatibile con l'avanzamento (con un nuovo schema binario di codifica). Qualunque sia la ragione, lo strumento axml2xml.pl non sarà in grado di estrarre correttamente tutti i valori dell'attributo. Tali attributi sono minSdkVersion, targetSdkVersion e fondamentalmente tutti gli attributi che fanno riferimento a risorse (come stringhe, icone, ecc.), Cioè solo i nomi delle classi (di attività, servizi, ecc.) Vengono estratti correttamente.

    Tuttavia, è ansible trovare queste informazioni mancanti eseguendo lo strumento aapt sul file originale di app Android ( .apk ):

    aapt l -a <someapp.apk>

    Controllare questo seguito di WPF Project che decodifica correttamente le properties;.

    apk-parser, https://github.com/caoqianli/apk-parser , un impl leggero per java, senza alcuna dipendenza per aapt o altri binari, è utile per analizzare i file xml binari e altre informazioni sugli apk.

     ApkParser apkParser = new ApkParser(new File(filePath)); // set a locale to translate resource tag into specific strings in language the locale specified, you set locale to Locale.ENGLISH then get apk title 'WeChat' instead of '@string/app_name' for example apkParser.setPreferredLocale(locale); String xml = apkParser.getManifestXml(); System.out.println(xml); String xml2 = apkParser.transBinaryXml(xmlPathInApk); System.out.println(xml2); ApkMeta apkMeta = apkParser.getApkMeta(); System.out.println(apkMeta); Set<Locale> locales = apkParser.getLocales(); for (Locale l : locales) { System.out.println(l); } apkParser.close(); 

    Nel caso in cui sia utile, ecco una versione C ++ dello snippet Java postato da Ribo:

     struct decompressXML { // decompressXML -- Parse the 'compressed' binary form of Android XML docs // such as for AndroidManifest.xml in .apk files enum { endDocTag = 0x00100101, startTag = 0x00100102, endTag = 0x00100103 }; decompressXML(const BYTE* xml, int cb) { // Compressed XML file/bytes starts with 24x bytes of data, // 9 32 bit words in little endian order (LSB first): // 0th word is 03 00 08 00 // 3rd word SEEMS TO BE: Offset at then of StringTable // 4th word is: Number of strings in string table // WARNING: Sometime I indiscriminently display or refer to word in // little endian storage format, or in integer format (ie MSB first). int numbStrings = LEW(xml, cb, 4*4); // StringIndexTable starts at offset 24x, an arrays of 32 bit LE offsets // of the length/string data in the StringTable. int sitOff = 0x24; // Offset of start of StringIndexTable // StringTable, each string is represented with a 16 bit little endian // character count, followed by that number of 16 bit (LE) (Unicode) chars. int stOff = sitOff + numbStrings*4; // StringTable follows StrIndexTable // XMLTags, The XML tag tree starts after some unknown content after the // StringTable. There is some unknown data after the StringTable, scan // forward from this point to the flag for the start of an XML start tag. int xmlTagOff = LEW(xml, cb, 3*4); // Start from the offset in the 3rd word. // Scan forward until we find the bytes: 0x02011000(x00100102 in normal int) for (int ii=xmlTagOff; ii<cb-4; ii+=4) { if (LEW(xml, cb, ii) == startTag) { xmlTagOff = ii; break; } } // end of hack, scanning for start of first start tag // XML tags and attributes: // Every XML start and end tag consists of 6 32 bit words: // 0th word: 02011000 for startTag and 03011000 for endTag // 1st word: a flag?, like 38000000 // 2nd word: Line of where this tag appeared in the original source file // 3rd word: FFFFFFFF ?? // 4th word: StringIndex of NameSpace name, or FFFFFFFF for default NS // 5th word: StringIndex of Element Name // (Note: 01011000 in 0th word means end of XML document, endDocTag) // Start tags (not end tags) contain 3 more words: // 6th word: 14001400 meaning?? // 7th word: Number of Attributes that follow this tag(follow word 8th) // 8th word: 00000000 meaning?? // Attributes consist of 5 words: // 0th word: StringIndex of Attribute Name's Namespace, or FFFFFFFF // 1st word: StringIndex of Attribute Name // 2nd word: StringIndex of Attribute Value, or FFFFFFF if ResourceId used // 3rd word: Flags? // 4th word: str ind of attr value again, or ResourceId of value // TMP, dump string table to tr for debugging //tr.addSelect("strings", null); //for (int ii=0; ii<numbStrings; ii++) { // // Length of string starts at StringTable plus offset in StrIndTable // String str = compXmlString(xml, sitOff, stOff, ii); // tr.add(String.valueOf(ii), str); //} //tr.parent(); // Step through the XML tree element tags and attributes int off = xmlTagOff; int indent = 0; int startTagLineNo = -2; while (off < cb) { int tag0 = LEW(xml, cb, off); //int tag1 = LEW(xml, off+1*4); int lineNo = LEW(xml, cb, off+2*4); //int tag3 = LEW(xml, off+3*4); int nameNsSi = LEW(xml, cb, off+4*4); int nameSi = LEW(xml, cb, off+5*4); if (tag0 == startTag) { // XML START TAG int tag6 = LEW(xml, cb, off+6*4); // Expected to be 14001400 int numbAttrs = LEW(xml, cb, off+7*4); // Number of Attributes to follow //int tag8 = LEW(xml, off+8*4); // Expected to be 00000000 off += 9*4; // Skip over 6+3 words of startTag data std::string name = compXmlString(xml, cb, sitOff, stOff, nameSi); //tr.addSelect(name, null); startTagLineNo = lineNo; // Look for the Attributes std::string sb; for (int ii=0; ii<numbAttrs; ii++) { int attrNameNsSi = LEW(xml, cb, off); // AttrName Namespace Str Ind, or FFFFFFFF int attrNameSi = LEW(xml, cb, off+1*4); // AttrName String Index int attrValueSi = LEW(xml, cb, off+2*4); // AttrValue Str Ind, or FFFFFFFF int attrFlags = LEW(xml, cb, off+3*4); int attrResId = LEW(xml, cb, off+4*4); // AttrValue ResourceId or dup AttrValue StrInd off += 5*4; // Skip over the 5 words of an attribute std::string attrName = compXmlString(xml, cb, sitOff, stOff, attrNameSi); std::string attrValue = attrValueSi!=-1 ? compXmlString(xml, cb, sitOff, stOff, attrValueSi) : "resourceID 0x"+toHexString(attrResId); sb.append(" "+attrName+"=\""+attrValue+"\""); //tr.add(attrName, attrValue); } prtIndent(indent, "<"+name+sb+">"); indent++; } else if (tag0 == endTag) { // XML END TAG indent--; off += 6*4; // Skip over 6 words of endTag data std::string name = compXmlString(xml, cb, sitOff, stOff, nameSi); prtIndent(indent, "</"+name+"> (line "+toIntString(startTagLineNo)+"-"+toIntString(lineNo)+")"); //tr.parent(); // Step back up the NobTree } else if (tag0 == endDocTag) { // END OF XML DOC TAG break; } else { prt(" Unreceachzed tag code '"+toHexString(tag0) +"' at offset "+toIntString(off)); break; } } // end of while loop scanning tags and attributes of XML tree prt(" end at offset "+off); } // end of decompressXML std::string compXmlString(const BYTE* xml, int cb, int sitOff, int stOff, int strInd) { if (strInd < 0) return std::string(""); int strOff = stOff + LEW(xml, cb, sitOff+strInd*4); return compXmlStringAt(xml, cb, strOff); } void prt(std::string str) { printf("%s", str.c_str()); } void prtIndent(int indent, std::string str) { char spaces[46]; memset(spaces, ' ', sizeof(spaces)); spaces[min(indent*2, sizeof(spaces) - 1)] = 0; prt(spaces); prt(str); prt("\n"); } // compXmlStringAt -- Return the string stored in StringTable format at // offset strOff. This offset points to the 16 bit string length, which // is followed by that number of 16 bit (Unicode) chars. std::string compXmlStringAt(const BYTE* arr, int cb, int strOff) { if (cb < strOff + 2) return std::string(""); int strLen = arr[strOff+1]<<8&0xff00 | arr[strOff]&0xff; char* chars = new char[strLen + 1]; chars[strLen] = 0; for (int ii=0; ii<strLen; ii++) { if (cb < strOff + 2 + ii * 2) { chars[ii] = 0; break; } chars[ii] = arr[strOff+2+ii*2]; } std::string str(chars); free(chars); return str; } // end of compXmlStringAt // LEW -- Return value of a Little Endian 32 bit word from the byte arrays // at offset off. int LEW(const BYTE* arr, int cb, int off) { return (cb > off + 3) ? ( arr[off+3]<<24&0xff000000 | arr[off+2]<<16&0xff0000 | arr[off+1]<<8&0xff00 | arr[off]&0xFF ) : 0; } // end of LEW std::string toHexString(DWORD attrResId) { char ch[20]; sprintf_s(ch, 20, "%lx", attrResId); return std::string(ch); } std::string toIntString(int i) { char ch[20]; sprintf_s(ch, 20, "%ld", i); return std::string(ch); } }; 

    Se il tuo in Python o utilizza Androguard , la funzionalità Androguard Androaxml farà questa conversione per te. La funzionalità è dettagliata in questo post di blog , con documentazione aggiuntiva qui e sorgente qui .

    Uso:

     $ ./androaxml.py -h Usage: androaxml.py [options] Options: -h, --help show this help message and exit -i INPUT, --input=INPUT filename input (APK or android's binary xml) -o OUTPUT, --output=OUTPUT filename output of the xml -v, --version version of the API $ ./androaxml.py -i yourfile.apk -o output.xml $ ./androaxml.py -i AndroidManifest.xml -o output.xml 

    per riferimento qui è la mia versione del codice di Ribo. La differenza principale è che decompressXML () restituisce direttamente una string, che per i miei scopi era un uso più appropriato.

    NOTA: il mio unico scopo nell'utilizzare la soluzione di Ribo era quello di recuperare una versione pubblicata del file .APK dal file Manifest XML e confermo che per questo scopo funziona in modo meraviglioso.

    EDIT [2013-03-16]: funziona splendidamente se la versione è impostata come text normale, ma se è impostata per fare riferimento ad un XML di risorsa, verrà visualizzata come ad esempio "Resource 0x1". In questo caso particolare, probabilmente dovrai associare questa soluzione ad un'altra soluzione che recupererà il giusto riferimento di risorse stringhe.

     /** * Binary XML doc ending Tag */ public static int endDocTag = 0x00100101; /** * Binary XML start Tag */ public static int startTag = 0x00100102; /** * Binary XML end Tag */ public static int endTag = 0x00100103; /** * Reference var for spacing * Used in prtIndent() */ public static String spaces = " "; /** * Parse the 'compressed' binary form of Android XML docs * such as for AndroidManifest.xml in .apk files * Source: http://stackoverflow.com/questions/2097813/how-to-parse-the-androidmanifest-xml-file-inside-an-apk-package/4761689#4761689 * * @param xml Encoded XML content to decompress */ public static String decompressXML(byte[] xml) { StringBuilder resultXml = new StringBuilder(); // Compressed XML file/bytes starts with 24x bytes of data, // 9 32 bit words in little endian order (LSB first): // 0th word is 03 00 08 00 // 3rd word SEEMS TO BE: Offset at then of StringTable // 4th word is: Number of strings in string table // WARNING: Sometime I indiscriminently display or refer to word in // little endian storage format, or in integer format (ie MSB first). int numbStrings = LEW(xml, 4*4); // StringIndexTable starts at offset 24x, an arrays of 32 bit LE offsets // of the length/string data in the StringTable. int sitOff = 0x24; // Offset of start of StringIndexTable // StringTable, each string is represented with a 16 bit little endian // character count, followed by that number of 16 bit (LE) (Unicode) chars. int stOff = sitOff + numbStrings*4; // StringTable follows StrIndexTable // XMLTags, The XML tag tree starts after some unknown content after the // StringTable. There is some unknown data after the StringTable, scan // forward from this point to the flag for the start of an XML start tag. int xmlTagOff = LEW(xml, 3*4); // Start from the offset in the 3rd word. // Scan forward until we find the bytes: 0x02011000(x00100102 in normal int) for (int ii=xmlTagOff; ii<xml.length-4; ii+=4) { if (LEW(xml, ii) == startTag) { xmlTagOff = ii; break; } } // end of hack, scanning for start of first start tag // XML tags and attributes: // Every XML start and end tag consists of 6 32 bit words: // 0th word: 02011000 for startTag and 03011000 for endTag // 1st word: a flag?, like 38000000 // 2nd word: Line of where this tag appeared in the original source file // 3rd word: FFFFFFFF ?? // 4th word: StringIndex of NameSpace name, or FFFFFFFF for default NS // 5th word: StringIndex of Element Name // (Note: 01011000 in 0th word means end of XML document, endDocTag) // Start tags (not end tags) contain 3 more words: // 6th word: 14001400 meaning?? // 7th word: Number of Attributes that follow this tag(follow word 8th) // 8th word: 00000000 meaning?? // Attributes consist of 5 words: // 0th word: StringIndex of Attribute Name's Namespace, or FFFFFFFF // 1st word: StringIndex of Attribute Name // 2nd word: StringIndex of Attribute Value, or FFFFFFF if ResourceId used // 3rd word: Flags? // 4th word: str ind of attr value again, or ResourceId of value // TMP, dump string table to tr for debugging //tr.addSelect("strings", null); //for (int ii=0; ii<numbStrings; ii++) { // // Length of string starts at StringTable plus offset in StrIndTable // String str = compXmlString(xml, sitOff, stOff, ii); // tr.add(String.valueOf(ii), str); //} //tr.parent(); // Step through the XML tree element tags and attributes int off = xmlTagOff; int indent = 0; int startTagLineNo = -2; while (off < xml.length) { int tag0 = LEW(xml, off); //int tag1 = LEW(xml, off+1*4); int lineNo = LEW(xml, off+2*4); //int tag3 = LEW(xml, off+3*4); int nameNsSi = LEW(xml, off+4*4); int nameSi = LEW(xml, off+5*4); if (tag0 == startTag) { // XML START TAG int tag6 = LEW(xml, off+6*4); // Expected to be 14001400 int numbAttrs = LEW(xml, off+7*4); // Number of Attributes to follow //int tag8 = LEW(xml, off+8*4); // Expected to be 00000000 off += 9*4; // Skip over 6+3 words of startTag data String name = compXmlString(xml, sitOff, stOff, nameSi); //tr.addSelect(name, null); startTagLineNo = lineNo; // Look for the Attributes StringBuffer sb = new StringBuffer(); for (int ii=0; ii<numbAttrs; ii++) { int attrNameNsSi = LEW(xml, off); // AttrName Namespace Str Ind, or FFFFFFFF int attrNameSi = LEW(xml, off+1*4); // AttrName String Index int attrValueSi = LEW(xml, off+2*4); // AttrValue Str Ind, or FFFFFFFF int attrFlags = LEW(xml, off+3*4); int attrResId = LEW(xml, off+4*4); // AttrValue ResourceId or dup AttrValue StrInd off += 5*4; // Skip over the 5 words of an attribute String attrName = compXmlString(xml, sitOff, stOff, attrNameSi); String attrValue = attrValueSi!=-1 ? compXmlString(xml, sitOff, stOff, attrValueSi) : "resourceID 0x"+Integer.toHexString(attrResId); sb.append(" "+attrName+"=\""+attrValue+"\""); //tr.add(attrName, attrValue); } resultXml.append(prtIndent(indent, "<"+name+sb+">")); indent++; } else if (tag0 == endTag) { // XML END TAG indent--; off += 6*4; // Skip over 6 words of endTag data String name = compXmlString(xml, sitOff, stOff, nameSi); resultXml.append(prtIndent(indent, "</"+name+"> (line "+startTagLineNo+"-"+lineNo+")")); //tr.parent(); // Step back up the NobTree } else if (tag0 == endDocTag) { // END OF XML DOC TAG break; } else { Log.e(TAG, " Unreceachzed tag code '"+Integer.toHexString(tag0) +"' at offset "+off); break; } } // end of while loop scanning tags and attributes of XML tree Log.i(TAG, " end at offset "+off); return resultXml.toString(); } // end of decompressXML /** * Tool Method for decompressXML(); * Compute binary XML to its string format * Source: Source: http://stackoverflow.com/questions/2097813/how-to-parse-the-androidmanifest-xml-file-inside-an-apk-package/4761689#4761689 * * @param xml Binary-formatted XML * @param sitOff * @param stOff * @param strInd * @return String-formatted XML */ public static String compXmlString(byte[] xml, int sitOff, int stOff, int strInd) { if (strInd < 0) return null; int strOff = stOff + LEW(xml, sitOff+strInd*4); return compXmlStringAt(xml, strOff); } /** * Tool Method for decompressXML(); * Apply indentation * * @param indent Indentation level * @param str String to indent * @return Indented string */ public static String prtIndent(int indent, String str) { return (spaces.substring(0, Math.min(indent*2, spaces.length()))+str); } /** * Tool method for decompressXML() * Return the string stored in StringTable format at * offset strOff. This offset points to the 16 bit string length, which * is followed by that number of 16 bit (Unicode) chars. * * @param arr StringTable arrays * @param strOff Offset to get string from * @return String from StringTable at offset strOff * */ public static String compXmlStringAt(byte[] arr, int strOff) { int strLen = arr[strOff+1]<<8&0xff00 | arr[strOff]&0xff; byte[] chars = new byte[strLen]; for (int ii=0; ii<strLen; ii++) { chars[ii] = arr[strOff+2+ii*2]; } return new String(chars); // Hack, just use 8 byte chars } // end of compXmlStringAt /** * Return value of a Little Endian 32 bit word from the byte arrays * at offset off. * * @param arr Byte arrays with 32 bit word * @param off Offset to get word from * @return Value of Little Endian 32 bit word specified */ public static int LEW(byte[] arr, int off) { return arr[off+3]<<24&0xff000000 | arr[off+2]<<16&0xff0000 | arr[off+1]<<8&0xff00 | arr[off]&0xFF; } // end of LEW 

    Hope it can help other people too.

    In Android studio 2.2 you can directly analyze the apk. Goto build- analyze apk. Select the apk, navigate to androidmanifest.xml. You can see the details of androidmanifest.

    I found the AXMLPrinter2, a Java app over at the Android4Me project to work fine on the AndroidManifest.xml that I had (and prints the XML out in a nicely formatted way). http://code.google.com/p/android4me/downloads/detail?name=AXMLPrinter2.jar

    One note.. it (and the code on this answer from Ribo) doesn't appear to handle every compiled XML file that I've come across. I found one where the strings were stored with one byte per character, rather than the double byte format that it assumes.

    it can be helpful

     public static int vCodeApk(String path) { PackageManager pm = G.context.getPackageManager(); PackageInfo info = pm.getPackageArchiveInfo(path, 0); return info.versionCode; // Toast.makeText(this, "VersionCode : " + info.versionCode + ", VersionName : " + info.versionName, Toast.LENGTH_LONG).show(); } 

    G is my Application class :

     public class G extends Application { 
    L'Android è un fan Android di Google, tutto su telefoni Android, Android Wear, Android Dev e applicazioni Android Games e così via.