Added service_id, ip_d and port_o to ensure traceability accross components (b0fc762c) · Commits · TFS / controller

proto/l3_attackmitigator.proto

+12 −9

Original line number	Diff line number	Diff line
		@@ -28,12 +28,15 @@ message L3AttackmitigatorOutput {
		float confidence = 1;
		string timestamp = 2;
		string ip_o = 3;
		string tag_name = 4;
		int32 tag = 5;
		string flow_id = 6;
		string protocol = 7;
		string port_d = 8;
		string ml_id = 9;
		float time_start = 10;
		float time_end = 11;
		string ip_d = 4;
		string tag_name = 5;
		int32 tag = 6;
		string flow_id = 7;
		string protocol = 8;
		string port_o = 9;
		string port_d = 10;
		string ml_id = 11;
		string service_id = 12;
		float time_start = 13;
		float time_end = 14;
		}

proto/l3_centralizedattackdetector.proto

+4 −3

Original line number	Diff line number	Diff line
		@@ -43,9 +43,10 @@ message L3CentralizedattackdetectorMetrics {
		string ip_d = 11;
		string port_d = 12;
		string flow_id = 13;
		string protocol = 14;
		float time_start = 15;
		float time_end = 16;
		string service_id = 14;
		string protocol = 15;
		float time_start = 16;
		float time_end = 17;
		}

		message Empty {

src/l3_attackmitigator/service/l3_attackmitigatorServiceServicerImpl.py

+229 −9

Original line number	Diff line number	Diff line
		@@ -14,41 +14,261 @@

		from __future__ import print_function
		import logging
		from common.proto.l3_attackmitigator_pb2 import (
		EmptyMitigator
		from common.proto.l3_centralizedattackdetector_pb2 import (
		Empty
		)
		from common.proto.l3_attackmitigator_pb2_grpc import (
		L3AttackmitigatorServicer,
		)
		from common.proto.context_pb2 import (
		Service, ServiceId, ServiceConfig, ServiceTypeEnum, ServiceStatusEnum, ServiceStatus, Context, ContextId, Uuid, Timestamp, ConfigRule, ConfigRule_Custom, ConfigActionEnum, Device, DeviceId, DeviceConfig, DeviceOperationalStatusEnum, DeviceDriverEnum, EndPoint, Link, LinkId, EndPoint, EndPointId, Topology, TopologyId
		)
		from common.proto.context_pb2_grpc import (
		ContextServiceStub
		)
		from common.proto.service_pb2_grpc import (
		ServiceServiceStub
		)
		from datetime import datetime
		import grpc

		LOGGER = logging.getLogger(__name__)
		CONTEXT_CHANNEL = "192.168.165.78:1010"
		SERVICE_CHANNEL = "192.168.165.78:3030"

		class l3_attackmitigatorServiceServicerImpl(L3AttackmitigatorServicer):

		def GetNewService(self, service_id):
		service = Service()
		service_id_obj = self.GenerateServiceId(service_id)
		"""
		ServiceId()
		context_id = ContextId()
		uuid = Uuid()
		uuid.uuid = service_id
		context_id.context_uuid.CopyFrom(uuid)
		service_id_obj.context_id.CopyFrom(context_id)
		service_id_obj.service_uuid.CopyFrom(uuid)
		"""
		service.service_id.CopyFrom(service_id_obj)
		service.service_type = ServiceTypeEnum.SERVICETYPE_L3NM
		service_status = ServiceStatus()
		service_status.service_status = ServiceStatusEnum.SERVICESTATUS_ACTIVE
		service.service_status.CopyFrom(service_status)
		timestamp = Timestamp()
		timestamp.timestamp = datetime.timestamp(datetime.now())
		service.timestamp.CopyFrom(timestamp)
		return service

		def GetNewContext(self, service_id):
		context = Context()
		context_id = ContextId()
		uuid = Uuid()
		uuid.uuid = service_id
		context_id.context_uuid.CopyFrom(uuid)
		context.context_id.CopyFrom(context_id)
		return context

		def GetNewDevice(self, service_id):
		device = Device()
		device_id = DeviceId()
		uuid = Uuid()
		uuid.uuid = service_id
		device_id.device_uuid.CopyFrom(uuid)
		device.device_type="test"
		device.device_id.CopyFrom(device_id)
		device.device_operational_status = DeviceOperationalStatusEnum.DEVICEOPERATIONALSTATUS_ENABLED
		return device

		def GetNewLink(self, service_id):
		link = Link()
		link_id = LinkId()
		uuid = Uuid()
		uuid.uuid = service_id
		link_id.link_uuid.CopyFrom(uuid)
		link.link_id.CopyFrom(link_id)
		return link

		def GetNewTopology(self,context_id, device_id, link_id):
		topology = Topology()
		topology_id = TopologyId()
		topology_id.context_id.CopyFrom(context_id)
		uuid = Uuid()
		uuid.uuid = "test_crypto"
		topology_id.topology_uuid.CopyFrom(uuid)
		topology.topology_id.CopyFrom(topology_id)
		topology.device_ids.extend([device_id])
		topology.link_ids.extend([link_id])
		return topology

		def GetNewEndpoint(self, topology_id, device_id, uuid_name):
		endpoint = EndPoint()
		endpoint_id = EndPointId()
		endpoint_id.topology_id.CopyFrom(topology_id)
		endpoint_id.device_id.CopyFrom(device_id)
		uuid = Uuid()
		uuid.uuid = uuid_name
		endpoint_id.endpoint_uuid.CopyFrom(uuid)
		endpoint.endpoint_id.CopyFrom(endpoint_id)
		endpoint.endpoint_type = "test"
		return endpoint


		def __init__(self):
		LOGGER.debug("Creating Servicer...")
		self.last_value = -1
		self.last_tag = 0

		context = self.GetNewContext("test_crypto")
		print(context, flush=True)
		print(self.SetContext(context))

		service = self.GetNewService("test_crypto")
		print("This is the new service", self.CreateService(service), flush = True)

		ip_o = "127.0.0.1"
		ip_d = "127.0.0.2"
		port_o = "123"
		port_d = "124"

		service_id = self.GenerateServiceId("test_crypto")

		config_rule = self.GetConfigRule(ip_o, ip_d, port_o, port_d)

		service = self.GetService(service_id)
		print("Service obtained from id", service, flush=True)

		config_rule = self.GetConfigRule(ip_o, ip_d, port_o, port_d)

		#service_config = service.service_config
		#service_config.append(config_rule)

		service_config = ServiceConfig()
		service_config.config_rules.extend([config_rule])
		service.service_config.CopyFrom(service_config)

		device = self.GetNewDevice("test_crypto")
		print("New device", device, flush=True)
		device_id = self.SetDevice(device)

		link = self.GetNewLink("test_crypto")
		print("New link", link, flush=True)
		link_id = self.SetLink(link)

		topology = self.GetNewTopology(context.context_id, device.device_id, link.link_id)
		print("New topology", topology, flush=True)
		topology_id = self.SetTopology(topology)

		endpoint = self.GetNewEndpoint(topology.topology_id, device.device_id, "test_crypto")
		print("New endpoint", endpoint, flush=True)
		link.link_endpoint_ids.extend([endpoint.endpoint_id])

		self.SetLink(link)

		print("Service with new rule", service, flush=True)
		self.UpdateService(service)

		service2 = self.GetService(service_id)
		print("Service obtained from id after updating", service2, flush=True)


		def GenerateRuleValue(self, ip_o, ip_d, port_o, port_d):
		value = {
		'ipv4:source-address': ip_o,
		'ipv4:destination-address': ip_d,
		'transport:source-port': port_o,
		'transport:destination-port': port_d,
		'forwarding-action': 'DROP',
		}
		return value

		def GetConfigRule(self, ip_o, ip_d, port_o, port_d):
		config_rule = ConfigRule()
		config_rule_custom = ConfigRule_Custom()
		config_rule.action = ConfigActionEnum.CONFIGACTION_SET
		config_rule_custom.resource_key = 'test'
		config_rule_custom.resource_value = str(self.GenerateRuleValue(ip_o, ip_d, port_o, port_d))
		config_rule.custom.CopyFrom(config_rule_custom)
		return config_rule

		def GenerateServiceId(self, service_id):
		service_id_obj = ServiceId()
		context_id = ContextId()
		uuid = Uuid()
		uuid.uuid = service_id
		context_id.context_uuid.CopyFrom(uuid)
		service_id_obj.context_id.CopyFrom(context_id)
		service_id_obj.service_uuid.CopyFrom(uuid)
		return service_id_obj

		def SendOutput(self, request, context):
		# SEND CONFIDENCE TO MITIGATION SERVER
		logging.debug("")
		print("Server received mitigation values...", request.confidence)
		print("Server received mitigation values...", request.confidence, flush=True)

		last_value = request.confidence
		last_tag = request.tag

		ip_o = request.ip_o
		ip_d = request.ip_d
		port_o = request.port_o
		port_d = request.port_d

		service_id = self.GenerateServiceId(request.service_id)

		config_rule = self.GetConfigRule(ip_o, ip_d, port_o, port_d)

		service = GetService(service_id)
		print(service)
		#service.config_rules.append(config_rule)
		#UpdateService(service)

		# RETURN OK TO THE CALLER
		return EmptyMitigator(
		return Empty(
		message=f"OK, received values: {last_tag} with confidence {last_value}."
		)

		def SetDevice(self, device):
		with grpc.insecure_channel(CONTEXT_CHANNEL) as channel:
		stub = ContextServiceStub(channel)
		return stub.SetDevice(device)

		def SetLink(self, link):
		with grpc.insecure_channel(CONTEXT_CHANNEL) as channel:
		stub = ContextServiceStub(channel)
		return stub.SetLink(link)

		def SetTopology(self, link):
		with grpc.insecure_channel(CONTEXT_CHANNEL) as channel:
		stub = ContextServiceStub(channel)
		return stub.SetTopology(link)


		def GetService(self, service_id):
		with grpc.insecure_channel(CONTEXT_CHANNEL) as channel:
		stub = ContextServiceStub(channel)
		return stub.GetService(service_id)

		def SetContext(self, context):
		with grpc.insecure_channel(CONTEXT_CHANNEL) as channel:
		stub = ContextServiceStub(channel)
		return stub.SetContext(context)

		def UpdateService(self, service):
		with grpc.insecure_channel(SERVICE_CHANNEL) as channel:
		stub = ServiceServiceStub(channel)
		stub.UpdateService(service)

		def CreateService(self, service):
		with grpc.insecure_channel(SERVICE_CHANNEL) as channel:
		stub = ServiceServiceStub(channel)
		stub.CreateService(service)

		def GetMitigation(self, request, context):
		# GET OR PERFORM MITIGATION STRATEGY
		logging.debug("")
		print("Returing mitigation strategy...")
		k = self.last_value * 2
		return EmptyMitigator(
		return Empty(
		message=f"Mitigation with double confidence = {k}"
		)

src/l3_centralizedattackdetector/service/l3_centralizedattackdetectorServiceServicerImpl.py

+18 −10

Original line number	Diff line number	Diff line
		@@ -70,12 +70,15 @@ class l3_centralizedattackdetectorServiceServicerImpl(L3Centralizedattackdetecto
		"confidence": None,
		"timestamp": datetime.now().strftime("%d/%m/%Y %H:%M:%S"),
		"ip_o": request.ip_o,
		"ip_d": request.ip_d,
		"tag_name": None,
		"tag": None,
		"flow_id": request.flow_id,
		"protocol": request.protocol,
		"port_o": request.port_o,
		"port_d": request.port_d,
		"ml_id": "RandomForest",
		"service_id": request.service_id,
		"time_start": request.time_start,
		"time_end": request.time_end,
		}
		@@ -93,7 +96,7 @@ class l3_centralizedattackdetectorServiceServicerImpl(L3Centralizedattackdetecto
		def SendInput(self, request, context):
		# PERFORM INFERENCE WITH SENT INPUTS
		logging.debug("")
		print("Inferencing ...")
		print("Inferencing ...", flush=True)

		# STORE VALUES
		self.inference_values.append(request)
		@@ -102,23 +105,28 @@ class l3_centralizedattackdetectorServiceServicerImpl(L3Centralizedattackdetecto
		output = self.make_inference(request)

		# SEND INFO TO MITIGATION SERVER


		try:
		with grpc.insecure_channel("localhost:10002") as channel:
		with grpc.insecure_channel("192.168.165.78:10002") as channel:
		stub = L3AttackmitigatorStub(channel)
		print("Sending to mitigator...")
		response = stub.SendOutput(output)
		print("Sent output to mitigator and received: ", response.message)
		#print("Response received", response, "Hola", flush=True)
		#print("Sent output to mitigator and received: ", response.message) #FIX No message received

		# RETURN "OK" TO THE CALLER
		return Empty(
		message="OK, information received and mitigator notified"
		)
		except:
		except Exception as e:
		print("This is an exception", repr(e), flush=True)
		print('Couldnt find l3_attackmitigator')
		return Empty(
		message="Mitigator Not found"
		)


		def GetOutput(self, request, context):
		logging.debug("")
		print("Returing inference output...")