domsniper 0.1.0

package/src/core/types.ts

@@ -0,0 +1,143 @@
+/**
+ * Shared type definitions used across all modules
+ */
+
+import type { DomainStatus } from "./theme.js";
+import type { WhoisResult } from "./whois.js";
+import type { RegistrationResult } from "./registrar.js";
+import type { RdapResult } from "./features/rdap.js";
+import type { SslResult } from "./features/ssl-check.js";
+import type { SubdomainResult } from "./features/subdomain-discovery.js";
+import type { MarketplaceListing } from "./features/marketplace.js";
+import type { SocialCheckResult } from "./features/social-check.js";
+import type { TechStackResult } from "./features/tech-stack.js";
+import type { BlacklistResult } from "./features/blacklist-check.js";
+import type { BacklinkResult } from "./features/backlinks.js";
+import type { PortScanResult } from "./features/port-scanner.js";
+import type { ReverseIpResult } from "./features/reverse-ip.js";
+import type { AsnResult } from "./features/asn-lookup.js";
+import type { EmailSecurityResult } from "./features/email-security.js";
+import type { ZoneTransferResult } from "./features/zone-transfer.js";
+import type { CertTransparencyResult } from "./features/cert-transparency.js";
+import type { TakeoverResult } from "./features/takeover-detect.js";
+import type { SecurityHeadersResult } from "./features/security-headers.js";
+import type { WafResult } from "./features/waf-detect.js";
+import type { PathScanResult } from "./features/path-scanner.js";
+import type { CorsResult } from "./features/cors-check.js";
+
+export type { RdapResult } from "./features/rdap.js";
+export type { SslResult } from "./features/ssl-check.js";
+export type { SubdomainResult } from "./features/subdomain-discovery.js";
+export type { MarketplaceListing } from "./features/marketplace.js";
+export type { SocialCheckResult } from "./features/social-check.js";
+export type { TechStackResult } from "./features/tech-stack.js";
+export type { BlacklistResult } from "./features/blacklist-check.js";
+export type { BacklinkResult } from "./features/backlinks.js";
+export type { PortScanResult } from "./features/port-scanner.js";
+export type { ReverseIpResult } from "./features/reverse-ip.js";
+export type { AsnResult } from "./features/asn-lookup.js";
+export type { EmailSecurityResult } from "./features/email-security.js";
+export type { ZoneTransferResult } from "./features/zone-transfer.js";
+export type { CertTransparencyResult } from "./features/cert-transparency.js";
+export type { TakeoverResult } from "./features/takeover-detect.js";
+export type { SecurityHeadersResult } from "./features/security-headers.js";
+export type { WafResult } from "./features/waf-detect.js";
+export type { PathScanResult } from "./features/path-scanner.js";
+export type { CorsResult } from "./features/cors-check.js";
+
+export interface DnsDetails {
+  a: string[];
+  aaaa: string[];
+  mx: string[];
+  txt: string[];
+  cname: string[];
+}
+
+export interface HttpProbeResult {
+  status: number | null;
+  redirectUrl: string | null;
+  server: string | null;
+  parked: boolean;
+  reachable: boolean;
+  error: string | null;
+}
+
+export interface WaybackResult {
+  hasHistory: boolean;
+  firstArchived: string | null;
+  lastArchived: string | null;
+  snapshots: number;
+}
+
+export interface DomainEntry {
+  domain: string;
+  status: DomainStatus;
+  whois: WhoisResult | null;
+  verification: { available: boolean; confidence: string; checks: string[] } | null;
+  registrarCheck: { available: boolean; price?: number; currency?: string } | null;
+  registration: RegistrationResult | null;
+  error: string | null;
+  tagged: boolean;
+  dns: DnsDetails | null;
+  httpProbe: HttpProbeResult | null;
+  wayback: WaybackResult | null;
+  domainAge: string | null;
+  rdap: RdapResult | null;
+  ssl: SslResult | null;
+  subdomains: SubdomainResult[] | null;
+  marketplace: MarketplaceListing[] | null;
+  socialMedia: SocialCheckResult[] | null;
+  techStack: TechStackResult | null;
+  blacklist: BlacklistResult | null;
+  backlinks: BacklinkResult | null;
+  portScan: PortScanResult | null;
+  reverseIp: ReverseIpResult | null;
+  asn: AsnResult | null;
+  emailSecurity: EmailSecurityResult | null;
+  zoneTransfer: ZoneTransferResult | null;
+  certTransparency: CertTransparencyResult | null;
+  takeover: TakeoverResult | null;
+  securityHeaders: SecurityHeadersResult | null;
+  waf: WafResult | null;
+  pathScan: PathScanResult | null;
+  cors: CorsResult | null;
+}
+
+/**
+ * Create an empty DomainEntry with sensible defaults
+ */
+export function createEmptyEntry(domain: string): DomainEntry {
+  return {
+    domain,
+    status: "pending",
+    whois: null,
+    verification: null,
+    registrarCheck: null,
+    registration: null,
+    error: null,
+    tagged: false,
+    dns: null,
+    httpProbe: null,
+    wayback: null,
+    domainAge: null,
+    rdap: null,
+    ssl: null,
+    subdomains: null,
+    marketplace: null,
+    socialMedia: null,
+    techStack: null,
+    blacklist: null,
+    backlinks: null,
+    portScan: null,
+    reverseIp: null,
+    asn: null,
+    emailSecurity: null,
+    zoneTransfer: null,
+    certTransparency: null,
+    takeover: null,
+    securityHeaders: null,
+    waf: null,
+    pathScan: null,
+    cors: null,
+  };
+}

package/src/core/validate.ts

@@ -0,0 +1,58 @@
+/**
+ * Input validation utilities for domain names, session IDs, and file paths
+ */
+
+import { resolve, normalize } from "path";
+
+export const DOMAIN_RE =
+  /^[a-z0-9]([a-z0-9\-]{0,61}[a-z0-9])?(\.[a-z0-9]([a-z0-9\-]{0,61}[a-z0-9])?)*\.[a-z]{2,}$/;
+
+/**
+ * Check if a string is a valid domain name (case-insensitive)
+ */
+export function isValidDomain(domain: string): boolean {
+  if (domain.length > 253) return false;
+  return DOMAIN_RE.test(domain.toLowerCase());
+}
+
+/**
+ * Assert that a string is a valid domain name, throwing if not
+ */
+export function assertValidDomain(domain: string): void {
+  if (!isValidDomain(domain)) {
+    throw new Error(`Invalid domain: ${domain}`);
+  }
+}
+
+/**
+ * Filter and normalize a list of domains to only valid ones (lowercased)
+ */
+export function sanitizeDomainList(domains: string[]): string[] {
+  return domains
+    .map((d) => d.toLowerCase())
+    .filter(isValidDomain);
+}
+
+/**
+ * Check if a string is a valid session ID (alphanumeric + hyphens, max 100 chars)
+ */
+export function isValidSessionId(id: string): boolean {
+  if (id.length === 0 || id.length > 100) return false;
+  return /^[a-z0-9\-]+$/.test(id);
+}
+
+/**
+ * Resolve and normalize a file path, ensuring it falls within one of the allowed root directories.
+ * Throws if the resolved path is outside all allowed roots.
+ */
+export function safePath(input: string, allowedRoots: string[]): string {
+  const resolved = normalize(resolve(input));
+  const isAllowed = allowedRoots.some((root) => {
+    const normalizedRoot = normalize(resolve(root));
+    return resolved.startsWith(normalizedRoot + "/") || resolved === normalizedRoot;
+  });
+  if (!isAllowed) {
+    throw new Error(`Path "${input}" is outside allowed roots`);
+  }
+  return resolved;
+}

package/src/core/whois.ts

@@ -0,0 +1,265 @@
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { assertValidDomain, isValidDomain } from "./validate.js";
+
+const execFileAsync = promisify(execFile);
+
+export interface WhoisResult {
+  domain: string;
+  available: boolean;
+  expired: boolean;
+  expiryDate: string | null;
+  registrar: string | null;
+  createdDate: string | null;
+  updatedDate: string | null;
+  status: string[];
+  nameServers: string[];
+  rawText: string;
+  error: string | null;
+}
+
+/**
+ * Parse a WHOIS response to extract domain info
+ */
+function parseWhoisResponse(domain: string, raw: string): WhoisResult {
+  const lines = raw.split("\n").map((l) => l.trim());
+
+  const result: WhoisResult = {
+    domain,
+    available: false,
+    expired: false,
+    expiryDate: null,
+    registrar: null,
+    createdDate: null,
+    updatedDate: null,
+    status: [],
+    nameServers: [],
+    rawText: raw,
+    error: null,
+  };
+
+  // Check for "not found" / available indicators
+  const notFoundPatterns = [
+    "no match for",
+    "not found",
+    "no entries found",
+    "no data found",
+    "domain not found",
+    "no object found",
+    "nothing found",
+    "status: free",
+    "status: available",
+    "is available for registration",
+  ];
+
+  const lowerRaw = raw.toLowerCase();
+  for (const pattern of notFoundPatterns) {
+    if (lowerRaw.includes(pattern)) {
+      result.available = true;
+      return result;
+    }
+  }
+
+  // Extract fields
+  for (const line of lines) {
+    const lower = line.toLowerCase();
+
+    // Expiry date
+    if (
+      !result.expiryDate &&
+      (lower.startsWith("registry expiry date:") ||
+        lower.startsWith("registrar registration expiration date:") ||
+        lower.startsWith("expiration date:") ||
+        lower.startsWith("expires:") ||
+        lower.startsWith("expiry date:") ||
+        lower.startsWith("paid-till:") ||
+        lower.startsWith("expire:"))
+    ) {
+      result.expiryDate = line.split(":").slice(1).join(":").trim();
+    }
+
+    // Registrar
+    if (!result.registrar && lower.startsWith("registrar:")) {
+      result.registrar = line.split(":").slice(1).join(":").trim();
+    }
+
+    // Created date
+    if (
+      !result.createdDate &&
+      (lower.startsWith("creation date:") ||
+        lower.startsWith("created:") ||
+        lower.startsWith("created date:") ||
+        lower.startsWith("registration date:"))
+    ) {
+      result.createdDate = line.split(":").slice(1).join(":").trim();
+    }
+
+    // Updated date
+    if (
+      !result.updatedDate &&
+      (lower.startsWith("updated date:") || lower.startsWith("last updated:"))
+    ) {
+      result.updatedDate = line.split(":").slice(1).join(":").trim();
+    }
+
+    // Status
+    if (
+      lower.startsWith("domain status:") ||
+      lower.startsWith("status:")
+    ) {
+      const status = line.split(":").slice(1).join(":").trim();
+      if (status) result.status.push(status);
+    }
+
+    // Name servers
+    if (lower.startsWith("name server:") || lower.startsWith("nserver:")) {
+      const ns = line.split(":").slice(1).join(":").trim();
+      if (ns) result.nameServers.push(ns);
+    }
+  }
+
+  // Check if domain is expired
+  if (result.expiryDate) {
+    try {
+      const expiry = new Date(result.expiryDate);
+      const now = new Date();
+      if (expiry < now) {
+        result.expired = true;
+      }
+    } catch {
+      // Could not parse date
+    }
+  }
+
+  // Check status for expiration indicators
+  const expiredStatuses = [
+    "redemptionperiod",
+    "pendingdelete",
+    "expired",
+    "autorenewperiod",
+  ];
+  for (const s of result.status) {
+    const lowerStatus = s.toLowerCase();
+    for (const es of expiredStatuses) {
+      if (lowerStatus.includes(es)) {
+        result.expired = true;
+        break;
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Perform a WHOIS lookup for a domain
+ */
+export async function whoisLookup(domain: string): Promise<WhoisResult> {
+  assertValidDomain(domain);
+  try {
+    const { stdout, stderr } = await execFileAsync("whois", [domain], {
+      timeout: 15000,
+    });
+
+    const raw = stdout || stderr || "";
+    return parseWhoisResponse(domain, raw);
+  } catch (err: any) {
+    // whois command may return non-zero but still have useful output
+    if (err.stdout) {
+      return parseWhoisResponse(domain, err.stdout);
+    }
+    return {
+      domain,
+      available: false,
+      expired: false,
+      expiryDate: null,
+      registrar: null,
+      createdDate: null,
+      updatedDate: null,
+      status: [],
+      nameServers: [],
+      rawText: "",
+      error: err.message || "WHOIS lookup failed",
+    };
+  }
+}
+
+/**
+ * Verify domain availability using multiple methods to avoid false positives
+ */
+export async function verifyAvailability(
+  domain: string
+): Promise<{ available: boolean; confidence: "high" | "medium" | "low"; checks: string[] }> {
+  assertValidDomain(domain);
+  const checks: string[] = [];
+  let availableCount = 0;
+  let totalChecks = 0;
+
+  // Check 1: WHOIS lookup
+  const whois = await whoisLookup(domain);
+  totalChecks++;
+  if (whois.available) {
+    availableCount++;
+    checks.push("✓ WHOIS: Domain not found in registry");
+  } else if (whois.expired) {
+    availableCount += 0.5;
+    checks.push("⚠ WHOIS: Domain expired (may be in grace period)");
+  } else {
+    checks.push("✗ WHOIS: Domain is registered");
+  }
+
+  // Check 2: DNS resolution check
+  try {
+    const { stdout } = await execFileAsync("dig", ["+short", domain, "A"], {
+      timeout: 10000,
+    });
+    totalChecks++;
+    if (!stdout.trim()) {
+      availableCount++;
+      checks.push("✓ DNS: No A records found");
+    } else {
+      checks.push(`✗ DNS: Resolves to ${stdout.trim().split("\n")[0]}`);
+    }
+  } catch {
+    checks.push("⚠ DNS: Check failed");
+  }
+
+  // Check 3: NS record check
+  try {
+    const { stdout } = await execFileAsync("dig", ["+short", domain, "NS"], {
+      timeout: 10000,
+    });
+    totalChecks++;
+    if (!stdout.trim()) {
+      availableCount++;
+      checks.push("✓ NS: No nameservers found");
+    } else {
+      checks.push(`✗ NS: Has nameservers (${stdout.trim().split("\n")[0]})`);
+    }
+  } catch {
+    checks.push("⚠ NS: Check failed");
+  }
+
+  const ratio = totalChecks > 0 ? availableCount / totalChecks : 0;
+  let confidence: "high" | "medium" | "low" = "low";
+  if (ratio >= 0.8) confidence = "high";
+  else if (ratio >= 0.5) confidence = "medium";
+
+  return {
+    available: ratio >= 0.5,
+    confidence,
+    checks,
+  };
+}
+
+/**
+ * Parse a domain list from file content (one domain per line)
+ */
+export function parseDomainList(content: string): string[] {
+  return content
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line && !line.startsWith("#") && !line.startsWith("//"))
+    .map((line) => line.toLowerCase())
+    .filter(isValidDomain);
+}