Added 1NDVCLUB task

Author: awengar

1NDVCLUB_TASK/create/constants.py

@@ -0,0 +1,7 @@
+hosts = "0.0.0.0"
+server_port = 5050
+input_chunk_size = 2**10
+max_users = 1000
+pause = 1
+socket_timeout = 5
+max_size_bytes = 1024 * 1024 * 2

1NDVCLUB_TASK/create/gansta_eye.py

@@ -0,0 +1,153 @@
+import cv2
+import numpy as np
+
+#WARNING! OpenCV 3.* required.
+
+# Parameters for lucas kanade optical flow
+lk_params = dict( winSize  = (15,15),
+                  maxLevel = 2,
+                  criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03))
+
+
+def getHarrisPoints(gray_img):
+    harris = cv2.cornerHarris(gray_img, 2, 3, 0.05)
+    # Threshold for an optimal value
+    xarr,yarr = np.nonzero(harris > 0.03*harris.max())
+    harrisPointsArray = [np.array([[x,y]]) for x,y in zip(xarr,yarr)]
+    return np.array(harrisPointsArray, dtype=np.float32)
+
+
+def getFASTPoints(gray_img):
+    # Initiate FAST object with default values
+    fast = cv2.FastFeatureDetector_create(threshold=5)
+    # find keypoints
+    kp_array = fast.detect(gray_img,None)
+    # print kp_array[0].pt[1]
+    fastPointsArray = [np.array([[kp.pt[0], kp.pt[1]]]) for kp in kp_array]
+    return np.array(fastPointsArray, dtype=np.float32)
+
+def videoTracking(cap, slow_motion_delay, detector):
+    # Create some random colors
+    color = np.random.randint(0,255,(100,3))
+    # Take first frame and find corners in it
+    ret, old_frame = cap.read()
+    old_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY)
+    # Create a mask image for drawing purposes
+    mask = np.zeros_like(old_frame)
+    # Define the codec and create VideoWriter object
+    # height, width, _ = old_frame.shape
+    # fourcc = cv2.VideoWriter_fourcc(*'XVID')
+    # out = cv2.VideoWriter('output_'+detector+'.avi',fourcc, slow_motion_delay, (width,height))
+    if detector == 'Harris':
+        oldTrackPoints = getHarrisPoints(old_gray)
+    elif detector == 'FAST':
+        oldTrackPoints = getFASTPoints(old_gray)
+    else:
+        print('Not correct method')
+    print "$$$ Checking if i can recognise your move, n1ggv"
+    while not len(oldTrackPoints) and cap.isOpened():
+        ret, old_frame = cap.read()
+        old_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY)
+        oldTrackPoints = getFASTPoints(old_gray)
+    while cap.isOpened():
+        ret, frame = cap.read()
+        track_img = None
+        if ret:
+            new_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            # calculate optical flow
+            newTrackPoints, st, err = cv2.calcOpticalFlowPyrLK(old_gray, new_gray, oldTrackPoints,
+                                                               None, **lk_params)
+
+            # Select good points
+            if newTrackPoints is not None and len(newTrackPoints):
+                good_new = newTrackPoints[st==1]
+                good_old = oldTrackPoints[st==1]
+                # draw the tracks
+                for i,(new,old) in enumerate(zip(good_new,good_old)):
+                    a,b = new.ravel()
+                    c,d = old.ravel()
+                    mask = cv2.line(mask, (a,b),(c,d),color[i%len(color)].tolist(), 2) #(255,0,0), 2)
+                    frame = cv2.circle(frame,(a,b),2,color[i%len(color)].tolist(),-1)#(0,255,0),-1)
+                track_img = cv2.add(frame, mask)
+                #write tracked frame
+                # out.write(track_img)
+                # cv2.imshow('videoTracking '+detector, track_img)
+                # if cv2.waitKey(slow_motion_delay) & 0xFF == ord('q'):
+                #     break
+
+                # Now update the previous frame and previous points
+                old_gray = new_gray.copy()
+                oldTrackPoints = good_new.reshape(-1,1,2)
+        else:
+            break
+    return mask
+
+def crop_image(input_img):
+    sum_rows = np.sum(input_img, axis=0)
+    nonnull = np.nonzero(sum_rows)[0]
+    left = nonnull[0]
+    right = nonnull[len(nonnull)-1]
+    sum_cols = np.sum(input_img, axis=1)
+    nonnull = np.nonzero(sum_cols)[0]
+    low = nonnull[0]
+    high = nonnull[len(nonnull)-1]
+    return input_img[low:high,left:right]
+
+
+def normalize_img(mask_img):
+    print "$$$ Be good, my beach"
+    normalized_img = cv2.cvtColor(mask_img, cv2.COLOR_BGR2GRAY)
+    _,thresh_img = cv2.threshold(normalized_img, 0, 255, cv2.THRESH_BINARY)
+    kernel = np.ones((5,5),dtype=np.uint8)
+    dilated_img = cv2.dilate(thresh_img, kernel)
+    dilated_img = crop_image(dilated_img)
+    height, width = dilated_img.shape
+    dilated_img = cv2.resize(dilated_img, (800,1143))
+    # delta_y = (1143 - dilated_img.shape[0])/2
+    # delta_y = delta_y  if delta_y > 0 else 0
+    # delta_x = (808 - dilated_img.shape[1])/2
+    # delta_x = delta_x  if delta_x > 0 else 0
+    # dilated_img = cv2.copyMakeBorder(dilated_img,delta_y,delta_y,delta_x,delta_x,cv2.BORDER_CONSTANT,value=0)
+    return dilated_img
+
+
+def detectIt(video, letter):
+    cap = cv2.VideoCapture(video)
+    try:
+        #slow_motion_delay in milliseconds
+        slow_motion_delay = 80
+        print "$$$~ Brick Squad Monopoly security ~$$$"
+        mask_img = videoTracking(cap, slow_motion_delay, 'FAST')
+        print "$$$ U can't hide u can't run."
+        cap.release()
+        cv2.imshow('mask_img', mask_img)
+        normalized_img = normalize_img(mask_img)
+        print "$$$ Here we watch ya."
+        let_symbol = cv2.imread("symbol_{0}.jpg".format(letter))
+        let_symbol = cv2.cvtColor(let_symbol, cv2.COLOR_BGR2GRAY)
+        _, let_symbol = cv2.threshold(let_symbol, 0, 255, cv2.THRESH_BINARY_INV)
+        let_symbol = crop_image(let_symbol)
+        _,let_symbol = cv2.threshold(let_symbol, 0, 255, cv2.THRESH_BINARY_INV)
+        #Good size for us
+        let_symbol = cv2.resize(let_symbol,(800,1143))
+        # cv2.imshow('let_symbol', let_symbol)
+        # cv2.imshow('normalized_img', normalized_img)
+        result_img = cv2.bitwise_and(normalized_img, normalized_img, mask=let_symbol)
+        # cv2.imshow('result_img', result_img)
+        # cv2.waitKey(0)
+        # cv2.destroyAllWindows()
+        if np.sum(result_img) < 0.15 * 255 * 800 * 1143:
+            print "$$$ Br0! You are masta!"
+            return True
+        print "$$$ Waka Fl0cka doesn't like it! Get the float of the property!"
+        return False
+    except:
+        print "$$$ Get OpenCV 3 or die tryin'."
+        cap.release()
+        return False
+        
+
+if __name__ == "__main__":
+    #Test purposes
+    filename = "test_L.avi"
+    detectIt(filename, "L")

1NDVCLUB_TASK/create/server_program.py

@@ -0,0 +1,118 @@
+import socket, threading, sys, os
+from datetime import datetime
+from constants import *
+from time import sleep
+import gansta_eye
+
+class ClientThread(threading.Thread):
+    def __init__(self, client_socket, cleint_ip, client_port):
+        threading.Thread.__init__(self)
+        self.ip = cleint_ip
+        self.port = client_port
+        self.client_socket = client_socket
+        self.client_socket.settimeout(socket_timeout)
+        self.id = str(datetime.now()).replace(":", "-").replace(".", "-").replace(" ", "-")
+        self.dead = False
+        print "#::New thread started for ({0}, ({1}))".format(str(cleint_ip), str(client_port))
+    
+    def validate_video(self, video_file, letter):
+        print "#:: Let's check u..."
+        return gansta_eye.detectIt(video_file, letter)
+
+    def run(self):    
+        print "#{}::Listening for requests.".format(self.id)
+        target_string = "1NDVCLUB"
+        validated = 0
+        for letter in target_string:
+            print "#::Server is expecting", letter
+            letter_video = None
+            video_created = False
+            client_bytes = "CamStudio"
+            bytes_received = 0
+            print "#::Ready to receive..."
+            while len(client_bytes):
+                try:
+                    client_bytes = self.client_socket.recv(input_chunk_size)
+                    bytes_received += len(client_bytes)
+                    if bytes_received > max_size_bytes:
+                        raise Exception("#::Too long video. Ain't u a cop?")
+                    if client_bytes and client_bytes != "JustALilByte":
+                        if not video_created: #lazy here
+                            letter_video = open("video_{0}_{1}.avi".format(letter, self.id), 'wb')
+                            video_created = True
+                        letter_video.write(client_bytes)
+                        letter_video.flush()
+                        print "-",
+                    else:
+                        print
+                        if video_created:
+                            print "#::Shiip, it seems your video is over."
+                            letter_video.flush()
+                            letter_video.close()
+                            print "#::video_{0}_{1} is saved.".format(letter, self.id)
+                        else:
+                            print "#::Nothin' from u nothin' from me, baby."
+                        break
+                except Exception as some_error:
+                        print "#{0}::ERROR({1})".format(self.id, str(some_error))
+                        break
+            if letter_video is not None:
+                filename = "video_{0}_{1}.avi".format(letter, self.id)
+                if self.validate_video(filename, letter):
+                    print "#::Cool, br0!"
+                    validated += 1
+                    os.remove(filename)
+                    print "#::I have removed all da evidence, my little homie. Relax for a while and keep pushin'!"
+                    sleep(pause)
+                else:
+                    print "#::U've made a mistake. VIP zone ain't for u."
+                    os.remove(filename)
+                    print "#::I do not need your video now, d0ll. I have thrown it away."
+                    break
+            else:
+                print "#::No video - no deal. Get out from our hood."
+                break
+        if validated == len(target_string):
+            print "#::Now you are in our club, man. Take your gun."
+            try:
+                flag_file = open(".\\test_folder\\flag.txt", "r")
+                flag = flag_file.readline()
+                flag_file.close()
+                print flag
+                self.client_socket.send(flag)
+                print "#::Use it as a real gangsta."
+            except Exception as error:
+                print "#::Worse for you, baby.", error
+        else:
+            print "See ya."
+        self.client_socket.close()
+        self.dead = True
+        return
+
+def main():
+    out = sys.stdout
+    host = hosts
+    port = server_port
+    server_socket = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
+    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    server_socket.bind((host, port))
+    client_threads = []
+    server_socket.listen(max_users)
+    while True:
+        try:
+            print "\n~~~Listening for incoming connections...(online:" + str(len(client_threads))+ ")\n"
+            (new_client_socket, (client_ip, client_port)) = server_socket.accept()
+            client_thread = ClientThread(new_client_socket, client_ip, client_port)
+            client_thread.start()
+            client_threads.append(client_thread)
+            for thread in client_threads:
+                if thread.dead:
+                    client_threads.remove(thread)
+        except:
+            print "~~~About to break..."
+            break  
+    server_socket.close()
+    sys.stdout = out
+    print "~~~PROGRAM OVER"
+        
+main()

1NDVCLUB_TASK/create/symbol_1.jpg

@@ -0,0 +1,5 @@
+���:
+������� ���� ������� ���� ������
+��� �������
+��� ����������
+��������� ��������� �������

1NDVCLUB_TASK/create/symbol_B.jpg

@@ -0,0 +1,16 @@
+from constants import *
+import socket               # Import socket module
+
+s = socket.socket()         # Create a socket object
+server_host = socket.gethostname() # Get local machine name
+
+s.connect((server_host, server_port))
+video = open('test_1.avi','r')
+chunk = "trvpLord" if video else ""
+while chunk:
+    chunk = video.read(1024)
+    s.send(chunk)
+    print 'Sent some part...'
+video.close()
+print "Done Sending"
+s.close   

1NDVCLUB_TASK/create/symbol_C.jpg

@@ -0,0 +1 @@
+1234512339806543

1NDVCLUB_TASK/create/symbol_D.jpg

@@ -0,0 +1,3 @@
+����� - �������
+��� �� ��� ������ �� �������� ���� �����
+� test_folder ��������� ����

1NDVCLUB_TASK/create/symbol_L.jpg

@@ -0,0 +1,6 @@
+author: 24power & b3ardbear
+category:?
+description:|
+Brick Squuad Monopoly устраивает Trap вечеринку для рэпера Waka Flacka в клубе.
+Вы являетесь агентом спецслужб. По предварительным данным, на ней будет проходить огромная подпольная сделка по закупке оружия в VIP зоне.
+В целях безопасности Waka Flacka закодил новую систему доступа. Вам необходимо пробраться в клуб и разоблачить коварные планы банды.