Local cyber security assistant for PC issue detection, malware analysis, and system scanning

GitHub stars
51

Install

/plugin install drbinary-chat-plugin@deepbits

Run it inside Claude Code after adding the marketplace with /plugin marketplace add DeepBitsTechnology/claude-plugins.

Contents

Discovered from source

Skills 2

Binary Analysis

This skill performs deep analysis of suspicious binaries using the remote Dr. Binary MCP server. The server runs analysis remotely and has no access to your local filesystem, so a local file must first be uploaded into the remote workspace before any analysis tool can read it.

The upload is done with a short-lived curl command that you (Claude) run from your own shell via the Bash tool — the file's bytes stream directly to the server and never pass through the model context.

When to Use This Skill

Use this skill when you need to:

  • Analyze suspicious executable files (.exe, .dll, .sys, ELF, Mach-O, APK)
  • Decompile binaries to understand their behavior
  • Extract strings, imports, and exports from files
  • Identify malware capabilities and techniques
  • Perform static analysis on unknown binaries
  • Investigate potential trojans, ransomware, or other malware
  • Generate threat assessment reports

Workflow

Step 1: Upload the local file

Call prepare_upload with the name to store the file under. It returns a ready-to-run curl command containing a single-use upload link (valid for 10 minutes), with an <ABSOLUTE_LOCAL_PATH> placeholder.

prepare_upload(file_name="suspicious.exe")

Run the returned command yourself with the Bash tool, substituting <ABSOLUTE_LOCAL_PATH> with the absolute path to the local file. Do not print the command for the user to run — execute it directly. For example:

curl -f -F 'file=@/Users/me/Downloads/suspicious.exe' 'https://chat.deepbits.com/api/workspace/upload?upload_token=...'

On success the file is stored in the remote workspace under the chosen filename. The sandbox/analysis CWD is the workspace root, so you can refer to the file by its bare filename (e.g. suspicious.exe) in subsequent tool calls.

If the upload fails (expired or already-used token), call prepare_upload again to mint a fresh link.

Step 2: Triage with inspect_binary

Call inspect_binary with the stored filename for fast, lightweight triage (powered by rz-bin / Rizin). It returns bounded file info, entrypoints, sections, imports, exports, linked libraries, symbol-derived functions, and strings — without full decompilation.

inspect_binary(filepath="suspicious.exe")

Use this first to understand what the file is before deciding where to dig deeper.

Step 3: Deep analysis with run_sandbox + Rizin

For focused, deeper analysis, use run_sandbox to execute Rizin commands against the workspace file:

run_sandbox(command="rizin -qc '<rizin commands>' suspicious.exe")

Useful rizin -qc command strings (separate multiple with ;):

  • aaa; afl — analyze all, then list functions
  • aaa; pdf @ main — decompile/disassemble the main function
  • iz — strings in data sections; izz — strings in the whole file
  • ii — imports; iE — exports; is — symbols
  • ie — entrypoints; iS — sections; iI — binary info

The sandbox image also includes radare2, binwalk, xxd, clang, python3 (with angr, pwntools, qiling), qemu (for qemu-{arch} -strace ...), apktool, jadx, and more — use run_sandbox for any of these when triage points to a specific need. run_sandbox takes an optional timeout (default 120s, max 600s).

Step 4 (optional): Full decompilation with dump_data

For broad Ghidra-based decompilation across all functions, call dump_data(filepath="suspicious.exe"). It returns a folder path of dumped decompiled/disassembled output, which you can then explore with list_files and read_file. This is heavier than inspect_binary and targeted rizin runs — reach for it when you need wide decompilation coverage.

Step 5: Read artifacts

Analysis tools write text artifacts (decompiled .c files, JSON reports) into the workspace. Use list_files to see them and read_file to read their contents.

Step 6: Generate Report

Provide a comprehensive analysis including:

  • File metadata (size, hash, compilation timestamp)
  • Identified capabilities (network, file system, registry, process manipulation)
  • Suspicious indicators
  • Malware classification (if applicable)
  • Recommended actions

Available Tools (remote MCP)

  • prepare_upload(file_name, size?) — mint a one-time curl upload command
  • inspect_binary(filepath) — lightweight rz-bin triage
  • run_sandbox(command, timeout?) — run shell/Rizin/analysis commands in the sandbox
  • dump_data(filepath) — full Ghidra decompilation dump
  • list_files(folder?) / read_file(filepath) — inspect workspace artifacts

Analysis Techniques

Static Analysis

  • PE/ELF/Mach-O header examination
  • Section analysis (.text, .data, .rdata, .rsrc)
  • Import Address Table (IAT) review
  • String artifact extraction
  • Code signature verification

Behavioral Indicators

Look for:

  • Anti-debugging techniques
  • Obfuscation/packing
  • Suspicious API calls (CreateRemoteThread, WriteProcessMemory, etc.)
  • Network communication patterns
  • Persistence mechanisms
  • Privilege escalation attempts

Malware Classification

Common categories:

  • Trojan/RAT (Remote Access Trojan)
  • Ransomware
  • Adware/PUP (Potentially Unwanted Program)
  • Rootkit
  • Worm
  • Spyware
  • Browser hijacker

Safety Considerations

  • Never execute the binary on the local system
  • All analysis occurs in the remote sandbox environment
  • Files are automatically isolated in a per-conversation workspace
  • Use static analysis tools; if dynamic techniques are needed, run them inside run_sandbox only
  • Document all findings for incident response

Output Format

## Binary Analysis Report

**File Information**
- Name: [filename]
- Size: [bytes]
- MD5: [hash]
- SHA256: [hash]

**Analysis Summary**
[Brief overview of findings]

**Detailed Findings**
1. [Finding category]
   - Evidence: [specific data]
   - Significance: [what it means]

**Threat Assessment**
- Severity: [Critical/High/Medium/Low]
- Classification: [malware type]
- Confidence: [High/Medium/Low]

**Recommendations**
1. [Action item]
2. [Action item]

Example Usage

User: "I found a suspicious file called setup_installer.exe. Can you analyze it?"

Response:

  1. prepare_upload(file_name="setup_installer.exe"), then run the returned curl (with the file's absolute path) via Bash
  2. inspect_binary(filepath="setup_installer.exe") for triage
  3. run_sandbox(command="rizin -qc 'aaa; izz; ii; afl' setup_installer.exe") and decompile suspicious functions as needed
  4. Identify malicious behavior (if any)
  5. Provide a detailed report with recommendations

Android Kernel CVE Analysis

This skill queries the remote Dr. Binary MCP server's Android/AOSP kernel CVE database. It helps determine which kernel vulnerabilities affect a given version, build date, or branch — and which are actually exploitable (bug-inducing code present and fix absent).

When to Use This Skill

Use this skill when the user wants to:

  • Look up details for a specific CVE (affected versions, fix, bug-inducing commit, branches)
  • Enumerate CVEs affecting a specific AOSP kernel version
  • Find CVEs affecting a kernel built at a specific date
  • Find unpatched CVEs in a specific branch
  • Identify exploitable CVEs for a branch at a point in time
  • Browse the CVE database

Available Tools (remote MCP)

ToolUse it when…Arguments
get_cve_infoThe user names a specific CVEcve_id (e.g. "CVE-2024-12345")
query_cves_by_version"Which CVEs affect kernel <version>?"aosp_version, limit? (default 100)
query_cves_by_date"Which CVEs affect a kernel built on <date>?"commit_date, limit? (default 100)
query_cves_by_branch"Which CVEs are unpatched in <branch>?"branch, limit? (default 100)
find_exploitable_cves"Which CVEs are exploitable in <branch> as of <date>?"commit_date, branch, limit? (default 50)
list_all_cves"Show me the CVEs in the database"limit? (default 100)

Notes on each tool

  • get_cve_info — returns a formatted report with type, severity, subcomponent, fixed-in version, affected version ranges, fix commits, and bug-inducing commits.
  • query_cves_by_version — all CVEs affecting a specific AOSP kernel version (e.g. 5.10, 5.15).
  • query_cves_by_date — CVEs affecting a kernel built at a specific commit date.
  • query_cves_by_branch — unpatched CVEs in a branch (fixes not yet present in that branch).
  • find_exploitable_cves — the flagship query: vulnerabilities present in a branch at a specific time where both the bug-inducing code exists and the fix is absent. Requires both commit_date and branch.
  • list_all_cves — enumerate the database with basic info.

Workflow

  1. Pick the right tool from the table above based on what the user gives you (a CVE id, a version, a date, a branch, or a branch+date pair).
  2. For exploitability questions, you need both a branch and a date. If the user supplied only one, ask for the other before calling find_exploitable_cves.
  3. Call the tool and summarize results: highlight severity, affected ranges, and patch status.
  4. Drill down into individual CVEs with get_cve_info when the user wants details on a specific result.

Output Format

When reporting results, prefer a concise table (CVE id, severity, subcomponent, affected range / patch status) followed by a short narrative for the most important findings, and call out any exploitable CVEs explicitly.

Commands 7

Binary File Analysis

Analyze a suspicious binary file using the remote Dr. Binary MCP server (Rizin triage, sandboxed deep analysis, and Ghidra decompilation).

Usage

Provide the full path to the suspicious file you want to analyze.

Analysis Process

Step 1: Upload the file to the remote workspace

The remote server cannot read your local filesystem, so the file must be uploaded first:

  1. Call prepare_upload(file_name="<name to store as>"). It returns a one-time curl command (valid 10 minutes) with an <ABSOLUTE_LOCAL_PATH> placeholder.
  2. Run that curl yourself with the Bash tool, substituting <ABSOLUTE_LOCAL_PATH> with the absolute path to the local file. The bytes upload directly to the server and never pass through the model context.
  3. After a successful upload, refer to the file by its stored filename (the sandbox CWD is the workspace root) in all subsequent tool calls.

If the link has expired or was already used, call prepare_upload again for a fresh one.

Step 2: Triage with inspect_binary

Call inspect_binary(filepath="<filename>") for fast rz-bin triage:

  1. Basic File Information — file size and type, PE/ELF/Mach-O header, entrypoints
  2. Imports / Exports — API calls and exported functions
  3. Sections — .text, .data, .rsrc, etc.
  4. Strings & Symbols — readable strings and symbol-derived functions

(For hashes like MD5/SHA256, compute them in run_sandbox, e.g. sha256sum <filename>.)

Step 3: Deep analysis with run_sandbox + Rizin

Use run_sandbox(command="rizin -qc '<commands>' <filename>") for focused analysis:

  • aaa; afl — analyze and list functions
  • aaa; pdf @ <func> — decompile/disassemble a specific function
  • izz — strings across the whole file; ii — imports; iE — exports

The sandbox also provides radare2, binwalk, xxd, angr/pwntools/qiling (python3), qemu (qemu-{arch} -strace ...), apktool, jadx, and more. run_sandbox accepts an optional timeout (default 120s, max 600s).

For broad decompilation across all functions, use dump_data(filepath="<filename>"), then list_files / read_file to read the output.

Step 4: Behavioral & malware indicators

  • Identify suspicious API calls
  • Check for network capabilities
  • Look for file system / registry operations
  • Detect process injection, anti-debugging, packing/encryption

Step 5: Generate Report

Provide comprehensive findings with:

  • File metadata
  • Capabilities identified
  • Malware classification
  • IoCs (Indicators of Compromise)
  • Risk assessment
  • Remediation recommendations

What to Look For

High-Risk API Calls

  • CreateRemoteThread - Process injection
  • WriteProcessMemory - Memory manipulation
  • VirtualAllocEx - Memory allocation in other processes
  • SetWindowsHookEx - Keylogging capability
  • URLDownloadToFile - Download additional payloads
  • Registry functions - Persistence mechanisms
  • Network functions - C2 communication

Suspicious Patterns

  • Hardcoded IP addresses
  • Base64 encoded strings
  • XOR encryption loops
  • Anti-VM checks
  • Sandbox detection
  • Privilege escalation attempts

Output Format

## Binary Analysis Report

### File Information
- Filename: [name]
- Path: [original path]
- Size: [bytes]
- MD5: [hash]
- SHA256: [hash]
- Type: [PE32/PE64/DLL/ELF/Mach-O/etc]

### Analysis Summary
[1-2 paragraph overview]

### Capabilities Detected
- [ ] Network Communication
- [ ] File System Access
- [ ] Registry Modification
- [ ] Process Manipulation
- [ ] Keylogging
- [ ] Screenshot Capture
- [ ] Persistence Mechanism

### Detailed Findings
1. **[Category]**
   - Evidence: [specific code/strings/API calls]
   - Significance: [explanation]
   - Risk: [High/Medium/Low]

### Threat Assessment
- Classification: [Trojan/Adware/RAT/Ransomware/etc]
- Severity: Critical/High/Medium/Low
- Confidence: High/Medium/Low

### Indicators of Compromise
- File hashes
- Mutex names
- Registry keys
- URLs/IPs
- File paths

### Recommendations
1. [Immediate actions]
2. [Remediation steps]
3. [Prevention measures]

Begin the analysis with the provided file path: upload it via prepare_upload + curl, then triage and dig in.

Browser Hijacking Detection

Scan all installed browsers for signs of hijacking, unauthorized modifications, and malicious extensions.

Browsers to Check

  • Google Chrome
  • Mozilla Firefox
  • Microsoft Edge
  • Internet Explorer
  • Brave
  • Opera

Detection Areas

1. Browser Settings Files

Check for unauthorized modifications in:

Chrome
  • %LOCALAPPDATA%\Google\Chrome\User Data\Default\Preferences
  • %LOCALAPPDATA%\Google\Chrome\User Data\Default\Secure Preferences
  • Look for: homepage_url, default_search_provider, homepage
Firefox
  • %APPDATA%\Mozilla\Firefox\Profiles\*.default*\prefs.js
  • Look for: browser.startup.homepage, browser.search.defaultenginename
Edge
  • %LOCALAPPDATA%\Microsoft\Edge\User Data\Default\Preferences
  • Similar structure to Chrome

2. Browser Extensions

Scan extension directories:

Chrome Extensions
  • %LOCALAPPDATA%\Google\Chrome\User Data\Default\Extensions\
  • Check for unknown or suspicious extension IDs
  • Review extension manifest.json files for:
    • Excessive permissions
    • Unknown developers
    • Suspicious URLs
Firefox Add-ons
  • %APPDATA%\Mozilla\Firefox\Profiles\*.default*\extensions\
  • Review extensions.json
Edge Extensions
  • %LOCALAPPDATA%\Microsoft\Edge\User Data\Default\Extensions\

3. Browser Shortcuts

Check desktop and taskbar shortcuts for hijacking:

# Check Chrome shortcut target
Get-ItemProperty "C:\Users\*\Desktop\*.lnk" | Select-Object Target

Look for modified targets with:

  • Suspicious command line arguments
  • URLs appended to shortcuts
  • Redirects to unwanted sites

4. Registry Browser Settings

# IE/Edge HomePage
HKCU:\Software\Microsoft\Internet Explorer\Main -> "Start Page"

# Default search providers
HKCU:\Software\Microsoft\Internet Explorer\SearchScopes

# Browser policies
HKCU:\Software\Policies\Microsoft\Edge
HKCU:\Software\Policies\Google\Chrome

5. Proxy Settings

Check for unauthorized proxy configurations:

HKCU:\Software\Microsoft\Windows\CurrentVersion\Internet Settings

Look for:

  • ProxyEnable = 1 (when not expected)
  • ProxyServer settings
  • AutoConfigURL (PAC file hijacking)

6. Hosts File

Check for redirections:

  • C:\Windows\System32\drivers\etc\hosts
  • Look for suspicious entries redirecting popular sites

Analysis Steps

  1. Inventory all installed browsers
  2. Check each browser's configuration files
  3. Scan extension directories
  4. Verify shortcut targets
  5. Review registry settings
  6. Check proxy and DNS settings
  7. Examine hosts file

Indicators of Hijacking

Critical Signs

  • Homepage changed to unknown search engine
  • Default search provider modified
  • Extensions installed without user knowledge
  • Shortcuts modified with appended URLs
  • Proxy settings enabled unexpectedly
  • Hosts file redirections

Common Hijacker Behaviors

  • Redirect to ad-filled search pages
  • Pop-up advertisements
  • New tabs opening to specific sites
  • Search queries redirected
  • Browser toolbars added

Output Format

## Browser Hijacking Scan Report

### Executive Summary
[Status: Clean / Hijacked / Suspicious Activity Detected]

### Browsers Analyzed
- [x] Google Chrome - [Status]
- [x] Mozilla Firefox - [Status]
- [x] Microsoft Edge - [Status]
- [x] Internet Explorer - [Status]

### Findings

#### Critical Issues
1. **[Browser Name] - [Issue Type]**
   - Location: [file path or registry key]
   - Evidence: [specific finding]
   - Severity: Critical/High
   - Recommendation: [action]

#### Suspicious Extensions
1. **Extension Name** (Browser)
   - ID: [extension ID]
   - Location: [path]
   - Permissions: [list concerning permissions]
   - Recommendation: Remove/Investigate

#### Modified Settings
- Homepage: [current vs expected]
- Search Engine: [current vs expected]
- Proxy: [enabled/disabled - details]

### Clean Items
[List verified legitimate configurations]

### Remediation Steps
1. [Step-by-step removal instructions]
2. Reset browser settings to defaults
3. Remove malicious extensions
4. Clear browser cache and cookies
5. Verify shortcuts
6. Check for associated malware

### Prevention Recommendations
- Install reputable ad blocker
- Avoid clicking suspicious links
- Keep browser updated
- Review extension permissions regularly

Begin the browser hijacking scan now.

Network Security Check

Analyze active network connections, listening ports, and detect suspicious network activity that may indicate malware communication.

Network Analysis Tasks

1. Active Network Connections

# All active TCP connections with process info
netstat -ano | findstr ESTABLISHED

# Get detailed connection info with process names
Get-NetTCPConnection | Select-Object LocalAddress, LocalPort, RemoteAddress, RemotePort, State, OwningProcess

2. Listening Ports

# All listening ports
netstat -ano | findstr LISTENING

# Services listening on all interfaces (0.0.0.0)
Get-NetTCPConnection -State Listen | Where-Object {$_.LocalAddress -eq '0.0.0.0'}

3. Process-to-Network Mapping

# Map connections to process names
Get-NetTCPConnection | ForEach-Object {
    $process = Get-Process -Id $_.OwningProcess -ErrorAction SilentlyContinue
    [PSCustomObject]@{
        LocalAddress = $_.LocalAddress
        LocalPort = $_.LocalPort
        RemoteAddress = $_.RemoteAddress
        RemotePort = $_.RemotePort
        State = $_.State
        ProcessId = $_.OwningProcess
        ProcessName = $process.ProcessName
        ProcessPath = $process.Path
    }
}

4. DNS Cache

# View DNS resolution cache
Get-DnsClientCache | Select-Object Entry, Data, TimeToLive

5. Firewall Rules

# Check for suspicious firewall rules
Get-NetFirewallRule | Where-Object {$_.Enabled -eq $true -and $_.Direction -eq 'Inbound'}

Suspicious Indicators

High-Risk Connections

1. Unusual Remote Ports
  • Common malware ports: 1337, 31337, 4444, 5555, 6666, 6667
  • IRC ports: 6660-6669
  • RAT ports: 1080 (socks), 3389 (RDP), 5900 (VNC)
  • Tor: 9001, 9030, 9050, 9051
2. Suspicious Remote IPs
  • Connections to unexpected countries
  • Known malicious IP ranges
  • Dynamic DNS domains
  • Recently registered domains
3. Unusual Process Behavior
  • svchost.exe - Should not make external connections (usually)
  • rundll32.exe - Suspicious if connecting to internet
  • regsvr32.exe - Should not have network activity
  • User processes from temp directories with network access
  • Unsigned processes with active connections
4. Suspicious Patterns
  • Multiple connections to same IP
  • Beaconing behavior (periodic connections)
  • Large data transfers
  • Connections during odd hours
  • P2P activity (if unexpected)

Port Analysis

Well-Known Ports to Monitor
  • 80, 443 - HTTP/HTTPS (normal but check destination)
  • 21 - FTP (data exfiltration)
  • 22 - SSH (remote access)
  • 23 - Telnet (insecure, rarely legitimate)
  • 25 - SMTP (spam/botnet)
  • 53 - DNS (DNS tunneling)
  • 135-139, 445 - SMB (lateral movement)
  • 3389 - RDP (unauthorized remote access)

Analysis Workflow

  1. Baseline Identification

    • Identify legitimate system processes (Windows Update, Microsoft services)
    • Known applications with network access (browsers, chat apps)
  2. Anomaly Detection

    • Compare against baseline
    • Flag unexpected processes with network access
    • Check process digital signatures
    • Verify process paths (beware of impersonation)
  3. Threat Assessment

    • Prioritize by risk level
    • Correlate with file system and registry scans
    • Check process parent-child relationships
  4. Evidence Collection

    • Document suspicious connections
    • Capture connection timeline
    • Note associated processes and files

Commands to Execute

# Comprehensive network analysis
$connections = Get-NetTCPConnection | Where-Object {$_.State -eq 'Established'} | ForEach-Object {
    $process = Get-Process -Id $_.OwningProcess -ErrorAction SilentlyContinue
    $signature = Get-AuthenticodeSignature -FilePath $process.Path -ErrorAction SilentlyContinue

    [PSCustomObject]@{
        RemoteIP = $_.RemoteAddress
        RemotePort = $_.RemotePort
        LocalPort = $_.LocalPort
        ProcessName = $process.ProcessName
        ProcessPath = $process.Path
        PID = $_.OwningProcess
        Signed = ($signature.Status -eq 'Valid')
    }
}

# Listening services
$listening = Get-NetTCPConnection -State Listen | ForEach-Object {
    $process = Get-Process -Id $_.OwningProcess -ErrorAction SilentlyContinue
    [PSCustomObject]@{
        LocalPort = $_.LocalPort
        ProcessName = $process.ProcessName
        ProcessPath = $process.Path
        PID = $_.OwningProcess
    }
}

# Recent DNS queries
Get-DnsClientCache | Where-Object {$_.TimeToLive -gt 0}

Output Format

## Network Security Analysis Report

### Executive Summary
- Active Connections: [count]
- Listening Ports: [count]
- Suspicious Activity Detected: Yes/No
- Critical Threats: [count]

### Critical Findings

#### 1. Suspicious Connection
- **Process**: [name] (PID: [id])
- **Path**: [full path]
- **Signed**: Yes/No
- **Remote IP**: [IP address]
- **Remote Port**: [port]
- **Reason**: [why flagged]
- **Risk**: Critical/High/Medium/Low

### Active Connections

#### Legitimate Connections
| Process | Remote IP | Remote Port | Local Port | Purpose |
|---------|-----------|-------------|------------|---------|
| [name]  | [IP]      | [port]      | [port]     | [desc]  |

#### Suspicious Connections
| Process | Remote IP | Remote Port | Signed | Risk | Reason |
|---------|-----------|-------------|--------|------|--------|
| [name]  | [IP]      | [port]      | No     | High | [desc] |

### Listening Ports

#### System Services (Expected)
- Port [X]: [Process] - [Description]

#### Suspicious Listeners
- Port [X]: [Process] - **INVESTIGATE**: [Reason]

### Process Analysis
[Detailed breakdown of processes with network activity]

### DNS Activity
- Recent queries to suspicious domains
- Unusual DNS lookups

### Firewall Analysis
- Unauthorized inbound rules
- Suspicious exceptions

### Recommendations

#### Immediate Actions
1. Kill suspicious processes (provide command)
2. Block suspicious IPs in firewall
3. Disconnect from network if critical threat

#### Investigation
1. Upload suspicious binaries for analysis
2. Check associated files and registry keys
3. Review process creation timeline

#### Remediation
1. Remove malware and associated files
2. Reset network settings if hijacked
3. Update firewall rules
4. Clear DNS cache

Begin the network security check now.

Find Android Kernel CVEs

Query the remote Dr. Binary CVE database for Android/AOSP kernel vulnerabilities. Interpret the user's request and route it to the right MCP tool.

Usage

/find-cves <query>

The query is free-form. Examples:

  • /find-cves CVE-2024-12345 — look up a specific CVE
  • /find-cves CVEs in 5.10 — CVEs affecting kernel version 5.10
  • /find-cves unpatched in android13-5.15 — unpatched CVEs in a branch
  • /find-cves exploitable in android13-5.15 as of 2024-06-01 — exploitable CVEs for a branch at a date
  • /find-cves list all — browse the database

Routing

Choose the tool that matches the user's phrasing:

User intentToolRequired args
Names a specific CVE idget_cve_infocve_id
"in / affecting version <v>"query_cves_by_versionaosp_version
"built on / as of <date>" (no branch)query_cves_by_datecommit_date
"unpatched in <branch>"query_cves_by_branchbranch
"exploitable in <branch> as of <date>"find_exploitable_cvescommit_date and branch
"list / show all"list_all_cves—

Important

  • find_exploitable_cves needs both a branch and a date. If the user asks for "exploitable" CVEs but supplies only one, ask for the missing value before calling the tool — do not guess.
  • After listing results, offer to drill into any specific CVE with get_cve_info.

Output

Summarize results as a concise table — CVE id, severity, subcomponent, and affected range / patch status — then a short narrative on the most significant findings. Call out any exploitable CVEs explicitly.

Windows Registry Security Scan

Perform a detailed analysis of Windows Registry for security threats and unauthorized modifications.

Registry Locations to Check

Autostart Locations

# User autostart
HKCU:\Software\Microsoft\Windows\CurrentVersion\Run
HKCU:\Software\Microsoft\Windows\CurrentVersion\RunOnce
HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders

# System autostart
HKLM:\Software\Microsoft\Windows\CurrentVersion\Run
HKLM:\Software\Microsoft\Windows\CurrentVersion\RunOnce
HKLM:\Software\Microsoft\Windows\CurrentVersion\RunServices
HKLM:\Software\Microsoft\Windows\CurrentVersion\RunServicesOnce

Browser Settings

# Internet Explorer
HKCU:\Software\Microsoft\Internet Explorer\Main
HKCU:\Software\Microsoft\Internet Explorer\SearchScopes

# Microsoft Edge
HKCU:\Software\Microsoft\Edge\Main
HKCU:\Software\Policies\Microsoft\Edge

# Chrome
HKCU:\Software\Google\Chrome\PreferenceMACs
HKCU:\Software\Policies\Google\Chrome

# Firefox
HKCU:\Software\Mozilla\Firefox

Policy Restrictions

HKCU:\Software\Microsoft\Windows\CurrentVersion\Policies
HKLM:\Software\Microsoft\Windows\CurrentVersion\Policies
HKCU:\Software\Policies
HKLM:\Software\Policies

Shell Extensions and BHO

HKLM:\Software\Microsoft\Windows\CurrentVersion\Explorer\Browser Helper Objects
HKLM:\Software\Microsoft\Windows\CurrentVersion\Shell Extensions\Approved
HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer\FileExts

Services and Drivers

HKLM:\System\CurrentControlSet\Services

Analysis Tasks

  1. Read each registry location using PowerShell

  2. Identify suspicious entries:

    • Unknown or obfuscated program paths
    • References to temporary directories
    • Unsigned or unusual executables
    • Recently added entries (if timestamps available)
    • Suspicious URLs in browser settings
  3. Document findings with:

    • Registry key path
    • Value name and data
    • Why it's suspicious
    • Severity level
  4. Check for common malware signatures:

    • Cryptomining software
    • Adware/browser hijackers
    • Trojans and RATs
    • Ransomware persistence

Output Format

## Registry Scan Report

### Executive Summary
[Brief overview of findings]

### Critical Findings
1. **[Registry Key Path]**
   - Value: [name] = [data]
   - Issue: [description]
   - Severity: Critical/High/Medium/Low
   - Recommendation: [action]

### Suspicious Entries
[List all questionable registry modifications]

### Baseline Normal Entries
[Document legitimate entries for comparison]

### Remediation Steps
1. [Step-by-step instructions]

Begin the registry scan now.

Suspicious File System Scan

Scan the local file system for suspicious files, malware indicators, and unauthorized modifications.

Target Directories

High-Risk Locations

%TEMP%                                    - Temporary files directory
%TMP%                                     - Alternative temp directory
%APPDATA%                                 - Application data
%LOCALAPPDATA%                            - Local application data
%PROGRAMDATA%                             - Program data (shared)
%USERPROFILE%\Downloads                   - Downloads folder
%USERPROFILE%\Desktop                     - Desktop
C:\Users\Public                           - Public user directory
C:\Windows\Temp                           - System temp directory
C:\Windows\System32\Tasks                 - Scheduled tasks

Additional Locations

%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup
%PROGRAMDATA%\Microsoft\Windows\Start Menu\Programs\Startup
C:\Windows\System32\drivers                - Kernel drivers
C:\Windows\SysWOW64                        - 32-bit on 64-bit system

Scan Criteria

Suspicious File Characteristics

1. File Extensions

Look for executables and scripts:

  • .exe, .dll, .sys, .scr
  • .bat, .cmd, .ps1, .vbs, .js
  • .com, .pif
  • Double extensions (e.g., document.pdf.exe)
2. Recently Modified Files
  • Files created/modified in last 7 days
  • Unexpected modification times (e.g., 3 AM)
3. Hidden or System Attributes
Get-ChildItem -Hidden -System -Recurse
4. Suspicious Names
  • Random character names (e.g., asdfjkl.exe)
  • System name impersonation (e.g., svch0st.exe, chr0me.exe)
  • Generic names (e.g., update.exe, install.exe, setup.exe)
5. Unsigned Executables
Get-AuthenticodeSignature *.exe | Where-Object {$_.Status -ne 'Valid'}
6. Large Files in Temp
  • Executables >10MB in temp directories
  • Archives in unusual locations

Analysis Process

Step 1: Directory Enumeration

For each target directory:

  1. List all files recursively
  2. Filter by suspicious criteria
  3. Check file metadata (size, dates, attributes)

Step 2: File Inspection

For suspicious files:

  1. Calculate hash (MD5, SHA256)
  2. Check digital signature
  3. Extract metadata (PE info, version info)
  4. Review file strings
  5. Check file reputation (VirusTotal hash lookup)

Step 3: Behavioral Indicators

Look for:

  • Multiple files from same source
  • Files dropped in sequence
  • Common naming patterns
  • Associated registry entries
  • Network indicators

Step 4: Prioritization

Rank findings by:

  • Critical: Active malware, known bad hashes
  • High: Unsigned in system directories, recent suspicious activity
  • Medium: Questionable files in user directories
  • Low: Old files, potential false positives

File Analysis Commands

# Recent executables in temp
Get-ChildItem -Path $env:TEMP -Recurse -Include *.exe,*.dll -ErrorAction SilentlyContinue |
  Where-Object {$_.LastWriteTime -gt (Get-Date).AddDays(-7)}

# Hidden files
Get-ChildItem -Path $env:APPDATA -Recurse -Hidden -ErrorAction SilentlyContinue

# Unsigned executables
Get-ChildItem -Path $env:LOCALAPPDATA -Recurse -Include *.exe -ErrorAction SilentlyContinue |
  Get-AuthenticodeSignature | Where-Object {$_.Status -ne 'Valid'}

# Large files in temp
Get-ChildItem -Path $env:TEMP -Recurse -File -ErrorAction SilentlyContinue |
  Where-Object {$_.Length -gt 10MB}

Output Format

## Suspicious File Scan Report

### Scan Summary
- Directories Scanned: [count]
- Files Analyzed: [count]
- Suspicious Files Found: [count]
- Critical Threats: [count]

### Critical Findings

#### 1. [Filename]
- **Path**: [full path]
- **Size**: [bytes]
- **Created**: [timestamp]
- **Modified**: [timestamp]
- **MD5**: [hash]
- **SHA256**: [hash]
- **Signed**: Yes/No
- **Reason**: [why flagged]
- **Risk Level**: Critical/High/Medium/Low
- **Recommendation**: [action]

### Suspicious Files by Location

#### %TEMP%
- [List of files with basic info]

#### %APPDATA%
- [List of files with basic info]

#### [Other Locations]
- [List of files with basic info]

### File Clusters
[Group related files that appear to be from same source]

### Recommendations
1. **Immediate Actions**
   - Quarantine critical threats
   - Disconnect from network if active malware detected

2. **Analysis**
   - Upload suspicious binaries for deep analysis
   - Check process list for running threats

3. **Remediation**
   - Remove confirmed malware
   - Clear temp directories
   - Run full antivirus scan

4. **Prevention**
   - Enable Windows Defender real-time protection
   - Keep system updated
   - Avoid running unknown executables

Begin the suspicious file scan now.

System Security Scan

Perform a comprehensive security assessment of the local Windows system. Check for:

1. Browser Hijacking Detection

  • Check browser homepage and search engine settings
  • Scan for unauthorized browser extensions
  • Review browser shortcut targets for hijacking

2. Registry Analysis

Use PowerShell to check these critical registry locations:

  • HKCU:\Software\Microsoft\Windows\CurrentVersion\Run
  • HKLM:\Software\Microsoft\Windows\CurrentVersion\Run
  • HKCU:\Software\Microsoft\Windows\CurrentVersion\RunOnce
  • HKLM:\Software\Microsoft\Windows\CurrentVersion\RunOnce
  • HKCU:\Software\Microsoft\Internet Explorer\Main
  • HKCU:\Software\Microsoft\Edge\Main
  • Browser policy keys

3. Suspicious Processes

  • List running processes with unusual characteristics
  • Check for processes running from temp directories
  • Identify unsigned or hidden processes

4. Startup Programs

  • Enumerate all startup programs and services
  • Check Task Scheduler for suspicious scheduled tasks
  • Review startup folder contents

5. File System Scan

  • Check common malware locations:
    • %TEMP%
    • %APPDATA%
    • %LOCALAPPDATA%
    • C:\Users\Public
  • Look for recently modified suspicious files
  • Scan for hidden or system files in user directories

6. Network Connections

  • List active network connections
  • Identify suspicious listening ports
  • Check for unexpected remote connections

Output Format

Provide a structured report with:

  • Summary: Overall security status
  • Findings: List each issue with severity rating
  • Evidence: File paths, registry keys, process names
  • Recommendations: Specific remediation steps

Begin the scan now.

Agents 1

Cyber Security Analyst Agent

You are a specialized cyber security analyst agent with expertise in detecting and analyzing system threats, malware, and security vulnerabilities on Windows systems.

Core Capabilities

1. System Scanning

  • Browser hijacking detection (homepage changes, search engine modifications, unwanted extensions)
  • Suspicious process identification
  • Startup program analysis
  • Network connection monitoring
  • File integrity verification

2. Windows Registry Analysis

Use PowerShell commands to:

  • Check for registry modifications in common hijacking locations:
    • HKCU:\Software\Microsoft\Windows\CurrentVersion\Run
    • HKLM:\Software\Microsoft\Windows\CurrentVersion\Run
    • HKCU:\Software\Microsoft\Internet Explorer\Main
    • HKCU:\Software\Microsoft\Windows\CurrentVersion\Policies
  • Detect suspicious registry entries
  • Monitor autostart locations
  • Identify persistence mechanisms

3. File System Analysis

Use Claude Code's file tools to:

  • Scan for suspicious files in common malware locations
  • Check Windows temp directories
  • Analyze recent file modifications
  • Identify unsigned or suspicious executables
  • Review browser extension directories

4. Binary File Analysis

When you need to analyze a suspicious binary file, use the remote Dr. Binary MCP tools. The server cannot read the local filesystem, so upload the file first:

  1. Upload: Call prepare_upload(file_name=...) to get a one-time curl command, then run that curl yourself via the Bash tool, substituting the absolute local path. The bytes upload directly and never pass through the model context. Afterward, refer to the file by its stored filename (sandbox CWD is the workspace root).
  2. Triage: inspect_binary(filepath=...) for lightweight rz-bin info — entrypoints, sections, imports, exports, symbols, strings.
  3. Deep analysis: run_sandbox(command="rizin -qc '<commands>' <filename>") for focused Rizin work (e.g. aaa; afl, pdf @ <func>, izz, ii). The sandbox also has radare2, binwalk, angr/pwntools/qiling, qemu, apktool, jadx, etc.
  4. Full decompilation: dump_data(filepath=...) for broad Ghidra decompilation, then list_files / read_file to read the output.

5. Threat Reporting

  • Provide clear, actionable security reports
  • Prioritize threats by severity (Critical, High, Medium, Low)
  • Include remediation steps
  • Document indicators of compromise (IoCs)

Analysis Workflow

  1. Initial Assessment: Gather system information and user concerns
  2. Targeted Scanning: Focus on specific areas based on symptoms
  3. Evidence Collection: Document findings with file paths and registry keys
  4. Binary Analysis: Upload suspicious files for deep analysis when needed
  5. Threat Correlation: Connect findings to known malware families or techniques
  6. Remediation Plan: Provide step-by-step removal/mitigation instructions

Security Best Practices

  • Always verify findings before recommending system changes
  • Backup critical registry keys before modifications
  • Quarantine suspicious files rather than immediate deletion
  • Recommend running additional security tools when appropriate
  • Document all analysis steps for forensic purposes

Tools Available

  • Local: PowerShell (registry access), file system tools, network utilities
  • Remote MCP Server (Dr. Binary): prepare_upload (file ingestion), inspect_binary (rz-bin triage), run_sandbox (Rizin/radare2/sandbox), dump_data (Ghidra decompilation), list_files/read_file
  • Claude Code Tools: Read, Write, Edit, Bash, Glob, Grep

Output Format

Structure your analysis reports as:

  1. Executive Summary: Brief overview of findings
  2. Detailed Findings: Each issue with evidence
  3. Risk Assessment: Severity and impact
  4. Remediation Steps: Clear instructions
  5. Prevention Recommendations: Future security measures

MCP servers 1

Sponsors

Details

Marketplace
DeepBitsTechnology/claude-plugins
Source
drbinary-chat-plugin
Category
Community