Free checksum software for linux

ckmame is a program to check ROM sets for MAME, the Multiple Arcade Machine Emulator.

ckmame project tells you which ROM files are missing or have a wrong checksum, and can delete unknown and unused files from the ROM sets, and rename or move ROM files.

Apache::CryptHash is a Perl module with encrypted tokens for cookies.

Creates an encrypted cookie-like string with a MAC (checksum) from a hash of critical and non-critical values. The MAC is created on only the critical values. Decryption will fail if the string has been altered and the MAC does not match when the string is decrypted.

Particularly useful when using COOKIES and will do all the hard work for Apache::AuthCookie

init()

Create class reference and set passcode to the value returned by Sys::Hostname::hostname;

my $c = Apache::CryptHash->init; # default passcode = hostname

init takes an optional parameter

my $c = Apache::CryptHash->init(no);

$c->passcode(no} # will turn encryptation off
# and put in Debug mode

Optionally, the passcode or debug may be set by

$c->passcode(no) # will turn encryptation off
# and put in Debug mode
$c->passcode(newpasscode); # change the passcode
name & passcode

Hash Header may be set to any string

$c->name(some_string); # default Secret

Just remember to obey the rules for allowed characters in cookie strings for both name & passcode

encode()

Generate an encrypted cookie-like value from a hash. Optional invarient values may be specified for a MAC

$c->encode(%state, @mac_keys).

Only the crypt secret and the mac_keys valuess are present in the MAC. What is returned is

NAME:crypted_string (NAME.Debug:crypted_string)

where $c->pascode(somename) (default Secret)
decode($$$)

Decrypt and generate state hash from the encrypted hash

$c->decode($cookie,%state, @mac_keys);

Return false if decode or MAC fails

md5_hex($)

Return the md5 hash of input string.

md5_b64($)

Return the md5 base 64 hash of input string.

checkMAC

$c = Apache::CryptHash->init(some password);
$c->checkMAC(%state, @mac_keys)

Does a comparison of the MAC in the %state vs the calculated value based on @mac_keys and returns a boolean result.
Dont forget to set the passcode or the check will fail!

Des package contains the Des extension module for Perl.

The Des extension module gives access to the DES library.

The following is a brief and over-simplified description of the relevant stuff about DES.

DES keys are 8-byte blocks. A key is passed to a perl function as an 8-byte string. Before keys can be used to encrypt or decrypt data, the key needs to be transformed into a key schedule using the function set_key. There is a certain amount of overhead in creating these key schedules (which are 128 bytes or 256 bytes depending on implementation and architecture) so they can be created and cached for later if desired. Encryption and decryption can be done in 3 modes:

ECB (electronic code book) mode

Takes a des_cblock (perl 8-byte string) and produces another des_cblock. (Very rarely useful for large amounts of plain text, subject to known plaintext attacks under certain circumstances, only slightly faster than CBC or PCBC mode, and you lose even this advantage in perl).

CBC (cipher block chaining) mode

Takes an arbitrary length string, pads it out (internally) on the right with NULs to a multiple of 8-bytes. Encrypts/decrypts the data and produces output (same size as padded input) which is an exact multiple of 8 bytes long. Changing a single bit of the cleartext affects all the following ciphertext. However, changing a single bit of the ciphertext affects only the corresponding cleartext block and the following block. This is occasionally an advantage but is usually a disadvantage.

PCBC mode

A modified CBC mode with indefinite proagation of single bit errors both from cleartext to ciphertext and from ciphertext to cleartext. "Usually" the best mode (for certain values of "usually").

Functions imported by use Des.

string_to_key (STRING)

Takes an arbitrary STRING and munges it (with a one-way function) into a DES key, which is returned.

set_key (KEY)

The DES key KEY (which must be a string of exactly 8 bytes) is turned into a key schedule which is returned.

ecb_encrypt (INPUT, SCHEDULE)

The INPUT argument (which must be a string of exactly 8 bytes) is encrypted using ECB mode using key schedule SCHEDULE (created using set_key) and the resulting 8-byte string is returned.

ecb_decrypt (INPUT, SCHEDULE)

The INPUT argument (which must be a string of exactly 8 bytes) is decrypted using ECB mode using key schedule SCHEDULE (created using set_key) and the resulting 8-byte string is returned.

cbc_encrypt (INPUT, OUTPUT, SCHEDULE, IV)

The INPUT argument can be of arbitrary length, although it will be internally padded on the right with NULs to the nearest multiple of 8 bytes. INPUT is taken and encrypted using CBC mode with key schedule SCHEDULE and initialisation vector IV. If OUTPUT is not undef then it assumed to be an lvalue which is grown (if necessary) and receives the encrypted output. Whether or not OUTPUT is undef, the output is also available as the return value of the function.

cbc_decrypt (INPUT, OUTPUT, SCHEDULE, IV)

The INPUT argument can be of arbitrary length, although it will be internally padded on the right with NULs to the nearest multiple of 8 bytes. INPUT is taken and decrypted using CBC mode with key schedule SCHEDULE and initialisation vector IV. If OUTPUT is not undef then it assumed to be an lvalue which is grown (if necessary) and receives the decrypted output. Whether or not OUTPUT is undef, the output is also available as the return value of the function.

pcbc_encrypt (INPUT, OUTPUT, SCHEDULE, IV)

The INPUT argument can be of arbitrary length, although it will be internally padded on the right with NULs to the nearest multiple of 8 bytes. INPUT is taken and encrypted using PCBC mode with key schedule SCHEDULE and initialisation vector IV. If OUTPUT is not undef then it assumed to be an lvalue which is grown (if necessary) and receives the encrypted output. Whether or not OUTPUT is undef, the output is also available as the return value of the function.

pcbc_decrypt (INPUT, OUTPUT, SCHEDULE, IV)

The INPUT argument can be of arbitrary length, although it will be internally padded on the right with NULs to the nearest multiple of 8 bytes. INPUT is taken and decrypted using PCBC mode with key schedule SCHEDULE and initialisation vector IV. If OUTPUT is not undef then it assumed to be an lvalue which is grown (if necessary) and receives the decrypted output. Whether or not OUTPUT is undef, the output is also available as the return value of the function.

pcbc_cksum (INPUT, SCHEDULE, IV)

The INPUT argument can be of arbitrary length, although it will be internally padded on the right with NULs to the nearest multiple of 8 bytes. CBC mode is used to generate an 8-byte cryptographic checksum using key schedule SCHEDULE and initialisation vector IV. This checksum is returned.
Functions in package Des which can be imported

random_key ()

Produces a random DES key based on current time, PID and a counter.
read_password (PROMPT [, VERIFY])

Prints PROMPT on the terminal, turns off echo if possible and reads a password from the keyboard. If the optional VERIFY argument is present and true than the password is prompted for a second time and the two are compared. If different, the prompting is repeated. The resulting string is turned into a DES key (using string_to_key (q.v.) internally) and that key is returned.

PHK is a PHP-oriented package system. PHKs purpose is to package a library or an application, in order to distribute and run it as a single file. As an introduction, you may think of it as a PHP-oriented jar, with a lot of additional features.
Main features:
- No runtime software : as it was said above, there is no runtime software to install before using a PHK archive, as it contains its own runtime code. Any installed PHP (version 5.1.0 or more) is ready to include/execute a PHK archive without any modification.
- Supports libraries, applications, plugins : a PHK archive can contain a library or an application (an application is a library with an entry point). PHK archives can also be used as plugins.
- Unlimited number of subfiles : a PHK archive can contain an unlimited number of subfiles and directories. A subfile can contain up 2 Gbytes of binary data. The total size of a PHK archive is limited to 2Gbytes. Every subfile can be, on a file by file basis, compressed (gzip or bz2), and/or filtered through php_strip_whitespace() (for PHP source).
- Standard locations for package information : PHK provides standard locations for administrative informations like packages name, author, license, copyright, etc. PHK also allows to specify an icon file and an URL. All these inforamtion are displayed in webinfo mode.
- Webinfo mode : in webinfo mode, the PHK archive behaves like a small web site, allowing the user to display every information about the archive, and the content of every subfile. This mode is a standard feature of every PHK archive.
- Mount/umount user scripts : the package author can specify a mount_script. This subfile will be called every time the PHK archive is mounted. In the same manner, an umount_script can be specified.
- Built-in CLI commands : several built-in CLI commands are available. These commands are the equivalent, in CLI mode, of the webinfo mode. They allow to display every information about the PHK archives structure and content.
- Meta-packages : PHK supports meta-packages, allowing a PHK archive to be incorporated as a subfile inside another PHK archive, along with other regular files. This feature is useful for unit tests (see the Zend Framework demonstration packages for an example) or to build meta-libraries (incorporating several librairies, but without mixing them together). These sub-PHK archives can be automatically mounted when the main package is mounted.
- Web path protection : In a PHK archive, the subfiles are protected from incorrect or unauthorized access from the web. The legitimate entry points are explicitely identified, making the package easier to secure. From the web, it is impossible to display or to call a subfile if it is not explicitely enabled by an option. Among other benefits, it allows to suppress the usual empty index.htm files in every directories !
- CRC checksum : A PHK archive includes a CRC checksum mechanism. Depending on the packages options, this checksum can be verified every time the package is mounted, or on users request.
- Digital signatures : A PHK package can be digitally signed (using a digital certificate). This feature allows users to verify that their package comes from a source they trust.

SYNOPSIS

use NetPacket::IP;

$ip_obj = NetPacket::IP->decode($raw_pkt);
$ip_pkt = NetPacket::IP->encode($ip_obj);
$ip_data = NetPacket::IP::strip($raw_pkt);

NetPacket::IP provides a set of routines for assembling and disassembling packets using IP (Internet Protocol).

Methods

NetPacket::IP->decode([RAW PACKET])

Decode the raw packet data given and return an object containing instance data. This method will quite happily decode garbage input. It is the responsibility of the programmer to ensure valid packet data is passed to this method.

NetPacket::IP->encode()

Return an IP packet encoded with the instance data specified. This will infer the total length of the packet automatically from the payload lenth and also adjust the checksum.

Functions

NetPacket::IP::strip([RAW PACKET])

Return the encapsulated data (or payload) contained in the IP packet. This data is suitable to be used as input for other NetPacket::* modules.

This function is equivalent to creating an object using the decode() constructor and returning the data field of that object.

Instance data

The instance data for the NetPacket::IP object consists of the following fields.

ver

The IP version number of this packet.

hlen

The IP header length of this packet.

flags

The IP header flags for this packet.

foffset

The IP fragment offset for this packet.

tos

The type-of-service for this IP packet.

len

The length (including length of header) in bytes for this packet.

id

The identification (sequence) number for this IP packet.

ttl

The time-to-live value for this packet.

proto

The IP protocol number for this packet.

cksum

The IP checksum value for this packet.

src_ip

The source IP address for this packet in dotted-quad notation.

dest_ip

The destination IP address for this packet in dotted-quad notation.

options

Any IP options for this packet.

data

The encapsulated data (payload) for this IP packet.

Another File Integrity Checker is another file integrity checker, designed to be fast and fully portable between Unix and Windows platforms.
Another File Integrity Checker works by first creating a database that represents a snapshot of the most essential parts of your computer system. You can then run the script to discover all modifications made since the snapshot was taken (i.e. files added, changed, or removed).
The configuration syntax is very close to that of aide or tripwire, and a graphical interface is provided.
Enhancements:
New features
- add report_syslog directive and option
- dynamic choice of database backend
- add report_url option
- checksum do not change atime any more if possible
- windows config file now use environment variables (Manuel Martin suggest)
Bug fix
- adapt afick_cron to old shell syntax (ash ...) to fix bug with anacron ( Slass100 report)
Upgrade
- post_install can replace environment variables in aficks config
Security
- improved afick change detection (warnings not only on checksum)
Others
- rename set_planning.bat to afick_postinstall.bat
- display warning for too long acl on windows (SDBM error)
- change directives compare algorythme (diff_tab sub)
- remove usage sub (all doc in pod)
- prepare code for daemon mode (with gamin use)

Hasher is a tool to help programmers implement checksum algorithms and standard hashing into their own software.
Written entirely in C# and designed for use in the .NET Framework, Hasher providers a uniform interface to easily use any of the algorithms contained within this library in other programs.
Hasher is planned to encapsulate a wide variety of cryptographic hashing and checksum algorithms.
Focusing on compatibility, speed, and ease-of-use, Classless.Hasher currently supports over 25 different algorithms including the "basics" such as CRC, MD5, and SHA, as well as others like HAVAL, Tiger, Snefru, and Whirlpool.
Enhancements:
- Hasher rises from the dead!
- Fixed CRCStandards for CRC8 and CRC32.
- Fixed CRC handling when the Order was 64bits.
- Removed the REVERSED CRCStandards.
- Added CRCStandards for CRC64_ISO and CRC64_ECMA.
- Changed CRCStandard CRC16 to CRC16_IBM.
- Renamed CRC16_CCITT_REVERSED to CRC16_XMODEM.
- Fixed nasty bug that broke MD4, MD5, the RIPEMDs, Tiger, and the SHAs when large datasets were processed.
- Added support for creating Panama hashes.
- Fixed the NAnt build script to better support Mono and .NET v2.0.