valid-email-checker 1.0.0

package/src/validators/spamDetector.js

@@ -0,0 +1,338 @@
+/**
+ * Spam Email Detector
+ * Detects spam patterns in email addresses
+ */
+
+const { extractLocal, extractDomain } = require('./formatValidator');
+
+// Spam patterns in local part of email
+const SPAM_LOCAL_PATTERNS = [
+  // Adult content patterns
+  /^(xxx|sex|porn|adult|nude|naked|hot|sexy)/i,
+  /(xxx|sex|porn|adult|nude|naked)$/i,
+  
+  // Scam patterns
+  /^(lottery|winner|prize|cash|money|profit|income)/i,
+  /(lottery|winner|prize|cash|money|profit)$/i,
+  /^(free|bonus|discount|deal|offer|promo)/i,
+  
+  // Suspicious number patterns
+  /^\d{8,}$/,  // Only numbers, 8+ digits
+  /^[a-z]\d{6,}$/i,  // Letter followed by many numbers
+  /^\d{3,}[a-z]{1,2}\d{3,}$/i,  // Numbers-letters-numbers pattern
+  
+  // Random looking patterns
+  /^[a-z]{1,2}\d{4,}[a-z]{1,2}$/i,  // a1234b pattern
+  /^[bcdfghjklmnpqrstvwxyz]{5,}$/i,  // Only consonants
+  
+  // Bot/automated patterns
+  /^(bot|robot|auto|system|noreply|no-reply|donotreply)/i,
+  /^(admin|administrator|support|help|info|contact)$/i,
+  
+  // Test patterns
+  /^(test|testing|demo|sample|example|dummy)/i,
+  /^(asdf|qwerty|zxcv|aaa|bbb|abc123)/i,
+  
+  // Suspicious keywords
+  /^(click|subscribe|unsubscribe|confirm|verify|validate)/i,
+  /(marketing|newsletter|promo|sales|advertising)/i,
+  
+  // Impersonation patterns
+  /^(paypal|amazon|google|microsoft|apple|facebook|instagram|twitter)\d/i,
+  /^(support|help|service)[-_]?(paypal|amazon|google|microsoft)/i,
+  
+  // Excessive special characters in local part
+  /[._-]{3,}/,  // Three or more consecutive special chars
+  /^[._-]/,     // Starting with special char
+  /[._-]$/,     // Ending with special char
+  
+  // Gibberish patterns
+  /([a-z])\1{4,}/i,  // Same letter repeated 5+ times
+  /\d{10,}/,         // 10+ consecutive digits
+];
+
+// Spam patterns in domain
+const SPAM_DOMAIN_PATTERNS = [
+  // Suspicious TLD patterns
+  /\.(xyz|top|wang|win|bid|stream|download|racing|date|accountant|science|party|loan|trade|webcam|gdn|men|work|click)$/i,
+  
+  // IP-like domains
+  /^\d{1,3}[-_.]\d{1,3}[-_.]\d{1,3}[-_.]\d{1,3}/,
+  
+  // Very long domains
+  /^[a-z0-9-]{40,}\./i,
+  
+  // Random-looking domains
+  /^[a-z]{15,}\.(com|net|org)$/i,
+  
+  // Typosquatting patterns for popular services
+  /^(g00gle|googl3|go0gle|gooogle|googlee)/i,
+  /^(faceb00k|facebo0k|facebok|faceboook)/i,
+  /^(paypall|paypa1|payp4l|paypa|paypl)/i,
+  /^(amaz0n|amazn|amazzon|amazonn)/i,
+  /^(micr0soft|mircosoft|microsft|m1crosoft)/i,
+  /^(app1e|aple|applle|4pple)/i,
+  
+  // Suspicious patterns
+  /-(secure|login|verify|account|update|confirm)\./i,
+  /\.(secure|login|verify)-/i,
+];
+
+// Known spam/phishing domain keywords
+const SPAM_DOMAIN_KEYWORDS = [
+  'phishing',
+  'scam',
+  'malware',
+  'virus',
+  'hack',
+  'crack',
+  'warez',
+  'pirate',
+  'torrent',
+  'download-free',
+  'free-download',
+  'win-prize',
+  'get-rich',
+  'make-money',
+  'earn-cash',
+  'crypto-profit',
+  'bitcoin-profit',
+  'forex-profit',
+];
+
+// Suspicious email characteristics scores
+const SPAM_SCORES = {
+  suspiciousLocalPattern: 15,
+  suspiciousDomainPattern: 20,
+  suspiciousDomainKeyword: 25,
+  excessiveNumbers: 10,
+  excessiveSpecialChars: 10,
+  randomLookingLocal: 15,
+  suspiciousTld: 15,
+  typosquatting: 30,
+  veryLongLocal: 10,
+  veryLongDomain: 10,
+  impersonation: 25,
+};
+
+/**
+ * Check if email matches spam patterns
+ * @param {string} email - Email address to check
+ * @param {object} options - Options for checking
+ * @returns {object} Result with isSpam flag and details
+ */
+function isSpamEmail(email, options = {}) {
+  const {
+    customPatterns = [],
+    threshold = 30,  // Score threshold to consider as spam
+    strictMode = false
+  } = options;
+
+  const result = {
+    isSpam: false,
+    email: email,
+    score: 0,
+    maxScore: 100,
+    reasons: [],
+    details: {
+      localPart: null,
+      domain: null,
+      matches: []
+    }
+  };
+
+  if (!email || typeof email !== 'string') {
+    result.reasons.push('Invalid email provided');
+    return result;
+  }
+
+  const local = extractLocal(email);
+  const domain = extractDomain(email);
+
+  if (!local || !domain) {
+    result.reasons.push('Could not parse email');
+    return result;
+  }
+
+  result.details.localPart = local;
+  result.details.domain = domain;
+
+  let score = 0;
+
+  // Check local part patterns
+  for (const pattern of SPAM_LOCAL_PATTERNS) {
+    if (pattern.test(local)) {
+      score += SPAM_SCORES.suspiciousLocalPattern;
+      result.reasons.push(`Local part matches spam pattern: ${pattern.toString()}`);
+      result.details.matches.push({ type: 'local_pattern', pattern: pattern.toString() });
+      break;  // Only count first match
+    }
+  }
+
+  // Check custom patterns
+  for (const pattern of customPatterns) {
+    if (pattern instanceof RegExp && pattern.test(email)) {
+      score += SPAM_SCORES.suspiciousLocalPattern;
+      result.reasons.push('Matches custom spam pattern');
+      result.details.matches.push({ type: 'custom_pattern', pattern: pattern.toString() });
+    }
+  }
+
+  // Check domain patterns
+  for (const pattern of SPAM_DOMAIN_PATTERNS) {
+    if (pattern.test(domain)) {
+      // Check if it's a typosquatting pattern
+      if (pattern.toString().includes('g00gle') || 
+          pattern.toString().includes('faceb00k') ||
+          pattern.toString().includes('paypall') ||
+          pattern.toString().includes('amaz0n') ||
+          pattern.toString().includes('micr0soft') ||
+          pattern.toString().includes('app1e')) {
+        score += SPAM_SCORES.typosquatting;
+        result.reasons.push('Domain appears to be typosquatting a known brand');
+      } else {
+        score += SPAM_SCORES.suspiciousDomainPattern;
+        result.reasons.push(`Domain matches spam pattern: ${pattern.toString()}`);
+      }
+      result.details.matches.push({ type: 'domain_pattern', pattern: pattern.toString() });
+      break;
+    }
+  }
+
+  // Check domain keywords
+  for (const keyword of SPAM_DOMAIN_KEYWORDS) {
+    if (domain.includes(keyword)) {
+      score += SPAM_SCORES.suspiciousDomainKeyword;
+      result.reasons.push(`Domain contains spam keyword: ${keyword}`);
+      result.details.matches.push({ type: 'domain_keyword', keyword });
+      break;
+    }
+  }
+
+  // Check for excessive numbers in local part
+  const numberCount = (local.match(/\d/g) || []).length;
+  if (numberCount > local.length * 0.6) {
+    score += SPAM_SCORES.excessiveNumbers;
+    result.reasons.push('Local part contains excessive numbers');
+    result.details.matches.push({ type: 'excessive_numbers', count: numberCount });
+  }
+
+  // Check for very long local part
+  if (local.length > 40) {
+    score += SPAM_SCORES.veryLongLocal;
+    result.reasons.push('Local part is unusually long');
+    result.details.matches.push({ type: 'long_local', length: local.length });
+  }
+
+  // Check for very long domain
+  const domainWithoutTld = domain.split('.')[0];
+  if (domainWithoutTld.length > 30) {
+    score += SPAM_SCORES.veryLongDomain;
+    result.reasons.push('Domain name is unusually long');
+    result.details.matches.push({ type: 'long_domain', length: domainWithoutTld.length });
+  }
+
+  // Strict mode: Additional checks
+  if (strictMode) {
+    // Check for low-quality TLDs
+    const tld = domain.split('.').pop();
+    const lowQualityTlds = ['xyz', 'top', 'wang', 'win', 'bid', 'stream', 'download', 'racing', 'date', 'click', 'link', 'gdn', 'men'];
+    if (lowQualityTlds.includes(tld)) {
+      score += SPAM_SCORES.suspiciousTld;
+      result.reasons.push(`Uses potentially suspicious TLD: .${tld}`);
+      result.details.matches.push({ type: 'suspicious_tld', tld });
+    }
+
+    // Check for impersonation patterns
+    const impersonationPatterns = [
+      /^(support|help|service|account|secure|verify)[-_]?/i,
+      /[-_]?(support|help|service|account|secure|verify)$/i
+    ];
+    
+    for (const pattern of impersonationPatterns) {
+      if (pattern.test(local)) {
+        const knownBrands = ['paypal', 'amazon', 'google', 'microsoft', 'apple', 'facebook', 'instagram', 'twitter', 'netflix', 'bank'];
+        for (const brand of knownBrands) {
+          if (domain.toLowerCase().includes(brand) && !domain.endsWith(`${brand}.com`)) {
+            score += SPAM_SCORES.impersonation;
+            result.reasons.push(`Possible impersonation of ${brand}`);
+            result.details.matches.push({ type: 'impersonation', brand });
+            break;
+          }
+        }
+        break;
+      }
+    }
+  }
+
+  result.score = Math.min(score, 100);  // Cap at 100
+  result.isSpam = result.score >= threshold;
+
+  // Classify spam level
+  if (result.score >= 70) {
+    result.spamLevel = 'high';
+  } else if (result.score >= 40) {
+    result.spamLevel = 'medium';
+  } else if (result.score >= 20) {
+    result.spamLevel = 'low';
+  } else {
+    result.spamLevel = 'none';
+  }
+
+  return result;
+}
+
+/**
+ * Quick check - returns boolean only
+ * @param {string} email - Email to check
+ * @param {number} threshold - Score threshold
+ * @returns {boolean} True if spam
+ */
+function isSpam(email, threshold = 30) {
+  return isSpamEmail(email, { threshold }).isSpam;
+}
+
+/**
+ * Get spam score for an email
+ * @param {string} email - Email to check
+ * @returns {number} Spam score (0-100)
+ */
+function getSpamScore(email) {
+  return isSpamEmail(email).score;
+}
+
+/**
+ * Check if domain is suspicious
+ * @param {string} domain - Domain to check
+ * @returns {boolean} True if suspicious
+ */
+function isSuspiciousDomain(domain) {
+  if (!domain) return false;
+  
+  // Check domain patterns
+  for (const pattern of SPAM_DOMAIN_PATTERNS) {
+    if (pattern.test(domain)) {
+      return true;
+    }
+  }
+  
+  // Check domain keywords
+  for (const keyword of SPAM_DOMAIN_KEYWORDS) {
+    if (domain.includes(keyword)) {
+      return true;
+    }
+  }
+  
+  return false;
+}
+
+module.exports = {
+  isSpamEmail,
+  isSpam,
+  getSpamScore,
+  isSuspiciousDomain,
+  SPAM_LOCAL_PATTERNS,
+  SPAM_DOMAIN_PATTERNS,
+  SPAM_DOMAIN_KEYWORDS,
+  SPAM_SCORES
+};

package/src/validators/tempMailDetector.js

@@ -0,0 +1,205 @@
+/**
+ * Temporary/Disposable Email Detector
+ * Detects if an email is from a known disposable email service
+ */
+
+const { DISPOSABLE_DOMAINS, DISPOSABLE_PATTERNS } = require('../data/disposableDomains');
+const { extractDomain } = require('./formatValidator');
+
+/**
+ * Check if email domain is a known disposable email service
+ * @param {string} email - Email address to check
+ * @param {object} options - Options for checking
+ * @returns {object} Result with isTemporary flag and details
+ */
+function isTemporaryEmail(email, options = {}) {
+  const {
+    customDomains = [],
+    customPatterns = [],
+    strictMode = false
+  } = options;
+
+  const result = {
+    isTemporary: false,
+    email: email,
+    domain: null,
+    reason: null,
+    confidence: 'none',
+    matchType: null
+  };
+
+  if (!email || typeof email !== 'string') {
+    result.reason = 'Invalid email provided';
+    return result;
+  }
+
+  const domain = extractDomain(email);
+  if (!domain) {
+    result.reason = 'Could not extract domain from email';
+    return result;
+  }
+
+  result.domain = domain;
+
+  // Check custom domains first
+  const customDomainSet = new Set(customDomains.map(d => d.toLowerCase()));
+  if (customDomainSet.has(domain)) {
+    result.isTemporary = true;
+    result.reason = 'Domain matches custom disposable domain list';
+    result.confidence = 'high';
+    result.matchType = 'custom_domain';
+    return result;
+  }
+
+  // Check known disposable domains
+  if (DISPOSABLE_DOMAINS.has(domain)) {
+    result.isTemporary = true;
+    result.reason = 'Known disposable email domain';
+    result.confidence = 'high';
+    result.matchType = 'known_domain';
+    return result;
+  }
+
+  // Check subdomain of known disposable domain
+  const domainParts = domain.split('.');
+  if (domainParts.length > 2) {
+    const parentDomain = domainParts.slice(-2).join('.');
+    if (DISPOSABLE_DOMAINS.has(parentDomain)) {
+      result.isTemporary = true;
+      result.reason = `Subdomain of known disposable email domain (${parentDomain})`;
+      result.confidence = 'high';
+      result.matchType = 'subdomain';
+      return result;
+    }
+  }
+
+  // Check custom patterns
+  for (const pattern of customPatterns) {
+    if (pattern instanceof RegExp && pattern.test(domain)) {
+      result.isTemporary = true;
+      result.reason = 'Domain matches custom disposable pattern';
+      result.confidence = 'medium';
+      result.matchType = 'custom_pattern';
+      return result;
+    }
+  }
+
+  // Check known disposable patterns
+  for (const pattern of DISPOSABLE_PATTERNS) {
+    if (pattern.test(domain)) {
+      result.isTemporary = true;
+      result.reason = `Domain matches disposable pattern: ${pattern.toString()}`;
+      result.confidence = 'medium';
+      result.matchType = 'pattern';
+      return result;
+    }
+  }
+
+  // Strict mode: Additional heuristic checks
+  if (strictMode) {
+    // Check for suspicious TLDs commonly used by disposable services
+    const suspiciousTlds = ['tk', 'ml', 'ga', 'cf', 'gq', 'cc', 'pw'];
+    const tld = domainParts[domainParts.length - 1];
+    
+    if (suspiciousTlds.includes(tld)) {
+      // Check if domain looks auto-generated
+      const domainWithoutTld = domainParts.slice(0, -1).join('.');
+      if (/^[a-z]{3,6}\d{2,}$/i.test(domainWithoutTld) || 
+          /^\d+[a-z]+$/i.test(domainWithoutTld)) {
+        result.isTemporary = true;
+        result.reason = 'Domain appears auto-generated with suspicious TLD';
+        result.confidence = 'low';
+        result.matchType = 'heuristic';
+        return result;
+      }
+    }
+
+    // Check for very long random-looking domains
+    if (domain.length > 30 && /^[a-z0-9-]+\.[a-z]{2,4}$/i.test(domain)) {
+      const entropy = calculateEntropy(domainParts[0]);
+      if (entropy > 3.5) {
+        result.isTemporary = true;
+        result.reason = 'Domain appears randomly generated';
+        result.confidence = 'low';
+        result.matchType = 'heuristic';
+        return result;
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Calculate Shannon entropy of a string
+ * Higher entropy = more random
+ * @param {string} str - String to calculate entropy for
+ * @returns {number} Entropy value
+ */
+function calculateEntropy(str) {
+  const len = str.length;
+  const frequencies = {};
+  
+  for (const char of str) {
+    frequencies[char] = (frequencies[char] || 0) + 1;
+  }
+  
+  let entropy = 0;
+  for (const char in frequencies) {
+    const p = frequencies[char] / len;
+    entropy -= p * Math.log2(p);
+  }
+  
+  return entropy;
+}
+
+/**
+ * Quick check - returns boolean only
+ * @param {string} email - Email to check
+ * @returns {boolean} True if temporary
+ */
+function isTempEmail(email) {
+  return isTemporaryEmail(email).isTemporary;
+}
+
+/**
+ * Get the domain from an email and check if it's disposable
+ * @param {string} domain - Domain to check
+ * @returns {boolean} True if disposable
+ */
+function isDisposableDomain(domain) {
+  if (!domain) return false;
+  const normalizedDomain = domain.toLowerCase().trim();
+  return DISPOSABLE_DOMAINS.has(normalizedDomain);
+}
+
+/**
+ * Add custom disposable domains to check
+ * @param {string[]} domains - Array of domains to add
+ */
+function addDisposableDomains(domains) {
+  if (Array.isArray(domains)) {
+    domains.forEach(domain => {
+      if (typeof domain === 'string') {
+        DISPOSABLE_DOMAINS.add(domain.toLowerCase().trim());
+      }
+    });
+  }
+}
+
+/**
+ * Get count of known disposable domains
+ * @returns {number} Count of disposable domains
+ */
+function getDisposableDomainCount() {
+  return DISPOSABLE_DOMAINS.size;
+}
+
+module.exports = {
+  isTemporaryEmail,
+  isTempEmail,
+  isDisposableDomain,
+  addDisposableDomains,
+  getDisposableDomainCount,
+  calculateEntropy
+};