GH-500 domain - 18% of the exam

Security operations: best practices, prioritization, and remediation

Security operations: best practices, prioritization, and remediation is 18% of the GH-500 exam. These are the objectives it covers, each with practice questions, with every answer explained.

The domain in numbers

55
Practice questions
5
Objectives
33
Medium
22
Hard

Where people go wrong

  • Giving the CVE a job it does not have

    The wrong answers give the CVE jobs that belong elsewhere. A CVE names one disclosed vulnerability; it is not a category shared across products, and it is CVSS that rates severity. The CWE classifies the type of weakness, which is what lets a team hunt the same flaw in first-party code with CodeQL queries mapped to it. Dependabot raises an alert from a GitHub-reviewed advisory with affected version ranges and a GHSA identifier, whether or not a CVE exists and whatever its severity.

    See it in a sample question
  • Expecting a security configuration or branch protection to gate by severity

    The wrong answers reach for a control that enables a feature or requires a check and assume it also blocks merges by alert severity. Branch protection has to be set up repository by repository and cannot tell severities apart. A security configuration enables and standardises features but does not itself block pull requests. Only an organisation ruleset with a code scanning merge protection rule and a severity threshold gates merges, and it also covers repositories created later.

    See it in a sample question
  • Treating push protection and alerting as one decision

    The wrong answers treat push protection and secret scanning alerting as one switch. A bypass does not strip the secret, suppress later scans or cancel the alert: the commit is accepted as written, the bypass actor and reason are recorded, and secret scanning raises an alert. Coverage is also per pattern. A partner key with push protection active blocks the push, while a token matching a published custom pattern without push protection turned on passes and is caught as an alert after the commit is accepted.

    See it in a sample question
  • Setting the security manager role too high or too low

    The wrong answers swap the security manager role for the maintain role, organisation owner, or a per-repository custom role, or claim it needs write access or an owner to apply a configuration. The role gives read access to every repository, including ones created later, plus viewing and dismissing alerts across code scanning, secret scanning and Dependabot, and managing security configurations. It withholds write access, deletion, merge-protection changes and billing.

    See it in a sample question
  • Using paths or registries to choose which queries run

    The wrong answers borrow a setting meant for something else to shape the query set. The paths input and paths-ignore filter source files, not queries, so they can neither drop one rule nor silence the defaults. The registries section only supplies authentication for private package registries, and a pack's version has no bearing on the default suite. A published pack goes in the packs input, a .qls suite drops one query with an exclude filter on its id, and disable-default-queries: true turns the built-in suite off.

    See it in a sample question

Objectives in this domain

What to study

The official documents this domain's practice questions cite most.

Sample questions from this domain

Free sampleSecurity operations: best practices, prioritization, and remediationmedium

A security engineer is triaging a Dependabot alert and wants to understand the weakness category behind the vulnerability so the team can search for the same coding mistake elsewhere in their own first-party code. The GitHub Advisory Database entry lists a CVE identifier, a CWE, and a CVSS score. Which of these is designed to classify the underlying type of software weakness rather than to identify a specific reported instance or rate its severity?

  • AThe CVE identifier, because it groups together every vulnerability that shares the same root cause across all affected products.
  • BThe CVSS score, because its base, temporal, and environmental metrics together decompose the flaw into the weakness category that produced it.
  • CThe CVE identifier, because each CVE is issued per weakness type so that one CVE maps to exactly one CWE category.
  • DThe CWE, because it names the general class of software weakness, such as improper input neutralisation, that the specific vulnerability is an instance of. Correct
Distinguish CWE as the weakness-type classification from CVE as a specific vulnerability identifier and CVSS as a severity rating. CWE is the Common Weakness Enumeration, a catalogue of weakness categories such as improper input neutralisation or use of hard-coded credentials. It abstracts the kind of mistake so engineers can find recurrences of the same pattern. A CVE identifies one specific publicly disclosed vulnerability in a product, and CVSS provides a severity score from exploitability and impact metrics. Only CWE classifies the underlying type of weakness, which is what supports searching first-party code for the same flaw.

Why A is wrong: This is tempting because a CVE is the most prominent identifier on the advisory, but a CVE names one specific publicly disclosed vulnerability in a particular product, not a reusable category of weakness shared across products.

Why B is wrong: CVSS base metrics describe exploitability and impact characteristics to produce a severity number; they rate how serious a flaw is and never classify the type of weakness behind it.

Why C is wrong: A CVE is issued per disclosed vulnerability, not per weakness type, and a single advisory can map a CVE to one or more CWEs, so the CVE is not the categorising framework here.

Why D is correct: CWE (Common Weakness Enumeration) is a hierarchy of weakness types, so it gives the engineer a category like SQL injection or path traversal that they can use to hunt for the same flaw pattern across their own code.

Free sampleSecurity operations: best practices, prioritization, and remediationhard

A platform team wants every repository in their organisation to block pull request merges only when code scanning reports a new alert of high or critical severity, while alerts of lower severity should appear but not block the merge. They want this enforced consistently without each repository owner configuring it manually. Which configuration achieves this at organisation scale?

  • AAdd a branch protection rule in each repository that requires the CodeQL status check to pass, since a failing check from any severity alert will block the merge until it is resolved.
  • BCreate an organisation ruleset targeting the default branches that adds a code scanning merge protection requirement, setting the alert security severity threshold so that only high and critical alerts cause a merge to be blocked. Correct
  • CApply a security configuration to all repositories that enables code scanning, because enabling the feature organisation-wide automatically blocks merges on any high or critical alert by default.
  • DSet the organisation default code scanning alert severity to high so that GitHub suppresses lower-severity alerts entirely and blocks merges whenever a remaining alert is introduced.
Enforce severity-based code scanning merge protection across an organisation using a ruleset with an alert security severity threshold rather than per-repository checks. Code scanning merge protection is expressed as a rule inside a ruleset, and a ruleset can target the default branches of many repositories at organisation scope. The rule carries an alert security severity threshold, so setting it to high means only high and critical alerts block a merge while lower-severity alerts stay visible and non-blocking. Branch protection per repository cannot filter by severity, security configurations only enable features, and default severity settings never create a merge gate.

Why A is wrong: Per-repository branch protection that only requires the analysis check to pass cannot distinguish severities and must be set up repository by repository, which violates the requirement for consistent organisation-wide enforcement. It also tends to block on any failing result rather than only on high or critical alerts.

Why B is correct: An organisation ruleset can target branches across many repositories and include a code scanning merge protection rule whose alert threshold is set to the chosen security severity. Setting that threshold to high or critical blocks merges only on those severities while lower-severity alerts remain visible but non-blocking, delivering consistent enforcement without per-repository setup.

Why C is wrong: A security configuration can enable and standardise features across repositories, but enabling code scanning does not by itself impose any merge-blocking behaviour, let alone a severity threshold. Merge protection on alerts is enforced through rulesets, so this conflates feature enablement with merge gating.

Why D is wrong: Changing a default severity does not create a merge gate, and the requirement was that lower-severity alerts still appear rather than being suppressed. This option both removes wanted visibility and assumes a blocking behaviour that severity settings alone never provide.

Free sampleSecurity operations: best practices, prioritization, and remediationmedium

A security lead is explaining to leadership why push protection is a prevention control rather than just another detector. A developer is blocked when pushing a recognised cloud provider key, but in the organisation anyone may bypass the block, and this developer bypasses it with a stated reason and completes the push. The lead is asked what protection the organisation actually retained in this specific case. Which statement most accurately describes the outcome once the bypass is used?

  • AThe secret never reaches the remote, because a recorded bypass downgrades the push to a warning that strips the credential from the commit before it is accepted.
  • BThe push is allowed but secret scanning is suppressed for that file going forward, because the recorded bypass reason is treated as an acknowledged false positive for future scans.
  • CThe secret is committed to the remote, but the bypass is recorded and a secret scanning alert is raised, so the organisation retains an audit trail and detection even though prevention was overridden. Correct
  • DThe push is allowed and no secret scanning alert is created, because push protection and secret scanning share one decision and a bypass clears both at once.
Recognise that bypassing push protection commits the secret but still records the bypass and raises a secret scanning alert, preserving detection and audit. Push protection prevents a secret reaching the remote only while the block holds; a bypass accepts the commit unchanged, so the credential enters history, but GitHub logs the bypass actor and reason and secret scanning then raises an alert, meaning detection and accountability persist after prevention is overridden.

Why A is wrong: This is appealing because push protection is marketed as keeping secrets out, but a bypass does not rewrite the commit; once the author bypasses the block the commit containing the secret is accepted as written.

Why B is wrong: A bypass reason is logged for that single event and does not create a standing suppression; secret scanning continues to scan the file and will alert on the committed secret rather than treating the bypass as a lasting false-positive marker.

Why C is correct: When push protection is bypassed the push proceeds and the credential lands in history, but GitHub records who bypassed and why and secret scanning raises an alert, so detection and an audit trail survive even though the preventive gate was overridden.

Why D is wrong: Push protection and secret scanning are related but distinct: bypassing the push-time block does not stop the post-commit scan, so an alert is still raised on the now-committed secret rather than being cleared by the bypass.

Free sampleSecurity operations: best practices, prioritization, and remediationmedium

A platform team wants one team of security staff to be able to triage and dismiss code scanning, secret scanning, and Dependabot alerts across every repository in an organisation, and to read each repository's code so they can investigate, but they must not be able to delete repositories, change merge protections, or alter billing. They also want this access to apply automatically to repositories created in future. Which approach grants exactly this scope?

  • AGrant the team the maintain role on every repository, since the maintain role includes alert triage across the organisation's security suites without the destructive permissions of administrators.
  • BAssign the security manager role to the team, which gives read access to every repository in the organisation plus the ability to view and dismiss alerts across the security suites, while withholding administrative powers such as deletion and billing. Correct
  • CAdd the team to the organisation owners group and document that they should refrain from deleting repositories, changing merge protections, or touching billing while they perform alert triage.
  • DCreate a custom organisation repository role that bundles the write permission with the security events scope, then assign that role to the team on each repository in the organisation in turn.
Use the security manager role to grant a team organisation-wide alert triage and read access without administrative powers. The security manager role grants a team read access to every repository in the organisation, including repositories created later, plus the ability to view and dismiss alerts across code scanning, secret scanning, and Dependabot, while deliberately excluding owner-level powers such as deletion, merge-protection changes, and billing. The maintain and write-based custom roles are per-repository and lack this cross-suite, organisation-wide alert governance, and owner membership over-grants.

Why A is wrong: The maintain role is a tempting middle tier because it sits below administrator, but it is assigned per repository rather than organisation-wide, does not extend to repositories created later, and does not grant the cross-suite alert triage that the security manager role provides. It overshoots on some repository management abilities while undershooting on alert governance.

Why B is correct: The security manager role is purpose-built for this: a team granted it receives read access across all of the organisation's repositories, including ones added later, together with the ability to view and manage alerts from code scanning, secret scanning, and Dependabot, but it does not confer deletion, merge-protection changes, or billing control. This matches the requested scope precisely.

Why C is wrong: Organisation owners certainly can triage every alert across all repositories, which is why this looks sufficient, but owners hold full administrative control including deletion, merge-protection changes, and billing, and a written request to avoid using granted powers is not an access boundary. This over-grants well beyond the requested scope and relies on discipline rather than permission scoping.

Why D is wrong: Custom repository roles can combine fine-grained permissions including security events, so this seems like a precise fit, but they are applied per repository rather than automatically across the whole organisation and to repositories created later, leaving future repositories uncovered until someone assigns the role again. The security manager role already packages organisation-wide alert governance for this exact need, making the custom-role route more brittle.

Free sampleSecurity operations: best practices, prioritization, and remediationhard

A platform team has published a versioned custom CodeQL pack named acme/python-security to their organisation's package registry. They want their advanced code scanning workflow to run the built-in Python security suite and additionally run every query inside a pinned release of acme/python-security on each analysis. The workflow already initialises CodeQL for Python. How should they wire the custom pack into the workflow so its queries run alongside the built-in suite?

- uses: github/codeql-action/init@v3
  with:
    languages: python
    # add reference to acme/python-security here
  • AAdd the custom queries to a paths input so CodeQL includes the acme/python-security directory in the database and evaluates its queries during analysis.
  • BReference acme/python-security from the config-file input under a registries key, because packs can only be loaded through the registries section of an external configuration file.
  • CAdd a packs input listing acme/python-security pinned to a version, alongside the default queries input, so CodeQL downloads that pack and runs its queries together with the built-in suite. Correct
  • DPass acme/python-security to the queries input using the same syntax as a built-in suite name, which replaces the default suite with the pack's queries.
Use the CodeQL action's packs input to install and run a published custom query pack by pinned version alongside the built-in query suite. The CodeQL action separates concerns: the packs input installs and runs published query packs by name and version, while the queries input selects suites or local queries. Listing acme/python-security under packs with a pinned version downloads that release and runs its queries in addition to whatever the default or specified suite already runs, so both the built-in Python security suite and the custom pack execute. The paths input controls analysed source, the registries key supplies registry credentials, and overloading the queries input would replace the built-in suite, so none of those wires the pack in correctly.

Why A is wrong: The paths input narrows which source files are added to the database, not which queries run, so it cannot pull in or execute a published query pack. It confuses controlling analysed source with selecting queries.

Why B is wrong: A config file's registries section supplies authentication for private package registries, not the list of packs to execute, so naming a pack there does not run its queries. It mistakes credential configuration for query selection.

Why C is correct: The packs input is the supported way to install and run a published CodeQL query pack by name and version, and it runs in addition to the default or named query suite, so the built-in Python security queries and the custom pack both execute. Pinning a version makes the analysis reproducible.

Why D is wrong: The queries input expects suite names or local query paths and using it to name a pack would replace rather than supplement the default analysis, dropping the built-in Python security suite. It both targets the wrong input and loses the built-in coverage the team wants to keep.

Other domains in this exam

See also the GH-500 cert hub, the study guide, and the cheat sheet.

Examworthy is not affiliated with or endorsed by GitHub. Original, blueprint-aligned practice material only.