def runTest(self):
import pytrap
a = pytrap.UnirecTemplate(
"ipaddr SRC_IP,time TIME_FIRST,uint32 ABC,uint32 BCD,string TEXT,bytes STREAMBYTES"
)
a.createMessage(100)
self.assertEqual(
a.getFieldsDict(), {
'SRC_IP': 0,
'STREAMBYTES': 5,
'TEXT': 4,
'TIME_FIRST': 1,
'ABC': 2,
'BCD': 3
})
a.SRC_IP = pytrap.UnirecIPAddr("1.2.3.4")
a.TIME_FIRST = pytrap.UnirecTime(123456)
a.ABC = 1234
a.BCD = 54321
a.STREAMBYTES = bytearray(b"streamtext")
a.TEXT = "stringmuj text"
tc = a.strRecord()
for i in range(100):
self.assertEqual(tc, a.strRecord())
a = pytrap.UnirecTemplate(
"ipaddr DST_IP,time TIME_FIRST,uint32 BCD,string TEXT2,bytes STREAMBYTES"
)
self.assertEqual(a.getFieldsDict(), {
'BCD': 3,
'DST_IP': 6,
'TIME_FIRST': 1,
'STREAMBYTES': 5,
'TEXT2': 7
})
try:
a.DST_IP = pytrap.UnirecIPAddr("4.4.4.4")
except:
pass
else:
self.fail("Data was not set, this should raise exception.")
a.createMessage(100)
try:
a.SRC_IP = pytrap.UnirecIPAddr("4.4.4.4")
except:
pass
else:
self.fail("This template has no SRC_IP.")
a.DST_IP = pytrap.UnirecIPAddr("4.4.4.4")
a.STREAMBYTES = bytearray(b"hello")
valdict = {}
for name, value in a:
valdict[name] = value
self.assertEqual(
valdict, {
'STREAMBYTES': bytearray(b'hello'),
'DST_IP': pytrap.UnirecIPAddr('4.4.4.4'),
'TIME_FIRST': pytrap.UnirecTime(0),
'TEXT2': '',
'BCD': 0
})
def runTest(self):
import pytrap
# Unsupported type
with self.assertRaises(TypeError):
pytrap.UnirecTime(tuple([1, 3]))
# Float
t = pytrap.UnirecTime(1.5)
self.assertEqual(t.getSeconds(), 1)
self.assertEqual(t.getMiliSeconds(), 500)
# seconds and miliseconds
t = pytrap.UnirecTime(1466701316, 123)
self.assertEqual(t.getSeconds(), 1466701316,
"Number of seconds differs.")
self.assertEqual(t.getMiliSeconds(), 123,
"Number of miliseconds differs.")
self.assertEqual(t.getTimeAsFloat(), 1466701316.123,
"Time as float differs.")
t1 = pytrap.UnirecTime("2019-03-18T20:58:12.100")
self.assertEqual(t1, pytrap.UnirecTime(1552942692, 100))
# test conversion from string with timezone to UnirecTime
t1 = pytrap.UnirecTime("2019-03-18T20:58:12.100Z")
t2 = pytrap.UnirecTime("2019-03-19T20:58:12.222Z")
self.assertEqual(t1, pytrap.UnirecTime(1552942692, 100))
self.assertEqual(t2, pytrap.UnirecTime(1553029092, 222))
self.assertEqual(t2.getSeconds() - t1.getSeconds(), 24 * 60 * 60)
# malformed format
with self.assertRaises(TypeError):
pytrap.UnirecTime("18.3.2019 20:58:12.100Z")
def runTest(self):
import pytrap
t = pytrap.UnirecTime(1466701316, 123)
self.assertEqual(type(t), pytrap.UnirecTime,
"Bad type of Time object.")
self.assertEqual(str(t), "1466701316.123",
"Time is not equal to its str().")
self.assertEqual(repr(t), "UnirecTime(1466701316, 123)",
"Time is not equal to its repr().")
self.assertEqual(float(t), 1466701316.123,
"Conversion of Time to float failed.")
self.assertEqual(t, t)
self.assertEqual(t.getSeconds(), 1466701316,
"Number of seconds differs.")
self.assertEqual(t.getMiliSeconds(), 123,
"Number of miliseconds differs.")
self.assertEqual(t.getTimeAsFloat(), 1466701316.123,
"Time as float differs.")
t2 = pytrap.UnirecTime(10, 100)
self.assertEqual(type(t2), pytrap.UnirecTime,
"Bad type of Time object.")
self.assertEqual(str(t2), "10.100", "Time is not equal to its str().")
self.assertEqual(repr(t2), "UnirecTime(10, 100)",
"Time is not equal to its repr().")
self.assertFalse(t == t2)
self.assertFalse(t <= t2)
self.assertTrue(t >= t2)
self.assertTrue(t != t2)
self.assertFalse(t < t2)
self.assertTrue(t > t2)
res1 = pytrap.UnirecTime(1466701326, 223)
self.assertEqual(t + t2, res1)
res2 = pytrap.UnirecTime(2466701316, 123)
self.assertEqual(t + 1000000000, res2)
res3 = pytrap.UnirecTime(466701316, 123)
self.assertEqual(t + (-1000000000), res3)
for i in range(10):
self.assertEqual(res1.format(), "2016-06-23T17:02:06Z")
for i in range(10):
self.assertEqual(res1.format("%d.%m.%Y"), "23.06.2016")
from datetime import datetime
now = pytrap.UnirecTime.now()
now2 = datetime.utcnow()
delta = now2 - now.toDatetime()
self.assertTrue(
timedelta_total_seconds(delta) <= 1,
"Now returns delayed time {0}.".format(str(delta)))
# convert datetime to UnirecTime and compare it
now = pytrap.UnirecTime.fromDatetime(now2)
self.assertTrue(abs(now.getSeconds() - int(now2.strftime("%s")) <= 1))
def runTest(self):
import pytrap
a = pytrap.UnirecTemplate(
"ipaddr SRC_IP,time TIME_FIRST,uint32 ABC,uint32 BCD,string TEXT,bytes STREAMBYTES"
)
a.createMessage(100)
self.assertEqual(
set(a.getFieldsDict().keys()),
set(['SRC_IP', 'STREAMBYTES', 'TEXT', 'TIME_FIRST', 'ABC', 'BCD']))
a.SRC_IP = pytrap.UnirecIPAddr("1.2.3.4")
a.TIME_FIRST = pytrap.UnirecTime(123456)
a.ABC = 1234
a.BCD = 54321
a.STREAMBYTES = bytearray(b"streamtext")
a.TEXT = "stringmuj text"
tc = a.strRecord()
for i in range(100):
self.assertEqual(tc, a.strRecord())
a = pytrap.UnirecTemplate(
"ipaddr DST_IP,time TIME_FIRST,uint32 BCD,string TEXT2,bytes STREAMBYTES"
)
self.assertEqual(
set(a.getFieldsDict().keys()),
set(['DST_IP', 'TIME_FIRST', 'BCD', 'STREAMBYTES', 'TEXT2']))
# Data was not set, this should raise exception.
with self.assertRaises(pytrap.TrapError):
a.DST_IP = pytrap.UnirecIPAddr("4.4.4.4")
a.createMessage(100)
# This template has no SRC_IP.
with self.assertRaises(AttributeError):
a.SRC_IP = pytrap.UnirecIPAddr("4.4.4.4")
a.DST_IP = pytrap.UnirecIPAddr("4.4.4.4")
a.STREAMBYTES = bytearray(b"hello")
valdict = {}
for name, value in a:
valdict[name] = value
self.assertEqual(
valdict, {
'STREAMBYTES': bytearray(b'hello'),
'DST_IP': pytrap.UnirecIPAddr('4.4.4.4'),
'TIME_FIRST': pytrap.UnirecTime(0),
'TEXT2': '',
'BCD': 0
})
def runTest(self):
import pytrap
a = pytrap.UnirecTemplate(
"ipaddr SRC_IP,time TIME_FIRST,uint32 ABC,uint32 BCD,string TEXT,bytes STREAMBYTES"
)
data = bytearray(
b'\x00\x00\x00\x00\x00\x00\x00\x00\x0A\x00\x00\x01\xff\xff\xff\xff\xc8\x76\xbe\xff\xe3\x2b\x6c\x57\x00\x00\x00\x01\x00\x00\x00\x02\x06\x00\x04\x00\x00\x00\x06\x00abcdef\xde\xad\xfe\xed'
)
a.setData(data)
self.assertEqual(len(a), 6, "Number of fields differs, 6 expected.")
self.assertEqual(
str(a),
"(ipaddr SRC_IP,time TIME_FIRST,uint32 ABC,uint32 BCD,bytes STREAMBYTES,string TEXT)"
)
d = a.getFieldsDict()
self.assertEqual(type(d), dict)
self.assertEqual(
d, {
'TIME_FIRST': 1,
'ABC': 2,
'BCD': 3,
'TEXT': 4,
'STREAMBYTES': 5,
'SRC_IP': 0
})
self.assertEqual(a.get(data, "SRC_IP"),
pytrap.UnirecIPAddr("10.0.0.1"))
self.assertEqual(a.get(data, "SRC_IP"), a.getByID(data, 0))
self.assertEqual(a.get(data, "SRC_IP"), a.SRC_IP)
self.assertEqual(a.get(data, "TIME_FIRST"), a.getByID(data, 1))
self.assertEqual(a.get(data, "TIME_FIRST"),
pytrap.UnirecTime(1466706915, 999))
self.assertEqual(a.get(data, "TIME_FIRST"), a.TIME_FIRST)
self.assertEqual(a.get(data, "ABC"), 16777216)
self.assertEqual(a.get(data, "ABC"), a.getByID(data, 2))
self.assertEqual(a.get(data, "ABC"), a.ABC)
self.assertEqual(a.get(data, "BCD"), 33554432)
self.assertEqual(a.get(data, "BCD"), a.getByID(data, 3))
self.assertEqual(a.get(data, "BCD"), a.BCD)
self.assertEqual(a.get(data, "TEXT"), "abcdef")
self.assertEqual(a.get(data, "TEXT"), a.getByID(data, 4))
self.assertEqual(a.get(data, "TEXT"), a.TEXT)
self.assertEqual(type(a.get(data, "STREAMBYTES")), bytearray)
self.assertEqual(a.get(data, "STREAMBYTES"),
bytearray(b'\xde\xad\xfe\xed'))
self.assertEqual(a.get(data, "STREAMBYTES"), a.getByID(data, 5))
self.assertEqual(a.get(data, "STREAMBYTES"), a.STREAMBYTES)
stream = a.get(data, "STREAMBYTES")
self.assertEqual(" ".join([hex(i) for i in stream]),
"0xde 0xad 0xfe 0xed")
def runTest(self):
import pytrap
a = pytrap.UnirecTemplate(
"ipaddr SRC_IP,time TIME_FIRST,uint32 ABC,uint32 BCD,string TEXT,bytes STREAMBYTES"
)
data = a.createMessage(100)
for i in range(100):
getdata = a.getData()
# size of created (allocated) message and retrieved message differs (due to non-filled variable fields)
self.assertEqual(data[:len(getdata)], getdata)
a.ABC = 666
self.assertEqual(a.ABC, 666)
a.SRC_IP = pytrap.UnirecIPAddr("147.32.1.1")
self.assertEqual(a.SRC_IP, pytrap.UnirecIPAddr("147.32.1.1"))
a.setByID(data, 0, pytrap.UnirecIPAddr("fd7c:e770:9b8a::465"))
self.assertEqual(a.SRC_IP, pytrap.UnirecIPAddr("fd7c:e770:9b8a::465"))
a.set(data, "SRC_IP", pytrap.UnirecIPAddr("10.0.0.1"))
self.assertEqual(a.SRC_IP, pytrap.UnirecIPAddr("10.0.0.1"))
a.TIME_FIRST = pytrap.UnirecTime(666, 0)
self.assertEqual(a.TIME_FIRST, pytrap.UnirecTime(666, 0))
a.setByID(data, 1, pytrap.UnirecTime(1234, 666))
self.assertEqual(a.TIME_FIRST, pytrap.UnirecTime(1234, 666))
a.set(data, "TIME_FIRST", pytrap.UnirecTime(1468962758, 166))
self.assertEqual(a.TIME_FIRST, pytrap.UnirecTime(1468962758, 166))
a.TEXT = "different text"
self.assertEqual(a.TEXT, "different text")
a.setByID(data, 4, "my long text")
self.assertEqual(a.TEXT, "my long text")
a.set(data, "TEXT", "long text")
self.assertEqual(a.TEXT, "long text")
a.STREAMBYTES = bytearray(b"he\x01\x01")
self.assertEqual(a.STREAMBYTES, bytearray(b"he\x01\x01"))
a.STREAMBYTES = bytes(b"\xca\xfe")
self.assertEqual(a.STREAMBYTES, bytes(b"\xca\xfe"))
a.setByID(data, 5, bytes(b"\xde\xad\xbe\xef"))
self.assertEqual(a.STREAMBYTES, bytes(b"\xde\xad\xbe\xef"))
data = a.createMessage(100)
a.setByID(data, 2, int(1234))
a.ABC = int(1)
self.assertEqual(a.ABC, int(1))
a.set(data, "ABC", int(666))
self.assertEqual(a.ABC, int(666))
a.ABC = int(222)
self.assertEqual(a.ABC, int(222))
# overflow
a.ABC = int(4294967296)
self.assertEqual(a.ABC, int(0))
print("GET 3")
print(a.get(3, data))
print("GET 4")
print(a.get(4, data))
print(a.TEXT)
print("GET 5")
print(type(a.get(5, data)))
stream = a.get(5, data)
print(" ".join([hex(i) for i in stream]))
print(a.STREAMBYTES)
print("UnirecTime")
t = pytrap.UnirecTime(1466701316, 123)
print("t")
print(t)
print(t.getSeconds())
print(t.getMiliSeconds())
print(t.getTimeAsFloat())
print(type(t.getTimeAsFloat()))
t2 = pytrap.UnirecTime(10, 100)
print("t + t2")
print(t + t2)
print("t + 1000000000")
constint = 1000000000
print(type(constint))
print(t + constint)
print("t + -1000000000")
print(t + -constint)
def runTest(self):
import pytrap
a = pytrap.UnirecTemplate("ipaddr IP,time TIME,uint64 U64,uint32 U32,uint16 U16,uint8 U8,int64 I64,int32 I32,int16 I16,int8 I8,float FL,double DB,char CHR,string TEXT,bytes STREAMBYTES")
a.createMessage(100)
a.IP = pytrap.UnirecIPAddr("1.2.3.4")
a.TIME = pytrap.UnirecTime(123456)
a.U64 = 0x100000000
a.U32 = 0x10000
a.U16 = 0x100
a.U8 = 0x1
a.I64 = -1
a.I32 = -1
a.I16 = -1
a.I8 = -1
a.FL = 1.234
a.DB = 1.234
#a.CHR = "a"
a.TEXT = "text"
a.STREAMBYTES = b"streambytes"
self.assertTrue(a.IP == pytrap.UnirecIPAddr("1.2.3.4"))
self.assertTrue(a.TIME == pytrap.UnirecTime(123456))
self.assertTrue(a.U64 == 0x100000000)
self.assertTrue(a.U32 == 0x10000)
self.assertTrue(a.U16 == 0x100)
self.assertTrue(a.U8 == 0x1)
self.assertTrue(a.I64 == -1)
self.assertTrue(a.I32 == -1)
self.assertTrue(a.I16 == -1)
self.assertTrue(a.I8 == b'\xff')
self.assertTrue(1.234 - a.FL < 1e-7)
self.assertTrue(a.DB == 1.234)
#self.assertTrue(a.CHR == "a")
self.assertTrue(a.TEXT == "text")
self.assertTrue(a.STREAMBYTES == b"streambytes")
# Check types
self.assertEqual(type(a.IP), pytrap.UnirecIPAddr)
self.assertEqual(type(a.TIME), pytrap.UnirecTime)
self.assertEqual(type(a.U64), long)
self.assertEqual(type(a.U32), int)
self.assertEqual(type(a.U16), int)
self.assertEqual(type(a.U8), int)
self.assertEqual(type(a.I64), long)
self.assertEqual(type(a.I32), int)
self.assertEqual(type(a.I16), int)
self.assertEqual(type(a.I8), bytes)
self.assertEqual(type(a.CHR), int)
self.assertEqual(type(a.FL), float)
self.assertEqual(type(a.DB), float)
self.assertEqual(type(a.TEXT), str)
self.assertEqual(type(a.STREAMBYTES), bytearray)
self.assertEqual(a.getFieldType("IP"), pytrap.UnirecIPAddr)
self.assertEqual(a.getFieldType("TIME"), pytrap.UnirecTime)
self.assertEqual(a.getFieldType("U64"), long)
self.assertEqual(a.getFieldType("U32"), long)
self.assertEqual(a.getFieldType("U16"), long)
self.assertEqual(a.getFieldType("U8"), long)
self.assertEqual(a.getFieldType("I64"), long)
self.assertEqual(a.getFieldType("I32"), long)
self.assertEqual(a.getFieldType("I16"), long)
self.assertEqual(a.getFieldType("I8"), long)
self.assertEqual(a.getFieldType("CHR"), long)
self.assertEqual(a.getFieldType("FL"), float)
self.assertEqual(a.getFieldType("DB"), float)
self.assertEqual(a.getFieldType("TEXT"), str)
self.assertEqual(a.getFieldType("STREAMBYTES"), bytearray)
def convert_to_idea(rec, opts=None):
"""
Converts the aggregated ipblacklistfilter event(json) to the IDEA format.
This module represents only one type of events - Cryptocurrency mining -
for the sake of simplicity.
For more universal purpose, use blacklist2idea.py.
Args:
rec: the record from ipblacklistfilter and aggregator
opts: cmd options
Returns:
dict: idea
"""
global GUARDED_PREFIXES
if not GUARDED_PREFIXES:
GUARDED_PREFIXES = load_prefixes(opts.prefixes)
idea = {
"Category": ["Suspicious.Miner"],
"Format":
"IDEA0",
"ID":
getRandomId(),
"CreateTime":
getIDEAtime(),
"EventTime":
getIDEAtime(pytrap.UnirecTime(rec["ts_first"])),
"DetectTime":
getIDEAtime(pytrap.UnirecTime(rec["ts_last"])),
"CeaseTime":
getIDEAtime(pytrap.UnirecTime(rec["ts_last"])),
"Description":
"Possible CryptoCurrency mining identified by connection with a mining pool.",
"Source": [],
"Target": [],
"Node": [{
"Name": "undefined",
"SW": ["Nemea", "blacklistfilter"],
"AggrWin": minutes_to_aggr_win(int(rec["agg_win_minutes"])),
"Type": ["Flow", "Blacklist"]
}],
"Ref": ["http://smashed.fit.vutbr.cz:8080/miningProp/json"]
}
if rec["protocol"] in PROTO_CONV:
proto = PROTO_CONV[rec["protocol"]]
idea['Source'].append({'Proto': [proto]})
idea['Target'].append({'Proto': [proto]})
miners = [pytrap.UnirecIPAddr(t) for t in rec["targets"]]
pool = pytrap.UnirecIPAddr(rec["source"])
idea['Source'][0]["Type"] = "Miner"
for miner in miners:
setAddr(idea['Source'][0], miner)
# look up pool IP in guarded prefixes
if GUARDED_PREFIXES and any([pool in p for p in GUARDED_PREFIXES]):
# own guarded resource was detected as a pool - add as Source
idea['Source'].append({"Proto": [proto]})
setAddr(idea['Source'][1], pool)
idea['Source'][1]["Type"] = "MiningPool"
idea[
'Note'] = 'IP {1} and port(s) {2} is listed as a mining pool server (by sMaSheD list of cryptocurrency mining pools), and IP {0} communicated with this service - possible miner.'.format(
", ".join([str(m) for m in miners]), str(pool),
", ".join([str(p) for p in rec["source_ports"]]))
del idea['Target']
else:
# pool is just an external IP and our resource is a potential miner
# - add pool as Target
setAddr(idea['Target'][0], pool)
idea['Target'][0]["Type"] = "MiningPool"
idea[
'Note'] = 'Detected possible CryptoCurrency mining by IP {0}, because of observed communication with {1}:{2} listed as a mining pool server (by sMaSheD list of cryptocurrency mining pools).'.format(
", ".join([str(m) for m in miners]), str(pool),
", ".join([str(p) for p in rec["source_ports"]]))
return idea
def runTest(self):
import pytrap
a = pytrap.UnirecTemplate(
"uint32 FOO, uint32 BAR, ipaddr IP, string STR, int32* ARR1, ipaddr* IPs, macaddr* MACs, uint64* ARR2, time* TIMEs"
)
data = bytearray(
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x61\x4e\xff\xff\xff\xff\x31\xd4\x00\x00\x39\x30\x00\x00\x00\x00\x0c\x00\x0c\x00\x28\x00\x34\x00\x12\x00\x46\x00\x50\x00\x96\x00\x18\x00\xae\x00\x50\x00\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21\xf7\xff\xff\xff\xf8\xff\xff\xff\xf9\xff\xff\xff\xfa\xff\xff\xff\xfb\xff\xff\xff\xfc\xff\xff\xff\xfd\xff\xff\xff\xfe\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x11\x11\x11\x11\x11\x22\x22\x22\x22\x22\x22\x0a\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x0e\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\xc0\x33\x5b\x00\x00\x00\x80\xe6\xc0\x33\x5b\x00\x00\x00\x00\xe6\xc0\x33\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x01\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x02\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x01\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x61\x4e\xff\xff\xff\xff'
)
a.setData(data)
self.assertEqual(len(a), 9, "Number of fields differs, 9 expected.")
self.assertEqual(
str(a),
"(ipaddr IP,uint32 BAR,uint32 FOO,string STR,int32* ARR1,macaddr* MACs,uint64* ARR2,time* TIMEs,ipaddr* IPs)"
)
d = a.getFieldsDict()
self.assertEqual(type(d), dict)
self.assertEqual(
set(d.keys()),
set([
'IP', 'BAR', 'FOO', 'STR', 'ARR1', 'MACs', 'ARR2', 'TIMEs',
'IPs'
]))
self.assertEqual(a.getFieldType("ARR1"), list)
self.assertEqual(a.getFieldType("ARR2"), list)
self.assertEqual(a.getFieldType("IPs"), list)
self.assertEqual(a.getFieldType("TIMEs"), list)
self.assertEqual(a.get(data, "FOO"), 12345)
self.assertEqual(a.get(data, "FOO"), a.getByID(data, 6))
self.assertEqual(a.get(data, "FOO"), a.FOO)
self.assertEqual(a.get(data, "BAR"), 54321)
self.assertEqual(a.get(data, "BAR"), a.getByID(data, 7))
self.assertEqual(a.get(data, "BAR"), a.BAR)
self.assertEqual(a.get(data, "IP"), pytrap.UnirecIPAddr("0.188.97.78"))
self.assertEqual(a.get(data, "IP"), a.getByID(data, 8))
self.assertEqual(a.get(data, "IP"), a.IP)
self.assertEqual(a.get(data, "STR"), "Hello World!")
self.assertEqual(a.get(data, "STR"), a.getByID(data, 9))
self.assertEqual(a.get(data, "STR"), a.STR)
self.assertEqual(a.get(data, "ARR1"),
[-9, -8, -7, -6, -5, -4, -3, -2, -1, 0])
self.assertEqual(a.get(data, "ARR1"), a.getByID(data, 10))
self.assertEqual(a.get(data, "ARR1"), a.ARR1)
self.assertEqual(a.get(data, "IPs"), [
pytrap.UnirecIPAddr("10.0.0.1"),
pytrap.UnirecIPAddr("10.0.0.2"),
pytrap.UnirecIPAddr("::1"),
pytrap.UnirecIPAddr("127.0.0.1"),
pytrap.UnirecIPAddr("0.188.97.78")
])
self.assertEqual(a.get(data, "IPs"), a.getByID(data, 11))
self.assertEqual(a.get(data, "IPs"), a.IPs)
self.assertEqual(a.get(data, "MACs"), [
pytrap.UnirecMACAddr("0:0:0:0:0:0"),
pytrap.UnirecMACAddr("11:11:11:11:11:11"),
pytrap.UnirecMACAddr("22:22:22:22:22:22")
])
self.assertEqual(a.get(data, "MACs"), a.getByID(data, 12))
self.assertEqual(a.get(data, "MACs"), a.MACs)
self.assertEqual(a.get(data, "ARR2"),
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19])
self.assertEqual(a.get(data, "ARR2"), a.getByID(data, 13))
self.assertEqual(a.get(data, "ARR2"), a.ARR2)
self.assertEqual(a.get(data, "TIMEs"), [
pytrap.UnirecTime("2018-06-27T16:52:54"),
pytrap.UnirecTime("2018-06-27T16:52:54.500"),
pytrap.UnirecTime("2018-06-27T16:52:54Z"),
])
self.assertEqual(a.get(data, "TIMEs"), a.getByID(data, 14))
self.assertEqual(a.get(data, "TIMEs"), a.TIMEs)
f_str = "Hello Unirec!"
f_arr1 = [-42, 7, 11, 13, -17, 19]
f_ips = [
pytrap.UnirecIPAddr("10.200.4.1"),
pytrap.UnirecIPAddr("192.168.0.200"),
pytrap.UnirecIPAddr("2000::1")
]
f_macs = [
pytrap.UnirecMACAddr("6:5:4:3:2:1"),
pytrap.UnirecMACAddr("FF:FF:FF:FF:FF:FF"),
pytrap.UnirecMACAddr("1:1:1:1:1:1"),
pytrap.UnirecMACAddr("1:2:3:4:5:6")
]
f_arr2 = [123467890, 987654321]
f_times = [
pytrap.UnirecTime(1466706915, 999),
pytrap.UnirecTime(146324234, 999),
pytrap.UnirecTime(0, 1),
pytrap.UnirecTime(1466700000, 0)
]
a.set(data, "STR", f_str)
a.set(data, "ARR1", f_arr1)
a.set(data, "IPs", f_ips)
a.MACs = f_macs
a.ARR2 = f_arr2
a.set(data, "TIMEs", f_times)
self.assertEqual(a.get(data, "STR"), f_str)
self.assertEqual(a.get(data, "ARR1"), f_arr1)
self.assertEqual(a.get(data, "IPs"), f_ips)
self.assertEqual(a.get(data, "MACs"), f_macs)
self.assertEqual(a.get(data, "ARR2"), f_arr2)
self.assertEqual(a.get(data, "TIMEs"), f_times)
f_arr2 = []
a.ARR2 = f_arr2
self.assertEqual(a.get(data, "ARR2"), f_arr2)
f_arr1 = -42
a.ARR1 = f_arr1
self.assertEqual(a.get(data, "ARR1"), [f_arr1])
import pytrap
a = pytrap.UnirecTime(1467376043, 666)
dt = a.toDatetime()
print(dt)
print(dt.strftime('%Y-%m-%dT%H:%M:%SZ'))
import pdb
pdb.set_trace()
