Solution for hackover

Author: mzfr

INShAck-2019/hackover/Luca.py

@@ -0,0 +1,54 @@
+import random
+
+with open("routes.txt") as f:
+   routes = f.readlines()
+
+with open("sol.txt") as f:
+   sol = [l.strip() for l in f.readlines()]
+
+routes = [set(r.strip().split(',')) for r in routes]
+
+routes.sort(key = lambda s: len(s))
+
+def fix_cover(cover):
+   for r in routes:
+       if len(cover & r) == 0:
+           chosen = random.sample(r, 1)[0]
+           cover.add(chosen)
+   return cover
+
+cover = set(sol)
+
+def compute_importance(cover, routes):
+   nodes = list(cover)
+   importances = []
+   for n in nodes:
+       importance = 0
+       for r in routes:
+           if n in r:
+               importance += 1.0 / 10**(len(cover & r))
+       importances.append(importance)
+
+   nodes = [[nodes[i], importances[i]] for i in range(len(nodes))]
+   nodes.sort(key = lambda s: s[1])
+
+   new_cover = set()
+   for n in nodes[30:]:
+       new_cover.add(n[0])
+   return new_cover
+
+
+score = len(cover)
+while True:
+   new_cover = compute_importance(cover, routes)
+   new_cover = fix_cover(new_cover)
+   new_score = len(new_cover)
+   if new_score < score:
+       print(new_score)
+       score = new_score
+       cover = new_cover
+   if score == 126:
+       with open("sol126.txt", "w") as f:
+           for c in cover:
+               f.write(c+"\n")
+       break

INShAck-2019/hackover/Readme.md

@@ -0,0 +1,34 @@
+# HackCode
+
+__Description__
+
+We have a little budgeting issue with our latest red team campaign. Please help us figure it out :
+
+https://hack-code.ctf.insecurity-insa.fr
+
+This challenge has 4 different flags, better solutions will grant you more flags.
+
+
+__SOLUTION__
+
+I didn't solve this challenge this my actually solved by __@nullpointer__ and __@luca__.
+
+Basically we need to write an algorithm that is efficient. The more efficient the algorith the more flag you'll get.
+
+This challenge had 4 flags.
+
+First __@NullPointer__ wrote a [script](nullpointer.py) with which we was able to get 128 taps which gave us 3 flags.
+
+```
+First flag is INSA{N0t_bad_f0r_a_start}. The next flag will be awarded at <= 135.
+```
+
+```
+INSA{135_is_pretty_g0Od_but_how_l0w_c4n_u_gO}. Get your next flag at <= 128
+```
+
+```
+INSA{Getting_cl0ser}. The last flag is waiting for you at 126 !
+```
+
+After that lot of people started to optimize the algorithm and finally __@luca__ was able to optimize the [script](luca.py) it to give us 126 taps and we got the final flag.

INShAck-2019/hackover/nullpointer.py

@@ -0,0 +1,47 @@
+with open( 'routes.txt', 'r') as f:
+   data=f.read().splitlines()
+tap=[]
+while len(data) > 0:
+    print( "There are %d routes"%len(data))
+    conn_stat = {}
+    conn_route = {}
+    conn_nr_route={}
+    i=0
+    for datum in data:
+        #print("Analysis of %s"%datum)
+        connections=datum.split(',')
+        for connection in connections:
+            if len(connection) < 5:
+                continue
+            #if connection == "e5a10f35":
+            #    print(datum)
+            #print(connection)
+            if connection not in conn_stat:
+                conn_stat[connection]=1
+                conn_route[connection]=[]
+                conn_nr_route[connection]=0
+            else:
+                #print("Extend")
+                conn_stat[connection]=conn_stat[connection]+1
+            if datum not in conn_route[connection]:
+                conn_route[connection].append( datum )
+                conn_nr_route[connection] = conn_nr_route[connection] + len( connections )
+                #conn_route[connection].append( i )
+        i=i+1
+    w=0
+    d=None
+    n = 0
+    for k in conn_stat.keys():
+        if w < conn_stat[k] or d == None:
+            if d == None or conn_nr_route[k] > conn_nr_route[d]:
+                d=k
+                w=conn_stat[k]
+    print( "Best tap point is %s and it lead to remove %d routes"% (d, len(conn_route[d])) )
+    #print( conn_route[d] )
+    tap.append(d)
+    #print( "Current tap list is ", tap)
+    for k in conn_route[d]:
+        data.remove(k)
+print( "Finished with %d"%len(tap))
+for t in tap:
+    print(t)