[people/pmueller/ipfire-2.x.git] / config / cfgroot / ids-functions.pl

#!/usr/bin/perl -w
############################################################################
#                                                                          #
# This file is part of the IPFire Firewall.                                #
#                                                                          #
# IPFire is free software; you can redistribute it and/or modify           #
# it under the terms of the GNU General Public License as published by     #
# the Free Software Foundation; either version 2 of the License, or        #
# (at your option) any later version.                                      #
#                                                                          #
# IPFire is distributed in the hope that it will be useful,                #
# but WITHOUT ANY WARRANTY; without even the implied warranty of           #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            #
# GNU General Public License for more details.                             #
#                                                                          #
# You should have received a copy of the GNU General Public License        #
# along with IPFire; if not, write to the Free Software                    #
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA #
#                                                                          #
# Copyright (C) 2018 IPFire Team <info@ipfire.org>.                        #
#                                                                          #
############################################################################

package IDS;

require '/var/ipfire/general-functions.pl';

# Location where all config and settings files are stored.
our $settingsdir = "${General::swroot}/suricata";

# Location and name of the tarball which contains the ruleset.
our $rulestarball = "/var/tmp/idsrules.tar.gz";

# File to store any errors, which also will be read and displayed by the wui.
our $storederrorfile = "/tmp/ids_storederror";

# Location where the rulefiles are stored.
our $rulespath = "/etc/suricata/rules";

# File which contains a list of all supported ruleset sources.
# (Sourcefire, Emergingthreads, etc..)
our $rulesetsourcesfile = "$settingsdir/ruleset-sources";

# The pidfile of the IDS.
our $idspidfile = "/var/run/suricata.pid";

#
## Function for checking if at least 300MB of free disk space are available
## on the "/var" partition.
#
sub checkdiskspace () {
	# Call diskfree to gather the free disk space of /var.
	my @df = `/bin/df -B M /var`;

	# Loop through the output.
	foreach my $line (@df) {
		# Ignore header line.
		next if $line =~ m/^Filesystem/;

		# Search for a line with the device information.
		if ($line =~ m/dev/ ) {
			# Split the line into single pieces.
			my @values = split(' ', $line);
			my ($filesystem, $blocks, $used, $available, $used_perenctage, $mounted_on) = @values;

			# Check if the available disk space is more than 300MB.
			if ($available < 300) {
				# Log error to syslog.
				&_log_to_syslog("Not enough free disk space on /var. Only $available MB from 300 MB available.");

				# Exit function and return "1" - False.
				return 1;
			}
		}
	}

	# Everything okay, return nothing.
	return;
}

#
## This function is responsible for downloading the configured snort ruleset.
##
## * At first it obtains from the stored snortsettings which ruleset should be downloaded.
## * The next step is to get the download locations for all available rulesets.
## * After that, the function will check if an upstream proxy should be used and grab the settings.
## * The last step will be to generate the final download url, by obtaining the URL for the desired
##   ruleset, add the settings for the upstream proxy and final grab the rules tarball from the server.
#
sub downloadruleset {
	# Get snort settings.
	my %snortsettings=();
	&General::readhash("$settingsdir/settings", \%snortsettings);

	# Get all available ruleset locations.
	my %rulesetsources=();
	&General::readhash($rulesetsourcesfile, \%rulesetsources);

	# Read proxysettings.
	my %proxysettings=();
	&General::readhash("${General::swroot}/proxy/settings", \%proxysettings);

	# Load required perl module to handle the download.
	use LWP::UserAgent;

	# Init the download module.
	my $downloader = LWP::UserAgent->new;

	# Set timeout to 10 seconds.
	$downloader->timeout(10);

	# Check if an upstream proxy is configured.
	if ($proxysettings{'UPSTREAM_PROXY'}) {
		my ($peer, $peerport) = (/^(?:[a-zA-Z ]+\:\/\/)?(?:[A-Za-z0-9\_\.\-]*?(?:\:[A-Za-z0-9\_\.\-]*?)?\@)?([a-zA-Z0-9\.\_\-]*?)(?:\:([0-9]{1,5}))?(?:\/.*?)?$/);
		my $proxy_url;

		# Check if we got a peer.
		if ($peer) {
			$proxy_url = "http://";

			# Check if the proxy requires authentication.
			if (($proxysettings{'UPSTREAM_USER'}) && ($proxysettings{'UPSTREAM_PASSWORD'})) {
				$proxy_url .= "$proxysettings{'UPSTREAM_USER'}\:$proxysettings{'UPSTREAM_PASSWORD'}\@";
			}

			# Add proxy server address and port.
			$proxy_url .= "$peer\:$peerport";
		} else {
			# Log error message and break.
			&_log_to_syslog("Could not proper configure the proxy server access.");

			# Return "1" - false.
			return 1;
		}

		# Setup proxy settings.
		$downloader->proxy('http', $proxy_url);
	}

	# Grab the right url based on the configured vendor.
	my $url = $rulesetsources{$snortsettings{'RULES'}};

	# Check if the vendor requires an oinkcode and add it if needed.
	$url =~ s/\<oinkcode\>/$snortsettings{'OINKCODE'}/g;

	# Abort if no url could be determined for the vendor.
	unless ($url) {
		# Log error and abort.
		&_log_to_syslog("Unable to gather a download URL for the selected ruleset.");
		return 1;
	}

	# Pass the requested url to the downloader.
	my $request = HTTP::Request->new(GET => $url);

	# Perform the request and save the output into the "$rulestarball" file.
	my $response = $downloader->request($request, $rulestarball);

	# Check if there was any error.
	unless ($response->is_success) {
		# Log error message.
		&_log_to_syslog("Unable to download the ruleset. $response->status_line");

		# Return "1" - false.
		return 1;
	}

	# If we got here, everything worked fine. Return nothing.
	return;
}

#
## A tiny wrapper function to call the oinkmaster script.
#
sub oinkmaster () {
	# Load perl module to talk to the kernel syslog.
	use Sys::Syslog qw(:DEFAULT setlogsock);

	# Establish the connection to the syslog service.
	openlog('oinkmaster', 'cons,pid', 'user');

	# Call oinkmaster to generate ruleset.
	open(OINKMASTER, "/usr/local/bin/oinkmaster.pl -v -s -u file://$rulestarball -C $settingsdir/oinkmaster.conf -o $rulespath|");

	# Log output of oinkmaster to syslog.
	while(<OINKMASTER>) {
		# The syslog function works best with an array based input,
		# so generate one before passing the message details to syslog.
		my @syslog = ("INFO", "$_");

		# Send the log message.
		syslog(@syslog);
	}

	# Close the pipe to oinkmaster process.
	close(OINKMASTER);

	# Close the log handle.
	closelog();
}

#
## Function to do all the logging stuff if the downloading or updating of the ruleset fails.
#
sub log_error ($) {
	my ($error) = @_;

	# Remove any newline.
	chomp($error);

	# Call private function to log the error message to syslog.
	&_log_to_syslog($error);

	# Call private function to write/store the error message in the storederrorfile.
	&_store_error_message($error);
}

#
## Function to log a given error message to the kernel syslog.
#
sub _log_to_syslog ($) {
	my ($message) = @_;

	# Load perl module to talk to the kernel syslog.
	use Sys::Syslog qw(:DEFAULT setlogsock);

	# The syslog function works best with an array based input,
	# so generate one before passing the message details to syslog.
	my @syslog = ("ERR", "<ERROR> $message");

	# Establish the connection to the syslog service.
	openlog('oinkmaster', 'cons,pid', 'user');

	# Send the log message.
	syslog(@syslog);

	# Close the log handle.
	closelog();
}

#
## Private function to write a given error message to the storederror file.
#
sub _store_error_message ($) {
        my ($message) = @_;

	# Remove any newline.
	chomp($message);

        # Open file for writing.
        open (ERRORFILE, ">$storederrorfile") or die "Could not write to $storederrorfile. $!\n";

        # Write error to file.
        print ERRORFILE "$message\n";

        # Close file.
        close (ERRORFILE);
}

#
## Function to get a list of all available network zones.
#
sub get_available_network_zones () {
	# Get netsettings.
	my %netsettings = ();
	&General::readhash("${General::swroot}/ethernet/settings", \%netsettings);

	# Obtain the configuration type from the netsettings hash.
	my $config_type = $netsettings{'CONFIG_TYPE'};

	# Hash which contains the conversation from the config mode
	# to the existing network interface names. They are stored like
	# an array.
	#
	# Mode "0" red is a modem and green
	# Mode "1" red is a netdev and green
	# Mode "2" red, green and orange
	# Mode "3" red, green and blue
	# Mode "4" red, green, blue, orange
	my %config_type_to_interfaces = (
		"0" => [ "red", "green" ],
		"1" => [ "red", "green" ],
		"2" => [ "red", "green", "orange" ],
		"3" => [ "red", "green", "blue" ],
		"4" => [ "red", "green", "blue", "orange" ]
	);

	# Obtain and dereference the corresponding network interaces based on the read
	# network config type.
	my @network_zones = @{ $config_type_to_interfaces{$config_type} };

	# Return them.
	return @network_zones;
}

#
## Function to check if the IDS is running.
#
sub ids_is_running () {
	if(-f $idspidfile) {
		# Open PID file for reading.
		open(PIDFILE, "$idspidfile") or die "Could not open $idspidfile. $!\n";

		# Grab the process-id.
		my $pid = <PIDFILE>;

		# Close filehandle.
		close(PIDFILE);

		# Remove any newline.
		chomp($pid);

		# Check if a directory for the process-id exists in proc.
		if(-d "/proc/$pid") {
			# The IDS daemon is running return the process id.
			return $pid;
		}
	}

	# Return nothing - IDS is not running.
	return;
}

1;
Commit	Line	Data
8dcebe53 SS	1	#!/usr/bin/perl -w
	2	############################################################################
	3	# #
	4	# This file is part of the IPFire Firewall. #
	5	# #
	6	# IPFire is free software; you can redistribute it and/or modify #
	7	# it under the terms of the GNU General Public License as published by #
	8	# the Free Software Foundation; either version 2 of the License, or #
	9	# (at your option) any later version. #
	10	# #
	11	# IPFire is distributed in the hope that it will be useful, #
	12	# but WITHOUT ANY WARRANTY; without even the implied warranty of #
	13	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
	14	# GNU General Public License for more details. #
	15	# #
	16	# You should have received a copy of the GNU General Public License #
	17	# along with IPFire; if not, write to the Free Software #
	18	# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA #
	19	# #
	20	# Copyright (C) 2018 IPFire Team <info@ipfire.org>. #
	21	# #
	22	############################################################################
	23
	24	package IDS;
	25
	26	require '/var/ipfire/general-functions.pl';
8dcebe53	27
02844177	28	# Location where all config and settings files are stored.
164eab66	29	our $settingsdir = "${General::swroot}/suricata";
02844177	30
eea2670b	31	# Location and name of the tarball which contains the ruleset.
164eab66	32	our $rulestarball = "/var/tmp/idsrules.tar.gz";
eea2670b	33
3983aebd	34	# File to store any errors, which also will be read and displayed by the wui.
77910792	35	our $storederrorfile = "/tmp/ids_storederror";
3983aebd	36
298ef5ba	37	# Location where the rulefiles are stored.
164eab66	38	our $rulespath = "/etc/suricata/rules";
298ef5ba	39
bce84f39 SS	40	# File which contains a list of all supported ruleset sources.
	41	# (Sourcefire, Emergingthreads, etc..)
	42	our $rulesetsourcesfile = "$settingsdir/ruleset-sources";
	43
796eea21 SS	44	# The pidfile of the IDS.
	45	our $idspidfile = "/var/run/suricata.pid";
	46
8dcebe53 SS	47	#
	48	## Function for checking if at least 300MB of free disk space are available
	49	## on the "/var" partition.
	50	#
	51	sub checkdiskspace () {
	52	# Call diskfree to gather the free disk space of /var.
	53	my @df = `/bin/df -B M /var`;
	54
	55	# Loop through the output.
	56	foreach my $line (@df) {
	57	# Ignore header line.
	58	next if $line =~ m/^Filesystem/;
	59
	60	# Search for a line with the device information.
	61	if ($line =~ m/dev/ ) {
	62	# Split the line into single pieces.
	63	my @values = split(' ', $line);
	64	my ($filesystem, $blocks, $used, $available, $used_perenctage, $mounted_on) = @values;
	65
	66	# Check if the available disk space is more than 300MB.
	67	if ($available < 300) {
434001d0 SS	68	# Log error to syslog.
434001d0 SS	69	&_log_to_syslog("Not enough free disk space on /var. Only $available MB from 300 MB available.");
8dcebe53	70
434001d0 SS	71	# Exit function and return "1" - False.
434001d0 SS	72	return 1;
8dcebe53 SS	73	}
	74	}
	75	}
	76
	77	# Everything okay, return nothing.
	78	return;
	79	}
	80
eea2670b SS	81	#
	82	## This function is responsible for downloading the configured snort ruleset.
	83	##
	84	## * At first it obtains from the stored snortsettings which ruleset should be downloaded.
	85	## * The next step is to get the download locations for all available rulesets.
	86	## * After that, the function will check if an upstream proxy should be used and grab the settings.
	87	## * The last step will be to generate the final download url, by obtaining the URL for the desired
	88	## ruleset, add the settings for the upstream proxy and final grab the rules tarball from the server.
	89	#
	90	sub downloadruleset {
	91	# Get snort settings.
	92	my %snortsettings=();
02844177	93	&General::readhash("$settingsdir/settings", \%snortsettings);
eea2670b SS	94
	95	# Get all available ruleset locations.
	96	my %rulesetsources=();
bce84f39	97	&General::readhash($rulesetsourcesfile, \%rulesetsources);
eea2670b SS	98
	99	# Read proxysettings.
	100	my %proxysettings=();
	101	&General::readhash("${General::swroot}/proxy/settings", \%proxysettings);
	102
	103	# Load required perl module to handle the download.
	104	use LWP::UserAgent;
	105
	106	# Init the download module.
	107	my $downloader = LWP::UserAgent->new;
	108
	109	# Set timeout to 10 seconds.
	110	$downloader->timeout(10);
	111
	112	# Check if an upstream proxy is configured.
	113	if ($proxysettings{'UPSTREAM_PROXY'}) {
	114	my ($peer, $peerport) = (/^(?:[a-zA-Z ]+\:\/\/)?(?:[A-Za-z0-9\_\.\-]?(?:\:[A-Za-z0-9\_\.\-]?)?\@)?([a-zA-Z0-9\.\_\-]?)(?:\:([0-9]{1,5}))?(?:\/.?)?$/);
	115	my $proxy_url;
	116
	117	# Check if we got a peer.
	118	if ($peer) {
	119	$proxy_url = "http://";
	120
	121	# Check if the proxy requires authentication.
	122	if (($proxysettings{'UPSTREAM_USER'}) && ($proxysettings{'UPSTREAM_PASSWORD'})) {
	123	$proxy_url .= "$proxysettings{'UPSTREAM_USER'}\:$proxysettings{'UPSTREAM_PASSWORD'}\@";
	124	}
	125
	126	# Add proxy server address and port.
	127	$proxy_url .= "$peer\:$peerport";
	128	} else {
434001d0 SS	129	# Log error message and break.
	130	&_log_to_syslog("Could not proper configure the proxy server access.");
	131
	132	# Return "1" - false.
	133	return 1;
eea2670b SS	134	}
	135
	136	# Setup proxy settings.
	137	$downloader->proxy('http', $proxy_url);
	138	}
	139
	140	# Grab the right url based on the configured vendor.
	141	my $url = $rulesetsources{$snortsettings{'RULES'}};
	142
	143	# Check if the vendor requires an oinkcode and add it if needed.
	144	$url =~ s/\<oinkcode\>/$snortsettings{'OINKCODE'}/g;
	145
	146	# Abort if no url could be determined for the vendor.
	147	unless ($url) {
434001d0 SS	148	# Log error and abort.
	149	&_log_to_syslog("Unable to gather a download URL for the selected ruleset.");
	150	return 1;
eea2670b SS	151	}
	152
	153	# Pass the requested url to the downloader.
	154	my $request = HTTP::Request->new(GET => $url);
	155
	156	# Perform the request and save the output into the "$rulestarball" file.
	157	my $response = $downloader->request($request, $rulestarball);
	158
	159	# Check if there was any error.
	160	unless ($response->is_success) {
434001d0 SS	161	# Log error message.
	162	&_log_to_syslog("Unable to download the ruleset. $response->status_line");
	163
	164	# Return "1" - false.
	165	return 1;
eea2670b SS	166	}
	167
	168	# If we got here, everything worked fine. Return nothing.
	169	return;
	170	}
8dcebe53	171
25f5cb0d SS	172	#
	173	## A tiny wrapper function to call the oinkmaster script.
	174	#
	175	sub oinkmaster () {
0e40e1e7 SS	176	# Load perl module to talk to the kernel syslog.
	177	use Sys::Syslog qw(:DEFAULT setlogsock);
	178
	179	# Establish the connection to the syslog service.
	180	openlog('oinkmaster', 'cons,pid', 'user');
	181
25f5cb0d	182	# Call oinkmaster to generate ruleset.
02844177	183	open(OINKMASTER, "/usr/local/bin/oinkmaster.pl -v -s -u file://$rulestarball -C $settingsdir/oinkmaster.conf -o $rulespath\|");
0e40e1e7 SS	184
	185	# Log output of oinkmaster to syslog.
	186	while(<OINKMASTER>) {
	187	# The syslog function works best with an array based input,
	188	# so generate one before passing the message details to syslog.
	189	my @syslog = ("INFO", "$_");
	190
	191	# Send the log message.
	192	syslog(@syslog);
	193	}
	194
	195	# Close the pipe to oinkmaster process.
	196	close(OINKMASTER);
	197
	198	# Close the log handle.
	199	closelog();
25f5cb0d SS	200	}
25f5cb0d SS	201
3983aebd SS	202	#
	203	## Function to do all the logging stuff if the downloading or updating of the ruleset fails.
	204	#
	205	sub log_error ($) {
	206	my ($error) = @_;
	207
	208	# Remove any newline.
	209	chomp($error);
	210
eb5592c1 SS	211	# Call private function to log the error message to syslog.
	212	&_log_to_syslog($error);
	213
3983aebd SS	214	# Call private function to write/store the error message in the storederrorfile.
	215	&_store_error_message($error);
	216	}
	217
eb5592c1 SS	218	#
	219	## Function to log a given error message to the kernel syslog.
	220	#
	221	sub _log_to_syslog ($) {
	222	my ($message) = @_;
	223
	224	# Load perl module to talk to the kernel syslog.
	225	use Sys::Syslog qw(:DEFAULT setlogsock);
	226
	227	# The syslog function works best with an array based input,
	228	# so generate one before passing the message details to syslog.
	229	my @syslog = ("ERR", "<ERROR> $message");
	230
	231	# Establish the connection to the syslog service.
	232	openlog('oinkmaster', 'cons,pid', 'user');
	233
	234	# Send the log message.
	235	syslog(@syslog);
	236
	237	# Close the log handle.
	238	closelog();
	239	}
	240
3983aebd SS	241	#
	242	## Private function to write a given error message to the storederror file.
	243	#
	244	sub _store_error_message ($) {
	245	my ($message) = @_;
	246
	247	# Remove any newline.
	248	chomp($message);
	249
	250	# Open file for writing.
	251	open (ERRORFILE, ">$storederrorfile") or die "Could not write to $storederrorfile. $!\n";
	252
	253	# Write error to file.
	254	print ERRORFILE "$message\n";
	255
	256	# Close file.
	257	close (ERRORFILE);
	258	}
	259
1cae702c SS	260	#
	261	## Function to get a list of all available network zones.
	262	#
	263	sub get_available_network_zones () {
	264	# Get netsettings.
	265	my %netsettings = ();
	266	&General::readhash("${General::swroot}/ethernet/settings", \%netsettings);
	267
	268	# Obtain the configuration type from the netsettings hash.
	269	my $config_type = $netsettings{'CONFIG_TYPE'};
	270
	271	# Hash which contains the conversation from the config mode
	272	# to the existing network interface names. They are stored like
	273	# an array.
	274	#
	275	# Mode "0" red is a modem and green
	276	# Mode "1" red is a netdev and green
	277	# Mode "2" red, green and orange
	278	# Mode "3" red, green and blue
	279	# Mode "4" red, green, blue, orange
	280	my %config_type_to_interfaces = (
	281	"0" => [ "red", "green" ],
	282	"1" => [ "red", "green" ],
	283	"2" => [ "red", "green", "orange" ],
	284	"3" => [ "red", "green", "blue" ],
	285	"4" => [ "red", "green", "blue", "orange" ]
	286	);
	287
	288	# Obtain and dereference the corresponding network interaces based on the read
	289	# network config type.
	290	my @network_zones = @{ $config_type_to_interfaces{$config_type} };
	291
	292	# Return them.
	293	return @network_zones;
	294	}
	295
796eea21 SS	296	#
	297	## Function to check if the IDS is running.
	298	#
	299	sub ids_is_running () {
	300	if(-f $idspidfile) {
	301	# Open PID file for reading.
	302	open(PIDFILE, "$idspidfile") or die "Could not open $idspidfile. $!\n";
	303
	304	# Grab the process-id.
	305	my $pid = <PIDFILE>;
	306
	307	# Close filehandle.
	308	close(PIDFILE);
	309
	310	# Remove any newline.
	311	chomp($pid);
	312
	313	# Check if a directory for the process-id exists in proc.
	314	if(-d "/proc/$pid") {
	315	# The IDS daemon is running return the process id.
	316	return $pid;
	317	}
	318	}
	319
	320	# Return nothing - IDS is not running.
	321	return;
	322	}
	323
8dcebe53	324	1;