Free spike software for linux

Spike Proxy is an open source HTTP proxy for finding security flaws in web sites.

SPIKE Proxy is part of the Spike Application Testing Suite and supports automated SQL injection detection, web site crawling, login form brute forcing, overflow detection, and directory traversal detection.

To Use:

python spkproxy.py [ optional port argument, 8080 is default ]
Then set up your browser to use that port for both HTTP and
HTTPS proxies.

Then watch the traffic go!

Spike PHPCoverage is an open-source tool for measuring and reporting code coverage provided by the test suite of a PHP application. The project can instrument and record the line coverage information for any PHP script at runtime.

Spike PHPCoverage also provides an extensible reporting mechanism with a standard HTML report implemented out of the box. The default report displays the summary information about the code coverage for an application and also shows the detailed information about a file including which lines were actually executed and with what frequency. It is possible to specify the directories and files that should be included and/or excluded from a coverage measurement.

Spike PHPCoverage works on PHP 5.0 and newer and uses Xdebug Extension for gathering the coverage data.

Spike PHP Security Audit Tool project is a tool that performs a static analysis of PHP code for security exploits.
Usage:
To install, unzip Spike phpSecAudit package.
> unzip spike_phpSecAudit.zip
Change directory to your php repository.
> cd /path/to/code/to/audit
Execute the run.php, passing the file name or directory to audit.
> php /path/to/spike_phpSecAudit/run.php test_file.php
or
> php /path/to/spike_phpSecAudit/run.php dir_name
Enhancements:
- Modified to be PHP 4 friendly.
- A few functions have been added to the knowledge base: extract, shell_exec, pcntl_exec, and exec.
- The organization of the knowledge base file (vuln_db.xml) has been slightly improved.
- The _getAllPhpFiles function may miss a few (unverified).
- The tokenizer needs to be able to differentiate between a native function call and class method call of the same name, i.e. mail() and $class->mail().

Klusters is a powerful and easy-to-use graphical application for spike sorting of extracellular neuronal recordings.
While the accuracy and speed of spike sorting is dramatically improved by automatic classification algorithms, the results of automatic algorithms must be examined manually to ensure that the assigned clusters correspond to single neurons. Klusters has been carefully designed to make this process as fast and error-free as possible.
Main features:
- Multiple type of views including Cluster View displaying spikes in the PCA feature space, Waveform View and Correlation View displaying auto-and cross-correlograms.
- Cluster colors making it easy to quickly identify a given cluster across different views.
- Time trajectory display to identify possible electrode drift.
- "Grouping Assistant" to suggest which pairs of clusters may result from overclustering of a single neuron.
- "Recluster" feature to automatically split clusters that may be several distinct neurons (underclustering), using an external classification program.
- Multiple displays open at once, which can be useful to examine different subsets of the data in parallel.
- Multiple undo and redo on the last actions.
- Print and export to postcript and pdf.
- Ergonomic user interface for maximum speed and reliability.
Enhancements:
- The source archive klusters-1.4.tar.gz released on July 08 did not compiled on certain distributions, this is now corrected.
- If you have encounter this problem, please download a copy of the corrected archive and try again. [This does not affect the debian package].
- In addition a layout bug was corrected in the documentation. [This affects both the source archive and the debian package].

SMTPGuard is a tool which controls the flow of email traversing an MTA (Mail Transfer Agent). It is designed to be used on an SMTP server for incoming mail, and currently supports postfix.
SMTPGuard was originally created to meet the needs of Internet Service Providers (ISPs). ISPs typically receive tremendous amounts of email from their local (user) network.
Within a wide variety of users, some are spammers, many unknowingly have virus infected PCs; each of these can send large quantities of mail through the ISPs SMTP (Simple Mail Transfer Protocol) servers.
This is especially a problem for ISPs who are connected to their users via high speed lines such as fiber or ADSL. SMTPGuard was developed to prevent SMTP servers from being overwhelmed by unexpected spikes in usage from specific (often malicious) users.
For a large ISP, their only problem isnt just with overloaded incoming SMTP servers. SPAM will also be queued on the outgoing server (perhaps the same server) for delivery to the Internet.
Because the mail is SPAM it will likely bounce, then double bounce putting extreme load on the outgoing server and its queue. smtpguard is designed to stop this type of extreme load by stopping floods of mail at the gate (incoming server).
SMTPGuard is point based. Each time a client connects to the SMTP server, SMTPGuard adds points according to the rules file. SMTPGuard uses information acquired during the SMTP session, adds points according to the rules file, and finally takes actions based on its settings. For example, the information below is used:
- Remote IP Address
- Character string provided by MAIL FROM command
- Character string provided by RCPT TO command
The following actions can be taken:
ok - white list
wait - delay processing
reject - reject messages
mail - send alert email to administrator
log - output message to log
delete - delete record in database
Enhancements:
- postfix/flexguard.c: remove word flexguard. use smtpguard instead. rename filename to postfix/smtpguard.c
- postfix/Makefile.am: rename flexguard -> smtpguard
- configure.in: 1.1.1
- rename FLEXGUARD_{CFLAGS,LIBS} -> SMTPGUARD_{CFLAGS,LIBS}
- smtpguard/Makefile.am,postfix/Makefile.am,test/Makefile.am: Ditto
- debian/postfix-smtpguard.files: added
- README.postfix: added

File::Wildcard is a Perl module for enhanced glob processing.

SYNOPSIS

use File::Wildcard;
my $foo = File::Wildcard->new(path => "/home/me///core");
while (my $file = $foo->next) {
unlink $file;
}

When looking at how various operating systems do filename wildcard expansion (globbing), VMS has a nice syntax which allows expansion and searching of whole directory trees. It would be nice if other operating systems had something like this built in. The best Unix can manage is through the utility program find.

This module provides this facility to Perl. Whereas native VMS syntax uses the ellipsis "...", this will not fit in with POSIX filenames, as ... is a valid (though somewhat strange) filename. Instead, the construct "///" is used as this cannot syntactically be part of a filename, as you do not get three concurrent filename separators with nothing between (three slashes are used to avoid confusion with //node/path/name syntax).

You dont have to use this syntax, as you can do the splitting yourself and pass in an arrayref as your path.

The module also forms a regular expression for the whole of the wildcard string, and binds a series of back references ($1, $2 etc.) which are available to construct new filenames.

new

File::Wildcard-new( $wildcard, [,option => value,...]);>
my $foo = File::Wildcard->new( path => "/home/me///core");
my $srcfnd = File::Wildcard->new( path => "src///*.cpp",
match => qr(^src/(.*?).cpp$),
derive => [src/$1.o,src/$1.hpp]);

This is the constructor for File::Wildcard objects. At a simple level, pass a single wildcard string as a path.

For more complicated operations, you can supply your own match regexp, or use the derive option to specify regular expression captures to form the basis of other filenames that are constructed for you.

The $srcfnd example gives you object files and header files corresponding to C++ source files.

Here are the options that are available:

path

This is the input parameter that specifies the range of files that will be looked at. This is a glob spec which can also contain the ellipsis /// (it could contain more than one ellipsis, but the benefit of this is questionable, and multiple ellipsi would cause a performance hit).

Note that the path can be relative or absolute. new will do the right thing, working out that a path starting with / is absolute. In order to recurse from the current directory downwards, specify .///foo.

As an alternative, you can supply an arrayref with the path constituents already split. If you do this, you need to tell new if the path is absolute. Include an empty string for an ellipsis. For example:

foo///bar/*.c is equivalent to [foo,,bar,*.c]

You can also construct a File::Wildcard without a path. A call to next will return undef, but paths can be added using the append and prepend methods.
absolute

This is ignored unless you are using a pre split path. If you are passing a string as the path, new will work out whether the path is absolute or relative. Pass a true value for absolute paths.

If your original filespec started with / before you split it, specify absolute => 1. absolute is not required for Windows if the path contains a drive specification, e.g. C:/foo/bar.

case_insensitive

By default, the module will use Filesys::Type to determine whether the file system of your wildcard is defined. This is an optional module (see Module::Optional), and File::Wildcard will guess at case sensitivity based on your operating system. This will not always be correct, as the file system might be VFAT mounted on Linux or ODS-5 on VMS.

Specifying the option case_insensitive explicitly forces this behaviour on the wildcard.

Note that File::Wildcard will use the file system of the current working directory if the path is not absolute. If the path is absolute, you should specify the case_sensitivity option explicitly.

exclude

You can provide a regexp to apply to any generated paths, which will cause any matching paths not to be processed. If the root of a directory tree matches, no processing is done on the entire tree.

This option can be useful for excluding version control repositories, e.g.

exclude => qr/.svn/
match

Optional. If you do not specify a regexp, you get all the files that match the glob; in addition, new will set up a regexp for you, to provide a capture for each wildcard used in the path.

If you do provide a match parameter, this will be used instead, and will filter the results.

derive

Supply an arrayref with a list of derived filenames, which will be constructed for each matching file. This causes next to return an arrayref instead of a scalar.
follow

If given a true value indicates that symbolic links are to be followed. Otherwise, the symbolic link target itself is presented, but the ellipsis will not traverse the link.

This module detects a looping symlink that points to a directory higher up, and will only present the tree once.

ellipsis_order

This can take one of the following values: normal, breadth-first, inside-out. The default option is normal. This controls how File::Wildcard handles the ellipsis. The default is a normal depth first search, presenting the name of each containing directory before the contents.

The inside-out order presents the contents of directories first before the directory, which is useful when you want to remove files and directories (all O/S require directories to be empty before rmdir will work). See t/03_absolute.t as this uses inside-out order to tidy up after the test.

Breadth-first is rarely needed (but I do have an application for it). Here, the whole directory contents is presented before traversing any subdirectories.
Consider the following tree: a/ a/bar/ a/bar/drink a/foo/ a/foo/lish
breadth-first will give the following order: qw(a/ a/bar/ a/foo/ a/bar/drink a/foo/lish). normal gives the order in which the files are listed. inside-out gives the following: qw(a/bar/drink a/bar/ a/foo/lish a/foo/ a/).

sort

By default, globbing returns the list of files in the order in which they are returned by the dirhandle (internally). If you specify sort => 1, the files are sorted into ASCII sequence (case insensitively if we are operating that way). If you specify a CODEREF, this will be used as a comparison routine. Note that this takes its operands in @_, not in $a and $b.

debug and debug_output

You can enable a trace of the internal states of File::Wildcard by setting debug to a true value. Set debug_output to an open filehandle to get the trace in a file. If you are submitting bug reports for File::Wildcard, attaching debug trace files would be very useful.

debug_output defaults to STDERR.
match
my $foo_re = $foo->match;
$foo->match(bar/core);

This is a get and set method that gives access to the match regexp that the File::Wildcard object is using. It is possible to change the regex on the fly in the middle of a search (though I dont know why anyone would want to do this).

append

$foo->append(path => /home/me///*.tmp);

appends a path to an objects todo list. This will be globbed after the object has finished processing the existing wildcards.

prepend
$srcfnd->prepend(path => $include_file);

This is similar to append, but prepends the path to the todo list. In other words, the current wildcard operation is interrupted to serve the new path, then the previous wildcard operation is resumed when this is exhausted.

next
while (my $core = $foo->next) {
unlink $core;
}
my ($src,$obj,$hdr) = @{$srcfnd->next};

The next method is an iterator, which returns successive files. Returns matching files if there was no derive option passed to new. If there was a derive option, returns an arrayref containing the matching filespec and all derived filespecs. The derived filespecs do not have to exist.

Note that next maintains an internal cursor, which retains context and state information. Beware if the contents of directories are changing while you are iterating with next; you may get unpredictable results. If you are intending to change the contents of the directories you are scanning (with unlink or rename), you are better off deferring this operation until you have processed the whole tree. For the pending delete or rename operations, you could always use another File::Wildcard object - see the spike example below:

all
my @cores = $foo->all;

all returns an array of matching files, in the simple case. Returns an array of arrays if you are constructing new filenames, like the $srcfnd example.

Beware of the performance and memory implications of using all. The method will not return until it has read the entire directory tree. Use of the all method is not recommended for traversing large directory trees and whole file systems. Consider coding the traversal using the iterator next instead.

reset

reset causes the wildcard context to be set to re-read the first filename again. Note that this will cause directory contents to be re-read.

Note also that this will cause the path to revert to the original path specified to new. Any additional paths appended or prepended will be forgotten.

close

Release all directory handles associated with the File::Wildcard object. An object that has been closed will be garbage collected once it goes out of scope. Wildcards that have been exhausted are automatically closed, (i.e. all was used, or c< next > returned undef).

Subsequent calls to next will return undef. It is possible to call reset after close on the same File::Wildcard object, which will cause it to be reopened.

Volume.app is a small graphical software utility enabling quick and convenient control of a computers audio volume level. Volume.app is intended for use on Linux/Unix systems in conjunction with an X window manager that supports dockable applications ("dockapps") such as AfterStep, BlackBox, or Window Maker.

It is a refinement of an idea that first appeared in Timecops WMix: a user interface comprising a "knob" that can be interactively "turned" by clicking and dragging the mouse. I found this approach quite appealing, both from an aesthetic viewpoint, and (more importantly) from a user-interface perspective.

A handful of other dockapp volume control programs are out there, and I have tried many of them. An interface element present in most of these is some form of "slider" as the primary means of adjusting the volume. (A fictitious example may be seen at right). To my dismay, with this kind of interface, volume adjustments tended to be large and abrupt. Because the slider was so small, raising or lowering the volume "just a bit" required extremely careful control of the mouse-- a slip of the hand had the potential to spike the volume to full blast. (I have a set of Altec-Lansing ACS48 speakers which make this a rather unpleasant experience). This approach left much to be desired.

I longed for an alternative, and upon playing with WMix (pictured at left) I had found it. The knob was genius in that it provided a means of graphically adjusting the volume, as a slider would, without tying itself directly to the motion of the mouse. The basic mode of usage is identical: you click on the thing and drag the mouse up or down. However, with the knob, the range of motion need not be confined to the postage-stamp-sized area of the dockapp. The mouse travel needed to cover the entire range of volume settings can be made longer, on the order of the full height of the screen-- almost like a much larger, easier-to-use slider. No longer were precise movements needed to make volume adjustments!

Still, I found WMixs interface to be a bit busy (never was a fan of tiny little buttons) and the all-important knob was yet a rather small target to find with the mouse. So, I grabbed a copy of the WMix source code, and rebuilt it into a dockapp that had a much larger knob as its sole interface element. I dubbed it Volume.app, and have placed it here for the benefit of everyone.

Escape of the Unicorn project is a side-scrolling, 2D flying shooter game.
Welcome to the land of miraculous creatures.
Take a risk and play the game called
Escape of the Unicorn.
You play a unicorn,
a noble and most beautiful animal,
the most beautiful to have ever existed.
Your goal is to escape
from a cave full of monsters and traps.
You can move with the arrow keys and fire missiles.
Every missile can harm a monster if it is aimed well.
Beware of the monsters and lasers.
They decrease your energy when you touch them.
The same happens when you hit walls.
Some creatures may also shoot fireballs.
Be careful at all times.
When you are out of energy,
you die and lose the game.
Enhancements:
- Levels now have more complex shape
- 3 crafted levels
- Per-object speed control, and new types of interactions
- New game objects such as Puff Fish, Wall Spikes, Bloops
- Walls no longer damage player, immunity time much shorter