Free history of cryptography software for linux

The Legion of the Bouncy Castle Java Cryptography API provides a lightweight cryptography API in Java. A provider for the JCE and JCA, a clean-room implementation of the JCE 1.2.1, generators for Version 1 and Version 3 X.509 certificates, generators for Version 2 X.509 attribute certificates, PKCS12 support, and APIs for dealing with S/MIME, CMS, OCSP, TSP, and OpenPGP. Versions are provided for the J2ME, and JDK 1.0-1.5.
Main features:
- A lightweight cryptography API in Java.
- A provider for the JCE and JCA.
- A clean room implementation of the JCE 1.2.1.
- A library for reading and writing encoded ASN.1 objects.
- Generators for Version 1 and Version 3 X.509 certificates, Version 2 CRLs, and PKCS12 files.
- Generators for Version 2 X.509 attribute certificates.
- Generators/Processors for S/MIME and CMS (PKCS7).
- Generators/Processors for OCSP (RFC 2560).
- Generators/Processors for TSP (RFC 3161).
- Generators/Processors for OpenPGP (RFC 2440).
- A signed jar version suitable for JDK 1.4/1.5 and the Sun JCE.

This class can be used to keep track of the pages navigated by a user, so it can generate back or next links providing a similar effect to the use of the Javascript history.go() function.
It uses sessions to store an array variable that holds the URL of each page of a site that the user accesses. It can limit the number of pages that are kept in the history array.
It may also ignore pages accessed with the POST method or with certain URLs based on options that define exclusion regular expressions. The class can generate links to go back to the last page or the first page that was recorded.
Enhancements:
- The class is completely changed.
- This release adds creation of several objects of a class, a predefined start page, an expanded list of exceptions, and the methods get_history_back, get_history_next, is_history_back (check back one page), is_history_next (check the next page), get_history_backs (go to the first page), get_history_nexts (go to the last page), and get_history_header (go to the previous and next pages using external parameters).
- It adds history "always", and has more compatibility with javascript:history.go() (no checking previous and next pages).
- New methods have been added for the manipulation of history "always".

Rails History Plugin is a Ruby on Rails plugin that stores user actions (i.e. URLs that the user has recently visited).
It avoids storage of POST and AJAX requests, and it provides a manual way to specify which actions not to store.
Installation:
Unpack into the vendor/plugin and that should be it.
Usage:
In your app/controllers/application_controller.rb, add a history line like this:
class ApplicationController < ActionController::Base
history :default => "http://default.url.com/",
:max => 10
end
The history function accepts a hash of options
:default, the default URL to redirect
:max, the maximum locations to remember (five by defaults).
None of the parameters are required. If somebody knows of a better way to obtain the default URL, he is welcomed to tell me how.
You can use the method history_skip in your controller if you want to avoid certain location to be stored in the history. By default, action resulting from a POST, PUT, DELETE request or an Ajax request are not stored in the history.
class FooController < ApplicationController
history_skip :action_to_skip
def action_to_skip
# I will not be stored in the history
end
end
In your actions, you can then use the following methods:
last_location: returns the last visited location, can be used with one numeric argument precising how many locations to go back in the history (1 by default),
peek_last_location: like last_location but dont remove it from the history,
redirect_back: redirect the user to the last location in history, it takes the same arguments as last_location,
store_location(force = false): stores the current location in the history, set force parameter to true to store location even if it would be skipped.
Note that if you want to use the plugin to create a "back" link on a page, you must go back two times. For example, using this controller
class HistoryController < ApplicationController
def foo
end
def bar
end
def back
redirect_back(2)
end
end
Ill try to explain clearly why. Lets say that in your bar view, you create a back link wich links to the back action. Now a user visits foo then bar. What you want is your user being redirected to foo when clicking your "back" link. Now your user hits the link. The controller will call the back action. From its point of view, you are in the back action so going back one time would take you to the bar action.
Enhancements:
- This release fixes a bug where a user variable was stored in a class variable instead of a session one, so a user going back would make another one skip a page in its history.
- The plugin no longer stores PUT and DELETE requests.
- A peek_last_location method was added to look at the history without modifying it, and a "force" parameter was added to the store_location method to force storing of a location even if it would normally be skipped.

kio_history is a protocol to access Konquerors browsing history. It is mostly experimental in nature.

Known bugs:

-Cannot delete entries / clear history.
-Does not receive real-time updates, must be refreshed.
-Folder URLS (e.g. svn://anonsvn.kde.org/home/kde) do not open correctly.

Ideas for the future?

-All of the above bugs could be fixed by modifying KonqHistoryManager.
-Display favicons.
-Store previews of all history entries?

LibTomCrypt is a comprehensive, modular, and portable cryptographic toolkit that provides developers with a vast array of well known published block ciphers, one-way hash functions, chaining modes, pseudo- random number generators, public key cryptography, and a plethora of other routines. It has been designed from the ground up to be very simple to use. It has a modular and standard API that allows new ciphers, hashes, and PRNGs to be added or removed without change to the overall end application. It features functions for easy handling and a complete user manual which has many source snippet examples.
LibTomCrypt is a fairly comprehensive, modular and portable cryptographic toolkit that provides developers with a vast array of well known published block ciphers, one-way hash functions, chaining modes, pseudo-random number generators, public key cryptography and a plethora of other routines.
LibTomCrypt has been designed from the ground up to be very simple to use. It has a modular and standard API that allows new ciphers, hashes and PRNGs to be added or removed without change to the overall end application. It features easy to use functions and a complete user manual which has many source snippet examples.
LibTomCrypt is free for all purposes under the public domain. This includes commercial use, redistribution and even branching.
Main features:
- Public domain and open source.
- Written entirely in portable ISO C source (except for things like RNGs for natural reasons)
- Builds out of the box on virtually every box. All that is required is GCC for the source to build.
- Includes a 90+ page user manual in PDF format (with working examples in it)
- Block Ciphers
- Ciphers come with an ECB encrypt/decrypt, setkey and self-test interfaces.
- All ciphers have the same prototype which facilitates using multiple ciphers at runtime.
- Some of the ciphers are flexible in terms of code size and memory usage.
- Ciphers Supported.
- Blowfish
- XTEA
- RC5
- RC6
- SAFER+
- Rijndael (aka AES)
- Twofish
- SAFER (K64, SK64, K128, SK128)
- RC2
- DES, 3DES
- CAST5
- Noekeon
- Skipjack
- Anubis (with optional tweak as proposed by the developers)
- Khazad
- Changing Modes
- Modes come with a start, encrypt/decrypt and set/get IV interfaces.
- Mode supported.
- ECB
- CBC
- OFB
- CFB
- CTR
- One-Way Hash Functions
- Hashes come with init, process, done and self-test interfaces.
- All hashes use the same prototypes for the interfaces.
- Hashes supported.
- MD2
- MD4
- MD5
- SHA-1
- SHA-224/256/384/512
- TIGER-192
- RIPE-MD 128/160
- WHIRLPOOL
- Message Authentication
- FIPS-198 HMAC (supports all hashes)
- FIPS pending OMAC1 (supports all ciphers)
- PMAC Authentication
- Message Encrypt+Authenticate Modes
- EAX Mode
- OCB Mode
- Pseudo-Random Number Generators
- Yarrow (based algorithm)
- RC4
- Support for /dev/random, /dev/urandom and the Win32 CSP RNG
- Fortuna
- SOBER-128
- Public Key Algorithms
- RSA (using PKCS #1 v2.1 and PKCS #1 v1.5)
- DH (using ElGamal signatures and simple DH encryption)
- ECC (over Z/pZ, ElGamal Signatures, simple DH style encryption)
- DSA (Users make their own groups)
- Other standards
- PKCS #1 (both v1.5 and v2.0 padding)
- PKCS #5
- ASN.1 DER for INTEGER types.
Enhancements:
- The ECC code was fixed, cleaned, and improved.
- GCM was fixed.
- UTF8 support was added to the ASN1 code.
- The documentation was improved.
- The published version of the manual is included.

There is quite a bit of history on this item. One of the assignments in a computer graphics course at the University of Victoria was to rotate a number of Bezier curves around an axis and display the result in 3D using a single light source.

This was on Sun Sparcs using X. Since then the program has mutated to match my platform preference at a given time (DOS, Windows, Linux).

The latest mutation has been to SDL/OpenGL and the result runs happily on Linux and Windows. Screenshot junkies might find the following of interest:

TaoCrypt project is a portable, fast, cryptographic library for most needs.
Main features:
- one way hash functions: SHA-1, MD2, MD4, MD5, RIPEMD-160;
- message authentication codes: HMAC;
- block ciphers: DES, Triple-DES, AES, Blowfish, Twofish;
- stream ciphers: ARC4;
- public key cryptography: RSA, DSA, Diffie-Hellman;
- password based key derivation: PBKDF2 from PKCS #5;
- a pseudo random number generator and large integer support.
There is also support for Base 16/64 encoding/decoding, DER encoding/decoding, and X.509 processing.
To build:
./configure
make
To test the build, from the ./test directory run ./test
Enhancements:
- This release includes bugfixes, portability enhancements, and some optimizations.

Tie::HashHistory can track history of all changes to a tied hash.

SYNOPSIS

my $hh = tie %hash => Tie::HashHistory, PACKAGE, ARGS...;

@values = $hh->history(KEY);

Tie::HashHistory interposes itself between your program and another tied hash. Fetching and storing to the hash looks completely normal, but Tie::HashHistory is keeping a record of all the changes to the each key, and can Tie::HashHistory will give you a list of all the values the key has ever had, in chronological order.

The arguments to the tie call should be Tie::HashHistory, and then the arguments that you would have given to tie to tie the hash without the history feature. For example, suppose you wanted to store your hash data in an NDBM file named database. Normally, you would say:

tie %hash => NDBM_File, database, $flags, $mode;

to get this history feature, just add Tie::HashHistory before NDBM_File:

my $hh = tie %hash => Tie::HashHistory,
NDBM_File, database, $flags, $mode;

The data will still be stored in database, and it will still be an NDBM file. All the fetching and storing will look the same, but the change history of each key will be available.
The tie call will return an object; to find out the history of a key, use the history method on this object. It takes one argument, which is a key string. It will return a list of all the values that have ever been associated with the key, in chronological order, starting with the most recent. For example:

$hash{a} = first;
$hash{b} = second;
$hash{a} = third; # Overwrites old value

# Prints "third second" as you would expect
print "$hash{a} $hash{b}n";

@values = $hh->history(a);
# @values now contains (third, first)

@values = $hh->history(b);
# @values now contains (second)

At present, if called in scalar context, the history() method will return the number of items in the history. This behavior may change in future versions.

The underlying hash can be any tied hash class at all. To use a regular in-memory hash, use Tie::StdHash (distributed with Perl) as the underlying implementation:

use Tie::Hash; # *NOT Tie::StdHash*
my $hh = tie %hash => Tie::HashHistory, Tie::StdHash;

This is not as efficient as it could be because fetches and stores on %hash still go through two layers of tieing. I may fix this in a future release.