rule
Sponsored Links
Sponsored Links
Secleted [ 0 ] software to compare
Results 1 - 15 of about 840
ruleCore 1.0
ruleCore provides a rule engine for event pattern detection. more>>
ruleCore provides a rule engine for event pattern detection.
The ruleCore Engine is an event-driven rule engine that manages and executes reaction rules. The rules are event-condition-action (ECA) style of rules.
The ruleCore Engine provides capabilities for detection of complex patterns of events, called situations. Events can be combined with logical and temporal operators in order to describe complex situations.
When a situation is detected, the ruleCore Engine can execute an action to alert external applications or users of the situation. The ruleCore Engine is fed with events through connectors.
Currently, connector implementations exist for plain sockets, XML-RPC, IBM WebSphere MQ, and TIBCO Rendezvous. Experimental support exists for running the engine within Zope and calling Zope methods when a rule triggers its action.
<<lessThe ruleCore Engine is an event-driven rule engine that manages and executes reaction rules. The rules are event-condition-action (ECA) style of rules.
The ruleCore Engine provides capabilities for detection of complex patterns of events, called situations. Events can be combined with logical and temporal operators in order to describe complex situations.
When a situation is detected, the ruleCore Engine can execute an action to alert external applications or users of the situation. The ruleCore Engine is fed with events through connectors.
Currently, connector implementations exist for plain sockets, XML-RPC, IBM WebSphere MQ, and TIBCO Rendezvous. Experimental support exists for running the engine within Zope and calling Zope methods when a rule triggers its action.
Download (18.8MB)
Added: 2007-02-19 License: GPL (GNU General Public License) Price:
978 downloads
Snort::Rule 1.03
Snort::Rule is a Perl extension for dynamically building snort rules. more>>
Snort::Rule is a Perl extension for dynamically building snort rules.
SYNOPSIS
use Snort::Rule;
$rule = Snort::Rule->new(
-action => alert,
-proto => tcp,
-src => any,
-sport => any,
-dir => ->,
-dst => 192.188.1.1,
-dport => 44444,
);
$rule->opts(msg,Test Rule");
$rule->opts(threshold,type limit,track by_src,count 1,seconds 3600);
$rule->opts(sid,500000);
print $rule->string()."n";
OR
$rule = alert tcp $SMTP_SERVERS any -> $EXTERNAL_NET 25 (msg:"BLEEDING-EDGE POLICY SMTP US Top Secret PROPIN"; flow:to_server,established; content:"Subject|3A|"; pcre:"/(TOPsSECRET|TS)//[sw,/-]*PROPIN[sw,/-]*(?=//(25)?X[1-9])/ism"; classtype:policy-violation; sid:2002448; rev:1;);
$rule = Snort::Rule->new(-parse => $rule);
print $rule->string()."n";
This is a very simple snort rule object. It was developed to allow for scripted dynamic rule creation. Ideally you could dynamically take a list of bad hosts and build an array of snort rule objects from that list. Then write that list using the string() method to a snort rules file.
<<lessSYNOPSIS
use Snort::Rule;
$rule = Snort::Rule->new(
-action => alert,
-proto => tcp,
-src => any,
-sport => any,
-dir => ->,
-dst => 192.188.1.1,
-dport => 44444,
);
$rule->opts(msg,Test Rule");
$rule->opts(threshold,type limit,track by_src,count 1,seconds 3600);
$rule->opts(sid,500000);
print $rule->string()."n";
OR
$rule = alert tcp $SMTP_SERVERS any -> $EXTERNAL_NET 25 (msg:"BLEEDING-EDGE POLICY SMTP US Top Secret PROPIN"; flow:to_server,established; content:"Subject|3A|"; pcre:"/(TOPsSECRET|TS)//[sw,/-]*PROPIN[sw,/-]*(?=//(25)?X[1-9])/ism"; classtype:policy-violation; sid:2002448; rev:1;);
$rule = Snort::Rule->new(-parse => $rule);
print $rule->string()."n";
This is a very simple snort rule object. It was developed to allow for scripted dynamic rule creation. Ideally you could dynamically take a list of bad hosts and build an array of snort rule objects from that list. Then write that list using the string() method to a snort rules file.
Download (0.005MB)
Added: 2006-09-02 License: Perl Artistic License Price:
1226 downloads
FSA::Rules 0.26
FSA::Rules is a Perl module to build simple rules-based state machines in Perl. more>>
FSA::Rules is a Perl module to build simple rules-based state machines in Perl.
Synopsis
my $fsa = FSA::Rules->new(
ping => {
do => sub {
print "ping!n";
my $state = shift;
$state->result(pong);
$state->machine->{count}++;
},
rules => [
game_over => sub { shift->machine->{count} >= 20 },
pong => sub { shift->result eq pong },
],
},
pong => {
do => sub { print "pong!n" },
rules => [ ping => 1, ], # always goes back to ping
},
game_over => { do => sub { print "Game Overn" } }
);
$fsa->start;
$fsa->switch until $fsa->at(game_over);
This class implements a simple state machine pattern, allowing you to quickly build rules-based state machines in Perl. As a simple implementation of a powerful concept, it differs slightly from an ideal DFA model in that it does not enforce a single possible switch from one state to another. Rather, it short circuits the evaluation of the rules for such switches, so that the first rule to return a true value will trigger its switch and no other switch rules will be checked. (But see the strict attribute and parameter to new().) It differs from an NFA model in that it offers no back-tracking. But in truth, you can use it to build a state machine that adheres to either model--hence the more generic FSA moniker.
FSA::Rules uses named states so that its easy to tell what state youre in and what state you want to go to. Each state may optionally define actions that are triggered upon entering the state, after entering the state, and upon exiting the state. They may also define rules for switching to other states, and these rules may specify the execution of switch-specific actions. All actions are defined in terms of anonymous subroutines that should expect an FSA::State object itself to be passed as the sole argument.
FSA::Rules objects and the FSA::State objects that make them up are all implemented as empty hash references. This design allows the action subroutines to use the FSA::State object passed as the sole argument, as well as the FSA::Rules object available via its machine() method, to stash data for other states to access, without the possibility of interfering with the state or the state machine itself.
<<lessSynopsis
my $fsa = FSA::Rules->new(
ping => {
do => sub {
print "ping!n";
my $state = shift;
$state->result(pong);
$state->machine->{count}++;
},
rules => [
game_over => sub { shift->machine->{count} >= 20 },
pong => sub { shift->result eq pong },
],
},
pong => {
do => sub { print "pong!n" },
rules => [ ping => 1, ], # always goes back to ping
},
game_over => { do => sub { print "Game Overn" } }
);
$fsa->start;
$fsa->switch until $fsa->at(game_over);
This class implements a simple state machine pattern, allowing you to quickly build rules-based state machines in Perl. As a simple implementation of a powerful concept, it differs slightly from an ideal DFA model in that it does not enforce a single possible switch from one state to another. Rather, it short circuits the evaluation of the rules for such switches, so that the first rule to return a true value will trigger its switch and no other switch rules will be checked. (But see the strict attribute and parameter to new().) It differs from an NFA model in that it offers no back-tracking. But in truth, you can use it to build a state machine that adheres to either model--hence the more generic FSA moniker.
FSA::Rules uses named states so that its easy to tell what state youre in and what state you want to go to. Each state may optionally define actions that are triggered upon entering the state, after entering the state, and upon exiting the state. They may also define rules for switching to other states, and these rules may specify the execution of switch-specific actions. All actions are defined in terms of anonymous subroutines that should expect an FSA::State object itself to be passed as the sole argument.
FSA::Rules objects and the FSA::State objects that make them up are all implemented as empty hash references. This design allows the action subroutines to use the FSA::State object passed as the sole argument, as well as the FSA::Rules object available via its machine() method, to stash data for other states to access, without the possibility of interfering with the state or the state machine itself.
Download (0.030MB)
Added: 2006-10-02 License: Perl Artistic License Price:
1117 downloads
XML::Rules 0.18
XML::Rules is a Perl module that can parse XML & process tags by rules starting from leaves. more>>
XML::Rules is a Perl module that can parse XML & process tags by rules starting from leaves.
SYNOPSIS
use XML::Rules;
$xml = < < *END*
< doc >
< person >
< fname >...< /fname >
< lname >...< /lname >
< email >...< /email >
< address >
< street >...< /street >
< city >...< /city >
< country >...< /country >
< bogus >...< /bogus >
< /address >
< phones >
< phone type="home" >123-456-7890< /phone >
< phone type="office" >663-486-7890< /phone >
< phone type="fax" >663-486-7000< /phone >
< /phones >
< /person >
< person >
< fname >...< /fname >
< lname >...< /lname >
< email >...< /email >
< address >
< street >...< /street >
< city >...< /city >
< country >...< /country >
< bogus >...< /bogus >
< /address >
< phones >
< phone type="office" >663-486-7891< /phone >
< /phones >
< /person >
< /doc >
*END*
@rules = (
_default = > sub {$_[0] = > $_[1]- >{_content}},
# by default Im only interested in the content of the tag, not the attributes
bogus = > undef,
# lets ignore this tag and all inner ones as well
address = > sub {address = > "$_[1]- >{street}, $_[1]- >{city} ($_[1]- >{country})"},
# merge the address into a single string
phone = > sub {$_[1]- >{type} = > $_[1]- >{content}},
# lets use the "type" attribute as the key and the content as the value
phones = > sub {delete $_[1]- >{_content}; %{$_[1]}},
# remove the text content and pass along the type = > content from the child nodes
person = > sub { # lets print the values, all the data is readily available in the attributes
print "$_[1]- >{lname}, $_[1]- >{fname} < $_[1]- >{email} >n";
print "Home phone: $_[1]- >{home}n" if $_[1]- >{home};
print "Office phone: $_[1]- >{office}n" if $_[1]- >{office};
print "Fax: $_[1]- >{fax}n" if $_[1]- >{fax};
print "$_[1]- >{address}nn";
return; # the < person > tag is processed, no need to remember what it contained
},
);
$parser = XML::Rules- >new(rules = > @rules);
$parser- >parse( $xml);
<<lessSYNOPSIS
use XML::Rules;
$xml = < < *END*
< doc >
< person >
< fname >...< /fname >
< lname >...< /lname >
< email >...< /email >
< address >
< street >...< /street >
< city >...< /city >
< country >...< /country >
< bogus >...< /bogus >
< /address >
< phones >
< phone type="home" >123-456-7890< /phone >
< phone type="office" >663-486-7890< /phone >
< phone type="fax" >663-486-7000< /phone >
< /phones >
< /person >
< person >
< fname >...< /fname >
< lname >...< /lname >
< email >...< /email >
< address >
< street >...< /street >
< city >...< /city >
< country >...< /country >
< bogus >...< /bogus >
< /address >
< phones >
< phone type="office" >663-486-7891< /phone >
< /phones >
< /person >
< /doc >
*END*
@rules = (
_default = > sub {$_[0] = > $_[1]- >{_content}},
# by default Im only interested in the content of the tag, not the attributes
bogus = > undef,
# lets ignore this tag and all inner ones as well
address = > sub {address = > "$_[1]- >{street}, $_[1]- >{city} ($_[1]- >{country})"},
# merge the address into a single string
phone = > sub {$_[1]- >{type} = > $_[1]- >{content}},
# lets use the "type" attribute as the key and the content as the value
phones = > sub {delete $_[1]- >{_content}; %{$_[1]}},
# remove the text content and pass along the type = > content from the child nodes
person = > sub { # lets print the values, all the data is readily available in the attributes
print "$_[1]- >{lname}, $_[1]- >{fname} < $_[1]- >{email} >n";
print "Home phone: $_[1]- >{home}n" if $_[1]- >{home};
print "Office phone: $_[1]- >{office}n" if $_[1]- >{office};
print "Fax: $_[1]- >{fax}n" if $_[1]- >{fax};
print "$_[1]- >{address}nn";
return; # the < person > tag is processed, no need to remember what it contained
},
);
$parser = XML::Rules- >new(rules = > @rules);
$parser- >parse( $xml);
Download (0.038MB)
Added: 2007-07-31 License: Perl Artistic License Price:
817 downloads
File::Find::Rule 0.30
File::Find::Rule is an alternative Perl interface to File::Find. more>>
SYNOPSIS
use File::Find::Rule;
# find all the subdirectories of a given directory
my @subdirs = File::Find::Rule->directory->in( $directory );
# find all the .pm files in @INC
my @files = File::Find::Rule->file()
->name( *.pm )
->in( @INC );
# as above, but without method chaining
my $rule = File::Find::Rule->new;
$rule->file;
$rule->name( *.pm );
my @files = $rule->in( @INC );
Download (0.014MB)
Added: 2007-04-26 License: Perl Artistic License Price:
911 downloads
Test::File::Find::Rule 1.00
Test::File::Find::Rule is a Perl module to test files and directories with File::Find::Rule. more>>
Test::File::Find::Rule is a Perl module to test files and directories with File::Find::Rule.
SYNOPSIS
use Test::File::Find::Rule;
# Check that all files in $dir have sensible names
my $rule = File::Find::Rule
->file
->relative
->not_name(qr/^[w]{1,8}.[a-z]{3,4}$/);
match_rule_no_result($rule, $dir, File names ok);
# Check that all our perl scripts have use strict !
my $rule = File::Find::Rule
->file
->relative
->name(@perl_ext)
->not_grep(qr/^s*uses+strict;/m, sub { 1 });
match_rule_no_result($rule, $dir, use strict usage);
# With some help of File::Find::Rule::MMagic
# Check that there is less than 10 images in $dir
# with a size > 1Mo
my $rule = File::Find::Rule
->file
->relative
->magic(image/*)
->size(>1Mo);
match_rule_nb_result($rule, $dir, 100, A lot of big images);
# Check the exact result from a rule
my $dirs = [qw(web lib data tmp)];
my $rule = File::Find::Rule
->directory
->mindepth(1)
->maxdepth(1)
->relative;
match_rule_array($rule, $dir, $dirs, Directory structure ok));
<<lessSYNOPSIS
use Test::File::Find::Rule;
# Check that all files in $dir have sensible names
my $rule = File::Find::Rule
->file
->relative
->not_name(qr/^[w]{1,8}.[a-z]{3,4}$/);
match_rule_no_result($rule, $dir, File names ok);
# Check that all our perl scripts have use strict !
my $rule = File::Find::Rule
->file
->relative
->name(@perl_ext)
->not_grep(qr/^s*uses+strict;/m, sub { 1 });
match_rule_no_result($rule, $dir, use strict usage);
# With some help of File::Find::Rule::MMagic
# Check that there is less than 10 images in $dir
# with a size > 1Mo
my $rule = File::Find::Rule
->file
->relative
->magic(image/*)
->size(>1Mo);
match_rule_nb_result($rule, $dir, 100, A lot of big images);
# Check the exact result from a rule
my $dirs = [qw(web lib data tmp)];
my $rule = File::Find::Rule
->directory
->mindepth(1)
->maxdepth(1)
->relative;
match_rule_array($rule, $dir, $dirs, Directory structure ok));
Download (0.003MB)
Added: 2007-05-04 License: Perl Artistic License Price:
903 downloads
File::Find::Rule::XPath 0.03
File::Find::Rule::XPath is a Perl module that contains rule to match on XPath expressions. more>>
File::Find::Rule::XPath is a Perl module that contains rule to match on XPath expressions.
SYNOPSIS
use File::Find::Rule::XPath;
my @files = File::Find::Rule->file
->name(*.dkb)
->xpath( //section/title[contains(., "Crustacean")] )
->in($root);
This module extends File::Find::Rule to provide the ability to locate XML files which match a given XPath expression.
METHODS
xpath( $xpath_expression )
Matches XML files which contain one or more nodes matching the given XPath expression. Files which are not well formed XML are silently skipped.
If no XPath expression is supplied, the value / is used. This will match all files which are well formed XML.
<<lessSYNOPSIS
use File::Find::Rule::XPath;
my @files = File::Find::Rule->file
->name(*.dkb)
->xpath( //section/title[contains(., "Crustacean")] )
->in($root);
This module extends File::Find::Rule to provide the ability to locate XML files which match a given XPath expression.
METHODS
xpath( $xpath_expression )
Matches XML files which contain one or more nodes matching the given XPath expression. Files which are not well formed XML are silently skipped.
If no XPath expression is supplied, the value / is used. This will match all files which are well formed XML.
Download (0.004MB)
Added: 2006-09-06 License: Perl Artistic License Price:
1143 downloads
Text::RewriteRules 0.10
Text::RewriteRules Perl module contains a system to rewrite text using regexp-based rules. more>>
Text::RewriteRules Perl module contains a system to rewrite text using regexp-based rules.
SYNOPSIS
use Text::RewriteRules;
RULES email
.==> DOT
@==> AT
ENDRULES
email("ambs@cpan.org") # returns ambs AT cpan DOT org
RULES/m inc
(d+)=e=> $1+1
ENDRULE
inc("I saw 11 cats and 23 docs") # returns I saw 12 cats and 24 docs
ABSTRACT
This module uses a simplified syntax for regexp-based rules for rewriting text. You define a set of rules, and the system applies them until no more rule can be applied.
Two variants are provided:
traditional rewrite (RULES function):
while it is possible do substitute
| apply first substitution rule
cursor based rewrite (RULES/m function):
add a cursor to the begining of the string
while not reach end of string
| apply substitute just after cursor and advance cursor
| or advance cursor if no rule can be applied
A lot of computer science problems can be solved using rewriting rules.
Rewriting rules consist of mainly two parts: a regexp (LHS: Left Hand Side) that is matched with the text, and the string to use to substitute the content matched with the regexp (RHS: Right Hand Side).
Now, why dont use a simple substitute? Because we want to define a set of rules and match them again and again, until no more regexp of the LHS matches.
A point of discussion is the syntax to define this system. A brief discussion shown that some users would prefer a function to receive an hash with the rules, some other, prefer some syntax sugar.
The approach used is the last: we use Filter::Simple such that we can add a specific non-perl syntax inside the Perl script. This improves legibility of big rewriting rules sytems.
This documentation is divided in two parts: first we will see the reference of the module. Kind of, what it does, with a brief explanation. Follows a tutorial which will be growing through time and releases.
<<lessSYNOPSIS
use Text::RewriteRules;
RULES email
.==> DOT
@==> AT
ENDRULES
email("ambs@cpan.org") # returns ambs AT cpan DOT org
RULES/m inc
(d+)=e=> $1+1
ENDRULE
inc("I saw 11 cats and 23 docs") # returns I saw 12 cats and 24 docs
ABSTRACT
This module uses a simplified syntax for regexp-based rules for rewriting text. You define a set of rules, and the system applies them until no more rule can be applied.
Two variants are provided:
traditional rewrite (RULES function):
while it is possible do substitute
| apply first substitution rule
cursor based rewrite (RULES/m function):
add a cursor to the begining of the string
while not reach end of string
| apply substitute just after cursor and advance cursor
| or advance cursor if no rule can be applied
A lot of computer science problems can be solved using rewriting rules.
Rewriting rules consist of mainly two parts: a regexp (LHS: Left Hand Side) that is matched with the text, and the string to use to substitute the content matched with the regexp (RHS: Right Hand Side).
Now, why dont use a simple substitute? Because we want to define a set of rules and match them again and again, until no more regexp of the LHS matches.
A point of discussion is the syntax to define this system. A brief discussion shown that some users would prefer a function to receive an hash with the rules, some other, prefer some syntax sugar.
The approach used is the last: we use Filter::Simple such that we can add a specific non-perl syntax inside the Perl script. This improves legibility of big rewriting rules sytems.
This documentation is divided in two parts: first we will see the reference of the module. Kind of, what it does, with a brief explanation. Follows a tutorial which will be growing through time and releases.
Download (0.008MB)
Added: 2007-07-10 License: Perl Artistic License Price:
837 downloads
Lingua::Phonology::Rules 0.32
Lingua::Phonology::Rules is a Perl module for defining and applying phonological rules. more>>
Lingua::Phonology::Rules is a Perl module for defining and applying phonological rules.
SYNOPSIS
use Lingua::Phonology;
$phono = new Lingua::Phonology;
$rules = $phono->rules;
# Adding and manipulating rules is discussed in the "WRITING RULES"
# section
This module allows for the creation of linguistic rules, and the application of those rules to "words" of Segment objects. You, the user, add rules to a Rules object, defining various parameters and code references that actually perform the action of the rule. Lingua::Phonology::Rules will take care of the guts of applying and creating rules.
The rules you create may have the following parameters. This is just a brief description of the parameters--a more detailed discussion of their effect is in the "WRITING RULES" section.
domain
Defines the domain within which the rule applies. This should be the name of a feature in the featureset of the segments which the rule is applied to.
tier
Defines the tier on which the rule applies. Must be the name of a feature in the feature set for the segments of the word you pass in.
direction
Defines the direction that the rule applies in. Must be either leftward or rightward. If no direction is given, defaults to rightward.
filter
Defines a filter for the segments that the rule applies on. Must a code reference that returns a truth value.
linguistic
Defines a linguistic-style rule to be parsed. When you provide a linguistic-style rule, it is parsed into code references that take the place of the where and do properties listed below. The format of linguistic rules is described in "LINGUISTIC-STYLE RULES" in Lingua::Phonology::FileFormatPOD.
where - defines the condition or conditions where the rule applies. Must be a coderef that returns a truth value. If no value is given, defaults to always true.
do - defines the action to take when the where condition is met. Must be a code reference. If no value is given, does nothing.
result - EXPERIMENTAL. Defines a condition that must be true after the do code has applied. Must be a code reference that returns a truth value. NOTE: This parameter depends on the module Whatif (available from CPAN), and will behave differently if this module is not present. See "Using result".
Lingua::Phonology::Rules is flexible and powerful enough to handle any sequential type of rule system. It cannot handle Optimality Theory-style processes, because those require a fundamentally different kind of algorithm.
<<lessSYNOPSIS
use Lingua::Phonology;
$phono = new Lingua::Phonology;
$rules = $phono->rules;
# Adding and manipulating rules is discussed in the "WRITING RULES"
# section
This module allows for the creation of linguistic rules, and the application of those rules to "words" of Segment objects. You, the user, add rules to a Rules object, defining various parameters and code references that actually perform the action of the rule. Lingua::Phonology::Rules will take care of the guts of applying and creating rules.
The rules you create may have the following parameters. This is just a brief description of the parameters--a more detailed discussion of their effect is in the "WRITING RULES" section.
domain
Defines the domain within which the rule applies. This should be the name of a feature in the featureset of the segments which the rule is applied to.
tier
Defines the tier on which the rule applies. Must be the name of a feature in the feature set for the segments of the word you pass in.
direction
Defines the direction that the rule applies in. Must be either leftward or rightward. If no direction is given, defaults to rightward.
filter
Defines a filter for the segments that the rule applies on. Must a code reference that returns a truth value.
linguistic
Defines a linguistic-style rule to be parsed. When you provide a linguistic-style rule, it is parsed into code references that take the place of the where and do properties listed below. The format of linguistic rules is described in "LINGUISTIC-STYLE RULES" in Lingua::Phonology::FileFormatPOD.
where - defines the condition or conditions where the rule applies. Must be a coderef that returns a truth value. If no value is given, defaults to always true.
do - defines the action to take when the where condition is met. Must be a code reference. If no value is given, does nothing.
result - EXPERIMENTAL. Defines a condition that must be true after the do code has applied. Must be a code reference that returns a truth value. NOTE: This parameter depends on the module Whatif (available from CPAN), and will behave differently if this module is not present. See "Using result".
Lingua::Phonology::Rules is flexible and powerful enough to handle any sequential type of rule system. It cannot handle Optimality Theory-style processes, because those require a fundamentally different kind of algorithm.
Download (0.097MB)
Added: 2007-07-16 License: Perl Artistic License Price:
831 downloads
Rule Set Based Access Control 1.3.5
Rule Set Based Access Control (RSBAC) is a Free Software security extension for current Linux kernels. more>>
Rule Set Based Access Control (RSBAC) is a Free Software security extension for current Linux kernels. Rule Set Based Access Control is based on the Generalized Framework for Access Control (GFAC) by Abrams and LaPadula and provides a flexible system of access control based on several modules.
All security relevant system calls are extended by security enforcement code. This code calls the central decision component, which in turn calls all active decision modules and generates a combined decision. This decision is then enforced by the system call extensions.
Main features:
- Free Open Source (GPL) Linux kernel security solution
- Independent of governments and big companies
- Several well-known and new security models, like MAC, ACL and RC
- On-access virus scanning with the Dazuko interface
- Detailed control over individual user and program network accesses
- Fully access controlled kernel level user management
- Any combination of security models possible
- Easily extensible: write your own model for runtime registration
- Support for latest kernels and stable for production use
Enhancements:
- This release relates to kernel 2.4.34.5 and 2.6.22.1.
- There are important fixes with some compilation errors and an important bug with User Management password hashing, introduced with the newer 2.6 kernel crypto API.
- Some security has been added with safety measures against null pointers.
<<lessAll security relevant system calls are extended by security enforcement code. This code calls the central decision component, which in turn calls all active decision modules and generates a combined decision. This decision is then enforced by the system call extensions.
Main features:
- Free Open Source (GPL) Linux kernel security solution
- Independent of governments and big companies
- Several well-known and new security models, like MAC, ACL and RC
- On-access virus scanning with the Dazuko interface
- Detailed control over individual user and program network accesses
- Fully access controlled kernel level user management
- Any combination of security models possible
- Easily extensible: write your own model for runtime registration
- Support for latest kernels and stable for production use
Enhancements:
- This release relates to kernel 2.4.34.5 and 2.6.22.1.
- There are important fixes with some compilation errors and an important bug with User Management password hashing, introduced with the newer 2.6 kernel crypto API.
- Some security has been added with safety measures against null pointers.
Download (0.36MB)
Added: 2007-07-20 License: GPL (GNU General Public License) Price:
831 downloads
Set up iptables NAT rules 1.2b2
Set up iptables NAT rules is an example IPTables 1.2.1 script for a multi-homed firewall. more>>
Set up iptables NAT rules is an example IPTables 1.2.1 script for a multi-homed firewall.
Please feel free to send me any comments or suggestions.
Current versions and documentation are available at http://www.sentry.net/~obsid/IPTables/rc.scripts.dir/current/
Sample:
## Variables ##
IPTABLES="/usr/local/sbin/iptables" ## Default IPTables >= v. 1.2.0
#IPTABLES="/usr/local/bin/iptables" ## Default IPTables<<less
Please feel free to send me any comments or suggestions.
Current versions and documentation are available at http://www.sentry.net/~obsid/IPTables/rc.scripts.dir/current/
Sample:
## Variables ##
IPTABLES="/usr/local/sbin/iptables" ## Default IPTables >= v. 1.2.0
#IPTABLES="/usr/local/bin/iptables" ## Default IPTables<<less
Download (MB)
Added: 2007-02-14 License: GPL (GNU General Public License) Price:
989 downloads
Basic Ipchains Firewall Rule Script 0.1.0 Beta
Basic Ipchains Firewall Rule Script is an iptables firewall script. more>>
Basic Ipchains Firewall Rule Script is an iptables firewall script.
WARNING THIS SCRIPT HAS NOT BEEN TESTED YET! USE AT YOUR OWN RISK.
TIPS:
- To test your ruleset without actually changing the firewall, you can change the IPTABLES variable below to "echo" and run the script. This will print a copy of the ruleset commands out to stdout (screen)
- To tidy it up even more, you could try this when you run the script with the "echo" setting:
/etc/rc.d/rc.firewall | grep ^- | sed s/^-/ipchains -/
- Or to create a prebuilt ruleset with your variables already set:
/etc/rc.d/rc.firewall | grep ^- | sed s/^-/ipchains -/ > newfile
Of course you will have to rerun this and create a new script whenever you change the variables in this script.
<<lessWARNING THIS SCRIPT HAS NOT BEEN TESTED YET! USE AT YOUR OWN RISK.
TIPS:
- To test your ruleset without actually changing the firewall, you can change the IPTABLES variable below to "echo" and run the script. This will print a copy of the ruleset commands out to stdout (screen)
- To tidy it up even more, you could try this when you run the script with the "echo" setting:
/etc/rc.d/rc.firewall | grep ^- | sed s/^-/ipchains -/
- Or to create a prebuilt ruleset with your variables already set:
/etc/rc.d/rc.firewall | grep ^- | sed s/^-/ipchains -/ > newfile
Of course you will have to rerun this and create a new script whenever you change the variables in this script.
Download (MB)
Added: 2007-02-14 License: GPL (GNU General Public License) Price:
982 downloads
Very restrictive set of firewall rules
Very restrictive set of firewall rules script is a sample firewall for ip_tables. more>>
Very restrictive set of firewall rules script is a sample firewall for ip_tables, the tool for doing firewalling and masquerading under the 2.3.x/2.4.x series of kernels.
Be warned, this is a very restrictive set of firewall rules (and they should be, for proper security). Anything that you do not _specifically_ allow is logged and dropped into /dev/null, so if youre wondering why something isnt working, check /var/log/messages.
This is about as close as you get to a secure firewall. Its nasty, its harsh, and it will make your machine nearly invisible to the rest of the internet world. Have fun.
To run this script you must chmod 700 iptables-script and then execute it. To stop it from running, run iptables -F
Sample:
#Point this to your copy of ip_tables
IPT="/usr/local/bin/iptables"
#Load the module.
modprobe ip_tables
#Flush old rules, delete the firewall chain if it exists
$IPT -F
$IPT -F -t nat
$IPT -X firewall
#Setup Masquerading. Change the IP to your internal network and uncomment
#this in order to enable it.
#$IPT -A POSTROUTING -t nat -s 192.168.1.0/24 -j MASQUERADE
#$IPT -P FORWARD ACCEPT
#echo 1 > /proc/sys/net/ipv4/ip_forward
#Set up the firewall chain
$IPT -N firewall
$IPT -A firewall -j LOG --log-level info --log-prefix "Firewall:"
$IPT -A firewall -j DROP
#Accept ourselves
$IPT -A INPUT -s 127.0.0.1/32 -d 127.0.0.1/32 -j ACCEPT
#If youre using IP Masquerading, change this IP to whatever your internl
#IP addres is and uncomment it
#$IPT -A INPUT -s 192.168.1.1/32 -d 0/0 -j ACCEPT
#Accept DNS, cause its warm and friendly
$IPT -A INPUT -p udp --source-port 53 -j ACCEPT
$IPT -A INPUT -p tcp --source-port 113 -j ACCEPT
$IPT -A INPUT -p tcp --destination-port 113 -j ACCEPT
#Allow ftp to send data back and forth.
$IPT -A INPUT -p tcp ! --syn --source-port 20 --destination-port 1024:65535 -j ACCEPT
#Accept SSH. Duh.
#$IPT -A INPUT -p tcp --destination-port 22 -j ACCEPT
#Send everything else ot the firewall.
$IPT -A INPUT -p icmp -j firewall
$IPT -A INPUT -p tcp --syn -j firewall
$IPT -A INPUT -p udp -j firewall
<<lessBe warned, this is a very restrictive set of firewall rules (and they should be, for proper security). Anything that you do not _specifically_ allow is logged and dropped into /dev/null, so if youre wondering why something isnt working, check /var/log/messages.
This is about as close as you get to a secure firewall. Its nasty, its harsh, and it will make your machine nearly invisible to the rest of the internet world. Have fun.
To run this script you must chmod 700 iptables-script and then execute it. To stop it from running, run iptables -F
Sample:
#Point this to your copy of ip_tables
IPT="/usr/local/bin/iptables"
#Load the module.
modprobe ip_tables
#Flush old rules, delete the firewall chain if it exists
$IPT -F
$IPT -F -t nat
$IPT -X firewall
#Setup Masquerading. Change the IP to your internal network and uncomment
#this in order to enable it.
#$IPT -A POSTROUTING -t nat -s 192.168.1.0/24 -j MASQUERADE
#$IPT -P FORWARD ACCEPT
#echo 1 > /proc/sys/net/ipv4/ip_forward
#Set up the firewall chain
$IPT -N firewall
$IPT -A firewall -j LOG --log-level info --log-prefix "Firewall:"
$IPT -A firewall -j DROP
#Accept ourselves
$IPT -A INPUT -s 127.0.0.1/32 -d 127.0.0.1/32 -j ACCEPT
#If youre using IP Masquerading, change this IP to whatever your internl
#IP addres is and uncomment it
#$IPT -A INPUT -s 192.168.1.1/32 -d 0/0 -j ACCEPT
#Accept DNS, cause its warm and friendly
$IPT -A INPUT -p udp --source-port 53 -j ACCEPT
$IPT -A INPUT -p tcp --source-port 113 -j ACCEPT
$IPT -A INPUT -p tcp --destination-port 113 -j ACCEPT
#Allow ftp to send data back and forth.
$IPT -A INPUT -p tcp ! --syn --source-port 20 --destination-port 1024:65535 -j ACCEPT
#Accept SSH. Duh.
#$IPT -A INPUT -p tcp --destination-port 22 -j ACCEPT
#Send everything else ot the firewall.
$IPT -A INPUT -p icmp -j firewall
$IPT -A INPUT -p tcp --syn -j firewall
$IPT -A INPUT -p udp -j firewall
Download (MB)
Added: 2007-02-14 License: GPL (GNU General Public License) Price:
984 downloads
Sakreble! 0.78
Sakreble! project is a word game. more>>
Sakreble! project is a word game. based loosely on Scrabble.
It is designed to be configurable to support different game boards, types of letters (for internationalization, point values, two-letter-glues, etc.), and rules.
Main features:
- Qt library, version >= 3.0
- libxml library, version >= 2.6
Enhancements:
- End game conditions rule parsed from config file and aplied.
<<lessIt is designed to be configurable to support different game boards, types of letters (for internationalization, point values, two-letter-glues, etc.), and rules.
Main features:
- Qt library, version >= 3.0
- libxml library, version >= 2.6
Enhancements:
- End game conditions rule parsed from config file and aplied.
Download (0.040MB)
Added: 2006-11-14 License: GPL (GNU General Public License) Price:
1074 downloads
TripleA 0.9.0.1
TripleA is a clone of the popular board game more>>
TripleA is an open source clone of the popular axis and allies boardgame.
TripleA game supports network play, alternative rule sets, and is easy to customize.
Enhancements:
- A lobby to find players on board, map scaling, an odds calculator, and new maps and rulesets were added.
<<lessTripleA game supports network play, alternative rule sets, and is easy to customize.
Enhancements:
- A lobby to find players on board, map scaling, an odds calculator, and new maps and rulesets were added.
Download (9.7MB)
Added: 2007-01-10 License: GPL (GNU General Public License) Price:
1080 downloads
Secleted [ 0 ] software to compare
Copyright Notice:
Software piracy is theft, Using crack, password, serial numbers, registration codes, key generators is illegal and prevent future software development. The above rule search only lists software in full, demo and trial versions for free download. Download links are directly from our mirror sites or publisher sites, torrent files or links from rapidshare.com, yousendit.com or megaupload.com are not allowed
