Comment analyser la AndroidManifest.xml fichier à l'intérieur d'un .package apk

Cette méthode Java qui s'exécute sur un Android, des documents (ce que j'ai pu interpréter environ) le format binaire de l'AndroidManifest.xml fichier dans le .package apk. La deuxième boîte de code montre comment appeler decompressXML et comment charger le byte[] à partir de l'app package de fichier sur le périphérique. (Il y a des champs dont le but, je ne comprends pas, si vous savez ce qu'ils signifient, dites-moi, je vais mettre à jour l'info.)

//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 array 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("  Unrecognized 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 array
//  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

Cette méthode lit la AndroidManifest dans un byte[] pour le traitement:

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 plupart des applications sont stockées dans /system/app qui est lisible sans racine de mon Evo, d'autres applications sont dans /data/app que j'ai eu besoin de la racine de voir. Le 'chemin' argument ci-dessus serait quelque chose comme: "/system/app/Météo.apk"

Vous pouvez utiliser axml2xml.pl outil développé il y a un moment dans android-aléatoire projet. Il va générer le texte du fichier de manifeste (AndroidManifest.xml) à partir de binaires.

Je dis "textuelle" et non pas "original" parce que comme beaucoup de rétro-ingénierie d'outils de celui-ci n'est pas parfaite et le résultat ne être complet. Je présume que soit il n'a jamais été complète ou tout simplement pas compatible (avec les nouveaux binaires schéma de codage). Quelle que soit la raison, axml2xml.pl outil ne sera pas en mesure d'extraire toutes les valeurs d'attribut correctement. Ces attributs sont minSdkVersion, targetSdkVersion et, fondamentalement, tous les attributs que sont le référencement des ressources (comme les chaînes, les icônes, etc.), c'est à dire uniquement les noms de classe (d'activités, de services, etc.) sont extraites correctement.

Cependant, vous pouvez toujours trouver ces informations manquantes par l'exécution de aapt outil sur l'original de l'application Android fichier (.apk):

aapt l-un <someapp.apk>

apk-analyseur, https://github.com/caoqianli/apk-parser, un léger impl pour java, avec aucune dépendance pour aapt ou d'autres binarys, est bon pour analyser binaire des fichiers xml, et d'autres apk infos.

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();

Dans le cas où c'est utile, voici une version C++ de la Java extrait posté par 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 array 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("  Unrecognized 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 array
//  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);
}
};

pour référence, voici ma version de la Ribo du code. La principale différence est que decompressXML() renvoie directement une Chaîne de caractères, qui pour ma part était plus approprié d'utilisation.

NOTE: mon seul but dans l'utilisation de Ribo la solution était d'aller chercher un .Fichier APK de la version publiée à partir du fichier Manifeste XML, et je confirme que, pour cet effet, il fonctionne à merveille.

MODIFIER [2013-03-16]: Il fonctionne à merveille SI la version est définie en tant que texte brut, mais si elle est définie pour faire référence à une Ressource XML, il va se montrer comme des "Ressources 0x1' par exemple. Dans ce cas, vous devrez probablement le couple de cette solution à une autre solution qui permettra d'aller chercher la bonne chaîne de référence de la ressource.

/**
* 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 array 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, "  Unrecognized 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 array
* @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 array
*   at offset off.
* 
* @param arr Byte array 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

Espère que cela peut aider d'autres personnes aussi.

J'ai trouvé le AXMLPrinter2, une application Java à la Android4Me projet de beaux travaux sur la AndroidManifest.xml que j'ai eu (et imprime le XML dans un bien formaté façon).
http://code.google.com/p/android4me/downloads/detail?name=AXMLPrinter2.jar

Une note.. (et le code sur cette réponse de Ribo) ne semble pas gérer tous les compilées fichier XML que je suis venu à travers. J'en ai trouvé un où les cordes ont été enregistrés avec un octet par caractère, plutôt que le double octet de format qu'elle suppose.

J'ai été en cours d'exécution avec la Ribo code affiché ci-dessus pour plus d'un an, et il nous a bien servi. Avec les récentes mises à jour (Gradle 3.x) mais, je n'étais plus en mesure d'analyser les AndroidManifest.xml je commençais à l'indice hors limites erreurs, et en général, il n'était plus en mesure d'analyser le fichier.

Mise à jour: maintenant, je crois que nos questions a été mise à jour pour Gradle 3.x. Cet article décrit comment AirWatch a eu des problèmes et peut être fixé à l'aide d'un Gradle paramètre à utiliser aapt au lieu de aapt2 AirWatch semble être incompatible avec Android Plugin Gradle 3.0.0-beta1

Dans la recherche, je suis tombé sur ce projet open source, et il est maintenu et j'ai été en mesure de faire le point et de lire mes deux vieux Apk que j'ai pu précédemment analysé, et le nouveau Apk que la logique de Ribo a jeté les exceptions

https://github.com/xgouchet/AXML

De son exemple, c'est ce que je fais

  zf = new ZipFile(apkFile);
//Getting the manifest
ZipEntry entry = zf.getEntry("AndroidManifest.xml");
InputStream is = zf.getInputStream(entry);
//Read our manifest Document
Document manifestDoc = new CompressedXmlParser().parseDOM(is);
//Make sure we got a doc, and that it has children
if (null != manifestDoc && manifestDoc.getChildNodes().getLength() > 0) {
//
Node firstNode = manifestDoc.getFirstChild();
//Now get the attributes out of the node
NamedNodeMap nodeMap = firstNode.getAttributes();
//Finally to a point where we can read out our values
versionName = nodeMap.getNamedItem("android:versionName").getNodeValue();
versionCode = nodeMap.getNamedItem("android:versionCode").getNodeValue();
}