__filename__ = "city.py" __author__ = "Bob Mottram" __license__ = "AGPL3+" __version__ = "1.2.0" __maintainer__ = "Bob Mottram" __email__ = "bob@libreserver.org" __status__ = "Production" __module_group__ = "Metadata" import os import datetime import random import math from random import randint from utils import acct_dir # states which the simulated city dweller can be in PERSON_SLEEP = 0 PERSON_WORK = 1 PERSON_PLAY = 2 PERSON_SHOP = 3 PERSON_EVENING = 4 PERSON_PARTY = 5 BUSY_STATES = (PERSON_WORK, PERSON_SHOP, PERSON_PLAY, PERSON_PARTY) def _get_decoy_camera(decoy_seed: int) -> (str, str, int): """Returns a decoy camera make and model which took the photo """ cameras = [ ["Apple", "iPhone SE"], ["Apple", "iPhone XR"], ["Apple", "iPhone 6"], ["Apple", "iPhone 7"], ["Apple", "iPhone 8"], ["Apple", "iPhone 11"], ["Apple", "iPhone 11 Pro"], ["Apple", "iPhone 12"], ["Apple", "iPhone 12 Mini"], ["Apple", "iPhone 12 Pro Max"], ["Apple", "iPhone 13"], ["Apple", "iPhone 13 Mini"], ["Apple", "iPhone 13 Pro"], ["Samsung", "Galaxy Note 20 Ultra"], ["Samsung", "Galaxy S20 Plus"], ["Samsung", "Galaxy S20 FE 5G"], ["Samsung", "Galaxy Z FOLD 2"], ["Samsung", "Galaxy S12 Plus"], ["Samsung", "Galaxy S12"], ["Samsung", "Galaxy S11 Plus"], ["Samsung", "Galaxy S10 Plus"], ["Samsung", "Galaxy S10e"], ["Samsung", "Galaxy Z Flip"], ["Samsung", "Galaxy A51"], ["Samsung", "Galaxy S10"], ["Samsung", "Galaxy S10 Plus"], ["Samsung", "Galaxy S10e"], ["Samsung", "Galaxy S10 5G"], ["Samsung", "Galaxy A60"], ["Samsung", "Note 12"], ["Samsung", "Note 12 Plus"], ["Samsung", "Note 11"], ["Samsung", "Note 11 Plus"], ["Samsung", "Note 10"], ["Samsung", "Note 10 Plus"], ["Samsung", "Galaxy S22 Ultra"], ["Samsung", "Galaxy S21 Ultra"], ["Samsung", "Galaxy Note 20 Ultra"], ["Samsung", "Galaxy S21"], ["Samsung", "Galaxy S21 Plus"], ["Samsung", "Galaxy S20 FE"], ["Samsung", "Galaxy Z Fold 2"], ["Samsung", "Galaxy A52 5G"], ["Samsung", "Galaxy A71 5G"], ["Google", "Pixel 6 Pro"], ["Google", "Pixel 6"], ["Google", "Pixel 5"], ["Google", "Pixel 4a"], ["Google", "Pixel 4 XL"], ["Google", "Pixel 3 XL"], ["Google", "Pixel 4"], ["Google", "Pixel 4a 5G"], ["Google", "Pixel 3"], ["Google", "Pixel 3a"] ] randgen = random.Random(decoy_seed) index = randgen.randint(0, len(cameras) - 1) serial_number = randgen.randint(100000000000, 999999999999999999999999) return cameras[index][0], cameras[index][1], serial_number def _get_city_pulse(curr_time_of_day, decoy_seed: int) -> (float, float): """This simulates expected average patterns of movement in a city. Jane or Joe average lives and works in the city, commuting in and out of the central district for work. They have a unique life pattern, which machine learning can latch onto. This returns a polar coordinate for the simulated city dweller: Distance from the city centre is in the range 0.0 - 1.0 Angle is in radians """ randgen = random.Random(decoy_seed) variance = 3 data_decoy_state = PERSON_SLEEP weekday = curr_time_of_day.weekday() min_hour = 7 + randint(0, variance) max_hour = 17 + randint(0, variance) if curr_time_of_day.hour > min_hour: if curr_time_of_day.hour <= max_hour: if weekday < 5: data_decoy_state = PERSON_WORK elif weekday == 5: data_decoy_state = PERSON_SHOP else: data_decoy_state = PERSON_PLAY else: if weekday < 5: data_decoy_state = PERSON_EVENING else: data_decoy_state = PERSON_PARTY randgen2 = random.Random(decoy_seed + data_decoy_state) angle_radians = \ (randgen2.randint(0, 100000) / 100000) * 2 * math.pi # some people are quite random, others have more predictable habits decoy_randomness = randgen.randint(1, 3) # occasionally throw in a wildcard to keep the machine learning guessing if randint(0, 100) < decoy_randomness: distance_from_city_center = (randint(0, 100000) / 100000) angle_radians = (randint(0, 100000) / 100000) * 2 * math.pi else: # what consitutes the central district is fuzzy central_district_fuzz = (randgen.randint(0, 100000) / 100000) * 0.1 busy_radius = 0.3 + central_district_fuzz if data_decoy_state in BUSY_STATES: # if we are busy then we're somewhere in the city center distance_from_city_center = \ (randgen.randint(0, 100000) / 100000) * busy_radius else: # otherwise we're in the burbs distance_from_city_center = busy_radius + \ ((1.0 - busy_radius) * (randgen.randint(0, 100000) / 100000)) return distance_from_city_center, angle_radians def parse_nogo_string(nogo_line: str) -> []: """Parses a line from locations_nogo.txt and returns the polygon """ nogo_line = nogo_line.replace('\n', '').replace('\r', '') polygon_str = nogo_line.split(':', 1)[1] if ';' in polygon_str: pts = polygon_str.split(';') else: pts = polygon_str.split(',') if len(pts) <= 4: return [] polygon = [] for index in range(int(len(pts)/2)): if index*2 + 1 >= len(pts): break longitude_str = pts[index*2].strip() latitude_str = pts[index*2 + 1].strip() if 'E' in latitude_str or 'W' in latitude_str: longitude_str = pts[index*2 + 1].strip() latitude_str = pts[index*2].strip() if 'E' in longitude_str: longitude_str = \ longitude_str.replace('E', '') longitude = float(longitude_str) elif 'W' in longitude_str: longitude_str = \ longitude_str.replace('W', '') longitude = -float(longitude_str) else: longitude = float(longitude_str) latitude = float(latitude_str) polygon.append([latitude, longitude]) return polygon def spoof_geolocation(base_dir: str, city: str, curr_time, decoy_seed: int, cities_list: [], nogo_list: []) -> (float, float, str, str, str, str, int): """Given a city and the current time spoofs the location for an image returns latitude, longitude, N/S, E/W, camera make, camera model, camera serial number """ locations_filename = base_dir + '/custom_locations.txt' if not os.path.isfile(locations_filename): locations_filename = base_dir + '/locations.txt' nogo_filename = base_dir + '/custom_locations_nogo.txt' if not os.path.isfile(nogo_filename): nogo_filename = base_dir + '/locations_nogo.txt' man_city_radius = 0.1 variance_at_location = 0.0004 default_latitude = 51.8744 default_longitude = 0.368333 default_latdirection = 'N' default_longdirection = 'W' if cities_list: cities = cities_list else: if not os.path.isfile(locations_filename): return (default_latitude, default_longitude, default_latdirection, default_longdirection, "", "", 0) cities = [] try: with open(locations_filename, 'r') as loc_file: cities = loc_file.readlines() except OSError: print('EX: unable to read locations ' + locations_filename) nogo = [] if nogo_list: nogo = nogo_list else: if os.path.isfile(nogo_filename): nogo_list = [] try: with open(nogo_filename, 'r') as nogo_file: nogo_list = nogo_file.readlines() except OSError: print('EX: unable to read ' + nogo_filename) for line in nogo_list: if line.startswith(city + ':'): polygon = parse_nogo_string(line) if polygon: nogo.append(polygon) city = city.lower() for city_name in cities: if city in city_name.lower(): city_fields = city_name.split(':') latitude = city_fields[1] longitude = city_fields[2] area_km2 = 0 if len(city_fields) > 3: area_km2 = int(city_fields[3]) latdirection = 'N' longdirection = 'E' if 'S' in latitude: latdirection = 'S' latitude = latitude.replace('S', '') if 'W' in longitude: longdirection = 'W' longitude = longitude.replace('W', '') latitude = float(latitude) longitude = float(longitude) # get the time of day at the city approx_time_zone = int(longitude / 15.0) if longdirection == 'E': approx_time_zone = -approx_time_zone curr_time_adjusted = curr_time - \ datetime.timedelta(hours=approx_time_zone) cam_make, cam_model, cam_serial_number = \ _get_decoy_camera(decoy_seed) valid_coord = False seed_offset = 0 while not valid_coord: # patterns of activity change in the city over time (distance_from_city_center, angle_radians) = \ _get_city_pulse(curr_time_adjusted, decoy_seed + seed_offset) # The city radius value is in longitude and the reference # is Manchester. Adjust for the radius of the chosen city. if area_km2 > 1: man_radius = math.sqrt(1276 / math.pi) radius = math.sqrt(area_km2 / math.pi) city_radius_deg = (radius / man_radius) * man_city_radius else: city_radius_deg = man_city_radius # Get the position within the city, with some randomness added latitude += \ distance_from_city_center * city_radius_deg * \ math.cos(angle_radians) longitude += \ distance_from_city_center * city_radius_deg * \ math.sin(angle_radians) longval = longitude if longdirection == 'W': longval = -longitude valid_coord = not point_in_nogo(nogo, latitude, longval) if not valid_coord: seed_offset += 1 if seed_offset > 100: break # add a small amount of variance around the location fraction = randint(0, 100000) / 100000 distance_from_location = fraction * fraction * variance_at_location fraction = randint(0, 100000) / 100000 angle_from_location = fraction * 2 * math.pi latitude += distance_from_location * math.cos(angle_from_location) longitude += distance_from_location * math.sin(angle_from_location) # gps locations aren't transcendental, so round to a fixed # number of decimal places latitude = int(latitude * 100000) / 100000.0 longitude = int(longitude * 100000) / 100000.0 return (latitude, longitude, latdirection, longdirection, cam_make, cam_model, cam_serial_number) return (default_latitude, default_longitude, default_latdirection, default_longdirection, "", "", 0) def get_spoofed_city(city: str, base_dir: str, nickname: str, domain: str) -> str: """Returns the name of the city to use as a GPS spoofing location for image metadata """ city = '' city_filename = acct_dir(base_dir, nickname, domain) + '/city.txt' if os.path.isfile(city_filename): try: with open(city_filename, 'r') as city_file: city = city_file.read().replace('\n', '') except OSError: print('EX: unable to read ' + city_filename) return city def _point_in_polygon(poly: [], x_coord: float, y_coord: float) -> bool: """Returns true if the given point is inside the given polygon """ num = len(poly) inside = False p2x = 0.0 p2y = 0.0 xints = 0.0 p1x, p1y = poly[0] for i in range(num + 1): p2x, p2y = poly[i % num] if y_coord > min(p1y, p2y): if y_coord <= max(p1y, p2y): if x_coord <= max(p1x, p2x): if p1y != p2y: xints = \ (y_coord - p1y) * (p2x - p1x) / (p2y - p1y) + p1x if p1x == p2x or x_coord <= xints: inside = not inside p1x, p1y = p2x, p2y return inside def point_in_nogo(nogo: [], latitude: float, longitude: float) -> bool: """Returns true of the given geolocation is within a nogo area """ for polygon in nogo: if _point_in_polygon(polygon, latitude, longitude): return True return False