[thirdparty/util-linux.git] / misc-utils / mcookie.c

/*
 * No copyright is claimed.  This code is in the public domain; do with
 * it what you wish.
 *
 * mcookie.c -- Generates random numbers for xauth
 * Created: Fri Feb  3 10:42:48 1995 by faith@cs.unc.edu
 * Revised: Fri Mar 19 07:48:01 1999 by faith@acm.org
 * Public Domain 1995, 1999 Rickard E. Faith (faith@acm.org)
 * This program comes with ABSOLUTELY NO WARRANTY.
 *
 * This program gathers some random bits of data and used the MD5
 * message-digest algorithm to generate a 128-bit hexadecimal number for
 * use with xauth(1).
 *
 * NOTE: Unless /dev/random is available, this program does not actually
 * gather 128 bits of random information, so the magic cookie generated
 * will be considerably easier to guess than one might expect.
 *
 * 1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL>
 * - added Native Language Support
 * 1999-03-21 aeb: Added some fragments of code from Colin Plumb.
 *
 */

#include "c.h"
#include "md5.h"
#include "nls.h"
#include "closestream.h"
#include "randutils.h"
#include "strutils.h"
#include "xalloc.h"
#include "all-io.h"

#include <fcntl.h>
#include <getopt.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <unistd.h>

enum {
	BUFFERSIZE = 4096,
	RAND_BYTES = 128
};

struct mcookie_control {
	struct	UL_MD5Context ctx;
	char	**files;
	size_t	nfiles;
	uint64_t maxsz;

	bool	verbose;
};

/* The basic function to hash a file */
static uint64_t hash_file(struct mcookie_control *ctl, int fd)
{
	unsigned char buf[BUFFERSIZE];
	uint64_t wanted, count;

	wanted = ctl->maxsz ? ctl->maxsz : sizeof(buf);

	for (count = 0; count < wanted; ) {
		size_t rdsz = sizeof(buf);
		ssize_t r;

		if (wanted - count < rdsz)
			rdsz = wanted - count;

		r = read_all(fd, (char *) buf, rdsz);
		if (r <= 0)
			break;
		ul_MD5Update(&ctl->ctx, buf, r);
		count += r;
	}
	/* Separate files with a null byte */
	buf[0] = '\0';
	ul_MD5Update(&ctl->ctx, buf, 1);
	return count;
}

static void __attribute__((__noreturn__)) usage(void)
{
	FILE *out = stdout;
	fputs(USAGE_HEADER, out);
	fprintf(out, _(" %s [options]\n"), program_invocation_short_name);

	fputs(USAGE_SEPARATOR, out);
	fputs(_("Generate magic cookies for xauth.\n"), out);

	fputs(USAGE_OPTIONS, out);
	fputs(_(" -f, --file <file>     use file as a cookie seed\n"), out);
	fputs(_(" -m, --max-size <num>  limit how much is read from seed files\n"), out);
	fputs(_(" -v, --verbose         explain what is being done\n"), out);

	fputs(USAGE_SEPARATOR, out);
	fprintf(out, USAGE_HELP_OPTIONS(23));

	fputs(USAGE_ARGUMENTS, out);
	fprintf(out, USAGE_ARG_SIZE(_("<num>")));

	fprintf(out, USAGE_MAN_TAIL("mcookie(1)"));

	exit(EXIT_SUCCESS);
}

static void randomness_from_files(struct mcookie_control *ctl)
{
	size_t i;

	for (i = 0; i < ctl->nfiles; i++) {
		const char *fname = ctl->files[i];
		size_t count;
		int fd;

		if (*fname == '-' && !*(fname + 1))
			fd = STDIN_FILENO;
		else
			fd = open(fname, O_RDONLY);

		if (fd < 0) {
			warn(_("cannot open %s"), fname);
		} else {
			count = hash_file(ctl, fd);
			if (ctl->verbose)
				fprintf(stderr,
					P_("Got %zu byte from %s\n",
					   "Got %zu bytes from %s\n", count),
					count, fname);

			if (fd != STDIN_FILENO && close(fd))
				err(EXIT_FAILURE, _("closing %s failed"), fname);
		}
	}
}

int main(int argc, char **argv)
{
	struct mcookie_control ctl = { .verbose = 0 };
	size_t i;
	unsigned char digest[UL_MD5LENGTH];
	unsigned char buf[RAND_BYTES];
	int c;

	static const struct option longopts[] = {
		{"file", required_argument, NULL, 'f'},
		{"max-size", required_argument, NULL, 'm'},
		{"verbose", no_argument, NULL, 'v'},
		{"version", no_argument, NULL, 'V'},
		{"help", no_argument, NULL, 'h'},
		{NULL, 0, NULL, 0}
	};

	setlocale(LC_ALL, "");
	bindtextdomain(PACKAGE, LOCALEDIR);
	textdomain(PACKAGE);
	close_stdout_atexit();

	while ((c = getopt_long(argc, argv, "f:m:vVh", longopts, NULL)) != -1) {
		switch (c) {
		case 'v':
			ctl.verbose = 1;
			break;
		case 'f':
			if (!ctl.files)
				ctl.files = xmalloc(sizeof(char *) * argc);
			ctl.files[ctl.nfiles++] = optarg;
			break;
		case 'm':
			ctl.maxsz = strtosize_or_err(optarg,
						     _("failed to parse length"));
			break;

		case 'V':
			print_version(EXIT_SUCCESS);
		case 'h':
			usage();
		default:
			errtryhelp(EXIT_FAILURE);
		}
	}

	if (ctl.maxsz && ctl.nfiles == 0)
		warnx(_("--max-size ignored when used without --file"));

	ul_MD5Init(&ctl.ctx);
	randomness_from_files(&ctl);
	free(ctl.files);

	ul_random_get_bytes(&buf, RAND_BYTES);
	ul_MD5Update(&ctl.ctx, buf, RAND_BYTES);
	if (ctl.verbose)
		fprintf(stderr, P_("Got %d byte from %s\n",
				   "Got %d bytes from %s\n", RAND_BYTES),
				RAND_BYTES, random_tell_source());

	ul_MD5Final(digest, &ctl.ctx);
	for (i = 0; i < UL_MD5LENGTH; i++)
		printf("%02x", digest[i]);
	putchar('\n');

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