HackTricks Cloud
HackTricks Cloud
Ask or search…
Comment on page

Github Security

Support HackTricks and get benefits!

What is Github

(From here) At a high level, GitHub is a website and cloud-based service that helps developers store and manage their code, as well as track and control changes to their code.

Basic Information

External Recon

Github repositories can be configured as public, private and internal.
  • Private means that only people of the organisation will be able to access them
  • Internal means that only people of the enterprise (an enterprise may have several organisations) will be able to access it
  • Public means that all internet is going to be able to access it.
In case you know the user, repo or organisation you want to target you can use github dorks to find sensitive information or search for sensitive information leaks on each repo.

Github Dorks

Github allows to search for something specifying as scope a user, a repo or an organisation. Therefore, with a list of strings that are going to appear close to sensitive information you can easily search for potential sensitive information in your target.
Tools (each tool contains its list of dorks):

Github Leaks

Please, note that the github dorks are also meant to search for leaks using github search options. This section is dedicated to those tools that will download each repo and search for sensitive information in them (even checking certain depth of commits).
Tools (each tool contains its list of regexes):
When you look for leaks in a repo and run something like git log -p don't forget there might be other branches with other commits containing secrets!

External Forks

It's possible to compromise repos abusing pull requests. To know if a repo is vulnerable you mostly need to read the Github Actions yaml configs. More info about this below.

Organization Hardening

Member Privileges

There are some default privileges that can be assigned to members of the organization. These can be controlled from the page https://github.com/organizations/<org_name>/settings/member_privileges or from the Organizations API.
  • Base permissions: Members will have the permission None/Read/write/Admin over the org repositories. Recommended is None or Read.
  • Repository forking: If not necessary, it's better to not allow members to fork organization repositories.
  • Pages creation: If not necessary, it's better to not allow members to publish pages from the org repos. If necessary you can allow to create public or private pages.
  • Integration access requests: With this enabled outside collaborators will be able to request access for GitHub or OAuth apps to access this organization and its resources. It's usually needed, but if not, it's better to disable it.
    • I couldn't find this info in the APIs response, share if you do
  • Repository visibility change: If enabled, members with admin permissions for the repository will be able to change its visibility. If disabled, only organization owners can change repository visibilities. If you don't want people to make things public, make sure this is disabled.
    • I couldn't find this info in the APIs response, share if you do
  • Repository deletion and transfer: If enabled, members with admin permissions for the repository will be able to delete or transfer public and private repositories.
    • I couldn't find this info in the APIs response, share if you do
  • Allow members to create teams: If enabled, any member of the organization will be able to create new teams. If disabled, only organization owners can create new teams. It's better to have this disabled.
    • I couldn't find this info in the APIs response, share if you do
  • More things can be configured in this page but the previous are the ones more security related.

Actions Settings

Several security related settings can be configured for actions from the page https://github.com/organizations/<org_name>/settings/actions.
Note that all this configurations can also be set on each repository independently
  • Github actions policies: It allows you to indicate which repositories can tun workflows and which workflows should be allowed. It's recommended to specify which repositories should be allowed and not allow all actions to run.
  • Fork pull request workflows from outside collaborators: It's recommended to require approval for all outside collaborators.
    • I couldn't find an API with this info, share if you do
  • Run workflows from fork pull requests: It's highly discouraged to run workflows from pull requests as maintainers of the fork origin will be given the ability to use tokens with read permissions on the source repository.
    • I couldn't find an API with this info, share if you do
  • Workflow permissions: It's highly recommended to only give read repository permissions. It's discouraged to give write and create/approve pull requests permissions to avoid the abuse of the GITHUB_TOKEN given to running workflows.


Let me know if you know the API endpoint to access this info!
  • Third-party application access policy: It's recommended to restrict the access to every application and allow only the needed ones (after reviewing them).
  • Installed GitHub Apps: It's recommended to only allow the needed ones (after reviewing them).

Recon & Attacks abusing credentials

For this scenario we are going to suppose that you have obtained some access to a github account.

With User Credentials

If you somehow already have credentials for a user inside an organization you can just login and check which enterprise and organization roles you have, if you are a raw member, check which permissions raw members have, in which groups you are, which permissions you have over which repos, and how are the repos protected.
Note that 2FA may be used so you will only be able to access this information if you can also pass that check.
Note that if you manage to steal the user_session cookie (currently configured with SameSite: Lax) you can completely impersonate the user without needing credentials or 2FA.
Check the section below about branch protections bypasses in case it's useful.

With User SSH Key

Github allows users to set SSH keys that will be used as authentication method to deploy code on their behalf (no 2FA is applied).
With this key you can perform changes in repositories where the user has some privileges, however you can not sue it to access github api to enumerate the environment. However, you can get enumerate local settings to get information about the repos and user you have access to:
# Go to the the repository folder
# Get repo config and current user name and email
git config --list
If the user has configured its username as his github username you can access the public keys he has set in his account in https://github.com/<github_username>.keys, you could check this to confirm the private key you found can be used.
SSH keys can also be set in repositories as deploy keys. Anyone with access to this key will be able to launch projects from a repository. Usually in a server with different deploy keys the local file ~/.ssh/config will give you info about key is related.

GPG Keys

As explained here sometimes it's needed to sign the commits or you might get discovered.
Check locally if the current user has any key with:
gpg --list-secret-keys --keyid-format=long

With User Token

For an introduction about User Tokens check the basic information.
A user token can be used instead of a password for Git over HTTPS, or can be used to authenticate to the API over Basic Authentication. Depending on the privileges attached to it you might be able to perform different actions.
A User token looks like this: ghp_EfHnQFcFHX6fGIu5mpduvRiYR584kK0dX123

With Oauth Application

An attacker might create a malicious Oauth Application to access privileged data/actions of the users that accepts them probably as part of a phishing campaign.
These are the scopes an Oauth application can request. A should always check the scopes requested before accepting them.
Moreover, as explained in the basic information, organizations can give/deny access to third party applications to information/repos/actions related with the organisation.

With Github Application

An attacker might create a malicious Github Application to access privileged data/actions of the users that accepts them probably as part of a phishing campaign.
Moreover, as explained in the basic information, organizations can give/deny access to third party applications to information/repos/actions related with the organisation.

Compromise & Abuse Github Action

There are several techniques to compromise and abuse a Github Action, check them here:

Branch Protection Bypass

  • Require a number of approvals: If you compromised several accounts you might just accept your PRs from other accounts. If you just have the account from where you created the PR you cannot accept your own PR. However, if you have access to a Github Action environment inside the repo, using the GITHUB_TOKEN you might be able to approve your PR and get 1 approval this way.
    • Note for this and for the Code Owners restriction that usually a user won't be able to approve his own PRs, but if you are, you can abuse it to accept your PRs.
  • Dismiss approvals when new commits are pushed: If this isn’t set, you can submit legit code, wait till someone approves it, and put malicious code and merge it into the protected branch.
  • Require reviews from Code Owners: If this is activated and you are a Code Owner, you could make a Github Action create your PR and then approve it yourself.
    • When a CODEOWNER file is missconfigured Github doesn't complain but it does't use it. Therefore, if it's missconfigured it's Code Owners protection isn't applied.
  • Allow specified actors to bypass pull request requirements: If you are one of these actors you can bypass pull request protections.
  • Include administrators: If this isn’t set and you are admin of the repo, you can bypass this branch protections.
  • PR Hijacking: You could be able to modify the PR of someone else adding malicious code, approving the resulting PR yourself and merging everything.
  • Removing Branch Protections: If you are an admin of the repo you can disable the protections, merge your PR and set the protections back.
  • Bypassing push protections: If a repo only allows certain users to send push (merge code) in branches (the branch protection might be protecting all the branches specifying the wildcard *).
    • If you have write access over the repo but you are not allowed to push code because of the branch protection, you can still create a new branch and within it create a github action that is triggered when code is pushed. As the branch protection won't protect the branch until it's created, this first code push to the branch will execute the github action.

Bypass Environments Protections

In case an environment can be accessed from all the branches, it's isn't protected and you can easily access the secrets inside the environment. Note that you might find repos where all the branches are protected (by specifying its names or by using *) in that scenario, find a branch were you can push code and you can exfiltrate the secrets creating a new github action (or modifying one).
Note, that you might find the edge case where all the branches are protected (via wildcard *) it's specified who can push code to the branches (you can specify that in the branch protection) and your user isn't allowed. You can still run a custom github action because you can create a branch and use the push trigger over itself. The branch protection allows the push to a new branch so the github action will be triggered.
push: # Run it when a push is made to a branch
- current_branch_name #Use '**' to run when a push is made to any branch
Note that after the creation of the branch the branch protection will apply to the new branch and you won't be able to modify it, but for that time you will have already dumped the secrets.


  • Generate user token
  • Steal github tokens from secrets
    • Deletion of workflow results and branches
  • Give more permissions to all the org
  • Create webhooks to exfiltrate information
  • Invite outside collaborators
  • Remove webhooks used by the SIEM
  • Create/modify Github Action with a backdoor
  • Find vulnerable Github Action to command injection via secret value modification

Imposter Commits - Backdoor via repo commits

In Github it's possible to create a PR to a repo from a fork. Even if the PR is not accepted, a commit id inside the orginal repo is going to be created for the fork version of the code. Therefore, an attacker could pin to use an specific commit from an apparently ligit repo that wasn't created by the owner of the repo.
Like this:
name: example
on: [push]
runs-on: ubuntu-latest
- uses: actions/checkout@c7d749a2d57b4b375d1ebcd17cfbfb60c676f18e
- shell: bash
run: |
echo 'hello world!'
Support HackTricks and get benefits!