/* ______________________________________________________________________________ ,sSSSis ,sSSSs, Beta v2.0 (w32). iS" dP dY" ,SP Encodes binary data to/from a variety of formats. .SP dSS" ,sS" Copyright (C) 2003-2005 by Berend-Jan Wever dS' Sb ,sY" .SP dSSP' sSSSSSSP http://spaces.msn.com/members/berendjanwever _ iS:_________________________________________________________________________ This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2, 1991 as published by the Free Software Foundation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. A copy of the GNU General Public License can be found at: http://www.gnu.org/licenses/gpl.html or you can write to: Free Software Foundation, Inc. 59 Temple Place - Suite 330 Boston, MA 02111-1307 USA. */ #include #include #include #include #include #include #define MAX_BUFFER_SIZE 0x1000 #define DEFAULT_PAD_BYTE 0x90 #define MAX_MARKER_SIZE 0x10 #define bool char #define true 1 #define false 0 char* hex = "0123456789abcdef"; void version(void) { printf( "______________________________________________________________________________\n" "\n" " ,sSSSis ,sSSSs, Beta v2.0.\n" " iS\" dP dY\" ,SP Encodes binary data to/from a variety of formats.\n" " .SP dSS\" ,sS\" Copyright (C) 2003-2005 by Berend-Jan Wever\n" " dS' Sb ,sY\" \n" " .SP dSSP' sSSSSSSP http://spaces.msn.com/members/berendjanwever\n" "_ iS:_________________________________________________________________________\n" "\n" ); return; } void help(void) { printf( "Beta was developed to convert raw binary shellcode into text that can be\n" "used in exploit source-code. It can convert raw binary data to a large\n" "number of encodings.\n" "\n" " Usage: BETA [options] [input file name]\n" "\n" " input file name Read input from the given file. By default BETA\n" " reads input from stdin.\n" "\n" "General options:\n" " --help Display this help and exit\n" " --version Output version information and exit\n" " --verbose Displays additional information.\n" " --pause Wait for keypress before exiting.\n" "\n" "Encoding options: (default = AA BB CC ...)\n" " \\x \\xAA\\xBB\\xCC ...\n" " 0x 0xAA 0xBB 0xCC ...\n" " %% %%AA%%BB%%CC...\n" " # oÞ!...\n" " %%u %%uBBAA%%uDDCC...\n" " --noencode Don't encode (only do checks).\n" "\n" "Layout options: (default = none)\n" " --chars/line=X Output a new line after every X encoded bytes.\n" " --quotes Wrap output in quotes. Only usefull in combination\n" " with chars/line argument.\n" " --quotesplus Wrap output in quotes and add a '+' at the end\n" " of each line. Only usefull in combination with\n" " chars/line argument.\n" " --spaces Seperate encoding entities by spaces.\n" " --commas Seperate encoding entities by commas and spaces.\n" "\n" "Additional options:\n" " --padbyte=AA When using a multibyte encoding (e.g. %%uXXXX)\n" " the data might need some padding. The given byte\n" " will be used, the default value is %02x.\n" " --badbytes[=AA[,BB[...]]] Check the input for presence of the given char-\n" " acters and report where they are found. You can\n" " supply a comma seperated list of hexadecimal\n" " character codes and the keywords \"alpha\" and\n" " \"print\" (to check for the presence of nonalpha-\n" " numeric or non-printable characters). If no char-\n" " acters are supplied, the input will be checked for\n" " the presence of 00, 0A and 0D. \n" " --marker[=AA[,BB[...]]] The input contains both garbage and data. The data\n" " is wrapped by the marker bytes, everything before\n" " the first set and after the last set of marker\n" " bytes will be ignored. If no marker bytes are\n" " supplied, \"CC CC CC\" (3xInt3) will be used.\n" " You can supply up to %d bytes as marker.\n", DEFAULT_PAD_BYTE, MAX_MARKER_SIZE ); return; } // Find a set of bytes in another set of bytes char* find_bytes(char* haystack, int haystack_length, char* needle, int needle_length) { int needle_start = -1, needle_checked = 1; do { if (haystack[needle_start+needle_checked] == needle[needle_checked]) // Yes, bytes match, check next byte of needle needle_checked++; else { // No, no match, check next byte of haystack needle_start++; needle_checked = 0; } if (needle_start + needle_length > haystack_length) // Not found. return 0; } while (needle_checked != needle_length); // Found! return haystack + needle_start; } int main(int argc, char** argv, char** envp) { // This will contain the input data char* buffer; int buffer_length = 0; // This will contain the marker char marker[MAX_MARKER_SIZE]; int marker_length = 0; // This will keep track of all "bad" bytes char char_is_bad[0x100]; for (int i = 0; i < sizeof(char_is_bad)/sizeof(*char_is_bad); i++) char_is_bad[i] = false; // These will store some values supplied by command line arguments bool switch_verbose = false, switch_encode = true, switch_pause = false; char pad_byte = DEFAULT_PAD_BYTE; int chars_per_line = -1; char *input_filename = 0; char *line_header = "", *line_footer = "\n", *footer = "\n"; char *bytes_format = "%02X", *byte_seperator = ""; int bytes = 1; //-------------------------------------------------------------------------- // Read and handle arguments for (int argn = 1; argn < argc; argn++) { //--help --------------------------------------------------------------- if (stricmp(argv[argn], "--help") == 0) { version(); help(); if (switch_pause) getchar(); exit(EXIT_SUCCESS); //--version ------------------------------------------------------------ } else if (stricmp(argv[argn], "--version") == 0) { version(); if (switch_pause) getchar(); exit(EXIT_SUCCESS); //--verbose ------------------------------------------------------------ } else if (stricmp(argv[argn], "--verbose") == 0) { switch_verbose = true; //--noencode ----------------------------------------------------------- } else if (stricmp(argv[argn], "--noencode") == 0) { switch_encode = false; //--noencode ----------------------------------------------------------- } else if (stricmp(argv[argn], "--pause") == 0) { switch_pause = true; //--chars/line= -------------------------------------------------------- } else if (strnicmp(argv[argn], "--chars/line=", 13)==0) { if ((chars_per_line = strtol(&(argv[argn][13]), NULL, 10)) < 1) { printf("Illegal number of characters per line: \"%s\".\n", &(argv[argn][13])); if (switch_pause) getchar(); exit(EXIT_FAILURE); } //--layout options ----------------------------------------------------- } else if (strcmp(argv[argn], "--quote") == 0 || strcmp(argv[argn], "--quotes") == 0) { line_header = "\""; line_footer = "\"\n"; footer = "\"\n"; } else if (strcmp(argv[argn], "--quoteplus") == 0 || strcmp(argv[argn], "--quotesplus") == 0) { line_header = "\""; line_footer = "\" +\n"; footer = "\"\n"; } else if (strcmp(argv[argn], "--comma") == 0 || strcmp(argv[argn], "--commas") == 0) { byte_seperator = ", "; } else if (strcmp(argv[argn], "--space") == 0 || strcmp(argv[argn], "--spaces") == 0) { byte_seperator = " "; //--encoding options --------------------------------------------------- } else if (stricmp(argv[argn], "\\x")==0) { bytes_format = "\\x%02X"; } else if (stricmp(argv[argn], "0x")==0) { bytes_format = "0x%02X"; } else if (stricmp(argv[argn], "#")==0) { bytes_format = "&#%d;"; } else if (stricmp(argv[argn], "%")==0) { bytes_format = "%%%02X"; } else if (stricmp(argv[argn], "%u")==0) { bytes_format = "%%u%04X"; bytes = 2; //--padbyte ------------------------------------------------------------ } else if (strnicmp(argv[argn], "--padbyte=", 10) == 0) { char* next_xarg; pad_byte = strtol(&(argv[argn][10]), &next_xarg, 0x10); if ((pad_byte & 0xFF) != pad_byte) { printf("Incorrect value in padbyte argument: \"%s\".\n", &(argv[argn][11])); printf(" Value cannot be converted to a byte "); for (int i = 0; i < strlen(&(argv[argn][10])); i++) printf("^"); printf("\n"); if (switch_pause) getchar(); exit(EXIT_FAILURE); } if (next_xarg == &(argv[argn][10])) { printf("Incorrect byte encoding in padbyte argument: \"%s\".\n", &(argv[argn][10])); if (switch_pause) getchar(); exit(EXIT_FAILURE); } //--badbytes ----------------------------------------------------------- } else if (stricmp(argv[argn], "--badbytes") == 0) { char_is_bad[0x0] = true; char_is_bad[0xA] = true; char_is_bad[0xD] = true; //--badbytes=XX,XX,... ------------------------------------------------- } else if (strnicmp(argv[argn], "--badbytes=", 11) == 0) { char* xarg = &(argv[argn][11]); while (strlen(xarg) > 0) { if (strnicmp(xarg, "alpha", 5) == 0) { for (int i = 0; i < 0x100; i++) { if (!isalnum(i)) char_is_bad[i] = true; } xarg += 5; } else if (strnicmp(xarg, "print", 5) == 0) { for (int i = 0; i < 0x100; i++) { if (!isprint(i)) char_is_bad[i] = true; } xarg += 5; } else { char* next_xarg; int decoded = strtol(xarg, &next_xarg, 0x10); if ((decoded & 0xFF) != decoded) { printf("Incorrect value in badbytes argument: \"%s\".\n", &(argv[argn][11])); for (char* i = &(argv[argn][9]); i < xarg; i++) printf(" "); printf(" Value cannot be converted to a byte "); for (char* i = xarg; i < next_xarg; i++) printf("^"); printf("\n"); if (switch_pause) getchar(); exit(EXIT_FAILURE); } if (next_xarg == xarg) { printf("Incorrect byte encoding in badbytes argument: \"%s\".\n", &(argv[argn][11])); for (char* i = &(argv[argn][11]); i < xarg; i++) printf(" "); printf(" Character '%c' not expected ^\n", *xarg); if (switch_pause) getchar(); exit(EXIT_FAILURE); } char_is_bad[decoded] = true; xarg = next_xarg; } if (*xarg == ',') xarg++; } //--marker ------------------------------------------------------------- } else if (stricmp(argv[argn], "--marker")==0) { marker_length = 3; for (int i = 0; i < marker_length; i++) marker[i] = 0xCC; //--marker= ------------------------------------------------------------ } else if (strnicmp(argv[argn], "--marker=", 9)==0) { char* xarg = &(argv[argn][9]); while (strlen(xarg) > 0) { if (marker_length == MAX_MARKER_SIZE) { printf("Given marker is too large, the maximum size is %d characters.\n", MAX_MARKER_SIZE); if (switch_pause) getchar(); exit(EXIT_FAILURE); } char* next_xarg; int decoded = strtol(xarg, &next_xarg, 0x10); if ((decoded & 0xFF) != decoded) { printf("Incorrect value in marker argument: \"%s\".\n", &(argv[argn][9])); for (char* i = &(argv[argn][9]); i < xarg; i++) printf(" "); printf(" Value cannot be converted to a byte "); for (char* i = xarg; i < next_xarg; i++) printf("^"); printf("\n"); if (switch_pause) getchar(); exit(EXIT_FAILURE); } marker[marker_length] = decoded; marker_length++; if (next_xarg == xarg) { printf("Incorrect byte encoding in marker argument: \"%s\".\n", &(argv[argn][9])); for (char* i = &(argv[argn][9]); i < xarg; i++) printf(" "); printf(" Character '%c' not expected ^\n", *xarg); if (switch_pause) getchar(); exit(EXIT_FAILURE); } xarg = next_xarg; if (*xarg == ',') xarg ++; } } else { //--input filename ----------------------------------------------------- if (input_filename != 0) { printf( "Two arguments are assumed to be file names, only one was expected:\n" "\"%s\" and \"%s\"\n", input_filename, argv[argn] ); if (switch_pause) getchar(); exit(EXIT_FAILURE); } input_filename = argv[argn]; } } if (switch_verbose) version(); if (input_filename == 0) { // Read from STDIN ----------------------------------------------------- buffer = malloc(MAX_BUFFER_SIZE); if (buffer == 0) { printf("- Cannot allocate %d bytes of memory for input buffer.\n", MAX_BUFFER_SIZE); if (switch_pause) getchar(); exit(EXIT_FAILURE); } if (switch_verbose) printf(" Input _______________: STDIN, reading..."); while (buffer_length < MAX_BUFFER_SIZE && (buffer[buffer_length] = getchar()) != EOF) buffer_length++; if (switch_verbose) { if (buffer_length == MAX_BUFFER_SIZE) printf("\r Input _______________: STDIN, %d bytes (maximum size for input data).\n", buffer_length); else printf("\r Input _______________: STDIN, %d bytes.\n", buffer_length); } } else { // Read from file ------------------------------------------------------ int input_filedescriptor = 0; if ((input_filedescriptor = open(input_filename, O_RDONLY | O_BINARY, 0)) == 0) { printf("- Cannot open file \"%s\".\n", input_filename); if (switch_pause) getchar(); exit(EXIT_FAILURE); } if ((buffer_length = lseek(input_filedescriptor, 0, SEEK_END)) == -1) { printf("- Cannot find end of file \"%s\".\n", input_filename); if (switch_pause) getchar(); exit(EXIT_FAILURE); } if (buffer_length == 0) { printf("- File \"%s\" is empty.\n", input_filename); if (switch_pause) getchar(); exit(EXIT_FAILURE); } if (lseek(input_filedescriptor, 0, SEEK_SET) == -1) { printf("- Cannot find start of file \"%s\".\n", input_filename); if (switch_pause) getchar(); exit(EXIT_FAILURE); } if (switch_verbose) printf(" Input file __________: \"%s\", %d bytes.\n", input_filename, buffer_length); if ((buffer = malloc(buffer_length)) == 0) { printf("- Cannot allocate %d bytes of memory for input buffer.\n", buffer_length); if (switch_pause) getchar(); exit(EXIT_FAILURE); } int bytes_read_total = 0; while (bytes_read_total < buffer_length) { int bytes_read = read(input_filedescriptor, buffer+bytes_read_total, buffer_length-bytes_read_total); if (bytes_read == -1) { printf("- Cannot read from file \"%s\".\n", input_filename); if (switch_pause) getchar(); exit(EXIT_FAILURE); } if (bytes_read == 0) { printf("- Cannot read more then %d bytes of file \"%s\".\n", bytes_read_total, input_filename); buffer_length = bytes_read_total; if (switch_pause) getchar(); exit(EXIT_FAILURE); } bytes_read_total += bytes_read; } close(input_filedescriptor); } // Cut out the part surrounded by the markers ------------------------------ if (marker_length > 0) { if (switch_verbose) { printf (" Marker bytes ________:"); for (int i = 0; i < marker_length; i++) printf(" %02X", marker[i] & 0xFF); printf (".\n"); } char *marker_start, *marker_end; // find the first marker marker_start = find_bytes(buffer, buffer_length, marker, marker_length); if (marker_start == 0) { printf("- Cannot find start marker.\n"); if (switch_pause) getchar(); exit(EXIT_FAILURE); } marker_start += marker_length; // find the second marker marker_end = find_bytes(marker_start, buffer + buffer_length - marker_start, marker, marker_length); if (marker_end == 0) { printf("- Cannot find end marker.\n"); if (switch_pause) getchar(); exit(EXIT_FAILURE); } if (switch_verbose) printf(" Markers found at ____: byte %d & %d.\n", (int)marker_start - (int)buffer - marker_length, (int)marker_end - (int)buffer); // copy data between markers to start of buffer; for (int i = 0; i < (int)marker_end - (int)marker_start; i++) { buffer[i] = marker_start[i]; } buffer_length = (int)marker_end - (int)marker_start; } // Check if we have input data to encode ----------------------------------- if (buffer_length == 0) { printf("- No data to encode.\n"); if (switch_pause) getchar(); exit(EXIT_FAILURE); } if (switch_verbose) printf(" Data length _________: %d bytes.\n", buffer_length); // Add some padding -------------------------------------------------------- if (buffer_length % bytes != 0 && switch_verbose) printf("* Data padding ________: %d x %02X.\n", bytes - (buffer_length % bytes), pad_byte & 0xff); while(buffer_length - 1 < MAX_BUFFER_SIZE && buffer_length % bytes != 0) { buffer[buffer_length] = pad_byte; buffer_length++; } // Check for bad characters ------------------------------------------------ for (int i = 0; i < 256; i++) { if (char_is_bad[i]) { // For each bad character bool this_bad_char_found = false; for (int j = 0; j < buffer_length; j++) { if (buffer[j] == i) { // Find all instances in the data if (this_bad_char_found) printf(", %d", j); else { this_bad_char_found = true; printf("* Bad character %02X at _: %d", i, j); } } } if (this_bad_char_found) printf(".\n"); else if (switch_verbose) printf(" Bad character %02X ____: Not found.\n", i); } } if (switch_encode) { // Encode the input data --------------------------------------------------- if (switch_verbose) printf( "\n" "_ Encoded data _______________________________________________________________\n" ); int input=0, count=0; // line header and footer only printed when we have a max. chars per line. if (chars_per_line>0) printf("%s", line_header); for (int i = 0; i < buffer_length; i+= bytes) { // read as many bytes as we encode and create one int from them. unsigned long input = 0; for (int j = 0; j < bytes; j++) input += (buffer[i+j] & 0xFF) << (j*8); // if we've allready printed chars we might have to print seperators if (i > 0) { // we have to seperate bytes from each other with this: printf("%s", byte_seperator); // if we've allready printed enough chars on this line, end it & start a new one: if (chars_per_line>0 && i % chars_per_line == 0) printf("%s%s", line_footer, line_header); } // print the byte (with it's own header and footer) and count it. printf(bytes_format, input); } // line header and footer only printed when we have a max. chars per line. if (chars_per_line>0) printf("%s", footer); } if (switch_pause) getchar(); exit(EXIT_SUCCESS); } // milw0rm.com [2005-12-16]

Query Builder