g10: Unattended key generation "Key-Grip" and "Subkey-Grip".
[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 <https://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 "../common/util.h"
44 #include "../common/i18n.h"
45 #include "../common/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   ARGPARSE_end ()
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", GPGRT_LOG_WITH_PREFIX);
169
170   /* Make sure that our subsystems are ready.  */
171   i18n_init ();
172   init_common_subsystems (&argc, &argv);
173
174   setup_libgcrypt_logging ();
175   gcry_control (GCRYCTL_INIT_SECMEM, 4096, 0);
176
177   pargs.argc = &argc;
178   pargs.argv = &argv;
179   pargs.flags=  1;  /* (do not remove the args) */
180   while (arg_parse (&pargs, opts) )
181     {
182       switch (pargs.r_opt)
183         {
184         case oVerbose: opt.verbose++; break;
185         case oHomedir: gnupg_set_homedir (pargs.r.ret_str); break;
186         case oCheck: opt.checkonly = 1; break;
187         case oNull: opt.null = 1; break;
188
189         default : pargs.err = 2; break;
190         }
191     }
192   if (log_get_errorcount(0))
193     exit (2);
194
195   if (argc != 1)
196     usage (1);
197
198   /* We read the entire pattern file into our memory and parse it
199      using a separate function.  This allows us to eventual do the
200      reading while running setuid so that the pattern file can be
201      hidden from regular users.  I am not sure whether this makes
202      sense, but lets be prepared for it.  */
203   raw_pattern = read_file (*argv, &raw_pattern_length);
204   if (!raw_pattern)
205     exit (2);
206
207   patternarray = parse_pattern_file (raw_pattern, raw_pattern_length);
208   if (!patternarray)
209     exit (1);
210   if (opt.checkonly)
211     return 0;
212
213 #ifdef HAVE_DOSISH_SYSTEM
214   setmode (fileno (stdin) , O_BINARY );
215 #endif
216   process (stdin, patternarray);
217
218   return log_get_errorcount(0)? 1 : 0;
219 }
220
221
222
223 /* Read a file FNAME into a buffer and return that malloced buffer.
224    Caller must free the buffer.  On error NULL is returned, on success
225    the valid length of the buffer is stored at R_LENGTH.  The returned
226    buffer is guarnteed to be nul terminated.  */
227 static char *
228 read_file (const char *fname, size_t *r_length)
229 {
230   FILE *fp;
231   char *buf;
232   size_t buflen;
233
234   if (!strcmp (fname, "-"))
235     {
236       size_t nread, bufsize = 0;
237
238       fp = stdin;
239 #ifdef HAVE_DOSISH_SYSTEM
240       setmode ( fileno(fp) , O_BINARY );
241 #endif
242       buf = NULL;
243       buflen = 0;
244 #define NCHUNK 8192
245       do
246         {
247           bufsize += NCHUNK;
248           if (!buf)
249             buf = xmalloc (bufsize+1);
250           else
251             buf = xrealloc (buf, bufsize+1);
252
253           nread = fread (buf+buflen, 1, NCHUNK, fp);
254           if (nread < NCHUNK && ferror (fp))
255             {
256               log_error ("error reading '[stdin]': %s\n", strerror (errno));
257               xfree (buf);
258               return NULL;
259             }
260           buflen += nread;
261         }
262       while (nread == NCHUNK);
263 #undef NCHUNK
264
265     }
266   else
267     {
268       struct stat st;
269
270       fp = fopen (fname, "rb");
271       if (!fp)
272         {
273           log_error ("can't open '%s': %s\n", fname, strerror (errno));
274           return NULL;
275         }
276
277       if (fstat (fileno(fp), &st))
278         {
279           log_error ("can't stat '%s': %s\n", fname, strerror (errno));
280           fclose (fp);
281           return NULL;
282         }
283
284       buflen = st.st_size;
285       buf = xmalloc (buflen+1);
286       if (fread (buf, buflen, 1, fp) != 1)
287         {
288           log_error ("error reading '%s': %s\n", fname, strerror (errno));
289           fclose (fp);
290           xfree (buf);
291           return NULL;
292         }
293       fclose (fp);
294     }
295   buf[buflen] = 0;
296   *r_length = buflen;
297   return buf;
298 }
299
300
301
302 static char *
303 get_regerror (int errcode, regex_t *compiled)
304 {
305   size_t length = regerror (errcode, compiled, NULL, 0);
306   char *buffer = xmalloc (length);
307   regerror (errcode, compiled, buffer, length);
308   return buffer;
309 }
310
311 /* Parse the pattern given in the memory aread DATA/DATALEN and return
312    a new pattern array.  The end of the array is indicated by a NULL
313    entry.  On error an error message is printed and the function
314    returns NULL.  Note that the function modifies DATA and assumes
315    that data is nul terminated (even if this is one byte past
316    DATALEN).  */
317 static pattern_t *
318 parse_pattern_file (char *data, size_t datalen)
319 {
320   char *p, *p2;
321   size_t n;
322   pattern_t *array;
323   size_t arraysize, arrayidx;
324   unsigned int lineno = 0;
325
326   /* Estimate the number of entries by counting the non-comment lines.  */
327   arraysize = 0;
328   p = data;
329   for (n = datalen; n && (p2 = memchr (p, '\n', n)); p2++, n -= p2 - p, p = p2)
330     if (*p != '#')
331       arraysize++;
332   arraysize += 2; /* For the terminating NULL and a last line w/o a LF.  */
333
334   array = xcalloc (arraysize, sizeof *array);
335   arrayidx = 0;
336
337   /* Loop over all lines.  */
338   while (datalen && data)
339     {
340       lineno++;
341       p = data;
342       p2 = data = memchr (p, '\n', datalen);
343       if (p2)
344         {
345           *data++ = 0;
346           datalen -= data - p;
347         }
348       else
349         p2 = p + datalen;
350       assert (!*p2);
351       p2--;
352       while (isascii (*p) && isspace (*p))
353         p++;
354       if (*p == '#')
355         continue;
356       while (p2 > p && isascii (*p2) && isspace (*p2))
357         *p2-- = 0;
358       if (!*p)
359         continue;
360       assert (arrayidx < arraysize);
361       array[arrayidx].lineno = lineno;
362       if (*p == '/')
363         {
364           int rerr;
365
366           p++;
367           array[arrayidx].type = PAT_REGEX;
368           if (*p && p[strlen(p)-1] == '/')
369             p[strlen(p)-1] = 0;  /* Remove optional delimiter.  */
370           array[arrayidx].u.r.regex = xcalloc (1, sizeof (regex_t));
371           rerr = regcomp (array[arrayidx].u.r.regex, p,
372                           REG_ICASE|REG_NOSUB|REG_EXTENDED);
373           if (rerr)
374             {
375               char *rerrbuf = get_regerror (rerr, array[arrayidx].u.r.regex);
376               log_error ("invalid r.e. at line %u: %s\n", lineno, rerrbuf);
377               xfree (rerrbuf);
378               if (!opt.checkonly)
379                 exit (1);
380             }
381         }
382       else
383         {
384           array[arrayidx].type = PAT_STRING;
385           array[arrayidx].u.s.string = p;
386           array[arrayidx].u.s.length = strlen (p);
387         }
388       arrayidx++;
389     }
390   assert (arrayidx < arraysize);
391   array[arrayidx].type = PAT_NULL;
392
393   return array;
394 }
395
396
397 /* Check whether string macthes any of the pattern in PATARRAY and
398    returns the matching pattern item or NULL.  */
399 static pattern_t *
400 match_p (const char *string, pattern_t *patarray)
401 {
402   pattern_t *pat;
403
404   if (!*string)
405     {
406       if (opt.verbose)
407         log_info ("zero length input line - ignored\n");
408       return NULL;
409     }
410
411   for (pat = patarray; pat->type != PAT_NULL; pat++)
412     {
413       if (pat->type == PAT_STRING)
414         {
415           if (!strcasecmp (pat->u.s.string, string))
416             return pat;
417         }
418       else if (pat->type == PAT_REGEX)
419         {
420           int rerr;
421
422           rerr = regexec (pat->u.r.regex, string, 0, NULL, 0);
423           if (!rerr)
424             return pat;
425           else if (rerr != REG_NOMATCH)
426             {
427               char *rerrbuf = get_regerror (rerr, pat->u.r.regex);
428               log_error ("matching r.e. failed: %s\n", rerrbuf);
429               xfree (rerrbuf);
430               return pat;  /* Better indicate a match on error.  */
431             }
432         }
433       else
434         BUG ();
435     }
436   return NULL;
437 }
438
439
440 /* Actual processing of the input.  This function does not return an
441    error code but exits as soon as a match has been found.  */
442 static void
443 process (FILE *fp, pattern_t *patarray)
444 {
445   char buffer[2048];
446   size_t idx;
447   int c;
448   unsigned long lineno = 0;
449   pattern_t *pat;
450
451   idx = 0;
452   c = 0;
453   while (idx < sizeof buffer -1 && c != EOF )
454     {
455       if ((c = getc (fp)) != EOF)
456         buffer[idx] = c;
457       if ((c == '\n' && !opt.null) || (!c && opt.null) || c == EOF)
458         {
459           lineno++;
460           if (!opt.null)
461             {
462               while (idx && isascii (buffer[idx-1]) && isspace (buffer[idx-1]))
463                 idx--;
464             }
465           buffer[idx] = 0;
466           pat = match_p (buffer, patarray);
467           if (pat)
468             {
469               if (opt.verbose)
470                 log_error ("input line %lu matches pattern at line %u"
471                            " - rejected\n",
472                            lineno, pat->lineno);
473               exit (1);
474             }
475           idx = 0;
476         }
477       else
478         idx++;
479     }
480   if (c != EOF)
481     {
482       log_error ("input line %lu too long - rejected\n", lineno+1);
483       exit (1);
484     }
485   if (ferror (fp))
486     {
487       log_error ("input read error at line %lu: %s - rejected\n",
488                  lineno+1, strerror (errno));
489       exit (1);
490     }
491   if (opt.verbose)
492     log_info ("no input line matches the pattern - accepted\n");
493 }
494