secure hash

Hash Calc description
Calculate the hash of a string using MD4, MD5 or SHA-1 algorithms using Hash Calc Opera widget The Hash Calc Opera widget allows you to quickly calculate the hash of a string using the MD4, MD5 and SHA-1 algorithms.

The MD4, MD5 and SHA-1 algorithms are secure hash functions.

Requirements:

· Opera 9 or later

hash.c is a C hash table with quadratic probing. hash.c is very small and easy to use.

Compile: gcc -c hash.c

This hashtable uses C-strings for keys and quadratic probing instead of linked-list chains. It depends only on ANSI C and so should work anywhere.

API

hash * hash_new ( unsigned int size ) Create new hashtable.
void hash_destroy ( hash *h ) Free hashtable.
int hash_add ( hash *h , const char *key , void *value ) Add key/value pair.
void * hash_get ( hash *h , const char *key ) Return value matching given key.
void * hash_remove ( hash *h , const char *key ) Remove key from table, returing value.
unsigned int hash_size ( hash *h ) Returns total number of keys.

Whats New in This Release:

· This release uses exponentiation instead of xor in hashing.
· It adds a hash_destroy function.

Hash allows you to check duplicate files to see if one is identical to the other.

Forensic examiners often need to quickly obtain the hash values for potential evidence files for reports or to verify their results. Pinpoint Hash was created to allow users to quickly obtain the hash values for CRC-32, MD5, SHA-1 and SHA-256 hash values for any file and quickly copy the results to the clipboard for easy transport to any other application. Hash integrates into the Windows "Send to" menu for easy access from Windows Explorer. Its quick. Its simple. Its free. Enjoy.

Hash is a small GUI utility created to perform MD5, SHA1and CRC32 hashing functions on a number of files. The file size and modified date is also optionally shown. Results displayed in the window can easily be copied to the Windows clipboard or saved to a text file.

The program allows direct browsing of multiple files and files can also be dragged and dropped onto the window. Files (with support for wildcard selections) can also be supplied on the command line.

A convenient use for this functionality is to place a shortcut to the program in the SendTo directory (C:Documents and Settings[name]SendTo) so you can send arbitrary files to it from the Explorer shell.

DopeCode Hash description
Hash a specific folder and copy the hashes to clpboard with DopeCode Hash. DopeCode Hash will add a Hash command to the context menu of all files in the system.

When you select Hash a screen like the one below pops up, which shows the MD5 and SHA hash of the specified file.

The hashes can be copied to the clipboard with a single click. This utility comes packaged in a Windows Installer for ease of use and removal.

Checking and comparing hashes is very easy. If there is a hash on the clipboard then the hashes on screen will light up green if they match it, and red if they dont.

Hash::NoVivify is a Perl extension for non-vivifying exists and defined functions.

SYNOPSIS

use Hash::NoVivify qw(Defined Exists);

...

if (Exists(%hash, qw(key1 key2 ... keyn ))) {
...
}

if (Defined(%hash, qw(key1 key2 ... keyn))) {
...
}

When used on a hash, the exists() and defined() functions will create entries in a hash in order to evaluate the function.

For instance, the code:

%a = (a => 1, b=> 2);
print "Doesnt existn" unless exists($a{c});
print "Also Doesnt existn" unless exists($a{c}->{d});
print "Oh, my, not goodn" if exists($a{c});

will print out:

Doesnt exist
Also Doesnt exist
Oh, my, not good

The Hash::NoVivify module provides two functions, Defined() and Exists(), which avoid this, at the cost of a slightly convoluted syntax. Both functions take a reference to a hash, followed by a list of descending keys defining the hash entry to be investigated.

febooti fileTweak Hash CRC description
febooti fileTweak Hash & CRC is a free and useful hash / CRC calculator febooti fileTweak Hash & CRC is a free and useful hash / CRC calculator. Compute hash fingerprint / CRC checksum from any provided file.

Supported hash / CRC formats: CRC32, MD2, MD4, MD5, SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, RIPEMD-128, RIPEMD-160, RIPEMD-256, RIPEMD-320, WHIRLPOOL-1 and Tiger-192.

Hash::Merge Perl module merges arbitrarily deep hashes into a single hash.

SYNOPSIS

use Hash::Merge qw( merge );
my %a = (
foo => 1,
bar => [ qw( a b e ) ],
querty => { bob => alice },
);
my %b = (
foo => 2,
bar => [ qw(c d) ],
querty => { ted => margeret },
);

my %c = %{ merge( %a, %b ) };

Hash::Merge::set_behavior( RIGHT_PRECEDENT );

# This is the same as above

Hash::Merge::specify_behavior(
{
SCALAR => {
SCALAR => sub { $_[1] },
ARRAY => sub { [ $_[0], @{$_[1]} ] },
HASH => sub { $_[1] },
},
ARRAY => {
SCALAR => sub { $_[1] },
ARRAY => sub { [ @{$_[0]}, @{$_[1]} ] },
HASH => sub { $_[1] },
},
HASH => {
SCALAR => sub { $_[1] },
ARRAY => sub { [ values %{$_[0]}, @{$_[1]} ] },
HASH => sub { Hash::Merge::_merge_hashes( $_[0], $_[1] ) },
},
},
My Behavior,
);

CLASS HIERARCHY

Hash::Case
is a Tie::StdHash
is a Tie::Hash

SYNOPSIS

use Hash::Case::Lower;
tie my(%lchash), Hash::Case::Lower;
$lchash{StraNGeKeY} = 3;
print keys %lchash; # strangekey

Hash::Case is the base class for various classes which tie special treatment for the casing of keys. Be aware of the differences in implementation: Lower and Upper are tied native hashes: these hashes have no need for hidden fields or other assisting data structured. A case Preserve hash will actually create three hashes.

The following strategies are implemented:

Hash::Case::Lower (native hash)

Keys are always considered lower case. The internals of this module translate any incoming key to lower case before it is used.

Hash::Case::Upper (native hash)

Like the ::Lower, but then all keys are always translated into upper case. This module can be of use for some databases, which do translate everything to capitals as well. To avoid confusion, you may want to have you own internal Perl hash do this as well.

Hash::Case::Preserve

The actual casing is ignored, but not forgotten.

METHODS

tie HASH, TIE, [VALUES,] OPTIONS

Tie the HASH with the TIE package which extends Hash::Case. The OPTIONS differ per implementation: read the manual page for the package you actually use. The VALUES is a reference to an array containing key-value pairs, or a reference to a hash: they fill the initial hash.

Examples:

my %x;
tie %x, Hash::Case::Lower;
$x{Upper} = 3;
print keys %x; # upper

my @y = (ABC => 3, DeF => 4);
tie %x, Hash::Case::Lower, @y;
print keys %x; # abc def

my %z = (ABC => 3, DeF => 4);
tie %x, Hash::Case::Lower, %z;
addPairs PAIRS

Specify an even length list of alternating key and value to be stored in the hash.

addHashData HASH

Add the data of a hash (passed as reference) to the created tied hash. The existing values in the hash remain, the keys are adapted to the needs of the the casing.

setHash HASH

The functionality differs for native and wrapper hashes. For native hashes, this is the same as first clearing the hash, and then a call to addHashData. Wrapper hashes will use the hash you specify here to store the data, and re-create the mapping hash.

Pinpoint Hash description
obtain the hash values for CRC-32, MD5, SHA-1 and SHA-256 Forensic examiners often need to quickly obtain the hash values for potential evidence files for reports or to verify their results.

Pinpoint Hash software was designed to allow users to quickly obtain the hash values for CRC-32, MD5, SHA-1 and SHA-256 hash values for any file and quickly copy the results to the clipboard for easy transport to any other application.

Fields Captured:
· File Name
· File Path
· Created Date
· Last Accessed
· Last Modified
· File Size
· CRC-32 Digest
· MD5 Hash
· SHA-1 Hash
· SHA-256 Hash

Hash integrates into the Windows "Send to" menu for easy access from Windows Explorer. Its quick. Its simple. Its free. Enjoy.

Hash Calculator description
To convert strings to various hash formats try the Hash Calculator Opera widget The Hash Calculator Opera widget allows you to convert a string to MD5, MD4 or SHA-1.

Hash Calculator converts the inputed strings to hex format.

Requirements:

· Opera 9 or later

MD5 Hash Extractor description
MD5 Hash Extractor is a free and powerful 128-bit hashing algorithm extractor utility MD5 Hash Extractor is a free and powerful 128-bit hashing algorithm extractor utility. All it does is to form a "practically unique" key of any data.

This tiny MD5 extractor has a Windows (any 32-bit) GUI and can extract MD5 out of files of gigabytes size. Now, version 1.3 supports files with up to 64-bit size!

Hash::Type module contains pseudo-hashes as arrays tied to a "type" (list of fields).

SYNOPSIS

use Hash::Type;

# create a Hash::Type
my $personType = new Hash::Type(qw(firstname lastname city));

# create and populate some hashes tied to $personType
tie %wolfgang, $personType, "wolfgang amadeus", "mozart", "salzburg";
$ludwig = new $personType ("ludwig", "van beethoven", "vienna");
$jsb = new $personType;
$jsb->{city} = "leipzig";
@{$jsb}{qw(firstname lastname)} = ("johann sebastian", "bach");

# add fields dynamically
$personType->add("birth", "death") or die "fields not added";
$wolfgang{birth} = 1750;

# More complete example : read a flat file with headers on first line
my ($headerline, @datalines) = map {chomp; $_} ;
my $ht = new Hash::Type(split /t/, $headerline);
foreach my $line (@datalines) {
my $data = new $ht(split /t/, $line);
work_with($data->{someField}, $data->{someOtherField});
}

# an alternative to Time::gmtime and Time::localtime
my $timeType = new Hash::Type qw(sec min hour mday mon year wday yday);
my $localtime = new $timeType (localtime);
my $gmtime = new $timeType (gmtime);
print $localtime->{hour} - $gmtime->{hour}, " hours difference to GMT";

# comparison functions
my $byAge = $personType->cmp("birth : -num, lastname, firstname");
my $byNameLength = $personType->cmp(lastname => {length($b) <=> length($a)},
lastname => alpha,
firstname => alpha);
showPerson($_) foreach (sort $byAge @people);
showPerson($_) foreach (sort $byNameLength @people);

# special comparisons : dates
my $US_DateCmp = $myHashType->cmp("someDateField : m/d/y");
my $FR_InverseDateCmp = $myHashType->cmp("someDateField : -d.m.y");

Tie::Hash::KeysMask - control key aliasing by mask function, e.g. omit case of character distinction.

SYNOPSIS

use Tie::Hash::KeysMask;

my $mask = sub {...};
tie %argH, Tie::Hash::KeyMask,$mask, more arguments;

Yield that the key mask function &$mask translates any key
when applied to %argH like ..

$k => $mask->($k, more arguments)

that is

$argH{$k} expands to $argH{$mask->($k, more arguments)}
$argH{$k} = $v expands to $argH{$mask->($k, more arguments)} = $v

If e.g. choose key mask sub {uc $_[0]} one can access an element without care of case of the key. In place of sub { } particular items can be used which will be translated into a CODE. The translation is

lc => sub { lc $_[0] }
uc => sub { uc $_[0] }
%M => sub { exists $M{$_[0]} ? $M{$_[0]} : $_[0]}

A class-method codemap manage this translation. If it is pleased one could override it and add ones own translations.
This class inherits from Tie::Hash::Create by which the tied hash can be obtained anonymously as reference with the command

Tie::Hash::KeyMask->newHASH (sub {...}, more arguments)

which overrides the tie syntax calling tie from body of newHash.

Tie::Hash::Stack is a Perl module which maintains an array of hashes like a stack.

SYNOPSIS

use Tie::Hash::Stack qw(pop_hash push_hash merge_hash);

my %hash;
tie( %hash, "Tie::Hash::Stack" ); # Ties the hash

$hash{ 1 } = "one";
$hash{ 2 } = "two";
$hash{ 3 } = "three";

push_hash %hash; # Pushes a new hash on the stack

$hash{ 2 } = "II"; # $hash{ 2 } now II
$hash{ 4 } = "IV";

push_hash %hash;

$hash{ 3 } = "9/3"; # $hash{ 3 } now 9/3
$hash{ 5 } = "10/2";

pop_hash %hash; # $hash{ 3 } now three;

delete $hash{ 2 }; # $hash{ 2 } now undefed;

my %merged = merge_hash %hash; # ( 1=>one, 3=>three, 4=>IV )

Tie::Hash::Stack allows one to tie a hash to a data structure that is composed of an ordered (FILO) sequence of hashes; hash values are always set on the newest hash of the stack, and are retrieved from the hash that contains the requested that is newest on the stack. The stack can be manipulated to add or remove these hashes. This type of structure is good when one is collecting data in stages with the possibility of having to "back up" to previous stages.

Set::Hash is a Perl module with hashes as objects with lots of handy methods (including set comparisons) and support for method chaining.

SYNOPSIS

use Set::Hash;
my $sh1 = Set::Hash->new(name=>"dan",age=>33);
my $sh2 = Set::Hash->new(qw/weight 185 height 72/);
$sh1->length->print; # 2
$sh1->push($sh2); # $sh1 now has weight=>185 and height=>72
$sh1->length->print; # 4
$sh2->values->join(",")->print(1); # 185, 72

Set::Hash allows you to create strings as objects and use OO-style methods on them. Many convenient methods are provided here that appear in the FAQs, the Perl Cookbook or posts from comp.lang.perl.misc. In addition, there are Set methods with corresponding (overloaded) operators for the purpose of Set comparison, i.e. +, ==, etc.

The purpose is to provide built-in methods for operations that people are always asking how to do, and which already exist in languages like Ruby. This should (hopefully) improve code readability and/or maintainability. The other advantage to this module is method-chaining by which any number of methods may be called on a single object in a single statement.

Note that Set::Hash is a subclass of Set::Array, although most of the methods of Set::Array have been overloaded, so youll want to check the documentation for what each method does exactly.

Tie::Proxy::Hash is a Perl module created to efficiently merge & translate hashes.

SYNOPSIS

my (%hash, $ref);
$ref = tie %hash, Tie::Proxy::Hash, (bart => +{a => 1,
b => 2},
maggie => +{a => 5,
c => 6,
e => 10},
);
$hash{a} == 1; # true
$hash{b} == 2; # true (bart supercedes maggie)
$hash{c} == 6; # true
! defined $hash{d}; # true
$hash{e} == 10; # true

$hash{c} = 9; # set in maggie
$hash{d} = 12; # set in default
$hash{f} = 11; # set in default

$ref->add_hash(lisa, +{d => 3, b => 4});
$hash{c} == 9; # true
$hash{b} == 2; # true (bart overrides lisa)
$hash{d} == 3; # true (lisa overrides default)
$hash{f} == 11; # true (only default knows f)

Proxy hash requests for one or more other hashes, with intermediate value translation.

Tie::Proxy::Hash merges hashes by maintaining a list of hashes to look up, and each key requested is looked up in each hash in order until a hit is found. Resultant values may be subject to a translating subr. In this way, hashes may be merged without the cost of by-value copying.

A default backing hash is provided to store values not present in other hashes.

Tying

$ref = tie %hash, Tie::Proxy::Hash,
bart => +{a => 1, b => 2},
maggie => +{a => 5, c => 6, e => 10} => sub {10*$_[0]},
;

Any arguments passed to tie are palmed off onto add_hash.

Retrieving Values

Values are retrieved by checking each hash in the order of insertion; the first hash found in which a given key exists supplies the value. The value is subject to translation if the given hash has an associated translator.