Add files via upload

CPScript · web-flow · commit 0304f699c349 · 2025-03-20T12:45:05.000-04:00
diff --git a/scripts/emulate_card.sh b/scripts/emulate_card.sh
@@ -0,0 +1,57 @@
+#!/bin/bash
+# Script to emulate an NFC card
+
+source ./scripts/card_utils.sh
+
+# Check if UID was passed
+if [ $# -lt 1 ]; then
+    echo "[!] Usage: $0 <card_uid>"
+    exit 1
+fi
+
+CARD_UID="$1"
+CARD_FILE=$(get_card_path "$CARD_UID")
+
+# Verify card exists
+if [ ! -f "$CARD_FILE" ]; then
+    echo "[!] Card not found: $CARD_UID"
+    echo "[!] Available cards:"
+    list_saved_cards
+    exit 1
+fi
+
+echo "[*] Preparing to emulate card: $CARD_UID"
+echo "[*] Card file: $CARD_FILE"
+
+# Create a temporary JSON settings file for the Android app
+TEMP_SETTINGS=$(mktemp)
+cat > "$TEMP_SETTINGS" << EOF
+{
+    "uid": "$CARD_UID",
+    "card_path": "$CARD_FILE",
+    "auto_response": true
+}
+EOF
+
+# Copy settings to a location accessible by the app
+ANDROID_STORAGE_PATH="/storage/emulated/0/Android/data/com.nfcclone.app/files"
+mkdir -p "$ANDROID_STORAGE_PATH"
+cp "$TEMP_SETTINGS" "$ANDROID_STORAGE_PATH/current_card.json"
+rm "$TEMP_SETTINGS"
+
+# Start the NFC Emulator app
+if am start -n com.nfcclone.app/.MainActivity --ez "start_emulation" true; then
+    echo "[+] NFC emulation service started"
+    # Notify user
+    termux-notification --title "NFC Emulation Active" --content "Emulating card: $CARD_UID" --priority high --ongoing
+    termux-toast "Card emulation started for UID: $CARD_UID"
+else
+    echo "[!] Failed to start NFC emulation service"
+    echo "[!] Check if the NFC Clone app is installed correctly"
+    exit 1
+fi
+
+echo "[*] Press Ctrl+C to stop emulation"
+# Wait for user to cancel
+trap 'echo "[*] Stopping emulation"; am broadcast -a com.nfcclone.app.STOP_EMULATION; termux-notification-remove nfc_emulation; echo "[+] Emulation stopped"' INT TERM
+read -r -d '' _ </dev/tty
diff --git a/scripts/read_card.py b/scripts/read_card.py
@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+import nfc
+import os
+import json
+import sys
+import base64
+import time
+import binascii
+from utils import load_config, get_card_path
+
+def on_connect(tag):
+    """Process tag when detected and save its data"""
+    if tag is None:
+        print("[!] No tag detected")
+        return False
+    
+    try:
+        # Extract UID
+        uid = binascii.hexlify(tag.identifier).decode().upper()
+        
+        # Get tag type info
+        tag_info = {
+            "UID": uid,
+            "Type": str(tag),
+            "Technologies": [tech for tech in dir(tag) if not tech.startswith('_') and tech != 'identifier'],
+            "Timestamp": int(time.time()),
+        }
+        
+        # Extract NDEF data if available
+        if hasattr(tag, 'ndef') and tag.ndef:
+            ndef_records = []
+            for record in tag.ndef.records:
+                record_data = {
+                    "type": binascii.hexlify(record.type).decode(),
+                    "name": record.name,
+                    "data": base64.b64encode(record.data).decode('ascii')
+                }
+                if hasattr(record, 'text'):
+                    record_data["text"] = record.text
+                ndef_records.append(record_data)
+            tag_info["NDEF"] = ndef_records
+        
+        # For MIFARE Classic, try to read sectors
+        if hasattr(tag, 'mifare'):
+            sectors_data = {}
+            for sector in range(16):  # Standard MIFARE Classic has 16 sectors
+                try:
+                    blocks = tag.mifare.read_blocks(sector * 4, 4)
+                    sectors_data[f"sector_{sector}"] = binascii.hexlify(blocks).decode()
+                except Exception as e:
+                    sectors_data[f"sector_{sector}"] = f"Error: {str(e)}"
+            tag_info["MIFARE_Data"] = sectors_data
+        
+        # Save the card data
+        config = load_config()
+        card_file = get_card_path(uid)
+        os.makedirs(os.path.dirname(card_file), exist_ok=True)
+        
+        # Save raw dump for advanced analysis
+        tag_info["RawData"] = {
+            "Identifier": binascii.hexlify(tag.identifier).decode(),
+        }
+        
+        # Add raw dumps of any available data
+        if hasattr(tag, 'dump'):
+            raw_dump = tag.dump()
+            tag_info["RawData"]["Dump"] = raw_dump
+        
+        # Add custom response template
+        tag_info["custom_response"] = "9000"  # Default success response
+        
+        with open(card_file, 'w') as f:
+            json.dump(tag_info, f, indent=4)
+        
+        print(f"[+] Card saved: {uid}")
+        print(f"[+] File: {card_file}")
+        return True
+    
+    except Exception as e:
+        print(f"[!] Error processing tag: {str(e)}")
+        return False
+
+def main():
+    """Main function to read an NFC card"""
+    try:
+        config = load_config()
+        reader = config.get('nfc_reader', 'usb')
+        
+        print("[*] Connecting to NFC reader...")
+        with nfc.ContactlessFrontend(reader) as clf:
+            print("[*] Place card on reader...")
+            
+            # Try to read for up to 30 seconds
+            clf.connect(rdwr={'on-connect': on_connect, 'beep-on-connect': True})
+            
+    except KeyboardInterrupt:
+        print("\n[*] Reading cancelled")
+        return 1
+    except Exception as e:
+        print(f"[!] Error: {str(e)}")
+        return 1
+    
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/utils.py b/scripts/utils.py
@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+import json
+import os
+import sys
+import binascii
+
+def load_config():
+    """Load configuration from config.json"""
+    try:
+        with open('config.json', 'r') as f:
+            return json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError) as e:
+        print(f"[!] Error loading config: {str(e)}")
+        return {"card_data_dir": "./cards", "nfc_reader": "usb"}
+
+def get_card_path(uid):
+    """Get the path for a card file based on its UID"""
+    config = load_config()
+    card_data_dir = config.get('card_data_dir', './cards')
+    return os.path.join(card_data_dir, f"card_{uid}.json")
+
+def list_saved_cards():
+    """List all saved cards"""
+    config = load_config()
+    card_data_dir = config.get('card_data_dir', './cards')
+    
+    if not os.path.exists(card_data_dir):
+        print(f"[!] Card directory not found: {card_data_dir}")
+        return []
+    
+    card_files = [f for f in os.listdir(card_data_dir) if f.startswith('card_') and f.endswith('.json')]
+    
+    cards = []
+    for card_file in card_files:
+        try:
+            with open(os.path.join(card_data_dir, card_file), 'r') as f:
+                card_data = json.load(f)
+                uid = card_data.get('UID', 'Unknown')
+                card_type = card_data.get('Type', 'Unknown')
+                timestamp = card_data.get('Timestamp', 0)
+                
+                cards.append({
+                    'uid': uid,
+                    'type': card_type,
+                    'timestamp': timestamp,
+                    'file': card_file
+                })
+        except Exception as e:
+            print(f"[!] Error reading card file {card_file}: {str(e)}")
+    
+    return cards
+
+def parse_hex_string(hex_string):
+    """Convert a hex string to byte array"""
+    try:
+        return binascii.unhexlify(hex_string)
+    except binascii.Error as e:
+        print(f"[!] Invalid hex string: {str(e)}")
+        return None
+
+def analyze_card(uid):
+    """Analyze a saved card and print detailed information"""
+    card_path = get_card_path(uid)
+    
+    if not os.path.exists(card_path):
+        print(f"[!] Card not found: {uid}")
+        return False
+    
+    try:
+        with open(card_path, 'r') as f:
+            card_data = json.load(f)
+        
+        print(f"\n[*] Card Analysis: {uid}")
+        print("-" * 50)
+        print(f"Type: {card_data.get('Type', 'Unknown')}")
+        
+        if 'Technologies' in card_data:
+            print("\nSupported Technologies:")
+            for tech in card_data['Technologies']:
+                print(f"- {tech}")
+        
+        if 'NDEF' in card_data:
+            print("\nNDEF Records:")
+            for i, record in enumerate(card_data['NDEF']):
+                print(f"\nRecord {i+1}:")
+                print(f"  Type: {record.get('type', 'Unknown')}")
+                if 'text' in record:
+                    print(f"  Text: {record['text']}")
+        
+        if 'MIFARE_Data' in card_data:
+            print("\nMIFARE Sectors:")
+            for sector, data in card_data['MIFARE_Data'].items():
+                if not data.startswith('Error'):
+                    print(f"  {sector}: {data[:20]}...")
+                else:
+                    print(f"  {sector}: {data}")
+        
+        return True
+    
+    except Exception as e:
+        print(f"[!] Error analyzing card: {str(e)}")
+        return False
