diff --git a/CHANGES b/CHANGES new file mode 100644 index 0000000..104eeb7 --- /dev/null +++ b/CHANGES @@ -0,0 +1,9 @@ +* v1.1 -> v1.2 + +- Open Source the project +- License is MIT +- Moved repository to github: https://github.com/hashcat/hashcat-utils +- Added CHANGES +- Added LICENSE +- Added README.md + diff --git a/LICENSE b/LICENSE index 20efd1b..ea53078 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ The MIT License (MIT) -Copyright (c) 2015 +Copyright (c) 2015 Jens Steube Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/README.md b/README.md index 6414a0b..554aaa5 100644 --- a/README.md +++ b/README.md @@ -1 +1,28 @@ -# hashcat-utils +hashcat-utils +============== + +Hashcat-utils are a set of small utilities that are useful in advanced password cracking + +Brief description +-------------- + +They all are packed into multiple stand-alone binaries. + +All of these utils are designed to execute only one specific function. + +Since they all work with STDIN and STDOUT you can group them into chains. + +Detailed description +-------------- + +tbd + +Compile +-------------- + +Simply run make + +Binary distribution +-------------- + +Binaries for Linux, Windows and OSX: https://github.com/hashcat/hashcat-utils/releases diff --git a/src/Makefile b/src/Makefile new file mode 100644 index 0000000..18c6652 --- /dev/null +++ b/src/Makefile @@ -0,0 +1,115 @@ +## +## Makefile +## + +CFLAGS = -Wall -W -pipe -O2 + +all: clean release + +release: linux windows osx + $(STRIP_LINUX) *.bin + $(STRIP_WINDOWS) *.exe + $(STRIP_OSX) *.app + +clean: + rm -f core *.bin *.exe *.app + +## +## LINUX +## + +CC_LINUX = gcc +STRIP_LINUX = strip +CFLAGS_LINUX = $(CFLAGS) -D_LINUX + +linux: + ${CC_LINUX} ${CFLAGS_LINUX} -o cleanup-rules.bin cleanup-rules.c + ${CC_LINUX} ${CFLAGS_LINUX} -o combinator.bin combinator.c + ${CC_LINUX} ${CFLAGS_LINUX} -o combinator3.bin combinator3.c + ${CC_LINUX} ${CFLAGS_LINUX} -o combipow.bin combipow.c + ${CC_LINUX} ${CFLAGS_LINUX} -o cutb.bin cutb.c + ${CC_LINUX} ${CFLAGS_LINUX} -o expander.bin expander.c + ${CC_LINUX} ${CFLAGS_LINUX} -o gate.bin gate.c + ${CC_LINUX} ${CFLAGS_LINUX} -o generate-rules.bin generate-rules.c + ${CC_LINUX} ${CFLAGS_LINUX} -o hcstatgen.bin hcstatgen.c -lm + ${CC_LINUX} ${CFLAGS_LINUX} -o keyspace.bin keyspace.c + ${CC_LINUX} ${CFLAGS_LINUX} -o len.bin len.c + ${CC_LINUX} ${CFLAGS_LINUX} -o mli2.bin mli2.c + ${CC_LINUX} ${CFLAGS_LINUX} -o morph.bin morph.c + ${CC_LINUX} ${CFLAGS_LINUX} -o permute.bin permute.c + ${CC_LINUX} ${CFLAGS_LINUX} -o permute_exist.bin permute_exist.c + ${CC_LINUX} ${CFLAGS_LINUX} -o prepare.bin prepare.c + ${CC_LINUX} ${CFLAGS_LINUX} -o req-include.bin req-include.c + ${CC_LINUX} ${CFLAGS_LINUX} -o req-exclude.bin req-exclude.c + ${CC_LINUX} ${CFLAGS_LINUX} -o rli.bin rli.c + ${CC_LINUX} ${CFLAGS_LINUX} -o rli2.bin rli2.c + ${CC_LINUX} ${CFLAGS_LINUX} -o splitlen.bin splitlen.c + ${CC_LINUX} ${CFLAGS_LINUX} -o strip-bsr.bin strip-bsr.c + ${CC_LINUX} ${CFLAGS_LINUX} -o strip-bsn.bin strip-bsn.c + +## +## WINDOWS +## + +CC_WINDOWS = x86_64-w64-mingw32-gcc +STRIP_WINDOWS = x86_64-w64-mingw32-strip +CFLAGS_WINDOWS = $(CFLAGS) -D_WINDOWS +GLOB_WINDOWS = /usr/x86_64-w64-mingw32/lib/CRT_glob.o + +windows: + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o cleanup-rules.exe cleanup-rules.c + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o combinator.exe combinator.c + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o combinator3.exe combinator3.c + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o combipow.exe combipow.c + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o cutb.exe cutb.c + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o expander.exe expander.c + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o gate.exe gate.c + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o generate-rules.exe generate-rules.c + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o hcstatgen.exe hcstatgen.c -lm + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o keyspace.exe keyspace.c + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o len.exe len.c + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o mli2.exe mli2.c + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o morph.exe morph.c + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o permute.exe permute.c + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o permute_exist.exe permute_exist.c + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o prepare.exe prepare.c + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o req-include.exe req-include.c + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o req-exclude.exe req-exclude.c + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o rli.exe rli.c ${GLOB_WINDOWS} + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o rli2.exe rli2.c + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o splitlen.exe splitlen.c + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o strip-bsr.exe strip-bsr.c + ${CC_WINDOWS} ${CFLAGS_WINDOWS} -o strip-bsn.exe strip-bsn.c + +## +## OSX +## + +CC_OSX = i686-apple-darwin10-gcc +STRIP_OSX = i686-apple-darwin10-strip +CFLAGS_OSX = $(CFLAGS) -D_OSX + +osx: + ${CC_OSX} ${CFLAGS_OSX} -o cleanup-rules.app cleanup-rules.c + ${CC_OSX} ${CFLAGS_OSX} -o combinator.app combinator.c + ${CC_OSX} ${CFLAGS_OSX} -o combinator3.app combinator3.c + ${CC_OSX} ${CFLAGS_OSX} -o combipow.app combipow.c + ${CC_OSX} ${CFLAGS_OSX} -o cutb.app cutb.c + ${CC_OSX} ${CFLAGS_OSX} -o expander.app expander.c + ${CC_OSX} ${CFLAGS_OSX} -o gate.app gate.c + ${CC_OSX} ${CFLAGS_OSX} -o generate-rules.app generate-rules.c + ${CC_OSX} ${CFLAGS_OSX} -o hcstatgen.app hcstatgen.c -lm + ${CC_OSX} ${CFLAGS_OSX} -o keyspace.app keyspace.c + ${CC_OSX} ${CFLAGS_OSX} -o len.app len.c + ${CC_OSX} ${CFLAGS_OSX} -o mli2.app mli2.c + ${CC_OSX} ${CFLAGS_OSX} -o morph.app morph.c + ${CC_OSX} ${CFLAGS_OSX} -o permute.app permute.c + ${CC_OSX} ${CFLAGS_OSX} -o permute_exist.app permute_exist.c + ${CC_OSX} ${CFLAGS_OSX} -o prepare.app prepare.c + ${CC_OSX} ${CFLAGS_OSX} -o req-include.app req-include.c + ${CC_OSX} ${CFLAGS_OSX} -o req-exclude.app req-exclude.c + ${CC_OSX} ${CFLAGS_OSX} -o rli.app rli.c + ${CC_OSX} ${CFLAGS_OSX} -o rli2.app rli2.c + ${CC_OSX} ${CFLAGS_OSX} -o splitlen.app splitlen.c + ${CC_OSX} ${CFLAGS_OSX} -o strip-bsr.app strip-bsr.c + ${CC_OSX} ${CFLAGS_OSX} -o strip-bsn.app strip-bsn.c diff --git a/src/cleanup-rules.c b/src/cleanup-rules.c new file mode 100644 index 0000000..bda27b4 --- /dev/null +++ b/src/cleanup-rules.c @@ -0,0 +1,418 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include +#include +#include "utils.c" + +/** + * Name........: cleanup-rules + * Autor.......: Jens Steube + * License.....: MIT + */ + +#define RULE_OP_MANGLE_NOOP ':' +#define RULE_OP_MANGLE_LREST 'l' +#define RULE_OP_MANGLE_UREST 'u' +#define RULE_OP_MANGLE_LREST_UFIRST 'c' +#define RULE_OP_MANGLE_UREST_LFIRST 'C' +#define RULE_OP_MANGLE_TREST 't' +#define RULE_OP_MANGLE_TOGGLE_AT 'T' +#define RULE_OP_MANGLE_REVERSE 'r' +#define RULE_OP_MANGLE_DUPEWORD 'd' +#define RULE_OP_MANGLE_DUPEWORD_TIMES 'p' +#define RULE_OP_MANGLE_REFLECT 'f' +#define RULE_OP_MANGLE_ROTATE_LEFT '{' +#define RULE_OP_MANGLE_ROTATE_RIGHT '}' +#define RULE_OP_MANGLE_APPEND '$' +#define RULE_OP_MANGLE_PREPEND '^' +#define RULE_OP_MANGLE_DELETE_FIRST '[' +#define RULE_OP_MANGLE_DELETE_LAST ']' +#define RULE_OP_MANGLE_DELETE_AT 'D' +#define RULE_OP_MANGLE_EXTRACT 'x' +#define RULE_OP_MANGLE_INSERT 'i' +#define RULE_OP_MANGLE_OVERSTRIKE 'o' +#define RULE_OP_MANGLE_TRUNCATE_AT '\'' +#define RULE_OP_MANGLE_REPLACE 's' +#define RULE_OP_MANGLE_PURGECHAR '@' +#define RULE_OP_MANGLE_TOGGLECASE_REC 'a' +#define RULE_OP_MANGLE_DUPECHAR_FIRST 'z' +#define RULE_OP_MANGLE_DUPECHAR_LAST 'Z' +#define RULE_OP_MANGLE_DUPECHAR_ALL 'q' +#define RULE_OP_MANGLE_EXTRACT_MEMORY 'X' +#define RULE_OP_MANGLE_APPEND_MEMORY '4' +#define RULE_OP_MANGLE_PREPEND_MEMORY '6' + +#define RULE_OP_MEMORIZE_WORD 'M' + +#define RULE_OP_REJECT_LESS '<' +#define RULE_OP_REJECT_GREATER '>' +#define RULE_OP_REJECT_CONTAIN '!' +#define RULE_OP_REJECT_NOT_CONTAIN '/' +#define RULE_OP_REJECT_EQUAL_FIRST '(' +#define RULE_OP_REJECT_EQUAL_LAST ')' +#define RULE_OP_REJECT_EQUAL_AT '=' +#define RULE_OP_REJECT_CONTAINS '%' +#define RULE_OP_REJECT_MEMORY 'Q' + +/* hashcat only */ +#define RULE_OP_MANGLE_SWITCH_FIRST 'k' +#define RULE_OP_MANGLE_SWITCH_LAST 'K' +#define RULE_OP_MANGLE_SWITCH_AT '*' +#define RULE_OP_MANGLE_CHR_SHIFTL 'L' +#define RULE_OP_MANGLE_CHR_SHIFTR 'R' +#define RULE_OP_MANGLE_CHR_INCR '+' +#define RULE_OP_MANGLE_CHR_DECR '-' +#define RULE_OP_MANGLE_REPLACE_NP1 '.' +#define RULE_OP_MANGLE_REPLACE_NM1 ',' +#define RULE_OP_MANGLE_DUPEBLOCK_FIRST 'y' +#define RULE_OP_MANGLE_DUPEBLOCK_LAST 'Y' +#define RULE_OP_MANGLE_TITLE 'E' + +#define ATTACK_EXEC_ON_CPU 1 +#define ATTACK_EXEC_ON_GPU 2 + +static int class_num (const char c) +{ + return ((c >= '0') && (c <= '9')); +} + +static int class_upper (const char c) +{ + return ((c >= 'A') && (c <= 'Z')); +} + +static char conv_ctoi (const char c) +{ + if (class_num (c)) + { + return c - '0'; + } + else if (class_upper (c)) + { + return c - 'A' + 10; + } + + return -1; +} + +int main (int argc, char *argv[]) +{ + if (argc != 2) + { + fprintf (stderr, "usage: %s mode\n", argv[0]); + + return (-1); + } + + int num = atoi (argv[1]); + + if ((num != ATTACK_EXEC_ON_CPU) && (num != ATTACK_EXEC_ON_GPU)) + { + fprintf (stderr, "mode: 1 = CPU, 2 = GPU\n"); + + return (-1); + } + + #ifdef _WINDOWS + _setmode (_fileno (stdin), _O_BINARY); + #endif + + char line_buf[BUFSIZ]; + + int line_len; + + #define NEXT_RULEPOS if (++pos == line_len) rc = -1; + #define NEXT_RPTOI if (conv_ctoi (line_buf[pos]) == -1) rc = -1; + #define DENY_GPU if (num == ATTACK_EXEC_ON_GPU) rc = -1; + + while ((line_len = fgetl (stdin, BUFSIZ, line_buf)) != -1) + { + int rc = 0; + + int cnt = 0; + + int pos; + + for (pos = 0; pos < line_len; pos++) + { + switch (line_buf[pos]) + { + case ' ': + break; + + case RULE_OP_MANGLE_NOOP: + break; + + case RULE_OP_MANGLE_LREST: + break; + + case RULE_OP_MANGLE_UREST: + break; + + case RULE_OP_MANGLE_LREST_UFIRST: + break; + + case RULE_OP_MANGLE_UREST_LFIRST: + break; + + case RULE_OP_MANGLE_TREST: + break; + + case RULE_OP_MANGLE_TOGGLE_AT: + NEXT_RULEPOS; + NEXT_RPTOI; + break; + + case RULE_OP_MANGLE_REVERSE: + break; + + case RULE_OP_MANGLE_DUPEWORD: + break; + + case RULE_OP_MANGLE_DUPEWORD_TIMES: + NEXT_RULEPOS; + NEXT_RPTOI; + break; + + case RULE_OP_MANGLE_REFLECT: + break; + + case RULE_OP_MANGLE_ROTATE_LEFT: + break; + + case RULE_OP_MANGLE_ROTATE_RIGHT: + break; + + case RULE_OP_MANGLE_APPEND: + NEXT_RULEPOS; + break; + + case RULE_OP_MANGLE_PREPEND: + NEXT_RULEPOS; + break; + + case RULE_OP_MANGLE_DELETE_FIRST: + break; + + case RULE_OP_MANGLE_DELETE_LAST: + break; + + case RULE_OP_MANGLE_DELETE_AT: + NEXT_RULEPOS; + NEXT_RPTOI; + break; + + case RULE_OP_MANGLE_EXTRACT: + NEXT_RULEPOS; + NEXT_RPTOI; + NEXT_RULEPOS; + NEXT_RPTOI; + break; + + case RULE_OP_MANGLE_INSERT: + NEXT_RULEPOS; + NEXT_RPTOI; + NEXT_RULEPOS; + break; + + case RULE_OP_MANGLE_OVERSTRIKE: + NEXT_RULEPOS; + NEXT_RPTOI; + NEXT_RULEPOS; + break; + + case RULE_OP_MANGLE_TRUNCATE_AT: + NEXT_RULEPOS; + NEXT_RPTOI; + break; + + case RULE_OP_MANGLE_REPLACE: + NEXT_RULEPOS; + NEXT_RULEPOS; + break; + + case RULE_OP_MANGLE_PURGECHAR: + NEXT_RULEPOS; + DENY_GPU; + break; + + case RULE_OP_MANGLE_TOGGLECASE_REC: + break; + + case RULE_OP_MANGLE_DUPECHAR_FIRST: + NEXT_RULEPOS; + NEXT_RPTOI; + break; + + case RULE_OP_MANGLE_DUPECHAR_LAST: + NEXT_RULEPOS; + NEXT_RPTOI; + break; + + case RULE_OP_MANGLE_DUPECHAR_ALL: + break; + + case RULE_OP_MANGLE_DUPEBLOCK_FIRST: + NEXT_RULEPOS; + NEXT_RPTOI; + break; + + case RULE_OP_MANGLE_DUPEBLOCK_LAST: + NEXT_RULEPOS; + NEXT_RPTOI; + break; + + case RULE_OP_MANGLE_SWITCH_FIRST: + break; + + case RULE_OP_MANGLE_SWITCH_LAST: + break; + + case RULE_OP_MANGLE_SWITCH_AT: + NEXT_RULEPOS; + NEXT_RPTOI; + NEXT_RULEPOS; + NEXT_RPTOI; + break; + + case RULE_OP_MANGLE_CHR_SHIFTL: + NEXT_RULEPOS; + NEXT_RPTOI; + break; + + case RULE_OP_MANGLE_CHR_SHIFTR: + NEXT_RULEPOS; + NEXT_RPTOI; + break; + + case RULE_OP_MANGLE_CHR_INCR: + NEXT_RULEPOS; + NEXT_RPTOI; + break; + + case RULE_OP_MANGLE_CHR_DECR: + NEXT_RULEPOS; + NEXT_RPTOI; + break; + + case RULE_OP_MANGLE_REPLACE_NP1: + NEXT_RULEPOS; + NEXT_RPTOI; + break; + + case RULE_OP_MANGLE_REPLACE_NM1: + NEXT_RULEPOS; + NEXT_RPTOI; + break; + + case RULE_OP_MANGLE_TITLE: + break; + + case RULE_OP_MANGLE_EXTRACT_MEMORY: + NEXT_RULEPOS; + NEXT_RPTOI; + NEXT_RULEPOS; + NEXT_RPTOI; + NEXT_RULEPOS; + NEXT_RPTOI; + DENY_GPU; + break; + + case RULE_OP_MANGLE_APPEND_MEMORY: + DENY_GPU; + break; + + case RULE_OP_MANGLE_PREPEND_MEMORY: + DENY_GPU; + break; + + case RULE_OP_MEMORIZE_WORD: + DENY_GPU; + break; + + case RULE_OP_REJECT_LESS: + NEXT_RULEPOS; + NEXT_RPTOI; + DENY_GPU; + break; + + case RULE_OP_REJECT_GREATER: + NEXT_RULEPOS; + NEXT_RPTOI; + DENY_GPU; + break; + + case RULE_OP_REJECT_CONTAIN: + NEXT_RULEPOS; + DENY_GPU; + break; + + case RULE_OP_REJECT_NOT_CONTAIN: + NEXT_RULEPOS; + DENY_GPU; + break; + + case RULE_OP_REJECT_EQUAL_FIRST: + NEXT_RULEPOS; + DENY_GPU; + break; + + case RULE_OP_REJECT_EQUAL_LAST: + NEXT_RULEPOS; + DENY_GPU; + break; + + case RULE_OP_REJECT_EQUAL_AT: + NEXT_RULEPOS; + NEXT_RPTOI; + NEXT_RULEPOS; + DENY_GPU; + break; + + case RULE_OP_REJECT_CONTAINS: + NEXT_RULEPOS; + NEXT_RPTOI; + NEXT_RULEPOS; + DENY_GPU; + break; + + case RULE_OP_REJECT_MEMORY: + DENY_GPU; + break; + + default: + rc = -1; + break; + } + + cnt++; + + if ((num == ATTACK_EXEC_ON_CPU) && (cnt >= 31)) + { + rc = -1; + + break; + } + + if ((num == ATTACK_EXEC_ON_GPU) && (cnt >= 15)) + { + rc = -1; + + break; + } + } + + if (rc == -1) continue; + + puts (line_buf); + } + + return 0; +} diff --git a/src/combinator.c b/src/combinator.c new file mode 100644 index 0000000..5a744be --- /dev/null +++ b/src/combinator.c @@ -0,0 +1,227 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include +#include +#include "utils.c" + +#define LEN_MAX 32 + +#define SEGMENT_SIZE (32 * 1024 * 1024) +#define SEGMENT_ALIGN ( 8 * 1024) + +/** + * Name........: combinator + * Autor.......: Jens Steube + * License.....: MIT + */ + +static size_t read_segment (char *buf, FILE *fd) +{ + size_t read_sz = SEGMENT_SIZE - SEGMENT_ALIGN; + + size_t real_sz = fread (buf, 1, read_sz, fd); + + if (real_sz == 0) return (0); + + if (real_sz != read_sz) + { + if (buf[real_sz - 1] != '\n') + { + real_sz++; + + buf[real_sz - 1] = '\n'; + } + + return (real_sz); + } + + size_t extra; + + for (extra = 0; extra < SEGMENT_ALIGN; extra++) + { + if (fread (buf + real_sz, 1, 1, fd) == 0) break; + + real_sz++; + + if (buf[real_sz - 1] == '\n') break; + } + + return (real_sz); +} + +static size_t get_line_len (char *pos, char *max) +{ + char *cur = pos; + + for (cur = pos; cur < max; cur++) + { + if (*cur == '\n') break; + } + + size_t len = cur - pos; + + return (len); +} + +static void add (char *ptr_out, char *ptr_in1, size_t len_in1, char *ptr_in2, size_t len_in2) +{ + memcpy (ptr_out, ptr_in1, len_in1); + + ptr_out += len_in1; + + memcpy (ptr_out, ptr_in2, len_in2); + + ptr_out += len_in2; + + *ptr_out = '\n'; +} + +int main (int argc, char *argv[]) +{ + if (argc != 3) + { + fprintf (stderr, "usage: %s file1 file2\n", argv[0]); + + return (-1); + } + + size_t sz_buf = SEGMENT_SIZE + SEGMENT_ALIGN; + + char *buf_in1 = (char *) malloc (sz_buf); + char *buf_in2 = (char *) malloc (sz_buf); + + char *buf_out = (char *) malloc (sz_buf); + + char *ptr_out = buf_out; + + FILE *fd1; + FILE *fd2; + + if ((fd1 = fopen (argv[1], "rb")) == NULL) + { + fprintf (stderr, "%s: %s\n", argv[1], strerror (errno)); + + free (buf_in1); + free (buf_in2); + free (buf_out); + + return (-1); + } + + if ((fd2 = fopen (argv[2], "rb")) == NULL) + { + fprintf (stderr, "%s: %s\n", argv[2], strerror (errno)); + + free (buf_in1); + free (buf_in2); + free (buf_out); + + fclose (fd1); + + return (-1); + } + + while (!feof (fd1)) + { + size_t real_sz1 = read_segment (buf_in1, fd1); + + char *max_in1 = buf_in1 + real_sz1; + + char *ptr_in1; + + size_t len_in1; + + for (ptr_in1 = buf_in1; ptr_in1 < max_in1; ptr_in1 += len_in1 + 1) + { + len_in1 = get_line_len (ptr_in1, max_in1); + + size_t vir_in1 = len_in1; + + while (vir_in1) + { + if (ptr_in1[vir_in1 - 1] != '\r') break; + + vir_in1--; + } + + if (vir_in1 > LEN_MAX) continue; + + while (!feof (fd2)) + { + size_t real_sz2 = read_segment (buf_in2, fd2); + + char *max_in2 = buf_in2 + real_sz2; + + char *ptr_in2; + + size_t len_in2; + + for (ptr_in2 = buf_in2; ptr_in2 < max_in2; ptr_in2 += len_in2 + 1) + { + len_in2 = get_line_len (ptr_in2, max_in2); + + size_t vir_in2 = len_in2; + + while (vir_in2) + { + if (ptr_in2[vir_in2 - 1] != '\r') break; + + vir_in2--; + } + + if (vir_in2 > LEN_MAX) continue; + + /** + * add to output buffer + */ + + size_t len_out = ptr_out - buf_out; + + size_t len_add = vir_in1 + vir_in2 + 1; + + if ((len_out + len_add) < SEGMENT_SIZE) + { + add (ptr_out, ptr_in1, vir_in1, ptr_in2, vir_in2); + + ptr_out += len_add; + } + else + { + size_t len_out = ptr_out - buf_out; + + fwrite (buf_out, 1, len_out, stdout); + + ptr_out = buf_out; + + add (ptr_out, ptr_in1, vir_in1, ptr_in2, vir_in2); + + ptr_out += len_add; + } + } + } + + rewind (fd2); + } + } + + size_t len_out = ptr_out - buf_out; + + fwrite (buf_out, 1, len_out, stdout); + + fclose (fd2); + fclose (fd1); + + free (buf_out); + + free (buf_in2); + free (buf_in1); + + return 0; +} diff --git a/src/combinator3.c b/src/combinator3.c new file mode 100644 index 0000000..ace0fbc --- /dev/null +++ b/src/combinator3.c @@ -0,0 +1,284 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include +#include +#include "utils.c" + +#define LEN_MAX 32 + +#define SEGMENT_SIZE (32 * 1024 * 1024) +#define SEGMENT_ALIGN ( 8 * 1024) + +/** + * Name........: combinator3 + * Autor.......: Jens Steube + * License.....: MIT + */ + +static size_t read_segment (char *buf, FILE *fd) +{ + size_t read_sz = SEGMENT_SIZE - SEGMENT_ALIGN; + + size_t real_sz = fread (buf, 1, read_sz, fd); + + if (real_sz == 0) return (0); + + if (real_sz != read_sz) + { + if (buf[real_sz - 1] != '\n') + { + real_sz++; + + buf[real_sz - 1] = '\n'; + } + + return (real_sz); + } + + size_t extra; + + for (extra = 0; extra < SEGMENT_ALIGN; extra++) + { + if (fread (buf + real_sz, 1, 1, fd) == 0) break; + + real_sz++; + + if (buf[real_sz - 1] == '\n') break; + } + + return (real_sz); +} + +static size_t get_line_len (char *pos, char *max) +{ + char *cur = pos; + + for (cur = pos; cur < max; cur++) + { + if (*cur == '\n') break; + } + + size_t len = cur - pos; + + return (len); +} + +static void add (char *ptr_out, char *ptr_in1, size_t len_in1, char *ptr_in2, size_t len_in2, char *ptr_in3, size_t len_in3) +{ + memcpy (ptr_out, ptr_in1, len_in1); + + ptr_out += len_in1; + + memcpy (ptr_out, ptr_in2, len_in2); + + ptr_out += len_in2; + + memcpy (ptr_out, ptr_in3, len_in3); + + ptr_out += len_in3; + + *ptr_out = '\n'; +} + +int main (int argc, char *argv[]) +{ + if (argc != 4) + { + fprintf (stderr, "usage: %s file1 file2 file3\n", argv[0]); + + return (-1); + } + + size_t sz_buf = SEGMENT_SIZE + SEGMENT_ALIGN; + + char *buf_in1 = (char *) malloc (sz_buf); + char *buf_in2 = (char *) malloc (sz_buf); + char *buf_in3 = (char *) malloc (sz_buf); + + char *buf_out = (char *) malloc (sz_buf); + + char *ptr_out = buf_out; + + FILE *fd1; + FILE *fd2; + FILE *fd3; + + if ((fd1 = fopen (argv[1], "rb")) == NULL) + { + fprintf (stderr, "%s: %s\n", argv[1], strerror (errno)); + + free (buf_in1); + free (buf_in2); + free (buf_in3); + + free (buf_out); + + return (-1); + } + + if ((fd2 = fopen (argv[2], "rb")) == NULL) + { + fprintf (stderr, "%s: %s\n", argv[2], strerror (errno)); + + free (buf_in1); + free (buf_in2); + free (buf_in3); + + free (buf_out); + + fclose (fd1); + + return (-1); + } + + if ((fd3 = fopen (argv[3], "rb")) == NULL) + { + fprintf (stderr, "%s: %s\n", argv[3], strerror (errno)); + + free (buf_in1); + free (buf_in2); + free (buf_in3); + + free (buf_out); + + fclose (fd1); + fclose (fd2); + + return (-1); + } + + while (!feof (fd1)) + { + size_t real_sz1 = read_segment (buf_in1, fd1); + + char *max_in1 = buf_in1 + real_sz1; + + char *ptr_in1; + + size_t len_in1; + + for (ptr_in1 = buf_in1; ptr_in1 < max_in1; ptr_in1 += len_in1 + 1) + { + len_in1 = get_line_len (ptr_in1, max_in1); + + size_t vir_in1 = len_in1; + + while (vir_in1) + { + if (ptr_in1[vir_in1 - 1] != '\r') break; + + vir_in1--; + } + + if (vir_in1 > LEN_MAX) continue; + + while (!feof (fd2)) + { + size_t real_sz2 = read_segment (buf_in2, fd2); + + char *max_in2 = buf_in2 + real_sz2; + + char *ptr_in2; + + size_t len_in2; + + for (ptr_in2 = buf_in2; ptr_in2 < max_in2; ptr_in2 += len_in2 + 1) + { + len_in2 = get_line_len (ptr_in2, max_in2); + + size_t vir_in2 = len_in2; + + while (vir_in2) + { + if (ptr_in2[vir_in2 - 1] != '\r') break; + + vir_in2--; + } + + if (vir_in2 > LEN_MAX) continue; + + while (!feof (fd3)) + { + size_t real_sz3 = read_segment (buf_in3, fd3); + + char *max_in3 = buf_in3 + real_sz3; + + char *ptr_in3; + + size_t len_in3; + + for (ptr_in3 = buf_in3; ptr_in3 < max_in3; ptr_in3 += len_in3 + 1) + { + len_in3 = get_line_len (ptr_in3, max_in3); + + size_t vir_in3 = len_in3; + + while (vir_in3) + { + if (ptr_in3[vir_in3 - 1] != '\r') break; + + vir_in3--; + } + + if (vir_in3 > LEN_MAX) continue; + + /** + * add to output buffer + */ + + size_t len_out = ptr_out - buf_out; + + size_t len_add = vir_in1 + vir_in2 + vir_in3 + 1; + + if ((len_out + len_add) < SEGMENT_SIZE) + { + add (ptr_out, ptr_in1, vir_in1, ptr_in2, vir_in2, ptr_in3, vir_in3); + + ptr_out += len_add; + } + else + { + size_t len_out = ptr_out - buf_out; + + fwrite (buf_out, 1, len_out, stdout); + + ptr_out = buf_out; + + add (ptr_out, ptr_in1, vir_in1, ptr_in2, vir_in2, ptr_in3, vir_in3); + + ptr_out += len_add; + } + } + } + + rewind (fd3); + } + } + + rewind (fd2); + } + } + + size_t len_out = ptr_out - buf_out; + + fwrite (buf_out, 1, len_out, stdout); + + fclose (fd3); + fclose (fd2); + fclose (fd1); + + free (buf_out); + + free (buf_in3); + free (buf_in2); + free (buf_in1); + + return 0; +} diff --git a/src/combipow.c b/src/combipow.c new file mode 100644 index 0000000..c04c151 --- /dev/null +++ b/src/combipow.c @@ -0,0 +1,204 @@ +#include +#include +#include +#include + +/** + * Name........: Combined-Power Utility + * Autor.......: Unix-Ninja + */ + +/* + * This utility is meant to created "unique combinations" of a given input file's lines. + * Please note, this will NOT create permutations of the input. + * + */ + +typedef int bool; +#define false 0 +#define true 1 +#define LINE_SIZE 64 +#define LINE_LIMIT 15 + 1 /* we add one to the limit for the null terminator */ +#define MAX_LINES 64 /* this is the limit of using a single unsigned 64-bit integer */ + /* exceeding this count will cause the counters to wrap */ +char *progname; + +int usage() +{ + fprintf (stderr, "%s - utility to create \"unique combinations\" of given input\n", progname); + fprintf (stderr, "\n"); + fprintf (stderr, "Usage: %s [options] file1\n", progname); + fprintf (stderr, "\n"); + fprintf (stderr, " Please note, you can not use more then 64 lines of input for this utility. In\n"); + fprintf (stderr, " all honesty, you don't want to. 64 lines would generate approximately 187 EB\n"); + fprintf (stderr, " (or 187,660,921,384 GB) worth of data (supposing each line was about 1 byte).\n"); + fprintf (stderr, " If you are trying to generate that much data, you're probably doing it wrong.\n"); + fprintf (stderr, "\n"); + fprintf (stderr, "=======\n"); + fprintf (stderr, "Options\n"); + fprintf (stderr, "=======\n"); + fprintf (stderr, "\n"); + fprintf (stderr, " -h display this message\n"); + fprintf (stderr, " -s use space separator in output\n"); + fprintf (stderr, " -l limit lines to 15 chars (useful for hashcat rules)\n"); + return (-1); +} + +int main (int argc, char *argv[]) +{ + bool op_space = false; + bool op_limit = false; + char *f1, *f2; + f1 = f2 = "\0"; + unsigned int i; + int lines; + progname = argv[0]; + + for (i = 1; i < (unsigned int) argc; i++) + { + if (*(argv[i] + 0) == '-') + { + if (!strcmp (argv[i],"-h")) + { + return usage(); + } + else if (!strcmp (argv[i],"-l")) + { + op_limit = true; + } + else if (!strcmp (argv[i],"-s")) + { + op_space = true; + } + } + else if (!strcmp (f1, "\0")) + { + f1 = argv[i]; + } + else + { + return usage(); + } + } + + if (!strcmp (f1, "\0")) + { + return usage(); + } + + FILE *fd1; + + if ((fd1 = fopen (f1, "rb")) == NULL) + { + fprintf (stderr, "%s: %s\n", f1, strerror (errno)); + return (-1); + } + + lines = 0; + char line[LINE_SIZE]; + while (fgets (line, LINE_SIZE, fd1)) + { + if (strlen(line) > LINE_LIMIT && op_limit) + { + fprintf(stderr, "Line length exceeded in input. Skipping...\n"); + continue; + } + lines++; + } + rewind (fd1); + + /* we can't exceed the max line count. err if we do. */ + if (lines > MAX_LINES) + { + fprintf (stderr, "You can not exceed %d lines in your input file! Unable to continue.\n", MAX_LINES); + return (-1); + } + + /* allocate mem for buffer and check for success */ + char **buf = calloc (lines, sizeof (char *)); + + if (buf == NULL) + { + fprintf (stderr, "Unable to allocate memory!"); + return (-1); + } + + i = 0; + while (fgets (line, LINE_SIZE, fd1)) + { + /* skip empty lines and remove them from line count */ + if (line[0] == '\r' || line[0] == '\n') + { + lines--; + continue; + } + /* skip long lines */ + if (strlen(line) > LINE_LIMIT && op_limit) + { + continue; + } + + int length = strlen (line); + + // copy line... + // but without newline char(s) + if ((int) line[length - 2] == '\r') length--; + + buf[i] = calloc (length, sizeof (char)); + + if (buf[i] == NULL) + { + fprintf (stderr, "Unable to allocate memory!"); + return (-1); + } + + strncpy ((char *) buf[i], line, length - 1); + + i++; + } + + fclose (fd1); + + /* printf ("%d lines found.\n", lines); */ + + /* find combinations */ + int j; + bool pad; + char lb[LINE_LIMIT]; + int pad_size = op_limit ? 1 : 0; + + for (i = 1; i < (unsigned int)(1 << lines); i++) + { + pad = false; + memset(lb, '\0', LINE_LIMIT); /* initialize the line buffer */ + + for (j = 0; j < lines; j++) + { + if (i & (1 << j)) + { + if(op_limit) + { + if ((strlen((char *)buf[j]) + strlen(lb) + pad_size) > (LINE_LIMIT-1)) + { + fprintf (stderr, "Line length exceeded in output. Skipping...\n"); + continue; + } + if (op_space && pad) strcat(lb, " "); + strcat(lb, (char *)buf[j]); + } else { + if (op_space && pad) printf (" "); + printf ("%s", (char *)buf[j]); + } + pad = true; + } + } + /* print buffer if not empty */ + if(strlen(lb)) + { + printf ("%s", lb); + } + printf("\n"); + } + + return 0; +} diff --git a/src/cutb.c b/src/cutb.c new file mode 100644 index 0000000..d0e4c9b --- /dev/null +++ b/src/cutb.c @@ -0,0 +1,71 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include +#include +#include "utils.c" + +/** + * Name........: cutb + * Autor.......: Jens Steube + * License.....: MIT + */ + +int main (int argc, char *argv[]) +{ + if ((argc != 2) && (argc != 3)) + { + fprintf (stderr, "usage: %s offset [length] < infile > outfile\n", argv[0]); + + return (-1); + } + + #ifdef _WINDOWS + _setmode (_fileno (stdin), _O_BINARY); + #endif + + int offset = atoi (argv[1]); + + int length = 1000; + + if (argc == 3) + { + length = atoi (argv[2]); + } + + char line_buf[BUFSIZ]; + + int line_len; + + while ((line_len = fgetl (stdin, BUFSIZ, line_buf)) != -1) + { + char *ptr = line_buf; + + if (offset > 0) + { + ptr += offset; + + line_len -= offset; + } + else if (offset < 0) + { + ptr += line_len + offset; + + line_len += offset; + } + + if (line_len > length) line_len = length; + + ptr[line_len] = 0; + + puts (ptr); + } + + return 0; +} diff --git a/src/expander.c b/src/expander.c new file mode 100644 index 0000000..3834d11 --- /dev/null +++ b/src/expander.c @@ -0,0 +1,133 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include +#include +#include "utils.c" + +#define LEN_MIN 1 +#define LEN_MAX 4 + +/** + * Name........: expander + * Autor.......: Jens Steube + * License.....: MIT + */ + +void strrotl (char *s, int len) +{ + char *s1 = s; + char *s2 = s; + + for (s2 += len - 1; s1 < s2; s2--) + { + *s1 ^= *s2; + *s2 ^= *s1; + *s1 ^= *s2; + } +} + +void strrotr (char *s, int len) +{ + char *s1 = s; + char *s2 = s; + + for (s2++; s2 < s1 + len; s2++) + { + *s1 ^= *s2; + *s2 ^= *s1; + *s1 ^= *s2; + } +} + +int main (int argc, char *argv[]) +{ + if (argc != 1) + { + fprintf (stderr, "usage: %s < infile > outfile\n", argv[0]); + + return (-1); + } + + #ifdef _WINDOWS + _setmode (_fileno (stdin), _O_BINARY); + #endif + + char line_buf[BUFSIZ]; + + int line_len; + + while ((line_len = fgetl (stdin, BUFSIZ, line_buf)) != -1) + { + if (line_len == 0) continue; + + int n; + + for (n = LEN_MIN; n <= LEN_MAX; n++) + { + if (n > line_len) break; + + char tmp2_buf[BUFSIZ]; + + memcpy (tmp2_buf, line_buf, line_len); + + int i; + + /* rotate to the left */ + + for (i = 0; i < n; i++) + { + int j; + + for (j = 0; j + n <= line_len; j += n) + { + int out_len = (int) strlen (tmp2_buf + j); + + if (out_len > n) out_len = n; + + char out_buf[BUFSIZ]; + + memcpy (out_buf, tmp2_buf + j, out_len); + + out_buf[out_len] = 0; + + puts (out_buf); + } + + strrotl (tmp2_buf, line_len); + } + + /* rotate to the right */ + + for (i = 0; i < n; i++) + { + int j; + + for (j = 0; j + n <= line_len; j += n) + { + int out_len = (int) strlen (tmp2_buf + j); + + if (out_len > n) out_len = n; + + char out_buf[BUFSIZ]; + + memcpy (out_buf, tmp2_buf + j, out_len); + + out_buf[out_len] = 0; + + puts (out_buf); + } + + strrotr (tmp2_buf, line_len); + } + } + } + + return 0; +} diff --git a/src/gate.c b/src/gate.c new file mode 100644 index 0000000..65f06ed --- /dev/null +++ b/src/gate.c @@ -0,0 +1,62 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include +#include +#include "utils.c" + +/** + * Name........: gate + * Autor.......: Jens Steube + * License.....: MIT + */ + +int main (int argc, char *argv[]) +{ + if (argc != 3) + { + fprintf (stderr, "usage: %s mod offset < infile > outfile\n", argv[0]); + + return (-1); + } + + #ifdef _WINDOWS + _setmode (_fileno (stdin), _O_BINARY); + #endif + + int mod = atoi (argv[1]); + + int offset = atoi (argv[2]); + + if (offset >= mod) + { + fprintf (stderr, "offset >= mod\n"); + + return (-1); + } + + int pos = 0; + + char line_buf[BUFSIZ]; + + int line_len; + + while ((line_len = fgetl (stdin, BUFSIZ, line_buf)) != -1) + { + if (line_len == 0) continue; + + if (pos == mod) pos = 0; + + if ((pos++ % mod) != offset) continue; + + puts (line_buf); + } + + return 0; +} diff --git a/src/generate-rules.c b/src/generate-rules.c new file mode 100644 index 0000000..00bb57c --- /dev/null +++ b/src/generate-rules.c @@ -0,0 +1,300 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include "utils.c" + +/** + * Name........: generate-rules + * Autor.......: Jens Steube + * License.....: MIT + */ + +#define RP_GEN_FUNC_MIN 1 +#define RP_GEN_FUNC_MAX 4 + +#define RULE_OP_MANGLE_NOOP ':' +#define RULE_OP_MANGLE_LREST 'l' +#define RULE_OP_MANGLE_UREST 'u' +#define RULE_OP_MANGLE_LREST_UFIRST 'c' +#define RULE_OP_MANGLE_UREST_LFIRST 'C' +#define RULE_OP_MANGLE_TREST 't' +#define RULE_OP_MANGLE_TOGGLE_AT 'T' +#define RULE_OP_MANGLE_REVERSE 'r' +#define RULE_OP_MANGLE_DUPEWORD 'd' +#define RULE_OP_MANGLE_DUPEWORD_TIMES 'p' +#define RULE_OP_MANGLE_REFLECT 'f' +#define RULE_OP_MANGLE_ROTATE_LEFT '{' +#define RULE_OP_MANGLE_ROTATE_RIGHT '}' +#define RULE_OP_MANGLE_APPEND '$' +#define RULE_OP_MANGLE_PREPEND '^' +#define RULE_OP_MANGLE_DELETE_FIRST '[' +#define RULE_OP_MANGLE_DELETE_LAST ']' +#define RULE_OP_MANGLE_DELETE_AT 'D' +#define RULE_OP_MANGLE_EXTRACT 'x' +#define RULE_OP_MANGLE_INSERT 'i' +#define RULE_OP_MANGLE_OVERSTRIKE 'o' +#define RULE_OP_MANGLE_TRUNCATE_AT '\'' +#define RULE_OP_MANGLE_REPLACE 's' +#define RULE_OP_MANGLE_PURGECHAR '@' +#define RULE_OP_MANGLE_TOGGLECASE_REC 'a' +#define RULE_OP_MANGLE_DUPECHAR_FIRST 'z' +#define RULE_OP_MANGLE_DUPECHAR_LAST 'Z' +#define RULE_OP_MANGLE_DUPECHAR_ALL 'q' +#define RULE_OP_MANGLE_EXTRACT_MEMORY 'X' +#define RULE_OP_MANGLE_APPEND_MEMORY '4' +#define RULE_OP_MANGLE_PREPEND_MEMORY '6' + +#define RULE_OP_MEMORIZE_WORD 'M' + +#define RULE_OP_REJECT_LESS '<' +#define RULE_OP_REJECT_GREATER '>' +#define RULE_OP_REJECT_CONTAIN '!' +#define RULE_OP_REJECT_NOT_CONTAIN '/' +#define RULE_OP_REJECT_EQUAL_FIRST '(' +#define RULE_OP_REJECT_EQUAL_LAST ')' +#define RULE_OP_REJECT_EQUAL_AT '=' +#define RULE_OP_REJECT_CONTAINS '%' +#define RULE_OP_REJECT_MEMORY 'Q' + +/* hashcat only */ +#define RULE_OP_MANGLE_SWITCH_FIRST 'k' +#define RULE_OP_MANGLE_SWITCH_LAST 'K' +#define RULE_OP_MANGLE_SWITCH_AT '*' +#define RULE_OP_MANGLE_CHR_SHIFTL 'L' +#define RULE_OP_MANGLE_CHR_SHIFTR 'R' +#define RULE_OP_MANGLE_CHR_INCR '+' +#define RULE_OP_MANGLE_CHR_DECR '-' +#define RULE_OP_MANGLE_REPLACE_NP1 '.' +#define RULE_OP_MANGLE_REPLACE_NM1 ',' +#define RULE_OP_MANGLE_DUPEBLOCK_FIRST 'y' +#define RULE_OP_MANGLE_DUPEBLOCK_LAST 'Y' +#define RULE_OP_MANGLE_TITLE 'E' + +static const char grp_op_nop[] = +{ + RULE_OP_MANGLE_LREST, + RULE_OP_MANGLE_UREST, + RULE_OP_MANGLE_LREST_UFIRST, + RULE_OP_MANGLE_UREST_LFIRST, + RULE_OP_MANGLE_TREST, + RULE_OP_MANGLE_REVERSE, + RULE_OP_MANGLE_DUPEWORD, + RULE_OP_MANGLE_REFLECT, + RULE_OP_MANGLE_DELETE_FIRST, + RULE_OP_MANGLE_DELETE_LAST, + RULE_OP_MANGLE_ROTATE_LEFT, + RULE_OP_MANGLE_ROTATE_RIGHT, + RULE_OP_MANGLE_SWITCH_FIRST, + RULE_OP_MANGLE_SWITCH_LAST, + RULE_OP_MANGLE_DUPECHAR_ALL, + RULE_OP_MANGLE_TITLE, + RULE_OP_MANGLE_APPEND_MEMORY, + RULE_OP_MANGLE_PREPEND_MEMORY, +}; + +static const char grp_op_pos_p0[] = +{ + RULE_OP_MANGLE_TOGGLE_AT, + RULE_OP_MANGLE_DELETE_AT, + RULE_OP_MANGLE_TRUNCATE_AT, + RULE_OP_MANGLE_CHR_INCR, + RULE_OP_MANGLE_CHR_DECR, + RULE_OP_MANGLE_CHR_SHIFTL, + RULE_OP_MANGLE_CHR_SHIFTR, + RULE_OP_MANGLE_REPLACE_NP1, + RULE_OP_MANGLE_REPLACE_NM1 +}; + +static const char grp_op_pos_p1[] = +{ + RULE_OP_MANGLE_DUPEWORD_TIMES, + RULE_OP_MANGLE_DUPECHAR_FIRST, + RULE_OP_MANGLE_DUPECHAR_LAST, + RULE_OP_MANGLE_DUPEBLOCK_FIRST, + RULE_OP_MANGLE_DUPEBLOCK_LAST +}; + +static const char grp_op_chr[] = +{ + RULE_OP_MANGLE_APPEND, + RULE_OP_MANGLE_PREPEND, + RULE_OP_MANGLE_PURGECHAR +}; + +static const char grp_op_chr_chr[] = +{ + RULE_OP_MANGLE_REPLACE +}; + +static const char grp_op_pos_chr[] = +{ + RULE_OP_MANGLE_INSERT, + RULE_OP_MANGLE_OVERSTRIKE +}; + +static const char grp_op_pos_pos0[] = +{ + RULE_OP_MANGLE_SWITCH_AT +}; + +static const char grp_op_pos_pos1[] = +{ + RULE_OP_MANGLE_EXTRACT +}; + +static const char grp_op_pos1_pos2_pos3[] = +{ + RULE_OP_MANGLE_EXTRACT_MEMORY +}; + +static const char grp_pos[] = +{ + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B' +}; + +static void generate_random_rule (char rule_buf[BUFSIZ], const uint32_t rp_gen_func_min, const uint32_t rp_gen_func_max) +{ + const uint32_t rp_gen_num = get_random_num (rp_gen_func_min, rp_gen_func_max); + + uint32_t j; + + uint32_t rule_pos = 0; + + for (j = 0; j < rp_gen_num; j++) + { + uint32_t r = 0; + uint32_t p1 = 0; + uint32_t p2 = 0; + uint32_t p3 = 0; + + switch ((char) get_random_num (0, 9)) + { + case 0: + r = get_random_num (0, sizeof (grp_op_nop)); + rule_buf[rule_pos++] = grp_op_nop[r]; + break; + + case 1: + r = get_random_num (0, sizeof (grp_op_pos_p0)); + rule_buf[rule_pos++] = grp_op_pos_p0[r]; + p1 = get_random_num (0, sizeof (grp_pos)); + rule_buf[rule_pos++] = grp_pos[p1]; + break; + + case 2: + r = get_random_num (0, sizeof (grp_op_pos_p1)); + rule_buf[rule_pos++] = grp_op_pos_p1[r]; + p1 = get_random_num (1, 6); + rule_buf[rule_pos++] = grp_pos[p1]; + break; + + case 3: + r = get_random_num (0, sizeof (grp_op_chr)); + rule_buf[rule_pos++] = grp_op_chr[r]; + p1 = get_random_num (0x20, 0x7e); + rule_buf[rule_pos++] = (char) p1; + break; + + case 4: + r = get_random_num (0, sizeof (grp_op_chr_chr)); + rule_buf[rule_pos++] = grp_op_chr_chr[r]; + p1 = get_random_num (0x20, 0x7e); + rule_buf[rule_pos++] = (char) p1; + p2 = get_random_num (0x20, 0x7e); + while (p1 == p2) + p2 = get_random_num (0x20, 0x7e); + rule_buf[rule_pos++] = (char) p2; + break; + + case 5: + r = get_random_num (0, sizeof (grp_op_pos_chr)); + rule_buf[rule_pos++] = grp_op_pos_chr[r]; + p1 = get_random_num (0, sizeof (grp_pos)); + rule_buf[rule_pos++] = grp_pos[p1]; + p2 = get_random_num (0x20, 0x7e); + rule_buf[rule_pos++] = (char) p2; + break; + + case 6: + r = get_random_num (0, sizeof (grp_op_pos_pos0)); + rule_buf[rule_pos++] = grp_op_pos_pos0[r]; + p1 = get_random_num (0, sizeof (grp_pos)); + rule_buf[rule_pos++] = grp_pos[p1]; + p2 = get_random_num (0, sizeof (grp_pos)); + while (p1 == p2) + p2 = get_random_num (0, sizeof (grp_pos)); + rule_buf[rule_pos++] = grp_pos[p2]; + break; + + case 7: + r = get_random_num (0, sizeof (grp_op_pos_pos1)); + rule_buf[rule_pos++] = grp_op_pos_pos1[r]; + p1 = get_random_num (0, sizeof (grp_pos)); + rule_buf[rule_pos++] = grp_pos[p1]; + p2 = get_random_num (1, sizeof (grp_pos)); + while (p1 == p2) + p2 = get_random_num (1, sizeof (grp_pos)); + rule_buf[rule_pos++] = grp_pos[p2]; + break; + + case 8: + r = get_random_num (0, sizeof (grp_op_pos1_pos2_pos3)); + rule_buf[rule_pos++] = grp_op_pos1_pos2_pos3[r]; + p1 = get_random_num (0, sizeof (grp_pos)); + rule_buf[rule_pos++] = grp_pos[p1]; + p2 = get_random_num (1, sizeof (grp_pos)); + rule_buf[rule_pos++] = grp_pos[p1]; + p3 = get_random_num (0, sizeof (grp_pos)); + rule_buf[rule_pos++] = grp_pos[p3]; + break; + } + + rule_buf[rule_pos++] = ' '; + } +} + +int main (int argc, char *argv[]) +{ + if ((argc != 2) && (argc != 3)) + { + fprintf (stderr, "usage: %s number [seed]\n", argv[0]); + + return (-1); + } + + int num = atoi (argv[1]); + + time_t seed; + + if (argc == 3) + { + seed = atoi (argv[2]); + } + else + { + time (&seed); + } + + srand (seed); + + int i; + + for (i = 0; i < num; i++) + { + char rule_buf[BUFSIZ]; + + memset (rule_buf, 0, sizeof (rule_buf)); + + generate_random_rule (rule_buf, RP_GEN_FUNC_MIN, RP_GEN_FUNC_MAX); + + puts (rule_buf); + } + + return 0; +} diff --git a/src/hcstatgen.c b/src/hcstatgen.c new file mode 100644 index 0000000..280270f --- /dev/null +++ b/src/hcstatgen.c @@ -0,0 +1,183 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include +#include +#include +#include "utils.c" + +/** + * Name........: hcstatgen + * Autor.......: Jens Steube + * License.....: MIT + */ + +#define CHARSIZ 0x100 + +#define PW_MIN 2 +#define PW_MAX 64 + +#define HEX 0 + +/** + * Outfile structure: + * + * - PW_MAX pw_pos + * - CHARSIZ root + * - PW_MAX pw_pos + * - CHARSIZ key0 + * - CHARSIZ key1 + */ + +static uint8_t hex_convert (uint8_t c) +{ + return (c & 15) + (c >> 6) * 9; +} + +int main (int argc, char *argv[]) +{ + uint32_t i, j; + + if (argc != 2) + { + fprintf (stderr, "usage: %s outfile < dictionary\n", argv[0]); + + return (-1); + } + + char *outfile = argv[1]; + + /* init data */ + + const uint32_t root_cnt = PW_MAX * CHARSIZ; + + uint64_t *root_stats_buf = (uint64_t *) calloc (root_cnt, sizeof (uint64_t)); + + uint64_t *root_stats_ptr = root_stats_buf; + + uint64_t *root_stats_buf_by_pos[PW_MAX]; + + for (i = 0; i < PW_MAX; i++) + { + root_stats_buf_by_pos[i] = root_stats_ptr; + + root_stats_ptr += CHARSIZ; + } + + const uint32_t markov_cnt = PW_MAX * CHARSIZ * CHARSIZ; + + uint64_t *markov_stats_buf = (uint64_t *) calloc (markov_cnt, sizeof (uint64_t)); + + uint64_t *markov_stats_ptr = markov_stats_buf; + + uint64_t *markov_stats_buf_by_key[PW_MAX][CHARSIZ]; + + for (i = 0; i < PW_MAX; i++) + { + for (j = 0; j < CHARSIZ; j++) + { + markov_stats_buf_by_key[i][j] = markov_stats_ptr; + + markov_stats_ptr += CHARSIZ; + } + } + + /* parse dictionary */ + + char tmp[BUFSIZ]; + + printf ("Reading input...\n"); + + if (HEX) + { + while (!feof (stdin)) + { + char *line_buf = fgets (tmp, BUFSIZ, stdin); + + if (line_buf == NULL) continue; + + size_t line_len = super_chop (line_buf, strlen (line_buf)); + + if (line_len < PW_MIN) continue; + if (line_len > PW_MAX) continue; + + size_t line_pos; + + for (line_pos = 0; line_pos < line_len - 2; line_pos += 2) + { + uint8_t c0 = hex_convert (line_buf[line_pos + 1]) << 0 + | hex_convert (line_buf[line_pos + 0]) << 4; + uint8_t c1 = hex_convert (line_buf[line_pos + 3]) << 0 + | hex_convert (line_buf[line_pos + 2]) << 4; + + root_stats_buf_by_pos[line_pos][c0]++; + + markov_stats_buf_by_key[line_pos][c0][c1]++; + } + + uint8_t c0 = hex_convert (line_buf[line_pos + 1]) << 0 + | hex_convert (line_buf[line_pos + 0]) << 4; + + root_stats_buf_by_pos[line_pos][c0]++; + } + } + else + { + while (!feof (stdin)) + { + char *line_buf = fgets (tmp, BUFSIZ, stdin); + + if (line_buf == NULL) continue; + + size_t line_len = super_chop (line_buf, strlen (line_buf)); + + if (line_len < PW_MIN) continue; + if (line_len > PW_MAX) continue; + + size_t line_pos; + + for (line_pos = 0; line_pos < line_len - 1; line_pos += 1) + { + uint8_t c0 = line_buf[line_pos + 0]; + uint8_t c1 = line_buf[line_pos + 1]; + + root_stats_buf_by_pos[line_pos][c0]++; + + markov_stats_buf_by_key[line_pos][c0][c1]++; + } + + uint8_t c0 = line_buf[line_pos + 0]; + + root_stats_buf_by_pos[line_pos][c0]++; + } + } + + /* write results */ + + printf ("Writing stats...\n"); + + FILE *fd = fopen (outfile, "wb"); + + if (fd == NULL) + { + fprintf (stderr, "%s: %s", outfile, strerror (errno)); + + return (-1); + } + + fwrite (root_stats_buf, sizeof (uint64_t), root_cnt, fd); + fwrite (markov_stats_buf, sizeof (uint64_t), markov_cnt, fd); + + free (root_stats_buf); + free (markov_stats_buf); + + fclose (fd); + + return 0; +} diff --git a/src/keyspace.c b/src/keyspace.c new file mode 100644 index 0000000..9050896 --- /dev/null +++ b/src/keyspace.c @@ -0,0 +1,729 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 +#define __USE_MINGW_ANSI_STDIO 1 + +#include +#include +#include +#include +#include +#include +#include +#include + +/** + * Name........: keyspace + * Autor.......: Jens Steube + * License.....: MIT + */ + +#define CHARSIZ 0x100 + +#define SP_HCSTAT "hashcat.hcstat" +#define SP_PW_MIN 2 +#define SP_PW_MAX 64 +#define SP_ROOT_CNT (SP_PW_MAX * CHARSIZ) +#define SP_MARKOV_CNT (SP_PW_MAX * CHARSIZ * CHARSIZ) + +#define OPTS_TYPE_PT_UNICODE (1 << 0) +#define OPTS_TYPE_ST_UNICODE (1 << 10) + +typedef struct +{ + uint8_t key; + uint64_t val; + +} hcstat_table_t; + +typedef struct +{ + uint8_t cs_buf[CHARSIZ]; + uint32_t cs_len; + +} cs_t; + +uint8_t hex_convert (const uint8_t c) +{ + return (c & 15) + (c >> 6) * 9; +} + +void mp_css_to_uniq_tbl (const int css_cnt, cs_t *css_buf, int uniq_tbls[SP_PW_MAX][CHARSIZ]) +{ + int css_pos; + + for (css_pos = 0; css_pos < css_cnt; css_pos++) + { + uint8_t *cs_buf = css_buf[css_pos].cs_buf; + uint32_t cs_len = css_buf[css_pos].cs_len; + + int *uniq_tbl = uniq_tbls[css_pos]; + + uint32_t cs_pos; + + for (cs_pos = 0; cs_pos < cs_len; cs_pos++) + { + const uint8_t c = cs_buf[cs_pos]; + + uniq_tbl[c] = 1; + } + } +} + +void mp_add_cs_buf (const uint32_t in_len, const uint8_t *in_buf, const int css_pos, cs_t *css_buf) +{ + cs_t *cs = &css_buf[css_pos]; + + int *css_uniq = (int *) calloc (CHARSIZ, sizeof (int)); + + uint32_t i; + + for (i = 0; i < cs->cs_len; i++) + { + const uint8_t u = cs->cs_buf[i]; + + css_uniq[u] = 1; + } + + for (i = 0; i < in_len; i++) + { + const uint8_t u = in_buf[i]; + + if (css_uniq[u] == 1) continue; + + css_uniq[u] = 1; + + cs->cs_buf[cs->cs_len] = u; + + cs->cs_len++; + } + + free (css_uniq); +} + +void mp_expand (const int in_len, const uint8_t *in_buf, cs_t *mp_sys, cs_t *mp_usr, const int css_pos, const int hex_charset) +{ + int in_pos; + + for (in_pos = 0; in_pos < in_len; in_pos++) + { + const uint8_t p0 = in_buf[in_pos]; + + if (p0 == '?') + { + in_pos++; + + if (in_pos == in_len) break; + + const uint8_t p1 = in_buf[in_pos]; + + switch (p1) + { + case 'l': mp_add_cs_buf (mp_sys[0].cs_len, mp_sys[0].cs_buf, css_pos, mp_usr); + break; + case 'u': mp_add_cs_buf (mp_sys[1].cs_len, mp_sys[1].cs_buf, css_pos, mp_usr); + break; + case 'd': mp_add_cs_buf (mp_sys[2].cs_len, mp_sys[2].cs_buf, css_pos, mp_usr); + break; + case 's': mp_add_cs_buf (mp_sys[3].cs_len, mp_sys[3].cs_buf, css_pos, mp_usr); + break; + case 'a': mp_add_cs_buf (mp_sys[4].cs_len, mp_sys[4].cs_buf, css_pos, mp_usr); + break; + case 'b': mp_add_cs_buf (mp_sys[5].cs_len, mp_sys[5].cs_buf, css_pos, mp_usr); + break; + case '1': mp_add_cs_buf (mp_usr[0].cs_len, mp_usr[0].cs_buf, css_pos, mp_usr); + break; + case '2': mp_add_cs_buf (mp_usr[1].cs_len, mp_usr[1].cs_buf, css_pos, mp_usr); + break; + case '3': mp_add_cs_buf (mp_usr[2].cs_len, mp_usr[2].cs_buf, css_pos, mp_usr); + break; + case '4': mp_add_cs_buf (mp_usr[3].cs_len, mp_usr[3].cs_buf, css_pos, mp_usr); + break; + case '?': mp_add_cs_buf (1, &p1, css_pos, mp_usr); + break; + default: fprintf (stderr, "Syntax error: %s\n", in_buf); + exit (-1); + } + } + else + { + if (hex_charset) + { + in_pos++; + + if (in_pos == in_len) break; + + const uint8_t p1 = in_buf[in_pos]; + + const uint8_t chr = hex_convert (p1) << 0 + | hex_convert (p0) << 4; + + mp_add_cs_buf (1, &chr, css_pos, mp_usr); + } + else + { + const uint8_t chr = p0; + + mp_add_cs_buf (1, &chr, css_pos, mp_usr); + } + } + } +} + +cs_t *mp_gen_css (const int in_len, const uint8_t *in_buf, cs_t *mp_sys, cs_t *mp_usr, int *css_cnt, const int hex_charset) +{ + cs_t *css_buf = (cs_t *) calloc (CHARSIZ, sizeof (cs_t)); + + int in_pos; + int css_pos; + + for (in_pos = 0, css_pos = 0; in_pos < in_len; in_pos++, css_pos++) + { + const uint8_t p0 = in_buf[in_pos]; + + if (p0 == '?') + { + in_pos++; + + if (in_pos == in_len) break; + + const uint8_t p1 = in_buf[in_pos]; + + switch (p1) + { + case 'l': mp_add_cs_buf (mp_sys[0].cs_len, mp_sys[0].cs_buf, css_pos, css_buf); + break; + case 'u': mp_add_cs_buf (mp_sys[1].cs_len, mp_sys[1].cs_buf, css_pos, css_buf); + break; + case 'd': mp_add_cs_buf (mp_sys[2].cs_len, mp_sys[2].cs_buf, css_pos, css_buf); + break; + case 's': mp_add_cs_buf (mp_sys[3].cs_len, mp_sys[3].cs_buf, css_pos, css_buf); + break; + case 'a': mp_add_cs_buf (mp_sys[4].cs_len, mp_sys[4].cs_buf, css_pos, css_buf); + break; + case 'b': mp_add_cs_buf (mp_sys[5].cs_len, mp_sys[5].cs_buf, css_pos, css_buf); + break; + case '1': mp_add_cs_buf (mp_usr[0].cs_len, mp_usr[0].cs_buf, css_pos, css_buf); + break; + case '2': mp_add_cs_buf (mp_usr[1].cs_len, mp_usr[1].cs_buf, css_pos, css_buf); + break; + case '3': mp_add_cs_buf (mp_usr[2].cs_len, mp_usr[2].cs_buf, css_pos, css_buf); + break; + case '4': mp_add_cs_buf (mp_usr[3].cs_len, mp_usr[3].cs_buf, css_pos, css_buf); + break; + case '?': mp_add_cs_buf (1, &p1, css_pos, css_buf); + break; + default: fprintf (stderr, "ERROR: syntax error: %s\n", in_buf); + exit (-1); + } + } + else + { + if (hex_charset) + { + in_pos++; + + if (in_pos == in_len) break; + + const uint8_t p1 = in_buf[in_pos]; + + const uint8_t chr = hex_convert (p1) << 0 + | hex_convert (p0) << 4; + + mp_add_cs_buf (1, &chr, css_pos, css_buf); + } + else + { + const uint8_t chr = p0; + + mp_add_cs_buf (1, &chr, css_pos, css_buf); + } + } + } + + *css_cnt = css_pos; + + return (css_buf); +} + +void mp_setup_sys (cs_t *mp_sys) +{ + int pos; + int chr; + + int donec[CHARSIZ]; + + memset (donec, 0, sizeof (donec)); + + for (pos = 0, chr = 'a'; chr <= 'z'; chr++) { donec[chr] = 1; + mp_sys[0].cs_buf[pos++] = chr; + mp_sys[0].cs_len = pos; } + + for (pos = 0, chr = 'A'; chr <= 'Z'; chr++) { donec[chr] = 1; + mp_sys[1].cs_buf[pos++] = chr; + mp_sys[1].cs_len = pos; } + + for (pos = 0, chr = '0'; chr <= '9'; chr++) { donec[chr] = 1; + mp_sys[2].cs_buf[pos++] = chr; + mp_sys[2].cs_len = pos; } + + for (pos = 0, chr = 0x20; chr <= 0x7e; chr++) { if (donec[chr]) continue; + mp_sys[3].cs_buf[pos++] = chr; + mp_sys[3].cs_len = pos; } + + for (pos = 0, chr = 0x20; chr <= 0x7e; chr++) { mp_sys[4].cs_buf[pos++] = chr; + mp_sys[4].cs_len = pos; } + + for (pos = 0, chr = 0x00; chr <= 0xff; chr++) { mp_sys[5].cs_buf[pos++] = chr; + mp_sys[5].cs_len = pos; } +} + +void mp_setup_usr (cs_t *mp_sys, cs_t *mp_usr, const int in_len, const uint8_t *in_buf, const int css_pos, const int hex_charset) +{ + mp_expand (in_len, in_buf, mp_sys, mp_usr, css_pos, hex_charset); +} + +uint64_t sp_get_sum (const int start, const int stop, const cs_t *root_css_buf) +{ + uint64_t sum = 1; + + int i; + + for (i = start; i < stop; i++) + { + sum *= root_css_buf[i].cs_len; + } + + return (sum); +} + +int sp_comp_val (const void *p1, const void *p2) +{ + hcstat_table_t *b1 = (hcstat_table_t *) p1; + hcstat_table_t *b2 = (hcstat_table_t *) p2; + + return b2->val - b1->val; +} + +void sp_setup_tbl (const char *markov_hcstat, hcstat_table_t *root_table_buf, hcstat_table_t *markov_table_buf) +{ + /** + * Initialize hcstats + */ + + uint64_t *root_stats_buf = (uint64_t *) calloc (SP_ROOT_CNT, sizeof (uint64_t)); + + uint64_t *root_stats_ptr = root_stats_buf; + + int i; + + for (i = 0; i < SP_PW_MAX; i++) + { + root_stats_ptr += CHARSIZ; + } + + uint64_t *markov_stats_buf = (uint64_t *) calloc (SP_MARKOV_CNT, sizeof (uint64_t)); + + uint64_t *markov_stats_ptr = markov_stats_buf; + + for (i = 0; i < SP_PW_MAX; i++) + { + int j; + + for (j = 0; j < CHARSIZ; j++) + { + markov_stats_ptr += CHARSIZ; + } + } + + /** + * Load hcstats File + */ + + FILE *fd = fopen (markov_hcstat, "rb"); + + if (fd == NULL) + { + fprintf (stderr, "%s: %s\n", markov_hcstat, strerror (errno)); + + exit (-1); + } + + if (fread (root_stats_buf, sizeof (uint64_t), SP_ROOT_CNT, fd) != SP_ROOT_CNT) + { + fprintf (stderr, "%s: Could not load data\n", markov_hcstat); + + exit (-1); + } + + if (fread (markov_stats_buf, sizeof (uint64_t), SP_MARKOV_CNT, fd) != SP_MARKOV_CNT) + { + fprintf (stderr, "%s: Could not load data\n", markov_hcstat); + + exit (-1); + } + + fclose (fd); + + /** + * Initialize tables + */ + + hcstat_table_t *root_table_ptr = root_table_buf; + + hcstat_table_t *root_table_buf_by_pos[SP_PW_MAX]; + + for (i = 0; i < SP_PW_MAX; i++) + { + root_table_buf_by_pos[i] = root_table_ptr; + + root_table_ptr += CHARSIZ; + } + + hcstat_table_t *markov_table_ptr = markov_table_buf; + + hcstat_table_t *markov_table_buf_by_key[SP_PW_MAX][CHARSIZ]; + + for (i = 0; i < SP_PW_MAX; i++) + { + int j; + + for (j = 0; j < CHARSIZ; j++) + { + markov_table_buf_by_key[i][j] = markov_table_ptr; + + markov_table_ptr += CHARSIZ; + } + } + + /** + * Convert hcstat to tables + */ + + for (i = 0; i < SP_ROOT_CNT; i++) + { + const uint8_t key = i % CHARSIZ; + + root_table_buf[i].key = key; + root_table_buf[i].val = root_stats_buf[i]; + } + + for (i = 0; i < SP_MARKOV_CNT; i++) + { + const uint8_t key = i % CHARSIZ; + + markov_table_buf[i].key = key; + markov_table_buf[i].val = markov_stats_buf[i]; + } + + free (root_stats_buf); + free (markov_stats_buf); + + /** + * Finally sort them + */ + + for (i = 0; i < SP_PW_MAX; i++) + { + qsort (root_table_buf_by_pos[i], CHARSIZ, sizeof (hcstat_table_t), sp_comp_val); + } + + for (i = 0; i < SP_PW_MAX; i++) + { + int j; + + for (j = 0; j < CHARSIZ; j++) + { + qsort (markov_table_buf_by_key[i][j], CHARSIZ, sizeof (hcstat_table_t), sp_comp_val); + } + } +} + +void sp_tbl_to_css (hcstat_table_t *root_table_buf, hcstat_table_t *markov_table_buf, cs_t *root_css_buf, cs_t *markov_css_buf, const uint32_t markov_threshold, int uniq_tbls[SP_PW_MAX][CHARSIZ]) +{ + int i; + + for (i = 0; i < SP_ROOT_CNT; i++) + { + const int pw_pos = i / CHARSIZ; + + cs_t *cs = &root_css_buf[pw_pos]; + + if (cs->cs_len == markov_threshold) continue; + + const uint8_t key = root_table_buf[i].key; + + if (uniq_tbls[pw_pos][key] == 0) continue; + + cs->cs_buf[cs->cs_len] = key; + + cs->cs_len++; + } + + for (i = 0; i < SP_MARKOV_CNT; i++) + { + const int c = i / CHARSIZ; + + cs_t *cs = &markov_css_buf[c]; + + if (cs->cs_len == markov_threshold) continue; + + const int pw_pos = c / CHARSIZ; + + const uint8_t key = markov_table_buf[i].key; + + if ((pw_pos + 1) < SP_PW_MAX) if (uniq_tbls[pw_pos + 1][key] == 0) continue; + + cs->cs_buf[cs->cs_len] = key; + + cs->cs_len++; + } +} + +uint64_t keyspace (const int in_len, const uint8_t *in_buf, cs_t mp_sys[5], cs_t mp_usr[4], const char *markov_hcstat, const uint32_t markov_threshold, const int opts_type, const int hex_charset) +{ + int css_cnt = 0; + + cs_t *css_buf = mp_gen_css (in_len, in_buf, mp_sys, mp_usr, &css_cnt, hex_charset); + + if (opts_type & OPTS_TYPE_PT_UNICODE) + { + int css_cnt_unicode = css_cnt * 2; + + cs_t *css_buf_unicode = (cs_t *) calloc (css_cnt_unicode, sizeof (cs_t)); + + int i; + int j; + + for (i = 0, j = 0; i < css_cnt; i += 1, j += 2) + { + memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t)); + memset (&css_buf_unicode[j + 1], 0, sizeof (cs_t)); + + css_buf_unicode[j + 1].cs_len = 1; + } + + free (css_buf); + + css_buf = css_buf_unicode; + css_cnt = css_cnt_unicode; + } + + int uniq_tbls[SP_PW_MAX][CHARSIZ]; + + memset (uniq_tbls, 0, sizeof (uniq_tbls)); + + mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls); + + hcstat_table_t *root_table_buf = (hcstat_table_t *) calloc (SP_ROOT_CNT, sizeof (hcstat_table_t)); + hcstat_table_t *markov_table_buf = (hcstat_table_t *) calloc (SP_MARKOV_CNT, sizeof (hcstat_table_t)); + + sp_setup_tbl (markov_hcstat, root_table_buf, markov_table_buf); + + cs_t *root_css_buf = (cs_t *) calloc (SP_PW_MAX, sizeof (cs_t)); + cs_t *markov_css_buf = (cs_t *) calloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t)); + + sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls); + + int css_cnt_r; + + if (css_cnt < 6) + { + css_cnt_r = 1; + } + else if (css_cnt == 6) + { + css_cnt_r = 2; + } + else + { + if (opts_type & OPTS_TYPE_PT_UNICODE) + { + if (css_cnt == 8 || css_cnt == 10) + { + css_cnt_r = 2; + } + else + { + css_cnt_r = 4; + } + } + else + { + if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256) + { + css_cnt_r = 3; + } + else + { + css_cnt_r = 4; + } + } + } + + return sp_get_sum (css_cnt_r, css_cnt, root_css_buf); +} + +void usage (char *program) +{ + const char *help_text[] = { + "%s, keyspace utility for oclHashcat", + "", + "Usage: %s [options] mask", + "", + "=======", + "Options", + "=======", + "", + " -m, --hash-type=NUM Hash-type", + " --hex-charset Assume charset is given in hex", + " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat", + " -t, --markov-threshold=NUM Threshold for markov-chains", + " -1, --custom-charset1=CS User-defined charsets", + " -2, --custom-charset2=CS Examples:", + " -3, --custom-charset3=CS --custom-charset3=?dabcdef : sets charset ?3 to 0123456789abcdef", + " -4, --custom-charset4=CS --custom-charset4=?l?u : sets charset ?4 to all lower and upper case letters", + " -h, --help Print help", + NULL + }; + + int i; + + for (i = 0; help_text[i] != NULL; i++) + { + fprintf (stderr, help_text[i], program, program); + + fprintf (stderr, "\n"); + } +} + +int main (int argc, char *argv[]) +{ + #define IDX_HASH_MODE 'm' + #define IDX_HEX_CHARSET 0xff20 + #define IDX_MARKOV_THRESHOLD 't' + #define IDX_MARKOV_HCSTAT 0xff24 + #define IDX_CUSTOM_CHARSET_1 '1' + #define IDX_CUSTOM_CHARSET_2 '2' + #define IDX_CUSTOM_CHARSET_3 '3' + #define IDX_CUSTOM_CHARSET_4 '4' + #define IDX_HELP 'h' + + int hash_mode = 0; + int hex_charset = 0; + int markov_threshold = CHARSIZ; + char *markov_hcstat = SP_HCSTAT; + char *custom_charset_1 = NULL; + char *custom_charset_2 = NULL; + char *custom_charset_3 = NULL; + char *custom_charset_4 = NULL; + + char short_options[] = "hm:t:1:2:3:4:"; + + struct option long_options[] = + { + {"hash-type", required_argument, 0, IDX_HASH_MODE}, + {"hex-charset", no_argument, 0, IDX_HEX_CHARSET}, + {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD}, + {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT}, + {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1}, + {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2}, + {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3}, + {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4}, + {"help", no_argument, 0, IDX_HELP}, + + {NULL, 0, 0, 0} + }; + + optind = 1; + + int option_index = 0; + int help = 0; + int c; + + while ((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) + { + switch (c) + { + case IDX_HASH_MODE: hash_mode = atoi (optarg); break; + case IDX_HEX_CHARSET: hex_charset = 1; break; + case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break; + case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break; + case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break; + case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break; + case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break; + case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break; + case IDX_HELP: help = 1; break; + } + } + + if (help == 1) + { + usage (argv[0]); + + exit (1); + } + + if (optind < 1) + { + usage (argv[0]); + + return (-1); + } + + char *mask = argv[optind]; + + if (mask == NULL) + { + usage (argv[0]); + + + return (-1); + } + + int opts_type = 0; + + switch (hash_mode) + { + case 30: opts_type |= OPTS_TYPE_PT_UNICODE; break; + case 40: opts_type |= OPTS_TYPE_PT_UNICODE; break; + case 130: opts_type |= OPTS_TYPE_PT_UNICODE; break; + case 131: opts_type |= OPTS_TYPE_PT_UNICODE; break; + case 132: opts_type |= OPTS_TYPE_PT_UNICODE; break; + case 133: opts_type |= OPTS_TYPE_PT_UNICODE; break; + case 140: opts_type |= OPTS_TYPE_PT_UNICODE; break; + case 141: opts_type |= OPTS_TYPE_PT_UNICODE; break; + case 1000: opts_type |= OPTS_TYPE_PT_UNICODE; break; + case 1100: opts_type |= OPTS_TYPE_PT_UNICODE; + opts_type |= OPTS_TYPE_ST_UNICODE; break; + case 1430: opts_type |= OPTS_TYPE_PT_UNICODE; break; + case 1440: opts_type |= OPTS_TYPE_PT_UNICODE; break; + case 1441: opts_type |= OPTS_TYPE_PT_UNICODE; break; + case 1730: opts_type |= OPTS_TYPE_PT_UNICODE; break; + case 1731: opts_type |= OPTS_TYPE_PT_UNICODE; break; + case 1740: opts_type |= OPTS_TYPE_PT_UNICODE; break; + case 2100: opts_type |= OPTS_TYPE_PT_UNICODE; break; + case 5500: opts_type |= OPTS_TYPE_PT_UNICODE; break; + case 5600: opts_type |= OPTS_TYPE_PT_UNICODE; break; + case 8000: opts_type |= OPTS_TYPE_PT_UNICODE; break; + } + + cs_t mp_sys[6]; + cs_t mp_usr[4]; + + memset (mp_sys, 0, sizeof (mp_sys)); + memset (mp_usr, 0, sizeof (mp_usr)); + + mp_setup_sys (mp_sys); + + if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, strlen (custom_charset_1), (uint8_t *) custom_charset_1, 0, hex_charset); + if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, strlen (custom_charset_2), (uint8_t *) custom_charset_2, 1, hex_charset); + if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, strlen (custom_charset_3), (uint8_t *) custom_charset_3, 2, hex_charset); + if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, strlen (custom_charset_4), (uint8_t *) custom_charset_4, 3, hex_charset); + + const uint64_t n = keyspace (strlen (mask), (uint8_t *) mask, mp_sys, mp_usr, markov_hcstat, markov_threshold, opts_type, hex_charset); + + printf ("%llu\n", (unsigned long long int) n); + + return 0; +} diff --git a/src/len.c b/src/len.c new file mode 100644 index 0000000..f649a15 --- /dev/null +++ b/src/len.c @@ -0,0 +1,58 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include +#include +#include "utils.c" + +/** + * Name........: len + * Autor.......: Jens Steube + * License.....: MIT + */ + +int main (int argc, char *argv[]) +{ + if (argc != 3) + { + fprintf (stderr, "usage: %s min max < infile > outfile\n", argv[0]); + + return (-1); + } + + #ifdef _WINDOWS + _setmode (_fileno (stdin), _O_BINARY); + #endif + + int min = atoi (argv[1]); + int max = atoi (argv[2]); + + if (min > max) + { + fprintf (stderr, "min > max\n"); + + return (-1); + } + + char line_buf[BUFSIZ]; + + int line_len; + + while ((line_len = fgetl (stdin, BUFSIZ, line_buf)) != -1) + { + if (line_len == 0) continue; + + if (line_len < min) continue; + if (line_len > max) continue; + + puts (line_buf); + } + + return 0; +} diff --git a/src/mli2.c b/src/mli2.c new file mode 100644 index 0000000..1456832 --- /dev/null +++ b/src/mli2.c @@ -0,0 +1,125 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "utils.c" + +/** + * Name........: mli2 + * Autor.......: Jens Steube + * License.....: MIT + */ + +static int cmp_cache (const void *p1, const void *p2) +{ + return strcmp (p1, p2); +} + +int main (int argc, char *argv[]) +{ + FILE *fd1; + FILE *fd2; + + if (argc != 3) + { + fprintf (stderr, "usage: %s infile mergefile\n", argv[0]); + + return (-1); + } + + char *infile = argv[1]; + char *mergefile = argv[2]; + + if ((fd1 = fopen (infile, "rb")) == NULL) + { + fprintf (stderr, "%s: %s\n", infile, strerror (errno)); + + return (-1); + } + + if ((fd2 = fopen (mergefile, "rb")) == NULL) + { + fprintf (stderr, "%s: %s\n", mergefile, strerror (errno)); + + fclose (fd1); + + return (-1); + } + + char line_buf1[BUFSIZ]; + char line_buf2[BUFSIZ]; + + if (fgetl (fd1, BUFSIZ, line_buf1) == -1) memset (line_buf1, 0, BUFSIZ); + if (fgetl (fd2, BUFSIZ, line_buf2) == -1) memset (line_buf2, 0, BUFSIZ); + + int comp = 1; + + while (!feof (fd1) && !feof (fd2)) + { + comp = cmp_cache (line_buf1, line_buf2); + + if (comp == 0) + { + puts (line_buf1); + + if (fgetl (fd1, BUFSIZ, line_buf1) == -1) memset (line_buf1, 0, BUFSIZ); + if (fgetl (fd2, BUFSIZ, line_buf2) == -1) memset (line_buf2, 0, BUFSIZ); + } + else if (comp > 0) + { + puts (line_buf2); + + if (fgetl (fd2, BUFSIZ, line_buf2) == -1) memset (line_buf2, 0, BUFSIZ); + } + else if (comp < 0) + { + puts (line_buf1); + + if (fgetl (fd1, BUFSIZ, line_buf1) == -1) memset (line_buf1, 0, BUFSIZ); + } + } + + if (!feof (fd1) && comp == 0) puts (line_buf1); + if (!feof (fd2) && comp == 0) puts (line_buf2); + + if (comp > 0) puts (line_buf1); + + while (!feof (fd1)) + { + if (fgetl (fd1, BUFSIZ, line_buf1) == -1) + { + memset (line_buf1, 0, BUFSIZ); + + continue; + } + + puts (line_buf1); + } + + while (!feof (fd2)) + { + if (fgetl (fd2, BUFSIZ, line_buf2) == -1) + { + memset (line_buf2, 0, BUFSIZ); + + continue; + } + + puts (line_buf2); + } + + fclose (fd1); + fclose (fd2); + + return 0; +} diff --git a/src/morph.c b/src/morph.c new file mode 100644 index 0000000..4deb5e5 --- /dev/null +++ b/src/morph.c @@ -0,0 +1,246 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include +#include +#include +#include "utils.c" + +#define CHR_MIN 0x20 +#define CHR_MAX 0x7f + +#define KEYS_CNT1 0xff +#define KEYS_CNT2 0xffff +#define KEYS_CNT3 0xffffff + +/** + * Name........: morph + * Autor.......: Jens Steube + * License.....: MIT + */ + +typedef struct +{ + uint32_t key; + uint32_t val; + +} node; + +int comp (const void *p1, const void *p2) +{ + node *b1 = (node *) p1; + node *b2 = (node *) p2; + + return b2->val - b1->val; +} + +uint32_t count_keys (const uint32_t *c, const uint32_t n) +{ + uint32_t v = 0; + + uint32_t i; + + for (i = 0; i < n; i++) + { + if (c[i] == 0) continue; + + v++; + } + + return v; +} + +void move_keys (const uint32_t *c, const uint32_t n, node *s) +{ + uint32_t i; + + for (i = 0; i < n; i++) + { + if (c[i] == 0) continue; + + s->key = i; + s->val = c[i]; + + s++; + } +} + +void output_rule (node *sort_buf, const uint32_t sort_cnt, const uint32_t pos, const uint32_t width, const uint32_t depth) +{ + uint32_t i; + + for (i = 0; i < sort_cnt; i++, sort_buf++) + { + if (i > depth) break; + + char *key = (char *) &sort_buf->key; + + switch (width) + { + case 1: printf ("i%X%c\n", + pos + 0, key[0] + ); + break; + + case 2: printf ("i%X%c i%X%c\n", + pos + 0, key[0], + pos + 1, key[1] + ); + break; + + case 3: printf ("i%X%c i%X%c i%X%c\n", + pos + 0, key[0], + pos + 1, key[1], + pos + 2, key[2] + ); + break; + } + } +} + +int main (int argc, char *argv[]) +{ + if (argc != 6) + { + fprintf (stderr, "usage: %s dictionary depth width pos_min pos_max\n", argv[0]); + + return (-1); + } + + const char *dictionary = argv[1]; + + const int depth = atoi (argv[2]); + const int width = atoi (argv[3]); + const int pos_min = atoi (argv[4]); + const int pos_max = atoi (argv[5]); + + if (width > 3) + { + fprintf (stderr, "width > 3\n"); + + return (-1); + } + + if ((width + pos_max - 1) > 15) + { + fprintf (stderr, "(width + pos_max - 1) > 15\n"); + + return (-1); + } + + /* who cares about RAM nowadays :-) */ + + const size_t keys_size1 = KEYS_CNT1 * sizeof (uint32_t); + const size_t keys_size2 = KEYS_CNT2 * sizeof (uint32_t); + const size_t keys_size3 = KEYS_CNT3 * sizeof (uint32_t); + + uint32_t *keys_buf1 = (uint32_t *) malloc (keys_size1); + uint32_t *keys_buf2 = (uint32_t *) malloc (keys_size2); + uint32_t *keys_buf3 = (uint32_t *) malloc (keys_size3); + + int pos; + + for (pos = pos_min; pos < pos_max; pos++) + { + memset (keys_buf1, 0, keys_size1); + memset (keys_buf2, 0, keys_size2); + memset (keys_buf3, 0, keys_size3); + + FILE *fd = fopen (dictionary, "rb"); + + if (fd == NULL) + { + fprintf (stderr, "%s: %s", dictionary, strerror (errno)); + + free (keys_buf1); + free (keys_buf2); + free (keys_buf3); + + return (-1); + } + + char line_buf[BUFSIZ]; + + int line_len; + + while ((line_len = fgetl (fd, BUFSIZ, line_buf)) != -1) + { + if (line_len == 0) continue; + + unsigned char c = 0; + + uint32_t key = 0; + + if ((pos + 0) >= line_len) continue; + + c = line_buf[pos + 0]; + + if (c < CHR_MIN) continue; + if (c > CHR_MAX) continue; + + key |= c << 0; + + keys_buf1[key]++; + + if ((pos + 1) >= line_len) continue; + + c = line_buf[pos + 1]; + + if (c < CHR_MIN) continue; + if (c > CHR_MAX) continue; + + key |= c << 8; + + keys_buf2[key]++; + + if ((pos + 2) >= line_len) continue; + + c = line_buf[pos + 2]; + + if (c < CHR_MIN) continue; + if (c > CHR_MAX) continue; + + key |= c << 16; + + keys_buf3[key]++; + } + + fclose (fd); + + const uint32_t sort_cnt1 = count_keys (keys_buf1, KEYS_CNT1); + const uint32_t sort_cnt2 = count_keys (keys_buf2, KEYS_CNT2); + const uint32_t sort_cnt3 = count_keys (keys_buf3, KEYS_CNT3); + + node *sort_buf1 = (node *) calloc (sort_cnt1, sizeof (node)); + node *sort_buf2 = (node *) calloc (sort_cnt2, sizeof (node)); + node *sort_buf3 = (node *) calloc (sort_cnt3, sizeof (node)); + + move_keys (keys_buf1, KEYS_CNT1, sort_buf1); + move_keys (keys_buf2, KEYS_CNT2, sort_buf2); + move_keys (keys_buf3, KEYS_CNT3, sort_buf3); + + qsort (sort_buf1, sort_cnt1, sizeof (node), comp); + qsort (sort_buf2, sort_cnt2, sizeof (node), comp); + qsort (sort_buf3, sort_cnt3, sizeof (node), comp); + + if (width > 0) output_rule (sort_buf1, sort_cnt1, pos, 1, depth); + if (width > 1) output_rule (sort_buf2, sort_cnt2, pos, 2, depth); + if (width > 2) output_rule (sort_buf3, sort_cnt3, pos, 3, depth); + + free (sort_buf1); + free (sort_buf2); + free (sort_buf3); + } + + free (keys_buf1); + free (keys_buf2); + free (keys_buf3); + + return 0; +} diff --git a/src/permute.c b/src/permute.c new file mode 100644 index 0000000..4341064 --- /dev/null +++ b/src/permute.c @@ -0,0 +1,79 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include +#include +#include "utils.c" + +/** + * Name........: permute + * Autor.......: Jens Steube + * License.....: MIT + * Credits.....: This program is using the awesome "Countdown QuickPerm Algorithm" developed by Phillip Paul Fuchs + */ + +size_t next_permutation (char *word, int *p, int k) +{ + p[k]--; + + int j = k % 2 * p[k]; + + char tmp = word[j]; + + word[j] = word[k]; + + word[k] = tmp; + + for (k = 1; p[k] == 0; k++) p[k] = k; + + return k; +} + +int main (int argc, char *argv[]) +{ + if (argc != 1) + { + fprintf (stderr, "usage: %s < infile > outfile\n", argv[0]); + + return (-1); + } + + #ifdef _WINDOWS + _setmode (_fileno (stdin), _O_BINARY); + #endif + + char line_buf[BUFSIZ]; + + int line_len; + + while ((line_len = fgetl (stdin, BUFSIZ, line_buf)) != -1) + { + if (line_len == 0) continue; + + /* init permutation */ + + int p[BUFSIZ]; + + int k; + + for (k = 0; k < line_len + 1; k++) p[k] = k; + + k = 1; + + /* run permutation */ + + puts (line_buf); + + while ((k = next_permutation (line_buf, p, k)) != line_len) puts (line_buf); + + puts (line_buf); + } + + return (0); +} diff --git a/src/permute_exist.c b/src/permute_exist.c new file mode 100644 index 0000000..21f1960 --- /dev/null +++ b/src/permute_exist.c @@ -0,0 +1,124 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include +#include +#include "utils.c" + +/** + * Name........: permute_exist + * Autor.......: Jens Steube + * License.....: MIT + */ + +typedef struct +{ + char chr; + int occ; + +} db_t; + +int scan_word (char *line_buf, int line_len, db_t db_buf[256]) +{ + int db_cnt = 0; + + int i; + + for (i = 0; i < line_len; i++) + { + const char chr = line_buf[i]; + + int j; + + for (j = 0; j < db_cnt; j++) + { + if (db_buf[j].chr == chr) + { + db_buf[j].occ++; + + break; + } + } + + if (j == db_cnt) + { + db_buf[j].chr = chr; + db_buf[j].occ = 0; + + db_cnt++; + } + } + + return db_cnt; +} + +int sort_by_key (const void *p1, const void *p2) +{ + const db_t *db1 = (db_t *) p1; + const db_t *db2 = (db_t *) p2; + + return db1->chr - db2->chr; +} + +int main (int argc, char *argv[]) +{ + if (argc != 2) + { + fprintf (stderr, "usage: %s word < infile > outfile\n", argv[0]); + + return (-1); + } + + char *word_buf = argv[1]; + + #ifdef _WINDOWS + _setmode (_fileno (stdin), _O_BINARY); + #endif + + db_t db1_buf[256]; + + memset (db1_buf, 0, sizeof (db1_buf)); + + int db1_cnt = scan_word (word_buf, strlen (word_buf), db1_buf); + + qsort (db1_buf, db1_cnt, sizeof (db_t), sort_by_key); + + char line_buf[BUFSIZ]; + + int line_len; + + while ((line_len = fgetl (stdin, BUFSIZ, line_buf)) != -1) + { + if (line_len == 0) continue; + + db_t db2_buf[256]; + + memset (db2_buf, 0, sizeof (db2_buf)); + + int db2_cnt = scan_word (line_buf, line_len, db2_buf); + + if (db1_cnt != db2_cnt) continue; + + qsort (db2_buf, db2_cnt, sizeof (db_t), sort_by_key); + + int i; + + for (i = 0; i < db1_cnt; i++) + { + if (db1_buf[i].chr != db2_buf[i].chr) break; + if (db1_buf[i].occ != db2_buf[i].occ) break; + } + + if (i < db1_cnt) continue; + + puts (line_buf); + } + + return (0); +} diff --git a/src/prepare.c b/src/prepare.c new file mode 100644 index 0000000..c10acf4 --- /dev/null +++ b/src/prepare.c @@ -0,0 +1,80 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include +#include +#include "utils.c" + +#define TMPSIZ 0x100 + +/** + * Name........: prepare + * Autor.......: Jens Steube + * License.....: MIT + */ + +int main (int argc, char *argv[]) +{ + if (argc != 1) + { + fprintf (stderr, "usage: %s < infile > outfile\n", argv[0]); + + return (-1); + } + + #ifdef _WINDOWS + _setmode (_fileno (stdin), _O_BINARY); + #endif + + char line_buf[BUFSIZ]; + + int line_len; + + while ((line_len = fgetl (stdin, BUFSIZ, line_buf)) != -1) + { + if (line_len == 0) continue; + + /* build prepare buffer */ + + char tmp_buf[TMPSIZ]; + + memset (tmp_buf, 0, TMPSIZ); + + int p; + + for (p = 0; p < line_len; p++) + { + int chr = (int) line_buf[p]; + + tmp_buf[chr]++; + } + + /* output prepare buffer */ + + int line_pos; + + int tmp_pos; + + for (tmp_pos = 0, line_pos = 0; tmp_pos < TMPSIZ; tmp_pos++) + { + int j; + + for (j = 0; j < tmp_buf[tmp_pos]; j++) + { + line_buf[line_pos] = tmp_pos; + + line_pos++; + } + } + + puts (line_buf); + } + + return 0; +} diff --git a/src/req-exclude.c b/src/req-exclude.c new file mode 100644 index 0000000..3aa7ce1 --- /dev/null +++ b/src/req-exclude.c @@ -0,0 +1,75 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include +#include +#include "utils.c" + +#define LOWER (1 << 0) +#define UPPER (1 << 1) +#define DIGIT (1 << 2) +#define SYMBOL (1 << 3) +#define OTHER (1 << 4) + +/** + * Name........: req-exclude + * Autor.......: Jens Steube + * License.....: MIT + */ + +int main (int argc, char *argv[]) +{ + if (argc != 2) + { + fprintf (stderr, "usage: %s exc_mask < infile > outfile\n", argv[0]); + fprintf (stderr, " exc_mask is the mask of prohibited (at least one character of ANY) types\n"); + fprintf (stderr, " type masks: add together the numbers, i.e. lower + upper = 3\n"); + fprintf (stderr, " LOWER 1\n"); + fprintf (stderr, " UPPER 2\n"); + fprintf (stderr, " DIGIT 4\n"); + fprintf (stderr, " SYMBOL 8 (0x20 to 0x7e NOT IN lower, upper, digit)\n"); + fprintf (stderr, " OTHER (tab, high ASCII, etc.) 16\n"); + + return (-1); + } + + #ifdef _WINDOWS + setmode (0, O_BINARY); + #endif + + int exc_mask = atoi (argv[1]); + + char line_buf[BUFSIZ]; + + int line_len; + + while ((line_len = fgetl (stdin, BUFSIZ, line_buf)) != -1) + { + if (line_len == 0) continue; + + int cur_mask = 0; + + int p; + + for (p = 0; p < line_len; p++) + { + if ((line_buf[p] >= 'a') && (line_buf[p] <= 'z')) cur_mask |= LOWER; + else if ((line_buf[p] >= 'A') && (line_buf[p] <= 'Z')) cur_mask |= UPPER; + else if ((line_buf[p] >= '0') && (line_buf[p] <= '9')) cur_mask |= DIGIT; + else if ((line_buf[p] >= 0x20) && (line_buf[p] <= 0x7e)) cur_mask |= SYMBOL; + else cur_mask |= OTHER; + } + + if (cur_mask & exc_mask) continue; + + puts (line_buf); + } + + return 0; +} diff --git a/src/req-include.c b/src/req-include.c new file mode 100644 index 0000000..b834c34 --- /dev/null +++ b/src/req-include.c @@ -0,0 +1,75 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include +#include +#include "utils.c" + +#define LOWER (1 << 0) +#define UPPER (1 << 1) +#define DIGIT (1 << 2) +#define SYMBOL (1 << 3) +#define OTHER (1 << 4) + +/** + * Name........: req-include + * Autor.......: Jens Steube + * License.....: MIT + */ + +int main (int argc, char *argv[]) +{ + if (argc != 2) + { + fprintf (stderr, "usage: %s inc_mask < infile > outfile\n", argv[0]); + fprintf (stderr, " inc_mask is the mask of required (at least one character of EACH) types\n"); + fprintf (stderr, " type masks: add together the numbers, i.e. lower + upper = 3\n"); + fprintf (stderr, " LOWER 1\n"); + fprintf (stderr, " UPPER 2\n"); + fprintf (stderr, " DIGIT 4\n"); + fprintf (stderr, " SYMBOL 8 (0x20 to 0x7e NOT IN lower, upper, digit)\n"); + fprintf (stderr, " OTHER (tab, high ASCII, etc.) 16\n"); + + return (-1); + } + + #ifdef _WINDOWS + _setmode (_fileno (stdin), _O_BINARY); + #endif + + int req_mask = atoi (argv[1]); + + char line_buf[BUFSIZ]; + + int line_len; + + while ((line_len = fgetl (stdin, BUFSIZ, line_buf)) != -1) + { + if (line_len == 0) continue; + + int cur_mask = 0; + + int p; + + for (p = 0; p < line_len; p++) + { + if ((line_buf[p] >= 'a') && (line_buf[p] <= 'z')) cur_mask |= LOWER; + else if ((line_buf[p] >= 'A') && (line_buf[p] <= 'Z')) cur_mask |= UPPER; + else if ((line_buf[p] >= '0') && (line_buf[p] <= '9')) cur_mask |= DIGIT; + else if ((line_buf[p] >= 0x20) && (line_buf[p] <= 0x7e)) cur_mask |= SYMBOL; + else cur_mask |= OTHER; + } + + if ((cur_mask & req_mask) != req_mask) continue; + + puts (line_buf); + } + + return 0; +} diff --git a/src/rli.c b/src/rli.c new file mode 100644 index 0000000..aac3e71 --- /dev/null +++ b/src/rli.c @@ -0,0 +1,305 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "utils.c" + +#define STEPS 0x1000000 + +/** + * Name........: rli + * Autor.......: Jens Steube + * License.....: MIT + */ + +typedef struct +{ + char *buf; + + uint len; + uint pos; + +} cache_t; + +static int cmp_cache (const cache_t *c1, const cache_t *c2) +{ + return strcmp (c1->buf, c2->buf); +} + +static int cmp_buf (const void *p1, const void *p2) +{ + cache_t *c1 = (cache_t *) p1; + cache_t *c2 = (cache_t *) p2; + + return cmp_cache (c1, c2); +} + +static int cmp_pos (const void *p1, const void *p2) +{ + cache_t *c1 = (cache_t *) p1; + cache_t *c2 = (cache_t *) p2; + + return c1->pos - c2->pos; +} + +int main (int argc, char *argv[]) +{ + /* buffers */ + + FILE *fd; + + uint avail = 0; + uint count = 0; + + cache_t *cache = NULL; + + /* stats */ + + uint removed = 0; + + /* arg */ + + if (argc < 4) + { + fprintf (stderr, "usage: %s infile outfile removefiles...\n", argv[0]); + + return (-1); + } + + char *infile = argv[1]; + char *outfile = argv[2]; + + /* cache */ + + printf ("Caching %s...\n", infile); + + if ((fd = fopen (infile, "rb")) == NULL) + { + fprintf (stderr, "%s: %s\n", infile, strerror (errno)); + + return (-1); + } + + char line_buf[BUFSIZ]; + + int line_len; + + while ((line_len = fgetl (fd, BUFSIZ, line_buf)) != -1) + { + if (count == avail) + { + avail += STEPS; + + cache = (cache_t *) realloc (cache, avail * sizeof (cache_t)); + + if (cache == NULL) + { + fprintf (stderr, "Not enough memory\n"); + + fclose (fd); + + return (-1); + } + + memset (&cache[count], 0, STEPS * sizeof (cache_t)); + } + + char *new_buf = (char *) malloc (line_len + 1); + + if (new_buf == NULL) + { + fprintf (stderr, "Not enough memory\n"); + + fclose (fd); + + return (-1); + } + + memcpy (new_buf, line_buf, line_len); + + new_buf[line_len] = 0; + + cache[count].buf = new_buf; + cache[count].len = line_len; + cache[count].pos = count; + + if ((count > 0) && ((count % 1000000) == 0)) + { + printf ("\rCached %u lines", count); + + fflush (stdout); + } + + count++; + } + + fclose (fd); + + printf ("\rCached %u lines\n", count); + + /* sort */ + + printf ("\nSorting...\n\n"); + + qsort (cache, count, sizeof (cache_t), cmp_buf); + + /* iterate through work */ + + uint i; + + for (i = 3; i < (uint) argc; i++) + { + uint removed_sav = removed; + + char *removefile = argv[i]; + + if (strcmp (removefile, infile) == 0) + { + fprintf (stderr, "Skipping check against infile %s\n\n", removefile); + + continue; + } + + if (strcmp (removefile, outfile) == 0) + { + fprintf (stderr, "Skipping check against outfile %s\n\n", removefile); + + continue; + } + + struct stat l0_stat; + + if (stat (removefile, &l0_stat) == -1) + { + fprintf (stderr, "%s: %s", removefile, strerror (errno)); + + return (-1); + } + + if (!S_ISREG (l0_stat.st_mode)) + { + fprintf (stderr, "Skipping check against unregular file %s\n\n", removefile); + + continue; + } + + printf ("Checking %s against cache\n", removefile); + + if ((fd = fopen (removefile, "rb")) == NULL) + { + fprintf (stderr, "%s: %s\n", removefile, strerror (errno)); + + return (-1); + } + + uint target_count = 0; + + while ((line_len = fgetl (fd, BUFSIZ, line_buf)) != -1) + { + target_count++; + + if ((target_count % 1000000) == 0) + { + printf ("\rLines compared %u", target_count); + + fflush (stdout); + } + + cache_t target; + + target.buf = line_buf; + target.len = line_len; + + cache_t *found = (cache_t *) bsearch (&target, cache, count, sizeof (cache_t), cmp_buf); + + if (found == NULL) continue; + + /* already found before */ + + if (found->len == 0) continue; + + found->len = 0; + + removed++; + + /* check possible duplicates */ + + cache_t *min = &cache[0]; + cache_t *max = &cache[count - 1]; + + cache_t *tmp; + + tmp = found; + + for (tmp--; tmp >= min; tmp--) + { + if (cmp_cache (tmp, &target)) break; + + tmp->len = 0; + + removed++; + } + + tmp = found; + + for (tmp++; tmp <= max; tmp++) + { + if (cmp_cache (tmp, &target)) break; + + tmp->len = 0; + + removed++; + } + } + + fclose (fd); + + printf ("\rLines compared %u\n", target_count); + + printf ("Removed %u lines from cache\n\n", removed - removed_sav); + } + + /* unsort */ + + printf ("Sorting back to original positions...\n\n"); + + qsort (cache, count, sizeof (cache_t), cmp_pos); + + /* save result */ + + printf ("Finished!\n"); + + printf ("Removed %u lines from cache\n", removed); + + printf ("Writing %u lines to %s\n", count - removed, outfile); + + if ((fd = fopen (outfile, "wb")) == NULL) + { + fprintf (stderr, "%s: %s\n", outfile, strerror (errno)); + + return (-1); + } + + for (i = 0; i < count; i++) + { + if (cache[i].len == 0) continue; + + fputs (cache[i].buf, fd); + + fputc ('\n', fd); + } + + fclose (fd); + + return 0; +} diff --git a/src/rli2.c b/src/rli2.c new file mode 100644 index 0000000..39d8b23 --- /dev/null +++ b/src/rli2.c @@ -0,0 +1,108 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "utils.c" + +/** + * Name........: rli2 + * Autor.......: Jens Steube + * License.....: MIT + */ + +static int cmp_cache (const void *p1, const void *p2) +{ + return strcmp (p1, p2); +} + +int main (int argc, char *argv[]) +{ + FILE *fd1; + FILE *fd2; + + if (argc != 3) + { + fprintf (stderr, "usage: %s infile removefile\n", argv[0]); + + return (-1); + } + + char *infile = argv[1]; + char *removefile = argv[2]; + + if ((fd1 = fopen (infile, "rb")) == NULL) + { + fprintf (stderr, "%s: %s\n", infile, strerror (errno)); + + return (-1); + } + + if ((fd2 = fopen (removefile, "rb")) == NULL) + { + fprintf (stderr, "%s: %s\n", removefile, strerror (errno)); + + fclose (fd1); + + return (-1); + } + + char line_buf1[BUFSIZ]; + char line_buf2[BUFSIZ]; + + if (fgetl (fd1, BUFSIZ, line_buf1) == -1) memset (line_buf1, 0, BUFSIZ); + if (fgetl (fd2, BUFSIZ, line_buf2) == -1) memset (line_buf2, 0, BUFSIZ); + + int comp = 1; + + while (!feof (fd1) && !feof (fd2)) + { + comp = cmp_cache (line_buf1, line_buf2); + + if (comp == 0) + { + if (fgetl (fd1, BUFSIZ, line_buf1) == -1) memset (line_buf1, 0, BUFSIZ); + if (fgetl (fd2, BUFSIZ, line_buf2) == -1) memset (line_buf2, 0, BUFSIZ); + } + else if (comp > 0) + { + if (fgetl (fd2, BUFSIZ, line_buf2) == -1) memset (line_buf2, 0, BUFSIZ); + } + else if (comp < 0) + { + puts (line_buf1); + + if (fgetl (fd1, BUFSIZ, line_buf1) == -1) memset (line_buf1, 0, BUFSIZ); + } + } + + if (!feof (fd1) && comp == 0) puts (line_buf1); + + if (comp > 0) puts (line_buf1); + + while (!feof (fd1)) + { + if (fgetl (fd1, BUFSIZ, line_buf1) == -1) + { + memset (line_buf1, 0, BUFSIZ); + + continue; + } + + puts (line_buf1); + } + + fclose (fd1); + fclose (fd2); + + return 0; +} diff --git a/src/seprule.pl b/src/seprule.pl new file mode 100755 index 0000000..9be08c6 --- /dev/null +++ b/src/seprule.pl @@ -0,0 +1,71 @@ +#!/usr/bin/env perl + +## Name........: seprule +## Autor.......: Jens Steube +## License.....: MIT + +use strict; +use warnings; + +## +## configuration +## + +my @rp = ('0'..'9', 'A'..'Z'); + +my $width = 3; +my $rule = "i"; +my $sep = " "; + +## +## code +## + +my $rp_size = scalar @rp; + +my $total = $rp_size ** $width; + +my $db; + +for (my $i = 0; $i < $total; $i++) +{ + my $left = $i; + + my @out; + + for (my $c = 0; $c < $width; $c++) + { + my $m = $left % $rp_size; + my $d = $left / $rp_size; + + push (@out, $m); + + $left = $d; + } + + @out = sort { $a <=> $b } @out; + + my $val = join ("", @out); + + next if (exists $db->{$val}); + + $db->{$val} = undef; + + my @final; + + for (my $c = 0; $c < $width; $c++) + { + my $s = sprintf ("T%s", $rp[$out[$c]]); + + push (@final, $s); + } + + for (my $c = 0; $c < $width; $c++) + { + my $s = sprintf ("%s%s%s", $rule, $rp[$out[$c]], $sep); + + push (@final, $s); + } + + print join (" ", "l", @final), "\n"; +} diff --git a/src/splitlen.c b/src/splitlen.c new file mode 100644 index 0000000..a647304 --- /dev/null +++ b/src/splitlen.c @@ -0,0 +1,73 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include +#include +#include "utils.c" + +#define LEN_MIN 1 +#define LEN_MAX 64 + +/** + * Name........: splitlen + * Autor.......: Jens Steube + * License.....: MIT + */ + +int main (int argc, char *argv[]) +{ + if (argc != 2) + { + fprintf (stderr, "usage: %s outdir < infile\n", argv[0]); + + return (-1); + } + + #ifdef _WINDOWS + _setmode (_fileno (stdin), _O_BINARY); + #endif + + FILE *fps[LEN_MAX + 1]; + + int i; + + for (i = LEN_MIN; i <= LEN_MAX; i++) + { + char name[BUFSIZ]; + + sprintf (name, "%s/%02d", argv[1], i); + + fps[i] = fopen (name, "wb"); + + if (fps[i] == NULL) + { + fprintf (stderr, "%s: %s\n", name, strerror (errno)); + + return (-1); + } + } + + char line_buf[BUFSIZ]; + + int line_len; + + while ((line_len = fgetl (stdin, BUFSIZ, line_buf)) != -1) + { + if (line_len < LEN_MIN) continue; + if (line_len > LEN_MAX) continue; + + fputs (line_buf, fps[line_len]); + + fputc ('\n', fps[line_len]); + } + + for (i = LEN_MIN; i < LEN_MAX; i++) fclose (fps[i]); + + return 0; +} diff --git a/src/strip-bsn.c b/src/strip-bsn.c new file mode 100644 index 0000000..fdbfbd7 --- /dev/null +++ b/src/strip-bsn.c @@ -0,0 +1,63 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include +#include +#include "utils.c" + +/** + * Name........: strip-bsn + * Autor.......: Jens Steube + * License.....: MIT + * Description.: strip all \0 bytes + */ + +int main (int argc, char *argv[]) +{ + if (argc != 1) + { + fprintf (stderr, "usage: %s < infile > outfile\n", argv[0]); + + return (-1); + } + + #ifdef _WINDOWS + _setmode (_fileno (stdin), _O_BINARY); + #endif + + char buf_i[BUFSIZ]; + char buf_o[BUFSIZ]; + + while (!feof (stdin)) + { + size_t len_i = fread (buf_i, 1, sizeof (buf_i), stdin); + + if (len_i <= 0) break; + + char *tmp_i = buf_i; + char *tmp_o = buf_o; + + size_t i; + + for (i = 0; i < len_i; i++) + { + const char c = *tmp_i++; + + if (c == '\0') continue; + + *tmp_o++ = c; + } + + size_t len_o = tmp_o - buf_o; + + fwrite (buf_o, 1, len_o, stdout); + } + + return 0; +} diff --git a/src/strip-bsr.c b/src/strip-bsr.c new file mode 100644 index 0000000..7cd7be6 --- /dev/null +++ b/src/strip-bsr.c @@ -0,0 +1,63 @@ +#define _GNU_SOURCE +#define _FILE_OFFSET_BITS 64 +#define __MSVCRT_VERSION__ 0x0700 + +#include +#include +#include +#include +#include +#include +#include +#include "utils.c" + +/** + * Name........: strip-bsr + * Autor.......: Jens Steube + * License.....: MIT + * Description.: strip all \r bytes + */ + +int main (int argc, char *argv[]) +{ + if (argc != 1) + { + fprintf (stderr, "usage: %s < infile > outfile\n", argv[0]); + + return (-1); + } + + #ifdef _WINDOWS + _setmode (_fileno (stdin), _O_BINARY); + #endif + + char buf_i[BUFSIZ]; + char buf_o[BUFSIZ]; + + while (!feof (stdin)) + { + size_t len_i = fread (buf_i, 1, sizeof (buf_i), stdin); + + if (len_i <= 0) break; + + char *tmp_i = buf_i; + char *tmp_o = buf_o; + + size_t i; + + for (i = 0; i < len_i; i++) + { + const char c = *tmp_i++; + + if (c == '\r') continue; + + *tmp_o++ = c; + } + + size_t len_o = tmp_o - buf_o; + + fwrite (buf_o, 1, len_o, stdout); + } + + return 0; +} diff --git a/src/tmesis.pl b/src/tmesis.pl new file mode 100755 index 0000000..0b9d43e --- /dev/null +++ b/src/tmesis.pl @@ -0,0 +1,59 @@ +#!/usr/bin/env perl + +## Name........: tmesis +## Autor.......: Jens Steube +## License.....: MIT + +use strict; +use warnings; + +#tmesis will take a wordlist and produce insertion rules that would insert each word of the wordlist to preset positions. +#For example: +#Word ‘password’ will create insertion rules that would insert ‘password’ from position 0 to position F (15) and It will mutate the string ‘123456’ as follows. +#password123456 +#1password23456 +#12password3456 +#123password456 +#1234password56 +#12345password6 +#123456password +# +#Hints: +#*Use tmesis to create rules to attack hashlists the came from the source. Run initial analysis on the cracked passwords , collect the top 10 – 20 words appear on the passwords and use tmesis to generate rules. +#*use tmesis generated rules in combination with best64.rules +# +# inspired by T0XlC + +my $min_rule_pos = 0; +my $max_rule_pos = 15; + +my $db; + +my @intpos_to_rulepos = ('0'..'9', 'A'..'Z'); + +my $function = "i"; +#my $function = "o"; + +while (my $word = <>) +{ + chomp $word; + + my $word_len = length $word; + + my @word_buf = split "", $word; + + for (my $rule_pos = $min_rule_pos; $rule_pos < $max_rule_pos - $word_len; $rule_pos++) + { + my @rule; + + for (my $word_pos = 0; $word_pos < $word_len; $word_pos++) + { + my $function_full = $function . $intpos_to_rulepos[$rule_pos + $word_pos] . $word_buf[$word_pos]; + + push @rule, $function_full; + } + + print join (" ", @rule), "\n"; + } +} + diff --git a/src/topmorph.pl b/src/topmorph.pl new file mode 100755 index 0000000..d98b0ef --- /dev/null +++ b/src/topmorph.pl @@ -0,0 +1,71 @@ +#!/usr/bin/env perl + +## Name........: topmorph +## Autor.......: Jens Steube +## License.....: MIT + +use strict; +use warnings; + +my @intpos_to_rulepos = ('0'..'9', 'A'..'Z'); + +my $function = "i"; +#my $function = "o"; + +if (scalar @ARGV != 5) +{ + print "usage: $0 dictionary depth width pos_min pos_max\n"; + + exit -1; +} + +my ($dictionary, $depth, $width, $pos_min, $pos_max) = @ARGV; + +if ($width > 20) +{ + print "width > 20\n"; + + exit -1; +} + +for (my $pos = $pos_min; $pos <= $pos_max; $pos++) +{ + my $db; + + open (IN, $dictionary) or die "$dictionary: $!\n"; + + while (my $line = ) + { + chomp $line; + + my $len = length $line; + + next if (($len - $pos) < $width); + + my $word = substr ($line, $pos, $width); + + next unless defined $word; + + $db->{$word}++; + } + + close (IN); + + my @keys = sort { $db->{$b} <=> $db->{$a} } keys %{$db}; + + for (my $i = 0; $i < $depth; $i++) + { + my @chars = split "", $keys[$i]; + + my @rule; + + for (my $j = 0; $j < $width; $j++) + { + my $function_full = join "", $function, $intpos_to_rulepos[$pos + $j], $chars[$j]; + + push @rule, $function_full; + } + + print join (" ", @rule), "\n"; + } +} diff --git a/src/utils.c b/src/utils.c new file mode 100644 index 0000000..c3794b3 --- /dev/null +++ b/src/utils.c @@ -0,0 +1,59 @@ +typedef unsigned int uint; + +size_t super_chop (char *s, size_t len) +{ + char *p = s + len - 1; + + while (len) + { + if (*p != '\n') break; + + *p-- = 0; + + len--; + } + + while (len) + { + if (*p != '\r') break; + + *p-- = 0; + + len--; + } + + return len; +} + +int fgetl (FILE *stream, size_t sz, char *buf) +{ + if (feof (stream)) return -1; + + char *s = fgets (buf, sz, stream); + + if (s == NULL) return -1; + + size_t len = strlen (s); + + len = super_chop (s, len); + + return len; +} + +#ifndef strdup +char *strdup (const char *s) +{ + char *b = malloc (strlen (s) + 1); + + strcpy (b, s); + + return (b); +} +#endif + +uint get_random_num (const uint min, const uint max) +{ + if (min == max) return (min); + + return ((rand () % (max - min)) + min); +}