Merge branch 'master' into antek

c5b39ce9 · Antek Grzanka · de6236c1 · 1528042f · c5b39ce9 · c5b39ce9
Commit c5b39ce9 authored Apr 01, 2016 by Antek Grzanka
35 changed files
--- a/Gruntfile.js
+++ b/Gruntfile.js
@@ -26,7 +26,7 @@ module.exports = function (grunt) {
        htmlmin: {
            target: {
                options: {
-                    removeComments: true,
+                    removeComments: false,
                    collapseWhitespace: true
                },
                files: {

--- a/flags/PHP_1/Hkuas7VKk7/flag.txt
+++ b/flags/PHP_1/Hkuas7VKk7/flag.txt
+Już blisko ...
+<?php
+//AGH_{FLAGA}
--- a/flags/PHP_1/Hkuas7VKk7/site.txt
+++ b/flags/PHP_1/Hkuas7VKk7/site.txt
+1
--- a/flags/PHP_1/Hkuas7VKk7/site1.txt
+++ b/flags/PHP_1/Hkuas7VKk7/site1.txt
+1
--- a/flags/PHP_1/Hkuas7VKk7/site2.txt
+++ b/flags/PHP_1/Hkuas7VKk7/site2.txt
+2
--- a/flags/PHP_1/Hkuas7VKk7/site3.txt
+++ b/flags/PHP_1/Hkuas7VKk7/site3.txt
+3
--- a/flags/PHP_1/Hkuas7VKk7/site4.txt
+++ b/flags/PHP_1/Hkuas7VKk7/site4.txt
+4
--- a/flags/PHP_1/README.md
+++ b/flags/PHP_1/README.md
+php.ini:
+allow_url_include should be enabled
--- a/flags/PHP_1/index.php
+++ b/flags/PHP_1/index.php
+<?php
+ini_set('display_errors', 1);
+ini_set('display_startup_errors', 1);
+error_reporting(E_ALL);
+$flag = 'AGH_{FLAGA}';
+$site = filter_input(INPUT_GET, 'site');
+if(!$site){
+    $site='site';
+}
+$header = filter_input(INPUT_SERVER, 'HTTP_KYN');
+if($header !== 'test'){
+    echo "Nie masz tutaj wstępu...";
+    exit;
+}
+?>
+Witaj, masz tu parę linków :)<br />
+<a href="?site=site1">Strona 1</a> | 
+<a href="?site=site2">Strona 2</a> | 
+<a href="?site=site3">Strona 3</a> | 
+<a href="?site=site4">Strona 4</a> | 
+<br />
+<pre>
+<?php
+header("FLAG: {$flag}");
+chdir('Hkuas7VKk7');
+include_once "{$site}.txt";
+echo "<pre>";
+?>
+</pre>
\ No newline at end of file
--- a/flags/README.md
+++ b/flags/README.md
+taiga_46:
+  - depend
+  - Kodowania base64, rot13, rot47 w jednym skrypcie
+taiga_48:
+  - supereasy
+  - Zwykłe przekierowania w JS
+taiga_62:
+  - easy
+  - checksum (bruteforce)
+php_1:
+  - medium
+  - niestandardowy naglowek + remote file inclusion
--- a/flags/ecb.py
+++ b/flags/ecb.py
+#!/usr/bin/python
+# coding=utf-8
+flag = "AGH_{FLAGA}"
+text = "To jest przykładowy tekst!"
+flag_int = [ord(letter) for letter in flag]
+text_int = [ord(letter) for letter in text]
+for i in range(len(text_int) % len(flag_int)):
+  text_int.append(0)
+flag_int = len(text_int)/len(flag_int)*flag_int
+result = [chr(i^j) for i,j in zip(flag_int, text_int)]
+print "".join(result)
--- a/flags/substitution.py
+++ b/flags/substitution.py
+#!/usr/bin/python
+from random import shuffle
+alphabet = [i for i in 'QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm']
+keys = alphabet[:]
+shuffle(keys)
+cb = dict(zip(keys, alphabet))
+message = "Ahjo, tym razem masz do rozszyfrowania prosty szyfr podstawieniowy, elo, a flaga to AGH{PodstawSieANieDajSie}"
+result = ""
+for letter in message:
+  if letter in alphabet:
+    result += cb[letter]
+  else:
+    result += letter
+print result
--- a/flags/taiga_46.py
+++ b/flags/taiga_46.py
+from sys import argv
+from _codecs import encode
+from base64 import b64encode, b64decode
+import sys
+def a(string):
+    return encode(string, 'rot_13')
+def c(s):
+    x = []
+    for i in xrange(len(s)):
+        j = ord(s[i])
+        if j >= 33 and j <= 126:
+            x.append(chr(33 + ((j + 14) % 94)))
+        else:
+            x.append(s[i])
+    return ''.join(x)
+def b(string):
+    return b64encode(string)
+def d(string):
+    return b64decode(string)
+if len(argv) < 3:
+    print """Usage:
+python taiga_46.py <type> <text>
+    type:
+        - b     base64
+        - d     base64_decode (for testing)
+        - a     rot13
+        - c     rot47
+for example: python taiga46.py bbac test return rot47(rot13(base64(base64("test"))))
+"""
+    exit(0)
+text = " ".join(argv[2:])
+result = text
+for letter in argv[1]:
+    if letter == "a":
+        result = a(result)
+    elif letter == "b":
+        result = b(result)
+    elif letter == "c":
+        result = c(result)
+    elif letter == "d":
+        result = d(result)
+print result
--- a/flags/taiga_48.html
+++ b/flags/taiga_48.html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Close all</title>
+    <script>
+        document.location.href="//google.pl";
+        flag = "AGH_{JuStGoogleIt}"
+    </script>
+</head>
+<body>
+</body>
+</html>
--- a/flags/taiga_62/copy.txt
+++ b/flags/taiga_62/copy.txt
+AGH_{8736510-132984639-76495612-15618703-7382}
--- a/flags/taiga_62/description.txt
+++ b/flags/taiga_62/description.txt
+Otrzymałeś wiadomość message.txt, niestety część wiadomosci jest nieczytelna i została oznaczona znakami '@'.
+Na szczęscie innym kanałem komunikacji otrzymałeś hash md5 wiadomości.
--- a/flags/taiga_62/generuj.py
+++ b/flags/taiga_62/generuj.py
+#!/usr/bin/python
+letters = [
+'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'
+]
+length = 4
+list = letters
+tmp_list = []
+def add_letter(list):
+  result = []
+  for text in list:
+    for letter in letters:
+      result.append(text+letter)
+  return result
+for i in range(length - 1):
+  list = add_letter(list);
+with open("slownik.txt", "wb") as f:
+  for element in list:
+    f.write(element+" ")
--- a/flags/taiga_62/md5sum.txt
+++ b/flags/taiga_62/md5sum.txt
+caaa589b1d9f8ff4fcd92ed575270553  message.txt
--- a/flags/taiga_62/message.txt
+++ b/flags/taiga_62/message.txt
+AGH_{8736510-132984639-76495612-15618703-@@@@}
--- a/flags/taiga_62/solve.sh
+++ b/flags/taiga_62/solve.sh
+#!/bin/bash
+python generuj.py
+cp message.txt message2.txt
+for i in `cat slownik.txt`;
+do cat message2.txt | replace '@@@@' $i > message.txt;
+md5sum -c md5sum.txt 2> /dev/null 1>/dev/null && cat message.txt;
+done;
--- a/service/src/main/java/com/telephoners/krakyournet/ctf/beans/tasks/Task.java
+++ b/service/src/main/java/com/telephoners/krakyournet/ctf/beans/tasks/Task.java
@@ -34,7 +34,7 @@ public abstract class Task
    {
    }
-    public abstract String getTextForUser(User user) throws IOException;
+    public abstract String getTextForUser(User user, String path) throws IOException;
    public String getName()
    {

--- a/service/src/main/java/com/telephoners/krakyournet/ctf/beans/tasks/TextTask.java
+++ b/service/src/main/java/com/telephoners/krakyournet/ctf/beans/tasks/TextTask.java
@@ -23,7 +23,7 @@ public class TextTask extends Task
    {
    }
-    public String getTextForUser(User user)
+    public String getTextForUser(User user, String path)
    {
        return text;
    }

--- a/service/src/main/java/com/telephoners/krakyournet/ctf/beans/tasks/WebTask.java
+++ b/service/src/main/java/com/telephoners/krakyournet/ctf/beans/tasks/WebTask.java
 package com.telephoners.krakyournet.ctf.beans.tasks;
 import com.fasterxml.jackson.annotation.JsonInclude;
+import com.google.common.base.Joiner;
 import com.telephoners.krakyournet.ctf.beans.Flag;
 import com.telephoners.krakyournet.ctf.beans.User;
 import com.telephoners.krakyournet.ctf.helpers.StreamUtils;
@@ -20,6 +21,7 @@ import java.util.List;
 public class WebTask extends Task
 {
    private String url;
+    private final Joiner urlJoiner = Joiner.on("/");
    public WebTask(String name, int level, List<Flag> flags, String url)
    {
@@ -31,9 +33,10 @@ public class WebTask extends Task
    {
    }
-    public String getTextForUser(User user) throws IOException
+    public String getTextForUser(User user, String path) throws IOException
    {
-        return StreamUtils.readStream(proxyRequest(getUrl(), user));
+        String url = urlJoiner.join(getUrl(), path);
+        return StreamUtils.readStream(proxyRequest(url, user));
    }
    public String getUrl()

--- a/service/src/main/java/com/telephoners/krakyournet/ctf/resources/ProxyResource.java
+++ b/service/src/main/java/com/telephoners/krakyournet/ctf/resources/ProxyResource.java
-package com.telephoners.krakyournet.ctf.resources;
-import com.telephoners.krakyournet.ctf.beans.User;
-import io.dropwizard.auth.Auth;
-import org.apache.http.HttpEntity;
-import org.apache.http.client.methods.CloseableHttpResponse;
-import org.apache.http.client.methods.HttpGet;
-import org.apache.http.impl.client.CloseableHttpClient;
-import org.apache.http.impl.client.HttpClients;
-import javax.ws.rs.GET;
-import javax.ws.rs.Path;
-import javax.ws.rs.PathParam;
-import javax.ws.rs.Produces;
-import javax.ws.rs.core.MediaType;
-import java.io.IOException;
-import java.io.InputStream;
-@Path(value = "/proxy/task")
-@Produces(MediaType.APPLICATION_JSON)
-public class ProxyResource {
-    @GET
-    @Path("{task_id}/{path: .*}")
-    @Produces("text/html; charset=UTF-8")
-    public InputStream task1(@Auth User user,
-                             final @PathParam("task_id") String taskId,
-                             final @PathParam("path") String path) throws IOException {
-        CloseableHttpClient httpClient = HttpClients.createDefault();
-        HttpGet httpget = new HttpGet("http://192.168.56.101/");
-        httpget.setHeader("CTF-User", user.getName());
-        CloseableHttpResponse execute = httpClient.execute(httpget);
-        HttpEntity entity = execute.getEntity();
-        return entity.getContent();
-    }
-}
--- a/service/src/main/java/com/telephoners/krakyournet/ctf/resources/TaskResource.java
+++ b/service/src/main/java/com/telephoners/krakyournet/ctf/resources/TaskResource.java
 package com.telephoners.krakyournet.ctf.resources;
+import com.google.common.base.Joiner;
 import com.telephoners.krakyournet.ctf.beans.User;
 import com.telephoners.krakyournet.ctf.beans.tasks.Task;
 import com.telephoners.krakyournet.ctf.repositories.TasksRepository;
@@ -25,12 +26,14 @@ public class TaskResource
        this.tasksRepository = tasksRepository;
    }
-    @Path("{task_level}")
+    @Path("{task_level}/{path: .*}")
    @GET
    public Response getTask(@Auth User user,
-                            final @PathParam("task_level") int taskLevel) throws IOException
+                            final @PathParam("task_level") int taskLevel,
+                            final @PathParam("path") String path) throws IOException
    {
        Task task = tasksRepository.getByLevel(taskLevel);
-        return Response.ok().entity(task.getTextForUser(user)).build();
+        //todo: refactor, path not necessary in textTasks
+        return Response.ok().entity(task.getTextForUser(user, path)).build();
    }
 }
--- a/service/src/main/resources/assets/index.html
+++ b/service/src/main/resources/assets/index.html
@@ -10,6 +10,16 @@
    <link rel="stylesheet" href="/statics/css/main.min.css">
 </head>
+<div id="background"></div>
+<!--
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
+iMVZxVGtOV1JteHlZVVZPV0dKSFVsbFVWV2h2Vm1zeFYyTkZhRnBoTW1oTVdWVmFTMVpyTlZkV2JGcHBWa1ZhVlZkc1dtRmhNazUwVW10YVVGWXlhRlJaYTJoRFRsWmtWVkZzVGxOTlZuQjZWakZvZDJGR1NrWk9WbWhhVmpOU1NGUnJXbHBrTVdSeldrWmtWMkV4Y0RaV01uUnJZakpHUmsxV2JGSldSWEJZV1d4U1IwMHhWbkZUYTFwc1VtNUNTRmxWV2s5aFJURnpVMnh3V0ZZemFISlVhMXBoVWpKS1NWVnRkRk5YUmtwYVYxZDBZV013TlVkYVJsWlZZbGhTY0ZWdGRIZGxiRnAwWTBaT1YwMVdjREJaVldoaFYyeGFjMk5HUWxaaVZFWlFWV3BLUzFJeVRraGlSbWhUVmtWVmQxWnRNVFJXTVd4WFYxaHNWbUV5YUZoWlZFbzBWbXhzV1dOSVRsaFNiWGg1Vm0wMWExZEdTbk5qU0hCWVlURktWRmxWVlhoV01rcEZWR3hXVjJKWGFFMVhWbVEwVXpGa1NGSnJhRk5pUmxwWVZtcEdTMDFzWkhOYVJGSllZbFphV1ZaR2FIZGhSa3B5VGxVNVYySkdTbGhVYkZwaFl6RndSVlZ0YUU1V2EzQTJWbFJHYjJJeFdraFNXR3hvVW0xNFlWbFVSbmROTVd0NVpVWmthbFpyY0hsWk1HUTBWVEpLU1ZGWWFGZGhNazQwVldwR1ZtVldUbk5hUmxKcFVqTm9XbFp0TlhkU2JWRjRWbXBhVTJKSFVuRlVWbVJUVFZaYVNHVklaRlZoZWtZd1dWVm9kMWRHV25SaFJFNVdZV3RhY2xWcVJtdFhWMHBHVDFaa1YxSXphRzlXYlRCNFpXc3hWMU5ZYUZaaWF6Vm9WVzV3YzFkR2JITldibVJYWWtaYU1GcFZXazlYUjBZMlVtdG9XazFIVW5aV01uTjRWakpPUjFGdFJsTldiRlY0Vm0xd1IxVXlVa2hUYTJSVllsZDRiMVJWWkRCTk1WcDBUVlJTYUdKV1JqVldiWFJyVmtaa1NHRkhhRlpOUmxWNFZqRmFjMlJIVmtaa1IzQk9WbXh2ZDFaR1dsTlZNV1JIVTI1T2FsTkhhRmhWYm5CQ1RWWnNWVk5yZEZOTmF6VktXVEJhYjJGRk1WZGpSemxZVmpOU2FGZFdaRTVsUm5CSlVteEthVk5GU2xsV2JUQXhVVEpKZUZwR1pGZGlXRkpVV1d4YVlWWXhVWGhXYms1YVZtdHdNRlpYTURWV1ZscHpWMnBPVmsxV2NHRmFWVnByWkVkU1IxWnJOVmRpV0dOM1ZtMHdkMDFXV1hoWGJsSlVZVEZ3VlZsclpHOVpWbXh5VjI1a1ZWSnNjRmRXTWpGSFlURktWVkpyV2xaaVdHaE1Wa2Q0WVdSSFVqWlJiR1JvWVRJNGQxZFhjRWRWTWsxNFdraEtZVkpzU25CVmJUVkRWakZhZEUxVVVtdE5iRnA2VmxkNFYxVXlTa1pPVm1oVlZqTlNhRlZxUm5kU2JHUjBaRVpXYVZaV1dUQlhWRUpUV1ZaWmVGZHJXbWxsYTBwaFdWZDBZV0ZHV25GU2JYUllWakExU0ZVeU1YTlZNREYwWVVad1YyRXhjRmhYVm1SU1pWWktjbHBHYUZoU01VcFpWbXBDYTJJeFpFZGlTRXBoVW1zMVQxVnROVU5XTVZsNVRWUkNWMVl3Y0VoWk1GSkhWbXhaZWxWcVRsZGhhM0JJV1RJeFNtVnNjRWRoUm1ScFZtdHdWVll5ZUdGWlZrMTVWRzVPWVZORmNGQldiVEZ2VmtaYWNsZHRSbGROVm13MFZqSXhNRlJzU1hoU2FsSllZVEZhY2xsV1drOVNiVTVIWWtad2FWSnNjRzlYVjNCSFZqSlNTRlpyYkdGU00yaFVXV3RhV2sxV1pGVlVibVJUVFd0YVdGVXlOVXRoYkVwR1YyeGtWMkZyTlZSVVZFWmhZMVpLY21SRk9XbFNXRUkxVjFaV1lXRXhXWGhUYkd4U1lYcEdXRmxYZEV0amJGWnhVbXR3YkZack5YbFhhMlJ2VlRKS1YxTnVaRmRXTTJoMlZWUkdUMk14WkZsaVIzUlRUVEJLZWxaWE1UUmpNRFZIVmxob2FGSjZiR0ZXYlhNeFVqRlNjMWR0T1ZoaVZWWTBXVEJXTkZkdFJuSlhibkJhVFc1b2FGcEdXbmRTTWtaSFdrZHNWRkpWY0V0V2JURjNVMjFXUjFOWWJGTmlhM0JQVm14YVlWZEdiSEphUnpsWVVteEtXVmt3V210V01VcHpZMFZhVm1KVVJraFdNRnBoWXpGa2RXTkdhR2hOV0VKWlZtMXdRbVF5VmtkVWJsSlFWbTFvY0ZWcVJrWmtNVnAwVFVob1YwMVhVa2hXTWpWTFlVWktjbE5zYUZwaVJuQk1WbFZhYTFZeFZuSlBWa3BwVm14d1NWWnFTalJoTVd4WFUydGFWR0pIVWxaV2JYaDNUVEZaZUZkc1pHcE5hMXBKVkRGa2IyRldTbGxSV0dSWVZteGFhRmRXV210a1JrNXlZVWRvVkZKdVFsbFdWM2hoWkRKV2MxVnVVbXhTVkd4eFdWaHdjMWRHV2xobFJUbFZZa1p3TVZWWGRIZFdNa3BaVlc1S1lWWXpUalJXYWtaaFYxZEdSMVZ0YkdobGJGbzBWbXhrTkdJeFJYaGFSV1JwVTBVMVYxbFVTbE5VTVZKWFYyeHdUbUpHVmpWYVZXUXdZVWRLVmxkVVNsZGlXR2gyVmpCa1JtVkhUa2xYYkdST1VtNUNURmRzVm1GVU1rMTRVbTVPWVZJeWVGbFZha3B2VGxaYWRHVkdUbFJOVmtZMFZqRm9iMWRIU25OWGJHUmFZa2RvVkZacldscGtNV1J5WkVab2FWSnVRWGRXUmxwVFZUSkZkMDFWVmxOaE1taGhWRlZhZDJGR1duRlRhMlJxWWtVMWVsbFZXbmRoUlRGWFlqTndXR0pIVVRCV01qRlhWMFphY21GR1RtbFNNVXAzVm0xNGIxRXhXWGhYYkdoc1VucHNiMVJXWkZObGJGbDRZVWhrVjFZd1ducFZNbmh2VmxaYVYyTkVUbGROUm5BelZXcEdkMUp0VWtkVWF6VllVbFZ3UzFZeFpEQlpWMGw0Vmxoa1RsZEdTbTlWYlhNeFYwWnNXR1JIUm1oU2JWSllWakkxVDFkR1NuSmpSbkJhVmxad1ZGbFdaRWRPYkZweldrWm9WMlZyV1RKV1JscGhWbTFXU0ZOcmJGUmlWVnBVV1Zod1YyVkdXbGhOVkZKcVRVUkNORmRyYUV0WGJWWnpWMnhvVlZac2NETmFWM2h5WkRGV2NsUnNhR2hsYTFwSlZtcEpNVk14V1hsVGEyUlhZV3hLV0Zsc1VrZFVSbFp6VjJ4a2FrMXJOVWRVYkZwUFlWWk9SbEpZYkZkaVZFSTBWRlZrUm1WR1VsbGhSbFpvVFcxb1ZWZFdVa3RPUmxWNFlraEtZVkpyTlhGVmJYaGhUVVpTYzFacmRHbFNNSEJKVmxjMWMxZEhSWGhUYkZKYVZsWldORll3V2xkamJVcEhXa1prVGsxVmNEVldiWEJEWVRGSmQwNVlUbGhpYXpWdlZXMDFRMWRHVm5OWmVsWlBZa1p3U0ZadE1VZFhiRmwzVFZSU1dtRXhTbWhXVkVwTFVqRmtjazlXWkdoaGVsWXlWbXBHWVZsV1dsZFVia1pXWWxkNFQxWnROVUprTVZwVlUycENhVTFyY0VoVk1XaHJWMGRLVmxkdFJsZGhNVnBvVkZSR2MxWnNaSE5qUjNST1ZqRktObFpyWTNoa01rWlhVMWhvVkZkSFVsaFdibkJEVGtad1JWSnNUbXRTYTNCYVdWVmtkMVV4WkVaVGJHeFhWak5TV0ZkV1pFZFNNa3BIVm14U2FFMXNTbGxXUmxwclZUSldjMXBJU2xoaVZHeFlWRlpXZDFZeGEzZFhibVJYVFd0d1dsWlhlRzlXYlZaeVYyMW9WbUZyV25KWk1uaGhZekZTZEdKR1pGZGlhMGt3Vm1wR1lXSXlVWGhUV0doWVYwZG9jRlZ0ZUhkWFZteHpWbTFHYVUxV2NEQmFSV2hQVkRGYWRHVkdaRmROYWtFeFZtcEJlRlp0VGtsalJuQk9VakZLTWxZeFdtRlRNVXB6V2toT2FGSnNjRzlaVkU1RFZWWmFXRTFVVW1oTmJFcElWVEkxVDFaWFNsaGxSbWhhVmtVMVJGWXdXbUZrUjFaSVpFZDBUbFpXV1RGV2JGcHZZakZhV0ZKWWJGWmlWMmhYVkZWYVlVMHhXWGhYYms1cVRXdGFTRlpIZUd0VWJGcHlZMFp3V0dFeFduWlpWRVpoVTBaT2NscEdhR2xTTTJob1YyeGtlazFYVW5OWGJrWlNWMGRvY1Zsc1ZURlRSbXQzVjIxR1YwMUVRalJWYkdoclZqSktXV0ZJU2xaaVZFWllWVEJhVTJOdFJrZFViV3hYVm01Q1dsWXhaREJpTVVWNFZXeGtXR0pyV2xSWmJHaFRWbFpTVjFadVRrOVNiSEF3Vkd4Vk5XRkdTbkpqU0d4VllrWlZNVll5TVV0VFJsWjFWMnhrVG1KdGFHOVhWRVpoVXpKU1NGUnJhR3hTYXpWWVZXMTRkMU5zV25Sa1IwWnBUV3RzTkZkclZtOVdSMFY1WVVaa1dtSllVa3hXYWtaVFZteGtkRkpyTlU1V00yaFlWbXBLTkdFeVJuUlRhMmhXWW0xNGFGVnNaRk5sYkZwSVpVZEdhazFyYkRaWGExcHZZVlpLYzJOSWJGZFdNMEpNVlhwR1NtVkdjRWxXYkZacFZqTm9WVlpYTVRSa01WbDRXa1pvYTFJelVsZFpiRnBIVGtaWmVHRkhkRmhTTUZZMlZsYzFSMWR0U2tkV1dHaFdUVzVvZVZwRVJtdGtSa3B6Vm0xc1YxZEZSak5XTVZwWFZURk5lRmRZYkZOaWEzQlZXVzEwZDFZeGJITlZhMlJZVW14V00xWXllRTloYlVwSlVXdG9WazFxUm5wV1ZFRjRWbTFPUlZSc1pHbFhSVXBGVjFaU1MxTnRWa2RXYms1aFVqQmFWRmxzYUc5bFJscFlaVWM1VmsxV2NIcFdWM2hyVmpGYVJsZHNiRmRpV0doWVZHeGFkMUpzY0VWUmJHaHBVbTVDTlZkVVFtRlpWbGw1VTJ4V1YyRXhTbGhVVnpWdlkyeFZlRmRyWkdwaVJscDZWbTB4YjFSc1pFWlRibHBYVFc1U1dGbFVSbHBsUms1WllVWmFhV0Y2VmxoWFZtaDNWakZrUjFkdVNsZGlSbkJ5VkZaYWQwMUdhM2RXYlhSb1ZsUkdlVmxyVWxOWGJVVjRZMGhLVjJKSFVrZGFWV1JQVTFaS2MxZHRhR2hOTUVsNVZtMHhkMUl5VFhsVVdHaFhZbXR3YUZWdE1WTldSbXh5V2tST2JHSkdjSGhWTW5CVFZsVXhWMkpFVWxkTmFsWk1Wa1JHWVZKc1RuTlhiRlpYWWtoQmVsZFdWbUZaVjA1WFZHNUthMUpzU2xoWlZFWjNUa1phY1ZOcVVtaE5hMXBZVlRGb2IxVXlSbkpPVm14WFlsaG9URlV3V25OV1ZrNXlUbGQ0VTJKclNrbFhWM1JyWWpGVmVWTnJXbXBUUm5CWVZXMHhVazFHVmpaU2JIQnNVbTFTZVZkcldtOWhWbHBYWTBoc1YxSnNjSEpXVkVaUFVqRmtXV0pGT1ZkV01VcFpWbGR3UTFZd05YTlhiR2hzVW0xU1dGbHNWbmRYYkd4V1drYzVXbFpzYkRaWlZXaDNWakpLV1dGSVNscGxhMW96VldwR2QxSnJOVmRhUm1oVFZsaENZVlp0Y0VkVk1VVjRWMjVTVjJFeVVsbFdNR1J2VjFac1ZWSnVaRmhXYlhoNlYydGpOVmRHV25OalJFSlZWbXh3VUZacVJrdGpNVnB4Vkd4a1RtSnRhRkZYVm1ONFV6Rk9SMVp1UmxKaVZWcFVWbTAxUTFWV1pGZFhiVVpVVFZkU1dGVnROVTlWTWtwSVZXczVWMkpVVmtSVVYzaHJZMnhXY2xwR1VrNWhlbFkxVmtaYVlWbFdiRmRUV0dSWVlrWktZVmxVUm5kTk1WcHlWMjEwV0ZJeFNrbGFSVnBoVkcxRmVXUjZRbGRpUjFFd1dXcEtSbVZHVGxsYVJtaHBVak5vV0ZkWGVHOWlNV1JIVlc1T1dHSkZOWEZVVmxwM1ZteGFkR1ZIT1ZaTmExWTFXa1JPZDFkR1drWlRibHBhWld0YWFGa3ljM2hYVmxwMFlVWlNVMWRGU2xwV2ExcHJaREZKZUZWclpGZFhSMUpvVld4a1UxWkdVbGRYYlVac1lrWndNRnBWWkRCV2F6RlhZMFJHVmxaNlFURldha0Y0WkZkR1NHRkdjRmRTVm5Cb1YyeFdZVlV5VG5SU2EyUllZbGRvVDFsclZuZE5iRnB6V1ROb2JHRjZSbGhXVm1odlYwZEtjazVYT1ZaaVJsVjRWbXhhVTFZeFpIVmFSM2hYWWtoQ1dsZHJWbXROUm1SSVUydGthbE5IZUZaV2JYaExWa1phY1ZKdFJrOWlSbkI2VlZkNGExUnNTWGhUYXpGWVZrVnNORlpFUmtwbFZrNXlXa2RHVTAxdGFGQldiVEF4VVRGU2MxZHVVbXBTVlRWaFZtcEJlRTVHWkhKV2JUbFhZbFZXTlZwVlduTlhiR1JKVVd4b1YyRXhjSHBaTWpGSFVteFNjazlXVG1sVFJVcGhWbXRhWVZVeFZYbFNhMXBPVjBWd1dGbFhlRXRXTVZKWVkwWmtWVkpzY0VaVmJURXdWa1phY2xkdWNGcFdWbkJZVm1wS1YyTXhaSEZUYkdob1RXeEZkMWRZY0VkWGJWWkhZMFZzVkdKWVVsUlVWRUpMVlVaa1YyRklaRmROVlRWNlYydGFhMVl5U2xaWGJrSlZWbXh3ZWxSc1dsWmxWMUpJVW0xb2FWSllRbHBYYkZaaFlqRmFWMWR1VG1wU1JUVllXVmQwWVUweFduUmxTR1JUWVhwV1dWcFZXazloVms1R1VtcFNWMkpZVW5GYVZXUktaVVphV1ZwRk5WUlNNMmgyVmxjeE5GbFdaRmRYYmtaVllsUnNiMVZ0ZUZwTmJGVjVaVWQwVjAxRVJsbFdWelYzVjJ4YVdGVlVRbGRXUlhCSVZHMTRZV015U2tkYVJrNXBVMFZLTlZadGVGTlNNa1Y0VTFoc1UxZElRbWhWYlRGVFkwWmFjMWR1WkZoaVJuQlpXVEJXVDJFd01WZGpTSEJhWVRKb1RGWXdaRXRYVmxaellVWmthVmRIWjNwV2FrSmhWbTFXV0ZWcmFGQldiVkp2V2xkMFdtVkdaRmRXYlVacFRWWnNNMVJXVm05V2JVcEhVMnhrVlZac2NETlVWRVpYWTFaS2RWcEdUbWhsYkZwYVYxWldWazFXVW5OVGJHeFNZVE5vV0Zsc2FFTlRSbHBWVW10YWJGSXdjRWhYYTFwclYwWkplV0ZHY0ZoV2VrWTJWRlphYTFZeVNrZFdiRTVwWWxaS1dsWnRNSGhPUlRGSFkwVmFhRkl6VWxsWmExcDNaV3hWZVdWSVRsZFdNSEJJVm14U1IxWXhTa1pYYTNoYVpXdHdVRlZzV2tka1JrcHpXa1prVG1KWFp6RldiVEUwVlRGR2RGWnJhRlZpYXpWb1ZUQldkMk5HVm5ST1ZVNXBUVlpLV1ZwVlZqQlVNa3BJVld4b1YySllhR2haYTFwTFkyczFWMkZHV21sV1JscFJWMVprTkZNeVVrZFdibFpTWWtkU1QxVnROVU5VVm1SWVkwVmtXbFl4U2tsV1IzUmhZVEZLY2s1WVFsZGlXR2d6VlRGYVlXTldUbkZWYlhCT1lURndTVlpVU1RGVk1rWkhVMnBhYVZKc2NGaFpWM014Wkd4YVJsZHVaRlJTTVZwSlZXMTRUMVJzV25OalJGWllZVEZhVjFSc1dsWmtNREZXVm14T1YxSlZjRmxYVjNoVFVXMVdSMVp1UmxOaVZWcFpWVzF6TVdWV1dYbGplbFpZVW10d1dGa3daRzlYUmxwelUydG9ZVkpGY0VoVmFrcFBVakpHU0dWR1RrNVNia0poVm14a2QxSXhiRmRVYkdScVVsWndXVmxzVW5OV01WSllaRWhrVkdKR1dsaFpWV1F3VjBaSmQyTkZhRmROYWxab1ZqSXhWMk5zWkhSU2JVWlRVbFZaTUZacVJtRlRNazE0Vlc1T2FGSnJOVTlXYkdoRFdWWmFjVkp0ZEU5U01HdzBWbFpvYTFReFdsaFZiR2hhWWxoTmVGWXhXbk5XVms1elZHMXdWMkpJUVhkWGJGWnZZVEpLU0ZOcmFGWmliWGhZVkZkd1JtUXhiRlpYYlVacVlsVTFTRmt3V21GV01EQjNUVlJTVjJKWVFreFZla1poVmpGT2RWSnNWbWxTYmtKNlYxWlNSMlF4VWtkYVNFNVlZbFZhVjFSWGVFdFhSbHBZVGxaT1ZrMXJjRWhWTW5oVFYyMUZlV0ZGVWxkaGExcGhXbFZhZDFKV1ZuTmFSVFZYVFRKb1dsWnRjRXROUjBWNFYxaHNWR0pyY0ZCV2JURTBXVlpzYzFWclpGZFNiR3d6VmpKNGEyRXhTbFZTYkdoWFVucEZNRmxXV2t0a1ZrWlpXa1prVTJKSVFsbFhWbEpIWVRGT1IxUnVTbUZTTTBKVVZXeFdkMWRXV25SalJUbHBUV3hLZWxZeGFITmhhekI1WVVaU1ZWWnRVbFJVVlZwelZteGtkR1JHWkU1V2JrRjRWbFpqZDA1V1pFaFNXR2hZWWxkb1dGbFhkSGRXUmxweFVtdDBhMVpzU25wWlZXUnZZa2RLUjJOR1dsZE5WMUYzV1dwR1JtVkdWblZVYkdocFlUTkNhRlpHVWt0aU1WWkhWbTVTVGxaR1NsbFdiWGgzVTBac1ZsbDZWbGROUkVaNVdUQm9jMWRyTVVkalIyaFhUV3BHUjFwV1dsZGpNVlp6V2taT1UxWnVRblpXTVdoM1VqRlplVlJ1VG1GVFJYQlFWbTF6TVdOR1ZYZFdhMlJPVFZac05WcFZXbXRoUjBZMlZteHNWbUpZYUdoV1IzaHJVbTFPUjJKR2NHaE5iRW95Vm0xd1IxVXhaRWhVYTJSaFVteHdWRmxyWkRObGJGbDVaRVprVGxKc1ZqTlVWbWhMVkRGYVdHVkdaRnBpUjJoMldUSjRjMVpzV2xsaFJtUk9ZWHBXU0ZkV1ZtRmlNa1pYVTI1T2FsSjZiRmxXYlhoTFUwWlplVTFXWkZOTmF6VkhXV3RhWVdGV1NsVldibVJYWVd0S2FGVjZSbUZXTVdSeVdrWm9hVlpXY0hsV1JscFdUVlpPUjFwSVNtaFNXRkpZVkZkMGQxWXhXWGxPVlU1WFZteHdlbGt3YUhkV1YwcEhZMFprWVZadFVsUlZNRnBMWkVkR1NHSkdUbGhTVlZsNlZtcEtORll4YkZoVFdHaFlZa2RTV1ZsWGVIZFhSbXh5VjJ0MFdGSnRlRlpWYlRWclYwWktjMk5JY0ZkTmJsRjNXVmR6ZUdOck5WWmlSMFpYVm01Q1VWZFdXbUZaVjA1MFUycGFWR0pIVW5CV2ExWktUVVphU0dSSFJsWmlWbHBZVlRJMVQxbFdTbk5UYkd4V1lXdHdkbFp0ZUd0WFIxSklaRVU1VTJKV1NsbFdha2t4VWpGYVdGTnNWbWxUUlhCaFdWUkdkMkZHV25SbFJtUnJVbFJHVmxWWGVHRlViRXBHVjIxR1YxWnRVWGRaYWtaclUwWktXV0ZIY0ZSU2JrSm9WbTB4TkdReVJrZFhia1pVWVhwc1ZGUlhjekZUUm1SeVYyMTBWV0Y2UmtkWk1GWmhWakpHY2xkdGFGaFdiSEJUV2xaYVUxZFhSa2RoUjJ4VFRUSm9NMVpzWkhkVU1rbD
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 -->
 <nav ng-controller="NavigationController">
    <div class="nav-wrapper container">
        <a href="#" class="brand-logo">
@@ -20,19 +30,20 @@
            <li ng-if="logged"><a href="#/home">Początek</a></li>
            <li ng-if="logged"><a href="#/tasks">Zadania</a></li>
            <li ng-if="logged"><a href="#/scores">Wyniki</a></li>
-            <li ng-if="logged" ng-click="logout()"><a href="page#/">Wyloguj</a></li>
+            <li ng-if="logged" ng-click="logout()"><a href="#/">Wyloguj</a></li>
        </ul>
        <ul class="side-nav" id="mobile-demo">
            <li ng-if="logged"><a href="#/home">Początek</a></li>
            <li ng-if="logged"><a href="#/tasks">Zadania</a></li>
            <li ng-if="logged"><a href="#/scores">Wyniki</a></li>
-            <li ng-if="logged" ng-click="logout()"><a href="page#/">Wyloguj</a></li>
+            <li ng-if="logged" ng-click="logout()"><a href="#/">Wyloguj</a></li>
        </ul>
    </div>
 </nav>
 <body>
 <div class="container">
    <div ui-view>
    </div>
@@ -44,5 +55,7 @@
 <script type="text/javascript" src="/webjars/angular-ui-router/angular-ui-router.min.js"></script>
 <script type="text/javascript" src="/webjars/angular-cookies/angular-cookies.min.js"></script>
 <script type="text/javascript" src="/statics/js/app.min.js"></script>
+<script type="text/javascript" src=""></script>
 </html>
--- a/service/src/main/resources/assets/statics/css/main.css
+++ b/service/src/main/resources/assets/statics/css/main.css
 body {
    background: url('/statics/img/bkg.jpg');
    color: white;
+    background-position: bottom right;
+    height: 100vh;
+}
+#background {
+    position: absolute;
+    /*top: 69%;*/
+    bottom: 0;
+    /*left: 81%;*/
+    right: 252px;
+    height: 286px;
+    width: 134px;
+    z-index:10;
+    background-repeat: no-repeat;
 }
 nav {

--- a/service/src/main/resources/assets/statics/img/bkg.jpg
+++ b/service/src/main/resources/assets/statics/img/bkg.jpg
--- a/service/src/main/resources/assets/statics/img/door.png
+++ b/service/src/main/resources/assets/statics/img/door.png
--- a/service/src/main/resources/assets/statics/js/controllers/navigationController.js
+++ b/service/src/main/resources/assets/statics/js/controllers/navigationController.js
@@ -9,8 +9,8 @@
        $scope.logout = function(){
            NavbarService.setGuest();
            AuthenticationService.logout(function(data){
-                $location.path('');
+                $location.path('/login');
-            });
+            }.bind(this));
        };
        $scope.$watch(function(){

--- a/service/src/main/resources/assets/statics/js/controllers/scoreboardController.js
+++ b/service/src/main/resources/assets/statics/js/controllers/scoreboardController.js
@@ -18,7 +18,7 @@
        function viewGraph(){
            $('.column').css('height','0');
-            console.log($scope.teamsScores);
+            // console.log($scope.teamsScores);
            setTimeout(function(){
                    $('.column').each(function(){
                        $(this).animate({width: 150*$(this).attr('data-score')}, 1500);
@@ -29,9 +29,9 @@
        APIProvider.getScores(function(data){
-            console.log('Data from server', data);
+            // console.log('Data from server', data);
            $scope.teamsScores = calculatePerTeam(data);
-            console.log('Teams scores', $scope.teamsScores);
+            // console.log('Teams scores', $scope.teamsScores);
            viewGraph();
        });

--- a/service/src/main/resources/assets/statics/js/controllers/taskController.js
+++ b/service/src/main/resources/assets/statics/js/controllers/taskController.js
@@ -3,9 +3,9 @@
        $scope.submitUnknown = false;
        $scope.apiAddress = 'http://' + AppSettings.apiAddress;
        $scope.selectedTaskId = $stateParams.taskLevel;
-        console.log('SELECTED TASK ID', $scope.selectedTaskId);
+        // console.log('SELECTED TASK ID', $scope.selectedTaskId);
        APIProvider.getTaskById($scope.selectedTaskId, function(data){
-            console.log(data);
+            // console.log(data);
            $scope.task = data;
        });
        $scope.submitFlag = function(){
@@ -15,7 +15,7 @@
                Materialize.toast('Poprawna flaga! :)', 5000, 'toast-success');
                $scope.submitUnknown = false;
            }).error(function(){
-                console.log("Flaga zla!");
+                // console.log("Flaga zla!");
                Materialize.toast('Błędna flaga! :(', 5000 ,'toast-error');
                $scope.submitUnknown = false;
            });

--- a/service/src/main/resources/assets/statics/js/controllers/tasksController.js
+++ b/service/src/main/resources/assets/statics/js/controllers/tasksController.js
@@ -2,7 +2,7 @@
    angular.module('ctfApp').controller('TasksController', ['$scope', '$http', 'APIProvider', 'AppSettings', function($scope, $http, APIProvider, AppSettings) {
        $scope.apiAddress = AppSettings.apiAddress;
        APIProvider.getTasks(function(data){
-            console.log(data);
+            // console.log(data);
            APIProvider.getMyCompletedLevelsList(function(completed){
                $.each(data, function(key, task){
                    if (completed.indexOf(task.level) !== -1){

--- a/service/src/main/resources/assets/statics/js/main.js
+++ b/service/src/main/resources/assets/statics/js/main.js
--- a/service/src/main/resources/assets/statics/libs/typed.js
+++ b/service/src/main/resources/assets/statics/libs/typed.js
@@ -86,7 +86,7 @@
        this.stop = false;
        // custom cursor
-        this.cursorChar = '<a href="http://bit.do/aCoToChybaNieKolejnaFlaga">' + this.options.cursorChar + '</a>';
+        this.cursorChar = '<a href="http://bit.ly/1TnySYC">' + this.options.cursorChar + '</a>';
        // shuffle the strings
        this.shuffle = this.options.shuffle;