解压 boot.img

./split_bootimg.pl boot.img

Page size: 2048 (0x00000800)

Kernel size: 7062084 (0x006bc244)

Ramdisk size: 1825217 (0x001bd9c1)

Second size: 0 (0x00000000)

Board name:

Command line:

Writing boot.img-kernel ... complete.

Writing boot.img-ramdisk.gz ... complete.

gzip -d boot.img-ramdisk.gz

cpio -i -F boot.img-ramdisk

#!/usr/bin/perl

######################################################################

#

#   File          : split_bootimg.pl

#   Author(s)     : William Enck <enck@cse.psu.edu>

#   Description   : Split appart an Android boot image created

#                   with mkbootimg. The format can be found in

#                   android-src/system/core/mkbootimg/bootimg.h

#

#                   Thanks to alansj on xda-developers.com for

#                   identifying the format in bootimg.h and

#                   describing initial instructions for splitting

#                   the boot.img file.

#

#   Last Modified : Tue Dec  2 23:36:25 EST 2008

#   By            : William Enck <enck@cse.psu.edu>

#

#   Copyright (c) 2008 William Enck

#

######################################################################

use strict;

use warnings;

# Turn on print flushing

$|++;

######################################################################

## Global Variables and Constants

my $SCRIPT = __FILE__;

my $IMAGE_FN = undef;

# Constants (from bootimg.h)

use constant BOOT_MAGIC => 'ANDROID!';

use constant BOOT_MAGIC_SIZE => 8;

use constant BOOT_NAME_SIZE => 16;

use constant BOOT_ARGS_SIZE => 512;

# Unsigned integers are 4 bytes

use constant UNSIGNED_SIZE => 4;

# Parsed Values

my $PAGE_SIZE = undef;

my $KERNEL_SIZE = undef;

my $RAMDISK_SIZE = undef;

my $SECOND_SIZE = undef;

######################################################################

## Main Code

&parse_cmdline();

&parse_header($IMAGE_FN);

=format (from bootimg.h)

** +-----------------+

** | boot header     | 1 page

** +-----------------+

** | kernel          | n pages

** +-----------------+

** | ramdisk         | m pages

** +-----------------+

** | second stage    | o pages

** +-----------------+

**

** n = (kernel_size + page_size - 1) / page_size

** m = (ramdisk_size + page_size - 1) / page_size

** o = (second_size + page_size - 1) / page_size

=cut

my $n = int(($KERNEL_SIZE + $PAGE_SIZE - 1) / $PAGE_SIZE);

my $m = int(($RAMDISK_SIZE + $PAGE_SIZE - 1) / $PAGE_SIZE);

my $o = int(($SECOND_SIZE + $PAGE_SIZE - 1) / $PAGE_SIZE);

my $k_offset = $PAGE_SIZE;

my $r_offset = $k_offset + ($n * $PAGE_SIZE);

my $s_offset = $r_offset + ($m * $PAGE_SIZE);

(my $base = $IMAGE_FN) =~ s/.*\/(.*)$/$1/;

my $k_file = $base . "-kernel";

my $r_file = $base . "-ramdisk.gz";

my $s_file = $base . "-second.gz";

# The kernel is always there

print "Writing $k_file ...";

&dump_file($IMAGE_FN, $k_file, $k_offset, $KERNEL_SIZE);

print " complete.\n";

# The ramdisk is always there

print "Writing $r_file ...";

&dump_file($IMAGE_FN, $r_file, $r_offset, $RAMDISK_SIZE);

print " complete.\n";

# The Second stage bootloader is optional

unless ($SECOND_SIZE == 0) {

    print "Writing $s_file ...";

    &dump_file($IMAGE_FN, $s_file, $s_offset, $SECOND_SIZE);

    print " complete.\n";

}

######################################################################

## Supporting Subroutines

=header_format (from bootimg.h)

struct boot_img_hdr

{

    unsigned char magic[BOOT_MAGIC_SIZE];

    unsigned kernel_size;  /* size in bytes */

    unsigned kernel_addr;  /* physical load addr */

    unsigned ramdisk_size; /* size in bytes */

    unsigned ramdisk_addr; /* physical load addr */

    unsigned second_size;  /* size in bytes */

    unsigned second_addr;  /* physical load addr */

    unsigned tags_addr;    /* physical addr for kernel tags */

    unsigned page_size;    /* flash page size we assume */

    unsigned unused[2];    /* future expansion: should be 0 */

    unsigned char name[BOOT_NAME_SIZE]; /* asciiz product name */

    unsigned char cmdline[BOOT_ARGS_SIZE];

    unsigned id[8]; /* timestamp / checksum / sha1 / etc */

};

=cut

sub parse_header {

    my ($fn) = @_;

    my $buf = undef;

    open INF, $fn or die "Could not open $fn: $!\n";

    binmode INF;

    # Read the Magic

    read(INF, $buf, BOOT_MAGIC_SIZE);

    unless ($buf eq BOOT_MAGIC) {

	die "Android Magic not found in $fn. Giving up.\n";

    }

    # Read kernel size and address (assume little-endian)

    read(INF, $buf, UNSIGNED_SIZE * 2);

    my ($k_size, $k_addr) = unpack("VV", $buf);

    # Read ramdisk size and address (assume little-endian)

    read(INF, $buf, UNSIGNED_SIZE * 2);

    my ($r_size, $r_addr) = unpack("VV", $buf);

    # Read second size and address (assume little-endian)

    read(INF, $buf, UNSIGNED_SIZE * 2);

    my ($s_size, $s_addr) = unpack("VV", $buf);

    # Ignore tags_addr

    read(INF, $buf, UNSIGNED_SIZE);

    # get the page size (assume little-endian)

    read(INF, $buf, UNSIGNED_SIZE);

    my ($p_size) = unpack("V", $buf);

    # Ignore unused

    read(INF, $buf, UNSIGNED_SIZE * 2);

    # Read the name (board name)

    read(INF, $buf, BOOT_NAME_SIZE);

    my $name = $buf;

    # Read the command line

    read(INF, $buf, BOOT_ARGS_SIZE);

    my $cmdline = $buf;

    # Ignore the id

    read(INF, $buf, UNSIGNED_SIZE * 8);

    # Close the file

    close INF;

    # Print important values

    printf "Page size: %d (0x%08x)\n", $p_size, $p_size;

    printf "Kernel size: %d (0x%08x)\n", $k_size, $k_size;

    printf "Ramdisk size: %d (0x%08x)\n", $r_size, $r_size;

    printf "Second size: %d (0x%08x)\n", $s_size, $s_size;

    printf "Board name: $name\n";

    printf "Command line: $cmdline\n";

    # Save the values

    $PAGE_SIZE = $p_size;

    $KERNEL_SIZE = $k_size;

    $RAMDISK_SIZE = $r_size;

    $SECOND_SIZE = $s_size;

}

sub dump_file {

    my ($infn, $outfn, $offset, $size) = @_;

    my $buf = undef;

    open INF, $infn or die "Could not open $infn: $!\n";

    open OUTF, ">$outfn" or die "Could not open $outfn: $!\n";

    binmode INF;

    binmode OUTF;

    seek(INF, $offset, 0) or die "Could not seek in $infn: $!\n";

    read(INF, $buf, $size) or die "Could not read $infn: $!\n";

    print OUTF $buf or die "Could not write $outfn: $!\n";

    close INF;

    close OUTF;

}

######################################################################

## Configuration Subroutines

sub parse_cmdline {

    unless ($#ARGV == 0) {

	die "Usage: $SCRIPT boot.img\n";

    }

    $IMAGE_FN = $ARGV[0];

}

巴特西

解压 boot.img

最新文章

热门文章