455 lines
10 KiB
C
455 lines
10 KiB
C
/*-
|
|
* Copyright (c) 2007 S.Sam Arun Raj
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
|
|
#include <ctype.h>
|
|
#include <err.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <getopt.h>
|
|
#include <inttypes.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include <libelf.h>
|
|
#include <libelftc.h>
|
|
#include <gelf.h>
|
|
|
|
#include "_elftc.h"
|
|
|
|
ELFTC_VCSID("$Id: strings.c 2351 2011-12-19 11:20:37Z jkoshy $");
|
|
|
|
enum return_code {
|
|
RETURN_OK,
|
|
RETURN_NOINPUT,
|
|
RETURN_SOFTWARE
|
|
};
|
|
|
|
enum radix_style {
|
|
RADIX_DECIMAL,
|
|
RADIX_HEX,
|
|
RADIX_OCTAL
|
|
};
|
|
|
|
enum encoding_style {
|
|
ENCODING_7BIT,
|
|
ENCODING_8BIT,
|
|
ENCODING_16BIT_BIG,
|
|
ENCODING_16BIT_LITTLE,
|
|
ENCODING_32BIT_BIG,
|
|
ENCODING_32BIT_LITTLE
|
|
};
|
|
|
|
#define PRINTABLE(c) \
|
|
((c) >= 0 && (c) <= 255 && \
|
|
((c) == '\t' || isprint((c)) || \
|
|
(encoding == ENCODING_8BIT && (c) > 127)))
|
|
|
|
|
|
int encoding_size, entire_file, min_len, show_filename, show_loc;
|
|
enum encoding_style encoding;
|
|
enum radix_style radix;
|
|
|
|
static struct option strings_longopts[] = {
|
|
{ "all", no_argument, NULL, 'a'},
|
|
{ "bytes", required_argument, NULL, 'n'},
|
|
{ "encoding", required_argument, NULL, 'e'},
|
|
{ "help", no_argument, NULL, 'h'},
|
|
{ "print-file-name", no_argument, NULL, 'f'},
|
|
{ "radix", required_argument, NULL, 't'},
|
|
{ "version", no_argument, NULL, 'v'},
|
|
{ NULL, 0, NULL, 0 }
|
|
};
|
|
|
|
long getcharacter(void);
|
|
int handle_file(const char *);
|
|
int handle_elf(const char *, int);
|
|
int handle_binary(const char *, int);
|
|
int find_strings(const char *, off_t, off_t);
|
|
void show_version(void);
|
|
void usage(void);
|
|
|
|
/*
|
|
* strings(1) extracts text(contiguous printable characters)
|
|
* from elf and binary files.
|
|
*/
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
int ch, rc;
|
|
|
|
rc = RETURN_OK;
|
|
min_len = 0;
|
|
encoding_size = 1;
|
|
if (elf_version(EV_CURRENT) == EV_NONE)
|
|
errx(EXIT_FAILURE, "ELF library initialization failed: %s",
|
|
elf_errmsg(-1));
|
|
|
|
while ((ch = getopt_long(argc, argv, "1234567890ae:fhn:ot:Vv",
|
|
strings_longopts, NULL)) != -1)
|
|
switch((char)ch) {
|
|
case 'a':
|
|
entire_file = 1;
|
|
break;
|
|
case 'e':
|
|
if (*optarg == 's') {
|
|
encoding = ENCODING_7BIT;
|
|
} else if (*optarg == 'S') {
|
|
encoding = ENCODING_8BIT;
|
|
} else if (*optarg == 'b') {
|
|
encoding = ENCODING_16BIT_BIG;
|
|
encoding_size = 2;
|
|
} else if (*optarg == 'B') {
|
|
encoding = ENCODING_32BIT_BIG;
|
|
encoding_size = 4;
|
|
} else if (*optarg == 'l') {
|
|
encoding = ENCODING_16BIT_LITTLE;
|
|
encoding_size = 2;
|
|
} else if (*optarg == 'L') {
|
|
encoding = ENCODING_32BIT_LITTLE;
|
|
encoding_size = 4;
|
|
} else
|
|
usage();
|
|
/* NOTREACHED */
|
|
break;
|
|
case 'f':
|
|
show_filename = 1;
|
|
break;
|
|
case 'n':
|
|
min_len = (int)strtoimax(optarg, (char**)NULL, 10);
|
|
break;
|
|
case 'o':
|
|
show_loc = 1;
|
|
radix = RADIX_OCTAL;
|
|
break;
|
|
case 't':
|
|
show_loc = 1;
|
|
if (*optarg == 'd')
|
|
radix = RADIX_DECIMAL;
|
|
else if (*optarg == 'o')
|
|
radix = RADIX_OCTAL;
|
|
else if (*optarg == 'x')
|
|
radix = RADIX_HEX;
|
|
else
|
|
usage();
|
|
/* NOTREACHED */
|
|
break;
|
|
case 'v':
|
|
case 'V':
|
|
show_version();
|
|
/* NOTREACHED */
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
min_len *= 10;
|
|
min_len += ch - '0';
|
|
break;
|
|
case 'h':
|
|
case '?':
|
|
default:
|
|
usage();
|
|
/* NOTREACHED */
|
|
}
|
|
argc -= optind;
|
|
argv += optind;
|
|
|
|
if (!min_len)
|
|
min_len = 4;
|
|
if (!*argv)
|
|
rc = handle_file("{standard input}");
|
|
else while (*argv) {
|
|
rc = handle_file(*argv);
|
|
argv++;
|
|
}
|
|
return (rc);
|
|
}
|
|
|
|
int
|
|
handle_file(const char *name)
|
|
{
|
|
int fd, rt;
|
|
|
|
if (name == NULL)
|
|
return (RETURN_NOINPUT);
|
|
if (strcmp("{standard input}", name) != 0) {
|
|
if (freopen(name, "rb", stdin) == NULL) {
|
|
warnx("'%s': %s", name, strerror(errno));
|
|
return (RETURN_NOINPUT);
|
|
}
|
|
} else {
|
|
return (find_strings(name, (off_t)0, (off_t)0));
|
|
}
|
|
|
|
fd = fileno(stdin);
|
|
if (fd < 0)
|
|
return (RETURN_NOINPUT);
|
|
rt = handle_elf(name, fd);
|
|
return (rt);
|
|
}
|
|
|
|
/*
|
|
* Files not understood by handle_elf, will be passed off here and will
|
|
* treated as a binary file. This would include text file, core dumps ...
|
|
*/
|
|
int
|
|
handle_binary(const char *name, int fd)
|
|
{
|
|
struct stat buf;
|
|
|
|
memset(&buf, 0, sizeof(struct stat));
|
|
(void) lseek(fd, (off_t)0, SEEK_SET);
|
|
if (!fstat(fd, &buf))
|
|
return (find_strings(name, (off_t)0, buf.st_size));
|
|
return (RETURN_SOFTWARE);
|
|
}
|
|
|
|
/*
|
|
* Will analyse a file to see if it ELF, other files including ar(1),
|
|
* core dumps are passed off and treated as flat binary files. Unlike
|
|
* GNU size in FreeBSD this routine will not treat ELF object from
|
|
* different archs as flat binary files(has to overridden using -a).
|
|
*/
|
|
int
|
|
handle_elf(const char *name, int fd)
|
|
{
|
|
GElf_Ehdr elfhdr;
|
|
GElf_Shdr shdr;
|
|
Elf *elf;
|
|
Elf_Scn *scn;
|
|
int rc;
|
|
|
|
rc = RETURN_OK;
|
|
/* If entire file is choosen, treat it as a binary file */
|
|
if (entire_file)
|
|
return (handle_binary(name, fd));
|
|
|
|
(void) lseek(fd, (off_t)0, SEEK_SET);
|
|
elf = elf_begin(fd, ELF_C_READ, NULL);
|
|
if (elf_kind(elf) != ELF_K_ELF) {
|
|
(void) elf_end(elf);
|
|
return (handle_binary(name, fd));
|
|
}
|
|
|
|
if (gelf_getehdr(elf, &elfhdr) == NULL) {
|
|
(void) elf_end(elf);
|
|
warnx("%s: ELF file could not be processed", name);
|
|
return (RETURN_SOFTWARE);
|
|
}
|
|
|
|
if (elfhdr.e_shnum == 0 && elfhdr.e_type == ET_CORE) {
|
|
(void) elf_end(elf);
|
|
return (handle_binary(name, fd));
|
|
} else {
|
|
scn = NULL;
|
|
while ((scn = elf_nextscn(elf, scn)) != NULL) {
|
|
if (gelf_getshdr(scn, &shdr) == NULL)
|
|
continue;
|
|
if (shdr.sh_type != SHT_NOBITS &&
|
|
(shdr.sh_flags & SHF_ALLOC) != 0) {
|
|
rc = find_strings(name, shdr.sh_offset,
|
|
shdr.sh_size);
|
|
}
|
|
}
|
|
}
|
|
(void) elf_end(elf);
|
|
return (rc);
|
|
}
|
|
|
|
/*
|
|
* Retrieves a character from input stream based on the encoding
|
|
* type requested.
|
|
*/
|
|
long
|
|
getcharacter(void)
|
|
{
|
|
long rt;
|
|
int i;
|
|
char buf[4], c;
|
|
|
|
rt = EOF;
|
|
for(i = 0; i < encoding_size; i++) {
|
|
c = getc(stdin);
|
|
if (feof(stdin))
|
|
return (EOF);
|
|
buf[i] = c;
|
|
}
|
|
|
|
switch(encoding) {
|
|
case ENCODING_7BIT:
|
|
case ENCODING_8BIT:
|
|
rt = buf[0];
|
|
break;
|
|
case ENCODING_16BIT_BIG:
|
|
rt = (buf[0] << 8) | buf[1];
|
|
break;
|
|
case ENCODING_16BIT_LITTLE:
|
|
rt = buf[0] | (buf[1] << 8);
|
|
break;
|
|
case ENCODING_32BIT_BIG:
|
|
rt = ((long) buf[0] << 24) | ((long) buf[1] << 16) |
|
|
((long) buf[2] << 8) | buf[3];
|
|
break;
|
|
case ENCODING_32BIT_LITTLE:
|
|
rt = buf[0] | ((long) buf[1] << 8) | ((long) buf[2] << 16) |
|
|
((long) buf[3] << 24);
|
|
break;
|
|
}
|
|
return (rt);
|
|
}
|
|
|
|
/*
|
|
* Input stream stdin is read until the end of file is reached or until
|
|
* the section size is reached in case of ELF files. Contiguous
|
|
* characters of >= min_size(default 4) will be displayed.
|
|
*/
|
|
int
|
|
find_strings(const char *name, off_t offset, off_t size)
|
|
{
|
|
off_t cur_off, start_off;
|
|
char *obuf;
|
|
long c;
|
|
int i;
|
|
|
|
if ((obuf = (char*)calloc(1, min_len + 1)) == NULL) {
|
|
(void) fprintf(stderr, "Unable to allocate memory: %s\n",
|
|
strerror(errno));
|
|
return (RETURN_SOFTWARE);
|
|
}
|
|
|
|
(void) fseeko(stdin, offset, SEEK_SET);
|
|
cur_off = offset;
|
|
start_off = 0;
|
|
while(1) {
|
|
if ((offset + size) && (cur_off >= offset + size))
|
|
break;
|
|
start_off = cur_off;
|
|
memset(obuf, 0, min_len+1);
|
|
for(i = 0; i < min_len; i++) {
|
|
c = getcharacter();
|
|
if (c == EOF && feof(stdin))
|
|
goto _exit1;
|
|
if (PRINTABLE(c)) {
|
|
obuf[i] = c;
|
|
obuf[i+1] = 0;
|
|
cur_off += encoding_size;
|
|
} else {
|
|
if (encoding == ENCODING_8BIT &&
|
|
(uint8_t)c > 127) {
|
|
obuf[i] = c;
|
|
obuf[i+1] = 0;
|
|
cur_off += encoding_size;
|
|
continue;
|
|
}
|
|
cur_off += encoding_size;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i >= min_len && ((cur_off <= offset + size) ||
|
|
!(offset + size))) {
|
|
if (show_filename)
|
|
printf ("%s: ", name);
|
|
if (show_loc) {
|
|
switch(radix) {
|
|
case RADIX_DECIMAL:
|
|
(void) printf("%7ju ",
|
|
(uintmax_t)start_off);
|
|
break;
|
|
case RADIX_HEX:
|
|
(void) printf("%7jx ",
|
|
(uintmax_t)start_off);
|
|
break;
|
|
case RADIX_OCTAL:
|
|
(void) printf("%7jo ",
|
|
(uintmax_t)start_off);
|
|
break;
|
|
}
|
|
}
|
|
printf("%s", obuf);
|
|
|
|
while(1) {
|
|
if ((offset + size) &&
|
|
(cur_off >= offset + size))
|
|
break;
|
|
c = getcharacter();
|
|
cur_off += encoding_size;
|
|
if (encoding == ENCODING_8BIT &&
|
|
(uint8_t)c > 127) {
|
|
putchar(c);
|
|
continue;
|
|
}
|
|
if (!PRINTABLE(c) || c == EOF)
|
|
break;
|
|
putchar(c);
|
|
}
|
|
putchar('\n');
|
|
}
|
|
}
|
|
_exit1:
|
|
free(obuf);
|
|
return (RETURN_OK);
|
|
}
|
|
|
|
#define USAGE_MESSAGE "\
|
|
Usage: %s [options] [file...]\n\
|
|
Print contiguous sequences of printable characters.\n\n\
|
|
Options:\n\
|
|
-a | --all Scan the entire file for strings.\n\
|
|
-e ENC | --encoding=ENC Select the character encoding to use.\n\
|
|
-f | --print-file-name Print the file name before each string.\n\
|
|
-h | --help Print a help message and exit.\n\
|
|
-n N | --bytes=N | -N Print sequences with 'N' or more characters.\n\
|
|
-o Print offsets in octal.\n\
|
|
-t R | --radix=R Print offsets using the radix named by 'R'.\n\
|
|
-v | --version Print a version identifier and exit.\n"
|
|
|
|
void
|
|
usage(void)
|
|
{
|
|
(void) fprintf(stderr, USAGE_MESSAGE, ELFTC_GETPROGNAME());
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
void
|
|
show_version(void)
|
|
{
|
|
(void) printf("%s (%s)\n", ELFTC_GETPROGNAME(), elftc_version());
|
|
exit(EXIT_SUCCESS);
|
|
}
|