aio_http_example.py

import asyncio
import aiohttp
import time

URLS = [
    'http://google.com',
    'http://twiytytfyfyfyfyfyfyfyyfer.com',
    'https://docs.python.org/3/library/asyncio-task.html#asyncio.Future',
    'http://9gag.com/hot',
    'https://www.youtube.com/watch?v=mdML5WPEhEY',
    'https://gist.github.com/keis/10627651',
    'http://stackoverflow.com/questions/610883/how-to-know-if-an-object-has-an-attribute-in-python',
    'http://stackoverflow.com/questions/20729104/python-asyncio-futures-and-yield-from',
    'http://docs.python-requests.org/en/master/user/quickstart/'
    'https://twitter.com/',
    'https://evdoxos.ds.unipi.gr/',
    'http://semantic-ui.com/',
    'http://codereview.stackexchange.com/',
]


async def get_page(url):
    # Coroutine η οποία κάνει ένα ασύγχρονο get
    # request και στην συνέχεια το κλείνει.
    response = await aiohttp.request('GET', url)
    response.close()


if __name__ == "__main__":
    # Χρόνος σε δευτερόλεπτα
    t0 = time.time()
    # Καταχώρηση μιας event loop
    loop = asyncio.get_event_loop()
    # Δημιουργία μιας λίστας από tasks τα οποία
    # κάνουν get request για κάθε url
    tasks = asyncio.wait([asyncio.tasks.Task(get_page(url)) for url in URLS])
    # Εκκίνηση της event loop μέχρι να
    # ολοκληρωθούν όλα τα tasks
    loop.run_until_complete(tasks)
    # Εμφάνισε το χρονο που χρειάστηκε για
    # να ολοκληρωθεί η διαδικασία
    print("Time : "+str(time.time()-t0))
        

crawler_example.py

import asyncio
import aiohttp
import re
import time
# Σύνδεσμος εκκίνησης του crawler
startingPoint = "http://giannispap-ei.blogspot.gr/"
# Regular expression για εξόρυξη συνδέσμων
urlRegex  = re.compile(b'href=[\'"]?([^\'" >]+)',
                       re.VERBOSE | re.MULTILINE)
# Σειρά όπου αποθηκεύονται οι σύνδεσμοι
urlQueue  = asyncio.Queue()
# Σειρά όπου αποθηκεύονται τα δεδομένα
# των ιστοσελίδων που επισκέφτηκε ο crawler
dataQueue = asyncio.Queue()



async def fetchUrl():
    # Coroutine η οποία επισκέπτεται τα urls 
    print("Starting fetchUrl()")
    global urlCount
    # Μετρητής των συνδέσμων που έχουν γίνει crawl
    urlCount = 0
    # Tοποθετούμε στην ουρά τον σύνδεσμο εκκίνησης 
    await urlQueue.put(startingPoint)
    
    while True:
        # Ατέρμονη loop
        try:
            # αποκτάμε ένα στόχο από την σειρά με τους
            # συνδέσμους
            target = await urlQueue.get() 
            print("Fetching: {0}".format(target))
            # Κάνουμε ένα ασύγχρονο get request
            response = await aiohttp.request('GET', target)
            # Διαβάζουμε ασύγχρονα την απάντηση 
            data = await response.read()
            # Τοποθετούμε τα δεδομένα στην σειρά των δεδομένων
            await dataQueue.put(data)
            # Ολοκληρώνουμε το request
            response.close()
            # Προσθέτουμε 1 στον μετρητή
            urlCount += 1
        except Exception as exc:
            # Εμφάνιση του σφάλματος
            print("Error fetchUrl: {0}".format(exc))
        



async def getUrls():
    # Coroutine η οποία βρίσκει τα urls σε μια σελίδα
    print("Starting getUrls()")
    # Λίστα με τα urls που έχουν γίνει crawl
    urlList = []
    while True:
        try:
            # Πέρνουμε από την σειρά τα δεδομένα που διαβάσαμε
            data = await dataQueue.get()
            # Βρίσκουμε τα urls μέσα στο html document
            urls = re.findall(urlRegex, data)
            for url in urls:
                try:
                    # Αν το url δεν έχει γίνει crawl
                    if not url in urlList:
                        # Το προσθέτουμε στην λίστα
                        urlList.append(url)
                        # και το προσθέτουμε στην σειρά με τα url
                        await urlQueue.put(url.decode("utf-8"))
                except Exception as exc:
                    # Εμφάνιση του σφάλματος
                    print("Error getUrls put: {0}".format(exc))
        except Exception as exc:
            # Εμφάνιση του σφάλματος
            print("Error getUrls: {0}".format(exc))



if __name__ == "__main__":
    # Καταχώρηση μιας event loop
    loop = asyncio.get_event_loop()
    # Δημιουργία tasks
    loop.create_task(fetchUrl())
    loop.create_task(getUrls())
    # Χρόνος σε δευτερόλεπτα
    t0 = time.time()
    print("Starting tasks")
    try:
        # Τρέξε την event loop για πάντα
        loop.run_forever()
    except KeyboardInterrupt:
        # Σταμάτα την loop
        loop.stop()
        # Εμφάνισε το πλήθος των url που έχουν γίνει crawl
        print("Total urls crawled: {0}".format(urlCount))
    finally:
        loop.close()
    # Εμφάνισε το χρονο που χρειάστηκε για
    # να ολοκληρωθεί η διαδικασία
    print("Time elapsed: {0}".format(time.time()-t0))
    

decorators_example.py

import logging

def excdecorator(old_function):
    def decorated_function(*args, **kwds):
        # Εσωτερική προστατευμένη μέθοσος
        print("Debug: function starting")
        try:
            # Εκτέλεση "τυλιγμένης" λειτουργίας
            return old_function(*args, **kwds)
        except Exception:
            # Εαν υπάρξει σφάλμα επέστρεψε None
            logging.exception("Exception caught from the decorator")
            return None
    # Επιστροφή εσωτερικής λειτουργίας
    return decorated_function



@excdecorator
def just_printing():
    print("Hi")

if __name__ == "__main__":
    just_printing()
    

Fosscomm 2016 Code

Code used in Fosscomm 2016 

honeypot_example.py

import asyncio
import logging

# Ports που θέλουμε να "παγιδέψουμε"
TRAPPED_PORTS = [23, 8888]
IP = "192.168.2.3"
logging.basicConfig(filename='incidents.log', level=logging.DEBUG)

class SimpleHoneyPotProtocol(asyncio.Protocol):
    # Δημιουργούμε μια υποκλάση του asyncio.Protocol
    def connection_made(self, transport):
        # šΚαταγράφουμε την κακόβουλη σύνδεση
        peername = transport.get_extra_info('peername')
        print('Connection from {}'.format(peername))
        logging.info(peername)
        
        self.transport = transport
        # Στέλνουμε ένα μύνημα ότι ο καταγράψαμε την
        # σύνδεση και δημιουργούμε ένα task το οποίο θα
        # κλείσει την σύνδεση μετά από 1 δευτερόλεπτο
        motd = "Illegal Access of this server, your IP \
[{0}] has been logged.".format(peername)
        
        self.transport.write(motd.encode())
        loop.create_task(self.kill(self.transport, peername))
        
    def data_received(self, data):
        # Καταγράφουμε τυχόν δεδομένα που μας στέλνονται
        # μέσα στο διάστημα του 1 δευτερολέπτου
        try:
            message = data.decode()
            logging.info(message)
        except:
            pass
        
    async def kill(self, transport, peername):
        # Περιμένουμε 1 δευτερόλεπτο
        await asyncio.sleep(1)
        # Κλείνουμε την σύνδεση
        transport.close()
        print("Closed connection with [{0}]".format(peername))


if __name__ == "__main__":
    print("Honeypot started!")
    # Δημιουργία κενής λίστας
    SERVERS = []
    
    # Καταχώρηση μιας event loop
    loop = asyncio.get_event_loop()

    # Δημιουργούμε ένα καινούργιο πρωτόκολλο
    # για κάθε παγιδευμένη port
    
    for enum, port in enumerate(TRAPPED_PORTS):
        coro = loop.create_server(SimpleHoneyPotProtocol, IP, port)
        SERVERS.append(loop.run_until_complete(coro))
        print('Serving on {}'.format(SERVERS[enum].sockets[0].getsockname())) 

    # Απάντησε στα αιτήματα μέχρι ο χρήστης
    # να πατήσει Ctrl-C
    try:
        loop.run_forever()
    except KeyboardInterrupt:
        pass

    # Κλείνουμε τους servers
    for server in SERVERS:
        server.close()
        loop.run_until_complete(server.wait_closed())
    # Τερματίζουμε την event loop
    loop.stop()
    loop.close()
    print("Honeypot stopped!")