PHP 解析 APK 中的 AndroidManifest.xml

左手的ㄟ右手 2022-08-26 14:23 156阅读 0赞

也是网上找的别人的代码

测试可用

<?php  
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
 \* Android APK File Parser  
 \* Author: Katana  
 \* Version: v0.1  
 \* Web: http://www.win-ing.cn  
 \*  
 \* 功能：解析安卓apk包中的压缩XML文件，还原和读取XML内容  
 \*  
 \* 依赖功能：需要PHP的ZIP包函数支持。  
 \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
   
class ApkParser\{  
//----------------------  
// 公共函数，供外部调用  
//----------------------  
    public function open($apk\_file, $xml\_file='AndroidManifest.xml')\{  
        $zip = new ZipArchive;  
        if ($zip->open($apk\_file) === TRUE) \{  
            $xml = $zip->getFromName($xml\_file);  
            $zip->close();  
            if ($xml)\{  
                try \{  
                    return $this->parseString($xml);  
                \}catch (Exception $e)\{  
                \}  
            \}  
        \}  
        return false;  
    \}  
   
    public function parseString($xml)\{  
        $this->xml = $xml;  
        $this->length = strlen($xml);  
   
        $this->root = $this->parseBlock(self::AXML\_FILE);  
        return true;  
    \}  
   
    public function getXML($node=NULL, $lv=-1)\{  
        if ($lv == -1) $node = $this->root;  
        if (!$node) return '';  
   
        if ($node\['type'\] == self::END\_TAG) $lv--;  
        $xml = ($node\['line'\] == 0 || $node\['line'\] == $this->line) ? '' : "\\n".str\_repeat('  ', $lv);  
        $xml .= $node\['tag'\];  
        $this->line = $node\['line'\];  
        foreach ($node\['child'\] as $c)\{  
            $xml .= $this->getXML($c, $lv+1);  
        \}  
        return $xml;  
    \}  
   
    public function getPackage()\{  
        return $this->getAttribute('manifest', 'package');  
    \}  
   
    public function getVersionName()\{  
        return $this->getAttribute('manifest', 'android:versionName');  
    \}  
   
    public function getVersionCode()\{  
        return $this->getAttribute('manifest', 'android:versionCode');  
    \}  
   
    public function getAppName()\{  
        return $this->getAttribute('manifest/application', 'android:name');  
    \}  
   
    public function getMainActivity()\{  
        for ($id=0; true; $id++)\{  
            $act = $this->getAttribute("manifest/application/activity\[\{$id\}\]/intent-filter/action", 'android:name');  
            if (!$act) break;  
            if ($act == 'android.intent.action.MAIN') return $this->getActivity($id);  
        \}  
        return NULL;  
    \}  
   
    public function getActivity($idx=0)\{  
        $idx = intval($idx);  
        return $this->getAttribute("manifest/application/activity\[\{$idx\}\]", 'android:name');  
    \}  
   
    public function getAttribute($path, $name)\{  
        $r = $this->getElement($path);  
        if (is\_null($r)) return NULL;  
   
        if (isset($r\['attrs'\]))\{  
            foreach ($r\['attrs'\] as $a)\{  
                if ($a\['ns\_name'\] == $name) return $this->getAttributeValue($a);  
            \}  
        \}  
        return NULL;  
    \}  
   
//----------------------  
// 类型常量定义  
//----------------------  
    const AXML\_FILE             = 0x00080003;  
    const STRING\_BLOCK          = 0x001C0001;  
    const RESOURCEIDS           = 0x00080180;  
    const START\_NAMESPACE       = 0x00100100;  
    const END\_NAMESPACE         = 0x00100101;  
    const START\_TAG             = 0x00100102;  
    const END\_TAG               = 0x00100103;  
    const TEXT                  = 0x00100104;  
   
    const TYPE\_NULL             =0;  
    const TYPE\_REFERENCE        =1;  
    const TYPE\_ATTRIBUTE        =2;  
    const TYPE\_STRING           =3;  
    const TYPE\_FLOAT            =4;  
    const TYPE\_DIMENSION        =5;  
    const TYPE\_FRACTION         =6;  
    const TYPE\_INT\_DEC          =16;  
    const TYPE\_INT\_HEX          =17;  
    const TYPE\_INT\_BOOLEAN      =18;  
    const TYPE\_INT\_COLOR\_ARGB8  =28;  
    const TYPE\_INT\_COLOR\_RGB8   =29;  
    const TYPE\_INT\_COLOR\_ARGB4  =30;  
    const TYPE\_INT\_COLOR\_RGB4   =31;  
   
    const UNIT\_MASK             = 15;  
    private static $RADIX\_MULTS = array(0.00390625, 3.051758E-005, 1.192093E-007, 4.656613E-010);  
    private static $DIMENSION\_UNITS = array("px","dip","sp","pt","in","mm","","");  
    private static $FRACTION\_UNITS  = array("%","%p","","","","","","");  
   
    private $xml='';  
    private $length = 0;  
    private $stringCount = 0;  
    private $styleCount  = 0;  
    private $stringTab = array();  
    private $styleTab  = array();  
    private $resourceIDs = array();  
    private $ns = array();  
    private $cur\_ns = NULL;  
    private $root = NULL;  
    private $line = 0;  
   
//----------------------  
// 内部私有函数  
//----------------------  
    private function getElement($path)\{  
        if (!$this->root) return NULL;  
        $ps = explode('/', $path);  
        $r  = $this->root;  
        foreach ($ps as $v)\{  
            if (preg\_match('/(\[^\\\[\]+)\\\[(\[0-9\]+)\\\]$/', $v, $ms))\{  
                $v = $ms\[1\];  
                $off = $ms\[2\];  
            \}else \{  
                $off = 0;  
            \}  
            foreach ($r\['child'\] as $c)\{  
                if ($c\['type'\] == self::START\_TAG && $c\['ns\_name'\] == $v)\{  
                    if ($off == 0)\{  
                        $r = $c; continue 2;  
                    \}else \{  
                        $off--;  
                    \}  
                \}  
            \}  
            // 没有找到节点  
            return NULL;  
        \}  
        return $r;  
    \}  
   
    private function parseBlock($need = 0)\{  
        $o = 0;  
        $type = $this->get32($o);  
        if ($need && $type != $need) throw new Exception('Block Type Error', 1);  
        $size = $this->get32($o);  
        if ($size < 8 || $size > $this->length) throw new Exception('Block Size Error', 2);  
        $left = $this->length - $size;  
   
        $props = false;  
        switch ($type)\{  
            case self::AXML\_FILE:  
                $props = array(  
                    'line' => 0,  
                    'tag' => '<?xml version="1.0" encoding="utf-8"?>'  
                );  
            break;  
            case self::STRING\_BLOCK:  
                $this->stringCount = $this->get32($o);  
                $this->styleCount  = $this->get32($o);  
                $o += 4;  
                $strOffset = $this->get32($o);  
                $styOffset = $this->get32($o);  
                $strListOffset = $this->get32array($o, $this->stringCount);  
                $styListOffset = $this->get32array($o, $this->styleCount);  
                $this->stringTab = $this->stringCount > 0 ? $this->getStringTab($strOffset, $strListOffset) : array();  
                $this->styleTab  = $this->styleCount > 0 ? $this->getStringTab($styOffset, $styListOffset) : array();  
                $o = $size;  
            break;  
            case self::RESOURCEIDS:  
                $count = $size / 4 - 2;  
                $this->resourceIDs = $this->get32array($o, $count);  
            break;  
            case self::START\_NAMESPACE:  
                $o += 8;  
                $prefix = $this->get32($o);  
                $uri = $this->get32($o);  
   
                if (empty($this->cur\_ns))\{  
                    $this->cur\_ns = array();  
                    $this->ns\[\] = &$this->cur\_ns;  
                \}  
                $this->cur\_ns\[$uri\] = $prefix;  
            break;  
            case self::END\_NAMESPACE:  
                $o += 8;  
                $prefix = $this->get32($o);  
                $uri = $this->get32($o);  
   
                if (empty($this->cur\_ns)) break;  
                unset($this->cur\_ns\[$uri\]);  
            break;  
            case self::START\_TAG:  
                $line = $this->get32($o);  
   
                $o += 4;  
                $attrs = array();  
                $props = array(  
                    'line' => $line,  
                    'ns' => $this->getNameSpace($this->get32($o)),  
                    'name' => $this->getString($this->get32($o)),  
                    'flag' => $this->get32($o),  
                    'count' => $this->get16($o),  
                    'id' => $this->get16($o)-1,  
                    'class' => $this->get16($o)-1,  
                    'style' => $this->get16($o)-1,  
                    'attrs' => &$attrs  
                );  
                $props\['ns\_name'\] = $props\['ns'\].$props\['name'\];  
                for ($i=0; $i < $props\['count'\]; $i++)\{  
                    $a = array(  
                        'ns' => $this->getNameSpace($this->get32($o)),  
                        'name' => $this->getString($this->get32($o)),  
                        'val\_str' => $this->get32($o),  
                        'val\_type' => $this->get32($o),  
                        'val\_data' => $this->get32($o)  
                    );  
                    $a\['ns\_name'\] = $a\['ns'\].$a\['name'\];  
                    $a\['val\_type'\] >>= 24;  
                    $attrs\[\] = $a;  
                \}  
                // 处理TAG字符串  
                $tag = "<\{$props\['ns\_name'\]\}";  
                foreach ($this->cur\_ns as $uri => $prefix)\{  
                    $uri = $this->getString($uri);  
                    $prefix = $this->getString($prefix);  
                    $tag .= " xmlns:\{$prefix\}=\\"\{$uri\}\\"";  
                \}  
                foreach ($props\['attrs'\] as $a)\{  
                    $tag .= " \{$a\['ns\_name'\]\}=\\"".  
                            $this->getAttributeValue($a).  
                            '"';  
                \}  
                $tag .= '>';  
                $props\['tag'\] = $tag;  
   
                unset($this->cur\_ns);  
                $this->cur\_ns = array();  
                $this->ns\[\] = &$this->cur\_ns;  
                $left = -1;  
            break;  
            case self::END\_TAG:  
                $line = $this->get32($o);  
                $o += 4;  
                $props = array(  
                    'line' => $line,  
                    'ns' => $this->getNameSpace($this->get32($o)),  
                    'name' => $this->getString($this->get32($o))  
                );  
                $props\['ns\_name'\] = $props\['ns'\].$props\['name'\];  
                $props\['tag'\] = "</\{$props\['ns\_name'\]\}>";  
                if (count($this->ns) > 1)\{  
                    array\_pop($this->ns);  
                    unset($this->cur\_ns);  
                    $this->cur\_ns = array\_pop($this->ns);  
                    $this->ns\[\] = &$this->cur\_ns;  
                \}  
            break;  
            case self::TEXT:  
                $o += 8;  
                $props = array(  
                    'tag' => $this->getString($this->get32($o))  
                );  
                $o += 8;  
            break;  
            default:  
                throw new Exception('Block Type Error', 3);  
            break;  
        \}  
   
        $this->skip($o);  
        $child = array();  
        while ($this->length > $left)\{  
            $c = $this->parseBlock();  
            if ($props && $c) $child\[\] = $c;  
            if ($left == -1 && $c\['type'\] == self::END\_TAG)\{  
                $left = $this->length;  
                break;  
            \}  
        \}  
        if ($this->length != $left) throw new Exception('Block Overflow Error', 4);  
        if ($props)\{  
            $props\['type'\] = $type;  
            $props\['size'\] = $size;  
            $props\['child'\] = $child;  
            return $props;  
        \}else \{  
            return false;  
        \}  
    \}  
   
    private function getAttributeValue($a)\{  
        $type = &$a\['val\_type'\];  
        $data = &$a\['val\_data'\];  
        switch ($type)\{  
            case self::TYPE\_STRING:  
                return $this->getString($a\['val\_str'\]);  
            case self::TYPE\_ATTRIBUTE:  
                return sprintf('?%s%08X', self::\_getPackage($data), $data);  
            case self::TYPE\_REFERENCE:  
                return sprintf('@%s%08X', self::\_getPackage($data), $data);  
            case self::TYPE\_INT\_HEX:  
                return sprintf('0x%08X', $data);  
            case self::TYPE\_INT\_BOOLEAN:  
                return ($data != 0 ? 'true' : 'false');  
            case self::TYPE\_INT\_COLOR\_ARGB8:  
            case self::TYPE\_INT\_COLOR\_RGB8:  
            case self::TYPE\_INT\_COLOR\_ARGB4:  
            case self::TYPE\_INT\_COLOR\_RGB4:  
                return sprintf('\#%08X', $data);  
            case self::TYPE\_DIMENSION:  
                return $this->\_complexToFloat($data).self::$DIMENSION\_UNITS\[$data & self::UNIT\_MASK\];  
            case self::TYPE\_FRACTION:  
                return $this->\_complexToFloat($data).self::$FRACTION\_UNITS\[$data & self::UNIT\_MASK\];  
            case self::TYPE\_FLOAT:  
                return $this->\_int2float($data);  
        \}  
        if ($type >=self::TYPE\_INT\_DEC && $type < self::TYPE\_INT\_COLOR\_ARGB8)\{  
            return (string)$data;  
        \}  
        return sprintf('<0x%X, type 0x%02X>', $data, $type);  
    \}  
   
    private function \_complexToFloat($data)\{  
        return (float)($data & 0xFFFFFF00) \* self::$RADIX\_MULTS\[($data>>4) & 3\];  
    \}  
    private function \_int2float($v) \{  
        $x = ($v & ((1 << 23) - 1)) + (1 << 23) \* ($v >> 31 | 1);  
        $exp = ($v >> 23 & 0xFF) - 127;  
        return $x \* pow(2, $exp - 23);  
    \}  
    private static function \_getPackage($data)\{  
        return ($data >> 24 == 1) ? 'android:' : '';  
    \}  
   
    private function getStringTab($base, $list)\{  
        $tab = array();  
        foreach ($list as $off)\{  
            $off += $base;  
            $len = $this->get16($off);  
            $mask = ($len >> 0x8) & 0xFF;  
            $len = $len & 0xFF;  
            if ($len == $mask)\{  
                if ($off + $len > $this->length) throw new Exception('String Table Overflow', 11);  
                $tab\[\] = substr($this->xml, $off, $len);  
            \}else \{  
                if ($off + $len \* 2 > $this->length) throw new Exception('String Table Overflow', 11);  
                $str = substr($this->xml, $off, $len \* 2);  
                $tab\[\] = mb\_convert\_encoding($str, 'UTF-8', 'UCS-2LE');  
            \}  
        \}  
        return $tab;  
    \}  
    private function getString($id)\{  
        if ($id > -1 && $id < $this->stringCount)\{  
            return $this->stringTab\[$id\];  
        \}else \{  
            return '';  
        \}  
    \}  
    private function getNameSpace($uri)\{  
        for ($i=count($this->ns); $i > 0; )\{  
            $ns = $this->ns\[--$i\];  
            if (isset($ns\[$uri\]))\{  
                $ns = $this->getString($ns\[$uri\]);  
                if (!empty($ns)) $ns .= ':';  
                return $ns;  
            \}  
        \}  
        return '';  
    \}  
    private function get32(&$off)\{  
        $int = unpack('V', substr($this->xml, $off, 4));  
        $off += 4;  
        return array\_shift($int);  
    \}  
    private function get32array(&$off, $size)\{  
        if ($size <= 0) return NULL;  
        $arr = unpack('V\*', substr($this->xml, $off, 4 \* $size));  
        if (count($arr) != $size) throw new Exception('Array Size Error', 10);  
        $off += 4 \* $size;  
        return $arr;  
    \}  
    private function get16(&$off)\{  
        $int = unpack('v', substr($this->xml, $off, 2));  
        $off += 2;  
        return array\_shift($int);  
    \}  
    private function skip($size)\{  
        $this->xml = substr($this->xml, $size);  
        $this->length -= $size;  
    \}  
\}  
?>