devicer.py 0.1.0__tar.gz

devicer_py-0.1.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: devicer.py
+Version: 0.1.0
+Summary: Open-Source Python Middleware for Digital Fingerprinting
+Author: One anonymous contributor
+Author-email: Samuel Roux <sam.roux.com@gmail.com>, Stephen Perso <stephenrperso@gmail.com>
+Project-URL: Homepage, https://gatewaycorporate.org/
+Project-URL: Repository, https://github.com/gatewaycorporate/fp-devicer-python.git
+Project-URL: Issues, https://github.com/gatewaycorporate/fp-devicer-python/issues
+Keywords: fingerprinting,identification,middleware,tracking
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: license.txt
+Requires-Dist: py-tlsh>=4.7.2
+Dynamic: license-file
+
+# FP-Devicer
+## Developed by Gateway Corporate Solutions LLC
+
+FP-Devicer is a digital fingerprinting middleware library designed for ease of use and near-universal compatibility with servers.
+
+Importing and using the library to compare fingerprints between users is as simple as collecting some user data and running the calculateConfidence function.
+```python
+from devicer.confidence import calculate_condifence
+
+user1, user2 = {
+  """Collected data goes here"""
+}
+
+const confidence = calculate_confidence(user1, user2)
+```
+
+The resulting confidence will range between 0 and 100, with 100 providing the highest confidence of the users being identical.

devicer_py-0.1.0/README.md

@@ -0,0 +1,17 @@
+# FP-Devicer
+## Developed by Gateway Corporate Solutions LLC
+
+FP-Devicer is a digital fingerprinting middleware library designed for ease of use and near-universal compatibility with servers.
+
+Importing and using the library to compare fingerprints between users is as simple as collecting some user data and running the calculateConfidence function.
+```python
+from devicer.confidence import calculate_condifence
+
+user1, user2 = {
+  """Collected data goes here"""
+}
+
+const confidence = calculate_confidence(user1, user2)
+```
+
+The resulting confidence will range between 0 and 100, with 100 providing the highest confidence of the users being identical.

devicer_py-0.1.0/license.txt

@@ -0,0 +1,26 @@
+# DON'T BE A DICK PUBLIC LICENSE
+
+> Version 1.1, December 2016
+
+> Copyright (C) 2025 Gateway Corporate Solutions LLC
+
+Everyone is permitted to copy and distribute verbatim or modified
+copies of this license document.
+
+> DON'T BE A DICK PUBLIC LICENSE
+> TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+1. Do whatever you like with the original work, just don't be a dick.
+
+   Being a dick includes - but is not limited to - the following instances:
+
+ 1a. Outright copyright infringement - Don't just copy this and change the name.
+ 1b. Selling the unmodified original with no work done what-so-ever, that's REALLY being a dick.
+ 1c. Modifying the original work to contain hidden harmful content. That would make you a PROPER dick.
+
+2. If you become rich through modifications, related works/services, or supporting the original work,
+share the love. Only a dick would make loads off this work and not buy the original work's
+creator(s) a pint.
+
+3. Code is provided with no warranty. Using somebody else's code and bitching when it goes wrong makes
+you a DONKEY dick. Fix the problem yourself. A non-dick would submit the fix back.

devicer_py-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = [
+    "setuptools>=61.2.0",
+    "wheel",
+]
+build-backend = "setuptools.build_meta"
+[project]
+name = "devicer.py"
+version = "0.1.0"
+authors = [
+    {name = "Samuel Roux", email = "sam.roux.com@gmail.com"},
+    {name = "Stephen Perso", email = "stephenrperso@gmail.com"},
+    {name = "One anonymous contributor"}
+]
+description = "Open-Source Python Middleware for Digital Fingerprinting"
+keywords = [
+    "fingerprinting",
+    "identification",
+    "middleware",
+    "tracking"
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Software Development :: Libraries"
+]
+dependencies = [
+    "py-tlsh>=4.7.2"
+]
+readme = "README.md"
+requires-python = ">=3.8"
+license-files = [
+    "license.txt"
+]
+[project.urls]
+Homepage = "https://gatewaycorporate.org/"
+Repository = "https://github.com/gatewaycorporate/fp-devicer-python.git"
+Issues = "https://github.com/gatewaycorporate/fp-devicer-python/issues"

devicer_py-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

devicer_py-0.1.0/src/devicer/confidence.py

@@ -0,0 +1,52 @@
+from hashing import get_tlsh_hash, get_hash_difference
+import math
+
+def compare_dictionaries(data1: dict, data2: dict) -> tuple[int, int]:
+    """
+    Compare two dictionaries and return the count of matching fields and total fields.
+    
+    Args:
+        data1 (dict): First dictionary containing data.
+        data2 (dict): Second dictionary containing data.
+    
+    Returns:
+        tuple: A tuple containing the count of matching fields and total fields compared.
+    """
+    fields = 0
+    matches = 0
+    for key in data1:
+        if key in data2:
+            fields += 1
+            if isinstance(data1[key], dict):
+                sub_matches, sub_fields = compare_dictionaries(data1[key], data2[key])
+                matches += sub_matches
+                fields += sub_fields
+            elif data1[key] == data2[key]:
+                matches += 1
+    return matches, fields
+
+def calculate_confidence(data1: dict, data2: dict) -> float:
+    """
+    Calculate the confidence score based on two dictionaries of data.
+    
+    Args:
+        data1 (dict): First dictionary containing data.
+        data2 (dict): Second dictionary containing data.
+    
+    Returns:
+        float: Confidence score calculated as the ratio of the sum of values in data1 to the sum of values in data2.
+    """
+    matches, fields = compare_dictionaries(data1, data2)
+    
+    if fields == 0:
+        return 0.0
+
+    hash1 = get_tlsh_hash(str(data1).encode('utf-8'))
+    hash2 = get_tlsh_hash(str(data2).encode('utf-8'))
+    difference_score = get_hash_difference(hash1, hash2)
+
+    inverse_match_score = 1 - (matches / fields)
+    x = (difference_score / 1.5) * inverse_match_score
+    if (inverse_match_score == 0 or difference_score == 0):
+        return 100
+    return 100 / (1 + math.e ** (-4.5 + (0.25 * x)))

devicer_py-0.1.0/src/devicer/confidence_test.py

@@ -0,0 +1,112 @@
+import unittest
+from confidence import calculate_confidence
+from hashing_test import random_string
+
+sampleData1 = {
+  "fonts": ['Arial', 'Verdana'],
+  "hardware": {
+    "cpu": 'Intel Core i7',
+    "gpu": 'NVIDIA GTX 1080',
+    "ram": 16384
+  },
+  "userAgent": 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3',
+  "screen": {
+    "width": 1920,
+    "height": 1080,
+    "colorDepth": 24
+  },
+  "timezone": 'America/New_York',
+  "ip": '157.185.170.244',
+  "languages": ['en-US', 'en'],
+  "plugins": ['Chrome PDF Viewer', 'Shockwave Flash'],
+  "canvasHash": random_string().encode('utf-8'),
+  "audioHash": random_string().encode('utf-8'),
+  "webglHash": random_string().encode('utf-8'),
+}
+
+sampleData2 = {
+  "fonts": ['Arial', 'Verdana'],
+  "hardware": {
+    "cpu": 'Pentium 4',
+    "gpu": 'Intel HD Graphics',
+    "ram": 4096
+  },
+  "userAgent": 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3',
+  "screen": {
+    "width": 1280,
+    "height": 720,
+    "colorDepth": 24
+  },
+  "timezone": 'Europe/London',
+  "ip": '178.238.11.6',
+  "languages": ['en-GB', 'en'],
+  "plugins": ['Chrome PDF Viewer', 'Shockwave Flash'],
+  "canvasHash": random_string().encode('utf-8'),
+  "audioHash": random_string().encode('utf-8'),
+  "webglHash": random_string().encode('utf-8'),
+}
+
+
+class TestConfidenceCalculation(unittest.TestCase):
+    def test_confidence_range(self):
+        """
+        Test that the confidence score is between 0 and 100.
+        """
+        confidence = calculate_confidence(sampleData1, sampleData2)
+        self.assertGreaterEqual(confidence, 0, "Confidence score should be at least 0.")
+        self.assertLessEqual(confidence, 100, "Confidence score should not exceed 100.")
+
+    def test_confidence_identical_data(self):
+        """
+        Test that the confidence score is 100 when both data dictionaries are identical.
+        """
+        confidence = calculate_confidence(sampleData1, sampleData1)
+        self.assertEqual(confidence, 100, "Confidence score should be 100 for identical data.")
+    
+    def test_confidence_different_data(self):
+        """
+        Test that the confidence score is less than 10 when data dictionaries are different.
+        """
+        confidence = calculate_confidence(sampleData1, sampleData2)
+        self.assertLess(confidence, 10, "Confidence score should be less than 10 for different data.")
+
+    def test_confidence_similar_data(self):
+        """
+        Test that the confidence score is greater than 80 when data dictionaries are similar.
+        """
+        similar_data = sampleData2.copy()
+        similar_data['hardware']['ram'] = 8192
+        confidence = calculate_confidence(sampleData2, similar_data)
+        self.assertGreater(confidence, 80, "Confidence score should be greater than 80 for similar data.")
+
+    def test_confidence_partial_data(self):
+        """
+        Test that the confidence score is calculated correctly when some fields match.
+        """
+        partial_data = sampleData1.copy()
+        partial_data['hardware']['cpu'] = 'Pentium 4'
+        partial_data['hardware']['gpu'] = 'Intel HD Graphics'
+        partial_data['hardware']['ram'] = 4096
+        partial_data['timezone'] = 'Europe/London'
+        partial_data['ip'] = '178.238.11.6'
+        partial_data['languages'] = ['en-GB', 'en']
+        partial_data['userAgent'] = 'Mozilla/5.0 (compatible; Konqueror/2.2.2-3; Linux)'
+        confidence = calculate_confidence(sampleData1, partial_data)
+        self.assertGreater(confidence, 10, "Confidence score should be greater than 10 for partially matching data.")
+        self.assertLess(confidence, 95, "Confidence score should be less than 95 for partially matching data.")
+
+    def test_confidence_empty_data(self):
+        """
+        Test that the confidence score is 0 when one of the data dictionaries is empty.
+        """
+        confidence = calculate_confidence({}, sampleData2)
+        self.assertEqual(confidence, 0, "Confidence score should be 0 for empty data.")
+        
+        confidence = calculate_confidence(sampleData1, {})
+        self.assertEqual(confidence, 0, "Confidence score should be 0 for empty data.")
+        
+        confidence = calculate_confidence({}, {})
+        self.assertEqual(confidence, 0, "Confidence score should be 0 for both data dictionaries being empty.")
+
+if __name__ == '__main__':
+    unittest.main()

devicer_py-0.1.0/src/devicer/data_test.py

@@ -0,0 +1,98 @@
+import unittest
+import random
+from hashing import get_tlsh_hash, get_hash_difference
+from hashing_test import random_string
+
+sampleData1 = {
+  "fonts": ['Arial', 'Verdana'],
+  "hardware": {
+    "cpu": 'Intel Core i7',
+    "gpu": 'NVIDIA GTX 1080',
+    "ram": 16384
+  },
+  "userAgent": 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3',
+  "screen": {
+    "width": 1920,
+    "height": 1080,
+    "colorDepth": 24
+  },
+  "timezone": 'America/New_York',
+  "ip": '157.185.170.244',
+  "languages": ['en-US', 'en'],
+  "plugins": ['Chrome PDF Viewer', 'Shockwave Flash'],
+  "canvasHash": random_string().encode('utf-8'),
+  "audioHash": random_string().encode('utf-8'),
+  "webglHash": random_string().encode('utf-8'),
+}
+
+sampleData2 = {
+  "fonts": ['Arial', 'Verdana'],
+  "hardware": {
+    "cpu": 'Pentium 4',
+    "gpu": 'Intel HD Graphics',
+    "ram": 4096
+  },
+  "userAgent": 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3',
+  "screen": {
+    "width": 1280,
+    "height": 720,
+    "colorDepth": 24
+  },
+  "timezone": 'Europe/London',
+  "ip": '178.238.11.6',
+  "languages": ['en-GB', 'en'],
+  "plugins": ['Chrome PDF Viewer', 'Shockwave Flash'],
+  "canvasHash": random_string().encode('utf-8'),
+  "audioHash": random_string().encode('utf-8'),
+  "webglHash": random_string().encode('utf-8'),
+}
+
+
+class TestHashingData(unittest.TestCase):
+    def test_hash_nonempty(self):
+        """
+        Test that the hashing function returns a non-empty string for a non-empty input.
+        """
+        data = str(sampleData1).encode('utf-8')
+        hash_value = get_tlsh_hash(data)
+        self.assertTrue(hash_value, "Hash value should not be empty for non-empty input.")
+
+    def test_hash_identical_inputs(self):
+        """
+        Test that the hashing function returns the same hash for identical inputs.
+        Also checks that the difference between the hashes is zero.
+        """
+        data = str(sampleData1).encode('utf-8')
+        hash1 = get_tlsh_hash(data)
+        hash2 = get_tlsh_hash(data)
+        difference = get_hash_difference(hash1, hash2)
+        self.assertEqual(hash1, hash2, "Hash values should be identical for identical inputs.")
+        self.assertEqual(difference, 0, "Hash difference should be zero for identical inputs.")
+      
+    def test_hash_distance_when_different(self):
+        """
+        Test that the hash difference is non-zero for different inputs.
+        Also checks that the difference is large for sufficiently different inputs.
+        """
+        data1 = str(sampleData1).encode('utf-8')
+        data2 = str(sampleData2).encode('utf-8')
+        hash1 = get_tlsh_hash(data1)
+        hash2 = get_tlsh_hash(data2)
+        difference = get_hash_difference(hash1, hash2)
+        self.assertGreater(difference, 0, "Hash difference should be greater than zero for different inputs.")
+        self.assertGreater(difference, 80, "Hash difference should be large for sufficiently different inputs.")
+
+    def test_hash_distance_when_similar(self):
+        """
+        Test that the hash difference is small for similar inputs.
+        """
+        data1 = str(sampleData1).encode('utf-8')
+        random_index = random.randint(0, len(data1) - 4)
+        data2 = data1[:random_index] + random_string(length=4).encode('utf-8') + data1[random_index + 4:]
+        hash1 = get_tlsh_hash(data1)
+        hash2 = get_tlsh_hash(data2)
+        difference = get_hash_difference(hash1, hash2)
+        self.assertLess(difference, 140, "Hash difference should be small for similar inputs.")
+
+if __name__ == '__main__':
+    unittest.main()

devicer_py-0.1.0/src/devicer/hashing.py

@@ -0,0 +1,27 @@
+import tlsh;
+
+def get_tlsh_hash(data: bytes) -> str:
+    """
+    Generate a TLSH hash for the given data.
+
+    Args:
+        data (bytes): The input data to hash.
+
+    Returns:
+        str: The TLSH hash as a hexadecimal string.
+    """
+    tlsh_hash = tlsh.hash(data)
+    return tlsh_hash
+
+def get_hash_difference(hash1: str, hash2: str) -> int:
+    """
+    Calculate the difference between two TLSH hashes.
+
+    Args:
+        hash1 (str): The first TLSH hash.
+        hash2 (str): The second TLSH hash.
+
+    Returns:
+        int: The difference score between the two hashes.
+    """
+    return tlsh.diff(hash1, hash2)

devicer_py-0.1.0/src/devicer/hashing_test.py

@@ -0,0 +1,66 @@
+import unittest
+import random
+from hashing import get_tlsh_hash, get_hash_difference
+
+def random_string(length=524):
+    """
+    Generate a random string of specified length.
+
+    Args:
+        length (int): The length of the string to generate. Default is 524.
+
+    Returns:
+        str: A random string of the specified length.
+    """
+    characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789[];!@#$%^&*()-_=+|;:,.<>?"
+    return ''.join(random.choice(characters) for _ in range(length))
+
+
+class TestHashingMethods(unittest.TestCase):
+    def test_hash_nonempty(self):
+        """
+        Test that the hashing function returns a non-empty string for a non-empty input.
+        """
+        data = random_string()
+        hash_value = get_tlsh_hash(data.encode('utf-8'))
+        self.assertTrue(hash_value, "Hash value should not be empty for non-empty input.")
+
+    def test_hash_identical_inputs(self):
+        """
+        Test that the hashing function returns the same hash for identical inputs.
+        Also checks that the difference between the hashes is zero.
+        """
+        data = random_string()
+        hash1 = get_tlsh_hash(data.encode('utf-8'))
+        hash2 = get_tlsh_hash(data.encode('utf-8'))
+        difference = get_hash_difference(hash1, hash2)
+        self.assertEqual(hash1, hash2, "Hash values should be identical for identical inputs.")
+        self.assertEqual(difference, 0, "Hash difference should be zero for identical inputs.")
+
+    def test_hash_distance_when_different(self):
+        """
+        Test that the hash difference is non-zero for different inputs.
+        Also checks that the difference is large for sufficiently different inputs.
+        """
+        data1 = random_string()
+        data2 = random_string()
+        hash1 = get_tlsh_hash(data1.encode('utf-8'))
+        hash2 = get_tlsh_hash(data2.encode('utf-8'))
+        difference = get_hash_difference(hash1, hash2)
+        self.assertGreater(difference, 0, "Hash difference should be greater than zero for different inputs.")
+        self.assertGreater(difference, 180, "Hash difference should be large for sufficiently different inputs.")
+
+    def test_hash_distance_when_similar(self):
+        """
+        Test that the hash difference is small for similar inputs.
+        """
+        data1 = random_string()
+        random_index = random.randint(0, len(data1) - 4)
+        data2 = data1[:random_index] + random_string(length=4) + data1[random_index + 4:]
+        hash1 = get_tlsh_hash(data1.encode('utf-8'))
+        hash2 = get_tlsh_hash(data2.encode('utf-8'))
+        difference = get_hash_difference(hash1, hash2)
+        self.assertLess(difference, 200, "Hash difference should be small for similar inputs.")
+
+if __name__ == '__main__':
+    unittest.main()

devicer_py-0.1.0/src/devicer.py.egg-info/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: devicer.py
+Version: 0.1.0
+Summary: Open-Source Python Middleware for Digital Fingerprinting
+Author: One anonymous contributor
+Author-email: Samuel Roux <sam.roux.com@gmail.com>, Stephen Perso <stephenrperso@gmail.com>
+Project-URL: Homepage, https://gatewaycorporate.org/
+Project-URL: Repository, https://github.com/gatewaycorporate/fp-devicer-python.git
+Project-URL: Issues, https://github.com/gatewaycorporate/fp-devicer-python/issues
+Keywords: fingerprinting,identification,middleware,tracking
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: license.txt
+Requires-Dist: py-tlsh>=4.7.2
+Dynamic: license-file
+
+# FP-Devicer
+## Developed by Gateway Corporate Solutions LLC
+
+FP-Devicer is a digital fingerprinting middleware library designed for ease of use and near-universal compatibility with servers.
+
+Importing and using the library to compare fingerprints between users is as simple as collecting some user data and running the calculateConfidence function.
+```python
+from devicer.confidence import calculate_condifence
+
+user1, user2 = {
+  """Collected data goes here"""
+}
+
+const confidence = calculate_confidence(user1, user2)
+```
+
+The resulting confidence will range between 0 and 100, with 100 providing the highest confidence of the users being identical.

devicer_py-0.1.0/src/devicer.py.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+license.txt
+pyproject.toml
+src/devicer/__init__.py
+src/devicer/confidence.py
+src/devicer/confidence_test.py
+src/devicer/data_test.py
+src/devicer/hashing.py
+src/devicer/hashing_test.py
+src/devicer.py.egg-info/PKG-INFO
+src/devicer.py.egg-info/SOURCES.txt
+src/devicer.py.egg-info/dependency_links.txt
+src/devicer.py.egg-info/requires.txt
+src/devicer.py.egg-info/top_level.txt

devicer_py-0.1.0/src/devicer.py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

devicer_py-0.1.0/src/devicer.py.egg-info/requires.txt

@@ -0,0 +1 @@
+py-tlsh>=4.7.2

devicer_py-0.1.0/src/devicer.py.egg-info/top_level.txt

@@ -0,0 +1 @@
+devicer