def do_one_test(self, ssl=True):
conf = Settings.get()
conf.set_bool('/settings/nscp/test_nscp_server', 'use ssl', ssl)
conf.set_bool('/settings/nscp/test_nscp_server', 'allow arguments',
True)
# TODO: conf.set_string('/settings/nscp/test_nscp_server', 'certificate', ssl)
core.reload('test_nscp_server')
conf.set_string('/settings/nscp/test_nscp_client/targets/default',
'address', 'nscp://127.0.0.1:35668')
conf.set_bool('/settings/nscp/test_nscp_client/targets/default',
'use ssl', not ssl)
conf.set_string('/settings/nscp/test_nscp_client/targets/invalid',
'address', 'nscp://127.0.0.1:25668')
conf.set_bool('/settings/nscp/test_nscp_client/targets/invalid',
'use ssl', not ssl)
conf.set_string('/settings/nscp/test_nscp_client/targets/valid',
'address', 'nscp://127.0.0.1:15668')
conf.set_bool('/settings/nscp/test_nscp_client/targets/valid',
'use ssl', ssl)
core.reload('test_nscp_client')
result = TestResult()
#result.add_message(isOpen('127.0.0.1', 15668), 'Checking that port is open (server is up)')
#result.add(self.test_one(ssl, length, state = status.UNKNOWN, tag = 'unknown'))
result.add(self.test_one(ssl, state=status.OK, tag='ok'))
#result.add(self.test_one(ssl, length, state = status.WARNING, tag = 'warn'))
#result.add(self.test_one(ssl, length, state = status.CRITICAL, tag = 'crit'))
return result
def test_w_expected(self, filter, syntax, expected):
result = TestResult('Validating filter: %s' % filter)
(res, msg, perf) = Core.get().simple_query('CheckEventLog', [
'file=Application', 'debug=true',
'warn=ne:%d' % expected,
'crit=ne:%d' % expected,
'filter=%s' % filter,
'syntax=%s' % syntax
])
result.assert_equals(res, status.OK,
"Validate status OK for %s" % filter)
(res, msg, perf) = Core.get().simple_query('CheckEventLog', [
'file=Application', 'debug=true',
'warn=eq:%d' % expected,
'crit=ne:%d' % expected,
'filter=%s' % filter,
'syntax=%s' % syntax
])
result.assert_equals(res, status.WARNING,
"Validate status OK for %s" % filter)
(res, msg, perf) = Core.get().simple_query('CheckEventLog', [
'file=Application', 'debug=true',
'warn=eq:%d' % expected,
'crit=eq:%d' % expected,
'filter=%s' % filter,
'syntax=%s' % syntax
])
result.assert_equals(res, status.CRITICAL,
"Validate status CRIT for %s" % filter)
return result
def run_test(self):
result = TestResult('Testing W32 file systems')
result.add(self.check_cli_ns())
result.add(self.check_cli_ls(None, 'Win32_Processor', 'LogFileEventConsumer'))
result.add(self.check_cli_ls('root\subscription', 'LogFileEventConsumer', 'Win32_Processor'))
result.add(self.check_cli_query('SELECT DeviceId, AddressWidth, Caption, Name FROM Win32_Processor', lambda x:x>1, lambda x:'CPU0' in x))
return result
def run_test(self, cases=None):
result = TestResult()
cryptos = [
"none", "xor", "des", "3des", "cast128", "xtea", "blowfish",
"twofish", "rc2", "aes", "aes256", "aes192", "aes128", "serpent",
"gost", "3way"
]
for c in cryptos:
run_l = None
run_this = False
if cases:
tmp_l = None
for case in cases:
if '-' in case:
(run_c, tmp_l) = case.split('-', 2)
else:
run_c = case
if c == run_c:
run_l = int(tmp_l) if tmp_l else None
run_this = True
if not run_this:
result.add_message(True, 'Ignoring: %s-*' % c)
continue
for l in [128, 512, 1024, 4096]:
if not run_l or run_l == l:
result.add(self.test_one_crypto(c, l))
else:
result.add_message(True, 'Ignoring: %s-%s' % (c, l))
return result
def test_create(self, source, id, level, severity, category, facility,
arguments):
result = TestResult(
'Creating log message: i:%d, l:%s, s:%s, c:%d, f:%d' %
(id, level, severity, category, facility))
args = [
'--source',
source,
'--id',
id, # Any number (corresponds with message identifier) -- Identifies message
'--level',
level, # error(1), warning(2), success(0), info(4), auditSuccess(8), auditFailure(10) -- Loglevel severity (ie log level)
'--severity',
severity, # success(0), informational(1), warning(2), error(3) -- Developer severity (ie classification)
'--category',
category, #
'--facility',
facility #
]
for f in arguments:
args.append('--argument')
args.append(f)
(ret, msg) = self.core.simple_exec('eventlog', 'insert', args)
result.assert_equals(ret, 0, 'return code')
result.assert_equals(len(msg), 1, 'Message length')
if len(msg) == 1:
result.assert_equals(msg[0], 'Message reported successfully',
'Status message')
return result
def do_one_test(self,
script,
expected=status.OK,
message="Foo Bar",
args=[],
cleanup=True):
result = TestResult('%s (%s)' % (script, args))
(ret, msg, perf) = self.core.simple_query(script, args)
if cleanup and os.name != 'nt':
message = message.replace('"', '')
message = message.replace('$ARG1$', '$')
message = message.replace('$ARG2$', '$')
message = message.replace('$ARG3$', '$')
message = message.replace('\r', '\n')
message = message.replace('\n\n', '\n')
msg = msg.replace('\r', '\n')
msg = msg.replace('\n\n', '\n')
result.assert_equals(ret, expected,
'Validate return code for %s' % script)
result.assert_equals(msg, message,
'Validate return message for %s' % script)
if msg != message:
diff = difflib.ndiff(msg.splitlines(1), message.splitlines(1))
for l in diff:
log_error(l)
return result
def test_w_expected(self, filter, syntax, expected):
result = TestResult('Validating filter: %s (%d)' % (filter, expected))
(res, msg, perf) = self.core.simple_query('CheckEventLog', [
'file=Application', 'debug=false',
'warn=gt:%d' % expected,
'crit=gt:%d' % expected,
'filter=%s' % filter,
'syntax=%s' % syntax, 'scan-range=-10m',
'top-syntax=${status} ${count}==%d: ${list}' % expected
])
result.assert_equals(res, status.OK,
"Validate status OK for %s" % filter)
(res, msg, perf) = self.core.simple_query('CheckEventLog', [
'file=Application', 'debug=false',
'warn=eq:%d' % expected,
'crit=gt:%d' % expected,
'filter=%s' % filter,
'syntax=%s' % syntax, 'scan-range=-10m',
'top-syntax=${status} ${count}==%d: ${list}' % expected
])
result.assert_equals(res, status.WARNING,
"Validate status OK for %s" % filter)
(res, msg, perf) = self.core.simple_query('CheckEventLog', [
'file=Application', 'debug=false',
'warn=eq:%d' % expected,
'crit=eq:%d' % expected,
'filter=%s' % filter,
'syntax=%s' % syntax, 'scan-range=-10m',
'top-syntax=${status} ${count}==%d: ${list}' % expected
])
result.assert_equals(res, status.CRITICAL,
"Validate status CRIT for %s" % filter)
return result
def run_boundry_test(self):
result = TestResult('Boundry tests')
result.add(
self.check_bound('none', 'count > 1', 'none', status.WARNING))
result.add(
self.check_bound('none', 'none', 'count > 1', status.CRITICAL))
result.add(
self.check_bound('column1 > 5', 'count > 2', 'count > 5',
status.OK))
result.add(
self.check_bound('column1 > 4', 'count > 2', 'count > 5',
status.OK))
result.add(
self.check_bound('column1 > 3', 'count > 2', 'count > 5',
status.WARNING))
result.add(
self.check_bound('column1 > 2', 'count > 2', 'count > 5',
status.WARNING))
result.add(
self.check_bound('column1 > 1', 'count > 2', 'count > 5',
status.WARNING))
result.add(
self.check_bound('column1 > 0', 'count > 2', 'count > 5',
status.CRITICAL))
result.add(
self.check_bound('column1 > 5', 'column1 = 3', 'none', status.OK))
result.add(
self.check_bound('column1 > 0', 'column1 = 3', 'none',
status.WARNING))
return result
def do_one_test(self, ssl=True, length=1024):
conf = self.conf
conf.set_int('/settings/NRPE/test_nrpe_server', 'payload length', length)
conf.set_bool('/settings/NRPE/test_nrpe_server', 'use ssl', ssl)
conf.set_bool('/settings/NRPE/test_nrpe_server', 'allow arguments', True)
# TODO: conf.set_string('/settings/NRPE/test_nrpe_server', 'certificate', ssl)
self.core.reload('test_nrpe_server')
conf.set_string('/settings/NRPE/test_nrpe_client/targets/default', 'address', 'nrpe://127.0.0.1:35666')
conf.set_bool('/settings/NRPE/test_nrpe_client/targets/default', 'use ssl', not ssl)
conf.set_int('/settings/NRPE/test_nrpe_client/targets/default', 'payload length', length*3)
conf.set_string('/settings/NRPE/test_nrpe_client/targets/invalid', 'address', 'nrpe://127.0.0.1:25666')
conf.set_bool('/settings/NRPE/test_nrpe_client/targets/invalid', 'use ssl', not ssl)
conf.set_int('/settings/NRPE/test_nrpe_client/targets/invalid', 'payload length', length*2)
conf.set_string('/settings/NRPE/test_nrpe_client/targets/valid', 'address', 'nrpe://127.0.0.1:15666')
conf.set_bool('/settings/NRPE/test_nrpe_client/targets/valid', 'use ssl', ssl)
conf.set_int('/settings/NRPE/test_nrpe_client/targets/valid', 'payload length', length)
self.core.reload('test_nrpe_client')
result = TestResult('ssl=%s, length=%s'%(ssl, length))
result.add_message(isOpen('127.0.0.1', 15666), 'Checking that port is open (server is up)')
result.add(self.test_one(ssl, length, state = status.UNKNOWN, tag = 'unknown'))
result.add(self.test_one(ssl, length, state = status.OK, tag = 'ok'))
result.add(self.test_one(ssl, length, state = status.WARNING, tag = 'warn'))
result.add(self.test_one(ssl, length, state = status.CRITICAL, tag = 'crit'))
return result
def run_test_counters(self):
result = TestResult('Checking CheckCounter')
(result_code,
result_message) = self.core.simple_exec('any', 'pdh',
['--list', '--all'])
count = 0
data = []
for m in result_message:
data = m.splitlines()
count = len(data)
result.add_message(count > 0,
'Managed to retrieve counters: %d' % count)
if len(data) == 0:
result.add_message(False,
'Failed to find counters: %s' % result_message)
counters = []
(subres, name1) = self.check_and_lookup_index(4)
result.add(subres)
(subres, name2) = self.check_and_lookup_index(26)
result.add(subres)
result.add(self.check_counter('\\4\\26', ['ShowAll', 'MaxWarn=10']))
result.add(
self.check_counter('\\4\\26', ['index', 'ShowAll', 'MaxWarn=10']))
result.add(
self.check_counter('\\%s\\%s' % (name1, name2),
['ShowAll', 'MaxWarn=10']))
return result
def run_test(self):
result = TestResult()
result.add(
self.test_simple('foobar', status.OK, 'qwerty', '', 'simple ok'))
result.add(
self.test_simple('foobar', status.WARNING, 'foobar', '',
'simple warning'))
result.add(
self.test_simple('foobar', status.CRITICAL, 'test', '',
'simple critical'))
result.add(
self.test_simple('foobar', status.UNKNOWN, '1234567890', '',
'simple unknown'))
result.add(
self.test_simple('foobar', status.OK, 'qwerty', "'foo'=5%",
'simple performance data 001'))
result.add(
self.test_simple('foobar', status.OK, 'qwerty', "'foo'=5%;10",
'simple performance data 002'))
result.add(
self.test_simple('foobar', status.OK, 'qwerty', "'foo'=5%;10;23",
'simple performance data 003'))
result.add(
self.test_simple('foobar', status.OK, 'qwerty',
"'foo'=5%;10;23;10;78",
'simple performance data 004'))
result.add(
self.test_simple('foobar', status.OK, 'qwerty',
"'foo'=5%;10;23;10;78 'bar'=1k;2;3",
'simple performance data 005'))
return result
def check_files(self, filter, text, expected, extra_args):
self.setup_files()
alias = '%s: %s' % (text, filter)
result = TestResult('Checking %s' % alias)
args = [
'path=%s' % self.work_path,
'filter=%s' % filter, 'syntax=%filename%: %size% %write%',
'warn=gt:1', 'crit=gt:3'
]
args.extend(extra_args)
(ret, msg, perf) = self.core.simple_query('CheckFiles', args)
#log("Messge: %s"%msg)
#log("Perf: %s"%perf)
count = self.get_count(perf)
result.add_message(
count == expected, 'Check that we get correct number of files',
'Invalid result: got %s expected %s' % (count, expected))
if expected > 3:
result.add_message(
ret == status.CRITICAL,
'Check that we get correct status back (CRIT)',
'We did not get a CRIT back as expected: %s' % ret)
elif expected > 1:
result.add_message(
ret == status.WARNING,
'Check that we get correct status back (WARN)',
'We did not get a WARN back as expected: %s' % ret)
else:
result.add_message(
ret == status.OK, 'Check that we get correct status back (OK)',
'We did not get a OK back as expected: %s' % ret)
return result
def check_cli_ns(self):
result = TestResult('Checking CLI list-ns')
(ret, ns_msgs) = self.core.simple_exec('any', 'wmi', ['--list-all-ns', '--namespace', 'root'])
result.assert_equals(ret, 1, 'Check that --list-all-ns returns ok')
result.assert_equals(len(ns_msgs), 1, 'Check that --list-all-ns returns one entry')
if len(ns_msgs) > 0:
result.assert_contains(ns_msgs[0], 'CIMV2', 'Check that --list-all-ns contains cimv2')
return result
def run_test(self):
result = TestResult()
result.add(self.do_one_test(ssl=True))
result.add(self.do_one_test(ssl=False))
result.add(self.do_one_test(ssl=True, length=4096))
result.add(self.do_one_test(ssl=True, length=65536))
result.add(self.do_one_test(ssl=True, length=1048576))
return result
def test_one_crypto(self, crypto, length=512):
log('Testing: %s %d' % (crypto, length))
conf = self.conf
conf.set_string('/settings/NSCA/test_nsca_server', 'encryption',
'%s' % crypto)
conf.set_string('/settings/NSCA/test_nsca_server', 'password',
'pwd-%s' % crypto)
conf.set_int('/settings/NSCA/test_nsca_server', 'payload length',
length)
self.core.reload('test_nsca_server')
conf.set_string('/settings/NSCA/test_nsca_client/targets/default',
'address', 'nsca://127.0.0.1:35667')
conf.set_string('/settings/NSCA/test_nsca_client/targets/default',
'encryption', '%s' % crypto)
conf.set_string('/settings/NSCA/test_nsca_client/targets/default',
'password', 'default-%s' % crypto)
conf.set_int('/settings/NSCA/test_nsca_client/targets/default',
'payload length', length * 3)
conf.set_string('/settings/NSCA/test_nsca_client/targets/invalid',
'address', 'nsca://127.0.0.1:25667')
conf.set_string('/settings/NSCA/test_nsca_client/targets/invalid',
'encryption', 'none')
conf.set_string('/settings/NSCA/test_nsca_client/targets/invalid',
'password', 'invalid-%s' % crypto)
conf.set_int('/settings/NSCA/test_nsca_client/targets/invalid',
'payload length', length * 2)
conf.set_string('/settings/NSCA/test_nsca_client/targets/valid',
'address', 'nsca://127.0.0.1:15667')
conf.set_string('/settings/NSCA/test_nsca_client/targets/valid',
'encryption', '%s' % crypto)
conf.set_string('/settings/NSCA/test_nsca_client/targets/valid',
'password', 'pwd-%s' % crypto)
conf.set_int('/settings/NSCA/test_nsca_client/targets/valid',
'payload length', length)
self.core.reload('test_nsca_client')
result = TestResult('Testing: %s/%d' % (crypto, length))
result.add_message(isOpen('localhost', 15667),
'Checking that port is open')
for target in ['valid', 'test_rp', 'invalid']:
result.add(
self.test_one_crypto_full(crypto, status.UNKNOWN, 'unknown',
target, length))
result.add(
self.test_one_crypto_full(crypto, status.OK, 'ok', target,
length))
result.add(
self.test_one_crypto_full(crypto, status.WARNING, 'warn',
target, length))
result.add(
self.test_one_crypto_full(crypto, status.CRITICAL, 'crit',
target, length))
return result
def test_one(self, ssl=True, state=status.UNKNOWN, tag='TODO'):
result = TestResult('Testing NSCP: %s/%s with various targets' %
(ssl, tag))
#for t in ['valid', 'test_rp', 'invalid']:
for t in ['valid']:
result.add(
self.submit_payload('%s/%s' % (ssl, tag), ssl,
'%ssrc%s' % (tag, tag), state,
'%smsg%s' % (tag, tag), '', t))
return result
def test_syntax(self, filter, syntax, expected):
result = TestResult('Validating syntax: %s' % syntax)
(res, msg, perf) = self.core.simple_query('CheckEventLog', [
'file=Application', 'warn=ne:1',
'filter=%s' % filter,
'syntax=%s' % syntax, 'descriptions', 'scan-range=-10m'
])
result.assert_equals(msg, expected,
"Validate message rendering syntax: %s" % msg)
return result
def submit_payload(self, alias, ssl, length, source, status, msg, perf, target):
message = plugin_pb2.QueryRequestMessage()
message.header.destination_id = target
message.header.command = 'nrpe_forward'
host = message.header.hosts.add()
host.address = "127.0.0.1:15666"
host.id = target
if (target == 'valid'):
pass
else:
enc = host.metadata.add()
enc.key = "use ssl"
enc.value = '%s'%ssl
enc = host.metadata.add()
enc.key = "payload length"
enc.value = '%d'%length
enc = host.metadata.add()
enc.key = "timeout"
enc.value = '5'
uid = str(uuid.uuid4())
payload = message.payload.add()
payload.command = 'check_py_nrpe_test_s'
payload.arguments.append(uid)
rmsg = self.get_request(uid)
rmsg.status = status
rmsg.message = msg
rmsg.perfdata = perf
self.set_request(rmsg)
(result_code, response) = self.core.query('ignored', message.SerializeToString())
response_message = plugin_pb2.QueryResponseMessage()
response_message.ParseFromString(response)
result = TestResult('Testing NRPE: %s for %s'%(alias, target))
found = False
for i in range(0,10):
if self.has_response(uid):
rmsg = self.get_response(uid)
#result.add_message(rmsg.got_response, 'Testing to recieve message using %s'%alias)
result.add_message(rmsg.got_simple_response, 'Testing to recieve simple message using %s'%alias)
result.add_message(len(response_message.payload) == 1, 'Verify that we only get one payload response for %s'%alias, '%s != 1'%len(response_message.payload))
if len(response_message.payload) == 1 and len(response_message.payload[0].lines) == 1:
result.assert_equals(response_message.payload[0].result, status, 'Verify that status is sent through %s'%alias)
result.assert_equals(response_message.payload[0].lines[0].message, msg, 'Verify that message is sent through %s'%alias)
#result.assert_equals(rmsg.perfdata, perf, 'Verify that performance data is sent through')
self.del_response(uid)
found = True
break
else:
log('Waiting for %s (%s/%s)'%(uid,alias,target))
sleep(500)
if not found:
result.add_message(False, 'Testing to recieve message using %s'%alias)
return result
def run_test_counters(self):
result = TestResult('Checking CheckCounter')
(result_code,
result_message) = core.simple_exec('any', 'pdh',
['--list', '--porcelain'])
count = 0
data = []
for m in result_message:
data = m.splitlines()
count = len(data)
result.add_message(count > 0,
'Managed to retrieve counters: %d' % count)
if len(data) == 0:
result.add_message(False,
'Failed to find counters: %s' % result_message)
counters = []
for x in range(1, 10):
try:
str = random.choice(data)
(alias, counter, message) = str.split(',', 2)
(retcode, retmessage,
retperf) = core.simple_query('CheckCounter', [
'index', 'ShowAll', 'MaxWarn=10',
'Counter:001=%s' % counter
])
result.add_message(retcode != status.UNKNOWN,
'Queried normal: %s' % counter)
result.add_message(
len(retmessage) > 0,
'Queried normal (got message): %s' % retmessage)
result.add_message(
len(retperf) > 0,
'Queried normal (got perf): %s' % retperf)
if retcode != status.UNKNOWN:
counters.append('Counter:%d=%s' % (x, counter))
except Exception as e:
result.add_message(False,
'Invalid counter found "%s": %s' % (str, e))
args = ['index', 'ShowAll', 'MaxWarn=10']
args.extend(counters)
(retcode, retmessage,
retperf) = core.simple_query('CheckCounter', args)
result.add_message(
retcode != status.UNKNOWN,
'Queried normal list of %d counters' % len(counters))
result.add_message(
len(retmessage) > 0,
'Queried normal (got message): %s' % retmessage)
result.add_message(
len(retperf) > 0, 'Queried normal (got perf): %s' % retperf)
result.add_message(
len(counters) == len(retperf.split(' ')),
'Got all responses: %d' % len(counters))
return result
def check_counter(self, counter, args):
result = TestResult('Checking counter: %s' % counter)
args.append('Counter=%s' % counter)
(retcode, retmessage,
retperf) = self.core.simple_query('CheckCounter', args)
result.add_message(retcode != status.UNKNOWN,
'Return code: %s' % retcode)
result.add_message(
len(retmessage) > 0, 'Returned message: %s' % retmessage)
result.add_message(len(retperf) > 0, 'Performance data: %s' % retperf)
return result
def run_test(self):
result = TestResult('Testing W32 file systems')
# Check size
result.add(self.check_files('size gt 0b', 'Count all files', 10, []))
result.add(self.check_files('size gt 4b', 'Count all files', 2, []))
result.add(self.check_files('size lt 4b', 'Count all files', 11, []))
result.add(self.check_files('size eq 4b', 'Count all files', 8, []))
result.add(self.check_files('size ne 4b', 'Count all files', 13, []))
result.add(self.check_files('size eq 0b', 'Count all folders', 11, []))
# Check flags (recursive, pattern)
result.add(
self.check_files('size eq 0b',
'Count all folders (non recursivly)', 3,
['max-dir-depth=0']))
result.add(
self.check_files('size eq 0b', 'Count all folders (recurse 1)', 6,
['max-dir-depth=1']))
result.add(
self.check_files('size gt 0b', 'Count all files (*.txt)', 9,
['pattern=*.txt']))
result.add(
self.check_files('size gt 0b', 'Count all files (*.txt)', 0,
['pattern=*.foo']))
# Check dates
result.add(
self.check_files('written ge -5m', 'Count all files (*.txt, >-5m)',
7, ['pattern=*.txt']))
result.add(
self.check_files('written le -5m', 'Count all files (*.txt, <-5m)',
4, ['pattern=*.txt']))
result.add(
self.check_files('written lt -9m', 'Count all files (*.txt, <-9m)',
2, ['pattern=*.txt']))
result.add(
self.check_files('written gt -9m', 'Count all files (*.txt, >-9m)',
7, ['pattern=*.txt']))
result.add(
self.check_files('written lt -1m', 'Count all files (*.txt, <-1m)',
4, ['pattern=*.txt']))
result.add(
self.check_files('written gt -9m and written lt -1m',
'Count all files (*.txt, >-10m<-5m)', 2,
['pattern=*.txt']))
result.add(
self.check_files('written gt 0m', 'Count all files (*.txt, >0m)',
4, ['pattern=*.txt']))
self.cleanup_files()
return result
def test_simple(self, command, code, message, perf, tag):
result = TestResult()
core = Core.get()
self.reset_last()
(ret, msg) = core.simple_submit(self.channel, '%s'%command, code, '%s'%message, '%s'%perf)
result.add_message(ret, 'Testing channels: %s'%tag, msg)
r1 = TestResult()
r1.assert_equals(self.last_status, code, 'Return code')
r1.assert_equals(self.last_message, message, 'Message')
r1.assert_equals(self.last_perf, perf, 'Performance data')
result.add(r1)
self.set_last('', '', code, message, perf)
(retcode, retmessage, retperf) = core.simple_query(self.channel, [])
result.add_message(True, 'Testing queries: %s'%tag)
r2 = TestResult()
r2.assert_equals(self.last_status, code, 'Return code')
r2.assert_equals(self.last_message, message, 'Message')
r2.assert_equals(self.last_perf, perf, 'Performance data')
result.add(r2)
return result
def check_cli_ls(self, ns, expected, missing):
result = TestResult('Checking CLI list-classes %s'%ns)
args = ['--list-classes', '--simple']
if ns != None:
args.extend(['--namespace', ns])
(ret, ns_msgs) = self.core.simple_exec('any', 'wmi', args)
result.assert_equals(ret, 1, 'Check that --list-classes returns ok')
result.assert_equals(len(ns_msgs), 1, 'Check that --list-classes returns one entry')
if len(ns_msgs) > 0:
result.assert_contains(ns_msgs[0], expected, 'Check that --list-classes contains %s'%expected)
result.assert_not_contains(ns_msgs[0], missing, 'Check that --list-classes does not contains %s'%missing)
return result
def check_cli_query(self, query, count, check, ns = None):
result = TestResult('Checking CLI query %s'%query)
args = ['--select', query, '--simple']
if ns != None:
args.extend(['--namespace', ns])
(ret, ns_msgs) = self.core.simple_exec('any', 'wmi', args)
result.assert_equals(ret, 1, 'Check that --select returns ok')
result.assert_equals(len(ns_msgs), 1, 'Check that --select returns one entry')
if len(ns_msgs) > 0:
result.add_message(count(ns_msgs[0].splitlines()), 'Check that it contains the right number of rows')
result.add_message(check(ns_msgs[0]), 'Check that it contains the right data')
return result
def run_test(self):
result = TestResult()
cryptos = [
"none", "xor", "des", "3des", "cast128", "xtea", "blowfish",
"twofish", "rc2", "aes", "aes256", "aes192", "aes128", "serpent",
"gost", "3way"
]
for c in cryptos:
for l in [128, 512, 1024, 4096]:
result.add(self.test_one_crypto(c, l))
#result.add(self.test_one_crypto(c))
return result
def test_one_crypto_full(self, encryption, state, key, target, length):
result = TestResult('Testing %s/%s' % (encryption, key))
result.add(
self.submit_payload(
encryption, target, length, '%ssrc%s' % (key, key), state,
'%smsg%s' % (key, key), '',
'%s/%s/%d/%s' % (state, encryption, length, target)))
result.add(
self.submit_via_exec(
encryption, target, length, '%ssrc%s' % (key, key), state,
'%smsg%s' % (key, key), '',
'%s/%s/%d/%s' % (state, encryption, length, target)))
return result
def run_test_proc(self):
master = TestResult('Checking check_process')
result = TestResult('0 notepads running')
for j in range(0, 3):
result.append(self.test_one_proc_int('notepad.exe', 0, j))
master.add(result)
pids = []
for i in range(1, 4):
result = TestResult('%d notepads running' % i)
log('Starting notepad...')
handle = subprocess.Popen('notepad.exe', shell=False)
sleep(500)
pids.append(handle.pid)
for j in range(0, 3):
result.append(self.test_one_proc_int('notepad.exe', i, j))
master.add(result)
for p in pids:
subprocess.Popen("taskkill /F /T /PID %i" % p, shell=True)
return master
def check_no_files(self):
self.setup_files()
result = TestResult('Checking no files')
args = ['path=%s\\aaa.txt' % self.work_path]
(ret, msg, perf) = self.core.simple_query('check_files', args)
#log("Messge: %s"%msg)
#log("Perf: %s"%perf)
result.add_message(ret == status.UNKNOWN,
'Check that we get correct status back',
'Return status was wrong: %s' % ret)
#count = self.get_count(perf)
result.assert_equals(msg, 'No files found', 'Validate return message')
return result
def test_one_proc_int(self, proc, actual, asked):
result = TestResult('Checking one state %d/%d' % (actual, asked))
for s in ['eq', 'gt', 'lt', 'ne']:
(retcode, retmessage,
retperf) = self.core.simple_query('check_process', [
'empty-state=OK', 'show-all',
'crit=count %s %d' % (s, asked),
"filter=exe='%s'" % proc
])
expected = self.get_expected_state(actual, s, asked)
result.add_message(
retcode == expected, 'Process: %s (%d %s %d): %s' %
(proc, actual, s, asked, retmessage),
'%s != %s' % (retcode, expected))
return result
def check_ts_query(self, task, code):
result = TestResult('Checking task %s'%task)
for i in [0, 1, 2, 3, 4]:
# check_tasksched "filter=title = 'NSCPSample_CRIT'" "warn=exit_code != 3"
args = ["filter=title = 'NSCPSample_%s'"%task,
"warn=exit_code = %d"%i]
log_debug(', '.join(args))
(ret, msg, perf) = self.core.simple_query('check_tasksched', args)
if i == code:
result.assert_equals(ret, status.WARNING, 'Verify WARN result: %s'%msg)
else:
result.assert_equals(ret, status.OK, 'Verify OK result: %s'%msg)
return result