fcrackzip/main.c

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <stdio.h>
#include <stdlib.h>
#ifdef HAVE_STDBOOL_H
#include <stdbool.h>
#else
typedef enum { FALSE = 0, TRUE = 1 } bool;
#endif
#ifdef HAVE_GETOPT_H
#include <getopt.h>
#else
#include "getopt.h"
#endif
#ifdef HAVE_GETTIMEOFDAY
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#endif

#include <string.h>

#ifdef USE_UNIX_REDIRECTION
#define DEVNULL ">/dev/null 2>&1"
#else
#define DEVNULL ">NUL 2>&1"
#endif

#include "crack.h"

int use_unzip;

static method *crack_method = methods;
static int method_number = -1;
static int min_length = -1;
static int max_length = -1;
static int residuent = 0;
static int modul = 1;

static FILE *dict_file;

int REGPARAM
check_unzip (const char *pw)
{
  char buff[1024];
  int status;

  sprintf (buff, "unzip -qqtP \"%s\" %s " DEVNULL, pw, file_path[0]);
  status = system (buff);

#undef REDIR

  if (status == EXIT_SUCCESS)
    {
      printf("\n\nPASSWORD FOUND!!!!: pw == %s\n", pw);
      exit (EXIT_SUCCESS);
    }

  return !status;
}

/* misc. callbacks.  */

static int
false_callback (const char *pw, const char *info)
{
  (void) pw;
  (void) info;                        /* suppress warning */
  return 0;
}

static int
true_callback (const char *pw, const char *info)
{
  (void) pw;
  (void) info;                        /* suppress warning */
  return 1;
}

static int
print_callback (const char *pw, const char *info)
{
  if (!use_unzip || check_unzip (pw))
    {
      printf ("possible pw found: %s (%s)\n", pw, info ? info : "");
      /*exit(0); */
    }

  return 0;
}

static int
brute_force_gen (void)
{
  u8 *p = pw_end;

  do
    {
      u8 o = *--p;
      *p = bf_next[o];
      if (o != bf_last)
        return pw_end - p;
    }
  while (p > pw);

  if (pw_end - pw < max_length)
    {
      p = ++pw_end;
      *p = 0;

      while (p > pw)
        *--p = bf_next[255];

      return -1;
    }
  else
    return 0;
}

static int
dictionary_gen (void)
{
  /* should optimize this, comparing prefixes would be a net win.
   * however, not using fgets but something better might be an
   * even higher win :(
   */
  if (fgets (pw, MAX_PW+1, dict_file))
    {
      pw[strlen (pw) - 1] = 0;
      return -1;
    }
  else
    {
      if (!feof (dict_file))
        perror ("dictionary_read_next_password");

      return 0;
    }
}

static int
validate_gen (void)
{
  return 0;
}

static void
validate (void)
{
  u8 header[HEADER_SIZE + 1] =
  {0xf4, 0x28, 0xd6, 0xee, 0xd7, 0xd2,
   0x3c, 0x1a, 0x20, 0xab, 0xdf, 0x73,
   0xd6, 0xba, 0};                /* PW: "Martha" */
  strcpy ((char *) files, (char *) header);        /* yeah, dirty... */
  file_count = 1;

  if (crack_method->desc[0] == 'z')
    {
      crack_method->init_crack_pw ();

      strcpy (pw, "Martha");
      if (crack_method->crack_pw (validate_gen, true_callback))
        printf ("validate ok (%s == Martha)\n", pw);
      else
        printf ("validation error (%s != Martha)\n", pw);
    }
  else
    printf ("validate only works for zip methods, use --method to select one.\n");
}

static void
parse_charset (char *cs)
{
  u8 chars[800];
  u8 map[256];
  u8 *p = chars;

  while (*cs)
    switch (*cs++)
      {
      case 'a':
        strcpy ((char *) p, "abcdefghijklmnopqrstuvwxyz");
        p += 26;
        break;

      case 'A':
        strcpy ((char *) p, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
        p += 26;
        break;

      case '1':
        strcpy ((char *) p, "0123456789");
        p += 10;
        break;

      case '!':
        strcpy ((char *) p, "!:$%&/()=?{[]}+-*~#");
        p += 18;
        break;

      case ':':
        while (*cs)
          *p++ = *cs++;
        break;

      default:
        fprintf (stderr, "unknown charset specifier, only 'aA1!:' recognized\n");
        exit (1);
      }

  *p = 0;

  p = chars;
  bf_last = *p++;
  memset (bf_next, bf_last, sizeof bf_next);
  memset (map, 0, 256);

  for (; *p; p++)
    if (!map[*p])
      {
        map[*p] = 1;
        bf_next[bf_last] = *p;
        bf_last = *p;
      }

  bf_next[bf_last] = chars[0];

/*  { int i; for (i = 0; i < 255; i++) printf ("bf_next [%3d] = %3d\n", i, bf_next[i]);}; */
}

static int benchmark_count;

static int
benchmark_gen (void)
{
  if (!--benchmark_count)
    return 0;

  return brute_force_gen ();
}

static void
benchmark (void)
{
#ifdef HAVE_GETTIMEOFDAY
  int i;
  long j, k;
  struct timeval tv1, tv2;

  do
    {
      for (i = 0; i < HEADER_SIZE * 3; i++)
        files[i] = i ^ (i * 3);

      file_count = 3;
      strcpy (pw, "abcdefghij");
      parse_charset ("a");
      benchmark_count = BENCHMARK_LOOPS;

      verbosity = 0;

      printf ("%c%s: ",
              (crack_method - methods == default_method) ? '*' : ' ',
              crack_method->desc);

      if (strncmp ("zip", crack_method->desc, 3))
        printf ("(skipped)");
      else
        {
          fflush (stdout);

          crack_method->init_crack_pw ();
          gettimeofday (&tv1, 0);
          crack_method->crack_pw (benchmark_gen, false_callback);
          gettimeofday (&tv2, 0);
          tv2.tv_sec -= tv1.tv_sec;
          tv2.tv_usec -= tv1.tv_usec;

          j = tv2.tv_sec * 1000000 + tv2.tv_usec;
          k = BENCHMARK_LOOPS;

          printf ("cracks/s = ");

          for (i = 7; i--;)
            printf ("%ld", k / j), k = (k - k / j * j) * 10;
        }

      printf ("\n");
      crack_method++;
    }
  while (method_number < 0 && crack_method->desc);
#else
  fprintf (stderr, "This executable was compiled without support for benchmarking\n");
  exit (1);
#endif
}

static void
usage (int ec)
{
  printf ("\n"
          PACKAGE " version " VERSION ", a fast/free zip password cracker\n"
          "written by Marc Lehmann <pcg@goof.com> You can find more info on\n"
          "http://www.goof.com/pcg/marc/\n"
          "\n"
          "USAGE: fcrackzip\n"
          "          [-b|--brute-force]            use brute force algorithm\n"
          "          [-D|--dictionary]             use a dictionary\n"
          "          [-B|--benchmark]              execute a small benchmark\n"
          "          [-c|--charset characterset]   use characters from charset\n"
          "          [-h|--help]                   show this message\n"
          "          [--version]                   show the version of this program\n"
          "          [-V|--validate]               sanity-check the algortihm\n"
          "          [-v|--verbose]                be more verbose\n"
          "          [-p|--init-password string]   use string as initial password/file\n"
          "          [-l|--length min-max]         check password with length min to max\n"
          "          [-u|--use-unzip]              use unzip to weed out wrong passwords\n"
          "          [-m|--method num]             use method number \"num\" (see below)\n"
          "          [-2|--modulo r/m]             only calculcate 1/m of the password\n"
          "          file...                    the zipfiles to crack\n"
          "\n"
    );

  printf ("methods compiled in (* = default):\n\n");
  for (crack_method = methods; crack_method->desc; crack_method++)
    printf ("%c%d: %s\n",
            (crack_method - methods == default_method) ? '*' : ' ',
            crack_method - methods,
            crack_method->desc);

  printf ("\n");
  exit (ec);
}

static struct option options[] =
{
  {"version", no_argument, 0, 'R'},
  {"brute-force", no_argument, 0, 'b'},
  {"dictionary", no_argument, 0, 'D'},
  {"benchmark", no_argument, 0, 'B'},
  {"charset", required_argument, 0, 'c'},
  {"help", no_argument, 0, 'h'},
  {"validate", no_argument, 0, 'V'},
  {"verbose", no_argument, 0, 'v'},
  {"init-password", required_argument, 0, 'p'},
  {"length", required_argument, 0, 'l'},
  {"use-unzip", no_argument, 0, 'u'},
  {"method", required_argument, 0, 'm'},
  {"modulo", required_argument, 0, 2},
  {0, 0, 0, 0},
};

int
main (int argc, char *argv[])
{
  int c;
  int option_index = 0;
  char *charset = "aA1!";
  enum { m_benchmark, m_brute_force, m_dictionary } mode = m_brute_force;

  while ((c = getopt_long (argc, argv, "DbBc:hVvp:l:um:2:", options, &option_index)) != -1)
    switch (c)
      {
      case 'b':
        mode = m_brute_force;
        break;

      case 'D':
        mode = m_dictionary;
        break;

      case 'p':
        strcpy (pw, optarg);
        break;

      case 'l':
        pw[0] = 0;
        switch (sscanf (optarg, "%d-%d", &min_length, &max_length))
          {
          default:
            fprintf (stderr, "'%s' is an incorrect length specification\n", optarg);
            exit (1);
          case 1:
            max_length = min_length;
          case 2:
            ;
          }
        break;

      case 2:
        if (sscanf (optarg, "%d/%d", &residuent, &modul) != 2)
          fprintf (stderr, "malformed --modulo option, expected 'residuent/modul'\n"), exit (1);

        if (residuent < 0 || modul <= 0)
          fprintf (stderr, "residuent and modul must be positive\n"), exit (1);

        if (residuent >= modul)
          fprintf (stderr, "residuent must be less than modul\n"), exit (1);

        break;

      case 'B':
        mode = m_benchmark;
        benchmark ();
        exit (0);

      case 'v':
        verbosity++;
        break;

      case 'm':
        {
          for (method_number = 0; methods[method_number].desc; method_number++)
            if (!strncmp (methods[method_number].desc, optarg, strlen (optarg)))
              break;

          if (!methods[method_number].desc)
            method_number = atoi (optarg);

          crack_method = methods + method_number;
        }
        break;

      case 'V':
        validate ();
        exit (0);

      case 'c':
        charset = optarg;
        break;

      case 'u':
        use_unzip = 1;
        break;

      case 'h':
        usage (0);
      case 'R':
        printf (PACKAGE " version " VERSION "\n");
        exit (0);

      case ':':
        fprintf (stderr, "required argument missing\n");
        exit (1);

      case '?':
        fprintf (stderr, "unknown option\n");
        exit (1);

      default:
        usage (1);
      }

  if (method_number < 0)
    {
      method_number = default_method;
      crack_method = methods + default_method;
    }

  if (optind >= argc)
    {
      fprintf (stderr, "you have to specify one or more zip files (try --help)\n");
      exit (1);
    }

  for (; optind < argc; optind++)
    if (file_count < MAX_FILES)
      crack_method->load_file (argv[optind]);
    else if (verbosity)
      printf ("%d file maximum reached, ignoring '%s'\n", MAX_FILES, argv[optind]);

  if (file_count == 0)
    {
      fprintf (stderr, "no usable files found\n");
      exit (1);
    }

  crack_method->init_crack_pw ();

  switch (mode)
    {
    case m_brute_force:
      parse_charset (charset);

      if (!pw[0])
        {
          if (min_length < 0)
            {
              fprintf (stderr, "you have to specify either --init-password or --length with --brute-force\n");
              exit (1);
            }
          else
            {
              u8 *p = pw;
              while (p < pw + min_length)
                *p++ = bf_next[255];

              *p++ = 0;
            }
        }

      if (residuent)
        {
          int xmodul = modul;
          modul = residuent;
          pw_end = pw + strlen (pw);
          brute_force_gen ();
          printf ("%s\n", pw);
          modul = xmodul;
          printf ("WARNING: residuent mode NOT supported YET!\n");
        }

      crack_method->crack_pw (brute_force_gen, print_callback);
      break;

    case m_dictionary:
      if (!pw[0])
        {
          fprintf (stderr, "you have to specify a file to read passwords from using the -p switch\n");
          exit (1);
        }

      if (!(dict_file = fopen (pw, "r")))
        {
          perror (pw);
          exit (1);
        }
      else
        {
          *(pw_end = pw) = 0;
          dictionary_gen (); /* fetch first password */
          crack_method->crack_pw (dictionary_gen, print_callback);

          fclose (dict_file);
        }

      break;

    default:
      fprintf (stderr, "specified mode not supported in this version\n");
      exit (1);
    }

  return 0;
}
Revision:	1.1
Committed:	Mon Aug 4 07:09:51 2008 UTC (15 years, 9 months ago) by root
Content type:	text/plain
Branch:	MAIN
Log Message:	initial check-in, also 1.0 check-in
#	User	Rev	Content
1	root	1.1	#ifdef HAVE_CONFIG_H
2			#include "config.h"
3			#endif
4
5			#include <stdio.h>
6			#include <stdlib.h>
7			#ifdef HAVE_STDBOOL_H
8			#include <stdbool.h>
9			#else
10			typedef enum { FALSE = 0, TRUE = 1 } bool;
11			#endif
12			#ifdef HAVE_GETOPT_H
13			#include <getopt.h>
14			#else
15			#include "getopt.h"
16			#endif
17			#ifdef HAVE_GETTIMEOFDAY
18			#ifdef HAVE_UNISTD_H
19			#include <unistd.h>
20			#endif
21			#ifdef HAVE_SYS_TIME_H
22			#include <sys/time.h>
23			#endif
24			#endif
25
26			#include <string.h>
27
28			#ifdef USE_UNIX_REDIRECTION
29			#define DEVNULL ">/dev/null 2>&1"
30			#else
31			#define DEVNULL ">NUL 2>&1"
32			#endif
33
34			#include "crack.h"
35
36			int use_unzip;
37
38			static method *crack_method = methods;
39			static int method_number = -1;
40			static int min_length = -1;
41			static int max_length = -1;
42			static int residuent = 0;
43			static int modul = 1;
44
45			static FILE *dict_file;
46
47			int REGPARAM
48			check_unzip (const char *pw)
49			{
50			char buff[1024];
51			int status;
52
53			sprintf (buff, "unzip -qqtP \"%s\" %s " DEVNULL, pw, file_path[0]);
54			status = system (buff);
55
56			#undef REDIR
57
58			if (status == EXIT_SUCCESS)
59			{
60			printf("\n\nPASSWORD FOUND!!!!: pw == %s\n", pw);
61			exit (EXIT_SUCCESS);
62			}
63
64			return !status;
65			}
66
67			/* misc. callbacks. */
68
69			static int
70			false_callback (const char pw, const char info)
71			{
72			(void) pw;
73			(void) info; /* suppress warning */
74			return 0;
75			}
76
77			static int
78			true_callback (const char pw, const char info)
79			{
80			(void) pw;
81			(void) info; /* suppress warning */
82			return 1;
83			}
84
85			static int
86			print_callback (const char pw, const char info)
87			{
88			if (!use_unzip \|\| check_unzip (pw))
89			{
90			printf ("possible pw found: %s (%s)\n", pw, info ? info : "");
91			/exit(0); /
92			}
93
94			return 0;
95			}
96
97			static int
98			brute_force_gen (void)
99			{
100			u8 *p = pw_end;
101
102			do
103			{
104			u8 o = *--p;
105			*p = bf_next[o];
106			if (o != bf_last)
107			return pw_end - p;
108			}
109			while (p > pw);
110
111			if (pw_end - pw < max_length)
112			{
113			p = ++pw_end;
114			*p = 0;
115
116			while (p > pw)
117			*--p = bf_next[255];
118
119			return -1;
120			}
121			else
122			return 0;
123			}
124
125			static int
126			dictionary_gen (void)
127			{
128			/* should optimize this, comparing prefixes would be a net win.
129			* however, not using fgets but something better might be an
130			* even higher win :(
131			*/
132			if (fgets (pw, MAX_PW+1, dict_file))
133			{
134			pw[strlen (pw) - 1] = 0;
135			return -1;
136			}
137			else
138			{
139			if (!feof (dict_file))
140			perror ("dictionary_read_next_password");
141
142			return 0;
143			}
144			}
145
146			static int
147			validate_gen (void)
148			{
149			return 0;
150			}
151
152			static void
153			validate (void)
154			{
155			u8 header[HEADER_SIZE + 1] =
156			{0xf4, 0x28, 0xd6, 0xee, 0xd7, 0xd2,
157			0x3c, 0x1a, 0x20, 0xab, 0xdf, 0x73,
158			0xd6, 0xba, 0}; /* PW: "Martha" */
159			strcpy ((char ) files, (char ) header); /* yeah, dirty... */
160			file_count = 1;
161
162			if (crack_method->desc[0] == 'z')
163			{
164			crack_method->init_crack_pw ();
165
166			strcpy (pw, "Martha");
167			if (crack_method->crack_pw (validate_gen, true_callback))
168			printf ("validate ok (%s == Martha)\n", pw);
169			else
170			printf ("validation error (%s != Martha)\n", pw);
171			}
172			else
173			printf ("validate only works for zip methods, use --method to select one.\n");
174			}
175
176			static void
177			parse_charset (char *cs)
178			{
179			u8 chars[800];
180			u8 map[256];
181			u8 *p = chars;
182
183			while (*cs)
184			switch (*cs++)
185			{
186			case 'a':
187			strcpy ((char *) p, "abcdefghijklmnopqrstuvwxyz");
188			p += 26;
189			break;
190
191			case 'A':
192			strcpy ((char *) p, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
193			p += 26;
194			break;
195
196			case '1':
197			strcpy ((char *) p, "0123456789");
198			p += 10;
199			break;
200
201			case '!':
202			strcpy ((char ) p, "!:$%&/()=?{[]}+-~#");
203			p += 18;
204			break;
205
206			case ':':
207			while (*cs)
208			p++ = cs++;
209			break;
210
211			default:
212			fprintf (stderr, "unknown charset specifier, only 'aA1!:' recognized\n");
213			exit (1);
214			}
215
216			*p = 0;
217
218			p = chars;
219			bf_last = *p++;
220			memset (bf_next, bf_last, sizeof bf_next);
221			memset (map, 0, 256);
222
223			for (; *p; p++)
224			if (!map[*p])
225			{
226			map[*p] = 1;
227			bf_next[bf_last] = *p;
228			bf_last = *p;
229			}
230
231			bf_next[bf_last] = chars[0];
232
233			/* { int i; for (i = 0; i < 255; i++) printf ("bf_next [%3d] = %3d\n", i, bf_next[i]);}; */
234			}
235
236			static int benchmark_count;
237
238			static int
239			benchmark_gen (void)
240			{
241			if (!--benchmark_count)
242			return 0;
243
244			return brute_force_gen ();
245			}
246
247			static void
248			benchmark (void)
249			{
250			#ifdef HAVE_GETTIMEOFDAY
251			int i;
252			long j, k;
253			struct timeval tv1, tv2;
254
255			do
256			{
257			for (i = 0; i < HEADER_SIZE * 3; i++)
258			files[i] = i ^ (i * 3);
259
260			file_count = 3;
261			strcpy (pw, "abcdefghij");
262			parse_charset ("a");
263			benchmark_count = BENCHMARK_LOOPS;
264
265			verbosity = 0;
266
267			printf ("%c%s: ",
268			(crack_method - methods == default_method) ? '*' : ' ',
269			crack_method->desc);
270
271			if (strncmp ("zip", crack_method->desc, 3))
272			printf ("(skipped)");
273			else
274			{
275			fflush (stdout);
276
277			crack_method->init_crack_pw ();
278			gettimeofday (&tv1, 0);
279			crack_method->crack_pw (benchmark_gen, false_callback);
280			gettimeofday (&tv2, 0);
281			tv2.tv_sec -= tv1.tv_sec;
282			tv2.tv_usec -= tv1.tv_usec;
283
284			j = tv2.tv_sec * 1000000 + tv2.tv_usec;
285			k = BENCHMARK_LOOPS;
286
287			printf ("cracks/s = ");
288
289			for (i = 7; i--;)
290			printf ("%ld", k / j), k = (k - k / j * j) * 10;
291			}
292
293			printf ("\n");
294			crack_method++;
295			}
296			while (method_number < 0 && crack_method->desc);
297			#else
298			fprintf (stderr, "This executable was compiled without support for benchmarking\n");
299			exit (1);
300			#endif
301			}
302
303			static void
304			usage (int ec)
305			{
306			printf ("\n"
307			PACKAGE " version " VERSION ", a fast/free zip password cracker\n"
308			"written by Marc Lehmann <pcg@goof.com> You can find more info on\n"
309			"http://www.goof.com/pcg/marc/\n"
310			"\n"
311			"USAGE: fcrackzip\n"
312			" [-b\|--brute-force] use brute force algorithm\n"
313			" [-D\|--dictionary] use a dictionary\n"
314			" [-B\|--benchmark] execute a small benchmark\n"
315			" [-c\|--charset characterset] use characters from charset\n"
316			" [-h\|--help] show this message\n"
317			" [--version] show the version of this program\n"
318			" [-V\|--validate] sanity-check the algortihm\n"
319			" [-v\|--verbose] be more verbose\n"
320			" [-p\|--init-password string] use string as initial password/file\n"
321			" [-l\|--length min-max] check password with length min to max\n"
322			" [-u\|--use-unzip] use unzip to weed out wrong passwords\n"
323			" [-m\|--method num] use method number \"num\" (see below)\n"
324			" [-2\|--modulo r/m] only calculcate 1/m of the password\n"
325			" file... the zipfiles to crack\n"
326			"\n"
327			);
328
329			printf ("methods compiled in (* = default):\n\n");
330			for (crack_method = methods; crack_method->desc; crack_method++)
331			printf ("%c%d: %s\n",
332			(crack_method - methods == default_method) ? '*' : ' ',
333			crack_method - methods,
334			crack_method->desc);
335
336			printf ("\n");
337			exit (ec);
338			}
339
340			static struct option options[] =
341			{
342			{"version", no_argument, 0, 'R'},
343			{"brute-force", no_argument, 0, 'b'},
344			{"dictionary", no_argument, 0, 'D'},
345			{"benchmark", no_argument, 0, 'B'},
346			{"charset", required_argument, 0, 'c'},
347			{"help", no_argument, 0, 'h'},
348			{"validate", no_argument, 0, 'V'},
349			{"verbose", no_argument, 0, 'v'},
350			{"init-password", required_argument, 0, 'p'},
351			{"length", required_argument, 0, 'l'},
352			{"use-unzip", no_argument, 0, 'u'},
353			{"method", required_argument, 0, 'm'},
354			{"modulo", required_argument, 0, 2},
355			{0, 0, 0, 0},
356			};
357
358			int
359			main (int argc, char *argv[])
360			{
361			int c;
362			int option_index = 0;
363			char *charset = "aA1!";
364			enum { m_benchmark, m_brute_force, m_dictionary } mode = m_brute_force;
365
366			while ((c = getopt_long (argc, argv, "DbBc:hVvp:l:um:2:", options, &option_index)) != -1)
367			switch (c)
368			{
369			case 'b':
370			mode = m_brute_force;
371			break;
372
373			case 'D':
374			mode = m_dictionary;
375			break;
376
377			case 'p':
378			strcpy (pw, optarg);
379			break;
380
381			case 'l':
382			pw[0] = 0;
383			switch (sscanf (optarg, "%d-%d", &min_length, &max_length))
384			{
385			default:
386			fprintf (stderr, "'%s' is an incorrect length specification\n", optarg);
387			exit (1);
388			case 1:
389			max_length = min_length;
390			case 2:
391			;
392			}
393			break;
394
395			case 2:
396			if (sscanf (optarg, "%d/%d", &residuent, &modul) != 2)
397			fprintf (stderr, "malformed --modulo option, expected 'residuent/modul'\n"), exit (1);
398
399			if (residuent < 0 \|\| modul <= 0)
400			fprintf (stderr, "residuent and modul must be positive\n"), exit (1);
401
402			if (residuent >= modul)
403			fprintf (stderr, "residuent must be less than modul\n"), exit (1);
404
405			break;
406
407			case 'B':
408			mode = m_benchmark;
409			benchmark ();
410			exit (0);
411
412			case 'v':
413			verbosity++;
414			break;
415
416			case 'm':
417			{
418			for (method_number = 0; methods[method_number].desc; method_number++)
419			if (!strncmp (methods[method_number].desc, optarg, strlen (optarg)))
420			break;
421
422			if (!methods[method_number].desc)
423			method_number = atoi (optarg);
424
425			crack_method = methods + method_number;
426			}
427			break;
428
429			case 'V':
430			validate ();
431			exit (0);
432
433			case 'c':
434			charset = optarg;
435			break;
436
437			case 'u':
438			use_unzip = 1;
439			break;
440
441			case 'h':
442			usage (0);
443			case 'R':
444			printf (PACKAGE " version " VERSION "\n");
445			exit (0);
446
447			case ':':
448			fprintf (stderr, "required argument missing\n");
449			exit (1);
450
451			case '?':
452			fprintf (stderr, "unknown option\n");
453			exit (1);
454
455			default:
456			usage (1);
457			}
458
459			if (method_number < 0)
460			{
461			method_number = default_method;
462			crack_method = methods + default_method;
463			}
464
465			if (optind >= argc)
466			{
467			fprintf (stderr, "you have to specify one or more zip files (try --help)\n");
468			exit (1);
469			}
470
471			for (; optind < argc; optind++)
472			if (file_count < MAX_FILES)
473			crack_method->load_file (argv[optind]);
474			else if (verbosity)
475			printf ("%d file maximum reached, ignoring '%s'\n", MAX_FILES, argv[optind]);
476
477			if (file_count == 0)
478			{
479			fprintf (stderr, "no usable files found\n");
480			exit (1);
481			}
482
483			crack_method->init_crack_pw ();
484
485			switch (mode)
486			{
487			case m_brute_force:
488			parse_charset (charset);
489
490			if (!pw[0])
491			{
492			if (min_length < 0)
493			{
494			fprintf (stderr, "you have to specify either --init-password or --length with --brute-force\n");
495			exit (1);
496			}
497			else
498			{
499			u8 *p = pw;
500			while (p < pw + min_length)
501			*p++ = bf_next[255];
502
503			*p++ = 0;
504			}
505			}
506
507			if (residuent)
508			{
509			int xmodul = modul;
510			modul = residuent;
511			pw_end = pw + strlen (pw);
512			brute_force_gen ();
513			printf ("%s\n", pw);
514			modul = xmodul;
515			printf ("WARNING: residuent mode NOT supported YET!\n");
516			}
517
518			crack_method->crack_pw (brute_force_gen, print_callback);
519			break;
520
521			case m_dictionary:
522			if (!pw[0])
523			{
524			fprintf (stderr, "you have to specify a file to read passwords from using the -p switch\n");
525			exit (1);
526			}
527
528			if (!(dict_file = fopen (pw, "r")))
529			{
530			perror (pw);
531			exit (1);
532			}
533			else
534			{
535			*(pw_end = pw) = 0;
536			dictionary_gen (); /* fetch first password */
537			crack_method->crack_pw (dictionary_gen, print_callback);
538
539			fclose (dict_file);
540			}
541
542			break;
543
544			default:
545			fprintf (stderr, "specified mode not supported in this version\n");
546			exit (1);
547			}
548
549			return 0;
550			}