Free keys to software for linux

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.

KeyNote is a simple and flexible trust-management system designed to work well for applications.

Trust management, introduced in the PolicyMaker system [BFL96], is a unified approach to specifying and interpreting security policies, credentials, and relationships; it allows direct authorization of security-critical actions. A trust-management system provides standard, general-purpose mechanisms for specifying application security policies and credentials. Trust-management credentials describe a specific delegation of trust and subsume the role of public key certificates; unlike traditional certificates, which bind keys to names, credentials can bind keys directly to the authorization to perform specific tasks.

A language for describing `actions, which are operations with security consequences that are to be controlled by the system.
A mechanism for identifying `principals, which are entities that can be authorized to perform actions.
A language for specifying application `policies, which govern the actions that principals are authorized to perform.
A language for specifying `credentials, which allow principals to delegate authorization to other principals.
A `compliance checker, which provides a service to applications for determining how an action requested by principals should be handled, given a policy and a set of credentials.

The trust-management approach has a number of advantages over other mechanisms for specifying and controlling authorization, especially when security policy is distributed over a network or is otherwise decentralized.

Trust management unifies the notions of security policy, credentials, access control, and authorization. An application that uses a trust- management system can simply ask the compliance checker whether a requested action should be allowed. Furthermore, policies and credentials are written in standard languages that are shared by all trust-managed applications; the security configuration mechanism for one application carries exactly the same syntactic and semantic structure as that of another, even when the semantics of the applications themselves are quite different.

Trust-management policies are easy to distribute across networks, helping to avoid the need for application-specific distributed policy configuration mechanisms, access control lists, and certificate parsers and interpreters.

For a general discussion of the use of trust management in distributed system security, see [Bla99].

KeyNote is a simple and flexible trust-management system designed to work well for a variety of large- and small- scale Internet-based applications. It provides a single, unified language for both local policies and credentials. KeyNote policies and credentials, called `assertions, contain predicates that describe the trusted actions permitted by the holders of specific public keys. KeyNote assertions are essentially small, highly-structured programs. A signed assertion, which can be sent over an untrusted network, is also called a `credential assertion. Credential assertions, which also serve the role of certificates, have the same syntax as policy assertions but are also signed by the principal delegating the trust.

In KeyNote:

Actions are specified as a collection of name-value pairs.
Principal names can be any convenient string and can directly represent cryptographic public keys.
The same language is used for both policies and credentials.
The policy and credential language is concise, highly expressive, human readable and writable, and compatible with a variety of storage and transmission media, including electronic mail.
The compliance checker returns an application-configured `policy compliance value that describes how a request should be handled by the application. Policy compliance values are always positively derived from policy and credentials, facilitating analysis of KeyNote-based systems.
Compliance checking is efficient enough for high-performance and real-time applications.

This document describes the KeyNote policy and credential assertion language, the structure of KeyNote action descriptions, and the KeyNote model of computation.

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

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 makes it possible to easily configure the extra function keys of a keyboard (like multimedia keys). keyTouch it allows the user to define which program will be executed when a key is pressed.

Tie::ListKeyedHash is a system allowing the use of anonymous arrays as keys to a hash.

SYNOPSIS

use Tie::ListKeyedHash;

[$X =] tie %hash, Tie::ListKeyedHash;


my $live_key = [key,items,live];
$hash{$live_key} = Hello!;

$hash{[key,trees,grow]} = Goodbye!;

print $hash{[key,items,live]},"n";
delete $hash{$live_key};

my @list = keys %{$hash{[key]}};
print "@listn";

untie %hash ;

Alternatively keys are accessible as:

$hash{key,items,live} = Hello!;

(a bare list/array for the key rather than using an anon list/array reference).

But that slows down the accesses by around 10% and cannot be used for keys that conflict with the value of the $; special variable.

Also usable via the object interface methods put, get,exists,delete,clear. The object interface is about 2x as fast as the tied interface.

Tie::ListKeyedHash ties a hash so that you can use a reference to an array as the key of the hash. It otherwise behaves exactly like a normal hash (including all caveats about trying to use a key as both a hash reference and a scalar value).

This frees you from needing to hardwire hash references in code or having to write tree traversal code to reach arbitrary points in a hash tree.
Example:
########################

#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper;

use Tie::ListKeyedHash;

my %example;
tie (%example, Tie::ListKeyedHash);

%example = (
a => {
b0 => {
c => value of c,
d => value of d,
e => {
f => value of f,
},
},
b1 => {
g => value of g,
},
},
h => r,
);

my $b_key = [a,b0];

my $d_key = [@$b_key,d];
my $d = $example{$d_key};
print "d = $dn";

my $e_key = [@$b_key, e];
my $e = $example{$e_key};
print e = . Dumper ($e);

my $f_key = [@$b_key, e,f];
my $f = $example{$f_key};
print "f = $fn";

my $h_key = [h];
my $h = $example{$h_key};
print "h = $hn";

########################

The virtues of this particular way of accessing hash-of-hashes (HoH) vs bare hardwired derefererences or tree crawling are as follows:

1) As the number of levels in a HoH increases, the tied object asymptotically approaches the speed of hardwired hash dereferencing without the loss of flexibility penalty of having to hardwire the keys into code in advance.
This gives an important property that it gets faster the deeper a HoH becomes as compared with the speed of software driven tree traveral.
So you can build and access arbitrarily structured HoH and still access deeply buried elements in the tree quickly.
2) The format was designed to use memory efficiently. It takes only a few hundred extra bytes over the size of an untied HoH in memory or when serialized (via Data::Dumper or Storable for example) regardless of how deep the hash is.
3) A reference to an existing HoH can be passed into Tie::ListKeyedHash->new and all of the OO key lists access methods will "just work".

Example:

use Tie::ListKeyedHash;

my %hash = ( a => { b => c } );
my $obj = Tie::ListKeyedHash->new(%hash);

my $b_value = $obj->get([a,b]);

aeswepd is UNIX daemon for changing WEP keys of WLAN devices in constant intervals. The WEP keys are calculated by encrypting the current UNIX time using the AES cypher with a given constant key. aeswepd strengthens the security of the weak hardware based, standards compliant WEP technology.

aeswepd may use up to three hardware WEP keys: the first is set to the current, the second to the previous and the third to the next key. This is useful when working with not completely synchronized RTCs. If only a single hardware WEP key is used, you have to synchronize your RTCs so that no connectivity interrupts may occur.

aeswepd has several advantages over other solutions to improve WEP: it is easy to use, doesnt involve computing intensive algorithms, doesnt increase traffic latency. On the other hand it has several disadvantages as well: it requires an installation of aeswepd on all network members, it is not standardized, currently only APs which run a flavour of Linux may be used with it.