Remove security and data classification tools

Deleted security analysis and data classification tools from both Python and Java codebases, including related handlers and tool registrations. This streamlines the codebase by removing unused or deprecated endpoints and features.

Author: DaCodeChick

bridge_mcp_ghidra/tools/functions.py

@@ -4,82 +4,6 @@
 def register_function_tools(mcp: FastMCP):
 	"""Register function-related tools to the FastMCP instance."""
 
-	@mcp.tool()
-	def analyze_control_flow(function_name: str) -> dict:
-		"""
-		Analyze control flow complexity, cyclomatic complexity, and basic blocks.
-		Provides detailed analysis of function complexity and structure.
-		
-		Args:
-			function_name: Name of the function to analyze
-			
-		Returns:
-			Dictionary with control flow analysis results
-		"""
-
-		if not ghidra_context.validate_function_name(function_name):
-			raise GhidraValidationError(f"Invalid function name: {function_name}")
-
-		return ghidra_context.http_client.safe_get("analyze_control_flow", {"function_name": function_name})
-
-	@mcp.tool()
-	def analyze_function_complexity(function_name: str) -> dict:
-		"""
-		Calculate various complexity metrics for a function.
-		Includes cyclomatic complexity, lines of code, branch count, etc.
-		
-		Args:
-			function_name: Name of the function to analyze
-			
-		Returns:
-			Dictionary with complexity metrics
-		"""
-
-		if not validate_function_name(function_name):
-			raise GhidraValidationError(f"Invalid function name: {function_name}")
-
-		return ghidra_context.http_client.safe_get("analyze_function_complexity", {"function_name": function_name})
-
-	@mcp.tool()
-	def batch_decompile_functions(function_names: list) -> dict:
-		"""
-		Decompile multiple functions in a single request for better performance.
-		
-		Args:
-			function_names: List of function names to decompile
-			
-		Returns:
-			Dictionary mapping function names to their decompiled code
-		"""
-		
-		# Validate all function names
-		for name in function_names:
-			if not validate_function_name(name):
-				raise GhidraValidationError(f"Invalid function name: {name}")
-
-		return ghidra_context.http_client.safe_get("batch_decompile", {"functions": ",".join(function_names)})
-
-	@mcp.tool()
-	def batch_rename_functions(renames: dict) -> dict:
-		"""
-		Rename multiple functions atomically.
-		
-		Args:
-			renames: Dictionary mapping old names to new names
-			
-		Returns:
-			Dictionary with rename results and any errors
-		"""
-
-		# Validate all function names
-		for old_name, new_name in renames.items():
-			if not validate_function_name(old_name):
-				raise GhidraValidationError(f"Invalid old function name: {old_name}")
-			if not validate_function_name(new_name):
-				raise GhidraValidationError(f"Invalid new function name: {new_name}")
-
-		return ghidra_context.http_client.safe_get("batch_rename_functions", {"renames": str(renames)})
-
 	@mcp.tool()
 	def create_function_signature(name: str, return_type: str, parameters: str = None) -> str:
 		"""
@@ -142,44 +66,6 @@ def disassemble_function(address: str) -> list:
 
 		return ghidra_context.http_client.safe_get("disassemble_function", {"address": address})
 
-	@mcp.tool()
-	def find_dead_code(function_name: str) -> list:
-		"""
-		Identify potentially unreachable code blocks within a function.
-		Useful for finding hidden functionality or dead code elimination.
-		
-		Args:
-			function_name: Name of the function to analyze
-			
-		Returns:
-			List of potentially unreachable code blocks with addresses
-		"""
-		if not ghidra_context.validate_function_name(function_name):
-			raise GhidraValidationError(f"Invalid function name: {function_name}")
-
-		return ghidra_context.http_client.safe_get("find_dead_code", {"function_name": function_name})
-
-	@mcp.tool()
-	def find_similar_functions(target_function: str, threshold: float = 0.8) -> list:
-		"""
-		Find functions similar to target using structural analysis.
-		Uses control flow and instruction patterns to identify similar functions.
-		
-		Args:
-			target_function: Name of the function to compare against
-			threshold: Similarity threshold (0.0 to 1.0, higher = more similar)
-			
-		Returns:
-			List of similar functions with similarity scores
-		"""
-		if not ghidra_context.validate_function_name(target_function):
-			raise GhidraValidationError(f"Invalid function name: {target_function}")
-
-		return ghidra_context.http_client.safe_get("find_similar_functions", {
-			"target_function": target_function,
-			"threshold": threshold
-		})
-	
 	@mcp.tool()
 	def get_current_function() -> str:
 		"""

bridge_mcp_ghidra/tools/globals.py

@@ -89,4 +89,4 @@ def rename_global_variable(old_name: str, new_name: str) -> str:
 		return ghidra_context.http_client.safe_post("rename_global_variable", {
 			"old_name": old_name,
 			"new_name": new_name
-		})
+		})

bridge_mcp_ghidra/tools/security.py

@@ -124,106 +124,6 @@ def clone_data_type(source_type: str, new_name: str) -> str:
 
 		return ghidra_context.http_client.safe_post("clone_data_type", {"source_type": source_type, "new_name": new_name})
 
-	@mcp.tool()
-	def create_and_apply_data_type(
-		address: str,
-		classification: str,
-		name: str = None,
-		comment: str = None,
-		type_definition: str | dict = None
-	) -> str:
-		"""
-		Apply data type, name, and comment in a single atomic operation.
-
-		This tool combines create_struct + apply_data_type + rename_data + set_comment
-		into one atomic operation, ensuring consistency and reducing round-trips.
-
-		Args:
-			address: Target address (e.g., "0x6fb835b8")
-			classification: Data classification: "PRIMITIVE", "STRUCTURE", or "ARRAY"
-			name: Name to apply (optional, only if meaningful)
-			comment: Comment to apply (optional)
-			type_definition: JSON string (NOT dict) with type definition:
-							For PRIMITIVE: '{\"type\": \"dword\"}'  # ← Note the quotes
-							For STRUCTURE: '{\"name\": \"StructName\", \"fields\": [...]}'
-							For ARRAY: '{\"element_type\": \"dword\", \"count\": 64}'
-									or '{\"element_struct\": \"StructName\", \"count\": 10}'
-
-							IMPORTANT: Must be a JSON string, not a Python dict.
-							Use json.dumps() if constructing programmatically.
-
-							Example (CORRECT):
-								create_and_apply_data_type(
-									address=\"0x6fb835b8\",
-									classification=\"ARRAY\",
-									name=\"MyArray\",
-									type_definition='{\"element_type\": \"dword\", \"count\": 7}'  # JSON string
-								)
-
-							Example (INCORRECT):
-								type_definition={\"element_type\": \"dword\", \"count\": 7}  # Will fail validation
-
-		Returns:
-			Success message with all operations performed:
-			\"Successfully applied classification at 0x6fb835b8:
-			- Created structure: PreTableConfigData (28 bytes)
-			- Applied data type: PreTableConfigData
-			- Renamed to: PreFrameThresholdConfig
-			- Added comment: 28-byte configuration structure...\"
-		"""
-		import json
-
-		if not validate_hex_address(address):
-			raise GhidraValidationError(f"Invalid hex address format: {address}")
-
-		valid_classifications = ["PRIMITIVE", "STRUCTURE", "ARRAY", "STRING"]
-		if classification not in valid_classifications:
-			raise GhidraValidationError(f"Classification must be one of: {', '.join(valid_classifications)}")
-
-		# CONTENT VERIFICATION: Check for string misidentification
-		# Only verify for PRIMITIVE and ARRAY (where misidentification is common)
-		if classification in ["PRIMITIVE", "ARRAY"]:
-			verification = _verify_content_before_classification(address)
-
-			if verification["is_string"]:
-				ghidra_context.http_client.logger.warning(
-					f"String detected at {address} but classification is {classification}. "
-					f"Detected: \"{verification['detected_string']}\" "
-					f"(printable ratio: {verification['printable_ratio']:.2f})"
-				)
-				ghidra_context.http_client.logger.warning(verification["recommendation"])
-
-				# Auto-correct to STRING classification if highly confident
-				if verification["printable_ratio"] >= 0.8:
-					ghidra_context.http_client.logger.info(f"Auto-correcting classification from {classification} to STRING")
-					classification = "STRING"
-					# Override type_definition with detected string type
-					if verification["suggested_type"]:
-						type_definition = json.dumps({"type": verification["suggested_type"]})
-
-		data = {
-			"address": address,
-			"classification": classification
-		}
-
-		if name:
-			data["name"] = name
-		if comment:
-			data["comment"] = comment
-		if type_definition:
-			try:
-				if not isinstance(type_definition, str):
-					raise GhidraValidationError(
-						"type_definition must be a JSON string (use json.dumps() if needed), "
-						f"got {type(type_definition).__name__}"
-					)
-				type_def = json.loads(type_definition)
-				data["type_definition"] = type_def
-			except json.JSONDecodeError as e:
-				raise GhidraValidationError(f"Invalid JSON in type_definition: {str(e)}")
-
-		return ghidra_context.http_client.safe_post_json("apply_data_classification", data)
-
 	@mcp.tool()
 	def create_pointer_type(base_type: str, name: str = None) -> str:
 		"""