## 사용법

Inquisitor는 `scan`, `status`, `classify`, `dump`, `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.

### 상태

상태 모드에서는 도구가 스캔 데이터베이스의 상태에 대한 간략한 요약을 출력합니다.```
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

덤프 모드에서는 인텔리전스 데이터베이스의 내용을 사람이 읽을 수 있는 JSON 파일로 덤프할 수 있습니다.```
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.

## Workflow

이제 Inquisitor의 기본 기능을 알게 되었으니, *실제로* 사용하는 방법을 배울 때입니다. Inquisitor는 다음과 같은 단계를 염두에 두고 작성되었습니다:

### Seeding

이 단계에서는 Intelligence Database에 아직 아무것도 저장되어 있지 않습니다. 어딘가에서 시작해야 하므로, 귀하의 대상 조직에 속한다고 알고 있는 자산으로 데이터베이스를 시드(seed)하십시오. 이 작업은 `classify` 명령을 사용하여 수행할 수 있습니다.

### Scanning

이제 데이터베이스에 대상 조직에 속하는 것으로 알려진 자산이 있습니다. 그런 다음 스캐닝을 진행할 수 있습니다. 이 작업은 `scan` 명령을 사용하여 수행할 수 있습니다.

Intelligence Database에서 `scan` 명령을 호출하면, Inquisitor는 `accepted`로 분류된 자산의 `transform` 메서드를 실행합니다. 스캐닝이 완료되면, 잠재적으로 대상 조직에 속할 수 있는 더 많은 자산이 생성됩니다.

새로운 자산이 생성되지 않은 경우, Intelligence Database에 새로운 정보로 시드(seed)하거나, 간단히 Reporting 단계로 진행하여 프로세스를 마무리할 수 있습니다.

### Classifying

Inquisitor가 자동으로 자산 분류를 수행하지만, 실제로 대상 조직에 속하는 일부 자산을 놓칠 수도 있습니다.

이런 경우, 데이터베이스 내용을 확인하고 수동으로 자산을 분류해야 합니다. 일반적으로 **Registrant** 자산에 주의를 기울여야 합니다. 이 자산 유형은 소유권을 자동으로 확인할 방법이 없기 때문입니다. 또한 대부분의 다른 자산 유형은 Registrant 자산의 소유권 분류에 의존하여 대상 조직에 속하는지 여부를 결정하므로, Registrant 자산에 주의를 기울이는 것이 가장 좋습니다. 게다가 처음부터 Registrant 자산이 많지 않으므로 이를 선별하는 것이 그렇게 어렵지 않을 것입니다.

### Reporting

`visualize` 명령이나 `dump` 명령을 사용하여 대상 조직에 속하는 자산의 시각화를 생성할 수 있습니다.

## Demo

다음 링크에서 도구가 실행되는 비디오 데모를 확인할 수 있습니다: https://drive.google.com/open?id=0B_O70BVu38TRclo5dWRBWkdTTWc

무료 화면 녹화 프로그램이 최대 10분까지만 녹화할 수 있어서 scan 명령의 전체 실행을 완전히 녹화하지는 못했습니다.

## Development

Inquisitor 프로젝트는 다음과 같은 형식으로 구성되어 있습니다:```
.
|-- 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.

### 자산

새로운 자산 유형을 생성하려면 `inquisitor/assets` 디렉토리 안에 새 파일을 만들고 다음 스켈레톤 코드를 붙여넣으세요:```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. 

[No input text provided.]```
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.
    

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.

Function

    parent_asset

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

Parameters

    repo: IntelligenceRepository

Returns

    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.
    
```
위 방법들을 구현한 후, 에셋 소스 코드 하단에 `REPOSITORY`, `ASSET_CLASS`, `OBJECT_ID` 변수를 설정해야 합니다.

## 연락처 및 참고 사항

스캔 모드는 관련 검색 엔진의 할당량 문제로 인해 완전히 테스트되지 않았습니다. 또한 이 프로젝트는 일주일 동안의 해커톤 챌린지의 일환으로 급하게 만들어졌기 때문에 여기저기 많은 문제가 있을 수 있습니다. 버그를 발견하거나 질문이 있으면 이슈 티켓을 생성하거나 [email protected]으로 연락해 주세요.

## 면책 조항

이 작업은 Maltego 및 recon-ng 오픈 소스 인텔리전스 도구에서 구현된 접근 방식을 기반으로 합니다. 저는 이러한 접근 방식에 이미 일반적으로 알려진 아이디어(예: whois는 도메인 소유자가 누구인지 알려주고, 서브도메인은 상위 도메인을 소유한 동일한 조직이 소유한다는 점(도메인 이름 무차별 대입 공격에서 암시됨), 조직은 자신이 소유한 도메인 이름에 대해 권위를 가짐 등) 또는 제가 취미 생활의 일환으로 개인 시간에 창안한 독창적인 아이디어(예: 수용 가능성 등급, 다양한 변환, 분류 상속 등)를 추가로 보완했습니다.

이 작업의 어떤 구성 요소도 과거에 제가 고용주를 위해 수행한 작업에서 파생되지 않았습니다. 개념 증명을 포함한 전체 프로젝트는 처음부터 작성되었으며 정보 보안 커뮤니티의 아이디어로 보강되었습니다.