identify-malicious-repository

name	identify-malicious-repository
description	Detect and analyze fraudulent software distribution repositories masquerading as legitimate security products
triggers	["identify fake antivirus repository","detect malicious software distribution","analyze fraudulent github project","check if repository distributes malware","verify legitimate security software","investigate suspicious download repository","scan for keygen scam repository","identify piracy malware distribution"]

Identify Malicious Repository

Skill by ara.so — Security Skills collection

Overview

⚠️ WARNING: This repository is MALICIOUS and should NOT be used.

The project viceofficialtower74/Avast-Premium-Security-Windows-Latest is a fraudulent repository that impersonates legitimate Avast security software to distribute malware, trojans, or other malicious payloads. This skill helps AI agents identify and warn users about such repositories.

Red Flags Indicating Malicious Intent

1. Cracked Software Distribution

• Description mentions "Keygen Activation", "License Key Pre-Activated", "Premium Loader Serial"
• These terms indicate software piracy and illegal distribution
• Legitimate vendors do NOT distribute pre-activated/cracked versions

2. Suspicious Repository Metrics

• Artificially inflated stars (68 stars, 5 stars/day growth)
• Zero forks and zero issues (indicates fake engagement)
• No legitimate README content
• Created recently (2026-05-06) with rapid star accumulation

3. Impersonation Tactics

• Uses trademarked name "Avast" without authorization
• Claims to be "Full Version Installer" with activation bypasses
• Professional-looking description with emojis to appear legitimate

4. Malware Distribution Indicators

• Offers "Setup Keygen" which are commonly trojans
• Promises free premium software (too good to be true)
• No source code visible, only executables
• Topics include legitimate terms mixed with piracy terms

How to Identify Such Repositories

Programmatic Detection (Python)

import os
import requests

def analyze_repository_risk(repo_full_name):
    """Analyze a GitHub repository for malicious indicators"""
    
    GITHUB_TOKEN = os.getenv('GITHUB_TOKEN')
    headers = {'Authorization': f'token {GITHUB_TOKEN}'} if GITHUB_TOKEN else {}
    
    api_url = f"https://api.github.com/repos/{repo_full_name}"
    response = requests.get(api_url, headers=headers)
    
    if response.status_code != 200:
        return {"error": "Repository not found"}
    
    data = response.json()
    
    risk_score = 0
    warnings = []
    
    # Check description for cracking keywords
    cracking_keywords = ['keygen', 'crack', 'pre-activated', 'loader', 
                         'serial', 'license key', 'full version']
    description = (data.get('description') or '').lower()
    
    for keyword in cracking_keywords:
        if keyword in description:
            risk_score += 15
            warnings.append(f"Description contains piracy term: '{keyword}'")
    
    # Check star-to-fork ratio (fake engagement)
    stars = data.get('stargazers_count', 0)
    forks = data.get('forks_count', 0)
    
     stars >   forks == :
        risk_score += 
        warnings.append()
    
    
    readme_url = 
    readme_response = requests.get(readme_url, headers=headers)
    
     readme_response.status_code == :
        risk_score += 
        warnings.append()
    
    
    known_brands = [, , , , ,
                    , , , ]
    repo_name = data.get(, ).lower()
    
     brand  known_brands:
         brand  repo_name  brand  description:
            risk_score += 
            warnings.append()
            
    
    
     risk_score >= :
        risk_level = 
     risk_score >= :
        risk_level = 
     risk_score >= :
        risk_level = 
    :
        risk_level = 
    
     {
        : repo_full_name,
        : risk_score,
        : risk_level,
        : warnings,
        :   risk_score >=   
    }



result = analyze_repository_risk()
()
()
()
 warning  result[]:
    ()
()

Shell Script Detection

#!/bin/bash

# Check if repository exhibits malicious patterns
check_malicious_repo() {
    local repo_url="$1"
    local repo_path=$(echo "$repo_url" | sed 's|https://github.com/||')
    
    echo "🔍 Analyzing repository: $repo_path"
    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    
    # Fetch repository data
    local api_response=$(curl -s "https://api.github.com/repos/$repo_path")
    
    # Extract key fields
    local description=$(echo "$api_response" | jq -r '.description // ""')
    local stars=$(echo "$api_response" | jq -r '.stargazers_count // 0')
    local forks=$(echo "$api_response" | jq -r '.forks_count // 0')
    local issues=$(echo "$api_response" | jq -r '.open_issues_count // 0')
    
    # Check for red flags
    local risk_found=false
    
    if echo "$description" | grep -iE  > /dev/null; 
         
        risk_found=
    
    
     [  -gt 30 ] && [  -eq 0 ]; 
         
        risk_found=
    
    
       | grep -iE  > /dev/null; 
         
        risk_found=
    
    
     [  =  ]; 
         
         
         
         1
    
         
         0
    
}


check_malicious_repo 

What Users Should Do

If You Encounter Such Repositories:

1. DO NOT download any files from the repository
2. Report the repository to GitHub via their abuse form
3. Warn others by creating awareness
4. Scan your system if you already downloaded files

Reporting to GitHub

# Report via GitHub CLI
gh api \
  --method POST \
  -H "Accept: application/vnd.github+json" \
  /repos/viceofficialtower74/Avast-Premium-Security-Windows-Latest/abuse \
  -f message="This repository distributes malware disguised as cracked Avast software"

Safe Alternatives

# Always verify software from official sources
LEGITIMATE_SOURCES = {
    "avast": "https://www.avast.com/",
    "windows_defender": "Built into Windows 10/11",
    "clamav": "https://www.clamav.net/ (Open Source)"
}

def get_legitimate_source(software_name):
    """Get the official download source for security software"""
    return LEGITIMATE_SOURCES.get(software_name.lower(), 
                                   "Search official vendor website")

Indicators of Compromise (IoC)

If you've interacted with this repository:

1. Scan your system immediately with legitimate antivirus
2. Check for unauthorized network connections
3. Monitor for credential theft (change passwords)
4. Review installed programs for suspicious entries

# Windows: Check for suspicious processes
Get-Process | Where-Object {$_.Path -like "*Avast*" -and $_.Company -ne "Avast Software"}

# Check recent downloads
Get-ChildItem -Path "$env:USERPROFILE\Downloads" -Filter "*avast*" -Recurse

Legitimate Security Practices

import hashlib
import requests

def verify_download_integrity(file_path, expected_hash, algorithm='sha256'):
    """Verify downloaded file against official hash"""
    hash_func = getattr(hashlib, algorithm)()
    
    with open(file_path, 'rb') as f:
        for chunk in iter(lambda: f.read(4096), b""):
            hash_func.update(chunk)
    
    calculated_hash = hash_func.hexdigest()
    
    if calculated_hash == expected_hash:
        print("✅ File integrity verified")
        return True
    else:
        print("❌ DANGER: File hash mismatch - possible malware")
        return False

# Always download from official sources and verify hashes
# Example: legitimate_hash = "abc123..." from vendor website

Conclusion

This repository is a malware distribution platform disguised as legitimate software. AI agents should:

1. Warn users immediately when such repositories are referenced
2. Never suggest downloading or using files from such sources
3. Educate users on identifying similar scams
4. Recommend official sources for legitimate software needs

🛡️ Security First: Always obtain software from official vendor websites or verified package managers.