## Uso

O Inquisitor tem cinco comandos básicos que incluem `scan`, `status`, `classify`, `dump` e `visualize`.```
usage: inq [-h] {scan,status,classify,dump,visualize} ...

optional arguments:
  -h, --help            show this help message and exit

command:
  {scan,status,classify,dump,visualize}
                        The action to perform.
    scan                Search OSINT sources for intelligence based on known
                        assets belonging to the target.
    status              Prints out the current status of the specified
                        intelligence database.
    classify            Classifies an existing asset as either belonging or
                        not belonging to the target. Adds a new asset with the
                        specified classification if none is present.
    dump                Dumps the contents of the database into a JSON file
    visualize           Create a D3.js visualization based on the contents of
                        the specified intelligence database.

### Status

No modo de status, a ferramenta simplesmente imprime um resumo rápido do status do seu banco de dados de varredura.```
usage: inq status [-h] [-s] DATABASE

positional arguments:
  DATABASE      The path to the intelligence database to use. If specified
                file does not exist, a new one will be created.

optional arguments:
  -h, --help    show this help message and exit
  -s, --strong  Indicates if the status will be based on the strong ownership
                classification.

### Dump

No modo Dump, você poderá extrair o conteúdo do Intelligence Database para um arquivo JSON legível por humanos.```
usage: inq dump [-h] [-j FILE] [-a] DATABASE

positional arguments:
  DATABASE              The path to the intelligence database to use. If
                        specified file does not exist, a new one will be
                        created.

optional arguments:
  -h, --help            show this help message and exit
  -j FILE, --json FILE  The path to dump the JSON file to. Overwrites existing
                        files.
  -a, --all             Include rejected assets in dump.

## Fluxo de Trabalho

Agora que você conhece os recursos básicos do Inquisitor, é hora de aprender como *realmente* usá-lo. O Inquisitor foi projetado com as seguintes etapas em mente:

### Semeadura

Nesta etapa, seu Banco de Dados de Inteligência ainda não possui nada. Teremos que começar de algum lugar, então vá em frente e alimente o banco de dados com ativos que você sabe que pertencem à sua organização alvo. Você pode fazer isso usando o comando `classify`.

### Varredura

Agora que o banco de dados possui ativos conhecidos por pertencer à sua organização alvo. Você pode então prosseguir com a varredura. Você pode fazer isso usando o comando `scan`.

Quando você invoca o comando `scan` no seu Banco de Dados de Inteligência, o Inquisitor executa os métodos `transform` dos ativos classificados como `accepted`. Quando a varredura terminar, você terá mais ativos que podem potencialmente pertencer à sua organização alvo.

Se você não obtiver novos ativos, pode semear seu Banco de Dados de Inteligência com novas informações, ou simplesmente prosseguir para finalizar o processo seguindo para a etapa de Relatório.

### Classificação

Embora o Inquisitor realize a classificação automática de ativos para você, pode acabar perdendo alguns ativos que, de fato, pertencem à sua organização alvo.

Quando isso acontecer, você terá que verificar o conteúdo do banco de dados e classificar manualmente os ativos. Geralmente, você deve prestar atenção aos ativos **Registrant**, pois não há como determinar automaticamente a propriedade para esse tipo de ativo. Além disso, a maioria dos outros tipos de ativos depende da classificação de propriedade dos ativos Registrant para determinar se pertencem ao seu alvo ou não, por isso é definitivamente melhor prestar atenção aos seus ativos Registrant. Além disso, você não acaba com muitos ativos Registrant em primeiro lugar, então não será tão difícil examiná-los.

### Relatório

Você pode gerar uma visualização dos ativos que pertencem à sua organização alvo usando o comando `visualize` ou o comando `dump`.

## Demonstração

Eu tenho vídeos de demonstração da ferramenta em execução no seguinte link: https://drive.google.com/open?id=0B_O70BVu38TRclo5dWRBWkdTTWc

No entanto, não consegui gravar completamente a execução do comando scan, pois meu gravador de tela gratuito só grava até 10 minutos.

## Desenvolvimento

O projeto Inquisitor está organizado no seguinte formato:```
.
|-- README.md
|-- inquisitor
|   |-- __init__.py
|   |-- assets
|   |   |-- __init__.py
|   |   |-- block.py
|   |   |-- email.py
|   |   |-- host.py
|   |   |-- linkedin.py
|   |   `-- registrant.py
|   |-- extractors
|   |   |-- __init__.py
|   |   `-- emails.py
|   `-- sources
|       |-- __init__.py
|       |-- google_search.py
|       `-- shodan_search.py
|-- inq
|-- report
|   `-- index.html
|-- setup.py
`-- tests
    |-- __init__.py
    `-- test_inq.py

Retrieves the primary key and asset object for the asset with the provided 
type and identifier.

asset_type: class, required

    The type of the asset to retrieve from the Intelligence Database. You
    will actually have to pass the class object of the asset type you want
    to retrieve.

identifier: any, required

    The identifier of the asset to retrieve. Consider the identifier as the
    unique attribute of an asset object. As for which attribute is to be
    used to identify an asset, it depends on the contents of the OBJECT_ID
    variable in the asset module.

create: bool, optional, default=False

    When no matching asset object is found, a new one will be created and 
    returned if this parameter is set to True. The new asset will not
    necessarily be stored in the Intelligence Database unless specified
    using the "store" parameter. However, I suggest you do not do this as
    adding assets to the Intelligence Database is the responsibility of
    another module.

store: bool, optional, default=False

    When a new asset is created when none is found, the new one will be
    stored in the Intelligence Database. As said previously, I suggest that
    you do not do this as adding assets to the Intelligence Database is the
    responsibility of another module.

A two-element tuple where the first element is the database primary key of 
the element returned, and the second element is the deserialized asset 
object retrieved from the database.

None if the asset was not found.

If the asset was not found and the create flag was set to True, the primary
key member of the tuple will be set to None.

### Ativos

Para criar um novo tipo de ativo, crie um novo arquivo dentro do diretório `inquisitor/assets` e cole o seguinte código esqueleto dentro:```python
import inquisitor.assets

class ASSET_NAMEValidateException(Exception):
    pass

def canonicalize(ASSET_IDENTIFIER):
    return ASSET_IDENTIFIER

def main_classify_args(parser):
    parser.add_argument(
        '-aASSET_NAME_LETTER', '--accept-ASSET_NAME',
        metavar='ASSET_NAME',
        type=canonicalize,
        nargs='+',
        help='Specifies a ASSET_NAME to classify as accepted.',
        dest='ASSET_NAMEs_accepted',
        default=list(),
    )
    parser.add_argument(
        '-uASSET_NAME_LETTER', '--unmark-ASSET_NAME',
        metavar='ASSET_NAME',
        type=canonicalize,
        nargs='+',
        help='Specifies a ASSET_NAME to classify as unmarked.',
        dest='ASSET_NAMEs_unmarked',
        default=list(),
    )
    parser.add_argument(
        '-rASSET_NAME_LETTER', '--reject-ASSET_NAME',
        metavar='ASSET_NAME',
        type=canonicalize,
        nargs='+',
        help='Specifies a ASSET_NAME to classify as rejected.',
        dest='ASSET_NAME_rejected',
        default=list(),
    )

def main_classify_canonicalize(args):
    accepted = set(args.ASSET_NAMEs_accepted)
    unmarked = set(args.ASSET_NAMEs_unmarked)
    rejected = set(args.ASSET_NAME_rejected)
    redundant = set.intersection(accepted, unmarked, rejected)
    if redundant:
        raise ValueError(
            ('Conflicting classifications for ASSET_NAMEs '
            ': {}').format(list(redundant))
        )
    accepted = set([canonicalize(a) for a in accepted])
    unmarked = set([canonicalize(a) for a in unmarked])
    rejected = set([canonicalize(a) for a in rejected])
    return (accepted, unmarked, rejected)

class ASSET_NAME(inquisitor.assets.Asset):

    def __init__(self, ASSET_IDENTIFIER, owned=None):
        super(self.__class__, self).__init__(owned=owned)
        self.ASSET_IDENTIFIER = canonicalize(ASSET_IDENTIFIER)
        # TODO: Perform other initialization actions here

    def __eq__(self, other):
        if not isinstance(other, self.__class__):
            return False
        return self.ASSET_IDENTIFIER == other.ASSET_IDENTIFIER

    def related(self, repo):
        # Prepare the results
        results = set()
        # TODO: Create related assets here based on the attributes of this asset
        # Return the results
        return results

    def transform(self, repo, sources):
        # Prepare the results
        assets = set()
        # Google Transforms
        if sources.get('google'):
            subassets = self.cache_transform_get('google', repo)
            if not subassets:
                # Acquire API
                google = sources['google']
                # TODO: Perform Google queries here and the results to 'subassets'
                # Cache The Transform
                self.cache_transform_store('google', subassets)
            assets.update(subassets)
        # Shodan Transforms
        if sources.get('shodan'):
            subassets = self.cache_transform_get('shodan', repo)
            if not subassets:
                # Acquire API
                shodan = sources['shodan']
                # TODO: Perform Google queries here and the results to 'subassets'
                # Cache The Transform
                self.cache_transform_store('shodan', subassets)
            assets.update(subassets)
        # Return the results
        return assets

    def is_owned(self, repo):
        if self.owned:
            return True
        # TODO: Automatically determine ownership based on repo contents
        return False

    def parent_asset(self, repo):
        # TODO: Return parent asset based on repo contents
        return None

REPOSITORY = 'ASSET_REPOSITORY'
ASSET_CLASS = ASSET_NAME
OBJECT_ID = 'ASSET_IDENTIFIER'

related

  Returns the set of assets directly related to the asset in question (i.e.
  those that can be derived without querying a search engine).

  When creating asset objects, make sure you use the 
  IntelligenceRepository.get_asset_string method instead of instatiating a 
  new one your self so the asset can be returned from the repository if it 
  exists.

  Set the create flag to True when calling the method in question in order
  to return a new object when one isn't found.

  Set the store flag to False as appending assets is the job of another
  module.

repo: IntelligenceRepository

    The Intelligence Repository that is being used in the current context.

Set of assets directly related to the asset in question. 

Por exemplo, para executar uma verificação de caminhos presentes na wordlist `quickhits.txt` usando a técnica **all**, ativando a recursão.```
Function

    transform

Description
  
      Returns the set of assets potentially related to the asset in question
      (i.e. those that can be derived by querying a search engine).

      You may access search engine objects through the provided sources
      parameter.

      Each search engine object has a transform method which automatically
      creates asset objects for you. You just need to provide it the repository
      and your query string, and then append the objects it returns to the set
      of assets to be returned by your asset's transform method.

Parameters

    repo: IntelligenceRepository

        The Intelligence Repository that is being used in the current context.

    sources: dict

        The list of search engine objects that are available for use.

Returns

    Set of assets potentially related to the asset in question.
    

python3 spiderfoot.py -s <target> -o <outputfile>

python3 spiderfoot.py -s <target> -f /path/to/ignorelist.txt

is_owned

 Determines if there is high confidence that this asset does indeed belong
 to the target. Usually checks for any "strong" classification tag first by
 looking at the contents of the "owned" variable, before performing
 automatic evaluation.

 Automatic evaluation depends on what type of asset you're writing. For
 example, for a Host asset, the secondary sources of determining ownership
 would include looking if its registrant is owned by the target, if it's
 parent domain is owned by the target. etc.

repo: IntelligenceRepository

    The Intelligence Repository that is being used in the current context.

True it is determined with high confidence that this asset does indeed 
belong to the target.

### 4.1 Criar um Projeto
Para começar, crie um projeto usando `create-oxy-x-project`:

```bash
npx create-oxy-x-project

✔ Project name: … test
✔ Pick a template › All Templates
? Pick target extension: » - Use arrow-keys. Return to submit.
>   Chrome/Edge Extension
    Firefox Addon
    User Script

parent_asset

 Returns the asset object that is considered the parent of this asset
 object.

repo: IntelligenceRepository

The asset object that this asset falls under (e.g. a Block is under a 
Registrant, a Host is under a Block, a Host is under another Host, an Email
is under a Host, etc. This is primarily used for visualization.

Após implementar os métodos acima, certifique-se de definir as variáveis `REPOSITORY`, `ASSET_CLASS` e `OBJECT_ID` na parte inferior do código-fonte do seu ativo.

## Contato e Notas

O modo de varredura não foi totalmente testado devido às cotas relacionadas aos mecanismos de busca envolvidos. Além disso, este projeto foi feito às pressas como parte de um desafio de hackaton de uma semana, então pode haver muitos problemas por aí. Por favor, crie um ticket de issue ou entre em contato comigo em [email protected] se encontrar um bug ou tiver alguma dúvida.

## Aviso Legal

Este trabalho é derivado das abordagens implementadas pelas ferramentas de Inteligência de Código Aberto Maltego e recon-ng. Eu suplementei essas abordagens com ideias que já são de conhecimento comum (por exemplo, whois informa quem é o proprietário de um domínio, subdomínios são de propriedade da mesma organização que possui seu domínio pai - conforme implícito em ataques de força bruta de nomes de domínio, organizações são autoritativas sobre os nomes de domínio que possuem, etc.), ou são originais e foram concebidas por mim no meu tempo pessoal como parte do meu hobby (por exemplo, classificações de aceitabilidade, várias transformações, herança de classificação, etc.).

Nenhum componente deste trabalho foi derivado de qualquer trabalho que tenha feito para qualquer empregador no passado. Todo o projeto, incluindo a prova de conceito, foi escrito do zero e foi incrementado com ideias da comunidade de segurança da informação.