Join FlipAndroid.COM Telegram Group: https://t.me/joinchat/F_aqThGkhwcLzmI49vKAiw


Leer ApplicationManifest de Aplicación de Android (apk) usando .NET

Estoy trabajando en una aplicación (desarrollada con .NET Framework) que gestiona los paquetes de aplicaciones de Android (apk) y el programa tiene que leer el ApplicationManifest.xml que reside dentro del apk. Extraer el archivo de manifiesto del apk no es un problema, porque puedo usar herramientas estándar de zip para extraer todos los archivos de un apk.

Pero la lectura del ApplicationManifest no es posible. Esperaba que contenga datos XML sin procesar, pero de alguna manera está encriptada o codificada.

  • Leer WCF REST fecha de android
  • ¿Cómo puedo Zip y descomprimir una cadena usando GZIPOutputStream que es compatible con .Net?
  • ¿Cómo solucionar este error en Android? Java.net.MalformedURLException: Protocolo no encontrado:
  • El envío de un mensaje GCM (del lado del servidor) falla a menudo - pero lejos de ser siempre
  • Escribir aplicaciones para Android en C # (Xamarin)
  • ¿Cómo utilizo una clave pública RSA generada en C # en Android?
  • ¿Existe alguna manera de utilizar el BCL de .NET Framework para leer los datos XML del ApplicationManifest? ¿O hay una biblioteca para .NET Framework para leer ApplicationManifest?

  • Cómo configurar la apariencia de texto en el archivo de manifiesto de Android?
  • Java.lang.ClassNotFoundException en mi aplicación de Android, pero no tengo ni idea de por qué
  • ¿Cómo especificar qué actividad se inicia al iniciar la aplicación?
  • No se puede usar la notación @string para definir <intento-filtro> en AndroidManifest.xml
  • Habilitar la depuración USB (bajo configuración / aplicaciones / desarrollo) mediante programación desde una aplicación
  • ¿Cómo incrustar un diseño dentro de otro en mi caso?
  • 2 Solutions collect form web for “Leer ApplicationManifest de Aplicación de Android (apk) usando .NET”

    Yo no recomendaría usar el apktool mencionado, ya que no es seguro para la descodificación automática – Yo solía usarlo por la misma razón que usted hizo, pero falló en algunos casos.

    Hay algunas herramientas como axml2xml que se especializan en archivos XML codificados con Android u otras herramientas como Android Asset Packaging Tool (aapt) . También puede codificar un decodificador por su cuenta.

    Axml2xml no es perfecto, por lo que recomendaría ejecutar aapt (incluido en Android SDK) en su apk, ya que imprimir una gran cantidad de información que puede analizar: aapt l -a <your.apk>

    Si quieres implementar código para analizar el Manifiesto, echa un vistazo a la entrada de wiki de ribo :

     // 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 

    Este método lee el AndroidManifest en un byte [] para su procesamiento:

     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 

    En conclusión, recomendaría analizar la salida de aapt (se podría agrupar con su aplicación).

    Afaik, la manera más fácil (y más comúnmente usada) para hacer esto es ejecutar la utilidad apktool como un comando externo y hacer que extraiga el archivo AndroidManifest.xml para usted (si lo necesita en su forma cruda), por ejemplo,

     apktool d -s -f /path/to/the/downloaded/apk/SomeName.apk /path/to/output 

    Que decodificar AndroidManifest.xml y colocarlo en su directorio de salida para que usted pueda leer. Es ejecutable en Windows, OSX y Linux, así que si no te importa algunas dependencias externas en tus aplicaciones .NET.

    FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.