mirror of
https://git.savannah.gnu.org/git/coreutils.git
synced 2026-11-19 03:33:43 +03:00
Use new random-number interface rather than rand-isaac.c.
Don't include rand-isaac.c; include randint.h and randread.h instead. (RANDOM_SOURCE_OPTION): New enum. (long_opts, usage, main): New option --random-source. (struct irand_state, irand_init, irand32, irand_mod): Remove. All callers changed to use randint interface. (fillrand): Remove. All callers changed to use randread interface. (dopass): Remove dependency on ISAAC buffer size. (genpattern): Don't wipe the random state here. (randint_source): New static var. (clear_random_data): New function. (main): Allocate random source, and arrange to wipe it on exit.
This commit is contained in:
1 parent
129e7756b9
commit
65533e1b09
1 file changed
+53
-105
+53
-105
@@ -60,9 +60,6 @@
|
||||
* If asked to wipe a file, this also unlinks it, renaming it to in a
|
||||
* clever way to try to leave no trace of the original filename.
|
||||
*
|
||||
* The ISAAC code still bears some resemblance to the code written
|
||||
* by Bob Jenkins, but he permits pretty unlimited use.
|
||||
*
|
||||
* This was inspired by a desire to improve on some code titled:
|
||||
* Wipe V1.0-- Overwrite and delete files. S. 2/3/96
|
||||
* but I've rewritten everything here so completely that no trace of
|
||||
@@ -108,8 +105,8 @@
|
||||
#include "inttostr.h"
|
||||
#include "quotearg.h" /* For quotearg_colon */
|
||||
#include "quote.h" /* For quotearg_colon */
|
||||
|
||||
#include "rand-isaac.c"
|
||||
#include "randint.h"
|
||||
#include "randread.h"
|
||||
|
||||
#define DEFAULT_PASSES 25 /* Default */
|
||||
|
||||
@@ -128,12 +125,20 @@ struct Options
|
||||
bool zero_fill; /* -z flag: Add a final zero pass */
|
||||
};
|
||||
|
||||
/* For long options that have no equivalent short option, use a
|
||||
non-character as a pseudo short option, starting with CHAR_MAX + 1. */
|
||||
enum
|
||||
{
|
||||
RANDOM_SOURCE_OPTION = CHAR_MAX + 1
|
||||
};
|
||||
|
||||
static struct option const long_opts[] =
|
||||
{
|
||||
{"exact", no_argument, NULL, 'x'},
|
||||
{"force", no_argument, NULL, 'f'},
|
||||
{"iterations", required_argument, NULL, 'n'},
|
||||
{"size", required_argument, NULL, 's'},
|
||||
{"random-source", required_argument, NULL, RANDOM_SOURCE_OPTION},
|
||||
{"remove", no_argument, NULL, 'u'},
|
||||
{"verbose", no_argument, NULL, 'v'},
|
||||
{"zero", no_argument, NULL, 'z'},
|
||||
@@ -165,6 +170,7 @@ Mandatory arguments to long options are mandatory for short options too.\n\
|
||||
printf (_("\
|
||||
-f, --force change permissions to allow writing if necessary\n\
|
||||
-n, --iterations=N Overwrite N times instead of the default (%d)\n\
|
||||
--random-source=FILE get random bytes from FILE (default /dev/urandom)\n\
|
||||
-s, --size=N shred this many bytes (suffixes like K, M, G accepted)\n\
|
||||
"), DEFAULT_PASSES);
|
||||
fputs (_("\
|
||||
@@ -227,65 +233,6 @@ to be recovered later.\n\
|
||||
exit (status);
|
||||
}
|
||||
|
||||
/* Single-word RNG built on top of ISAAC */
|
||||
struct irand_state
|
||||
{
|
||||
uint32_t r[ISAAC_WORDS];
|
||||
unsigned int numleft;
|
||||
struct isaac_state *s;
|
||||
};
|
||||
|
||||
static void
|
||||
irand_init (struct irand_state *r, struct isaac_state *s)
|
||||
{
|
||||
r->numleft = 0;
|
||||
r->s = s;
|
||||
}
|
||||
|
||||
/*
|
||||
* We take from the end of the block deliberately, so if we need
|
||||
* only a small number of values, we choose the final ones which are
|
||||
* marginally better mixed than the initial ones.
|
||||
*/
|
||||
static uint32_t
|
||||
irand32 (struct irand_state *r)
|
||||
{
|
||||
if (!r->numleft)
|
||||
{
|
||||
isaac_refill (r->s, r->r);
|
||||
r->numleft = ISAAC_WORDS;
|
||||
}
|
||||
return r->r[--r->numleft];
|
||||
}
|
||||
|
||||
/*
|
||||
* Return a uniformly distributed random number between 0 and n,
|
||||
* inclusive. Thus, the result is modulo n+1.
|
||||
*
|
||||
* Theory of operation: as x steps through every possible 32-bit number,
|
||||
* x % n takes each value at least 2^32 / n times (rounded down), but
|
||||
* the values less than 2^32 % n are taken one additional time. Thus,
|
||||
* x % n is not perfectly uniform. To fix this, the values of x less
|
||||
* than 2^32 % n are disallowed, and if the RNG produces one, we ask
|
||||
* for a new value.
|
||||
*/
|
||||
static uint32_t
|
||||
irand_mod (struct irand_state *r, uint32_t n)
|
||||
{
|
||||
uint32_t x;
|
||||
uint32_t lim;
|
||||
|
||||
if (!++n)
|
||||
return irand32 (r);
|
||||
|
||||
lim = -n % n; /* == (2**32-n) % n == 2**32 % n */
|
||||
do
|
||||
{
|
||||
x = irand32 (r);
|
||||
}
|
||||
while (x < lim);
|
||||
return x % n;
|
||||
}
|
||||
|
||||
/*
|
||||
* Fill a buffer with a fixed pattern.
|
||||
@@ -314,23 +261,6 @@ fillpattern (int type, unsigned char *r, size_t size)
|
||||
r[i] ^= 0x80;
|
||||
}
|
||||
|
||||
/*
|
||||
* Fill a buffer, R (of size SIZE_MAX), with random data.
|
||||
* SIZE is rounded UP to a multiple of ISAAC_BYTES.
|
||||
*/
|
||||
static void
|
||||
fillrand (struct isaac_state *s, uint32_t *r, size_t size_max, size_t size)
|
||||
{
|
||||
size_t refills = (size + ISAAC_BYTES - 1) / ISAAC_BYTES;
|
||||
assert (refills * ISAAC_BYTES <= size_max);
|
||||
|
||||
while (refills--)
|
||||
{
|
||||
isaac_refill (s, r);
|
||||
r += ISAAC_WORDS;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Generate a 6-character (+ nul) pass name string
|
||||
* FIXME: allow translation of "random".
|
||||
@@ -419,7 +349,7 @@ direct_mode (int fd, bool enable)
|
||||
*/
|
||||
static int
|
||||
dopass (int fd, char const *qname, off_t *sizep, int type,
|
||||
struct isaac_state *s, unsigned long int k, unsigned long int n)
|
||||
struct randread_source *s, unsigned long int k, unsigned long int n)
|
||||
{
|
||||
off_t size = *sizep;
|
||||
off_t offset; /* Current file posiiton */
|
||||
@@ -428,7 +358,7 @@ dopass (int fd, char const *qname, off_t *sizep, int type,
|
||||
size_t lim; /* Amount of data to try writing */
|
||||
size_t soff; /* Offset into buffer for next write */
|
||||
ssize_t ssize; /* Return value from write */
|
||||
uint32_t r[3 * MAX (ISAAC_WORDS, 1024)]; /* Fill pattern. */
|
||||
uint32_t r[3 * 1024]; /* Fill pattern. */
|
||||
char pass_string[PASS_NAME_SIZE]; /* Name of current pass */
|
||||
bool write_error = false;
|
||||
bool first_write = true;
|
||||
@@ -481,7 +411,7 @@ dopass (int fd, char const *qname, off_t *sizep, int type,
|
||||
break;
|
||||
}
|
||||
if (type < 0)
|
||||
fillrand (s, r, sizeof r, lim);
|
||||
randread (s, r, lim);
|
||||
/* Loop to retry partial writes. */
|
||||
for (soff = 0; soff < lim; soff += ssize, first_write = false)
|
||||
{
|
||||
@@ -700,9 +630,8 @@ static int const
|
||||
* order.
|
||||
*/
|
||||
static void
|
||||
genpattern (int *dest, size_t num, struct isaac_state *s)
|
||||
genpattern (int *dest, size_t num, struct randint_source *s)
|
||||
{
|
||||
struct irand_state r;
|
||||
size_t randpasses;
|
||||
int const *p;
|
||||
int *d;
|
||||
@@ -713,8 +642,6 @@ genpattern (int *dest, size_t num, struct isaac_state *s)
|
||||
if (!num)
|
||||
return;
|
||||
|
||||
irand_init (&r, s);
|
||||
|
||||
/* Stage 1: choose the passes to use */
|
||||
p = patterns;
|
||||
randpasses = 0;
|
||||
@@ -756,7 +683,7 @@ genpattern (int *dest, size_t num, struct isaac_state *s)
|
||||
{ /* Pad out with k of the n available */
|
||||
do
|
||||
{
|
||||
if (n == (size_t) k-- || irand_mod (&r, k) < n)
|
||||
if (n == (size_t) k || randint_choose (s, k) < n)
|
||||
{
|
||||
*d++ = *p;
|
||||
n--;
|
||||
@@ -802,7 +729,7 @@ genpattern (int *dest, size_t num, struct isaac_state *s)
|
||||
}
|
||||
else
|
||||
{
|
||||
swap = n + irand_mod (&r, top - n - 1);
|
||||
swap = n + randint_choose (s, top - n);
|
||||
k = dest[n];
|
||||
dest[n] = dest[swap];
|
||||
dest[swap] = k;
|
||||
@@ -810,8 +737,6 @@ genpattern (int *dest, size_t num, struct isaac_state *s)
|
||||
accum -= randpasses;
|
||||
}
|
||||
/* assert (top == num); */
|
||||
|
||||
memset (&r, 0, sizeof r); /* Wipe this on general principles */
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -819,7 +744,7 @@ genpattern (int *dest, size_t num, struct isaac_state *s)
|
||||
* size bytes of the given fd. Return true if successful.
|
||||
*/
|
||||
static bool
|
||||
do_wipefd (int fd, char const *qname, struct isaac_state *s,
|
||||
do_wipefd (int fd, char const *qname, struct randint_source *s,
|
||||
struct Options const *flags)
|
||||
{
|
||||
size_t i;
|
||||
@@ -828,6 +753,7 @@ do_wipefd (int fd, char const *qname, struct isaac_state *s,
|
||||
unsigned long int n; /* Number of passes for printing purposes */
|
||||
int *passarray;
|
||||
bool ok = true;
|
||||
struct randread_source *rs;
|
||||
|
||||
n = 0; /* dopass takes n -- 0 to mean "don't print progress" */
|
||||
if (flags->verbose)
|
||||
@@ -894,10 +820,12 @@ do_wipefd (int fd, char const *qname, struct isaac_state *s,
|
||||
/* Schedule the passes in random order. */
|
||||
genpattern (passarray, flags->n_iterations, s);
|
||||
|
||||
rs = randint_get_source (s);
|
||||
|
||||
/* Do the work */
|
||||
for (i = 0; i < flags->n_iterations; i++)
|
||||
{
|
||||
int err = dopass (fd, qname, &size, passarray[i], s, i + 1, n);
|
||||
int err = dopass (fd, qname, &size, passarray[i], rs, i + 1, n);
|
||||
if (err)
|
||||
{
|
||||
if (err < 0)
|
||||
@@ -915,7 +843,7 @@ do_wipefd (int fd, char const *qname, struct isaac_state *s,
|
||||
|
||||
if (flags->zero_fill)
|
||||
{
|
||||
int err = dopass (fd, qname, &size, 0, s, flags->n_iterations + 1, n);
|
||||
int err = dopass (fd, qname, &size, 0, rs, flags->n_iterations + 1, n);
|
||||
if (err)
|
||||
{
|
||||
if (err < 0)
|
||||
@@ -939,7 +867,7 @@ do_wipefd (int fd, char const *qname, struct isaac_state *s,
|
||||
|
||||
/* A wrapper with a little more checking for fds on the command line */
|
||||
static bool
|
||||
wipefd (int fd, char const *qname, struct isaac_state *s,
|
||||
wipefd (int fd, char const *qname, struct randint_source *s,
|
||||
struct Options const *flags)
|
||||
{
|
||||
int fd_flags = fcntl (fd, F_GETFL);
|
||||
@@ -1110,7 +1038,7 @@ wipename (char *oldname, char const *qoldname, struct Options const *flags)
|
||||
*/
|
||||
static bool
|
||||
wipefile (char *name, char const *qname,
|
||||
struct isaac_state *s, struct Options const *flags)
|
||||
struct randint_source *s, struct Options const *flags)
|
||||
{
|
||||
bool ok;
|
||||
int fd;
|
||||
@@ -1137,16 +1065,30 @@ wipefile (char *name, char const *qname,
|
||||
return ok;
|
||||
}
|
||||
|
||||
|
||||
/* Buffers for random data. */
|
||||
static struct randint_source *randint_source;
|
||||
|
||||
/* Just on general principles, wipe buffers containing information
|
||||
that may be related to the possibly-pseudorandom values used during
|
||||
shredding. */
|
||||
static void
|
||||
clear_random_data (void)
|
||||
{
|
||||
randint_all_free (randint_source);
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
struct isaac_state s;
|
||||
bool ok = true;
|
||||
struct Options flags;
|
||||
char **file;
|
||||
int n_files;
|
||||
int c;
|
||||
int i;
|
||||
char const *random_source = NULL;
|
||||
|
||||
initialize_main (&argc, &argv);
|
||||
program_name = argv[0];
|
||||
@@ -1156,8 +1098,6 @@ main (int argc, char **argv)
|
||||
|
||||
atexit (close_stdout);
|
||||
|
||||
isaac_seed (&s);
|
||||
|
||||
memset (&flags, 0, sizeof flags);
|
||||
|
||||
flags.n_iterations = DEFAULT_PASSES;
|
||||
@@ -1185,6 +1125,12 @@ main (int argc, char **argv)
|
||||
}
|
||||
break;
|
||||
|
||||
case RANDOM_SOURCE_OPTION:
|
||||
if (random_source && !STREQ (random_source, optarg))
|
||||
error (EXIT_FAILURE, 0, _("multiple random sources specified"));
|
||||
random_source = optarg;
|
||||
break;
|
||||
|
||||
case 'u':
|
||||
flags.remove_file = true;
|
||||
break;
|
||||
@@ -1232,24 +1178,26 @@ main (int argc, char **argv)
|
||||
usage (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
randint_source = randint_all_new (random_source, SIZE_MAX);
|
||||
if (! randint_source)
|
||||
error (EXIT_FAILURE, errno, "%s", quotearg_colon (random_source));
|
||||
atexit (clear_random_data);
|
||||
|
||||
for (i = 0; i < n_files; i++)
|
||||
{
|
||||
char *qname = xstrdup (quotearg_colon (file[i]));
|
||||
if (STREQ (file[i], "-"))
|
||||
{
|
||||
ok &= wipefd (STDOUT_FILENO, qname, &s, &flags);
|
||||
ok &= wipefd (STDOUT_FILENO, qname, randint_source, &flags);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Plain filename - Note that this overwrites *argv! */
|
||||
ok &= wipefile (file[i], qname, &s, &flags);
|
||||
ok &= wipefile (file[i], qname, randint_source, &flags);
|
||||
}
|
||||
free (qname);
|
||||
}
|
||||
|
||||
/* Just on general principles, wipe s. */
|
||||
memset (&s, 0, sizeof s);
|
||||
|
||||
exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);
|
||||
}
|
||||
/*
|
||||
|
||||
Reference in new issue
Block a user