在android系统里，通过复杂的编译过程，会把java源代码生成dex文件，然后在虚拟机里就会加载这个文件运行。那么这个文件的格式是什么样的呢？为什么android不直接使用class文件，而采用这个不一样文件呢？其实它是针对嵌入式系统优化的结果，比如dex文件采用的指令码，并不是java的标准虚拟机指令，而是自己独立成一套。如果有自己的编译系统，可以不生成class文件，直接生成dex文件。还有dex文件是共用很多类名称、常量字符串，导致它的体积比较小，运行效率比较高。归根到底，就是它采用了基于寄存器的虚拟机实现。
接着来分析Dex的文件头，如下：
| 偏移 | 大小 | 说明 |
| magic | 8 | 魔数占4个字节，版本占4个字节。 |
| checksum | 4 | 检验码 |
| signature | 20 | SHA-1签名 |
| file_size | 4 | 文件总长有多少个字节 |
| header_size | 4 | 文件头的长度。 |
| endian_tag | 4 | 标识字节顺序的常量。 uintENDIAN_CONSTANT = 0x12345678; uintREVERSE_ENDIAN_CONSTANT = 0x78563412; 根据这个常量可以判断文件是否交换了字节顺序。 缺省情况下，使用小端格式。 |
| link_size | 4 | 连接段的大小，如果为0就表示是静态连接。 |
| link_off | 4 | 连接段的开始位置，从本文件头开始算起。如果连接段的大小为0，这里也是0。 |
| map_off | 4 | map数据开始位置。 |
| string_ids_size | 4 | 字符串列表的字符串个数。 |
| string_ids_off | 4 | 字符串列表的开始位置。 |
| type_ids_size | 4 | 类型列表里类型个数。 |
| type_ids_off | 4 | 类型列表开始位置。 |
| proto_ids_size | 4 | 原型列表个数。 |
| proto_ids_off | 4 | 原型列表开始位置。 |
| field_ids_size | 4 | 字段列表个数。 |
| field_ids_off | 4 | 字段列表开始位置。 |
| method_ids_size | 4 | 方法列表个数。 |
| method_ids_off | 4 | 方法列表的开始位置。 |
| class_defs_size | 4 | 类定义的个数。 |
| class_defs_off | 4 | 类定义列表开始位置。 |
| data_size | 4 | 数据段的大小，必须以4字节对齐。 |
| data_off | 4 | 数据段的开始位置。 |
魔数字段，主要就是Dex文件的标识符，它占用4个字节，在目前的源码里是 “dex\n”，它的作用是用来区别其它文件的，比如有一个文件也叫Dex结尾的文件，就可以认为它是Davlik虚拟机运行的文件吗？当然不行，因此这四个字节，就起到与别的结尾也是Dex文件的区分。还有Davlik虚拟机也有优化的Dex，也是通过个字段来区分的，当它是优化的Dex文件时，它的值就变成”dey\n”了。根据这四个字节，就可以识别不同类型的Dex文件了。到这里，已经搞清楚什么是魔数的作用了。
版本字段，主要用来标识Dex文件的版本。目前支持的版本号为“035\0”，不管是否优化的版本，都是使用这个版本号。
检验码字段，主要用来检查从这个字段开始到文件结尾，这段数据是否完整，有没有人修改过，或者传送过程中是否有出错等等。我们知道常常用来检查数据是否完整算法，有CRC32、有SHA128等，但这里采用都不是这两类，而采用一个比较特别的算法，叫做adler32，这是在开源zlib里常用的算法，用来检查文件是否完整性。这个算法是由MarkAdler发明的，它的可靠程度跟CRC32差不多，不过还是弱一点点，不过它有一个特好的优点，就是使用软件来计算检验码时比较CRC32要快很多。可见Android系统，就算法上就已经为移动设备进行优化了。
Adler32算法的源码如下：
#defineZLIB_INTERNAL
#include"zlib.h"
#defineBASE 65521UL /* largest prime smaller than 65536 */
#defineNMAX 5552
/*NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <=2^32-1 */
#defineDO1(buf,i) {adler += (buf)[i]; sum2 += adler;}
#defineDO2(buf,i) DO1(buf,i); DO1(buf,i+1);
#defineDO4(buf,i) DO2(buf,i); DO2(buf,i+2);
#defineDO8(buf,i) DO4(buf,i); DO4(buf,i+4);
#defineDO16(buf) DO8(buf,0); DO8(buf,8);
/*use NO_DIVIDE if your processor does not do division in hardware */
#ifdefNO_DIVIDE
# define MOD(a) \
do{ \
if(a >= (BASE << 16)) a -= (BASE << 16); \
if(a >= (BASE << 15)) a -= (BASE << 15); \
if(a >= (BASE << 14)) a -= (BASE << 14); \
if(a >= (BASE << 13)) a -= (BASE << 13); \
if(a >= (BASE << 12)) a -= (BASE << 12); \
if(a >= (BASE << 11)) a -= (BASE << 11); \
if(a >= (BASE << 10)) a -= (BASE << 10); \
if(a >= (BASE << 9)) a -= (BASE << 9); \
if(a >= (BASE << 8)) a -= (BASE << 8); \
if(a >= (BASE << 7)) a -= (BASE << 7); \
if(a >= (BASE << 6)) a -= (BASE << 6); \
if(a >= (BASE << 5)) a -= (BASE << 5); \
if(a >= (BASE << 4)) a -= (BASE << 4); \
if(a >= (BASE << 3)) a -= (BASE << 3); \
if(a >= (BASE << 2)) a -= (BASE << 2); \
if(a >= (BASE << 1)) a -= (BASE << 1); \
if(a >= BASE) a -= BASE; \
}while (0)
# define MOD4(a) \
do{ \
if(a >= (BASE << 4)) a -= (BASE << 4); \
if(a >= (BASE << 3)) a -= (BASE << 3); \
if(a >= (BASE << 2)) a -= (BASE << 2); \
if(a >= (BASE << 1)) a -= (BASE << 1); \
if(a >= BASE) a -= BASE; \
}while (0)
#else
# define MOD(a) a %= BASE
# define MOD4(a) a %= BASE
#endif
/*=========================================================================*/
uLongZEXPORT adler32(adler, buf, len)
uLongadler;
constBytef *buf;
uIntlen;
{
unsignedlong sum2;
unsignedn;
/*split Adler-32 into component sums */
sum2= (adler >> 16) & 0xffff;
adler&= 0xffff;
/*in case user likes doing a byte at a time, keep it fast */
if(len == 1) {
adler+= buf[0];
if(adler >= BASE)
adler-= BASE;
sum2+= adler;
if(sum2 >= BASE)
sum2-= BASE;
returnadler | (sum2 << 16);
}
/*initial Adler-32 value (deferred check for len == 1 speed) */
if(buf == Z_NULL)
return1L;
/*in case short lengths are provided, keep it somewhat fast */
if(len < 16) {
while(len--) {
adler+= *buf++;
sum2+= adler;
}
if(adler >= BASE)
adler-= BASE;
MOD4(sum2); /* only added so many BASE's */
returnadler | (sum2 << 16);
}
/*do length NMAX blocks -- requires just one modulo operation */
while(len >= NMAX) {
len-= NMAX;
n= NMAX / 16; /* NMAX is divisible by 16 */
do{
DO16(buf); /* 16 sums unrolled */
buf+= 16;
}while (--n);
MOD(adler);
MOD(sum2);
}
/*do remaining bytes (less than NMAX, still just one modulo) */
if(len) { /* avoid modulos if none remaining */
while(len >= 16) {
len-= 16;
DO16(buf);
buf+= 16;
}
while(len--) {
adler+= *buf++;
sum2+= adler;
}
MOD(adler);
MOD(sum2);
}
/*return recombined sums */
returnadler | (sum2 << 16);
}
SHA－1签名字段 从dex文件头里，已经看到前面有一个4字节的字段检验码了，那为什么又需要一个SHA－1签名字段呢？ 这不是重复了吗？起初始看来，好像是有点重复，可是仔细考虑一下，这样设计，还是比较高明的。因为dex文件的大小，一般都不是很小，简单的应用程序都有几十K大小，这么多数据使用一个4字节的检验码，重复的机率还是有的，也就是说当文件里的数据修改了，还是检验不出来。那么这时，检验码就失去了作用，需要使用更加强大的检验码，这就是SHA－1，它是20个字节，比前面的检验码多了16个字节，理论上就强大了很多，几乎不会不同的文件计算出来的检验是一样的了。设计两个检验码的目的，就是先使用第一个检验码进行快速检查，这样可以先把简单出错的dex文件丢掉了。接着再使用第二个复杂的检验码进行复杂计算，验证文件是否完整，这样确保执行的文件完整和安全。
SHA（Secure Hash Algorithm, 安全散列算法）是美国国家安全局设计，美国国家标准与技术研究院发布的一系列密码散列函数。SHA－1看起来和MD5算法很像，也许是Ron Rivest在SHA－1的设计中起了一定的作用。SHA－1的内部比MD5更强，其摘要比MD5的16字节长4个字节，这个算法成功经受了密码分析专家的攻击，也因而受到密码学界的广泛推崇。这个算法，在目前网络上的签名，大名顶顶的BT软件里就大量使用，比如在BT里要计算是否同一个种子时，就是使用判断不同的签名。比如验证同一份8G的电影从几千BT用户那里下载，也不会出现错误的数据，导致电影不播放。
在Android系统使用的SHA－1算法源码如下：
/*
* Tweaked in various ways for Google/Android:
* - Changed from .cpp to .c.
* - Made argument to SHA1Update a const pointer, and enabled
* SHA1HANDSOFF. This incurs a speed penalty but prevents us from
* trashing the input.
* - Include <endian.h> to get endian info.
* - Split a small piece into a header file.
*/
/*
sha1sum: inspired by md5sum.
SHA-1 in C
By Steve Reid <steve@edmweb.com>
100% Public Domain
-----------------
Modified 7/98
By James H. Brown <jbrown@burgoyne.com>
Still 100% Public Domain
bit machines
Routine SHA1Update changed from
void SHA1Update(SHA1_CTX* context, unsigned char* data,
unsigned int len)
to
void SHA1Update(SHA1_CTX* context, unsigned char* data,
unsigned long len)
The 'len' parameter was declared an int which works fine on 32
bit machines. However, on 16 bit machines an int is too small
for the shifts being done against it. This caused the hash
function to generate incorrect values if len was greater than
8191 (8K - 1) due to the 'len << 3' on line 3 of SHA1Update().
Since the file IO in main() reads 16K at a time, any file 8K or
larger would be guaranteed to generate the wrong hash (e.g.
Test Vector #3, a million "a"s).
I also changed the declaration of variables i & j in SHA1Update
to unsigned long from unsigned int for the same reason.
These changes should make no difference to any 32 bit
implementations since an int and a long are the same size in
those environments.
--
I also corrected a few compiler warnings generated by Borland
C.
1. Added #include <process.h> for exit() prototype
2. Removed unused variable 'j' in SHA1Final
3. Changed exit(0) to return(0) at end of main.
ALL changes I made can be located by searching for comments
containing 'JHB'
-----------------
Modified 13 August 2000
By Michael Paul Johnson <mpj@cryptography.org>
Still 100% Public Domain
Changed command line syntax, added feature to automatically
check files against their previous SHA-1 check values, kind of
like md5sum does. Added functions hexval, verifyfile,
and sha1file. Rewrote main().
-----------------
Test Vectors (from FIPS PUB 180-1)
"abc"
A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
A million repetitions of "a"
34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
*/
#define SHA1HANDSOFF /*Copies data before messing with it.*/
/*#define CMDLINE * include main() and file processing */
#include "sha1.h"
#include <stdio.h>
#include <string.h>
#ifdef __BORLANDC__
#include <dir.h>
#include <dos.h>
#include <process.h> /* prototype for exit() - JHB
needed for Win32, but chokes Linux - MPJ */
#define X_LITTLE_ENDIAN /* This should be #define'd if true.*/
#else
# include <unistd.h>
# include <stdlib.h>
//# include <endian.h>
#include "DexFile.h" // want common byte ordering def
# if __BYTE_ORDER == __LITTLE_ENDIAN
# define X_LITTLE_ENDIAN
# endif
#endif
#include <ctype.h>
#define LINESIZE 2048
static void SHA1Transform(unsigned long state[5],
const unsigned char buffer[64]);
#define rol(value,bits) \
(((value)<<(bits))|((value)>>(32-(bits))))
/* blk0() and blk() perform the initial expand. */
/* I got the idea of expanding during the round function from
SSLeay */
#ifdef X_LITTLE_ENDIAN
#define blk0(i) (block->l[i]=(rol(block->l[i],24)&0xFF00FF00) \
|(rol(block->l[i],8)&0x00FF00FF))
#else
#define blk0(i) block->l[i]
#endif
#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
^block->l[(i+2)&15]^block->l[i&15],1))
/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
/* Hash a single 512-bit block. This is the core of the algorithm. */
static void SHA1Transform(unsigned long state[5],
const unsigned char buffer[64])
{
unsigned long a, b, c, d, e;
typedef union {
unsigned char c[64];
unsigned long l[16];
} CHAR64LONG16;
CHAR64LONG16* block;
#ifdef SHA1HANDSOFF
static unsigned char workspace[64];
block = (CHAR64LONG16*)workspace;
memcpy(block, buffer, 64);
#else
block = (CHAR64LONG16*)buffer;
#endif
/* Copy context->state[] to working vars */
a = state[0];
b = state[1];
c = state[2];
d = state[3];
e = state[4];
/* 4 rounds of 20 operations each. Loop unrolled. */
R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2);
R0(c,d,e,a,b, 3); R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5);
R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7); R0(c,d,e,a,b, 8);
R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14);
R0(a,b,c,d,e,15); R1(e,a,b,c,d,16); R1(d,e,a,b,c,17);
R1(c,d,e,a,b,18); R1(b,c,d,e,a,19); R2(a,b,c,d,e,20);
R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26);
R2(d,e,a,b,c,27); R2(c,d,e,a,b,28); R2(b,c,d,e,a,29);
R2(a,b,c,d,e,30); R2(e,a,b,c,d,31); R2(d,e,a,b,c,32);
R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38);
R2(b,c,d,e,a,39); R3(a,b,c,d,e,40); R3(e,a,b,c,d,41);
R3(d,e,a,b,c,42); R3(c,d,e,a,b,43); R3(b,c,d,e,a,44);
R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50);
R3(e,a,b,c,d,51); R3(d,e,a,b,c,52); R3(c,d,e,a,b,53);
R3(b,c,d,e,a,54); R3(a,b,c,d,e,55); R3(e,a,b,c,d,56);
R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62);
R4(c,d,e,a,b,63); R4(b,c,d,e,a,64); R4(a,b,c,d,e,65);
R4(e,a,b,c,d,66); R4(d,e,a,b,c,67); R4(c,d,e,a,b,68);
R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74);
R4(a,b,c,d,e,75); R4(e,a,b,c,d,76); R4(d,e,a,b,c,77);
R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
/* Add the working vars back into context.state[] */
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
state[4] += e;
/* Wipe variables */
/* a = b = c = d = e = 0; Nice try, but the compiler
optimizes this out, anyway, and it produces an annoying
warning. */
}
/* SHA1Init - Initialize new context */
void SHA1Init(SHA1_CTX* context)
{
/* SHA1 initialization constants */
context->state[0] = 0x67452301;
context->state[1] = 0xEFCDAB89;
context->state[2] = 0x98BADCFE;
context->state[3] = 0x10325476;
context->state[4] = 0xC3D2E1F0;
context->count[0] = context->count[1] = 0;
}
/* Run your data through this. */
void SHA1Update(SHA1_CTX* context, const unsigned char* data,
unsigned long len) /* JHB */
{
unsigned long i, j; /* JHB */
j = (context->count[0] >> 3) & 63;
if ((context->count[0] += len << 3) < (len << 3))
context->count[1]++;
context->count[1] += (len >> 29);
if ((j + len) > 63)
{
memcpy(&context->buffer[j], data, (i = 64-j));
SHA1Transform(context->state, context->buffer);
for ( ; i + 63 < len; i += 64) {
SHA1Transform(context->state, &data[i]);
}
j = 0;
}
else
i = 0;
memcpy(&context->buffer[j], &data[i], len - i);
}
/* Add padding and return the message digest. */
void SHA1Final(unsigned char digest[HASHSIZE], SHA1_CTX*
context)
{
unsigned long i; /* JHB */
unsigned char finalcount[8];
for (i = 0; i < 8; i++)
{
finalcount[i] = (unsigned char)((context->count[(i>=4?
0:1)]>>((3-(i&3))*8))&255);
/* Endian independent */
}
SHA1Update(context, (unsigned char *)"\200", 1);
while ((context->count[0] & 504) != 448) {
SHA1Update(context, (unsigned char *)"\0", 1);
}
SHA1Update(context, finalcount, 8);
/* Should cause a SHA1Transform() */
for (i = 0; i < HASHSIZE; i++) {
digest[i] = (unsigned char)
((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
}
/* Wipe variables */
memset(context->buffer, 0, 64);
memset(context->state, 0, HASHSIZE);
memset(context->count, 0, 8);
memset(&finalcount, 0, 8);
#ifdef SHA1HANDSOFF
/* make SHA1Transform overwrite it's own static vars */
SHA1Transform(context->state, context->buffer);
#endif
}
#ifdef CMDLINE
/* sha1file computes the SHA-1 hash of the named file and puts
it in the 20-byte array digest. If fname is NULL, stdin is
assumed.
*/
void sha1file(char *fname, unsigned char* digest)
{
int bytesread;
SHA1_CTX context;
unsigned char buffer[16384];
FILE* f;
if (fname)
{
f = fopen(fname, "rb");
if (!f)
{
fprintf(stderr, "Can't open %s\n", fname);
memset(digest, 0, HASHSIZE);
return;
}
}
else
{
f = stdin;
}
SHA1Init(&context);
while (!feof(f))
{
bytesread = fread(buffer, 1, 16384, f);
SHA1Update(&context, buffer, bytesread);
}
SHA1Final(digest, &context);
if (fname)
fclose(f);
}
/* Convert ASCII hexidecimal digit to 4-bit value. */
unsigned char hexval(char c)
{
unsigned char h;
c = toupper(c);
if (c >= 'A')
h = c - 'A' + 10;
else
h = c - '0';
return h;
}
/* Verify a file created with sha1sum by redirecting output
to a file. */
int verifyfile(char *fname)
{
int j, k;
int found = 0;
unsigned char digest[HASHSIZE];
unsigned char expected_digest[HASHSIZE];
FILE *checkfile;
char checkline[LINESIZE];
char *s;
unsigned char err;
checkfile = fopen(fname, "rt");
if (!checkfile)
{
fprintf(stderr, "Can't open %s\n", fname);
return(0);
}
do
{
s = fgets(checkline, LINESIZE, checkfile);
if (s)
{
if ((strlen(checkline)>26)&&
1 /*(!strncmp(checkline,"SHA1=", 5))*/)
{
/* Overwrite newline. */
checkline[strlen(checkline)-1]=0;
found = 1;
/* Read expected check value. */
for (k=0, j=5; k < HASHSIZE; k++)
{
expected_digest[k]=hexval(checkline[j++]);
expected_digest[k]=(expected_digest[k]<<4)
+hexval(checkline[j++]);
}
/* Compute fingerprints */
s = checkline+46;
sha1file(s, digest);
/* Compare fingerprints */
err = 0;
for (k=0; k<HASHSIZE; k++)
err |= digest[k]-
expected_digest[k];
if (err)
{
fprintf(stderr, "FAILED: %s\n"
" EXPECTED: ", s);
for (k=0; k<HASHSIZE; k++)
fprintf(stderr, "%02X",
expected_digest[k]);
fprintf(stderr,"\n FOUND: ");
for (k=0; k<HASHSIZE; k++)
fprintf(stderr, "%02X", digest[k]);
fprintf(stderr, "\n");
}
else
{
printf("OK: %s\n", s);
}
}
}
} while (s);
return found;
}
void syntax(char *progname)
{
printf("\nsyntax:\n"
"%s [-c|-h][-q] file name[s]\n"
" -c = check files against previous check values\n"
" -g = generate SHA-1 check values (default action)\n"
" -h = display this help\n"
"For example,\n"
"sha1sum test.txt > check.txt\n"
"generates check value for test.txt in check.txt, and\n"
"sha1sum -c check.txt\n"
"checks test.txt against the check value in check.txt\n",
progname);
exit(1);
}
/**********************************************************/
int main(int argc, char** argv)
{
int i, j, k;
int check = 0;
int found = 0;
unsigned char digest[HASHSIZE];
unsigned char expected_digest[HASHSIZE];
FILE *checkfile;
char checkline[LINESIZE];
char *s;
#ifdef __BORLANDC__
struct ffblk f;
int done;
char path[MAXPATH];
char drive[MAXDRIVE];
char dir[MAXDIR];
char name[MAXFILE];
char ext[MAXEXT];
#endif
unsigned char err;
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '-')
{
switch (argv[i][1])
{
case 'c':
case 'C':
check = 1;
break;
case 'g':
case 'G':
check = 0;
break;
default:
syntax(argv[0]);
}
}
}
for (i=1; i<argc; i++)
{
if (argv[i][0] != '-')
{
#ifdef __BORLANDC__
fnsplit(argv[i], drive, dir, name, ext);
done = findfirst(argv[i], &f, FA_RDONLY |
FA_HIDDEN|FA_SYSTEM|FA_ARCH);
while (!done)
{
sprintf(path, "%s%s%s", drive, dir, f.ff_name);
s = path;
#else
s = argv[i];
#endif
if (check)
{ /* Check fingerprint file. */
found |= verifyfile(s);
}
else
{ /* Generate fingerprints & write to
stdout. */
sha1file(s, digest);
//printf("SHA1=");
for (j=0; j<HASHSIZE; j++)
printf("%02x", digest[j]);
printf(" %s\n", s);
found = 1;
}
#ifdef __BORLANDC__
done = findnext(&f);
}
#endif
}
}
if (!found)
{
if (check)
{
fprintf(stderr,
"No SHA1 lines found in %s\n",
argv[i]);
}
else
{
fprintf(stderr, "No files checked.\n");
syntax(argv[0]);
}
}
return(0); /* JHB */
}
#endif /*CMDLINE*/
map_off字段 这个字段主要保存map开始位置，就是从文件头开始到map出现的数据长度，通过这个索引就可以找到map数据。那么map保存些什么数据呢？有什么作用呢？下面就来解决这两个问题，首先来分析map的数据结构：
| 名称 | 大小 | 说明 |
| size | 4字节 | map里项的个数 |
| list | 变长 | 每一项定义为12字节，项的个数由上面项大小决定。 |
每一个map项的结构定义如下：
/*
*Direct-mapped "map_item".
*/
typedefstruct DexMapItem {
u2 type; /* type code (seekDexType* above) */
u2 unused;
u4 size; /* count of items ofthe indicated type */
u4 offset; /* file offset tothe start of data */
}DexMapItem;
map数据排列结构定义如下：
/*
*Direct-mapped "map_list".
*/
typedefstruct DexMapList {
u4 size; /* #of entries inlist */
DexMapItem list[1]; /* entries */
}DexMapList;
DexMapItem结构定义每一项的数据意义：类型、类型个数、类型开始位置。其中的类型定义如下：
/*map item type codes */
enum{
kDexTypeHeaderItem = 0x0000,
kDexTypeStringIdItem = 0x0001,
kDexTypeTypeIdItem = 0x0002,
kDexTypeProtoIdItem = 0x0003,
kDexTypeFieldIdItem = 0x0004,
kDexTypeMethodIdItem = 0x0005,
kDexTypeClassDefItem = 0x0006,
kDexTypeMapList = 0x1000,
kDexTypeTypeList = 0x1001,
kDexTypeAnnotationSetRefList = 0x1002,
kDexTypeAnnotationSetItem = 0x1003,
kDexTypeClassDataItem = 0x2000,
kDexTypeCodeItem = 0x2001,
kDexTypeStringDataItem = 0x2002,
kDexTypeDebugInfoItem = 0x2003,
kDexTypeAnnotationItem = 0x2004,
kDexTypeEncodedArrayItem = 0x2005,
kDexTypeAnnotationsDirectoryItem = 0x2006,
};
从上面的类型可知，它已经包括在dex文件里出现的所有类型。细心的读者也许发现这里的类型与文件头里定义的类型有很多是一样的，没错，这里的类型其实就是文件头里定义的类型。因为这个map的数据，就是头里类型的重复，完全是为了检验作用而存在的。当Android系统加载dex文件时，如果比较文件头类型个数与map里类型不一致时，就会停止使用这个dex文件。
string_ids_size和string_ids_off字段 这两个字段主要用来访问字符串资源，由于源程序里编译后，程序所需要使用到的字符串都保存在这个数据段里，以便解释执行这个dex文件代码时使用。比如调用库函数里的类名称描述，输出显示给用户查看的字符串。string_ids_size说明了有多少个字符串，而string_ids_off说明字符串数据区的开始位置。那么字符串数据区里的内容是怎么样排列的呢？下面就来分析这个字符串结构：
/*
* Direct-mapped "string_id_item".
*/
typedef struct DexStringId {
u4 stringDataOff; /* file offset to string_data_item */
} DexStringId;
从上面的结构可以看出来，这个数据区保存的只是字符串表的地址索引。如果要找到字符串的实际数据，还需要从这个地址索引找到文件的相应开始位置，然后才得到字符串数据。每一个字符串项占用4个字节。因此这个数据区的大小就为4＊string_ids_size。在保存字符串实际数据区，采用UTF16的格式来保存，也就是每两个字节为一个单位保存，因此发现这里保存的字符串是交错在一起，比如直接从dex文件里使用16进制显示出来内容如下：
3c06 6e69 7469 003e
实际这段数据是描述”<init>\0”，可见字符顺序与ASCII码的顺序并不一致，再仔细一看是交错在一起的，如果按16位的方式来读取，再把低字节放在前面，高字节放在后面，再拼接到一起，就是相应的顺序了。这段数据包括字符串的长度、字符串内容、字符串结束标志。把字符串按16位读取，再交换字节顺序，就变成如下字符串：
063c 696e 6974 3e00
字符串的长度是采用固定的长度，还是变长的长度来表示呢？在dex文件里是采用变长来表示字符串的长度。因为一个字符串的长度可能是一个字节，比如小于256；或者4个字节，比如1G大小以上。由于字符串的长度，大多数都是小于256个字节，因此需要使用一种编码，既可以表示一个字节的长度，也可以表示4个字节的长度。并且1个字节的长度占绝大多数，能满足这种表示的编码方式有很多，但dex文件里采用uleb128方式。leb128编码是一种变长编码，每个字节采用７位来表达原来的数据，最高位用来表示是否有后继字节。它的编码算法如下：
/*
* Writes a 32-bit value in unsigned ULEB128 format.
*
* Returns the updated pointer.
*/
DEX_INLINE u1* writeUnsignedLeb128(u1* ptr, u4 data)
{
while (true) {
u1 out = data & 0x7f;
if (out != data) {
*ptr++ = out | 0x80;
data >>= 7;
} else {
*ptr++ = out;
break;
}
}
return ptr;
}
它的解码算法如下：
/*
* Reads an unsigned LEB128 value, updating the given pointer to point
* just past the end of the read value. This function tolerates
* non-zero high-order bits in the fifth encoded byte.
*/
DEX_INLINE int readUnsignedLeb128(const u1** pStream) {
const u1* ptr = *pStream;
int result = *(ptr++);
if (result > 0x7f) {
int cur = *(ptr++);
result = (result & 0x7f) | ((cur & 0x7f) << 7);
if (cur > 0x7f) {
cur = *(ptr++);
result |= (cur & 0x7f) << 14;
if (cur > 0x7f) {
cur = *(ptr++);
result |= (cur & 0x7f) << 21;
if (cur > 0x7f) {
/*
* Note: We don't check to see if cur is out of
* range here, meaning we tolerate garbage in the
* high four-order bits.
*/
cur = *(ptr++);
result |= cur << 28;
}
}
}
}
*pStream = ptr;
return result;
}
根据上面的算法，来分析上面例子字符串，取得第一个字节是06，最高位为０，因此没有后继字节，那么取出这个字节里７位有效数据，就是６，也就是说这个字符串是６个字节，但不包括结束字符“\0”。到这里，就非常清楚字符串数据区的数据保存表示方式了。
372
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
