I have a confession...
I love one-way hash functions. Really I do.
Cryptographic (one-way) hash functions are useful for generating
a unique (more or less) fixed length value (the hash) for an
arbitrary set of input data (the message) such that the original
data can not be determined by running the process backwards.
So for example:
Using the MD5 hashing algorithm I can generate the hash for the
phrase "The Smelly Weasel Sulked Soundlessly." and represent it as
"2fb45d9394a1ba58ea0f1ee80dd3d644".
There is only a single input that will generate this particular
hash but there is no way to reverse the process and come up with
the original phrase just by inspecting at the hash. If you want to
find out what the original message was you are pretty much stuck
with generating every possible message until you find one that
generates the same hash (an insurmountable tasks for messages of
any significant length).
Another interesting property of hashing algorithms is that tiny
changes to the input produce huge changes in the generated hash.
For example if I were to just change the first letter of the phrase
to "t" instead of "T" the generated hash would be
"997ce5e6d357e1078f8a454a9d18588a".
These properties of hash functions make them useful for an
enormous number of things including, strangely, making frustrating
geocache puzzles.
From Wikipedia...
A cryptographic hash function is a deterministic procedure that
takes an arbitrary block of data and returns a fixed-size bit
string, the (cryptographic) hash value, such that an accidental or
intentional change to the data will change the hash value. The data
to be encoded is often called the "message," and the hash value is
sometimes called the message digest or simply digest.
The ideal cryptographic hash function has four main or
significant properties:
- it is easy (but not necessarily quick) to compute the hash
value for any given message,
- it is infeasible to generate a message that has a given
hash,
- it is infeasible to modify a message without hash being
changed,
- it is infeasible to find two different messages with the same
hash.
To find the coordinates of this cache you'll have to do the
impossible... extract the message from the SHA1 hash below.
8882caa3b88a5a16fad6287e26d8a8f9454ad643
The message is plain text in the format "N51 03.### W114
07.###".
For a normal message of 22 characters we have about 8.787877
× 1052 possible messages which is beyond the range
of computation.
Fortunately you know most of the message and have a fairly
constrained list of only 1 million possible messages so a
brute force attack is feasible (by a computer... not by you).
Now why don't I make this a little harder still and rub some
salt in the wound and this time the salt is PEPPER.
NOTE: Once I have my program written it only takes about 4
seconds to run the 1M combinations through the hashing function to
find the right one. You shouldn't be numbering crunching for too
long on this one.