class MorseParity:
def __init__(self):
self.morse = Morse()
def encode(self,value):
value = self.morse.encode(value)
if self.even_dots(value):
value = value + "-"
else:
value = value + "."
return value
def decode(self,value):
if not self.even_dots(value):
return "?"
value = value[:-1]
return self.morse.decode(value)
def even_dots(self, value):
count = 0
for currentChar in value:
if currentChar == '.':
count = count + 1
if count % 2 == 0:
return True
else:
return False
def test_invalid_message(self):
test_patterns = [('%test', '*%* - . ... -'), ('i%u', '.. *%* ..-')]
morse = Morse()
signals = ['-', '.', ' ', '\n']
for message, expect in test_patterns:
with self.subTest(message=message, expect=expect):
endoded = morse.enc(message)
self.assertEqual(endoded, expect)
def test_invalid_morse(self):
test_patterns = [
('._..', '*._..*'),
('', '**'),
('_.. -.-', '*_..*K'),
]
morse = Morse()
signals = ['-', '.', ' ', '\n']
for mor, expect in test_patterns:
with self.subTest(mor=mor, expect=expect):
decoded = morse.dec(mor)
self.assertEqual(decoded, expect)
def getFileNode(self, morse: Morse) -> FileNode:
if self.type != -1:
return None
try:
if self.subtype == -1:
if (len(self.params) != 1):
return None
res = CommonFile(self.Id, self.time, self.type, self.subtype,
self.params[0], morse.get_itag_benign(),
morse.get_ctag_benign())
return res
elif self.subtype == 1:
#shared memory
# if (len(self.params) != 1):
# return None
# res = CommonFile(self.Id, self.time, self.type, self.subtype, self.params[0])
# return res
pass
elif self.subtype == 2:
if (len(self.params) != 1):
return None
res = UnixSocketFile(self.Id, self.time, self.type,
self.subtype, self.params[0], morse)
return res
elif self.subtype == 3:
if (len(self.params) != 3):
return None
res = InetSocketFile(self.Id, self.time, self.type,
self.subtype, self.params[0],
self.params[1], self.params[2], morse)
return res
elif self.subtype == 4:
if (len(self.params) != 2):
return None
res = PipFile(self.Id, self.time, self.type, self.subtype,
self.params[0], self.params[1],
morse.get_itag_benign(), morse.get_ctag_benign())
return res
else:
print("unexpected filenode subtype", self.subtype)
except Exception as err:
logger.error("get file node failed")
msg = str(self.Id) + " " + str(self.time) + " " + str(
self.type) + " " + str(self.subtype) + " " + str(self.params)
logger.error(msg)
traceback.print_exc()
# print("get file node failed")
return None
def setUpClass(self):
""" this sets up a class through each of the initiation methods, making
sure they all work """
self.morse_test1 = Morse(morse='... --- ... / .----')
self.morse_test2 = Morse(words='You... never did! - The Kenosha Kid')
self.morse_test3 = Morse()
self.morse_test3.read(words='cam was here')
self.morse_test4 = Morse()
self.morse_test4.read(morse='-.-. .- -- / -. ..- --. . -. -')
self.morse_test5 = Morse()
self.morse_test5.read(morse='... --- ...')
def test_normal(self):
test_patterns = [
('test', '- . ... -'),
('hello, world!',
'.... . .-.. .-.. --- --..-- \n.-- --- .-. .-.. -.. -.-.--'),
('This is Letter A.',
'- .... .. ... \n.. ... \n.-.. . - - . .-. \n.- .-.-.-')
]
morse = Morse()
for message, expect in test_patterns:
with self.subTest(message=message, expect=expect):
endoded = morse.enc(message)
self.assertEqual(endoded, expect)
decoded = morse.dec(endoded)
self.assertEqual(decoded, message.upper())
def __init__(self, id: int, time: int, type: int, subtype: int,
inetSocketFd: str, ip: str, port: int, morse: Morse):
super(InetSocketFile, self).__init__(id, time, type, subtype)
self.inetSocketFd = inetSocketFd
self.ip = ip
self.port = port
# for localhost connection or local network connection, we set them as benign
self.iTag = morse.get_itag_susp_env()
self.cTag = morse.get_itag_susp_env()
for pattern in trusted_ip_pattern:
if re.search(self.ip, pattern):
self.iTag = morse.get_itag_benign()
self.cTag = morse.get_ctag_benign()
break
def __init__(self, id: int, time: int, type: int, subtype: int, pid: int, ppid: int, cmdLine: str,
processName: str, morse: Morse = None):
self.id = id
self.time = time
self.type = type
self.subtype = subtype
self.pid = pid
self.ppid = ppid
self.cmdLine = cmdLine
self.processName = processName
self.event_list = []
self.event_id_list = []
self.event_type_list = []
self.state_list = []
self.morse_grad_list = []
self.simple_net_grad_list = []
# grad list stores grad of morse
self.cur_state = np.zeros([2, 3])
self.seq_len = 0
# init tags
self.sTag: float = 0.0
# benign
self.iTag: float = 0.0
#
self.cTag: float = 0.0
if self.ppid == -1:
# unknown parent
self.sTag = morse.get_stag_dangerous()
elif self.ppid == 0:
# process generated by root
self.sTag = morse.get_stag_benign()
else:
from globals import GlobalVariable as gv
parent_id = gv.get_processNode_by_pid(self.ppid)
parent_node = gv.get_processNode(parent_id)
if not parent_node:
# parent node not exist or has been released, then this node is not valid
self.sTag = morse.get_stag_dangerous()
self.iTa = morse.get_itag_dangerous()
self.cTag = morse.get_ctag_dangerous()
else:
self.sTag = parent_node.sTag
self.iTag = parent_node.iTag
self.cTag = parent_node.cTag
def say_morse(self, text: str):
"""
Play the provided morse code text string via the audio player.
"""
from morse import Morse
m = Morse(morse=text)
self.enable_tx()
try:
# TODO: Play callsign in morse
LOG.trace('Playing morse code "%s"' % (m.morse))
m.transmit()
finally:
self.disable_tx()
def say_text_morse(self, text: str):
"""
Convert the provided text string to a morse code and play it via the audio player.
"""
from morse import Morse
m = Morse(words=text)
self.enable_tx()
try:
# TODO: Play callsign in morse
LOG.trace('Playing text "%s" as morse code (%s)' % (text, m.morse))
m.transmit()
finally:
self.disable_tx()
def convert(iFile, oFile, mode):
try:
with open(iFile) as i, open(oFile, 'w') as o:
for line in i:
line = line.strip()
if mode == 'decode':
m = Morse(line).decode()
elif mode == 'encode':
m = Morse(line).encode()
else:
print('Unknown mode. Exiting')
sys.exit()
o.write('{}\n'.format(m))
except TypeError:
print("Could not open files")
parser.print_help()
def encode_text_to_morse_wave(text, filename):
encoded_text = Morse().encode(text)
encoded_exact_text = Morse('=', '===').encode_exact(text)
print '"%s" in Morse code:' % text
print encoded_text
sample_rate = 8000 # 8000 Hz
frequency = 600 # 600 Hz
dot_dur = 0.050 # 50 ms
volume = 0.8 # 80%
wave = WaveFile(sample_rate)
wave_duration = 0
wave_data = []
for c in encoded_exact_text:
wave_duration += dot_dur
if c != ' ':
wave_data += generate_sin_wave(sample_rate, frequency, dot_dur,
volume)
else:
wave_data += generate_sin_wave(sample_rate, frequency, dot_dur, 0)
wave.add_data_subchunk(wave_duration, wave_data)
wave.save(filename)
def file2process_parser(self,
record: Record,
morse: Morse = None) -> np.ndarray((4, 4)):
id = record.Id
time = record.time
subtype = record.subtype
srcNode: FileNode
destNode: ProcessNode
if not gv.exist_fileNode(record.srcId):
if record.srcId == -1:
return None
logger.error("file to process, can't find srcNode " +
str(record.srcId))
return None
else:
srcNode = gv.get_fileNode(record.srcId)
if not gv.exist_processNode(record.desId):
logger.error("file to process, can't find desNode " +
str(record.desId))
return None
else:
destNode = gv.get_processNode(record.desId)
if not srcNode or not destNode:
logger.error("file to process, can't find srcNode or destNode " +
' ' + str(record.srcId) + ' ' + str(record.desId))
return None
eventArray = [id, time, subtype, 0]
srcArray = srcNode.get_matrix_array(4)
desArray = destNode.get_matrix_array(4)
p1 = morse.get_attenuate_benign()
if not isinstance(p1, float):
p1 = p1.cpu().detach().numpy()
p2 = morse.get_attenuate_susp_env()
if not isinstance(p2, float):
p2 = p2.cpu().detach().numpy()
params = [
p1, p2,
morse.get_benign_possibility(srcArray[1]).cpu().detach().numpy(),
morse.get_susp_possibility(srcArray[1]).cpu().detach().numpy()
]
benign_grad = morse.get_benign_thresh_grad()
susp_grad = morse.get_susp_thresh_grad()
gv.add_morse_grad(id, np.concatenate([benign_grad, susp_grad]))
# print("params: ", params[2].detach().numpy())
return np.array([eventArray, params, srcArray, desArray])
def main():
drv = Adafruit_DRV2605(busnum=1)
drv.begin()
drv.setMode(DRV2605_MODE_INTTRIG)
drv.selectLibrary(1)
morse_player = Morse(drv)
morse_player.play_string("vk1atp")
while (1):
sequence = generateSequence(64)
for item in sequence:
print item
morse_player.play_letter(item)
time.sleep(0.5)
def file2file_parser(self, record: Record,
morse: Morse) -> np.ndarray((4, 4)):
id = record.Id
time = record.time
subtype = record.subtype
srcNode: FileNode = None
destNode: FileNode = None
if not gv.exist_fileNode(record.srcId):
logger.error("file to file, can't find srcNode" + ' ' +
str(record.srcId))
return None
else:
srcNode = gv.get_fileNode(record.srcId)
if not gv.exist_fileNode(record.desId):
logger.error("file to file, can't find desNode" + ' ' +
str(record.desId))
return None
else:
destNode = gv.get_fileNode(record.desId)
if not srcNode or not destNode:
logger.error("file to file, can't find desNode or destNode" + ' ' +
str(record.srcId) + ' ' + str(record.desId))
return None
eventArray = [id, time, subtype, 0]
srcArray = srcNode.get_matrix_array(4)
desArray = destNode.get_matrix_array(4)
params = [
morse.get_attenuate_benign(),
morse.get_attenuate_susp_env(),
morse.get_benign_possibility(srcArray[1]),
morse.get_susp_possibility(srcArray[1])
] + [0] * (4 - len(record.params))
benign_grad = morse.get_benign_thresh_grad()
susp_grad = morse.get_susp_thresh_grad()
gv.add_morse_grad(id, np.concatenate([benign_grad, susp_grad]))
return np.array([eventArray, params, srcArray, desArray])
def test_v(self):
self.assertEqual(Morse().decode("...-"), "V")
def test_u(self):
self.assertEqual(Morse().decode("..-"), "U")
def test_t(self):
self.assertEqual(Morse().decode("-"), "T")
def test_r(self):
self.assertEqual(Morse().decode(".-."), "R")
def test_empty_message(self):
self.assertEqual(Morse().decode(""), "")
class SanityCheck(unittest.TestCase):
def setUp(self):
self.morse = Morse()
def testEncodeA(self):
self.assertEqual(".-", self.morse.encode("a"))
def testEncodeB(self):
self.assertEqual("-...", self.morse.encode("b"))
def testEncodeC(self):
self.assertEqual("-.-.", self.morse.encode("c"))
def testEncodeD(self):
self.assertEqual("-..", self.morse.encode("d"))
def testEncodeE(self):
self.assertEqual(".", self.morse.encode("e"))
def testEncodeF(self):
self.assertEqual("..-.", self.morse.encode("f"))
def testEncodeG(self):
self.assertEqual("--.", self.morse.encode("g"))
def testEncodeH(self):
self.assertEqual("....", self.morse.encode("h"))
def testEncodeI(self):
self.assertEqual("..", self.morse.encode("i"))
def testEncodeJ(self):
self.assertEqual(".---", self.morse.encode("j"))
def testEncodeK(self):
self.assertEqual("-.-", self.morse.encode("k"))
def testEncodeL(self):
self.assertEqual(".-..", self.morse.encode("l"))
def testEncodeM(self):
self.assertEqual("--", self.morse.encode("m"))
def testEncodeN(self):
self.assertEqual("-.", self.morse.encode("n"))
def testEncodeO(self):
self.assertEqual("---", self.morse.encode("o"))
def testEncodeP(self):
self.assertEqual(".--.", self.morse.encode("p"))
def testEncodeQ(self):
self.assertEqual("--.-", self.morse.encode("q"))
def testEncodeR(self):
self.assertEqual(".-.", self.morse.encode("r"))
def testEncodeS(self):
self.assertEqual("...", self.morse.encode("s"))
def testEncodeT(self):
self.assertEqual("-", self.morse.encode("t"))
def testEncodeU(self):
self.assertEqual("..-", self.morse.encode("u"))
def testEncodeV(self):
self.assertEqual("...-", self.morse.encode("v"))
def testEncodeW(self):
self.assertEqual(".--", self.morse.encode("w"))
def testEncodeX(self):
self.assertEqual("-..-", self.morse.encode("x"))
def testEncodeY(self):
self.assertEqual("-.--", self.morse.encode("y"))
def testEncodeZ(self):
self.assertEqual("--..", self.morse.encode("z"))
def testDecode(self):
for c in ascii_lowercase:
self.assertEqual(c, self.morse.decode(self.morse.encode(c)))
def testUppercase(self):
for c in ascii_lowercase:
self.assertEqual(c, self.morse.decode(self.morse.encode(c.upper())))
def test_y(self):
self.assertEqual(Morse().decode("-.--"), "Y")
def test_o(self):
self.assertEqual(Morse().decode("---"), "O")
def __init__(self):
self.morse = Morse()
# Morse Code Translator
# Python
# Copyright (C) 2013 Ng Tzy Luen. All Rights Reserved.
#
# Notes:
# Tested under Python 2.7.3
import sys, os
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from morse import Morse
#from collections import OrderedDict
import fileinput
for line in fileinput.input():
s = list(line)
morse_code_line = ""
for c in s[:-1]:
morse_code = Morse.get_morse(c)
morse_code_line += morse_code + " "
morse_code = Morse.get_morse(s[-1])
morse_code_line += morse_code
sys.stdout.write(morse_code_line)
import re
for words in re.split(" ", morse_code_line):
for morse in re.split(" ", words):
sys.stdout.write(str(Morse.to_letter(morse)))
def test_whole_sentence(self):
message = Morse().decode(
".- .-.. .-.. / -.-- --- ..- / -. . . -.. / .. ... / -.-. --- -.. ."
)
self.assertEqual(message, "ALL YOU NEED IS CODE")
def test_sos(self):
self.assertEqual(Morse().decode("... --- ..."), "SOS")
def test_w(self):
self.assertEqual(Morse().decode(".--"), "W")
def test_p(self):
self.assertEqual(Morse().decode(".--."), "P")
def test_x(self):
self.assertEqual(Morse().decode("-..-"), "X")
def test_q(self):
self.assertEqual(Morse().decode("--.-"), "Q")
def test_z(self):
self.assertEqual(Morse().decode("--.."), "Z")
def setUp(self):
self.morse = Morse()
def test_a(self):
self.assertEqual(Morse().decode(".-"), "A")
def test_encode(self):
self.failUnless(Morse.encode_morse(self.plaintext) == self.cipher_text)
# here is some example code!
from morse import Morse, DotDash #assuming you are working in the same directory as the morse.py file (or it is on the search path)
test = 'sos, we are going down!'
test
morse_test = Morse()
morse_test.words #this throws a value error, no message yet
morse_test.read(words=test) # read in the string test
morse_test.words #show the words
morse_test.morse #show the morse code
print(morse_test) #show the pretty print version of the message
morse_test.transmit() #play message in morse code
morse_test.speak() #say the message
test2 = '... --- ... / .----'
morse_test2 = Morse(morse=test2) #read in to start
morse_test2.morse
morse_test2.words
morse_test2.transmit()
print(morse_test2)
test3 = 'not cam'
morse_test3 = Morse(
words=test3, morse='... --- ...') #ValueError - can only do one at a time!
morse_test3 = Morse()
morse_test3.read(words='cam') #the read method
morse_test3.words = 'dave' #this throws an attribute error so you don't overwrite your message unless you really want to!
morse_test3.read(words='dave') #change the message
morse_test3.words
morse_test3.morse
print(morse_test3)
def test_decode(self):
self.failUnless(Morse.decode_morse(self.cipher_text) == self.plaintext.replace(" ", "").upper())
