def _serializeJsonToModel(self, object, json):
# runs if emergency is on
if isinstance(json, EmergencyPost):
object.settype(
RestEnumerations.emergencyTypes[json.getemergencyType()])
object.detail.contact.setcallsign(json.getname())
object.detail.emergency.settype(json.getemergencyType())
if json.getaddress():
locator = Nominatim(user_agent="myGeocoder")
location = locator.geocode(json.getaddress())
object.point.setlon(location.longitude)
object.point.setlat(location.latitude)
else:
object.point.setlon(json.getlongitude())
object.point.setlat(json.getlatitude())
DatabaseController().create_ActiveEmergency(object)
return object
# runs if emergency is off
elif isinstance(json, EmergencyDelete):
object.setuid(json.getuid())
DatabaseController().remove_ActiveEmergency(
query=f'uid == "{object.uid}"')
object.settype('b-a-o-can')
object.detail.emergency.setcancel('true')
return object
def start(self, IP, CoTPort, Event, clientDataPipe,
ReceiveConnectionKillSwitch, RestAPIPipe):
try:
self.dbController = DatabaseController()
# self.clear_user_table()
os.chdir('../../../')
# create socket controller
self.TCPSocketController = TCPSocketController()
self.TCPSocketController.changeIP(IP)
self.TCPSocketController.changePort(CoTPort)
sock = self.TCPSocketController.createSocket()
pool = ThreadPool(processes=2)
self.pool = pool
clientData = pool.apply_async(ClientReceptionHandler().startup,
(self.clientInformationQueue, ))
receiveConnection = pool.apply_async(ReceiveConnections().listen,
(sock, ))
# instantiate domain model and save process as object
self.mainRunFunction(clientData, receiveConnection, sock, pool,
Event, clientDataPipe,
ReceiveConnectionKillSwitch, RestAPIPipe)
except Exception as e:
logger.error('there has been an exception in the start function '
'of TCPCoTService ' + str(e))
return e
def start(self, pipe, ip, port):
self.db = DatabaseController()
self.pipe = pipe
self._create_context()
self._create_listener(ip, port)
print('started federation server service')
self.main()
def getAllPackages(self):
data = DatabaseController().query_datapackage("Privacy == 0")
package_dict = {"resultCount": len(data), "results": []}
for i in data:
package_dict["results"].append({
"UID":
i.uid,
"Name":
i.Name,
"Hash":
i.Hash,
"PrimaryKey":
i.PrimaryKey,
"SubmissionDateTime":
str(i.SubmissionDateTime.strftime("%Y-%m-%dT%H:%M:%S.%fZ")),
"SubmissionUser":
i.SubmissionUser,
"CreatorUid":
i.CreatorUid,
"Keywords":
i.Keywords,
"MIMEType":
i.MIMEType,
"Size":
i.Size
})
return package_dict
def __init__(self, RawCoT):
if RawCoT.status == 'on':
tempObject = super().Event.emergecyOn()
object = SendEmergency()
object.status = 'on'
self.fill_object(object, tempObject, RawCoT, addToDB=False)
obj = self.getObject()
DatabaseController().create_ActiveEmergency(obj.modelObject)
elif RawCoT.status == 'off':
tempObject = super().Event.emergecyOff()
object = SendEmergency()
object.status = 'off'
self.fill_object(object, tempObject, RawCoT, addToDB=False)
obj = self.getObject()
DatabaseController().remove_ActiveEmergency(
query=f'uid = "{obj.modelObject.uid}"')
def __init__(self, json):
tempObject = event.SimpleCoT()
object = SendSimpleCoT()
object.setModelObject(tempObject)
object.modelObject = self._serializeJsonToModel(object.modelObject, json)
DatabaseController().create_CoT(object.modelObject)
object.setXmlString(XMLCoTController().serialize_model_to_CoT(object.modelObject))
self.setCoTObject(object)
def __init__(self, json):
tempObject = event.SimpleCoT()
object = SendSimpleCoT()
object.setModelObject(tempObject)
object.modelObject = self._serializeJsonToModel(object.modelObject, json)
DatabaseController().create_CoT(object.modelObject)
object.setXmlString(etree.tostring(XmlSerializer().from_fts_object_to_format(object.modelObject)))
self.setCoTObject(object)
def ExCheckTemplates():
try:
# when no data available
# return b'{"version":"2","type":"Mission","data":[{"name":"exchecktemplates","description":"","chatRoom":"","tool":"ExCheck","keywords":[],"creatorUid":"ExCheck","createTime":"2020-10-19T22:37:39.290Z","externalData":[],"uids":[],"contents":[]}],"nodeId":"TAK-Server-560c34e9"}'
# when data available
return templateSerializer().convert_object_to_json(
DatabaseController().query_ExCheck())
except Exception as e:
print(e)
def testing(self):
"""
function which creates variables for testing
"""
from multiprocessing import Pipe
from FreeTAKServer.controllers.DatabaseControllers.DatabaseController import DatabaseController
self.dbController = DatabaseController()
self.CoTSharePipe, other = Pipe()
return None
def systemUsers(empty=None):
systemUserArray = DatabaseController().query_systemUser()
jsondata = {"SystemUsers": []}
for user in systemUserArray:
userjson = {}
userjson['Name'] = user.name
userjson["Group"] = user.group
userjson["Token"] = user.token
userjson["Password"] = user.password
userjson["Certs"] = user.certificate_package_name
userjson["Uid"] = user.uid
jsondata["SystemUsers"].append(userjson)
emit('systemUsersUpdate', json.dumps(jsondata))
def __init__(self):
self.CoTService = None
self.TCPDataPackageService = None
self.UserCommand = None
self.killSwitch = False
self.ReceiveConnectionsReset = None
self.CoTPoisonPill = None
self.ClientDataPipe = None
self.SSLClientDataPipe = None
self.clientArray = []
self.socketCount = 0
self.pipeList = {}
self.FilterGroup = FilterGroup()
self.FTSServiceStartupConfigObject = FTSObj()
self.dbController = DatabaseController()
logger.propagate = True
logger.info('something')
def start(self, IP, CoTPort, Event, clientDataPipe, ReceiveConnectionKillSwitch, RestAPIPipe):
try:
self.dbController = DatabaseController()
print('ssl cot service starting')
os.chdir('../../')
# create socket controller
self.SSLSocketController = SSLSocketController()
self.SSLSocketController.changeIP(IP)
self.SSLSocketController.changePort(CoTPort)
sock = self.SSLSocketController.createSocket()
#threadpool is used as it allows the transfer of SSL socket unlike processes
pool = ThreadPool(processes=2)
self.pool = pool
clientData = pool.apply_async(ClientReceptionHandler().startup, (self.clientInformationQueue,))
receiveConnection = pool.apply_async(ReceiveConnections().listen, (sock,))
# instantiate domain model and save process as object
self.mainRunFunction(clientData, receiveConnection, sock, pool, Event, clientDataPipe,
ReceiveConnectionKillSwitch, RestAPIPipe, True)
except Exception as e:
logger.error("there has been an exception thrown in"
" the starting of the ssl service " + str(e))
return e
def addSystemUser(jsondata):
from FreeTAKServer.controllers import certificate_generation
import uuid
for systemuser in json.loads(jsondata)['systemUsers']:
if systemuser["Certs"] == "true":
# create certs
certificate_generation.AtakOfTheCerts().bake(cn=systemuser["Name"])
certificate_generation.generate_zip(
user_filename=systemuser["Name"] + '.p12')
# add DP
import string
import random
from pathlib import PurePath, Path
import hashlib
from lxml import etree
import shutil
import os
dp_directory = str(PurePath(Path(MainConfig.DataPackageFilePath)))
letters = string.ascii_letters
openfile = open(str(
PurePath(
Path(str(MainConfig.clientPackages),
systemuser["Name"] + '.zip'))),
mode='rb')
file_hash = str(hashlib.sha256(openfile.read()).hexdigest())
openfile.close()
newDirectory = str(PurePath(Path(dp_directory), Path(file_hash)))
os.mkdir(newDirectory)
shutil.copy(
str(
PurePath(
Path(str(MainConfig.clientPackages),
systemuser["Name"] + '.zip'))),
str(
PurePath(Path(newDirectory),
Path(systemuser["Name"] + '.zip'))))
fileSize = Path(str(newDirectory),
systemuser["Name"] + '.zip').stat().st_size
dbController.create_datapackage(uid=str(uuid.uuid4()),
Name=systemuser["Name"] + '.zip',
Hash=file_hash,
SubmissionUser='******',
CreatorUid='server-uid',
Size=fileSize,
Privacy=1)
DatabaseController().create_systemUser(
name=systemuser["Name"],
group=systemuser["Group"],
token=systemuser["Token"],
password=systemuser["Password"],
uid=str(uuid.uuid4()),
certificate_package_name=systemuser["Name"] + '.zip')
import datetime as dt
DATETIME_FMT = "%Y-%m-%dT%H:%M:%S.%fZ"
timer = dt.datetime
now = timer.utcnow()
zulu = now.strftime(DATETIME_FMT)
add = dt.timedelta(seconds=600)
stale_part = dt.datetime.strptime(zulu, DATETIME_FMT) + add
stale = stale_part.strftime(DATETIME_FMT)
timer = dt.datetime
now = timer.utcnow()
zulu = now.strftime(DATETIME_FMT)
time = zulu
from FreeTAKServer.controllers.SpecificCoTControllers.SendOtherController import SendOtherController
from FreeTAKServer.model.RawCoT import RawCoT
cot = RawCoT()
clientXML = f'<?xml version="1.0"?><event version="2.0" uid="{str(uuid.uuid4())}" type="b-f-t-r" time="{time}" start="{time}" stale="{stale}" how="h-e"><point lat="43.85570300" lon="-66.10801200" hae="19.55866360" ce="3.21600008" le="nan" /><detail><fileshare filename="{systemuser["Name"]}" senderUrl="{MainConfig.DataPackageServiceDefaultIP}:8080/Marti/api/sync/metadata/{str(file_hash)}/tool" sizeInBytes="{fileSize}" sha256="{str(file_hash)}" senderUid="{"server-uid"}" senderCallsign="{"server"}" name="{systemuser["Name"]+".zip"}" /><ackrequest uid="{uuid.uuid4()}" ackrequested="true" tag="{systemuser["Name"]+".zip"}" /><marti><dest callsign="{systemuser["Name"]}" /></marti></detail></event>'
cot.xmlString = clientXML.encode()
newCoT = SendOtherController(cot)
APIPipe.send(newCoT.getObject())
else:
DatabaseController().create_systemUser(
name=systemuser["Name"],
group=systemuser["Group"],
token=systemuser["Token"],
password=systemuser["Password"],
uid=str(uuid.uuid4()))
def start(self, pipe):
self.db = DatabaseController()
self.pipe = pipe
self._create_context()
print('started federation federate service')
self.main()
from flask_socketio import SocketIO, emit
from flask_cors import CORS
import json
from FreeTAKServer.controllers.DatabaseControllers.DatabaseController import DatabaseController
from FreeTAKServer.controllers.configuration.MainConfig import MainConfig
from FreeTAKServer.controllers.configuration.RestAPIVariables import RestAPIVariables as vars
functionNames = vars()
functionNames.function_names()
app = Flask(__name__)
CORS(app)
socketio = SocketIO(app, async_handlers=True, async_mode="eventlet")
socketio.init_app(app, cors_allowed_origins="*")
dbController = DatabaseController()
def startup(self, APIPipea, CommandPipea, IP, Port, starttime):
global APIPipe, CommandPipe, StartTime
StartTime = starttime
APIPipe = APIPipea
CommandPipe = CommandPipea
socketio.run(app, host=IP, port=Port)
def socket_auth(session=None):
def innerfunc(x):
def wrapper(*args, **kwargs):
if hasattr(session, 'authenticated') and session.authenticated:
x(*args, **kwargs)
def create_DB_object(self, templateObject):
self.DataBase = DatabaseController()
output = self.DataBase.create_ExCheck(templateObject)
self.DataBase.shutdown_Connection()
return output
pass
for relationship in SqlAlchemyObject.__mapper__.relationships:
try:
y = str(relationship)
relationship = '.'.join(str(relationship).split('.', 1)[1::])
relationshipObject = getattr(SqlAlchemyObject, relationship)
if relationshipObject != None:
modelObjectInstance = getattr(modelObject, relationship)
setter = getattr(modelObject, 'set' + relationship)
setter(
self.convert_sqlalchemy_to_modelobject(
relationshipObject, modelObjectInstance))
else:
pass
except Exception as e:
print(str(e))
return modelObject
if __name__ == "__main__":
from FreeTAKServer.controllers.DatabaseControllers.DatabaseController import DatabaseController
contr = DatabaseController().query_ActiveEmergency()
x = contr[0]
from FreeTAKServer.model.FTSModel.Event import Event
modelobj = Event.emergecyOn()
y = SqlAlchemyObjectController().convert_sqlalchemy_to_modelobject(
x.event, modelobj)
1 == 1
def excheck_table():
try:
from os import listdir
from pathlib import PurePath, Path
from datetime import datetime
from flask import request
if request.method == "GET":
jsondata = {"ExCheck": {'Templates': [], 'Checklists': []}}
from FreeTAKServer.controllers.ExCheckControllers.templateToJsonSerializer import templateSerializer
excheckTemplates = DatabaseController().query_ExCheck()
for template in excheckTemplates:
templateData = template.data
templatejson = {
"filename":
templateData.filename,
"name":
templateData.keywords.name,
"submissionTime":
templateData.submissionTime,
"submitter":
str(
dbController.query_user(
query=f'uid == "{template.creatorUid}"',
column=['callsign'])),
"uid":
templateData.uid,
"hash":
templateData.hash,
"size":
templateData.size,
"description":
templateData.keywords.description
}
jsondata["ExCheck"]['Templates'].append(templatejson)
excheckChecklists = DatabaseController().query_ExCheckChecklist()
for checklist in excheckChecklists:
try:
templatename = checklist.template.data.name
except AttributeError:
templatename = "template removed"
checklistjson = {
"filename":
checklist.filename,
"name":
checklist.name,
"startTime":
datetime.strftime(checklist.startTime,
"%Y-%m-%dT%H:%M:%S.%fZ"),
"submitter":
checklist.callsign,
"uid":
checklist.uid,
"description":
checklist.description,
"template":
templatename
}
jsondata["ExCheck"]['Checklists'].append(checklistjson)
return json.dumps(jsondata), 200
elif request.method == "DELETE":
jsondata = request.data
ExCheckArray = json.loads(jsondata)["ExCheck"]
for item in ExCheckArray["Templates"]:
templateitem = DatabaseController().query_ExCheck(
f'ExCheckData.uid == "{item["uid"]}"', verbose=True)[0]
os.remove(
str(
PurePath(Path(MainConfig.ExCheckFilePath),
Path(templateitem.data.filename))))
DatabaseController().remove_ExCheck(
f'PrimaryKey == "{templateitem.PrimaryKey}"')
for item in ExCheckArray["Checklists"]:
checklistitem = DatabaseController().query_ExCheckChecklist(
f'uid == "{item["uid"]}"')[0]
os.remove(
str(
PurePath(Path(MainConfig.ExCheckChecklistFilePath),
Path(checklistitem.filename))))
DatabaseController().remove_ExCheckChecklist(
f'uid == "{item["uid"]}"')
return 'success', 200
elif request.method == "POST":
try:
import uuid
from FreeTAKServer.controllers.ExCheckControllers.templateToJsonSerializer import templateSerializer
xmlstring = f'<?xml version="1.0"?><event version="2.0" uid="{uuid.uuid4()}" type="t-x-m-c" time="2020-11-28T17:45:51.000Z" start="2020-11-28T17:45:51.000Z" stale="2020-11-28T17:46:11.000Z" how="h-g-i-g-o"><point lat="0.00000000" lon="0.00000000" hae="0.00000000" ce="9999999" le="9999999" /><detail><mission type="CHANGE" tool="ExCheck" name="exchecktemplates" authorUid="S-1-5-21-2720623347-3037847324-4167270909-1002"><MissionChanges><MissionChange><contentResource><filename>61b01475-ad44-4300-addc-a9474ebf67b0.xml</filename><hash>018cd5786bd6c2e603beef30d6a59987b72944a60de9e11562297c35ebdb7fd6</hash><keywords>test init</keywords><keywords>dessc init</keywords><keywords>FEATHER</keywords><mimeType>application/xml</mimeType><name>61b01475-ad44-4300-addc-a9474ebf67b0</name><size>1522</size><submissionTime>2020-11-28T17:45:47.980Z</submissionTime><submitter>wintak</submitter><tool>ExCheck</tool><uid>61b01475-ad44-4300-addc-a9474ebf67b0</uid></contentResource><creatorUid>S-1-5-21-2720623347-3037847324-4167270909-1002</creatorUid><missionName>exchecktemplates</missionName><timestamp>2020-11-28T17:45:47.983Z</timestamp><type>ADD_CONTENT</type></MissionChange></MissionChanges></mission></detail></event>'
# this is where the client will post the xmi of a template
from datetime import datetime
from lxml import etree
import hashlib
# possibly the uid of the client submitting the template
authoruid = request.args.get('clientUid')
if not authoruid:
authoruid = 'server-uid'
XMI = request.data.decode()
serializer = templateSerializer(XMI)
object = serializer.convert_template_to_object()
object.timestamp = datetime.strptime(object.timestamp,
"%Y-%m-%dT%H:%M:%S.%fZ")
serializer.create_DB_object(object)
xml = etree.fromstring(XMI)
path = str(
PurePath(Path(MainConfig.ExCheckFilePath),
Path(f'{object.data.uid}.xml')))
with open(path, 'w+') as file:
file.write(XMI)
file.close()
uid = object.data.uid
temp = etree.fromstring(XMI)
cot = etree.fromstring(xmlstring)
cot.find('detail').find('mission').set("authorUid", authoruid)
resources = cot.find('detail').find('mission').find(
'MissionChanges').find('MissionChange').find(
'contentResource')
resources.find('filename').text = temp.find(
'checklistDetails').find('uid').text + '.xml'
resources.findall('keywords')[0].text = temp.find(
'checklistDetails').find('name').text
resources.findall('keywords')[1].text = temp.find(
'checklistDetails').find('description').text
resources.findall('keywords')[2].text = temp.find(
'checklistDetails').find('creatorCallsign').text
resources.find('uid').text = temp.find(
'checklistDetails').find('uid').text
resources.find('name').text = temp.find(
'checklistDetails').find('uid').text
resources.find('size').text = str(len(XMI))
resources.find('hash').text = str(
hashlib.sha256(str(XMI).encode()).hexdigest())
z = etree.tostring(cot)
from FreeTAKServer.model.testobj import testobj
object = testobj()
object.xmlString = z
APIPipe.send(object)
return str(uid), 200
except Exception as e:
print(str(e))
except Exception as e:
return str(e), 500