secure-scan 1.2.2

package/src/dependencies/parsers/csharp/csharpParser.ts

@@ -0,0 +1,151 @@
+/**
+ * C# Dependency Parser
+ * Parses .csproj and packages.config
+ */
+
+import { BaseDependencyParser } from '../base';
+import { 
+  DependencyManifest, 
+  ManifestFileType, 
+  PackageEcosystem,
+  Dependency
+} from '../../types';
+
+/**
+ * C# Dependency Parser
+ */
+export class CSharpDependencyParser extends BaseDependencyParser {
+  name = 'C# Dependency Parser';
+  supportedFiles: ManifestFileType[] = ['csproj', 'packages.config'];
+  ecosystem: PackageEcosystem = 'nuget';
+
+  /**
+   * Check if parser supports a file
+   */
+  supports(fileName: string): boolean {
+    const baseName = fileName.split(/[/\\]/).pop() || '';
+    return baseName.endsWith('.csproj') || baseName === 'packages.config';
+  }
+
+  /**
+   * Parse manifest file
+   */
+  async parse(filePath: string, content: string): Promise<DependencyManifest> {
+    this.logParsing(filePath);
+
+    const fileName = filePath.split(/[/\\]/).pop() || '';
+    const dependencies: Dependency[] = [];
+    const parseErrors: string[] = [];
+
+    try {
+      if (fileName.endsWith('.csproj')) {
+        dependencies.push(...this.parseCsproj(content, filePath, parseErrors));
+      } else if (fileName === 'packages.config') {
+        dependencies.push(...this.parsePackagesConfig(content, filePath, parseErrors));
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      parseErrors.push(`Failed to parse ${fileName}: ${errorMsg}`);
+      this.logError(filePath, errorMsg);
+    }
+
+    return {
+      filePath,
+      fileType: fileName.endsWith('.csproj') ? 'csproj' : 'packages.config',
+      ecosystem: this.ecosystem,
+      dependencies,
+      parseErrors: parseErrors.length > 0 ? parseErrors : undefined,
+      isLockFile: false
+    };
+  }
+
+  /**
+   * Parse .csproj (SDK-style or traditional)
+   */
+  private parseCsproj(content: string, filePath: string, errors: string[]): Dependency[] {
+    const dependencies: Dependency[] = [];
+
+    // SDK-style .csproj: <PackageReference Include="Package" Version="x.x.x" />
+    const packageRefRegex = /<PackageReference\s+Include=["']([^"']+)["']\s*(?:Version=["']([^"']+)["'])?[^>]*\/?>/gi;
+    
+    let match;
+    while ((match = packageRefRegex.exec(content)) !== null) {
+      const name = match[1];
+      const version = match[2] || '*';
+      
+      dependencies.push(this.createDependency(name, version, filePath, {
+        dependencyType: 'direct'
+      }));
+    }
+
+    // Also check for <Version> as child element
+    const packageRefBlockRegex = /<PackageReference\s+Include=["']([^"']+)["'][^>]*>([\s\S]*?)<\/PackageReference>/gi;
+    
+    while ((match = packageRefBlockRegex.exec(content)) !== null) {
+      const name = match[1];
+      const block = match[2];
+      const versionMatch = block.match(/<Version>([^<]+)<\/Version>/i);
+      const version = versionMatch ? versionMatch[1] : '*';
+      
+      // Check if not already added
+      if (!dependencies.some(d => d.name === name)) {
+        dependencies.push(this.createDependency(name, version, filePath, {
+          dependencyType: 'direct'
+        }));
+      }
+    }
+
+    // Traditional .csproj: <Reference Include="Package, Version=x.x.x.x, Culture=..." />
+    const referenceRegex = /<Reference\s+Include=["']([^,"']+)(?:,\s*Version=([^,"']+))?[^>]*\/?>/gi;
+    
+    while ((match = referenceRegex.exec(content)) !== null) {
+      const name = match[1];
+      const version = match[2] || '*';
+      
+      // Skip system assemblies
+      if (name.startsWith('System') || name.startsWith('Microsoft.CSharp')) continue;
+      
+      dependencies.push(this.createDependency(name, version, filePath, {
+        dependencyType: 'direct'
+      }));
+    }
+
+    // FrameworkReference for .NET Core/5+
+    const frameworkRefRegex = /<FrameworkReference\s+Include=["']([^"']+)["'][^>]*\/?>/gi;
+    
+    while ((match = frameworkRefRegex.exec(content)) !== null) {
+      const name = match[1];
+      
+      dependencies.push(this.createDependency(name, '*', filePath, {
+        dependencyType: 'direct'
+      }));
+    }
+
+    return dependencies;
+  }
+
+  /**
+   * Parse packages.config (legacy NuGet)
+   */
+  private parsePackagesConfig(content: string, filePath: string, errors: string[]): Dependency[] {
+    const dependencies: Dependency[] = [];
+
+    // <package id="Package" version="x.x.x" />
+    const packageRegex = /<package\s+id=["']([^"']+)["']\s+version=["']([^"']+)["'][^>]*\/?>/gi;
+    
+    let match;
+    while ((match = packageRegex.exec(content)) !== null) {
+      const name = match[1];
+      const version = match[2];
+      
+      dependencies.push(this.createDependency(name, version, filePath, {
+        dependencyType: 'direct',
+        resolvedVersion: version
+      }));
+    }
+
+    return dependencies;
+  }
+}
+
+export default CSharpDependencyParser;

package/src/dependencies/parsers/csharp/index.ts

@@ -0,0 +1,6 @@
+/**
+ * C# Parser Module Exports
+ */
+
+export * from './csharpParser';
+export { default as CSharpDependencyParser } from './csharpParser';

package/src/dependencies/parsers/index.ts

@@ -0,0 +1,56 @@
+/**
+ * Dependency Parsers Module Exports
+ */
+
+export * from './base';
+export * from './javascript';
+export * from './python';
+export * from './php';
+export * from './java';
+export * from './cpp';
+export * from './csharp';
+
+import { DependencyParser } from '../types';
+import { JavaScriptDependencyParser } from './javascript';
+import { PythonDependencyParser } from './python';
+import { PHPDependencyParser } from './php';
+import { JavaDependencyParser } from './java';
+import { CppDependencyParser } from './cpp';
+import { CSharpDependencyParser } from './csharp';
+
+/**
+ * All available dependency parsers
+ */
+const parsers: DependencyParser[] = [
+  new JavaScriptDependencyParser(),
+  new PythonDependencyParser(),
+  new PHPDependencyParser(),
+  new JavaDependencyParser(),
+  new CppDependencyParser(),
+  new CSharpDependencyParser()
+];
+
+/**
+ * Get all dependency parsers
+ */
+export function getAllDependencyParsers(): DependencyParser[] {
+  return parsers;
+}
+
+/**
+ * Get parser for a specific file
+ */
+export function getParserForFile(fileName: string): DependencyParser | undefined {
+  return parsers.find(p => p.supports(fileName));
+}
+
+/**
+ * Get all supported manifest file names
+ */
+export function getSupportedManifestFiles(): string[] {
+  const files: string[] = [];
+  for (const parser of parsers) {
+    files.push(...parser.supportedFiles);
+  }
+  return [...new Set(files)];
+}

package/src/dependencies/parsers/java/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Java Parser Module Exports
+ */
+
+export * from './javaParser';
+export { default as JavaDependencyParser } from './javaParser';

package/src/dependencies/parsers/java/javaParser.ts

@@ -0,0 +1,203 @@
+/**
+ * Java Dependency Parser
+ * Parses pom.xml and build.gradle
+ */
+
+import { BaseDependencyParser } from '../base';
+import { 
+  DependencyManifest, 
+  ManifestFileType, 
+  PackageEcosystem,
+  Dependency
+} from '../../types';
+
+/**
+ * Java Dependency Parser
+ */
+export class JavaDependencyParser extends BaseDependencyParser {
+  name = 'Java Dependency Parser';
+  supportedFiles: ManifestFileType[] = ['pom.xml', 'build.gradle'];
+  ecosystem: PackageEcosystem = 'maven';
+
+  /**
+   * Parse manifest file
+   */
+  async parse(filePath: string, content: string): Promise<DependencyManifest> {
+    this.logParsing(filePath);
+
+    const fileName = filePath.split(/[/\\]/).pop() || '';
+    const dependencies: Dependency[] = [];
+    const parseErrors: string[] = [];
+
+    try {
+      if (fileName === 'pom.xml') {
+        dependencies.push(...this.parsePomXml(content, filePath, parseErrors));
+      } else if (fileName === 'build.gradle') {
+        dependencies.push(...this.parseBuildGradle(content, filePath, parseErrors));
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      parseErrors.push(`Failed to parse ${fileName}: ${errorMsg}`);
+      this.logError(filePath, errorMsg);
+    }
+
+    return {
+      filePath,
+      fileType: fileName as ManifestFileType,
+      ecosystem: fileName === 'build.gradle' ? 'gradle' : 'maven',
+      dependencies,
+      parseErrors: parseErrors.length > 0 ? parseErrors : undefined,
+      isLockFile: false
+    };
+  }
+
+  /**
+   * Parse pom.xml (Maven)
+   */
+  private parsePomXml(content: string, filePath: string, errors: string[]): Dependency[] {
+    const dependencies: Dependency[] = [];
+    
+    // Simple XML parser for Maven dependencies
+    // Pattern: <dependency><groupId>...</groupId><artifactId>...</artifactId><version>...</version></dependency>
+    const dependencyRegex = /<dependency>\s*([\s\S]*?)<\/dependency>/g;
+    const groupIdRegex = /<groupId>([^<]+)<\/groupId>/;
+    const artifactIdRegex = /<artifactId>([^<]+)<\/artifactId>/;
+    const versionRegex = /<version>([^<]+)<\/version>/;
+    const scopeRegex = /<scope>([^<]+)<\/scope>/;
+
+    let match;
+    while ((match = dependencyRegex.exec(content)) !== null) {
+      const depBlock = match[1];
+      
+      const groupId = groupIdRegex.exec(depBlock)?.[1];
+      const artifactId = artifactIdRegex.exec(depBlock)?.[1];
+      const version = versionRegex.exec(depBlock)?.[1] || '*';
+      const scope = scopeRegex.exec(depBlock)?.[1] || 'compile';
+
+      if (groupId && artifactId) {
+        // Maven uses groupId:artifactId format
+        const name = `${groupId}:${artifactId}`;
+        
+        // Determine dependency type based on scope
+        let depType: 'direct' | 'dev' | 'optional' = 'direct';
+        if (scope === 'test') depType = 'dev';
+        if (scope === 'provided' || scope === 'optional') depType = 'optional';
+
+        dependencies.push(this.createDependency(name, version, filePath, {
+          dependencyType: depType
+        }));
+      }
+    }
+
+    // Also parse plugin dependencies
+    const pluginRegex = /<plugin>\s*([\s\S]*?)<\/plugin>/g;
+    while ((match = pluginRegex.exec(content)) !== null) {
+      const pluginBlock = match[1];
+      
+      const groupId = groupIdRegex.exec(pluginBlock)?.[1] || 'org.apache.maven.plugins';
+      const artifactId = artifactIdRegex.exec(pluginBlock)?.[1];
+      const version = versionRegex.exec(pluginBlock)?.[1] || '*';
+
+      if (artifactId) {
+        const name = `${groupId}:${artifactId}`;
+        dependencies.push(this.createDependency(name, version, filePath, {
+          dependencyType: 'dev' // Plugins are build-time dependencies
+        }));
+      }
+    }
+
+    return dependencies;
+  }
+
+  /**
+   * Parse build.gradle (Gradle)
+   */
+  private parseBuildGradle(content: string, filePath: string, errors: string[]): Dependency[] {
+    const dependencies: Dependency[] = [];
+    
+    // Gradle dependency patterns
+    // implementation 'group:artifact:version'
+    // implementation "group:artifact:version"
+    // implementation("group:artifact:version")
+    // implementation group: 'x', name: 'y', version: 'z'
+    
+    const configTypes = [
+      'implementation',
+      'api',
+      'compile',
+      'compileOnly',
+      'runtimeOnly',
+      'testImplementation',
+      'testCompile',
+      'testRuntimeOnly',
+      'annotationProcessor',
+      'kapt'
+    ];
+
+    // Pattern for string notation: implementation 'group:artifact:version'
+    const stringPattern = new RegExp(
+      `(${configTypes.join('|')})\\s*[("']([^"')]+)[)"']`,
+      'g'
+    );
+
+    // Pattern for map notation: implementation group: 'x', name: 'y', version: 'z'
+    const mapPattern = new RegExp(
+      `(${configTypes.join('|')})\\s+group:\\s*['"]([^'"]+)['"],\\s*name:\\s*['"]([^'"]+)['"](?:,\\s*version:\\s*['"]([^'"]+)['"])?`,
+      'g'
+    );
+
+    let match;
+
+    // Parse string notation
+    while ((match = stringPattern.exec(content)) !== null) {
+      const configType = match[1];
+      const depString = match[2];
+      
+      // Parse group:artifact:version
+      const parts = depString.split(':');
+      if (parts.length >= 2) {
+        const groupId = parts[0];
+        const artifactId = parts[1];
+        const version = parts[2] || '*';
+        const name = `${groupId}:${artifactId}`;
+        
+        const depType = this.getGradleDepType(configType);
+        
+        dependencies.push(this.createDependency(name, version, filePath, {
+          dependencyType: depType
+        }));
+      }
+    }
+
+    // Parse map notation
+    while ((match = mapPattern.exec(content)) !== null) {
+      const configType = match[1];
+      const groupId = match[2];
+      const artifactId = match[3];
+      const version = match[4] || '*';
+      const name = `${groupId}:${artifactId}`;
+      
+      const depType = this.getGradleDepType(configType);
+      
+      dependencies.push(this.createDependency(name, version, filePath, {
+        dependencyType: depType
+      }));
+    }
+
+    return dependencies;
+  }
+
+  /**
+   * Map Gradle configuration to dependency type
+   */
+  private getGradleDepType(configType: string): 'direct' | 'dev' | 'optional' {
+    const testConfigs = ['testImplementation', 'testCompile', 'testRuntimeOnly'];
+    const devConfigs = ['annotationProcessor', 'kapt', 'compileOnly'];
+    
+    if (testConfigs.includes(configType)) return 'dev';
+    if (devConfigs.includes(configType)) return 'dev';
+    return 'direct';
+  }
+}
+
+export default JavaDependencyParser;

package/src/dependencies/parsers/javascript/index.ts

@@ -0,0 +1,6 @@
+/**
+ * JavaScript Parser Module Exports
+ */
+
+export * from './javascriptParser';
+export { default as JavaScriptDependencyParser } from './javascriptParser';