saidsurucu
9b43070754
Applied automatic fixes for 315 out of 597 linting errors: - Remove unused imports (F401) - Fix f-string without placeholders (F541) - Split multiple imports (E401) - Remove redundant import aliases Remaining 272 errors are mostly style issues: - 164 E701: Multiple statements on one line (colon) - 70 E402: Module import not at top of file - 13 F841: Unused variables - Various other style warnings Code functionality unchanged - all fixes are cosmetic improvements.
238 lines
10 KiB
Python
238 lines
10 KiB
Python
#!/usr/bin/env python3
|
|
|
|
"""
|
|
Analyze KİK v2 hash generation by examining JavaScript code patterns
|
|
and trying to reverse engineer the hash generation logic.
|
|
"""
|
|
|
|
import asyncio
|
|
import json
|
|
import hashlib
|
|
import base64
|
|
from fastmcp import Client
|
|
from mcp_server_main import app
|
|
|
|
def analyze_webpack_hash_patterns():
|
|
"""
|
|
Analyze the webpack JavaScript code you provided to find hash generation patterns
|
|
"""
|
|
print("🔍 Analyzing webpack hash generation patterns...")
|
|
|
|
# From the JavaScript code, I can see several hash/ID generation patterns:
|
|
hash_patterns = {
|
|
# Webpack chunk system hashes (from the JS code)
|
|
"webpack_chunks": {
|
|
315: "d9a9486a4f5ba326",
|
|
531: "cd8fb385c88033ae",
|
|
671: "04c48b287646627a",
|
|
856: "682c9a7b87351f90",
|
|
1017: "9de022378fc275f6",
|
|
# ... many more from the __webpack_require__.u function
|
|
},
|
|
|
|
# Symbol generation from Zone.js
|
|
"zone_symbols": [
|
|
"__zone_symbol__",
|
|
"__Zone_symbol_prefix",
|
|
"Zone.__symbol__"
|
|
],
|
|
|
|
# Angular module federation patterns
|
|
"module_federation": [
|
|
"__webpack_modules__",
|
|
"__webpack_module_cache__",
|
|
"__webpack_require__"
|
|
]
|
|
}
|
|
|
|
# The target hash format
|
|
target_hash = "42f9bcd59e0dfbca36dec9accf5686c7a92aa97724cd8fc3550beb84b80409da"
|
|
print(f"🎯 Target hash: {target_hash}")
|
|
print(f" Length: {len(target_hash)} characters")
|
|
print(f" Format: {'SHA256' if len(target_hash) == 64 else 'Other'} (64 chars = SHA256)")
|
|
|
|
return hash_patterns
|
|
|
|
def test_webpack_style_hashing(data_dict):
|
|
"""Test webpack-style hash generation methods"""
|
|
hashes = {}
|
|
|
|
for key, value in data_dict.items():
|
|
test_string = str(value)
|
|
|
|
# Try various webpack-style hash methods
|
|
hashes[f"webpack_md5_{key}"] = hashlib.md5(test_string.encode()).hexdigest()
|
|
hashes[f"webpack_sha1_{key}"] = hashlib.sha1(test_string.encode()).hexdigest()
|
|
hashes[f"webpack_sha256_{key}"] = hashlib.sha256(test_string.encode()).hexdigest()
|
|
|
|
# Try with various prefixes/suffixes (common in webpack)
|
|
prefixed = f"__webpack__{test_string}"
|
|
hashes[f"webpack_prefixed_sha256_{key}"] = hashlib.sha256(prefixed.encode()).hexdigest()
|
|
|
|
# Try with module federation style
|
|
module_style = f"shell:{test_string}"
|
|
hashes[f"module_fed_sha256_{key}"] = hashlib.sha256(module_style.encode()).hexdigest()
|
|
|
|
# Try JSON stringified
|
|
json_style = json.dumps({"id": value, "type": "decision"}, separators=(',', ':'))
|
|
hashes[f"json_sha256_{key}"] = hashlib.sha256(json_style.encode()).hexdigest()
|
|
|
|
# Try with timestamp or sequence
|
|
with_seq = f"{test_string}_0"
|
|
hashes[f"seq_sha256_{key}"] = hashlib.sha256(with_seq.encode()).hexdigest()
|
|
|
|
return hashes
|
|
|
|
def test_angular_routing_hashes(data_dict):
|
|
"""Test Angular routing/state management hash generation"""
|
|
hashes = {}
|
|
|
|
for key, value in data_dict.items():
|
|
# Angular often uses route parameters for hash generation
|
|
route_style = f"/kurul-kararlari/{value}"
|
|
hashes[f"route_sha256_{key}"] = hashlib.sha256(route_style.encode()).hexdigest()
|
|
|
|
# Component state style
|
|
state_style = f"KurulKararGoster_{value}"
|
|
hashes[f"state_sha256_{key}"] = hashlib.sha256(state_style.encode()).hexdigest()
|
|
|
|
# Angular module style
|
|
module_style = f"kik.kurul.karar.{value}"
|
|
hashes[f"module_sha256_{key}"] = hashlib.sha256(module_style.encode()).hexdigest()
|
|
|
|
return hashes
|
|
|
|
def test_base64_encoding_variants(data_dict):
|
|
"""Test various base64 and encoding variants"""
|
|
hashes = {}
|
|
|
|
for key, value in data_dict.items():
|
|
test_string = str(value)
|
|
|
|
# Try base64 encoding then hashing
|
|
b64_encoded = base64.b64encode(test_string.encode()).decode()
|
|
hashes[f"b64_sha256_{key}"] = hashlib.sha256(b64_encoded.encode()).hexdigest()
|
|
|
|
# Try URL-safe base64
|
|
b64_url = base64.urlsafe_b64encode(test_string.encode()).decode()
|
|
hashes[f"b64url_sha256_{key}"] = hashlib.sha256(b64_url.encode()).hexdigest()
|
|
|
|
# Try hex encoding
|
|
hex_encoded = test_string.encode().hex()
|
|
hashes[f"hex_sha256_{key}"] = hashlib.sha256(hex_encoded.encode()).hexdigest()
|
|
|
|
return hashes
|
|
|
|
async def test_hash_generation_comprehensive():
|
|
print("🔐 Comprehensive KİK document hash generation analysis...")
|
|
print("=" * 70)
|
|
|
|
# First analyze the webpack patterns
|
|
webpack_patterns = analyze_webpack_hash_patterns()
|
|
|
|
client = Client(app)
|
|
|
|
async with client:
|
|
print("✅ MCP client connected")
|
|
|
|
# Get sample decisions
|
|
print("\n📊 Getting sample decisions for hash analysis...")
|
|
search_result = await client.call_tool("search_kik_v2_decisions", {
|
|
"decision_type": "uyusmazlik",
|
|
"karar_metni": "2024"
|
|
})
|
|
|
|
if hasattr(search_result, 'content') and search_result.content:
|
|
search_data = json.loads(search_result.content[0].text)
|
|
decisions = search_data.get('decisions', [])
|
|
|
|
if decisions:
|
|
print(f"✅ Found {len(decisions)} decisions")
|
|
|
|
# Test with first decision
|
|
sample_decision = decisions[0]
|
|
print("\n📋 Sample decision for hash analysis:")
|
|
for key, value in sample_decision.items():
|
|
print(f" {key}: {value}")
|
|
|
|
target_hash = "42f9bcd59e0dfbca36dec9accf5686c7a92aa97724cd8fc3550beb84b80409da"
|
|
print(f"\n🎯 Target hash to match: {target_hash}")
|
|
|
|
all_hashes = {}
|
|
|
|
# Test different hash generation methods
|
|
print("\n🔨 Testing webpack-style hashing...")
|
|
webpack_hashes = test_webpack_style_hashing(sample_decision)
|
|
all_hashes.update(webpack_hashes)
|
|
|
|
print("🔨 Testing Angular routing hashes...")
|
|
angular_hashes = test_angular_routing_hashes(sample_decision)
|
|
all_hashes.update(angular_hashes)
|
|
|
|
print("🔨 Testing base64 encoding variants...")
|
|
b64_hashes = test_base64_encoding_variants(sample_decision)
|
|
all_hashes.update(b64_hashes)
|
|
|
|
# Check for matches
|
|
print("\n🎯 Checking for hash matches...")
|
|
matches_found = []
|
|
partial_matches = []
|
|
|
|
for hash_name, hash_value in all_hashes.items():
|
|
if hash_value == target_hash:
|
|
matches_found.append((hash_name, hash_value))
|
|
print(f" 🎉 EXACT MATCH FOUND: {hash_name}")
|
|
elif hash_value[:8] == target_hash[:8]: # First 8 chars match
|
|
partial_matches.append((hash_name, hash_value))
|
|
print(f" 🔍 Partial match (first 8): {hash_name} -> {hash_value[:16]}...")
|
|
elif hash_value[-8:] == target_hash[-8:]: # Last 8 chars match
|
|
partial_matches.append((hash_name, hash_value))
|
|
print(f" 🔍 Partial match (last 8): {hash_name} -> ...{hash_value[-16:]}")
|
|
|
|
if not matches_found and not partial_matches:
|
|
print(" ❌ No matches found")
|
|
print("\n📝 Sample generated hashes (first 10):")
|
|
for i, (hash_name, hash_value) in enumerate(list(all_hashes.items())[:10]):
|
|
print(f" {hash_name}: {hash_value}")
|
|
|
|
# Try combinations with other decisions
|
|
print("\n🔄 Testing hash combinations with multiple decisions...")
|
|
if len(decisions) > 1:
|
|
for i, decision in enumerate(decisions[1:3]): # Test 2 more
|
|
print(f"\n Testing decision {i+2}: {decision.get('kararNo')}")
|
|
decision_hashes = test_webpack_style_hashing(decision)
|
|
|
|
for hash_name, hash_value in decision_hashes.items():
|
|
if hash_value == target_hash:
|
|
print(f" 🎉 MATCH FOUND in decision {i+2}: {hash_name}")
|
|
matches_found.append((f"decision_{i+2}_{hash_name}", hash_value))
|
|
|
|
# Try composite hashes (combining multiple fields)
|
|
print("\n🔗 Testing composite hash generation...")
|
|
composite_tests = [
|
|
f"{sample_decision.get('gundemMaddesiId')}_{sample_decision.get('kararNo')}",
|
|
f"{sample_decision.get('kararNo')}_{sample_decision.get('kararTarihi')}",
|
|
f"uyusmazlik_{sample_decision.get('gundemMaddesiId')}_{sample_decision.get('kararTarihi')}",
|
|
json.dumps(sample_decision, separators=(',', ':'), sort_keys=True),
|
|
f"{sample_decision.get('basvuran')}_{sample_decision.get('gundemMaddesiId')}",
|
|
]
|
|
|
|
for i, composite_str in enumerate(composite_tests):
|
|
composite_hash = hashlib.sha256(composite_str.encode()).hexdigest()
|
|
if composite_hash == target_hash:
|
|
print(f" 🎉 COMPOSITE MATCH FOUND: test_{i} -> {composite_str[:50]}...")
|
|
matches_found.append((f"composite_{i}", composite_hash))
|
|
|
|
print("\n🎯 Hash analysis completed!")
|
|
print(f" Total matches found: {len(matches_found)}")
|
|
print(f" Partial matches: {len(partial_matches)}")
|
|
|
|
else:
|
|
print("❌ No decisions found")
|
|
else:
|
|
print("❌ Search failed")
|
|
|
|
print("=" * 70)
|
|
|
|
if __name__ == "__main__":
|
|
asyncio.run(test_hash_generation_comprehensive()) |