Hashes As Hand Signatures
A hash is no more than an encryption algorithm that is intended to be
non-revertible - a one way encryption.
Just like Hand Signatures, its main function is to verify the authenticity
of the source or initiator of a particular transaction.
The strength of a hash algorithm lies in the certainty that the hashed data
cannot in be reversed to obtain the original data.
Properties of a Good Hash Algorithm
Any good hash algorithm is expected to possess the following characteristics:
-
Same input data must result in the same hash output every time
hashing is carried out - i.e., hashes must be unique .
This assertion still holds even if the hash is been salted and the salt happens to be changed though the equality may become technical. - A minute alteration in an input data should lead to a very large difference in the hash output.
-
Hashes may be made to be of fixed length or in a particular length range;
So that a hash of an input of say 5 characters will be the same as
that with 1005 characters.
I.e.,length(hash(character_length_5)) = length(hash(character_length_1005)).
Application of Hash Algorithms
If two parties intend to communicate securely with a Public Key -
Private Key set-up over the Internet, the only uncertainty they will face
will be who exactly is the author of a particular message, since a Public Key
is accessible to everybody and anybody on the Internet and files sent
over the Internet - or any other network for that matter - can be
intercepted (and changed - since the Public Key for encrypting messages is available to everyone)
by a suitably placed third party on the network.
This is where Hash Algorithms come into play.
Now since hashes should both be unique and non-revertible, the first party
produces a hash of his message first and encrypts this hash value using his
Private Key before encrypting his message proper using the Public Key of the second party.
The first party sends both message and hash value to the second party.
When the second party receives the message and message hash value in
encrypted forms, he decrypts the message using his private key and
the hash value using the public key of the first party; carries out
a fresh hash on the message, and compares his fresh hash and the sent hash.
If both hashes correspond, then the authenticity of the message has been
verified - i.e., the message could only have been authored by the first party
since even if the message was intercepted, and a change attempted, the hash value
could not be changed unless the intercepting party has knowledge of the first party's
Private Key.
Passwords to online user accounts are also widely hashed before they
are committed to databases.
Every time a user tries to log into his/her account, the entered
password is hashed before been compared to the hash value in the
application's database.
As hash values, if the security of a web application were to be breached
and user account details were stolen, these accounts cannot be compromised
since hash values are non-revertible.
It has to be mentioned though that common passwords can still be made out
by comparing the stolen hash values to hash values for known common passwords.
Create a new C++ class file;
Call it Hashes
.
Type out the adjoining C++ Hashing Algorithm.
Important: We obligatorily wrote a BigInteger class
for use with this section.
It is freely available on Github
or you can download it as a zip file here.
Hashes Header File
#include "BigInteger.h"
#include <algorithm>
#include <string>
#include <vector>
using namespace std;
class Hashes
{
public:
Hashes();
virtual ~Hashes();
string hashWord(vector<char>);
};
C++ Code for Hashes Class File
#include "Hashes.h"
Hashes::Hashes()
{
}
string Hashes::hashWord(vector<char> msg) {
// encoding eqn { Tn = (n-2)t1 + 2^n } - please use your own eqn
string hash = "", t1, x;
int n;
for (size_t i = 0; i < msg.size(); i++) {
// get unicode of this character as n
n = (int)msg[i];
t1 = to_string(i + 1);
// use recurrence series equation to hash
x = BigInteger::addition(BigInteger::multiplication(to_string(n-2), t1), BigInteger::exponentialPower("2", n));
if (i == 0) {
hash = x;
continue;
}
// bitwise rotate left with the modulo of x
string binary = BigInteger::decToBin(hash);
x = BigInteger::modulus(x, to_string(binary.size()));
string slice_1 = binary.substr(stoi(x));
// keep as '1' to preserve hash size
slice_1[0] = '1';
string slice_2 = binary.substr(0, stoi(x));
hash = slice_1 + slice_2;
hash = BigInteger::binToDec(hash);
}
hash = BigInteger::decToHex(hash);
transform(hash.begin(), hash.end(), hash.begin(), ::toupper);
return hash;
}
Hashes::~Hashes()
{
}
Main Class
#include "Hashes.h"
#include <iostream>
using namespace std;
int main()
{
char message[] = "merry xmas";
unsigned i = 0;
vector<char> msg = {};
while (message[i] != '\0') {
msg.push_back(message[i++]);
}
msg.shrink_to_fit();
Hashes one_way;
string hashed = one_way.hashWord(msg);
cout << "Message is '" << string(message) << "';\nMessage hash is " << hashed << endl;
return 0;
}