This is designed for checking disk - and disk-like devices - for cases
where two sectors collide.  This is most plausible for things like
cheap USB thumbdrives, some of the worst of which claim to be, say, 1G
but actually contain only ¼G of storage, but it can occur in other
cases.  The most obvious is probably firmware bugs, but it can also
serve to, for example, help track down code paths in the OS kernel
which truncate offsets to the low N bits, for some value of N.  (A
realistic, if now historical, example might be using 6-byte CDBs for
all SCSI I/O.)

For full info, such as command-line flags to invoke the facilities
described below, see the comment at the beginning of the source.

This writes data to a drive such that the each sector's content
includes knowledge of which sector it is.  It also has a mode which,
instead of writing, checks that the data on the drive is what a write
pass would have written.

Thus, the usual case is that you run it once in write mode and then
again in check mode.  If there are fewer sectors effectively available
than the disk's apparent size, the pigeonhole principle guarantees that
you'll see sector content mismatches on the check pass.

It also has a mode which does the same thing, but encrypts the data.
This is designed to defeat devices which compress the data as a way to
make the storage look larger than it is.  It is not good cryptographic
practice in the usual sense; its only purpose is to defeat compression.

You can also specify a magic string, which is used to overwrite the
beginning of each generated sector.  This allows you to avoid confusing
data from one drive with data from another drive (while in most cases
that's not a likely issue, it was easy to do).  Of course, if you
specify a magic string when writing, you have to specifiy the same
magic string when checking, or the checks will fail.  (This is not
usable for security; simply reading the disk will reveal the magic
string.)