<?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 Nuel Ojeabulu on Medium]]></title>
        <description><![CDATA[Stories by Nuel Ojeabulu on Medium]]></description>
        <link>https://medium.com/@nuel.ojeabulu?source=rss-a571f4dfe4c9------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*9RjDKKuAD0HCDGwa</url>
            <title>Stories by Nuel Ojeabulu on Medium</title>
            <link>https://medium.com/@nuel.ojeabulu?source=rss-a571f4dfe4c9------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 20:37:13 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@nuel.ojeabulu/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[Building a Secure Delivery Platform On-Prem — Part 1/3]]></title>
            <link>https://medium.com/@nuel.ojeabulu/building-a-secure-delivery-platform-on-prem-part-1-3-459734e85a9b?source=rss-a571f4dfe4c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/459734e85a9b</guid>
            <dc:creator><![CDATA[Nuel Ojeabulu]]></dc:creator>
            <pubDate>Sat, 07 Nov 2026 12:24:42 GMT</pubDate>
            <atom:updated>2026-11-07T12:24:42.197Z</atom:updated>
            <content:encoded><![CDATA[<p>Most DevSecOps tutorials start in the cloud. You click through an AWS console, spin up a managed Kubernetes cluster, and connect a pipeline that has full admin keys to production. It works, and it’s fast. It’s also not how a lot of regulated companies, especially banks and the fintechs that partner with them, actually run their systems.</p><p>This series is that write-up. It’s in three parts:</p><ul><li><strong>Part 1 (this one):</strong> the foundation. A cluster that stands in for an on-prem data centre, a pipeline that builds infrastructure from code, and guardrails that prove themselves.</li><li><strong>Part 2:</strong> the software supply chain. Hardened container images, security scanning, SBOMs, image signing, and packaging the app with Helm.</li><li><strong>Part 3:</strong> delivery and encryption. GitOps with Argo CD, admission control with Kyverno, HTTPS, mutual TLS, SSL pinning, and a timed rollback drill.</li></ul><p>It’s not a polished “here’s how it should work” guide. I’m including the errors, the wrong turns, and the moments I was completely lost, because those are where the real learning happened. If you’re new to DevOps, I hope it shows you that being confused is part of the job. If you’re experienced, I hope a few of the gotchas save you an afternoon.</p><h3>The scenario: NairaFlow and a 90-day deadline</h3><p>The project is built around a fictional company, <strong>NairaFlow</strong>: a Lagos fintech with a payments API, a merchant dashboard and a mobile wallet. It has about 1.2 million monthly users and partners with a commercial bank for settlement. Because the bank keeps sensitive workloads on its own servers, NairaFlow runs its production platform <strong>on-prem</strong>, not in a public cloud.</p><p>In one quarter, NairaFlow had four incidents:</p><ol><li><strong>A Friday deploy took payments down for 47 minutes.</strong> Someone deployed by SSH-ing into a server and running scripts. Nobody knew which version was live, and there was no fast way to roll back.</li><li><strong>Merchant KYC files sat in a publicly readable storage bucket.</strong> Someone had created it by hand in a console, with unsafe defaults.</li><li><strong>A hijacked open-source package got into a build.</strong> Nothing pinned dependencies, nothing scanned images, and nobody could say what was inside them.</li><li><strong>A penetration tester read login tokens from the mobile app</strong> on public Wi-Fi. The API still accepted plain HTTP, and the app trusted any certificate the phone trusted.</li></ol><p>The partner bank responded with five requirements and 90 days to meet them, or it would pause settlement:</p><h3>Day 1: a data centre on a laptop</h3><p>The first day has two goals: build the place where everything will run, and look honestly at the problem before reaching for solutions.</p><p>The cluster comes from a small config file: one control-plane node (the “brain” that decides what runs where) and one worker node (where apps actually run). I also mapped two ports from the laptop into the cluster now, because the HTTPS work in Part 3 needs them and kind can’t add port mappings to an existing cluster.</p><pre>kind: Cluster<br>apiVersion: kind.x-k8s.io/v1alpha4<br>name: nairaflow<br>nodes:<br>  - role: control-plane<br>    extraPortMappings:<br>      - containerPort: 30080<br>        hostPort: 8080<br>      - containerPort: 30443<br>        hostPort: 8443<br>  - role: worker</pre><pre>kind create cluster --config kind.yaml<br>kubectl get nodes</pre><p>Two minutes later, two nodes reported Ready. Under the hood, kind had started two Docker containers and turned each one into a Kubernetes node. That&#39;s the whole trick: a multi-machine cluster, faked convincingly enough to learn everything that matters.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rV0v_7sXa_PBdyomvjtTGg.png" /></figure><p>Then I did something deliberately old-fashioned: I ran the NairaFlow app with Docker Compose, by hand. Three services (a web dashboard, a payments API and a worker), plus Postgres and Redis. I sent a test transfer, watched it complete, and wrote down everything wrong with it:</p><ul><li>built and started by hand, with no record of what version is running</li><li>containers running as root</li><li>plain HTTP everywhere</li><li>database passwords sitting in a file</li></ul><p>That list is the “before” picture. Every one of those problems gets fixed later in the project, and on the final day we compare against it.</p><blockquote><strong><em>Why start by running it badly?</em></strong><em> Engineers who jump straight to tools build solutions to problems they don’t understand. Day 1 is about understanding.</em></blockquote><h3>Day 2: control, our own runner, and a threat model</h3><p>Day 2 sets the rules of the road.</p><p><strong>First, nobody pushes straight to production code.</strong> In GitLab, I protected the main branch so that nobody, including me, can push to it directly. Changes go through a merge request, and the merge button stays disabled until the pipeline passes. That single setting is the first real fix for the 47-minute outage: every change now has an author, a reviewer and a history.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CMQN6f3bJayKvqgZHQbRAg.png" /></figure><p><strong>Second, a GitLab Runner inside our own cluster.</strong> This is where I had to slow down and really understand the moving parts, so here’s the analogy that finally made it click for me:</p><ul><li><strong>GitLab</strong> is head office. It holds the code and the rulebook (the pipeline), and decides <em>what</em> work needs doing.</li><li><strong>The runner</strong> is a staff member who sits inside our building (the cluster). Head office sends instructions, and the runner does the work and reports back.</li><li><strong>The runner token</strong> is the staff ID card. It proves to GitLab that this runner belongs to our project.</li><li><strong>Helm</strong> is the moving company. A runner needs about seven Kubernetes objects to exist: a Deployment, a Secret for the token, a ConfigMap, a ServiceAccount, permissions and so on. Helm installs all of them from one command and one settings file.</li></ul><p>If you’ve used Homebrew on a Mac, Helm is the same idea for a Kubernetes cluster: helm install, helm upgrade, helm uninstall, helm list.</p><pre>helm repo add gitlab https://charts.gitlab.io &amp;&amp; helm repo update<br>helm upgrade --install gitlab-runner gitlab/gitlab-runner \<br>  -n gitlab-runner --create-namespace -f runner-values.yaml</pre><p>Why run it in our own cluster instead of using GitLab’s shared cloud runners? Because NairaFlow’s code shouldn’t be built on someone else’s machines, and later pipeline jobs need to reach an on-prem cluster that the cloud can’t see. Hold that thought; it comes back to bite me in Day 4.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iDrRei1HXm5Fx89n1YYijg.png" /></figure><p><strong>Third, a threat model.</strong> Before building any defences, I sat down with STRIDE (Spoofing, Tampering, Repudiation, Information disclosure, Denial of service, Elevation of privilege) and listed how an attacker could abuse the system as it stood. Each threat maps to a control the project will build, and each control maps back to one of the four incidents. It’s the project’s to-do list, and it’s also the best answer I know to the interview question, <em>“why did you build that?”</em></p><h3>Days 3–4: infrastructure as code, and a pipeline that builds it</h3><p>The public KYC bucket happened because someone built infrastructure by hand. Days 3 and 4 make that impossible: infrastructure is written as code, checked automatically, and only ever built by the pipeline.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q3HmcPMWu6NV4oxlTfhZmA.png" /></figure><h3>What the code describes</h3><p>The infrastructure lives in an infra/ folder inside the same repository as the app. It&#39;s built from two reusable <strong>modules</strong>, which work like recipes:</p><ul><li><strong>A namespace module.</strong> Each environment (dev, staging, prod) gets its own Kubernetes namespace (think of it as a separate room in the building) with name tags (owner, cost-centre, env), a <strong>quota</strong> so one room can&#39;t use all the CPU and memory, a <strong>limit range</strong> that gives every container sensible default sizes, and a <strong>network policy</strong> that acts as a guest list for who may connect in.</li><li><strong>A GitLab repo module.</strong> It creates private repositories with a protected main branch. The first one is nairaflow-config, which Argo CD will read from in Part 3.</li></ul><pre>module &quot;namespace&quot; {<br>  source      = &quot;../../modules/namespace&quot;<br>  name        = &quot;nairaflow-prod&quot;<br>  env         = &quot;prod&quot;<br>  owner       = &quot;platform-team&quot;<br>  cost_centre = &quot;payments&quot;<br>  quota       = { cpu = &quot;4&quot;, memory = &quot;8Gi&quot;, pods = &quot;50&quot; }<br>}</pre><p>Dev, staging and prod each use the same recipe with different sizes, so they can’t drift apart.</p><h3>State, locking and a limited key</h3><p>OpenTofu keeps a <strong>state</strong> file: its memory of what it built. I stored it in GitLab’s built-in OpenTofu state backend, which handles locking (so two runs can’t overwrite each other) and encrypts state at rest. No extra storage server needed.</p><p>Then came the part I’m proudest of: the pipeline gets its own <strong>least-privilege key</strong>. A Kubernetes ServiceAccount called tofu-apply can manage namespaces, quotas, limit ranges and network policies, and nothing else.</p><pre>kubectl auth can-i create namespaces --as=system:serviceaccount:gitlab-runner:tofu-apply   # yes<br>kubectl auth can-i create pods --as=system:serviceaccount:gitlab-runner:tofu-apply         # no</pre><p>If the pipeline were ever compromised, the attacker could create an empty namespace. They couldn’t run a single container.</p><h3>The pipeline</h3><p>The root pipeline runs the app’s tests, and starts a separate <strong>child pipeline</strong> only when something in infra/ changes:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*avF5vwvmU17l1teoO-72Gg.png" /></figure><p>The five house rules, written in Rego: repos must be private; repos must block merges when the pipeline fails; every namespace needs owner, cost-centre and env labels; production namespaces must have a quota; and no network rule may open SSH, RDP or Postgres ports to the whole internet.</p><p>The key design choice: <strong>plan on the merge request, apply only after merge, and only when a person approves.</strong> When I finally merged and clicked apply on the main pipeline, three namespaces appeared in the cluster, and a private config repo appeared in GitLab. I hadn&#39;t run a single kubectl create or clicked a single &quot;New project&quot; button.</p><pre>kubectl get ns --show-labels | grep nairaflow<br># nairaflow-dev      Active   cost-centre=payments,env=dev,owner=platform-team<br># nairaflow-prod     Active   cost-centre=payments,env=prod,owner=platform-team<br># nairaflow-staging  Active   cost-centre=payments,env=staging,owner=platform-team</pre><h3>Day 5: proving the guardrails</h3><p>A control you haven’t tested is just a hope. Day 5 is about trying to break the guardrails on purpose, and collecting evidence that they hold.</p><p><strong>Test 1: the careless engineer.</strong> I opened a merge request that overrode the config repo’s safe default:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*70WQowCtmWuP6d_tS65Xog.png" /></figure><pre>module &quot;config_repo&quot; {<br>  # ...<br>  visibility_level = &quot;public&quot;<br>}<br></pre><h3>What broke, and what it taught me</h3><p>The week was not smooth, and I think that’s the most useful part of this write-up. Here’s every real problem I hit, in order:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hh4D5EAdLi-0bZQVDWDAtA.png" /></figure><p><strong>In Part 2</strong>, the focus moves from <em>how the platform is built</em> to <em>what runs on it</em>. I’ll harden the container images (multi-stage, non-root, pinned), add secret and vulnerability scanning that fails the pipeline, generate SBOMs, sign every image with Cosign, and package the whole app as a Helm chart.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=459734e85a9b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Part 2: Automating Microsoft Entra ID User Provisioning (Python, Graph API, and Azure Identity).]]></title>
            <link>https://medium.com/@nuel.ojeabulu/part-2-automating-microsoft-entra-id-user-provisioning-python-graph-api-and-azure-identity-c067e23c25ef?source=rss-a571f4dfe4c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/c067e23c25ef</guid>
            <category><![CDATA[azure]]></category>
            <category><![CDATA[azure-identitymanagement]]></category>
            <category><![CDATA[entra-id]]></category>
            <category><![CDATA[rbac-access-control]]></category>
            <dc:creator><![CDATA[Nuel Ojeabulu]]></dc:creator>
            <pubDate>Fri, 07 Aug 2026 12:01:03 GMT</pubDate>
            <atom:updated>2026-08-07T12:05:42.989Z</atom:updated>
            <content:encoded><![CDATA[<p>In Part 1 of this series, I made the case for why manual user onboarding processes are obsolete. Now, it is time to architect the solution.</p><p>This article serves as the engineering core of the series: how to transform a raw CSV file from HR into properly configured Entra ID accounts, with no human intervention required other than reviewing the logs. I will walk through the architecture exactly as I would while pair-programming with another engineer — explaining what each component does, why it is designed this way, and where the common traps lie.</p><blockquote><strong><em>Note on the code:</em></strong><em> The snippets provided are illustrative reconstructions. They utilize the exact stack documented in the project — Pydantic for schema validation, </em><em>ClientSecretCredential from the Azure Identity SDK, and the Microsoft Graph SDK’s </em><em>User and </em><em>PasswordProfile models. They are cleaned-up for readability but accurately represent the production logic.</em></blockquote><h3>Identity First: Authenticating the Automation</h3><p>Before the automation can create a single user, it must answer the foundational question of any Zero Trust architecture: <em>Who are you, and what are you authorized to do?</em></p><p>The wrong answer is running the script under a human administrator’s credentials. This inevitably leads to passwords stored in plaintext config files, execution with dangerously broad permissions, and audit logs that cannot distinguish between the automated script and the human admin.</p><p>The right answer is utilizing a dedicated application service principal. This is an identity registered in Entra ID that belongs exclusively to the automation, granted only the specific Microsoft Graph permissions required for user provisioning.</p><p>The Azure Identity SDK makes authenticating as this principal highly efficient:</p><pre>from azure.identity import ClientSecretCredential<br>from msgraph import GraphServiceClient<br>import config</pre><pre>credential = ClientSecretCredential(<br>    tenant_id=config.TENANT_ID,<br>    client_id=config.CLIENT_ID,<br>    client_secret=config.CLIENT_SECRET,<br>)</pre><pre>graph_client = GraphServiceClient(<br>    credentials=credential,<br>    scopes=[&quot;https://graph.microsoft.com/.default&quot;],<br>)</pre><p>The ClientSecretCredential handles token acquisition, caching, and renewal against the Microsoft identity platform. The .default scope instructs Graph to issue a token containing exactly the application permissions consented to in the tenant—nothing more.</p><blockquote><strong><em>Security Insight:</em></strong><em> A service principal provides three critical advantages a human account cannot: </em><strong><em>least privilege by design</em></strong><em> (it holds specific </em><em>User.ReadWrite.All permissions, not tenant-wide admin rights), a </em><strong><em>clean audit trail</em></strong><em> (every log entry identifies the application), and </em><strong><em>revocability</em></strong><em> (you can rotate the secret without impacting any human access).</em></blockquote><blockquote><strong><em>Common Trap:</em></strong><em> Never hardcode the client secret in your script. Secrets belong in configuration files excluded from version control (like </em><em>.env) or, ideally, a secure vault service. The separation of </em><em>config.py from the main automation logic is intentional and necessary.</em></blockquote><h3>The Unsung Hero: Validating HR Data with Pydantic</h3><p>Here is an architectural truth rarely captured in diagrams: the reliability of your onboarding automation is exactly equal to the quality of your HR data.</p><p>HR spreadsheets are notorious for containing empty surname cells, trailing spaces in usernames, duplicated principal names, and inconsistent department spellings. If your script blindly trusts this data, the Graph API will reject malformed records with cryptic errors — or worse, accept them, resulting in the automated creation of broken accounts.</p><p>To prevent this, our pipeline validates every single row against a Pydantic schema <em>before</em> making any API calls:</p><p>Python</p><pre>from pydantic import BaseModel, Field, ValidationError<br>from typing import Optional</pre><pre>class UserRecord(BaseModel):<br>    display_name: str = Field(min_length=1)<br>    given_name: str = Field(min_length=1)<br>    surname: str = Field(min_length=1)<br>    user_principal_name: str = Field(pattern=r&quot;^[^@\s]+@[^@\s]+$&quot;)<br>    department: Optional[str] = None<br>    job_title: Optional[str] = None<br>    manager: Optional[str] = None</pre><p>Required fields must be present and structurally sound. Optional attributes are handled safely when absent, preventing the pipeline from crashing.</p><p>The subsequent design decision is equally critical: rows that fail validation are skipped and logged individually, rather than halting the entire batch.</p><p>Python</p><pre>valid_users = []<br>rejected = []</pre><pre>for row_number, row in enumerate(csv_rows, start=1):<br>    try:<br>        valid_users.append(UserRecord(**row))<br>    except ValidationError as exc:<br>        rejected.append((row_number, exc))<br>        logging.warning(&quot;Row %d rejected: %s&quot;, row_number, exc)</pre><p>Consider the alternative: a large batch process dies halfway through because of one bad row. Half your users exist, half do not, and the IT team is left untangling the mess. By validating and isolating failures per-record, a single typo in HR’s spreadsheet cannot block the entire batch, and the generated logs tell HR exactly which rows require fixing.</p><h3>Generating Secure Initial Credentials</h3><p>Every new account requires an initial credential. This is where manual processes often fall back on embarrassing defaults like Welcome2026! shared insecurely over email.</p><p>Our automation generates a cryptographically random, temporary password for each account using Python’s secrets module (avoiding the predictable random module), ensuring it meets Entra ID’s strict complexity requirements:</p><pre>import secrets<br>import string</pre><pre>def generate_temp_password(length: int = 16) -&gt; str:<br>    alphabet = string.ascii_letters + string.digits + &quot;!@#$%^&amp;*&quot;<br>    while True:<br>        pwd = &quot;&quot;.join(secrets.choice(alphabet) for _ in range(length))<br>        if (any(c.islower() for c in pwd) and <br>            any(c.isupper() for c in pwd) and <br>            any(c.isdigit() for c in pwd)):<br>            return pwd</pre><p>Just as important is the lifecycle of this password: the profile forces a change at first sign-in. This temporary credential exists solely to bootstrap the user into choosing their own secure password, after which the automated value is permanently invalidated.</p><h3>Executing the Provisioning</h3><p>With identity, data validation, and secure credentials established, the actual user creation becomes straightforward:</p><p>Python</p><pre>from msgraph.generated.models.user import User<br>from msgraph.generated.models.password_profile import PasswordProfile</pre><pre>async def create_user(graph_client, record: UserRecord) -&gt; None:<br>    user = User(<br>        account_enabled=True,<br>        display_name=record.display_name,<br>        given_name=record.given_name,<br>        surname=record.surname,<br>        user_principal_name=record.user_principal_name,<br>        mail_nickname=record.user_principal_name.split(&quot;@&quot;)[0],<br>        department=record.department,<br>        job_title=record.job_title,<br>        password_profile=PasswordProfile(<br>            password=generate_temp_password(),<br>            force_change_password_next_sign_in=True,<br>        ),<br>    )<br>    <br>    await graph_client.users.post(user)</pre><p>Notice the inclusion of the department attribute. That single line does quiet, heavy lifting. As we will explore in Part 3, group membership in this tenant is dynamic and keyed on the department. The moment this user is created, they automatically land in the correct security group with the right access—zero clicks required.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cmm22c0Qkx5ZCthbymGQJQ.png" /></figure><h3>Enterprise-Grade Logging and Audit Trails</h3><p>When the script finishes, there is no ambiguity about the outcome. The execution log captures every step: successful token acquisition, HTTP POST requests to the Graph API, and a definitive status line for every account processed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/1*KExq-e0K4CZdDMp-O47oIQ.png" /></figure><p>Python</p><pre>import logging</pre><pre>logging.basicConfig(<br>    level=logging.INFO,<br>    format=&quot;[%(asctime)s] %(levelname)s: %(message)s&quot;,<br>    handlers=[<br>        logging.FileHandler(&quot;execution_log.txt&quot;, encoding=&quot;utf-8&quot;),<br>        logging.StreamHandler(),<br>    ],<br>)</pre><p>This logging strategy serves three audiences simultaneously:</p><ul><li><strong>The Engineer:</strong> Live console output for debugging and monitoring.</li><li><strong>IT Operations:</strong> A definitive record verifying that a batch completed successfully.</li><li><strong>Security &amp; Auditors:</strong> A precise trace of which application identity created which account and when (a non-negotiable requirement in regulated industries).</li></ul><blockquote><strong><em>Best Practice:</em></strong><em> Wrap every Graph API call in exception handling that captures the failing record and allows the loop to continue. Transient API errors are inevitable; a production pipeline treats them as data points, not disasters.</em></blockquote><h3>Conclusion: From Accounts to Governance</h3><p>Step back and look at what we have built: a highly repeatable pipeline. Validated records go in; fully configured accounts come out — each equipped with a strong temporary credential, accurate attributes, and a comprehensive audit trail. The manual chaos described in Part 1 has been engineered out of existence.</p><p>But an account is just the foundation of a digital identity. The moment a user exists, harder questions emerge: <em>What applications can they access? From which devices? Under what conditions?</em></p><p>Automation builds the user. Governance decides what the user can do.</p><p><strong>Next up — Part 3: Building Enterprise Identity Governance: RBAC, Dynamic Groups, Administrative Units, and Conditional Access.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c067e23c25ef" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Part 1: From Manual Chaos to Identity Automation: Architecting a Secure Onboarding System with…]]></title>
            <link>https://medium.com/@nuel.ojeabulu/part-1-from-manual-chaos-to-identity-automation-architecting-a-secure-onboarding-system-with-766a82de2855?source=rss-a571f4dfe4c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/766a82de2855</guid>
            <dc:creator><![CDATA[Nuel Ojeabulu]]></dc:creator>
            <pubDate>Tue, 04 Aug 2026 07:12:01 GMT</pubDate>
            <atom:updated>2026-08-04T07:12:01.285Z</atom:updated>
            <content:encoded><![CDATA[<h3>Part 1: From Manual Chaos to Identity Automation: Architecting a Secure Onboarding System with Microsoft Entra ID</h3><p>There is a phrase buried in the executive summary of my project report that captures the core objective of this entire engagement: <strong>reducing the standing-privilege attack surface</strong>.</p><p>This does not just mean blocking attacks or detecting threats. It means actively reducing the sheer volume of always-on access that exists within a tenant, regardless of whether that access is actively in use. This surface area is rarely created by malicious actors; it is built, one well-intentioned decision at a time, through manual, inconsistent, and rushed onboarding processes that rely on cloning whatever configuration worked last time.</p><p>This series documents the replacement of that flawed operational model. For a financial services organization operating on Microsoft Entra ID, I delivered a paired solution: a Python-based provisioning automation engine built on the Microsoft Graph API and Azure Identity SDK, heavily reinforced by a comprehensive Identity and Access Management (IAM) framework. This framework wraps every newly created account in Role-Based Access Control (RBAC), Conditional Access, Privileged Identity Management (PIM) with Just-in-Time (JIT) access, periodic access reviews, and strict license governance.</p><p>This series tells the complete story of that build: the architecture, the Python implementation, the governance controls, the missteps, and the resulting lessons.</p><blockquote><strong><em>Key Takeaway:</em></strong><em> Manual onboarding is not merely an operational bottleneck; it is a critical security vulnerability. Every inconsistently configured account introduces a fracture in your identity perimeter — and identity is the modern security perimeter.</em></blockquote><h3>The Security Risks of Manual Onboarding</h3><ul><li><strong>Compounding Inconsistency:</strong> When multiple administrators manually provision accounts over several years, the result is fragmented naming conventions, subjective interpretations of “standard access,” and a directory structure that defies logical auditing. You cannot secure what you cannot predict.</li><li><strong>Invisible Privilege Sprawl:</strong> The fastest way to manually onboard an employee is to clone an existing user. Consequently, permissions are inherited blindly across generations of accounts. In a highly regulated environment like financial services, an entry-level employee inadvertently retaining access to a payments database is not an IT quirk — it is a regulatory breach.</li><li><strong>Accumulation of Standing Privilege:</strong> Manual workflows often default to granting permanent administrative roles to avoid the operational friction of revisiting them later. Permanent Global Administrators are highly lucrative targets for threat actors. Every standing privileged account represents a continuous, 24/7 attack surface.</li><li><strong>Lack of Traceability:</strong> When auditors require the “who, what, when, and why” of account creation and approval, manual processes fail to provide an evidence-based answer.</li></ul><p>The industry standard for addressing these vulnerabilities is Zero Trust: verify explicitly, enforce least privilege, and assume breach. However, Zero Trust is an architecture you build, not a product you buy — and that architecture begins with identity.</p><h3>The Project: Scope and Deliverables</h3><p>This engagement required two distinct but highly interdependent phases:</p><ol><li><strong>Automation Engine:</strong> A Python application leveraging the Microsoft Graph API and Azure Identity SDK. It ingests HR data via CSV, rigorously validates every record against a predefined schema, and provisions Entra ID accounts with cryptographically secure, temporary passwords. This eliminates manual data entry, account cloning, and guesswork.</li><li><strong>Governance Framework:</strong> A robust IAM structure applied automatically to the provisioned accounts. This includes RBAC scoped to specific job functions, dynamic groups driven by departmental attributes, Administrative Units for delegated management, and Conditional Access policies enforcing Multi-Factor Authentication (MFA) while blocking legacy protocols. Furthermore, it replaces standing admin rights with PIM/JIT activation and enforces continuous compliance through periodic access reviews and automated license reclamation.</li></ol><p>Automation without governance simply accelerates the creation of non-compliant accounts. Governance without automation collapses under the weight of manual overhead. The success of this project hinged on deploying both in tandem.</p><h3>Solution Architecture</h3><p>The architecture was designed to flow data through progressively stricter control gates, ensuring no human makes an unrecorded or unverified decision at any stage of the lifecycle.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/560/1*4CPVFdC7NHY0Yjb4ncfA9Q.png" /><figcaption>Architecture diagram</figcaption></figure><p><strong>Architectural Layer, Component &amp; Function</strong></p><ol><li><strong>Data Ingestion &amp; Validation: </strong>HR CSV pipelines through Pydantic validation into the Python provisioning engine.</li><li><strong>Provisioning &amp; Placement: </strong>Entra ID account creation via Microsoft Graph API and automated placement into dynamic groups.</li><li><strong>Access Control (IAM)</strong>Structural organization using Administrative Units and RBAC roles scoped by department.</li><li><strong>Authentication Security: </strong>Conditional Access policies enforcing MFA, blocking legacy authentication, and assessing risk.</li><li><strong>Privileged Access Management: </strong>PIM/JIT implementation for administrative access (time-bound to 1–2 hours) and periodic access reviews.</li><li><strong>Lifecycle Governance: </strong>Automated license reclamation based on a 30-day inactivity threshold.</li></ol><p><em>Note: This architecture directly aligns with Microsoft Zero Trust, CIS Controls v8, NIST CSF, and ISO 27001.</em></p><blockquote><strong><em>Security Insight:</em></strong><em> The strength of this design lies not in any individual control, but in the mandate that </em>every<em> account must pass through </em>every<em> control. Consistent enforcement is what transforms a collection of security features into a unified security posture.</em></blockquote><h3>Technology Stack Selection</h3><p>Choosing the right tooling was critical for auditability, reliability, and security.</p><ul><li><strong>Microsoft Graph API:</strong> The definitive programmatic interface for Microsoft 365 and Entra ID. It is the most robust option for comprehensive user provisioning.</li><li><strong>Azure Identity SDK:</strong> Utilized to authenticate the automation script as a dedicated application Service Principal. This ensures no human credentials are hardcoded, scopes permissions strictly to what the script requires, and provides a pristine audit trail.</li><li><strong>Python &amp; Pydantic:</strong> Deployed to handle data validation. Because HR data quality dictates onboarding reliability, Pydantic ensures every CSV row matches a strict schema before any Graph API calls are made. Malformed rows are isolated and logged, ensuring bad data never reaches the directory or disrupts the batch process.</li><li><strong>Entra ID Governance Stack:</strong> The native enforcement layer (Conditional Access, PIM, dynamic groups) that ensures the automated accounts remain secure and compliant over time.</li></ul><blockquote><strong><em>Common Mistake:</em></strong><em> Engineering teams often prioritize writing the provisioning script and defer governance planning. Design your target state — who requires what access, under what conditions, and for how long — before automating account creation.</em></blockquote><h3>Defining Success</h3><p>To ensure alignment with both business and security objectives, I defined the following success criteria prior to deployment:</p><ul><li>Establish a standardized, auditable onboarding workflow with full execution logging.</li><li>Enforce least-privilege access structurally via RBAC, dynamic groups, and Administrative Units.</li><li>Drastically reduce standing privilege by converting in-scope admin roles to PIM-eligible assignments (requiring MFA, business justification, and approval for 1–2 hour activations).</li><li>Implement ongoing posture maintenance via periodic access reviews and automated license reclamation.</li></ul><p>By the project’s conclusion, every control was successfully implemented, evidenced, and mapped to major cybersecurity frameworks.</p><h3>The Journey Ahead</h3><p>If you have ever managed user accounts manually and recognized the need for a scalable, secure alternative, this series will show you exactly how to build it.</p><ul><li><strong>Part 2:</strong> Automating Microsoft Entra ID User Provisioning (Python, Graph API, and Azure Identity).</li><li><strong>Part 3:</strong> Building the Governance Structure (RBAC, Dynamic Groups, Administrative Units, and Conditional Access).</li><li><strong>Part 4:</strong> Eliminating Standing Privilege (PIM, JIT Activation, and Access Reviews).</li><li><strong>Part 5:</strong> Project Retrospective and Framework Mapping.</li></ul><p>Next up: <strong>Part 2: Automating Microsoft Entra ID User Provisioning with Python, Microsoft Graph API, and Azure Identity.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=766a82de2855" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Secure Networking In the Cloud: A Secure Azure Story]]></title>
            <link>https://medium.com/@nuel.ojeabulu/secure-networking-in-the-cloud-a-secure-azure-story-0e0570f72659?source=rss-a571f4dfe4c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/0e0570f72659</guid>
            <category><![CDATA[cloud-security]]></category>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[azure]]></category>
            <dc:creator><![CDATA[Nuel Ojeabulu]]></dc:creator>
            <pubDate>Wed, 19 Nov 2025 12:56:24 GMT</pubDate>
            <atom:updated>2025-11-19T12:56:24.809Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/673/1*loO3B9H6PIMdAbTL02pU-Q.png" /></figure><blockquote>A young engineer named Tunde joined a company that was slowly moving everything into Azure. On his first week, his manager handed him the keys to their cloud environment the same way someone might toss you the keys to an unfamiliar car: casually…</blockquote><blockquote>Tunde opened the Azure portal and felt that quiet mix of excitement and confusion — so many services, so many buttons, and somewhere inside all that… the network that kept the whole company running.</blockquote><blockquote>He clicked into their Virtual Network and noticed something odd. Traffic was flowing in directions no one intended. A subnet meant for internal systems somehow had a public IP floating around like a lost balloon. Logs were silent in places they should’ve been loud. It wasn’t broken, but it wasn’t safe either — just messy, the way a room gets messy when everyone assumes someone else will tidy it.</blockquote><p>After Tunde’s moment of clarity, the first thing he truly understood was that everything in Azure starts with the Virtual Network. It’s the foundation — the digital ground you build and secure everything else on. A single Virtual Network becomes the private space where your Azure resources talk to each other, reach your on-premises environment, and interact with the wider internet when you allow them to.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fSCmDPf44dF_AzhsR_sbog.jpeg" /></figure><p>Tunde didn’t fix everything in one day. He spent the next week doing something that felt almost old-fashioned in a digital world: he tried to understand the <em>shape</em> of the network before touching anything major.</p><p>He noticed that some services were talking to each other that shouldn’t be. A test database in one corner of the cloud somehow had a clear path to production resources. A public-facing web app had no clear boundary protecting it. Everything worked… but everything felt exposed, like a house with all the windows open.</p><p>One afternoon, his manager stopped by and asked, “Any progress?”</p><p>Tunde nodded. “Yeah. I’m beginning to see how everything connects. The issue isn’t the cloud. It’s that we didn’t design it to be safe.”</p><p>That was the real turning point. Just the realization that security in Azure begins long before the attackers show up. It begins with shaping the network itself.</p><p>So he walked back to his diagram and circled the one thing every connection depended on: the Virtual Network. It was the quiet backbone of the entire environment, the unseen “ground” where all their resources lived. If he could get this part right — its boundaries, its subnets, its flow of traffic — everything else would fall into place.</p><p>Tunde started rebuilding the network the way an architect redraws a city, intentionally, with an eye for how people <em>move</em> through it.</p><p>He began with the Virtual Network, carving it into subnets that suited the company’s real structure instead of the accidental sprawl they had before. Production sat in one neighborhood, testing in another, and the publicly exposed services stayed in their own fenced-off space where mistakes couldn’t spill into critical systems.</p><p>Each subnet felt like a small district with its own purpose. And as he separated them. Traffic stopped wandering into places it didn’t belong.</p><p>The next step was to define how people and services actually entered those districts. That’s where the Network Security Groups came in — quiet little rulebooks that decided who could knock, who could enter, and who should be turned away. He didn’t rely on complex rules. He kept them simple. Clear. Deliberate. Allowed this. Denied that. No more strange ports left open “just in case.”</p><p>Once the NSGs were in place, the noise in the logs dropped. Strange connections disappeared. It felt like closing doors that had been swinging in the wind.</p><p>Routing came after that. Azure had its own default paths, but Tunde took control where needed — guiding traffic away from sensitive areas and making sure data took the safer roads, not the convenient ones. It wasn’t glamorous work, but it brought order to the environment.</p><p>And because a network is never truly secure without watching it, he turned on the flow logs, the watchers, the monitors. It wasn’t about paranoia. It was about visibility, letting the network speak, letting it tell its story through metadata and flow patterns.</p><p>His last task was linking the cloud gently to the on-premises environment. A VPN tunnel here, a route table there — just enough to keep the business connected without exposing the internal network to unnecessary risks.</p><p>By the end of the month, the environment looked nothing like what he inherited.<br> It was just… clean. Predictable. Governed.</p><p>His manager walked over and asked him how things were going.</p><p>“It’s stable,” Tunde said, but what he meant was something deeper:<br> “It finally makes sense.”</p><blockquote>And that’s the quiet beauty of secure networking in Azure.<br>You start with confusion, with too many buttons, too many paths, too many unknowns. But as you learn the terrain — VNets, subnets, NSGs, routing, firewalls, monitoring — it opens up a beautiful landscape.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0e0570f72659" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding Custom Rules in Azure: PoLP Setup]]></title>
            <link>https://medium.com/@nuel.ojeabulu/understanding-custom-rules-in-azure-polp-setup-b266a09aaa6f?source=rss-a571f4dfe4c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/b266a09aaa6f</guid>
            <category><![CDATA[rbac]]></category>
            <category><![CDATA[cloud-security]]></category>
            <category><![CDATA[azure]]></category>
            <category><![CDATA[security-engineering]]></category>
            <category><![CDATA[ami]]></category>
            <dc:creator><![CDATA[Nuel Ojeabulu]]></dc:creator>
            <pubDate>Fri, 14 Nov 2025 13:54:13 GMT</pubDate>
            <atom:updated>2025-11-14T13:54:13.257Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*Tp8DiNI990ND3FCObAFm4A.jpeg" /></figure><blockquote>Custom roles in Azure are the key to applying the principle of least privilege — ensuring users only access what they need. This guide explains how to plan, create, and manage Azure custom roles effectively.</blockquote><p>Here are a few things we are going to cover in this guide:</p><ol><li>Why Least Privilege Matters</li><li>The Challenges of built-in roles</li><li>The benefits of custom roles</li><li>How to create custom roles in Azure</li></ol><h3><strong>Why Least Privilege Matters</strong></h3><p>The principle of <strong>least privilege</strong> (PoLP) is a principle in identity governance that involves assigning users and groups only the minimum level of access and permissions necessary to perform their duties.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/236/1*V4DX7LmvK4B3Y4JCt1HdyQ.jpeg" /></figure><p>The idea is to <strong><em>restrict access rights </em></strong>so that a user or group can complete their work, but also minimizing unnecessary privileges that could potentially be exploited by attackers or lead to security breaches.</p><h3>The Challenges of built-in roles</h3><p><a href="https://learn.microsoft.com/en-us/azure/role-based-access-control/overview"><em>Azure role-based access control (Azure RBAC)</em></a> has several Azure built-in roles that you can assign to users, groups, service principals, and managed identities. Role assignments are the way you control access to Azure resources.<br>Built-in roles take a one-size-fits-all approach, which rarely matches the specific needs of an organization.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/683/1*mFb4b6rL1Lq73eJr7HIV5g.png" /></figure><p>These gaps in role definitions can lead to unnecessary security vulnerabilities.</p><h3>Custom Roles</h3><p>Custom roles allow you to fine-tune permissions, bridging the gaps left by built-in roles. This ensures users have only the access they need, reducing risks while keeping operations smooth.</p><p>Steps to create a custom role</p><p>Here are the basic steps to create a custom role.</p><ol><li><strong>Determine the permissions you need</strong>: When you create a custom role, you need to know the actions that are available to define your permissions. Typically, you start with an existing built-in role and then modify it for your needs. You will add the actions to the Actions or NotActions properties of the role definition. If you have data actions, you will add those to the DataActions or NotDataActions properties.</li><li>Decide how you want to create the custom role.</li><li>You can create custom roles using Azure portal, Azure PowerShell, Azure CLI, or the REST API.</li><li>Create the custom role.</li><li>Test the custom role.</li><li>Once you have your custom role, you have to test it to verify that it works as you expect. If you need to make adjustments later, you can update the custom role.</li></ol><h3>Case study</h3><p>A medium-sized hospital — Greenfield Medical Center — recently moved its IT operations into Azure. For compliance reasons, the hospital must tightly control who can touch sensitive data, especially patient records.</p><p>The IT team splits responsibilities across three people:</p><ol><li>Dr. Ada — Data Analyst<br>She needs to run analytics on patient data stored in Azure Storage and Azure SQL.<br>She should be able to read from those services but must never modify infrastructure.</li><li>Kemi — VM Administrator<br>She manages virtual machines used by the radiology department.<br>She needs full access to start/stop VMs and view their logs, but she must not access patient data.</li><li>James — Security Intern<br>He’s learning Azure and needs visibility into security alerts in Defender for Cloud, but he must not change any security settings.</li></ol><p>The hospital discovers that Azure’s built-in roles don’t fit these responsibilities perfectly. For example:</p><p>“Storage Blob Data Reader” gives Ada the right access to the data, but she also needs read-only visibility into SQL databases, which requires a different role.</p><p>“Virtual Machine Contributor” gives Kemi most of what she needs, but it also allows changing networking configurations, which the hospital doesn’t want.</p><p>“Security Reader” gives James too much visibility into compliance reports that the hospital considers sensitive.</p><p>To create each of these rules:</p><p><strong>Step 1 — Go to your azure subscription→ Access Control (IAM) → Add New → Add Custom Role</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*thUtlOqY8brVYctUnBjuPw.png" /></figure><p>Step 2: Give your custom role a name</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SbxORZxQ6aVcSi5WqD27Rw.png" /></figure><p>PS: if you are like me who writes JSON then, move to JSON and add the following code(This is however for the data analytics reader)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/982/1*4Wm2UklIie6PE0PvVqQ9NQ.png" /></figure><p>The <strong>Data Analytics Reader</strong> role which we just created gives a user the power to <em>look</em> at things but never <em>change</em> anything.</p><p>It lets them browse Azure resources, view Storage accounts, open and read blob files, and see SQL database details such as names and properties. They can’t modify data, can’t delete anything, and can’t change any settings. It’s a safe, read-only role designed for analysts who need visibility into data without the risk of altering the environment.</p><p>This role becomes especially useful in environments where people must study information while keeping the infrastructure protected.</p><p>Similarly procedure for the rest of the roles<br><strong>VM Admin</strong></p><pre>{<br>  &quot;properties&quot;: {<br>    &quot;roleName&quot;: &quot;Radiology VM Operator&quot;,<br>    &quot;description&quot;: &quot;Can start, stop, restart, and monitor VMs for the Radiology department, but cannot access patient data.&quot;,<br>    &quot;assignableScopes&quot;: [<br>      &quot;/subscriptions/&lt;YOUR_SUBSCRIPTION_ID&gt;&quot;<br>    ],<br>    &quot;permissions&quot;: [<br>      {<br>        &quot;actions&quot;: [<br>          &quot;Microsoft.Compute/virtualMachines/start/action&quot;,<br>          &quot;Microsoft.Compute/virtualMachines/restart/action&quot;,<br>          &quot;Microsoft.Compute/virtualMachines/deallocate/action&quot;,<br>          &quot;Microsoft.Compute/virtualMachines/read&quot;,<br>          &quot;Microsoft.Insights/metricDefinitions/read&quot;,<br>          &quot;Microsoft.Insights/metrics/read&quot;,<br>          &quot;Microsoft.Insights/diagnosticSettings/read&quot;<br>        ],<br>        &quot;notActions&quot;: [<br>          &quot;Microsoft.Compute/virtualMachines/extensions/write&quot;,<br>          &quot;Microsoft.Storage/*&quot;,<br>          &quot;Microsoft.Sql/*&quot;<br>        ],<br>        &quot;dataActions&quot;: [],<br>        &quot;notDataActions&quot;: []<br>      }<br>    ]<br>  }<br>}</pre><p>The <strong>VM Operator </strong>role is a pair of steady hands: it gives someone enough power to operate virtual machines without giving them the keys to the kingdom.</p><p>They can start, stop, and restart VMs, and they can view the underlying network setup so they understand how machines are connected. What they cannot do is create new VMs, delete existing ones, or change networking. It keeps operations running smoothly while keeping the environment protected from accidental or unauthorized changes.</p><p>This role is especially helpful in production setups where uptime matters but full administrative access would be too risky.</p><p>James — Security Intern</p><pre>{<br>  &quot;properties&quot;: {<br>    &quot;roleName&quot;: &quot;Security Intern - Read Only&quot;,<br>    &quot;description&quot;: &quot;Can view security alerts and recommendations in Microsoft Defender for Cloud, but cannot modify any security settings.&quot;,<br>    &quot;assignableScopes&quot;: [<br>      &quot;/subscriptions/&lt;YOUR_SUBSCRIPTION_ID&gt;&quot;<br>    ],<br>    &quot;permissions&quot;: [<br>      {<br>        &quot;actions&quot;: [<br>          &quot;Microsoft.Security/locations/alerts/read&quot;,<br>          &quot;Microsoft.Security/locations/assessments/read&quot;,<br>          &quot;Microsoft.Security/locations/pricings/read&quot;,<br>          &quot;Microsoft.Security/locations/secureScores/read&quot;<br>        ],<br>        &quot;notActions&quot;: [],<br>        &quot;dataActions&quot;: [],<br>        &quot;notDataActions&quot;: []<br>      }<br>    ]<br>  }<br>}</pre><p>The <strong>Security Intern — Read Only</strong> role is designed to let the intern <strong>observe security operations without being able to make any changes</strong>.</p><p><strong>Can:</strong></p><ul><li>View security alerts in Microsoft Defender for Cloud.</li><li>Check assessments, recommendations, and secure scores.</li><li>Monitor the organization’s security posture.</li></ul><p><strong>Cannot:</strong></p><ul><li>Change security policies or settings.</li><li>Access or modify sensitive resources like databases or storage accounts.</li></ul><p><strong>Purpose:</strong></p><ul><li>Allows the intern to <strong>learn and practice security monitoring safely</strong>.</li><li>Ensures <strong>no accidental changes</strong> that could affect the hospital’s security.</li></ul><h3>Conclusion</h3><p>To make the most of least privilege principles, follow these essential steps:</p><ul><li>Start by granting only the minimum permissions required for each role. Gradually expand as needed.</li><li>Regularly review permissions to remove unnecessary access that could pose a risk.</li></ul><p>References:</p><p><a href="https://azure.criticalcloud.ai/azure-custom-roles-least-privilege-setup-guide/">https://azure.criticalcloud.ai/azure-custom-roles-least-privilege-setup-guide/</a><br><a href="https://youtu.be/zhYW-cIsM9E">https://youtu.be/zhYW-cIsM9E</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b266a09aaa6f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Gift of No Escape]]></title>
            <link>https://medium.com/@nuel.ojeabulu/the-gift-of-no-escape-dbece9f2258a?source=rss-a571f4dfe4c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/dbece9f2258a</guid>
            <category><![CDATA[freedom]]></category>
            <category><![CDATA[life]]></category>
            <category><![CDATA[careers]]></category>
            <dc:creator><![CDATA[Nuel Ojeabulu]]></dc:creator>
            <pubDate>Sun, 31 Aug 2025 05:55:24 GMT</pubDate>
            <atom:updated>2025-08-31T05:55:24.696Z</atom:updated>
            <content:encoded><![CDATA[<p>Every time we reach for something beyond ourselves — a goal, a dream, a daring ambition — we collide with an unfamiliar version of who we are. The comfortable self that thrives on routine gives way to a rawer self: untested, vulnerable, uncertain. At that edge, the choice appears stark. Push forward into discomfort, or retreat into safety.</p><p>The decision often hinges on two questions. First: is the goal heavy enough to pull us forward, like gravity? Second: has the universe left us a way to retreat? For most, the presence of an escape route is enough to tilt the scales. Humans are wired for comfort; when exits are visible, we take them.</p><p>But here lies the paradox: those without escape routes may be the luckiest of all. Circumstance, fate, or necessity closes the doors behind them, and what looks like cruelty becomes a hidden form of mercy. With no way back, they must go forward. The absence of alternatives strips away hesitation, self-betrayal, and the temptation of comfort. Transformation becomes compulsory.</p><p>We see this everywhere. Myth insists the hero cannot return across the threshold; the old life is already lost. Philosophy echoes the lesson. Nietzsche urged us to embrace <em>amor fati</em> — love of one’s fate — as the deepest form of strength. The Stoics taught that obstacles are not interruptions of the path, but the path itself. History shows it too: Viktor Frankl found meaning in a concentration camp by discovering freedom not in external choices, but in how he chose to endure suffering. Epictetus, born enslaved, taught the same.</p><p>Yet necessity has its dangers. To burn all ships is to court ruin if the chosen path proves destructive. Rigidity can trap us in cycles of despair. And desperation, without vision, corrodes more than it builds.</p><p>On the other hand, freedom — the abundance of choice — offers its own trap. Modern life brims with exits. Career paths, reinventions, identities, and distractions are infinite. At first, this abundance looks like liberation. But too much choice breeds paralysis. Psychologists call it the paradox of choice: the more exits we see, the less likely we are to commit fully to any one. We hover in doorways, rehearsing lives we never step into.</p><p>Earlier generations lived within sharper constraints. A farmer’s son became a farmer, a soldier’s child a soldier. Life was narrower but more focused. Modernity, with its infinite horizons, often dissolves us into indecision. We are freer than ever before — and yet more restless, more lost.</p><p>So which is better? Necessity or freedom? The answer is that both carry poison and medicine. Too much necessity becomes oppression. Too much freedom becomes noise. Growth happens in the space between. It requires what might be called <em>designed irreversibility</em>: the conscious narrowing of options, not recklessly, but intentionally. The pruning of exits that lead to stagnation, so that energy is forced through the path that matters.</p><p>The irony is that those who lament having “no choice” may in fact be holding the greatest gift: the universe has removed the luxury of quitting. For the rest of us, the challenge is harder. We must create our own thresholds, close our own doors, and accept the strangeness of growing not by multiplying options, but by reducing them.</p><p>In the end, transformation does not come from abundance, but from the willingness to let some possibilities die so that one possibility can fully live.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dbece9f2258a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TRAFFIC ANALYSIS EXERCISE: BIG FISH IN A LITTLE POND]]></title>
            <link>https://medium.com/@nuel.ojeabulu/traffic-analysis-exercise-big-fish-in-a-little-pond-354782311d10?source=rss-a571f4dfe4c9------2</link>
            <guid isPermaLink="false">https://medium.com/p/354782311d10</guid>
            <dc:creator><![CDATA[Nuel Ojeabulu]]></dc:creator>
            <pubDate>Wed, 26 Feb 2025 18:43:35 GMT</pubDate>
            <atom:updated>2025-02-26T18:43:35.436Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Solutions to the 2024–09–04 — TRAFFIC ANALYSIS EXERCISE: BIG FISH IN A LITTLE POND</strong></p><ol><li>Here in this challenge, we have a pcap file and an alert file. Lets look for the malicious indicators based on the network activity in the alert and pcap files</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lCDItkv_Vobca3-4eay3hA.png" /></figure><p>2. Our alerts flag something quite interesting. An IP on our network(<strong>172.17.0.99)</strong> is communicating with a suspicious IP address that is hosting a malware called “<strong><em>Koi Stealer</em></strong>”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/996/1*N9ndK_wSPQqXoaDshq8S_A.png" /></figure><p>3. Further investigation into that IP address communicating with a suspicious IP indicates the host name which is <strong>DESKTOP-RNV09AT. </strong>This information was however gotten using the <strong>nbns capture filter.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/958/1*NzQwawvEqbRNX2rP1y6yUA.png" /></figure><p>3. Further investigation into the user of that workstation shows that the user of the infected workstation is <strong>Andrew Fletcher. </strong>We got this using the display filter <strong>ldap contains “CN=Users”.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/956/1*vOjxmKiIu5svH8cPciArvg.png" /></figure><p>4. Upon deeper inspection into the header of the packet, I found the MAC address off the infected system <strong>18:3d:a2:b6:8d:c4</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ErIe0TIz5VOzrqoJl2l60g.png" /></figure><p>5. Earlier in our alert we saw that the compromised host sent a POST request to the malicious IP address: <strong>79.124.78.197 </strong>However looking through the PCAP file i found the post request and got the full url which is highlighted below. “<a href="http://79.124.78.194/"><strong>http://79.124.78.19</strong></a><strong>7/foot.php”</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WdBtWRJetG7On93qOj289g.png" /></figure><p><strong>Executive Summary</strong>: As early as Wednesday 2024–09–04 at 17:35 UTC, a Windows host used by Andrew Fletcher showed signs of being infected with Koi Stealer malware.</p><p><strong>Victim Details:</strong></p><p>• Host name: DESKTOP-RNVO9AT</p><p>• IP address: 172.17.0.99</p><ul><li>MAC address: 18:3d:a2:b6:8d:c4 •</li><li>Windows user account name: afletcher</li><li>Name of victim: Andrew Fletcher</li></ul><p><strong>Indicators of Compromise (IOCs)</strong>:</p><p>Alert information:</p><p>Src IP:port Dest IP:port Alert name 172.17.0.99:49813 79.124.78.197:80 ETPRO TROJAN Win32/Koi Stealer CnC Checkin (POST) M2</p><p><strong>URLs generating the alert traffic:</strong></p><p><strong>79.124.78.197:80 </strong>— 79.124.78.197 — POST /foots.php</p><p><strong>79.124.78.197:80 </strong>— 79.124.78.197 — POST /index.php?id&amp;subid=qIOuKk7U</p><p>Thanks to <strong>Malware-traffic-analysis.net </strong>making this challenges to test knowledge in malware traffic analysis available.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=354782311d10" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>