Add dumpimage, a tool to extract data from U-Boot images
Given a multi-file image created through the mkimage's -d option:
$ mkimage -A x86 -O linux -T multi -n x86 -d vmlinuz:initrd.img:System.map \
multi.img
Image Name: x86
Created: Thu Jul 25 10:29:13 2013
Image Type: Intel x86 Linux Multi-File Image (gzip compressed)
Data Size: 13722956 Bytes = 13401.32 kB = 13.09 MB
Load Address: 00000000
Entry Point: 00000000
Contents:
Image 0: 4040128 Bytes = 3945.44 kB = 3.85 MB
Image 1: 7991719 Bytes = 7804.41 kB = 7.62 MB
Image 2: 1691092 Bytes = 1651.46 kB = 1.61 MB
It is possible to perform the innverse operation -- extracting any file from
the image -- by using the dumpimage's -i option:
$ dumpimage -i multi.img -p 2 System.map
Although it's feasible to retrieve "data files" from image through scripting,
the requirement to embed tools such 'dd', 'awk' and 'sed' for this sole purpose
is cumbersome and unreliable -- once you must keep track of file sizes inside
the image. Furthermore, extracting data files using "dumpimage" tool is faster
than through scripting.
Signed-off-by: Guilherme Maciel Ferreira <guilherme.maciel.ferreira@gmail.com>
Signed-off-by: Simon Glass <sjg@chromium.org>
This commit is contained in:
Guilherme Maciel Ferreira
Tom Rini
parent
f86ed6a8d5
commit
a804b5ce2d
1
Makefile
1
Makefile
|
|
@ -797,6 +797,7 @@ clean:
|
|||
$(obj)tools/envcrc \
|
||||
$(obj)tools/gdb/{astest,gdbcont,gdbsend} \
|
||||
$(obj)tools/gen_eth_addr $(obj)tools/img2srec \
|
||||
$(obj)tools/dump{env,}image \
|
||||
$(obj)tools/mk{env,}image $(obj)tools/mpc86x_clk \
|
||||
$(obj)tools/mk{$(BOARD),}spl \
|
||||
$(obj)tools/mxsboot \
|
||||
|
|
|
|||
9
README
9
README
|
|
@ -5252,6 +5252,15 @@ when your kernel is intended to use an initial ramdisk:
|
|||
Load Address: 0x00000000
|
||||
Entry Point: 0x00000000
|
||||
|
||||
The "dumpimage" is a tool to disassemble images built by mkimage. Its "-i"
|
||||
option performs the converse operation of the mkimage's second form (the "-d"
|
||||
option). Given an image built by mkimage, the dumpimage extracts a "data file"
|
||||
from the image:
|
||||
|
||||
tools/dumpimage -i image -p position data_file
|
||||
-i ==> extract from the 'image' a specific 'data_file', \
|
||||
indexed by 'position'
|
||||
|
||||
|
||||
Installing a Linux Image:
|
||||
-------------------------
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@
|
|||
/gen_eth_addr
|
||||
/img2srec
|
||||
/kwboot
|
||||
/dumpimage
|
||||
/mkenvimage
|
||||
/mkimage
|
||||
/mpc86x_clk
|
||||
|
|
|
|||
|
|
@ -50,6 +50,7 @@ BIN_FILES-$(CONFIG_BUILD_ENVCRC) += envcrc$(SFX)
|
|||
BIN_FILES-$(CONFIG_CMD_NET) += gen_eth_addr$(SFX)
|
||||
BIN_FILES-$(CONFIG_CMD_LOADS) += img2srec$(SFX)
|
||||
BIN_FILES-$(CONFIG_XWAY_SWAP_BYTES) += xway-swap-bytes$(SFX)
|
||||
BIN_FILES-y += dumpimage$(SFX)
|
||||
BIN_FILES-y += mkenvimage$(SFX)
|
||||
BIN_FILES-y += mkimage$(SFX)
|
||||
BIN_FILES-$(CONFIG_EXYNOS5250) += mk$(BOARD)spl$(SFX)
|
||||
|
|
@ -72,6 +73,7 @@ EXT_OBJ_FILES-y += lib/sha1.o
|
|||
# Source files located in the tools directory
|
||||
NOPED_OBJ_FILES-y += aisimage.o
|
||||
NOPED_OBJ_FILES-y += default_image.o
|
||||
NOPED_OBJ_FILES-y += dumpimage.o
|
||||
NOPED_OBJ_FILES-y += fit_image.o
|
||||
NOPED_OBJ_FILES-y += image-host.o
|
||||
NOPED_OBJ_FILES-y += imximage.o
|
||||
|
|
@ -200,6 +202,30 @@ $(obj)xway-swap-bytes$(SFX): $(obj)xway-swap-bytes.o
|
|||
$(HOSTCC) $(HOSTCFLAGS) $(HOSTLDFLAGS) -o $@ $^
|
||||
$(HOSTSTRIP) $@
|
||||
|
||||
$(obj)dumpimage$(SFX): $(obj)aisimage.o \
|
||||
$(FIT_SIG_OBJS) \
|
||||
$(obj)crc32.o \
|
||||
$(obj)default_image.o \
|
||||
$(obj)fit_image.o \
|
||||
$(obj)image-fit.o \
|
||||
$(obj)image.o \
|
||||
$(obj)image-host.o \
|
||||
$(obj)imagetool.o \
|
||||
$(obj)imximage.o \
|
||||
$(obj)kwbimage.o \
|
||||
$(obj)dumpimage.o \
|
||||
$(obj)md5.o \
|
||||
$(obj)mxsimage.o \
|
||||
$(obj)omapimage.o \
|
||||
$(obj)os_support.o \
|
||||
$(obj)pblimage.o \
|
||||
$(obj)sha1.o \
|
||||
$(obj)ublimage.o \
|
||||
$(LIBFDT_OBJS) \
|
||||
$(RSA_OBJS)
|
||||
$(HOSTCC) $(HOSTCFLAGS) $(HOSTLDFLAGS) -o $@ $^ $(HOSTLIBS)
|
||||
$(HOSTSTRIP) $@
|
||||
|
||||
$(obj)mkenvimage$(SFX): $(obj)crc32.o $(obj)mkenvimage.o \
|
||||
$(obj)os_support.o
|
||||
$(HOSTCC) $(HOSTCFLAGS) $(HOSTLDFLAGS) -o $@ $^
|
||||
|
|
|
|||
|
|
@ -117,6 +117,62 @@ static void image_set_header(void *ptr, struct stat *sbuf, int ifd,
|
|||
image_set_hcrc(hdr, checksum);
|
||||
}
|
||||
|
||||
static int image_save_datafile(struct image_tool_params *params,
|
||||
ulong file_data, ulong file_len)
|
||||
{
|
||||
int dfd;
|
||||
const char *datafile = params->outfile;
|
||||
|
||||
dfd = open(datafile, O_RDWR | O_CREAT | O_TRUNC | O_BINARY,
|
||||
S_IRUSR | S_IWUSR);
|
||||
if (dfd < 0) {
|
||||
fprintf(stderr, "%s: Can't open \"%s\": %s\n",
|
||||
params->cmdname, datafile, strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (write(dfd, (void *)file_data, file_len) != (ssize_t)file_len) {
|
||||
fprintf(stderr, "%s: Write error on \"%s\": %s\n",
|
||||
params->cmdname, datafile, strerror(errno));
|
||||
close(dfd);
|
||||
return -1;
|
||||
}
|
||||
|
||||
close(dfd);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int image_extract_datafile(void *ptr, struct image_tool_params *params)
|
||||
{
|
||||
const image_header_t *hdr = (const image_header_t *)ptr;
|
||||
ulong file_data;
|
||||
ulong file_len;
|
||||
|
||||
if (image_check_type(hdr, IH_TYPE_MULTI)) {
|
||||
ulong idx = params->pflag;
|
||||
ulong count;
|
||||
|
||||
/* get the number of data files present in the image */
|
||||
count = image_multi_count(hdr);
|
||||
|
||||
/* retrieve the "data file" at the idx position */
|
||||
image_multi_getimg(hdr, idx, &file_data, &file_len);
|
||||
|
||||
if ((file_len == 0) || (idx >= count)) {
|
||||
fprintf(stderr, "%s: No such data file %ld in \"%s\"\n",
|
||||
params->cmdname, idx, params->imagefile);
|
||||
return -1;
|
||||
}
|
||||
} else {
|
||||
file_data = image_get_data(hdr);
|
||||
file_len = image_get_size(hdr);
|
||||
}
|
||||
|
||||
/* save the "data file" into the file system */
|
||||
return image_save_datafile(params, file_data, file_len);
|
||||
}
|
||||
|
||||
/*
|
||||
* Default image type parameters definition
|
||||
*/
|
||||
|
|
@ -128,6 +184,7 @@ static struct image_type_params defimage_params = {
|
|||
.verify_header = image_verify_header,
|
||||
.print_header = image_print_contents,
|
||||
.set_header = image_set_header,
|
||||
.extract_datafile = image_extract_datafile,
|
||||
.check_params = image_check_params,
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,305 @@
|
|||
/*
|
||||
* Based on mkimage.c.
|
||||
*
|
||||
* Written by Guilherme Maciel Ferreira <guilherme.maciel.ferreira@gmail.com>
|
||||
*
|
||||
* SPDX-License-Identifier: GPL-2.0+
|
||||
*/
|
||||
|
||||
#include "dumpimage.h"
|
||||
#include <image.h>
|
||||
#include <version.h>
|
||||
|
||||
static void usage(void);
|
||||
|
||||
/* image_type_params linked list to maintain registered image types supports */
|
||||
static struct image_type_params *dumpimage_tparams;
|
||||
|
||||
/* parameters initialized by core will be used by the image type code */
|
||||
static struct image_tool_params params = {
|
||||
.type = IH_TYPE_KERNEL,
|
||||
};
|
||||
|
||||
/**
|
||||
* dumpimage_register() - register respective image generation/list support
|
||||
*
|
||||
* the input struct image_type_params is checked and appended to the link
|
||||
* list, if the input structure is already registered, issue an error
|
||||
*
|
||||
* @tparams: Image type parameters
|
||||
*/
|
||||
static void dumpimage_register(struct image_type_params *tparams)
|
||||
{
|
||||
struct image_type_params **tp;
|
||||
|
||||
if (!tparams) {
|
||||
fprintf(stderr, "%s: %s: Null input\n", params.cmdname,
|
||||
__func__);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/* scan the linked list, check for registry and point the last one */
|
||||
for (tp = &dumpimage_tparams; *tp != NULL; tp = &(*tp)->next) {
|
||||
if (!strcmp((*tp)->name, tparams->name)) {
|
||||
fprintf(stderr, "%s: %s already registered\n",
|
||||
params.cmdname, tparams->name);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
/* add input struct entry at the end of link list */
|
||||
*tp = tparams;
|
||||
/* mark input entry as last entry in the link list */
|
||||
tparams->next = NULL;
|
||||
|
||||
debug("Registered %s\n", tparams->name);
|
||||
}
|
||||
|
||||
/**
|
||||
* dumpimage_get_type() - find the image type params for a given image type
|
||||
*
|
||||
* Scan all registered image types and check the input type_id for each
|
||||
* supported image type
|
||||
*
|
||||
* @return respective image_type_params pointer. If the input type is not
|
||||
* supported by any of registered image types, returns NULL
|
||||
*/
|
||||
static struct image_type_params *dumpimage_get_type(int type)
|
||||
{
|
||||
struct image_type_params *curr;
|
||||
|
||||
for (curr = dumpimage_tparams; curr != NULL; curr = curr->next) {
|
||||
if (curr->check_image_type) {
|
||||
if (!curr->check_image_type(type))
|
||||
return curr;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* dumpimage_verify_print_header() - verifies the image header
|
||||
*
|
||||
* Scan registered image types and verify the image_header for each
|
||||
* supported image type. If verification is successful, this prints
|
||||
* the respective header.
|
||||
*
|
||||
* @return 0 on success, negative if input image format does not match with
|
||||
* any of supported image types
|
||||
*/
|
||||
static int dumpimage_verify_print_header(void *ptr, struct stat *sbuf)
|
||||
{
|
||||
int retval = -1;
|
||||
struct image_type_params *curr;
|
||||
|
||||
for (curr = dumpimage_tparams; curr != NULL; curr = curr->next) {
|
||||
if (curr->verify_header) {
|
||||
retval = curr->verify_header((unsigned char *)ptr,
|
||||
sbuf->st_size, ¶ms);
|
||||
if (retval != 0)
|
||||
continue;
|
||||
/*
|
||||
* Print the image information if verify is
|
||||
* successful
|
||||
*/
|
||||
if (curr->print_header) {
|
||||
curr->print_header(ptr);
|
||||
} else {
|
||||
fprintf(stderr,
|
||||
"%s: print_header undefined for %s\n",
|
||||
params.cmdname, curr->name);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
/*
|
||||
* dumpimage_extract_datafile -
|
||||
*
|
||||
* It scans all registered image types,
|
||||
* verifies image_header for each supported image type
|
||||
* if verification is successful, it extracts the desired file,
|
||||
* indexed by pflag, from the image
|
||||
*
|
||||
* returns negative if input image format does not match with any of
|
||||
* supported image types
|
||||
*/
|
||||
static int dumpimage_extract_datafile(void *ptr, struct stat *sbuf)
|
||||
{
|
||||
int retval = -1;
|
||||
struct image_type_params *curr;
|
||||
|
||||
for (curr = dumpimage_tparams; curr != NULL; curr = curr->next) {
|
||||
if (curr->verify_header) {
|
||||
retval = curr->verify_header((unsigned char *)ptr,
|
||||
sbuf->st_size, ¶ms);
|
||||
if (retval != 0)
|
||||
continue;
|
||||
/*
|
||||
* Extract the file from the image
|
||||
* if verify is successful
|
||||
*/
|
||||
if (curr->extract_datafile) {
|
||||
curr->extract_datafile(ptr, ¶ms);
|
||||
} else {
|
||||
fprintf(stderr,
|
||||
"%s: extract_datafile undefined for %s\n",
|
||||
params.cmdname, curr->name);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
int opt;
|
||||
int ifd = -1;
|
||||
struct stat sbuf;
|
||||
char *ptr;
|
||||
int retval = 0;
|
||||
struct image_type_params *tparams = NULL;
|
||||
|
||||
/* Init all image generation/list support */
|
||||
register_image_tool(dumpimage_register);
|
||||
|
||||
params.cmdname = *argv;
|
||||
|
||||
while ((opt = getopt(argc, argv, "li:o:p:V")) != -1) {
|
||||
switch (opt) {
|
||||
case 'l':
|
||||
params.lflag = 1;
|
||||
break;
|
||||
case 'i':
|
||||
params.imagefile = optarg;
|
||||
params.iflag = 1;
|
||||
break;
|
||||
case 'o':
|
||||
params.outfile = optarg;
|
||||
break;
|
||||
case 'p':
|
||||
params.pflag = strtoul(optarg, &ptr, 10);
|
||||
if (*ptr) {
|
||||
fprintf(stderr,
|
||||
"%s: invalid file position %s\n",
|
||||
params.cmdname, *argv);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
break;
|
||||
case 'V':
|
||||
printf("dumpimage version %s\n", PLAIN_VERSION);
|
||||
exit(EXIT_SUCCESS);
|
||||
default:
|
||||
usage();
|
||||
}
|
||||
}
|
||||
|
||||
if (optind >= argc)
|
||||
usage();
|
||||
|
||||
/* set tparams as per input type_id */
|
||||
tparams = dumpimage_get_type(params.type);
|
||||
if (tparams == NULL) {
|
||||
fprintf(stderr, "%s: unsupported type %s\n",
|
||||
params.cmdname, genimg_get_type_name(params.type));
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/*
|
||||
* check the passed arguments parameters meets the requirements
|
||||
* as per image type to be generated/listed
|
||||
*/
|
||||
if (tparams->check_params) {
|
||||
if (tparams->check_params(¶ms))
|
||||
usage();
|
||||
}
|
||||
|
||||
if (params.iflag)
|
||||
params.datafile = argv[optind];
|
||||
else
|
||||
params.imagefile = argv[optind];
|
||||
if (!params.outfile)
|
||||
params.outfile = params.datafile;
|
||||
|
||||
ifd = open(params.imagefile, O_RDONLY|O_BINARY);
|
||||
if (ifd < 0) {
|
||||
fprintf(stderr, "%s: Can't open \"%s\": %s\n",
|
||||
params.cmdname, params.imagefile,
|
||||
strerror(errno));
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
if (params.lflag || params.iflag) {
|
||||
if (fstat(ifd, &sbuf) < 0) {
|
||||
fprintf(stderr, "%s: Can't stat \"%s\": %s\n",
|
||||
params.cmdname, params.imagefile,
|
||||
strerror(errno));
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
if ((unsigned)sbuf.st_size < tparams->header_size) {
|
||||
fprintf(stderr,
|
||||
"%s: Bad size: \"%s\" is not valid image\n",
|
||||
params.cmdname, params.imagefile);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_SHARED, ifd, 0);
|
||||
if (ptr == MAP_FAILED) {
|
||||
fprintf(stderr, "%s: Can't read \"%s\": %s\n",
|
||||
params.cmdname, params.imagefile,
|
||||
strerror(errno));
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/*
|
||||
* Both calls bellow scan through dumpimage registry for all
|
||||
* supported image types and verify the input image file
|
||||
* header for match
|
||||
*/
|
||||
if (params.iflag) {
|
||||
/*
|
||||
* Extract the data files from within the matched
|
||||
* image type. Returns the error code if not matched
|
||||
*/
|
||||
retval = dumpimage_extract_datafile(ptr, &sbuf);
|
||||
} else {
|
||||
/*
|
||||
* Print the image information for matched image type
|
||||
* Returns the error code if not matched
|
||||
*/
|
||||
retval = dumpimage_verify_print_header(ptr, &sbuf);
|
||||
}
|
||||
|
||||
(void)munmap((void *)ptr, sbuf.st_size);
|
||||
(void)close(ifd);
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
(void)close(ifd);
|
||||
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
static void usage(void)
|
||||
{
|
||||
fprintf(stderr, "Usage: %s -l image\n"
|
||||
" -l ==> list image header information\n",
|
||||
params.cmdname);
|
||||
fprintf(stderr,
|
||||
" %s -i image [-p position] [-o outfile] data_file\n"
|
||||
" -i ==> extract from the 'image' a specific 'data_file'"
|
||||
", indexed by 'position' (starting at 0)\n",
|
||||
params.cmdname);
|
||||
fprintf(stderr,
|
||||
" %s -V ==> print version information and exit\n",
|
||||
params.cmdname);
|
||||
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
/*
|
||||
* Based on mkimage.c.
|
||||
*
|
||||
* Written by Guilherme Maciel Ferreira <guilherme.maciel.ferreira@gmail.com>
|
||||
*
|
||||
* SPDX-License-Identifier: GPL-2.0+
|
||||
*/
|
||||
|
||||
#ifndef _DUMPIMAGE_H_
|
||||
#define _DUMPIMAGE_H_
|
||||
|
||||
#include "os_support.h"
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/stat.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
#include <sha1.h>
|
||||
#include "fdt_host.h"
|
||||
#include "imagetool.h"
|
||||
|
||||
#undef DUMPIMAGE_DEBUG
|
||||
|
||||
#ifdef DUMPIMAGE_DEBUG
|
||||
#define debug(fmt, args...) printf(fmt, ##args)
|
||||
#else
|
||||
#define debug(fmt, args...)
|
||||
#endif /* DUMPIMAGE_DEBUG */
|
||||
|
||||
#endif /* _DUMPIMAGE_H_ */
|
||||
|
|
@ -34,7 +34,9 @@ struct image_tool_params {
|
|||
int dflag;
|
||||
int eflag;
|
||||
int fflag;
|
||||
int iflag;
|
||||
int lflag;
|
||||
int pflag;
|
||||
int vflag;
|
||||
int xflag;
|
||||
int skipcpy;
|
||||
|
|
@ -50,6 +52,7 @@ struct image_tool_params {
|
|||
char *datafile;
|
||||
char *imagefile;
|
||||
char *cmdname;
|
||||
const char *outfile; /* Output filename */
|
||||
const char *keydir; /* Directory holding private keys */
|
||||
const char *keydest; /* Destination .dtb for public key */
|
||||
const char *comment; /* Comment to add to signature node */
|
||||
|
|
@ -96,6 +99,15 @@ struct image_type_params {
|
|||
*/
|
||||
void (*set_header) (void *, struct stat *, int,
|
||||
struct image_tool_params *);
|
||||
/*
|
||||
* This function is used by the command to retrieve a data file from
|
||||
* the image (i.e. dumpimage -i <image> -p <position> <data_file>).
|
||||
* Thus the code to extract a file from an image must be put here.
|
||||
*
|
||||
* Returns 0 if the file was successfully retrieved from the image,
|
||||
* or a negative value on error.
|
||||
*/
|
||||
int (*extract_datafile) (void *, struct image_tool_params *);
|
||||
/*
|
||||
* Some image generation support for ex (default image type) supports
|
||||
* more than one type_ids, this callback function is used to check
|
||||
|
|
|
|||
Loading…
Reference in New Issue