Home | History | Annotate | Line # | Download | only in rndctl
rndctl.c revision 1.24 
      1 /*	$NetBSD: rndctl.c,v 1.24 2012/02/02 19:42:57 tls Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 1997 Michael Graff.
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. Neither the name of the author nor the names of other contributors
     16  *    may be used to endorse or promote products derived from this software
     17  *    without specific prior written permission.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
     24  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
     25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
     26  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
     27  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29  * SUCH DAMAGE.
     30  */
     31 #include <sys/cdefs.h>
     32 #include <sys/types.h>
     33 #include <sha1.h>
     34 
     35 #ifndef lint
     36 __RCSID("$NetBSD: rndctl.c,v 1.24 2012/02/02 19:42:57 tls Exp $");
     37 #endif
     38 
     39 
     40 #include <sys/types.h>
     41 #include <sys/ioctl.h>
     42 #include <sys/param.h>
     43 #include <sys/rnd.h>
     44 
     45 #include <stdio.h>
     46 #include <stdlib.h>
     47 #include <unistd.h>
     48 #include <fcntl.h>
     49 #include <errno.h>
     50 #include <err.h>
     51 #include <string.h>
     52 
     53 typedef struct {
     54 	const char *a_name;
     55 	u_int32_t a_type;
     56 } arg_t;
     57 
     58 static const arg_t source_types[] = {
     59 	{ "???",     RND_TYPE_UNKNOWN },
     60 	{ "disk",    RND_TYPE_DISK },
     61 	{ "net",     RND_TYPE_NET },
     62 	{ "tape",    RND_TYPE_TAPE },
     63 	{ "tty",     RND_TYPE_TTY },
     64 	{ "rng",     RND_TYPE_RNG },
     65 	{ "skew",    RND_TYPE_SKEW },
     66 	{ "env",     RND_TYPE_ENV },
     67 	{ "vm",      RND_TYPE_VM },
     68 	{ "power",   RND_TYPE_POWER },
     69 	{ NULL,      0 }
     70 };
     71 
     72 __dead static void usage(void);
     73 static u_int32_t find_type(const char *name);
     74 static const char *find_name(u_int32_t);
     75 static void do_ioctl(rndctl_t *);
     76 static char * strflags(u_int32_t);
     77 static void do_list(int, u_int32_t, char *);
     78 static void do_stats(void);
     79 
     80 static void
     81 usage(void)
     82 {
     83 
     84 	fprintf(stderr, "usage: %s -CEce [-d devname | -t devtype]\n",
     85 	    getprogname());
     86 	fprintf(stderr, "       %s -ls [-d devname | -t devtype]\n",
     87 	    getprogname());
     88 	fprintf(stderr, "	%s -[L|S] save-file\n", getprogname());
     89 	exit(1);
     90 }
     91 
     92 static u_int32_t
     93 find_type(const char *name)
     94 {
     95 	const arg_t *a;
     96 
     97 	a = source_types;
     98 
     99 	while (a->a_name != NULL) {
    100 		if (strcmp(a->a_name, name) == 0)
    101 			return (a->a_type);
    102 		a++;
    103 	}
    104 
    105 	errx(1, "device name %s unknown", name);
    106 	return (0);
    107 }
    108 
    109 static const char *
    110 find_name(u_int32_t type)
    111 {
    112 	const arg_t *a;
    113 
    114 	a = source_types;
    115 
    116 	while (a->a_name != NULL) {
    117 		if (type == a->a_type)
    118 			return (a->a_name);
    119 		a++;
    120 	}
    121 
    122 	warnx("device type %u unknown", type);
    123 	return ("???");
    124 }
    125 
    126 static void
    127 do_save(const char *const filename)
    128 {
    129 	int est1, est2;
    130 	rndpoolstat_t rp;
    131 	rndsave_t rs;
    132 	SHA1_CTX s;
    133 
    134 	int fd;
    135 
    136 	fd = open("/dev/urandom", O_RDONLY, 0644);
    137 	if (fd < 0) {
    138 		err(1, "device open");
    139 	}
    140 
    141 	if (ioctl(fd, RNDGETPOOLSTAT, &rp) < 0) {
    142 		err(1, "ioctl(RNDGETPOOLSTAT)");
    143 	}
    144 
    145 	est1 = rp.curentropy;
    146 
    147 	if (read(fd, rs.data, sizeof(rs.data)) != sizeof(rs.data)) {
    148 		err(1, "entropy read");
    149 	}
    150 
    151 	if (ioctl(fd, RNDGETPOOLSTAT, &rp) < 0) {
    152 		err(1, "ioctl(RNDGETPOOLSTAT)");
    153 	}
    154 
    155 	est2 = rp.curentropy;
    156 
    157 	if (est1 - est2 < 0) {
    158 		rs.entropy = 0;
    159 	} else {
    160 		rs.entropy = est1 - est2;
    161 	}
    162 
    163 	SHA1Init(&s);
    164 	SHA1Update(&s, (uint8_t *)&rs.entropy, sizeof(rs.entropy));
    165 	SHA1Update(&s, rs.data, sizeof(rs.data));
    166 	SHA1Final(rs.digest, &s);
    167 
    168 	close(fd);
    169 	unlink(filename);
    170 	fd = open(filename, O_CREAT|O_EXCL|O_WRONLY, 0600);
    171 	if (fd < 0) {
    172 		err(1, "output open");
    173 	}
    174 
    175 	if (write(fd, &rs, sizeof(rs)) != sizeof(rs)) {
    176 		unlink(filename);
    177 		fsync_range(fd, FDATASYNC|FDISKSYNC, (off_t)0, (off_t)0);
    178 		err(1, "write");
    179 	}
    180 	fsync_range(fd, FDATASYNC|FDISKSYNC, (off_t)0, (off_t)0);
    181 	close(fd);
    182 }
    183 
    184 static void
    185 do_load(const char *const filename)
    186 {
    187 	int fd;
    188 	rndsave_t rs, rszero;
    189 	rnddata_t rd;
    190 	SHA1_CTX s;
    191 	uint8_t digest[SHA1_DIGEST_LENGTH];
    192 
    193 	fd = open(filename, O_RDWR, 0600);
    194 	if (fd < 0) {
    195 		err(1, "input open");
    196 	}
    197 
    198 	unlink(filename);
    199 
    200 	if (read(fd, &rs, sizeof(rs)) != sizeof(rs)) {
    201 		err(1, "read");
    202 	}
    203 
    204 	memset(&rszero, 0, sizeof(rszero));
    205 	if (write(fd, &rszero, sizeof(rszero) != sizeof(rszero))) {
    206 		err(1, "overwrite");
    207 	}
    208 	fsync_range(fd, FDATASYNC|FDISKSYNC, (off_t)0, (off_t)0);
    209 	close(fd);
    210 
    211 	SHA1Init(&s);
    212 	SHA1Update(&s, (uint8_t *)&rs.entropy, sizeof(rs.entropy));
    213 	SHA1Update(&s, rs.data, sizeof(rs.data));
    214 	SHA1Final(digest, &s);
    215 
    216 	if (memcmp(digest, rs.digest, sizeof(digest))) {
    217 		errx(1, "bad digest");
    218 	}
    219 
    220 	rd.len = MIN(sizeof(rd.data), sizeof(rs.data));
    221 	rd.entropy = rs.entropy;
    222 	memcpy(rd.data, rs.data, MIN(sizeof(rd.data), sizeof(rs.data)));
    223 
    224 	fd = open("/dev/urandom", O_RDWR, 0644);
    225 	if (fd < 0) {
    226 		err(1, "device open");
    227 	}
    228 
    229 	if (ioctl(fd, RNDADDDATA, &rd) < 0) {
    230 		err(1, "ioctl");
    231 	}
    232 	close(fd);
    233 }
    234 
    235 static void
    236 do_ioctl(rndctl_t *rctl)
    237 {
    238 	int fd;
    239 	int res;
    240 
    241 	fd = open("/dev/urandom", O_RDONLY, 0644);
    242 	if (fd < 0)
    243 		err(1, "open");
    244 
    245 	res = ioctl(fd, RNDCTL, rctl);
    246 	if (res < 0)
    247 		err(1, "ioctl(RNDCTL)");
    248 
    249 	close(fd);
    250 }
    251 
    252 static char *
    253 strflags(u_int32_t fl)
    254 {
    255 	static char str[512];
    256 
    257 	str[0] = 0;
    258 	if (fl & RND_FLAG_NO_ESTIMATE)
    259 		;
    260 	else
    261 		strlcat(str, "estimate", sizeof(str));
    262 
    263 	if (fl & RND_FLAG_NO_COLLECT)
    264 		;
    265 	else {
    266 		if (str[0])
    267 			strlcat(str, ", ", sizeof(str));
    268 		strlcat(str, "collect", sizeof(str));
    269 	}
    270 
    271 	return (str);
    272 }
    273 
    274 #define HEADER "Source                 Bits Type      Flags\n"
    275 
    276 static void
    277 do_list(int all, u_int32_t type, char *name)
    278 {
    279 	rndstat_t rstat;
    280 	rndstat_name_t rstat_name;
    281 	int fd;
    282 	int res;
    283 	uint32_t i;
    284 	u_int32_t start;
    285 
    286 	fd = open("/dev/urandom", O_RDONLY, 0644);
    287 	if (fd < 0)
    288 		err(1, "open");
    289 
    290 	if (all == 0 && type == 0xff) {
    291 		strncpy(rstat_name.name, name, sizeof(rstat_name.name));
    292 		res = ioctl(fd, RNDGETSRCNAME, &rstat_name);
    293 		if (res < 0)
    294 			err(1, "ioctl(RNDGETSRCNAME)");
    295 		printf(HEADER);
    296 		printf("%-16s %10u %-4s %s\n",
    297 		    rstat_name.source.name,
    298 		    rstat_name.source.total,
    299 		    find_name(rstat_name.source.type),
    300 		    strflags(rstat_name.source.flags));
    301 		close(fd);
    302 		return;
    303 	}
    304 
    305 	/*
    306 	 * Run through all the devices present in the system, and either
    307 	 * print out ones that match, or print out all of them.
    308 	 */
    309 	printf(HEADER);
    310 	start = 0;
    311 	for (;;) {
    312 		rstat.count = RND_MAXSTATCOUNT;
    313 		rstat.start = start;
    314 		res = ioctl(fd, RNDGETSRCNUM, &rstat);
    315 		if (res < 0)
    316 			err(1, "ioctl(RNDGETSRCNUM)");
    317 
    318 		if (rstat.count == 0)
    319 			break;
    320 
    321 		for (i = 0; i < rstat.count; i++) {
    322 			if (all != 0 ||
    323 			    type == rstat.source[i].type)
    324 				printf("%-16s %10u %-4s %s\n",
    325 				    rstat.source[i].name,
    326 				    rstat.source[i].total,
    327 				    find_name(rstat.source[i].type),
    328 				    strflags(rstat.source[i].flags));
    329 		}
    330 		start += rstat.count;
    331 	}
    332 
    333 	close(fd);
    334 }
    335 
    336 static void
    337 do_stats(void)
    338 {
    339 	rndpoolstat_t rs;
    340 	int fd;
    341 
    342 	fd = open("/dev/urandom", O_RDONLY, 0644);
    343 	if (fd < 0)
    344 		err(1, "open");
    345 
    346 	if (ioctl(fd, RNDGETPOOLSTAT, &rs) < 0)
    347 		err(1, "ioctl(RNDGETPOOLSTAT)");
    348 
    349 	printf("\t%9u bits mixed into pool\n", rs.added);
    350 	printf("\t%9u bits currently stored in pool (max %u)\n",
    351 	    rs.curentropy, rs.maxentropy);
    352 	printf("\t%9u bits of entropy discarded due to full pool\n",
    353 	    rs.discarded);
    354 	printf("\t%9u hard-random bits generated\n", rs.removed);
    355 	printf("\t%9u pseudo-random bits generated\n", rs.generated);
    356 
    357 	close(fd);
    358 }
    359 
    360 int
    361 main(int argc, char **argv)
    362 {
    363 	rndctl_t rctl;
    364 	int ch, cmd, lflag, mflag, sflag;
    365 	u_int32_t type;
    366 	char name[16];
    367 	const char *filename = NULL;
    368 
    369 	rctl.mask = 0;
    370 	rctl.flags = 0;
    371 
    372 	cmd = 0;
    373 	lflag = 0;
    374 	mflag = 0;
    375 	sflag = 0;
    376 	type = 0xff;
    377 
    378 	while ((ch = getopt(argc, argv, "CES:L:celt:d:s")) != -1) {
    379 		switch (ch) {
    380 		case 'C':
    381 			rctl.flags |= RND_FLAG_NO_COLLECT;
    382 			rctl.mask |= RND_FLAG_NO_COLLECT;
    383 			mflag++;
    384 			break;
    385 		case 'E':
    386 			rctl.flags |= RND_FLAG_NO_ESTIMATE;
    387 			rctl.mask |= RND_FLAG_NO_ESTIMATE;
    388 			mflag++;
    389 			break;
    390 		case 'L':
    391 			if (cmd != 0)
    392 				usage();
    393 			cmd = 'L';
    394 			filename = optarg;
    395 			break;
    396 		case 'S':
    397 			if (cmd != 0)
    398 				usage();
    399 			cmd = 'S';
    400 			filename = optarg;
    401 			break;
    402 		case 'c':
    403 			rctl.flags &= ~RND_FLAG_NO_COLLECT;
    404 			rctl.mask |= RND_FLAG_NO_COLLECT;
    405 			mflag++;
    406 			break;
    407 		case 'e':
    408 			rctl.flags &= ~RND_FLAG_NO_ESTIMATE;
    409 			rctl.mask |= RND_FLAG_NO_ESTIMATE;
    410 			mflag++;
    411 			break;
    412 		case 'l':
    413 			lflag++;
    414 			break;
    415 		case 't':
    416 			if (cmd != 0)
    417 				usage();
    418 			cmd = 't';
    419 
    420 			type = find_type(optarg);
    421 			break;
    422 		case 'd':
    423 			if (cmd != 0)
    424 				usage();
    425 			cmd = 'd';
    426 
    427 			type = 0xff;
    428 			strlcpy(name, optarg, sizeof(name));
    429 			break;
    430 		case 's':
    431 			sflag++;
    432 			break;
    433 		case '?':
    434 		default:
    435 			usage();
    436 		}
    437 	}
    438 	argc -= optind;
    439 	argv += optind;
    440 
    441 	/*
    442 	 * No leftover non-option arguments.
    443 	 */
    444 	if (argc > 0)
    445 		usage();
    446 
    447 	/*
    448 	 * Save.
    449 	 */
    450 	if (cmd == 'S') {
    451 		do_save(filename);
    452 		exit(0);
    453 	}
    454 
    455 	/*
    456 	 * Load.
    457 	 */
    458 	if (cmd == 'L') {
    459 		do_load(filename);
    460 		exit(0);
    461 	}
    462 
    463 	/*
    464 	 * Cannot list and modify at the same time.
    465 	 */
    466 	if ((lflag != 0 || sflag != 0) && mflag != 0)
    467 		usage();
    468 
    469 	/*
    470 	 * Bomb out on no-ops.
    471 	 */
    472 	if (lflag == 0 && mflag == 0 && sflag == 0)
    473 		usage();
    474 
    475 	/*
    476 	 * If not listing, we need a device name or a type.
    477 	 */
    478 	if (lflag == 0 && cmd == 0 && sflag == 0)
    479 		usage();
    480 
    481 	/*
    482 	 * Modify request.
    483 	 */
    484 	if (mflag != 0) {
    485 		rctl.type = type;
    486 		strncpy(rctl.name, name, sizeof(rctl.name));
    487 		do_ioctl(&rctl);
    488 
    489 		exit(0);
    490 	}
    491 
    492 	/*
    493 	 * List sources.
    494 	 */
    495 	if (lflag != 0)
    496 		do_list(cmd == 0, type, name);
    497 
    498 	if (sflag != 0)
    499 		do_stats();
    500 
    501 	exit(0);
    502 }
    503