Serendipity Spam Statistics

#!/usr/bin/perl -w
# File: log2ipf.pl
# Author: Jez Hancock
# Description: strips a list of IP addresses out of a logfile based on
# variousperl regular expressions.
# License: GPL
use strict;
use Getopt::Long;

########################################################################
# Start config
########################################################################
eval 'exec /usr/bin/perl -w -S $0 ${1+"$@"}'
    if 0; # not running under some shell

my $progname = $0;
$progname =~ s,.*/,,;  # use basename only
$progname =~ s/\.\w*$//; # strip extension, if any

my $VERSION = sprintf("%d.%d", q$Revision: 0.1 $ =~ /(\d+)\.(\d+)/);

# Commandline params:
my($help, $verbose, $debug, $err)=
(
    undef,
    undef,
    undef,
    undef
);

# Path to the ipfilter ruleset:
my $ipf_rules="/etc/ipf.rules";

# Threshold of blocked entries above which we should include this IP:
my $threshold = 0;

# list of offending ips:
my %ips;

# indicates to use ipf ruleset output:
my $ipf=0;

# Holds the ipf rules created if applic:
my $ipfrules="";

# count of abuse entries:
my $count=0;

# for buffering output:
my $output="";

# whether to add a comment block at the top of ipf rules:
my $comments=0;

# whether to display list of offending ip addresses only:
my $ips_only=0;

# whether or not to output rules for an ip if a rule already exists
# in /etc/ipf.rules for it:
my $check_dups=0;

# Type of logfile we're searching in, default to s9y:
my $logtype="s9y";

# whether to output ipf rules in a form ready for execution on the
# commandline:
my $executable=0;

# Types of regular expression to use for different types of logs
# the regexp should contain one single pair of brackets - the IP of the
# offending host:
my %re=(
    "s9y"           =>qr/.*\[REJECTED: [No API-created comments|Trackback URL invalid|Filtered by Akismet\.com].*, IP (.*?)].*/,
    "picasa"        =>qr/^.*?\s+(.*?)\s+.*%22index\+of%22\+%2F\+picasa\.ini.*/
);

########################################################################
# End config
########################################################################

sub usage{
    $err && (print $err,"\n");
    die<<"~USAGE~";
Usage: $progname [-h] [-v] [-d] [-n] [-t <number>]

       -h                     Display this help.

       -v                     Display verbose logging output.

       -d                     Display added debug info.

       -n                     Do not execute any commands, dry run.

       -i                     Print out results in ipf rule format.

       -z                     Don't dispaly duplicate rules - if a rule
                              already exists in /etc/ipf.rules for the current
                              ip, don't create another.

       -n                     Only print a list of offending IP addresses
                              and exit.

       -e                     Make any ipf rules output 'executable'.

       -t <number>            Number of times an IP must have been blocked
                              for us to include it in our reports.

       -l <logtype>           Specify the <logtype> to search in.  Valid options are:

                              s9y or my_ egallery

$progname takes lines of spamblock log entries from the serendipity weblogging
application and works out how many times each IP address has attempted to 'spam'
us.


With the -t <number> option, only list IPs where the number of attempts is over
<number> attempts.


With the -l <logtype> option, allows the user to specify alternative types of logfile
to search for attack vectors in.  Current supported searches are s9y and my_ egallery.


With the -e option, $progname will output ipfilter rules in a form suitable for
executing from the commandline.  Output looks as follows:

echo 'block in quick from x.x.x.x to any group 100' | ipf -f -

Can be executed by adding '|sh' onto the end of the $progname command once output
has been checked over.

Version $VERSION
~USAGE~
}

MAIN:{
    # validate input:
    GetOptions(
        'v|verbose'         => \$verbose,
        'h|help'            => \$help,
        'd|debug'           => \$debug,
        't=i'               => \$threshold,
        'c'                 => \$comments,
        'n'                 => \$ips_only,
        'z'                 => \$check_dups,
        'i|ipf'             => \$ipf,
        'e|executable'      => \$executable,
        'l=s'               => \$logtype
    );

    usage() if($help);

    if($comments && !$ipf){
        $err="-c specified without -i, must use -i with -c\n";
        usage();
        exit;
    }

    if($ips_only && $ipf){
        $err="-n makes no sense with -i, quitting\n";
        usage();
        exit;
    }

    if(!defined($re{$logtype})){
        $err="Logtype '$logtype' not recognized, see below for valid options for -l\n";
        usage();
        exit;
    }

    while(<>){
        next if(!/$re{$logtype}/);
        $ips{$1}++;
        $count++;
    }


    print "Total log entries for period: $count\n\n" if $verbose;
    print "Unique IPs for period: " . int(keys (%ips)) . "\n\n" if $verbose;

    if($threshold && $verbose){
        print "Threshold is set to $threshold - only display IPs with $threshold or more entries.\n";
    }

    my $format_space=4;

    IP: foreach (sort {$ips{$a}<=>$ips{$b}} keys %ips) {
        if($ips{$_}>=$threshold){
            if($check_dups){
                # check if this ip is already in /etc/ipf.rules:
                my $ipf_check="";
                $ipf_check=`grep $_ $ipf_rules`;
                chomp $ipf_check;
                if ( $ipf_check ne ""){
                    $verbose && print "Skipping $_, already exists in $ipf_rules...\n";
                    next IP;
                }
            }
            if($ipf){
                $output.= $executable ? "echo '" : "";
                $output.= sprintf "block in quick from %15s to any group 100", $_;
                $output.= $executable ? "' | ipf -f -" : "";
                $output.= "\n";
            }elsif($ips_only){
                $output.="$_\n";
            }else{
                $output.=sprintf "%15s:%10s\n", $_, $ips{$_};
            }
        }
    }

    if($output ne ""){
        if($ipf && $comments){
            my $date=`date`;
            chomp $date;
            $output="\n# $date  - entries blocked by $logtype:\n".$output."\n";
        }
        print $output;
    }
}