<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Reva Zuranti on Medium]]></title>
        <description><![CDATA[Stories by Reva Zuranti on Medium]]></description>
        <link>https://medium.com/@revazuranti?source=rss-48f479942854------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*5fCCkSkYC-6nVGt4</url>
            <title>Stories by Reva Zuranti on Medium</title>
            <link>https://medium.com/@revazuranti?source=rss-48f479942854------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 16:27:30 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@revazuranti/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[An Insider Threat Incident Response Playbook, Walked Through a Simulated Case]]></title>
            <link>https://medium.com/@revazuranti/an-insider-threat-incident-response-playbook-walked-through-a-simulated-case-90e83e2f3a3b?source=rss-48f479942854------2</link>
            <guid isPermaLink="false">https://medium.com/p/90e83e2f3a3b</guid>
            <dc:creator><![CDATA[Reva Zuranti]]></dc:creator>
            <pubDate>Thu, 19 Nov 2026 02:33:28 GMT</pubDate>
            <atom:updated>2026-11-19T02:33:28.654Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>What happens when the attacker already has a badge. A step by step response to sabotage of a SIEM server.</blockquote><p>Outside attackers get the headlines, but insiders already have access. This playbook follows a simulated scenario, so no real organization is involved.</p><p><strong>The Scenario</strong></p><p>On 1 July 2025 at 08:15 WIB, the Wazuh SIEM raised alerts about deleted system logs and a changed main configuration file on the Wazuh server. The alert was backed up by a high severity notification to Telegram from TheHive about unauthorized access to /var/ossec/logs and /etc/ossec.conf. The user was an internal account called admin_1 that should already have been disabled, and Graylog showed SSH access from an internal campus IP outside working hours.</p><p><strong>Step 1 — Detect from many angles</strong></p><p>No single tool told the whole story. Together they did.</p><ol><li>Filebeat captured the change events on ossec.conf.</li><li>Snort alerted on a privilege escalation attempt through command injection, rule ID 1000012.</li><li>Graylog showed the same anomaly across SSH logins, bash history and auth.log.</li><li>Grafana showed a CPU spike and a drop in the log ingestion rate from Wazuh agents.</li><li>TheHive received automatic alerts through Cortex analyzers, using sources such as abuse.ch and VirusTotal, on a suspicious script.</li></ol><p><strong>Step 2 — Triage</strong></p><ol><li><strong>Severity</strong></li></ol><ul><li>Assessment: High, with unauthorized access and likely sabotage</li></ul><p>2. Assets affected</p><ul><li>Assessment: Wazuh Manager, the log pipeline with Filebeat and Graylog, and the rule analyzer</li></ul><p>3. Scope</p><ul><li>One node for now, with potential to spread</li></ul><p>4. Actor</p><ul><li>Internal account admin_1, which should have been disabled</li></ul><p><strong>Step 3 — Contain while keeping evidence</strong></p><ol><li>Cut SSH access to all affected SIEM servers for now.</li><li>Isolate the Wazuh and Filebeat VLAN with firewall and NAT settings.</li><li>Force disable admin_1 and audit user privileges on every connected platform.</li><li>Take snapshots of the Wazuh, Graylog and OpenSearch machines for forensics and rollback.</li><li>Allow only approved sources to reach critical endpoints through the reverse proxy.</li><li>Put Grafana in maintenance mode so non technical staff do not misread the data.</li><li>Let TheHive run Cortex response scripts that stop services temporarily and tag suspicious artifacts.</li></ol><p><strong>Step 4 — Clean up and recover</strong></p><ol><li>Analyze the snapshots for unauthorized changes, malicious scripts or backdoors.</li><li>Scan suspicious files in /var/ossec/logs and /etc/ossec.conf with VirusTotal and YARA rules through Cortex.</li><li>Compare SHA256 checksums with trusted backups, then remove or quarantine anything malicious.</li><li>Restore ossec.conf from a verified backup stored safely, for example in a versioned storage bucket.</li><li>Reset all admin credentials and turn on MFA across Wazuh, Graylog and related systems.</li><li>Update the operating system and the Wazuh, Filebeat, Graylog and OpenSearch software.</li><li>Allow SSH only through a VPN with refreshed keys.</li><li>Test that log collection, rules and integrations work, watch Snort for new suspicious traffic, and run a simple unauthorized access test.</li><li>Return SSH and VLAN access step by step to audited users, then switch Grafana back to normal.</li><li>Document everything and update the asset inventory and TheHive logs.</li></ol><p><strong>Step 5 — After the incident</strong></p><ol><li>Meet with the response team and do a root cause analysis. The key question is how a disabled account could still log in. Possible causes are a failed offboarding process or weak identity management.</li><li>Apply least privilege and audit admin accounts regularly.</li><li>Add Wazuh rules for access outside working hours and unauthorized file changes, and add Snort rules for similar command injection and privilege escalation.</li><li>Rotate SSH keys and API credentials on a schedule.</li><li>Consider User Behavior Analytics, write admin logs to read only storage, tighten network segmentation and protect dashboards with a web application firewall.</li><li>Train the team on insider threats and run tabletop exercises.</li><li>Update the playbook with what you learned and share the report with stakeholders.</li></ol><p><strong>What I learned</strong></p><p>The most useful defense against insiders is boring. Remove access quickly when people leave, give each person only the access they need, and log what admins do in a place they cannot edit.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=90e83e2f3a3b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Ransomware Incident Response Playbook]]></title>
            <link>https://medium.com/@revazuranti/a-ransomware-incident-response-playbook-e9e4b90d1a62?source=rss-48f479942854------2</link>
            <guid isPermaLink="false">https://medium.com/p/e9e4b90d1a62</guid>
            <dc:creator><![CDATA[Reva Zuranti]]></dc:creator>
            <pubDate>Thu, 19 Nov 2026 02:33:20 GMT</pubDate>
            <atom:updated>2026-11-19T02:33:20.548Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>What to do in the first minutes, the first hours and the weeks after ransomware hits.</blockquote><p>Where the IR Plan sets the strategy, a playbook gives the exact steps for one type of attack. This article covers ransomware, based on the playbook my team wrote.</p><p><strong>Step 1: Recognize the trigger</strong></p><p>Treat it as ransomware when one or more of these appear.</p><ol><li>Users find files with unknown extensions such as .locked, .crypt or .zepto, or ransom notes in many folders.</li><li>EDR, antivirus or an IDPS alerts on mass file changes, malicious files or contact with a command and control server.</li><li>The SIEM warns about abnormal behavior, such as unauthorized access attempts to several servers at once or a sudden jump in disk activity.</li></ol><p><strong>Step 2 — Confirm and classify</strong></p><p>Check affected machines for the unknown extensions and ransom notes, then review SIEM, EDR and IDPS logs. Do a quick check of how far the damage goes. If the first signs are confirmed, disconnect the affected system from the network right away by unplugging the cable, turning off wireless or isolating the switch port.</p><ol><li>Critical</li></ol><ul><li>Criteria: More than 50 percent of systems encrypted, operations fully stopped, mission critical systems hit, or double extortion threat</li><li>Priority Actions: Activate the emergency team, isolate the network completely, involve executives and external forensics</li></ul><p>2. High</p><ul><li>Criteria: One department or site infected, partial operational impact, signs of lateral spread</li><li>Priority Actions: Activate the IR team, isolate the network segment, start restoring from backup, report to the data protection officer if needed</li></ul><p>3. Medium</p><ul><li>Criteria: A few less critical workstations, no spread to servers</li><li>Priority Actions: Isolate the workstations, monitor for 24 to 48 hours, standard cleanup</li></ul><p><strong>Step 3 — Escalate</strong></p><p>Report to the incident commander, to legal and compliance if data may have leaked, and to executive management for business continuity decisions. An example flow for a critical case: the analyst confirms ransomware, the team rates it critical, the commander is contacted within 15 minutes, and within one hour the CEO and legal team are briefed to decide on communication and on how to treat the ransom demand.</p><p><strong>Step 4 — Contain</strong></p><p>Short term, in the first minutes:</p><ol><li>Physically isolate infected systems.</li><li>Block command and control addresses on the firewall and disable risky protocols such as RDP and SMB if lateral movement is seen.</li><li>Preserve evidence. Capture memory with a tool such as WinPMem or FTK Imager, and record the ransom note, system logs and encryption time stamps.</li></ol><p>Longer term, to stabilize the network:</p><ol><li>Move critical systems into an isolated VLAN with strict access rules.</li><li>Review event logs to find abused accounts, then revoke access and reset credentials.</li><li>Disable unnecessary shared folders and restrict running executable files.</li></ol><p><strong>Step 5 — Eradicate and recover</strong></p><ol><li>Find persistence. Check startup settings, scheduled tasks and registry run keys.</li><li>Clean the systems with an EDR tool, and rebuild from a clean backup when needed.</li><li>Restore by business priority. Critical systems such as databases and email first, then department file shares, then ordinary workstations.</li><li>Validate. Verify checksums of restored files and monitor for a return of the malware.</li><li>Harden. Patch RDP and SMB weaknesses, block macros in Office documents through group policy, turn on MFA for admin access and apply least privilege.</li></ol><p><strong>Step 6 — Learn from it</strong></p><p>Build a full timeline from first entry to full recovery, find gaps in detection and response, update the plan and playbooks, and write an executive report covering the length and impact of the outage, the cost, the main causes and the recommended fixes. Meet reporting duties to regulators and cyber security authorities where required. Then train staff and run tabletop exercises regularly.</p><blockquote><strong>What I learned</strong></blockquote><blockquote>Speed matters most in the first minutes. Knowing exactly who decides what, before the attack, is what keeps the team calm.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e9e4b90d1a62" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Writing an Incident Response Plan Step by Step]]></title>
            <link>https://medium.com/@revazuranti/writing-an-incident-response-plan-step-by-step-f481b448184f?source=rss-48f479942854------2</link>
            <guid isPermaLink="false">https://medium.com/p/f481b448184f</guid>
            <dc:creator><![CDATA[Reva Zuranti]]></dc:creator>
            <pubDate>Thu, 19 Nov 2026 02:15:28 GMT</pubDate>
            <atom:updated>2026-11-19T02:15:28.270Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>A practical guide to the plan that tells your team who does what when something goes wrong.</blockquote><p>When an incident happens, there is no time to invent a process. An Incident Response Plan, or IR Plan, turns chaos into a calm and repeatable routine. My team wrote one for an organization, based on the NIST lifecycle. Here is how it is built so you can write your own.</p><p><strong>Step 1 — Define purpose and scope</strong></p><p>The plan should help the organization respond quickly, coordinate across teams, communicate clearly and learn from every incident. It covers all technology assets, all people with access, and all types of incidents. It is a high level strategy. Technical steps for specific attacks live in separate playbooks.</p><p><strong>Step 2 — Define what an incident is</strong></p><p>Not everything strange is an incident. We used three levels.</p><p><strong>1. Event</strong></p><ul><li>Something observable that is part of normal operations</li><li><strong>Example:</strong> A user logs in</li></ul><p><strong>2. Adverse event</strong></p><ul><li>An event with a negative effect that is not yet confirmed as a security problem</li><li><strong>Example: </strong>Five failed logins, a CPU spike</li></ul><p><strong>3. Security incident</strong></p><ul><li>An adverse event confirmed as a real threat to confidentiality, integrity or availability</li><li><strong>Example: </strong>Ransomware encrypts files</li></ul><blockquote>Only a security incident activates the IR Plan.</blockquote><p><strong>Step 3 — Assign roles</strong></p><ol><li>Incident Manager. Leads the response and has authority over every part of it.</li><li>Tech Lead. Forms hypotheses about the cause and decides on technical fixes.</li><li>Communications Manager. Writes all internal and external messages.</li><li>Response team members. Analysts and engineers who do the technical work.</li></ol><blockquote>A tip from our review. Our plan used the terms Incident Manager and Incident Commander in different places. Pick one name and use it everywhere.</blockquote><p><strong>Step 4 — Set severity and priority</strong></p><p><strong>1. SEV1</strong></p><ul><li>Critical, major business impact</li><li><strong>Example: </strong>Payment system down, customer data leak</li></ul><p><strong>2. SEV2</strong></p><ul><li>Major but limited impact</li><li><strong>Example: </strong>Some users affected, small scale DoS</li></ul><p><strong>3. SEV 3</strong></p><ul><li>Minor, no direct impact on core operations</li><li><strong>Example: </strong>Slow application, minor UI issue</li></ul><blockquote>Priority combines impact and urgency using an ITIL style matrix.</blockquote><ol><li>High Impact</li></ol><ul><li>High Urgency: Priority 1</li><li>Medium Urgency: Priority 2</li><li>Low Urgency: Priority 3</li></ul><p>2. Medium Impact</p><ul><li>High Urgency: Priority 2</li><li>Medium Urgency: Priority 3</li><li>Low Urgency: Priority 4</li></ul><p>3. Low Impact</p><ul><li>High Urgency: Priority 3</li><li>Medium Urgency: Priority 4</li><li>Low Urgency: Priority 5</li></ul><blockquote>Priority 1 means act immediately and activate the whole response team. Priority 2 means handle within one hour.</blockquote><p><strong>Step 5 — Follow the lifecycle</strong></p><ol><li>Preparation. Build the team, set up tools such as SIEM and IDS, write playbooks and practice with tabletop exercises.</li><li>Detection and analysis. Monitor, filter out false alarms, do a first forensic look and classify the incident.</li><li>Containment, eradication and recovery. Stop the spread, remove the cause and restore systems from validated backups.</li><li>Post incident activity. Hold a blameless review, find the root cause, update documents and train again.</li></ol><p><strong>Step 6 — Plan communication</strong></p><p>Internally, use official channels only, such as a dedicated chat channel or bridge call, keep information confidential and log every important conversation. Externally, share facts, not guesses. Say what is known, what is being done and when service is expected to return. All external messages should be approved by the incident lead and the legal team first.</p><p><strong>Step 7 — Handle reporting and legal duties</strong></p><p>Every incident gets a ticket with a unique number, detection time, severity, a timeline and the person in charge. SEV1 and SEV2 incidents also get a Post Incident Review covering the summary, timeline, impact, root cause, corrective actions and lessons learned. Involve the legal team early, especially when personal data is involved. GDPR, for example, requires reporting certain breaches to the authority within 72 hours. Check the rules that apply in your own country and sector. Keep evidence in access controlled and hard to modify storage.</p><p><strong>Step 8 — Measure how well you do</strong></p><ol><li>MTTD, mean time to detect = How good your monitoring is</li><li>MTTR, mean time to respond = How fast you respond and recover</li><li>Repeat incidents = Whether permanent fixes really work</li><li>Share of SEV1 and SEV2 incidents reviewed = Whether the team learns consistently</li><li>SLA compliance = How disciplined the response is</li><li>Self reported incidents = How aware your users are</li></ol><p><strong>Step 9 — Keep contact lists and a report form ready</strong></p><p>Attach a contact list for every role and a simple incident report form with the reporter, the time, a short description, the affected systems, how it was found and what the reporter already did. Make it easy to report, because early reports save time.</p><p><strong>What I learned</strong></p><p>A plan is only useful if people can find it, understand it and practice it. Treat it as a living document and update it after every incident.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f481b448184f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Spot ARP Spoofing in a Wireshark Capture]]></title>
            <link>https://medium.com/@revazuranti/how-to-spot-arp-spoofing-in-a-wireshark-capture-84c91cea3b86?source=rss-48f479942854------2</link>
            <guid isPermaLink="false">https://medium.com/p/84c91cea3b86</guid>
            <category><![CDATA[networking]]></category>
            <category><![CDATA[wireshark]]></category>
            <category><![CDATA[arp-spoofing]]></category>
            <category><![CDATA[network-forensics]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Reva Zuranti]]></dc:creator>
            <pubDate>Thu, 19 Nov 2026 01:55:53 GMT</pubDate>
            <atom:updated>2026-11-19T01:55:53.784Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/822/1*l3grWgMb0ga9-WX-bPvD9w.png" /></figure><blockquote>Two devices claiming the same IP address is a classic warning sign. Here is how I found it in a practice capture.</blockquote><p>ARP spoofing is an old trick that still shows up in labs and real networks. In this article I walk through how ARP works and how I found the signs of an attack in a practice capture file from class.</p><p><strong>Step 1 — Remember how ARP works</strong></p><p>On a local network, devices talk using MAC addresses, but applications use IP addresses. ARP connects the two. A device that wants to reach 192.168.1.1 broadcasts a question, who has 192.168.1.1, and the owner answers with its MAC address.</p><p><strong>Message</strong></p><p>ARP REQUEST = Broadcast to everyone, asking who owns an IP address</p><p>ARP REPLY = A direct answers saying this IP address is at this MAC address</p><p>The weakness is that ARP has no authentication. Devices accept replies even when they never asked, so an attacker can send false ones.</p><p><strong>Step 2 — Filter the ARP Traffic</strong></p><p>Open the capture in Wireshark and start with these display filters.</p><pre>arp<br>arp.opcode == 2<br>arp.duplicate-address-detected</pre><p>The first shows all ARP packets. The second shows replies only. The third shows packets that Wireshark flags because two MAC addresses claim one IP address. Check the exact filter name in your Wireshark version.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/757/1*05QsRY37kcrOLSawu507Bw.png" /><figcaption>ARP packets in the capture with the suspicious frames highlighted</figcaption></figure><p><strong>Step 3 — Look for conflicting claims</strong></p><p>In my capture, the address 192.168.1.1 was claimed by two different MAC addresses.</p><p>08:00:27:5e:01:7c = 192.168.1.1— Appears to be the real gateway</p><p>08:00:27:2d:f8:5a = 192.168.1.1— Suspected attacker</p><p>Wireshark added a warning to the suspicious reply saying a duplicate IP address was detected and that the address was also in use by the other MAC address in an earlier frame.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/763/1*pURxzpuZoKDn46kaiSaSnQ.png" /><figcaption>the ARP details with the duplicate IP warning</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/692/1*JOxJgADZSMXLPAd5aIZIlw.png" /><figcaption><strong>the list of replies where 192.168.1.1 points to the attacker MAC</strong></figcaption></figure><p><strong>Step 4 — Identify who is who</strong></p><p>From the replies I read the scene like this. The attacker MAC 08:00:27:2d:f8:5a sent replies to the victim at 192.168.1.104, telling it that the gateway 192.168.1.1 lives at the attacker’s MAC. The attacker’s own address appears to be 192.168.1.105. Once the victim believes this, its traffic to the gateway goes to the attacker first.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/759/1*EcRqOPSMz3jnZK-urdLKPQ.png" /><figcaption>the ARP reply to 192.168.1.104 with sender and target fields</figcaption></figure><p>I also saw an ICMP destination unreachable message between the two hosts around the same time. I treat it as supporting context only, because it alone does not prove spoofing.</p><p><strong>Step 5 — How to defend against it</strong></p><ol><li>Use static ARP entries for critical devices such as the gateway.</li><li>Turn on Dynamic ARP Inspection and port security on managed switches.</li><li>Segment the network with VLANs to limit who can reach whom.</li><li>Use encrypted protocols such as HTTPS and SSH, so intercepted data is not readable.</li><li>Monitor for duplicate IP warnings with an IDS or a tool that watches ARP.</li></ol><p><strong>What i learned</strong></p><p>The strongest evidence was not one packet. It was the pattern of two MAC addresses fighting over one IP address. Always compare more than one packet before you call something an attack.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=84c91cea3b86" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding CVE 2023 45866, the Bluetooth Keyboard Injection Flaw]]></title>
            <link>https://medium.com/@revazuranti/understanding-cve-2023-45866-the-bluetooth-keyboard-injection-flaw-ddf5175f8430?source=rss-48f479942854------2</link>
            <guid isPermaLink="false">https://medium.com/p/ddf5175f8430</guid>
            <category><![CDATA[cve]]></category>
            <category><![CDATA[mobile-security]]></category>
            <category><![CDATA[bluetooth]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[vulnerability]]></category>
            <dc:creator><![CDATA[Reva Zuranti]]></dc:creator>
            <pubDate>Thu, 19 Nov 2026 01:55:26 GMT</pubDate>
            <atom:updated>2026-11-19T01:55:26.290Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/834/1*Wu1TLKLkEdln7kT8RFNQyw.png" /></figure><blockquote><em>How a device that pretends to be a keyboard can type on your phone or laptop, and what you can do about it.</em></blockquote><p>Bluetooth connects our phones, headsets, keyboards and TVs. In late 2023 researchers disclosed CVE 2023 45866, a flaw that lets a nearby attacker pose as a Bluetooth keyboard and send keystrokes to the target without the owner approving anything. In this article I explain the issue, who is affected and how to protect yourself. I studied the published proof of concept for my coursework and I am deliberately leaving exploit commands out here.</p><p><strong>Step 1 — Understand the problem</strong></p><p>The weakness is classified as improper authentication. A Human Interface Device such as a keyboard is normally trusted once it is paired. In the affected implementations, a fake input device could connect and be accepted without the normal pairing confirmation. Keystrokes are powerful. They can open apps, install software, send messages or run commands, all as if you were typing yourself.</p><p><strong>Step 2 — Know the attack flow</strong></p><ol><li>Discovery. The attacker scans for Bluetooth devices nearby.</li><li>Spoofing. The attacker presents itself as a trusted input device.</li><li>Injection. The attacker sends keystrokes that the target treats as real typing.</li></ol><p>The attacker must be within Bluetooth range, which limits the risk but does not remove it in crowded places.</p><p><strong>Step 3 — Check whether you are affected</strong></p><p>My report lists Android, Linux using BlueZ, macOS and iOS with certain keyboards, and Android or Linux based smart TVs as affected systems. Patches depend on the vendor, and some older Android versions did not get an official fix. Always confirm exact versions on the official entry at <a href="https://nvd.nist.gov/vuln/detail/CVE-2023-45866">https://nvd.nist.gov/vuln/detail/CVE-2023-45866</a> and in your vendor’s security bulletin.</p><p><strong>Step 4 — Protect yourself</strong></p><ol><li>Install the latest security updates for your phone, computer and smart TV.</li><li>Turn Bluetooth off when you do not need it.</li><li>Review the list of paired devices and remove anything you do not recognize.</li><li>Install apps only from official stores.</li><li>Avoid using Bluetooth in crowded public places when you can.</li><li>If your phone no longer receives updates, consider replacing it.</li></ol><p><strong>What I learned</strong></p><p>Security is not only about passwords and firewalls. Even small convenience features can open a door. Patching quickly and turning off what you do not use are simple habits that remove a lot of risk.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ddf5175f8430" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Detecting Pings with Snort, Then Tuning the Rule]]></title>
            <link>https://medium.com/@revazuranti/detecting-pings-with-snort-then-tuning-the-rule-9c96bb0c2968?source=rss-48f479942854------2</link>
            <guid isPermaLink="false">https://medium.com/p/9c96bb0c2968</guid>
            <category><![CDATA[snort-ids]]></category>
            <category><![CDATA[snort]]></category>
            <category><![CDATA[network-security]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[blue-team]]></category>
            <dc:creator><![CDATA[Reva Zuranti]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 02:04:15 GMT</pubDate>
            <atom:updated>2026-11-18T02:04:15.080Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/835/1*4KQroegGJ75M6JLfeAATGA.png" /></figure><blockquote><em>Write your first intrusion detection rule, watch it fire, and learn why a rule that works is not always a rule that is good.</em></blockquote><p>Snort is an intrusion detection system. It watches network traffic and raises an alert when a packet matches a rule. I started with a very broad rule and improved it, which is how real tuning feels.</p><p><strong>Environment</strong></p><p>Ubuntu 24.04.2 and Snort 2.9.20.</p><p><strong>Step 1 — Install Snort</strong></p><pre>sudo apt update &amp;&amp; sudo apt install snort -y</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/767/1*DqUmHbSBEQ4tNUGGltCkmw.png" /><figcaption>the install command</figcaption></figure><p>The installer asks for your local network range. I entered 192.168.157.0/24</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/744/1*OkMe0PVUd0YieXf2vUnRWA.png" /><figcaption>the HOME_NET prompt</figcaption></figure><p>Confirm the version.</p><pre>snort -V</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/745/1*EMWbOmfE3TrtacSI7HaNNg.png" /><figcaption>Snort version 2.9.20</figcaption></figure><p><strong>Step 2 — Check the configuration</strong></p><pre>sudo nano /etc/snort/snort.conf</pre><p>Make sure HOME_NET is your local network and EXTERNAL_NET is set to any, so traffic from every source is checked.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/678/1*c4iNe5kDwOpS_AYTgU2YVw.png" /><figcaption>HOME_NET and EXTERNAL_NET in snort.conf</figcaption></figure><p><strong>Step 3 — Write a first rule</strong></p><pre>sudo nano /etc/snort/rules/local.rules</pre><pre>alert icmp any any -&gt; $HOME_NET any (msg:&quot;ICMP Ping Detected&quot;; sid:1000001; rev:1;)</pre><p>Read it from left to right. Alert on ICMP from any address and port, going to anything inside HOME_NET, with a message and a unique rule ID. IDs from 1000000 up are meant for local rules.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/627/1*qzMvmveTSwkPuRhhg5gqkg.png" /><figcaption><strong>opening local.rules</strong></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*Mp1-0qWUC65lrtJste5V5w.png" /><figcaption><strong>the rule inside the file</strong></figcaption></figure><p><strong>Step 4 — Run Snort and generate a ping</strong></p><p>Start Snort in alert mode. Replace ens33 with your own interface name.</p><pre>sudo snort -A console -q -c /etc/snort/snort.conf -i ens33</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/658/1*ptCWHLL6gL_nSsFznu4Ocw.png" /><figcaption>Snort running</figcaption></figure><p>From the host computer, ping the Ubuntu VM. In my lab the host was 192.168.157.1 and the VM was 192.168.157.133.</p><pre>ping 192.168.157.133</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/739/1*Ij33EV1wmJgQNfxrGJA1KA.png" /><figcaption>the VM’s IP address</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/746/1*igr1axv8FAH_ZZeMmK56Sw.png" /><figcaption>ping from the host</figcaption></figure><p><strong>Step 5 — Read the alerts</strong></p><p>Snort raised alerts for the request and for the reply. Ping itself was healthy, with 0 percent loss and an average of about 3 ms.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/758/1*MHAIwCKOmWOpSR966H7iNw.png" /><figcaption><strong>Snort alerts for ICMP in both directions</strong></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/656/1*T8vO8s9S7Je9XIRLGQP8SQ.png" /><figcaption><strong>the ping result</strong></figcaption></figure><p>The double alerts surprised me at first. The reason is that my host address sits inside HOME_NET too, so the reply travelling back to it matched the rule as well. Snort was working correctly. The rule was simply too broad.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/733/1*-KCFfbi9eZM_HoS3L23pRg.png" /><figcaption>the rule file</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/761/1*vda7LrdrhVm5lWf9wK602w.png" /><figcaption>alert output</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/602/1*GU6_lnbgnKYfew18g4t3WQ.png" /><figcaption>connectivity stays stable</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/734/1*-3dhizm2_K9uPTlVJtk9bA.png" /><figcaption>nromal ping results</figcaption></figure><p><strong>Step 6 — Tune the rule</strong></p><p>I narrowed the rule to echo requests only, which are ICMP type 8.</p><pre>alert icmp any any -&gt; $HOME_NET any (msg:&quot;ICMP Echo Request Detected&quot;; itype:8; sid:1000002; rev:1;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/729/1*cW3dGRAYq6vFKkBgdlQfhg.png" /><figcaption>the modified rule</figcaption></figure><p>After restarting Snort, only the requests triggered alerts, and the replies from 192.168.157.133 to 192.168.157.1 were ignored. Latency stayed stable at about 2 ms on average.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/681/1*Wt1AEbD3RwcGG_37Qq7ktQ.png" /><figcaption>the alerts after tuning</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/634/1*ZQv3_reD0Xoy1iowr5-NWA.png" /><figcaption>ping after tuning</figcaption></figure><p><strong>What I Learned</strong></p><p>A rule can work and still be noisy. In my report I first called the extra reply alerts false positives. Stricly, they were true matches of a rule that was too broad. Either way the fix is the same: describe exactly what you care about. Also remember that here Snort only alerts. Blocking traffic needs IPS mode and careful tuning.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9c96bb0c2968" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bulding a pfSense Firewall with a DMZ and Testing It with Kali Linux]]></title>
            <link>https://medium.com/@revazuranti/bulding-a-pfsense-firewall-with-a-dmz-and-testing-it-with-kali-linux-5275aafc8735?source=rss-48f479942854------2</link>
            <guid isPermaLink="false">https://medium.com/p/5275aafc8735</guid>
            <category><![CDATA[dmz]]></category>
            <category><![CDATA[firewall]]></category>
            <category><![CDATA[pfsense]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[network-security]]></category>
            <dc:creator><![CDATA[Reva Zuranti]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 01:48:32 GMT</pubDate>
            <atom:updated>2026-11-18T01:48:32.816Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QlY8BmBRYPcCuw_onucjcg.png" /></figure><blockquote><em>Set up three network zones, publish a web server safely, and attack your own lab to see whether the rules really work.</em></blockquote><p>A firewall decides which traffic may pass. A DMZ is a separate zone for public facing servers, so if one of them is hacked the attacker is still outside your internal network. In this lab I built both with pfSense and tested them with Kali Linux.</p><p><strong>Step 1 — Create the pfSense virtual machine</strong></p><p>Install pfSense in a VM and give it three network adapters.</p><p><strong>Network Adapter Configuration</strong></p><p><strong>1. Adapter 1 — NAT</strong></p><ul><li><strong>Zone:</strong> WAN (the internet side).</li><li><strong>Address in my lab:</strong> 192.168.157.132.</li></ul><p><strong>2. Adapter 2 — LAN Segment</strong></p><ul><li><strong>Zone:</strong> LAN (internal devices).</li><li><strong>Address in my lab:</strong> 192.168.1.1.</li></ul><p><strong>3. Adapter 3 — Segment Named DMZ</strong></p><ul><li><strong>Zone:</strong> DMZ (public servers).</li><li><strong>Address in my lab:</strong> 192.168.40.1.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/724/1*oIB9Iu-C828uGIzJ5yBdCg.png" /><figcaption>VM network adapter settings</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/661/1*ZR_lKQY3kI-q77daNeWSAQ.png" /><figcaption>the pfSense console showing WAN, LAN, and DMZ</figcaption></figure><p><strong>Step 2 — Configure the DMZ interface</strong></p><p>Open the web interface at 192.168.1.1. Under Interfaces, assign the third adapter as DMZ and enable it. Choose Static IPv4 and set 192.168.40.1/24.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/713/1*iA5E77sFP8Oa6axjvuDuFQ.png" /><figcaption>interface assignments</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/767/1*1HWlK8aHrtZjfub1_IkrRQ.png" /><figcaption>enabling the DMZ interface</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/721/1*dc55m6SVKG6ffYQd6fL3gg.png" /><figcaption>the static IPv4 address</figcaption></figure><p>Then open Services, DHCP Server, DMZ, enable it and set a pool such as 192.168.40.100 to 192.168.40.199, so machines in the DMZ get addresses automatically.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/744/1*oP-CMFRXNhsq4M84cRtk_Q.png" /><figcaption>DHCP enabled on the DMZ</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/740/1*0_0EAqacM4qHNwaJpuMyNg.png" /><figcaption>the address pool range</figcaption></figure><p><strong>Step 3 — Add a web server in the DMZ</strong></p><p>Place an Ubuntu server in the DMZ segment. It should receive 192.168.40.100 by DHCP. Then install Apache and check that it runs.</p><pre>sudo apt install apache2 -y<br>sudo systemctl status apache2</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/715/1*nmnXT6FuEXC6mEKAsx2b1Q.png" /><figcaption>the server’s IP address</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/716/1*3cymt_7yOAVO5-aYzkUyFw.png" /><figcaption>installing Apache</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/732/1*weW2vAG1gy0tfmsC23o-1A.png" /><figcaption>Apache active and running</figcaption></figure><p><strong>Step 4 — Write the firewall rules</strong></p><p>pfSense reads rules from top to bottom and the first match wins. Anything not allowed is blocked by default, which is the safest starting point.</p><h3>Firewall Rules Configuration</h3><p><strong>1. WAN Interface</strong></p><ul><li><strong>Rule:</strong> Block ICMP to the WAN address.</li><li><strong>Why:</strong> Outsiders cannot ping the firewall.</li></ul><p><strong>2. WAN Interface</strong></p><ul><li><strong>Rule:</strong> Allow TCP port 80 to 192.168.40.100.</li><li><strong>Why:</strong> The public can reach the web server.</li></ul><p><strong>3. LAN Interface</strong></p><ul><li><strong>Rule:</strong> Allow SSH only from 192.168.1.101 to 192.168.40.100.</li><li><strong>Why:</strong> Only one trusted client can administer the server.</li></ul><p><strong>4. LAN Interface</strong></p><ul><li><strong>Rule:</strong> Block SSH from any other source.</li><li><strong>Why:</strong> Everyone else is denied. This rule must sit below the allow rule.</li></ul><p><strong>5. DMZ Interface</strong></p><ul><li><strong>Rule:</strong> Allow SSH from 192.168.1.101.</li><li><strong>Why:</strong> Matches the LAN rule.</li></ul><p><strong>6. NAT Configuration</strong></p><ul><li><strong>Rule:</strong> Forward WAN port 80 to 192.168.40.100 port 80.</li><li><strong>Why:</strong> Publishes the web server.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/747/1*3Ygd2ofa4rhXL7Zd-EaKIw.png" /><figcaption>the WAN rule that blocks ping</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/710/1*Cjmk-qXrjlD5i6HQ-pNOAQ.png" /><figcaption>the WAN rule that allows HTTP</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/725/1*Rh9r9acedflEsSlBFiBLTA.png" /><figcaption>the LAN SSH rule</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/782/1*FHSyKA4G3cO220k2Xdf3Cg.png" /><figcaption>the DMZ SSH rule</figcaption></figure><p><strong>Step 5 — Attack your own lab</strong></p><p>Use Kali Linux, and only against your own lab!</p><p>ping flood</p><pre>ping -f 192.168.157.132</pre><p>My run sent 317 packets and received none, so the ICMP block worked. Then check the firewall log filtered for ICMP to see the blocked entries.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/672/1*6YpAprIVYhpbsHSlmvOvlw.png" /><figcaption>the ping flood with 100 percent loss</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/687/1*otdko-fOe4dNtSjqhyMVXw.png" /><figcaption>the firewall log showing default deny entries</figcaption></figure><p><strong>Unauthorized SSH.</strong> From a client at 192.168.1.103, try to reach 192.168.40.100. It fails because that address is not on the allowed list. From 192.168.1.101 it works.</p><pre>ssh user@192.168.40.100</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/740/1*TotEPKWfapnASFMNTbUgew.png" /><figcaption>the failed SSH attempt</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/743/1*tfP_CJ19ScMbGGfiaFwRog.png" /><figcaption>the LAN rules showing allow above block</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/728/1*Qw_r0X8uzDRxX2Radf2uYg.png" /><figcaption>the successful SSH login</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/758/1*fYu6TQzklXy8_qo6Eh0gyQ.png" /><figcaption>the allow rule hit counters</figcaption></figure><p><strong>Publishing the web server.</strong> Add a WAN rule for TCP port 80, then the port forward, then a DMZ rule that allows HTTP to the server. Finally open the pfSense WAN address in a browser on Kali.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/737/1*zVoTl2DxT0hCO78r60BPpg.png" /><figcaption>the WAN rule for port 80</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/753/1*xlQX2M2CBHlvz1c6wjKMAA.png" /><figcaption>the NAT port forward</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/746/1*6P6wmkrPLn83DAp_ehQ2Zg.png" /><figcaption>the DMZ HTTP rule</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/780/1*PmgNOpNsWc3m1zIgT7aSlg.png" /><figcaption>the Apache default page loaded from the WAN address</figcaption></figure><p>If you see the Apache page, the port forward and both rules work.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5275aafc8735" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Adding MFA to SSH and Simulating Role Based Access Control]]></title>
            <link>https://medium.com/@revazuranti/adding-mfa-to-ssh-and-simulating-role-based-access-control-240c608ca25f?source=rss-48f479942854------2</link>
            <guid isPermaLink="false">https://medium.com/p/240c608ca25f</guid>
            <category><![CDATA[networking]]></category>
            <category><![CDATA[role-based-access-control]]></category>
            <category><![CDATA[mfa]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[ssh]]></category>
            <dc:creator><![CDATA[Reva Zuranti]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 01:31:54 GMT</pubDate>
            <atom:updated>2026-11-18T01:31:54.265Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CG1jSWe4SQHjKDoLfckdDA.png" /></figure><blockquote><em>A password alone is not enough. Here is how I added one time codes to SSH and tested role based rules in pfSense.</em></blockquote><p>This lab had two parts. First I made SSH ask for a second factor. Then I simulated three user roles and checked that a firewall enforced what each role could reach.</p><p><strong>Part 1: MFA on SSH</strong></p><p><strong>Step 1 — Install the PAM module on the Ubuntu Server.</strong></p><pre>sudo apt-get install libpam-google-authenticator</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/676/1*qP0Blo_uqcGNZHZxSYXxpA.png" /><figcaption><strong>installing the package</strong></figcaption></figure><p><strong>Step 2 — Run the setup as the user you want to protect.</strong></p><p>Choose time based tokens. A QR code appears. Scan it with an authenticator app. I used Authy. The app then shows a six digit code that refreshes every 30 seconds.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/693/1*nF0PvgWNVWAemwg6Gm4bVQ.png" /><figcaption>the QR code step, with the URL and secret hidden</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/705/1*goU2PuTuP5ojCTi2wfVhJw.png" /><figcaption>the setup questions, with the secret key and scratch codes hidden</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/433/1*Kk4UcWUW3YuK4-m0zwFBKg.png" /><figcaption>the code shown in the authenticator app</figcaption></figure><p><strong>Step 3 — Install the SSH server and confirm it runs</strong></p><pre>sudo apt-get install openssh-server<br>sudo systemctl status ssh</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/606/1*EBZnOPrBbXIzRez_qjwduQ.png" /><figcaption>Installin OpenSSH</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/682/1*p6OpIcCjhuQrlUuTUSi_MA.png" /><figcaption>ssh service active and running</figcaption></figure><p><strong>Step 4 — Tell PAM to ask for the code. Open the SSH PAM file.</strong></p><pre>sudo nano /etc/pam.d/sshd</pre><p>Add this line near the bottom and save.</p><pre>auth required pam_google_authenticator.so</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/523/1*ks2gxH46bIpeKREWTIUU9g.png" /><figcaption>opening the PAM file</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/639/1*vgf7pmwphhg_upigfFldpg.png" /><figcaption>the added line highlighted</figcaption></figure><p><strong>Step 5 — Enable challenge response in the SSH config.</strong></p><pre>sudo nano /etc/ssh/sshd_config</pre><p>Change ChallengeResponseAuthentication from no to yes. On newer Ubuntu releases the option is called KbdInteractiveAuthentication, so check which name your version uses.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/630/1*y33Do5tk_AO3H5KlV72Npw.png" /><figcaption>opening sshd_config</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/629/1*GplEP6XN6y49iqDKKUEoAA.png" /><figcaption>the option set to no</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/648/1*x3pQeTljZEcJstKkCn_Lfg.png" /><figcaption>the option changed to yes</figcaption></figure><p><strong>Step 6 — Restart SSH</strong></p><pre>sudo systemctl restart ssh</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/671/1*t_ShHktBmFTUwXKwGu-Z0Q.png" /><figcaption>restarting SSH</figcaption></figure><p><strong>Step 7 — Test from another computer.</strong></p><pre>ssh vboxuser@192.168.1.11</pre><p>You are asked for the password and then a verification code. A wrong code is rejected.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/730/1*Gbib0gqyU0qfJnCp9VULyA.png" /><figcaption>a successful login then a verification code. A wrong code is rejected.</figcaption></figure><p>A safety tip. Keep your current SSH session open while you test in a second one, so a typo does not lock you out.</p><p><strong>Part 2 — Simulating RBAC with pfSense</strong></p><p>In a real company, RBAC is tied to user accounts and groups. For this lab I faked three roles by giving one network interface three IP addresses.</p><p><strong>Step 1 — Edit the Netplan file.</strong></p><pre>sudo nano /etc/netplan/01-network-manager-all.yaml</pre><pre>network:<br>  version: 2<br>  renderer: NetworkManager<br>  ethernets:<br>    ens33:<br>      addresses: [192.168.1.10/24, 192.168.1.11/24, 192.168.1.12/24]<br>      gateway4: 192.168.1.1<br>      nameservers:<br>        addresses: [1.1.1.1, 8.8.8.8, 4.4.4.4]</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*HwCE6X0k06Nv4C1LYzMsBA.png" /><figcaption>opening the Netplan file</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/703/1*zLbG32aQj3s6713uF83QXA.png" /><figcaption>the edited configuration</figcaption></figure><p><strong>Step 2 — Apply it and verify the addresses.</strong></p><pre>sudo netplan apply<br>ip a</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/595/1*eySwkguRwDZxizxhCkduZA.png" /><figcaption>netplan apply</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/733/1*uza5BPyb_rqeGtGqWzK7DA.png" /><figcaption>ip showing .10 as admin, .11 as employee, .12 as guest</figcaption></figure><p><strong>Step 3 — In the pfSense web page, open Firewall, Rules, LAN, and create one rule set per role.</strong></p><p>Role</p><ul><li>Admin (Full Access): 192.168.1.10</li><li>Employee (Only the shared folder service on port 445, everything else blocked): 192.168.1.11</li><li>Guest (Only web browsing on port 80, internal resources blocked): 192.168.1.12</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/748/1*xyiexPJAut0lCHUCBZqoxA.png" /><figcaption>the firewall menu</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/713/1*sKPqJ2xD_3LYuXCVF72eSA.png" /><figcaption>the LAN rules table</figcaption></figure><p><strong>Step 4 — Test each role by choosing its source address.</strong></p><pre>ping -I 192.168.1.10 8.8.8.8<br>curl --interface 192.168.1.10 https://google.com<br>ping -I 192.168.1.11 8.8.8.8<br>smbclient -L //192.168.1.1 -U user --source-ip=192.168.1.11<br>ping -I 192.168.1.12 8.8.8.8</pre><p>The admin address got replies and loaded the page. The employee and guest addresses showed 100 percent packet loss for ping, and the SMB connection from the employee address failed, which matched the rules.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/745/1*UP-P6SLCZDZM6DtKUYftxA.png" /><figcaption>admin ping with replies</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*pQLv1cFclYBf3zgELruPiQ.png" /><figcaption>admin curl result</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/743/1*spcd8ngXcgBfxkp_KyeT_A.png" /><figcaption>employee ping, 100 percent loss</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/754/1*4ekCXshEtrF5cg9KG3MvUQ.png" /><figcaption>smbclient result</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/748/1*9FoE5gTkS0f7WAjj-ptqaQ.png" /><figcaption>guest ping, 100 percent loss</figcaption></figure><p><strong>The honest limitation</strong></p><p>Identifying a role by IP address is only a simulation. Anyone who can change their IP can pretend to be someone else. Real RBAC ties access to authenticated identities. Still, the exercise shows the core idea: define roles first, then give each role the smallest access it needs.</p><p><strong>Case study: what the LastPass breach teaches</strong></p><p>The LastPass incident is a good reminder that strong cryptography is not enough on its own. The main lessons I took from public reporting were these. Users need MFA and strong, unique master passwords. Companies need to keep security settings up to date for all accounts. And clear, honest communication after a breach rebuilds trust faster than silence.</p><p><strong>What I learned</strong></p><p>MFA stops a stolen password from being enough. RBAC limits the damage when an account is misused. Technology only works when people understand why it is there.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=240c608ca25f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Encrypting Files and Signing Data with OpenSSL]]></title>
            <link>https://medium.com/@revazuranti/encrypting-files-and-signing-data-with-openssl-e4016d5ca392?source=rss-48f479942854------2</link>
            <guid isPermaLink="false">https://medium.com/p/e4016d5ca392</guid>
            <category><![CDATA[openssl]]></category>
            <category><![CDATA[digital-signatures]]></category>
            <category><![CDATA[beginner]]></category>
            <category><![CDATA[cryptography]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Reva Zuranti]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 07:29:34 GMT</pubDate>
            <atom:updated>2026-11-17T07:29:34.405Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MhCdOYIMLZuxIxaN3ZlhsA.png" /></figure><blockquote><em>Encryption keeps secrets. Signatures prove who wrote something and that it was not changed. Here is how to do both from the command line.</em></blockquote><p>People often mix up encryption and digital signatures. They solve different problems, and OpenSSL lets you try both in a few minutes.</p><h3>AES vs RSA</h3><p><strong>1. AES (Advanced Encryption Standard)</strong></p><ul><li><strong>Type:</strong> Symmetric, one shared key.</li><li><strong>Speed:</strong> Fast.</li><li><strong>Typical use:</strong> Encrypting large amounts of data.</li><li><strong>Typical key size:</strong> 128, 192, or 256 bits.</li></ul><p><strong>2. RSA (Rivest–Shamir–Adleman)</strong></p><ul><li><strong>Type:</strong> Asymmetric, public and private key.</li><li><strong>Speed:</strong> Slower.</li><li><strong>Typical use:</strong> Protecting keys and creating signatures.</li><li><strong>Typical key size:</strong> 2048 bits or more.</li></ul><blockquote>A common mistake is saying RSA is more secure than AES. They do different jobs, and real protocols such as TLS use both together. AES works on blocks of 128 bits, which is 16 bytes.</blockquote><p><strong>How PKI creates trust in websites</strong></p><p>PKI is the system that manages digital certificates. A Certificate Authority checks who owns a website and signs a certificate for it. Your browser already trusts a list of authorities, so when a site shows a certificate signed by one of them, the browser can confirm the site is the real one and set up an encrypted connection.</p><p><strong>Part 1 — Encrypt and decrypt a file</strong></p><p><strong>Step 1. Check your OpenSSL version.</strong></p><pre>openssl version</pre><p><strong>Step 2. Create a test message.</strong></p><pre>echo [message]. &gt; file.txt<br>type file.txt</pre><p>On Linux or macOS use cat instead of type.</p><p><strong>Step 3. Encrypt it with AES and a 256 bit key in CBC mode.</strong></p><pre>openssl enc -aes-256-cbc -pbkdf2 -in file.txt -out file.enc</pre><p>OpenSSL asks you to type a password. In my first attempt I wrote the password inside the command and got a warning about deprecated key derivation. The pbkdf2 option fixes that warning. Typing a password into a command is also a bad habit because it ends up in your shell history.</p><p><strong>Step 4.</strong> <strong>Decrypt it.</strong></p><pre>openssl enc -aes-256-cbc -pbkdf2 -d -in file.enc -out file.dec<br>type file.dec</pre><p>The original text comes back.</p><p><strong>Part 2 — Generate a key</strong></p><pre>openssl genrsa -out private.pem 2048<br>openssl rsa -in private.pem -pubout -out public.pem</pre><p>The private key stays with you. The public key can be shared with anyone.</p><p>A warning for bloggers. Never publish a screenshot of a private key you plan to keep using. Generate a throwaway key just for the screenshot.</p><p><strong>Part 3 — Sign and verify</strong></p><pre>openssl dgst -sha256 -sign private.pem -out signature.sign file.txt<br>openssl dgst -sha256 -verify public.pem -signature signature.sign file.txt</pre><p><strong>Part 4— Break it on purpose</strong></p><p>Change the file and verify again.</p><pre>echo tampered &gt; file.txt<br>openssl dgst -sha256 -verify public.pem -signature signature.sign file.txt</pre><p>Now verification fails. That is the real meaning of Verified OK. It says the file is exactly what was signed and that the signature was made by the matching private key. It does not mean the file cannot be changed. It means any change gets noticed.</p><p><strong>What i learned</strong></p><blockquote>Encryption protects confidentiality. A signature protects integrity and proves authenticity. You often need both.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e4016d5ca392" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Capturing and Reading Network Traffic with Docker and Wireshark]]></title>
            <link>https://medium.com/@revazuranti/capturing-and-reading-network-traffic-with-docker-and-wireshark-5b0948343c3d?source=rss-48f479942854------2</link>
            <guid isPermaLink="false">https://medium.com/p/5b0948343c3d</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[networking]]></category>
            <category><![CDATA[wireshark]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[beginner]]></category>
            <dc:creator><![CDATA[Reva Zuranti]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 02:56:04 GMT</pubDate>
            <atom:updated>2026-11-17T02:56:04.308Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*slMdjUW-YBy9iaE7mTbHXA.png" /></figure><blockquote>Build a tiny lab, send some packets, and finally see what ping, curl and a TCP handshake look like on the wire.</blockquote><p>Reading a packet captures feels like reading a foreign languange at first. This lab is what made it click for me. I built a small virtual network with Docker Compose, generated traffic between a client and a web server, captured it, and studied it in Wireshark. Here is the whole walkthrough so you can repeat in on your own machine.</p><p><strong>What you need?</strong></p><p>Docker with Docker Compose and Wireshark. Nothing else.</p><p><strong>Step 1 — Create the project folder and the Compose file</strong></p><p>Create a folder called <em>network_traffic_lab. </em>Inside it, add a file named <em>docker-compose.yml.</em> It defines one bridge network called <em>my_network, </em>an Nginx web server and an Ubuntu client with an interactive shell.</p><pre>version: &#39;3.8&#39;<br><br>services:<br>  web_server: <br>    image: nginx:latest<br>    container_name: web_server<br>    networks:<br>    - my_network<br><br>  client:<br>    image: ubuntu:latest<br>    container_name: client<br>    tty: true <br>    networks:<br>      - my_network<br>    command: bash <br><br>networks:<br>  my_network:<br>    driver: bridge</pre><p>Older tutorials begin the file with a version line. Docker now ignores it and prints a warning, which you will see in the next step.</p><p><strong>Step 2 — Start the containers</strong></p><p>Run the containers in the background, then check that both are up.</p><pre>docker compose up -d<br>docker ps</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/774/1*JrLRZhah0F5KNUadHG4LPQ.png" /><figcaption>output of docker compose up</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/686/1*txRMJuG4x9trC0qCNLyzUQ.png" /><figcaption>docker ps showing web_server and client running</figcaption></figure><p><strong>Step 3 — Prepare the client</strong></p><p>Open the shell inside the client container and install the tools we need to create traffic.</p><pre>docker exec -it client bash<br>apt update &amp;&amp; apt install -y curl iputils-ping nmap</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/533/1*FPBYxJuQdKU9BFOJu-0nzA.png" /><figcaption>entering the client container and running apt update</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/488/1*03K_heDywLaS1lqcSfXCZw.png" /><figcaption>installing curl</figcaption></figure><p><strong>Step 4 — Start capturing packets</strong></p><p>Open a second terminal. We borrow the client’s network with a helper container that already contains <em>tcpdump</em>. The option net container: client means the helper sees exactly what the client see.</p><pre>docker run -it --rm --net container:client -v &quot;$(pwd)&quot;:/tcpdump<br>nicolaka/netshoot tcpdump -i eth0 -w /tcpdump/client_web_server.pcap</pre><p>On Windows, replace the volume path with the full path of your own folder. Leave this terminal running.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/719/1*nfFyQBMrrd0naxjZqk7jsQ.png" /><figcaption>tcpdump listening on eth0</figcaption></figure><p><strong>Step 5 — Generate some traffic</strong></p><p>Back in the client shell, run these three commands one by one.</p><pre>nmap -sC -sV -p 80 web_server<br>ping web_server<br>curl web_server</pre><p>The nmap scan finds Nginx 1.27.4 on port 80. Ping shows replies with a TTL of 64. Curl prints the Nginx welcome page.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/565/1*pW4qWQVwalw2iiNDuYQakg.png" /><figcaption>Nmap result</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/611/1*ImwoTCXBcayN228K9aS0Dg.png" /><figcaption>ping result, 0 percent packet loss</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/543/1*dfO-gxuAYZ6Lu1LKluZ-wg.png" /><figcaption>curl printing the HTML page</figcaption></figure><p>Stop ping with Ctrl+C, then stop <em>tcpdump </em>the same way. My capture contained 379 packets and 0 were dropeed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/764/1*c5nIGcCvpc_M42MenUZhXw.png" /><figcaption><em>tcpdump summary, 379 packets captured</em></figcaption></figure><p><strong>Step 6 — Read the capture in Wireshark</strong></p><p>Open the <em>pcap </em>file and try the display filters <em>icmp, tcp.port == 80 </em>and <em>http, </em>one at a time.</p><p><strong>ICMP. </strong>The client at 172.20.0.2 sends <em>echo </em>requests to the server at 172.20.0.3 and the servers answers with <em>echo </em>replies. In my capture the very first request was marked no response found, and the later ones worked. A likely cause is that the first packet had to wait while the two containers learned each other’s MAC addresses with ARP. Check for ARP packets near the first ping in your own capture before you claim that.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/710/1*xRGuppB3iozOahxX3pMiWQ.png" /><figcaption>ICMP packets in Wireshark</figcaption></figure><p><strong>TCP. </strong>The curl request produced a full connection from start to finish. Here is how I read packets 16 to 27.</p><p><strong>Packet 16</strong></p><ul><li><strong>Flags:</strong> SYN, client to server</li><li><strong>What it means:</strong> The client asks to open a connection</li></ul><p><strong>Packet 17</strong></p><ul><li><strong>Flags:</strong> SYN ACK, server to client</li><li><strong>What it means:</strong> The server agrees</li></ul><p><strong>Packet 18</strong></p><ul><li><strong>Flags:</strong> ACK, client to server</li><li><strong>What it means:</strong> The handshake is complete</li></ul><p><strong>Packet 19</strong></p><ul><li><strong>Flags:</strong> HTTP GET /</li><li><strong>What it means:</strong> The client requests the home page</li></ul><p><strong>Packet 20</strong></p><ul><li><strong>Flags:</strong> ACK</li><li><strong>What it means:</strong> The server confirms it got the request</li></ul><p><strong>Packet 21</strong></p><ul><li><strong>Flags:</strong> PSH ACK</li><li><strong>What it means:</strong> The server sends the response data</li></ul><p><strong>Packet 22</strong></p><ul><li><strong>Flags:</strong> ACK</li><li><strong>What it means:</strong> The client confirms the data</li></ul><p><strong>Packet 23</strong></p><ul><li><strong>Flags:</strong> HTTP 200 OK, text/html</li><li><strong>What it means:</strong> Wireshark shows the reassembled response</li></ul><p><strong>Packet 24</strong></p><ul><li><strong>Flags:</strong> ACK</li><li><strong>What it means:</strong> The client confirms the response</li></ul><p><strong>Packet 25</strong></p><ul><li><strong>Flags:</strong> FIN ACK, client</li><li><strong>What it means:</strong> The client starts closing</li></ul><p><strong>Packet 26</strong></p><ul><li><strong>Flags:</strong> FIN ACK, server</li><li><strong>What it means:</strong> The server agrees to close</li></ul><p><strong>Packet 27</strong></p><ul><li><strong>Flags:</strong> ACK, client</li><li><strong>What it means:</strong> The connection is closed</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/751/1*75eJ2j3JnuAE716IxbR15Q.png" /><figcaption><strong>TCP packets 16 to 27</strong></figcaption></figure><p><strong>HTTP.</strong> Packet 19 carries GET / HTTP/1.1 from the client. Packet 23 carries HTTP/1.1 200 OK from the server, which means the page was found and delivered.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/754/1*E-eD-Y9zGHdbi-j1B9i4oQ.png" /><figcaption><strong>HTTP request and response</strong></figcaption></figure><p><strong>What I Learned</strong></p><blockquote>None of this traffic was encrypted, so anyone on the same network segment could read it with the same tools. That is a good reason to use HTTPS. Also, only scan or capture systems that you own or have permission to test.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5b0948343c3d" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>