Free identity software for linux

User::Identity::Archive is a base class for archiving user information.

INHERITANCE

User::Identity::Archive
is a User::Identity::Item

User::Identity::Archive is extended by
User::Identity::Archive::Plain

SYNOPSIS

use User::Identity::Archive::Plain;
my $friends = User::Identity::Archive::Plain->new(friends);
$friends->from(*FH);
$friends->from(.friends);

An archive stores collections. It depends on the type of archive how and where that is done. Some archivers may limit the kinds of selections which can be stored.

Host Identity Protocol on Linux is an implemetation of the Host Identity Protocol (HIP) and the related architecture. Host Identity Protocol (HIP) is a proposal to change the TCP/IP stack to securely support mobility and multi-homing.
Additionally, it provides for enhanced security and privacy and advanced network concepts, such as moving networks and mobile ad hoc networks. HIP is "cool", which means that as a mobile VPN solution, when your network interfaces go up or down, there is no need to re-establish a secure tunnel.
Enhancements:
- The implementation was moved from kernel to user space.
- Support for the Nokia 770 Linux PDA (ARM) was added.

Antispyd is a HTTP/HTTPS proxy server designed to be fast, efficient, modular and secure. Its written in pure C and uses a simple and customizable configuration file. Its POSIX compliant and has been developed under Gentoo/Linux.
The server is designed with a modular software architecture, the following filters can be used and configured independently :
Url Filtering
Mime-type Filtering
Web-Identity Masking
Shellcode and Zero-day threat Filtering
Cookie Removal
Simple Signature based Filtering
Inappropriate content Blocking
Pop-up Deleting
So, Antispyd can be used to satisfy some current companys security needs like :
Web Usage Policy establishment
Instant Messaging control
Peer-to-Peer Filtering
Malware Protection
Enhancements:
- This release provides a major improvement of the signature based filtering engine (the BLOCK_SIGN filter) in terms of both performance and functionality.
- The signatures are now stored in a 3-Tree to enhance the matching of each HTTP message.
- This filtering can be performed on each HTTP messages content.
- A signature can use the hexadecimal array of a byte to specify a fields value

Gentle.NET is an RDBMS independent object persistence framework. Gentle.NET features automatic SQL generation and object construction, an SQL factory for creating custom queries, DataView construction helpers, excellent performance and reasonably complete docs.
The framework defines a few attributes with which you have to decorate the objects you wish to persist. Decorate classes with the TableName attribute, and members (properties and fields as you see fit) with the TableColumn attribute.
There are additional attributes available which need only be used when no Analyzer class exists for the database you are using (see Database Provider - Implementation Status). The Analyzer classes are used to obtain metadata on the current schema directly from the database, thus bypassing the need for replicating this information in your code.
If no Analyzer exists, primary key columns must be decorated with the PrimaryKey attribute, and foreign keys and their mappings must be declared using the ForeignKey attribute. The TableColumn attribute provides properties allowing you to provide details on type, size and null-handling. If an Analyzer does exist, the information obtained automatically overrides any such setting.
Business objects may optionally inherit from the Persistent class, which provides a set of standard methods for persisting and retrieving objects. You can replicate these on a different base class if needed, or on a manager class if you prefer a more SOA-oriented design. Gentle provides support for identity columns (where the database assigns a primary key value to the row being inserted) to implementors of IPersistent (which includes the Persistent class).
The main access point into the framework functionality is provided by the PersistenceBroker class, which is responsible for orchestrating all access to a given database provider.
The PersistenceBroker is responsible for basic query construction and caching, as well as interaction with the database backends. You can create as many PersistenceBroker instances as needed, such as one for every database to which you need to connect. Various classes permit or require you to pass a PersistenceBroker instance, which will be used subsequently for all database operations performed by the class.
If you need to connect to a single database only, you can use the static Broker class, which delegates all calls to a default PersistenceBroker instance (using the DefaultProvider configured in the configuration file).
Persistent objects are identified by a Key, which is really just a Hashtable with some convenient methods for gathering property values from objects. The Key class knows how to populate itself when given an object instance and a set of property names, and also provides a means of obtaining a key holding just the primary key fields.
This is useful when constructing custom queries as constraints can be passed as Key instances to methods on both the (Persistence)Broker and SqlBuilder classes. This encapsulation also enables Gentle to work with multi-column primary keys.
To execute custom SQL statements use the SqlStatement class. Use the SqlBuilder class to construct instances of this class whenever the statement is for a supported type (i.e. a class decorated with the proper attributes as outlined above).
The SqlBuilder provides a database independent way of constructing queries and has many methods for adding constraints and otherwise customizing the query. It is used internally by the PersistenceBroker whenever it needs to generate statements.
You can declare a DataView layout using the CustomView attribute on the properties to include in the DataView. The actual DataView can be obtained using the ObjectView class by supplying an array of business objects.
Multiple statements can be transacted (grouped) using the Transaction class.
Enhancements:
- This release features a complete rewrite of the cache subsystem, with significant performance improvements as a result.
- There have also been several minor improvements and bugfixes throughout the code base.

mod_auth_openid is an authentication module for the Apache 2 Web server. It handles the functions of an OpenID consumer as specified in the OpenID 1.1 specification.

Once installed, a simple configuration directive can secure a directory or application on your Web server and require a valid OpenID identity. You can configure trusted/untrusted identity providers along with a number of other options.

Compile

Enter the mod_auth_openid directory and type:

./configure

You can use the following to see additional configuration options:

./configure --help

Then:

make
su root
make install

Depending on where you specify your AuthOpenIDDBLocation (see below), you may need to touch the db file as the user thats running Apache (or chown the directory its being stored in). For instance:

# /tmp/mod_auth_openid.db is the default location for the DB
su root
touch /tmp/mod_auth_openid.db
chown www-data /tmp/mod_auth_openid.db

Come And Go Encryption provides an encryption program based off one-time pads.
Cum And Go Encryption is a very basic program to encrypt or decrypt a program using a variant of the one-time pad. This allows for almost uncrackable encryption.
Why is it still crackable? The program uses one relatively small key to XOR the contents of another file, encrypting it.
A one-time pad uses a very large key (about the same size as the file/data to encrypt) and is completely random. Still, the encryption is good enough to mask the identity of a program or document, or stop someone from accessing that document or program.
The origins of this program were an effort to stop a specific kind of movie and image from being viewed normally.
Installing is a breeze: simply run the program. Put it anywhere you like, it wont matter as long as you put the full path to the program to encrypt/decrypt.
Run the program to see a basic description of its use.
This program works very well in windows but was designed for use in Linux/UNIX. The stdout option allows for decryption to standard output, allowing one to pipe the programs decrypted data to another program.
This could be used to view an encrypted movie without having to write the whole movie to disk; the only problem with this is that on some Operating Systems pipes are slow and inefficient, especially with a high-bitrate movie. Steps will be taken to speed this up in the future.
Enhancements:
- Fix password use so the password is not shown in "encrypted" files
- Use an actual encryption method, and not a cheesy XOR
- Adapt CAG to use modules such as SHA, Crypt, MD5, and others

Enigform is a Mozilla Firefox extension that provides you the ability to digitally sign HTTP GET and POST requests, even those generated via AJAX calls. The project implements the mechanism described in the white paper entitled OpenPGP based Identity and Data Authentication for HTTP POST payload by Arturo Buanzo Busleiman. Okay, me.
This extension is focused on adding an extra layer of security to the payload of HTTP POST requests. There is also a great extension called Enigmail that enhances Mozilla Thunderbird with PGP capabilities. You can check out Enigmail at its Mozdev Page.
For years different methods for User Authentication and Session Management have been implemented:
- HTTP Authentication
- Cookies
- GET/POST values
- SSL Certificates
- A combination of all the above.
Regarding SMTP, e-mail has been digitally signed for a long time now, and it is a standard. Extending its usage to the HTTP protocol sounded like a natural idea, specially at 3am when I woke up with a OpenPGP-signed HTTP POST request in my head.
By having the GET query string and the POST payload ("variable=test") signed using an ASCII armored, Clearsign, OpenPGP based procedure, the browsing user can provide Identity and Data Authentication to that payload, thus adding all OpenPGP benefits to the HTTP protocol.
This allows web developers to add a new layer of security to their applications, and if correctly implemented will render man in the middle attacks useless. The direct benefit of implementing this extension is that web developers will be able to verify the payloads signature, potentially avoiding obscure session management, and/or complicated login procedures.
For example, Highly Secure Home Banking sites could be created by using Enigform + some simple server side code.