Free keys software for linux

SSH KeyServer provides a simple key-distribution server for SSH.

ssh-keyserv can be used in trusted networks to centrally generate and distribute SSH keys to other computers.

This is very useful in situations were the computers are reinstalled often and you do not want new SSH keys all the time.

SSH with Keys HOWTO is a document which shows how to use SSH with keys, passphrases, and ssh-agent.

For those of you who have been using SSH for a while, you will probably understand its advantages over the previous telnet style applications such as telnet and remote shell.

Although SSH with keys has always been there, not many people know what it is about, and how you can utilize its strenghts to make your life as a system administrator a bit more easy.

CryptNET Keyserver is an effort to develop an openPGP (RFC2440) compliant public keys server which is licensed under the terms of the GNU GPL.
It is written in C, and runs on Linux. It uses PostgreSQL for key storage, and supports the hkp protocol (it can interface with GnuPG and NAI PGP). The keyserver is mostly functional, and there is a link to a running copy on the homepage.
Main features:
- openPGP (RFC2440) compatible (version 3 and version 4 packets)
- Validate keys packets and subpackets
- Tied to free RDBMS (postgreSQL)
- Interface with programs through standard keyserver interface
- Capable of updating previously stored keys
- Key caching
- Fully multi-threaded
- Fully (cryptographically) validate signatures
- Handle signature expiration
- Handle key expiration and revocation
- Allow users to submit and retrieve keys through web browser
- Allow users to submit and retrieve multiple keys as key ring through web browser
- Synchronize with other keyservers through HTTP protocol (PKS)
Enhancements:
- Feature Request Completed: [ 1000332 ] sigalm to prevent cpu throttle (vab)
- Feature Request Completed: [ 1192629 ] (Optional) Large File Support (vab)
- Fixed Bug: [ 999662 ] Legacy gcc compatibility (pacoje)
- Fixed Bug: [ 999656 ] tcpwrappers problems in-addr.arpa (pacoje)
- Fixed Bug: [ 999925 ] cks import problems (vab)
- Fixed Bug: [ 969089 ] cks_import skips last pubkey in keyring (vab)
- Fixed Bug: [ 999676 ] cks import problems (vab)
- Fixed Bug: [ 966767 ] cks_import race condition on import error (vab)
- Fixed Bug: [ 969739 ] Valgrind: parse_attribute_sub_packets (vab)
- Fixed Bug: [ 969734 ] Valgrind: Memory Violation (vab)
- A context was created to handle state information (vab)
- sql updates (tab vs. spaces bug in formatting of cks.sql.in) (vab)
- General code clean-up (Function Signature Changes) (vab)
- cks_install.pl removed (Integrated into Autoconf/Automake) (vab)
- Fixes to correct most -Wall warnings (vab)
- Fix for memory leak in parse.c (vab)
- Code to force cksd to exit if it is running with root privileges (vab)
- cksd.init rewritten (vab)
- Support of storage of pid in /var/run for init system usage (vab)
- CGI processing code clean-up (vab)
- Creation of etc dir in project root w/ separate Makefile (vab)
- Clean-up of HTML pages (vab)
- Removal of db2 hooks - no longer have access to the software (vab)
- Removal of some out dated documentation (vab)
- Fix for potential read_line race condition (vab)
- Default user for keyserver changed to "cks" (vab)
- Default user for webserver changed to "apache" for Gentoo (vab)
- New hook HTML page for Web Of Trust Information (vab)
- HTML Layout bug fix in keys.c print_uid: echo_signatures (vab)
- SIGPIPE in now ignored. SIGTERM and SIGHUP are now caught (vab)

Sort::Key is the fastest way to sort anything in Perl.

SYNOPSIS

use Sort::Key qw(keysort nkeysort ikeysort);

@by_name = keysort { "$_->{surname} $_->{name}" } @people;

# sorting by a numeric key:
@by_age = nkeysort { $_->{age} } @people;

# sorting by a numeric integer key:
@by_sons = ikeysort { $_->{sons} } @people;

Sort::Key provides a set of functions to sort lists of values by some calculated key value.

It is faster (usually much faster) and uses less memory than other alternatives implemented around perl sort function (ST, GRT, etc.).

Multikey sorting functionality is also provided via the companion modules Sort::Key::Multi, Sort::Key::Maker and Sort::Key::Register.

FUNCTIONS

This module provides a large number of sorting subroutines but they are all variations off the keysort one:

@sorted = keysort { CALC_KEY($_) } @data

that is conceptually equivalent to

@sorted = sort { CALC_KEY($a) cmp CALC_KEY($b) } @data

and where CALC_KEY($_) can be any expresion to extract the key value from $_ (not only a subroutine call).

For instance, some variations are nkeysort that performs a numeric comparison, rkeysort that orders the data in descending order, ikeysort and ukeysort that are optimized versions of nkeysort that can be used when the keys are integers or unsigned integers respectively, etc.

Also, inplace versions of the sorters are provided. For instance

keysort_inplace { CALC_KEY($_) } @data

that is equivalent to

@data = keysort { CALC_KEY($_) } @data

but being (a bit) faster and using less memory.

The full list of subroutines that can be imported from this module follows:

keysort { CALC_KEY } @array

returns the elements on @array sorted by the key calculated applying { CALC_KEY } to them.

Inside { CALC_KEY }, the object is available as $_.

For example:

@a=({name=>john, surname=>smith}, {name=>paul, surname=>belvedere});
@by_name=keysort {$_->{name}} @a;

This function honours the use locale pragma.

nkeysort { CALC_KEY } @array

similar to keysort but compares the keys numerically instead of as strings.

This function honours the use integer pragma, i.e.:

use integer;
my @s=(2.4, 2.0, 1.6, 1.2, 0.8);
my @ns = nkeysort { $_ } @s;
print "@nsn"
prints
0.8 1.6 1.2 2.4 2

rnkeysort { CALC_KEY } @array
works as nkeysort, comparing keys in reverse (or descending) numerical order.
ikeysort { CALC_KEY } @array
works as keysort but compares the keys as integers (32 bits or more, no checking is performed for overflows).
rikeysort { CALC_KEY } @array
works as ikeysort, but in reverse (or descending) order.
ukeysort { CALC_KEY } @array
works as keysort but compares the keys as unsigned integers (32 bits or more).

For instance, it can be used to efficiently sort IP4 addresses:

my @data = qw(1.2.3.4 4.3.2.1 11.1.111.1 222.12.1.34
0.0.0.0 255.255.255.0) 127.0.0.1);

my @sorted = ukeysort {
my @a = split /./;
(((($a[0] name,
$_->middlename },
qw(str str str);

Sort::Key::register_type Color =>
sub { $_->R, $_->G, $_->B },
qw(int int int);

Once a datatype has been registered it can be used in the same way as types supported natively, even for defining new types, i.e.:

Sort::Key::register_type Family =>
sub { $_->man, $_->woman },
qw(Person Person);

KeyTouch is a program which allows you to easily configure the extra function keys of your keyboard. This means that you can define, for every individual function key, what to do if it is pressed.

When you buy a new keyboard a CD-ROM will probably included. This CD-ROM contains software to configure the extra function keys (the image above shows an example of extra function keys) of your keyboard with. The problem however is that most of the times the software is not available for Linux.

KeyTouch is the solution to this problem. It allows you to easily configure the extra funtion keys of your keyboard.

Sort::Key::Top is a Perl module that can select and sort top n elements.

SYNOPSIS

use Sort::Key::Top (nkeytop top);

# select 5 first numbers by absolute value:
@top = nkeytop { abs $_ } 5 => 1, 2, 7, 5, 5, 1, 78, 0, -2, -8, 2;
# ==> @top = (1, 2, 1, 0, -2)

# select 5 first words by lexicographic order:
@a = qw(cat fish bird leon penguin horse rat elephant squirrel dog);
@top = top 5 => @a;
# ==> @top = qw(cat fish bird elephant dog);

The functions available from this module select the top n elements from a list using several common orderings and custom key extraction procedures.

They are all variations around

keytopsort { CALC_KEY($_) } $n => @data;

This function calculates the ordering key for every element in @data using the expression inside the block. Then it selects and orders the $n elements with the lower keys when compared lexicographically.

It is equivalent to the pure Perl expression:

(sort { CALC_KEY($a) cmp CALC_KEY($b) } @data)[0 .. $n-1];

Variations allow to:

- use the own values as the ordering keys
topsort 5 => qw(a b ab t uu g h aa aac);

==> a aa aac ab b
- return the selected values in the original order
top 5 => qw(a b ab t uu g h aa aac);

==> a b ab aa aac
- use a different ordering
For instance comparing the keys as numbers, using the locale configuration or in reverse order:
rnkeytop { length $_ } 3 => qw(a ab aa aac b t uu g h);

==> ab aa aac

rnkeytopsort { length $_ } 3 => qw(a ab aa aac b t uu g h);

==> aac ab aa

A prefix is used to indicate the required ordering:

(no prefix)

lexicographical ascending order

r

lexicographical descending order

l

lexicographical ascending order obeying locale configuration

r

lexicographical descending order obeying locale configuration

n

numerical ascending order

rn

numerical descending order

i

numerical ascending order but converting the keys to integers first

ri

numerical descending order but converting the keys to integers first

u

numerical ascending order but converting the keys to unsigned integers first

ru

numerical descending order but converting the keys to unsigned integers first

The full list of available functions is:

top ltop ntop itop utop rtop rltop rntop ritop rutop

keytop lkeytop nkeytop ikeytop ukeytop rkeytop rlkeytop rnkeytop
rikeytop rukeytop

topsort ltopsort ntopsort itopsort utopsort rtopsort rltopsort
rntopsort ritopsort rutopsort

keytopsort lkeytopsort nkeytopsort ikeytopsort ukeytopsort
rkeytopsort rlkeytopsort rnkeytopsort rikeytopsort rukeytopsort

Rocket project is a game where you try to land a rocket on a moving platform.

Running Rocket:

- Unzip the archive into its own directory.
- cd to the directory.
# perl rocket.pl

You fly the rocket with the left, right, and down keys.

Other keys:

- pause
- exit
- new game
- God mode?

ESE Key Daemon is a multimedia keyboard driver for Linux. No kernel patch is needed.
ESE Key Daemon is a userspace program which pools /dev/input/event interfaces for incoming keyboard key presses.
Enhancements:
- A bug in the configuration file handling routines was fixed.