osn-selenium 0.0.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

osn_selenium/javascript/fingerprint/spoof/rules.py

@@ -0,0 +1,313 @@
+from pydantic import Field
+from typing import (
+	Dict,
+	Literal,
+	Optional
+)
+from osn_selenium.javascript._functions import convert_to_js_value
+from osn_selenium.javascript.fingerprint._functions import add_code_level
+from osn_selenium.javascript.fingerprint.spoof.noise import (
+	RandomNoise,
+	StaticNoise
+)
+from osn_selenium.javascript.fingerprint.spoof._typehints import (
+	RANDOM_VALUE_TYPEHINT
+)
+from osn_selenium.javascript.fingerprint.spoof.core_rules import (
+	ArrayRule,
+	BaseRule,
+	RandomRule
+)
+from osn_selenium.javascript.fingerprint.spoof._functions import (
+	get_noise_js,
+	get_random_expression_js
+)
+from osn_selenium.javascript.fingerprint.spoof._templates import (
+	CUSTOM_RULE,
+	PERSISTED_RANDOM_ITEM_NOISE,
+	PERSISTED_RANDOM_ITEM_SET,
+	PERSISTENCE_CHECK_NOISE,
+	PERSISTENCE_CHECK_RETURN,
+	PERSISTENCE_SAVE_NOISE,
+	PERSISTENCE_SAVE_RESULT,
+	RANDOM_ITEM_NOISE,
+	RANDOM_ITEM_SET,
+	STATIC_ITEM_NOISE,
+	STATIC_ITEM_SET
+)
+
+
+__all__ = [
+	"CustomRule",
+	"RandomArrayNoiseRule",
+	"RandomArraySetRule",
+	"RandomItemNoiseRule",
+	"RandomItemSetRule",
+	"StaticArrayNoiseRule",
+	"StaticArraySetRule",
+	"StaticItemNoiseRule",
+	"StaticItemSetRule"
+]
+
+
+class StaticItemSetRule(BaseRule):
+	"""
+	Rule to replace a value with a static constant.
+	"""
+	
+	mode: Literal["static_item_set"] = "static_item_set"
+	
+	def generate_js(self, path: str) -> str:
+		"""
+		Generates JS to return a fixed value.
+
+		Args:
+			path (str): The object path.
+
+		Returns:
+			str: The generated JS.
+		"""
+		
+		return STATIC_ITEM_SET.format(result_value=convert_to_js_value(self.value))
+
+
+class StaticItemNoiseRule(BaseRule):
+	"""
+	Rule to apply static noise to a value.
+	"""
+	
+	mode: Literal["static_item_noise"] = "static_item_noise"
+	value: StaticNoise
+	
+	def generate_js(self, path: str) -> str:
+		"""
+		Generates JS to apply calculated static noise.
+
+		Args:
+			path (str): The object path.
+
+		Returns:
+			str: The generated JS.
+		"""
+		
+		expression = get_noise_js(
+				target="originalValue",
+				noise=str(self.value.value),
+				operation=self.value.operation,
+				round_result=self.value.round,
+				precision=self.value.precision,
+		)
+		
+		return STATIC_ITEM_NOISE.format(math_expression=expression)
+
+
+class StaticArraySetRule(ArrayRule):
+	"""
+	Rule to replace elements in an array with static values.
+	"""
+	
+	mode: Literal["static_array_set"] = "static_array_set"
+	
+	def generate_js(self, path: str) -> str:
+		"""
+		Generates JS to loop through array and set static values.
+
+		Args:
+			path (str): The object path.
+
+		Returns:
+			str: The generated JS.
+		"""
+		
+		def get_expr(item):
+			return convert_to_js_value(item)
+		
+		return self._generate_array_js(get_expr)
+
+
+class StaticArrayNoiseRule(ArrayRule):
+	"""
+	Rule to apply static noise to elements in an array.
+	"""
+	
+	mode: Literal["static_array_noise"] = "static_array_noise"
+	value_by_channel: Dict[int, StaticNoise] = Field(default_factory=dict)
+	
+	def generate_js(self, path: str) -> str:
+		"""
+		Generates JS to loop through array and apply static noise.
+
+		Args:
+			path (str): The object path.
+
+		Returns:
+			str: The generated JS.
+		"""
+		
+		def get_expr(item):
+			return get_noise_js(
+					target="dataArray[i]",
+					noise=str(item.value),
+					operation=item.operation,
+					round_result=item.round,
+					precision=item.precision,
+			)
+		
+		return self._generate_array_js(get_expr)
+
+
+class RandomItemSetRule(RandomRule):
+	"""
+	Rule to replace a value with a randomly generated one.
+	"""
+	
+	mode: Literal["random_item_set"] = "random_item_set"
+	
+	def generate_js(self, path: str) -> str:
+		"""
+		Generates JS to return a random value, optionally persisted.
+
+		Args:
+			path (str): The object path.
+
+		Returns:
+			str: The generated JS.
+		"""
+		
+		if self.persist:
+			storage_key = f"prop_{path.replace('.', '_')}"
+		
+			return PERSISTED_RANDOM_ITEM_SET.format(
+					persistence_check_code=add_code_level(code=PERSISTENCE_CHECK_RETURN.format(storage_key=storage_key), num=1),
+					calculation_expression=get_random_expression_js(self.value),
+					persistence_save_code=PERSISTENCE_SAVE_RESULT.format(storage_key=storage_key)
+			)
+		
+		return RANDOM_ITEM_SET.format(calculation_expression=get_random_expression_js(self.value))
+
+
+class RandomItemNoiseRule(RandomRule):
+	"""
+	Rule to apply random noise to a value.
+	"""
+	
+	mode: Literal["random_item_noise"] = "random_item_noise"
+	
+	def generate_js(self, path: str) -> str:
+		"""
+		Generates JS to apply random noise, optionally persisted.
+
+		Args:
+			path (str): The object path.
+
+		Returns:
+			str: The generated JS.
+		"""
+		
+		storage_key = f"prop_{path.replace('.', '_')}"
+		
+		math_expression = get_noise_js(
+				target="originalValue",
+				noise="noiseValue",
+				operation=self.value.operation,
+				round_result=self.value.round,
+				precision=self.value.precision,
+		)
+		
+		if self.persist:
+			return PERSISTED_RANDOM_ITEM_NOISE.format(
+					persistence_check_code=add_code_level(
+							code=PERSISTENCE_CHECK_NOISE.format(storage_key=storage_key, math_expression_with_noise=math_expression),
+							num=1
+					),
+					calculation_expression=get_random_expression_js(self.value.value),
+					persistence_save_code=PERSISTENCE_SAVE_NOISE.format(storage_key=storage_key),
+					math_expression=math_expression
+			)
+		
+		return RANDOM_ITEM_NOISE.format(
+				calculation_expression=get_random_expression_js(self.value.value),
+				math_expression=math_expression
+		)
+
+
+class RandomArraySetRule(ArrayRule):
+	"""
+	Rule to replace elements in an array with random values.
+	"""
+	
+	mode: Literal["random_array_set"] = "random_array_set"
+	value: Optional[RANDOM_VALUE_TYPEHINT]
+	value_by_channel: Dict[int, RANDOM_VALUE_TYPEHINT] = Field(default_factory=dict)
+	
+	def generate_js(self, path: str) -> str:
+		"""
+		Generates JS to loop through array and set random values.
+
+		Args:
+			path (str): The object path.
+
+		Returns:
+			str: The generated JS.
+		"""
+		
+		def get_expr(item):
+			return get_random_expression_js(item)
+		
+		return self._generate_array_js(get_expr)
+
+
+class RandomArrayNoiseRule(ArrayRule):
+	"""
+	Rule to apply random noise to elements in an array.
+	"""
+	
+	mode: Literal["random_array_noise"] = "random_array_noise"
+	value: Optional[RandomNoise]
+	value_by_channel: Dict[int, RandomNoise] = Field(default_factory=dict)
+	
+	def generate_js(self, path: str) -> str:
+		"""
+		Generates JS to loop through array and apply random noise.
+
+		Args:
+			path (str): The object path.
+
+		Returns:
+			str: The generated JS.
+		"""
+		
+		def get_expr(item):
+			noise_expr = get_random_expression_js(item.value)
+			
+			return get_noise_js(
+					target="dataArray[i]",
+					noise=noise_expr,
+					operation=item.operation,
+					round_result=item.round,
+					precision=item.precision,
+			)
+		
+		return self._generate_array_js(get_expr)
+
+
+class CustomRule(BaseRule):
+	"""
+	Rule to apply custom JavaScript code.
+	"""
+	
+	mode: Literal["custom"] = "custom"
+	value: str
+	
+	def generate_js(self, path: str) -> str:
+		"""
+		Generates the custom JS injection.
+
+		Args:
+			path (str): The object path.
+
+		Returns:
+			str: The generated JS.
+		"""
+		
+		return CUSTOM_RULE.format(custom_javascript_code=self.value)

osn_selenium/javascript/functions.py

@@ -0,0 +1,44 @@
+import pathlib
+from typing import Optional
+from pydantic import ValidationError
+from osn_selenium.javascript.models import JS_Scripts
+from osn_selenium.exceptions.javascript import (
+	JavaScriptResourceError
+)
+
+
+__all__ = ["get_js_scripts"]
+
+_CACHED_JS_SCRIPTS: Optional[JS_Scripts] = None
+
+
+def get_js_scripts() -> JS_Scripts:
+	"""
+	Reads JavaScript scripts from files and returns them in a JS_Scripts object.
+
+	This function locates all `.js` files within the 'scripts' directory, which is expected
+	to be located in the same parent directory as this module. It reads the content of each
+	JavaScript file using UTF-8 encoding and stores these scripts in a `JS_Scripts` model.
+	The filenames (without the `.js` extension) are used as keys.
+
+	Returns:
+		JS_Scripts: An object containing the content of each JavaScript file as attributes.
+	"""
+	
+	global _CACHED_JS_SCRIPTS
+	
+	if _CACHED_JS_SCRIPTS is None:
+		scripts = {}
+		path_to_js_scripts = pathlib.Path(__file__).parent / "scripts"
+	
+		for script_file in path_to_js_scripts.iterdir():
+			scripts[script_file.stem] = script_file.read_text(encoding="utf-8")
+	
+		try:
+			_CACHED_JS_SCRIPTS = JS_Scripts.model_validate(scripts)
+		except ValidationError as exception:
+			missing_fields = [error["loc"][0] for error in exception.errors()]
+	
+			raise JavaScriptResourceError(missing_script=missing_fields)
+	
+	return _CACHED_JS_SCRIPTS

osn_selenium/javascript/models.py

@@ -0,0 +1,35 @@
+from osn_selenium.models import DictModel
+
+
+__all__ = ["JS_Scripts"]
+
+
+class JS_Scripts(DictModel):
+	"""
+	Represents a collection of JavaScript script snippets for use with WebDriver.
+
+	Attributes:
+		check_element_in_viewport (str): JS to check if element is in the viewport.
+		get_document_scroll_size (str): JS to get total scrollable dimensions.
+		get_element_css (str): JS to get computed CSS styles of an element.
+		get_element_rect_in_viewport (str): JS to get element bounds in viewport.
+		get_random_element_point_in_viewport (str): JS to get a random visible point in element.
+		get_viewport_position (str): JS to get scroll position of viewport.
+		get_viewport_rect (str): JS to get viewport scroll offset and dimensions.
+		get_viewport_size (str): JS to get dimensions of the viewport.
+		open_new_tab (str): JS to open a new tab.
+		start_fingerprint_detection (str): JS to initialize fingerprint detection hooks.
+		stop_window_loading (str): JS to stop the page from loading.
+	"""
+	
+	check_element_in_viewport: str
+	get_document_scroll_size: str
+	get_element_css: str
+	get_element_rect_in_viewport: str
+	get_random_element_point_in_viewport: str
+	get_viewport_position: str
+	get_viewport_rect: str
+	get_viewport_size: str
+	open_new_tab: str
+	start_fingerprint_detection: str
+	stop_window_loading: str

osn_selenium/javascript/scripts/start_fingerprint_detection.js

@@ -0,0 +1,56 @@
+function start_fingerprint_detection(settings) {
+    const CONFIG = {
+        BINDING: '__osn_fingerprint_report__',
+        SILENT_ERRORS: true,
+        EVENTS_OPTIMIZATION: settings.optimize_events
+    };
+
+    const MODIFIERS = {};
+__MODIFIERS_PLACEHOLDER__
+
+    const STORAGE = new Map();
+
+    const hookedRegistry = new WeakSet();
+    const sentEvents = new Set();
+
+    function guard(fn, fallback = undefined) {
+        try {
+            return fn();
+        } catch (e) {
+            if (!CONFIG.SILENT_ERRORS) console.error('FingerprintHook Error:', e);
+            return fallback;
+        }
+    }
+
+    const Reporter = {
+        send(api, target, method) {
+            guard(() => {
+                if (CONFIG.EVENTS_OPTIMIZATION) {
+                    const key = `${api}:${target}:${method}`;
+
+                    if (sentEvents.has(key)) return;
+
+                    sentEvents.add(key);
+                }
+
+                const reportFn = window[CONFIG.BINDING];
+
+                if (typeof reportFn === 'function') {
+                    const stack = (new Error()).stack;
+
+                    const payload = JSON.stringify({
+                        api: api,
+                        used_method: `${target}.${method}`,
+                        stacktrace: stack
+                    });
+
+                    reportFn(payload);
+                }
+            });
+        }
+    };
+
+__DETECTION_PLACEHOLDER__
+}
+
+start_fingerprint_detection(__SETTINGS__PLACEHOLDER__);

osn_selenium/models.py

@@ -0,0 +1,139 @@
+from typing import Self
+from pydantic import (
+	BaseModel,
+	ConfigDict
+)
+
+
+__all__ = [
+	"DictModel",
+	"ExtraDictModel",
+	"Point",
+	"Position",
+	"Rectangle",
+	"Size",
+	"WindowRect"
+]
+
+
+class DictModel(BaseModel):
+	"""
+	Base class for Pydantic models with a predefined configuration.
+
+	This configuration enforces strict validation rules such as forbidding extra
+	fields and stripping whitespace from string inputs.
+	"""
+	
+	model_config = ConfigDict(
+			populate_by_name=True,
+			extra="forbid",
+			use_enum_values=True,
+			str_strip_whitespace=True,
+			validate_assignment=True,
+	)
+
+
+class WindowRect(DictModel):
+	"""
+	Defines a window's geometry with default values relative to screen size.
+
+	The default values position the window in the center of the screen,
+	occupying a significant portion of it.
+
+	Attributes:
+		x (int): The x-coordinate of the window's top-left corner. Defaults to 100.
+		y (int): The y-coordinate of the window's top-left corner. Defaults to 100.
+		width (int): The width of the window. Defaults to 400.
+		height (int): The height of the window. Defaults to 400.
+	"""
+	
+	x: int = 100
+	y: int = 100
+	width: int = 1024
+	height: int = 768
+
+
+class Size(DictModel):
+	"""
+	Represents a 2D size.
+
+	Attributes:
+		width (int): The width dimension.
+		height (int): The height dimension.
+	"""
+	
+	width: int
+	height: int
+
+
+class Rectangle(DictModel):
+	"""
+	Defines a rectangle by its top-left corner and dimensions.
+
+	Attributes:
+		x (int): The x-coordinate of the top-left corner.
+		y (int): The y-coordinate of the top-left corner.
+		width (int): The width of the rectangle.
+		height (int): The height of the rectangle.
+	"""
+	
+	x: int
+	y: int
+	width: int
+	height: int
+
+
+class Position(DictModel):
+	"""
+	Represents a 2D coordinate.
+
+	Attributes:
+		x (int): The x-coordinate.
+		y (int): The y-coordinate.
+	"""
+	
+	x: int
+	y: int
+
+
+class Point:
+	"""
+	Represents a 2D point with integer coordinates (x, y).
+
+	Attributes:
+		x (int): The horizontal coordinate.
+		y (int): The vertical coordinate.
+	"""
+	
+	def __init__(self, x: int, y: int):
+		self.x: int = x
+		self.y: int = y
+	
+	def __repr__(self) -> str:
+		return self.__str__()
+	
+	def __str__(self) -> str:
+		return f"Point(x={self.x}, y={self.y})"
+	
+	def __eq__(self, other: Self) -> bool:
+		return self.x == other.x and self.y == other.y
+	
+	def __ne__(self, other: Self) -> bool:
+		return not self.__eq__(other)
+
+
+class ExtraDictModel(BaseModel):
+	"""
+	Base class for Pydantic models that allows extra fields.
+
+	This configuration allows the model to accept fields that are not
+	explicitly defined in the model's schema.
+	"""
+	
+	model_config = ConfigDict(
+			populate_by_name=True,
+			extra="allow",
+			use_enum_values=True,
+			str_strip_whitespace=True,
+			validate_assignment=True,
+	)