chiwormjava 2.0.4 → 2.0.6

package/readme.md

@@ -42,247 +42,488 @@ javacodewatch
 
 ---
 
+
 ---
-Step 1: Place devices
-Add in Packet Tracer:
-2 Routers (2621XM)
-2 Switches (2960)
-4 PCs
-
-Arrange as:
-PC1 PC2        PC3 PC4
- |    |          |    |
-Switch1          Switch2
-    |                |
-  Router1 ---- WAN ---- Router2
-
-Step 2: Add Serial Ports
-Click Router -> Physical tab
-Turn Power OFF
-Insert WIC-2T module
-Turn Power ON
-Now Serial0/0/0 and Serial0/0/1 will be available
-
-Step 3: Connect cables
-LAN:
-PC to Switch using Copper Straight-Through
-Switch to Router using Copper Straight-Through
-
-WAN:
-Use Serial DCE cable
-Router1 Serial0/0/0 to Router2 Serial0/0/0
-
-Step 4: Configure Router1
-enable
-configure terminal
-
-interface gigabitEthernet 0/0
-ip address 192.168.1.1 255.255.255.0
-no shutdown
-exit
-
-interface serial 0/0/0
-ip address 172.16.1.1 255.255.255.252
-clock rate 64000
-no shutdown
-exit
-
-Step 5: Configure Router2
-enable
-configure terminal
-
-interface gigabitEthernet 0/0
-ip address 10.0.0.1 255.255.255.248
-no shutdown
-exit
-
-interface serial 0/0/0
-ip address 172.16.1.2 255.255.255.252
-no shutdown
-exit
-
-Step 6: Configure PCs
-Left network:
-PC1 IP 192.168.1.2 Mask 255.255.255.0 Gateway 192.168.1.1
-PC2 IP 192.168.1.3 Gateway 192.168.1.1
-
-Right network:
-PC3 IP 10.0.0.2 Mask 255.255.255.248 Gateway 10.0.0.1
-PC4 IP 10.0.0.3 Gateway 10.0.0.1
-
-Step 7: Configure Routing
-Router1:
-ip route 10.0.0.0 255.255.255.248 172.16.1.2
-
-Router2:
-ip route 192.168.1.0 255.255.255.0 172.16.1.1
-
-Step 8: Verify interfaces
-Run:
-show ip interface brief
+const http = require('http')
+const fs = require('fs')
+
+const server = http.createServer();
+
+server.on('request', (req, res) => {
+    const rstream = fs.createReadStream('./product.json',"utf-8");
+    rstream.pipe(res);
+})
+
+server.on("request", (req, res) => {
+
+    const rstream = fs.createReadStream("./product.json", "utf-8");
+
+    rstream.on("data", (chunkData) => {
+        res.write(chunkData);
+    });
+
+    rstream.on("end", () => {
+        res.end();   // ✅ correct: just end response
+    });
+
+    rstream.on("error", (err) => {
+        console.log(err);
+        res.writeHead(500, { "Content-Type": "text/plain" });
+        res.end("File not found");
+    });
+
+});
+
+server.listen(3000, "127.0.0.1", () => {
+    console.log("Server is running at http://127.0.0.1:3000");
+});
+
+
+
+---
+
+import readline from "readline";
+
+const r1 = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+})
+
+
+// Armstrong
+let n;
+r1.question('Enter a num : ', (num) => {
+    n = parseInt(num)
+    let arm = 0;
+    let og = n;
+
+    let len = num.length;
+
+    while(n > 0){
+        let dig = n % 10;
+        arm += Math.pow(dig,len);
+        n = Math.floor(n / 10);
+    }
+    if(og == arm)
+        console.log('Is Armstrong!!');
+    else 
+        console.log('Is Not a Armstrong!!');
+})
+
+
+// calculator
+let n1, n2;
+r1.question('Enter the num : ', (num1) => {
+    n1 = parseInt(num1);
+    r1.question('Enter the num : ', (num2) => {
+        n2 = parseInt(num2);
+
+        let sum = n1 + n2;
+        let sub = n1 - n2;
+        let mul = n1 * n2;
+        let div = n1 / n2;
+
+        console.log('Addition : ', sum);
+        console.log('Subtraction : ', sub);
+        console.log('Multiplication : ', mul);
+        console.log('Division : ', div);
+    })
+})
+
+// Even or ODD
+r1.question('Enter a num : ', (num) => {
+    let n = num;
+    if(n % 2 == 0)
+        console.log('Even');
+    else
+        console.log('Odd');
+})
+
+
+// palindrom 
+r1.question('Enter a num : ', (num) => {
+    let s = num.toString();
+    let revNum = s.split('').reverse().join('');
+    if(revNum == s)
+        console.log('Is palindrome')
+    else 
+        console.log('Not a palindrome')
+})
+
+
+//Factorial of a Number
+r1.question('Enter a number: ', (num) => {
+    let n = parseInt(num);
+    let fact = 1;
+
+    for(let i = 1; i <= n; i++){
+        fact *= i;
+    }
+
+    console.log('Factorial:', fact);
+});
+
+
+//Fibonacci Series
+r1.question('Enter number of terms: ', (num) => {
+    let n = parseInt(num);
+    let a = 0, b = 1;
+
+    console.log(a);
+    console.log(b);
+
+    for(let i = 2; i < n; i++){
+        let next = a + b;
+        console.log(next);
+        a = b;
+        b = next;
+    }
+});
+
+//Prime Number Check
+r1.question('Enter a number: ', (num) => {
+    let n = parseInt(num);
+    let isPrime = true;
+
+    if(n <= 1) isPrime = false;
+
+    for(let i = 2; i <= Math.sqrt(n); i++){
+        if(n % i === 0){
+            isPrime = false;
+            break;
+        }
+    }
+
+    console.log(isPrime ? 'Prime' : 'Not Prime');
+});
 
-Status should be up up
-If not, use no shutdown
 
-Step 9: Test connectivity
-From PC1:
-ping 10.0.0.2
+//Sum of Digits
+r1.question('Enter a number: ', (num) => {
+    let n = parseInt(num);
+    let sum = 0;
 
-Expected reply from destination
+    while(n > 0){
+        sum += n % 10;
+        n = Math.floor(n / 10);
+    }
 
-Step 10: Simulation Mode
-Click Simulation
-Reset Simulation
-Edit Filters and select ARP and ICMP
+    console.log('Sum of digits:', sum);
+});
 
-Send packet using Add Simple PDU from PC1 to PC3
-Click Play or Capture/Forward
 
-Expected packet flow:
-PC1 -> Switch1 -> Router1 -> Router2 -> Switch2 -> PC3
+//Reverse a Number
+r1.question('Enter a number: ', (num) => {
+    let n = parseInt(num);
+    let rev = 0;
 
-First ARP then ICMP communication successful
+    while(n > 0){
+        let digit = n % 10;
+        rev = rev * 10 + digit;
+        n = Math.floor(n / 10);
+    }
 
+    console.log('Reversed number:', rev);
+});
 
 
-Step 1: Setting Up the Topology
-Add devices:
-1 Router (2911 or similar)
-1 Switch (2960)
-3 PCs (PC0, PC1, PC2)
-1 Cloud or Server
+//Largest of Three Numbers
+r1.question('Enter first number: ', (a) => {
+    r1.question('Enter second number: ', (b) => {
+        r1.question('Enter third number: ', (c) => {
 
-Step 2: Assign IP Addresses
-Private Network:
-PC0 IP 192.168.1.2 Mask 255.255.255.0 Gateway 192.168.1.1
-PC1 IP 192.168.1.3 Mask 255.255.255.0 Gateway 192.168.1.1
-PC2 IP 192.168.1.4 Mask 255.255.255.0 Gateway 192.168.1.1
+            let n1 = parseInt(a);
+            let n2 = parseInt(b);
+            let n3 = parseInt(c);
 
-Step 3: Configure Router Interfaces
-Router> enable
-Router# configure terminal
+            let max = Math.max(n1, n2, n3);
 
-Interface gig0/0
-Router(config)# interface gig0/0
-Router(config-if)# ip address 192.168.1.1 255.255.255.0
-Router(config-if)# no shutdown
+            console.log('Largest:', max);
+        });
+    });
+});
 
-Interface gig0/1
-Router(config)# interface gig0/1
-Router(config-if)# ip address 203.0.113.1 255.255.255.0
-Router(config-if)# no shutdown
 
-Assign IP to Cloud/Server
-IP 203.0.113.2
-Mask 255.255.255.0
+//Largest of Three Numbers
+r1.question('Enter a number: ', (num) => {
+    let n = parseInt(num);
 
-Step 4: Configure NAT
-Define inside and outside interfaces
-Router(config)# interface gig0/0
-Router(config-if)# ip nat inside
-Router(config-if)# exit
+    for(let i = 1; i <= 10; i++){
+        console.log(`${n} x ${i} = ${n * i}`);
+    }
+});
 
-Router(config)# interface gig0/1
-Router(config-if)# ip nat outside
-Router(config-if)# exit
 
-Configure PAT
-Router(config)# access-list 1 permit 192.168.1.0 0.0.0.255
-Router(config)# ip nat inside source list 1 interface gig0/1 overload
+//Count Digits
+r1.question('Enter a number: ', (num) => {
+    let count = num.length;
+    console.log('Total digits:', count);
+});
 
-Step 5: Configure Routing
-Router(config)# ip route 0.0.0.0 0.0.0.0 203.0.113.2
 
-Step 6: Test Configuration
-From PC command prompt:
-ping 203.0.113.2
 
-If reply is received, NAT is working
+---
+
+
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>My App</title>
+
+  <style>
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+      font-family: Arial, sans-serif;
+    }
+
+    body {
+      background: #f5f7fa;
+    }
+
+    .navbar {
+      display: flex;
+      justify-content: space-between;
+      padding: 15px 40px;
+      background: #333;
+      color: white;
+    }
+
+    .navbar a {
+      color: white;
+      margin-left: 20px;
+      text-decoration: none;
+    }
+
+    .hero {
+      text-align: center;
+      padding: 60px 20px;
+    }
+
+    .hero h1 {
+      font-size: 36px;
+    }
+
+    .hero p {
+      margin: 10px 0;
+    }
+
+    .features {
+      display: flex;
+      justify-content: center;
+      gap: 20px;
+      padding: 40px;
+    }
+
+    .card {
+      background: white;
+      padding: 20px;
+      width: 200px;
+      text-align: center;
+      border-radius: 8px;
+    }
+
+    .dynamic {
+      text-align: center;
+      margin: 20px;
+      font-size: 20px;
+      color: #333;
+    }
+
+    footer {
+      text-align: center;
+      padding: 15px;
+      background: #333;
+      color: white;
+    }
+  </style>
+</head>
+
+<body>
+
+  <!-- Navbar -->
+  <nav class="navbar">
+    <h2>MyApp</h2>
+    <div>
+      <a href="/home">Home</a>
+      <a href="/about">About</a>
+      <a href="/contact">Contact</a>
+      <a href="/support">Support</a>
+    </div>
+  </nav>
+
+  <!-- Dynamic Content from Server -->
+  <div class="dynamic">
+    {{CONTENT}}
+  </div>
+
+  <!-- Hero Section -->
+  <section class="hero">
+    <h1>Simple Node Application</h1>
+    <p>This page is served using a basic Node.js server.</p>
+  </section>
+
+  <!-- Features -->
+  <section class="features">
+    <div class="card">
+      <h3>Fast</h3>
+      <p>Handles requests efficiently</p>
+    </div>
+    <div class="card">
+      <h3>Simple</h3>
+      <p>Easy routing and structure</p>
+    </div>
+    <div class="card">
+      <h3>Flexible</h3>
+      <p>Can be extended easily</p>
+    </div>
+  </section>
+
+  <!-- Footer -->
+  <footer>
+    <p>Basic Node Server Example</p>
+  </footer>
+
+</body>
+</html>
+
+
+
+
+---
+
+
+
+const http = require("http");
+const fs = require("fs");
+const path = require("path");
+
+let counter = 0;
+
+// Read HTML template
+const content = fs.readFileSync("./indexFinal.html", "utf-8");
 
-Verify NAT translations
-Router# show ip nat translations
+const server = http.createServer((req, res) => {
 
+    counter++;
+    console.log(`Server hit ${counter} times`);
 
+    let url = req.url.toLowerCase();
 
+    // Serve CSS
+    if (url === "/style.css") {
+        const cssPath = path.join(__dirname, "style.css");
+        const style = fs.readFileSync(cssPath, "utf-8");
 
+        res.writeHead(200, { "Content-Type": "text/css" });
+        return res.end(style);
+    }
 
+    // Routing pages
+    let pageContent = "";
 
+    if (url === "/" || url === "/home") {
+        pageContent = "🏠 Welcome to Home Page";
+    } 
+    else if (url === "/about") {
+        pageContent = "📖 About Us Page";
+    } 
+    else if (url === "/contact") {
+        pageContent = "📞 Contact Page";
+    } 
+    else if (url === "/support") {
+        pageContent = "🛠 Support Page";
+    } 
+    else {
+        res.writeHead(404, { "Content-Type": "text/html" });
+        return res.end(content.replace("{{CONTENT}}", " 404 Page Not Found"));
+    }
 
+    // Common response
+    res.writeHead(200, { "Content-Type": "text/html" });
+    res.end(content.replace("{{CONTENT}}", pageContent));
 
+});
 
+server.listen(3000, "127.0.0.1", () => {
+    console.log("Server running at http://127.0.0.1:3000");
+});
 
 
 
 
 
 
+---
 
 
+const http = require("http");
+const fs = require("fs");
 
+let counter = 0;
 
+const content = fs.readFileSync("./Template/index.html", "utf-8");
 
+const server = http.createServer((request, response) => {
 
-AIM:
-To analyze packet fragmentation by changing packet size and observing its effect using Wireshark.
+    counter++;
+    console.log(`Server started ${counter} times`);
 
-Step 1: Open Wireshark
-Launch Wireshark
-Select active interface (WiFi or Ethernet)
-Click Start Capture
+    let path = request.url.toLowerCase();
 
-Step 2: Check MTU size
-Open Command Prompt and run:
-netsh interface ipv4 show subinterfaces
-Note MTU value (usually 1500 bytes)
+    
+    if (path === "/" || path === "/home") {
+        response.writeHead(200, { "Content-Type": "text/html" });
+        response.end(content.replace("{{CONTENT}}", "You are in home page"));
+    }
 
-Step 3: Test without fragmentation
-ping 8.8.8.8 -f -l 1472
-1472 + 28 header = 1500, fits MTU
-Output: Reply received, no fragmentation
+  
+    else if (path === "/about") {
+        response.writeHead(200, { "Content-Type": "text/html" });
+        response.end(content.replace("{{CONTENT}}", "You are in about us page"));
+    }
 
-Step 4: Force fragmentation error
-ping 8.8.8.8 -f -l 2000
-Output: Packet needs to be fragmented but DF set
-Meaning: Packet too large and fragmentation not allowed
+   
+    else if (path === "/contact") {
+        response.writeHead(200, { "Content-Type": "text/html" });
+        response.end(content.replace("{{CONTENT}}", "You are in contact page"));
+    }
 
-Step 5: Allow fragmentation
-ping 8.8.8.8 -l 2000
-Packet is divided into fragments
-May observe delay or packet loss
+    
+    else if (path === "/support") {
+        response.writeHead(200, { "Content-Type": "text/html" });
+        response.end(content.replace("{{CONTENT}}", "Support me aagya bhai"));
+    }
 
-Step 6: Analyze in Wireshark
-Apply filter:
-ip.flags.mf == 1 or ip.frag_offset > 0
+    
+    else if (path === "/product") {
 
-Observation:
-Multiple packets for single ping
-Fragmented packets visible
+        fs.readFile("./data/products.json", "utf-8", (error, jsonData) => {
 
-Observations:
-Fragmented packets have same Identification ID
-Different Fragment Offset values
-MF flag indicates more fragments
-Last packet has MF = 0
+            if (error) {
+                response.writeHead(500, { "Content-Type": "text/plain" });
+                return response.end("Error reading JSON file");
+            }
 
-Performance Impact:
-More packets generated
-Increased delay
-Possible packet loss
+            response.writeHead(200, { "Content-Type": "application/json" });
+            response.end(jsonData);
+        });
+    }
 
-Final Observation:
-Small packet: No fragmentation
-Large packet with DF: Error
-Large packet without DF: Fragmentation occurs
+    // 404
+    else {
+        response.writeHead(404, { "Content-Type": "text/html" });
+        response.end(content.replace("{{CONTENT}}", "Error : 404 NOT FOUND"));
+    }
 
-Conclusion:
-If packet size exceeds MTU, it is divided into smaller fragments, affecting performance
+});
 
-Output:
-Ping command results showing success or error
-Wireshark showing fragmented packets using filter
+server.listen(3000, "127.0.0.1", () => {
+    console.log("Server running at http://127.0.0.1:3000");
+});
 
-Result:
-Fragmentation observed and analyzed successfully
 
 
 
@@ -302,87 +543,39 @@ Fragmentation observed and analyzed successfully
 
 
 
-AIM:
-To identify vulnerabilities and secure the network using Access Control List (ACL) and Port Security.
 
-Step 1: Topology Setup
-Add devices:
-1 Router (2911)
-1 Switch (2960)
-2 PCs
 
-Step 2: Connections
-PC1 FastEthernet0 to Switch Fa0/1 using Copper Straight-Through
-PC2 FastEthernet0 to Switch Fa0/2 using Copper Straight-Through
-Switch Fa0/24 to Router GigabitEthernet0/0
 
-Step 3: Configure PCs
-PC1 IP 192.168.1.10 Mask 255.255.255.0 Gateway 192.168.1.1
-PC2 IP 192.168.1.20 Mask 255.255.255.0 Gateway 192.168.1.1
+---
 
-Step 4: Configure Router
-enable
-configure terminal
-interface g0/0
-ip address 192.168.1.1 255.255.255.0
-no shutdown
-exit
+[
+  {
+    "id": 1,
+    "name": "Laptop",
+    "price": 60000
+  },
+  {
+    "id": 2,
+    "name": "Phone",
+    "price": 20000
+  },
+  {
+    "id": 3,
+    "name": "Tablet",
+    "price": 30000
+  }
+]
 
-Step 5: Test Before Security
-From PC2:
-ping 192.168.1.10
-Communication should be successful
 
-Step 6: Apply ACL
-access-list 1 deny 192.168.1.20
-access-list 1 permit any
 
-Apply ACL:
-interface g0/0
-ip access-group 1 in
-exit
 
-Step 7: Test After Security
-From PC2:
-ping 192.168.1.10
-Should fail
 
-From PC1:
-ping 192.168.1.20
-Should work
 
-Step 8: Configure Port Security on Switch
-enable
-configure terminal
-interface fa0/1
-switchport mode access
-switchport port-security
-switchport port-security maximum 1
-exit
 
-Vulnerabilities Identified:
-No access control
-No device restriction
-No traffic filtering
 
-Security Measures Applied:
-ACL controls communication between devices
-Port Security restricts number of devices per port
 
-Additional Concepts:
-IDS detects suspicious activities such as unusual traffic
-IPsec encrypts data for secure transmission
 
-Simulation (Optional):
-Use Simulation mode
-Filter ICMP
-Observe packet drop due to ACL
 
-Final Result:
-PC2 is blocked
-PC1 is allowed
-Switch ports are secured
-Network is protected successfully
 
 
 
@@ -400,113 +593,86 @@ Network is protected successfully
 
 
 
+---
 
 
+GET
 
+---
+const express = require('express');
+const fs = require('fs');
 
+const app = express();
 
+// Helper function to read data
+function getProducts() {
+    const data = fs.readFileSync('./product.json', 'utf-8');
+    return JSON.parse(data).products;
+}
 
+// Home route
+app.get('/', (req, res) => {
+    res.status(200).send('You are on home page');
+});
 
-AIM:
-To demonstrate IP Spoofing attack and implement security measures to prevent unauthorized access.
+// About route
+app.get('/about', (req, res) => {
+    res.status(200).send('You are on about page');
+});
 
-Step 1: Topology Setup
-Devices required:
-1 Router (2911)
-1 Switch (2960)
-PC1 (Trusted user)
-PC2 (Attacker)
-1 Server
+// Get all products
+app.get('/product', (req, res) => {
+    const products = getProducts();
 
-Connections:
-PC1 to Switch Fa0/1
-PC2 to Switch Fa0/2
-Switch Fa0/24 to Router G0/0
-Server to Router G0/1
+    res.status(200).json({
+        status: 'success',
+        results: products.length,
+        data: products
+    });
+});
 
-Step 2: IP Configuration
-PC1 IP 192.168.1.10 Gateway 192.168.1.1
-PC2 IP 192.168.1.20 Gateway 192.168.1.1
-Server IP 10.0.0.2 Gateway 10.0.0.1
+// Get single product by ID
+app.get('/product/:id', (req, res) => {
+    const products = getProducts();
+    const id = parseInt(req.params.id);
 
-Step 3: Configure Router
-enable
-configure terminal
+    const product = products.find(el => el.id === id);
 
-interface g0/0
-ip address 192.168.1.1 255.255.255.0
-no shutdown
-exit
+    if (!product) {
+        return res.status(404).json({
+            status: 'fail',
+            message: 'Product not found'
+        });
+    }
 
-interface g0/1
-ip address 10.0.0.1 255.255.255.0
-no shutdown
-exit
+    res.status(200).json({
+        status: 'success',
+        data: product
+    });
+});
 
-Step 4: Configure Routing
-ip route 10.0.0.0 255.255.255.0 10.0.0.1
+// Contact route
+app.get('/contact', (req, res) => {
+    res.status(200).send('You are on contact page');
+});
 
-Step 5: Apply Trust-Based ACL
-access-list 10 permit 192.168.1.10
-access-list 10 deny any
+app.listen(3000, () => {
+    console.log('Server running on port 3000');
+});
 
-interface g0/0
-ip access-group 10 in
 
-Step 6: Test Before Attack
-From PC1:
-ping 10.0.0.2 (should work)
 
-From PC2:
-ping 10.0.0.2 (should fail)
 
-Step 7: Simulate IP Spoofing
-Change PC2 IP to 192.168.1.10
 
-Test again:
-ping 10.0.0.2 (should work)
 
-Step 8: Impact
-Unauthorized access
-Security bypass
-Fake identity
 
-Step 9: Countermeasure 1 Anti-Spoofing ACL
-ip access-list extended ANTI-SPOOF
-deny ip 192.168.1.0 0.0.0.255 any
-permit ip any any
 
-interface g0/1
-ip access-group ANTI-SPOOF in
 
-Step 10: Countermeasure 2 uRPF
-interface g0/0
-ip verify unicast source reachable-via rx
 
-Step 11: Switch Port Security
-enable
-configure terminal
 
-interface fa0/1
-switchport mode access
-switchport port-security
-switchport port-security maximum 1
-switchport port-security mac-address sticky
-switchport port-security violation shutdown
 
-Final Understanding:
-Before ACL everyone allowed
-ACL allows only trusted IP
-Spoofing bypasses security
-uRPF blocks spoofed packets
 
-Conclusion:
-IP-based trust is not secure and must be verified using mechanisms like uRPF and port security
 
-Result:
-Attack simulated successfully
-Vulnerability identified
-Security measures implemented
 
 
 
@@ -527,110 +693,67 @@ Security measures implemented
 
 
 
+POST
 
+---
 
+const express = require('express');
+const fs = require('fs');
 
-AIM:
-To allow normal UDP communication and block unwanted UDP traffic using ACL.
+const app = express();
 
-Step 1: Build the Network
-Devices required:
-1 Router (2911)
-1 Switch (2960)
-PC1 (Client)
-PC2 (Attacker)
-1 Server
+app.use(express.json());
 
-Connections:
-PC1 FastEthernet0 to Switch Fa0/1
-PC2 FastEthernet0 to Switch Fa0/2
-Server FastEthernet0 to Switch Fa0/3
-Switch Fa0/24 to Router GigabitEthernet0/0
 
-Step 2: IP Configuration
-PC1 IP 192.168.1.10 Gateway 192.168.1.1
-PC2 IP 192.168.1.30 Gateway 192.168.1.1
-Server IP 192.168.1.20
-Subnet Mask 255.255.255.0
+function getProducts() {
+    const data = fs.readFileSync('./product.json', 'utf-8');
+    return JSON.parse(data).products;
+}
 
-Step 3: Configure Router
-enable
-configure terminal
-interface g0/0
-ip address 192.168.1.1 255.255.255.0
-no shutdown
-exit
+function saveProducts(products) {
+    fs.writeFileSync('./product.json', JSON.stringify({ products }, null, 2));
+}
 
-Step 4: Enable UDP Service on Server
-Open Server -> Services -> DNS
-Turn DNS ON
-Add entry:
-Name example.com
-Address 192.168.1.20
+app.post('/product', (req, res) => {
 
-Step 5: Test UDP Communication
-From PC1:
-nslookup example.com 192.168.1.20
-UDP communication should work
+    const products = getProducts();
+    const newProduct = req.body;
 
-Step 6: Apply ACL to Block Attacker
-Router(config)# access-list 100 deny udp host 192.168.1.30 any
-Router(config)# access-list 100 permit ip any any
+   
+    if (!newProduct.name || !newProduct.price) {
+        return res.status(400).json({
+            status: 'fail',
+            message: 'Name and price are required'
+        });
+    }
 
-Apply ACL:
-interface g0/0
-ip access-group 100 in
-exit
+    
+    const newId = products.length > 0 
+        ? products[products.length - 1].id + 1 
+        : 1;
 
-Step 7: Test After ACL
-From PC2:
-nslookup example.com 192.168.1.20 (should fail)
+    newProduct.id = newId;
 
-From PC1:
-nslookup example.com 192.168.1.20 (should work)
+    products.push(newProduct);
 
-Step 8: Block DNS Service (Port-Based ACL)
-Router(config)# access-list 101 deny udp any any eq 53
-Router(config)# access-list 101 permit ip any any
+    saveProducts(products);
 
-Apply:
-interface g0/0
-ip access-group 101 in
-exit
+    res.status(201).json({
+        status: 'success',
+        message: 'Product added successfully',
+        data: newProduct
+    });
+});
 
-Test:
-From PC1:
-nslookup example.com 192.168.1.20 (should fail)
+app.listen(3000, () => {
+    console.log('Server running on port 3000');
+});
 
-Step 9: Important Concept
-If all devices are in same network, traffic bypasses router
-Communication becomes PC -> Switch -> Server
-ACL will not work
 
-Step 10: Fix Topology
-Change Server network:
-Server IP 10.0.0.2 Gateway 10.0.0.1
 
-Configure Router:
-interface g0/1
-ip address 10.0.0.1 255.255.255.0
-no shutdown
 
-Now traffic flows through router:
-PC -> Router -> Server
-ACL works correctly
 
-Concepts:
-UDP is fast and connectionless protocol
-ACL filters traffic based on rules
-Port 53 is used for DNS
-Router must be in path for ACL to work
 
-Result:
-UDP communication tested
-Attacker blocked using ACL
-DNS service blocked using port-based ACL
-Network secured successfully
 
 
 
@@ -654,95 +777,75 @@ Network secured successfully
 
 
 
-AIM:
-Create a network, enable DNS (UDP), allow normal user, and block attacker using ACL.
 
-Step 1: Topology
-PC1 (Client) and PC2 (Attacker) connected to Switch
-Switch connected to Router G0/0
-Router G0/1 connected to Server
 
-Step 2: Connections
-Use Copper Straight-Through cables
-PC1 to Switch Fa0/1
-PC2 to Switch Fa0/2
-Switch to Router G0/0
-Router G0/1 to Server
-All links should be active
 
-Step 3: IP Configuration
-PC1 IP 192.168.1.10 Mask 255.255.255.0 Gateway 192.168.1.1 DNS 10.0.0.2
-PC2 IP 192.168.1.30 Mask 255.255.255.0 Gateway 192.168.1.1 DNS 10.0.0.2
-Server IP 10.0.0.2 Mask 255.255.255.0 Gateway 10.0.0.1
 
-Step 4: Router Configuration
-enable
-configure terminal
 
-interface g0/0
-ip address 192.168.1.1 255.255.255.0
-no shutdown
-exit
 
-interface g0/1
-ip address 10.0.0.1 255.255.255.0
-no shutdown
-exit
 
-Step 5: Enable DNS on Server
-Open Server -> Services -> DNS
-Turn DNS ON
-Add entry:
-Name example.com
-Address 10.0.0.2
 
-Step 6: Initial Testing
-From PC1:
-ping 10.0.0.2
-This builds ARP
+--- 
+PATCH
+---
 
-Then:
-nslookup example.com
-Should work successfully
 
-Step 7: Apply ACL Security
-configure terminal
+const express = require('express');
+const fs = require('fs');
 
-access-list 101 deny udp host 192.168.1.30 any
-access-list 101 permit ip any any
+const app = express();
 
-interface g0/0
-ip access-group 101 in
-exit
+app.use(express.json());
 
-Step 8: Final Testing
-From PC1:
-nslookup example.com
-Should work
+// Helper functions
+function getProducts() {
+    const data = fs.readFileSync('./product.json', 'utf-8');
+    return JSON.parse(data).products;
+}
 
-From PC2:
-nslookup example.com
-Should fail
+function saveProducts(products) {
+    fs.writeFileSync('./product.json', JSON.stringify({ products }, null, 2));
+}
 
-Concepts:
-Router must be in path for ACL to work
-DNS uses UDP port 53
-First ping builds ARP and avoids timeout
-ACL filters traffic based on rules
 
-Final Result:
-PC1 allowed
-PC2 blocked
-DNS working
-ACL applied successfully
+app.patch('/product/:id', (req, res) => {
 
+    const products = getProducts();
+    const id = parseInt(req.params.id);
 
+    const product = products.find(el => el.id === id);
 
+    
+    if (!product) {
+        return res.status(404).json({
+            status: 'fail',
+            message: 'Product not found'
+        });
+    }
 
+  
+    if (req.body.id) {
+        return res.status(400).json({
+            status: 'fail',
+            message: 'Cannot update product id'
+        });
+    }
 
+    
+    Object.assign(product, req.body);
 
+    saveProducts(products);
 
+    res.status(200).json({
+        status: 'success',
+        message: 'Product updated successfully',
+        data: product
+    });
+});
 
+app.listen(3000, () => {
+    console.log('Server running on port 3000');
+});
 
 
 
@@ -764,108 +867,73 @@ ACL applied successfully
 
 
 
-AIM:
-Simulate a DNS-based UDP hijacking scenario, observe its impact on the client, and apply basic protection.
 
-Step 1: Topology Setup
-Connect devices using Copper Straight-Through:
-PC1 to Switch
-PC2 to Switch
-Server to Switch
-Switch to Router
-Ensure all connections are active
 
-Step 2: IP Configuration
-PC1 IP 192.168.1.10 Mask 255.255.255.0 Gateway 192.168.1.1 DNS 192.168.1.100
-PC2 IP 192.168.1.20 Gateway 192.168.1.1
-Server IP 192.168.1.100 Gateway 192.168.1.1
 
-Step 3: Router Configuration
-enable
-configure terminal
-interface g0/0
-ip address 192.168.1.1 255.255.255.0
-no shutdown
-exit
 
-Step 4: Enable DNS on Real Server
-Open Server -> Services -> DNS
-Turn DNS ON
-Add entry:
-example.com maps to 192.168.1.100
 
-Step 5: Test Normal Output
-From PC1:
-nslookup example.com
-Expected result:
-Name example.com
-Address 192.168.1.100
 
-Step 6: Simulate Attack
-Turn OFF real server
-On PC2 change IP to 192.168.1.100
-Enable DNS on PC2
-Add entry:
-example.com maps to 5.5.5.5
 
-Step 7: Test Attack Output
-From PC1:
-nslookup example.com
-Expected result:
-Name example.com
-Address 5.5.5.5
 
-Observation:
-Before attack DNS resolves to 192.168.1.100
-After attack DNS resolves to 5.5.5.5
-Client is misled
 
-Step 8: Apply Basic Protection using Port Security
-On Switch CLI:
-enable
-configure terminal
-interface fa0/2
-switchport mode access
-switchport port-security
-switchport port-security maximum 1
-switchport port-security mac-address sticky
-switchport port-security violation shutdown
-exit
 
-Step 9: Final Check
-Attempt attack again
-Port security blocks attacker or shuts down port
 
-Output Observation Methods:
-Command Line:
-Use nslookup example.com before and after attack
+---
+DELETE
+---
+
+const express = require('express');
+const fs = require('fs');
 
-Simulation Mode:
-Select Simulation
-Filter DNS or UDP
-Run nslookup
-Observe source IP, destination IP, and UDP port 53
+const app = express();
 
-Conclusion:
-DNS over UDP can be exploited by spoofing
-Client blindly trusts DNS response
-Security measures like port security help prevent attacks
+app.use(express.json());
 
-Result:
-Attack successfully simulated
-Impact observed
-Basic protection applied
+function getProducts() {
+    const data = fs.readFileSync('./product.json', 'utf-8');
+    return JSON.parse(data).products;
+}
 
+function saveProducts(products) {
+    fs.writeFileSync('./product.json', JSON.stringify({ products }, null, 2));
+}
 
+app.delete('/product/:id', (req, res) => {
 
+    const products = getProducts();
+    const id = parseInt(req.params.id);
 
+    
+    const index = products.findIndex(el => el.id === id);
 
+    
+    if (index === -1) {
+        return res.status(404).json({
+            status: 'fail',
+            message: 'Product not found'
+        });
+    }
 
+  
+    const deletedProduct = products.splice(index, 1);
 
+    saveProducts(products);
 
+    res.status(200).json({
+        status: 'success',
+        message: 'Product deleted successfully',
+        data: deletedProduct[0]
+    });
+});
 
+app.listen(3000, () => {
+    console.log('Server running on port 3000');
+});
 
 
+---
+PUT
+---
 
 
 
@@ -888,126 +956,79 @@ Basic protection applied
 
 
 
-AIM:
-Simulate a DoS condition using continuous requests, observe its impact on a server, and apply prevention techniques.
 
-Step 1: Topology
-Devices:
-PC1, PC2, PC3, Server connected to Switch
-Switch connected to Router G0/0
-Ensure all connections are active
 
-Step 2: IP Configuration
-PC1 IP 192.168.1.10
-PC2 IP 192.168.1.20
-PC3 IP 192.168.1.30
-Server IP 192.168.1.100
-Mask 255.255.255.0
-Gateway 192.168.1.1
 
-Step 3: Router Configuration
-enable
-configure terminal
-interface g0/0
-ip address 192.168.1.1 255.255.255.0
-no shutdown
-exit
 
-Step 4: Enable Server Service
-Open Server -> Services -> HTTP
-Turn HTTP ON
 
-Step 5: Normal Test
-From PC1:
-ping 192.168.1.100
-Stable replies indicate normal operation
 
-Step 6: Simulate DoS Attack
-From PC2:
-ping 192.168.1.100 -t
+const express = require('express');
+const fs = require('fs');
 
-From PC3:
-ping 192.168.1.100 -t
+const app = express();
 
-Continuous traffic is generated
+app.use(express.json());
 
-Step 7: Observe Impact
-From PC1:
-ping 192.168.1.100
+// Helper functions
+function getProducts() {
+    const data = fs.readFileSync('./product.json', 'utf-8');
+    return JSON.parse(data).products;
+}
 
-Expected results:
-Request timed out
-High delay
-Packet loss
+function saveProducts(products) {
+    fs.writeFileSync('./product.json', JSON.stringify({ products }, null, 2));
+}
 
-Indicates server overload and network congestion
+// PUT: Replace product completely
+app.put('/product/:id', (req, res) => {
 
-Step 8: Important Concept
-If all devices are in same network, traffic flows directly
-PC -> Switch -> Server
-Router is bypassed
-ACL on router will not work
+    const products = getProducts();
+    const id = parseInt(req.params.id);
 
-Step 9: Apply Switch Port Security
-enable
-configure terminal
+    const index = products.findIndex(el => el.id === id);
 
-interface fa0/2
-switchport port-security
-switchport port-security maximum 1
-switchport port-security violation shutdown
-exit
+    
+    if (index === -1) {
+        return res.status(404).json({
+            status: 'fail',
+            message: 'Product not found'
+        });
+    }
 
-interface fa0/3
-switchport port-security
-switchport port-security maximum 1
-switchport port-security violation shutdown
-exit
+    const newData = req.body;
 
-Limits attacker behavior
+    
+    if (!newData.name || !newData.price) {
+        return res.status(400).json({
+            status: 'fail',
+            message: 'Name and price are required'
+        });
+    }
 
-Step 10: Improved Topology for Router Control
-Change Server network:
-Server IP 10.0.0.2 Gateway 10.0.0.1
+    
+    newData.id = id;
 
-Add router interface:
-interface g0/1
-ip address 10.0.0.1 255.255.255.0
-no shutdown
+    
+    products[index] = newData;
 
-Traffic now passes through router
+    saveProducts(products);
 
-Step 11: Apply ACL Protection
-ip access-list extended BLOCK_ICMP
-permit icmp host 192.168.1.10 host 10.0.0.2
-deny icmp any any
+    res.status(200).json({
+        status: 'success',
+        message: 'Product replaced successfully',
+        data: newData
+    });
+});
 
-interface g0/0
-ip access-group BLOCK_ICMP in
+app.listen(3000, () => {
+    console.log('Server running on port 3000');
+});
 
-Step 12: Final Testing
-From PC1:
-ping 10.0.0.2 (should work)
 
-From PC2 and PC3:
-ping 10.0.0.2 (should fail)
 
-Output Observation:
-Command Line:
-Compare ping before and during attack
 
-Simulation Mode:
-Filter ICMP
-Observe multiple packets and congestion
 
-Conclusion:
-DoS attack floods server with requests causing delay and packet loss
-Switch port security and ACL help control traffic
 
-Result:
-Attack simulated
-Impact observed
-Protection applied successfully
 
 
 
@@ -1024,3 +1045,27 @@ Protection applied successfully
 
 
 
+---
+chalk
+---
+const chalk = require('chalk');
+
+console.log(chalk.red.bold('Error!'));
+console.log(chalk.green.underline('Success!'));
+console.log(chalk.blue.italic('Info message'));
+console.log(chalk.white.bgBlue.bold(' Important Message '));
+console.log(chalk.black.bgYellow(' Warning Block '));
+console.log(chalk.bgRed.white.bold(' Critical Error '));
+console.log(chalk.rgb(255, 136, 0)('Custom Orange Text'));
+console.log(chalk.hex('#00FFAA')('Hex Color Text'));
+console.log(chalk.bgHex('#FF5733').white('Styled Background'));
+console.log(
+  chalk.blue('Hello ' + chalk.yellow.bold('World') + '!')
+);
+console.log(
+  chalk.red('H') +
+  chalk.yellow('e') +
+  chalk.green('l') +
+  chalk.blue('l') +
+  chalk.magenta('o')
+);