def initASAs(self, registrar, proxy):
###################################
# Main thread starts here
###################################
grasp.tprint("==========================")
grasp.tprint("GRASP Service is starting up.")
grasp.tprint("==========================")
#grasp.test_mode = True # tell everybody it's a test, will print extra diagnostics
#time.sleep(1) # time to read the text
####################################
# Register this ASA
####################################
# The ASA name is arbitrary - it just needs to be
# unique in the GRASP instance.
grasp.skip_dialogue(False, False, True)
_err, self._asa_nonce = grasp.register_asa("Pledge")
if not _err:
grasp.tprint("ASA Pledge registered OK")
else:
grasp.tprint("ASA registration failure:", grasp.etext[_err])
exit()
####################################
# Construct a GRASP objective
####################################
# This is an empty GRASP objective to find the proxy
# It's only used for get_flood so doesn't need to be filled in
if proxy:
proxy_obj = grasp.objective("AN_proxy")
proxy_obj.synch = True
else:
proxy_obj = None
if registrar:
reg_obj = grasp.objective("AN_join_registrar")
reg_obj.synch = True
else:
reg_obj = None
return proxy_obj, reg_obj
grasp.tprint("Using subnet length", subnet_length)
subnet_unit = subnet_length #delegator counts in delegated lengths
quickly = False
try:
_ = input("Run delegation extra fast? Y/N:")
if _[0] == "Y" or _[0] == "y":
quickly = True
except:
pass
btext = "Pfxm3 Delegator"
####################################
# Register ASA/objectives
####################################
_err, asa_nonce = grasp.register_asa("pfxm3")
if not _err:
grasp.tprint("ASA pfxm3 registered OK")
else:
grasp.tprint("Fatal error:", grasp.etext[_err])
exit()
obj1 = grasp.objective("PrefixManager")
obj1.loop_count = 4
obj1.neg = True
obj1.value = None
# Value is defined as a list [IPversion, length, prefix]
## Value is defined as a list [IPversion, PDcapable, length, prefix]
# Offset definitions:
####################################
# General initialisation
####################################
#time.sleep(8) # so the user can read the text
#this instance of GRASP must run unencrypted
grasp.skip_dialogue(selfing=True, quadsing=False)
#grasp.tprint("Encryption", grasp.crypto, "(should be False)")
####################################
# Register ASA/objectives
####################################
err, asa_nonce = grasp.register_asa("quadski")
if not err:
grasp.tprint("ASA quadski registered OK")
else:
exit()
keys_obj = grasp.objective("411:quadski")
keys_obj.loop_count = 4
keys_obj.neg = True
#The pledge sends the [encrypted_domain_password, pledge_PEM] as the
#value of this objective, as a list of bytes objects. The password is
#RSA encrypted with quadski's public key.
#quadski sends the key bytes and iv (initialisation vector) bytes
#file as the return value of this objective, as an array [key, iv]
grasp.tprint("ASA TestClient is starting up.")
grasp.tprint("==========================")
grasp.tprint("TestClient is a demonstration Autonomic Service Agent.")
grasp.tprint("It just tests out gsend() and grecv() by talking to its peer")
grasp.tprint("On Windows or Linux, there should be a nice window")
grasp.tprint("that displays the talking process.")
grasp.tprint("==========================")
time.sleep(8) # so the user can read the text
####################################
# Register ASA/objectives
####################################
name = "TestClient"
err, asa_nonce = grasp.register_asa(name)
if err:
exit()
grasp.tprint("ASA", name, "registered OK")
obj3 = grasp.objective("EX3")
obj3.neg = True
err = grasp.register_obj(asa_nonce, obj3)
if not err:
grasp.tprint("Objective EX3 registered OK")
else:
exit()
grasp.init_bubble_text(name)
def run(self):
global cheat_nonce
iwant = grasp._prng.randint(10, 500)
grasp.tprint("Asking for $", iwant)
err, asa_nonce2 = grasp.register_asa("Neg2") #assume it worked
obj = grasp.objective("EX2")
obj.neg = True
#obj.loop_count = 2 #for testing purposes
while cheat_nonce == None:
time.sleep(
1) #we should exit after neg1 has registered the objective
asa_nonce = cheat_nonce #now we can pretend to own the objective
grasp.tprint("Got nonce", asa_nonce)
err, ll = grasp.discover(asa_nonce, obj, 5000)
if ll == []:
grasp.tprint("Discovery failed: exit")
return
grasp.tprint("Discovered locator", ll[0].locator)
#attempt to negotiate
obj.value = ["NZD", iwant]
if not iwant % 7:
obj.value = ["USD", iwant] # for testing purposes
err, snonce, answer = grasp.req_negotiate(asa_nonce, obj, ll[0], None)
if err:
if err == grasp.errors.declined and answer != "":
_t = answer
else:
_t = grasp.etext[err]
grasp.tprint("req_negotiate error:", _t)
elif (not err) and snonce:
grasp.tprint("requested, session_nonce:", snonce, "answer", answer)
if answer.value[1] < 0.75 * iwant:
answer.value[1] = int(0.75 * iwant)
err, temp, answer2 = grasp.negotiate_step(
asa_nonce, snonce, answer, 1000)
grasp.tprint("Step1 gave:", err, temp, answer2)
if (not err) and (not temp):
grasp.tprint("Negotiation succeeded", answer.value)
elif not err:
#not acceptable, try one more time
answer2.value[1] = int(0.6 * iwant)
#at random, throw an invalid format of message
if not iwant % 3:
grasp.tprint("Trying badmess")
grasp._make_badmess = True
err, temp, answer3 = grasp.negotiate_step(
asa_nonce, snonce, answer2, 1000)
grasp.tprint("Step2 gave:", err, temp, answer3)
if (not err) and (not temp):
grasp.tprint("Negotiation succeeded", answer3.value)
elif (not err):
#not acceptable
err = grasp.end_negotiate(asa_nonce,
snonce,
False,
reason="You are mean!")
if err:
grasp.tprint("end_negotiate error:",
grasp.etext[err])
else:
#other end rejected
grasp.tprint("Peer reject:", answer3)
else:
#other end rejected
grasp.tprint("Peer reject:", answer2)
else: #acceptable answer
err = grasp.end_negotiate(asa_nonce, snonce, True)
if not err:
grasp.tprint("Negotiation succeeded", answer.value)
else:
grasp.tprint("end_negotiate error:", grasp.etext[err])
else: #acceptable answer first time
grasp.tprint("Negotiation succeeded", answer.value)
grasp.tprint("Exit")
def main(args):
###################################
# Main thread starts here
###################################
grasp.tprint("==========================")
grasp.tprint("Registrar initializing")
grasp.tprint("==========================")
grasp.test_mode = False # set if you want detailed diagnostics
#time.sleep(1) # time to read the text
####################################
# Register this ASA
####################################
# The ASA name is arbitrary - it just needs to be
# unique in the GRASP instance. If you wanted to
# run two registrars in one GRASP instance, they
# would need different names. For example the name
# could include a timestamp.
grasp.skip_dialogue(False, False, True)
_err, asa_nonce = grasp.register_asa("Reggie")
#grasp.tprint("TYPE: ", type(asa_nonce))
#.skip_dialogue(False,False,True)
if not _err:
grasp.tprint("ASA Registrar registered OK")
else:
grasp.tprint("ASA Registrar failure:", grasp.etext[_err])
exit() # demo code doesn't handle registration errors
#grasp.skip_dialogue(False,False,True)
####################################
# Create a TCP port for BRSKI-TCP
####################################
# For this demo, we just make up some numbers:
tcp_port = 80
tcp_proto = socket.IPPROTO_TCP
tcp_address = grasp._my_address # current address determined by GRASP kernel
####################################
# Construct a correponding GRASP ASA locator
####################################
tcp_locator = grasp.asa_locator(tcp_address, None, False)
tcp_locator.protocol = tcp_proto
tcp_locator.port = tcp_port
tcp_locator.is_ipaddress = True
####################################
# Create a IPv4 port for BRSKI-IPv4
####################################
# For this demo, we just make up some numbers:
ipv4_port = 80
ipv4_proto = socket.IPPROTO_TCP
#ipv4_address = '172.2.13.0' #grasp._my_address # current address determined by GRASP kernel
ipv4_address = findOwnIPv4() # current address determined by GRASP kernel
####################################
# Construct a correponding GRASP ASA locator
####################################
ipv4_locator = grasp.asa_locator(ipv4_address, None, False)
ipv4_locator.protocol = ipv4_proto
ipv4_locator.port = ipv4_port
#ipv4_locator.is_ipaddress = True
ipv4_locator.is_fqdn = True
####################################
# Construct the GRASP objective
####################################
radius = 255 # Limit the radius of flooding
reg_obj = grasp.objective("AN_join_registrar")
reg_obj.loop_count = radius
reg_obj.synch = True # needed for flooding
reg_obj.value = None
####################################
# Register the GRASP objective
####################################
_err = grasp.register_obj(asa_nonce, reg_obj)
if not _err:
grasp.tprint("Objective", reg_obj.name, "registered OK")
else:
grasp.tprint("Objective registration failure:", grasp.etext[_err])
exit() # demo code doesn't handle registration errors
####################################
# Start pretty printing
####################################
#grasp.init_bubble_text("BRSKI Join Registrar (flooding method)")
grasp.tprint("==========================")
grasp.tprint("Registrar starting now")
grasp.tprint("==========================")
####################################
# Start flooding thread
####################################
f = flooder(reg_obj, ipv4_locator, asa_nonce)
f.start()
#flooder().start()
grasp.tprint("Flooding", reg_obj.name, "for ever")
###################################
# Listen for requests
###################################
# Here, launch a thread to do the real work of the registrar
# via the various ports But for the demo, we just pretend...
#grasp.tprint("Pretending to listen to ports", tcp_port,",", udp_port,
# "and for IP-in-IP")
###################################
# Do whatever needs to be done in the main thread
###################################
# At a minimum, the main thread should keep an eye
# on the other threads and restart them if needed.
# For the demo, we just dump some diagnostic data...
try:
while True:
time.sleep(5)
#grasp.tprint("Registrar main loop diagnostic dump:")
#dump_some()
except KeyboardInterrupt:
print('interrupted!')
grasp.tprint("EXITTING")
f.stop()
exit()
grasp.tprint("On Windows or Linux, there should soon be")
grasp.tprint("a nice window that displays the process.")
grasp.tprint("==========================")
#grasp.test_mode = True # tell everybody it's a test, will print extra diagnostics
time.sleep(8) # time to read the text
####################################
# Register this ASA
####################################
# The ASA name is arbitrary - it just needs to be
# unique in the GRASP instance.
_err,_asa_nonce = grasp.register_asa("Newby")
if not _err:
grasp.tprint("ASA Newby registered OK")
else:
grasp.tprint("ASA registration failure:",grasp.etext[_err])
exit()
####################################
# Construct GRASP objectives
####################################
# These are empty GRASP objectives to find the peer(s)
# They are only used for get_flood so don't need to be filled in
acp_obj = grasp.objective("AN_ACP")
acp_obj.synch = True
grasp.tprint("It acts as the banker, giving out money, and can")
grasp.tprint("handle multiple overlapping negotiations.")
grasp.tprint("The sum available is random for each negotiation,")
grasp.tprint("and the negotiation timeout is changed at random.")
grasp.tprint("On Windows or Linux, there should be a nice window")
grasp.tprint("that displays the negotiation process.")
grasp.tprint("==========================")
#grasp.test_mode = True # set if you want detailed diagnostics
time.sleep(8) # so the user can read the text
####################################
# Register ASA/objectives
####################################
err, asa_nonce = grasp.register_asa("Briggs")
if not err:
grasp.tprint("ASA Briggs registered OK")
else:
exit()
obj1 = grasp.objective("EX1")
obj1.loop_count = 4
obj1.synch = True
err = grasp.register_obj(asa_nonce, obj1)
if not err:
grasp.tprint("Objective EX1 registered OK")
else:
exit()
grasp.tprint("then runs indefinitely as one side of a negotiation.")
grasp.tprint("It acts as a client, asking for money.")
grasp.tprint("The sum requested is random for each negotiation,")
grasp.tprint("and some GRASP features are used at random.")
grasp.tprint("On Windows or Linux, there should be a nice window")
grasp.tprint("that displays the negotiation process.")
grasp.tprint("========================")
time.sleep(8) # so the user can read the text
_prng = random.SystemRandom() # best PRNG we can get
####################################
# Register ASA/objectives
####################################
err, asa_nonce = grasp.register_asa("Gray")
if not err:
grasp.tprint("ASA Gray registered OK")
else:
exit()
#This objective is for the flooding test
#so doesn't need to be registered
obj1 = grasp.objective("EX1")
obj1.loop_count = 4
obj1.synch = True
#This objective is for the synchronizing test
#so doesn't need to be registered
obj2 = grasp.objective("EX2")
obj2.loop_count = 4
#grasp.tprint('modulo an error in the "AN_proxy" definition')
grasp.tprint("On Windows or Linux, there should soon be")
grasp.tprint("a nice window that displays the process.")
grasp.tprint("==========================")
#grasp.test_mode = True # tell everybody it's a test, will print extra diagnostics
time.sleep(8) # time to read the text
####################################
# Register this ASA
####################################
# The ASA name is arbitrary - it just needs to be
# unique in the GRASP instance.
_err, _asa_nonce = grasp.register_asa("Procksy")
if not _err:
grasp.tprint("ASA Procksy registered OK")
else:
grasp.tprint("ASA registration failure:", grasp.etext[_err])
exit()
####################################
# Construct a GRASP objective
####################################
# This is an empty GRASP objective to find the registrar
# It's only used for get_flood so doesn't need to be filled in
reg_obj = grasp.objective("AN_join_registrar")
reg_obj.synch = True
grasp.tprint("On Windows or Linux, there should be a nice")
grasp.tprint("window that displays the process.")
grasp.tprint("==========================")
####################################
# General initialisation
####################################
time.sleep(8) # so the user can read the text
grasp.skip_dialogue(selfing=True)
####################################
# Register ASA/objective
####################################
err, asa_nonce = grasp.register_asa("pusher")
if not err:
grasp.tprint("ASA pusher registered OK")
else:
exit()
supported_obj = grasp.objective("411:mvFile")
supported_obj.loop_count = 4
supported_obj.neg = True
err = grasp.register_obj(asa_nonce, supported_obj)
if not err:
grasp.tprint("Objective", supported_obj.name, "registered OK")
else:
exit()
grasp.tprint("==========================")
#grasp.test_mode = True # set if you want detailed diagnostics
time.sleep(8) # time to read the text
####################################
# Register this ASA
####################################
# The ASA name is arbitrary - it just needs to be
# unique in the GRASP instance. If you wanted to
# run two registrars in one GRASP instance, they
# would need different names. For example the name
# could include a timestamp.
_err, asa_nonce = grasp.register_asa("Reggie")
if not _err:
grasp.tprint("ASA Reggie registered OK")
else:
grasp.tprint("ASA registration failure:", grasp.etext[_err])
exit() # demo code doesn't handle registration errors
####################################
# Create a TCP port for BRSKI-TCP
####################################
# For this demo, we just make up some numbers:
tcp_port = 80
tcp_proto = socket.IPPROTO_TCP
tcp_address = grasp._my_address # current address determined by GRASP kernel
grasp.tprint("that displays the process.")
grasp.tprint("========================")
####################################
# General initialisation
####################################
grasp.skip_dialogue(selfing=True)
time.sleep(8) # so the user can read the text
failct = 0 # fail counter to control discovery retries
####################################
# Register ASA/objectives
####################################
err, asa_nonce = grasp.register_asa("getter")
if not err:
grasp.tprint("ASA getter registered OK")
else:
exit()
#This objective is for the negotiating test
requested_obj = grasp.objective("411:mvFile")
requested_obj.neg = True
requested_obj.loop_count = 4
err = grasp.register_obj(asa_nonce, requested_obj)
if not err:
grasp.tprint("Objective", requested_obj.name, "registered OK")
else:
exit()
#grasp.tprint('modulo an error in the "AN_proxy" definition')
grasp.tprint("On Windows or Linux, there should soon be")
grasp.tprint("a nice window that displays the process.")
grasp.tprint("==========================")
#grasp.test_mode = True # tell everybody it's a test, will print extra diagnostics
time.sleep(8) # time to read the text
####################################
# Register this ASA
####################################
# The ASA name is arbitrary - it just needs to be
# unique in the GRASP instance.
_err, _asa_nonce = grasp.register_asa("Pledji")
if not _err:
grasp.tprint("ASA Pledji registered OK")
else:
grasp.tprint("ASA registration failure:", grasp.etext[_err])
exit()
####################################
# Construct a GRASP objective
####################################
# This is an empty GRASP objective to find the proxy
# It's only used for get_flood so doesn't need to be filled in
proxy_obj = grasp.objective("AN_proxy")
proxy_obj.synch = True
####################################
private_key = rsa.generate_private_key(
public_exponent=65537,
key_size=2048,
backend=default_backend() )
public_key = private_key.public_key()
pem = public_key.public_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PublicFormat.SubjectPublicKeyInfo )
####################################
# Register ASA/objectives
####################################
err, asa_nonce = grasp.register_asa("qpledge")
if not err:
grasp.tprint("QUADS pledge registered OK")
else:
exit()
flood_obj = grasp.objective("411:quadskip")
flood_obj.loop_count = 4
flood_obj.synch = True
#The value of this objective is the quadski public key PEM
keys_obj = grasp.objective("411:quadski")
keys_obj.neg = True
keys_obj.loop_count = 4
#The pledge sends the [encrypted_domain_password, pledge_PEM] as the
#value of this objective, as a list of bytes objects. The password is
grasp.tprint("On Windows or Linux, there should be a nice")
grasp.tprint("window that displays the process.")
grasp.tprint("==========================")
####################################
# General initialisation
####################################
#grasp.test_mode = True # set if you want detailed diagnostics
time.sleep(8) # so the user can read the text
####################################
# Register ASA/objective
####################################
err,asa_nonce = grasp.register_asa("GetDNSSD2")
if not err:
grasp.tprint("ASA GetDNSSD2 registered OK")
else:
exit()
obj1 = grasp.objective("SRV.")
obj1.loop_count = 4
obj1.neg = True
err = grasp.register_obj(asa_nonce,obj1)
if not err:
grasp.tprint("Objective", obj1.name, "registered OK")
else:
grasp.tprint("that displays the process.")
grasp.tprint("========================")
####################################
# General initialisation
####################################
#grasp.test_mode = True # tell everybody it's a test
time.sleep(8) # so the user can read the text
failct = 0 # fail counter to control discovery retries
####################################
# Register ASA/objectives
####################################
err, asa_nonce = grasp.register_asa("AskDNSSD")
if not err:
grasp.tprint("ASA AskDNSSD registered OK")
else:
exit()
#This objective is for the negotiating test
obj3 = grasp.objective("411:DNSSD")
obj3.neg = True
obj3.loop_count = 4
err = grasp.register_obj(asa_nonce, obj3)
if not err:
grasp.tprint("Objective", obj3.name, "registered OK")
else:
exit()
grasp.tprint("========================")
grasp.tprint("Mudslinger is a demonstration Autonomic Service Agent.")
grasp.tprint("It acts the part of a node that needs to send its")
grasp.tprint("MUD URL to the local MUD manager.")
grasp.tprint("On Windows or Linux, there should be a nice window")
grasp.tprint("that displays the process.")
grasp.tprint("========================")
time.sleep(8) # so the user can read the text
####################################
# Register ASA/objectives
####################################
asa_name = "Mudslinger"
err, asa_nonce = grasp.register_asa("asa_name")
if not err:
grasp.tprint("ASA", asa_name, "registered OK")
else:
grasp.tprint("ASA registration failure:", grasp.etext[err])
time.sleep(60)
exit()
obj_name = "411:MUDURL"
obj3 = grasp.objective(obj_name)
obj3.neg = True
err = grasp.register_obj(asa_nonce, obj3)
if not err:
grasp.tprint("Objective", obj_name, "registered OK")
else:
grasp.tprint("ASA TestClient is starting up.")
grasp.tprint("==========================")
grasp.tprint("TestClient is a demonstration Autonomic Service Agent.")
grasp.tprint("It just tests out gsend() and grecv() by talking to its peer")
grasp.tprint("On Windows or Linux, there should be a nice window")
grasp.tprint("that displays the talking process.")
grasp.tprint("==========================")
time.sleep(8) # so the user can read the text
####################################
# Register ASA/objectives
####################################
name = "TestClient"
err,asa_handle = grasp.register_asa(name)
if err:
exit()
grasp.tprint("ASA", name, "registered OK")
obj3 = grasp.objective("EX3")
obj3.neg = True
err = grasp.register_obj(asa_handle,obj3)
if not err:
grasp.tprint("Objective EX3 registered OK")
else:
exit()
grasp.init_bubble_text(name)
def run(self):
time.sleep(1) # avoid printing glitch
grasp.tprint(
"WARNING: you can't run this test suite more than once without restarting the Python context; it leaves GRASP data structures dirty!\n"
)
grasp.skip_dialogue(testing=True, selfing=True, diagnosing=True)
time.sleep(1) # just to avoid mixed up print output
####################################
# Test code: register ASA/objective#
####################################
test_obj = grasp.objective("EX1")
test_obj.loop_count = 2
test_obj.synch = True
err, test_nonce = grasp.register_asa("ASA-1")
if not err:
err = grasp.register_obj(test_nonce, test_obj, ttl=10000)
if not err:
grasp.tprint("ASA-1 and EX1 Registered OK")
####################################
# Test code: discover EX1 #
####################################
err, test_ll = grasp.discover(test_nonce, test_obj, 10000)
if len(test_ll) > 0:
grasp.tprint("EX1 discovery result", test_ll[0].locator)
else:
grasp.tprint("No EX1 discovery response")
####################################
# Test code: register and discover #
# Boot ASA/objective #
####################################
err, boot_nonce = grasp.register_asa("Boot")
if err:
#we've got a problem...
raise RuntimeError("Can't register Boot as ASA")
boot_obj = grasp.objective("Boot")
boot_obj.loop_count = 2
boot_obj.synch = True
err = grasp.register_obj(boot_nonce, boot_obj, discoverable=True)
if err:
#we've got a different problem...
raise RuntimeError("Can't register Boot objective")
for i in range(3):
#test discovery 3 times, including artificial Divert
grasp.tprint("Test ASA: grasp.test_divert", grasp.test_divert)
err, boot_ll = grasp.discover(boot_nonce, boot_obj, 5000)
if len(boot_ll) > 0:
grasp.tprint("Boot discovery result", boot_ll[0].locator)
grasp.test_divert = True
else:
grasp.tprint("No Boot discovery response")
time.sleep(5)
grasp.test_divert = False
####################################
# Test code: send Flood messages
####################################
obj1 = grasp.objective("Money")
obj1.synch = True
obj1.loop_count = 2
err = grasp.register_obj(test_nonce, obj1)
obj1.value = [100, "NZD"]
obj2 = grasp.objective("Bling")
obj2.synch = True
obj2.loop_count = 2
err = grasp.register_obj(test_nonce, obj2)
obj2.value = ["Diamonds", "Rubies"]
err = grasp.register_obj(test_nonce, obj2)
if err:
grasp.tprint(grasp.etext[err])
obj3 = grasp.objective("Intent.PrefixManager")
obj3.synch = True
obj3.loop_count = 2
err = grasp.register_obj(test_nonce, obj3)
#obj3.value = '{"autonomic_intent":[{"model_version": "1.0"},{"intent_type": "Network management"},{"autonomic_domain": "Customer_X_intranet"},{"intent_name": "Prefix management"},{"intent_version": 73},{"Timestamp": "20150606 00:00:00"},{"Lifetime": "Permanent"},{"signature":"XXXXXXXXXXXXXXXXXXX"},{"content":[{"role": [{"role_name": "RSG"},{"role_characteristic":[{"prefix_length":"34"}]}]},{"role": [{"role_name": "ASG"},{"role_characteristic":[{"prefix_length": "44"}]}]},{"role": [{"role_name": "CSG"},{"role_characteristic":[{"prefix_length": "56"}]}]}]}]}'
#obj3.value = '{"autonomic_intent dummy text"}'
#obj3.value = bytes.fromhex('48deadbeefdeadbeef') #dummy CBOR
obj3.value = cbor.dumps(["Some", "embedded", "CBOR", [1, 2, 3]])
grasp.flood(test_nonce, 0, grasp.tagged_objective(obj1, None),
grasp.tagged_objective(obj2, None),
grasp.tagged_objective(obj3, None))
###################################
# Test code: Listen Synchronize as from Boot ASA
###################################
boot_obj.value = [1, "two", 3]
boot_obj.synch = True
err = grasp.listen_synchronize(boot_nonce, boot_obj)
grasp.tprint("Listen synch", grasp.etext[err])
grasp.tprint(grasp._obj_registry[1].objective.name, "value",
grasp._obj_registry[1].objective.value)
###################################
# Test code: call Synchronize as from EX1
###################################
time.sleep(5)
err, result = grasp.synchronize(test_nonce, obj2, None, 5000)
if not err:
grasp.tprint("Flooded synch obj2", result.value)
else:
grasp.tprint("Synch fail obj2", grasp.etext[err])
err, result = grasp.synchronize(test_nonce, obj3, None, 5000)
if not err:
grasp.tprint("Flooded synch obj3", result.value)
else:
grasp.tprint("Synch fail obj3", grasp.etext[err])
#this should fail as test_obj was neither flooded or listened for.
err, result = grasp.synchronize(test_nonce, test_obj, None, 5000)
if not err:
grasp.tprint("Synch test_obj (should fail)", result.value)
else:
grasp.tprint("Synch fail test_obj (should fail)", grasp.etext[err])
boot2_obj = grasp.objective("Boot")
boot2_obj.synch = True
err, result = grasp.synchronize(test_nonce, boot2_obj, None, 5000)
if not err:
grasp.tprint("Synch boot2_obj", result.name, result.value)
else:
grasp.tprint("Synch fail boot2_obj", grasp.etext[err])
###################################
# Test code: print obj_registry
# and flood cache
###################################
grasp.tprint("Objective registry contents:")
for x in grasp._obj_registry:
o = x.objective
grasp.tprint(o.name, "ASA:", x.asa_id, "Listen:", x.listening,
"Neg:", o.neg, "Synch:", o.synch, "Count:",
o.loop_count, "Value:", o.value)
grasp.tprint("Flood cache contents:")
for x in grasp._flood_cache:
grasp.tprint(x.objective.name, "count:", x.objective.loop_count,
"value:", x.objective.value, "source:", x.source)
time.sleep(5)
###################################
# Test code: check flood cache for Tag 24 case
###################################
flobj = grasp.objective("Intent.PrefixManager")
flobj.synch = True
err, tobs = grasp.get_flood(test_nonce, flobj)
if not err:
for x in tobs:
try:
grasp.tprint("Flooded CBOR", x.objective.name,
cbor.loads(x.objective.value))
except:
grasp.tprint("Flooded raw", x.objective.name,
x.objective.value)
###################################
# Test code: deregister and then
# attempt synch
###################################
err = grasp.deregister_obj(boot_nonce, boot_obj)
if not err:
grasp.tprint("Deregistered Boot", )
else:
grasp.tprint("Deregister failure", grasp.etext[err])
err, result = grasp.synchronize(test_nonce, boot2_obj, None, 5000)
if not err:
grasp.tprint("Synch boot2_obj (should fail)", result.name,
result.value)
else:
grasp.tprint("Synch fail boot2_obj (should fail)",
grasp.etext[err])
###################################
# Test code: start in-host negotiate test
###################################
cheat_nonce = None
Neg1().start()
time.sleep(10)
Neg2().start()
#####################################
# Test code:
# test deregistering an ASA,
# and exit the thread
#####################################
grasp.deregister_asa(test_nonce, "ASA-1")
grasp.tprint("Exiting ASA test thread")
grasp.tprint("It also announce itself as an EST server.")
grasp.tprint("On Windows or Linux, there should soon be")
grasp.tprint("a nice window that displays the process.")
grasp.tprint("==========================")
#grasp.test_mode = True # tell everybody it's a test, will print extra diagnostics
time.sleep(8) # time to read the text
####################################
# Register this ASA
####################################
# The ASA name is arbitrary - it just needs to be
# unique in the GRASP instance.
_err, _asa_nonce = grasp.register_asa("ACPcontainer")
if not _err:
grasp.tprint("ASA ACPcontainer registered OK")
else:
grasp.tprint("ASA registration failure:", grasp.etext[_err])
exit()
####################################
# Construct GRASP objectives
####################################
acp_obj = grasp.objective("AN_ACP")
acp_obj.synch = True
acp_obj.discoverable = False #override default
acp_obj.value = "IKEv2"
# acp_obj.loop_count not set, the API forces it to 1 for link-local use
def run(self):
global cheat_nonce
reserves = grasp._prng.randint(100, 400)
wt = grasp._prng.randint(15000, 40000)
grasp.tprint("Reserves: $", reserves, "wait:", wt)
err, asa_nonce = grasp.register_asa("Neg1") #assume it worked
obj = grasp.objective("EX2")
obj.neg = True
#obj.loop_count = 2 #for testing purposes
grasp.register_obj(asa_nonce, obj) #assume it worked
cheat_nonce = asa_nonce #pass the nonce to the other negotiator!
#attempt to listen
err, snonce, answer = grasp.listen_negotiate(asa_nonce, obj)
if err:
grasp.tprint("listen_negotiate error:", grasp.etext[err])
else:
grasp.tprint("listened, answer", answer.name, answer.value)
grasp.tprint("Source was", snonce.id_source)
result = True
reason = None
concluded = False
if answer.value[0] != "NZD":
result = False
reason = "Invalid currency"
elif answer.value[1] > reserves / 2:
answer.value = ["NZD", int(reserves / 2)]
err, temp, answer2 = grasp.negotiate_step(
asa_nonce, snonce, answer, 1000)
grasp.tprint("Step1 gave:", err, temp, answer2)
if (not err) and (not temp):
concluded = True
grasp.tprint("Negotiation succeeded", answer2.value)
elif not err:
err1 = grasp.negotiate_wait(asa_nonce, snonce, wt)
grasp.tprint("Tried wait:", grasp.etext[err1])
time.sleep(
20) #note - if wt<20000 this tests anomaly handling
grasp.tprint("Woke up")
answer2.value = ["NZD", int(0.75 * reserves)]
err2, temp, answer3 = grasp.negotiate_step(
asa_nonce, snonce, answer2, 1000)
grasp.tprint("Step2 gave:", err2, temp, answer3)
if (not err2) and (not temp):
concluded = True
grasp.tprint("Negotiation succeeded", answer3.value)
elif not err2:
result = False
if reserves % 2:
reason = "Insufficient funds"
else:
reason = u"Недостаточно средств"
else:
#other end rejected
concluded = True
grasp.tprint("Peer reject2:", answer3)
else:
#other end rejected
concluded = True
grasp.tprint("Peer reject1:", answer2)
else: #can accept the requested value
pass
if not concluded:
err = grasp.end_negotiate(asa_nonce,
snonce,
result,
reason=reason)
if err:
grasp.tprint("end_negotiate error:", grasp.etext[err])
grasp.tprint("Exit")
