/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package dxconvext;
import dxconvext.util.FileUtils;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.security.DigestException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.zip.Adler32;
public class ClassFileAssembler {
/**
* @param args
*/
public static void main(String[] args) {
ClassFileAssembler cfa = new ClassFileAssembler();
cfa.run(args);
}
private void run(String[] args) {
// this class can be used to generate .class files that are somehow
// damaged in order to test the dalvik vm verifier.
// The input is a .cfh (class file hex) file.
// The output is a java vm .class file.
// The .cfh files can be generated as follows:
// 1. create the initial .cfh file from an existing .class files by using
// the ClassFileParser
// 2. modify some bytes to damage the structure of the .class file in a
// way that would not be possible with e.g. jasmin (otherwise you are
// better off using jasmin).
// Uncomment the original bytes, and write "MOD:" meaning a modified
// entry (with the original commented out)
//
// Use the ClassFileAssembler to generate the .class file.
// this class here simply takes all non-comment lines from the .cfh
// file, parses them as hex values and writes the bytes to the class file
File cfhF = new File(args[0]);
if (!cfhF.getName().endsWith(".cfh") &&
!cfhF.getName().endsWith(".dfh")) {
System.out.println("file must be a .cfh or .dfh file, and its filename end with .cfh or .dfh");
return;
}
String outBase = args[1];
boolean isDex = cfhF.getName().endsWith(".dfh");
byte[] cfhbytes = FileUtils.readFile(cfhF);
ByteArrayInputStream bais = new ByteArrayInputStream(cfhbytes);
// encoding should not matter, since we are skipping comment lines and parsing
try {
// get the package name
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(cfhF)));
String firstLine = br.readLine();
br.close();
String classHdr = "//@class:";
String dexHdr = "// Processing '";
String hdr;
if(isDex)
hdr = dexHdr;
else
hdr = classHdr;
if (!firstLine.startsWith(hdr)) throw new RuntimeException("wrong format:"+firstLine +" isDex=" + isDex);
String tFile;
if(isDex) {
tFile = outBase + "/classes.dex";
} else {
String classO = firstLine.substring(hdr.length()).trim();
tFile = outBase +"/"+classO+".class";
}
File outFile = new File(tFile);
System.out.println("outfile:" + outFile);
String mkdir = tFile.substring(0, tFile.lastIndexOf("/"));
new File(mkdir).mkdirs();
Reader r = new InputStreamReader(bais,"utf-8");
OutputStream os = new FileOutputStream(outFile);
BufferedOutputStream bos = new BufferedOutputStream(os);
writeClassFile(r, bos, isDex);
bos.close();
} catch (UnsupportedEncodingException e) {
throw new RuntimeException("problem while parsing .dfh or .cfh file: "+cfhF.getAbsolutePath(), e);
} catch (FileNotFoundException e) {
throw new RuntimeException("problem while parsing .dfh or .cfh file: "+cfhF.getAbsolutePath(), e);
} catch (IOException e) {
throw new RuntimeException("problem while parsing .dfh or .cfh file: "+cfhF.getAbsolutePath(), e);
}
}
/**
* Calculates the signature for the <code>.dex</code> file in the
* given array, and modify the array to contain it.
*
* Originally from com.android.dx.dex.file.DexFile.
*
* @param bytes non-null; the bytes of the file
*/
private void calcSignature(byte[] bytes) {
MessageDigest md;
try {
md = MessageDigest.getInstance("SHA-1");
} catch (NoSuchAlgorithmException ex) {
throw new RuntimeException(ex);
}
md.update(bytes, 32, bytes.length - 32);
try {
int amt = md.digest(bytes, 12, 20);
if (amt != 20) {
throw new RuntimeException("unexpected digest write: " + amt +
" bytes");
}
} catch (DigestException ex) {
throw new RuntimeException(ex);
}
}
/**
* Calculates the checksum for the <code>.dex</code> file in the
* given array, and modify the array to contain it.
*
* Originally from com.android.dx.dex.file.DexFile.
*
* @param bytes non-null; the bytes of the file
*/
private void calcChecksum(byte[] bytes) {
Adler32 a32 = new Adler32();
a32.update(bytes, 12, bytes.length - 12);
int sum = (int) a32.getValue();
bytes[8] = (byte) sum;
bytes[9] = (byte) (sum >> 8);
bytes[10] = (byte) (sum >> 16);
bytes[11] = (byte) (sum >> 24);
}
public void writeClassFile(Reader r, OutputStream rOs, boolean isDex) {
ByteArrayOutputStream baos = new ByteArrayOutputStream(8192);
BufferedReader br = new BufferedReader(r);
String line;
String secondLine = null;
int lineCnt = 0;
try {
while ((line = br.readLine()) != null) {
if (isDex && lineCnt++ == 1) {
secondLine = line;
}
// skip it if it is a comment
if (!line.trim().startsWith("//")) {
// we have a row like " ae 08 21 ff" etc.
String[] parts = line.split("\\s+");
for (int i = 0; i < parts.length; i++) {
String part = parts[i].trim();
if (!part.equals("")) {
int res = Integer.parseInt(part, 16);
baos.write(res);
}
}
}
}
// now for dex, update the checksum and the signature.
// special case:
// for two tests (currently T_f1_9.dfh and T_f1_10.dfh), we need
// to keep the checksum or the signature, respectively.
byte[] outBytes = baos.toByteArray();
if (isDex) {
boolean leaveChecksum = secondLine.contains("//@leaveChecksum");
boolean leaveSignature= secondLine.contains("//@leaveSignature");
// update checksum and signature for dex file
if(!leaveSignature)
calcSignature(outBytes);
if(!leaveChecksum)
calcChecksum(outBytes);
}
rOs.write(outBytes);
rOs.close();
} catch (IOException e) {
throw new RuntimeException("problem while writing file",e);
}
}
}