Zum Inhalt springen

English:Cyber security, validation and authentication - Computing Year 10

Aus MOOCsWiki Staging
aiMOOC-Siegel aiMOOC

Cyber security, validation and authentication - Computing Year 10

QR-Code



Introduction

Historical desktop system illustrating a device whose software and accounts need protection
Gustavb’s system illustration gives hardware context. It is not evidence of infection,a security certification or a diagram of the club’s account system;the defensive cases and data below are fictional.

Distinguish cyber threats, vulnerabilities and impacts; design the required age 11–18 club-registration rules; and separate validation, authentication and authorisation. Run a complete synthetic validator and explain the trusted controls a real service would additionally need.


Connect threats vulnerabilities controls and reporting


Distinguish a threat, vulnerability and impact

A threat is a potential cause of harm; a vulnerability is a weakness that may be exploited; an impact is the resulting harm to information, service or people. An unexpected message is not automatically proof that an account has been compromised. A risk assessment connects a plausible threat, an exposed weakness, likely consequences and proportionate controls rather than simply listing alarming words.

For the fictional learning club, consider account misuse, loss of submitted work, unauthorised access and unnecessary collection of personal information. The course uses synthetic examples only. It does not ask learners to inspect real pupil records, attack a login page, install malware or bypass school protections.

Scenario Threat or weakness Possible impact Defensive response
A message imitates a trusted club invitation Phishing/social engineering exploits misplaced trust A learner could reveal credentials or follow a malicious route Verify through an established route, avoid the suspicious link and report it
A device runs unsupported software Unpatched or unsupported software is a vulnerability Known weaknesses may allow compromise or disruption Use approved supported versions and managed updates
The same weak password is reused Credential weakness makes account misuse easier More than one account may be exposed after one compromise Use approved unique credentials/password-manager or passkey arrangements and suitable MFA
A downloaded attachment runs harmful code Malware is malicious software, not every ordinary attachment Files or availability may be harmed Use approved software, protective tools and reporting; do not execute samples
A service trusts a user-supplied staff flag Missing server-side authorisation is a design weakness Internal records may be exposed Obtain trusted identity/permissions server-side and check each request
Only an always-connected working copy exists Recovery design shares a failure exposure Deletion or ransomware can remove accessible work Keep policy-approved protected recovery copies and test restoration

Controls reduce particular risks; none of these labels guarantees that every attack is impossible. A scanner complements secure design and maintenance rather than replacing them. A backup supports recovery rather than preventing every incident. An encrypted connection protects specified communications but does not establish that a request is authorised or a web page is truthful.


Identify vulnerabilities throughout development

During design, review what data are actually necessary and which actions each role requires. During implementation, validate untrusted input and use well-maintained security components. During testing, try normal, boundary, invalid and unauthorised cases in an isolated synthetic environment. During use, maintain updates, review permitted access, monitor proportionately and follow the agreed incident route.

An authorised review can inspect a design, configuration or supplied code and compare it with documented requirements. Do not infer permission to scan or probe a live network merely because "finding vulnerabilities" is part of computing. State the test scope, approved environment, expected outcome and who will receive a report. Evidence should name the observation without including passwords, tokens or private records.


Report concerns calmly and precisely

If a learner sees an unexpected login request or suspicious message, stop interacting with that route and use the school’s known reporting process or a trusted adult. Record the relevant time and non-sensitive symptom if instructed. Do not forward active suspicious links to classmates, publicly post credentials or attempt retaliation. If real credentials may have been entered, report promptly and use the official recovery route with appropriate support.

CodeAI / Code.org: Cybersecurity & Crime. Identify a threat, an exploitable weakness and a defensive control, then compare them with the synthetic club table. The written lesson and native activities work without sound or the player. Original: CodeAI, The Internet: Cybersecurity & Crime. The written explanations and native tasks work without sound or the external player. For the core 55-minute sequence, use five minutes for retrieval, ten for defensive concepts, twelve for the worked registration model, ten for guided rules, thirteen for the changed-input transfer and five for evidence/reflection. Additional tasks extend the work. Year 10 sequencing is editorial within the mapped GCSE/KS 4 pathway.



Design validation identity and scoped access rules


Give validation a precise contract

Validation checks whether a submitted value meets declared rules. It can check presence, type, length, format, range or consistency with other values. It cannot by itself prove that the claim is true. A submitted age 14 can pass a range check even if the person is not 14. The course’s fictional 11–18 range is an exercise requirement, not a claim that a real club must collect ages or that it resolves any real consent or safeguarding requirement.

For the required registration design, accept a claimed age from 11 through 18 inclusive and an available fictional login identifier. Do not collect date of birth, home address, photograph, school identifier or free-form personal details just because a form could contain them. In this teaching prototype, the age is used transiently for the range check and is not returned in the accepted summary; even the retained identifier/range flag would require a justified purpose and retention policy in a real service.

Field or condition Declared teaching rule What it does not prove
Login identifier After trimming/lowercasing,3–20 ASCII letters, digits, underscore or hyphen It is not a real name or proof of identity
Login uniqueness Canonical identifier is not in the supplied synthetic set A local set snapshot does not guarantee race-free real account creation
Claimed age One/twoASCII decimal digits after trimming; integer 11–18 It does not establish the person’s actual age
Missing/invalid input Reject without storing a partial account Rejection does not prove a malicious intent
Extra personal fields Not requested or stored by this prototype A minimal prototype is not a complete legal/privacy assessment

The narrow ASCII identifier contract makes this small exercise easy to test; it is not a general recommendation to reject people’s names or all Unicode text. Different fields need different rules. A denylist of suspicious punctuation is not a substitute for a defined contract, parameterised database operations, appropriate output encoding and separate permission checks in a real application.


Separate authentication and authorisation

Authentication establishes a claimed identity through a suitable trusted mechanism. Authorisation decides whether that identity may perform a particular action on a particular resource. A valid field format and a signed-in session solve different problems. Neither means every user may read every record.

Synthetic request Required decision Reason
Visitor opens public club information May be public under the stated policy Some resources can be intentionally available without login
Authenticated member reads their own permitted application Allow only within the defined member scope Identity, ownership and permission must match
Authenticated member asks for another member’s private review Deny Signing in does not grant cross-user access
Staff member from a different fictional club asks for this club’s records Deny without the specific scope permission A role label alone is not sufficient across organisations
Assigned staff requests the permitted review within their scope Allow only after trusted permission checks Check the current action and resource on the server
Client sends a text field saying staff=true Do not treat that field as trusted authority A user can control submitted form fields

Use an established authentication framework or approved identity provider rather than inventing a classroom password service. A real design needs secure transport, safe credential storage/comparison or suitable passkey arrangements, protected sessions, recovery, appropriate multi-factor protection and controlled attempt handling. Do not store plaintext passwords or secret tokens in course source, logs, QR codes or URLs. The validation program below intentionally implements none of those account/session operations.

Authentication-error messages should avoid unnecessarily revealing account existence or security details. The prototype prints only numbered synthetic-case outcomes; it is not a complete registration user interface. Real account uniqueness must also be enforced atomically by the authoritative storage/service, not trusted to a client-side check or an old local set.


Explain client and server responsibilities

A browser can give helpful immediate feedback, but users can bypass or alter client-side checks. The authoritative service must enforce its own validation and permission rules. Obtain identity and access scope from trusted server-side context, not from an editable hidden field. Deny access when the required permission is absent and check each relevant request, including access to supposedly hidden records.



Test the fictional registration model and its limits


Run a complete synthetic validation prototype

The following original Python 3 program exercises only the declared login/claimed-age validation rules against two invented existing identifiers. It has no network, file, account or database writes; creates no real account; and contains no password. Existing identifiers are canonical lowercase strings in a supplied set. Every accepted result says only that the claim met the stated range rule, not that identity or age has been verified.

ALLOWED_LOGIN = "abcdefghijklmnopqrstuvwxyz0123456789_-"

def canonical_login(value):
    if type(value) is not str:
        raise ValueError("Registration input not accepted")
    login = value.strip().lower()
    if not 3 <= len(login) <= 20:
        raise ValueError("Registration input not accepted")
    if any(character not in ALLOWED_LOGIN for character in login):
        raise ValueError("Registration input not accepted")
    return login

def validate_registration(login_text, age_text, existing_logins):
    if type(existing_logins) is not set:
        raise ValueError("Invalid teaching fixture")
    for item in existing_logins:
        if canonical_login(item) != item:
            raise ValueError("Invalid teaching fixture")
    login = canonical_login(login_text)
    if type(age_text) is not str:
        raise ValueError("Registration input not accepted")
    age_digits = age_text.strip()
    if not 1 <= len(age_digits) <= 2:
        raise ValueError("Registration input not accepted")
    if any(character not in "0123456789" for character in age_digits):
        raise ValueError("Registration input not accepted")
    age = int(age_digits)
    if age not in range(11, 19) or login in existing_logins:
        raise ValueError("Registration input not accepted")
    return {"login": login, "claimed_age_in_range": True}

if __name__ == "__main__":
    existing = {"robin1", "fox2"}
    cases = [("newbird", "11"), ("newbird", "18"),
             ("newbird", "7"), ("newbird", "25"),
             ("newbird", ""), ("ROBIN1", "14"),
             ("  NEWBIRD  ", " 14 "), ("new bird", "14")]
    for number, pair in enumerate(cases, start=1):
        try:
            result = validate_registration(pair[0], pair[1], existing)
            print("Case", number, "accepted", result)
        except ValueError:
            print("Case", number, "not accepted")

Expected results: cases 1 and 2 accept the boundaries 11 and 18; cases 3 and 4 reject 7 and 25; case 5 rejects missing age; case 6 rejects the canonical collision ROBIN 1; case 7 accepts the stripped/lowercased newbird identifier and whitespace-trimmed 14; case 8 rejects the internal space in new bird. No accepted summary contains the raw claimed age. The original fixture set remains unchanged. Each numbered case is an independent test against that same unchanged fixture. Repeated acceptance of newbird does not reserve or create an account; a real registration service would need an atomic write and uniqueness enforcement.


Choose boundary and invalid tests deliberately

Test Expected result Purpose
New identifier with age 11 or 18 Accepted range claim Both inclusive boundaries
Age 10 or 19 Rejected Immediate values outside the allowed range
Age 7,25, blank,14.5 or+14 Rejected by this exact format/range contract Distinguish format and value checks
Boolean, number or null instead of age text Rejected Enforce the declared input type
ROBIN 1 with valid age Rejected as the existing canonical identifier Case-insensitive uniqueness in the fixture
New identifier length 2 or 21 Rejected Login length boundaries
Whitespace around a valid identifier/age Accepted after the declared trimming Normalisation is explicit
Two simultaneous real registrations for one identifier Not implemented by this prototype Requires authoritative atomic uniqueness enforcement

For a wrong first attempt that accepts age 19, inspect the upper boundary before changing the test. For a case-collision defect, check whether both the incoming identifier and the fixture use the same declared canonical convention. Do not silently change an unrelated account or invent a second record to avoid a conflict. Validation findings should be repaired together and the complete test set rerun.


Build the complete required fictional service design

Combine the validation rules with a separate authentication plan and a server-side permission table. Explain what is stored, why it is needed, who may access it and when it is removed. Use synthetic data in every example. Staff-only review data must remain outside a member’s permitted scope even after that member signs in successfully.

Write a threat-control-evidence table. For example, a forged staff field is addressed by trusting only server-established identity and scoped permissions; the distinguishing test is a synthetic ordinary-member request that includes the forged field but is still denied. That is a design-test specification here, not a report that a real account service has been tested. A phishing concern needs verification/reporting and suitable authentication support, not just an age-range rule.

If a security check or protective limit prevents an operation, investigate the actual prerequisite and use the official route. Do not remove rate limits, turn off access checks or copy another person’s session to make a demonstration appear successful. Availability, privacy and controlled recovery belong in the design alongside convenience.


Evaluate the evidence honestly

Submit the complete threat-control table, all validation rules, the role/resource permission decisions and a separate authentication/session plan. If you ran the supplied program, include full source and expected/observed synthetic tests. Explain that its accepted values are range/format claims only and that no real account, authentication or authorisation service is implemented.

A screenshot of accepted input does not prove secure deployment, actual age, lawful data collection or practical security competence. A teacher can review the bounded prototype and reasoning in an approved environment. Paper predictions remain useful but should be labelled unexecuted. Report one remaining risk and a proportionate next review without accessing real pupils’ data or attacking a live system.



Interactive Tasks


Quiz: Test Your Knowledge

What does validation establish by itself? (A submitted value meets declared input rules) (!The submitted age is necessarily true) (!The user owns every referenced record) (!The service has no security risks)



Which claimed ages meet the stated inclusive range? (11 through 18) (!10 through 19) (!Only 14) (!Every positive integer)



What is authentication intended to establish? (A claimed identity through a suitable trusted mechanism) (!That any entered age is true by format alone) (!That every signed-in user may read staff records) (!That a filename is short)



What is authorisation intended to decide? (Whether the identity may perform the requested action on that resource) (!Whether a field contains decimal digits only) (!Whether every visitor is a staff member) (!Whether all network traffic must stop)



Why is a user-submitted staff flag not trusted permission? (The submitter can control that field; authority must come from trusted server context) (!Every hidden field is protected from changes by definition) (!A range check automatically signs every field) (!A successful login grants all roles)



Which weakness is illustrated by unsupported unpatched software? (A vulnerability that a suitable threat may exploit) (!Proof that every incoming message is malware) (!An independent tested backup) (!A necessary condition for all teaching software)



What does the prototype do with the valid uppercase identifier ROBIN 1? (Normalises it and rejects the collision with the synthetic existing login) (!Creates an extra staff account automatically) (!Treats uppercase letters as proof of identity) (!Publishes an account to the school server)



Why are both browser and authoritative server validation discussed? (Client feedback is useful, but the service must enforce rules independently) (!A browser check makes all server checks unnecessary) (!A hidden input cannot be changed by a user) (!Validation and encryption are identical)



What is the appropriate response to a suspicious school-login message? (Use a known reporting/verification route and avoid interacting with the suspicious request) (!Forward active credentials to classmates) (!Test the real account by repeatedly bypassing limits) (!Disable the school’s access checks)



What does an accepted result from the supplied program prove? (Only the synthetic identifier and claimed-age rules passed under the declared fixture) (!A real account was securely created) (!The person’s actual age was verified) (!Staff-only access was successfully authorised)





Memory Game

Threat A potential cause of harm to the service or people
Vulnerability A weakness that may be exploited
Validation Checking submitted values against declared rules
Authentication Establishing a claimed identity through a trusted mechanism
Authorisation Deciding permitted actions on specified resources
Least privilege Granting only the access needed for the defined role and context





Drag and Drop

Check a claimed age range Validate presence, format and 11–18 value without claiming truth
Establish identity Use the approved authentication mechanism and protected session
Restrict staff-only information Enforce current server-side permission and scope checks
Find a canonical collision Apply the same identifier convention before checking the synthetic fixture
Handle a suspicious invitation Avoid its interaction route and report through an established channel





Crossword Puzzle

THREAT What is a potential cause of harm?
VULNERABILITY What is a weakness that may be exploited?
VALIDATION What checks input against declared rules?
AUTHENTICATION What establishes a claimed identity?
AUTHORISATION What decides permitted actions on resources?
PHISHING What deceptive approach may imitate a trusted message?





LearningApps

Optional extra practice. Choose an appropriate activity with your teacher. If the external collection is unavailable, use the native activities and independent tasks in this course.


Cloze Text

Complete the explanation.
Validation checks declared

, not necessarily the truth of a claim. The fictional age range is 11 to

. Authentication establishes a claimed

. Authorisation checks permitted

. A user-supplied staff field is not trusted

. The same canonical identifier must be used for a uniqueness

. The prototype creates no real

. Suspicious requests should be reported through an established

.



Open Tasks


Easy

  1. Distinguish three security concepts: Give separate examples of validation, authentication and authorisation.
  2. Classify a threat and weakness: Explain phishing, unsupported software and one likely impact without claiming an incident occurred.
  3. Write the range rules: Explain presence, type, format and inclusive 11–18 bounds.
  4. Explain minimum data collection: Identify fields the fictional exercise does not need and why a range claim is not proven age.


Standard

  1. Complete the required club design: Provide input rules, a separate secure sign-in plan and scoped staff-only permissions using synthetic data.
  2. Test the complete validator: Record both boundaries, immediate out-of-range cases, missing/invalid formats and canonical collision.
  3. Create a threat-control table: Tie each control to a weakness, expected protection and distinguishing safe test.
  4. Explain client and server checks: Show why editable form fields cannot establish a role or replace authoritative enforcement.


Advanced

  1. Evaluate a uniqueness race: Explain why the local snapshot set cannot guarantee atomic real registration.
  2. Design an unauthorised-request test: Specify how a synthetic ordinary member remains denied even with a forged staff field.
  3. Evaluate authentication completeness: List framework/session/recovery/attempt-control needs omitted from this validation-only prototype.
  4. Defend the security portfolio: Combine rules, roles, controls, actual synthetic test evidence and honest limitations without probing a live system.



Learning Check

  1. Required club-registration transfer: Design rules accepting claimed ages 11–18 with minimal data.
  2. Identity and permissions: Distinguish the three core checks.
  3. Boundaries and collisions: Explain the expected eight-case demonstration.
  4. Threat-control reasoning: Connect specific weaknesses and defences.
  5. Real-service omissions: Evaluate what the program does not implement.
  6. Evidence and reporting: Explain a defensible final submission.


Worked checks and assessment guidance

  1. Require a present appropriately typed/formed age claim within 11–18 inclusive and an available canonical login identifier. Do not collect date of birth, address, photo or school identity without a separate necessary purpose. The prototype returns no raw age. Passing a range check is not proof of actual age or a real safeguarding/privacy assessment.
  2. Validation tests input rules; authentication establishes a claimed identity; authorisation checks the requested action and resource in its current scope. A signed-in member still cannot read another member’s private review or staff-only information. Trusted server-established context, not an editable staff flag, must supply authority.
  3. Cases 1/2 accept 11 and 18;3/4 reject 7 and 25;5 rejects blank age;6 normalises ROBIN 1 and rejects the existing robin 1 collision;7 accepts trimmed/lowercased newbird with 14;8 rejects the internal space. The synthetic fixture is unchanged and no account is written.
  4. Phishing exploits trust and needs verification/reporting plus suitable authentication support; unsupported software needs approved maintenance; missing permission checks need server-side action/resource enforcement. Backups support recovery rather than preventing every incident, and scanners do not replace secure design. Tests need an authorised synthetic scope.
  5. The code performs only bounded format/range/fixture checks. It does not verify age, authenticate a person, protect sessions, store credentials, enforce atomic database uniqueness or grant permissions. A real design needs trusted components, secure transport, appropriate credential/passkey and MFA/recovery arrangements, current scoped access checks and suitable limits.
  6. Submit threat-control reasoning, field rules, a separate sign-in/session plan, role/resource decisions and expected/observed synthetic program tests if executed. Label paper predictions separately. Use the established reporting route for suspicious requests; never publish secrets, attack a live service or remove protections to make a test pass. No security certification or practical competence follows from a quiz alone.


Learning evidence

Keep the required club specification, minimal-data rules, threat-control table, separate authentication plan and current action/resource permission decisions. Add complete validator source and actual synthetic valid/invalid/collision results if executed. State the absence of real account/authentication/session/atomic-storage operations, what each check proves, and one remaining risk without exposing real identities or secrets.


OER and Wikipedia

DfE GCSE Computer Science subject content and the mapped KS 4 safety objective supply the baseline; Year 10 allocation is editorial. Primary development guidance: OWASP Input Validation, OWASP Authentication and OWASP Authorization. Original scenarios, rules, prototype and feedback are bounded learning material, not a production security service. Reviewed 14 November 2026.

Personal computer, exploded.svg, Gustavb, CC BY 2.5. Unchanged original; caption and learning activities are original.

https://www.youtube.com/watch?v=AuYNXgO_f3Y — CodeAI / Code.org: The Internet: Cybersecurity & Crime; unchanged original publisher embed.


Linked learning areas


aiMOOC Projects



Schulfach+




aiMOOCs



aiMOOC Projekte









MOOCwiki · Deutsch

Nach dem Lernen ist vor dem Lernen

Entdecke direkt den nächsten Lernkurs. Weitere Inhalte erscheinen, wenn Du weiter nach unten scrollst.

Zur MOOCwiki-Hauptseite

Mediathek

Suche verfeinern

Dein Lernplan bestimmt, was oben steht. Alle anderen Inhalte bleiben erreichbar. Seitenaufrufe beeinflussen die Auswahl nicht.

Inhalte werden geladen ...

Mediathek wird aus dem Wiki geladen ...