gpg: Fix buglet in the check_all_keysigs function.
[gnupg.git] / tools / gpg-check-pattern.c
1 /* gpg-check-pattern.c - A tool to check passphrases against pattern.
2  * Copyright (C) 2007 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <stddef.h>
25 #include <stdarg.h>
26 #include <string.h>
27 #include <errno.h>
28 #include <assert.h>
29 #ifdef HAVE_LOCALE_H
30 # include <locale.h>
31 #endif
32 #ifdef HAVE_LANGINFO_CODESET
33 # include <langinfo.h>
34 #endif
35 #ifdef HAVE_DOSISH_SYSTEM
36 # include <fcntl.h> /* for setmode() */
37 #endif
38 #include <sys/stat.h>
39 #include <sys/types.h>
40 #include <regex.h>
41 #include <ctype.h>
42
43 #include "util.h"
44 #include "i18n.h"
45 #include "sysutils.h"
46 #include "../common/init.h"
47
48
49 enum cmd_and_opt_values
50 { aNull = 0,
51   oVerbose        = 'v',
52   oArmor          = 'a',
53   oPassphrase     = 'P',
54
55   oProtect        = 'p',
56   oUnprotect      = 'u',
57   oNull           = '0',
58
59   oNoVerbose = 500,
60   oCheck,
61
62   oHomedir
63 };
64
65
66 /* The list of commands and options.  */
67 static ARGPARSE_OPTS opts[] = {
68
69   { 301, NULL, 0, N_("@Options:\n ") },
70
71   { oVerbose, "verbose",   0, "verbose" },
72
73   { oHomedir, "homedir", 2, "@" },
74   { oCheck,   "check", 0,  "run only a syntax check on the patternfile" },
75   { oNull,    "null", 0,   "input is expected to be null delimited" },
76
77   {0}
78 };
79
80
81 /* Global options are accessed through the usual OPT structure. */
82 static struct
83 {
84   int verbose;
85   const char *homedir;
86   int checkonly;
87   int null;
88 } opt;
89
90
91 enum {
92   PAT_NULL,    /* Indicates end of the array.  */
93   PAT_STRING,  /* The pattern is a simple string.  */
94   PAT_REGEX    /* The pattern is an extended regualr expression. */
95 };
96
97
98 /* An object to decibe an item of our pattern table. */
99 struct pattern_s
100 {
101   int type;
102   unsigned int lineno;     /* Line number of the pattern file.  */
103   union {
104     struct {
105       const char *string;  /* Pointer to the actual string (nul termnated).  */
106       size_t length;       /* The length of this string (strlen).  */
107     } s; /*PAT_STRING*/
108     struct {
109       /* We allocate the regex_t because this type is larger than what
110          we need for PAT_STRING and we expect only a few regex in a
111          patternfile.  It would be a waste of core to have so many
112          unused stuff in the table.  */
113       regex_t *regex;
114     } r; /*PAT_REGEX*/
115   } u;
116 };
117 typedef struct pattern_s pattern_t;
118
119
120
121 /*** Local prototypes ***/
122 static char *read_file (const char *fname, size_t *r_length);
123 static pattern_t *parse_pattern_file (char *data, size_t datalen);
124 static void process (FILE *fp, pattern_t *patarray);
125
126
127
128 \f
129 /* Info function for usage().  */
130 static const char *
131 my_strusage (int level)
132 {
133   const char *p;
134   switch (level)
135     {
136     case 11: p = "gpg-check-pattern (@GnuPG@)";
137       break;
138     case 13: p = VERSION; break;
139     case 17: p = PRINTABLE_OS_NAME; break;
140     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
141
142     case 1:
143     case 40:
144       p =  _("Usage: gpg-check-pattern [options] patternfile (-h for help)\n");
145       break;
146     case 41:
147       p =  _("Syntax: gpg-check-pattern [options] patternfile\n"
148              "Check a passphrase given on stdin against the patternfile\n");
149     break;
150
151     default: p = NULL;
152     }
153   return p;
154 }
155
156
157 int
158 main (int argc, char **argv )
159 {
160   ARGPARSE_ARGS pargs;
161   char *raw_pattern;
162   size_t raw_pattern_length;
163   pattern_t *patternarray;
164
165   early_system_init ();
166   set_strusage (my_strusage);
167   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
168   log_set_prefix ("gpg-check-pattern", 1);
169
170   /* Make sure that our subsystems are ready.  */
171   i18n_init ();
172   init_common_subsystems (&argc, &argv);
173
174   /* We need Libgcrypt for hashing.  */
175   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
176     {
177       log_fatal ( _("%s is too old (need %s, have %s)\n"), "libgcrypt",
178                   NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
179     }
180
181   setup_libgcrypt_logging ();
182   gcry_control (GCRYCTL_INIT_SECMEM, 4096, 0);
183
184   opt.homedir = default_homedir ();
185
186   pargs.argc = &argc;
187   pargs.argv = &argv;
188   pargs.flags=  1;  /* (do not remove the args) */
189   while (arg_parse (&pargs, opts) )
190     {
191       switch (pargs.r_opt)
192         {
193         case oVerbose: opt.verbose++; break;
194         case oHomedir: opt.homedir = pargs.r.ret_str; break;
195         case oCheck: opt.checkonly = 1; break;
196         case oNull: opt.null = 1; break;
197
198         default : pargs.err = 2; break;
199         }
200     }
201   if (log_get_errorcount(0))
202     exit (2);
203
204   if (argc != 1)
205     usage (1);
206
207   /* We read the entire pattern file into our memory and parse it
208      using a separate function.  This allows us to eventual do the
209      reading while running setuid so that the pattern file can be
210      hidden from regular users.  I am not sure whether this makes
211      sense, but lets be prepared for it.  */
212   raw_pattern = read_file (*argv, &raw_pattern_length);
213   if (!raw_pattern)
214     exit (2);
215
216   patternarray = parse_pattern_file (raw_pattern, raw_pattern_length);
217   if (!patternarray)
218     exit (1);
219   if (opt.checkonly)
220     return 0;
221
222 #ifdef HAVE_DOSISH_SYSTEM
223   setmode (fileno (stdin) , O_BINARY );
224 #endif
225   process (stdin, patternarray);
226
227   return log_get_errorcount(0)? 1 : 0;
228 }
229
230
231
232 /* Read a file FNAME into a buffer and return that malloced buffer.
233    Caller must free the buffer.  On error NULL is returned, on success
234    the valid length of the buffer is stored at R_LENGTH.  The returned
235    buffer is guarnteed to be nul terminated.  */
236 static char *
237 read_file (const char *fname, size_t *r_length)
238 {
239   FILE *fp;
240   char *buf;
241   size_t buflen;
242
243   if (!strcmp (fname, "-"))
244     {
245       size_t nread, bufsize = 0;
246
247       fp = stdin;
248 #ifdef HAVE_DOSISH_SYSTEM
249       setmode ( fileno(fp) , O_BINARY );
250 #endif
251       buf = NULL;
252       buflen = 0;
253 #define NCHUNK 8192
254       do
255         {
256           bufsize += NCHUNK;
257           if (!buf)
258             buf = xmalloc (bufsize+1);
259           else
260             buf = xrealloc (buf, bufsize+1);
261
262           nread = fread (buf+buflen, 1, NCHUNK, fp);
263           if (nread < NCHUNK && ferror (fp))
264             {
265               log_error ("error reading '[stdin]': %s\n", strerror (errno));
266               xfree (buf);
267               return NULL;
268             }
269           buflen += nread;
270         }
271       while (nread == NCHUNK);
272 #undef NCHUNK
273
274     }
275   else
276     {
277       struct stat st;
278
279       fp = fopen (fname, "rb");
280       if (!fp)
281         {
282           log_error ("can't open '%s': %s\n", fname, strerror (errno));
283           return NULL;
284         }
285
286       if (fstat (fileno(fp), &st))
287         {
288           log_error ("can't stat '%s': %s\n", fname, strerror (errno));
289           fclose (fp);
290           return NULL;
291         }
292
293       buflen = st.st_size;
294       buf = xmalloc (buflen+1);
295       if (fread (buf, buflen, 1, fp) != 1)
296         {
297           log_error ("error reading '%s': %s\n", fname, strerror (errno));
298           fclose (fp);
299           xfree (buf);
300           return NULL;
301         }
302       fclose (fp);
303     }
304   buf[buflen] = 0;
305   *r_length = buflen;
306   return buf;
307 }
308
309
310
311 static char *
312 get_regerror (int errcode, regex_t *compiled)
313 {
314   size_t length = regerror (errcode, compiled, NULL, 0);
315   char *buffer = xmalloc (length);
316   regerror (errcode, compiled, buffer, length);
317   return buffer;
318 }
319
320 /* Parse the pattern given in the memory aread DATA/DATALEN and return
321    a new pattern array.  The end of the array is indicated by a NULL
322    entry.  On error an error message is printed and the function
323    returns NULL.  Note that the function modifies DATA and assumes
324    that data is nul terminated (even if this is one byte past
325    DATALEN).  */
326 static pattern_t *
327 parse_pattern_file (char *data, size_t datalen)
328 {
329   char *p, *p2;
330   size_t n;
331   pattern_t *array;
332   size_t arraysize, arrayidx;
333   unsigned int lineno = 0;
334
335   /* Estimate the number of entries by counting the non-comment lines.  */
336   arraysize = 0;
337   p = data;
338   for (n = datalen; n && (p2 = memchr (p, '\n', n)); p2++, n -= p2 - p, p = p2)
339     if (*p != '#')
340       arraysize++;
341   arraysize += 2; /* For the terminating NULL and a last line w/o a LF.  */
342
343   array = xcalloc (arraysize, sizeof *array);
344   arrayidx = 0;
345
346   /* Loop over all lines.  */
347   while (datalen && data)
348     {
349       lineno++;
350       p = data;
351       p2 = data = memchr (p, '\n', datalen);
352       if (p2)
353         {
354           *data++ = 0;
355           datalen -= data - p;
356         }
357       else
358         p2 = p + datalen;
359       assert (!*p2);
360       p2--;
361       while (isascii (*p) && isspace (*p))
362         p++;
363       if (*p == '#')
364         continue;
365       while (p2 > p && isascii (*p2) && isspace (*p2))
366         *p2-- = 0;
367       if (!*p)
368         continue;
369       assert (arrayidx < arraysize);
370       array[arrayidx].lineno = lineno;
371       if (*p == '/')
372         {
373           int rerr;
374
375           p++;
376           array[arrayidx].type = PAT_REGEX;
377           if (*p && p[strlen(p)-1] == '/')
378             p[strlen(p)-1] = 0;  /* Remove optional delimiter.  */
379           array[arrayidx].u.r.regex = xcalloc (1, sizeof (regex_t));
380           rerr = regcomp (array[arrayidx].u.r.regex, p,
381                           REG_ICASE|REG_NOSUB|REG_EXTENDED);
382           if (rerr)
383             {
384               char *rerrbuf = get_regerror (rerr, array[arrayidx].u.r.regex);
385               log_error ("invalid r.e. at line %u: %s\n", lineno, rerrbuf);
386               xfree (rerrbuf);
387               if (!opt.checkonly)
388                 exit (1);
389             }
390         }
391       else
392         {
393           array[arrayidx].type = PAT_STRING;
394           array[arrayidx].u.s.string = p;
395           array[arrayidx].u.s.length = strlen (p);
396         }
397       arrayidx++;
398     }
399   assert (arrayidx < arraysize);
400   array[arrayidx].type = PAT_NULL;
401
402   return array;
403 }
404
405
406 /* Check whether string macthes any of the pattern in PATARRAY and
407    returns the matching pattern item or NULL.  */
408 static pattern_t *
409 match_p (const char *string, pattern_t *patarray)
410 {
411   pattern_t *pat;
412
413   if (!*string)
414     {
415       if (opt.verbose)
416         log_info ("zero length input line - ignored\n");
417       return NULL;
418     }
419
420   for (pat = patarray; pat->type != PAT_NULL; pat++)
421     {
422       if (pat->type == PAT_STRING)
423         {
424           if (!strcasecmp (pat->u.s.string, string))
425             return pat;
426         }
427       else if (pat->type == PAT_REGEX)
428         {
429           int rerr;
430
431           rerr = regexec (pat->u.r.regex, string, 0, NULL, 0);
432           if (!rerr)
433             return pat;
434           else if (rerr != REG_NOMATCH)
435             {
436               char *rerrbuf = get_regerror (rerr, pat->u.r.regex);
437               log_error ("matching r.e. failed: %s\n", rerrbuf);
438               xfree (rerrbuf);
439               return pat;  /* Better indicate a match on error.  */
440             }
441         }
442       else
443         BUG ();
444     }
445   return NULL;
446 }
447
448
449 /* Actual processing of the input.  This function does not return an
450    error code but exits as soon as a match has been found.  */
451 static void
452 process (FILE *fp, pattern_t *patarray)
453 {
454   char buffer[2048];
455   size_t idx;
456   int c;
457   unsigned long lineno = 0;
458   pattern_t *pat;
459
460   idx = 0;
461   c = 0;
462   while (idx < sizeof buffer -1 && c != EOF )
463     {
464       if ((c = getc (fp)) != EOF)
465         buffer[idx] = c;
466       if ((c == '\n' && !opt.null) || (!c && opt.null) || c == EOF)
467         {
468           lineno++;
469           if (!opt.null)
470             {
471               while (idx && isascii (buffer[idx-1]) && isspace (buffer[idx-1]))
472                 idx--;
473             }
474           buffer[idx] = 0;
475           pat = match_p (buffer, patarray);
476           if (pat)
477             {
478               if (opt.verbose)
479                 log_error ("input line %lu matches pattern at line %u"
480                            " - rejected\n",
481                            lineno, pat->lineno);
482               exit (1);
483             }
484           idx = 0;
485         }
486       else
487         idx++;
488     }
489   if (c != EOF)
490     {
491       log_error ("input line %lu too long - rejected\n", lineno+1);
492       exit (1);
493     }
494   if (ferror (fp))
495     {
496       log_error ("input read error at line %lu: %s - rejected\n",
497                  lineno+1, strerror (errno));
498       exit (1);
499     }
500   if (opt.verbose)
501     log_info ("no input line matches the pattern - accepted\n");
502 }
503