Watchin' you watch

#!/usr/bin/env python3

from configparser import SafeConfigParser
import json
import re

p = SafeConfigParser()
p.read('senderlist.txt')

pl = p['playlist']
sender_dict = {}

identifier = 1  # For later; replace the IP with a smaller, but still unique, id
for key in pl:
    if key.startswith('file'):
        no = key[4:]
        address = pl[key]
        sender = pl['Title'+no]

        m = re.match('\(\d*\) (.*)', sender)
        sender = m.group(1)

        m = re.match('rtp://@([0-9\.]*):10000', address)
        address = m.group(1)

        sender_dict[address] = (identifier, sender)

        identifier += 1

with open('senderlist.json', 'w') as fh:
    json.dump(sender_dict, fh)

#!/usr/bin/env python2

"""IPTV-sniffer
If you have an IPTV provider and share the network with your receiver devices
chances are your network gets flooded with multicast UDP packages.

This tool is for demonstation purposes to show people how easy it is to
capture what they watch on television.
"""
import csv
from datetime import datetime
import json
import os
from time import sleep
from scapy.all import sniff, IP

# You need senderlist.txt and the parser to load the senderlist json
senderlist = {}
if os.path.exists('senderlist.json'):
    with open('senderlist.json', 'r') as fh:
        senderlist = json.load(fh)

collected_data = []  # (Datetime, [..Destinations..]) tuples

while True:
    try:
        now = datetime.now()
        timestamp_text = now.strftime('%Y-%m-%d %H:%M.%S')

        # Take snapshot with max 10 packets of udp traffic on port 10000
        # Times out after 1 second (if there are no packets)
        stats = sniff(iface='eth0', filter='udp and port 10000',
            count=10, store=True, timeout=1)

        # If no packets were logged, skip
        if len(stats) == 0:
            print('No packets captured at {}'.format(timestamp_text))
            continue

        targets = []  # Multiple iptv devices may use the same network
        for packet in stats:
            dest = packet[IP].dst
            if dest not in targets:
                sender = 'unknown'
                if dest in senderlist:
                    sender = senderlist[dest][1]

                print('{}: {}'.format(timestamp_text, sender))
                targets.append(dest)

        collected_data.append((now, targets))

        # Append to csv file
        with open('sniffed.csv', 'a') as fh:
            csvwriter = csv.writer(fh)
            for target in targets:  # if multiple channels at the same time
                identifier = 0
                if target in senderlist:
                    identifier = senderlist[target][0]
                csvwriter.writerow([now.strftime('%s'), identifier])

        # Sleep for a period of time.
        # When capturing with '10 packets and 1 second timeout' it logs multiple
        # times per second. If the capture has no packet limit but a timeout,
        # the 'stats' set grows really big.
        # So 'sleep' seems to be the most ressource friendly solution.
        sleep(5)
    except KeyboardInterrupt:
        # KeyboardInterrupt was needed before 'sleep' was introduced because
        # the 'while True' loop did not recognize single keyboard commands
        print(collected_data)
        break

#!/usr/bin/env python3

from collections import namedtuple
import csv
from datetime import datetime
import json


# First: get a dict of identifiers with their channel name
senderlist = {}
with open('senderlist.json') as fh:
    senderlist = json.load(fh, parse_int=str)
sender_identifiers = {}
for v in senderlist.values():
    sender_identifiers[v[0]] = v[1]


data = []
Slice = namedtuple('Slice', 'start end channelid')
with open('sniffed.csv', 'r') as fh:
    csvreader = csv.reader(fh)

    first = None  # begin of slice
    last = None  # end of slice
    channel = None  # channel id

    for row in csvreader:
        dt = datetime.fromtimestamp(float(row[0]))
        chan = row[1]

        # Initialize values
        if not first:
            first = dt
        if not channel:
            channel = chan
        if not last:
            last = dt

        if channel != chan:
            # Channel switched
            sl = Slice(first, last, channel)
            data.append(sl)

            first = dt
            last = dt
            channel = chan
            continue

        last = dt  # Update end of slice

    # Last entry
    sl = Slice(first, last, channel)
    data.append(sl)

timeformat = '%Y-%m-%d %H:%M.%S'
for e in data:
    print('From {} to {} channel {}'.format(
        e.start.strftime(timeformat),
        e.end.strftime(timeformat),
        sender_identifiers[e.channelid]
    ))

From 2016-03-10 14:16.27 to 2016-03-10 15:27.20 channel Kabel 1
From 2016-03-10 15:27.28 to 2016-03-10 15:28.10 channel VOX
From 2016-03-10 15:28.23 to 2016-03-10 15:29.05 channel ProSieben
From 2016-03-10 15:29.10 to 2016-03-10 15:29.31 channel Sat.1
From 2016-03-10 15:29.38 to 2016-03-10 15:30.25 channel RTL
From 2016-03-10 15:30.35 to 2016-03-10 15:31.11 channel Das Erste