Cyber security and ethical analysis

Cyber security and ethical analysis Cyber security essentials code οΏ½ ethical security
(3)

03/06/2026

A harnessed LLM agent, clearly explained!

Most people picture this as a model with tools bolted on. The real architecture inverts that relationship.

The model itself is deliberately thin. Intelligence gets pushed outward, and the harness composes it at runtime.

Three dimensions orbit the harness core:

- π— π—²π—Ίπ—Όπ—Ώπ˜† holds the state a model shouldn't carry in weights or context. Working context, semantic knowledge, episodic experience, and personalized memory each have their own lifecycle.

- π—¦π—Έπ—Άπ—Ήπ—Ήπ˜€ hold procedural knowledge. This can cover operational procedures, decision heuristics, and normative constraints that specialize the general model per task.

- π—£π—Ώπ—Όπ˜π—Όπ—°π—Όπ—Ήπ˜€ hold the interaction contracts. Agent-to-user, agent-to-agent, and agent-to-tools are three distinct surfaces with their own failure modes.

Between the core and these modules sit the mediators, like sandboxing, observability, compression, evaluation, approval loops, and sub-agent orchestration.

They govern how the harness reaches out and how state flows back in.

The useful question this framing unlocks is: for any new capability, where should it live?

- Stable knowledge goes to memory
- Learned playbooks go to skills
- Communication contracts go to protocols
- Loop governance goes to the mediators

Harness design becomes a question of what to externalize, and how to mediate it.

I'm building a minimal agent harness from scratch and will open-source it soon.

In the meantime, my co-founder wrote an article about the anatomy of Agent Harness, covering the orchestration loop, tools, memory, context management, and everything else that transforms a stateless LLM into a capable agent.

#

03/06/2026

plaintext, hashing, encoding, and encryption, highlighting their differences and typical use cases:

Plaintext

Definition: Human-readable data stored or transmitted without any transformation.
Example: `"Hello, World!"` in a text file.
Use case: Data meant to be directly read or edited by users.

Hashing

Definition: Converts input data into a fixed-length string of characters (called hash) using a hash function; it is one-way.
Properties:
Irreversible: Cannot retrieve original data from hash.
Used for verifying data integrity or storing passwords securely.
- Example: `SHA-256("password")
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855`
Use case: Password storage, checksum verification.

Encoding

Definition: Transforms data into a different format using a reversible process, mainly for data transmission or storage.
Properties:
Reversible via the same encoding method.
Not meant for security, but for compatibility.
Common Types:
Base64: Encodes binary data into ASCII characters.
Example: `Hello` in Base64 is `SGVsbG8=`.
Use case: Embedding binary data in text formats like JSON, email attachments.

Encryption

Definition: Converts plaintext into ciphertext using algorithms and keys, reversing this process with the correct key.
Properties:
Reversible when the key is known.
Used to protect data confidentiality during storage or transmission.
Types:
Symmetric: Same key for encrypt/decrypt (e.g., AES).
Asymmetric: Uses public/private keys (e.g., RSA).
Example: Encrypting "Hello" with AES yields unreadable ciphertext, which can be decrypted back.
Use case: Secure messaging, data protection.

03/06/2026

Git workflow to help you manage your code effectively:

1. Cloning the Repository
To start working on a project, clone the remote repository:
```bash
git clone https://github.com/username/repository.git
```

2. Creating a Branch
It's best to create a new branch for each feature or bug fix:
```bash
git checkout -b feature-branch-name
```

3. Making Changes and Committing
After editing files, stage them:
```bash
git add filename
```
or stage all changes:
```bash
git add .
```
Then commit with a clear message:
```bash
git commit -m "Describe your changes"
```

4. Pulling Latest Changes
Before pushing, ensure your branch is up-to-date with the main branch:
```bash
git fetch origin
git rebase origin/main
```
or
```bash
git pull origin main
```

5. Pushing Changes
Push your branch to the remote repository:
```bash
git push origin feature-branch-name
```

6. Creating a Pull Request (PR)
Once your changes are pushed, open a PR on platforms like GitHub, GitLab, or Bitbucket to merge your feature branch into main.

7. Code Review & Merging
Collaborate with team members for review. After approval, merge the PR into main.

8. Updating Local Main
After merging, update your local main branch:
```bash
git checkout main
git pull origin main
```

03/06/2026

π—–π˜†π—―π—²π—Ώπ˜€π—²π—°π˜‚π—Ώπ—Άπ˜π˜† π—§π—Όπ—Όπ—Ήπ˜€ β€” πŸ”΄ π—’π—³π—³π—²π—»π˜€π—Άπ˜ƒπ—² vs πŸ”΅ π——π—²π—³π—²π—»π˜€π—Άπ˜ƒπ—²

πŸ”΄ RED TEAM (Offensive β€” Finding Weaknesses)

β€’ Nmap β†’ Network scanning & port discovery
β€’ Burp Suite β†’ Web app testing (auth, bugs, APIs)
β€’ Metasploit β†’ Exploitation & payload ex*****on
β€’ Wireshark β†’ Packet-level traffic analysis
β€’ SQLmap β†’ Automated SQL injection testing
β€’ Hydra β†’ Brute-force login attacks
β€’ John the Ripper β†’ Password cracking (offline)
β€’ Aircrack-ng β†’ WiFi attacks & auditing

πŸ‘‰ Use when: You are simulating an attacker

πŸ”΅ BLUE TEAM (Defensive β€” Detect & Respond)

β€’ SIEM β†’ Centralized log monitoring (alerts)
β€’ IDS/IPS β†’ Detect/block suspicious traffic
β€’ Splunk β†’ Log analysis & threat hunting
β€’ ELK Stack β†’ Logging + visualization
β€’ Suricata β†’ Network-based threat detection
β€’ OSSEC β†’ Host-based intrusion detection
β€’ Snort β†’ Signature-based network IDS

πŸ‘‰ Use when: You are defending systems

πŸ•΅οΈ OSINT (Recon β€” Information Gathering)

β€’ Maltego β†’ Relationship mapping (people/domains)
β€’ Shodan β†’ Find exposed services on internet
β€’ theHarvester β†’ Emails, domains, metadata
β€’ Recon-ng β†’ Automated recon framework

πŸ‘‰ Use when: You need intel before attacking/defending

πŸ’» PLATFORMS (Your Lab Environment)

β€’ Kali Linux β†’ Offensive security toolkit
β€’ Parrot OS β†’ Security + privacy-focused OS

03/06/2026

MASTERING PLAN FOR PYTHON

STEP 1: UNDERSTAND PYTHON FUNDAMENTALS

β†’ Installing Python and setting up the environment
β†’ Variables and data types
β†’ Operators and expressions
β†’ Input and output
β†’ Type conversion
β†’ Writing your first Python programs

Build a strong foundation before moving to advanced topics.

STEP 2: MASTER CONTROL FLOW

β†’ Conditional statements (if, elif, else)
β†’ Comparison and logical operators
β†’ Loops (for, while)
β†’ Nested loops
β†’ Break and continue statements
β†’ Match-case statements

Control flow allows you to create dynamic applications.

STEP 3: FUNCTIONS AND MODULAR PROGRAMMING

β†’ Defining functions
β†’ Parameters and return values
β†’ Default arguments
β†’ Variable-length arguments (*args, **kwargs)
β†’ Lambda functions
β†’ Creating reusable modules

Functions help organize and reuse code efficiently.

STEP 4: WORKING WITH DATA STRUCTURES

LISTS

β†’ Creating and manipulating lists
β†’ List comprehensions
β†’ Sorting and filtering

TUPLES

β†’ Immutable collections
β†’ Tuple unpacking

SETS

β†’ Unique data storage
β†’ Set operations

DICTIONARIES

β†’ Key-value storage
β†’ Dictionary methods
β†’ Nested dictionaries

Data structures are essential for solving real-world problems.

STEP 5: OBJECT-ORIENTED PROGRAMMING (OOP)

β†’ Classes and objects
β†’ Constructors (__init__)
β†’ Encapsulation
β†’ Inheritance
β†’ Polymorphism
β†’ Abstraction

OOP helps build scalable and maintainable applications.

STEP 6: FILE HANDLING

β†’ Reading files
β†’ Writing files
β†’ Working with CSV files
β†’ Working with JSON files
β†’ File paths and directories
β†’ Error handling during file operations

Most real-world applications interact with files and data.

STEP 7: EXCEPTION HANDLING

β†’ Understanding errors and exceptions
β†’ try, except, finally
β†’ Custom exceptions
β†’ Debugging techniques
β†’ Logging basics

Robust applications handle errors gracefully.

STEP 8: WORKING WITH LIBRARIES AND PACKAGES

β†’ Installing packages using pip
β†’ Virtual environments
β†’ Python standard library
β†’ Third-party packages
β†’ Package management best practices

Libraries dramatically increase development speed.

STEP 9: DATABASES WITH PYTHON

β†’ SQLite fundamentals
β†’ Connecting to databases
β†’ CRUD operations
β†’ Working with PostgreSQL and MySQL
β†’ ORM basics (SQLAlchemy)

Databases are at the heart of most applications.

STEP 10: WEB DEVELOPMENT WITH PYTHON

β†’ HTTP fundamentals
β†’ Flask basics
β†’ Django fundamentals
β†’ REST APIs
β†’ Authentication systems
β†’ Deploying web applications

Python powers many modern web applications.

STEP 11: AUTOMATION AND SCRIPTING

β†’ Automating repetitive tasks
β†’ Web scraping basics
β†’ Scheduling tasks
β†’ Email automation
β†’ File automation
β†’ API integrations

Automation is one of Python’s greatest strengths.

STEP 12: DATA SCIENCE AND AI

β†’ NumPy
β†’ Pandas
β†’ Data visualization
β†’ Machine learning fundamentals
β†’ Scikit-learn
β†’ AI and LLM integrations

Python dominates the data science and AI ecosystem.

STEP 13: ADVANCED PYTHON CONCEPTS

β†’ Generators and iterators
β†’ Decorators
β†’ Context managers
β†’ Multithreading
β†’ Multiprocessing
β†’ Async programming (asyncio)

Advanced concepts improve performance and code quality.

STEP 14: BUILD REAL-WORLD PROJECTS

β†’ Expense tracker
β†’ Task management application
β†’ REST API project
β†’ Web scraper
β†’ AI-powered chatbot
β†’ Full-stack Python application

Projects transform knowledge into practical skills.

STEP 15: INTERVIEW PREPARATION AND PROFESSIONAL DEVELOPMENT

β†’ Python coding challenges
β†’ Data structures and algorithms in Python
β†’ System design basics
β†’ Debugging exercises
β†’ Code optimization techniques
β†’ Real-world software engineering practices

Consistent practice is the key to Python mastery.

03/06/2026

Top 20 Python one-liners

𝗗𝗔𝗧𝗔 π—€π—¨π—”π—Ÿπ—œπ—§π—¬

df.duplicated() β€” find duplicate rows
df.isna().sum() β€” count missing values per column
df.describe() β€” get a full statistics summary instantly

π—–π—Ÿπ—˜π—”π—‘π—œπ—‘π—š

df.drop_duplicates(keep='last') β€” remove duplicates, keep the latest
df.fillna() β€” handle missing values
df.replace({dict}) β€” replace multiple values at once
df.str.contains() β€” filter text columns without regex headaches
df.clip() β€” cap outliers without removing them from your dataset

π—”π—‘π—”π—Ÿπ—¬π—¦π—œπ—¦

df.value_counts(normalize=True) β€” calculate percentages instantly
pd.crosstab() β€” create a pivot summary in one line
df.groupby().nlargest() β€” get the top N results per group

𝗧π—₯𝗔𝗑𝗦𝗙𝗒π—₯π— π—”π—§π—œπ—’π—‘

pd.cut() β€” create bins from continuous numbers
df.merge() β€” join two dataframes
df.pivot_table() β€” create flexible pivots
df.assign() β€” add new columns without overwriting your original dataframe
df.explode() β€” unnest list columns into individual rows
df.pipe() β€” chain multiple operations cleanly in sequence

π—¦π—˜π—Ÿπ—˜π—–π—§π—œπ—’π—‘ & 𝗦𝗒π—₯π—§π—œπ—‘π—š

df.query() β€” filter with readable syntax instead of brackets
df.nlargest(n, 'col') β€” get the top N rows by column value
df.sort_values() β€” sort by one or multiple columns

02/06/2026

Which of the following is not a cybercrime?

A. Denial of Service (DoS)

B. Man-in-the-Middle (MiTM)

C. Malware

D. AES (Advanced Encryption Standard)

02/06/2026

When a user types a website into their browser, what is the first place the system checks for the IP address?

A. DNS server on the internet

B. Local DNS cache

C. Root DNS server

D. ISP DNS server

02/06/2026

Most beginners learn coding in the wrong order.

They jump between random tutorials, get overwhelmed, and quit.

If I had to start from scratch in 2026, this is the roadmap I'd follow:

πŸ“ STEP 1 β€” HTML & CSS
Learn how websites are actually built.
πŸ”— CSS-Tricks

πŸ“ STEP 2 β€” JavaScript
The language that powers the web.
πŸ”— JavaScript.info

πŸ“ STEP 3 β€” Git & GitHub
Version control is a superpower.
πŸ”— GitHub Skills

πŸ“ STEP 4 β€” SQL
Every developer should know how data is stored and queried.
πŸ”— Codecademy SQL

πŸ“ STEP 5 β€” React
Build modern frontend applications.
πŸ”— Scrimba

πŸ“ STEP 6 β€” APIs
Learn how applications communicate.
πŸ”— RapidAPI

πŸ“ STEP 7 β€” Python
Automation, AI, Data Science, Backend.
πŸ”— Kaggle Python

πŸ“ STEP 8 β€” Data Structures & Algorithms
The skill that helps you crack interviews.
πŸ”— Programiz

πŸ“ STEP 9 β€” Full-Stack Development
Connect frontend, backend, databases, and APIs.
πŸ”— freeCodeCamp

πŸ“ STEP 10 β€” Pick Your Specialization

πŸ€– AI/ML β†’ Python + AI Libraries
☁️ Cloud/DevOps β†’ AWS + Docker + Kubernetes
πŸ“± Mobile β†’ React Native / Flutter
πŸ”’ Cybersecurity β†’ Networking + Security
βš™οΈ Backend β†’ Node.js / Java / Go

Most developers fail because they don't have a roadmap.

Not because they lack talent.

Save this.

It can save you months of confusion. πŸš€

02/06/2026

RAG was never the end goal.

Memory in AI agents is where everything is heading. Let me break down this evolution.

RAG (2020 to 2023):

- Retrieve info once, generate response
- No decision making, just fetch and answer
- Problem: often retrieves irrelevant context

Agentic RAG:

- Agent decides if retrieval is needed
- Agent picks which source to query
- Agent validates if results are useful
- Problem: still read only, can’t learn from interactions

AI Memory:

- Read AND write to external knowledge
- Learns from past conversations
- Remembers user preferences, past context
- Enables true personalization

The mental model is simple:

↳ RAG: read only, one shot
↳ Agentic RAG: read only via tool calls
↳ Agent Memory: read write via tool calls

With memory, the agent can now remember things like user preferences, past conversations, and important dates. And all of it is stored and retrievable for future interactions.

This gives the agent a layer for continual learning, where instead of being frozen at all times, agent can accumulate knowledge from every interaction and improve over time without retraining.

This isn't simple because in practice, production systems need to think about memory corruption, decide what to forget, and manage multiple memory types like procedural, episodic, and semantic.

Graphiti (open source with 26k+ stars) already implements all of that if you want to build real time, temporally aware knowledge graphs that power self evolving AI memory.

Instead of recomputing the whole graph on every update, Graphiti ingests new info incrementally and tracks when each fact was true.

And when that info changes, the old facts are invalidated rather than deleted, so an agent can query what is true now and reconstruct what was true at any earlier point.

The core loop is two calls, one to write an episode into the graph and one to search across it:
After this, Graphiti handles entity extraction, relationship building, and temporal updates underneath.

Here's the GitHub Repo: github.com/getzep/graphiti

(don't forget to star it ⭐)

Note that there's one practical detail that decides whether this graph will be actually useful.

By default, the extraction model picks the entity types and relationship labels on its own.

This returns generic results, where everything collapses into a Topic or Object node connected by RELATES_TO edges that cannot be queried meaningfully.

Defining the schema yourself as Pydantic models makes the layer resilient.

My co-founder wrote a full breakdown on this, walking through why agent memory is only as good as its schema and how to define a custom ontology with code.
#

Address

Abuja
Bwari
902101

Website

Alerts

Be the first to know and let us send you an email when Cyber security and ethical analysis posts news and promotions. Your email address will not be used for any other purpose, and you can unsubscribe at any time.

Shortcuts

Share

Category