File Coverage

blib/lib/CrowdSec/Client.pm

Criterion	Covered	Total	%
statement	21	97	21.6
branch	0	42	0.0
condition	0	12	0.0
subroutine	7	11	63.6
pod	2	4	50.0
total	30	166	18.0

package CrowdSec::Client;

use strict;
use Date::Parse;
use HTTP::Request::Common;
use JSON;
use LWP::UserAgent;
use Moo;
use POSIX "strftime";

our $VERSION = '0.04';

# Default alert template
our %DEFAULTS = (
    duration  => '4h',
    labels    => undef,
    origin    => 'CrowdSec::Client',
    reason    => 'Banned by CrowdSec::Client',
    scenario  => 'Banned by CrowdSec::Client',
    simulated => JSON::false,
    type      => 'ban',
);

# Watcher accessors
has machineId => ( is => 'ro' );
has password  => ( is => 'ro' );
has token     => ( is => 'rw' );
has tokenVal  => ( is => 'rw' );
has strictSsl => ( is => 'ro', default => 1, );
has baseUrl   => ( is => 'ro' );

# Bouncer accessors
has apiKey => ( is => 'ro' );

# Common accessors
has userAgent => (
    is      => 'ro',
    default => sub {
        return LWP::UserAgent->new(
            $_[0]->strictSsl
            ? ()
            : (
                ssl_opts => {
                    verify_hostname => 0,
                    SSL_verify_mode => 0
                }
            )
        );
    }
);

has autoLogin => ( is => 'ro' );

has error => ( is => 'rw' );

sub login {
    my ($self) = @_;
    my $error = 0;
    return 1 if $self->tokenIsvalid;
    foreach my $k (qw(machineId password baseUrl)) {
        unless ( $self->{$k} ) {
            $self->error("Missing parameter: $k");
            $error++;
        }
    }
    return if $error;
    my $request = POST(
        $self->baseUrl . '/v1/watchers/login',
        Accept       => 'application/json',
        Content_Type => 'application/json',
        Content      => JSON::to_json(
            {
                machine_id => $self->machineId,
                password   => $self->password,
                scenarios  => [],
            }
        )
    );
    my $response = $self->userAgent->request($request);
    if ( $response->is_success ) {
        eval {
            my $tmp = JSON::from_json( $response->content );
            $self->token( $tmp->{token} );
            $self->tokenVal( str2time( $tmp->{expire} ) );
        };
        if ($@) {
            $self->error("Bad response content from CrowdSec server: $@");
            return;
        }
        if ( !$self->token and !$self->tokenVal ) {
            $self->error(
                "Missing token and expire fields in CrowdSec response: "
                  . $response->content );
        }
        return 1;
    }
    else {
        $self->error(
            "Bad response from CrowdSec server: " . $response->status_line );
        return;
    }
}

sub banIp {
    my ( $self, $ip, %params ) = @_;
    unless ( $ip ) {
        $self->error('Usage: banIp($ip, \%options)');
        return;
    }
    if ( $self->autoLogin ) {
        unless ( $self->login ) {
            return;
        }
    }
    unless ( $self->token ) {
        $self->error("No valid token");
        return;
    }
    my %prm = ( %DEFAULTS, %params );
    $prm{simulated} = $prm{simulated} ? JSON::true : JSON::false;
    my $stamp    = strftime "%Y-%m-%dT%H:%M:%SZ", gmtime(time);
    my $decision = [
        {
            capacity   => 0,
            created_at => $stamp,
            decisions  => [
                {
                    duration => $prm{duration},
                    origin   => $prm{origin},
                    scenario => $prm{scenario},
                    scope    => 'Ip',
                    type     => $prm{type},
                    value    => $ip,
                }
            ],
            events           => [],
            events_count     => 1,
            labels           => $prm{labels},
            leakspeed        => '0',
            message          => $prm{reason},
            scenario         => $prm{reason},
            scenario_hash    => '',
            scenario_version => '',
            simulated        => $prm{simulated},
            source           => {
                ip    => $ip,
                scope => 'Ip',
                value => $ip,
            },
            start_at => $stamp,
            stop_at  => $stamp,
        }
    ];
    my $request = POST(
        $self->baseUrl . '/v1/alerts',
        Authorization => 'Bearer ' . $self->token,
        Content_Type  => 'application/json',
        Content       => JSON::to_json($decision),
    );
    my $response = $self->userAgent->request($request);
    if ( $response->is_success ) {
        my $response_content = $response->content;
        my $res              = eval { JSON::from_json($response_content)->[0] };
        if ($@) {
            $self->error(
                "CrowdSec didn't return an array: " . $response->content );
            return;
        }
        return $res;
    }
    else {
        print "Échec de la requête : " . $response->status_line . "\n";
        return;
    }
}

sub testIp {
    my ( $self, $ip ) = @_;
    my $error = 0;;
    foreach my $k (qw(apiKey baseUrl)) {
        unless ( $self->{$k} ) {
            $self->error("Missing parameter: $k");
            $error++;
        }
    }
    unless ($ip) {
        $self->error('Missing IP');
        $error++;
    }
    return (0, $self->error) if $error;
    my $response = $self->userAgent->get(
        $self->baseUrl . "/v1/decisions?ip=$ip",
        Accept      => 'application/json',
        'X-Api-Key' => $self->apiKey,
    );
    if ( $response->is_success ) {
        my @decisions;
        return 0 if !$response->content or $response->content eq 'null';
        eval {
            my $tmp = JSON::from_json( $response->content );
            @decisions = @$tmp;
        };
        if ($@) {
            $self->error("Bad response content from CrowdSec server: $@");
            return (0, $self->error);
        }
        return 0 unless @decisions;
        foreach my $decision (@decisions) {
            if ( $decision->{type} and $decision->{type} eq 'ban' ) {
                return 1;
            }
        }
        return 0;
    };
}

sub tokenIsvalid {
    my ($self) = @_;
    return ( $self->tokenVal and ( $self->tokenVal > time ) );
}

1;
__END__