hardware-hardspoof-spoofing-toolkit

# Run installer as Administrator
.\HardSpoof-Installer.exe
 
# Or manual driver installation
pnputil /add-driver .\drivers\hardsp00f.inf /install
sc create hardsp00f binPath= "C:\Program Files\HardSpoof\hardsp00fd.exe"
sc start hardsp00f

# Basic daemon start
sudo hardsp00fd --daemonize
 
# With specific profile
sudo hardsp00fd --profile /etc/hardsp00f/profiles/stealth.yaml --daemonize
 
# Verbose logging
sudo hardsp00fd --profile stealth_session --verbose 3 --log /var/log/hardsp00f.log

# List available profiles
hardsp00f-cli list-profiles
 
# Create new profile
hardsp00f-cli create-profile --name custom_stealth --template default
 
# Apply profile
hardsp00f-cli apply --profile custom_stealth
 
# Stop spoofing
hardsp00f-cli stop

# Spoof specific interface
hardsp00f-cli spoof-interface eth0 --randomize-mac
 
# Spoof all interfaces
hardsp00f-cli spoof-interface all --mode adaptive
 
# Revert interface
hardsp00f-cli revert-interface eth0

# Check current status
hardsp00f-cli status
 
# Show active spoofs
hardsp00f-cli show-active
 
# Export current configuration
hardsp00f-cli export-config > current_config.yaml

profile:
  name: "stealth_research"
  persona:
    architecture: "random_walk_plus_mode"
    entropy_source: "hardware_thermal_noise"
  
  device_fingerprint:
    cpu:
      vendor: ["GenuineIntel", "AuthenticAMD"]
      cores: [4, 8, 16]
      hyperthreading: true
    memory:
      type: ["DDR4", "DDR5"]
      total_gb: [16, 32]
    storage:
      model: ["Samsung 980 Pro", "WD Black SN850X"]
      interface: "NVMe"
    network:
      mac_vendor: ["Intel Corporation", "Realtek Semiconductor"]
      interface_type: "Gigabit Ethernet"
  
  spoofing_strategy:
    arp:
      enabled: true
      interval_ms: 30000
      jitter_percent: 15
    dns:
      enabled: true
      cache_poison_period: 120
      resolver_rotation: true
      resolvers: ["8.8.8.8", "1.1.1.1", "9.9.9.9"]
    sni:
      enabled: true
      tls_version_probability:
        "1.2": 0.3
        "1.3": 0.7
    browser_header:
      enabled: true
      user_agent_generator: "bayesian_decision_forest"
      canvas_noise_level: 0.02
      webgl_renderer: "ANGLE (Intel, Intel(R) UHD Graphics)"
    packet_spoofing:
      enabled: true
      ttl_variation: [64, 128]
      window_size_variation: true

profile:
  name: "basic_mac_spoof"
  persona:
    architecture: "simple_random"
  
  spoofing_strategy:
    arp:
      enabled: true
      interval_ms: 60000
    dns:
      enabled: false
    sni:
      enabled: false
    browser_header:
      enabled: false

# Set config directory
export HARDSPOOF_CONFIG_DIR=/home/user/.hardspoof
 
# Set log level
export HARDSPOOF_LOG_LEVEL=debug
 
# Set default profile
export HARDSPOOF_DEFAULT_PROFILE=stealth_research
 
# Disable AI integration
export HARDSPOOF_DISABLE_AI=true

from hardspoof import HardSpoofClient, Profile
 
# Initialize client
client = HardSpoofClient(config_dir="/etc/hardsp00f")
 
# Load profile
profile = Profile.from_file("/etc/hardsp00f/profiles/stealth.yaml")
 
# Apply profile
session = client.apply_profile(profile)
 
# Check status
status = session.get_status()
print(f"Active spoofs: {status['active_count']}")
print(f"Current MAC (eth0): {status['interfaces']['eth0']['mac']}")
 
# Stop session
session.stop()

from hardspoof import Profile, DeviceFingerprint, SpoofingStrategy
 
# Create custom profile
profile = Profile(name="custom_test")
 
# Configure device fingerprint
profile.device_fingerprint = DeviceFingerprint(
    cpu_vendor=["GenuineIntel"],
    cpu_cores=[8],
    memory_type=["DDR4"],
    memory_total_gb=[16]
)
 
# Configure spoofing strategy
profile.spoofing_strategy = SpoofingStrategy(
    arp_enabled=True,
    arp_interval_ms=45000,
    dns_enabled=True,
    dns_resolvers=["1.1.1.1", "8.8.8.8"]
)
 
# Save profile
profile.save("/etc/hardsp00f/profiles/custom_test.yaml")
 
# Apply
client.apply_profile(profile)

from hardspoof import NetworkInterface
 
# Get interface
iface = NetworkInterface("eth0")
 
# Randomize MAC
original_mac = iface.get_mac()
iface.randomize_mac(vendor_prefix="Intel Corporation")
print(f"MAC changed from {original_mac} to {iface.get_mac()}")
 
# Set specific MAC
iface.set_mac("00:1A:2B:3C:4D:5E")
 
# Revert to original
iface.revert_mac()

#!/bin/bash
# research_session.sh
 
# Load stealth profile
sudo hardsp00fd --profile research_stealth --daemonize
 
# Wait for initialization
sleep 2
 
# Verify spoofing is active
hardsp00f-cli status
 
# Run your research tools
# tcpdump, nmap, etc.
 
# Cleanup on exit
trap "hardsp00f-cli stop && sudo killall hardsp00fd" EXIT
 
# Keep session alive
while true; do
    sleep 60
    hardsp00f-cli status | grep -q "active: true" || {
        echo "Spoofing session died, restarting..."
        sudo hardsp00fd --profile research_stealth --daemonize
    }
done

from hardspoof import BrowserFingerprint
import requests
 
# Initialize browser fingerprint spoofing
bf = BrowserFingerprint()
bf.enable(
    canvas_noise=0.02,
    webgl_variation=True,
    user_agent_rotation=True
)
 
# Get spoofed headers
headers = bf.get_headers()
 
# Make request with spoofed fingerprint
response = requests.get(
    "https://example.com",
    headers=headers
)
 
# Check fingerprint detection
fingerprint_test = requests.get(
    "https://browserleaks.com/json",
    headers=headers
).json()
 
print(f"Detected UA: {fingerprint_test.get('user_agent')}")
print(f"Canvas hash: {fingerprint_test.get('canvas')}")

from hardspoof import NetworkInterface
import time
import random
 
iface = NetworkInterface("wlan0")
 
vendors = [
    "Intel Corporation",
    "Realtek Semiconductor",
    "Qualcomm Atheros"
]
 
# Rotate MAC every 5 minutes
while True:
    vendor = random.choice(vendors)
    iface.randomize_mac(vendor_prefix=vendor)
    print(f"Rotated to: {iface.get_mac()} ({vendor})")
    time.sleep(300)  # 5 minutes

# adaptive_dns.yaml
profile:
  name: "adaptive_dns"
  spoofing_strategy:
    dns:
      enabled: true
      adaptive_mode: true
      fallback_resolvers:
        - "8.8.8.8"
        - "1.1.1.1"
        - "9.9.9.9"
      poison_detection: true
      auto_rotate_on_anomaly: true
      rotation_interval: 180

# Apply adaptive DNS profile
sudo hardsp00fd --profile adaptive_dns --log /var/log/hardspoof_dns.log --verbose 2 &
 
# Monitor DNS queries
tail -f /var/log/hardspoof_dns.log | grep "DNS"

# Check module dependencies
modinfo hardsp00f
 
# Check kernel logs
dmesg | tail -n 50 | grep hardsp00f
 
# Verify kernel headers match running kernel
uname -r
dpkg -l | grep linux-headers
 
# Rebuild module
cd /usr/src/hardsp00f
sudo make clean
sudo make kernel-module
sudo make install

# Check if daemon is running
systemctl status hardsp00f
 
# Enable persistence mode in profile
cat > /etc/hardsp00f/profiles/persistent.yaml <<EOF
profile:
  name: "persistent"
  persistence:
    mode: "reboot_persistent"
    restore_on_crash: true
EOF
 
# Apply with persistence
sudo hardsp00fd --profile persistent --persistence until_reboot

# Disable NetworkManager interference
sudo systemctl stop NetworkManager
 
# Or configure NetworkManager to ignore interface
cat > /etc/NetworkManager/conf.d/hardspoof.conf <<EOF
[keyfile]
unmanaged-devices=interface-name:eth0
EOF
 
sudo systemctl restart NetworkManager
 
# Apply MAC spoof
hardsp00f-cli spoof-interface eth0 --randomize-mac --persistent

# Ensure running as root/sudo
sudo hardsp00fd
 
# Check file permissions
ls -la /etc/hardsp00f/
sudo chmod 755 /etc/hardsp00f
sudo chmod 644 /etc/hardsp00f/profiles/*
 
# Verify user in required groups (Linux)
sudo usermod -aG hardspoof $USER
newgrp hardspoof

# Disable AI if not needed
export HARDSPOOF_DISABLE_AI=true
 
# Or configure with API keys
cat > /etc/hardsp00f/ai_config.yaml <<EOF
ai_integration:
  enabled: false  # Set to true only if needed
  openai:
    api_key: ${OPENAI_API_KEY}
    model: "gpt-4-turbo-2026"
  privacy_mode: true
EOF

# Detailed status
hardsp00f-cli status --verbose
 
# List all spoofed interfaces
ip link show | grep -E "link/ether"
 
# Check current DNS resolvers
cat /etc/resolv.conf
 
# Verify ARP table changes
arp -a

# Stop all spoofing
hardsp00f-cli stop
 
# Revert all interfaces
hardsp00f-cli revert-interface all
 
# Unload kernel module
sudo modprobe -r hardsp00f
 
# Restart networking
sudo systemctl restart NetworkManager

from hardspoof import EntropySource
import os
 
# Use custom entropy
class CustomEntropy(EntropySource):
    def generate(self, size):
        # Use /dev/urandom or hardware RNG
        return os.urandom(size)
 
# Configure client to use custom entropy
client = HardSpoofClient()
client.set_entropy_source(CustomEntropy())

#!/bin/bash
# rotate_profiles.sh
 
PROFILES=("stealth_1" "stealth_2" "stealth_3")
INTERVAL=600  # 10 minutes
 
while true; do
    for profile in "${PROFILES[@]}"; do
        echo "Applying profile: $profile"
        hardsp00f-cli stop
        sleep 2
        sudo hardsp00fd --profile "$profile" --daemonize
        sleep "$INTERVAL"
    done
done