Permalink
Switch branches/tags
Nothing to show
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
785 lines (720 sloc) 19 KB
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import (
"encoding/xml"
"fmt"
"io"
"sort"
"strconv"
"strings"
"unicode/utf16"
)
// binaryXML converts XML into Android's undocumented binary XML format.
//
// The best source of information on this format seems to be the source code
// in AOSP frameworks-base. Android "resource" types seem to describe the
// encoded bytes, in particular:
//
// ResChunk_header
// ResStringPool_header
// ResXMLTree_node
//
// These are defined in:
//
// https://android.googlesource.com/platform/frameworks/base/+/master/include/androidfw/ResourceTypes.h
//
// The rough format of the file is a resource chunk containing a sequence of
// chunks. Each chunk is made up of a header and a body. The header begins with
// the contents of the ResChunk_header struct, which includes the size of both
// the header and the body.
//
// Both the header and body are 4-byte aligned.
//
// Values are encoded as little-endian.
//
// The android source code for encoding is done in the aapt tool. Its source
// code lives in AOSP:
//
// https://android.googlesource.com/platform/frameworks/base.git/+/master/tools/aapt
//
// A sample layout:
//
// File Header (ResChunk_header, type XML)
// Chunk: String Pool (type STRING_POOL)
// Sequence of strings, each with the format:
// uint16 length
// uint16 extended_length -- only if top bit set on length
// UTF-16LE string
// two zero bytes
// Resource Map
// The [i]th 4-byte entry in the resource map corresponds with
// the [i]th string from the string pool. The 4-bytes are a
// Resource ID constant defined:
// http://developer.android.com/reference/android/R.attr.html
// This appears to be a way to map strings onto enum values.
// Chunk: Namespace Start (ResXMLTree_node; ResXMLTree_namespaceExt)
// Chunk: Element Start
// ResXMLTree_node
// ResXMLTree_attrExt
// ResXMLTree_attribute (repeated attributeCount times)
// Chunk: Element End
// (ResXMLTree_node; ResXMLTree_endElementExt)
// ...
// Chunk: Namespace End
func binaryXML(r io.Reader) ([]byte, error) {
lr := &lineReader{r: r}
d := xml.NewDecoder(lr)
pool := new(binStringPool)
depth := 0
elements := []chunk{}
namespaceEnds := make(map[int][]binEndNamespace)
for {
line := lr.line(d.InputOffset())
tok, err := d.Token()
if err != nil {
if err == io.EOF {
break
}
return nil, err
}
switch tok := tok.(type) {
case xml.StartElement:
// uses-sdk is synthesized by the writer, disallow declaration in manifest.
if tok.Name.Local == "uses-sdk" {
return nil, fmt.Errorf("unsupported manifest tag <uses-sdk .../>")
} else if tok.Name.Local == "application" {
// synthesize <uses-sdk/> before handling <application> token
attr := xml.Attr{
Name: xml.Name{
Space: "http://schemas.android.com/apk/res/android",
Local: "minSdkVersion",
},
Value: "15",
}
ba, err := pool.getAttr(attr)
if err != nil {
return nil, fmt.Errorf("failed to synthesize attr minSdkVersion=\"15\"")
}
elements = append(elements,
&binStartElement{
line: line - 1, // current testing strategy is not friendly to synthesized tags, -1 for would-be location
ns: pool.getNS(""),
name: pool.get("uses-sdk"),
attr: []*binAttr{ba},
},
&binEndElement{
line: line - 1,
ns: pool.getNS(""),
name: pool.get("uses-sdk"),
})
}
// Intercept namespace definitions.
var attr []*binAttr
for _, a := range tok.Attr {
if a.Name.Space == "xmlns" {
elements = append(elements, binStartNamespace{
line: line,
prefix: pool.get(a.Name.Local),
url: pool.get(a.Value),
})
namespaceEnds[depth] = append([]binEndNamespace{{
line: line,
prefix: pool.get(a.Name.Local),
url: pool.get(a.Value),
}}, namespaceEnds[depth]...)
continue
}
ba, err := pool.getAttr(a)
if err != nil {
return nil, fmt.Errorf("%d: %s: %v", line, a.Name.Local, err)
}
attr = append(attr, ba)
}
depth++
elements = append(elements, &binStartElement{
line: line,
ns: pool.getNS(tok.Name.Space),
name: pool.get(tok.Name.Local),
attr: attr,
})
case xml.EndElement:
elements = append(elements, &binEndElement{
line: line,
ns: pool.getNS(tok.Name.Space),
name: pool.get(tok.Name.Local),
})
depth--
if nsEnds := namespaceEnds[depth]; len(nsEnds) > 0 {
delete(namespaceEnds, depth)
for _, nsEnd := range nsEnds {
elements = append(elements, nsEnd)
}
}
case xml.CharData:
// The aapt tool appears to "compact" leading and
// trailing whitepsace. See XMLNode::removeWhitespace in
// https://android.googlesource.com/platform/frameworks/base.git/+/master/tools/aapt/XMLNode.cpp
if len(tok) == 0 {
continue
}
start, end := 0, len(tok)
for start < len(tok) && isSpace(tok[start]) {
start++
}
for end > start && isSpace(tok[end-1]) {
end--
}
if start == end {
continue // all whitespace, skip it
}
// Preserve one character of whitespace.
if start > 0 {
start--
}
if end < len(tok) {
end++
}
elements = append(elements, &binCharData{
line: line,
data: pool.get(string(tok[start:end])),
})
case xml.Comment:
// Ignored by Anroid Binary XML format.
case xml.ProcInst:
// Ignored by Anroid Binary XML format?
case xml.Directive:
// Ignored by Anroid Binary XML format.
default:
return nil, fmt.Errorf("apk: unexpected token: %v (%T)", tok, tok)
}
}
sortPool(pool)
for _, e := range elements {
if e, ok := e.(*binStartElement); ok {
sortAttr(e, pool)
}
}
resMap := &binResMap{pool}
size := 8 + pool.size() + resMap.size()
for _, e := range elements {
size += e.size()
}
b := make([]byte, 0, size)
b = appendHeader(b, headerXML, size)
b = pool.append(b)
b = resMap.append(b)
for _, e := range elements {
b = e.append(b)
}
return b, nil
}
func isSpace(b byte) bool {
switch b {
case '\t', '\n', '\v', '\f', '\r', ' ', 0x85, 0xA0:
return true
}
return false
}
type headerType uint16
const (
headerXML headerType = 0x0003
headerStringPool = 0x0001
headerResourceMap = 0x0180
headerStartNamespace = 0x0100
headerEndNamespace = 0x0101
headerStartElement = 0x0102
headerEndElement = 0x0103
headerCharData = 0x0104
)
func appendU16(b []byte, v uint16) []byte {
return append(b, byte(v), byte(v>>8))
}
func appendU32(b []byte, v uint32) []byte {
return append(b, byte(v), byte(v>>8), byte(v>>16), byte(v>>24))
}
func appendHeader(b []byte, typ headerType, size int) []byte {
b = appendU16(b, uint16(typ))
b = appendU16(b, 8)
b = appendU16(b, uint16(size))
b = appendU16(b, 0)
return b
}
// Attributes of the form android:key are mapped to resource IDs, which are
// embedded into the Binary XML format.
//
// http://developer.android.com/reference/android/R.attr.html
var resourceCodes = map[string]uint32{
"versionCode": 0x0101021b,
"versionName": 0x0101021c,
"minSdkVersion": 0x0101020c,
"windowFullscreen": 0x0101020d,
"theme": 0x01010000,
"label": 0x01010001,
"hasCode": 0x0101000c,
"debuggable": 0x0101000f,
"name": 0x01010003,
"screenOrientation": 0x0101001e,
"configChanges": 0x0101001f,
"value": 0x01010024,
}
// http://developer.android.com/reference/android/R.attr.html#configChanges
var configChanges = map[string]uint32{
"mcc": 0x0001,
"mnc": 0x0002,
"locale": 0x0004,
"touchscreen": 0x0008,
"keyboard": 0x0010,
"keyboardHidden": 0x0020,
"navigation": 0x0040,
"orientation": 0x0080,
"screenLayout": 0x0100,
"uiMode": 0x0200,
"screenSize": 0x0400,
"smallestScreenSize": 0x0800,
"layoutDirection": 0x2000,
"fontScale": 0x40000000,
}
// http://developer.android.com/reference/android/R.attr.html#screenOrientation
var screenOrientation = map[string]int{
"unspecified": -1,
"landscape": 0,
"portrait": 1,
"user": 2,
"behind": 3,
"sensor": 4,
"nosensor": 5,
"sensorLandscape": 6,
"sensorPortrait": 7,
"reverseLandscape": 8,
"reversePortrait": 9,
"fullSensor": 10,
"userLandscape": 11,
"userPortrait": 12,
"fullUser": 13,
"locked": 14,
}
// reference is an alias used to write out correct type in bin.
type reference uint32
// http://developer.android.com/reference/android/R.style.html
var theme = map[string]reference{
"Theme": 0x01030005,
"Theme_NoTitleBar": 0x01030006,
"Theme_NoTitleBar_Fullscreen": 0x01030007,
"Theme_Black": 0x01030008,
"Theme_Black_NoTitleBar": 0x01030009,
"Theme_Black_NoTitleBar_Fullscreen": 0x0103000a,
"Theme_Light": 0x0103000c,
"Theme_Light_NoTitleBar": 0x0103000d,
"Theme_Light_NoTitleBar_Fullscreen": 0x0103000e,
"Theme_Translucent": 0x0103000f,
"Theme_Translucent_NoTitleBar": 0x01030010,
"Theme_Translucent_NoTitleBar_Fullscreen": 0x01030011,
}
type lineReader struct {
off int64
lines []int64
r io.Reader
}
func (r *lineReader) Read(p []byte) (n int, err error) {
n, err = r.r.Read(p)
for i := 0; i < n; i++ {
if p[i] == '\n' {
r.lines = append(r.lines, r.off+int64(i))
}
}
r.off += int64(n)
return n, err
}
func (r *lineReader) line(pos int64) int {
return sort.Search(len(r.lines), func(i int) bool {
return pos < r.lines[i]
}) + 1
}
type bstring struct {
ind uint32
str string
enc []byte // 2-byte length, utf16le, 2-byte zero
}
type chunk interface {
size() int
append([]byte) []byte
}
type binResMap struct {
pool *binStringPool
}
func (p *binResMap) append(b []byte) []byte {
b = appendHeader(b, headerResourceMap, p.size())
for _, bstr := range p.pool.s {
c, ok := resourceCodes[bstr.str]
if !ok {
break
}
b = appendU32(b, c)
}
return b
}
func (p *binResMap) size() int {
count := 0
for _, bstr := range p.pool.s {
if _, ok := resourceCodes[bstr.str]; !ok {
break
}
count++
}
return 8 + 4*count
}
type binStringPool struct {
s []*bstring
m map[string]*bstring
}
func (p *binStringPool) get(str string) *bstring {
if p.m == nil {
p.m = make(map[string]*bstring)
}
res := p.m[str]
if res != nil {
return res
}
res = &bstring{
ind: uint32(len(p.s)),
str: str,
}
p.s = append(p.s, res)
p.m[str] = res
if len(str)>>16 > 0 {
panic(fmt.Sprintf("string lengths over 1<<15 not yet supported, got len %d for string that starts %q", len(str), str[:100]))
}
strUTF16 := utf16.Encode([]rune(str))
res.enc = appendU16(nil, uint16(len(strUTF16)))
for _, w := range strUTF16 {
res.enc = appendU16(res.enc, w)
}
res.enc = appendU16(res.enc, 0)
return res
}
func (p *binStringPool) getNS(ns string) *bstring {
if ns == "" {
// Register empty string for inclusion in output (like aapt),
// but do not reference it from namespace elements.
p.get("")
return nil
}
return p.get(ns)
}
func (p *binStringPool) getAttr(attr xml.Attr) (*binAttr, error) {
a := &binAttr{
ns: p.getNS(attr.Name.Space),
name: p.get(attr.Name.Local),
}
if attr.Name.Space != "http://schemas.android.com/apk/res/android" {
a.data = p.get(attr.Value)
return a, nil
}
// Some android attributes have interesting values.
switch attr.Name.Local {
case "versionCode", "minSdkVersion":
v, err := strconv.Atoi(attr.Value)
if err != nil {
return nil, err
}
a.data = int(v)
case "hasCode", "debuggable":
v, err := strconv.ParseBool(attr.Value)
if err != nil {
return nil, err
}
a.data = v
case "configChanges":
v := uint32(0)
for _, c := range strings.Split(attr.Value, "|") {
v |= configChanges[c]
}
a.data = v
case "screenOrientation":
v := 0
for _, c := range strings.Split(attr.Value, "|") {
v |= screenOrientation[c]
}
a.data = v
case "theme":
v := attr.Value
// strip prefix if present as only platform themes are supported
if idx := strings.Index(attr.Value, "/"); idx != -1 {
v = v[idx+1:]
}
v = strings.Replace(v, ".", "_", -1)
a.data = theme[v]
default:
a.data = p.get(attr.Value)
}
return a, nil
}
const stringPoolPreamble = 0 +
8 + // chunk header
4 + // string count
4 + // style count
4 + // flags
4 + // strings start
4 + // styles start
0
func (p *binStringPool) unpaddedSize() int {
strLens := 0
for _, s := range p.s {
strLens += len(s.enc)
}
return stringPoolPreamble + 4*len(p.s) + strLens
}
func (p *binStringPool) size() int {
size := p.unpaddedSize()
size += size % 0x04
return size
}
// overloaded for testing.
var (
sortPool = func(p *binStringPool) {
sort.Sort(p)
// Move resourceCodes to the front.
s := make([]*bstring, 0)
m := make(map[string]*bstring)
for str := range resourceCodes {
bstr := p.m[str]
if bstr == nil {
continue
}
bstr.ind = uint32(len(s))
s = append(s, bstr)
m[str] = bstr
delete(p.m, str)
}
for _, bstr := range p.m {
bstr.ind = uint32(len(s))
s = append(s, bstr)
}
p.s = s
p.m = m
}
sortAttr = func(e *binStartElement, p *binStringPool) {}
)
func (b *binStringPool) Len() int { return len(b.s) }
func (b *binStringPool) Less(i, j int) bool { return b.s[i].str < b.s[j].str }
func (b *binStringPool) Swap(i, j int) {
b.s[i], b.s[j] = b.s[j], b.s[i]
b.s[i].ind, b.s[j].ind = b.s[j].ind, b.s[i].ind
}
func (p *binStringPool) append(b []byte) []byte {
stringsStart := uint32(stringPoolPreamble + 4*len(p.s))
b = appendU16(b, uint16(headerStringPool))
b = appendU16(b, 0x1c) // chunk header size
b = appendU16(b, uint16(p.size()))
b = appendU16(b, 0)
b = appendU32(b, uint32(len(p.s)))
b = appendU32(b, 0) // style count
b = appendU32(b, 0) // flags
b = appendU32(b, stringsStart)
b = appendU32(b, 0) // styles start
off := 0
for _, bstr := range p.s {
b = appendU32(b, uint32(off))
off += len(bstr.enc)
}
for _, bstr := range p.s {
b = append(b, bstr.enc...)
}
for i := p.unpaddedSize() % 0x04; i > 0; i-- {
b = append(b, 0)
}
return b
}
type binStartElement struct {
line int
ns *bstring
name *bstring
attr []*binAttr
}
func (e *binStartElement) size() int {
return 8 + // chunk header
4 + // line number
4 + // comment
4 + // ns
4 + // name
2 + 2 + 2 + // attribute start, size, count
2 + 2 + 2 + // id/class/style index
len(e.attr)*(4+4+4+4+4)
}
func (e *binStartElement) append(b []byte) []byte {
b = appendU16(b, uint16(headerStartElement))
b = appendU16(b, 0x10) // chunk header size
b = appendU16(b, uint16(e.size()))
b = appendU16(b, 0)
b = appendU32(b, uint32(e.line))
b = appendU32(b, 0xffffffff) // comment
if e.ns == nil {
b = appendU32(b, 0xffffffff)
} else {
b = appendU32(b, e.ns.ind)
}
b = appendU32(b, e.name.ind)
b = appendU16(b, 0x14) // attribute start
b = appendU16(b, 0x14) // attribute size
b = appendU16(b, uint16(len(e.attr)))
b = appendU16(b, 0) // ID index (none)
b = appendU16(b, 0) // class index (none)
b = appendU16(b, 0) // style index (none)
for _, a := range e.attr {
b = a.append(b)
}
return b
}
type binAttr struct {
ns *bstring
name *bstring
data interface{} // either int (INT_DEC) or *bstring (STRING)
}
func (a *binAttr) append(b []byte) []byte {
if a.ns != nil {
b = appendU32(b, a.ns.ind)
} else {
b = appendU32(b, 0xffffffff)
}
b = appendU32(b, a.name.ind)
switch v := a.data.(type) {
case int:
b = appendU32(b, 0xffffffff) // raw value
b = appendU16(b, 8) // size
b = append(b, 0) // unused padding
b = append(b, 0x10) // INT_DEC
b = appendU32(b, uint32(v))
case bool:
b = appendU32(b, 0xffffffff) // raw value
b = appendU16(b, 8) // size
b = append(b, 0) // unused padding
b = append(b, 0x12) // INT_BOOLEAN
if v {
b = appendU32(b, 0xffffffff)
} else {
b = appendU32(b, 0)
}
case uint32:
b = appendU32(b, 0xffffffff) // raw value
b = appendU16(b, 8) // size
b = append(b, 0) // unused padding
b = append(b, 0x11) // INT_HEX
b = appendU32(b, uint32(v))
case reference:
b = appendU32(b, 0xffffffff) // raw value
b = appendU16(b, 8) // size
b = append(b, 0) // unused padding
b = append(b, 0x01) // REFERENCE
b = appendU32(b, uint32(v))
case *bstring:
b = appendU32(b, v.ind) // raw value
b = appendU16(b, 8) // size
b = append(b, 0) // unused padding
b = append(b, 0x03) // STRING
b = appendU32(b, v.ind)
default:
panic(fmt.Sprintf("unexpected attr type: %T (%v)", v, v))
}
return b
}
type binEndElement struct {
line int
ns *bstring
name *bstring
attr []*binAttr
}
func (*binEndElement) size() int {
return 8 + // chunk header
4 + // line number
4 + // comment
4 + // ns
4 // name
}
func (e *binEndElement) append(b []byte) []byte {
b = appendU16(b, uint16(headerEndElement))
b = appendU16(b, 0x10) // chunk header size
b = appendU16(b, uint16(e.size()))
b = appendU16(b, 0)
b = appendU32(b, uint32(e.line))
b = appendU32(b, 0xffffffff) // comment
if e.ns == nil {
b = appendU32(b, 0xffffffff)
} else {
b = appendU32(b, e.ns.ind)
}
b = appendU32(b, e.name.ind)
return b
}
type binStartNamespace struct {
line int
prefix *bstring
url *bstring
}
func (binStartNamespace) size() int {
return 8 + // chunk header
4 + // line number
4 + // comment
4 + // prefix
4 // url
}
func (e binStartNamespace) append(b []byte) []byte {
b = appendU16(b, uint16(headerStartNamespace))
b = appendU16(b, 0x10) // chunk header size
b = appendU16(b, uint16(e.size()))
b = appendU16(b, 0)
b = appendU32(b, uint32(e.line))
b = appendU32(b, 0xffffffff) // comment
b = appendU32(b, e.prefix.ind)
b = appendU32(b, e.url.ind)
return b
}
type binEndNamespace struct {
line int
prefix *bstring
url *bstring
}
func (binEndNamespace) size() int {
return 8 + // chunk header
4 + // line number
4 + // comment
4 + // prefix
4 // url
}
func (e binEndNamespace) append(b []byte) []byte {
b = appendU16(b, uint16(headerEndNamespace))
b = appendU16(b, 0x10) // chunk header size
b = appendU16(b, uint16(e.size()))
b = appendU16(b, 0)
b = appendU32(b, uint32(e.line))
b = appendU32(b, 0xffffffff) // comment
b = appendU32(b, e.prefix.ind)
b = appendU32(b, e.url.ind)
return b
}
type binCharData struct {
line int
data *bstring
}
func (*binCharData) size() int {
return 8 + // chunk header
4 + // line number
4 + // comment
4 + // data
8 // junk
}
func (e *binCharData) append(b []byte) []byte {
b = appendU16(b, uint16(headerCharData))
b = appendU16(b, 0x10) // chunk header size
b = appendU16(b, 0x1c) // size
b = appendU16(b, 0)
b = appendU32(b, uint32(e.line))
b = appendU32(b, 0xffffffff) // comment
b = appendU32(b, e.data.ind)
b = appendU16(b, 0x08)
b = appendU16(b, 0)
b = appendU16(b, 0)
b = appendU16(b, 0)
return b
}