Free 9.25 x 2.25 cubical sign software for linux

This project provides software suitable for smartcard based digital signature and both local and remote authentication security services. It can also be used to integrate smart card technology into a working Certification Authority that issues public key certificates for the users through the web.

For example, we provide a module that is known to work with the OpenCA Certification Authority for on-board keypair generation.

Our software works with different kinds of smart cards. Actually we have modules that work with Schlumberger Cyberflex Access 16K and Cryptoflex 16K smart cards and any Java Card 2.1.1 compliant smart card (i.e. both Schlumberger Cyberflex Access 32K and Gemplus GemXpresso 211/PK).

Our software has been developed and tested with Towitokos CHIPDRIVE and Schlumbergers Reflex 72 card readers. It is known to work fine with Gemplus GCR410, GCR400FD, GemPC and Microsystems SCM readers too.

Here are some of its functionalities:

automatic storing of private key and public certificate on the smartcard during the interaction with OpenCA for the "certification process"
use of smartcard to sign e-mail and e-news from within Netscape Messenger
use of smartcard to sign/verify every kind of file with a simple shell command
smartcard-based authentication of local users to a system by means of a public key authentication protocol
smartcard-based authentication of remote users to a system by means of a smart card enabled OpenSSH
interactive command line browsing and invoking of all supported card commands for Cyberflex cards (ISO 7816 compliant and not)

Mamory is a set of usefull functions for emulators related projects.
Mamory project allows easy inclusion of roms management features into these projects through a simple API.
The distributed packages also contain a command line interface that use the potential of the library libmamory.so.
Enhancements:
- The embedded expat library has been removed: this release requires that expat is installed on your system.

orbitclock displays a small circular representation of a clock in a pseudo-Star-Trek style.

Nifty little Star-Trek-ish clock display. Resizable, but some of the parameters in the code may need to be tweaked to make it look good at other sizes.

Feel free to play with the parameters at the top of draw() and the colors. Let me know if you get something niftier.

Usage:

orbitclock [options]
-geometry WxH[+X+Y] set window geometry
-bg < color name > background color
-fg < color name > foreground 1 color (tick)
-fg2 < color name > foreground 2 color (block)
-rings < hms|smh|etc. > ordering of rings from inside out (default hms)
-font < font > font to use for date (implies -date)
-date[=optional format] draw date in center, strftime format string literal n causes line break example: -date="%m/%d/%Yn%H:%M:%S" equals sign is REQUIRED, dont ask me why.

Module::Signature is a Perl module signature file manipulation.

SYNOPSIS

As a shell command:
% cpansign # verify an existing SIGNATURE, or
# make a new one if none exists

% cpansign sign # make signature; overwrites existing one
% cpansign -s # same thing

% cpansign verify # verify a signature
% cpansign -v # same thing
% cpansign -v --skip # ignore files in MANIFEST.SKIP

% cpansign help # display this documentation
% cpansign -h # same thing
In programs:
use Module::Signature qw(sign verify SIGNATURE_OK);
sign();
sign(overwrite => 1); # overwrites without asking

# see the CONSTANTS section below
(verify() == SIGNATURE_OK) or die "failed!";

Jar::Signer Perl module ease the process of creating a signed Jar file.

SYNOPSIS

# using FindBin is just a suggestion.
use FindBin qw( $RealBin );
use Jar::Signer;
my $signer = Jar::Signer->new;
# location of the keystore, created if needed.
$signer->keystore("$RealBin/MyKeyStore");
# dname properties of the certificate.
$signer->dname("CN=Mark Southern, O=My Corporation, L=My State, C=USA");
# name for .fingerprint and ..cert files, created if needed.
$signer->alias("$RealBin/MyCert");
# the Jar file that we want to sign.
$signer->jar(shift);
# if signed_jar is undefined then the default is basename.signed.jar where basename is the basename of the Jar file.
$signer->signed_jar(shift);
# create the signed Jar.
$signer->process;

This module, and the script that uses it make it a lot simpler to generate signed Jar files for use in Java applets etc. It steps through all the needed jar, jarsigner and keytool command lines.

Zapping VBI library provides routines to read from raw Vertical Blanking Interval capture devices, to demodulate raw to sliced VBI data, and to interpret the data of several popular services.
Basically, it offers all the functionality needed by a VBI application except for the UI.
Main features:
- Captures raw VBI samples from V4L, V4L2 (Linux 2.6) and FreeBSD BKTR devices, sliced VBI data from Linux DVB devices
- Implements a VBI Proxy to share one VBI device between multiple applications
- Has a robust and versatile bit slicer which handles a wide range of data services
- Functions to capture multiple data services at once, such as Closed Caption (both NTSC and PAL), Teletext, VPS, WSS, XDS
- Level 3.5 Teletext decoder with support for all Teletext character sets, graphics, 4096 colors, with built-in page cache including search functions
- Closed Caption decoder which supports roll-up, pop-up and paint-on style caption, color, expanded character set, text attributes and free text placement
- Renders Teletext and Caption pages, can export to HTML, PNG and other formats
- Can determine network names
- Can find Teletext subtitle and program pages
- Functions to extract data transmissions in Teletext streams (currently Page Format Clear and Independent Data Line Format A)

sign is a file signing and signature verification utility. Its main purpose is to be a simple and convenient extension to a tar/gz/bzip2 line of tools to check file integrity and authenticity. Its small and simple, it does just one thing and hopefully does it well.

I needed a tool to digitally sign a bunch of .tar.gz and to allow recepients of the files to easily check, unzip, untar and start enjoying the content as quickly and painlessly as possible.

There are OpenSSL, GnuPG, PGP and others and they are of course perfectly capable of file signing. OpenSSL is probably the most widely spread one and best suited for the role of being a universal signing utility. However the state of affairs is such that OpenSSL as an application is not really used for anything more than generating tarball MD5 hashes. The other packages are plain big and complex for a simple task of file integrity checking. Its like getting a professional sound editing suite instead of a dead-simple .mp3 player. The larger crypto-packages also tend to lack modularity in a sense that to get file signing working I would need to configure a handful of core, but otherwise unrelated settings first. Besides if I am not going to use anything but a signing code, the rest will be sitting there collecting dust, creating untrivial shared libraries dependencies and a general feeling of a wasted disk space.

First of all, sign is a file processing tool, it reads from the files (including stdin) and writes to the files (including stdout). It can be used to attach signatures to the files or to verify and/or strip them.

Between signing and verifying latter will account for a bulk of usage. When checking the signature, sign will check for both integrity and authenticity of the file. An integrity check is done by validating SHA-1 hash embedded into the signature, and an authenticity is ensured by checking signers credentials against a trusted list.

sign adopts OpenSSH-style authentication model, where the trust hierarchy is flat (no certificates), an authentication is done with public keys and the list of trusted keys is grown gradually on as-needed basis.

Every trusted key is associated with a file name prefix called the title. The key can be trusted for signing files, whose name start with keys title. The same key may be associated with more than one title, but not vice versa.

The signature is appended at the end of the file and it carries three bits of information - the title, the public key of the signer and the hash of all preceeding data encrypted with signers private key. The verification is performed as follows:

The filename is checked to start with a title
The hash is decrypted using the public key
The hash is compared to the locally computed value (this ensures integrity)
The title is looked up locally; if its known and associated public key is the same as in the signature, the file is deemed authentic.
Otherwise if the title is known, but the key is different, the file is considered to be signed by untrusted, impersonating party and the check fails.
And lastly, if the title is unknown, the authenticity of the file cannot be established. The user is provided with public key fingerprint, which should be manually authenticated. Then the title and the key are added to the trusted list; and subsequent signatures from the this signer for this particular title will be cleared automatically.

In order to sign files, the signing keypair must first be generated. The keypair is maintained on per-user basis and can be created by running sign with a special command-line flag. The signing process itself is as follows (give or take insignificant details):

Run the filename through a list of owned titles and find the best match. Alternately accept explicit title from the user using one of the command-line flags.
Attach the title, attach public signing key
Compute the hash, encrypt it with private signing key
Attach encrypted hash.

For details on command-line syntax and other operating parameters, please refer to a man page; an online version is here.