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