def json(self):
return {
"origin": self.origin_value,
"origin_string": BGPTranslation.origin(self.origin_value),
"type": self.type,
"type_string": BGPTranslation.path_attribute(self.type),
"error": self.error,
}
def __str__(self):
if isinstance(self.global_administrator, int) and isinstance(
self.local_administrator, int) and isinstance(
self.type, int) and isinstance(self.sub_type, int):
type = self.type
sub_type = self.sub_type
global_administrator = self.global_administrator
local_administrator = self.local_administrator
elif isinstance(self.global_administrator, bytes) and isinstance(
self.local_administrator, bytes) and isinstance(
self.type, bytes) and isinstance(self.sub_type, bytes):
type = struct.unpack("!B", self.type)[0]
sub_type = struct.unpack("!B", self.sub_type)[0]
global_administrator = struct.unpack("!H",
self.global_administrator)[0]
local_administrator = struct.unpack("!I",
self.local_administrator)[0]
else:
return ""
type_string = BGPTranslation.extended_community(type, sub_type)
return type_string + " (" + str(self.global_administrator) + ":" + str(
self.local_administrator) + ")"
def json(self):
return {
"multiple_exit_discriminator": self.multiple_exit_discriminator,
"type": self.type,
"type_string": BGPTranslation.path_attribute(self.type),
"error": self.error,
}
def json(self):
return {
"type": self.type,
"type_string": BGPTranslation.path_attribute(self.type),
"error": self.error,
"next_hop": str(BGPRoute.decimal_ip_to_string(self.next_hop))
}
def __str__(self):
# Return the string identifier of the BGP message
# Example return: <BGPMessage type=UPDATE length=128>
message_type_string = BGPTranslation.message_type(self.type)
message_length_string = self.length
message_parsed_string = BGPTranslation.boolean(self.parsed)
message_error_string = BGPTranslation.boolean(self.error)
# Assemble first part of message
return_string = "<BGPMessage type="
# Assemble message type
if message_type_string is not None:
return_string += message_type_string
else:
return_string += "UNKNOWN"
# Assemble length
return_string += " " + "length="
if message_length_string is not None:
return_string += str(message_length_string)
else:
return_string += "UNKNOWN"
# Assemble parsed
return_string += " " + "parsed="
if message_parsed_string is not None:
return_string += message_parsed_string
else:
return_string += "UNKNOWN"
# Assemble error
return_string += " " + "error="
if message_error_string is not None:
return_string += message_error_string
else:
return_string += "UNKNOWN"
# Close message
return_string += ">"
# Return fully assembled message
return return_string
def json(self):
r = {
"type":
self.type,
"type_string":
BGPTranslation.extended_community_type(self.type),
"sub_type":
self.sub_type,
"sub_type_string":
BGPTranslation.extended_community_subtype(self.type,
self.sub_type),
"global_administrator":
self.global_administrator,
"local_administrator":
self.local_administrator
}
return r
def json(self):
r = {
"segment_type": self.segment_type,
"segment_type_string": BGPTranslation.path_segment_type(self.segment_type),
"segments": []
}
for s in self.segments:
r["segments"].append(s)
return r
def json(self):
r = {
"type": self.type,
"type_string": BGPTranslation.path_attribute(self.type),
"error": self.error,
"extended_communities": []
}
for e in self.extended_communities:
r["extended_communities"].append(e.json())
return r
def json(self):
r = {
"asn_byte_length": self.asn_byte_length,
"type": self.type,
"type_string": BGPTranslation.path_attribute(self.type),
"path_segments": [],
"error": self.error,
}
for segment in self.path_segments:
r["path_segments"].append(segment.json())
return r
def __str__(self):
return BGPTranslation.origin(self.origin_value)
def apply(self, message):
# Example return:
#
# [BGPMessage UPDATE] - [123.123.123.123 -> 123.123.123.123]
# |- IP: 123.123.123.123 -> 123.123.123.123
# |- MAC: 11:11:11:11:11:11 -> 11:11:11:11:11
# |- Unix Time: 1412416346.123245123
# |
# |- Withdrawn Routes Length: 0
# |- Total Path Attribute Length: 55
# |- Path Attributes
# |--- ORIGIN: IGP
# |--- AS_PATH: (9498 9430)
# |--- NEXT_HOP: 80.81.194.250
# |--- COMMUNITIES: 9498:1 9498:11 9498:91
# |- NLRI
# |--- 203.190.42.0/24
##
# Initialize basic return string and PCAP information
string = "[BGPMessage " + BGPTranslation.message_type(message.type) + "] - " + str(message.length) + " Bytes\n"
string += self.prefix(0) + "MAC: " + message.pcap_information.get_mac().get_source_string(separated=True) + " -> " + message.pcap_information.get_mac().get_destination_string(separated=True) + "\n"
string += self.prefix(0) + "IP: " + message.pcap_information.get_ip().get_source_string() + ":" + message.pcap_information.get_ports().get_source_string() + " -> " + message.pcap_information.get_ip().get_destination_string() + ":" + message.pcap_information.get_ports().get_destination_string() + "\n"
string += self.prefix(0) + "Timestamp: " + message.pcap_information.get_timestmap_utc() + " (" + str(message.pcap_information.get_timestamp()[0]) + "." + str(message.pcap_information.get_timestamp()[1]) + ")\n"
# Display additional information
if BGPStatics.MESSAGE_TYPE_KEEPALIVE == message.type:
pass
if BGPStatics.MESSAGE_TYPE_OPEN == message.type:
# --- Divider for PCAP information
string += self.prefix(-1) + "\n"
string += self.prefix(0) + "Version: " + str(message.version) + "\n"
string += self.prefix(0) + "My ASN: " + str(message.asn) + "\n"
string += self.prefix(0) + "Hold Time: " + str(message.hold_time) + "\n"
string += self.prefix(0) + "BGP Identifier: " + str(BGPRoute.decimal_ip_to_string(message.identifier)) + "\n"
# --- Optional Parameters
string += self.prefix(0) + "Optional Parameters Length: " + str(message.optional_parameter_length) + " Bytes" + "\n"
# Process optional parameters
if message.optional_parameter_length > 0:
string += self.prefix(0) + "Optional Parameters:" + "\n"
for parameter in message.optional_parameter:
if parameter.type == BGPStatics.OPEN_CAPABILITY:
string += self.prefix(1) + "Parameter: Capability" + "\n"
# Process capabilities
for capability in parameter.capability_list:
string += self.prefix(2) + BGPTranslation.capability(capability.type) + "\n"
elif parameter.type == BGPStatics.OPEN_AUTHENTICATION:
string += self.prefix(1) + "Parameter: Authentication" + "\n"
elif parameter.type == BGPStatics.OPEN_RESERVED:
string += self.prefix(1) + "Parameter: Reserved" + "\n"
if BGPStatics.MESSAGE_TYPE_UPDATE == message.type:
# --- Divider for PCAP information
string += self.prefix(-1) + "\n"
# --- Update Message Sub-Type
string += self.prefix(0) + "Update Message Sub-Type: " + BGPTranslation.update_subtype(message.subtype) + "\n"
# --- Lengths
string += self.prefix(0) + "Withdrawn Routes Length: " + str(message.withdrawn_routes_length) + " Bytes\n"
string += self.prefix(0) + "Total Path Attribute Length: " + str(message.path_attributes_length) + " Bytes\n"
# --- NLRI
if len(message.nlri) > 0:
string += self.prefix(0) + "Prefix (NLRI):" + "\n"
# Process NLRI
for route in message.nlri:
string += self.prefix(1) + str(route) + "\n"
# --- Path Attributes
if message.path_attributes_length > 0:
# Process path attributes
for attribute in message.path_attributes:
string += self.prefix(0) + "Path Attributes:" + "\n"
if attribute.type == BGPStatics.UPDATE_ATTRIBUTE_EXTENDED_COMMUNITIES:
# Extended Communities must be displayed in another way than other attributes
string += self.prefix(1) + BGPTranslation.path_attribute(attribute.type) + ":\n"
for community in attribute.extended_communities:
string += self.prefix(2) + str(community) + "\n"
else:
# We got a "normal" path attribute
string += self.prefix(1) + BGPTranslation.path_attribute(attribute.type) + ": " + str(attribute) + "\n"
# --- Withdrawn Routes
if message.withdrawn_routes_length > 0:
string += self.prefix(0) + "Withdrawn Routes:" + "\n"
# Process withdrawn routes
for route in message.withdrawn_routes:
string += self.prefix(1) + str(route) + "\n"
if BGPStatics.MESSAGE_TYPE_NOTIFICATION == message.type:
pass
if BGPStatics.MESSAGE_TYPE_ROUTE_REFRESH == message.type:
pass
if BGPStatics.MESSAGE_TYPE_RESERVED == message.type:
pass
# Return assembled string plus final line break
return string + "\n"
def apply(self, message):
r = ""
for f in self.fields:
if f == self.FIELD_MESSAGE_TIMESTAMP:
r += self.separator + str(
message.pcap_information.get_timestamp()[0]) + "." + str(
message.pcap_information.get_timestamp()[1])
elif f == self.FIELD_MESSAGE_IP_SOURCE:
r += self.separator + message.pcap_information.get_ip(
).get_source_string()
elif f == self.FIELD_MESSAGE_IP_DESTINATION:
r += self.separator + message.pcap_information.get_ip(
).get_destination_string()
elif f == self.FIELD_MESSAGE_MAC_SOURCE:
r += self.separator + message.pcap_information.get_mac(
).get_source_string()
elif f == self.FIELD_MESSAGE_MAC_DESTINATION:
r += self.separator + message.pcap_information.get_mac(
).get_destination_string()
elif f == self.FIELD_MESSAGE_LENGTH:
r += self.separator + str(message.length)
elif f == self.FIELD_MESSAGE_TYPE:
r += self.separator + BGPTranslation.message_type(message.type)
elif f == self.FIELD_UPDATE_SUBTYPE:
# We can only display this information if we are handling an UPDATE message
if message.type == BGPStatics.MESSAGE_TYPE_UPDATE:
r += self.separator + BGPTranslation.update_subtype(
message.subtype)
else:
r += self.separator
elif f == self.FIELD_UPDATE_PATH_ATTRIBUTES_LENGTH:
# We can only display this information if we are handling an UPDATE message
if message.type == BGPStatics.MESSAGE_TYPE_UPDATE:
r += self.separator + str(message.path_attributes_length)
else:
r += self.separator
elif f == self.FIELD_UPDATE_WITHDRAWN_ROUTES_LENGTH:
# We can only display this information if we are handling an UPDATE message
if message.type == BGPStatics.MESSAGE_TYPE_UPDATE:
r += self.separator + str(message.withdrawn_routes_length)
else:
r += self.separator
elif f == self.FIELD_UPDATE_WITHDRAWN_ROUTES:
# We can only display this information if we are handling an UPDATE message
if message.type == BGPStatics.MESSAGE_TYPE_UPDATE:
if len(message.withdrawn_routes) > 0:
add = ""
for route in message.withdrawn_routes:
add += ";" + str(route)
# Skip first separator character
r += self.separator + add[1:]
else:
r += self.separator
else:
r += self.separator
elif f == self.FIELD_UPDATE_NLRI:
# We can only display this information if we are handling an UPDATE message
if message.type == BGPStatics.MESSAGE_TYPE_UPDATE:
if len(message.nlri) > 0:
add = ""
for route in message.nlri:
add += ";" + str(route)
# Skip first separator character
r += self.separator + add[1:]
else:
r += self.separator
else:
r += self.separator
elif f == self.FIELD_UPDATE_ATTRIBUTE_ORIGIN:
# We can only display this information if we are handling an UPDATE message
if message.type == BGPStatics.MESSAGE_TYPE_UPDATE:
if len(message.path_attributes) > 0:
for attribute in message.path_attributes:
# We found the correct path attribute
if isinstance(attribute, PathAttributeOrigin):
r += self.separator + str(attribute)
break
else:
r += self.separator
else:
r += self.separator
elif f == self.FIELD_UPDATE_ATTRIBUTE_AS_PATH:
# We can only display this information if we are handling an UPDATE message
if message.type == BGPStatics.MESSAGE_TYPE_UPDATE:
if len(message.path_attributes) > 0:
for attribute in message.path_attributes:
# We found the correct path attribute
if isinstance(attribute, PathAttributeASPath):
if len(attribute.path_segments) > 0:
add = ""
for segment in attribute.path_segments:
add += ";" + str(segment)
# Skip first separator
r += self.separator + add[1:]
break
else:
r += self.separator
break
else:
r += self.separator
else:
r += self.separator
elif f == self.FIELD_UPDATE_ATTRIBUTE_NEXT_HOP:
# We can only display this information if we are handling an UPDATE message
if message.type == BGPStatics.MESSAGE_TYPE_UPDATE:
if len(message.path_attributes) > 0:
for attribute in message.path_attributes:
# We found the correct path attribute
if isinstance(attribute, PathAttributeNextHop):
r += self.separator + str(attribute)
break
else:
r += self.separator
else:
r += self.separator
elif f == self.FIELD_UPDATE_ATTRIBUTE_COMMUNITIES:
# We can only display this information if we are handling an UPDATE message
if message.type == BGPStatics.MESSAGE_TYPE_UPDATE:
if len(message.path_attributes) > 0:
for attribute in message.path_attributes:
# We found the correct path attribute
if isinstance(attribute, PathAttributeCommunities):
if len(attribute.communities) > 0:
add = ""
for community in attribute.communities:
add += ";" + str(community)
r += self.separator + add[1:]
break
else:
r += self.separator
else:
r += self.separator
else:
r += self.separator
elif f == self.FIELD_UPDATE_ATTRIBUTE_EXTENDED_COMMUNITIES:
# @todo Find a good way to display extended communities in just one line
r += self.separator
else:
# No field match
pass
# Delete first tab
return r[1:]
def apply(self, message):
# Basic data for every message type
data = {
"timestamp":
str(message.pcap_information.get_timestamp()[0]) + "." +
str(message.pcap_information.get_timestamp()[1]),
"message_type":
message.type,
"message_type_string":
BGPTranslation.message_type(message.type),
"length":
message.length,
"source_mac":
message.pcap_information.get_mac().get_source_string(),
"destination_mac":
message.pcap_information.get_mac().get_destination_string(),
"source_ip":
message.pcap_information.get_ip().get_source_string(),
"destination_ip":
message.pcap_information.get_ip().get_destination_string(),
"message_data":
None
}
# Handle specific message types that contain more information than added above
# Currently we just need to add information to OPEN- and UPDATE-messages
if message.type == BGPStatics.MESSAGE_TYPE_OPEN:
message_data = {}
elif message.type == BGPStatics.MESSAGE_TYPE_UPDATE:
message_data = {
"sub_type_string":
BGPTranslation.update_subtype(message.subtype),
"withdrawn_routes_length": message.withdrawn_routes_length,
"path_attributes_length": message.path_attributes_length,
"path_attributes": None,
"withdrawn_routes": None,
"nlri": None
}
path_attributes = []
withdrawn_routes = []
nlri = []
# Add path attributes
if len(message.path_attributes) > 0:
for a in message.path_attributes:
path_attributes.append(a.json())
# Add withdrawn routes
if len(message.withdrawn_routes) > 0:
for w in message.withdrawn_routes:
withdrawn_routes.append(str(w))
# Add NLRI
if len(message.nlri) > 0:
for n in message.nlri:
nlri.append(str(n))
# Assign to message data
message_data["path_attributes"] = path_attributes
message_data["withdrawn_routes"] = withdrawn_routes
message_data["nlri"] = nlri
# Assign message data to return data
data["message_data"] = message_data
return json.dumps(data)
def json(self):
return {
"type": self.type,
"type_string": BGPTranslation.path_attribute(self.type),
"error": self.error,
}