> For the complete documentation index, see [llms.txt](https://mysther.gitbook.io/knowledge-base/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://mysther.gitbook.io/knowledge-base/ataques/web-exploitation/git.md).

# Git

### Comandos Básicos

| **COMANDO**                                                                                  | **DESCRIÇÃO**                                                                                                                                                                                             |
| -------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `git init <directory>`                                                                       | Cria um repositório local                                                                                                                                                                                 |
| `git clone <url>`                                                                            | Clona um repositório pra a máquina local                                                                                                                                                                  |
| `git clone <url> -b <branch>`                                                                | Clona um projeto de determinada branch. Por padrão é a `master`                                                                                                                                           |
| `git -c http.sslVerify=False clone <url>`                                                    | Clona um repositório ignorando TLS / SSL (útil quando o servidor não possui um certificado válido)                                                                                                        |
| `git branch`                                                                                 | Verifica a branch atual e as que branches que já foram utilizadas                                                                                                                                         |
| `git branch -a`                                                                              | Exibe todas as branches                                                                                                                                                                                   |
| `git branch <branch>`                                                                        | Cria uma branch                                                                                                                                                                                           |
| `git branch -D <branch>`                                                                     | Remove uma branch                                                                                                                                                                                         |
| `git checkout <branch>`                                                                      | Alterando de branch                                                                                                                                                                                       |
| `git checkout -b <new_branch>`                                                               | Cria uma branch e deixa ela como o repositório de uso                                                                                                                                                     |
| `git for-each-ref --format='%(committerdate) %09 %(authorname) %09 %(refname)' \| sort`      | Verificando quem criou as branchs                                                                                                                                                                         |
| `git fetch`                                                                                  | Atualiza os objetos e referências de outros repositórios                                                                                                                                                  |
| `git add <file1> <file2> ... <file 10>`                                                      | Adiciona arquivos para  commit                                                                                                                                                                            |
| `git add .`                                                                                  | Adiciona todos os arquivos para commit                                                                                                                                                                    |
| `git diff`                                                                                   | Mostra o que foi alterado na brach atual                                                                                                                                                                  |
| `git diff  <remote_branch> -- <file>`                                                        | Comparando o arquivo atual com o mesmo em outra branch                                                                                                                                                    |
| `git diff <branch1> <branch2>`                                                               | Compara uma branch com outra                                                                                                                                                                              |
| `git commit -m '<messagem>'`                                                                 | Definindo mensagem de Commit                                                                                                                                                                              |
| `git push`                                                                                   | Enviando arquivos para o server                                                                                                                                                                           |
| `git push -u origin <branch>`                                                                | Enviando arquivos para o server em uma determnada branch                                                                                                                                                  |
| `git merge <remote_branch>`                                                                  | <p>Pega o código de uma branch remota e trás para a branch atual.</p><p><strong>OBS.:</strong> Antes de executar esse comando, entre na branch atual e execute <strong><code>git pull</code></strong></p> |
| `git stash ; git checkout <brach> ; git stash apply`                                         | Importando as modificações de uma branch para outra. Útil para cenários onde o Git pede para fazer um commit antes de alterar de branch                                                                   |
| `git reset --hard HEAD`                                                                      | Restaurando código para última versão da branch                                                                                                                                                           |
| `git checkout HEAD -- <arquivo.txt>`                                                         | Restaundo somente um arquivo para o estado do último commit                                                                                                                                               |
| `git reset --hard <id_commit>`                                                               | Desfazendo commit ou merge                                                                                                                                                                                |
| `git log`                                                                                    | Mostra Logs da Branch                                                                                                                                                                                     |
| `git log --graph --decorate`                                                                 | Mostra Logs da Branch com uma árvore do lado                                                                                                                                                              |
| `git log --graph --oneline --all`                                                            | Mostrando a árvore do GIT                                                                                                                                                                                 |
| `git log -p -- <file>`                                                                       | <p>Vendo histórico de determinado arquivo.</p><p><strong>OBS</strong>.: Remova o parâmetro <strong><code>-p</code></strong> para editar o diff</p>                                                        |
| `git reflog`                                                                                 | Os logs de referência, ou "reflogs", registram quando as dicas de ramificações e outras referências foram atualizadas no repositório local                                                                |
| `git reset --hard <commit> ; git reset --soft HEAD@{1} ; git commit -m "Revert to <commit>"` | Voltando uma commit antigo                                                                                                                                                                                |

###

### Baixando Git Exposto

É comum acharmos o subdiretório `.git` aberto e, caso o ache, execute o comando abaixo para baixar todo o projeto:

```bash
wget --mirror -I .git https://<domain>/.git/
```

Depois podemos executar o comando `git checkout --` para resetar o repositório, recuperando todos os arquivos.

### Gitdumper

Baixando o repositório GIT com todo o seu histórico. Note  que será criado um diretório chamado .`git` no dentro do diretório de destino.

```bash
./gitdumper.sh https://site.com/.git/ <diretório_destino>
```

Após baixar o repositório, podemos filtrar pelos logs (commits) ou podemos usar o `Extractor`, para extrair todos os arquivos em suas respectivas versões. Indique o local que exportou o `.git` (no comando anterior)**.**

```bash
./extractor.sh </path/repo/> <diretório_destino>
```

### Truffle Hog

Filtra o histórico de commits buscando dados sensíveis.

```bash
python3 truffleHog.py https://github.com/<profile>/<repo>
```

###

### GitLeaks

Ferramenta que encontra senhas não criptografadas e outros tipos de dados sensíveis em repositórios Git que estão públicos.

```bash
gitleaks -v --repo-path=</path/repository>/
# Ou 
docker run -it -v </path/git_repository/>:/data/ zricethezav/gitleaks gitleaks -v --repo-path=/data/
```

### GitMiner

```bash
python3 gitminer-v2.0.py --query '<query>' -m <module> -c <cookie>
```

**OBS.:** O cookie tem que ser extraído (pode ser direto do navegador) no fomato:

```
_octo=<value>
user_session=<value>
```

Verificar no site (github) todos os módulos que ele possui

### Acessando Informações do Git Manualmente

#### Método 1

Esse método é utilizando quando temos o acesso aos arquivos do diretório `.git/objects` e nele podemos ver diretórios com nome que contém apenas dois caracteres.

Muitas vezes, o diretório `.git` ou `.git/` está protegido, mas arquivos como `.git/config` e `.git/HEAD` estão disponíveis para leitura. Então para começar, vamos ler o arquivo `.git/HEAD`.

```bash
https://site.com/.git/HEAD
```

Irá ser retornado algo como `ref: refs/heads/master`. Então vamos acessar o valor de `ref`, da seguinte forma:

```bash
https://site.com/.git/refs/heads/master
```

Com isso, será retornado um hash (parecido com um MD5) que servirá como base do nossa próxima URL. Vamos supor que o hash retornado do comando anterior, seja `e62a9ebea4632f2f7746ad9a1bbf3424171fe410`. Iremos pegar os dois primeiros caracteres (`e6`) para usarmos como nome do diretório e o restante (`2a9ebea4632f2f7746ad9a1bbf3424171fe410`) será o nome do arquivo. A URL irá ser a seguinte:

```bash
https://site.com/.git/objects/e6/2a9ebea4632f2f7746ad9a1bbf3424171fe410
```

Note que será disponibilizado um arquivo para download. Esse arquivo não está legível no momento, mas podemos descomprimí-lo, para ler seu conteúdo.

```bash
printf "\x1f\x8b\x08\x00\x00\x00\x00\x00" | cat - <file_downloaded> | gzip  -cd -q | strings -a
```

Nesse momento, podemos ver nome(s) de arquivo(s) ou hash de commit. Caso tenha algum commit, repita o processo utilizando o hash informado para baixar um novo arquivo.

Caso consiga visualizar nomes de arquivos, devemos criar nosso próprio repositório local, pois o comando `strings` não consegue nos mostrar o hash de cada arquivo.

```bash
mkdir /tmp/git
cd /tmp/git
git init

# Altere o final "e6" pelos dois primeiros caracteres que encontrar
mkdir -p .git/objects/e6
cp </path/file_downloaded> /tmp/git/.git/objects/e6/

# Note que estamos usando o hash que achamos no início
git cat-file -p e62a9ebea4632f2f7746ad9a1bbf3424171fe410
```

Após ter executado este último comando, conseguimos ver as hashes completas de cada arquivo, então podemos usar essa hash para realizar o download do arquivo, como fizemos anteriormente.

#### Método 2

Esse método é utilizando quando temos o acesso aos arquivos do diretório `.git/objects` e nele podemos ver um arquivo com extensão `pack`.

Baixe o arquivo `.pack` localizado em `.git/objects`. Acesso o diretório onde salvou o arquivo pack, e execute os seguintes comandos:

```bash
git init
cat <file.pack> | git unpack-objects
```

Note que agora há alguns (ou vários) diretórios com nomes que tenham apenas dois caracteres em `.git/objects`. Agora para ler o conteúdo dos arquivos basta executar o comando abaixo:

```bash
printf "\x1f\x8b\x08\x00\x00\x00\x00\x00" | cat - .git/objects/<diretorio_com_dois_caracteres>/<arquivo_qualquer> | gzip -cd -q | strings -a
```

#### Sites

```bash
# Gitdumper
https://github.com/internetwache/GitTools
```
