You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1367 lines
71 KiB
1367 lines
71 KiB
#!/usr/bin/env python
|
|
# Copyright 2015-2016, Tresys Technology, LLC
|
|
#
|
|
# This file is part of SETools.
|
|
#
|
|
# SETools 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.
|
|
#
|
|
# SETools 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 SETools. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
|
|
from __future__ import print_function
|
|
import setools
|
|
import argparse
|
|
import sys
|
|
import logging
|
|
from itertools import chain
|
|
|
|
parser = argparse.ArgumentParser(
|
|
description="SELinux policy semantic difference tool.",
|
|
epilog="If no differences are selected, all differences will be printed.")
|
|
parser.add_argument("POLICY1", help="Path to the first SELinux policy to diff.", nargs=1)
|
|
parser.add_argument("POLICY2", help="Path to the second SELinux policy to diff.", nargs=1)
|
|
parser.add_argument("--version", action="version", version=setools.__version__)
|
|
parser.add_argument("--stats", action="store_true", help="Display only statistics.")
|
|
parser.add_argument("-v", "--verbose", action="store_true",
|
|
help="Print extra informational messages")
|
|
parser.add_argument("--debug", action="store_true", dest="debug", help="Enable debugging.")
|
|
|
|
comp = parser.add_argument_group("component differences")
|
|
comp.add_argument("--common", action="store_true", help="Print common differences")
|
|
comp.add_argument("-c", "--class", action="store_true", help="Print class differences",
|
|
dest="class_")
|
|
comp.add_argument("-t", "--type", action="store_true", help="Print type differences",
|
|
dest="type_")
|
|
comp.add_argument("-a", "--attribute", action="store_true", help="Print type attribute differences")
|
|
comp.add_argument("-r", "--role", action="store_true", help="Print role differences")
|
|
comp.add_argument("-u", "--user", action="store_true", help="Print user differences")
|
|
comp.add_argument("-b", "--bool", action="store_true", help="Print Boolean differences",
|
|
dest="bool_")
|
|
comp.add_argument("--sensitivity", action="store_true", help="Print MLS sensitivity differences")
|
|
comp.add_argument("--category", action="store_true", help="Print MLS category differences")
|
|
comp.add_argument("--level", action="store_true", help="Print MLS level definition differences")
|
|
|
|
terule = parser.add_argument_group("type enforcement rule differences")
|
|
terule.add_argument("-A", action="store_true", help="Print allow and allowxperm rule differences")
|
|
terule.add_argument("--allow", action="store_true", help="Print allow rule differences")
|
|
terule.add_argument("--neverallow", action="store_true", help="Print neverallow rule differences")
|
|
terule.add_argument("--auditallow", action="store_true", help="Print auditallow rule differences")
|
|
terule.add_argument("--dontaudit", action="store_true", help="Print dontaudit rule differences")
|
|
terule.add_argument("--allowxperm", action="store_true", help="Print allowxperm rule differences")
|
|
terule.add_argument("--neverallowxperm", action="store_true",
|
|
help="Print neverallowxperm rule differences")
|
|
terule.add_argument("--auditallowxperm", action="store_true",
|
|
help="Print auditallowxperm rule differences")
|
|
terule.add_argument("--dontauditxperm", action="store_true",
|
|
help="Print dontauditxperm rule differences")
|
|
terule.add_argument("-T", "--type_trans", action="store_true",
|
|
help="Print type_transition rule differences")
|
|
terule.add_argument("--type_change", action="store_true", help="Print type_change rule differences")
|
|
terule.add_argument("--type_member", action="store_true",
|
|
help="Print type_member rule differences")
|
|
|
|
rbacrule = parser.add_argument_group("RBAC rule differences")
|
|
rbacrule.add_argument("--role_allow", action="store_true", help="Print role allow rule differences")
|
|
rbacrule.add_argument("--role_trans", action="store_true",
|
|
help="Print role_transition rule differences")
|
|
|
|
mlsrule = parser.add_argument_group("MLS rule differences")
|
|
mlsrule.add_argument("--range_trans", action="store_true",
|
|
help="Print range_transition rule differences")
|
|
|
|
constrain = parser.add_argument_group("Constraint differences")
|
|
constrain.add_argument("--constrain", action="store_true", help="Print constrain differences")
|
|
constrain.add_argument("--mlsconstrain", action="store_true", help="Print mlsconstrain differences")
|
|
constrain.add_argument("--validatetrans", action="store_true",
|
|
help="Print validatetrans differences")
|
|
constrain.add_argument("--mlsvalidatetrans", action="store_true",
|
|
help="Print mlsvalidatetrans differences")
|
|
|
|
labeling = parser.add_argument_group("labeling statement differences")
|
|
labeling.add_argument("--initialsid", action="store_true", help="Print initial SID differences")
|
|
labeling.add_argument("--fs_use", action="store_true", help="Print fs_use_* differences")
|
|
labeling.add_argument("--genfscon", action="store_true", help="Print genfscon differences")
|
|
labeling.add_argument("--netifcon", action="store_true", help="Print netifcon differences")
|
|
labeling.add_argument("--nodecon", action="store_true", help="Print nodecon differences")
|
|
labeling.add_argument("--portcon", action="store_true", help="Print portcon differences")
|
|
|
|
other = parser.add_argument_group("other differences")
|
|
other.add_argument("--default", action="store_true", help="Print default_* differences")
|
|
other.add_argument("--property", action="store_true",
|
|
help="Print policy property differences (handle_unknown, version, MLS)")
|
|
other.add_argument("--polcap", action="store_true", help="Print policy capability differences")
|
|
other.add_argument("--typebounds", action="store_true", help="Print typebounds differences")
|
|
|
|
args = parser.parse_args()
|
|
|
|
if args.A:
|
|
args.allow = True
|
|
args.allowxperm = True
|
|
|
|
all_differences = not any((args.class_, args.common, args.type_, args.attribute, args.role,
|
|
args.user, args.bool_, args.sensitivity, args.category, args.level,
|
|
args.allow, args.neverallow, args.auditallow, args.dontaudit,
|
|
args.type_trans, args.type_change, args.type_member, args.role_allow,
|
|
args.role_trans, args.range_trans, args.initialsid, args.genfscon,
|
|
args.netifcon, args.nodecon, args.portcon, args.fs_use, args.polcap,
|
|
args.property, args.default, args.constrain, args.mlsconstrain,
|
|
args.validatetrans, args.mlsvalidatetrans, args.typebounds,
|
|
args.allowxperm, args.neverallowxperm, args.auditallowxperm,
|
|
args.dontauditxperm))
|
|
|
|
if args.debug:
|
|
logging.basicConfig(level=logging.DEBUG,
|
|
format='%(asctime)s|%(levelname)s|%(name)s|%(message)s')
|
|
elif args.verbose:
|
|
logging.basicConfig(level=logging.INFO, format='%(message)s')
|
|
else:
|
|
logging.basicConfig(level=logging.WARNING, format='%(message)s')
|
|
|
|
try:
|
|
p1 = setools.SELinuxPolicy(args.POLICY1[0])
|
|
p2 = setools.SELinuxPolicy(args.POLICY2[0])
|
|
diff = setools.PolicyDifference(p1, p2)
|
|
|
|
if all_differences or args.property:
|
|
print("Policy Properties ({0} Modified)".format(len(diff.modified_properties)))
|
|
|
|
if diff.modified_properties and not args.stats:
|
|
for name, added, removed in sorted(diff.modified_properties, key=lambda x: x.property):
|
|
print(" * {0} +{1} -{2}".format(name, added, removed))
|
|
|
|
print()
|
|
|
|
if all_differences or args.common:
|
|
if diff.added_commons or diff.removed_commons or diff.modified_commons or args.common:
|
|
print("Commons ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_commons), len(diff.removed_commons), len(diff.modified_commons)))
|
|
if diff.added_commons and not args.stats:
|
|
print(" Added Commons: {0}".format(len(diff.added_commons)))
|
|
for c in sorted(diff.added_commons):
|
|
print(" + {0}".format(c))
|
|
if diff.removed_commons and not args.stats:
|
|
print(" Removed Commons: {0}".format(len(diff.removed_commons)))
|
|
for c in sorted(diff.removed_commons):
|
|
print(" - {0}".format(c))
|
|
if diff.modified_commons and not args.stats:
|
|
print(" Modified Commons: {0}".format(len(diff.modified_commons)))
|
|
for name, mod in sorted(diff.modified_commons.items()):
|
|
change = []
|
|
if mod.added_perms:
|
|
change.append("{0} Added permissions".format(len(mod.added_perms)))
|
|
if mod.removed_perms:
|
|
change.append("{0} Removed permissions".format(len(mod.removed_perms)))
|
|
|
|
print(" * {0} ({1})".format(name, ", ".join(change)))
|
|
for p in sorted(mod.added_perms):
|
|
print(" + {0}".format(p))
|
|
for p in sorted(mod.removed_perms):
|
|
print(" - {0}".format(p))
|
|
print()
|
|
|
|
if all_differences or args.class_:
|
|
if diff.added_classes or diff.removed_classes or diff.modified_classes or args.class_:
|
|
print("Classes ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_classes), len(diff.removed_classes), len(diff.modified_classes)))
|
|
if diff.added_classes and not args.stats:
|
|
print(" Added Classes: {0}".format(len(diff.added_classes)))
|
|
for c in sorted(diff.added_classes):
|
|
print(" + {0}".format(c))
|
|
if diff.removed_classes and not args.stats:
|
|
print(" Removed Classes: {0}".format(len(diff.removed_classes)))
|
|
for c in sorted(diff.removed_classes):
|
|
print(" - {0}".format(c))
|
|
if diff.modified_classes and not args.stats:
|
|
print(" Modified Classes: {0}".format(len(diff.modified_classes)))
|
|
for name, mod in sorted(diff.modified_classes.items()):
|
|
change = []
|
|
if mod.added_perms:
|
|
change.append("{0} Added permissions".format(len(mod.added_perms)))
|
|
if mod.removed_perms:
|
|
change.append("{0} Removed permissions".format(len(mod.removed_perms)))
|
|
|
|
print(" * {0} ({1})".format(name, ", ".join(change)))
|
|
for p in sorted(mod.added_perms):
|
|
print(" + {0}".format(p))
|
|
for p in sorted(mod.removed_perms):
|
|
print(" - {0}".format(p))
|
|
print()
|
|
|
|
if all_differences or args.bool_:
|
|
if diff.added_booleans or diff.removed_booleans or \
|
|
diff.modified_booleans or args.bool_:
|
|
print("Booleans ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_booleans), len(diff.removed_booleans),
|
|
len(diff.modified_booleans)))
|
|
if diff.added_booleans and not args.stats:
|
|
print(" Added Booleans: {0}".format(len(diff.added_booleans)))
|
|
for a in sorted(diff.added_booleans):
|
|
print(" + {0}".format(a))
|
|
if diff.removed_booleans and not args.stats:
|
|
print(" Removed Booleans: {0}".format(len(diff.removed_booleans)))
|
|
for a in sorted(diff.removed_booleans):
|
|
print(" - {0}".format(a))
|
|
if diff.modified_booleans and not args.stats:
|
|
print(" Modified Booleans: {0}".format(len(diff.modified_booleans)))
|
|
for name, mod in sorted(diff.modified_booleans.items()):
|
|
print(" * {0} (Modified default state)".format(name))
|
|
print(" + {0}".format(mod.added_state))
|
|
print(" - {0}".format(mod.removed_state))
|
|
|
|
print()
|
|
|
|
if all_differences or args.role:
|
|
if diff.added_roles or diff.removed_roles or diff.modified_roles or args.role:
|
|
print("Roles ({0} Added, {1} Removed, {2} Modified)".format(len(diff.added_roles),
|
|
len(diff.removed_roles),
|
|
len(diff.modified_roles)))
|
|
if diff.added_roles and not args.stats:
|
|
print(" Added Roles: {0}".format(len(diff.added_roles)))
|
|
for r in sorted(diff.added_roles):
|
|
print(" + {0}".format(r))
|
|
if diff.removed_roles and not args.stats:
|
|
print(" Removed Roles: {0}".format(len(diff.removed_roles)))
|
|
for r in sorted(diff.removed_roles):
|
|
print(" - {0}".format(r))
|
|
if diff.modified_roles and not args.stats:
|
|
print(" Modified Roles: {0}".format(len(diff.modified_roles)))
|
|
for name, mod in sorted(diff.modified_roles.items()):
|
|
change = []
|
|
if mod.added_types:
|
|
change.append("{0} Added types".format(len(mod.added_types)))
|
|
if mod.removed_types:
|
|
change.append("{0} Removed types".format(len(mod.removed_types)))
|
|
|
|
print(" * {0} ({1})".format(name, ", ".join(change)))
|
|
for t in sorted(mod.added_types):
|
|
print(" + {0}".format(t))
|
|
for t in sorted(mod.removed_types):
|
|
print(" - {0}".format(t))
|
|
print()
|
|
|
|
if all_differences or args.type_:
|
|
if diff.added_types or diff.removed_types or diff.modified_types or args.type_:
|
|
print("Types ({0} Added, {1} Removed, {2} Modified)".format(len(diff.added_types),
|
|
len(diff.removed_types),
|
|
len(diff.modified_types)))
|
|
if diff.added_types and not args.stats:
|
|
print(" Added Types: {0}".format(len(diff.added_types)))
|
|
for r in sorted(diff.added_types):
|
|
print(" + {0}".format(r))
|
|
if diff.removed_types and not args.stats:
|
|
print(" Removed Types: {0}".format(len(diff.removed_types)))
|
|
for r in sorted(diff.removed_types):
|
|
print(" - {0}".format(r))
|
|
if diff.modified_types and not args.stats:
|
|
print(" Modified Types: {0}".format(len(diff.modified_types)))
|
|
for name, mod in sorted(diff.modified_types.items()):
|
|
change = []
|
|
if mod.added_attributes:
|
|
change.append("{0} Added attributes".format(len(mod.added_attributes)))
|
|
if mod.removed_attributes:
|
|
change.append("{0} Removed attributes".format(len(mod.removed_attributes)))
|
|
if mod.added_aliases:
|
|
change.append("{0} Added aliases".format(len(mod.added_aliases)))
|
|
if mod.removed_aliases:
|
|
change.append("{0} Removed aliases".format(len(mod.removed_aliases)))
|
|
if mod.modified_permissive:
|
|
if mod.permissive:
|
|
change.append("Removed permissive")
|
|
else:
|
|
change.append("Added permissive")
|
|
|
|
print(" * {0} ({1})".format(name, ", ".join(change)))
|
|
if mod.added_attributes or mod.removed_attributes:
|
|
print(" Attributes:")
|
|
for t in sorted(mod.added_attributes):
|
|
print(" + {0}".format(t))
|
|
for t in sorted(mod.removed_attributes):
|
|
print(" - {0}".format(t))
|
|
|
|
if mod.added_aliases or mod.removed_aliases:
|
|
print(" Aliases:")
|
|
for t in sorted(mod.added_aliases):
|
|
print(" + {0}".format(t))
|
|
for t in sorted(mod.removed_aliases):
|
|
print(" - {0}".format(t))
|
|
|
|
print()
|
|
|
|
if all_differences or args.attribute:
|
|
if diff.added_type_attributes or diff.removed_type_attributes or \
|
|
diff.modified_type_attributes or args.attribute:
|
|
print("Type Attributes ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_type_attributes), len(diff.removed_type_attributes),
|
|
len(diff.modified_type_attributes)))
|
|
if diff.added_type_attributes and not args.stats:
|
|
print(" Added Type Attributes: {0}".format(len(diff.added_type_attributes)))
|
|
for a in sorted(diff.added_type_attributes):
|
|
print(" + {0}".format(a))
|
|
if diff.removed_type_attributes and not args.stats:
|
|
print(" Removed Type Attributes: {0}".format(len(diff.removed_type_attributes)))
|
|
for a in sorted(diff.removed_type_attributes):
|
|
print(" - {0}".format(a))
|
|
if diff.modified_type_attributes and not args.stats:
|
|
print(" Modified Type Attributes: {0}".format(len(diff.modified_type_attributes)))
|
|
for name, mod in sorted(diff.modified_type_attributes.items()):
|
|
change = []
|
|
if mod.added_types:
|
|
change.append("{0} Added types".format(len(mod.added_types)))
|
|
if mod.removed_types:
|
|
change.append("{0} Removed types".format(len(mod.removed_types)))
|
|
|
|
print(" * {0} ({1})".format(name, ", ".join(change)))
|
|
for t in sorted(mod.added_types):
|
|
print(" + {0}".format(t))
|
|
for t in sorted(mod.removed_types):
|
|
print(" - {0}".format(t))
|
|
print()
|
|
|
|
if all_differences or args.user:
|
|
if diff.added_users or diff.removed_users or diff.modified_users or args.user:
|
|
print("Users ({0} Added, {1} Removed, {2} Modified)".format(len(diff.added_users),
|
|
len(diff.removed_users),
|
|
len(diff.modified_users)))
|
|
if diff.added_users and not args.stats:
|
|
print(" Added Users: {0}".format(len(diff.added_users)))
|
|
for u in sorted(diff.added_users):
|
|
print(" + {0}".format(u))
|
|
if diff.removed_users and not args.stats:
|
|
print(" Removed Users: {0}".format(len(diff.removed_users)))
|
|
for u in sorted(diff.removed_users):
|
|
print(" - {0}".format(u))
|
|
if diff.modified_users and not args.stats:
|
|
print(" Modified Users: {0}".format(len(diff.modified_users)))
|
|
for name, mod in sorted(diff.modified_users.items()):
|
|
change = []
|
|
if mod.added_roles:
|
|
change.append("{0} Added roles".format(len(mod.added_roles)))
|
|
if mod.removed_roles:
|
|
change.append("{0} Removed roles".format(len(mod.removed_roles)))
|
|
if mod.removed_level:
|
|
change.append("Modified default level")
|
|
if mod.removed_range:
|
|
change.append("Modified range")
|
|
|
|
print(" * {0} ({1})".format(name, ", ".join(change)))
|
|
if mod.added_roles or mod.removed_roles:
|
|
print(" Roles:")
|
|
for t in sorted(mod.added_roles):
|
|
print(" + {0}".format(t))
|
|
for t in sorted(mod.removed_roles):
|
|
print(" - {0}".format(t))
|
|
|
|
if mod.removed_level:
|
|
print(" Default level:")
|
|
print(" + {0}".format(mod.added_level))
|
|
print(" - {0}".format(mod.removed_level))
|
|
|
|
if mod.removed_range:
|
|
print(" Range:")
|
|
print(" + {0}".format(mod.added_range))
|
|
print(" - {0}".format(mod.removed_range))
|
|
print()
|
|
|
|
if all_differences or args.category:
|
|
if diff.added_categories or diff.removed_categories or diff.modified_categories \
|
|
or args.category:
|
|
print("Categories ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_categories), len(diff.removed_categories),
|
|
len(diff.modified_categories)))
|
|
if diff.added_categories and not args.stats:
|
|
print(" Added Categories: {0}".format(len(diff.added_categories)))
|
|
for c in sorted(diff.added_categories):
|
|
print(" + {0}".format(c))
|
|
if diff.removed_categories and not args.stats:
|
|
print(" Removed Categories: {0}".format(len(diff.removed_categories)))
|
|
for c in sorted(diff.removed_categories):
|
|
print(" - {0}".format(c))
|
|
if diff.modified_categories and not args.stats:
|
|
print(" Modified Categories: {0}".format(len(diff.modified_categories)))
|
|
for name, mod in sorted(diff.modified_categories.items()):
|
|
change = []
|
|
if mod.added_aliases:
|
|
change.append("{0} Added Aliases".format(len(mod.added_aliases)))
|
|
if mod.removed_aliases:
|
|
change.append("{0} Removed Aliases".format(len(mod.removed_aliases)))
|
|
|
|
print(" * {0} ({1})".format(name, ", ".join(change)))
|
|
print(" Aliases:")
|
|
for a in sorted(mod.added_aliases):
|
|
print(" + {0}".format(a))
|
|
for a in sorted(mod.removed_aliases):
|
|
print(" - {0}".format(a))
|
|
|
|
print()
|
|
|
|
if all_differences or args.sensitivity:
|
|
if diff.added_sensitivities or diff.removed_sensitivities or diff.modified_sensitivities \
|
|
or args.sensitivity:
|
|
print("Sensitivities ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_sensitivities), len(diff.removed_sensitivities),
|
|
len(diff.modified_sensitivities)))
|
|
if diff.added_sensitivities and not args.stats:
|
|
print(" Added Sensitivites: {0}".format(len(diff.added_sensitivities)))
|
|
for s in sorted(diff.added_sensitivities):
|
|
print(" + {0}".format(s))
|
|
if diff.removed_sensitivities and not args.stats:
|
|
print(" Removed Sensitivities: {0}".format(len(diff.removed_sensitivities)))
|
|
for s in sorted(diff.removed_sensitivities):
|
|
print(" - {0}".format(s))
|
|
if diff.modified_sensitivities and not args.stats:
|
|
print(" Modified Sensitivities: {0}".format(len(diff.modified_sensitivities)))
|
|
for name, mod in sorted(diff.modified_sensitivities.items()):
|
|
change = []
|
|
if mod.added_aliases:
|
|
change.append("{0} Added Aliases".format(len(mod.added_aliases)))
|
|
if mod.removed_aliases:
|
|
change.append("{0} Removed Aliases".format(len(mod.removed_aliases)))
|
|
|
|
print(" * {0} ({1})".format(name, ", ".join(change)))
|
|
print(" Aliases:")
|
|
for a in sorted(mod.added_aliases):
|
|
print(" + {0}".format(a))
|
|
for a in sorted(mod.removed_aliases):
|
|
print(" - {0}".format(a))
|
|
|
|
print()
|
|
|
|
if all_differences or args.level:
|
|
if diff.added_levels or diff.removed_levels or \
|
|
diff.modified_levels or args.level:
|
|
print("Levels ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_levels), len(diff.removed_levels),
|
|
len(diff.modified_levels)))
|
|
if diff.added_levels and not args.stats:
|
|
print(" Added Levels: {0}".format(len(diff.added_levels)))
|
|
for l in sorted(diff.added_levels):
|
|
print(" + {0}".format(l))
|
|
if diff.removed_levels and not args.stats:
|
|
print(" Removed Levels: {0}".format(len(diff.removed_levels)))
|
|
for l in sorted(diff.removed_levels):
|
|
print(" - {0}".format(l))
|
|
if diff.modified_levels and not args.stats:
|
|
print(" Modified Levels: {0}".format(len(diff.modified_levels)))
|
|
for level, added_categories, removed_categories, _ in sorted(diff.modified_levels,
|
|
key=lambda x: x.level):
|
|
change = []
|
|
if added_categories:
|
|
change.append("{0} Added Categories".format(len(added_categories)))
|
|
if removed_categories:
|
|
change.append("{0} Removed Categories".format(len(removed_categories)))
|
|
|
|
print(" * {0} ({1})".format(level.sensitivity, ", ".join(change)))
|
|
for c in sorted(added_categories):
|
|
print(" + {0}".format(c))
|
|
for c in sorted(removed_categories):
|
|
print(" - {0}".format(c))
|
|
print()
|
|
|
|
if all_differences or args.allow:
|
|
if diff.added_allows or diff.removed_allows or diff.modified_allows or args.allow:
|
|
print("Allow Rules ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_allows), len(diff.removed_allows), len(diff.modified_allows)))
|
|
|
|
if diff.added_allows and not args.stats:
|
|
print(" Added Allow Rules: {0}".format(len(diff.added_allows)))
|
|
for r in sorted(diff.added_allows):
|
|
print(" + {0}".format(r))
|
|
|
|
if diff.removed_allows and not args.stats:
|
|
print(" Removed Allow Rules: {0}".format(len(diff.removed_allows)))
|
|
for r in sorted(diff.removed_allows):
|
|
print(" - {0}".format(r))
|
|
|
|
if diff.modified_allows and not args.stats:
|
|
print(" Modified Allow Rules: {0}".format(len(diff.modified_allows)))
|
|
|
|
for rule, added_perms, removed_perms, matched_perms in sorted(diff.modified_allows,
|
|
key=lambda x: x.rule):
|
|
perms = " ".join(chain((p for p in matched_perms),
|
|
("+" + p for p in added_perms),
|
|
("-" + p for p in removed_perms)))
|
|
rule_string = "{0.ruletype} {0.source} {0.target}:{0.tclass} {{ {1} }};".format(
|
|
rule, perms)
|
|
|
|
try:
|
|
rule_string += " [ {0} ]".format(rule.conditional)
|
|
except AttributeError:
|
|
pass
|
|
print(" * {0}".format(rule_string))
|
|
|
|
print()
|
|
|
|
if all_differences or args.allowxperm:
|
|
if diff.added_allowxperms or diff.removed_allowxperms or diff.modified_allowxperms \
|
|
or args.allowxperm:
|
|
|
|
print("Allowxperm Rules ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_allowxperms), len(diff.removed_allowxperms),
|
|
len(diff.modified_allowxperms)))
|
|
|
|
if diff.added_allowxperms and not args.stats:
|
|
print(" Added Allowxperm Rules: {0}".format(len(diff.added_allowxperms)))
|
|
for r in sorted(diff.added_allowxperms):
|
|
print(" + {0}".format(r))
|
|
|
|
if diff.removed_allowxperms and not args.stats:
|
|
print(" Removed Allowxperm Rules: {0}".format(len(diff.removed_allowxperms)))
|
|
for r in sorted(diff.removed_allowxperms):
|
|
print(" - {0}".format(r))
|
|
|
|
if diff.modified_allowxperms and not args.stats:
|
|
print(" Modified Allowxperm Rules: {0}".format(len(diff.modified_allowxperms)))
|
|
|
|
for rule, added_perms, removed_perms, matched_perms in sorted(
|
|
diff.modified_allowxperms, key=lambda x: x.rule):
|
|
|
|
# Process the string representation of the sets
|
|
# so hex representation and ranges are preserved.
|
|
# Check if the perm sets have contents, otherwise
|
|
# split on empty string will be an empty string.
|
|
# Add brackets to added and removed permissions
|
|
# in case there is a range of permissions.
|
|
perms = []
|
|
if matched_perms:
|
|
for p in str(matched_perms).split(" "):
|
|
perms.append(p)
|
|
if added_perms:
|
|
for p in str(added_perms).split(" "):
|
|
if '-' in p:
|
|
perms.append("+[{0}]".format(p))
|
|
else:
|
|
perms.append("+{0}".format(p))
|
|
if removed_perms:
|
|
for p in str(removed_perms).split(" "):
|
|
if '-' in p:
|
|
perms.append("-[{0}]".format(p))
|
|
else:
|
|
perms.append("-{0}".format(p))
|
|
|
|
rule_string = \
|
|
"{0.ruletype} {0.source} {0.target}:{0.tclass} {0.xperm_type} {{ {1} }};". \
|
|
format(rule, perms)
|
|
|
|
print(" * {0.ruletype} {0.source} {0.target}:{0.tclass} {0.xperm_type} "
|
|
"{{ {1} }};".format(rule, " ".join(perms)))
|
|
|
|
print()
|
|
|
|
if all_differences or args.neverallow:
|
|
if diff.added_neverallows or diff.removed_neverallows or diff.modified_neverallows or \
|
|
args.neverallow:
|
|
print("Neverallow Rules ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_neverallows), len(diff.removed_neverallows),
|
|
len(diff.modified_neverallows)))
|
|
|
|
if diff.added_neverallows and not args.stats:
|
|
print(" Added Neverallow Rules: {0}".format(len(diff.added_neverallows)))
|
|
for r in sorted(diff.added_neverallows):
|
|
print(" + {0}".format(r))
|
|
|
|
if diff.removed_neverallows and not args.stats:
|
|
print(" Removed Neverallow Rules: {0}".format(len(diff.removed_neverallows)))
|
|
for r in sorted(diff.removed_neverallows):
|
|
print(" - {0}".format(r))
|
|
|
|
if diff.modified_neverallows and not args.stats:
|
|
print(" Modified Neverallow Rules: {0}".format(len(diff.modified_neverallows)))
|
|
|
|
for rule, added_perms, removed_perms, matched_perms in sorted(
|
|
diff.modified_neverallows, key=lambda x: x.rule):
|
|
perms = " ".join(chain((p for p in matched_perms),
|
|
("+" + p for p in added_perms),
|
|
("-" + p for p in removed_perms)))
|
|
rule_string = "{0.ruletype} {0.source} {0.target}:{0.tclass} {{ {1} }};".format(
|
|
rule, perms)
|
|
|
|
try:
|
|
rule_string += " [ {0} ]".format(rule.conditional)
|
|
except AttributeError:
|
|
pass
|
|
print(" * {0}".format(rule_string))
|
|
|
|
print()
|
|
|
|
if all_differences or args.neverallowxperm:
|
|
if diff.added_neverallowxperms or diff.removed_neverallowxperms or \
|
|
diff.modified_neverallowxperms or args.neverallowxperm:
|
|
|
|
print("Neverallowxperm Rules ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_neverallowxperms), len(diff.removed_neverallowxperms),
|
|
len(diff.modified_neverallowxperms)))
|
|
|
|
if diff.added_neverallowxperms and not args.stats:
|
|
print(" Added Neverallowxperm Rules: {0}".format(
|
|
len(diff.added_neverallowxperms)))
|
|
for r in sorted(diff.added_neverallowxperms):
|
|
print(" + {0}".format(r))
|
|
|
|
if diff.removed_neverallowxperms and not args.stats:
|
|
print(" Removed Neverallowxperm Rules: {0}".format(
|
|
len(diff.removed_neverallowxperms)))
|
|
for r in sorted(diff.removed_neverallowxperms):
|
|
print(" - {0}".format(r))
|
|
|
|
if diff.modified_neverallowxperms and not args.stats:
|
|
print(" Modified Neverallowxperm Rules: {0}".format(
|
|
len(diff.modified_neverallowxperms)))
|
|
|
|
for rule, added_perms, removed_perms, matched_perms in sorted(
|
|
diff.modified_neverallowxperms, key=lambda x: x.rule):
|
|
|
|
# Process the string representation of the sets
|
|
# so hex representation and ranges are preserved.
|
|
# Check if the perm sets have contents, otherwise
|
|
# split on empty string will be an empty string.
|
|
# Add brackets to added and removed permissions
|
|
# in case there is a range of permissions.
|
|
perms = []
|
|
if matched_perms:
|
|
for p in str(matched_perms).split(" "):
|
|
perms.append(p)
|
|
if added_perms:
|
|
for p in str(added_perms).split(" "):
|
|
if '-' in p:
|
|
perms.append("+[{0}]".format(p))
|
|
else:
|
|
perms.append("+{0}".format(p))
|
|
if removed_perms:
|
|
for p in str(removed_perms).split(" "):
|
|
if '-' in p:
|
|
perms.append("-[{0}]".format(p))
|
|
else:
|
|
perms.append("-{0}".format(p))
|
|
|
|
rule_string = \
|
|
"{0.ruletype} {0.source} {0.target}:{0.tclass} {0.xperm_type} {{ {1} }};". \
|
|
format(rule, perms)
|
|
|
|
print(" * {0.ruletype} {0.source} {0.target}:{0.tclass} {0.xperm_type} "
|
|
"{{ {1} }};".format(rule, " ".join(perms)))
|
|
|
|
print()
|
|
|
|
if all_differences or args.auditallow:
|
|
if diff.added_auditallows or diff.removed_auditallows or diff.modified_auditallows or \
|
|
args.auditallow:
|
|
print("Auditallow Rules ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_auditallows), len(diff.removed_auditallows),
|
|
len(diff.modified_auditallows)))
|
|
|
|
if diff.added_auditallows and not args.stats:
|
|
print(" Added Auditallow Rules: {0}".format(len(diff.added_auditallows)))
|
|
for r in sorted(diff.added_auditallows):
|
|
print(" + {0}".format(r))
|
|
|
|
if diff.removed_auditallows and not args.stats:
|
|
print(" Removed Auditallow Rules: {0}".format(len(diff.removed_auditallows)))
|
|
for r in sorted(diff.removed_auditallows):
|
|
print(" - {0}".format(r))
|
|
|
|
if diff.modified_auditallows and not args.stats:
|
|
print(" Modified Auditallow Rules: {0}".format(len(diff.modified_auditallows)))
|
|
|
|
for rule, added_perms, removed_perms, matched_perms in sorted(
|
|
diff.modified_auditallows, key=lambda x: x.rule):
|
|
perms = " ".join(chain((p for p in matched_perms),
|
|
("+" + p for p in added_perms),
|
|
("-" + p for p in removed_perms)))
|
|
rule_string = "{0.ruletype} {0.source} {0.target}:{0.tclass} {{ {1} }};".format(
|
|
rule, perms)
|
|
|
|
try:
|
|
rule_string += " [ {0} ]".format(rule.conditional)
|
|
except AttributeError:
|
|
pass
|
|
print(" * {0}".format(rule_string))
|
|
|
|
print()
|
|
|
|
if all_differences or args.auditallowxperm:
|
|
if diff.added_auditallowxperms or diff.removed_auditallowxperms or \
|
|
diff.modified_auditallowxperms or args.auditallowxperm:
|
|
|
|
print("Auditallowxperm Rules ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_auditallowxperms), len(diff.removed_auditallowxperms),
|
|
len(diff.modified_auditallowxperms)))
|
|
|
|
if diff.added_auditallowxperms and not args.stats:
|
|
print(" Added Auditallowxperm Rules: {0}".format(
|
|
len(diff.added_auditallowxperms)))
|
|
for r in sorted(diff.added_auditallowxperms):
|
|
print(" + {0}".format(r))
|
|
|
|
if diff.removed_auditallowxperms and not args.stats:
|
|
print(" Removed Auditallowxperm Rules: {0}".format(
|
|
len(diff.removed_auditallowxperms)))
|
|
for r in sorted(diff.removed_auditallowxperms):
|
|
print(" - {0}".format(r))
|
|
|
|
if diff.modified_auditallowxperms and not args.stats:
|
|
print(" Modified Auditallowxperm Rules: {0}".format(
|
|
len(diff.modified_auditallowxperms)))
|
|
|
|
for rule, added_perms, removed_perms, matched_perms in sorted(
|
|
diff.modified_auditallowxperms, key=lambda x: x.rule):
|
|
|
|
# Process the string representation of the sets
|
|
# so hex representation and ranges are preserved.
|
|
# Check if the perm sets have contents, otherwise
|
|
# split on empty string will be an empty string.
|
|
# Add brackets to added and removed permissions
|
|
# in case there is a range of permissions.
|
|
perms = []
|
|
if matched_perms:
|
|
for p in str(matched_perms).split(" "):
|
|
perms.append(p)
|
|
if added_perms:
|
|
for p in str(added_perms).split(" "):
|
|
if '-' in p:
|
|
perms.append("+[{0}]".format(p))
|
|
else:
|
|
perms.append("+{0}".format(p))
|
|
if removed_perms:
|
|
for p in str(removed_perms).split(" "):
|
|
if '-' in p:
|
|
perms.append("-[{0}]".format(p))
|
|
else:
|
|
perms.append("-{0}".format(p))
|
|
|
|
rule_string = \
|
|
"{0.ruletype} {0.source} {0.target}:{0.tclass} {0.xperm_type} {{ {1} }};". \
|
|
format(rule, perms)
|
|
|
|
print(" * {0.ruletype} {0.source} {0.target}:{0.tclass} {0.xperm_type} "
|
|
"{{ {1} }};".format(rule, " ".join(perms)))
|
|
|
|
print()
|
|
|
|
if all_differences or args.dontaudit:
|
|
if diff.added_dontaudits or diff.removed_dontaudits or diff.modified_dontaudits or \
|
|
args.dontaudit:
|
|
print("Dontaudit Rules ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_dontaudits), len(diff.removed_dontaudits),
|
|
len(diff.modified_dontaudits)))
|
|
|
|
if diff.added_dontaudits and not args.stats:
|
|
print(" Added Dontaudit Rules: {0}".format(len(diff.added_dontaudits)))
|
|
for r in sorted(diff.added_dontaudits):
|
|
print(" + {0}".format(r))
|
|
|
|
if diff.removed_dontaudits and not args.stats:
|
|
print(" Removed Dontaudit Rules: {0}".format(len(diff.removed_dontaudits)))
|
|
for r in sorted(diff.removed_dontaudits):
|
|
print(" - {0}".format(r))
|
|
|
|
if diff.modified_dontaudits and not args.stats:
|
|
print(" Modified Dontaudit Rules: {0}".format(len(diff.modified_dontaudits)))
|
|
|
|
for rule, added_perms, removed_perms, matched_perms in sorted(
|
|
diff.modified_dontaudits, key=lambda x: x.rule):
|
|
perms = " ".join(chain((p for p in matched_perms),
|
|
("+" + p for p in added_perms),
|
|
("-" + p for p in removed_perms)))
|
|
rule_string = "{0.ruletype} {0.source} {0.target}:{0.tclass} {{ {1} }};".format(
|
|
rule, perms)
|
|
|
|
try:
|
|
rule_string += " [ {0} ]".format(rule.conditional)
|
|
except AttributeError:
|
|
pass
|
|
print(" * {0}".format(rule_string))
|
|
|
|
print()
|
|
|
|
if all_differences or args.dontauditxperm:
|
|
if diff.added_dontauditxperms or diff.removed_dontauditxperms or \
|
|
diff.modified_dontauditxperms or args.dontauditxperm:
|
|
|
|
print("Dontauditxperm Rules ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_dontauditxperms), len(diff.removed_dontauditxperms),
|
|
len(diff.modified_dontauditxperms)))
|
|
|
|
if diff.added_dontauditxperms and not args.stats:
|
|
print(" Added Dontauditxperm Rules: {0}".format(
|
|
len(diff.added_dontauditxperms)))
|
|
for r in sorted(diff.added_dontauditxperms):
|
|
print(" + {0}".format(r))
|
|
|
|
if diff.removed_dontauditxperms and not args.stats:
|
|
print(" Removed Dontauditxperm Rules: {0}".format(
|
|
len(diff.removed_dontauditxperms)))
|
|
for r in sorted(diff.removed_dontauditxperms):
|
|
print(" - {0}".format(r))
|
|
|
|
if diff.modified_dontauditxperms and not args.stats:
|
|
print(" Modified Dontauditxperm Rules: {0}".format(
|
|
len(diff.modified_dontauditxperms)))
|
|
|
|
for rule, added_perms, removed_perms, matched_perms in sorted(
|
|
diff.modified_dontauditxperms, key=lambda x: x.rule):
|
|
|
|
# Process the string representation of the sets
|
|
# so hex representation and ranges are preserved.
|
|
# Check if the perm sets have contents, otherwise
|
|
# split on empty string will be an empty string.
|
|
# Add brackets to added and removed permissions
|
|
# in case there is a range of permissions.
|
|
perms = []
|
|
if matched_perms:
|
|
for p in str(matched_perms).split(" "):
|
|
perms.append(p)
|
|
if added_perms:
|
|
for p in str(added_perms).split(" "):
|
|
if '-' in p:
|
|
perms.append("+[{0}]".format(p))
|
|
else:
|
|
perms.append("+{0}".format(p))
|
|
if removed_perms:
|
|
for p in str(removed_perms).split(" "):
|
|
if '-' in p:
|
|
perms.append("-[{0}]".format(p))
|
|
else:
|
|
perms.append("-{0}".format(p))
|
|
|
|
rule_string = \
|
|
"{0.ruletype} {0.source} {0.target}:{0.tclass} {0.xperm_type} {{ {1} }};". \
|
|
format(rule, perms)
|
|
|
|
print(" * {0.ruletype} {0.source} {0.target}:{0.tclass} {0.xperm_type} "
|
|
"{{ {1} }};".format(rule, " ".join(perms)))
|
|
|
|
print()
|
|
|
|
if all_differences or args.type_trans:
|
|
if diff.added_type_transitions or diff.removed_type_transitions or \
|
|
diff.modified_type_transitions or args.type_trans:
|
|
print("Type_transition Rules ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_type_transitions), len(diff.removed_type_transitions),
|
|
len(diff.modified_type_transitions)))
|
|
|
|
if diff.added_type_transitions and not args.stats:
|
|
print(" Added Type_transition Rules: {0}".format(
|
|
len(diff.added_type_transitions)))
|
|
for r in sorted(diff.added_type_transitions):
|
|
print(" + {0}".format(r))
|
|
|
|
if diff.removed_type_transitions and not args.stats:
|
|
print(" Removed Type_transition Rules: {0}".format(
|
|
len(diff.removed_type_transitions)))
|
|
for r in sorted(diff.removed_type_transitions):
|
|
print(" - {0}".format(r))
|
|
|
|
if diff.modified_type_transitions and not args.stats:
|
|
print(" Modified Type_transition Rules: {0}".format(
|
|
len(diff.modified_type_transitions)))
|
|
|
|
for rule, added_default, removed_default in sorted(diff.modified_type_transitions,
|
|
key=lambda x: x.rule):
|
|
rule_string = "{0.ruletype} {0.source} {0.target}:{0.tclass} +{1} -{2}".format(
|
|
rule, added_default, removed_default)
|
|
|
|
try:
|
|
rule_string += " {0}".format(rule.filename)
|
|
except AttributeError:
|
|
pass
|
|
|
|
rule_string += ";"
|
|
|
|
try:
|
|
rule_string += " [ {0} ]".format(rule.conditional)
|
|
except AttributeError:
|
|
pass
|
|
|
|
print(" * {0}".format(rule_string))
|
|
|
|
print()
|
|
|
|
if all_differences or args.type_change:
|
|
if diff.added_type_changes or diff.removed_type_changes or \
|
|
diff.modified_type_changes or args.type_change:
|
|
print("Type_change Rules ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_type_changes), len(diff.removed_type_changes),
|
|
len(diff.modified_type_changes)))
|
|
|
|
if diff.added_type_changes and not args.stats:
|
|
print(" Added Type_change Rules: {0}".format(len(diff.added_type_changes)))
|
|
for r in sorted(diff.added_type_changes):
|
|
print(" + {0}".format(r))
|
|
|
|
if diff.removed_type_changes and not args.stats:
|
|
print(" Removed Type_change Rules: {0}".format(len(diff.removed_type_changes)))
|
|
for r in sorted(diff.removed_type_changes):
|
|
print(" - {0}".format(r))
|
|
|
|
if diff.modified_type_changes and not args.stats:
|
|
print(" Modified Type_change Rules: {0}".format(len(diff.modified_type_changes)))
|
|
|
|
for rule, added_default, removed_default in sorted(diff.modified_type_changes,
|
|
key=lambda x: x.rule):
|
|
rule_string = "{0.ruletype} {0.source} {0.target}:{0.tclass} +{1} -{2}".format(
|
|
rule, added_default, removed_default)
|
|
|
|
try:
|
|
rule_string += " {0}".format(rule.filename)
|
|
except AttributeError:
|
|
pass
|
|
|
|
rule_string += ";"
|
|
|
|
try:
|
|
rule_string += " [ {0} ]".format(rule.conditional)
|
|
except AttributeError:
|
|
pass
|
|
|
|
print(" * {0}".format(rule_string))
|
|
|
|
print()
|
|
|
|
if all_differences or args.type_member:
|
|
if diff.added_type_members or diff.removed_type_members or \
|
|
diff.modified_type_members or args.type_member:
|
|
print("Type_member Rules ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_type_members), len(diff.removed_type_members),
|
|
len(diff.modified_type_members)))
|
|
|
|
if diff.added_type_members and not args.stats:
|
|
print(" Added Type_member Rules: {0}".format(len(diff.added_type_members)))
|
|
for r in sorted(diff.added_type_members):
|
|
print(" + {0}".format(r))
|
|
|
|
if diff.removed_type_members and not args.stats:
|
|
print(" Removed Type_member Rules: {0}".format(len(diff.removed_type_members)))
|
|
for r in sorted(diff.removed_type_members):
|
|
print(" - {0}".format(r))
|
|
|
|
if diff.modified_type_members and not args.stats:
|
|
print(" Modified Type_member Rules: {0}".format(len(diff.modified_type_members)))
|
|
|
|
for rule, added_default, removed_default in sorted(diff.modified_type_members,
|
|
key=lambda x: x.rule):
|
|
rule_string = "{0.ruletype} {0.source} {0.target}:{0.tclass} +{1} -{2}".format(
|
|
rule, added_default, removed_default)
|
|
|
|
try:
|
|
rule_string += " {0}".format(rule.filename)
|
|
except AttributeError:
|
|
pass
|
|
|
|
rule_string += ";"
|
|
|
|
try:
|
|
rule_string += " [ {0} ]".format(rule.conditional)
|
|
except AttributeError:
|
|
pass
|
|
|
|
print(" * {0}".format(rule_string))
|
|
|
|
print()
|
|
|
|
if all_differences or args.role_allow:
|
|
if diff.added_role_allows or diff.removed_role_allows or args.role_allow:
|
|
print("Role allow Rules ({0} Added, {1} Removed)".format(
|
|
len(diff.added_role_allows), len(diff.removed_role_allows)))
|
|
|
|
if diff.added_role_allows and not args.stats:
|
|
print(" Added Role Allow Rules: {0}".format(
|
|
len(diff.added_role_allows)))
|
|
for r in sorted(diff.added_role_allows):
|
|
print(" + {0}".format(r))
|
|
|
|
if diff.removed_role_allows and not args.stats:
|
|
print(" Removed Role Allow Rules: {0}".format(
|
|
len(diff.removed_role_allows)))
|
|
for r in sorted(diff.removed_role_allows):
|
|
print(" - {0}".format(r))
|
|
|
|
print()
|
|
|
|
if all_differences or args.role_trans:
|
|
if diff.added_role_transitions or diff.removed_role_transitions or \
|
|
diff.modified_role_transitions or args.role_trans:
|
|
print("Role_transition Rules ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_role_transitions), len(diff.removed_role_transitions),
|
|
len(diff.modified_role_transitions)))
|
|
|
|
if diff.added_role_transitions and not args.stats:
|
|
print(" Added Role_transition Rules: {0}".format(
|
|
len(diff.added_role_transitions)))
|
|
for r in sorted(diff.added_role_transitions):
|
|
print(" + {0}".format(r))
|
|
|
|
if diff.removed_role_transitions and not args.stats:
|
|
print(" Removed Role_transition Rules: {0}".format(
|
|
len(diff.removed_role_transitions)))
|
|
for r in sorted(diff.removed_role_transitions):
|
|
print(" - {0}".format(r))
|
|
|
|
if diff.modified_role_transitions and not args.stats:
|
|
print(" Modified Role_transition Rules: {0}".format(
|
|
len(diff.modified_role_transitions)))
|
|
|
|
for rule, added_default, removed_default in sorted(diff.modified_role_transitions,
|
|
key=lambda x: x.rule):
|
|
rule_string = \
|
|
"{0.ruletype} {0.source} {0.target}:{0.tclass} +{1} -{2}".format(
|
|
rule, added_default, removed_default)
|
|
|
|
print(" * {0}".format(rule_string))
|
|
|
|
print()
|
|
|
|
if all_differences or args.range_trans:
|
|
if diff.added_range_transitions or diff.removed_range_transitions or \
|
|
diff.modified_range_transitions or args.range_trans:
|
|
print("Range_transition Rules ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_range_transitions), len(diff.removed_range_transitions),
|
|
len(diff.modified_range_transitions)))
|
|
|
|
if diff.added_range_transitions and not args.stats:
|
|
print(" Added Range_transition Rules: {0}".format(
|
|
len(diff.added_range_transitions)))
|
|
for r in sorted(diff.added_range_transitions):
|
|
print(" + {0}".format(r))
|
|
|
|
if diff.removed_range_transitions and not args.stats:
|
|
print(" Removed Range_transition Rules: {0}".format(
|
|
len(diff.removed_range_transitions)))
|
|
for r in sorted(diff.removed_range_transitions):
|
|
print(" - {0}".format(r))
|
|
|
|
if diff.modified_range_transitions and not args.stats:
|
|
print(" Modified Range_transition Rules: {0}".format(
|
|
len(diff.modified_range_transitions)))
|
|
|
|
for rule, added_default, removed_default in sorted(diff.modified_range_transitions,
|
|
key=lambda x: x.rule):
|
|
# added brackets around range change for clarity since ranges
|
|
# can have '-' and spaces.
|
|
rule_string = \
|
|
"{0.ruletype} {0.source} {0.target}:{0.tclass} +[{1}] -[{2}]".format(
|
|
rule, added_default, removed_default)
|
|
|
|
print(" * {0}".format(rule_string))
|
|
|
|
print()
|
|
|
|
if all_differences or args.constrain:
|
|
if diff.added_constrains or diff.removed_constrains or args.constrain:
|
|
print("Constraints ({0} Added, {1} Removed)".format(
|
|
len(diff.added_constrains), len(diff.removed_constrains)))
|
|
|
|
if diff.added_constrains and not args.stats:
|
|
print(" Added Constraints: {0}".format(
|
|
len(diff.added_constrains)))
|
|
for r in sorted(diff.added_constrains):
|
|
print(" + {0}".format(r))
|
|
|
|
if diff.removed_constrains and not args.stats:
|
|
print(" Removed Constraints: {0}".format(
|
|
len(diff.removed_constrains)))
|
|
for r in sorted(diff.removed_constrains):
|
|
print(" - {0}".format(r))
|
|
|
|
print()
|
|
|
|
if all_differences or args.mlsconstrain:
|
|
if diff.added_mlsconstrains or diff.removed_mlsconstrains or args.mlsconstrain:
|
|
print("MLS Constraints ({0} Added, {1} Removed)".format(
|
|
len(diff.added_mlsconstrains), len(diff.removed_mlsconstrains)))
|
|
|
|
if diff.added_mlsconstrains and not args.stats:
|
|
print(" Added MLS Constraints: {0}".format(
|
|
len(diff.added_mlsconstrains)))
|
|
for r in sorted(diff.added_mlsconstrains):
|
|
print(" + {0}".format(r))
|
|
|
|
if diff.removed_mlsconstrains and not args.stats:
|
|
print(" Removed MLS Constraints: {0}".format(
|
|
len(diff.removed_mlsconstrains)))
|
|
for r in sorted(diff.removed_mlsconstrains):
|
|
print(" - {0}".format(r))
|
|
|
|
print()
|
|
|
|
if all_differences or args.validatetrans:
|
|
if diff.added_validatetrans or diff.removed_validatetrans or args.validatetrans:
|
|
print("Validatetrans ({0} Added, {1} Removed)".format(
|
|
len(diff.added_validatetrans), len(diff.removed_validatetrans)))
|
|
|
|
if diff.added_validatetrans and not args.stats:
|
|
print(" Added Validatetrans: {0}".format(
|
|
len(diff.added_validatetrans)))
|
|
for r in sorted(diff.added_validatetrans):
|
|
print(" + {0}".format(r))
|
|
|
|
if diff.removed_validatetrans and not args.stats:
|
|
print(" Removed Validatetrans: {0}".format(
|
|
len(diff.removed_validatetrans)))
|
|
for r in sorted(diff.removed_validatetrans):
|
|
print(" - {0}".format(r))
|
|
|
|
print()
|
|
|
|
if all_differences or args.mlsvalidatetrans:
|
|
if diff.added_mlsvalidatetrans or diff.removed_mlsvalidatetrans or args.mlsvalidatetrans:
|
|
print("MLS Validatetrans ({0} Added, {1} Removed)".format(
|
|
len(diff.added_mlsvalidatetrans), len(diff.removed_mlsvalidatetrans)))
|
|
|
|
if diff.added_mlsvalidatetrans and not args.stats:
|
|
print(" Added MLS Validatetrans: {0}".format(
|
|
len(diff.added_mlsvalidatetrans)))
|
|
for r in sorted(diff.added_mlsvalidatetrans):
|
|
print(" + {0}".format(r))
|
|
|
|
if diff.removed_mlsvalidatetrans and not args.stats:
|
|
print(" Removed MLS Validatetrans: {0}".format(
|
|
len(diff.removed_mlsvalidatetrans)))
|
|
for r in sorted(diff.removed_mlsvalidatetrans):
|
|
print(" - {0}".format(r))
|
|
|
|
print()
|
|
|
|
if all_differences or args.initialsid:
|
|
if diff.added_initialsids or diff.removed_initialsids or diff.modified_initialsids \
|
|
or args.initialsid:
|
|
print("Initial SIDs ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_initialsids), len(diff.removed_initialsids),
|
|
len(diff.modified_initialsids)))
|
|
if diff.added_initialsids and not args.stats:
|
|
print(" Added Initial SIDs: {0}".format(len(diff.added_initialsids)))
|
|
for s in sorted(diff.added_initialsids):
|
|
print(" + {0}".format(s.statement()))
|
|
if diff.removed_initialsids and not args.stats:
|
|
print(" Removed Initial SIDs: {0}".format(len(diff.removed_initialsids)))
|
|
for s in sorted(diff.removed_initialsids):
|
|
print(" - {0}".format(s.statement()))
|
|
if diff.modified_initialsids and not args.stats:
|
|
print(" Modified Initial SIDs: {0}".format(len(diff.modified_initialsids)))
|
|
for name, mod in sorted(diff.modified_initialsids.items()):
|
|
print(" * {0} +[{1.added_context}] -[{1.removed_context}];".format(
|
|
name, mod))
|
|
|
|
print()
|
|
|
|
if all_differences or args.fs_use:
|
|
if diff.added_fs_uses or diff.removed_fs_uses or diff.modified_fs_uses \
|
|
or args.fs_use:
|
|
print("Fs_use ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_fs_uses), len(diff.removed_fs_uses),
|
|
len(diff.modified_fs_uses)))
|
|
if diff.added_fs_uses and not args.stats:
|
|
print(" Added Fs_use: {0}".format(len(diff.added_fs_uses)))
|
|
for s in sorted(diff.added_fs_uses):
|
|
print(" + {0}".format(s))
|
|
if diff.removed_fs_uses and not args.stats:
|
|
print(" Removed Fs_use: {0}".format(len(diff.removed_fs_uses)))
|
|
for s in sorted(diff.removed_fs_uses):
|
|
print(" - {0}".format(s))
|
|
if diff.modified_fs_uses and not args.stats:
|
|
print(" Modified Fs_use: {0}".format(len(diff.modified_fs_uses)))
|
|
for entry in sorted(diff.modified_fs_uses, key=lambda x: x.rule):
|
|
print(" * {0.ruletype} {0.fs} +[{1}] -[{2}];".format(
|
|
entry.rule, entry.added_context, entry.removed_context))
|
|
|
|
print()
|
|
|
|
if all_differences or args.genfscon:
|
|
if diff.added_genfscons or diff.removed_genfscons or diff.modified_genfscons \
|
|
or args.genfscon:
|
|
print("Genfscons ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_genfscons), len(diff.removed_genfscons),
|
|
len(diff.modified_genfscons)))
|
|
if diff.added_genfscons and not args.stats:
|
|
print(" Added Genfscons: {0}".format(len(diff.added_genfscons)))
|
|
for s in sorted(diff.added_genfscons):
|
|
print(" + {0}".format(s))
|
|
if diff.removed_genfscons and not args.stats:
|
|
print(" Removed Genfscons: {0}".format(len(diff.removed_genfscons)))
|
|
for s in sorted(diff.removed_genfscons):
|
|
print(" - {0}".format(s))
|
|
if diff.modified_genfscons and not args.stats:
|
|
print(" Modified Genfscons: {0}".format(len(diff.modified_genfscons)))
|
|
for entry in sorted(diff.modified_genfscons, key=lambda x: x.rule):
|
|
print(" * genfscon {0.fs} {0.path} {0.filetype} +[{1}] -[{2}];".format(
|
|
entry.rule, entry.added_context, entry.removed_context))
|
|
|
|
print()
|
|
|
|
if all_differences or args.netifcon:
|
|
if diff.added_netifcons or diff.removed_netifcons or \
|
|
diff.modified_netifcons or args.netifcon:
|
|
print("Netifcons ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_netifcons), len(diff.removed_netifcons),
|
|
len(diff.modified_netifcons)))
|
|
if diff.added_netifcons and not args.stats:
|
|
print(" Added Netifcons: {0}".format(len(diff.added_netifcons)))
|
|
for n in sorted(diff.added_netifcons):
|
|
print(" + {0}".format(n))
|
|
if diff.removed_netifcons and not args.stats:
|
|
print(" Removed Netifcons: {0}".format(len(diff.removed_netifcons)))
|
|
for n in sorted(diff.removed_netifcons):
|
|
print(" - {0}".format(n))
|
|
if diff.modified_netifcons and not args.stats:
|
|
print(" Modified Netifcons: {0}".format(len(diff.modified_netifcons)))
|
|
for entry in sorted(diff.modified_netifcons, key=lambda x: x.rule):
|
|
# This output is different than other statements because
|
|
# it becomes difficult to read if this was condensed
|
|
# into a single line, especially if both contexts
|
|
# are modified.
|
|
change = []
|
|
if entry.removed_context:
|
|
change.append("Modified Context")
|
|
if entry.removed_packet:
|
|
change.append("Modified Packet Context")
|
|
|
|
print(" * {0.netif} ({1})".format(entry.rule, ", ".join(change)))
|
|
|
|
if entry.removed_context:
|
|
print(" Context:")
|
|
print(" + {0}".format(entry.added_context))
|
|
print(" - {0}".format(entry.removed_context))
|
|
if entry.removed_packet:
|
|
print(" Packet Context:")
|
|
print(" + {0}".format(entry.added_packet))
|
|
print(" - {0}".format(entry.removed_packet))
|
|
|
|
print()
|
|
|
|
if all_differences or args.nodecon:
|
|
if diff.added_nodecons or diff.removed_nodecons or diff.modified_nodecons \
|
|
or args.nodecon:
|
|
print("Nodecons ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_nodecons), len(diff.removed_nodecons),
|
|
len(diff.modified_nodecons)))
|
|
if diff.added_nodecons and not args.stats:
|
|
print(" Added Nodecons: {0}".format(len(diff.added_nodecons)))
|
|
for n in sorted(diff.added_nodecons):
|
|
print(" + {0}".format(n))
|
|
if diff.removed_nodecons and not args.stats:
|
|
print(" Removed Nodecons: {0}".format(len(diff.removed_nodecons)))
|
|
for n in sorted(diff.removed_nodecons):
|
|
print(" - {0}".format(n))
|
|
if diff.modified_nodecons and not args.stats:
|
|
print(" Modified Nodecons: {0}".format(len(diff.modified_nodecons)))
|
|
for con, added_context, removed_context in sorted(diff.modified_nodecons,
|
|
key=lambda x: x.rule):
|
|
print(" * nodecon {0.address} {0.netmask} +[{1}] -[{2}];".format(
|
|
con, added_context, removed_context))
|
|
|
|
print()
|
|
|
|
if all_differences or args.portcon:
|
|
if diff.added_portcons or diff.removed_portcons or diff.modified_portcons \
|
|
or args.portcon:
|
|
print("Portcons ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_portcons), len(diff.removed_portcons),
|
|
len(diff.modified_portcons)))
|
|
if diff.added_portcons and not args.stats:
|
|
print(" Added Portcons: {0}".format(len(diff.added_portcons)))
|
|
for n in sorted(diff.added_portcons):
|
|
print(" + {0}".format(n))
|
|
if diff.removed_portcons and not args.stats:
|
|
print(" Removed Portcons: {0}".format(len(diff.removed_portcons)))
|
|
for n in sorted(diff.removed_portcons):
|
|
print(" - {0}".format(n))
|
|
if diff.modified_portcons and not args.stats:
|
|
print(" Modified Portcons: {0}".format(len(diff.modified_portcons)))
|
|
for con, added_context, removed_context in sorted(diff.modified_portcons,
|
|
key=lambda x: x.rule):
|
|
low, high = con.ports
|
|
if low == high:
|
|
print(" * portcon {0.protocol} {1} +[{2}] -[{3}];".format(
|
|
con, low, added_context, removed_context))
|
|
else:
|
|
print(" * portcon {0.protocol} {1}-{2} +[{3}] -[{4}];".format(
|
|
con, low, high, added_context, removed_context))
|
|
|
|
print()
|
|
|
|
if all_differences or args.polcap:
|
|
if diff.added_polcaps or diff.removed_polcaps or args.polcap:
|
|
print("Policy Capabilities ({0} Added, {1} Removed)".format(
|
|
len(diff.added_polcaps), len(diff.removed_polcaps)))
|
|
if diff.added_polcaps and not args.stats:
|
|
print(" Added Policy Capabilities: {0}".format(len(diff.added_polcaps)))
|
|
for n in sorted(diff.added_polcaps):
|
|
print(" + {0}".format(n))
|
|
if diff.removed_polcaps and not args.stats:
|
|
print(" Removed Policy Capabilities: {0}".format(len(diff.removed_polcaps)))
|
|
for n in sorted(diff.removed_polcaps):
|
|
print(" - {0}".format(n))
|
|
|
|
print()
|
|
|
|
if all_differences or args.default:
|
|
if diff.added_defaults or diff.removed_defaults or args.default:
|
|
print("Defaults ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_defaults), len(diff.removed_defaults), len(diff.modified_defaults)))
|
|
if diff.added_defaults and not args.stats:
|
|
print(" Added Defaults: {0}".format(len(diff.added_defaults)))
|
|
for d in sorted(diff.added_defaults):
|
|
print(" + {0}".format(d))
|
|
if diff.removed_defaults and not args.stats:
|
|
print(" Removed Defaults: {0}".format(len(diff.removed_defaults)))
|
|
for d in sorted(diff.removed_defaults):
|
|
print(" - {0}".format(d))
|
|
if diff.modified_defaults and not args.stats:
|
|
print(" Modified Defaults: {0}".format(len(diff.modified_defaults)))
|
|
for default, added_default, removed_default, added_range, removed_range in sorted(
|
|
diff.modified_defaults, key=lambda x: x.rule):
|
|
line = " * {0.ruletype} {0.tclass} ".format(default)
|
|
if removed_default:
|
|
line += "+{0} -{1}".format(added_default, removed_default)
|
|
else:
|
|
line += default.default
|
|
|
|
if removed_range:
|
|
line += " +{0} -{1};".format(added_range, removed_range)
|
|
else:
|
|
try:
|
|
line += " {0};".format(default.default_range)
|
|
except AttributeError:
|
|
line += ";"
|
|
print(line)
|
|
|
|
print()
|
|
|
|
if all_differences or args.typebounds:
|
|
if diff.added_typebounds or diff.removed_typebounds or args.typebounds:
|
|
print("Typebounds ({0} Added, {1} Removed, {2} Modified)".format(
|
|
len(diff.added_typebounds), len(diff.removed_typebounds),
|
|
len(diff.modified_typebounds)))
|
|
if diff.added_typebounds and not args.stats:
|
|
print(" Added Typebounds: {0}".format(len(diff.added_typebounds)))
|
|
for d in sorted(diff.added_typebounds):
|
|
print(" + {0}".format(d))
|
|
if diff.removed_typebounds and not args.stats:
|
|
print(" Removed Typebounds: {0}".format(len(diff.removed_typebounds)))
|
|
for d in sorted(diff.removed_typebounds):
|
|
print(" - {0}".format(d))
|
|
if diff.modified_typebounds and not args.stats:
|
|
print(" Modified Typebounds: {0}".format(len(diff.modified_typebounds)))
|
|
for bound, added_bound, removed_bound in sorted(
|
|
diff.modified_typebounds, key=lambda x: x.rule):
|
|
print(" * {0.ruletype} +{1} -{2} {0.child};".format(
|
|
bound, added_bound, removed_bound))
|
|
|
|
print()
|
|
|
|
except Exception as err:
|
|
if args.debug:
|
|
logging.exception(str(err))
|
|
else:
|
|
print(err)
|
|
|
|
sys.exit(1)
|