1 /* mcookie.c -- Generates random numbers for xauth
2 * Created: Fri Feb 3 10:42:48 1995 by faith@cs.unc.edu
3 * Revised: Fri Mar 19 07:48:01 1999 by faith@acm.org
4 * Public Domain 1995, 1999 Rickard E. Faith (faith@acm.org)
5 * This program comes with ABSOLUTELY NO WARRANTY.
6 *
7 * This program gathers some random bits of data and used the MD5
8 * message-digest algorithm to generate a 128-bit hexadecimal number for
9 * use with xauth(1).
10 *
11 * NOTE: Unless /dev/random is available, this program does not actually
12 * gather 128 bits of random information, so the magic cookie generated
13 * will be considerably easier to guess than one might expect.
14 *
15 * 1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL>
16 * - added Native Language Support
17 * 1999-03-21 aeb: Added some fragments of code from Colin Plumb.
18 *
19 */
20
21 #include "c.h"
22 #include "md5.h"
23 #include "nls.h"
24 #include "closestream.h"
25 #include "randutils.h"
26 #include "strutils.h"
27 #include "xalloc.h"
28 #include "all-io.h"
29
30 #include <fcntl.h>
31 #include <getopt.h>
32 #include <stddef.h>
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <sys/time.h>
36 #include <unistd.h>
37
38 enum {
39 BUFFERSIZE = 4096,
40 RAND_BYTES = 128
41 };
42
43 struct mcookie_control {
44 struct UL_MD5Context ctx;
45 char **files;
46 size_t nfiles;
47 uint64_t maxsz;
48
49 unsigned int verbose:1;
50 };
51
52 /* The basic function to hash a file */
53 static uint64_t hash_file(struct mcookie_control *ctl, int fd)
54 {
55 unsigned char buf[BUFFERSIZE];
56 uint64_t wanted, count;
57
58 wanted = ctl->maxsz ? ctl->maxsz : sizeof(buf);
59
60 for (count = 0; count < wanted; ) {
61 size_t rdsz = sizeof(buf);
62 ssize_t r;
63
64 if (wanted - count < rdsz)
65 rdsz = wanted - count;
66
67 r = read_all(fd, (char *) buf, rdsz);
68 if (r <= 0)
69 break;
70 ul_MD5Update(&ctl->ctx, buf, r);
71 count += r;
72 }
73 /* Separate files with a null byte */
74 buf[0] = '\0';
75 ul_MD5Update(&ctl->ctx, buf, 1);
76 return count;
77 }
78
79 static void __attribute__((__noreturn__)) usage(void)
80 {
81 FILE *out = stdout;
82 fputs(USAGE_HEADER, out);
83 fprintf(out, _(" %s [options]\n"), program_invocation_short_name);
84
85 fputs(USAGE_SEPARATOR, out);
86 fputs(_("Generate magic cookies for xauth.\n"), out);
87
88 fputs(USAGE_OPTIONS, out);
89 fputs(_(" -f, --file <file> use file as a cookie seed\n"), out);
90 fputs(_(" -m, --max-size <num> limit how much is read from seed files\n"), out);
91 fputs(_(" -v, --verbose explain what is being done\n"), out);
92
93 fputs(USAGE_SEPARATOR, out);
94 printf(USAGE_HELP_OPTIONS(23));
95
96 fputs(USAGE_ARGUMENTS, out);
97 printf(USAGE_ARG_SIZE(_("<num>")));
98
99 printf(USAGE_MAN_TAIL("mcookie(1)"));
100
101 exit(EXIT_SUCCESS);
102 }
103
104 static void randomness_from_files(struct mcookie_control *ctl)
105 {
106 size_t i;
107
108 for (i = 0; i < ctl->nfiles; i++) {
109 const char *fname = ctl->files[i];
110 size_t count;
111 int fd;
112
113 if (*fname == '-' && !*(fname + 1))
114 fd = STDIN_FILENO;
115 else
116 fd = open(fname, O_RDONLY);
117
118 if (fd < 0) {
119 warn(_("cannot open %s"), fname);
120 } else {
121 count = hash_file(ctl, fd);
122 if (ctl->verbose)
123 fprintf(stderr,
124 P_("Got %zu byte from %s\n",
125 "Got %zu bytes from %s\n", count),
126 count, fname);
127
128 if (fd != STDIN_FILENO && close(fd))
129 err(EXIT_FAILURE, _("closing %s failed"), fname);
130 }
131 }
132 }
133
134 int main(int argc, char **argv)
135 {
136 struct mcookie_control ctl = { .verbose = 0 };
137 size_t i;
138 unsigned char digest[UL_MD5LENGTH];
139 unsigned char buf[RAND_BYTES];
140 int c;
141
142 static const struct option longopts[] = {
143 {"file", required_argument, NULL, 'f'},
144 {"max-size", required_argument, NULL, 'm'},
145 {"verbose", no_argument, NULL, 'v'},
146 {"version", no_argument, NULL, 'V'},
147 {"help", no_argument, NULL, 'h'},
148 {NULL, 0, NULL, 0}
149 };
150
151 setlocale(LC_ALL, "");
152 bindtextdomain(PACKAGE, LOCALEDIR);
153 textdomain(PACKAGE);
154 close_stdout_atexit();
155
156 while ((c = getopt_long(argc, argv, "f:m:vVh", longopts, NULL)) != -1) {
157 switch (c) {
158 case 'v':
159 ctl.verbose = 1;
160 break;
161 case 'f':
162 if (!ctl.files)
163 ctl.files = xmalloc(sizeof(char *) * argc);
164 ctl.files[ctl.nfiles++] = optarg;
165 break;
166 case 'm':
167 ctl.maxsz = strtosize_or_err(optarg,
168 _("failed to parse length"));
169 break;
170
171 case 'V':
172 print_version(EXIT_SUCCESS);
173 case 'h':
174 usage();
175 default:
176 errtryhelp(EXIT_FAILURE);
177 }
178 }
179
180 if (ctl.maxsz && ctl.nfiles == 0)
181 warnx(_("--max-size ignored when used without --file"));
182
183 ul_MD5Init(&ctl.ctx);
184 randomness_from_files(&ctl);
185 free(ctl.files);
186
187 ul_random_get_bytes(&buf, RAND_BYTES);
188 ul_MD5Update(&ctl.ctx, buf, RAND_BYTES);
189 if (ctl.verbose)
190 fprintf(stderr, P_("Got %d byte from %s\n",
191 "Got %d bytes from %s\n", RAND_BYTES),
192 RAND_BYTES, random_tell_source());
193
194 ul_MD5Final(digest, &ctl.ctx);
195 for (i = 0; i < UL_MD5LENGTH; i++)
196 printf("%02x", digest[i]);
197 putchar('\n');
198
199 return EXIT_SUCCESS;
200 }