@yognky/premium-security 1.0.0

package/examples/with-express.ts

@@ -0,0 +1,33 @@
+import express from 'express';
+import ModulesEz from '../src/index';
+
+const app = express();
+
+// TypeScript version with full config
+ModulesEz({
+  anti_ddos: { maxPerMinute: 60, blockDuration: 60 },
+  anti_sql: true,
+  anti_xss: true,
+  anti_curl: true,
+  anti_header: true,
+  anti_bruteforce: true,
+  anti_rateLimit: { windowMs: 60000, maxRequests: 100 },
+  anti_malware: true,
+  anti_pengunjung: "127.0.0.1"
+})(app);
+
+interface User {
+  id: number;
+  name: string;
+}
+
+app.get<{}, { message: string; user?: User }>('/api/user', (req, res) => {
+  res.json({
+    message: 'User data protected by YONGKY',
+    user: { id: 1, name: 'YONGKY' }
+  });
+});
+
+app.listen(3000, () => {
+  console.log('TypeScript server with YONGKY Security running! 🗿');
+});

package/gitignore

@@ -0,0 +1,48 @@
+# Dependencies
+node_modules/
+package-lock.json
+yarn.lock
+
+# Build output
+dist/
+build/
+*.tsbuildinfo
+
+# Logs
+logs/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Coverage
+coverage/
+.nyc_output/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# Testing
+jest.config.js
+test-report.xml
+
+# Temporary files
+tmp/
+temp/
+*.tmp

package/nodemon.json

@@ -0,0 +1,11 @@
+{
+  "watch": ["src"],
+  "ext": "ts,js,json",
+  "ignore": ["src/**/*.test.ts", "src/**/*.spec.ts"],
+  "exec": "ts-node ./src/index.ts",
+  "env": {
+    "NODE_ENV": "development"
+  },
+  "signal": "SIGTERM",
+  "delay": 500
+}

package/npmignore

@@ -0,0 +1,36 @@
+
+# Source files
+src/
+tests/
+examples/
+docs/
+
+# Config files
+tsconfig.json
+tsconfig.build.json
+.eslintrc
+.prettierrc
+.gitignore
+.npmignore
+
+# Development
+node_modules/
+coverage/
+.nyc_output/
+
+# Logs
+*.log
+yongky-security.log
+
+# IDE
+.vscode/
+.idea/
+
+# Test files
+*.test.ts
+*.spec.ts
+jest.config.js
+
+# Only keep dist and essential files
+# dist/ will be included
+# README.md, LICENSE, CHANGELOG.md will be included

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@yognky/premium-security",
+  "version": "1.0.0",
+  "description": "💎 PREMIUM SECURITY - Official Premium Package by YOGNKY",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "build:dev": "tsc",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "keywords": ["premium", "security", "yognky"],
+  "author": "YOGNKY",
+  "license": "UNLICENSED",
+  "dependencies": {
+    "express": "^4.18.2",
+    "chalk": "^4.1.2",
+    "figlet": "^1.6.0",
+    "gradient-string": "^2.0.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0"
+  }
+}

package/src/defenses/advanced.ts

@@ -0,0 +1,6 @@
+import { Request, Response, NextFunction } from 'express';
+
+export const advancedProtection = (req: Request, res: Response, next: NextFunction) => {
+  // Advanced fingerprinting protection
+  next();
+};

package/src/defenses/advenced.ts

@@ -0,0 +1,54 @@
+import { Request, Response, NextFunction } from 'express';
+import crypto from 'crypto';
+
+const fingerprintMap = new Map<string, number>();
+const requestHistory = new Map<string, string[]>();
+
+// Generate unique fingerprint
+const generateFingerprint = (req: Request): string => {
+  const ip = req.ip || '';
+  const ua = req.get('user-agent') || '';
+  const acceptLang = req.get('accept-language') || '';
+  const acceptEncoding = req.get('accept-encoding') || '';
+  
+  return crypto
+    .createHash('sha256')
+    .update(`${ip}|${ua}|${acceptLang}|${acceptEncoding}`)
+    .digest('hex');
+};
+
+export const advancedProtection = (req: Request, res: Response, next: NextFunction) => {
+  const fingerprint = generateFingerprint(req);
+  const requests = fingerprintMap.get(fingerprint) || 0;
+  
+  // Deteksi fingerprint anomali
+  if (requests > 100) {
+    res.status(403).json({
+      error: '🔐 Advanced Detection!',
+      message: 'Fingerprint anomaly detected - YOGNKY KNOWS! 🗿',
+      by: 'YOGNKY ADVANCED SECURITY'
+    });
+    return;
+  }
+  
+  // Deteksi request pattern mencurigakan
+  const urlHistory = requestHistory.get(fingerprint) || [];
+  const currentPath = req.path;
+  
+  if (urlHistory.length > 10 && !urlHistory.includes(currentPath)) {
+    // Attacker scanning banyak endpoint
+    res.status(403).json({
+      error: '🔍 Scanning Detected!',
+      message: 'Lu lagi scanning ya? YOGNKY tau! 🗿',
+      by: 'YOGNKY SECURITY'
+    });
+    return;
+  }
+  
+  urlHistory.push(currentPath);
+  if (urlHistory.length > 50) urlHistory.shift();
+  requestHistory.set(fingerprint, urlHistory);
+  
+  fingerprintMap.set(fingerprint, requests + 1);
+  next();
+};

package/src/defenses/bruteforce.ts

@@ -0,0 +1,47 @@
+import { Request, Response, NextFunction } from 'express';
+
+const loginAttempts = new Map<string, { count: number; firstAttempt: number }>();
+const blockedLogins = new Map<string, number>();
+
+export const bruteforceProtection = (req: Request, res: Response, next: NextFunction) => {
+  if (req.method !== 'POST') return next();
+  
+  const ip = req.ip || req.socket.remoteAddress || 'unknown';
+  const now = Date.now();
+
+  if (blockedLogins.has(ip)) {
+    const unblockTime = blockedLogins.get(ip)!;
+    if (now < unblockTime) {
+      res.status(429).json({
+        error: '🔒 Brute Force Protection!',
+        message: `Coba lagi ${Math.ceil((unblockTime - now) / 1000)} detik lagi`,
+        by: 'YOGNKY SECURITY'
+      });
+      return;
+    } else {
+      blockedLogins.delete(ip);
+    }
+  }
+
+  const attempts = loginAttempts.get(ip) || { count: 0, firstAttempt: now };
+  
+  if (now - attempts.firstAttempt > 15 * 60 * 1000) {
+    attempts.count = 0;
+    attempts.firstAttempt = now;
+  }
+
+  attempts.count++;
+  loginAttempts.set(ip, attempts);
+
+  if (attempts.count >= 5) {
+    blockedLogins.set(ip, now + 30 * 60 * 1000);
+    res.status(429).json({
+      error: '⛔ Account Temporary Locked!',
+      message: 'Terlalu banyak percobaan login. Coba lagi 30 menit kemudian.',
+      by: 'YOGNKY SECURITY'
+    });
+    return;
+  }
+
+  next();
+};

package/src/defenses/curlBot.ts

@@ -0,0 +1,33 @@
+import { Request, Response, NextFunction } from 'express';
+
+const botSignatures = [
+  /curl/i, /wget/i, /python/i, /perl/i, /ruby/i,
+  /java/i, /php/i, /libwww/i, /http client/i,
+  /scrapy/i, /spider/i, /crawler/i, /bot/i,
+  /scraper/i, /fetch/i, /headless/i, /puppeteer/i,
+  /selenium/i, /phantomjs/i, /axios/i, /requests/i,
+  /go-http-client/i, /okhttp/i, /python-requests/i,
+  /node-fetch/i, /got/i, /axios/i, /superagent/i
+];
+
+const suspiciousHeaders = [
+  'x-scrapy', 'x-requested-with', 'x-http-method-override',
+  'x-crawler', 'x-bot', 'x-scraper'
+];
+
+export const curlBotProtection = (req: Request, res: Response, next: NextFunction) => {
+  const ua = req.get('user-agent') || '';
+  const isBot = botSignatures.some(pattern => pattern.test(ua));
+  const hasSuspiciousHeader = suspiciousHeaders.some(header => req.headers[header]);
+
+  if (isBot || hasSuspiciousHeader) {
+    res.status(403).json({
+      error: '🤖 Bot Detected!',
+      message: 'BOT ga boleh lewat kata YOGNKY 🤣',
+      by: 'YOGNKY SECURITY'
+    });
+    return;
+  }
+
+  next();
+};

package/src/defenses/ddos.ts

@@ -0,0 +1,46 @@
+import { Request, Response, NextFunction } from 'express';
+
+const requestMap = new Map<string, number[]>();
+const blockedIPs = new Map<string, number>();
+
+export const ddosProtection = (config: any = {}) => {
+  const maxPerMinute = config.maxPerMinute || 10;
+  const blockDuration = (config.blockDuration || 60) * 1000;
+
+  return (req: Request, res: Response, next: NextFunction) => {
+    const ip = req.ip || req.socket.remoteAddress || 'unknown';
+    const now = Date.now();
+
+    // Cek apakah IP diblokir
+    if (blockedIPs.has(ip)) {
+      const unblockTime = blockedIPs.get(ip)!;
+      if (now < unblockTime) {
+        res.status(429).json({
+          error: '⛔ DDoS Protection',
+          message: `IP diblokir ${Math.ceil((unblockTime - now) / 1000)} detik lagi`,
+          by: 'YOGNKY SECURITY'
+        });
+        return;
+      } else {
+        blockedIPs.delete(ip);
+      }
+    }
+
+    const requests = requestMap.get(ip) || [];
+    const recent = requests.filter(time => time > now - 60000);
+
+    if (recent.length >= maxPerMinute) {
+      blockedIPs.set(ip, now + blockDuration);
+      res.status(429).json({
+        error: '🔥 DDoS Attack Detected!',
+        message: `IP ${ip} diblokir sementara`,
+        by: 'YOGNKY SECURITY'
+      });
+      return;
+    }
+
+    recent.push(now);
+    requestMap.set(ip, recent);
+    next();
+  };
+};

package/src/defenses/headers.ts

@@ -0,0 +1,27 @@
+import { Request, Response, NextFunction } from 'express';
+
+const maliciousHeaders = [
+  'x-forwarded-for', 'x-real-ip', 'x-original-url',
+  'x-http-method-override', 'x-http-method', 
+  'x-method-override', 'x-rewrite-url'
+];
+
+export const headerProtection = (req: Request, res: Response, next: NextFunction) => {
+  const hasMalicious = maliciousHeaders.some(header => req.headers[header] !== undefined);
+
+  if (hasMalicious) {
+    res.status(400).json({
+      error: '🎭 Malicious Headers Detected!',
+      message: 'Jangan nakal pake header aneh2 ya 🙏',
+      by: 'YOGNKY SECURITY'
+    });
+    return;
+  }
+
+  res.setHeader('X-Powered-By', 'YOGNKY SECURITY 🗿');
+  res.setHeader('X-Content-Type-Options', 'nosniff');
+  res.setHeader('X-Frame-Options', 'DENY');
+  res.setHeader('X-XSS-Protection', '1; mode=block');
+
+  next();
+};

package/src/defenses/malware.ts

@@ -0,0 +1,35 @@
+import { Request, Response, NextFunction } from 'express';
+
+const malwarePatterns = [
+  /base64_decode/i, /eval\(/i, /system\(/i, /shell_exec/i,
+  /passthru/i, /proc_open/i, /popen/i, /curl_exec/i,
+  /file_get_contents/i, /fopen/i, /readfile/i,
+  /\.\.\/|\.\.\\/, /etc\/passwd/i, /wget\s+http/i,
+  /cmd\.exe/i, /powershell/i
+];
+
+const checkMalware = (data: any): boolean => {
+  if (!data) return false;
+  if (typeof data === 'string') {
+    return malwarePatterns.some(pattern => pattern.test(data));
+  }
+  if (typeof data === 'object') {
+    return Object.values(data).some(val => checkMalware(val));
+  }
+  return false;
+};
+
+export const malwareProtection = (req: Request, res: Response, next: NextFunction) => {
+  const hasMalware = checkMalware(req.query) || checkMalware(req.body);
+
+  if (hasMalware) {
+    res.status(403).json({
+      error: '🦠 Malware Detected!',
+      message: 'Woi jangan coba2 pake malware 🗿',
+      by: 'YOGNKY SECURITY'
+    });
+    return;
+  }
+
+  next();
+};

package/src/defenses/rateLimit.ts

@@ -0,0 +1,34 @@
+import { Request, Response, NextFunction } from 'express';
+
+const rateMap = new Map<string, { count: number; resetTime: number }>();
+
+export const rateLimitProtection = (config: any = {}) => {
+  const windowMs = config.windowMs || 60000;
+  const maxRequests = config.maxRequests || 10;
+
+  return (req: Request, res: Response, next: NextFunction) => {
+    const ip = req.ip || req.socket.remoteAddress || 'unknown';
+    const now = Date.now();
+    const rate = rateMap.get(ip);
+
+    if (!rate || now > rate.resetTime) {
+      rateMap.set(ip, { count: 1, resetTime: now + windowMs });
+      next();
+      return;
+    }
+
+    if (rate.count >= maxRequests) {
+      res.status(429).json({
+        error: '🐌 Rate Limit Exceeded!',
+        message: `Maksimal ${maxRequests} request per ${windowMs / 1000} detik`,
+        retryAfter: Math.ceil((rate.resetTime - now) / 1000),
+        by: 'YOGNKY SECURITY'
+      });
+      return;
+    }
+
+    rate.count++;
+    rateMap.set(ip, rate);
+    next();
+  };
+};

package/src/defenses/spoofing.ts

@@ -0,0 +1,5 @@
+import { Request, Response, NextFunction } from 'express';
+
+export const antiSpoofing = (req: Request, res: Response, next: NextFunction) => {
+  next();
+};

package/src/defenses/sqlInjection.ts

@@ -0,0 +1,41 @@
+import { Request, Response, NextFunction } from 'express';
+
+const sqlPatterns = [
+  /(\%27)|(\')|(\-\-)|(\%23)|(#)/i,
+  /select.+from/i,
+  /insert.+into/i,
+  /delete.+from/i,
+  /update.+set/i,
+  /drop.+table/i,
+  /union.+select/i,
+  /exec(\s|\+)+(s|x)p\w+/i,
+  /sleep\(/i,
+  /benchmark\(/i,
+  /information_schema/i
+];
+
+const checkNested = (obj: any): boolean => {
+  if (!obj) return false;
+  if (typeof obj === 'string') {
+    return sqlPatterns.some(pattern => pattern.test(obj));
+  }
+  if (typeof obj === 'object') {
+    return Object.values(obj).some(val => checkNested(val));
+  }
+  return false;
+};
+
+export const sqlInjectionProtection = (req: Request, res: Response, next: NextFunction) => {
+  const isInjected = checkNested(req.query) || checkNested(req.body) || checkNested(req.params);
+
+  if (isInjected) {
+    res.status(403).json({
+      error: '💉 SQL Injection Detected!',
+      message: 'Nice try, tapi YOGNKY gaakan kena 😎',
+      by: 'YOGNKY SECURITY'
+    });
+    return;
+  }
+
+  next();
+};

package/src/defenses/timingAttack.ts

@@ -0,0 +1,5 @@
+import { Request, Response, NextFunction } from 'express';
+
+export const antiTimingAttack = (req: Request, res: Response, next: NextFunction) => {
+  next();
+};

package/src/defenses/whitelist.ts

@@ -0,0 +1,23 @@
+import { Request, Response, NextFunction } from 'express';
+
+export const whitelistProtection = (allowedIPsStr: string | false) => {
+  if (!allowedIPsStr) return (_req: Request, _res: Response, next: NextFunction) => next();
+  
+  const allowedIPs = allowedIPsStr.split(',').map(ip => ip.trim());
+  
+  return (req: Request, res: Response, next: NextFunction) => {
+    const clientIP = req.ip || req.socket.remoteAddress || 'unknown';
+    const cleanIP = clientIP.replace('::ffff:', '');
+    
+    if (!allowedIPs.includes(cleanIP) && !allowedIPs.includes(clientIP)) {
+      res.status(403).json({
+        error: '🚫 Access Denied!',
+        message: `IP ${clientIP} tidak ada di whitelist`,
+        by: 'YOGNKY SECURITY'
+      });
+      return;
+    }
+    
+    next();
+  };
+};

package/src/defenses/xss.ts

@@ -0,0 +1,46 @@
+import { Request, Response, NextFunction } from 'express';
+
+const xssPatterns = [
+  /<script.*?>.*?<\/script>/i,
+  /javascript:/i,
+  /onerror=/i,
+  /onload=/i,
+  /onclick=/i,
+  /onmouseover=/i,
+  /eval\(/i,
+  /alert\(/i,
+  /prompt\(/i,
+  /confirm\(/i,
+  /document\./i,
+  /window\./i,
+  /location\./i,
+  /<iframe/i,
+  /<object/i,
+  /<embed/i
+];
+
+const checkXSS = (data: any): boolean => {
+  if (!data) return false;
+  if (typeof data === 'string') {
+    return xssPatterns.some(pattern => pattern.test(data));
+  }
+  if (typeof data === 'object') {
+    return Object.values(data).some(val => checkXSS(val));
+  }
+  return false;
+};
+
+export const xssProtection = (req: Request, res: Response, next: NextFunction) => {
+  const hasXSS = checkXSS(req.query) || checkXSS(req.body) || checkXSS(req.params);
+
+  if (hasXSS) {
+    res.status(403).json({
+      error: '⚠️ XSS Attack Detected!',
+      message: 'Ga bisa XSS disini, YOGNKY pinter 😤',
+      by: 'YOGNKY SECURITY'
+    });
+    return;
+  }
+
+  next();
+};