What does ISO 27001 A.8.4 require for source code access?
ISO 27001 A.8.4 covers access to source code: who can read it, change it or administer the repository. Include credentials used by build and deployment jobs. Removing unwanted access needs the owner's approval and a test afterward: the old path must fail, and approved work must still run.
A private repository can give a former contractor access long after the assignment ends. Its visibility has stayed the same; the reason for that permission has changed. A.8.4 brings these everyday access decisions into the organization's ISO 27001 program.
Approved source code access
Each permission needs a reason that the repository owner can explain. An external reviewer may need to read an integration's code, while a developer needs to change it. A build job has its own purpose and should have permissions suited to that job.
Write the access rule in terms that can be checked: which code, which actions and whose approval. When a permission looks unusual, those details help the reviewer decide what to do. The owner may need to remove it or explain why it should remain.
Repository coverage
The access review needs a current list of the repositories covered by the commitment. A review of last quarter's list can miss a repository created for a new service. Give each repository an owner and connect it to the applicable access rule.
Compare the list with the repositories in use before drawing a conclusion about coverage. A missing repository needs a scope decision and a check. Keep exclusions explicit so the next reviewer can distinguish a deliberate boundary from a repository nobody examined.
Read and change permissions
Decide separately who needs to read code and who needs to change it. An integration reviewer may only need a copy to inspect. Giving that reviewer a contributor role would add rights beyond the task, even if the repository remains private.
In GitHub, repository roles provide different permissions for members, teams and outside collaborators. Include organization base permissions in the review as well as individual repository grants. Look at the combined result of those grants before deciding whether the account has the intended rights.
Administrative access
Repository administrators can change the protections that other contributors must follow. Include them in the review even when they rarely contribute code. The reason for administrative access should explain the responsibility that requires it and who approved that responsibility.
Keep an exception's owner and review conditions beside its approval. A temporary administrator assignment can otherwise survive the migration or support work that justified it. When that work ends, the owner can decide whether to remove the assignment or approve a continuing need.
Automation credentials
An automation credential can retain repository access after the person who created it leaves. GitHub deploy keys attach to a repository and remain active independently of the creator's membership. A review of employee accounts alone can therefore miss a working access path.
For each credential, identify the job that uses it and the access that job needs. Check whether the job still runs before removing its credential. Where the job remains necessary, agree how it will retain approved access and verify that path after the correction.
Access changes between audits
Review a permission when the assignment that required it changes. The owner can make a better decision while that work is still familiar. A finished contract or team transfer is a reason to check whether the same repository rights are still justified.
A new repository introduces a different problem: it may never have been checked. Compare its permissions with the rule when it enters the review scope. Keep any finding against that repository so an earlier successful review cannot obscure the new gap.
Code review boundaries
A branch review rule protects the route by which changes enter maintained code. It leaves other access questions to answer, including who can retrieve the source and who can change repository settings. Keep those questions visible alongside the checks on code review.
If an unreviewed change can enter the branch, examine the settings and permissions that allowed it. That investigation overlaps with change and development controls, which cover review and testing. Record the access finding where it belongs, with a link to any associated change-control work.
Approval before removal
An access correction needs an owner who can judge what will stop working. Describe the unwanted permission and the intended access afterward. For an old automation credential, include the jobs that might still depend on it and how those dependencies were checked.
The owner can then approve removal, a narrower permission or a documented exception. Keep the decision with the proposed action so the person making the change understands its limits. If nobody knows whether a job still uses the credential, investigate before removing it.
Verification after correction
A completed change needs a fresh check of the access it was meant to remove. Test that the obsolete path is denied and that the approved work can still proceed. Removing a credential from a list is only one part of that check.
Retain the repository identifier, observation time and result for each path tested. If the old path still works, keep the gap open. If the approved job fails, investigate that failure before closure. Missing or stale observations leave the result unresolved until a fresh check is available.
Continuing access checks
Assign responsibility for the changes that will follow this review. Someone needs to check new repositories and decide what to do with access left behind by completed work. Agree a review schedule and where to send a gap that needs an engineer's attention.
Through its GitHub integration, ZeroTB checks commitments against repositories and proposes fixes for gaps. People approve the correction before ZeroTB verifies it. The resulting Verified Control Record gives the reviewer the original commitment, the decision and evidence of what the change achieved.
Evidence for access decisions
These records help an auditor trace a repository permission from its approved purpose to the latest test.
| Requirement | What an auditor asks for | Where it comes from |
|---|---|---|
| Defined scope | The reviewed repositories, their owners and the reasons for exclusions | Current repository list and the approved scope |
| Approved permissions | The current permissions and the approved reason for retaining each grant | Access grants, team membership and the owner's approvals |
| Accountable automation access | The job behind each credential and the permissions approved for it | Credential list and build or deployment records |
| Controlled correction | The observed gap, the agreed correction and any exception kept in place | The decision recorded against the proposed change |
| Verified result | The failed attempt through the old path and the successful approved job | Dated tests retained in the Verified Control Record |
Related framework requirements
| Framework | Control | What it covers |
|---|---|---|
| ISO 27001 | A.8.4 | Source code access, with rights assigned according to the work people and automated jobs need to perform |
| SOC 2 | CC8.1 | Control over changes to code and systems, supported where relevant by records from the repository workflow |
| HIPAA | 164.308(a)(4) | Authorization of access to electronic protected health information; a repository record helps only when it addresses that protected information |
Example of removing obsolete code access
This example follows a migration key that can still read code after its job has ended. Removal needs the repository owner's approval and two checks afterward. The old key must lose access, and the active build must continue using its own approved credential.

Remaining access. The migration is finished, but its old key can still retrieve the repository's source code.
Owner decision. The owner confirms that the key has no remaining job and approves its removal.
Tested result. An access test rejects the old key, and the active build retrieves the code successfully.
Retained evidence. Both test results carry dates and sit beside the approval and the record of removal.
Source code access checklist
Check the repository list against the approved scope, then add any new code that belongs in the review.
Match current permissions to the work they allow, including unattended jobs as well as individual contributors.
Explain the unwanted permission and its dependencies so the owner can approve a correction or retain an exception.
Test the blocked path and the approved work after the change; resolve either failure before closing the gap.
Retain the observations and results beside the approval, with responsibility assigned for the checks that follow.
Sources
- ISO/IEC, ISO/IEC 27002:2022 overview, 2022.
- GitHub, Repository roles for an organization, accessed November 4, 2026.
- GitHub, Managing deploy keys, accessed November 4, 2026.
- HHS, Summary of the HIPAA Security Rule, accessed November 4, 2026.
- ZeroTB, Control automation with human approval, 2026.
Start with the Pilot
Talk with our team about the repository access problems that keep returning. In the eight-week Pilot, we map up to 25 commitments and take two real control gaps through approved correction and verified restoration, with evidence of the results.