CYBERSECURITY EXPLAINED Beginner website security guide
How Do Ethical Hackers Find Website Vulnerabilities? A Beginner’s Guide
AUTHORISE → MAP → VERIFY → REPORT → RETEST
How ethical hackers trace a possible website weakness from the first clue to reliable evidence, a clear report and a retested fix—with a fictional student portal and safe examples.
GOOD TESTING USES EVIDENCE
A clue is a question. Reproducible evidence supports the answer.Quick answer
How do ethical hackers discover website vulnerabilities?
Hackers find website vulnerabilities by learning how a website works, identifying where security rules might fail and checking observations against those rules. Ethical hackers do this with permission and a defined scope. A scanner alert is a lead—not proof that a website is compromised.
- Permission and scope first
- Test the expected security rule
- Evidence, responsible fixes and retesting
The methods that reveal weak security controls are not automatically ethical or unethical: permission, scope, purpose and conduct make the difference. This guide explains the authorised testing process; it does not require you to test somebody else’s live website.
Imagine a student portal where Amina and Brian each have private examination results. Both can sign in successfully. But does the server actually check whose results each student is allowed to see? That simple question reveals how security testing works: establish the rule, observe what happens, test the boundary safely and explain the result.
This guide follows that reasoning from start to finish. It uses a fictional classroom portal and synthetic accounts , not a real school or publicly accessible website.
What makes a website vulnerable?
A website vulnerability is a weakness in design, code, configuration or operation that may allow a security requirement to fail. Examples include an application disclosing private records to the wrong account, accepting an action a user is not authorised to perform, or exposing sensitive diagnostic information. The OWASP Web Security Testing Guide [1] describes how professionals assess different kinds of web-application controls.
A bug and a vulnerability are not quite the same. A results page showing the wrong examination date is a bug. A results page letting one student retrieve another student’s private report is a security vulnerability. An unexpected error message could be either, or neither; its meaning depends on what it exposes and what the application is supposed to do.
| Term | Plain-English meaning | Fictional portal example |
|---|---|---|
| Security rule | What the website must prevent or allow | A student may read only their own report |
| Clue | Something worth examining | Two accounts receive unexpectedly similar responses |
| Finding | A documented security observation supported by evidence | Account B receives Account A’s private report in a controlled test |
| Impact | The harm the weakness could cause | Exposure of confidential academic records |
| Remediation | The change intended to correct the root cause | Enforce report ownership on the server |
On a narrow screen, swipe horizontally to read all columns.
The key distinction: a clue tells a tester where to look . A confirmed finding explains what failed, under which conditions, and with what evidence . A test can also end with no issue observed or inconclusive evidence . Not every unusual response is a vulnerability.
First understand the website—not just its homepage
When you open a page, your browser sends an HTTP request to a server. The server returns a response and may consult an application, API or database. An API is a way for software components to exchange requests and results. A session helps the application recognise a signed-in user across requests. These are everyday web fundamentals, explained further in MDN’s HTTP overview [6] .
Picture an imaginary examination portal:
- The browser displays the learner’s dashboard.
- The server receives the request to open a report.
- The database stores synthetic student records.
- The permission check decides whether the signed-in account may access the requested record.
A website can look perfectly normal while one of these server-side checks is missing.
Authentication and authorisation are different
Authentication answers, “Which user signed in?” Authorisation answers, “What may that user do?” Amina’s valid password proves she is Amina; it does not give her permission to see Brian’s marks. Proper authorisation must be enforced by trusted server-side application logic—not merely by hiding a button in the browser. OWASP’s Broken Access Control guidance [5] describes this distinction in practice.
For example, the fictional request below simply means a signed-in account has asked for its own report. It is not a test against a real domain:
The
.example
domain is
reserved for illustrations
[14]
. A response such as
200 OK
means a request succeeded at the HTTP level; it does
not
, on its own, prove that the right person received the right information.
Build a simple map of what needs protection
Before looking for weaknesses, ask what the application must protect and where those rules are enforced. This is sometimes called mapping the attack surface : the exposed functions and components that might need security checks. In an authorised assessment, the map is limited to the systems and features the owner has approved.
| Area to understand | Fictional portal question | Possible security rule |
|---|---|---|
| Login and sessions | How does the site remember that a student signed in? | A signed-out visitor cannot see protected reports |
| Records and downloads | Where do students retrieve their results and receipts? | A student may retrieve only their own records |
| Forms and data changes | Can a student update contact information? | Changing personal details requires the right account |
| Administrative functions | Who may publish marks or change a student record? | A student cannot perform staff-only actions |
| APIs and background requests | Do app requests use the same permission rules as visible pages? | Every relevant server endpoint checks the user’s authority |
On a narrow screen, swipe horizontally to read all columns.
For example, a portal may hide a report-download button from Brian but still accept an unauthorised download request. The visible interface is therefore only one part of the assessment. OWASP’s Application Security Verification Standard 5.0.0 [9] provides a separate catalogue of security requirements that developers and testers can use to define such expectations.
How do ethical hackers actually find weaknesses? A practical workflow
Security work is not a single magic scan. In a classroom, it can be taught as seven connected activities. Professional engagements may perform them in another order or repeat them as new information appears; the OWASP testing framework [3] is flexible rather than a compulsory seven-step sequence.
Authorise and define the scope
1. Confirm permission. Agree systems, test accounts, permitted methods, timing and stop conditions
Output: Written scope and rules
Understand and map
2. Learn expected behaviour. Ask what each account or feature is supposed to do
3. Map the application. Review approved pages, forms, API functions and software components
Output: A list of security rules; A simple application map
Investigate and verify
4. Look for clues. Inspect traffic, settings, messages, roles and relevant tool alerts
5. Check the hypothesis. Compare expected and observed behaviour with controlled test data
Output: Questions needing verification; Reproducible evidence or a rejected hypothesis
Explain, fix and retest
6. Explain the finding. Document affected control, impact and corrective action
7. Retest. Verify the correction and normal user functions
Output: A clear, actionable report; Evidence of the fix under tested conditions
Here, reconnaissance simply means learning what is present and in scope. It may involve information already supplied by a system owner, reading documentation and observing the behaviour of permitted accounts. More intrusive discovery or testing requires explicit authorisation. The OWASP information-gathering guidance [2] explains why an incomplete application map can lead to an incomplete assessment.
Where do testers get clues that a website might be insecure?
The most useful question is not “Which hacking tool should I open?” but “Which security rule might fail here, and what observation would support that suspicion?”
| Possible clue | Why it deserves attention | What it does not prove |
|---|---|---|
| One account appears to receive another account’s data | The application may be missing a resource-ownership check | That every record is accessible |
| An error reveals detailed internal paths or configuration | Sensitive diagnostic information may be exposed | That a stranger can take control of the server |
| A scanner flags a missing security header | A hardening control may be absent | That a successful attack is possible in the current circumstances |
| Software inventory shows an older component | A known security advisory may apply | That the installed component is definitely exploitable |
| A login remains recognised after a sign-out in a controlled test | Session invalidation may need review | That all sessions or accounts are affected |
| A form returns unexpected content | Input handling or output encoding may need investigation | That the page necessarily has an exploitable injection vulnerability |
On a narrow screen, swipe horizontally to read all columns.
A clue becomes useful when the tester can explain the expectation , the observation and the limits of the conclusion . For a software-version alert, for instance, the next question is whether the exact installed version and configuration match an applicable advisory. For an access-control clue, the next question is whether the response truly contains another account’s protected data or only harmless shared page content.
Three particularly useful discovery questions are what can the user see , what can the user change , and what should happen when their permission ends . These reveal different classes of problems: private data exposure, unauthorised actions and expired-session handling. A tester documents the expected rule first, then chooses only the least intrusive approved check that can answer it.
One important distinction: seeing an endpoint in a browser or proxy does not mean it is insecure. An endpoint is simply a place where the application accepts a request; its security depends on what it allows and what controls it enforces.
How do testers separate a genuine vulnerability from a false alarm?
Suppose a scanning tool highlights a missing header. That is a finding about an observable response header, but it does not automatically establish an exploitable security flaw or its severity. A tester must interpret it in context.
Use this four-question evidence check:
What rule should hold?
For example, only a report owner should receive that report’s content.
What did we observe?
Record the account role, relevant request, response and outcome using synthetic data.
Can the result be reproduced safely?
Repeat only the necessary approved check and rule out test-account or configuration mistakes.
What conclusion is justified?
Describe the specific control failure, not a dramatic claim about the whole website.
A false positive is an alert that does not represent the claimed issue in the tested context. A false negative is an existing weakness that a tool or test misses. Neither can be eliminated merely by running more tools. A high-severity label from software does not override the need to check relevance and impact.
An evidence ladder: four ways a security check can end
| Result | What the evidence supports | What the tester should write |
|---|---|---|
| No issue | The approved case behaved as expected | “Access denied in this tested case”—not “the whole site is secure” |
| Possible | An unexpected alert or response needs explanation | “Possible issue; confirmation pending” |
| Verified | A reproducible, authorised observation violates a defined security rule | State the affected function, condition and impact supported by evidence |
| Unclear | The tester cannot separate an anomaly from session, cache, configuration or test-data errors | Record what was tried and why no conclusion is justified |
On a narrow screen, swipe horizontally to read all columns.
Quick example:
A publicly accessible school calendar returns
200 OK
: that may be entirely correct. A
200 OK
response that contains only a login page, perhaps after a redirect, is not evidence that private data was exposed. But if a fully documented local lab test shows Brian receiving Amina’s private marks, the ownership rule failed. A version alert about an old software library stays a
lead
until the exact component, applicable advisory and deployment context are checked. No single HTTP status, scanner label or screenshot tells the whole story.
That is why a report should be more precise than “the website has been hacked.” A strong description might read: “In this local test environment, Student B received Student A’s private report, although the documented policy requires denial.” The statement identifies the environment, rule, observation and scope.
Classroom walkthrough: test a fictional student portal
Meet Lakeview Training Portal —an imaginary application prepared for a supervised lesson. It has two made-up students: Amina (account A) and Brian (account B) . Each owns one fake examination report. The instructor has authorised the class to check report access using only these synthetic accounts.
Define the rules
Steps 1–2: establish ownership and write the permitted/denied test matrix.
Lesson: check expected behaviour against observed evidence.
Observe and compare
Steps 3–4: confirm normal access, then check an approved cross-account boundary.
Lesson: check expected behaviour against observed evidence.
Validate and diagnose
Steps 5–6: rule out misleading evidence and identify the missing control.
Lesson: check expected behaviour against observed evidence.
Report and retest
Step 7: document the result and repeat every expected test after correction.
Lesson: check expected behaviour against observed evidence.
Scope sheet for this exercise: The included system is the isolated Lakeview Training Portal. The permitted accounts are Amina, Brian and a signed-out visitor. The permitted activity is reading synthetic report data and checking the pre-agreed access outcomes. Real school websites, personal records, password guessing, destructive tests and unrelated systems are excluded. The instructor will stop testing if unexpected data or functionality appears.
Step 1: Write the security rule before testing
Amina may read Amina’s report. Brian may read Brian’s report. Neither may read the other’s report. A visitor who has not signed in may read neither report.
Step 2: Record the expected outcomes
| Account making request | Requested fictional report | Expected result |
|---|---|---|
| Amina | Amina’s | Allow |
| Brian | Brian’s | Allow |
| Brian | Amina’s | Deny |
| Amina | Brian’s | Deny |
| Signed-out visitor | Either report | Deny |
On a narrow screen, swipe horizontally to read all columns.
These positive tests (legitimate access) and negative tests (access that must fail) matter equally. A fix that blocks everyone is not a satisfactory solution.
Step 3: Observe ordinary behaviour
The instructor signs in to each synthetic account in turn and confirms that each can open its own report. The class notes the user role, requested resource and visible outcome. The purpose is to establish a baseline, not to guess passwords or access unrelated systems.
Step 4: Compare an authorised boundary case
Inside the local lab, the instructor checks the pre-agreed case in which Brian’s account requests Amina’s synthetic report. Two fictional outcomes illustrate how the reasoning changes:
The
content and account ownership
matter here—not merely the HTTP status code. A properly implemented application may return
403 Forbidden
or deliberately use
404 Not Found
; either can be consistent with denying access depending on its design. A
200 OK
response could contain an ordinary login page rather than somebody’s protected report. Look at the actual, approved evidence.
Step 5: Rule out misleading explanations
Check that the accounts are distinct, the reports are correctly assigned, the displayed content is not a cached page from the wrong session, and the instructor has not accidentally granted both students a special teaching role. The observation should be repeatable under documented conditions before being treated as confirmed.
For example, seeing Amina’s name on a shared class notice does not prove that Brian received her private report. Seeing Amina’s synthetic marks inside the protected report response , while signed in as Brian, is a different observation. The instructor verifies which account is active and which record the response actually contains before drawing the conclusion.
Step 6: Explain the likely root cause
In the fictional faulty version, the server checks whether Brian is signed in but fails to check whether Brian owns the particular report . The page may hide other students’ links, but the server still needs to enforce the ownership rule when handling the request. The same rule should apply whether a report is opened in the page, retrieved through an approved API, or downloaded as a file. OWASP’s Authorisation Cheat Sheet [10] recommends deny-by-default and server-side enforcement.
A defensive implementation can be understood with this simplified pseudocode:
This illustrates a principle, not a complete security implementation. Production systems also need appropriate session handling, logging and consistent permission checks across related endpoints.
Step 7: Document and retest the fix
The class writes a report describing the confirmed lab failure, possible harm if the same defect existed in production and a recommended server-side ownership check. After the developer corrects the training app, the class repeats all five cases from the expected-results table. Legitimate access still works; cross-account and signed-out access are denied.
What this exercise proves: the particular access rule works or fails under these synthetic test conditions. It does not establish that every function in the application has been tested or that all other security weaknesses are absent.
Does the same reasoning apply beyond student portals?
Online shop
A customer may read only their own delivery address. In a synthetic check, test whether one account can access another account’s protected address.
Testing question: does the server enforce the account’s authorised role?
Salon booking
Only authorised staff may change another customer’s appointment. Test that ordinary customer roles cannot perform staff-only actions.
Testing question: does the server enforce the account’s authorised role?
On a fictional salon booking system , the rule may be: “Only authorised staff can change another customer’s appointment.” The tester checks that ordinary customer accounts cannot perform that staff-only action. These examples differ in purpose, but both start with a specific permission rule and end with evidence about whether that rule was enforced.
Can a vulnerability scanner find everything?
No. Automated scanning and human security testing solve different parts of the problem.
| Technique | What it is useful for | Its boundary |
|---|---|---|
| Passive scanning | Reviews requests and responses already observed, such as headers or cookies | Cannot fully assess most business rules |
| Active scanning | Sends new test requests to check for particular weakness patterns | Can change application state or cause disruption; needs specific permission |
| Manual verification | Compares behaviour with real account, workflow and permission expectations | Depends on the tester’s knowledge and the test cases chosen |
| Code/component review | Examines source code, dependencies or configuration when access is provided | Needs authorised access and an understanding of the deployed environment |
On a narrow screen, swipe horizontally to read all columns.
The ZAP documentation on active scanning [7] makes two important points: active scans can put systems at risk, and automated checks cannot replace human analysis of application logic. Its passive-scan documentation [7] explains a less intrusive form of inspection. “Passive” does not remove the requirement to follow the agreed assessment rules, and even apparently harmless requests can have unexpected effects on a fragile system.
The proper lesson is not “run every available scanner.” It is “choose a method appropriate to the security question, scope and system.”
A vulnerability assessment commonly aims to identify and prioritise weaknesses across the agreed scope. A penetration test may go further by safely validating potential impact under explicit rules of engagement. Neither term authorises unrestricted activity, and neither method can guarantee that every flaw has been found. NC4’s framework [12] describes their complementary purposes.
Why this matters to a beginner: Suppose a scanner reports five outdated software packages. That is assessment evidence worth checking and prioritising. It is not permission to attempt to exploit them. A controlled demonstration of a specific weakness requires separate, suitable authorisation and a safe method. For our fictional portal, comparing an explicit permission rule with synthetic account behaviour is enough to demonstrate the lesson.
What kinds of website vulnerabilities do testers investigate?
The OWASP Top 10:2025 [4] identifies broad categories of web application security risk. It is an awareness resource, not a complete testing checklist. In the current release, A01 is Broken Access Control, A02 is Security Misconfiguration, A03 is Software Supply Chain Failures, A04 is Cryptographic Failures, A05 is Injection and A07 is Authentication Failures . Earlier editions use different category numbers and names.
| Weakness or risk area | Beginner example | Main defensive idea |
|---|---|---|
| Broken access control | One student sees another student’s private report | Check every relevant action and record on the server |
| Security misconfiguration | Debug information is exposed on a public-facing page | Review deployment settings and remove unsafe defaults |
| Injection | Untrusted input is combined unsafely with a database query | Use parameterised queries and safe APIs |
| Authentication or session weakness | A session remains usable when it should no longer be valid | Apply appropriate login and session controls |
| Cross-site scripting (XSS) | User-supplied text is displayed in a way that executes unintended browser script | Apply context-appropriate output encoding and safe browser APIs |
| Software supply-chain failure | A compromised build component reaches the released application | Inventory components and protect the build and update process |
| Cryptographic failure | Sensitive information is stored without suitable protection | Use established cryptographic protections correctly |
On a narrow screen, swipe horizontally to read all columns.
Do not use this table to label every discovered issue as “critical.” Severity depends on the affected information, access conditions, realistic impact and the surrounding system. The same type of flaw can have very different consequences in two applications.
What should a useful vulnerability report contain?
A security report is valuable when somebody responsible for the website can act on it. Kenya’s National Computer and Cybercrimes Co-ordination Committee (NC4) [12] emphasises authorisation, evidence-based findings, prioritised remediation and retesting.
Here is a concise example from the fictional Lakeview classroom exercise:
| Report field | Example entry |
|---|---|
| Title | Missing report-ownership check |
| Scope | Local training portal; approved synthetic accounts |
| Expected | Brian cannot read Amina’s report |
| Observed | Brian’s test session received Amina’s synthetic report |
| Evidence | Redacted lab screenshot, account roles and test-case record |
| Likely cause | Server checks login but not resource ownership |
| Impact | In a real deployment, unauthorised disclosure of private results |
| Recommended fix | Apply server-side ownership checks to report retrieval and related operations |
| Retest | All five authorised access cases pass after correction |
On a narrow screen, swipe horizontally to read all columns.
A useful report also identifies who owns the fix and how it will be verified. Keep proof minimal: the affected function, the expected rule, the specific observation and enough synthetic or redacted evidence to reproduce it. Do not collect real private records or publish account secrets as “proof.”
Which finding should be fixed first?
A report should help the owner prioritise, not just collect warnings. Consider sensitivity of the exposed data , who can reach the affected function , how reliably the issue can be reproduced , realistic impact , and existing protections . In the fictional school portal, a confirmed ability to retrieve another student’s private report deserves prompt attention. A missing optional hardening header or an unverified version alert requires a different assessment; the correct priority cannot be assigned from the scanner label alone. NC4’s framework likewise emphasises real risk, exposure and exploitability rather than raw finding counts.
A successful retest means the tested issue was corrected under tested conditions . It is not a certificate that the entire website is invulnerable.
How can a beginner practise safely?
Start with an exercise that requires reasoning before tools . Draw a small website with three roles—visitor, student and administrator. Write down what each role may read or change. Then design one allowed and one denied test for each sensitive function. If you cannot explain the expected permission, a scanner will not fix that gap in understanding.
Next, use an intentionally vulnerable teaching environment prepared for learning. OWASP Juice Shop [8] is a deliberately insecure training application; it should be used only in its permitted learning deployment or an isolated local setup you control. A browser’s developer tools can help you understand your own lab requests and responses. OWASP ZAP can help learners inspect traffic and understand alerts within a properly authorised scope.
Try this paper-based five-minute exercise: a student can view their own marks, edit their contact telephone number, and download fee receipts. For each function, write a rule saying whose records may be accessed, whether a signed-out visitor may use the function, and what evidence would demonstrate denial. This gives you an assessment plan before you install anything.
Check your reasoning: (1) Each student may read only their own marks and receipts. (2) Only the signed-in account may change its own contact number, unless a separate authorised staff workflow applies. (3) A signed-out visitor is denied these private operations. (4) A convincing test record shows the account role, the synthetic resource, the expected outcome and the observed result. If the rule is unclear, ask the system owner to define it before testing.
If you want a collection of projects with deliverables, NIT’s Cybersecurity Projects for Beginners covers that separate learning objective. This article focuses on how the discovery and evidence process works .
Is ethical website security testing legal in Kenya?
Permission and scope are essential. Kenya’s Computer Misuse and Cybercrimes Act, Cap. 79C [13] , including Section 14 on unauthorised access, provides relevant legal context; Because laws and court interpretations can change, check the current applicable legislation before drawing conclusions about a particular proposed test. The NC4 vulnerability-assessment framework [12] specifically calls for written authorisation, agreed objectives, defined scope and rules of engagement.
For a beginner, the practical boundary is clear: a website being publicly reachable does not give you permission to probe it . Use a controlled training application or an assessment expressly approved by someone authorised to grant that permission. Know which accounts, systems and methods are included. Stop if your actions may expose real records or affect an excluded service.
If you unexpectedly notice what seems to be a serious weakness, do not keep exploring other people’s information. Preserve only minimal safe details and report privately through the website owner’s designated security channel or published disclosure policy. OWASP’s Vulnerability Disclosure guidance [11] explains how to report clearly while respecting privacy. Specific legal questions should be resolved against the current law and the facts of the proposed activity.
Common mistakes that lead to poor findings
Mistake: treating a scanner alert as a confirmed exploit. Better: state exactly what was observed, check applicability, and qualify any unverified claim.
Mistake: checking the login page but not the resource permission. Better: document both authentication and authorisation rules. A signed-in account may still be barred from a particular action.
Mistake: making a fix that blocks legitimate users. Better: retest both permitted and prohibited actions, as the Lakeview matrix demonstrates.
Mistake: focusing only on the visible page. Better: understand the server, its APIs, sessions, configuration and other approved components.
Mistake: saving unnecessary private information. Better: use synthetic records, redact evidence and share reports only with the responsible team.
Frequently asked questions
How do hackers know which websites might have vulnerabilities?
They examine the systems and functionality within their authorised scope, look for known risk patterns and investigate unusual security behaviour. A possible clue does not establish a real weakness until its meaning is checked.
Can a normal-looking website still be insecure?
Yes. The problem may be in server-side permissions or application logic that is invisible to an ordinary visitor. A polished interface is not a substitute for tested security controls.
Does HTTPS mean a website is secure?
No. HTTPS helps protect data in transit, but it does not prove that accounts have the right permissions or that application code and settings are free of weaknesses.
Can a scanner tell me whether a website is safe?
Not conclusively. Scanners check particular patterns. They can miss business-logic problems, and alerts require interpretation. An assessment’s conclusion must reflect its scope and evidence.
Must a beginner learn programming first?
Not before learning the basic method. Start with HTTP, login sessions, roles and access rules. Programming becomes increasingly helpful when reading code, building test applications and understanding fixes.
Can I use someone else’s school or business website for practice?
Not without valid authorisation for the specific assessment. Use an isolated lab or a training environment that permits those exercises.
What happens after a vulnerability is reported?
The responsible team evaluates the finding, addresses its root cause and arranges an appropriate retest. The tester records the retest result and any remaining limitations.
The lesson to remember
A responsible tester does not begin by trying random attacks. They begin with an expectation: “Brian must not be able to read Amina’s report.” They gather authorised evidence, decide whether that expectation failed, explain the risk and check the correction. This disciplined approach applies to online shops, booking systems, student portals and many other web applications.
For details about the NIT study pathway, see the official Cybersecurity Course in Kenya [15] .
To compare the career roles rather than the website-testing method, see Cybersecurity Analyst vs Ethical Hacker .
Learn to test responsibly
Learn cybersecurity at Newton Institute of Technology
At Newton Institute of Technology in Migori Town, Kenya, students explore computer systems, networking, Linux, authorised testing, security monitoring and technical reporting through structured learning.
The published cybersecurity pathway includes six months of institutional training followed by three months of compulsory industrial attachment. Confirm current study arrangements with Admissions.
Institutional training 6 months
Industrial attachment 3 months
Location Migori Town, Kenya
Call / WhatsApp +254 713 584 858
Sources and references
- OWASP Web Security Testing Guide — stable web application testing chapters . Technical testing categories; current hosted stable guide.
- OWASP Web Security Testing Guide — information gathering, latest development edition . Attack-surface discovery and scope.
- OWASP Web Security Testing Guide — testing framework, latest development edition . Flexible testing activity model.
- OWASP Top 10:2025 . Current published category list and awareness framework.
- OWASP Top 10:2025 — Broken Access Control . Server-side access enforcement guidance.
- MDN — Overview of HTTP . Requests and responses.
- ZAP — Active Scan and Passive Scan . Scanning methods and limitations.
- OWASP Juice Shop . Deliberately vulnerable training application.
- OWASP Application Security Verification Standard 5.0.0 . Stable application-control verification requirements (released 30 May 2025).
- OWASP Authorisation Cheat Sheet . Deny-by-default and trusted-side access checks.
- OWASP Vulnerability Disclosure Cheat Sheet . Private reporting and evidence handling.
- NC4 Kenya — Vulnerability Assessment Framework . Written authorisation, scope, reporting, remediation and retesting.
- Kenya Law — Computer Misuse and Cybercrimes Act, Cap. 79C, consolidated 4 November 2025 ; Parliament of Kenya — Amendment Act No. 17 of 2025 .
-
IETF RFC 6761 — Special-Use Domain Names
. Reserved
.exampledocumentation names. - Newton Institute of Technology — Cybersecurity Course in Kenya and Admissions . Institutional programme and contact information.
Sources reviewed 12 November 2026 · Editorial responsibility: Newton Institute of Technology Editorial Team.