Free lets users software for linux

Apache Users project is an Apache username enumerator, via /~username requests. This script uses a list of common system names like root, admin etc ...

You should manually check the issue to establish the http return code, ie: 403 as this is needed for the command line. No native SSL support.

USAGE apache.pl -h 1.2.3.4 -l names -p 80 (No SSL Support) -e 403 (http code)

Sample script:

use IO::Socket;
use Getopt::Std;
getopt ("h: l: p: e: ");
use vars qw( $opt_h $opt_l $opt_p $opt_e );


if ((! $opt_h) || (! $opt_l ) || (! $opt_p ) || (! $opt_e)) {
print "nUSAGE: apache.pl -h 1.2.3.4 -l names -p 80 (No SSL Support) -e 403 (http code)nn ";

exit 1;
};

$host = $opt_h;
$list = $opt_l;
$port = $opt_p;
$num = $opt_e;

open (LIST, "$list") or die "Unable to open $list ....$!";

&connect;
exit 0;


sub connect {

foreach $name (< LIST >) {


$connection = IO::Socket::INET->new (
Proto => "tcp",
PeerAddr => "$host",
PeerPort => "$port",
) or die "Cant CONNECT to $host on the Port specified.n";

$connection -> autoflush;

chomp $name;
print $connection "GET /~$name HTTP/1.0rnrn";


$results = < $connection >;
if ( $results =~/($num)/g ) {
print "$name exists on $hostn";
};

}

close ($connection);

sleep 1;
};
close LIST;

Debian Desktop Users Guide project is a guide which is targeted toward new Debian users.
It brings up-to-date and effective documentation to new Debian users.
This document is based on the Progeny users guide.
This guide is planned to be released in conjunction with Sarge.
Enhancements:
- sections 6.2.1 and 6.2.2 have been rewritten.

Xreversi project is a networked Reversi/Othello program.

Xreversi is a complete implementation of the well-known Reversi (or Othello) board game.

It lets users play against the computer with 10 levels of AI, or against each other through a network.

Xreversi currently supports English and French languages.

GTK+ Send-PR is a user friendly GNATS client.

gtk-send-pr is a problem report tool, designed to send reports to a GNATS database server using libesmtp to deliver mail.

The program has a user friendly interface and lets you use any SMTP server, including support for AUTH and TLS, to send the report, removing the need for a local configured sendmail. gtk-send-pr is part of both the FreeBSD ports and NetBSDs pkgsrc.

UTUTO XS is a desktop and extensible solution based totally in Free/Libre software. It only includes (and will ever do) free/libre and open source software. But it let users the possibility to install other programs.

UTUTO XS is free/libre software, so their users have a high quality desktop system, with legal rights to use, copy, distribute and modify it according to their needs. UTUTO Xs includes the main common-use software for home, developers, companies, organizations, government users.

SigBrowser is a small tool to display large signals (up to 2 GB filesize / 1-6 channels / 16 bit integer).

SigBrowser allows you to smoothly browse in a large signal. It can load 16 bit signed integer data with up to 6 interlaced channels.

Unfortunately theres no large-file support, so the limit is at 2 GB. You cant do much except looking at the signal with various zooming factors.

But if youre searching for certain artefacts in a signal then its probably quite useful for you.

It can visualize large signals with filesizes of up to 2 GB. Currently only 16 bit signed integer signals with up to 8 interlaced channels can be loaded.

Using a P4 @ 1.8 GHz with 512 MB RAM and a GeForce 4 graphics card you can scroll and zoom quite smoothly through the whole signal. On a Sun Ultra 1500 its a bit slower but you can still work fine with it.

By using something which I call block-reduction (BL). BL uses the fact that todays screens only have a limited amount of pixels. That means to display the whole signal at once, the worst case regarding performance restrictions, you would have to display thousands of samples on one pixel coordinate in x (horizontal) direction.

Assuming we plot lines between each pair of following samples the user will see a colored area which borders in vertical direction are the minimum and maximum value of all samples falling on the same x-coordinate.

Using this fact we let the user create a so called signal profile. Besides storing the sampling rate, file format info, number of channels to visualize and similar things its main purpose is to contain min/max pairs each of which calculated from a block of N samples per channel. N gets specified by the user, usually 10..50, depending on signal size and computer beeing used.

By visualizing these min/max blocks instead of the real signal as long as the user doesnt zoom into the signal to much we dont loose any information on the screen. But we get a nice performance boost as the signal profile has a much smaller size (signal_lengh_in_samples / N * 2) than the original signal has. Unfortunately we cant do this anymore when the user zooms into details. Then SigBrowser switches to direct display of the signal but it loads only about 1 MB of the original signal at once, which would result in a width of usually several screens.

Example:

* C = number of channels in origianl signal
* V = number of channels to visualize
* S = original signal length in samples per channel
* B = block size

I have a signal of 1.1 GB, C = V = 8 channels, 16 bit integer samples which in my case contains S = 73298610 samples per channel. Using a block size of B = 10 samples per min/max block (really smooth interaction on a P4 3.2 GHz) you get a signal-profile of S / B * 4 / (1024*1024) = 84 MB which you have to keep in memory.

Kopete Massive Messenger is a Kommander script that lets you send repetitive messages to your Kopete contacts.

Fast Secure File System exports existing directories securely over the network, letting users store and retrieve encrypted data in a scalable and transparent way. FSFS is written in C and works on GNU/Linux systems on x86 and PPC architectures, with help from FUSE and OpenSSL.
File systems are easily the most evident, from the point of view of users, component of an operating system. Through file systems it is possible to organize data in a wide variety of ways, and access resources through a common interface.
Users can nowadays not only store and retrieve documents, but also find information on running processes and system settings (through ProcFS), access and manipulate e-mail (for example with GmailFS), or perform several other operations.
In several circumstances and scenarios it is desirable to protect stored files and directories from manipulation by unknown or malicious users: financial or health-related data, confidential documents, or any kind of personal or sensitive data may need to be stored securely, in such a way that it can not be examined or modified freely by third parties.
Most file systems do not take action in this sense, and external cryptographic utilities are sometimes employed to secure data before storage. While this can be a perfectly secure solution, it is not transparent to users.
Distributed file systems propose efficient ways of accessing data remotely as if it resided on the local machine; when it comes to dealing with securely stored data as in the examples above, care must be taken to preserve confidentiality and integrity also during network transfer.
Not all distributed file systems accomplish this task, weakening the overall security of the system, or do so inefficiently, making it inconvenient for users.
FSFS is a secure, distributed file system in users space, written in C with much help from FUSE and OpenSSL. It lets users store and retrieve data securely and transparently, knowing that it is protected both on permanent storage devices and while in transit over the network.
It is also concerned with scalability, therefore separates data cryptography from the server, leaving it to the clients; this approach is similar to the one used in CFS, and opposite to those taken on by other secure file system solutions (like NFS on top of IPsec).
FSFS is written as a pair of user space daemons that act as client and server. Because of this, it needs no kernel support (unlike NFS over IPsec), save the FUSE loadable kernel module on clients, included in Linux since 2.6.14; servers dont use FUSE and depend only on user space OpenSSL libraries.
Servers export an existing file system (of virtually any kind) to clients over the network through two separate channels: a TLS connection set up with OpenSSL, and a clear channel. Requests from the clients to the servers are sent via the TLS socket, thus they are encrypted and authenticated, according to TLS v1 specifications, by the channel itself and decrypted on receipt, as they are usually very short and the relevant cryptography does not constitute a great overhead; simple server replies undergo the same process.
Cryptography in this case happens at both ends of the transmission.
In a distributed file system, large amounts of data may be transferred between clients and servers, thus encrypting and decrypting everything may become too cumbersome for both parties, and as more clients are added to the system the server may severely lose performance; moreover, file data should be stored encrypted anyway, so the cryptography could be moved to the clients, in such a way that each encrypts data before a write operation sends it over the network to the server, and decrypts it after a read retrieves it.
This way servers only deal with TLS details and can concentrate on serving client requests by doing the relevant I/O on the underlying, "physical" file system. As the data is already encrypted, it does not need to go through the TLS channel and the corresponding overhead, but can be sent via the clear channel, provided the messages are authenticated.
Enhancements:
- This release fixes two bugs. One bug related to socket creation and would cause problems on some systems (namely OpenSUSE 10.2). The other bug related to server configuration creation when using the Python configuration utilities. Users dont need to upgrade to this release if theyre not experiencing problems or are not using the Python configuration utilities.