Free cookie jars software for linux

Auth MemCookie is an Apache v2 authentification and authorization modules are based on "cookie" authentification mecanism.

The module dont make authentification by it self, but verify if authentification "the cookie" are valid for each url protected by the module. The module validate also if the "authentificated user" have authorisation to acces url.

Authentification are made externaly by an authentification form page and all authentification information nessary to the module a stored in memcached indentified by the cookie value "authentification session id" by this login page.

How it Works

Phase 1 : The login Form

Authentification are made by a login formular page.
This login page must authenticate the user with any authenticate source (ldap, /etc/password, file, database....) accessible to langage of the page (php, perl, java... an ldap login page sample in php are in samples directory).

Then must set cookie that contain only a key the "authentification unique id" of the "authentification session".

The login page must store authorisation and user information of the authenticated user in memcached identified by the cookie key "authentification unique id".

The login page can be developted in any langage you want, but must be capable to use memcached (they must have memcache client api for us)

Phase 2 : The Apache v2 Module

After the user are logged, the apache 2 module check on each protected page by apache ACL the presence of the "cookie".

if the "cookie" exist, try to get session in memcached with the "cookie" value if not found return "HTTP_UNAUTHORIZED" page.

if session exist in memcached verify if acl match user session information if not match return "HTTP_FORBIDDEN" page.

Permit Cookies is a Firefox extension that allows you to set cookie permissions for the site you are viewing. Suggested usage: Disable cookies in Tools-Options-Privacy and only permit cookies from sites you trust.

One-JAR is a simple solution to the problem of distributing an application as a single jar file, when it depends on multiple other jar files.

It uses a custom classloader to discover library jar files inside the main jar.

Cookie Button in the status bar is a Firefox button for easy access to cookie permissions in the status bar. For those who have been asking for cookie button in the status bar.

Some features are optional. See Tools -> Extensions/Addons, select Cookie button in the status bar, press Options/Preference Button.

Please post more info about the context menu bug to http://bugzilla.mozdev.org/show_bug.cgi?id=15011

Simple to use, single file with no dependencies, and short learning curve for those times when you dont want or need the swiss army knife of cgi modules.

Synopsis

use CGI::EasyCGI;
my $Page = EasyCGI->new_page("html");
my $Cookie = {Name => "pklogin", Value => {UserName => $Self->{Env}{username}, Password => $Self->{Env}{password}}; $Page->add_cookie($Cookie);
%PKEnv = EasyCGI::cgi_request() or die "No Http Environment";
%Cookies = EasyCGI::get_cookie_list() or die "no cookies";
$SomeCookie = $Cookies{SomeCookieName}; $SomeCookieValue = $$SomeCookie(SomeCookieVariable};
my $Html = "hello world!!"; $Page->append_to_page($Html);
$Page->print_page();

This module handles all the details of sending a document of any content type to a WebBrowser. It also handles retrieving form data from sent via "get" or "post" in regular or multipart/form-data encodings(file uploads). It does this transparently to the user through a single interface. Finally it handles setting and retrieving cookies. It does all this as a standalone module with no dependencies for an easy install.

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.

CGI::Simple is a simple totally OO CGI interface that is CGI.pm compliant.

SYNOPSIS

use CGI::Simple;
$CGI::Simple::POST_MAX = 1024; # max upload via post default 100kB
$CGI::Simple::DISABLE_UPLOADS = 0; # enable uploads

$q = new CGI::Simple;
$q = new CGI::Simple( { foo=>1, bar=>[2,3,4] } );
$q = new CGI::Simple( foo=1&bar=2&bar=3&bar=4 );
$q = new CGI::Simple( *FILEHANDLE );

$q->save( *FILEHANDLE ); # save current object to a file as used by new

@params = $q->param; # return all param names as a list
$value = $q->param(foo); # return the first value supplied for foo
@values = $q->param(foo); # return all values supplied for foo

%fields = $q->Vars; # returns untied key value pair hash
$hash_ref = $q->Vars; # or as a hash ref
%fields = $q->Vars("|"); # packs multiple values with "|" rather than " ";

@keywords = $q->keywords; # return all keywords as a list

$q->param( foo, some, new, values ); # set new foo values
$q->param( -name=>foo, -value=>bar );
$q->param( -name=>foo, -value=>[bar,baz] );

$q->param( foo, some, new, values ); # append values to foo
$q->append( -name=>foo, -value=>bar );
$q->append( -name=>foo, -value=>[some, new, values] );

$q->delete(foo); # delete param foo and all its values
$q->delete_all; # delete everything



$files = $q->upload() # number of files uploaded
@files = $q->upload(); # names of all uploaded files
$filename = $q->param(upload_file) # filename of uploaded file
$mime = $q->upload_info($filename,mime); # MIME type of uploaded file
$size = $q->upload_info($filename,size); # size of uploaded file

my $fh = $q->upload($filename); # get filehandle to read from
while ( read( $fh, $buffer, 1024 ) ) { ... }

# short and sweet upload
$ok = $q->upload( $q->param(upload_file), /path/to/write/file.name );
print "Uploaded ".$q->param(upload_file)." and wrote it OK!" if $ok;

$decoded = $q->url_decode($encoded);
$encoded = $q->url_encode($unencoded);
$escaped = $q->escapeHTML("&);
$unescaped = $q->unescapeHTML("&);

$qs = $q->query_string; # get all data in $q as a query string OK for GET

$q->no_cache(1); # set Pragma: no-cache + expires
print $q->header(); # print a simple header
# get a complex header
$header = $q->header( -type => image/gif
-nph => 1,
-status => 402 Payment required,
-expires =>+24h,
-cookie => $cookie,
-charset => utf-7,
-attachment => foo.gif,
-Cost => $2.00
);
# a p3p header (OK for redirect use as well)
$header = $q->header( -p3p => policyref="http://somesite.com/P3P/PolicyReferences.xml );

@cookies = $q->cookie(); # get names of all available cookies
$value = $q->cookie(foo) # get first value of cookie foo
@value = $q->cookie(foo) # get all values of cookie foo
# get a cookie formatted for header() method
$cookie = $q->cookie( -name => Password,
-values => [superuser,god,my dog woofie],
-expires => +3d,
-domain => .nowhere.com,
-path => /cgi-bin/database,
-secure => 1
);
print $q->header( -cookie=>$cookie ); # set cookie

print $q->redirect(http://go.away.now); # print a redirect header

dienice( $q->cgi_error ) if $q->cgi_error;

CGI::Simple provides a relatively lightweight drop in replacement for CGI.pm. It shares an identical OO interface to CGI.pm for parameter parsing, file upload, cookie handling and header generation. This module is entirely object oriented, however a complete functional interface is available by using the CGI::Simple::Standard module.

Essentially everything in CGI.pm that relates to the CGI (not HTML) side of things is available. There are even a few new methods and additions to old ones! If you are interested in what has gone on under the hood see the Compatibility with CGI.pm section at the end.

In practical testing this module loads and runs about twice as fast as CGI.pm depending on the precise task.