# Pentesting Checklist Security Assessment

> Interactive security assessment checklist covering 23 platforms with 1,000+ checks for penetration testing, bug bounty, and security audits.

- Skill: `aradotso-security-skills/pentesting-checklist-security-assessment` (Agent Skill)
- Install (CLI): `npx skillmds@latest add aradotso-security-skills/pentesting-checklist-security-assessment`
- Raw SKILL.md: https://api.skillmd.com/api/skills/aradotso-security-skills/pentesting-checklist-security-assessment/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Security
- Author: aradotso (https://skillmd.com/u/aradotso-security-skills)
- Updated: 2026-09-10
- Page: https://skillmd.com/skills/aradotso-security-skills/pentesting-checklist-security-assessment

---


# Pentesting Checklist Security Assessment

> Skill by [ara.so](https://ara.so) — Security Skills collection.

## Overview

PentestingChecklist is a comprehensive, client-side security assessment framework covering 23 platforms (Web, API, Mobile, Cloud, Active Directory, Kubernetes, LLM, and more) with over 1,000 security checks. It runs entirely in the browser with no backend, storing all progress, notes, and findings in localStorage.

**Key Features:**
- Hierarchical checklist: Platform → Category → Technology → Check
- Global search across all content (⌘K/Ctrl+K)
- Progress tracking with status (Open/Closed/N/A)
- Per-check notes for evidence and payloads
- Severity-based filtering (Critical → Info)
- Export to Markdown, CSV, Excel, JSON
- Import JSON to resume assessments

**Live Tool:** https://checklist.m14r41.in/

## Installation & Setup

This is a web-based application. For local development or self-hosting:

```bash
# Clone the repository
git clone https://github.com/m14r41/PentestingChecklist.git
cd PentestingChecklist

# Install dependencies
npm install

# Start development server
npm run dev

# Build for production
npm run build

# Preview production build
npm run preview
```

## Project Structure

```typescript
// Typical project structure
src/
├── components/          # React/UI components
├── data/               # Checklist data (JSON/TypeScript)
├── hooks/              # Custom React hooks
├── utils/              # Helper functions
├── types/              # TypeScript type definitions
└── App.tsx             # Main application component
```

## Core Data Structure

The checklist follows a four-level hierarchy:

```typescript
interface Platform {
  id: string;
  name: string;
  description: string;
  categories: Category[];
}

interface Category {
  id: string;
  name: string;
  description: string;
  technologies: Technology[];
}

interface Technology {
  id: string;
  name: string;
  checks: Check[];
}

interface Check {
  id: string;
  title: string;
  description: string;
  severity: 'critical' | 'high' | 'medium' | 'low' | 'info';
  tags: string[];
  tools?: string[];
  references?: string[];
  status?: 'open' | 'closed' | 'na';
  notes?: string;
}
```

## Using the Checklist (Browser Interface)

### Navigation

```typescript
// URL structure
https://checklist.m14r41.in/                    # All platforms overview
https://checklist.m14r41.in/checklist           # Full checklist view
https://checklist.m14r41.in/web-application     # Web app checklist
https://checklist.m14r41.in/api                 # API security checklist
https://checklist.m14r41.in/active-directory    # AD security checklist
```

### Global Search

Keyboard shortcut: **⌘K** (Mac) or **Ctrl+K** (Windows/Linux)

Search across:
- Platform names
- Category names
- Technology names
- Check titles and descriptions
- Tags, tools, references

### Progress Tracking

```typescript
// Status options for each check
type CheckStatus = 'open' | 'closed' | 'na';

// Example: Marking a check status
const updateCheckStatus = (checkId: string, status: CheckStatus) => {
  // Stored in localStorage
  const key = `check_${checkId}_status`;
  localStorage.setItem(key, status);
};

// Example: Adding notes to a check
const addCheckNote = (checkId: string, note: string) => {
  const key = `check_${checkId}_note`;
  localStorage.setItem(key, note);
};
```

### Filtering by Severity

```typescript
// Severity levels (highest to lowest)
const severityLevels = [
  'critical',  // Immediate exploitation, severe impact
  'high',      // Major security impact
  'medium',    // Moderate security impact
  'low',       // Minor security impact
  'info'       // Informational findings
];

// Filter checks by severity
const filterBySeverity = (checks: Check[], minSeverity: string): Check[] => {
  const severityOrder = { critical: 4, high: 3, medium: 2, low: 1, info: 0 };
  const threshold = severityOrder[minSeverity] || 0;
  
  return checks.filter(check => 
    severityOrder[check.severity] >= threshold
  );
};
```

## Export & Import

### Export Formats

```typescript
// Export to Markdown
const exportToMarkdown = (assessment: Assessment): string => {
  let markdown = `# Security Assessment Report\n\n`;
  markdown += `**Date:** ${new Date().toISOString()}\n\n`;
  
  assessment.platforms.forEach(platform => {
    markdown += `## ${platform.name}\n\n`;
    platform.categories.forEach(category => {
      markdown += `### ${category.name}\n\n`;
      category.technologies.forEach(tech => {
        markdown += `#### ${tech.name}\n\n`;
        tech.checks.forEach(check => {
          if (check.status === 'open') {
            markdown += `- [x] **${check.title}** (${check.severity})\n`;
            markdown += `  ${check.description}\n`;
            if (check.notes) {
              markdown += `  \n  **Notes:** ${check.notes}\n`;
            }
            markdown += `\n`;
          }
        });
      });
    });
  });
  
  return markdown;
};

// Export to JSON (for re-import)
const exportToJSON = (assessment: Assessment): string => {
  return JSON.stringify({
    version: '1.0',
    exportDate: new Date().toISOString(),
    platforms: assessment.platforms.map(platform => ({
      id: platform.id,
      checks: platform.categories.flatMap(cat =>
        cat.technologies.flatMap(tech =>
          tech.checks
            .filter(check => check.status || check.notes)
            .map(check => ({
              id: check.id,
              status: check.status,
              notes: check.notes
            }))
        )
      )
    }))
  }, null, 2);
};

// Export to CSV
const exportToCSV = (assessment: Assessment): string => {
  let csv = 'Platform,Category,Technology,Check,Severity,Status,Notes\n';
  
  assessment.platforms.forEach(platform => {
    platform.categories.forEach(category => {
      category.technologies.forEach(tech => {
        tech.checks.forEach(check => {
          const row = [
            platform.name,
            category.name,
            tech.name,
            check.title,
            check.severity,
            check.status || 'pending',
            check.notes || ''
          ].map(field => `"${String(field).replace(/"/g, '""')}"`);
          csv += row.join(',') + '\n';
        });
      });
    });
  });
  
  return csv;
};
```

### Import JSON Assessment

```typescript
interface ImportedAssessment {
  version: string;
  exportDate: string;
  platforms: Array<{
    id: string;
    checks: Array<{
      id: string;
      status?: CheckStatus;
      notes?: string;
    }>;
  }>;
}

const importAssessment = (jsonData: string): void => {
  const imported: ImportedAssessment = JSON.parse(jsonData);
  
  imported.platforms.forEach(platform => {
    platform.checks.forEach(check => {
      if (check.status) {
        localStorage.setItem(`check_${check.id}_status`, check.status);
      }
      if (check.notes) {
        localStorage.setItem(`check_${check.id}_note`, check.notes);
      }
    });
  });
  
  console.log(`Imported ${imported.platforms.length} platforms from ${imported.exportDate}`);
};
```

## Platform-Specific Examples

### Web Application Security

```typescript
// Example check structure for web security
const webAppChecks: Check[] = [
  {
    id: 'web-auth-001',
    title: 'Test for SQL Injection in authentication',
    description: 'Verify input validation and parameterized queries in login forms',
    severity: 'critical',
    tags: ['injection', 'authentication', 'sqli'],
    tools: ['sqlmap', 'burp suite', 'manual testing'],
    references: [
      'OWASP Top 10 2021 - A03:2021-Injection',
      'https://portswigger.net/web-security/sql-injection'
    ]
  },
  {
    id: 'web-auth-002',
    title: 'Check for broken authentication',
    description: 'Test session management, password policies, and MFA implementation',
    severity: 'high',
    tags: ['authentication', 'session', 'password'],
    tools: ['burp suite', 'postman'],
    references: ['OWASP Top 10 2021 - A07:2021-Identification and Authentication Failures']
  }
];
```

### API Security

```typescript
// API security assessment pattern
const apiSecurityChecks = [
  {
    id: 'api-bola-001',
    title: 'Test for Broken Object Level Authorization (BOLA)',
    description: 'Manipulate object IDs to access unauthorized resources',
    severity: 'critical',
    tags: ['authorization', 'bola', 'idor'],
    tools: ['postman', 'burp suite', 'curl'],
    references: ['OWASP API Security Top 10 - API1:2023 Broken Object Level Authorization']
  },
  {
    id: 'api-rate-001',
    title: 'Verify rate limiting implementation',
    description: 'Test API endpoints for rate limiting and DoS protection',
    severity: 'medium',
    tags: ['rate-limiting', 'dos', 'resource'],
    tools: ['ab', 'wrk', 'postman'],
    references: ['OWASP API Security Top 10 - API4:2023 Unrestricted Resource Consumption']
  }
];
```

### Active Directory Assessment

```typescript
// Active Directory security checks
const adSecurityChecks = [
  {
    id: 'ad-kerb-001',
    title: 'Kerberoasting attack vector',
    description: 'Enumerate and request service tickets for accounts with SPNs',
    severity: 'high',
    tags: ['kerberos', 'spn', 'privilege-escalation'],
    tools: ['Rubeus', 'Invoke-Kerberoast', 'GetUserSPNs.py'],
    references: ['T1558.003 - Steal or Forge Kerberos Tickets: Kerberoasting']
  },
  {
    id: 'ad-acl-001',
    title: 'ACL abuse for privilege escalation',
    description: 'Identify misconfigured ACLs allowing unintended permissions',
    severity: 'critical',
    tags: ['acl', 'privilege-escalation', 'active-directory'],
    tools: ['BloodHound', 'PowerView', 'SharpHound'],
    references: ['Active Directory Security - ACL Abuse']
  }
];
```

## LocalStorage Management

```typescript
// Helper functions for localStorage operations
class ChecklistStorage {
  private static prefix = 'pentesting_checklist_';
  
  static saveCheckStatus(checkId: string, status: CheckStatus): void {
    localStorage.setItem(
      `${this.prefix}check_${checkId}_status`,
      status
    );
  }
  
  static getCheckStatus(checkId: string): CheckStatus | null {
    const status = localStorage.getItem(`${this.prefix}check_${checkId}_status`);
    return status as CheckStatus | null;
  }
  
  static saveCheckNote(checkId: string, note: string): void {
    localStorage.setItem(
      `${this.prefix}check_${checkId}_note`,
      note
    );
  }
  
  static getCheckNote(checkId: string): string | null {
    return localStorage.getItem(`${this.prefix}check_${checkId}_note`);
  }
  
  static clearAllData(): void {
    const keys = Object.keys(localStorage);
    keys.forEach(key => {
      if (key.startsWith(this.prefix)) {
        localStorage.removeItem(key);
      }
    });
  }
  
  static exportAllData(): Record<string, string> {
    const data: Record<string, string> = {};
    const keys = Object.keys(localStorage);
    keys.forEach(key => {
      if (key.startsWith(this.prefix)) {
        data[key] = localStorage.getItem(key) || '';
      }
    });
    return data;
  }
}
```

## Progress Calculation

```typescript
// Calculate completion percentage
interface ProgressStats {
  total: number;
  completed: number;
  open: number;
  closed: number;
  notApplicable: number;
  percentage: number;
}

const calculateProgress = (checks: Check[]): ProgressStats => {
  const stats: ProgressStats = {
    total: checks.length,
    completed: 0,
    open: 0,
    closed: 0,
    notApplicable: 0,
    percentage: 0
  };
  
  checks.forEach(check => {
    const status = ChecklistStorage.getCheckStatus(check.id);
    
    if (status === 'open') stats.open++;
    if (status === 'closed') stats.closed++;
    if (status === 'na') stats.notApplicable++;
    
    if (status) stats.completed++;
  });
  
  stats.percentage = stats.total > 0
    ? Math.round((stats.completed / stats.total) * 100)
    : 0;
  
  return stats;
};

// Get platform-wise progress
const getPlatformProgress = (platform: Platform): ProgressStats => {
  const allChecks = platform.categories.flatMap(cat =>
    cat.technologies.flatMap(tech => tech.checks)
  );
  return calculateProgress(allChecks);
};
```

## Common Patterns

### Filtering Open Findings

```typescript
// Get all open findings across platforms
const getOpenFindings = (platforms: Platform[]): Check[] => {
  const openChecks: Check[] = [];
  
  platforms.forEach(platform => {
    platform.categories.forEach(category => {
      category.technologies.forEach(tech => {
        tech.checks.forEach(check => {
          const status = ChecklistStorage.getCheckStatus(check.id);
          if (status === 'open') {
            openChecks.push({
              ...check,
              status,
              notes: ChecklistStorage.getCheckNote(check.id) || undefined
            });
          }
        });
      });
    });
  });
  
  return openChecks.sort((a, b) => {
    const severityOrder = { critical: 4, high: 3, medium: 2, low: 1, info: 0 };
    return severityOrder[b.severity] - severityOrder[a.severity];
  });
};
```

### Search Implementation

```typescript
// Global search across all checklist content
interface SearchResult {
  platform: string;
  category: string;
  technology: string;
  check: Check;
  matchType: 'title' | 'description' | 'tag' | 'tool' | 'reference';
}

const searchChecklist = (query: string, platforms: Platform[]): SearchResult[] => {
  const results: SearchResult[] = [];
  const searchTerm = query.toLowerCase();
  
  platforms.forEach(platform => {
    platform.categories.forEach(category => {
      category.technologies.forEach(tech => {
        tech.checks.forEach(check => {
          let matchType: SearchResult['matchType'] | null = null;
          
          if (check.title.toLowerCase().includes(searchTerm)) {
            matchType = 'title';
          } else if (check.description.toLowerCase().includes(searchTerm)) {
            matchType = 'description';
          } else if (check.tags.some(tag => tag.toLowerCase().includes(searchTerm))) {
            matchType = 'tag';
          } else if (check.tools?.some(tool => tool.toLowerCase().includes(searchTerm))) {
            matchType = 'tool';
          } else if (check.references?.some(ref => ref.toLowerCase().includes(searchTerm))) {
            matchType = 'reference';
          }
          
          if (matchType) {
            results.push({
              platform: platform.name,
              category: category.name,
              technology: tech.name,
              check,
              matchType
            });
          }
        });
      });
    });
  });
  
  return results;
};
```

## Troubleshooting

### LocalStorage Issues

```typescript
// Check localStorage availability
const isLocalStorageAvailable = (): boolean => {
  try {
    const test = '__storage_test__';
    localStorage.setItem(test, test);
    localStorage.removeItem(test);
    return true;
  } catch (e) {
    return false;
  }
};

// Handle localStorage quota exceeded
const safeLocalStorageSet = (key: string, value: string): boolean => {
  try {
    localStorage.setItem(key, value);
    return true;
  } catch (e) {
    if (e instanceof DOMException && e.name === 'QuotaExceededError') {
      console.error('LocalStorage quota exceeded. Consider exporting and clearing old data.');
      return false;
    }
    throw e;
  }
};
```

### Data Migration

```typescript
// Migrate old data format to new format
const migrateDataFormat = (oldVersion: string, newVersion: string): void => {
  if (oldVersion === '1.0' && newVersion === '2.0') {
    // Example migration logic
    const keys = Object.keys(localStorage);
    keys.forEach(key => {
      if (key.startsWith('check_') && !key.includes('pentesting_checklist_')) {
        const value = localStorage.getItem(key);
        if (value) {
          localStorage.setItem(`pentesting_checklist_${key}`, value);
          localStorage.removeItem(key);
        }
      }
    });
  }
};
```

### Browser Compatibility

```typescript
// Ensure browser compatibility
const checkBrowserSupport = (): { supported: boolean; issues: string[] } => {
  const issues: string[] = [];
  
  if (!isLocalStorageAvailable()) {
    issues.push('LocalStorage not available or disabled');
  }
  
  if (typeof window.crypto === 'undefined') {
    issues.push('Web Crypto API not available');
  }
  
  return {
    supported: issues.length === 0,
    issues
  };
};
```

## Best Practices

1. **Export regularly**: Export your assessment data to JSON to prevent data loss
2. **Use severity filters**: Focus on critical and high findings first
3. **Add detailed notes**: Include payloads, URLs, and evidence in check notes
4. **Track N/A items**: Mark irrelevant checks as N/A to get accurate progress metrics
5. **Search effectively**: Use tags and tool names in search for faster navigation
6. **Review open findings**: Before final report, filter by "open" status to review all findings

## Related Resources

- OWASP Testing Guide: https://owasp.org/www-project-web-security-testing-guide/
- OWASP API Security Top 10: https://owasp.org/API-Security/
- OWASP Mobile Security Testing Guide: https://owasp.org/www-project-mobile-security-testing-guide/
- PTES Technical Guidelines: http://www.pentest-standard.org/