class AP():
"""I'm a router!!!"""
def __init__(self, contract_address):
# Global vars
# UDP Socket
self.emulation_time = 200
self.sock_udp = socket(AF_INET, SOCK_DGRAM)
self.sock_udp.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
self.contract = App()
self.contract_address = contract_address
# node PIT data structure
self.this_PIT = dict()
# General PIT
self.PIT = dict()
try:
self.contract.initWeb3()
self.contract.initContract(self.contract_address)
self.contract.initContract(self.contract_address)
except Exception as err:
print(err)
exit(-1)
def onInterest(self):
# Consumer side
sock_udp = socket(AF_INET, SOCK_DGRAM)
sock_udp.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
# Listen for requests from anywhere
sock_udp.bind(("", 2222))
while 1:
data, addr = sock_udp.recvfrom(1024)
ndn_packet = json.loads(data.decode('utf-8'))
pkt_type = ndn_packet['type']
# Data Infos
provider = ndn_packet['name'].split('/')[1]
name = ndn_packet['name'].split('/')[2]
# Here starts the attack <----
if pkt_type == "VER":
# TODO: Check if this packet was already verified
if self.PIT.get(name): # 4s default NDN interestLifetime
# Link provider ID with an wallet account
prefix = self.contract.getAnAccount(int(provider))
content_name = "/{0}/{1}".format(prefix, name)
try:
provider = self.contract.getAnAccount(
int(ndn_packet['provider']))
# print("[DEBUG-AP] AP verifying Content %s for provider %s" % (name,provider))
status = self.contract._verifyContent(
content_name, provider)
# print("[DEBUG-AP] Status ", status)
message = {
'hop_count': 15,
'type': 'VER',
'name': ndn_packet['name'],
'status': status
}
message2json = str(json.dumps(message)).encode('ascii')
self.sock_udp.sendto(
message2json,
("10.0.0.255",
2222)) # Using broadcast address of eth0
except Exception as err:
# print ("Error: {0} => {1}".format(err,ndn_packet))
pass
elif pkt_type == "REG":
# TODO: Finish this implementation
provider = self.contract.getAnAccount(int(provider))
content_name = "/{0}/{1}".format(provider, name)
if not self.PIT.get(name):
# print("[DEBUG-AP] AP registering content %s" % (content_name))
self.contract._registerContent(content_name, provider)
self.writeRegisteredContents(ndn_packet['name'])
self.PIT[name] = 4
# TODO: Finish this implementation
# elif data_2_json['type'] == "AUT":
# self.contract._registerProvider(name,provider)
def writeRegisteredContents(self, content_name):
content_list = open("/tmp/content_list.txt", "a+")
content_list.write(content_name + "\n")
content_list.close()
def StopEmulation(self):
time.sleep(self.emulation_time + 2)
output_file = open("/tmp/emulation_output.txt", "a+")
output_file.write(self.contract.getStatistics())
output_file.close()
os.system("killall python3.7")
class Consumer():
"""docstring for Consumer."""
def __init__(self, contract_address, emulation_time, my_id):
self.emulation_time = float(emulation_time)
self.contract = App()
self.contract_address = contract_address
# File with content names TODO: remove '\n' chars
self.content_file_array = ""
# According to the emulation time
self.maximum_request = 5 #random.randint(20,500)
self.requests_per_second = 5
# UDP Socket
self.sock_udp = socket(AF_INET, SOCK_DGRAM)
self.sock_udp.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
self.sock_udp.bind(('', 2222))
# node PIT data structure
self.this_PIT = dict()
# General PIT
self.PIT = dict()
# Metrics
self.interests_sent = 0.0
self.data_received = 0.0
#
try:
self.contract.initWeb3()
self.contract.getAnAccount(int(my_id))
self.contract.initContract(self.contract_address)
# realAddr = self.contract.getAnAccount(1)
# fakeAddr = self.contract.getAnAccount(2)
# Problemas de DoS realizados pelo consumidor que tenta inundar a BC
# com falsas requisicoes ou incriminar algum produtor autentico
# self.contract._verifyContent("data1",fakeAddr)
# self.contract._verifyContent("data1",fakeAddr)
except Exception as err:
print(err)
exit(-1)
def setFile(self):
self.content_file_array = list(
open("/tmp/contents.txt", "r").readlines())
def sendInterest(self):
if (self.maximum_request > 0):
file_size = len(self.content_file_array)
try:
for c in range(self.requests_per_second):
name = self.content_file_array[random.randint(
0, file_size - 1)].replace('\n', '')
# interest packet format
data_2_json = {
"hop_count": 15,
"type": "interest",
"name": name,
"payload": [hex(x) for x in range(10)]
}
interest = str(json.dumps(data_2_json)).encode('ascii')
# Send interest
self.sock_udp.sendto(interest, ('<broadcast>', 2222))
# Add on PIT
self.this_PIT[name] = True
# count
self.interests_sent += 1.0
self.maximum_request -= 1
except:
pass
# Interval
time.sleep(1)
# Loop
self.sendInterest()
# On consumer, onData works for both Interests and Data packets
def onData(self):
while 1:
data, addr = self.sock_udp.recvfrom(1024)
data_2_json = json.loads(data.decode('utf-8'))
name = data_2_json['name']
# Is pending?
print(
"[DEBUG] Node has received a data packet for {}".format(name))
if self.this_PIT.get(name) and data_2_json['type'] == "data":
provider = data_2_json['account']
status = self.contract._verifyContent(name, provider)
if status:
# count
self.data_received += 1
# Delete entry
del (self.this_PIT[name])
elif self.PIT.get(name) and data_2_json[
'type'] == "data": # Did I Forward it?
# Forward data packet
self.sock_udp.sendto(data, ('<broadcast>', 2222))
del (self.PIT[name])
elif data_2_json['type'] == "interest" and not (
self.this_PIT.get(name)
or self.PIT.get(name)): # Forward it
hop_count = data_2_json['hop_count']
if hop_count >= 1:
# Decrement hop count
data_2_json['hop_count'] = data_2_json['hop_count'] - 1
# Forward interest packet
message = str(json.dumps(data_2_json)).encode('ascii')
self.sock_udp.sendto(message, ('<broadcast>', 2222))
# Add on PIT
self.PIT[name] = True
# else: #drop it
# print (data_2_json)
def StopEmulation(self):
time.sleep(self.emulation_time)
output_file = open("/tmp/emulation_output", "a+")
output_file.write(self.contract.getStatistics())
try:
output_file.write("ISR:{0}\n".format(self.data_received /
self.interests_sent))
except:
output_file.write("ISR: 0")
output_file.close()
os.system("killall python3.7")
