Free dsa software for linux

Bundle::SSH is a Perl bundle to install modules to use SSH from Perl.

SYNOPSIS

First you have to download and expand the PARI itself.
See INSTALL PARI below.
Then:

perl -MCPAN -e force install Bundle::SSH

This bundle defines the modules you need to use SSH from Perl. Thre are two ways to do this. One is using Net::SSH which is a wrapper around the ssh command installed (or not) on your computer. It is simple to install and use but it depends on external executabel and has other drawbacks too. I have included it in this bundle.

The other way which is more involved both in terms of installation and in the way you use it is called Net::SSH::Perl . It is a Perl/C implementation of the SSH protocol.

This module should list all the required modules (and maybe more) to use either of the above way to ssh to another machine. It is organized in a way so it will be able to install everything without the need to install prerequsite modules.

CONTENTS

Net::SSH - independent wrapper around the ssh command
Math::Pari - interface to PARI, testing gave me errors, need force
Class::Loader
Crypt::Random - errors, needed force
Digest::SHA1
Digest::HMAC
Digest::BubbleBabble - it seems that there are very few tests
Digest::MD2
Convert::ASN1
Crypt::Rijndael
Crypt::CBC
Crypt::DES
Crypt::DES_EDE3
Convert::PEM
Data::Buffer
Crypt::DSA
Crypt::DH
String::CRC32
Math::GMP
Compress::Zlib - I think this also needed force but I am not sure
Convert::ASCII::Armour
Crypt::Blowfish
Crypt::Primes - needs force
Sort::Versions
Tie::EncryptedHash
Crypt::RSA - needs force
Net::SSH::Perl - asks, intimate questions, my answereses are [3] and [2]

PDL::IO::Misc is a Perl module with misc IO routines for PDL.

rcols()

Read ASCII whitespaced cols from a file into piddles and perl arrays (also see "rgrep()").

There are two calling conventions - the old version, where a pattern can be specified after the filename/handle, and the new version where options are given as as hash reference. This reference can be given as either the second or last argument.

The default behaviour is to ignore lines beginning with a # character and lines that only consist of whitespace. Options exist to only read from lines that match, or do not match, supplied patterns, and to set the types of the created piddles.
Can take file name or *HANDLE, and if no columns are specified, all are assumed. For the allowed types, see "Datatype_conversions" in PDL::Core.

Options:

EXCLUDE or IGNORE - ignore lines matching this pattern (default /^#/).
INCLUDE or KEEP - only use lines which match this pattern (default ).
LINES - which line numbers to use. Line numbers start at 0 and the syntax is a:b:c to use every cth matching line between a and b (default ).
DEFTYPE - default data type for stored data (if not specified, use the type stored in $PDL::IO::Misc::deftype, which starts off as double).
TYPES - reference to an array of data types, one element for each column to be read in. Any missing columns use the DEFTYPE value (default []).
PERLCOLS - an array of column numbers which are to be read into perl arrays rather than piddles. References to these arrays are returned after the requested piddles (default undef).

Usage:

($x,$y,...) = rcols( *HANDLE|"filename", { EXCLUDE => /^!/ },
$col1, $col2, ... )
($x,$y,...) = rcols( *HANDLE|"filename", $col1, $col2, ...,
{ EXCLUDE => /^!/ } )
($x,$y,...) = rcols( *HANDLE|"filename", "/foo/", $col1, $col2, ... )

e.g.,

$x = PDL->rcols file1;
($x,$y) = rcols *STDOUT;

# read in lines containing the string foo, where the first
# example also ignores lines that with a # character.
($x,$y,$z) = rcols file2, 0,4,5, { INCLUDE => /foo/ };
($x,$y,$z) = rcols file2, 0,4,5,
{ INCLUDE => /foo/, EXCLUDE => };

# ignore the first 27 lines of the file, reading in as ushorts
($x,$y) = rcols file3, { LINES => 27:-1, DEFTYPE => ushort };
($x,$y) = rcols file3,
{ LINES => 27:, TYPES => [ ushort, ushort ] };

# read in the first column as a perl array and the next two as piddles
($x,$y,$name) = rcols file4, 1, 2, { PERLCOLS => [ 0 ] };
printf "Number of names read in = %dn", 1 + $#$name;

Notes:

1. Quotes are required on patterns.
2. Columns are separated by whitespace by default, use $PDL::IO::Misc::colsep to specify an alternate separator.
3. For PDL-2.003, the meaning of the c value in the LINES option has changed: it now only counts matching lines rather than all lines as in previous versions of PDL.
4. LINES => -1:0:3 may not work as you expect, since lines are skipped when read in, then the whole array reversed.

wcols()

Write ASCII whitespaced cols into file from piddles efficiently.
If no columns are specified all are assumed. Will optionally only process lines matching a pattern. Can take file name or *HANDLE, and if no file/filehandle is given defaults to STDOUT.

Options:

HEADER - prints this string before the data. If the string is not terminated by a newline, one is added (default ).

Usage: wcols $piddle1, $piddle2,..., *HANDLE|"outfile", [%options];

e.g.,

wcols $x, $y+2, foo.dat;
wcols $x, $y+2, *STDERR;
wcols $x, $y+2, |wc;
wcols $a,$b,$c; # Orthogonal version of print $a,$b,$c :-)

wcols "%10.3f", $a,$b; # Formatted
wcols "%10.3f %10.5g", $a,$b; # Individual column formatting

wcols $a,$b, { HEADER => "# a b" };

Note: columns are separated by whitespace by default, use $PDL::IO::Misc::colsep to specify an alternate separator.

swcols()

generate string list from sprintf format specifier and a list of piddles
swcols takes an (optional) format specifier of the printf sort and a list of 1d piddles as input. It returns a perl array (or array reference if called in scalar context) where each element of the array is the string generated by printing the corresponding element of the piddle(s) using the format specified. If no format is specified it uses the default print format.

Usage: @str = swcols format, pdl1,pdl2,pdl3,...;

or

$str = swcols format, pdl1,pdl2,pdl3,...;

rgrep()

Read columns into piddles using full regexp pattern matching.

Options:

UNDEFINED: This option determines what will be done for undefined values. For instance when reading a comma-separated file of the type 1,2,,4 where the ,, indicates a missing value.

The default value is to assign $PDL::undefval to undefined values, but if UNDEFINED is set this is used instead. This would normally be set to a number, but if it is set to Bad and PDL is compiled with Badvalue support (see "" in PDL::Bad) then undefined values are set to the appropriate badvalue and the column is marked as bad.

DEFTYPE: Sets the default type of the columns - see the documentation for "rcols()"

TYPES: A reference to a Perl array with types for each column - see the documentation for "rcols()"

BUFFERSIZE: The number of lines to extend the piddle by. It might speed up the reading a little bit by setting this to the number of lines in the file, but in general "rasc()" is a better choice

Usage

($x,$y,...) = rgrep(sub, *HANDLE|"filename")

e.g.

($a,$b) = rgrep {/Foo (.*) Bar (.*) Mumble/} $file;

i.e. the vectors $a and $b get the progressive values of $1, $2 etc.

rdsa()

Read a FIGARO/NDF format file.

Requires non-PDL DSA module. Contact Frossie (frossie@jach.hawaii.edu) Usage:
([$xaxis],$data) = rdsa($file)
$a = rdsa file.sdf

Not yet tested with PDL-1.9X versions

isbigendian()

Determine endianness of machine - returns 0 or 1 accordingly

rasc()

Simple function to slurp in ASCII numbers quite quickly, although error handling is marginal (to nonexistent).

$pdl->rasc("filename"|FILEHANDLE [,$noElements]);
Where:
filename is the name of the ASCII file to read or
open file handle
$noElements is the optional number of elements in the file to read.
(If not present, all of the file will be read to fill up $pdl).
$pdl can be of type float or double for more precision.
# (test.num is an ascii file with 20 numbers. One number per line.)
$in = PDL->null;
$num = 20;
$in->rasc(test.num,20);
$imm = zeroes(float,20,2);
$imm->rasc(test.num);

rcube

Read list of files directly into a large data cube (for efficiency)

$cube = rcube &reader_function, @files;
$cube = rcube &rfits, glob("*.fits");

This IO function allows direct reading of files into a large data cube, Obviously one could use cat() but this is more memory efficient.

The reading function (e.g. rfits, readfraw) (passed as a reference) and files are the arguments.

The cube is created as the same X,Y dims and datatype as the first image specified. The Z dim is simply the number of images.

MUltihost SSH Wrapper is a shell script that allows you to execute a command or script over SSH on multiple hosts with one command. When possible, it will use ssh-agent and RSA/DSA keys to minimize the need to enter your password more than once.
Enhancements:
- An error is now avoided when someone hits CTRL- and there are no .active files.
- A man page was added.
- ssh timeout was added.

JSch is a pure Java implementation of SSH2.
JSch project allows the user to connect to an sshd server and use port forwarding, X11 forwarding, file transfer, etc., and you can integrate its functionality into your own Java programs. JSch is licensed under BSD style license.
Our intension in developing this stuff is to enable users of our pure java X servers, WiredX and WeirdX, to enjoy secure X sessions. Our efforts have mostly targeted the SSH2 protocol in relation to X window system and X11 forwarding. Of course, we are also interested in adding other functionality - port forward, file transfer, terminal emulation, etc.
Needless to say, SSH provides support for secure remote login, secure file transfer, and secure TCP/IP and X11 forwarding. It can automatically encrypt, authenticate, and compress transmitted data.
The SSH protocol is available in two incompatible varieties: SSH1 and SSH2. SSH2 was invented to avoid the patent issues regarding RSA (RSA patent has expired), and to fix some data integrity problem that SSH1 has, and for a number of other technical reasons.
SSH2 protocol has been standardized on IETF Secure Shell working group and drafts related to SSH2 protocol are available on the web. In developing JSch, we are now referring to following documents:
SSH Protocol Architecture
SSH Transport Layer Protocol
Diffie-Hellman Group Exchange for the SSH Transport Layer Protocol
SSH Connection Protocol
SSH Authentication Protocol
Main features:
- JSch is in pure Java, but it depends on JavaTM Cryptography Extension (JCE). JSch is know to work with:
- J2SE 1.4.0 or later (no additional libraries required).
- J2SE 1.3 and Suns JCE reference implementation that can be obtained at http://java.sun.com/products/jce/.
- J2SE 1.2.2 and later and Bouncycastles JCE implementation that can be obtained at http://www.bouncycastle.org/.
- SSH2 protocol support.
- Key exchange: diffie-hellman-group-exchange-sha1, diffie-hellman-group1-sha1
- Cipher: blowfish-cbc, 3des-cbc, aes128-cbc,aes192-cbc,aes256-cbcnew!
- MAC: hmac-md5, hmac-sha1, hmac-md5-96, hmac-sha1-96
- Host key type: ssh-dss,ssh-rsa
- Userauth: password
- Userauth: publickey(DSA,RSA)
- Userauth: keyboard-interactive
- X11 forwarding
- xauth spoofing
- connection through HTTP proxy.
- connection through SOCKS5 proxy.
- port forwarding.
- stream forwarding.
- signal sending. The unofficial patch for sshd of openssh will be found in this thread.
- remote exec.
- generating DSA and RSA key pairs.
- changing the passphrase for a private key.
- partial authentication
- SSH File Transfer Protocol(version 0, 1, 2, 3)
- packet compression. JZlib has been used.
- JSch is licensed under BSD style license.
Enhancements:
- bugfix: freeze in diffie-hellman-group-exchange-sha1. FIXED. By the default, diffie-hellman-group1-sha1 will be used and if you have not chosen diffie-hellman-group-exchange-sha1 explicitly, you dont have to worry about it.
- bugfix: there should be timeout mechanism in opening a socket for remote port forwarding. FIXED. At the failure or timeout, SSH_MSG_CHANNEL_OPEN_FAILURE will be sent to sshd.
- bugfix: there should be timeout mechanism in opening a socket for X11 forwarding. FIXED. At the failure or timeout, SSH_MSG_CHANNEL_OPEN_FAILURE will be sent to sshd.

pam_usb is a PAM modules that enables either two-factor or password-less authentication using an USB storage device (such as an USB Flash Memory Token).
It can work with any PAM enabled program, such as login, su, gdm/kdm/xdm, xlock...
This is done with a pair of DSA keys, the private one is stored on the device and the public one on the computer.
Whenever a user tries to authenticate, pam_usb will try to find the usb device and will load the private key.
Then it will compute a private/public key signing challenge using the public key contained in the users home directory.
Then, if configured in two-factor mode (additional mode, in the documentation), a password is asked to the user in order to finish the authentication. Otherwise, if configured in password-less mode (alternative / unique in the documentation) it will log in the user without asking any password.
It can also work using any kind of mountable devices such as floppy disks or cd-roms. To improve security, it supports private key encryption and serial number access list.
Sorry for the poor informations provided here but the website is being redesigned.
Enhancements:
- A security issue related to OpenSSH authentication has been fixed.
- The quiet option has been fixed (now it is really quiet).
- Support has been added for devices without vendor/model information.

The OpenSSL Project is a collaborative effort to develop a robust, commercial-grade, full-featured, and Open Source toolkit implementing the Secure Sockets Layer (SSL v2/v3) and Transport Layer Security (TLS v1) protocols as well as a full-strength general purpose cryptography library.
OpenSSL project is managed by a worldwide community of volunteers that use the Internet to communicate, plan, and develop the OpenSSL toolkit and its related documentation.
OpenSSL is based on the excellent SSLeay library developed by Eric A. Young and Tim J. Hudson. The OpenSSL toolkit is licensed under an Apache-style licence, which basically means that you are free to get and use it for commercial and non-commercial purposes subject to some simple license conditions.
Main features:
- Creation of RSA, DH and DSA key parameters
- Creation of X.509 certificates, CSRs and CRLs
- Calculation of Message Digests
- Encryption and Decryption with Ciphers
- SSL/TLS Client and Server Tests
- Handling of S/MIME signed or encrypted mail

The keychain script makes handling RSA and DSA keys both convenient and secure.
Many of us use the excellent OpenSSH as a secure, encrypted replacement for the venerable telnet and rsh commands. One of OpenSSHs (and the commercial SSH2s) intriguing features is its ability to authenticate users using the RSA and DSA authentication protocols, which are based upon a pair of complementary numerical "keys". And one of the main appeals of RSA and DSA authentication is the promise of being able to establish connections to remote systems without supplying a password.
The keychain script makes handling RSA and DSA keys both convenient and secure. It acts as a front-end to ssh-agent, allowing you to easily have one long-running ssh-agent process per system, rather than per login session. This dramatically reduces the number of times you need to enter your passphrase from once per new login session to once every time your local machine is rebooted.
Keychain was first introduced in a series of IBM developerWorks articles. The first article introduces the concepts behind RSA/DSA key authentication and shows you how to set up primitive (with passphrase) RSA/DSA authentication. The second article shows you how to use keychain to set up secure, passwordless ssh access in an extremely convenient way. keychain also provides a clean, secure way for cron jobs to take advantage of RSA/DSA keys without having to use insecure unencrypted private keys. The third article shows you how to use ssh-agent for authentication forwarding mechanism.
Current versions of keychain are known to run on Linux, BSD, Cygwin, Tru64 UNIX, HP-UX, Mac OS X, and Solaris using whatever variant of Bourne shell you have available.
Enhancements:
- Keychain 2.5.4.1 fixes a minor bug introduced in 2.5.4 that resulted in always
- exiting with non-zero status.