1 /*-
2  * Copyright (c) 2007 S.Sam Arun Raj
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  */
26 
27 #include <sys/types.h>
28 #include <sys/stat.h>
29 
30 #include <ctype.h>
31 #include <err.h>
32 #include <errno.h>
33 #include <fcntl.h>
34 #include <getopt.h>
35 #include <inttypes.h>
36 #include <stdint.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <sysexits.h>
41 #include <unistd.h>
42 
43 #include <libelf.h>
44 #include <libelftc.h>
45 #include <gelf.h>
46 
47 #include "_elftc.h"
48 
49 ELFTC_VCSID("$Id: strings.c 3648 2018-11-22 23:26:43Z emaste $");
50 
51 enum radix_style {
52 	RADIX_DECIMAL,
53 	RADIX_HEX,
54 	RADIX_OCTAL
55 };
56 
57 enum encoding_style {
58 	ENCODING_7BIT,
59 	ENCODING_8BIT,
60 	ENCODING_16BIT_BIG,
61 	ENCODING_16BIT_LITTLE,
62 	ENCODING_32BIT_BIG,
63 	ENCODING_32BIT_LITTLE
64 };
65 
66 #define PRINTABLE(c)						\
67       ((c) >= 0 && (c) <= 255 &&				\
68 	  ((c) == '\t' || isprint((c)) ||			\
69 	      (encoding == ENCODING_8BIT && (c) > 127)))
70 
71 static int encoding_size, entire_file, show_filename, show_loc;
72 static enum encoding_style encoding;
73 static enum radix_style radix;
74 static intmax_t min_len;
75 
76 static struct option strings_longopts[] = {
77 	{ "all",		no_argument,		NULL,	'a'},
78 	{ "bytes",		required_argument,	NULL,	'n'},
79 	{ "encoding",		required_argument,	NULL,	'e'},
80 	{ "help",		no_argument,		NULL,	'h'},
81 	{ "print-file-name",	no_argument,		NULL,	'f'},
82 	{ "radix",		required_argument,	NULL,	't'},
83 	{ "version",		no_argument,		NULL,	'v'},
84 	{ NULL, 0, NULL, 0 }
85 };
86 
87 long	getcharacter(void);
88 int	handle_file(const char *);
89 int	handle_elf(const char *, int);
90 int	handle_binary(const char *, int);
91 int	find_strings(const char *, off_t, off_t);
92 void	show_version(void);
93 void	usage(void);
94 
95 /*
96  * strings(1) extracts text(contiguous printable characters)
97  * from elf and binary files.
98  */
99 int
100 main(int argc, char **argv)
101 {
102 	int ch, rc;
103 
104 	rc = 0;
105 	min_len = 0;
106 	encoding_size = 1;
107 	if (elf_version(EV_CURRENT) == EV_NONE)
108 		errx(EXIT_FAILURE, "ELF library initialization failed: %s",
109 		    elf_errmsg(-1));
110 
111 	while ((ch = getopt_long(argc, argv, "1234567890ae:fhn:ot:Vv",
112 	    strings_longopts, NULL)) != -1) {
113 		switch ((char)ch) {
114 		case 'a':
115 			entire_file = 1;
116 			break;
117 		case 'e':
118 			if (*optarg == 's') {
119 				encoding = ENCODING_7BIT;
120 			} else if (*optarg == 'S') {
121 				encoding = ENCODING_8BIT;
122 			} else if (*optarg == 'b') {
123 				encoding = ENCODING_16BIT_BIG;
124 				encoding_size = 2;
125 			} else if (*optarg == 'B') {
126 				encoding = ENCODING_32BIT_BIG;
127 				encoding_size = 4;
128 			} else if (*optarg == 'l') {
129 				encoding = ENCODING_16BIT_LITTLE;
130 				encoding_size = 2;
131 			} else if (*optarg == 'L') {
132 				encoding = ENCODING_32BIT_LITTLE;
133 				encoding_size = 4;
134 			} else
135 				usage();
136 			        /* NOTREACHED */
137 			break;
138 		case 'f':
139 			show_filename = 1;
140 			break;
141 		case 'n':
142 			min_len = strtoimax(optarg, (char**)NULL, 10);
143 			if (min_len <= 0)
144 				errx(EX_USAGE, "option -n should specify a "
145 				    "positive decimal integer.");
146 			break;
147 		case 'o':
148 			show_loc = 1;
149 			radix = RADIX_OCTAL;
150 			break;
151 		case 't':
152 			show_loc = 1;
153 			if (*optarg == 'd')
154 				radix = RADIX_DECIMAL;
155 			else if (*optarg == 'o')
156 				radix = RADIX_OCTAL;
157 			else if (*optarg == 'x')
158 				radix = RADIX_HEX;
159 			else
160 				usage();
161 			        /* NOTREACHED */
162 			break;
163 		case 'v':
164 		case 'V':
165 			show_version();
166 			/* NOTREACHED */
167 		case '0':
168 	        case '1':
169 		case '2':
170 		case '3':
171 		case '4':
172 		case '5':
173 		case '6':
174 		case '7':
175 		case '8':
176 		case '9':
177 			min_len *= 10;
178 			min_len += ch - '0';
179 			break;
180 		case 'h':
181 		case '?':
182 		default:
183 			usage();
184 			/* NOTREACHED */
185 		}
186 	}
187 	argc -= optind;
188 	argv += optind;
189 
190 	if (min_len == 0)
191 		min_len = 4;
192 	if (*argv == NULL)
193 		rc = find_strings("{standard input}", 0, 0);
194 	else while (*argv != NULL) {
195 		if (handle_file(*argv) != 0)
196 			rc = 1;
197 		argv++;
198 	}
199 	return (rc);
200 }
201 
202 int
203 handle_file(const char *name)
204 {
205 	int fd, rt;
206 
207 	if (name == NULL)
208 		return (1);
209 	if (freopen(name, "rb", stdin) == NULL) {
210 		warnx("'%s': %s", name, strerror(errno));
211 		return (1);
212 	}
213 
214 	fd = fileno(stdin);
215 	if (fd < 0)
216 		return (1);
217 	rt = handle_elf(name, fd);
218 	return (rt);
219 }
220 
221 /*
222  * Files not understood by handle_elf, will be passed off here and will
223  * treated as a binary file. This would include text file, core dumps ...
224  */
225 int
226 handle_binary(const char *name, int fd)
227 {
228 	struct stat buf;
229 
230 	memset(&buf, 0, sizeof(buf));
231 	(void)lseek(fd, 0, SEEK_SET);
232 	if (!fstat(fd, &buf))
233 		return (find_strings(name, 0, buf.st_size));
234 	return (1);
235 }
236 
237 /*
238  * Will analyse a file to see if it ELF, other files including ar(1),
239  * core dumps are passed off and treated as flat binary files. Unlike
240  * GNU size in FreeBSD this routine will not treat ELF object from
241  * different archs as flat binary files(has to overridden using -a).
242  */
243 int
244 handle_elf(const char *name, int fd)
245 {
246 	GElf_Ehdr elfhdr;
247 	GElf_Shdr shdr;
248 	Elf *elf;
249 	Elf_Scn *scn;
250 	int rc;
251 
252 	rc = 0;
253 	/* If entire file is chosen, treat it as a binary file */
254 	if (entire_file)
255 		return (handle_binary(name, fd));
256 
257 	(void)lseek(fd, 0, SEEK_SET);
258 	elf = elf_begin(fd, ELF_C_READ, NULL);
259 	if (elf_kind(elf) != ELF_K_ELF) {
260 		(void)elf_end(elf);
261 		return (handle_binary(name, fd));
262 	}
263 
264 	if (gelf_getehdr(elf, &elfhdr) == NULL) {
265 		(void)elf_end(elf);
266 		warnx("%s: ELF file could not be processed", name);
267 		return (1);
268 	}
269 
270 	if (elfhdr.e_shnum == 0 && elfhdr.e_type == ET_CORE) {
271 		(void)elf_end(elf);
272 		return (handle_binary(name, fd));
273 	} else {
274 		scn = NULL;
275 		while ((scn = elf_nextscn(elf, scn)) != NULL) {
276 			if (gelf_getshdr(scn, &shdr) == NULL)
277 				continue;
278 			if (shdr.sh_type != SHT_NOBITS &&
279 			    (shdr.sh_flags & SHF_ALLOC) != 0) {
280 				rc = find_strings(name, shdr.sh_offset,
281 				    shdr.sh_size);
282 			}
283 		}
284 	}
285 	(void)elf_end(elf);
286 	return (rc);
287 }
288 
289 /*
290  * Retrieves a character from input stream based on the encoding
291  * type requested.
292  */
293 long
294 getcharacter(void)
295 {
296 	long rt;
297 	int i;
298 	char buf[4], c;
299 
300 	rt = EOF;
301 	for(i = 0; i < encoding_size; i++) {
302 		c = getc(stdin);
303 		if (feof(stdin))
304 			return (EOF);
305 		buf[i] = c;
306 	}
307 
308 	switch (encoding) {
309 	case ENCODING_7BIT:
310 	case ENCODING_8BIT:
311 		rt = buf[0];
312 		break;
313 	case ENCODING_16BIT_BIG:
314 		rt = (buf[0] << 8) | buf[1];
315 		break;
316 	case ENCODING_16BIT_LITTLE:
317 		 rt = buf[0] | (buf[1] << 8);
318 		 break;
319 	case ENCODING_32BIT_BIG:
320 		rt = ((long) buf[0] << 24) | ((long) buf[1] << 16) |
321 		    ((long) buf[2] << 8) | buf[3];
322 		break;
323 	case ENCODING_32BIT_LITTLE:
324 		rt = buf[0] | ((long) buf[1] << 8) | ((long) buf[2] << 16) |
325 		    ((long) buf[3] << 24);
326 		break;
327 	}
328 	return (rt);
329 }
330 
331 /*
332  * Input stream stdin is read until the end of file is reached or until
333  * the section size is reached in case of ELF files. Contiguous
334  * characters of >= min_size(default 4) will be displayed.
335  */
336 int
337 find_strings(const char *name, off_t offset, off_t size)
338 {
339 	off_t cur_off, start_off;
340 	char *obuf;
341 	long c;
342 	int i;
343 
344 	if ((obuf = (char*)calloc(1, min_len + 1)) == NULL) {
345 		fprintf(stderr, "Unable to allocate memory: %s\n",
346 		    strerror(errno));
347 		return (1);
348 	}
349 
350 	(void)fseeko(stdin, offset, SEEK_SET);
351 	cur_off = offset;
352 	start_off = 0;
353 	for (;;) {
354 		if ((offset + size) && (cur_off >= offset + size))
355 			break;
356 		start_off = cur_off;
357 		memset(obuf, 0, min_len + 1);
358 		for(i = 0; i < min_len; i++) {
359 			c = getcharacter();
360 			if (c == EOF && feof(stdin))
361 				goto _exit1;
362 			if (PRINTABLE(c)) {
363 				obuf[i] = c;
364 				obuf[i + 1] = 0;
365 				cur_off += encoding_size;
366 			} else {
367 				if (encoding == ENCODING_8BIT &&
368 				    (uint8_t)c > 127) {
369 					obuf[i] = c;
370 					obuf[i + 1] = 0;
371 					cur_off += encoding_size;
372 					continue;
373 				}
374 				cur_off += encoding_size;
375 				break;
376 			}
377 		}
378 
379 		if (i >= min_len && ((cur_off <= offset + size) ||
380 		    !(offset + size))) {
381 			if (show_filename)
382 				printf("%s: ", name);
383 			if (show_loc) {
384 				switch (radix) {
385 				case RADIX_DECIMAL:
386 					printf("%7ju ", (uintmax_t)start_off);
387 					break;
388 				case RADIX_HEX:
389 					printf("%7jx ", (uintmax_t)start_off);
390 					break;
391 				case RADIX_OCTAL:
392 					printf("%7jo ", (uintmax_t)start_off);
393 					break;
394 				}
395 			}
396 			printf("%s", obuf);
397 
398 			for (;;) {
399 				if ((offset + size) &&
400 				    (cur_off >= offset + size))
401 					break;
402 				c = getcharacter();
403 				cur_off += encoding_size;
404 				if (encoding == ENCODING_8BIT &&
405 				    (uint8_t)c > 127) {
406 					putchar(c);
407 					continue;
408 				}
409 				if (!PRINTABLE(c) || c == EOF)
410 					break;
411 				putchar(c);
412 			}
413 			putchar('\n');
414 		}
415 	}
416 _exit1:
417 	free(obuf);
418 	return (0);
419 }
420 
421 #define	USAGE_MESSAGE	"\
422 Usage: %s [options] [file...]\n\
423   Print contiguous sequences of printable characters.\n\n\
424   Options:\n\
425   -a     | --all               Scan the entire file for strings.\n\
426   -e ENC | --encoding=ENC      Select the character encoding to use.\n\
427   -f     | --print-file-name   Print the file name before each string.\n\
428   -h     | --help              Print a help message and exit.\n\
429   -n N   | --bytes=N | -N      Print sequences with 'N' or more characters.\n\
430   -o                           Print offsets in octal.\n\
431   -t R   | --radix=R           Print offsets using the radix named by 'R'.\n\
432   -v     | --version           Print a version identifier and exit.\n"
433 
434 void
435 usage(void)
436 {
437 
438 	fprintf(stderr, USAGE_MESSAGE, ELFTC_GETPROGNAME());
439 	exit(EXIT_FAILURE);
440 }
441 
442 void
443 show_version(void)
444 {
445 
446         printf("%s (%s)\n", ELFTC_GETPROGNAME(), elftc_version());
447         exit(EXIT_SUCCESS);
448 }
449