What does shred actually do?

       -f, --force
              change permissions to allow writing if necessary

       -n, --iterations=N
              overwrite N times instead of the default (3)

       --random-source=FILE
              get random bytes from FILE

       -s, --size=N
              shred this many bytes (suffixes like K, M, G accepted)

       -u     deallocate and remove file after overwriting

       --remove[=HOW]
              like -u but give control on HOW to delete;  See below

       -v, --verbose
              show progress

       -x, --exact
              do not round file sizes up to the next full block;

              this is the default for non-regular files

       -z, --zero
              add a final overwrite with zeros to hide shredding

λ  echo 'sphinx of black quartz judge my vow' > foo.txt

λ  bat foo.txt 
sphinx of black quartz judge my vow

λ  hexyl foo.txt 
┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
│00000000│ 73 70 68 69 6e 78 20 6f ┊ 66 20 62 6c 61 63 6b 20 │sphinx o┊f black │
│00000010│ 71 75 61 72 74 7a 20 6a ┊ 75 64 67 65 20 6d 79 20 │quartz j┊udge my │
│00000020│ 76 6f 77 0a             ┊                         │vow_    ┊        │
└────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘

λ  shred foo.txt

λ  hexyl foo.txt 
┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
│00000000│ ab 9d fe 9c ad fa de 97 ┊ cf 14 6b 3d ea 9e 8d 97 │××××××××┊וk=××××│
│00000010│ 8f f2 38 e9 10 6d 52 51 ┊ e3 fa 5a 10 a5 24 a2 05 │××8וmRQ┊××Z•×$ו│
│00000020│ d0 5c 78 16 70 7b f9 4d ┊ ef 14 50 60 4e fd 27 0a │×\x•p{×M┊וP`N×'_│
│00000030│ 3e 64 3c 81 79 15 da 3d ┊ 9d d8 01 32 c3 4a e7 4f │>d<×y•×=┊×ו2×J×O│
│00000040│ b9 64 2c 25 1a 9c a9 59 ┊ aa 15 be 4e ad d2 8d b1 │×d,%•××Y┊ו×N××××│
│00000050│ be 09 63 07 b0 5f 2f b2 ┊ 7d c5 95 46 fc 4d 74 33 │×_c•×_/×┊}××F×Mt3│
│00000060│ a6 4e fc 7f 70 16 fe e4 ┊ 24 df 35 6e 36 cf ba 3c │×Nוp•××┊$×5n6××<│
│00000070│ 2a af 07 60 dd c1 57 83 ┊ 33 2d 1b ac 67 78 e1 4f │*ו`××W×┊3-•×gx×O│
│00000080│ 77 9e d8 45 51 b2 99 ee ┊ c2 81 4d 2f 5f 9c 51 bd │w××EQ×××┊××M/_×Q×│
│00000090│ 65 61 8b 93 4a f2 84 a3 ┊ bd 1f 4e c8 1c 0f ca 0f │ea××J×××┊וNו•×•│
│000000a0│ fa 05 43 b3 78 da 9d e4 ┊ f5 58 53 d3 45 d7 f1 02 │וC×x×××┊×XS×E×ו│
│000000b0│ 35 3d 1d 13 54 3e ac 18 ┊ 14 09 39 22 2b d0 15 28 │5=••T>ו┊•_9"+ו(│
│000000c0│ 55 03 6a b6 d8 92 85 99 ┊ 85 2b c6 7d c2 2f 5c bc │U•j×××××┊×+×}×/\×│
│000000d0│ 83 03 29 97 da af ab 2a ┊ 5d 84 be 8d fb e4 05 c7 │ו)××××*┊]××××ו×│
│000000e0│ 9f 29 b9 9f d6 81 e8 60 ┊ f3 44 0f b9 95 ad 48 05 │×)×××××`┊×D•×××H•│
│000000f0│ 33 d8 80 c0 46 04 bc c9 ┊ 46 58 ec a9 7b c2 60 10 │3×××F•××┊FX××{×`•│

-- snip --

│00000f40│ 71 21 da 30 ad de aa b3 ┊ 48 b6 a9 a4 70 b6 60 1d │q!×0××××┊H×××p×`•│
│00000f50│ d3 15 e3 fb a5 e1 93 f7 ┊ 2d 69 c3 af 07 38 ff d4 │ו××××××┊-i×ו8××│
│00000f60│ 22 fd 0e 8a bf e7 eb 58 ┊ 98 19 ab a9 77 b5 f3 42 │"ו××××X┊ו××w××B│
│00000f70│ 2d 47 4b c6 d2 9c fb f8 ┊ 1a b4 c2 27 9e 5c d1 16 │-GK×××××┊•××'×\ו│
│00000f80│ b3 f7 23 6f e5 fe a6 2a ┊ 61 30 cd e8 8c 76 bc 9f │××#o×××*┊a0×××v××│
│00000f90│ fb cc 34 6c 38 55 e1 39 ┊ 73 45 4d 2f e5 16 cb fd │××4l8U×9┊sEM/ו××│
│00000fa0│ 89 71 ee f4 f8 55 ee 77 ┊ cf 7e e4 d8 c2 fd 9e 7e │×q×××U×w┊×~×××××~│
│00000fb0│ a4 f4 39 f7 7c f3 b3 8f ┊ 3d a0 41 c0 8a 12 f6 c2 │××9×|×××┊=×A×ו××│
│00000fc0│ 96 cd 00 ff 20 4f 84 af ┊ dd 83 e1 ac 55 dd a8 6f │××⋄× O××┊××××U××o│
│00000fd0│ eb cb c0 49 f2 cf e5 29 ┊ 45 ba fd 67 04 f5 13 f5 │×××I×××)┊E××g•×•×│
│00000fe0│ 65 74 70 b3 0b 9b 1d e4 ┊ 48 a5 58 e4 ed 8a 30 d1 │etpוו×┊H×X×××0×│
│00000ff0│ 8a 29 48 06 e8 c8 b1 1b ┊ 2c da 93 4f 23 c9 99 fa │×)H•××ו┊,××O#×××│
└────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘

/*
 * Finally, the function that actually takes a filename and grinds
 * it into hamburger.
 --snip--
 */
static bool
wipefile (char *name, char const *qname,
          struct randint_source *s, struct Options const *flags)
{
  bool ok;
  int fd;

  fd = open (name, O_WRONLY | O_NOCTTY | O_BINARY);
  if (fd < 0
      && (errno == EACCES && flags->force)
      && chmod (name, S_IWUSR) == 0)
    fd = open (name, O_WRONLY | O_NOCTTY | O_BINARY);
  if (fd < 0)
    {
      error (0, errno, _("%s: failed to open for writing"), qname);
      return false;
    }

  ok = do_wipefd (fd, qname, s, flags);
  if (close (fd) != 0)
    {
      error (0, errno, _("%s: failed to close"), qname);
      ok = false;
    }
  if (ok && flags->remove_file)
    ok = wipename (name, qname, flags);
  return ok;
}

static bool
do_wipefd (int fd, char const *qname, struct randint_source *s,
           struct Options const *flags)
{
  size_t i;
  struct stat st;
  off_t size;       /* Size to write, size to read */
  off_t i_size = 0; /* For small files, initial size to overwrite inode */
  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)
    n = flags->n_iterations + flags->zero_fill;

  if (fstat (fd, &st))
    {
      error (0, errno, _("%s: fstat failed"), qname);
      return false;
    }

  /* If we know that we can't possibly shred the file, give up now.
     Otherwise, we may go into an infinite loop writing data before we
     find that we can't rewind the device.  */
  if ((S_ISCHR (st.st_mode) && isatty (fd))
      || S_ISFIFO (st.st_mode)
      || S_ISSOCK (st.st_mode))
    {
      error (0, 0, _("%s: invalid file type"), qname);
      return false;
    }
  else if (S_ISREG (st.st_mode) && st.st_size < 0)
    {
      error (0, 0, _("%s: file has negative size"), qname);
      return false;
    }

  /* Allocate pass array */
  passarray = xnmalloc (flags->n_iterations, sizeof *passarray);

  size = flags->size;
  if (size == -1)
    {
      if (S_ISREG (st.st_mode))
        {
          size = st.st_size;

          if (! flags->exact)
            {
              /* Round up to the nearest block size to clear slack space.  */
              off_t remainder = size % STP_BLKSIZE (&st);
              if (size && size < STP_BLKSIZE (&st))
                i_size = size;
              if (remainder != 0)
                {
                  off_t size_incr = STP_BLKSIZE (&st) - remainder;
                  size += MIN (size_incr, OFF_T_MAX - size);
                }
            }
        }
  else if (S_ISREG (st.st_mode)
           && st.st_size < MIN (STP_BLKSIZE (&st), size))
    i_size = st.st_size;

  /* Schedule the passes in random order. */
  genpattern (passarray, flags->n_iterations, s);

  rs = randint_get_source (s);

  while (true)
    {
      off_t pass_size;
      unsigned long int pn = n;

      if (i_size)
        {
          pass_size = i_size;
          i_size = 0;
          pn = 0;
        }
      else if (size)
        {
          pass_size = size;
          size = 0;
        }
      /* TODO: consider handling tail packing by
         writing the tail padding as a separate pass,
         (that would not rewind).  */
             else
        break;

      for (i = 0; i < flags->n_iterations + flags->zero_fill; i++)
        {
          int err = 0;
          int type = i < flags->n_iterations ? passarray[i] : 0;

          err = dopass (fd, &st, qname, &pass_size, type, rs, i + 1, pn);

          if (err)
            {
              ok = false;
              if (err < 0)
                goto wipefd_out;
            }
        }
    }

  /* Now deallocate the data.  The effect of ftruncate is specified
     on regular files and shared memory objects (also directories, but
     they are not possible here); don't worry about errors reported
     for other file types.  */

  if (flags->remove_file && ftruncate (fd, 0) != 0
      && (S_ISREG (st.st_mode) || S_TYPEISSHM (&st)))
    {
      error (0, errno, _("%s: error truncating"), qname);
      ok = false;
      goto wipefd_out;
    }

wipefd_out:
  free (passarray);
  return ok;
}

λ  echo 'sphinx of black quartz hear my vow' > foo.txt

λ  ls -la foo.txt 
.rw-rw-r-- kingsfoil kingsfoil 35 B Wed May 22 23:01:11 2024  foo.txt

λ  chmod -w foo.txt 

λ  ls -la foo.txt 
.r--r--r-- kingsfoil kingsfoil 35 B Wed May 22 23:01:11 2024  foo.txt

λ  shred foo.txt 
shred: foo.txt: failed to open for writing: Permission denied

λ  shred --force foo.txt

λ ## Yep

λ  echo 'sphinx of black quartz hear my vow' > foo.txt

λ  shred foo.txt && hexyl foo.txt | head
┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
│00000000│ 92 e2 68 9f ac c8 93 6e ┊ 7f f1 d1 00 2c ca ae 5d │××h××××n┊•××⋄,××]│
│00000010│ b7 c0 67 b9 42 58 2f 55 ┊ 87 43 49 e4 25 6f 56 7a │××g×BX/U┊×CI×%oVz│
│00000020│ b2 4b d2 38 13 c3 66 10 ┊ fa a4 e0 b7 18 2f d4 4b │×K×8•×f•┊×××ו/×K│
│00000030│ c7 8b 02 03 65 b0 81 a6 ┊ d9 e3 b4 5f cc e9 10 96 │×ו•e×××┊×××_×ו×│
│00000040│ eb 73 39 be a5 6f 02 d3 ┊ 34 25 24 ee c2 a5 05 6d │×s9××o•×┊4%$××וm│
│00000050│ 28 d2 e9 6e 0e 37 5c fb ┊ ba 65 5e 4f 39 fa ae ce │(××n•7\×┊×e^O9×××│
│00000060│ 5e db 63 f5 12 ae a1 8b ┊ ca 0f 9b 0a 19 30 39 95 │^×cו×××┊ו×_•09×│
│00000070│ 18 76 4c 85 eb ae 37 d9 ┊ 67 7f 6c d4 26 2c 63 56 │•vL×××7×┊g•l×&,cV│
│00000080│ 14 9e 93 8c 45 ee bb 69 ┊ 91 a4 dd e4 b1 fc 14 80 │•×××E××i┊×××××ו×│

λ  echo 'sphinx of black quartz hear my vow' > foo.txt

λ  shred --iterations=3 foo.txt && hexyl foo.txt | head
┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
│00000000│ 43 ff 1b 70 38 5b f1 e2 ┊ 98 78 89 9b 71 0e 1a 72 │Cוp8[××┊×x××q••r│
│00000010│ c2 cd 5f 66 97 65 32 5b ┊ b5 d1 52 93 e4 99 70 c0 │××_f×e2[┊××R×××p×│
│00000020│ 30 7e a4 06 74 4d e1 6f ┊ 93 7c f5 cd 8d 96 ba 27 │0~וtM×o┊×|×××××'│
│00000030│ f9 d6 14 c0 80 bd 72 0f ┊ df dc f2 18 93 cc ed 06 │×ו×××r•┊××ו××ו│
│00000040│ 62 91 77 a3 0b 86 6d 95 ┊ 18 11 a0 22 df 1b 22 1b │b×wו×m×┊••×"ו"•│
│00000050│ 8e e0 6f 3f 4d fe ee bd ┊ 3f 31 04 ad 70 7d 3a da │××o?M×××┊?1•×p}:×│
│00000060│ 51 6a 4d 8e 51 78 a8 8e ┊ 30 98 ca 9f a2 7e fb 2a │QjM×Qx××┊0××××~×*│
│00000070│ 03 8c 54 29 48 df 4c b2 ┊ 70 07 b3 da 1c f7 7f 41 │•×T)H×L×┊p•×ווA│
│00000080│ 98 5c 37 36 a9 b5 3a e2 ┊ 50 2f fd 61 4c 44 7d ea │×\76××:×┊P/×aLD}×│

λ  echo 'sphinx of black quartz hear my vow' > foo.txt

λ  shred --random-source=/dev/urandom foo.txt && hexyl foo.txt | head
┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
│00000000│ 38 3b 5f 85 07 85 db eb ┊ 3e f8 b6 14 0a 1f e4 5c │8;_ו×××┊>×ו_•×\│
│00000010│ aa ed 02 02 64 d7 bd 39 ┊ 89 eb 43 e4 f1 b2 9e c3 │×ו•d××9┊××C×××××│
│00000020│ 3f 22 3a 99 14 1d 51 47 ┊ 78 43 3c 39 fe b9 aa 51 │?":ו•QG┊xC<9×××Q│
│00000030│ 01 54 f6 ff d0 69 01 10 ┊ 3f fe 78 d0 52 9c 54 b6 │•T×××i••┊?×x×R×T×│
│00000040│ ad 3f ce a9 24 ce 10 f6 ┊ c3 e9 bc f1 fc c3 fa 29 │×?××$ו×┊×××××××)│
│00000050│ 1b 8a bb db c4 d7 94 95 ┊ c7 f9 3f 2a 62 60 22 61 │•×××××××┊××?*b`"a│
│00000060│ b3 cf 36 db c6 c2 37 57 ┊ 2f e0 24 57 f0 2d 99 64 │××6×××7W┊/×$W×-×d│
│00000070│ 6f ed 8d dc 2f b5 66 26 ┊ 56 29 56 e4 7f d9 ea a2 │o×××/×f&┊V)Vו×××│
│00000080│ 26 69 ce bc b0 51 05 1f ┊ ad f6 bc 79 0c f6 6d bb │&i×××Q••┊×××y_×m×│

λ  shred --random-source=/dev/zero foo.txt && hexyl foo.txt | head
┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
│00000000│ 00 00 00 00 00 00 00 00 ┊ 00 00 00 00 00 00 00 00 │⋄⋄⋄⋄⋄⋄⋄⋄┊⋄⋄⋄⋄⋄⋄⋄⋄│
│*       │                         ┊                         │        ┊        │
│00001000│                         ┊                         │        ┊        │
└────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘

λ  echo 'sphinx of black quartz hear my vow' > foo.txt

λ  bat zork.txt
Oh ye who go about saying unto each:  "Hello sailor":
Dost thou know the magnitude of thy sin before the gods?
Yea, verily, thou shalt be ground between two stones.
Shall the angry gods cast thy body into the whirlpool?
Surely, thy eye shall be put out with a sharp stick!
Even unto the ends of the earth shalt thou wander and
unto the land of the dead shalt thou be sent at last.
Surely thou shalt repent of thy cunning.

λ  shred --random-source=./zork.txt foo.txt
shred: ‘./zork.txt’: end of file

λ  hexyl foo.txt 
┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
│00000000│ 68 65 20 6d 61 67 6e 69 ┊ 74 75 64 65 20 6f 66 20 │he magni┊tude of │
│00000010│ 74 68 79 20 73 69 6e 20 ┊ 62 65 66 6f 72 65 20 74 │thy sin ┊before t│
│00000020│ 68 65 20                ┊                         │he      ┊        │
└────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘

λ  bat foo.txt 
he magnitude of thy sin before the 

λ  echo 'sphinx of black quartz hear my vow' > foo.txt

λ  hexyl foo.txt 
┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
│00000000│ 73 70 68 69 6e 78 20 6f ┊ 66 20 62 6c 61 63 6b 20 │sphinx o┊f black │
│00000010│ 71 75 61 72 74 7a 20 68 ┊ 65 61 72 20 6d 79 20 76 │quartz h┊ear my v│
│00000020│ 6f 77 0a                ┊                         │ow_     ┊        │
└────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘

λ  shred --size=12 foo.txt 

λ  hexyl foo.txt 
┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
│00000000│ 54 91 41 44 0f 92 d1 5f ┊ 8e 8d 05 05 61 63 6b 20 │T×AD•××_┊×ו•ack │
│00000010│ 71 75 61 72 74 7a 20 68 ┊ 65 61 72 20 6d 79 20 76 │quartz h┊ear my v│
│00000020│ 6f 77 0a                ┊                         │ow_     ┊        │
└────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘

λ  echo 'sphinx of black quartz hear my vow' > foo.txt

λ  hexyl foo.txt 
┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
│00000000│ 73 70 68 69 6e 78 20 6f ┊ 66 20 62 6c 61 63 6b 20 │sphinx o┊f black │
│00000010│ 71 75 61 72 74 7a 20 68 ┊ 65 61 72 20 6d 79 20 76 │quartz h┊ear my v│
│00000020│ 6f 77 0a                ┊                         │ow_     ┊        │
└────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘

λ  wc --bytes foo.txt 
35 foo.txt

λ  shred --size=35 foo.txt ## Identical to a normal call to shred

λ  hexyl foo.txt 
┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
│00000000│ 46 75 e0 3b b2 69 75 05 ┊ 5a 65 2a b5 87 26 9a 2d │Fu×;×iu•┊Ze*××&×-│
│00000010│ cf 68 bb 0b 82 d0 80 ba ┊ 46 42 87 33 79 45 78 00 │×hו××××┊FB×3yEx⋄│
│00000020│ 82 9f 83                ┊                         │×××     ┊        │
└────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘

λ  echo 'sphinx of black quartz hear my vow' > foo.txt

λ  hexyl foo.txt 
┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
│00000000│ 73 70 68 69 6e 78 20 6f ┊ 66 20 62 6c 61 63 6b 20 │sphinx o┊f black │
│00000010│ 71 75 61 72 74 7a 20 68 ┊ 65 61 72 20 6d 79 20 76 │quartz h┊ear my v│
│00000020│ 6f 77 0a                ┊                         │ow_     ┊        │
└────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘

λ  shred --size=36 foo.txt ## n+1 bytes

λ  hexyl foo.txt 
┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
│00000000│ 67 6f d7 fb ab 70 d4 fb ┊ 87 c3 dd 93 67 02 ef f7 │go×××p××┊××××g•××│
│00000010│ 28 17 0c 49 73 ec 50 ee ┊ 5e 51 ae 5a 4e 18 53 10 │(•_Is×P×┊^Q×ZN•S•│
│00000020│ 66 76 da f4             ┊                         │fv××    ┊        │
└────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘

λ  echo 'sphinx of black quartz hear my vow' > foo.txt

λ  hexyl foo.txt
┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
│00000000│ 73 70 68 69 6e 78 20 6f ┊ 66 20 62 6c 61 63 6b 20 │sphinx o┊f black │
│00000010│ 71 75 61 72 74 7a 20 68 ┊ 65 61 72 20 6d 79 20 76 │quartz h┊ear my v│
│00000020│ 6f 77 0a                ┊                         │ow_     ┊        │
└────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘

λ  wc --bytes foo.txt 
35 foo.txt

λ  shred --size=34 foo.txt ## n-1 bytes

λ  hexyl foo.txt 
┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
│00000000│ 58 a5 36 b0 e5 dd ee f5 ┊ b9 fa a7 7e ec b0 5c 8c │X×6×××××┊×××~××\×│
│00000010│ 6c b7 87 77 20 4e d2 b9 ┊ ea a8 26 0f a9 35 55 0d │l××w N××┊××&•×5U_│
│00000020│ 50 c7 0a                ┊                         │P×_     ┊        │
└────────┴─────────────────────────┴─────────────────────────┴────────┴────────┘

λ  echo 'sphinx of black quartz hear my vow' > foo.txt

~/misc via C v11.4.0-gcc took 2s 
λ  shred --size=5G foo.txt ## n-1 bytes

~/misc via C v11.4.0-gcc took 36s 
λ  wc --bytes foo.txt 
5368709120 foo.txt

~/misc via C v11.4.0-gcc 
λ  du -h foo.txt 
5.1G    foo.txt

~/misc via C v11.4.0-gcc 
λ  hexyl foo.txt | head
┌────────┬─────────────────────────┬─────────────────────────┬────────┬────────┐
│00000000│ ac ef eb 4f 12 ee c8 b4 ┊ ab 08 a5 73 7c 2f f4 61 │×××O•×××┊ו×s|/×a│
│00000010│ a3 85 3b 8f 83 37 b5 73 ┊ 0b a1 32 ce a6 02 89 60 │××;××7×s┊•×2×ו×`│
│00000020│ 0d 9d bb e1 40 05 49 3e ┊ a3 f3 f8 b7 e1 1f a7 a2 │_×××@•I>┊××××ו××│
│00000030│ aa df 5e 5f 47 17 4e d4 ┊ 30 b0 3d 9e 4a c1 dc d5 │××^_G•N×┊0×=×J×××│
│00000040│ 59 11 4d 66 60 af a2 a8 ┊ f1 86 cc 66 9b ad 20 1a │Y•Mf`×××┊×××f×× •│
│00000050│ c0 81 eb 1a 6b 44 bb ff ┊ 4c 6c 33 3a 5a 43 bd 96 │××וkD××┊Ll3:ZC××│
│00000060│ 21 57 9a 4c 00 13 3f ee ┊ c6 71 b3 49 bb c9 ed 86 │!W×L⋄•?×┊×q×I××××│
│00000070│ 81 96 1f d0 1a 24 98 79 ┊ f3 73 70 5a 46 50 08 8e │×וו$×y┊×spZFP•×│
│00000080│ a4 6b fb 94 78 83 e9 98 ┊ 5f 48 84 d7 bd 9d 5c 2d │×k××x×××┊_H××××\-│

λ  shred --random-source=./zork.txt --size=1G foo.txt
shred: ‘./zork.txt’: end of file

λ  bat foo.txt 
he magnitude of thy sin before the 

λ  wc --bytes foo.txt 
35 foo.txt

static struct randint_source *randint_source;

do_wipefd (int fd, char const *qname, struct randint_source *s,
           struct Options const *flags)
{
  size_t i;
  struct stat st;
  off_t size;       /* Size to write, size to read */
  off_t i_size = 0; /* For small files, initial size to overwrite inode */
  unsigned long int n;  /* Number of passes for printing purposes */
  int *passarray;
  bool ok = true;
  struct randread_source *rs;


--snip--

  rs = randint_get_source (s);

...

}

struct randread_source *
randint_get_source (struct randint_source const *s)
{
  return s->source;
}

/* A source of random data for generating random integers.  */
struct randint_source
{
  /* The source of random bytes.  */
  struct randread_source *source;

  /* RANDNUM is a buffered random integer, whose information has not
     yet been delivered to the caller.  It is uniformly distributed in
     the range 0 <= RANDNUM <= RANDMAX.  If RANDMAX is zero, then
     RANDNUM must be zero (and in some sense it is not really
     "random").  */
  randint randnum;
  randint randmax;
};

/* A source of random data for generating random buffers.  */
struct randread_source
{
  /* Stream to read random bytes from.  If null, the current
     implementation uses an internal PRNG (ISAAC).  */
  FILE *source;

  /* Function to call, and its argument, if there is an input error or
     end of file when reading from the stream; errno is nonzero if
     there was an error.  If this function returns, it should fix the
     problem before returning.  The default handler assumes that
     handler_arg is the file name of the source.  */
  void (*handler) (void const *);
  void const *handler_arg;

  /* The buffer for SOURCE.  It's kept here to simplify storage
     allocation and to make it easier to clear out buffered random
     data.  */
  union
  {
    /* The stream buffer, if SOURCE is not null.  */
    char c[RANDREAD_BUFFER_SIZE];

    /* The buffered ISAAC pseudorandom buffer, if SOURCE is null.  */
    struct isaac
    {
      /* The number of bytes that are buffered at the end of data.b.  */
      size_t buffered;

      /* State of the ISAAC generator.  */
      struct isaac_state state;

      /* Up to a buffer's worth of pseudorandom data.  */
      union
      {
        isaac_word w[ISAAC_WORDS];
        unsigned char b[ISAAC_BYTES];
      } data;
    } isaac;
  } buf;
};

rs = randint_get_source (s);

 for (i = 0; i < flags->n_iterations + flags->zero_fill; i++)
        {
          int err = 0;
          int type = i < flags->n_iterations ? passarray[i] : 0;

          err = dopass (fd, &st, qname, &pass_size, type, rs, i + 1, pn);

          if (err)
            {
              ok = false;
              if (err < 0)
                goto wipefd_out;
            }
        }

err = dopass (fd, &st, qname, &pass_size, type, rs, i + 1, pn);

/*
 * Do pass number K of N, writing *SIZEP bytes of the given pattern TYPE
 * to the file descriptor FD.  K and N are passed in only for verbose
 * progress message purposes.  If N == 0, no progress messages are printed.
 *
 * If *SIZEP == -1, the size is unknown, and it will be filled in as soon
 * as writing fails with ENOSPC.
 *
 * Return 1 on write error, -1 on other error, 0 on success.
 */
static int
dopass (int fd, struct stat const *st, char const *qname, off_t *sizep,
        int type, struct randread_source *s,
        unsigned long int k, unsigned long int n)
{
...
}

--snip--

randread (s, pbuf, lim);

--snip--