Attachment #251805 for bug #337108

View | Details | Raw Unified | Return to bug 337108
Collapse All | Expand All

Lines 1-8 Link Here

(-)ELFkickers.orig/ebfc/Makefile (-3 lines)
1	# Makefile for ebfc	1	# Makefile for ebfc
2		2
3	CC = gcc
4	CFLAGS = -ggdb -Wall
5
6	ebfc: ebfc.o brainfuck.o libelfparts.a	3	ebfc: ebfc.o brainfuck.o libelfparts.a
7		4
8	ebfc.o: ebfc.c elfparts.h ebfc.h	5	ebfc.o: ebfc.c elfparts.h ebfc.h

Lines 5-10 Link Here

(-)ELFkickers.orig/ebfc/rel.c (+1 lines)
5	*/	5	*/
6		6
7	#include <stdlib.h>	7	#include <stdlib.h>
		8	#include <string.h>
8	#include <linux/elf.h>	9	#include <linux/elf.h>
9	#include "elfparts.h"	10	#include "elfparts.h"
10	#include "gen.h"	11	#include "gen.h"





#include	<stdio.h>
#include	<stdlib.h>
#include	<string.h>
#include	<errno.h>
#include	<stdarg.h>
#include	<unistd.h>

#define	FALSE		0
#endif

#if ELF_CLASS == ELFCLASS32
 #define Elf_Ehdr	Elf32_Ehdr
 #define Elf_Phdr	Elf32_Phdr
 #define Elf_Shdr	Elf32_Shdr
 #define Elf_Sym	Elf32_Sym
 #define Elf_Dyn	Elf32_Dyn
#else
 #define Elf_Ehdr	Elf64_Ehdr
 #define Elf_Phdr	Elf64_Phdr
 #define Elf_Shdr	Elf64_Shdr
 #define Elf_Sym	Elf64_Sym
 #define Elf_Dyn	Elf64_Dyn
#endif


/* Memory allocation error message.
 */
#define	nomem()		(fputs("Out of memory!\n", stderr), exit(EXIT_FAILURE))

 * Global variables
 */

static Elf_Ehdr	elffhdr;	/* ELF header of current file	*/
static Elf_Phdr      *proghdr = NULL;	/* program header table		*/
static Elf_Shdr      *secthdr = NULL;	/* section header table		*/
static char	       *sectstr = NULL;	/* sh string table		*/

static int		proghdrs;	/* FALSE if no ph table		*/
static int		secthdrs;	/* FALSE if no sh table		*/
static Elf_Phdr      *phentry = NULL;	/* ph with the entry point	*/
static Elf_Shdr      *shshstr = NULL;	/* sh with the sh string table	*/

static char const      *thisprog;	/* name of this program		*/
static char const      *thefilename;	/* name of current file		*/

    }
    if (skipID)
	return TRUE;
#if ELF_CLASS == ELFCLASS32
    if (id[EI_CLASS] != ELFCLASS32) {
	fprintf(stderr, "%s: not a 32-bit ELF file "
			"(class = %d instead of %d).\n",

			ELFCLASS32);
	return FALSE;
    }
#else
    if (id[EI_CLASS] != ELFCLASS64) {
	fprintf(stderr, "%s: not a 64-bit ELF file "
			"(class = %d instead of %d).\n",
			thefilename, (int)(unsigned char)id[EI_CLASS],
			ELFCLASS64);
	return FALSE;
    }
#endif
    bigendian = TRUE;
    *(char*)&bigendian = 0;
    if (id[EI_DATA] != (bigendian ? ELFDATA2MSB : ELFDATA2LSB)) {

	return FALSE;
    switch (elffhdr.e_type) {
      case ET_REL:
      case ET_CORE:
      case ET_EXEC:
      case ET_DYN:
	return TRUE;

    }
    if (elffhdr.e_ehsize != sizeof elffhdr)
	fprintf(stderr, "%s: warning: unrecognized ELF header size "
			"(size = %u instead of %lu).\n",
			thefilename, elffhdr.e_ehsize, sizeof elffhdr);
    return TRUE;
}

	return TRUE;
    }
    if (elffhdr.e_phentsize == sizeof *proghdr)
	proghdr = (Elf_Phdr*)buf;
    else {
	fprintf(stderr, "%s: warning: unrecognized program header entry size "
			"(size = %u instead of %lu).\n",
			thefilename, elffhdr.e_phentsize, sizeof *proghdr);
	if (!(proghdr = calloc(elffhdr.e_phnum, sizeof *proghdr)))
	    nomem();

	return TRUE;
    }
    if (elffhdr.e_shentsize == sizeof *secthdr)
	secthdr = (Elf_Shdr*)buf;
    else {
	fprintf(stderr, "%s: warning: unrecognized section header entry size "
			"(size = %u instead of %lu).\n",
			thefilename, elffhdr.e_shentsize, sizeof *secthdr);
	if (!(secthdr = calloc(elffhdr.e_shnum, sizeof *secthdr)))
	    nomem();

 */
static int getsrcfiles(textline **plines)
{
    Elf_Sym  *syms;
    char       *nmstr;
    textline   *lines;
    char       *str;

    lines = gettextlines(count);
    n = 0;
    for (i = 0 ; i < count ; ++i) {
#if ELF_CLASS == ELFCLASS32
	if (ELF32_ST_TYPE(syms[i].st_info) != STT_FILE)
#else
	if (ELF64_ST_TYPE(syms[i].st_info) != STT_FILE)
#endif
	    continue;
	str = nmstr + syms[i].st_name;
	for (j = 0 ; j < n ; ++j)

 */
static int getlibraries(textline **plines)
{
    Elf_Dyn  *dyns;
    char       *nmstr;
    textline   *lines;
    char       *str;

 * offset and size within the file, and the virtual address at which
 * to load the contents.
 */
static void describephdr(textline *line, Elf_Phdr *phdr)
{
    char const *str;
    int		n;

 * within the file, and the section name and the indices of any
 * related sections.
 */
static void describeshdr(textline *line, Elf_Shdr *shdr)
{
    char const *str;
    int		n;

Lines 1-7 Link Here

(-)ELFkickers.orig/elfls/Makefile (-1 / +1 lines)
1	# Makefile for elfls	1	# Makefile for elfls
2		2
3	elfls: elfls.c	3	elfls: elfls.c
4	gcc -ggdb -Wall -W -o elfls elfls.c	4	$(CC) $(CFLAGS) $(LDFLAGS) -W -o elfls elfls.c
5		5
6	clean:	6	clean:
7	rm -f elfls	7	rm -f elfls

Lines 1-9 Link Here

(-)ELFkickers.orig/elftoc/Makefile (-4 lines)
1	# Makefile for elftoc	1	# Makefile for elftoc
2		2
3	CC = gcc
4	CFLAGS = -ggdb -Wall
5	LDFLAGS = $(CFLAGS)
6
7	OBJS = pieces.o addr.o shdrtab.o dynamic.o outbasic.o outtools.o out.o elftoc.o	3	OBJS = pieces.o addr.o shdrtab.o dynamic.o outbasic.o outtools.o out.o elftoc.o
8		4
9	elftoc: $(OBJS)	5	elftoc: $(OBJS)

Lines 5-10 Link Here

(-)ELFkickers.orig/elftoc/shdrtab.c (+1 lines)
5	*/	5	*/
6		6
7	#include <stdlib.h>	7	#include <stdlib.h>
		8	#include <string.h>
8	#include <ctype.h>	9	#include <ctype.h>
9	#include "gen.h"	10	#include "gen.h"
10	#include "elf.h"	11	#include "elf.h"

Line 0 Link Here

(-)ELFkickers.orig/Makefile (+6 lines)
	1	SUBDIRS = ebfc elfls elftoc rebind sstrip
	2
	3	all:
	4	for d in $(SUBDIRS); do cd $$d ; CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS)" CC=$(CC) $(MAKE) ; cd - ; done
	5	clean:
	6	for d in $(SUBDIRS); do cd $$d ; $(MAKE) clean; cd - ; done

Lines 1-7 Link Here

(-)ELFkickers.orig/rebind/Makefile (-1 / +1 lines)
1	# Makefile for rebind	1	# Makefile for rebind
2		2
3	rebind: rebind.c	3	rebind: rebind.c
4	gcc -ggdb -Wall -W -o rebind rebind.c	4	$(CC) $(CFLAGS) $(LDFLAGS) -W -o rebind rebind.c
5		5
6	clean:	6	clean:
7	rm -f rebind	7	rm -f rebind




#include	<string.h>
#include	<errno.h>
#include	<unistd.h>
#include        <elf.h>

#ifndef TRUE
#define	TRUE		1
#define	FALSE		0
#endif

#if ELF_CLASS == ELFCLASS32
 #define Elf_Ehdr       Elf32_Ehdr
 #define Elf_Phdr       Elf32_Phdr
 #define Elf_Shdr       Elf32_Shdr
 #define Elf_Sym        Elf32_Sym
 #define Elf_Dyn        Elf32_Dyn
#else
 #define Elf_Ehdr       Elf64_Ehdr
 #define Elf_Phdr       Elf64_Phdr
 #define Elf_Shdr       Elf64_Shdr
 #define Elf_Sym        Elf64_Sym
 #define Elf_Dyn        Elf64_Dyn
#endif

#ifndef ELF32_ST_INFO
#define ELF32_ST_INFO(b, t) (((b) << 4) + ((t) & 0xF))
#endif

#ifndef ELF64_ST_INFO
#define ELF64_ST_INFO ELF32_ST_INFO /* does not really matter however as they are the same. */
#endif

/* The memory-allocation macro.
 */
#define	alloc(p, n)	(((p) = realloc(p, n))				\

static char const      *thefilename;	/* the current file name */
static FILE	       *thefile;	/* the current file handle */

static Elf_Ehdr	ehdr;		/* the file's ELF header */


/* Standard qsort/bsearch string comparison function.

			thefilename, endianness ? "big" : "little");
	return FALSE;
    }
    if (ehdr.e_ehsize != sizeof(Elf_Ehdr))
	return err("unrecognized ELF header size");
    if (!ehdr.e_shoff)
	return err("no section header table.");
    if (ehdr.e_shentsize != sizeof(Elf_Shdr))
	return err("unrecognized section header size");

    return TRUE;

 * appear in the namelist with the specified binding and alters their
 * binding strength.
 */
static int changesymbols(Elf_Sym *symtab, char const *strtab, int count)
{
    Elf_Sym  *sym;
    char const *name;
    int		touched;
    int		i;

	name = strtab + sym->st_name;
	if (!bsearch(&name, namelist, namecount, sizeof *namelist, qstrcmp))
	    continue;
#if ELF_CLASS == ELFCLASS32
	sym->st_info = ELF32_ST_INFO(tostrength, ELF32_ST_TYPE(sym->st_info));
#else
	sym->st_info = ELF32_ST_INFO(tostrength, ELF64_ST_TYPE(sym->st_info));
#endif
	printf("%s \"%s\".\n", tostrengthtext, name);
	touched = TRUE;
    }

 */
static int rebind(void)
{
    Elf_Shdr *shdrs;
    Elf_Sym  *symtab;
    char       *strtab;
    unsigned	offset, count;
    int		i;

    if (!readheader())
	return FALSE;
    if (!(shdrs = getarea(ehdr.e_shoff, ehdr.e_shnum * sizeof(Elf_Shdr))))
	return err("invalid section header table.");

    for (i = 0 ; i < ehdr.e_shnum ; ++i) {

Lines 1-7 Link Here

(-)ELFkickers.orig/sstrip/Makefile (-1 / +1 lines)
1	# Makefile for sstrip	1	# Makefile for sstrip
2		2
3	sstrip: sstrip.c	3	sstrip: sstrip.c
4	gcc -ggdb -Wall -W -o sstrip sstrip.c	4	$(CC) $(CFLAGS) $(LDFLAGS) -W -o sstrip sstrip.c
5		5
6	clean:	6	clean:
7	rm -f sstrip	7	rm -f sstrip




/* http://www.muppetlabs.com/~breadbox/software/elfkickers.html */

/* sstrip: Copyright (C) 1999-2001 by Brian Raiter, under the GNU
 * General Public License. No warranty. See COPYING for details.
 *
 * Aug 23, 2004 Hacked by Manuel Novoa III <mjn3@codepoet.org> to
 * handle targets of different endianness and/or elf class, making
 * it more useful in a cross-devel environment.
 */

/* ============== original README ===================
 *
 * sstrip is a small utility that removes the contents at the end of an
 * ELF file that are not part of the program's memory image.
 * 
 * Most ELF executables are built with both a program header table and a
 * section header table. However, only the former is required in order
 * for the OS to load, link and execute a program. sstrip attempts to
 * extract the ELF header, the program header table, and its contents,
 * leaving everything else in the bit bucket. It can only remove parts of
 * the file that occur at the end, after the parts to be saved. However,
 * this almost always includes the section header table, and occasionally
 * a few random sections that are not used when running a program.
 * 
 * It should be noted that the GNU bfd library is (understandably)
 * dependent on the section header table as an index to the file's
 * contents. Thus, an executable file that has no section header table
 * cannot be used with gdb, objdump, or any other program based upon the
 * bfd library, at all. In fact, the program will not even recognize the
 * file as a valid executable. (This limitation is noted in the source
 * code comments for bfd, and is marked "FIXME", so this may change at
 * some future date. However, I would imagine that it is a pretty
 * low-priority item, as executables without a section header table are
 * rare in the extreme.) This probably also explains why strip doesn't
 * offer the option to do this.
 * 
 * Shared library files may also have their section header table removed.
 * Such a library will still function; however, it will no longer be
 * possible for a compiler to link a new program against it.
 * 
 * As an added bonus, sstrip also tries to removes trailing zero bytes
 * from the end of the file. (This normally cannot be done with an
 * executable that has a section header table.)
 * 
 * sstrip is a very simplistic program. It depends upon the common
 * practice of putting the parts of the file that contribute to the
 * memory image at the front, and the remaining material at the end. This
 * permits it to discard the latter material without affecting file
 * offsets and memory addresses in what remains. Of course, the ELF
 * standard permits files to be organized in almost any order, so if a
 * pathological linker decided to put its section headers at the top,
 * sstrip would be useless on such executables.
 */

#include	<stdio.h>

#include	<unistd.h>
#include	<fcntl.h>
#include	<elf.h>
#ifdef __FreeBSD__
/**
 * This seems to work on FreeBSD 5.3, should
 * work on all newer versions as well. I have
 * no idea if it will work on versions < 5.3
 *
 * Joe Estock (guru) <jestock at nutextonline.com>
 */
#include <sys/endian.h>
#define bswap_64 __bswap64
#define bswap_32 __bswap32
#define bswap_16 __bswap16
#else
#include	<endian.h>
#include	<byteswap.h>
#endif /* defined(__FreeBSD__) */


#ifndef TRUE
#define	TRUE		1
#define	FALSE		0
#endif

#if ELF_CLASS == ELFCLASS32
#define	Elf_Ehdr	Elf32_Ehdr
#define	Elf_Phdr	Elf32_Phdr
#else
#define	Elf_Ehdr	Elf64_Ehdr
#define	Elf_Phdr	Elf64_Phdr
#endif

/* The name of the program.
 */
static char const	*progname;

/* The name of the current file.
 */
static char const	*filename;


/* A simple error-handling function. FALSE is always returned for the

 */
static int err(char const *errmsg)
{
	fprintf(stderr, "%s: %s: %s\n", progname, filename, errmsg);
	return FALSE;
}

/* A flag to signal the need for endian reversal.
 * errno is not set.
 */
static int do_reverse_endian;

/* Get a value from the elf header, compensating for endianness.
 * checks to make sure that this is in fact a file that we should be
 * munging.
 */
#define EGET(X) \
	(__extension__ ({ \
		uint64_t __res; \
		if (!do_reverse_endian) { \
			__res = (X); \
		} else if (sizeof(X) == 1) { \
			__res = (X); \
		} else if (sizeof(X) == 2) { \
			__res = bswap_16((X)); \
		} else if (sizeof(X) == 4) { \
			__res = bswap_32((X)); \
		} else if (sizeof(X) == 8) { \
			__res = bswap_64((X)); \
		} else { \
			fprintf(stderr, "%s: %s: EGET failed for size %ld\n", \
					progname, filename, sizeof(X)); \
			exit(EXIT_FAILURE); \
		} \
		__res; \
	}))

/* Set a value 'Y' in the elf header to 'X', compensating for endianness.
 */
#define ESET(Y,X) \
		do if (!do_reverse_endian) { \
			Y = (X); \
		} else if (sizeof(Y) == 1) { \
			Y = (X); \
		} else if (sizeof(Y) == 2) { \
			Y = bswap_16((uint16_t)(X)); \
		} else if (sizeof(Y) == 4) { \
			Y = bswap_32((uint32_t)(X)); \
		} else if (sizeof(Y) == 8) { \
			Y = bswap_64((uint64_t)(X)); \
		} else { \
			fprintf(stderr, "%s: %s: ESET failed for size %ld\n", \
					progname, filename, sizeof(Y)); \
			exit(EXIT_FAILURE); \
		} while (0)

    return TRUE;
}

/* A macro for I/O errors: The given error message is used only when
 * errno is not set.
 */
#define	ferr(msg)	(err(errno ? strerror(errno) : (msg)))
{
    size_t	size;

    if (!ehdr->e_phoff || !ehdr->e_phnum)
	return err("ELF file has no program header table.");

    size = ehdr->e_phnum * sizeof **phdrs;
    if (!(*phdrs = malloc(size)))
	return err("Out of memory!");

    errno = 0;
    if (read(fd, *phdrs, size) != (ssize_t)size)
	return ferr("missing or incomplete program segment header table.");

#define HEADER_FUNCTIONS(CLASS) \
 \
/* readelfheader() reads the ELF header into our global variable, and \
 * checks to make sure that this is in fact a file that we should be \
 * munging. \
 */ \
static int readelfheader ## CLASS (int fd, Elf ## CLASS ## _Ehdr *ehdr) \
{ \
	 if (read(fd, ((char *)ehdr)+EI_NIDENT, sizeof(*ehdr) - EI_NIDENT) \
		!= sizeof(*ehdr) - EI_NIDENT) \
		return ferr("missing or incomplete ELF header."); \
 \
	/* Verify the sizes of the ELF header and the program segment \
	 * header table entries. \
	 */ \
	if (EGET(ehdr->e_ehsize) != sizeof(Elf ## CLASS ## _Ehdr)) \
		return err("unrecognized ELF header size."); \
	if (EGET(ehdr->e_phentsize) != sizeof(Elf ## CLASS ## _Phdr)) \
		return err("unrecognized program segment header size."); \
 \
	/* Finally, check the file type. \
	 */ \
	if (EGET(ehdr->e_type) != ET_EXEC && EGET(ehdr->e_type) != ET_DYN) \
		return err("not an executable or shared-object library."); \
 \
	return TRUE; \
} \
 \
/* readphdrtable() loads the program segment header table into memory. \
 */ \
static int readphdrtable ## CLASS (int fd, Elf ## CLASS ## _Ehdr const *ehdr, \
								   Elf ## CLASS ## _Phdr **phdrs) \
{ \
	size_t	size; \
 \
	if (!EGET(ehdr->e_phoff) || !EGET(ehdr->e_phnum) \
)		return err("ELF file has no program header table."); \
 \
	size = EGET(ehdr->e_phnum) * sizeof **phdrs; \
	if (!(*phdrs = malloc(size))) \
		return err("Out of memory!"); \
 \
	errno = 0; \
	if (read(fd, *phdrs, size) != (ssize_t)size) \
		return ferr("missing or incomplete program segment header table."); \
 \
	return TRUE; \
} \
 \
/* getmemorysize() determines the offset of the last byte of the file \
 * that is referenced by an entry in the program segment header table. \
 * (Anything in the file after that point is not used when the program \
 * is executing, and thus can be safely discarded.) \
 */ \
static int getmemorysize ## CLASS (Elf ## CLASS ## _Ehdr const *ehdr, \
								   Elf ## CLASS ## _Phdr const *phdrs, \
						 unsigned long *newsize) \
{ \
	Elf ## CLASS ## _Phdr const   *phdr; \
	unsigned long	size, n; \
	int			i; \
 \
	/* Start by setting the size to include the ELF header and the \
	 * complete program segment header table. \
	 */ \
	size = EGET(ehdr->e_phoff) + EGET(ehdr->e_phnum) * sizeof *phdrs; \
	if (size < sizeof *ehdr) \
		size = sizeof *ehdr; \
 \
	/* Then keep extending the size to include whatever data the \
	 * program segment header table references. \
	 */ \
	for (i = 0, phdr = phdrs ; i < EGET(ehdr->e_phnum) ; ++i, ++phdr) { \
		if (EGET(phdr->p_type) != PT_NULL) { \
			n = EGET(phdr->p_offset) + EGET(phdr->p_filesz); \
			if (n > size) \
				size = n; \
		} \
	} \
 \
	*newsize = size; \
	return TRUE; \
} \
 \
/* modifyheaders() removes references to the section header table if \
 * it was stripped, and reduces program header table entries that \
 * included truncated bytes at the end of the file. \
 */ \
static int modifyheaders ## CLASS (Elf ## CLASS ## _Ehdr *ehdr, \
								   Elf ## CLASS ## _Phdr *phdrs, \
								   unsigned long newsize) \
{ \
	Elf ## CLASS ## _Phdr *phdr; \
	int		i; \
 \
	/* If the section header table is gone, then remove all references \
	 * to it in the ELF header. \
	 */ \
	if (EGET(ehdr->e_shoff) >= newsize) { \
		ESET(ehdr->e_shoff,0); \
		ESET(ehdr->e_shnum,0); \
		ESET(ehdr->e_shentsize,0); \
		ESET(ehdr->e_shstrndx,0); \
	} \
 \
	/* The program adjusts the file size of any segment that was \
	 * truncated. The case of a segment being completely stripped out \
	 * is handled separately. \
	 */ \
	for (i = 0, phdr = phdrs ; i < EGET(ehdr->e_phnum) ; ++i, ++phdr) { \
		if (EGET(phdr->p_offset) >= newsize) { \
			ESET(phdr->p_offset,newsize); \
			ESET(phdr->p_filesz,0); \
		} else if (EGET(phdr->p_offset) + EGET(phdr->p_filesz) > newsize) { \
			newsize -= EGET(phdr->p_offset); \
			ESET(phdr->p_filesz, newsize); \
		} \
	} \
 \
	return TRUE; \
} \
 \
/* commitchanges() writes the new headers back to the original file \
 * and sets the file to its new size. \
 */ \
static int commitchanges ## CLASS (int fd, Elf ## CLASS ## _Ehdr const *ehdr, \
								   Elf ## CLASS ## _Phdr *phdrs, \
								   unsigned long newsize) \
{ \
	size_t	n; \
 \
	/* Save the changes to the ELF header, if any. \
	 */ \
	if (lseek(fd, 0, SEEK_SET)) \
		return ferr("could not rewind file"); \
	errno = 0; \
	if (write(fd, ehdr, sizeof *ehdr) != sizeof *ehdr) \
		return err("could not modify file"); \
 \
	/* Save the changes to the program segment header table, if any. \
	 */ \
	if (lseek(fd, EGET(ehdr->e_phoff), SEEK_SET) == (off_t)-1) { \
		err("could not seek in file."); \
		goto warning; \
	} \
	n = EGET(ehdr->e_phnum) * sizeof *phdrs; \
	if (write(fd, phdrs, n) != (ssize_t)n) { \
		err("could not write to file"); \
		goto warning; \
	} \
 \
	/* Eleventh-hour sanity check: don't truncate before the end of \
	 * the program segment header table. \
	 */ \
	if (newsize < EGET(ehdr->e_phoff) + n) \
		newsize = EGET(ehdr->e_phoff) + n; \
 \
	/* Chop off the end of the file. \
	 */ \
	if (ftruncate(fd, newsize)) { \
		err("could not resize file"); \
		goto warning; \
	} \
 \
	return TRUE; \
 \
 warning: \
	return err("ELF file may have been corrupted!"); \
}

/* getmemorysize() determines the offset of the last byte of the file
 * that is referenced by an entry in the program segment header table.
 * (Anything in the file after that point is not used when the program
 * is executing, and thus can be safely discarded.)
 */
static int getmemorysize(Elf_Ehdr const *ehdr, Elf_Phdr const *phdrs,
			 unsigned long *newsize)
{
    Elf32_Phdr const   *phdr;
    unsigned long	size, n;
    int			i;

    /* Start by setting the size to include the ELF header and the
     * complete program segment header table.
     */
    size = ehdr->e_phoff + ehdr->e_phnum * sizeof *phdrs;
    if (size < sizeof *ehdr)
	size = sizeof *ehdr;

    /* Then keep extending the size to include whatever data the
     * program segment header table references.
     */
    for (i = 0, phdr = phdrs ; i < ehdr->e_phnum ; ++i, ++phdr) {
	if (phdr->p_type != PT_NULL) {
	    n = phdr->p_offset + phdr->p_filesz;
	    if (n > size)
		size = n;
	}
    }

    *newsize = size;
    return TRUE;
}

/* First elements of Elf32_Ehdr and Elf64_Ehdr are common.
 * size-to-be, and reduces the size to exclude any trailing zero
 * bytes.
 */
static int readelfheaderident(int fd, Elf32_Ehdr *ehdr)
{
	errno = 0;
	if (read(fd, ehdr, EI_NIDENT) != EI_NIDENT)
		return ferr("missing or incomplete ELF header.");

	/* Check the ELF signature.
	 */
	if (!(ehdr->e_ident[EI_MAG0] == ELFMAG0 &&
		  ehdr->e_ident[EI_MAG1] == ELFMAG1 &&
		  ehdr->e_ident[EI_MAG2] == ELFMAG2 &&
		  ehdr->e_ident[EI_MAG3] == ELFMAG3))
	{
		err("missing ELF signature.");
		return -1;
	}

	/* Compare the file's class and endianness with the program's.
	 */
#if __BYTE_ORDER == __LITTLE_ENDIAN
	if (ehdr->e_ident[EI_DATA] == ELFDATA2LSB) {
		do_reverse_endian = 0;
	} else if (ehdr->e_ident[EI_DATA] == ELFDATA2MSB) {
/* 		fprintf(stderr, "ELF file has different endianness.\n"); */
		do_reverse_endian = 1;
	}
#elif __BYTE_ORDER == __BIG_ENDIAN
	if (ehdr->e_ident[EI_DATA] == ELFDATA2LSB) {
/* 		fprintf(stderr, "ELF file has different endianness.\n"); */
		do_reverse_endian = 1;
	} else if (ehdr->e_ident[EI_DATA] == ELFDATA2MSB) {
		do_reverse_endian = 0;
	}
#else
#error unkown endianness
#endif
	else {
		err("Unsupported endianness");
		return -1;
	}

	/* Check the target architecture.
	 */
/*	 if (EGET(ehdr->e_machine) != ELF_ARCH) { */
/* 		/\* return err("ELF file created for different architecture."); *\/ */
/* 		fprintf(stderr, "ELF file created for different architecture.\n"); */
/* 	} */
	return ehdr->e_ident[EI_CLASS];
}

/* modifyheaders() removes references to the section header table if
 * it was stripped, and reduces program header table entries that
 * included truncated bytes at the end of the file.
 */
static int modifyheaders(Elf_Ehdr *ehdr, Elf_Phdr *phdrs,
			 unsigned long newsize)
{
    Elf32_Phdr *phdr;
    int		i;

HEADER_FUNCTIONS(32)
     * to it in the ELF header.
     */
    if (ehdr->e_shoff >= newsize) {
	ehdr->e_shoff = 0;
	ehdr->e_shnum = 0;
	ehdr->e_shentsize = 0;
	ehdr->e_shstrndx = 0;
    }

    /* The program adjusts the file size of any segment that was
     * truncated. The case of a segment being completely stripped out
     * is handled separately.
     */
    for (i = 0, phdr = phdrs ; i < ehdr->e_phnum ; ++i, ++phdr) {
	if (phdr->p_offset >= newsize) {
	    phdr->p_offset = newsize;
	    phdr->p_filesz = 0;
	} else if (phdr->p_offset + phdr->p_filesz > newsize) {
	    phdr->p_filesz = newsize - phdr->p_offset;
	}
    }

HEADER_FUNCTIONS(64)
}

/* truncatezeros() examines the bytes at the end of the file's
 * size-to-be, and reduces the size to exclude any trailing zero
 * bytes.
 */
static int truncatezeros(int fd, unsigned long *newsize)
			 unsigned long newsize)
{
	unsigned char	contents[1024];
	unsigned long	size, n;
    /* Save the changes to the ELF header, if any.
     */
    if (lseek(fd, 0, SEEK_SET))
	return ferr("could not rewind file");
    errno = 0;
    if (write(fd, ehdr, sizeof *ehdr) != sizeof *ehdr)
	return err("could not modify file");

    /* Save the changes to the program segment header table, if any.
     */
    if (lseek(fd, ehdr->e_phoff, SEEK_SET) == (off_t)-1) {
	err("could not seek in file.");
	goto warning;
    }
    n = ehdr->e_phnum * sizeof *phdrs;
    if (write(fd, phdrs, n) != (ssize_t)n) {
	err("could not write to file");
	goto warning;
    }

    /* Eleventh-hour sanity check: don't truncate before the end of
     * the program segment header table.
     */
    if (newsize < ehdr->e_phoff + n)
	newsize = ehdr->e_phoff + n;

    /* Chop off the end of the file.
     */
    if (ftruncate(fd, newsize)) {
	err("could not resize file");
	goto warning;
    }

	size = *newsize;
	do {
		n = sizeof contents;
		if (n > size)
			n = size;
		if (lseek(fd, size - n, SEEK_SET) == (off_t)-1)
			return ferr("cannot seek in file.");
		if (read(fd, contents, n) != (ssize_t)n)
			return ferr("cannot read file contents");
		while (n && !contents[--n])
			--size;
	} while (size && !n);

	/* Sanity check.
	 */
	if (!size)
		return err("ELF file is completely blank!");

	*newsize = size;
	return TRUE;
}

/* main() loops over the cmdline arguments, leaving all the real work

 */
int main(int argc, char *argv[])
{
	int				fd;
	union {
		Elf32_Ehdr	ehdr32;
		Elf64_Ehdr	ehdr64;
	} e;
	union {
		Elf32_Phdr	*phdrs32;
		Elf64_Phdr	*phdrs64;
	} p;
	unsigned long	newsize;
	char			**arg;
	int				failures = 0;

	if (argc < 2 || argv[1][0] == '-') {
		printf("Usage: sstrip FILE...\n"
			   "sstrip discards all nonessential bytes from an executable.\n\n"
			   "Version 2.0-X Copyright (C) 2000,2001 Brian Raiter.\n"
			   "Cross-devel hacks Copyright (C) 2004 Manuel Novoa III.\n"
			   "This program is free software, licensed under the GNU\n"
			   "General Public License. There is absolutely no warranty.\n");
		return EXIT_SUCCESS;
	fd = open(*arg, O_RDWR);
	if (fd < 0) {
	    ferr("can't open");
	    ++failures;
	    continue;
	}

	progname = argv[0];
	      readphdrtable(fd, &ehdr, &phdrs)		&&
	      getmemorysize(&ehdr, phdrs, &newsize)	&&
	      truncatezeros(fd, &newsize)		&&
	      modifyheaders(&ehdr, phdrs, newsize)	&&
	      commitchanges(fd, &ehdr, phdrs, newsize)))
	    ++failures;

	for (arg = argv + 1 ; *arg != NULL ; ++arg) {
		filename = *arg;

		fd = open(*arg, O_RDWR);
		if (fd < 0) {
			ferr("can't open");
			++failures;
			continue;
		}

		switch (readelfheaderident(fd, &e.ehdr32)) {
			case ELFCLASS32:
				if (!(readelfheader32(fd, &e.ehdr32)				&&
					  readphdrtable32(fd, &e.ehdr32, &p.phdrs32)		&&
					  getmemorysize32(&e.ehdr32, p.phdrs32, &newsize)	&&
					  truncatezeros(fd, &newsize)				&&
					  modifyheaders32(&e.ehdr32, p.phdrs32, newsize)	&&
					  commitchanges32(fd, &e.ehdr32, p.phdrs32, newsize)))
					++failures;
				break;
			case ELFCLASS64:
				if (!(readelfheader64(fd, &e.ehdr64)				&&
					  readphdrtable64(fd, &e.ehdr64, &p.phdrs64)		&&
					  getmemorysize64(&e.ehdr64, p.phdrs64, &newsize)	&&
					  truncatezeros(fd, &newsize)				&&
					  modifyheaders64(&e.ehdr64, p.phdrs64, newsize)	&&
					  commitchanges64(fd, &e.ehdr64, p.phdrs64, newsize)))
					++failures;
				break;
			default:
				++failures;
				break;
		}
		close(fd);
	}

	return failures ? EXIT_FAILURE : EXIT_SUCCESS;
}

Return to bug 337108

Lines 4-9 Link Here

(-)ELFkickers.orig/elfls/elfls.c (-14 / +45 lines)
4		4
5	#include <stdio.h>	5	#include <stdio.h>
6	#include <stdlib.h>	6	#include <stdlib.h>
		7	#include <string.h>
7	#include <errno.h>	8	#include <errno.h>
8	#include <stdarg.h>	9	#include <stdarg.h>
9	#include <unistd.h>	10	#include <unistd.h>
Lines 15-20 Link Here
15	#define FALSE 0	16	#define FALSE 0
16	#endif	17	#endif
17		18
		19	#if ELF_CLASS == ELFCLASS32
		20	#define Elf_Ehdr Elf32_Ehdr
		21	#define Elf_Phdr Elf32_Phdr
		22	#define Elf_Shdr Elf32_Shdr
		23	#define Elf_Sym Elf32_Sym
		24	#define Elf_Dyn Elf32_Dyn
		25	#else
		26	#define Elf_Ehdr Elf64_Ehdr
		27	#define Elf_Phdr Elf64_Phdr
		28	#define Elf_Shdr Elf64_Shdr
		29	#define Elf_Sym Elf64_Sym
		30	#define Elf_Dyn Elf64_Dyn
		31	#endif
		32
		33
18	/* Memory allocation error message.	34	/* Memory allocation error message.
19	*/	35	*/
20	#define nomem() (fputs("Out of memory!\n", stderr), exit(EXIT_FAILURE))	36	#define nomem() (fputs("Out of memory!\n", stderr), exit(EXIT_FAILURE))
Lines 51-65 Link Here
51	* Global variables	67	* Global variables
52	*/	68	*/
53		69
54	static Elf32_Ehdr elffhdr; /* ELF header of current file */	70	static Elf_Ehdr elffhdr; /* ELF header of current file */
55	static Elf32_Phdr proghdr = NULL; / program header table */	71	static Elf_Phdr proghdr = NULL; / program header table */
56	static Elf32_Shdr secthdr = NULL; / section header table */	72	static Elf_Shdr secthdr = NULL; / section header table */
57	static char sectstr = NULL; / sh string table */	73	static char sectstr = NULL; / sh string table */
58		74
59	static int proghdrs; /* FALSE if no ph table */	75	static int proghdrs; /* FALSE if no ph table */
60	static int secthdrs; /* FALSE if no sh table */	76	static int secthdrs; /* FALSE if no sh table */
61	static Elf32_Phdr phentry = NULL; / ph with the entry point */	77	static Elf_Phdr phentry = NULL; / ph with the entry point */
62	static Elf32_Shdr shshstr = NULL; / sh with the sh string table */	78	static Elf_Shdr shshstr = NULL; / sh with the sh string table */
63		79
64	static char const thisprog; / name of this program */	80	static char const thisprog; / name of this program */
65	static char const thefilename; / name of current file */	81	static char const thefilename; / name of current file */
Lines 272-277 Link Here
272	}	288	}
273	if (skipID)	289	if (skipID)
274	return TRUE;	290	return TRUE;
		291	#if ELF_CLASS == ELFCLASS32
275	if (id[EI_CLASS] != ELFCLASS32) {	292	if (id[EI_CLASS] != ELFCLASS32) {
276	fprintf(stderr, "%s: not a 32-bit ELF file "	293	fprintf(stderr, "%s: not a 32-bit ELF file "
277	"(class = %d instead of %d).\n",	294	"(class = %d instead of %d).\n",
Lines 279-284 Link Here
279	ELFCLASS32);	296	ELFCLASS32);
280	return FALSE;	297	return FALSE;
281	}	298	}
		299	#else
		300	if (id[EI_CLASS] != ELFCLASS64) {
		301	fprintf(stderr, "%s: not a 64-bit ELF file "
		302	"(class = %d instead of %d).\n",
		303	thefilename, (int)(unsigned char)id[EI_CLASS],
		304	ELFCLASS64);
		305	return FALSE;
		306	}
		307	#endif
282	bigendian = TRUE;	308	bigendian = TRUE;
283	(char)&bigendian = 0;	309	(char)&bigendian = 0;
284	if (id[EI_DATA] != (bigendian ? ELFDATA2MSB : ELFDATA2LSB)) {	310	if (id[EI_DATA] != (bigendian ? ELFDATA2MSB : ELFDATA2LSB)) {
Lines 316-321 Link Here
316	return FALSE;	342	return FALSE;
317	switch (elffhdr.e_type) {	343	switch (elffhdr.e_type) {
318	case ET_REL:	344	case ET_REL:
		345	case ET_CORE:
319	case ET_EXEC:	346	case ET_EXEC:
320	case ET_DYN:	347	case ET_DYN:
321	return TRUE;	348	return TRUE;
Lines 333-339 Link Here
333	}	360	}
334	if (elffhdr.e_ehsize != sizeof elffhdr)	361	if (elffhdr.e_ehsize != sizeof elffhdr)
335	fprintf(stderr, "%s: warning: unrecognized ELF header size "	362	fprintf(stderr, "%s: warning: unrecognized ELF header size "
336	"(size = %u instead of %u).\n",	363	"(size = %u instead of %lu).\n",
337	thefilename, elffhdr.e_ehsize, sizeof elffhdr);	364	thefilename, elffhdr.e_ehsize, sizeof elffhdr);
338	return TRUE;	365	return TRUE;
339	}	366	}
Lines 358-367 Link Here
358	return TRUE;	385	return TRUE;
359	}	386	}
360	if (elffhdr.e_phentsize == sizeof *proghdr)	387	if (elffhdr.e_phentsize == sizeof *proghdr)
361	proghdr = (Elf32_Phdr*)buf;	388	proghdr = (Elf_Phdr*)buf;
362	else {	389	else {
363	fprintf(stderr, "%s: warning: unrecognized program header entry size "	390	fprintf(stderr, "%s: warning: unrecognized program header entry size "
364	"(size = %u instead of %u).\n",	391	"(size = %u instead of %lu).\n",
365	thefilename, elffhdr.e_phentsize, sizeof *proghdr);	392	thefilename, elffhdr.e_phentsize, sizeof *proghdr);
366	if (!(proghdr = calloc(elffhdr.e_phnum, sizeof *proghdr)))	393	if (!(proghdr = calloc(elffhdr.e_phnum, sizeof *proghdr)))
367	nomem();	394	nomem();
Lines 405-414 Link Here
405	return TRUE;	432	return TRUE;
406	}	433	}
407	if (elffhdr.e_shentsize == sizeof *secthdr)	434	if (elffhdr.e_shentsize == sizeof *secthdr)
408	secthdr = (Elf32_Shdr*)buf;	435	secthdr = (Elf_Shdr*)buf;
409	else {	436	else {
410	fprintf(stderr, "%s: warning: unrecognized section header entry size "	437	fprintf(stderr, "%s: warning: unrecognized section header entry size "
411	"(size = %u instead of %u).\n",	438	"(size = %u instead of %lu).\n",
412	thefilename, elffhdr.e_shentsize, sizeof *secthdr);	439	thefilename, elffhdr.e_shentsize, sizeof *secthdr);
413	if (!(secthdr = calloc(elffhdr.e_shnum, sizeof *secthdr)))	440	if (!(secthdr = calloc(elffhdr.e_shnum, sizeof *secthdr)))
414	nomem();	441	nomem();
Lines 436-442 Link Here
436	*/	463	*/
437	static int getsrcfiles(textline **plines)	464	static int getsrcfiles(textline **plines)
438	{	465	{
439	Elf32_Sym *syms;	466	Elf_Sym *syms;
440	char *nmstr;	467	char *nmstr;
441	textline *lines;	468	textline *lines;
442	char *str;	469	char *str;
Lines 460-466 Link Here
460	lines = gettextlines(count);	487	lines = gettextlines(count);
461	n = 0;	488	n = 0;
462	for (i = 0 ; i < count ; ++i) {	489	for (i = 0 ; i < count ; ++i) {
		490	#if ELF_CLASS == ELFCLASS32
463	if (ELF32_ST_TYPE(syms[i].st_info) != STT_FILE)	491	if (ELF32_ST_TYPE(syms[i].st_info) != STT_FILE)
		492	#else
		493	if (ELF64_ST_TYPE(syms[i].st_info) != STT_FILE)
		494	#endif
464	continue;	495	continue;
465	str = nmstr + syms[i].st_name;	496	str = nmstr + syms[i].st_name;
466	for (j = 0 ; j < n ; ++j)	497	for (j = 0 ; j < n ; ++j)
Lines 488-494 Link Here
488	*/	519	*/
489	static int getlibraries(textline **plines)	520	static int getlibraries(textline **plines)
490	{	521	{
491	Elf32_Dyn *dyns;	522	Elf_Dyn *dyns;
492	char *nmstr;	523	char *nmstr;
493	textline *lines;	524	textline *lines;
494	char *str;	525	char *str;
Lines 581-587 Link Here
581	* offset and size within the file, and the virtual address at which	612	* offset and size within the file, and the virtual address at which
582	* to load the contents.	613	* to load the contents.
583	*/	614	*/
584	static void describephdr(textline line, Elf32_Phdr phdr)	615	static void describephdr(textline line, Elf_Phdr phdr)
585	{	616	{
586	char const *str;	617	char const *str;
587	int n;	618	int n;
Lines 646-652 Link Here
646	* within the file, and the section name and the indices of any	677	* within the file, and the section name and the indices of any
647	* related sections.	678	* related sections.
648	*/	679	*/
649	static void describeshdr(textline line, Elf32_Shdr shdr)	680	static void describeshdr(textline line, Elf_Shdr shdr)
650	{	681	{
651	char const *str;	682	char const *str;
652	int n;	683	int n;

Lines 7-23 Link Here

(-)ELFkickers.orig/rebind/rebind.c (-9 / +31 lines)
7	#include <string.h>	7	#include <string.h>
8	#include <errno.h>	8	#include <errno.h>
9	#include <unistd.h>	9	#include <unistd.h>
10	#include <linux/elf.h>	10	#include <elf.h>
11		11
12	#ifndef TRUE	12	#ifndef TRUE
13	#define TRUE 1	13	#define TRUE 1
14	#define FALSE 0	14	#define FALSE 0
15	#endif	15	#endif
16		16
		17	#if ELF_CLASS == ELFCLASS32
		18	#define Elf_Ehdr Elf32_Ehdr
		19	#define Elf_Phdr Elf32_Phdr
		20	#define Elf_Shdr Elf32_Shdr
		21	#define Elf_Sym Elf32_Sym
		22	#define Elf_Dyn Elf32_Dyn
		23	#else
		24	#define Elf_Ehdr Elf64_Ehdr
		25	#define Elf_Phdr Elf64_Phdr
		26	#define Elf_Shdr Elf64_Shdr
		27	#define Elf_Sym Elf64_Sym
		28	#define Elf_Dyn Elf64_Dyn
		29	#endif
		30
17	#ifndef ELF32_ST_INFO	31	#ifndef ELF32_ST_INFO
18	#define ELF32_ST_INFO(b, t) (((b) << 4) + ((t) & 0xF))	32	#define ELF32_ST_INFO(b, t) (((b) << 4) + ((t) & 0xF))
19	#endif	33	#endif
20		34
		35	#ifndef ELF64_ST_INFO
		36	#define ELF64_ST_INFO ELF32_ST_INFO /* does not really matter however as they are the same. */
		37	#endif
		38
21	/* The memory-allocation macro.	39	/* The memory-allocation macro.
22	*/	40	*/
23	#define alloc(p, n) (((p) = realloc(p, n)) \	41	#define alloc(p, n) (((p) = realloc(p, n)) \
Lines 50-56 Link Here
50	static char const thefilename; / the current file name */	68	static char const thefilename; / the current file name */
51	static FILE thefile; / the current file handle */	69	static FILE thefile; / the current file handle */
52		70
53	static Elf32_Ehdr ehdr; /* the file's ELF header */	71	static Elf_Ehdr ehdr; /* the file's ELF header */
54		72
55		73
56	/* Standard qsort/bsearch string comparison function.	74	/* Standard qsort/bsearch string comparison function.
Lines 136-146 Link Here
136	thefilename, endianness ? "big" : "little");	154	thefilename, endianness ? "big" : "little");
137	return FALSE;	155	return FALSE;
138	}	156	}
139	if (ehdr.e_ehsize != sizeof(Elf32_Ehdr))	157	if (ehdr.e_ehsize != sizeof(Elf_Ehdr))
140	return err("unrecognized ELF header size");	158	return err("unrecognized ELF header size");
141	if (!ehdr.e_shoff)	159	if (!ehdr.e_shoff)
142	return err("no section header table.");	160	return err("no section header table.");
143	if (ehdr.e_shentsize != sizeof(Elf32_Shdr))	161	if (ehdr.e_shentsize != sizeof(Elf_Shdr))
144	return err("unrecognized section header size");	162	return err("unrecognized section header size");
145		163
146	return TRUE;	164	return TRUE;
Lines 150-158 Link Here
150	* appear in the namelist with the specified binding and alters their	168	* appear in the namelist with the specified binding and alters their
151	* binding strength.	169	* binding strength.
152	*/	170	*/
153	static int changesymbols(Elf32_Sym symtab, char const strtab, int count)	171	static int changesymbols(Elf_Sym symtab, char const strtab, int count)
154	{	172	{
155	Elf32_Sym *sym;	173	Elf_Sym *sym;
156	char const *name;	174	char const *name;
157	int touched;	175	int touched;
158	int i;	176	int i;
Lines 164-170 Link Here
164	name = strtab + sym->st_name;	182	name = strtab + sym->st_name;
165	if (!bsearch(&name, namelist, namecount, sizeof *namelist, qstrcmp))	183	if (!bsearch(&name, namelist, namecount, sizeof *namelist, qstrcmp))
166	continue;	184	continue;
		185	#if ELF_CLASS == ELFCLASS32
167	sym->st_info = ELF32_ST_INFO(tostrength, ELF32_ST_TYPE(sym->st_info));	186	sym->st_info = ELF32_ST_INFO(tostrength, ELF32_ST_TYPE(sym->st_info));
		187	#else
		188	sym->st_info = ELF32_ST_INFO(tostrength, ELF64_ST_TYPE(sym->st_info));
		189	#endif
168	printf("%s \"%s\".\n", tostrengthtext, name);	190	printf("%s \"%s\".\n", tostrengthtext, name);
169	touched = TRUE;	191	touched = TRUE;
170	}	192	}
Lines 181-195 Link Here
181	*/	203	*/
182	static int rebind(void)	204	static int rebind(void)
183	{	205	{
184	Elf32_Shdr *shdrs;	206	Elf_Shdr *shdrs;
185	Elf32_Sym *symtab;	207	Elf_Sym *symtab;
186	char *strtab;	208	char *strtab;
187	unsigned offset, count;	209	unsigned offset, count;
188	int i;	210	int i;
189		211
190	if (!readheader())	212	if (!readheader())
191	return FALSE;	213	return FALSE;
192	if (!(shdrs = getarea(ehdr.e_shoff, ehdr.e_shnum * sizeof(Elf32_Shdr))))	214	if (!(shdrs = getarea(ehdr.e_shoff, ehdr.e_shnum * sizeof(Elf_Shdr))))
193	return err("invalid section header table.");	215	return err("invalid section header table.");
194		216
195	for (i = 0 ; i < ehdr.e_shnum ; ++i) {	217	for (i = 0 ; i < ehdr.e_shnum ; ++i) {