././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6681454
censys-2.2.17/LICENSE 0000644 0000000 0000000 00000023676 14777466662 011111 0 ustar 00
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6681454
censys-2.2.17/README.md 0000644 0000000 0000000 00000011545 14777466662 011353 0 ustar 00 # Censys Python Library
[](https://pypi.org/project/censys/)
[](https://www.python.org/downloads/)
[](https://censys-python.readthedocs.io/en/stable/?badge=stable)
[](https://github.com/censys/censys-python/discussions)
[](http://makeapullrequest.com)
[](https://github.com/censys/censys-python/blob/main/LICENSE)
An easy-to-use and lightweight API wrapper for Censys APIs ([censys.io](https://censys.io/)). Python 3.8+ is currently supported. This library has been tested on Python 3.8 and 3.x (Currently version 3.10).
> **Notice:** The Censys Search v1 endpoints are deprecated as of Nov. 30, 2021. Please begin using v2 endpoints to query hosts and certificates and check out our [support center](https://support.censys.io/hc/en-us/sections/360013076551-Censys-Search-2-0) for resources.
> [!IMPORTANT]
> This library does not support the new Censys Platform, however a new set of SDKs that do support the platform are coming soon.
> Please refer to the [platform API refrence docs](https://docs.censys.com/reference/get-started#/) in the mean time.
## Features
- [Search Censys data](https://censys-python.readthedocs.io/en/stable/usage-v2.html)
- [Bulk Certificate lookups](https://censys-python.readthedocs.io/en/stable/usage-v2.html#bulk-view)
- [Download Bulk Data](https://censys-python.readthedocs.io/en/stable/usage-v1.html#data)
- [Manage assets, events, and seeds in Censys ASM](https://censys-python.readthedocs.io/en/stable/usage-asm.html)
- [Command-line interface](https://censys-python.readthedocs.io/en/stable/cli.html)
## Getting Started
The library can be installed using `pip`.
```sh
pip install censys
```
To upgraded using `pip`.
```sh
pip install --upgrade censys
```
Alternatively, you can install the library using `poetry`.
```sh
git clone https://github.com/censys/censys-python.git
cd censys-python/
poetry install
```
Optionally, you can enable tab completion for the CLI by adding this line to your `~/.bashrc`, `~/.zshrc`, or equivalent.
> Please note that autocomplete is supported for field names in the `search` command.
```sh
eval "$(register-python-argcomplete censys)"
```
To configure your search credentials run `censys config` or set both `CENSYS_API_ID` and `CENSYS_API_SECRET` environment variables.
```sh
$ censys config
Censys API ID: XXX
Censys API Secret: XXX
Do you want color output? [y/n]: y
Successfully authenticated for your@email.com
```
If you have a Censys ASM account, you can configure your ASM credentials by running `censys asm config` or set both `CENSYS_ASM_API_KEY` environment variables.
```sh
$ censys asm config
Censys ASM API Key: XXX
Do you want color output? [y/n]: y
Successfully authenticated
```
## Examples
The examples located in the [`examples/`](examples/) directory are a great place to start. You can also find more examples in the [usage documentation](https://censys-python.readthedocs.io/en/stable/usage-v2.html).
## [Documentation](https://censys-python.readthedocs.io/)
[](https://censys-python.readthedocs.io/)
## Resources
- [Source](https://github.com/censys/censys-python)
- [Issue Tracker](https://github.com/censys/censys-python/issues)
- [Changelog](https://github.com/censys/censys-python/releases)
- [Documentation](https://censys-python.rtfd.io)
- [Discussions](https://github.com/censys/censys-python/discussions)
- [Censys Homepage](https://censys.io/)
- [Censys Search](https://search.censys.io/)
## Contributing
All contributions (no matter how small) are always welcome. See [Contributing to Censys Python](.github/CONTRIBUTING.md)
## Development
This project uses [poetry](https://python-poetry.org/) for dependency management. Please ensure you have [installed the latest version](https://python-poetry.org/docs/#installation).
```sh
git clone git@github.com:censys/censys-python.git
cd censys-python/
poetry install
```
## Testing
```sh
# Run tests
poetry run pytest
# With coverage report
poetry run pytest --cov-report html
```
## License
This software is licensed under [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0)
- Copyright (C) 2024 Censys, Inc.
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6681454
censys-2.2.17/censys/__main__.py 0000644 0000000 0000000 00000000134 14777466662 013462 0 ustar 00 """Main function for when executed with python -m censys."""
from .cli import main
main()
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6681454
censys-2.2.17/censys/asm/__init__.py 0000644 0000000 0000000 00000001516 14777466662 014266 0 ustar 00 """An easy-to-use and lightweight API wrapper for Censys ASM (app.censys.io)."""
from .assets import (
Assets,
CertificatesAssets,
DomainsAssets,
HostsAssets,
ObjectStoragesAssets,
SubdomainsAssets,
WebEntitiesAssets,
)
from .beta import Beta
from .client import AsmClient
from .clouds import Clouds
from .inventory import InventorySearch
from .logbook import Events, Logbook
from .risks import Risks
from .saved_queries import SavedQueries
from .seeds import Seeds
__all__ = [
"AsmClient",
"Assets",
"Beta",
"CertificatesAssets",
"Clouds",
"DomainsAssets",
"Events",
"HostsAssets",
"InventorySearch",
"Logbook",
"Risks",
"SavedQueries",
"Seeds",
"SubdomainsAssets",
"WebEntitiesAssets",
"ObjectStoragesAssets",
]
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6681454
censys-2.2.17/censys/asm/api.py 0000644 0000000 0000000 00000007141 14777466662 013300 0 ustar 00 """Base for interacting with the Censys ASM API."""
import os
from math import inf
from typing import Iterator, Optional, Type
from requests.models import Response
from censys.common.base import CensysAPIBase
from censys.common.config import DEFAULT, get_config
from censys.common.exceptions import (
CensysAsmException,
CensysException,
CensysExceptionMapper,
)
class CensysAsmAPI(CensysAPIBase):
"""This is the base class for ASM's Seeds, Assets, and Events classes."""
DEFAULT_URL: str = "https://app.censys.io/api"
"""Default ASM API base URL."""
def __init__(self, api_key: Optional[str] = None, **kwargs):
"""Inits CensysAsmAPI.
Args:
api_key (str): Optional; The API Key provided by Censys.
**kwargs: Arbitrary keyword arguments.
Raises:
CensysException: Base Exception Class for the Censys API.
"""
url = kwargs.pop("url", self.DEFAULT_URL)
CensysAPIBase.__init__(self, url=url, **kwargs)
# Gets config file
config = get_config()
# Try to get credentials
self._api_key = (
api_key
or os.getenv("CENSYS_ASM_API_KEY")
or config.get(DEFAULT, "asm_api_key")
)
if not self._api_key:
raise CensysException("No ASM API key configured.")
self._session.headers.update(
{"Content-Type": "application/json", "Censys-Api-Key": self._api_key}
)
def _get_exception_class( # type: ignore
self, res: Response
) -> Type[CensysAsmException]:
return CensysExceptionMapper.ASM_EXCEPTIONS.get(
res.json().get("errorCode"), CensysAsmException
)
def _get_page(
self,
path: str,
page_number: int = 1,
page_size: Optional[int] = None,
args: Optional[dict] = None,
keyword: str = "assets",
) -> Iterator[dict]:
"""Fetches paginated ASM resource API results.
Args:
path (str): The API url endpoint.
page_number (int): Optional; Page number to begin at when getting results.
page_size (int):
Optional; Number of results to return per HTTP request. Defaults to 500.
args (dict): Optional; URL args that are mapped to params.
keyword (str): Optional; The keyword to iterate over in the results.
Yields:
dict: The resource result returned.
"""
total_pages = inf
args = args or {}
while page_number <= total_pages:
args.update({"pageNumber": page_number, "pageSize": page_size or 500})
res = self._get(path, args=args)
page_number = int(res["pageNumber"]) + 1
total_pages = int(res["totalPages"])
yield from res[keyword]
def _get_logbook_page(
self, path: str, args: Optional[dict] = None
) -> Iterator[dict]:
"""Fetches paginated ASM logbook API events.
Args:
path (str): The API url endpoint.
args (dict): Optional; URL args that are mapped to params (cursor).
Yields:
dict: The event result returned.
"""
end_of_events = False
while not end_of_events:
res = self._get(path, args=args)
end_of_events = res["endOfEvents"]
args = {"cursor": res["nextCursor"]}
yield from res["events"]
def get_workspace_id(self) -> str:
"""Get the workspace ID.
Returns:
str: The workspace ID.
"""
return self._get("/integrations/v1/account")["workspaceId"]
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6681454
censys-2.2.17/censys/asm/assets/__init__.py 0000644 0000000 0000000 00000000751 14777466662 015570 0 ustar 00 """Interact with the Censys Assets API."""
from .assets import Assets
from .certificates import CertificatesAssets
from .domains import DomainsAssets
from .hosts import HostsAssets
from .object_storages import ObjectStoragesAssets
from .subdomains import SubdomainsAssets
from .web_entities import WebEntitiesAssets
__all__ = [
"Assets",
"CertificatesAssets",
"DomainsAssets",
"HostsAssets",
"ObjectStoragesAssets",
"SubdomainsAssets",
"WebEntitiesAssets",
]
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6681454
censys-2.2.17/censys/asm/assets/assets.py 0000644 0000000 0000000 00000014507 14777466662 015337 0 ustar 00 """Base for interacting with the Censys Assets API."""
import re
from typing import Any, Dict, Iterator, List, Optional
from ..api import CensysAsmAPI
from censys.common.exceptions import CensysInvalidColorException
HEX_REGEX = re.compile(r"^#(?:[0-9a-fA-F]{3}){1,2}$")
class Assets(CensysAsmAPI):
"""Assets API class."""
asset_type: str
def __init__(self, asset_type: str, *args, **kwargs):
"""Inits Assets.
Args:
asset_type (str): Type of asset to interact with.
*args: Variable length argument list.
**kwargs: Arbitrary keyword arguments.
"""
CensysAsmAPI.__init__(self, *args, **kwargs)
api_version = kwargs.get("api_version", "v1")
self.base_path = f"/{api_version}/assets/{asset_type}"
self.asset_type = asset_type
def _format_asset_id(self, asset_id: str) -> str:
"""Formats asset ID.
Args:
asset_id (str): Asset ID to format.
Returns:
str: Formatted asset ID.
"""
return asset_id
def get_assets(
self,
page_number: int = 1,
page_size: Optional[int] = None,
tag: Optional[List[str]] = None,
tag_operator: Optional[str] = None,
source: Optional[List[str]] = None,
discovery_trail: Optional[bool] = None,
) -> Iterator[dict]:
"""Requests assets data.
Args:
page_number (int): Optional; Page number to begin at when searching.
page_size (int): Optional; Page size for retrieving assets.
tag (list): Optional; List of tags to search for.
tag_operator (str): Optional; Operator to use when searching for tags.
source (list): Optional; List of sources to search for.
discovery_trail (bool): Optional; Bool indicating whether to return discovery trail.
Yields:
dict: The assets result returned.
"""
args: Dict[str, Any] = {}
if tag:
args["tag"] = tag
if tag_operator:
args["tagOperator"] = tag_operator
if source:
args["source"] = source
if discovery_trail:
args["discoveryTrail"] = discovery_trail
yield from self._get_page(
self.base_path, page_number=page_number, page_size=page_size, args=args
)
def get_asset_by_id(self, asset_id: str) -> dict:
"""Requests asset data by ID.
Args:
asset_id (str): Requested asset ID.
Returns:
dict: Asset search result.
"""
path = f"{self.base_path}/{self._format_asset_id(asset_id)}"
return self._get(path)
def get_comments(
self,
asset_id: str,
page_number: int = 1,
page_size: Optional[int] = None,
) -> Iterator[dict]:
"""Requests comments on a specified asset.
Args:
asset_id (str): Asset ID for requested comments.
page_number (int): Optional; Page number to begin at when searching.
page_size (int): Optional; Page size for retrieving comments.
Returns:
generator: Comment search results.
"""
path = f"{self.base_path}/{self._format_asset_id(asset_id)}/comments"
return self._get_page(
path, page_number=page_number, page_size=page_size, keyword="comments"
)
def get_comment_by_id(self, asset_id: str, comment_id: int) -> dict:
"""Requests a comment on a specified asset by comment ID.
Args:
asset_id (str): Asset ID for requested comments.
comment_id (int): Requested comment ID.
Returns:
dict: Comment search result.
"""
path = (
f"{self.base_path}/{self._format_asset_id(asset_id)}/comments/{comment_id}"
)
return self._get(path)
def add_comment(self, asset_id: str, comment: str) -> dict:
"""Adds a comment to a specified asset on the ASM platform.
Args:
asset_id (str): Asset ID to add comment to.
comment (str): New comment text.
Returns:
dict: Added comment results.
"""
path = f"{self.base_path}/{self._format_asset_id(asset_id)}/comments"
data = {"markdown": str(comment)}
return self._post(path, data=data)
def delete_comment(self, asset_id: str, comment_id: int) -> dict:
"""Deletes a comment from a specified asset on the ASM platform by comment ID.
Args:
asset_id (str): Asset ID to delete comment from.
comment_id (int): Comment ID to delete.
Returns:
dict: Deleted comment results.
"""
path = (
f"{self.base_path}/{self._format_asset_id(asset_id)}/comments/{comment_id}"
)
return self._delete(path)
def add_tag(self, asset_id: str, name: str, color: Optional[str] = None) -> dict:
"""Adds a tag to a specified asset on the ASM platform.
Args:
asset_id (str): Asset ID to add tag to.
name (str): New tag name.
color (str): Optional; New tag color (hex).
Returns:
dict: Added tag results.
"""
path = f"{self.base_path}/{self._format_asset_id(asset_id)}/tags"
data = format_tag(name, color)
return self._post(path, data=data)
def delete_tag(self, asset_id: str, name: str) -> dict:
"""Deletes a tag from a specified asset on the ASM platform by tag name.
Args:
asset_id (str): Asset ID to delete tag from.
name (str): Tag name to delete.
Returns:
dict: Deleted tag results.
"""
path = f"{self.base_path}/{self._format_asset_id(asset_id)}/tags/{name}"
return self._delete(path)
def format_tag(name: str, color: Optional[str] = None) -> dict:
"""Formats tag name and color request data.
Args:
name (str): Tag name.
color (str): Optional; Tag color (hex).
Raises:
CensysInvalidColorException: Raised if color is not a valid hex color.
Returns:
dict: Formatted tag request data.
"""
if color:
if not HEX_REGEX.match(color):
raise CensysInvalidColorException(10037, f"{color} is not a valid color.")
return {"name": str(name), "color": str(color)}
return {"name": str(name)}
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6681454
censys-2.2.17/censys/asm/assets/certificates.py 0000644 0000000 0000000 00000000651 14777466662 016475 0 ustar 00 """Interact with the Censys Certificate Assets API."""
from .assets import Assets
class CertificatesAssets(Assets):
"""Certificates Assets API class."""
def __init__(self, *args, **kwargs):
"""Inits CertificatesAssets.
Args:
*args: Variable length argument list.
**kwargs: Arbitrary keyword arguments.
"""
super().__init__("certificates", *args, **kwargs)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/asm/assets/domains.py 0000644 0000000 0000000 00000002137 14777466662 015463 0 ustar 00 """Interact with the Censys Domain Assets API."""
from typing import Iterator, Optional
from .assets import Assets
class DomainsAssets(Assets):
"""Domains Assets API class."""
def __init__(self, *args, **kwargs):
"""Inits DomainsAssets.
Args:
*args: Variable length argument list.
**kwargs: Arbitrary keyword arguments.
"""
super().__init__("domains", *args, **kwargs)
def get_subdomains(
self, domain: str, page_number: int = 1, page_size: Optional[int] = None
) -> Iterator[dict]:
"""List all subdomains of the parent domain.
Args:
domain: (str): Parent domain to query.
page_number (int): Optional; Page number to begin at when searching.
page_size (int): Optional; Page size for retrieving assets.
Yields:
dict: The assets result returned.
"""
yield from self._get_page(
f"{self.base_path}/{domain}/subdomains",
page_number=page_number,
page_size=page_size,
keyword="subdomains",
)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/asm/assets/hosts.py 0000644 0000000 0000000 00000000606 14777466662 015170 0 ustar 00 """Interact with the Censys Host Assets API."""
from .assets import Assets
class HostsAssets(Assets):
"""Hosts Assets API class."""
def __init__(self, *args, **kwargs):
"""Inits HostsAssets.
Args:
*args: Variable length argument list.
**kwargs: Arbitrary keyword arguments.
"""
super().__init__("hosts", *args, **kwargs)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/asm/assets/object_storages.py 0000644 0000000 0000000 00000001523 14777466662 017204 0 ustar 00 """Interact with the Censys Object Storage Assets API."""
from urllib.parse import quote
from .assets import Assets
class ObjectStoragesAssets(Assets):
"""Object Storage Assets API class.
Please note that the Object Storage Assets API is currently in beta and
is subject to change.
"""
def __init__(self, *args, **kwargs):
"""Inits ObjectStoragesAssets.
Args:
*args: Variable length argument list.
**kwargs: Arbitrary keyword arguments.
"""
super().__init__("object-storages", api_version="beta", *args, **kwargs)
def _format_asset_id(self, asset_id: str) -> str:
"""Formats asset ID.
Args:
asset_id (str): Asset ID to format.
Returns:
str: Formatted asset ID.
"""
return quote(asset_id, safe="")
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/asm/assets/subdomains.py 0000644 0000000 0000000 00000003611 14777466662 016173 0 ustar 00 """Interact with the Censys Subdomain Assets API."""
from typing import Any, Dict, Iterator, List, Optional
from .assets import Assets
class SubdomainsAssets(Assets):
"""Subdomains Assets API class."""
def __init__(self, *args, **kwargs):
"""Inits SubdomainsAssets.
Args:
*args: Variable length argument list.
**kwargs: Arbitrary keyword arguments.
"""
super().__init__("subdomains", *args, **kwargs)
def get_assets(
self,
page_number: int = 1,
page_size: Optional[int] = None,
tag: Optional[List[str]] = None,
tag_operator: Optional[str] = None,
source: Optional[List[str]] = None,
discovery_trail: Optional[bool] = None,
) -> Iterator[dict]:
"""Requests assets data.
Override for subdomains due to it return value in a different key.
Args:
page_number (int): Optional; Page number to begin at when searching.
page_size (int): Optional; Page size for retrieving assets.
tag (list): Optional; List of tags to search for.
tag_operator (str): Optional; Operator to use when searching for tags.
source (list): Optional; List of sources to search for.
discovery_trail (bool): Optional; Bool indicating whether to return discovery trail.
Yields:
dict: The assets result returned.
"""
args: Dict[str, Any] = {}
if tag:
args["tag"] = tag
if tag_operator:
args["tagOperator"] = tag_operator
if source:
args["source"] = source
if discovery_trail:
args["discoveryTrail"] = discovery_trail
yield from self._get_page(
self.base_path,
page_number=page_number,
page_size=page_size,
args=args,
keyword="subdomains",
)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/asm/assets/web_entities.py 0000644 0000000 0000000 00000003360 14777466662 016511 0 ustar 00 """Interact with the Censys Web Entities Assets API."""
from typing import Iterator, Optional
from .assets import Assets
class WebEntitiesAssets(Assets):
"""Web Entities Assets API class."""
def __init__(self, *args, **kwargs):
"""Inits WebEntitiesAssets.
Args:
*args: Variable length argument list.
**kwargs: Arbitrary keyword arguments.
"""
super().__init__("web-entities", *args, **kwargs)
def get_assets(self, *args, **kwargs):
"""Requests assets data.
This method is not implemented for web entities.
Please see the inventory search and aggregation API.
Args:
*args: Variable length argument list.
**kwargs: Arbitrary keyword arguments.
Raises:
NotImplementedError: This method is not implemented.
"""
raise NotImplementedError("This method is not implemented.")
def get_instances(
self,
name_and_port: str,
page_size: Optional[int] = None,
cursor: Optional[str] = None,
) -> Iterator[dict]:
"""List all instances of the web entity.
Args:
name_and_port: (str): Web entity to query.
page_size (int): Optional; Page size for retrieving assets.
cursor (str): Optional; Cursor to use for pagination.
Yields:
dict: The assets result returned.
"""
args = {"pageSize": page_size, "cursor": cursor}
while True:
res = self._get(f"{self.base_path}/{name_and_port}/instances", args=args)
yield from res.get("instances", [])
cursor = res.get("cursor")
if not cursor:
break
args["cursor"] = cursor
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/asm/beta.py 0000644 0000000 0000000 00000006434 14777466662 013446 0 ustar 00 """Interact with miscellaneous Censys Beta APIs."""
from typing import List, Optional
from ..common.types import Datetime
from ..common.utils import format_iso8601
from .api import CensysAsmAPI
class Beta(CensysAsmAPI):
"""Beta API class."""
base_path = "/beta"
def get_logbook_data(
self, filters: Optional[dict] = None, cursor: Optional[str] = None
):
"""Retrieve logbook data.
Args:
filters (dict): Optional; Filter parameters.
cursor (str): Optional; Cursor for pagination.
Returns:
dict: Logbook data result.
"""
data = {"filters": filters, "nextWindowCursor": cursor}
return self._post(f"{self.base_path}/logbook/getLogbookData", data=data)
def add_cloud_assets(
self,
cloud_connector_uid: str,
cloud_assets: List[dict],
):
"""Add cloud assets.
Args:
cloud_connector_uid (str): Cloud connector UID.
cloud_assets (List[dict]): Cloud assets.
Returns:
dict: Add cloud assets result.
"""
data = {
"cloudConnectorUid": cloud_connector_uid,
"cloudAssets": cloud_assets,
}
return self._post(f"{self.base_path}/cloudConnector/addCloudAssets", data=data)
def get_input_assets(self, page_number: int = 1, page_size: Optional[int] = None):
"""Retrieve input assets.
Args:
page_number (int): Optional; Page number to begin at when searching.
page_size (int): Optional; Page size for retrieving assets.
Returns:
dict: Input assets result.
"""
return self._get(
f"{self.base_path}/assets/inputAssets",
params={"pageNumber": page_number, "pageSize": page_size},
)
def get_asset_counts(self, since: Datetime, environment: str, asset_type: str):
"""Retrieve asset counts.
Args:
since (Datetime): Date to include assets from.
environment (str): Environment to include assets from.
asset_type (str): Asset type to include.
Returns:
dict: Asset count result.
"""
params = {
"since": format_iso8601(since),
"environment": environment,
"assetType": asset_type,
}
return self._get(
f"{self.base_path}/assets/counts",
params=params,
)
def get_host_counts_by_country(self, since: Datetime, environment: str):
"""Retrieve host counts by country.
Args:
since (Datetime): Date to include hosts from.
environment (str): Environment to include hosts from.
Returns:
dict: Host count result.
"""
params = {
"since": format_iso8601(since),
"environment": environment,
}
return self._get(
f"{self.base_path}/assets/hostCountsByCountry",
params=params,
)
def get_user_workspaces(self, user_uuid: str):
"""Retrieve user workspaces.
Args:
user_uuid (str): User UUID.
Returns:
dict: User workspaces result.
"""
return self._get(
f"{self.base_path}/users/{user_uuid}/workspaces",
)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/asm/client.py 0000644 0000000 0000000 00000003024 14777466662 014001 0 ustar 00 """Interact with the Censys Seeds, Assets, and Logbook APIs."""
from typing import Optional
from .assets import (
CertificatesAssets,
DomainsAssets,
HostsAssets,
ObjectStoragesAssets,
SubdomainsAssets,
WebEntitiesAssets,
)
from .beta import Beta
from .clouds import Clouds
from .inventory import InventorySearch
from .logbook import Logbook
from .risks import Risks
from .saved_queries import SavedQueries
from .seeds import Seeds
class AsmClient:
"""Client ASM API class."""
def __init__(self, api_key: Optional[str] = None, **kwargs):
"""Inits AsmClient.
Args:
api_key (str): Optional; The API Key provided by Censys.
**kwargs: Arbitrary keyword arguments.
"""
self.seeds = Seeds(api_key, **kwargs)
self.hosts = HostsAssets(api_key, **kwargs)
self.certificates = CertificatesAssets(api_key, **kwargs)
self.domains = DomainsAssets(api_key, **kwargs)
self.subdomains = SubdomainsAssets(api_key, **kwargs)
self.logbook = Logbook(api_key, **kwargs)
self.events = self.logbook
self.clouds = Clouds(api_key, **kwargs)
self.risks = Risks(api_key, **kwargs)
self.inventory = InventorySearch(api_key, **kwargs)
self.object_storages = ObjectStoragesAssets(api_key, **kwargs)
self.web_entities = WebEntitiesAssets(api_key, **kwargs)
self.beta = Beta(api_key, **kwargs)
self.saved_queries = SavedQueries(api_key, **kwargs)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/asm/clouds.py 0000644 0000000 0000000 00000004007 14777466662 014016 0 ustar 00 """Interact with the Censys Clouds API."""
from ..common.types import Datetime
from ..common.utils import format_iso8601
from .api import CensysAsmAPI
class Clouds(CensysAsmAPI):
"""Clouds API class."""
base_path = "/v1/clouds"
def get_host_counts(
self,
since: Datetime,
) -> dict:
"""Retrieve host counts by cloud.
Hosts found after the date provided in the `since` parameter will be included in the new asset counts.
Args:
since (Datetime): Date to include hosts from.
Returns:
dict: Host count result.
"""
since = format_iso8601(since)
return self._get(f"{self.base_path}/hostCounts/{since}")
def get_domain_counts(self, since: Datetime) -> dict:
"""Retrieve domain counts by cloud.
Args:
since (Datetime): Date to include domains from.
Returns:
dict: Domain count result.
"""
since = format_iso8601(since)
return self._get(f"{self.base_path}/domainCounts/{since}")
def get_object_store_counts(self, since: Datetime) -> dict:
"""Retrieve object store counts by cloud.
Args:
since (Datetime): Date to include object stores from.
Returns:
dict: Object store count result.
"""
since = format_iso8601(since)
return self._get(f"{self.base_path}/objectStoreCounts/{since}")
def get_subdomain_counts(self, since: Datetime) -> dict:
"""Retrieve subdomain counts by cloud.
Args:
since (Datetime): Date to include subdomains from.
Returns:
dict: Subdomain count result.
"""
since = format_iso8601(since)
return self._get(f"{self.base_path}/subdomainCounts/{since}")
def get_unknown_counts(self) -> dict:
"""Retrieve known and unknown counts for hosts by cloud.
Returns:
dict: Unknown count result.
"""
return self._get(f"{self.base_path}/unknownCounts")
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/asm/inventory.py 0000644 0000000 0000000 00000007764 14777466662 014577 0 ustar 00 """Interact with the Censys Inventory Search API."""
import warnings
from typing import List, Optional
from .api import CensysAsmAPI
class InventorySearch(CensysAsmAPI):
"""Inventory Search API class."""
base_path = "/inventory/v1"
def search(
self,
workspaces: Optional[List[str]] = None,
query: Optional[str] = None,
page_size: Optional[int] = None,
cursor: Optional[str] = None,
sort: Optional[List[str]] = None,
fields: Optional[List[str]] = None,
pages: Optional[int] = None,
) -> dict:
"""Search inventory data.
Args:
workspaces (List[str], optional): List of workspace IDs to search. Deprecated. The workspace associated with `CENSYS-API-KEY` will be used automatically.
query (str, optional): Query string.
page_size (int, optional): Number of results to return. Defaults to 50.
cursor (str, optional): Cursor to start search from.
sort (List[str], optional): List of fields to sort by.
fields (List[str], optional): List of fields to return.
pages (int, optional): Number of pages of results to return (when set to -1 returns all pages available).
Returns:
dict: Inventory search results.
"""
if workspaces is None:
workspaces = [self.get_workspace_id()]
else:
warnings.warn(
"The field 'workspaces' is being deprecated. The workspace associated with `CENSYS-API-KEY` will be used automatically.",
category=DeprecationWarning,
stacklevel=2,
)
if page_size is None:
page_size = 50
if pages is None:
pages = 1
args = {
"workspaces": workspaces,
"pageSize": page_size,
}
if query:
args["query"] = query
if cursor:
args["cursor"] = cursor
if sort:
args["sort"] = sort
if fields:
args["fields"] = fields
page = 1
next_cursor = None
hits = []
resp = self._get(self.base_path, args=args)
next_cursor = resp.get("nextCursor")
hits.extend(resp.get("hits", []))
# Fetch additional pages if next_cursor is available AND additional pages are requested
# Loop will exit if next_cursor is None or if the number of pages requested is reached
# Loop will exit if non-200 status code is returned
while next_cursor and (pages == -1 or page < pages):
args["cursor"] = next_cursor
resp = self._get(self.base_path, args=args)
if "nextCursor" in resp:
next_cursor = resp.get("nextCursor")
else:
next_cursor = None
hits.extend(resp.get("hits", []))
page += 1
resp["hits"] = hits
return resp
def aggregate(
self,
workspaces: List[str],
query: Optional[str] = None,
aggregation: Optional[dict] = None,
) -> dict:
"""Aggregate inventory data.
Args:
workspaces (List[str]): List of workspace IDs to search.
query (str, optional): Query string.
aggregation (dict, optional): Aggregation object.
Returns:
dict: Inventory aggregation results.
"""
body = {
"workspaces": workspaces,
"query": query,
"aggregation": aggregation,
}
return self._post(f"{self.base_path}/aggregate", data=body)
def fields(self, fields: Optional[List[str]] = None) -> dict:
"""List inventory fields.
If no fields are specified, all fields will be returned.
Args:
fields (List[str], optional): List of fields to return.
Returns:
dict: Inventory field results.
"""
args = {"fields": fields}
return self._get(f"{self.base_path}/fields", args=args)
Inventory = InventorySearch
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/asm/logbook.py 0000644 0000000 0000000 00000005021 14777466662 014156 0 ustar 00 """Interact with the Censys Logbook API."""
import datetime
from typing import Iterator, List, Optional, Union
from .api import CensysAsmAPI
class Logbook(CensysAsmAPI):
"""Logbook API class."""
base_path = "/v1/logbook"
def get_cursor(
self,
start: Optional[Union[datetime.datetime, int]] = None,
filters: Optional[List[str]] = None,
) -> str:
"""Requests a logbook cursor.
Args:
start ([datetime.datetime, int]): Optional; Timestamp or event ID to begin searching.
filters (list): Optional; List of filters applied to logbook search results.
Returns:
str: Cursor result.
"""
path = f"{self.base_path}-cursor"
data = format_data(start=start, filters=filters)
return self._post(path, data=data)["cursor"]
def get_events(self, cursor: Optional[str] = None) -> Iterator[dict]:
"""Requests logbook events from inception or from the provided cursor.
Args:
cursor (str): Optional; Logbook cursor.
Yields:
dict: Logbook event.
"""
args = {"cursor": cursor}
yield from self._get_logbook_page(self.base_path, args)
# Alias for backwards compatibility
Events = Logbook
class Filters:
"""Logbook filters class."""
CERT = "CERT"
CERT_RISK = "CERT_RISK"
DOMAIN = "DOMAIN"
DOMAIN_EXPIRATION_DATE = "DOMAIN_EXPIRATION_DATE"
DOMAIN_MAIL_EXCHANGE_SERVER = "DOMAIN_MAIL_EXCHANGE_SERVER"
DOMAIN_NAME_SERVER = "DOMAIN_NAME_SERVER"
DOMAIN_REGISTRAR = "DOMAIN_REGISTRAR"
DOMAIN_RISK = "DOMAIN_RISK"
DOMAIN_SUBDOMAIN = "DOMAIN_SUBDOMAIN"
HOST = "HOST"
HOST_CERT = "HOST_CERT"
HOST_PORT = "HOST_PORT"
HOST_PROTOCOL = "HOST_PROTOCOL"
HOST_RISK = "HOST_RISK"
HOST_SOFTWARE = "HOST_SOFTWARE"
HOST_VULNERABILITY = "HOST_VULNERABILITY"
def format_data(
start: Optional[Union[datetime.datetime, int]] = None,
filters: Optional[List[str]] = None,
) -> dict:
"""Formats cursor request data into a start date/id and filter list.
Args:
start ([datetime.datetime, int]): Optional; Timestamp or event ID to begin searching.
filters (list): Optional; List of filters applied to logbook search results.
Returns:
dict: Formatted logbook cursor request data
"""
data: dict = {}
if filters:
data["filter"] = {"type": filters}
if isinstance(start, int):
data["idFrom"] = start
elif start:
data["dateFrom"] = start
return data
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/asm/risks.py 0000644 0000000 0000000 00000013417 14777466662 013665 0 ustar 00 """Interact with the Censys Risks API."""
import urllib.parse
from typing import Any, Dict, List, Optional
from .api import CensysAsmAPI
class Risks(CensysAsmAPI):
"""Risks API class."""
base_path = "/v2/risk"
risk_events_path = f"{base_path}-events"
risk_instances_path = f"{base_path}-instances"
risk_types_path = f"{base_path}-types"
def get_risk_events(
self,
start: Optional[str] = None,
end: Optional[str] = None,
after_id: Optional[int] = None,
limit: Optional[int] = None,
cursor: Optional[str] = None,
accept: Optional[str] = None,
) -> dict:
"""Retrieve risk events.
Args:
start (str): Optional; Starting event time, inclusive (in RFC3339 format).
end (str): Optional; Ending event time, inclusive (in RFC3339 format).
after_id (int): Optional; Risk event ID to query for events after.
limit (int): Optional; Max number of events to return.
cursor (str): Optional; Cursor value to continue collecting events started in a previous request.
accept (str): Optional; Accept header.
Returns:
dict: Risk events result.
"""
args: Dict[str, Any] = {}
if start:
args["start"] = start
if end:
args["end"] = end
if after_id:
args["afterID"] = after_id
if limit:
args["limit"] = limit
if cursor:
args["cursor"] = cursor
return self._get(
self.risk_events_path,
args=args,
headers={"Accept": accept} if accept else None,
)
def get_risk_instances(
self, include_events: Optional[bool] = None, accept: Optional[str] = None
) -> dict:
"""Retrieve risk instances.
Args:
include_events (bool): Optional; Whether to include events.
accept (str): Optional; Accept header.
Returns:
dict: Risk instances result.
"""
args = {"includeEvents": include_events}
return self._get(
self.risk_instances_path,
args=args,
headers={"Accept": accept} if accept else None,
)
def patch_risk_instances(self, data: dict) -> dict:
"""Patch risk instances.
Args:
data (dict): Risk instances data.
Returns:
dict: Risk instances result.
"""
return self._patch(self.risk_instances_path, data=data)
def search_risk_instances(self, data: dict, accept: Optional[str] = None) -> dict:
"""Search risk instances.
Args:
data (dict): Query data.
accept (str): Optional; Accept header.
Returns:
dict: Risk instances result.
"""
return self._post(
f"{self.risk_instances_path}/search",
data=data,
headers={"Accept": accept} if accept else None,
)
def get_risk_instance(
self, risk_instance_id: int, include_events: Optional[bool] = None
) -> dict:
"""Retrieve a risk instance.
Args:
risk_instance_id (int): Risk instance ID.
include_events (bool): Optional; Whether to include events.
Returns:
dict: Risk instance result.
"""
args = {"includeEvents": include_events}
return self._get(f"{self.risk_instances_path}/{risk_instance_id}", args=args)
def patch_risk_instance(self, risk_instance_id: int, data: dict) -> dict:
"""Patch a risk instance.
Args:
risk_instance_id (int): Risk instance ID.
data (dict): Risk instance data.
Returns:
dict: Risk instance result.
"""
return self._patch(f"{self.risk_instances_path}/{risk_instance_id}", data=data)
def get_risk_types(
self,
limit: Optional[int] = None,
page: Optional[int] = None,
sort: Optional[List[str]] = None,
include_events: Optional[bool] = None,
accept: Optional[str] = None,
) -> dict:
"""Retrieve risk types.
Args:
limit (int, optional): Maximum number of results to return. Defaults to 1000.
page (int, optional): Page number to begin at when searching. Defaults to 1.
sort (list): Optional; Sort by field(s).
include_events (bool): Optional; Whether to include events.
accept (str): Optional; Accept header.
Returns:
dict: Risk types result.
"""
args: Dict[str, Any] = {"sort": sort, "includeEvents": include_events}
if page:
args["page"] = page
if limit:
args["limit"] = limit
return self._get(
self.risk_types_path,
args=args,
headers={"Accept": accept} if accept else None,
)
def get_risk_type(
self, risk_type: str, include_events: Optional[bool] = None
) -> dict:
"""Retrieve a risk type.
Args:
risk_type (str): Risk type.
include_events (bool): Optional; Whether to include events.
Returns:
dict: Risk type result.
"""
escaped_risk_type = urllib.parse.quote(risk_type, safe="")
args = {"includeEvents": include_events}
return self._get(f"{self.risk_types_path}/{escaped_risk_type}", args=args)
def patch_risk_type(self, risk_type: str, data: dict) -> dict:
"""Patch a risk type.
Args:
risk_type (str): Risk type.
data (dict): Risk type data.
Returns:
dict: Risk type result.
"""
escaped_risk_type = urllib.parse.quote(risk_type, safe="")
return self._patch(f"{self.risk_types_path}/{escaped_risk_type}", data=data)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/asm/saved_queries.py 0000644 0000000 0000000 00000006113 14777466662 015364 0 ustar 00 """Interact with the Censys Saved Queries API."""
from typing import Optional
from .api import CensysAsmAPI
class SavedQueries(CensysAsmAPI):
"""Saved Queries API class."""
base_path = "/inventory/v1/saved-query"
def get_saved_queries(
self,
query_name_prefix: Optional[str] = None,
page_size: Optional[int] = None,
page: Optional[int] = None,
filter_term: Optional[str] = None,
) -> dict:
"""Get saved queries.
Args:
query_name_prefix (str, optional): Prefix for the saved query name.
page_size (int, optional): Number of results to return. Defaults to 50.
page (int, optional): Page number to begin at when searching. Defaults to 1.
filter_term (str, optional): Term used to filter the list of saved query names and the saved queries.
Returns:
dict: Saved queries results.
"""
if page_size is None:
page_size = 50
if page is None:
page = 1
args: dict = {
"pageSize": page_size,
"page": page,
}
if query_name_prefix:
args["queryNamePrefix"] = query_name_prefix
if filter_term:
args["filterTerm"] = filter_term
return self._get(self.base_path, args=args)
def add_saved_query(
self,
query: str,
query_name: str,
) -> dict:
"""Add a new saved query to the ASM platform.
Args:
query (str): Query string.
query_name (str): Saved query name.
Returns:
dict: Added saved query results.
"""
body = {
"query": query,
"queryName": query_name,
}
return self._post(self.base_path, data=body)
def get_saved_query_by_id(
self,
query_id: str,
) -> dict:
"""Get saved query by query ID.
Args:
query_id (str): The saved query's ID.
Returns:
dict: Saved query result.
"""
return self._get(f"{self.base_path}/{query_id}")
def edit_saved_query_by_id(
self,
query_id: str,
query: str,
query_name: str,
) -> dict:
"""Edit an existing saved query by query ID.
Args:
query_id (str): The saved query's ID.
query (str): New query string.
query_name (str): New saved query name.
Returns:
dict: Edited saved query result.
"""
body = {
"query": query,
"queryName": query_name,
}
return self._put(f"{self.base_path}/{query_id}", data=body)
def delete_saved_query_by_id(
self,
query_id: str,
) -> dict:
"""Delete saved query by query ID.
Args:
query_id (str): The saved query's ID.
Returns:
dict: Delete results.
"""
return self._delete(f"{self.base_path}/{query_id}")
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/asm/seeds.py 0000644 0000000 0000000 00000005363 14777466662 013636 0 ustar 00 """Interact with the Censys Seeds API."""
from typing import List, Optional
from .api import CensysAsmAPI
SEED_TYPES = ["IP_ADDRESS", "DOMAIN_NAME", "CIDR", "ASN"]
class Seeds(CensysAsmAPI):
"""Seeds API class."""
base_path = "/v1/seeds"
def get_seeds(
self, seed_type: Optional[str] = None, label: Optional[str] = None
) -> List[dict]:
"""Requests seed data.
Args:
seed_type (str):
Optional; Seed type ['IP_ADDRESS', 'DOMAIN_NAME', 'CIDR', 'ASN'].
label (str): Optional; Seed label.
Returns:
List[dict]: Seed search results.
"""
args = {}
if seed_type:
args["type"] = seed_type
if label:
args["label"] = label
return self._get(self.base_path, args=args)["seeds"]
def get_seed_by_id(self, seed_id: int) -> dict:
"""Requests seed data by ID.
Args:
seed_id (int): Seed ID to get.
Returns:
dict: Seed search result.
"""
path = f"{self.base_path}/{seed_id}"
return self._get(path)
def add_seeds(self, seeds: list, force: Optional[bool] = None) -> dict:
"""Add seeds to the ASM platform.
Args:
seeds (list): List of seed objects to add.
force (bool, optional): Forces replace operation.
Returns:
dict: Added seeds results.
"""
data = {"seeds": seeds}
args = {"force": force}
return self._post(self.base_path, args=args, data=data)
def replace_seeds_by_label(
self, label: str, seeds: list, force: Optional[bool] = None
) -> dict:
"""Replace seeds in the ASM platform by label.
Args:
label (str): Label name to replace by.
seeds (list): List of seed objects to add.
force (bool): Optional; Forces replace operation.
Returns:
dict: Added and removed seeds results.
"""
data = {"seeds": seeds}
args = {"label": label, "force": force}
return self._put(self.base_path, args=args, data=data)
def delete_seeds_by_label(self, label: str) -> dict:
"""Delete seeds in the ASM platform by label.
Args:
label (str): Label name to delete by.
Returns:
dict: Delete results.
"""
args = {"label": label}
return self._delete(self.base_path, args=args)
def delete_seed_by_id(self, seed_id: int) -> dict:
"""Delete a seed in the ASM platform by id.
Args:
seed_id (int): Seed ID to delete by.
Returns:
dict: Delete results.
"""
path = f"{self.base_path}/{seed_id}"
return self._delete(path)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/cli/__init__.py 0000644 0000000 0000000 00000001243 14777466662 014252 0 ustar 00 #!/usr/bin/env python3
# PYTHON_ARGCOMPLETE_OK
"""Interact with the Censys Search API through the command line."""
import sys
import argcomplete
from .args import get_parser
from censys.common.version import __version__
def main():
"""Main cli function."""
parser = get_parser()
# Adds autocomplete
argcomplete.autocomplete(parser)
# Executes by subcommand
args = parser.parse_args()
if args.version:
print(f"Censys Python Version: {__version__}")
sys.exit(0)
try:
args.func(args)
except KeyboardInterrupt: # pragma: no cover
sys.exit(1)
if __name__ == "__main__": # pragma: no cover
main()
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/cli/args.py 0000644 0000000 0000000 00000003556 14777466662 013460 0 ustar 00 """Interact with argparser."""
import argparse
import os
from . import commands
from censys.common.config import DEFAULT, get_config
def get_parser() -> argparse.ArgumentParser:
"""Gets ArgumentParser for CLI.
Returns:
argparse.ArgumentParser
"""
config = get_config()
auth = argparse.ArgumentParser(add_help=False)
auth.add_argument(
"--api-id",
default=os.getenv("CENSYS_API_ID") or config.get(DEFAULT, "api_id"),
required=False,
help="a Censys API ID \
(alternatively you can use the env variable CENSYS_API_ID)",
)
auth.add_argument(
"--api-secret",
default=os.getenv("CENSYS_API_SECRET") or config.get(DEFAULT, "api_secret"),
required=False,
help="a Censys API SECRET \
(alternatively you can use the env variable CENSYS_API_SECRET)",
)
asm_auth = argparse.ArgumentParser(add_help=False)
asm_auth.add_argument(
"--api-key",
default=os.getenv("CENSYS_ASM_API_KEY") or config.get(DEFAULT, "asm_api_key"),
required=False,
help="a Censys ASM API Key \
(alternatively you can use the env variable CENSYS_ASM_API_KEY)",
)
parser = argparse.ArgumentParser()
parser.add_argument(
"-v",
"--version",
action="store_true",
default=False,
help="display version",
)
def print_help(_: argparse.Namespace):
"""Prints help."""
parser.print_help()
parser.exit()
parser.set_defaults(func=print_help)
subparsers = parser.add_subparsers()
parents = {
"auth": auth,
"asm_auth": asm_auth,
}
for command in commands.__dict__.values():
try:
include_func = command.include
except AttributeError:
continue
include_func(subparsers, parents)
return parser
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/cli/commands/__init__.py 0000644 0000000 0000000 00000000257 14777466662 016057 0 ustar 00 """Censys CLI commands."""
from . import account, asm, config, hnri, search, subdomains, view
__all__ = ["account", "asm", "config", "hnri", "search", "subdomains", "view"]
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/cli/commands/account.py 0000644 0000000 0000000 00000004104 14777466662 015747 0 ustar 00 """Censys config CLI."""
import argparse
import sys
from rich import box
from rich.table import Table
from censys.cli.utils import console
from censys.common.exceptions import CensysUnauthorizedException
from censys.search.v2.api import CensysSearchAPIv2
def cli_account(args: argparse.Namespace): # pragma: no cover
"""Account subcommand.
Args:
args: Argparse Namespace.
"""
try:
client = CensysSearchAPIv2(args.api_id, args.api_secret)
account = client.account()
if args.json:
console.print_json(data=account)
else:
table = Table(
"Key", "Value", show_header=False, box=box.SQUARE, highlight=True
)
table.add_row("Email", account["email"])
table.add_row("Login ID", account["login"])
table.add_row("First Login", account["first_login"])
table.add_row("Last Login", account["last_login"][:-7])
quota = account["quota"]
table.add_row(
"Query Quota",
f"{quota['used']} / {quota['allowance']} ({quota['used']/quota['allowance'] * 100 :.2f}%)", # noqa
)
table.add_row("Quota Resets At", quota["resets_at"])
console.print(table)
sys.exit(0)
except CensysUnauthorizedException:
console.print("Failed to authenticate")
sys.exit(1)
def include(parent_parser: argparse._SubParsersAction, parents: dict):
"""Include this subcommand into the parent parser.
Args:
parent_parser (argparse._SubParsersAction): Parent parser.
parents (dict): Parent arg parsers.
"""
account_parser = parent_parser.add_parser(
"account",
description="Check Censys account details and quota",
help="check Censys account details and quota",
parents=[parents["auth"]],
)
account_parser.add_argument(
"-j", "--json", action="store_true", help="Output in JSON format"
)
account_parser.set_defaults(func=cli_account)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/cli/commands/asm.py 0000644 0000000 0000000 00000077451 14777466662 015112 0 ustar 00 """Censys ASM CLI."""
import argparse
import concurrent.futures
import csv
import json
import sys
import threading
from typing import Dict, List, Union
from xml.etree import ElementTree
from rich.progress import Progress, TaskID
from rich.prompt import Confirm, Prompt
from censys.asm.api import CensysAsmAPI
from censys.asm.inventory import InventorySearch
from censys.asm.saved_queries import SavedQueries
from censys.asm.seeds import SEED_TYPES, Seeds
from censys.cli.utils import console
from censys.common.config import DEFAULT, get_config, write_config
from censys.common.exceptions import (
CensysAsmException,
CensysSeedNotFoundException,
CensysUnauthorizedException,
)
def cli_asm_config(_: argparse.Namespace): # pragma: no cover
"""Config asm subcommand.
Args:
_: Argparse Namespace.
"""
api_key_prompt = "Censys ASM API Key"
config = get_config()
api_key = config.get(DEFAULT, "asm_api_key")
if api_key:
key_len = len(api_key) - 4
redacted_api_key = api_key.replace(api_key[:key_len], key_len * "*")
api_key_prompt = f"{api_key_prompt} [cyan]({redacted_api_key})[/cyan]"
api_key = Prompt.ask(api_key_prompt, console=console) or api_key
try:
c = CensysAsmAPI(api_key)
w = c.get_workspace_id()
console.print(f"Successfully authenticated to workspace {w}")
except CensysUnauthorizedException:
console.print("Failed to authenticate")
sys.exit(1)
if not api_key:
console.print("Please enter valid credentials")
sys.exit(1)
color = Confirm.ask(
"Do you want color output?", default=True, show_default=False, console=console
)
config.set(DEFAULT, "color", "auto" if color else "")
try:
# Assumes that login was successfully
config.set(DEFAULT, "asm_api_key", api_key)
write_config(config)
console.print("\nSuccessfully configured credentials")
sys.exit(0)
except CensysUnauthorizedException:
console.print("Failed to authenticate")
sys.exit(1)
def get_seeds_from_xml(file: str) -> List[Dict[str, str]]:
"""Get seeds from nmap xml.
Args:
file (str): Nmap xml file.
Returns:
List[Dict[str, str]]: List of seeds.
"""
tree = ElementTree.parse(file)
root = tree.getroot()
ips = set()
domains = set()
for element in root.findall("host"):
address_element = element.find("address")
hostnames_element = element.find("hostnames")
if address_element is not None and address_element.get("addrtype") == "ipv4":
ip_address = address_element.get("addr")
if ip_address:
ips.add(ip_address)
if hostnames_element is not None:
hostname_elements = hostnames_element.findall("hostname")
for hostname_element in hostname_elements:
hostname_type = hostname_element.get("type")
if hostname_type != "user":
continue
hostname = hostname_element.get("name")
if hostname:
domains.add(hostname)
return [{"value": ip, "type": "IP_ADDRESS"} for ip in ips] + [
{"value": domain, "type": "DOMAIN_NAME"} for domain in domains
]
def get_seeds_from_params(
args: argparse.Namespace, command_name: str
) -> List[Dict[str, Union[str, int]]]:
"""Get seeds from params.
Args:
args (Namespace): Argparse Namespace.
command_name (str): The name of the command getting the seeds to be processed.
Returns:
List[Dict[str, str]]: List of seeds.
"""
is_csv = args.csv
if args.input_file or args.json:
json_data = None
if args.input_file:
if args.input_file == "-":
file = sys.stdin
else:
if not args.csv and args.input_file.endswith(".csv"):
is_csv = True
file = open(args.input_file) # noqa: SIM115
if is_csv:
seeds = []
csv_reader = csv.DictReader(file, delimiter=",")
if csv_reader.fieldnames:
# Lowercase the field names
csv_reader.fieldnames = [
string.lower() for string in csv_reader.fieldnames
]
for row in csv_reader:
seeds.append(row)
else:
json_data = file.read()
else:
json_data = args.json
if json_data:
try:
seeds = json.loads(json_data)
except json.decoder.JSONDecodeError as e:
console.print(f"Invalid json {e}")
sys.exit(1)
elif args.nmap_xml:
try:
seeds = get_seeds_from_xml(args.nmap_xml)
except ElementTree.ParseError as e:
console.print(f"Invalid xml {e}")
sys.exit(1)
seeds_to_add = []
for seed in seeds:
if isinstance(seed, str):
seed = {"value": seed}
if not isinstance(seed, dict):
console.print(f"Invalid seed {seed}")
sys.exit(1)
if command_name != "delete-seeds" and "type" not in seed:
seed["type"] = args.default_type
if (
command_name != "replace-labeled-seeds"
and "label" not in seed
and "label" in args
):
seed["label"] = args.label
# The back end is really picky about sending extra fields, so we'll prune out anything it won't like.
# This makes it possible to output to CSV, edit, and then pipe the same CSV back into add-seeds, where
# we will strip the id, source, createdOn, and any other junk that might be there
#
valid_params = ["type", "value"]
if command_name == "add-seeds":
valid_params.append("label")
elif command_name == "delete-seeds" and "value" not in seed:
valid_params.append("id")
filtered_seeds = {key: seed[key] for key in seed if key in valid_params}
seeds_to_add.append(filtered_seeds)
return seeds_to_add
def console_clear_line():
"""Clear previous line in console."""
sys.stdout.write("\033[F") # Move the cursor to the previous line
sys.stdout.write("\033[K") # Clear the line
def cli_add_seeds(args: argparse.Namespace):
"""Add seed subcommand.
Args:
args (Namespace): Argparse Namespace.
"""
seeds_to_add = get_seeds_from_params(args, "add-seeds")
s = Seeds(args.api_key)
to_add_count = len(seeds_to_add)
res = s.add_seeds(seeds_to_add)
added_seeds = res["addedSeeds"]
added_count = len(added_seeds)
if not added_count:
console.print("No seeds were added. (Run with -v to get more info)")
if not args.verbose:
sys.exit(1)
else:
console.print(f"Added {added_count} seeds.")
if added_count < to_add_count:
console.print(f"Seeds not added: {to_add_count - added_count}")
if args.verbose: # pragma: no cover
console.print(
"The following seed(s) were not able to be added as they already exist or are reserved."
)
for seed in seeds_to_add:
if not any(s for s in added_seeds if seed["value"] == s["value"]):
console.print(f"{seed}")
def cli_delete_seeds(args: argparse.Namespace):
"""Delete seeds subcommand.
Args:
args (Namespace): Argparse Namespace.
"""
seeds_to_delete = get_seeds_from_params(args, "delete-seeds")
s = Seeds(args.api_key)
# Get all seeds into a dict indexed by value (for later lookups)
console.print("Getting seeds...")
seeds = s.get_seeds()
console_clear_line()
seeds_dict_indexed_by_value = {}
for seed in seeds:
seeds_dict_indexed_by_value[seed["value"]] = seed
seed_ids_to_delete = []
seed_ids_not_found = []
for seed_to_delete in seeds_to_delete:
if seed_id := seed_to_delete.get("id"):
seed_ids_to_delete.append(seed_id)
elif seed_value := seed_to_delete.get("value"):
# value may not be in current seeds - can't delete
if seed_value in seeds_dict_indexed_by_value:
seed_ids_to_delete.append(seeds_dict_indexed_by_value[seed_value]["id"])
else:
seed_ids_not_found.append(seed_value)
else:
console.print("Error, no seed id or value for seed.")
if len(seed_ids_to_delete) == 0:
console.print("No seeds to delete.")
sys.exit(0)
seed_ids_deleted = []
# Create a lock to protect shared variables
lock = threading.Lock()
def delete_seed(seed_id: int, progress: Progress, task_id: TaskID):
try:
s.delete_seed_by_id(seed_id)
with lock:
nonlocal seed_ids_deleted
seed_ids_deleted.append(seed_id)
except CensysSeedNotFoundException: # pragma: no cover
with lock:
nonlocal seed_ids_not_found
seed_ids_not_found.append(seed_id)
progress.update(task_id, advance=1)
# Create a rich Progress instance
with Progress() as progress:
progress_task_id = progress.add_task(
"[cyan]Deleting[/cyan]", total=len(seeds_to_delete)
)
tasks = []
with concurrent.futures.ThreadPoolExecutor(max_workers=25) as executor:
# Submit requests using the executor
for seed_id in seed_ids_to_delete:
if isinstance(seed_id, str): # pragma: no cover
console.print(f"Invalid seed id {seed_id}")
continue
task = executor.submit(delete_seed, seed_id, progress, progress_task_id)
tasks.append(task)
# Wait for all requests to complete
concurrent.futures.wait(tasks)
console.print(f"Deleted {len(seed_ids_deleted)} seeds.")
if len(seed_ids_not_found) > 0:
console.print(
f"Unable to delete {len(seed_ids_not_found)} seeds because they were not present."
)
def cli_delete_all_seeds(args: argparse.Namespace):
"""Delete all seeds subcommand.
Args:
args (Namespace): Argparse Namespace.
"""
if not args.force:
delete_all = Confirm.ask(
"Are you sure you want to delete all seeds?",
default=False,
show_default=True,
console=console,
)
console_clear_line()
if not delete_all:
sys.exit(1)
s = Seeds(args.api_key)
console.print("Getting seeds...")
seeds = s.get_seeds()
console_clear_line()
# Create a lock to protect shared variables
lock = threading.Lock()
seeds_delete_count = 0
def delete_seed(seed_id: int, progress: Progress, task_id: TaskID):
s.delete_seed_by_id(seed_id)
with lock:
nonlocal seeds_delete_count
seeds_delete_count += 1
progress.update(task_id, advance=1)
# Create a rich Progress instance
with Progress() as progress:
progress_task_id = progress.add_task("[cyan]Deleting[/cyan]", total=len(seeds))
tasks = []
with concurrent.futures.ThreadPoolExecutor(max_workers=25) as executor:
# Submit requests using the executor
for seed in seeds:
task = executor.submit(
delete_seed, seed["id"], progress, progress_task_id
)
tasks.append(task)
# Wait for all requests to complete
concurrent.futures.wait(tasks)
console.print(f"Deleted {seeds_delete_count} of {len(seeds)} total seeds.")
def cli_delete_seeds_with_label(args: argparse.Namespace):
"""Delete seeds with label subcommand.
Args:
args (Namespace): Argparse Namespace.
"""
s = Seeds(args.api_key)
s.delete_seeds_by_label(args.label)
console.print(f'Deleted seeds with label "{args.label}".')
def cli_replace_seeds_with_label(args: argparse.Namespace):
"""Replace seeds with label subcommand.
Args:
args (Namespace): Argparse Namespace.
"""
seeds_to_add = get_seeds_from_params(args, "replace-labeled-seeds")
s = Seeds(args.api_key)
res = s.replace_seeds_by_label(args.label, seeds_to_add, True)
console.print(
f"Removed {len(res['removedSeeds'])} seeds. Added {len(res['addedSeeds'])} seeds. Skipped {len(res['skippedReservedSeeds'])} reserved seeds."
)
if args.verbose: # pragma: no cover
added_seeds = res.get("addedSeeds", [])
if len(added_seeds) > 0:
console.print("The following seed(s) were added.")
for added_seed in added_seeds:
console.print(f" {added_seed}")
removed_seeds = res.get("removedSeeds", [])
if len(removed_seeds) > 0:
console.print("The following seed(s) were removed.")
for removed_seed in removed_seeds:
console.print(f" {removed_seed}")
skipped_seeds = res.get("skippedReservedSeeds", [])
if len(skipped_seeds) > 0:
console.print(
"The following seed(s) were not added because they are reserved."
)
for skipped_seed in skipped_seeds:
console.print(f" {skipped_seed}")
def cli_list_seeds(args: argparse.Namespace):
"""List seeds subcommand.
Args:
args (Namespace): Argparse Namespace.
"""
s = Seeds(args.api_key)
res = s.get_seeds(args.type, args.label)
if args.csv:
console.print("id,type,value,label,source,createdOn")
for seed in res:
console.print(
f"{seed['id']},{seed['type']},{seed['value']},{seed['label']},{seed['source']},{seed['createdOn']}" # noqa: E231
)
else:
console.print_json(json.dumps(res))
def add_seed_arguments(parser: argparse._SubParsersAction, is_delete=False) -> None:
"""Add seed arguments to parser.
Args:
parser (argparse._SubParsersAction): Parser.
is_delete (Boolean): Is this a delete command.
"""
if not is_delete:
parser.add_argument( # type: ignore[attr-defined]
"--default-type",
help="type of the seed(s) if type is not already provided (default: %(default)s)",
choices=SEED_TYPES,
default="IP_ADDRESS",
)
parser.add_argument("--csv", help="process input in CSV format", action="store_true") # type: ignore[attr-defined]
seeds_group = parser.add_mutually_exclusive_group(required=True) # type: ignore[attr-defined]
seeds_group.add_argument(
"--input-file",
"-i",
help="input file name containing valid seeds in JSON format, unless --csv is specified (use - for stdin)",
type=str,
)
seeds_group.add_argument(
"--json", "-j", help="input string containing valid json seeds", type=str
)
seeds_group.add_argument(
"--nmap-xml", help="input file name containing valid xml nmap output", type=str
)
def cli_list_saved_queries(args: argparse.Namespace):
"""List saved queries subcommand.
Args:
args (Namespace): Argparse Namespace.
"""
s = SavedQueries(args.api_key)
try:
res = s.get_saved_queries(
args.query_name_prefix, args.page_size, args.page, args.filter_term
)
if args.csv:
console.print("queryId,queryName,query,createdAt")
for query in res["results"]:
console.print(
f"{query['queryId']},{query['queryName']},{query['query']},{query['createdAt']}" # noqa: E231
)
else:
console.print_json(json.dumps(res))
except KeyError:
console.print("Failed to get saved queries.")
sys.exit(1)
def cli_add_saved_query(args: argparse.Namespace):
"""Add saved query subcommand.
Args:
args (Namespace): Argparse Namespace.
"""
s = SavedQueries(args.api_key)
res = s.add_saved_query(args.query, args.query_name)
try:
console.print(
f"Added saved query.\nQuery name: {res['result']['queryName']}\nQuery: {res['result']['query']}\nQuery ID: {res['result']['queryId']}\nCreated at: {res['result']['createdAt']}"
)
except (KeyError, CensysAsmException):
console.print("Failed to add saved query.")
sys.exit(1)
def cli_get_saved_query_by_id(args: argparse.Namespace):
"""Get saved query by id subcommand.
Args:
args (Namespace): Argparse Namespace.
"""
s = SavedQueries(args.api_key)
res = s.get_saved_query_by_id(args.query_id)
try:
console.print(
f"Query name: {res['result']['queryName']}\nQuery: {res['result']['query']}\nQuery ID: {res['result']['queryId']}\nCreated at: {res['result']['createdAt']}"
)
except (KeyError, CensysAsmException):
console.print("Failed to get saved query.")
sys.exit(1)
def cli_edit_saved_query_by_id(args: argparse.Namespace):
"""Edit saved query by id subcommand.
Args:
args (Namespace): Argparse Namespace.
"""
s = SavedQueries(args.api_key)
res = s.edit_saved_query_by_id(args.query_id, args.query, args.query_name)
try:
console.print(
f"Edited saved query.\nQuery name: {res['result']['queryName']}\nQuery: {res['result']['query']}\nQuery ID: {res['result']['queryId']}\nCreated at: {res['result']['createdAt']}"
)
except (KeyError, CensysAsmException):
console.print("Failed to edit saved query.")
sys.exit(1)
def cli_delete_saved_query_by_id(args: argparse.Namespace):
"""Delete saved query by id subcommand.
Args:
args (Namespace): Argparse Namespace.
"""
s = SavedQueries(args.api_key)
res = s.delete_saved_query_by_id(args.query_id)
if res == {}:
console.print(f"Deleted saved query with ID {args.query_id}.")
else:
console.print("Failed to delete saved query.")
sys.exit(1)
def cli_execute_saved_query_by_name(args: argparse.Namespace):
"""Execute saved query by name subcommand.
Args:
args (Namespace): Argparse Namespace.
"""
# do some sanity checking on page size before anything else
if args.page_size > 1000:
console.print(
"page size must be within [0,1000]. To fetch all pages, specify --pages -1 with any legal page size"
)
sys.exit(1)
s = InventorySearch(args.api_key)
q = SavedQueries(args.api_key)
# get query from name
queries = q.get_saved_queries(args.query_name, 1, 1)
results = queries.get("results")
if not results:
console.print("No saved query found with that name.")
sys.exit(1)
query = results[0]["query"]
try:
res = s.search(
None, query, args.page_size, None, args.sort, args.fields, args.pages
)
console.print_json(json.dumps(res))
except CensysAsmException:
console.print("Failed to execute saved query.")
sys.exit(1)
def cli_execute_saved_query_by_id(args: argparse.Namespace):
"""Execute saved query by id subcommand.
Args:
args (Namespace): Argparse Namespace.
"""
# do some sanity checking on page size before anything else
if args.page_size > 1000:
console.print(
"page size must be within [0,1000]. To fetch all pages, specify --pages -1 with any legal page size"
)
sys.exit(1)
s = InventorySearch(args.api_key)
q = SavedQueries(args.api_key)
try:
query_json = q.get_saved_query_by_id(args.query_id)
query = query_json["result"]["query"]
except (KeyError, CensysAsmException):
console.print("No saved query found with that ID.")
sys.exit(1)
try:
res = s.search(
None, query, args.page_size, None, args.sort, args.fields, args.pages
)
console.print_json(json.dumps(res))
except CensysAsmException:
console.print("Failed to execute saved query.")
sys.exit(1)
def cli_search(args: argparse.Namespace):
"""Inventory search subcommand.
Args:
args (Namespace): Argparse Namespace.
"""
s = InventorySearch(args.api_key)
try:
res = s.search(
args.workspaces,
args.query,
args.page_size,
args.cursor,
args.sort,
args.fields,
args.pages,
)
console.print_json(json.dumps(res))
except CensysAsmException:
console.print("Failed to execute query.")
sys.exit(1)
def include(parent_parser: argparse._SubParsersAction, parents: dict):
"""Include this subcommand into the parent parser.
Args:
parent_parser (argparse._SubParsersAction): Parent parser.
parents (dict): Parent arg parsers.
"""
asm_parser = parent_parser.add_parser(
"asm", description="Interact with the Censys ASM API", help="interact with ASM"
)
def add_verbose(parser):
parser.add_argument(
"-v",
"--verbose",
help="verbose output",
action="store_true",
)
asm_subparser = asm_parser.add_subparsers()
# Add config command
config_parser = asm_subparser.add_parser(
"config",
description="Configure Censys ASM API Settings",
help="configure Censys ASM API settings",
)
config_parser.set_defaults(func=cli_asm_config)
add_parser = asm_subparser.add_parser(
"add-seeds",
description="Add seeds to ASM",
help="add seeds",
parents=[parents["asm_auth"]],
)
add_verbose(add_parser)
add_seed_arguments(add_parser)
add_parser.add_argument(
"-l",
"--label",
help='label to apply to seeds without label (default: "")',
type=str,
default="",
)
add_parser.set_defaults(func=cli_add_seeds)
delete_parser = asm_subparser.add_parser(
"delete-seeds",
description="Delete ASM seeds",
help="delete seeds",
parents=[parents["asm_auth"]],
)
add_verbose(delete_parser)
add_seed_arguments(delete_parser, True)
delete_parser.set_defaults(func=cli_delete_seeds)
delete_all_parser = asm_subparser.add_parser(
"delete-all-seeds",
description="Delete all ASM seeds",
help="delete all seeds",
parents=[parents["asm_auth"]],
)
delete_all_parser.add_argument(
"-f",
"--force",
help="force delete all (no confirmation prompt)",
action="store_true",
)
add_verbose(delete_all_parser)
delete_all_parser.set_defaults(func=cli_delete_all_seeds)
delete_with_label_parser = asm_subparser.add_parser(
"delete-labeled-seeds",
description="Delete all ASM seeds with specified label",
help="delete all seeds having label",
parents=[parents["asm_auth"]],
)
delete_with_label_parser.add_argument(
"-l",
"--label",
help="label for which to delete all seeds",
type=str,
default="",
required=True,
)
add_verbose(delete_with_label_parser)
delete_with_label_parser.set_defaults(func=cli_delete_seeds_with_label)
replace_with_label_parser = asm_subparser.add_parser(
"replace-labeled-seeds",
description="Replace all ASM seeds with specified label with new seeds",
help="replace all seeds having label",
parents=[parents["asm_auth"]],
)
replace_with_label_parser.add_argument(
"-l",
"--label",
help="label for which to replace all seeds",
type=str,
default="",
required=True,
)
add_verbose(replace_with_label_parser)
add_seed_arguments(replace_with_label_parser)
replace_with_label_parser.set_defaults(func=cli_replace_seeds_with_label)
list_parser = asm_subparser.add_parser(
"list-seeds",
description="List all ASM seeds, optionally filtered by label and type",
help="list seeds",
parents=[parents["asm_auth"]],
)
list_parser.add_argument(
"-t",
"--type",
help="type of the seed to list, if not specified, all types returned",
choices=SEED_TYPES,
default="",
)
list_parser.add_argument(
"-l",
"--label",
help="label of seeds to list, if not specified, all labels returned",
type=str,
default="",
)
list_parser.add_argument(
"--csv", help="output in CSV format (otherwise JSON)", action="store_true"
)
add_verbose(list_parser)
list_parser.set_defaults(func=cli_list_seeds)
list_saved_queries_parser = asm_subparser.add_parser(
"list-saved-queries",
description="List all ASM saved queries, optionally filtered by query name prefix and filter term",
help="list saved queries",
parents=[parents["asm_auth"]],
)
list_saved_queries_parser.add_argument(
"--query-name-prefix",
help="Prefix for the saved query name to filter by",
type=str,
default="",
)
list_saved_queries_parser.add_argument(
"--filter-term",
help="Term used to filter the list of saved query names and the saved queries",
type=str,
default="",
)
list_saved_queries_parser.add_argument(
"--page-size",
help="Number of results to return. Defaults to 50.",
type=int,
default=50,
)
list_saved_queries_parser.add_argument(
"--page",
help="Page number to begin at when searching. Defaults to 1.",
type=int,
default=1,
)
list_saved_queries_parser.add_argument(
"--csv", help="output in CSV format (otherwise JSON)", action="store_true"
)
add_verbose(list_saved_queries_parser)
list_saved_queries_parser.set_defaults(func=cli_list_saved_queries)
add_saved_query_parser = asm_subparser.add_parser(
"add-saved-query",
description="Add a saved query to ASM",
help="add saved query",
parents=[parents["asm_auth"]],
)
add_saved_query_parser.add_argument(
"--query-name",
help="Name of the saved query",
type=str,
required=True,
)
add_saved_query_parser.add_argument(
"--query",
help="Query string",
type=str,
required=True,
)
add_verbose(add_saved_query_parser)
add_saved_query_parser.set_defaults(func=cli_add_saved_query)
get_saved_query_by_id_parser = asm_subparser.add_parser(
"get-saved-query-by-id",
description="Get a saved query by ID",
help="get saved query by ID",
parents=[parents["asm_auth"]],
)
get_saved_query_by_id_parser.add_argument(
"--query-id",
help="ID of the saved query",
type=str,
required=True,
)
add_verbose(get_saved_query_by_id_parser)
get_saved_query_by_id_parser.set_defaults(func=cli_get_saved_query_by_id)
edit_saved_query_by_id_parser = asm_subparser.add_parser(
"edit-saved-query-by-id",
description="Edit a saved query by ID",
help="edit saved query by ID",
parents=[parents["asm_auth"]],
)
edit_saved_query_by_id_parser.add_argument(
"--query-id",
help="ID of the saved query",
type=str,
required=True,
)
edit_saved_query_by_id_parser.add_argument(
"--query-name",
help="Name of the saved query",
type=str,
required=True,
)
edit_saved_query_by_id_parser.add_argument(
"--query",
help="Query string",
type=str,
required=True,
)
add_verbose(edit_saved_query_by_id_parser)
edit_saved_query_by_id_parser.set_defaults(func=cli_edit_saved_query_by_id)
delete_saved_query_by_id_parser = asm_subparser.add_parser(
"delete-saved-query-by-id",
description="Delete a saved query by ID",
help="delete saved query by ID",
parents=[parents["asm_auth"]],
)
delete_saved_query_by_id_parser.add_argument(
"--query-id",
help="ID of the saved query",
type=str,
required=True,
)
add_verbose(delete_saved_query_by_id_parser)
delete_saved_query_by_id_parser.set_defaults(func=cli_delete_saved_query_by_id)
execute_saved_query_by_name_parser = asm_subparser.add_parser(
"execute-saved-query-by-name",
description="Execute a saved query by name in inventory search",
help="execute saved query by name",
parents=[parents["asm_auth"]],
)
execute_saved_query_by_name_parser.add_argument(
"--query-name",
help="Query name",
type=str,
required=True,
)
execute_saved_query_by_name_parser.add_argument(
"--page-size",
help="Number of results to return. Defaults to 50.",
type=int,
default=50,
)
execute_saved_query_by_name_parser.add_argument(
"--sort",
help="Sort order for results",
type=List[str],
default=[],
)
execute_saved_query_by_name_parser.add_argument(
"--fields",
help="Fields to include in results",
type=List[str],
default=[],
)
execute_saved_query_by_name_parser.add_argument(
"--pages",
help="Number of pages to return. Defaults to 1.",
type=int,
default=1,
)
add_verbose(execute_saved_query_by_name_parser)
execute_saved_query_by_name_parser.set_defaults(
func=cli_execute_saved_query_by_name
)
execute_saved_query_by_id_parser = asm_subparser.add_parser(
"execute-saved-query-by-id",
description="Execute a saved query by id in inventory search",
help="execute saved query by id",
parents=[parents["asm_auth"]],
)
execute_saved_query_by_id_parser.add_argument(
"--query-id",
help="Query ID",
type=str,
required=True,
)
execute_saved_query_by_id_parser.add_argument(
"--page-size",
help="Number of results to return. Defaults to 50.",
type=int,
default=50,
)
execute_saved_query_by_id_parser.add_argument(
"--sort",
help="Sort order for results",
type=List[str],
default=[],
)
execute_saved_query_by_id_parser.add_argument(
"--fields",
help="Fields to include in results",
type=List[str],
default=[],
)
execute_saved_query_by_id_parser.add_argument(
"--pages",
help="Number of pages to return. Defaults to 1.",
type=int,
default=1,
)
add_verbose(execute_saved_query_by_id_parser)
execute_saved_query_by_id_parser.set_defaults(func=cli_execute_saved_query_by_id)
search_parser = asm_subparser.add_parser(
"search",
description="Execute a query in inventory search",
help="execute query in inventory search",
parents=[parents["asm_auth"]],
)
search_parser.add_argument(
"--query",
help="Query string",
type=str,
required=True,
)
search_parser.add_argument(
"--page-size",
help="Number of results to return. Defaults to 50.",
type=int,
default=50,
)
search_parser.add_argument(
"--cursor",
help="Cursor to use for pagination",
type=str,
default="",
)
search_parser.add_argument(
"--sort",
help="Sort order for results",
type=List[str],
default=[],
)
search_parser.add_argument(
"--fields",
help="Fields to include in results",
type=List[str],
default=[],
)
search_parser.add_argument(
"--workspaces",
help="Workspace IDs to search. Deprecated. The workspace associated with `CENSYS-API-KEY` will be used automatically.",
type=str,
required=False,
)
search_parser.add_argument(
"--pages",
help="Number of pages to return. Defaults to 1.",
type=int,
default=1,
)
add_verbose(search_parser)
search_parser.set_defaults(func=cli_search)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/cli/commands/config.py 0000644 0000000 0000000 00000006144 14777466662 015566 0 ustar 00 """Censys config CLI."""
import argparse
import os
import sys
from rich.prompt import Confirm, Prompt
from censys.cli.utils import console
from censys.common.config import DEFAULT, get_config, write_config
from censys.common.exceptions import CensysUnauthorizedException
from censys.search.v2.api import CensysSearchAPIv2
def cli_config(_: argparse.Namespace): # pragma: no cover
"""Config subcommand.
Args:
_: Argparse Namespace.
"""
api_id_prompt = "Censys API ID"
api_secret_prompt = "Censys API Secret"
config = get_config()
api_id = config.get(DEFAULT, "api_id")
api_secret = config.get(DEFAULT, "api_secret")
api_id_env = os.getenv("CENSYS_API_ID")
api_secret_env = os.getenv("CENSYS_API_SECRET")
if api_id_env is not None or api_secret_env is not None:
console.print(
"Please note environment variables (CENSYS_API_ID & CENSYS_API_SECRET) "
"will take priority over configured credentials."
)
api_id = api_id_env or api_id
api_secret = api_secret_env or api_secret
if api_id and api_secret:
redacted_id = api_id.replace(api_id[:32], 32 * "*")
redacted_secret = api_secret.replace(api_secret[:28], 28 * "*")
api_id_prompt = f"{api_id_prompt} [cyan]({redacted_id})[/cyan]"
api_secret_prompt = f"{api_secret_prompt} [cyan]({redacted_secret})[/cyan]"
api_id = Prompt.ask(api_id_prompt, console=console) or api_id
api_secret = Prompt.ask(api_secret_prompt, console=console) or api_secret
if not (api_id and api_secret):
console.print("Please enter valid credentials")
sys.exit(1)
api_id = api_id.strip()
api_secret = api_secret.strip()
color = Confirm.ask(
"Do you want color output?", default=True, show_default=False, console=console
)
config.set(DEFAULT, "color", "auto" if color else "")
try:
client = CensysSearchAPIv2(api_id, api_secret)
account = client.account()
email = account.get("email")
console.print(f"\nSuccessfully authenticated for {email}")
# Assumes that login was successfully
config.set(DEFAULT, "api_id", api_id)
config.set(DEFAULT, "api_secret", api_secret)
write_config(config)
sys.exit(0)
except CensysUnauthorizedException:
console.print("Failed to authenticate")
sys.exit(1)
except PermissionError as e:
console.print(e)
console.print(
"Cannot write config file to directory. "
+ "Please set the `CENSYS_CONFIG_PATH` environmental variable to a writeable location."
)
sys.exit(1)
def include(parent_parser: argparse._SubParsersAction, parents: dict):
"""Include this subcommand into the parent parser.
Args:
parent_parser (argparse._SubParsersAction): Parent parser.
parents (dict): Parent arg parsers.
"""
config_parser = parent_parser.add_parser(
"config",
description="Configure Censys Search API Settings",
help="configure Censys search API settings",
)
config_parser.set_defaults(func=cli_config)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/cli/commands/hnri.py 0000644 0000000 0000000 00000013124 14777466662 015255 0 ustar 00 """Censys HNRI CLI."""
import argparse
import sys
import webbrowser
from typing import Any, List, Optional, Tuple
import requests
from rich import box
from rich.table import Table
from censys.cli.utils import console
from censys.common.exceptions import CensysCLIException, CensysNotFoundException
from censys.search import CensysHosts
class CensysHNRI:
"""Searches the Censys API for the user's current IP to scan for risks."""
HIGH_RISK_DEFINITION: List[str] = ["TELNET", "REDIS", "POSTGRES", "VNC"]
MEDIUM_RISK_DEFINITION: List[str] = ["SSH", "HTTP", "HTTPS"]
def __init__(self, api_id: Optional[str] = None, api_secret: Optional[str] = None):
"""Inits CensysHNRI.
Args:
api_id (str): Optional; The API ID provided by Censys.
api_secret (str): Optional; The API secret provided by Censys.
"""
self.index = CensysHosts(api_id, api_secret)
@staticmethod
def get_current_ip() -> str:
"""Uses ipify.org to get the current IP address.
Returns:
str: IP address.
"""
response = requests.get("https://api.ipify.org?format=json")
current_ip = str(response.json().get("ip"))
return current_ip
def translate_risk(self, services: List[dict]) -> Tuple[List[dict], List[dict]]:
"""Interpret protocols to risks.
Args:
services (list): List of services.
Returns:
Tuple[list, list]: Lists of high and medium risks.
"""
high_risk = []
medium_risk = []
for service in services:
service_name = service.get("service_name")
if service_name in self.HIGH_RISK_DEFINITION:
high_risk.append(service)
elif service_name in self.MEDIUM_RISK_DEFINITION:
medium_risk.append(service)
else:
medium_risk.append(service)
return high_risk, medium_risk
def make_risks_into_table(self, title: str, risks: List[dict]) -> Table:
"""Creates a table of risks.
Args:
title (str): Title of the table.
risks (list): List of risks.
Returns:
Table: Table of risks.
"""
table = Table("Port", "Service Name", title=title, box=box.SQUARE)
for risk in risks:
table.add_row(str(risk.get("port")), risk.get("service_name"))
return table
def risks_to_string(self, high_risks: list, medium_risks: list) -> List[Any]:
"""Risks to printable string.
Args:
high_risks (list): Lists of high risks.
medium_risks (list): Lists of medium risks.
Raises:
CensysCLIException: No information/risks found.
Returns:
list: Printable objects for CLI.
"""
len_high_risk = len(high_risks)
len_medium_risk = len(medium_risks)
if len_high_risk + len_medium_risk == 0:
raise CensysCLIException
response: List[Any] = []
if len_high_risk > 0:
response.append(
self.make_risks_into_table(
":exclamation: High Risks Found",
high_risks,
)
)
else:
response.append("You don't have any High Risks in your network\n")
if len_medium_risk > 0:
response.append(
self.make_risks_into_table(
":grey_exclamation: Medium Risks Found",
medium_risks,
)
)
else:
response.append("You don't have any Medium Risks in your network\n")
return response
def view_current_ip_risks(self):
"""Gets protocol information for the current IP and returns any risks."""
current_ip = self.get_current_ip()
try:
console.print(f"Searching for information on {current_ip}...")
results = self.index.view(current_ip)
services = results.get("services", [])
high_risk, medium_risk = self.translate_risk(services)
for res in self.risks_to_string(high_risk, medium_risk):
console.print(res)
console.print(
f"\nFor more information, please visit: https://search.censys.io/hosts/{current_ip}" # noqa: E231
)
except (CensysNotFoundException, CensysCLIException):
console.print(
"[green]:white_check_mark: No Risks were found on your network[/green]"
)
def cli_hnri(args: argparse.Namespace):
"""HNRI subcommand.
Args:
args (Namespace): Argparse Namespace.
"""
if args.open:
webbrowser.open("https://search.censys.io/me")
sys.exit(0)
client = CensysHNRI(args.api_id, args.api_secret)
client.view_current_ip_risks()
def include(parent_parser: argparse._SubParsersAction, parents: dict):
"""Include this subcommand into the parent parser.
Args:
parent_parser (argparse._SubParsersAction): Parent parser.
parents (dict): Parent arg parsers.
"""
hnri_parser = parent_parser.add_parser(
"hnri",
description="Home Network Risk Identifier (H.N.R.I.)",
help="home network risk identifier",
parents=[parents["auth"]],
)
hnri_parser.add_argument(
"-O",
"--open",
action="store_true",
help="open your IP in browser",
)
hnri_parser.set_defaults(func=cli_hnri)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6691453
censys-2.2.17/censys/cli/commands/search.py 0000644 0000000 0000000 00000016036 14777466662 015567 0 ustar 00 """Censys search CLI."""
import argparse
import json
import sys
import webbrowser
from pathlib import Path
from typing import Any, Dict, List
from urllib.parse import urlencode
from censys.cli.utils import V2_INDEXES, err_console, write_file
from censys.common.exceptions import CensysCLIException
from censys.search import SearchClient
from censys.search.v2.api import CensysSearchAPIv2
Results = List[dict]
DATA_DIR = Path(__file__).parent.parent / "data"
HOSTS_AUTOCOMPLETE = DATA_DIR / "hosts_autocomplete.json"
CERTIFICATES_AUTOCOMPLETE = DATA_DIR / "certificates_autocomplete.json"
def fields_completer(
prefix: str, parsed_args: argparse.Namespace, **kwargs
) -> List[str]:
"""Fields completer.
Args:
prefix (str): Prefix to complete.
parsed_args (Namespace): Argparse Namespace.
**kwargs: Keyword arguments.
Returns:
List[str]: List of fields.
"""
index_type = parsed_args.index_type
autocomplete_json = {}
if index_type == "hosts":
with HOSTS_AUTOCOMPLETE.open() as autocomplete_file:
autocomplete_json = json.load(autocomplete_file)
elif index_type == "certificates":
with CERTIFICATES_AUTOCOMPLETE.open() as autocomplete_file:
autocomplete_json = json.load(autocomplete_file)
else:
return []
autocomplete_data = autocomplete_json.get("data", [])
fields = [
field_value
for field in autocomplete_data
if not (field_value := field["value"]).endswith(".type")
]
if not prefix:
# Returns first 20 fields if no prefix is provided
return fields[:20]
return fields
def cli_search(args: argparse.Namespace):
"""Search subcommand.
Args:
args (Namespace): Argparse Namespace.
Raises:
CensysCLIException: If invalid options are provided.
"""
index_type = args.index_type or args.query_type
if args.open:
url_query = {"q": args.query, "resource": index_type}
webbrowser.open(
f"https://search.censys.io/search?{urlencode(url_query)}" # noqa: E231
)
sys.exit(0)
if args.timeout < 1:
raise CensysCLIException("Timeout must be greater than 0.")
censys_args = {
"timeout": args.timeout,
}
if args.api_id:
censys_args["api_id"] = args.api_id
if args.api_secret:
censys_args["api_secret"] = args.api_secret
c = SearchClient(**censys_args)
search_args = {}
write_args = {"file_format": args.format, "file_path": args.output}
results: List[Dict[str, Any]] = []
index: CensysSearchAPIv2 = getattr(c.v2, index_type)
search_args.update(
{
"pages": args.pages,
"per_page": args.per_page,
"fields": args.fields,
}
)
if index_type == "hosts":
search_args.update(
{
"sort": args.sort_order,
"virtual_hosts": args.virtual_hosts,
}
)
elif index_type == "certificates":
search_args.update({"sort": args.sort})
if args.output and not args.output.endswith(".json"):
raise CensysCLIException(
"JSON is the only valid file format for Search 2.0 responses."
)
write_args.update(
{
"file_format": "json" if args.output else "screen",
}
)
with err_console.status("Searching"):
try:
for page in index.search(args.query, **search_args):
results.extend(page)
except Exception:
err_console.print_exception(max_frames=4)
except KeyboardInterrupt: # pragma: no cover
pass
try:
write_file(results, **write_args)
except ValueError as error: # pragma: no cover
err_console.print(f"Error writing log file. Error: {error}")
def include(parent_parser: argparse._SubParsersAction, parents: dict):
"""Include this subcommand into the parent parser.
Args:
parent_parser (argparse._SubParsersAction): Parent parser.
parents (dict): Parent arg parsers.
"""
search_parser = parent_parser.add_parser(
"search",
description="Query Censys Search for resource data by providing a query \
string, the resource index, and the fields to be returned",
help="query Censys search",
parents=[parents["auth"]],
)
search_parser.add_argument(
"query",
type=str,
help="a string written in Censys Search syntax",
).completer = fields_completer
index_metavar = "|".join(V2_INDEXES)
index_default = "hosts"
search_parser.add_argument(
"--index-type",
type=str,
default=index_default,
choices=V2_INDEXES,
metavar=index_metavar,
help="which resource index to query",
)
# Backwards compatibility
search_parser.add_argument(
"-f",
"--format",
type=str,
default="screen",
choices=["screen", "json"],
metavar="screen|json",
help=argparse.SUPPRESS,
)
search_parser.add_argument(
"-o",
"--output",
type=str,
help="output file path",
)
search_parser.add_argument(
"-O",
"--open",
action="store_true",
help="open query in browser",
)
search_parser.add_argument(
"--pages",
default=1,
type=int,
help="number of pages of results to return (when set to -1 returns all pages available)",
)
search_parser.add_argument(
"--per-page",
default=100,
type=int,
help="number of results to return per page",
)
search_parser.add_argument(
"--timeout",
default=30,
type=int,
help="number of seconds to wait for a response",
)
search_parser.add_argument(
"--fields",
dest="fields",
type=str,
nargs="+",
help="additional fields to return in the matching results",
).completer = fields_completer
hosts_group = search_parser.add_argument_group("hosts specific arguments")
hosts_group.add_argument(
"--sort-order",
dest="sort_order",
type=str,
default="RELEVANCE",
choices=["RELEVANCE", "ASCENDING", "DESCENDING", "RANDOM"],
help="sort order of results",
)
hosts_group.add_argument(
"--virtual-hosts",
type=str,
default="EXCLUDE",
choices=["INCLUDE", "EXCLUDE", "ONLY"],
metavar="INCLUDE|EXCLUDE|ONLY",
help="whether to include virtual hosts in the results",
)
certs_group = search_parser.add_argument_group("certificates specific arguments")
certs_group.add_argument(
"--sort",
dest="sort",
type=str,
nargs="+",
help="fields to sort by",
)
search_parser.set_defaults(func=cli_search)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6701455
censys-2.2.17/censys/cli/commands/subdomains.py 0000644 0000000 0000000 00000007033 14777466662 016463 0 ustar 00 """Censys subdomains CLI."""
import argparse
import json
import sys
from typing import List, Set
from censys.cli.utils import console, err_console
from censys.common.exceptions import (
CensysException,
CensysRateLimitExceededException,
CensysUnauthorizedException,
)
from censys.search import CensysCerts
def print_subdomains(subdomains: Set[str], as_json: bool = False):
"""Print subdomains.
Args:
subdomains (Set[str]): Subdomains.
as_json (bool): Output in JSON format.
"""
if as_json:
console.print_json(json.dumps(list(subdomains)))
else:
for subdomain in subdomains:
console.print(f" - {subdomain}") # noqa: E221
def cli_subdomains(args: argparse.Namespace): # pragma: no cover
"""Subdomain subcommand.
Args:
args: Argparse Namespace.
"""
subdomains = set()
try:
client = CensysCerts(api_id=args.api_id, api_secret=args.api_secret)
certificate_query = f"names: {args.domain}"
with err_console.status(f"Querying {args.domain} subdomains"):
query = client.search(
certificate_query, per_page=100, pages=args.pages
) # 100 is the max per page
# Flatten the result, and remove duplicates
for hits in query:
for cert in hits:
new_subdomains: List[str] = cert.get("names", [])
subdomains.update(
[
subdomain
for subdomain in new_subdomains
if subdomain.endswith(args.domain)
]
)
# Don't make console prints if we're in json mode
if not args.json:
if len(subdomains) == 0:
err_console.print(f"No subdomains found for {args.domain}")
return
console.print(
f"Found {len(subdomains)} unique subdomain(s) of {args.domain}"
)
print_subdomains(subdomains, args.json)
except CensysRateLimitExceededException:
err_console.print("Censys API rate limit exceeded")
print_subdomains(subdomains, args.json)
except CensysUnauthorizedException:
err_console.print("Invalid Censys API ID or secret")
sys.exit(1)
except CensysException as e:
err_console.print(str(e))
print_subdomains(subdomains, args.json)
sys.exit(1)
except KeyboardInterrupt:
err_console.print("Caught Ctrl-C, exiting...")
print_subdomains(subdomains, args.json)
sys.exit(1)
def include(parent_parser: argparse._SubParsersAction, parents: dict):
"""Include this subcommand into the parent parser.
Args:
parent_parser (argparse._SubParsersAction): Parent parser.
parents (dict): Parent arg parsers.
"""
subdomains_parser = parent_parser.add_parser(
"subdomains",
description="Enumerates subdomains using the Censys Search Certificates index",
help="enumerate subdomains",
parents=[parents["auth"]],
)
subdomains_parser.add_argument("domain", help="The base domain to search for")
subdomains_parser.add_argument(
"--pages", type=int, default=1, help="Max records to query"
)
subdomains_parser.add_argument(
"-j", "--json", action="store_true", help="Output in JSON format"
)
subdomains_parser.set_defaults(func=cli_subdomains)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6701455
censys-2.2.17/censys/cli/commands/view.py 0000644 0000000 0000000 00000007507 14777466662 015277 0 ustar 00 """Censys view CLI."""
import argparse
import ipaddress
import sys
import webbrowser
from censys.cli.utils import (
V2_INDEXES,
console,
err_console,
valid_datetime_type,
write_file,
)
from censys.common.exceptions import CensysCLIException
from censys.search import SearchClient
from censys.search.v2.api import CensysSearchAPIv2
def cli_view(args: argparse.Namespace):
"""Search subcommand.
Args:
args (Namespace): Argparse Namespace.
Raises:
CensysCLIException: If invalid options are provided.
"""
if args.open:
webbrowser.open(
f"https://search.censys.io/{args.index_type}/{args.document_id}" # noqa: E231
)
sys.exit(0)
censys_args = {}
if args.api_id:
censys_args["api_id"] = args.api_id
if args.api_secret:
censys_args["api_secret"] = args.api_secret
c = SearchClient(**censys_args)
index_type = args.index_type
if index_type == "hosts":
try:
ip_address = args.document_id
if "+" in ip_address:
ip_address, _ = args.document_id.split("+")
ipaddress.ip_address(ip_address)
except ValueError:
if len(args.document_id) == 64:
err_console.print(
"This is a SHA-256 certificate fingerprint. Switching to certificates index."
)
index_type = "certificates"
else:
raise CensysCLIException(
f"Invalid IP address: {args.document_id}. Please provide a valid IPv4 or IPv6 address."
)
index: CensysSearchAPIv2 = getattr(c.v2, index_type)
view_args = {}
write_args = {
"file_format": "json" if args.output else "screen",
"file_path": args.output,
}
if args.at_time:
if index_type == "hosts":
view_args["at_time"] = args.at_time
else:
err_console.print(
"The --at-time option is only supported for the hosts index. Ignoring."
)
document = index.view(args.document_id, **view_args)
try:
write_file(document, **write_args)
except ValueError as error: # pragma: no cover
console.print(f"Error writing log file. Error: {error}")
def include(parent_parser: argparse._SubParsersAction, parents: dict):
"""Include this subcommand into the parent parser.
Args:
parent_parser (argparse._SubParsersAction): Parent parser.
parents (dict): Parent arg parsers.
"""
view_parser = parent_parser.add_parser(
"view",
description="View a document in Censys Search by providing a document \
id and the resource index",
help="view document",
parents=[parents["auth"]],
)
view_parser.add_argument(
"document_id",
type=str,
help="a document id (IP address or SHA-256 certificate fingerprint) to view",
)
view_parser.add_argument(
"--index-type",
type=str,
default="hosts",
choices=V2_INDEXES,
metavar="|".join(V2_INDEXES),
help="which resource index to query",
)
view_parser.add_argument(
"-o",
"--output",
type=str,
help="json output file path",
)
view_parser.add_argument(
"-O",
"--open",
action="store_true",
help="open document in browser",
)
hosts_group = view_parser.add_argument_group("hosts specific arguments")
hosts_group.add_argument(
"--at-time",
type=valid_datetime_type,
metavar="YYYY-MM-DD (HH:mm)",
help="Fetches a document at a given point in time",
)
view_parser.set_defaults(func=cli_view)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6701455
censys-2.2.17/censys/cli/data/certificates_autocomplete.json 0000644 0000000 0000000 00000243171 14777466662 021203 0 ustar 00 {
"data": [
{
"data": {
"category": " METADATA"
},
"value": "added_at"
},
{
"data": {
"category": " METADATA"
},
"value": "labels"
},
{
"data": {
"category": " METADATA"
},
"value": "modified_at"
},
{
"data": {
"category": " METADATA"
},
"value": "parse_status"
},
{
"data": {
"category": " CERTIFICATE TRANSPARENCY LOGS"
},
"value": "ct.entries.key"
},
{
"data": {
"category": " CERTIFICATE TRANSPARENCY LOGS"
},
"value": "ct.entries.value.added_to_ct_at"
},
{
"data": {
"category": " CERTIFICATE TRANSPARENCY LOGS"
},
"value": "ct.entries.value.ct_to_censys_at"
},
{
"data": {
"category": " CERTIFICATE TRANSPARENCY LOGS"
},
"value": "ct.entries.value.index"
},
{
"data": {
"category": " MISC"
},
"value": "ever_seen_in_scan"
},
{
"data": {
"category": " MISC"
},
"value": "parent_spki_subject_fingerprint_sha256"
},
{
"data": {
"category": " MISC"
},
"value": "parsed.redacted"
},
{
"data": {
"category": " MISC"
},
"value": "parsed.serial_number_hex"
},
{
"data": {
"category": " MISC"
},
"value": "parsed.version"
},
{
"data": {
"category": " MISC"
},
"value": "precert"
},
{
"data": {
"category": " MISC"
},
"value": "spki_subject_fingerprint_sha256"
},
{
"data": {
"category": " MISC"
},
"value": "validation_level"
},
{
"data": {
"category": " FINGERPRINT"
},
"value": "fingerprint_md5"
},
{
"data": {
"category": " FINGERPRINT"
},
"value": "fingerprint_sha1"
},
{
"data": {
"category": " FINGERPRINT"
},
"value": "fingerprint_sha256"
},
{
"data": {
"category": " FINGERPRINT"
},
"value": "tbs_fingerprint_sha256"
},
{
"data": {
"category": " FINGERPRINT"
},
"value": "tbs_no_ct_fingerprint_sha256"
},
{
"data": {
"category": " BASIC INFORMATION"
},
"value": "names"
},
{
"data": {
"category": " BASIC INFORMATION"
},
"value": "parsed.issuer_dn"
},
{
"data": {
"category": " BASIC INFORMATION"
},
"value": "parsed.serial_number"
},
{
"data": {
"category": " BASIC INFORMATION"
},
"value": "parsed.subject_dn"
},
{
"data": {
"category": " BASIC INFORMATION"
},
"value": "validated_at"
},
{
"data": {
"category": " AUTHORITY INFO ACCESS (AIA)"
},
"value": "parsed.extensions.authority_info_access.issuer_urls"
},
{
"data": {
"category": " AUTHORITY INFO ACCESS (AIA)"
},
"value": "parsed.extensions.authority_info_access.ocsp_urls"
},
{
"data": {
"category": " AUTHORITY KEY ID (AKID)"
},
"value": "parsed.extensions.authority_key_id"
},
{
"data": {
"category": " BASIC CONSTRAINTS"
},
"value": "parsed.extensions.basic_constraints.is_ca"
},
{
"data": {
"category": " BASIC CONSTRAINTS"
},
"value": "parsed.extensions.basic_constraints.max_path_len"
},
{
"data": {
"category": " CABF ORGANIZATION ID EXTENSION"
},
"value": "parsed.extensions.cabf_organization_id.country"
},
{
"data": {
"category": " CABF ORGANIZATION ID EXTENSION"
},
"value": "parsed.extensions.cabf_organization_id.reference"
},
{
"data": {
"category": " CABF ORGANIZATION ID EXTENSION"
},
"value": "parsed.extensions.cabf_organization_id.scheme"
},
{
"data": {
"category": " CABF ORGANIZATION ID EXTENSION"
},
"value": "parsed.extensions.cabf_organization_id.state"
},
{
"data": {
"category": " CERTIFICATE POLICIES"
},
"value": "parsed.extensions.certificate_policies.cps"
},
{
"data": {
"category": " CERTIFICATE POLICIES"
},
"value": "parsed.extensions.certificate_policies.id"
},
{
"data": {
"category": " CERTIFICATE POLICIES"
},
"value": "parsed.extensions.certificate_policies.user_notice.explicit_text"
},
{
"data": {
"category": " CERTIFICATE POLICIES"
},
"value": "parsed.extensions.certificate_policies.user_notice.notice_reference.notice_numbers"
},
{
"data": {
"category": " CERTIFICATE POLICIES"
},
"value": "parsed.extensions.certificate_policies.user_notice.notice_reference.organization"
},
{
"data": {
"category": " CRL DISTRIBUTION POINTS"
},
"value": "parsed.extensions.crl_distribution_points"
},
{
"data": {
"category": " EMBEDDED SCTS / CT POISON"
},
"value": "parsed.extensions.ct_poison"
},
{
"data": {
"category": " EMBEDDED SCTS / CT POISON"
},
"value": "parsed.extensions.signed_certificate_timestamps.log_id"
},
{
"data": {
"category": " EMBEDDED SCTS / CT POISON"
},
"value": "parsed.extensions.signed_certificate_timestamps.signature.hash_algorithm"
},
{
"data": {
"category": " EMBEDDED SCTS / CT POISON"
},
"value": "parsed.extensions.signed_certificate_timestamps.signature.signature"
},
{
"data": {
"category": " EMBEDDED SCTS / CT POISON"
},
"value": "parsed.extensions.signed_certificate_timestamps.signature.signature_algorithm"
},
{
"data": {
"category": " EMBEDDED SCTS / CT POISON"
},
"value": "parsed.extensions.signed_certificate_timestamps.timestamp"
},
{
"data": {
"category": " EMBEDDED SCTS / CT POISON"
},
"value": "parsed.extensions.signed_certificate_timestamps.version"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.any"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.apple_code_signing"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.apple_code_signing_development"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.apple_code_signing_third_party"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.apple_crypto_development_env"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.apple_crypto_env"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.apple_crypto_maintenance_env"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.apple_crypto_production_env"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.apple_crypto_qos"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.apple_crypto_test_env"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.apple_crypto_tier0_qos"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.apple_crypto_tier1_qos"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.apple_crypto_tier2_qos"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.apple_crypto_tier3_qos"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.apple_ichat_encryption"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.apple_ichat_signing"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.apple_resource_signing"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.apple_software_update_signing"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.apple_system_identity"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.client_auth"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.code_signing"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.dvcs"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.eap_over_lan"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.eap_over_ppp"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.email_protection"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.ipsec_end_system"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.ipsec_intermediate_system_usage"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.ipsec_tunnel"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.ipsec_user"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_ca_exchange"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_cert_trust_list_signing"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_csp_signature"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_document_signing"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_drm"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_drm_individualization"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_efs_recovery"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_embedded_nt_crypto"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_encrypted_file_system"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_enrollment_agent"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_kernel_mode_code_signing"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_key_recovery_21"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_key_recovery_3"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_license_server"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_licenses"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_lifetime_signing"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_mobile_device_software"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_nt5_crypto"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_oem_whql_crypto"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_qualified_subordinate"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_root_list_signer"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_server_gated_crypto"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_sgc_serialized"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_smart_display"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_smartcard_logon"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_system_health"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_system_health_loophole"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_timestamp_signing"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.microsoft_whql_crypto"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.netscape_server_gated_crypto"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.ocsp_signing"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.sbgp_cert_aa_service_auth"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.server_auth"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.time_stamping"
},
{
"data": {
"category": " EXTENDED KEY USAGE"
},
"value": "parsed.extensions.extended_key_usage.unknown"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.directory_names.common_name"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.directory_names.country"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.directory_names.domain_component"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.directory_names.email_address"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.directory_names.given_name"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.directory_names.jurisdiction_country"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.directory_names.jurisdiction_locality"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.directory_names.jurisdiction_province"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.directory_names.locality"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.directory_names.organization"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.directory_names.organization_id"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.directory_names.organizational_unit"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.directory_names.postal_code"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.directory_names.province"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.directory_names.serial_number"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.directory_names.street_address"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.directory_names.surname"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.dns_names"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.edi_party_names.name_assigner"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.edi_party_names.party_name"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.email_addresses"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.ip_addresses"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.other_names.id"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.other_names.value"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.registered_ids"
},
{
"data": {
"category": " ISSUER ALTERNATE NAMES (IANS)"
},
"value": "parsed.extensions.issuer_alt_name.uniform_resource_identifiers"
},
{
"data": {
"category": " KEY USAGE"
},
"value": "parsed.extensions.key_usage.certificate_sign"
},
{
"data": {
"category": " KEY USAGE"
},
"value": "parsed.extensions.key_usage.content_commitment"
},
{
"data": {
"category": " KEY USAGE"
},
"value": "parsed.extensions.key_usage.crl_sign"
},
{
"data": {
"category": " KEY USAGE"
},
"value": "parsed.extensions.key_usage.data_encipherment"
},
{
"data": {
"category": " KEY USAGE"
},
"value": "parsed.extensions.key_usage.decipher_only"
},
{
"data": {
"category": " KEY USAGE"
},
"value": "parsed.extensions.key_usage.digital_signature"
},
{
"data": {
"category": " KEY USAGE"
},
"value": "parsed.extensions.key_usage.encipher_only"
},
{
"data": {
"category": " KEY USAGE"
},
"value": "parsed.extensions.key_usage.key_agreement"
},
{
"data": {
"category": " KEY USAGE"
},
"value": "parsed.extensions.key_usage.key_encipherment"
},
{
"data": {
"category": " KEY USAGE"
},
"value": "parsed.extensions.key_usage.value"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.critical"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_directory_names.common_name"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_directory_names.country"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_directory_names.domain_component"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_directory_names.email_address"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_directory_names.given_name"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_directory_names.jurisdiction_country"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_directory_names.jurisdiction_locality"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_directory_names.jurisdiction_province"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_directory_names.locality"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_directory_names.organization"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_directory_names.organization_id"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_directory_names.organizational_unit"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_directory_names.postal_code"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_directory_names.province"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_directory_names.serial_number"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_directory_names.street_address"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_directory_names.surname"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_edi_party_names.name_assigner"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_edi_party_names.party_name"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_email_addresses"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_ip_addresses.begin"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_ip_addresses.cidr"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_ip_addresses.end"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_ip_addresses.mask"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_names"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_registered_ids"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.excluded_uris"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_directory_names.common_name"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_directory_names.country"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_directory_names.domain_component"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_directory_names.email_address"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_directory_names.given_name"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_directory_names.jurisdiction_country"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_directory_names.jurisdiction_locality"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_directory_names.jurisdiction_province"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_directory_names.locality"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_directory_names.organization"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_directory_names.organization_id"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_directory_names.organizational_unit"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_directory_names.postal_code"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_directory_names.province"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_directory_names.serial_number"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_directory_names.street_address"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_directory_names.surname"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_edi_party_names.name_assigner"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_edi_party_names.party_name"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_email_addresses"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_ip_addresses.begin"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_ip_addresses.cidr"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_ip_addresses.end"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_ip_addresses.mask"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_names"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_registered_ids"
},
{
"data": {
"category": " NAME CONSTRAINTS"
},
"value": "parsed.extensions.name_constraints.permitted_uris"
},
{
"data": {
"category": " QC STATEMENTS EXTENSION"
},
"value": "parsed.extensions.qc_statements.ids"
},
{
"data": {
"category": " QC STATEMENTS EXTENSION"
},
"value": "parsed.extensions.qc_statements.parsed.etsi_compliance"
},
{
"data": {
"category": " QC STATEMENTS EXTENSION"
},
"value": "parsed.extensions.qc_statements.parsed.legislation.country_codes"
},
{
"data": {
"category": " QC STATEMENTS EXTENSION"
},
"value": "parsed.extensions.qc_statements.parsed.limit.amount"
},
{
"data": {
"category": " QC STATEMENTS EXTENSION"
},
"value": "parsed.extensions.qc_statements.parsed.limit.currency"
},
{
"data": {
"category": " QC STATEMENTS EXTENSION"
},
"value": "parsed.extensions.qc_statements.parsed.limit.currency_number"
},
{
"data": {
"category": " QC STATEMENTS EXTENSION"
},
"value": "parsed.extensions.qc_statements.parsed.limit.exponent"
},
{
"data": {
"category": " QC STATEMENTS EXTENSION"
},
"value": "parsed.extensions.qc_statements.parsed.pds_locations.language"
},
{
"data": {
"category": " QC STATEMENTS EXTENSION"
},
"value": "parsed.extensions.qc_statements.parsed.pds_locations.url"
},
{
"data": {
"category": " QC STATEMENTS EXTENSION"
},
"value": "parsed.extensions.qc_statements.parsed.retention_period"
},
{
"data": {
"category": " QC STATEMENTS EXTENSION"
},
"value": "parsed.extensions.qc_statements.parsed.sscd"
},
{
"data": {
"category": " QC STATEMENTS EXTENSION"
},
"value": "parsed.extensions.qc_statements.parsed.types.ids"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.directory_names.common_name"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.directory_names.country"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.directory_names.domain_component"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.directory_names.email_address"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.directory_names.given_name"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.directory_names.jurisdiction_country"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.directory_names.jurisdiction_locality"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.directory_names.jurisdiction_province"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.directory_names.locality"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.directory_names.organization"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.directory_names.organization_id"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.directory_names.organizational_unit"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.directory_names.postal_code"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.directory_names.province"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.directory_names.serial_number"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.directory_names.street_address"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.directory_names.surname"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.dns_names"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.edi_party_names.name_assigner"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.edi_party_names.party_name"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.email_addresses"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.ip_addresses"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.other_names.id"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.other_names.value"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.registered_ids"
},
{
"data": {
"category": " SUBJECT ALTERNATE NAMES (SANS)"
},
"value": "parsed.extensions.subject_alt_name.uniform_resource_identifiers"
},
{
"data": {
"category": " SUBJECT KEY ID (SKID)"
},
"value": "parsed.extensions.subject_key_id"
},
{
"data": {
"category": " TOR SERVICE DESCRIPTORS"
},
"value": "parsed.extensions.tor_service_descriptors.algorithm_name"
},
{
"data": {
"category": " TOR SERVICE DESCRIPTORS"
},
"value": "parsed.extensions.tor_service_descriptors.hash"
},
{
"data": {
"category": " TOR SERVICE DESCRIPTORS"
},
"value": "parsed.extensions.tor_service_descriptors.hash_bits"
},
{
"data": {
"category": " TOR SERVICE DESCRIPTORS"
},
"value": "parsed.extensions.tor_service_descriptors.onion"
},
{
"data": {
"category": " ISSUER"
},
"value": "parsed.issuer.common_name"
},
{
"data": {
"category": " ISSUER"
},
"value": "parsed.issuer.country"
},
{
"data": {
"category": " ISSUER"
},
"value": "parsed.issuer.domain_component"
},
{
"data": {
"category": " ISSUER"
},
"value": "parsed.issuer.email_address"
},
{
"data": {
"category": " ISSUER"
},
"value": "parsed.issuer.given_name"
},
{
"data": {
"category": " ISSUER"
},
"value": "parsed.issuer.jurisdiction_country"
},
{
"data": {
"category": " ISSUER"
},
"value": "parsed.issuer.jurisdiction_locality"
},
{
"data": {
"category": " ISSUER"
},
"value": "parsed.issuer.jurisdiction_province"
},
{
"data": {
"category": " ISSUER"
},
"value": "parsed.issuer.locality"
},
{
"data": {
"category": " ISSUER"
},
"value": "parsed.issuer.organization"
},
{
"data": {
"category": " ISSUER"
},
"value": "parsed.issuer.organization_id"
},
{
"data": {
"category": " ISSUER"
},
"value": "parsed.issuer.organizational_unit"
},
{
"data": {
"category": " ISSUER"
},
"value": "parsed.issuer.postal_code"
},
{
"data": {
"category": " ISSUER"
},
"value": "parsed.issuer.province"
},
{
"data": {
"category": " ISSUER"
},
"value": "parsed.issuer.serial_number"
},
{
"data": {
"category": " ISSUER"
},
"value": "parsed.issuer.street_address"
},
{
"data": {
"category": " ISSUER"
},
"value": "parsed.issuer.surname"
},
{
"data": {
"category": " SIGNATURE"
},
"value": "parsed.signature.self_signed"
},
{
"data": {
"category": " SIGNATURE"
},
"value": "parsed.signature.signature_algorithm.name"
},
{
"data": {
"category": " SIGNATURE"
},
"value": "parsed.signature.signature_algorithm.oid"
},
{
"data": {
"category": " SIGNATURE"
},
"value": "parsed.signature.valid"
},
{
"data": {
"category": " SIGNATURE"
},
"value": "parsed.signature.value"
},
{
"data": {
"category": " SUBJECT"
},
"value": "parsed.subject.common_name"
},
{
"data": {
"category": " SUBJECT"
},
"value": "parsed.subject.country"
},
{
"data": {
"category": " SUBJECT"
},
"value": "parsed.subject.domain_component"
},
{
"data": {
"category": " SUBJECT"
},
"value": "parsed.subject.email_address"
},
{
"data": {
"category": " SUBJECT"
},
"value": "parsed.subject.given_name"
},
{
"data": {
"category": " SUBJECT"
},
"value": "parsed.subject.jurisdiction_country"
},
{
"data": {
"category": " SUBJECT"
},
"value": "parsed.subject.jurisdiction_locality"
},
{
"data": {
"category": " SUBJECT"
},
"value": "parsed.subject.jurisdiction_province"
},
{
"data": {
"category": " SUBJECT"
},
"value": "parsed.subject.locality"
},
{
"data": {
"category": " SUBJECT"
},
"value": "parsed.subject.organization"
},
{
"data": {
"category": " SUBJECT"
},
"value": "parsed.subject.organization_id"
},
{
"data": {
"category": " SUBJECT"
},
"value": "parsed.subject.organizational_unit"
},
{
"data": {
"category": " SUBJECT"
},
"value": "parsed.subject.postal_code"
},
{
"data": {
"category": " SUBJECT"
},
"value": "parsed.subject.province"
},
{
"data": {
"category": " SUBJECT"
},
"value": "parsed.subject.serial_number"
},
{
"data": {
"category": " SUBJECT"
},
"value": "parsed.subject.street_address"
},
{
"data": {
"category": " SUBJECT"
},
"value": "parsed.subject.surname"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.dsa.g"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.dsa.p"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.dsa.q"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.dsa.y"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.ecdsa.b"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.ecdsa.curve"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.ecdsa.gx"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.ecdsa.gy"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.ecdsa.length"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.ecdsa.n"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.ecdsa.p"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.ecdsa.pub"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.ecdsa.x"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.ecdsa.y"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.fingerprint_sha256"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.key_algorithm.name"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.key_algorithm.oid"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.rsa.exponent"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.rsa.length"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.rsa.modulus"
},
{
"data": {
"category": " PUBLIC KEY"
},
"value": "parsed.subject_key_info.unrecognized.raw"
},
{
"data": {
"category": " UNKNOWN EXTENSIONS"
},
"value": "parsed.unknown_extensions.critical"
},
{
"data": {
"category": " UNKNOWN EXTENSIONS"
},
"value": "parsed.unknown_extensions.id"
},
{
"data": {
"category": " UNKNOWN EXTENSIONS"
},
"value": "parsed.unknown_extensions.value"
},
{
"data": {
"category": " VALIDITY PERIOD"
},
"value": "parsed.validity_period.length_seconds"
},
{
"data": {
"category": " VALIDITY PERIOD"
},
"value": "parsed.validity_period.not_after"
},
{
"data": {
"category": " VALIDITY PERIOD"
},
"value": "parsed.validity_period.not_before"
},
{
"data": {
"category": " CRL VALIDATION"
},
"value": "revocation.crl.next_update"
},
{
"data": {
"category": " CRL VALIDATION"
},
"value": "revocation.crl.reason"
},
{
"data": {
"category": " CRL VALIDATION"
},
"value": "revocation.crl.revocation_time"
},
{
"data": {
"category": " CRL VALIDATION"
},
"value": "revocation.crl.revoked"
},
{
"data": {
"category": " CRL VALIDATION"
},
"value": "revoked"
},
{
"data": {
"category": " OCSP VALIDATION"
},
"value": "revocation.ocsp.next_update"
},
{
"data": {
"category": " OCSP VALIDATION"
},
"value": "revocation.ocsp.reason"
},
{
"data": {
"category": " OCSP VALIDATION"
},
"value": "revocation.ocsp.revocation_time"
},
{
"data": {
"category": " OCSP VALIDATION"
},
"value": "revocation.ocsp.revoked"
},
{
"data": {
"category": " APPLE VALIDATION"
},
"value": "validation.apple.chains.sha256fp"
},
{
"data": {
"category": " APPLE VALIDATION"
},
"value": "validation.apple.ever_valid"
},
{
"data": {
"category": " APPLE VALIDATION"
},
"value": "validation.apple.had_trusted_path"
},
{
"data": {
"category": " APPLE VALIDATION"
},
"value": "validation.apple.has_trusted_path"
},
{
"data": {
"category": " APPLE VALIDATION"
},
"value": "validation.apple.in_revocation_set"
},
{
"data": {
"category": " APPLE VALIDATION"
},
"value": "validation.apple.is_valid"
},
{
"data": {
"category": " APPLE VALIDATION"
},
"value": "validation.apple.parents"
},
{
"data": {
"category": " CHROME VALIDATION"
},
"value": "validation.chrome.chains.sha256fp"
},
{
"data": {
"category": " CHROME VALIDATION"
},
"value": "validation.chrome.ever_valid"
},
{
"data": {
"category": " CHROME VALIDATION"
},
"value": "validation.chrome.had_trusted_path"
},
{
"data": {
"category": " CHROME VALIDATION"
},
"value": "validation.chrome.has_trusted_path"
},
{
"data": {
"category": " CHROME VALIDATION"
},
"value": "validation.chrome.in_revocation_set"
},
{
"data": {
"category": " CHROME VALIDATION"
},
"value": "validation.chrome.is_valid"
},
{
"data": {
"category": " CHROME VALIDATION"
},
"value": "validation.chrome.parents"
},
{
"data": {
"category": " MICROSOFT VALIDATION"
},
"value": "validation.microsoft.chains.sha256fp"
},
{
"data": {
"category": " MICROSOFT VALIDATION"
},
"value": "validation.microsoft.ever_valid"
},
{
"data": {
"category": " MICROSOFT VALIDATION"
},
"value": "validation.microsoft.had_trusted_path"
},
{
"data": {
"category": " MICROSOFT VALIDATION"
},
"value": "validation.microsoft.has_trusted_path"
},
{
"data": {
"category": " MICROSOFT VALIDATION"
},
"value": "validation.microsoft.in_revocation_set"
},
{
"data": {
"category": " MICROSOFT VALIDATION"
},
"value": "validation.microsoft.is_valid"
},
{
"data": {
"category": " MICROSOFT VALIDATION"
},
"value": "validation.microsoft.parents"
},
{
"data": {
"category": " NSS (FIREFOX) VALIDATION"
},
"value": "validation.nss.chains.sha256fp"
},
{
"data": {
"category": " NSS (FIREFOX) VALIDATION"
},
"value": "validation.nss.ever_valid"
},
{
"data": {
"category": " NSS (FIREFOX) VALIDATION"
},
"value": "validation.nss.had_trusted_path"
},
{
"data": {
"category": " NSS (FIREFOX) VALIDATION"
},
"value": "validation.nss.has_trusted_path"
},
{
"data": {
"category": " NSS (FIREFOX) VALIDATION"
},
"value": "validation.nss.in_revocation_set"
},
{
"data": {
"category": " NSS (FIREFOX) VALIDATION"
},
"value": "validation.nss.is_valid"
},
{
"data": {
"category": " NSS (FIREFOX) VALIDATION"
},
"value": "validation.nss.parents"
},
{
"data": {
"category": " ZLINT"
},
"value": "zlint.errors_present"
},
{
"data": {
"category": " ZLINT"
},
"value": "zlint.failed_lints"
},
{
"data": {
"category": " ZLINT"
},
"value": "zlint.fatals_present"
},
{
"data": {
"category": " ZLINT"
},
"value": "zlint.notices_present"
},
{
"data": {
"category": " ZLINT"
},
"value": "zlint.timestamp"
},
{
"data": {
"category": " ZLINT"
},
"value": "zlint.version"
},
{
"data": {
"category": " ZLINT"
},
"value": "zlint.warnings_present"
}
]
}
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6711454
censys-2.2.17/censys/cli/data/hosts_autocomplete.json 0000644 0000000 0000000 00001473030 14777466662 017676 0 ustar 00 {
"data": [
{
"data": {
"category": " HOST INFORMATION"
},
"value": "ip"
},
{
"data": {
"category": " HOST INFORMATION"
},
"value": "ip.type"
},
{
"data": {
"category": " HOST INFORMATION"
},
"value": "name"
},
{
"data": {
"category": " SERVICE INFORMATION"
},
"value": "services.banner"
},
{
"data": {
"category": " SERVICE INFORMATION"
},
"value": "services.banner_hex"
},
{
"data": {
"category": " SERVICE INFORMATION"
},
"value": "services.extended_service_name"
},
{
"data": {
"category": " SERVICE INFORMATION"
},
"value": "services.perspective_id"
},
{
"data": {
"category": " SERVICE INFORMATION"
},
"value": "services.port"
},
{
"data": {
"category": " SERVICE INFORMATION"
},
"value": "services.port.type"
},
{
"data": {
"category": " SERVICE INFORMATION"
},
"value": "services.service_name"
},
{
"data": {
"category": " SERVICE INFORMATION"
},
"value": "services.source_ip"
},
{
"data": {
"category": " SERVICE INFORMATION"
},
"value": "services.source_ip.type"
},
{
"data": {
"category": " SERVICE INFORMATION"
},
"value": "services.transport_protocol"
},
{
"data": {
"category": " SERVICE INFORMATION"
},
"value": "services.truncated"
},
{
"data": {
"category": " SERVICE INFORMATION"
},
"value": "services.truncated.type"
},
{
"data": {
"category": " SERVICE INFORMATION"
},
"value": "services.banner_grab.banner"
},
{
"data": {
"category": " SERVICE INFORMATION"
},
"value": "services.banner_grab.transport"
},
{
"data": {
"category": " HOST DNS"
},
"value": "dns.names"
},
{
"data": {
"category": " HOST DNS"
},
"value": "dns.reverse_dns.names"
},
{
"data": {
"category": " HOST DNS"
},
"value": "dns.reverse_dns.resolved_at"
},
{
"data": {
"category": " HOST DNS"
},
"value": "dns.reverse_dns.resolved_at.type"
},
{
"data": {
"category": " HOST LOCATION"
},
"value": "location.city"
},
{
"data": {
"category": " HOST LOCATION"
},
"value": "location.continent"
},
{
"data": {
"category": " HOST LOCATION"
},
"value": "location.continent.type"
},
{
"data": {
"category": " HOST LOCATION"
},
"value": "location.coordinates.latitude"
},
{
"data": {
"category": " HOST LOCATION"
},
"value": "location.coordinates.latitude.type"
},
{
"data": {
"category": " HOST LOCATION"
},
"value": "location.coordinates.longitude"
},
{
"data": {
"category": " HOST LOCATION"
},
"value": "location.coordinates.longitude.type"
},
{
"data": {
"category": " HOST LOCATION"
},
"value": "location.country"
},
{
"data": {
"category": " HOST LOCATION"
},
"value": "location.country_code"
},
{
"data": {
"category": " HOST LOCATION"
},
"value": "location.country_code.type"
},
{
"data": {
"category": " HOST LOCATION"
},
"value": "location.postal_code"
},
{
"data": {
"category": " HOST LOCATION"
},
"value": "location.postal_code.type"
},
{
"data": {
"category": " HOST LOCATION"
},
"value": "location.province"
},
{
"data": {
"category": " HOST LOCATION"
},
"value": "location.registered_country"
},
{
"data": {
"category": " HOST LOCATION"
},
"value": "location.registered_country_code"
},
{
"data": {
"category": " HOST LOCATION"
},
"value": "location.registered_country_code.type"
},
{
"data": {
"category": " HOST LOCATION"
},
"value": "location.timezone"
},
{
"data": {
"category": " HOST OPERATING SYSTEM"
},
"value": "operating_system.component_uniform_resource_identifiers"
},
{
"data": {
"category": " HOST OPERATING SYSTEM"
},
"value": "operating_system.cpe"
},
{
"data": {
"category": " HOST OPERATING SYSTEM"
},
"value": "operating_system.edition"
},
{
"data": {
"category": " HOST OPERATING SYSTEM"
},
"value": "operating_system.language"
},
{
"data": {
"category": " HOST OPERATING SYSTEM"
},
"value": "operating_system.other.key"
},
{
"data": {
"category": " HOST OPERATING SYSTEM"
},
"value": "operating_system.other.value"
},
{
"data": {
"category": " HOST OPERATING SYSTEM"
},
"value": "operating_system.part"
},
{
"data": {
"category": " HOST OPERATING SYSTEM"
},
"value": "operating_system.part.type"
},
{
"data": {
"category": " HOST OPERATING SYSTEM"
},
"value": "operating_system.product"
},
{
"data": {
"category": " HOST OPERATING SYSTEM"
},
"value": "operating_system.source"
},
{
"data": {
"category": " HOST OPERATING SYSTEM"
},
"value": "operating_system.sw_edition"
},
{
"data": {
"category": " HOST OPERATING SYSTEM"
},
"value": "operating_system.target_hw"
},
{
"data": {
"category": " HOST OPERATING SYSTEM"
},
"value": "operating_system.target_sw"
},
{
"data": {
"category": " HOST OPERATING SYSTEM"
},
"value": "operating_system.update"
},
{
"data": {
"category": " HOST OPERATING SYSTEM"
},
"value": "operating_system.vendor"
},
{
"data": {
"category": " HOST OPERATING SYSTEM"
},
"value": "operating_system.version"
},
{
"data": {
"category": " HOST AUTONOMOUS SYSTEM"
},
"value": "autonomous_system.asn"
},
{
"data": {
"category": " HOST AUTONOMOUS SYSTEM"
},
"value": "autonomous_system.asn.type"
},
{
"data": {
"category": " HOST AUTONOMOUS SYSTEM"
},
"value": "autonomous_system.bgp_prefix"
},
{
"data": {
"category": " HOST AUTONOMOUS SYSTEM"
},
"value": "autonomous_system.country_code"
},
{
"data": {
"category": " HOST AUTONOMOUS SYSTEM"
},
"value": "autonomous_system.country_code.type"
},
{
"data": {
"category": " HOST AUTONOMOUS SYSTEM"
},
"value": "autonomous_system.description"
},
{
"data": {
"category": " HOST AUTONOMOUS SYSTEM"
},
"value": "autonomous_system.name"
},
{
"data": {
"category": " HOST AUTONOMOUS SYSTEM"
},
"value": "autonomous_system.organization"
},
{
"data": {
"category": " TEAM SPECIFIC FIELDS"
},
"value": "tags"
},
{
"data": {
"category": " TLS"
},
"value": "services.certificate"
},
{
"data": {
"category": " TLS"
},
"value": "services.jarm.cipher_and_version_fingerprint"
},
{
"data": {
"category": " TLS"
},
"value": "services.jarm.fingerprint"
},
{
"data": {
"category": " TLS"
},
"value": "services.jarm.observed_at"
},
{
"data": {
"category": " TLS"
},
"value": "services.jarm.observed_at.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.jarm.tls_extensions_sha256"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.added_at"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.added_at.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.ct.entries"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.ct.entries.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.ct.entries.key"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.ct.entries.value.added_to_ct_at"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.ct.entries.value.added_to_ct_at.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.ct.entries.value.ct_to_censys_at"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.ct.entries.value.ct_to_censys_at.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.ct.entries.value.index"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.ct.entries.value.index.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.ever_seen_in_scan"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.ever_seen_in_scan.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.fingerprint_md5"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.fingerprint_sha1"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.fingerprint_sha256"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.modified_at"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.modified_at.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.names"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parent_spki_subject_fingerprint_sha256"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parse_status"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.authority_info_access.issuer_urls"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.authority_info_access.ocsp_urls"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.authority_key_id"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.basic_constraints.is_ca"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.basic_constraints.is_ca.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.basic_constraints.max_path_len"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.basic_constraints.max_path_len.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.cabf_organization_id.country"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.cabf_organization_id.reference"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.cabf_organization_id.scheme"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.cabf_organization_id.state"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.certificate_policies"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.certificate_policies.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.certificate_policies.cps"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.certificate_policies.id"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.certificate_policies.user_notice"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.certificate_policies.user_notice.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.certificate_policies.user_notice.explicit_text"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.certificate_policies.user_notice.notice_reference.notice_numbers"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.certificate_policies.user_notice.notice_reference.notice_numbers.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.certificate_policies.user_notice.notice_reference.organization"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.crl_distribution_points"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.ct_poison"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.ct_poison.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.any"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.any.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_code_signing"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_code_signing.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_code_signing_development"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_code_signing_development.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_code_signing_third_party"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_code_signing_third_party.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_crypto_development_env"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_crypto_development_env.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_crypto_env"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_crypto_env.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_crypto_maintenance_env"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_crypto_maintenance_env.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_crypto_production_env"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_crypto_production_env.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_crypto_qos"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_crypto_qos.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_crypto_test_env"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_crypto_test_env.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_crypto_tier0_qos"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_crypto_tier0_qos.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_crypto_tier1_qos"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_crypto_tier1_qos.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_crypto_tier2_qos"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_crypto_tier2_qos.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_crypto_tier3_qos"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_crypto_tier3_qos.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_ichat_encryption"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_ichat_encryption.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_ichat_signing"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_ichat_signing.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_resource_signing"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_resource_signing.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_software_update_signing"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_software_update_signing.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_system_identity"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.apple_system_identity.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.client_auth"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.client_auth.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.code_signing"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.code_signing.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.dvcs"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.dvcs.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.eap_over_lan"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.eap_over_lan.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.eap_over_ppp"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.eap_over_ppp.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.email_protection"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.email_protection.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.ipsec_end_system"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.ipsec_end_system.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.ipsec_intermediate_system_usage"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.ipsec_intermediate_system_usage.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.ipsec_tunnel"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.ipsec_tunnel.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.ipsec_user"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.ipsec_user.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_ca_exchange"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_ca_exchange.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_cert_trust_list_signing"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_cert_trust_list_signing.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_csp_signature"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_csp_signature.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_document_signing"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_document_signing.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_drm"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_drm.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_drm_individualization"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_drm_individualization.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_efs_recovery"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_efs_recovery.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_embedded_nt_crypto"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_embedded_nt_crypto.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_encrypted_file_system"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_encrypted_file_system.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_enrollment_agent"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_enrollment_agent.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_kernel_mode_code_signing"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_kernel_mode_code_signing.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_key_recovery_21"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_key_recovery_21.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_key_recovery_3"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_key_recovery_3.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_license_server"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_license_server.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_licenses"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_licenses.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_lifetime_signing"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_lifetime_signing.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_mobile_device_software"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_mobile_device_software.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_nt5_crypto"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_nt5_crypto.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_oem_whql_crypto"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_oem_whql_crypto.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_qualified_subordinate"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_qualified_subordinate.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_root_list_signer"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_root_list_signer.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_server_gated_crypto"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_server_gated_crypto.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_sgc_serialized"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_sgc_serialized.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_smart_display"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_smart_display.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_smartcard_logon"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_smartcard_logon.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_system_health"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_system_health.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_system_health_loophole"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_system_health_loophole.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_timestamp_signing"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_timestamp_signing.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_whql_crypto"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.microsoft_whql_crypto.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.netscape_server_gated_crypto"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.netscape_server_gated_crypto.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.ocsp_signing"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.ocsp_signing.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.sbgp_cert_aa_service_auth"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.sbgp_cert_aa_service_auth.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.server_auth"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.server_auth.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.time_stamping"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.time_stamping.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.extended_key_usage.unknown"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names.common_name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names.country"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names.domain_component"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names.email_address"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names.given_name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names.jurisdiction_country"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names.jurisdiction_locality"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names.jurisdiction_province"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names.locality"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names.organization"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names.organization_id"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names.organizational_unit"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names.postal_code"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names.postal_code.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names.province"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names.serial_number"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names.serial_number.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names.street_address"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.directory_names.surname"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.dns_names"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.edi_party_names"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.edi_party_names.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.edi_party_names.name_assigner"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.edi_party_names.party_name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.email_addresses"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.ip_addresses"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.other_names"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.other_names.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.other_names.id"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.other_names.value"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.registered_ids"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.issuer_alt_name.uniform_resource_identifiers"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.key_usage.certificate_sign"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.key_usage.certificate_sign.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.key_usage.content_commitment"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.key_usage.content_commitment.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.key_usage.crl_sign"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.key_usage.crl_sign.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.key_usage.data_encipherment"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.key_usage.data_encipherment.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.key_usage.decipher_only"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.key_usage.decipher_only.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.key_usage.digital_signature"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.key_usage.digital_signature.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.key_usage.encipher_only"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.key_usage.encipher_only.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.key_usage.key_agreement"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.key_usage.key_agreement.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.key_usage.key_encipherment"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.key_usage.key_encipherment.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.key_usage.value"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.key_usage.value.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.critical"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.critical.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names.common_name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names.country"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names.domain_component"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names.email_address"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names.given_name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names.jurisdiction_country"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names.jurisdiction_locality"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names.jurisdiction_province"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names.locality"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names.organization"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names.organization_id"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names.organizational_unit"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names.postal_code"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names.postal_code.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names.province"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names.serial_number"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names.serial_number.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names.street_address"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_directory_names.surname"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_edi_party_names"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_edi_party_names.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_edi_party_names.name_assigner"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_edi_party_names.party_name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_email_addresses"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_ip_addresses"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_ip_addresses.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_ip_addresses.begin"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_ip_addresses.cidr"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_ip_addresses.end"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_ip_addresses.mask"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_names"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_registered_ids"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.excluded_uris"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names.common_name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names.country"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names.domain_component"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names.email_address"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names.given_name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names.jurisdiction_country"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names.jurisdiction_locality"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names.jurisdiction_province"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names.locality"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names.organization"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names.organization_id"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names.organizational_unit"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names.postal_code"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names.postal_code.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names.province"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names.serial_number"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names.serial_number.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names.street_address"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_directory_names.surname"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_edi_party_names"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_edi_party_names.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_edi_party_names.name_assigner"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_edi_party_names.party_name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_email_addresses"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_ip_addresses"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_ip_addresses.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_ip_addresses.begin"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_ip_addresses.cidr"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_ip_addresses.end"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_ip_addresses.mask"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_names"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_registered_ids"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.name_constraints.permitted_uris"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.ids"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.etsi_compliance"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.etsi_compliance.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.legislation"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.legislation.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.legislation.country_codes"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.limit"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.limit.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.limit.amount"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.limit.amount.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.limit.currency"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.limit.currency_number"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.limit.currency_number.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.limit.exponent"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.limit.exponent.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.pds_locations"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.pds_locations.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.pds_locations.language"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.pds_locations.url"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.retention_period"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.retention_period.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.sscd"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.sscd.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.types"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.types.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.qc_statements.parsed.types.ids"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.signed_certificate_timestamps"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.signed_certificate_timestamps.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.signed_certificate_timestamps.log_id"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.signed_certificate_timestamps.signature.hash_algorithm"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.signed_certificate_timestamps.signature.signature"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.signed_certificate_timestamps.signature.signature_algorithm"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.signed_certificate_timestamps.timestamp"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.signed_certificate_timestamps.timestamp.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.signed_certificate_timestamps.version"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.signed_certificate_timestamps.version.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names.common_name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names.country"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names.domain_component"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names.email_address"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names.given_name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names.jurisdiction_country"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names.jurisdiction_locality"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names.jurisdiction_province"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names.locality"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names.organization"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names.organization_id"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names.organizational_unit"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names.postal_code"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names.postal_code.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names.province"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names.serial_number"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names.serial_number.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names.street_address"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.directory_names.surname"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.dns_names"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.edi_party_names"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.edi_party_names.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.edi_party_names.name_assigner"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.edi_party_names.party_name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.email_addresses"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.ip_addresses"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.other_names"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.other_names.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.other_names.id"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.other_names.value"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.registered_ids"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_alt_name.uniform_resource_identifiers"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.subject_key_id"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.tor_service_descriptors"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.tor_service_descriptors.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.tor_service_descriptors.algorithm_name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.tor_service_descriptors.hash"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.tor_service_descriptors.hash_bits"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.tor_service_descriptors.hash_bits.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.extensions.tor_service_descriptors.onion"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.issuer.common_name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.issuer.country"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.issuer.domain_component"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.issuer.email_address"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.issuer.given_name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.issuer.jurisdiction_country"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.issuer.jurisdiction_locality"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.issuer.jurisdiction_province"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.issuer.locality"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.issuer.organization"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.issuer.organization_id"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.issuer.organizational_unit"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.issuer.postal_code"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.issuer.postal_code.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.issuer.province"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.issuer.serial_number"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.issuer.serial_number.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.issuer.street_address"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.issuer.surname"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.issuer_dn"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.redacted"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.redacted.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.serial_number"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.serial_number_hex"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.signature.self_signed"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.signature.self_signed.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.signature.signature_algorithm.name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.signature.signature_algorithm.oid"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.signature.valid"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.signature.valid.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.signature.value"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject.common_name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject.country"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject.domain_component"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject.email_address"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject.given_name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject.jurisdiction_country"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject.jurisdiction_locality"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject.jurisdiction_province"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject.locality"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject.organization"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject.organization_id"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject.organizational_unit"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject.postal_code"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject.postal_code.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject.province"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject.serial_number"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject.serial_number.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject.street_address"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject.surname"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_dn"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.dsa.g"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.dsa.p"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.dsa.q"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.dsa.y"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.ecdsa.b"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.ecdsa.curve"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.ecdsa.gx"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.ecdsa.gy"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.ecdsa.length"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.ecdsa.length.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.ecdsa.n"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.ecdsa.p"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.ecdsa.pub"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.ecdsa.x"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.ecdsa.y"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.fingerprint_sha256"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.key_algorithm.name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.key_algorithm.oid"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.rsa.exponent"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.rsa.exponent.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.rsa.length"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.rsa.length.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.rsa.modulus"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.subject_key_info.unrecognized.raw"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.unknown_extensions"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.unknown_extensions.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.unknown_extensions.critical"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.unknown_extensions.critical.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.unknown_extensions.id"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.unknown_extensions.value"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.validity_period.length_seconds"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.validity_period.length_seconds.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.validity_period.not_after"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.validity_period.not_after.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.validity_period.not_before"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.validity_period.not_before.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.version"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.parsed.version.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.precert"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.precert.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.revocation.crl.next_update"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.revocation.crl.next_update.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.revocation.crl.reason"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.revocation.crl.revocation_time"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.revocation.crl.revocation_time.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.revocation.crl.revoked"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.revocation.crl.revoked.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.revocation.ocsp.next_update"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.revocation.ocsp.next_update.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.revocation.ocsp.reason"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.revocation.ocsp.revocation_time"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.revocation.ocsp.revocation_time.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.revocation.ocsp.revoked"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.revocation.ocsp.revoked.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.revoked"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.revoked.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.spki_subject_fingerprint_sha256"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.tbs_fingerprint_sha256"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.tbs_no_ct_fingerprint_sha256"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validated_at"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validated_at.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.apple.chains"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.apple.chains.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.apple.chains.sha256fp"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.apple.ever_valid"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.apple.ever_valid.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.apple.had_trusted_path"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.apple.had_trusted_path.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.apple.has_trusted_path"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.apple.has_trusted_path.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.apple.in_revocation_set"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.apple.in_revocation_set.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.apple.is_valid"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.apple.is_valid.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.apple.parents"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.apple.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.chrome.chains"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.chrome.chains.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.chrome.chains.sha256fp"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.chrome.ever_valid"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.chrome.ever_valid.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.chrome.had_trusted_path"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.chrome.had_trusted_path.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.chrome.has_trusted_path"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.chrome.has_trusted_path.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.chrome.in_revocation_set"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.chrome.in_revocation_set.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.chrome.is_valid"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.chrome.is_valid.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.chrome.parents"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.chrome.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.microsoft.chains"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.microsoft.chains.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.microsoft.chains.sha256fp"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.microsoft.ever_valid"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.microsoft.ever_valid.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.microsoft.had_trusted_path"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.microsoft.had_trusted_path.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.microsoft.has_trusted_path"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.microsoft.has_trusted_path.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.microsoft.in_revocation_set"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.microsoft.in_revocation_set.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.microsoft.is_valid"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.microsoft.is_valid.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.microsoft.parents"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.microsoft.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.nss.chains"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.nss.chains.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.nss.chains.sha256fp"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.nss.ever_valid"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.nss.ever_valid.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.nss.had_trusted_path"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.nss.had_trusted_path.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.nss.has_trusted_path"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.nss.has_trusted_path.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.nss.in_revocation_set"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.nss.in_revocation_set.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.nss.is_valid"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.nss.is_valid.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.nss.parents"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation.nss.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.validation_level"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.zlint.errors_present"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.zlint.errors_present.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.zlint.failed_lints"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.zlint.fatals_present"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.zlint.fatals_present.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.zlint.notices_present"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.zlint.notices_present.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.zlint.timestamp"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.zlint.timestamp.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.zlint.version"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.zlint.version.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.zlint.warnings_present"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificate.zlint.warnings_present.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.chain.fingerprint"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.chain.fingerprint.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.chain.issuer_dn"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.chain.subject_dn"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.chain_fps_sha_256"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.chain_fps_sha_256.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.fingerprint"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.fingerprint.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.issuer.common_name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.issuer.country"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.issuer.domain_component"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.issuer.email_address"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.issuer.jurisdiction_country"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.issuer.jurisdiction_locality"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.issuer.jurisdiction_province"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.issuer.locality"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.issuer.organization"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.issuer.organization_id"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.issuer.organizational_unit"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.issuer.postal_code"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.issuer.postal_code.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.issuer.province"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.issuer.serial_number"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.issuer.serial_number.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.issuer.street_address"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.issuer_dn"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.names"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.pubkey_algorithm"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.pubkey_bit_size"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.pubkey_bit_size.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.dsa.g"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.dsa.p"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.dsa.q"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.dsa.y"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.ecdsa.b"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.ecdsa.curve"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.ecdsa.curve.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.ecdsa.gx"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.ecdsa.gy"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.ecdsa.length"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.ecdsa.length.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.ecdsa.n"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.ecdsa.p"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.ecdsa.pub"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.ecdsa.x"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.ecdsa.y"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.fingerprint"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.key_algorithm"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.key_algorithm.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.rsa.exponent"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.rsa.length"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.rsa.length.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.public_key.rsa.modulus"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.signature.self_signed"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.signature.self_signed.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.signature.signature_algorithm"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.signature.signature_algorithm.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.subject.common_name"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.subject.country"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.subject.domain_component"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.subject.email_address"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.subject.jurisdiction_country"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.subject.jurisdiction_locality"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.subject.jurisdiction_province"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.subject.locality"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.subject.organization"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.subject.organization_id"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.subject.organizational_unit"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.subject.postal_code"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.subject.postal_code.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.subject.province"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.subject.serial_number"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.subject.serial_number.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.subject.street_address"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.subject_dn"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.tbs_fingerprint"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_data.tbs_fingerprint.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_fp_sha_256"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.certificates.leaf_fp_sha_256.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.cipher_selected"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.ja3s"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.presented_chain.fingerprint"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.presented_chain.fingerprint.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.presented_chain.issuer_dn"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.presented_chain.subject_dn"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.server_key_exchange.ec_params.named_curve"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.server_key_exchange.ec_params.named_curve.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.server_key_exchange.ec_params.public_key"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.session_ticket.length"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.session_ticket.length.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.session_ticket.lifetime_hint"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.session_ticket.lifetime_hint.type"
},
{
"data": {
"category": " TLS"
},
"value": "services.tls.version_selected"
},
{
"data": {
"category": " SOFTWARE"
},
"value": "services.software"
},
{
"data": {
"category": " SOFTWARE"
},
"value": "services.software.type"
},
{
"data": {
"category": " SOFTWARE"
},
"value": "services.software.component_uniform_resource_identifiers"
},
{
"data": {
"category": " SOFTWARE"
},
"value": "services.software.cpe"
},
{
"data": {
"category": " SOFTWARE"
},
"value": "services.software.edition"
},
{
"data": {
"category": " SOFTWARE"
},
"value": "services.software.language"
},
{
"data": {
"category": " SOFTWARE"
},
"value": "services.software.other.key"
},
{
"data": {
"category": " SOFTWARE"
},
"value": "services.software.other.value"
},
{
"data": {
"category": " SOFTWARE"
},
"value": "services.software.part"
},
{
"data": {
"category": " SOFTWARE"
},
"value": "services.software.part.type"
},
{
"data": {
"category": " SOFTWARE"
},
"value": "services.software.product"
},
{
"data": {
"category": " SOFTWARE"
},
"value": "services.software.source"
},
{
"data": {
"category": " SOFTWARE"
},
"value": "services.software.sw_edition"
},
{
"data": {
"category": " SOFTWARE"
},
"value": "services.software.target_hw"
},
{
"data": {
"category": " SOFTWARE"
},
"value": "services.software.target_sw"
},
{
"data": {
"category": " SOFTWARE"
},
"value": "services.software.update"
},
{
"data": {
"category": " SOFTWARE"
},
"value": "services.software.vendor"
},
{
"data": {
"category": " SOFTWARE"
},
"value": "services.software.version"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.request.body"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.request.headers"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.request.headers.type"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.request.headers.key"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.request.headers.value.headers"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.request.method"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.request.uri"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.response.body"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.response.body_hashes"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.response.body_size"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.response.body_size.type"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.response.favicons.md5_hash"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.response.favicons.md5_hash.type"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.response.favicons.name"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.response.favicons.size"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.response.favicons.size.type"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.response.headers"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.response.headers.type"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.response.headers.key"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.response.headers.value.headers"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.response.html_tags"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.response.html_title"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.response.protocol"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.response.status_code"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.response.status_code.type"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.response.status_reason"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.supports_http2"
},
{
"data": {
"category": " HTTP"
},
"value": "services.http.supports_http2.type"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.algorithm_selection.client_to_server_alg_group.cipher"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.algorithm_selection.client_to_server_alg_group.compression"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.algorithm_selection.client_to_server_alg_group.mac"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.algorithm_selection.host_key_algorithm"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.algorithm_selection.kex_algorithm"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.algorithm_selection.server_to_client_alg_group.cipher"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.algorithm_selection.server_to_client_alg_group.compression"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.algorithm_selection.server_to_client_alg_group.mac"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.endpoint_id.comment"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.endpoint_id.protocol_version"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.endpoint_id.raw"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.endpoint_id.software_version"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.hassh_fingerprint"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.kex_init_message.client_to_server_ciphers"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.kex_init_message.client_to_server_compression"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.kex_init_message.client_to_server_languages"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.kex_init_message.client_to_server_macs"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.kex_init_message.first_kex_follows"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.kex_init_message.first_kex_follows.type"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.kex_init_message.host_key_algorithms"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.kex_init_message.kex_algorithms"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.kex_init_message.server_to_client_ciphers"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.kex_init_message.server_to_client_compression"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.kex_init_message.server_to_client_languages"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.kex_init_message.server_to_client_macs"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.certkey_public_key"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.dsa_public_key.g"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.dsa_public_key.p"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.dsa_public_key.q"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.dsa_public_key.y"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.ecdsa_public_key.b"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.ecdsa_public_key.curve"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.ecdsa_public_key.curve.type"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.ecdsa_public_key.gx"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.ecdsa_public_key.gy"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.ecdsa_public_key.length"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.ecdsa_public_key.length.type"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.ecdsa_public_key.n"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.ecdsa_public_key.p"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.ecdsa_public_key.pub"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.ecdsa_public_key.x"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.ecdsa_public_key.y"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.ed25519_public_key.public_bytes"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.fingerprint_sha256"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.rsa_public_key.exponent"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.rsa_public_key.length"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.rsa_public_key.length.type"
},
{
"data": {
"category": " SSH"
},
"value": "services.ssh.server_host_key.rsa_public_key.modulus"
},
{
"data": {
"category": " TELNET"
},
"value": "services.telnet.banner"
},
{
"data": {
"category": " TELNET"
},
"value": "services.telnet.do.key"
},
{
"data": {
"category": " TELNET"
},
"value": "services.telnet.do.key.type"
},
{
"data": {
"category": " TELNET"
},
"value": "services.telnet.do.value"
},
{
"data": {
"category": " TELNET"
},
"value": "services.telnet.dont.key"
},
{
"data": {
"category": " TELNET"
},
"value": "services.telnet.dont.key.type"
},
{
"data": {
"category": " TELNET"
},
"value": "services.telnet.dont.value"
},
{
"data": {
"category": " TELNET"
},
"value": "services.telnet.will.key"
},
{
"data": {
"category": " TELNET"
},
"value": "services.telnet.will.key.type"
},
{
"data": {
"category": " TELNET"
},
"value": "services.telnet.will.value"
},
{
"data": {
"category": " TELNET"
},
"value": "services.telnet.wont.key"
},
{
"data": {
"category": " TELNET"
},
"value": "services.telnet.wont.key.type"
},
{
"data": {
"category": " TELNET"
},
"value": "services.telnet.wont.value"
},
{
"data": {
"category": " FTP"
},
"value": "services.ftp.auth_ssl_response"
},
{
"data": {
"category": " FTP"
},
"value": "services.ftp.auth_tls_response"
},
{
"data": {
"category": " FTP"
},
"value": "services.ftp.banner"
},
{
"data": {
"category": " FTP"
},
"value": "services.ftp.implicit_tls"
},
{
"data": {
"category": " FTP"
},
"value": "services.ftp.implicit_tls.type"
},
{
"data": {
"category": " FTP"
},
"value": "services.ftp.status_code"
},
{
"data": {
"category": " FTP"
},
"value": "services.ftp.status_code.type"
},
{
"data": {
"category": " FTP"
},
"value": "services.ftp.status_meaning"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.additionals.name"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.additionals.response"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.additionals.type"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.answers.name"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.answers.response"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.answers.type"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.authorities.name"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.authorities.response"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.authorities.type"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.edns.do"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.edns.do.type"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.edns.options"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.edns.udp"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.edns.udp.type"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.edns.version"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.edns.version.type"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.questions.name"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.questions.response"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.questions.type"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.r_code"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.resolves_correctly"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.resolves_correctly.type"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.server_type"
},
{
"data": {
"category": " DNS"
},
"value": "services.dns.version"
},
{
"data": {
"category": " AMQP"
},
"value": "services.amqp.explicit_tls"
},
{
"data": {
"category": " AMQP"
},
"value": "services.amqp.explicit_tls.type"
},
{
"data": {
"category": " AMQP"
},
"value": "services.amqp.implicit_tls"
},
{
"data": {
"category": " AMQP"
},
"value": "services.amqp.implicit_tls.type"
},
{
"data": {
"category": " AMQP"
},
"value": "services.amqp.protocol_id.id"
},
{
"data": {
"category": " AMQP"
},
"value": "services.amqp.protocol_id.id.type"
},
{
"data": {
"category": " AMQP"
},
"value": "services.amqp.protocol_id.name"
},
{
"data": {
"category": " AMQP"
},
"value": "services.amqp.version.major"
},
{
"data": {
"category": " AMQP"
},
"value": "services.amqp.version.major.type"
},
{
"data": {
"category": " AMQP"
},
"value": "services.amqp.version.minor"
},
{
"data": {
"category": " AMQP"
},
"value": "services.amqp.version.minor.type"
},
{
"data": {
"category": " AMQP"
},
"value": "services.amqp.version.revision"
},
{
"data": {
"category": " AMQP"
},
"value": "services.amqp.version.revision.type"
},
{
"data": {
"category": " ANY_CONNECT"
},
"value": "services.any_connect.aggregate_auth_version"
},
{
"data": {
"category": " ANY_CONNECT"
},
"value": "services.any_connect.aggregate_auth_version.type"
},
{
"data": {
"category": " ANY_CONNECT"
},
"value": "services.any_connect.auth_methods"
},
{
"data": {
"category": " ANY_CONNECT"
},
"value": "services.any_connect.groups"
},
{
"data": {
"category": " ANY_CONNECT"
},
"value": "services.any_connect.raw"
},
{
"data": {
"category": " ANY_CONNECT"
},
"value": "services.any_connect.response_type"
},
{
"data": {
"category": " BACNET"
},
"value": "services.bacnet.application_software_revision"
},
{
"data": {
"category": " BACNET"
},
"value": "services.bacnet.description"
},
{
"data": {
"category": " BACNET"
},
"value": "services.bacnet.firmware_revision"
},
{
"data": {
"category": " BACNET"
},
"value": "services.bacnet.instance_number"
},
{
"data": {
"category": " BACNET"
},
"value": "services.bacnet.instance_number.type"
},
{
"data": {
"category": " BACNET"
},
"value": "services.bacnet.location"
},
{
"data": {
"category": " BACNET"
},
"value": "services.bacnet.model_name"
},
{
"data": {
"category": " BACNET"
},
"value": "services.bacnet.object_name"
},
{
"data": {
"category": " BACNET"
},
"value": "services.bacnet.vendor_id"
},
{
"data": {
"category": " BACNET"
},
"value": "services.bacnet.vendor_id.type"
},
{
"data": {
"category": " BACNET"
},
"value": "services.bacnet.vendor_name"
},
{
"data": {
"category": " COAP"
},
"value": "services.coap.code"
},
{
"data": {
"category": " COAP"
},
"value": "services.coap.message_id"
},
{
"data": {
"category": " COAP"
},
"value": "services.coap.message_id.type"
},
{
"data": {
"category": " COAP"
},
"value": "services.coap.message_type"
},
{
"data": {
"category": " COAP"
},
"value": "services.coap.payload"
},
{
"data": {
"category": " COAP"
},
"value": "services.coap.token"
},
{
"data": {
"category": " COAP"
},
"value": "services.coap.version"
},
{
"data": {
"category": " COAP"
},
"value": "services.coap.version.type"
},
{
"data": {
"category": " CWMP"
},
"value": "services.cwmp.http_info.body"
},
{
"data": {
"category": " CWMP"
},
"value": "services.cwmp.http_info.body_hashes"
},
{
"data": {
"category": " CWMP"
},
"value": "services.cwmp.http_info.body_size"
},
{
"data": {
"category": " CWMP"
},
"value": "services.cwmp.http_info.body_size.type"
},
{
"data": {
"category": " CWMP"
},
"value": "services.cwmp.http_info.favicons.md5_hash"
},
{
"data": {
"category": " CWMP"
},
"value": "services.cwmp.http_info.favicons.md5_hash.type"
},
{
"data": {
"category": " CWMP"
},
"value": "services.cwmp.http_info.favicons.name"
},
{
"data": {
"category": " CWMP"
},
"value": "services.cwmp.http_info.favicons.size"
},
{
"data": {
"category": " CWMP"
},
"value": "services.cwmp.http_info.favicons.size.type"
},
{
"data": {
"category": " CWMP"
},
"value": "services.cwmp.http_info.headers"
},
{
"data": {
"category": " CWMP"
},
"value": "services.cwmp.http_info.headers.type"
},
{
"data": {
"category": " CWMP"
},
"value": "services.cwmp.http_info.headers.key"
},
{
"data": {
"category": " CWMP"
},
"value": "services.cwmp.http_info.headers.value.headers"
},
{
"data": {
"category": " CWMP"
},
"value": "services.cwmp.http_info.html_tags"
},
{
"data": {
"category": " CWMP"
},
"value": "services.cwmp.http_info.html_title"
},
{
"data": {
"category": " CWMP"
},
"value": "services.cwmp.http_info.protocol"
},
{
"data": {
"category": " CWMP"
},
"value": "services.cwmp.http_info.status_code"
},
{
"data": {
"category": " CWMP"
},
"value": "services.cwmp.http_info.status_code.type"
},
{
"data": {
"category": " CWMP"
},
"value": "services.cwmp.http_info.status_reason"
},
{
"data": {
"category": " DNP3"
},
"value": "services.dnp3.banner"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.http_info.headers"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.http_info.headers.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.http_info.headers.key"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.http_info.headers.value.headers"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.http_info.status"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.http_info.status_code"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.http_info.status_code.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.filesystem.available"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.filesystem.available_in_bytes"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.filesystem.available_in_bytes.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.filesystem.free"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.filesystem.free_in_bytes"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.filesystem.free_in_bytes.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.filesystem.total"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.filesystem.total_in_bytes"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.filesystem.total_in_bytes.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.indices.count"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.indices.count.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.indices.docs.count"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.indices.docs.count.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.indices.docs.deleted"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.indices.docs.deleted.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.indices.store.reserved_in_bytes"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.indices.store.reserved_in_bytes.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.indices.store.size_in_bytes"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.indices.store.size_in_bytes.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.name"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.status"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.timestamp"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.timestamp.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.cluster_combined_info.uuid"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.build_flavor"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.build_hash"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.build_type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.host"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.ingest_processors"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.ip"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.ip.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.jvm.gc"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.jvm.input_args"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.jvm.memory_pools"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.jvm.start_time"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.jvm.start_time_ms"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.jvm.start_time_ms.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.jvm.version"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.jvm.vm_name"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.jvm.vm_vendor"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.jvm.vm_version"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.modules.class_name"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.modules.desc"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.modules.elastic_version"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.modules.ext_plugins"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.modules.has_native_ctrl"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.modules.has_native_ctrl.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.modules.java_version"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.modules.name"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.modules.version"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.name"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.os.allocated_proc"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.os.allocated_proc.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.os.arch"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.os.available_proc"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.os.available_proc.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.os.name"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.os.pretty_name"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.os.refresh_interval_ms"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.os.refresh_interval_ms.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.os.version"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.roles"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.settings.cluster_name"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.settings.node.attr.ml.enabled"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.settings.node.attr.ml.machine_memory"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.settings.node.attr.ml.max_open_jobs"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.settings.node.attr.xpack_installed"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.settings.node.name"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.thread_pool_list.keep_alive"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.thread_pool_list.max"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.thread_pool_list.max.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.thread_pool_list.min"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.thread_pool_list.min.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.thread_pool_list.queue_size"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.thread_pool_list.queue_size.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.thread_pool_list.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.total_indexing_buffer"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.total_indexing_buffer.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_data.version"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.node_info.nodes.node_name"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.system_info.cluster_uuid"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.system_info.name"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.system_info.tagline"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.system_info.version.build_date"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.system_info.version.build_flavor"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.system_info.version.build_hash"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.system_info.version.build_snapshot"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.system_info.version.build_snapshot.type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.system_info.version.build_type"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.system_info.version.lucene_version"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.system_info.version.min_idx_compat_ver"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.system_info.version.min_wire_compat_ver"
},
{
"data": {
"category": " ELASTICSEARCH"
},
"value": "services.elasticsearch.system_info.version.number"
},
{
"data": {
"category": " FORTIGATE"
},
"value": "services.fortigate.api_version"
},
{
"data": {
"category": " FORTIGATE"
},
"value": "services.fortigate.build"
},
{
"data": {
"category": " FORTIGATE"
},
"value": "services.fortigate.build.type"
},
{
"data": {
"category": " FORTIGATE"
},
"value": "services.fortigate.http_info.headers"
},
{
"data": {
"category": " FORTIGATE"
},
"value": "services.fortigate.http_info.headers.type"
},
{
"data": {
"category": " FORTIGATE"
},
"value": "services.fortigate.http_info.headers.key"
},
{
"data": {
"category": " FORTIGATE"
},
"value": "services.fortigate.http_info.headers.value.headers"
},
{
"data": {
"category": " FORTIGATE"
},
"value": "services.fortigate.http_info.status"
},
{
"data": {
"category": " FORTIGATE"
},
"value": "services.fortigate.http_info.status_code"
},
{
"data": {
"category": " FORTIGATE"
},
"value": "services.fortigate.http_info.status_code.type"
},
{
"data": {
"category": " FORTIGATE"
},
"value": "services.fortigate.serial"
},
{
"data": {
"category": " FORTIGATE"
},
"value": "services.fortigate.status_code"
},
{
"data": {
"category": " FORTIGATE"
},
"value": "services.fortigate.status_code.type"
},
{
"data": {
"category": " FORTIGATE"
},
"value": "services.fortigate.status_msg"
},
{
"data": {
"category": " FORTIGATE"
},
"value": "services.fortigate.version"
},
{
"data": {
"category": " FOX"
},
"value": "services.fox.app_name"
},
{
"data": {
"category": " FOX"
},
"value": "services.fox.app_version"
},
{
"data": {
"category": " FOX"
},
"value": "services.fox.auth_agent_type"
},
{
"data": {
"category": " FOX"
},
"value": "services.fox.brand_id"
},
{
"data": {
"category": " FOX"
},
"value": "services.fox.host_address"
},
{
"data": {
"category": " FOX"
},
"value": "services.fox.hostid"
},
{
"data": {
"category": " FOX"
},
"value": "services.fox.hostname"
},
{
"data": {
"category": " FOX"
},
"value": "services.fox.id"
},
{
"data": {
"category": " FOX"
},
"value": "services.fox.id.type"
},
{
"data": {
"category": " FOX"
},
"value": "services.fox.language"
},
{
"data": {
"category": " FOX"
},
"value": "services.fox.os_name"
},
{
"data": {
"category": " FOX"
},
"value": "services.fox.os_version"
},
{
"data": {
"category": " FOX"
},
"value": "services.fox.station_name"
},
{
"data": {
"category": " FOX"
},
"value": "services.fox.sys_info"
},
{
"data": {
"category": " FOX"
},
"value": "services.fox.time_zone"
},
{
"data": {
"category": " FOX"
},
"value": "services.fox.version"
},
{
"data": {
"category": " FOX"
},
"value": "services.fox.vm_name"
},
{
"data": {
"category": " FOX"
},
"value": "services.fox.vm_uuid"
},
{
"data": {
"category": " FOX"
},
"value": "services.fox.vm_version"
},
{
"data": {
"category": " IKE"
},
"value": "services.ike.v1.accepted_proposal"
},
{
"data": {
"category": " IKE"
},
"value": "services.ike.v1.accepted_proposal.type"
},
{
"data": {
"category": " IKE"
},
"value": "services.ike.v1.notify_message_types"
},
{
"data": {
"category": " IKE"
},
"value": "services.ike.v1.notify_message_types.type"
},
{
"data": {
"category": " IKE"
},
"value": "services.ike.v1.vendor_ids"
},
{
"data": {
"category": " IKE"
},
"value": "services.ike.v2.accepted_proposal"
},
{
"data": {
"category": " IKE"
},
"value": "services.ike.v2.accepted_proposal.type"
},
{
"data": {
"category": " IKE"
},
"value": "services.ike.v2.notify_message_types"
},
{
"data": {
"category": " IKE"
},
"value": "services.ike.v2.notify_message_types.type"
},
{
"data": {
"category": " IKE"
},
"value": "services.ike.v2.vendor_ids"
},
{
"data": {
"category": " IMAP"
},
"value": "services.imap.banner"
},
{
"data": {
"category": " IMAP"
},
"value": "services.imap.start_tls"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.auth_status.anonymous_login_enabled"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.auth_status.anonymous_login_enabled.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.auth_status.auth_each_message"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.auth_status.auth_each_message.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.auth_status.has_anonymous_users"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.auth_status.has_anonymous_users.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.auth_status.has_named_users"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.auth_status.has_named_users.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.auth_status.two_key_login_required"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.auth_status.two_key_login_required.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.auth_status.user_auth_disabled"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.auth_status.user_auth_disabled.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.channel_number"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.channel_number.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.completion_code.name"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.completion_code.raw"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.completion_code.raw.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.extended_capabilities.supports_ipmi_v1_5"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.extended_capabilities.supports_ipmi_v1_5.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.extended_capabilities.supports_ipmi_v2_0"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.extended_capabilities.supports_ipmi_v2_0.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.oem_data"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.oem_data.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.oem_id"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.supported_auth_types.extended"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.supported_auth_types.extended.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.supported_auth_types.md2"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.supported_auth_types.md2.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.supported_auth_types.md5"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.supported_auth_types.md5.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.supported_auth_types.none"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.supported_auth_types.none.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.supported_auth_types.oem_proprietary"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.supported_auth_types.oem_proprietary.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.supported_auth_types.password"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.supported_auth_types.password.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.supported_auth_types.raw"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.capabilities.supported_auth_types.raw.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.checksum_error"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.checksum_error.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.data"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.ipmi_command_number.name"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.ipmi_command_number.raw"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.ipmi_command_number.raw.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.network_function_code.logical_unit_number.name"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.network_function_code.logical_unit_number.raw"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.network_function_code.logical_unit_number.raw.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.network_function_code.net_fn.is_request"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.network_function_code.net_fn.is_request.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.network_function_code.net_fn.is_response"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.network_function_code.net_fn.is_response.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.network_function_code.net_fn.name"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.network_function_code.net_fn.raw"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.network_function_code.net_fn.raw.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.network_function_code.net_fn.value"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.network_function_code.net_fn.value.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.network_function_code.raw"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.network_function_code.raw.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.requestor_sequence_number"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.command_payload.requestor_sequence_number.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.raw"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.rmcp_header.message_class.class"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.rmcp_header.message_class.class.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.rmcp_header.message_class.is_ack"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.rmcp_header.message_class.is_ack.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.rmcp_header.message_class.name"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.rmcp_header.message_class.raw"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.rmcp_header.message_class.raw.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.rmcp_header.sequence_number"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.rmcp_header.sequence_number.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.rmcp_header.version"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.rmcp_header.version.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.session_header.auth_code"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.session_header.auth_type.name"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.session_header.auth_type.raw"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.session_header.auth_type.raw.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.session_header.auth_type.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.session_header.auth_type.type.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.session_header.session_id"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.session_header.session_id.type"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.session_header.session_sequence_number"
},
{
"data": {
"category": " IPMI"
},
"value": "services.ipmi.session_header.session_sequence_number.type"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.attribute_cups_version"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.attribute_ipp_versions"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.attribute_printer_uris"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.attributes.name"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.attributes.value_tag"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.attributes.value_tag.type"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.cups_response.body"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.cups_response.body_hashes"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.cups_response.body_size"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.cups_response.body_size.type"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.cups_response.favicons.md5_hash"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.cups_response.favicons.md5_hash.type"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.cups_response.favicons.name"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.cups_response.favicons.size"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.cups_response.favicons.size.type"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.cups_response.headers"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.cups_response.headers.type"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.cups_response.headers.key"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.cups_response.headers.value.headers"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.cups_response.html_tags"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.cups_response.html_title"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.cups_response.protocol"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.cups_response.status_code"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.cups_response.status_code.type"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.cups_response.status_reason"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.cups_version"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.major_version"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.major_version.type"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.minor_version"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.minor_version.type"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.response.body"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.response.body_hashes"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.response.body_size"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.response.body_size.type"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.response.favicons.md5_hash"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.response.favicons.md5_hash.type"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.response.favicons.name"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.response.favicons.size"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.response.favicons.size.type"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.response.headers"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.response.headers.type"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.response.headers.key"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.response.headers.value.headers"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.response.html_tags"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.response.html_title"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.response.protocol"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.response.status_code"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.response.status_code.type"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.response.status_reason"
},
{
"data": {
"category": " IPP"
},
"value": "services.ipp.version_string"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.endpoints.name"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.endpoints.self_link"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.endpoints.subsets.addresses.hostname"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.endpoints.subsets.addresses.ip"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.endpoints.subsets.addresses.ip.type"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.endpoints.subsets.addresses.node_name"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.endpoints.subsets.ports.name"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.endpoints.subsets.ports.port"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.endpoints.subsets.ports.port.type"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.endpoints.subsets.ports.protocol"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.kubernetes_dashboard_found"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.kubernetes_dashboard_found.type"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.nodes.addresses.address"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.nodes.addresses.address.type"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.nodes.addresses.address_type"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.nodes.architecture"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.nodes.container_runtime_version"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.nodes.images"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.nodes.kernel_version"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.nodes.kube_proxy_version"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.nodes.kubelet_version"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.nodes.name"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.nodes.operating_system"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.nodes.os_image"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.pod_names"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.roles.name"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.roles.rules.api_groups"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.roles.rules.resources"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.roles.rules.verbs"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.version_info.build_date"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.version_info.compiler"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.version_info.git_commit"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.version_info.git_tree_state"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.version_info.git_version"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.version_info.go_version"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.version_info.major"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.version_info.minor"
},
{
"data": {
"category": " KUBERNETES"
},
"value": "services.kubernetes.version_info.platform"
},
{
"data": {
"category": " LDAP"
},
"value": "services.ldap.allows_anonymous_bind"
},
{
"data": {
"category": " LDAP"
},
"value": "services.ldap.allows_anonymous_bind.type"
},
{
"data": {
"category": " LDAP"
},
"value": "services.ldap.attributes.name"
},
{
"data": {
"category": " LDAP"
},
"value": "services.ldap.attributes.values"
},
{
"data": {
"category": " LDAP"
},
"value": "services.ldap.resultcode"
},
{
"data": {
"category": " LDAP"
},
"value": "services.ldap.resultcode.type"
},
{
"data": {
"category": " MEMCACHED"
},
"value": "services.memcached.ascii_binding_protocol_enabled"
},
{
"data": {
"category": " MEMCACHED"
},
"value": "services.memcached.ascii_binding_protocol_enabled.type"
},
{
"data": {
"category": " MEMCACHED"
},
"value": "services.memcached.binary_binding_protocol_enabled"
},
{
"data": {
"category": " MEMCACHED"
},
"value": "services.memcached.binary_binding_protocol_enabled.type"
},
{
"data": {
"category": " MEMCACHED"
},
"value": "services.memcached.responds_to_udp"
},
{
"data": {
"category": " MEMCACHED"
},
"value": "services.memcached.responds_to_udp.type"
},
{
"data": {
"category": " MEMCACHED"
},
"value": "services.memcached.stats"
},
{
"data": {
"category": " MEMCACHED"
},
"value": "services.memcached.stats.type"
},
{
"data": {
"category": " MEMCACHED"
},
"value": "services.memcached.stats.key"
},
{
"data": {
"category": " MEMCACHED"
},
"value": "services.memcached.stats.value"
},
{
"data": {
"category": " MEMCACHED"
},
"value": "services.memcached.version"
},
{
"data": {
"category": " MMS"
},
"value": "services.mms.model"
},
{
"data": {
"category": " MMS"
},
"value": "services.mms.revision"
},
{
"data": {
"category": " MMS"
},
"value": "services.mms.vendor"
},
{
"data": {
"category": " MODBUS"
},
"value": "services.modbus.exception_response.exception_function"
},
{
"data": {
"category": " MODBUS"
},
"value": "services.modbus.exception_response.exception_function.type"
},
{
"data": {
"category": " MODBUS"
},
"value": "services.modbus.exception_response.exception_type"
},
{
"data": {
"category": " MODBUS"
},
"value": "services.modbus.exception_response.exception_type.type"
},
{
"data": {
"category": " MODBUS"
},
"value": "services.modbus.function"
},
{
"data": {
"category": " MODBUS"
},
"value": "services.modbus.function.type"
},
{
"data": {
"category": " MODBUS"
},
"value": "services.modbus.mei_response.conformity_level"
},
{
"data": {
"category": " MODBUS"
},
"value": "services.modbus.mei_response.conformity_level.type"
},
{
"data": {
"category": " MODBUS"
},
"value": "services.modbus.mei_response.more_follows"
},
{
"data": {
"category": " MODBUS"
},
"value": "services.modbus.mei_response.more_follows.type"
},
{
"data": {
"category": " MODBUS"
},
"value": "services.modbus.mei_response.objects"
},
{
"data": {
"category": " MODBUS"
},
"value": "services.modbus.mei_response.objects.type"
},
{
"data": {
"category": " MODBUS"
},
"value": "services.modbus.mei_response.objects.key"
},
{
"data": {
"category": " MODBUS"
},
"value": "services.modbus.mei_response.objects.value"
},
{
"data": {
"category": " MODBUS"
},
"value": "services.modbus.unit_id"
},
{
"data": {
"category": " MODBUS"
},
"value": "services.modbus.unit_id.type"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.build_info.build_environment.cc"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.build_info.build_environment.cc_flags"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.build_info.build_environment.cxx"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.build_info.build_environment.cxx_flags"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.build_info.build_environment.dist_arch"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.build_info.build_environment.dist_mod"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.build_info.build_environment.link_flags"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.build_info.build_environment.target_arch"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.build_info.build_environment.target_os"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.build_info.git_version"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.build_info.version"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.is_master.is_master"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.is_master.is_master.type"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.is_master.logical_session_timeout_minutes"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.is_master.logical_session_timeout_minutes.type"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.is_master.max_bson_object_size"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.is_master.max_bson_object_size.type"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.is_master.max_message_size_bytes"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.is_master.max_message_size_bytes.type"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.is_master.max_wire_version"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.is_master.max_wire_version.type"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.is_master.max_write_batch_size"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.is_master.max_write_batch_size.type"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.is_master.min_wire_version"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.is_master.min_wire_version.type"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.is_master.read_only"
},
{
"data": {
"category": " MONGODB"
},
"value": "services.mongodb.is_master.read_only.type"
},
{
"data": {
"category": " MQTT"
},
"value": "services.mqtt.connection_ack_raw"
},
{
"data": {
"category": " MQTT"
},
"value": "services.mqtt.connection_ack_return.raw"
},
{
"data": {
"category": " MQTT"
},
"value": "services.mqtt.connection_ack_return.raw.type"
},
{
"data": {
"category": " MQTT"
},
"value": "services.mqtt.connection_ack_return.return_value"
},
{
"data": {
"category": " MQTT"
},
"value": "services.mqtt.connection_ack_return.return_value.type"
},
{
"data": {
"category": " MQTT"
},
"value": "services.mqtt.subscription_ack_return.raw"
},
{
"data": {
"category": " MQTT"
},
"value": "services.mqtt.subscription_ack_return.raw.type"
},
{
"data": {
"category": " MQTT"
},
"value": "services.mqtt.subscription_ack_return.return_value"
},
{
"data": {
"category": " MQTT"
},
"value": "services.mqtt.subscription_ack_return.return_value.type"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.encrypt_mode"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.instance_name"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.prelogin_options.encrypt_mode"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.prelogin_options.fed_auth_required"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.prelogin_options.fed_auth_required.type"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.prelogin_options.instance"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.prelogin_options.mars"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.prelogin_options.mars.type"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.prelogin_options.nonce"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.prelogin_options.server_version.build_number"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.prelogin_options.server_version.build_number.type"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.prelogin_options.server_version.major"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.prelogin_options.server_version.major.type"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.prelogin_options.server_version.minor"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.prelogin_options.server_version.minor.type"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.prelogin_options.thread_id"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.prelogin_options.thread_id.type"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.prelogin_options.trace_id"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.prelogin_options.unknown.key"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.prelogin_options.unknown.key.type"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.prelogin_options.unknown.value"
},
{
"data": {
"category": " MSSQL"
},
"value": "services.mssql.version"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.auth_plugin_data"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.auth_plugin_name"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.capability_flags"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.capability_flags.type"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.capability_flags.key"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.capability_flags.value"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.capability_flags.value.type"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.character_set"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.character_set.type"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.connection_id"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.connection_id.type"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.error_code"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.error_code.type"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.error_id"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.error_message"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.protocol_version"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.protocol_version.type"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.server_version"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.status_flags"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.status_flags.type"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.status_flags.key"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.status_flags.value"
},
{
"data": {
"category": " MYSQL"
},
"value": "services.mysql.status_flags.value.type"
},
{
"data": {
"category": " NTP"
},
"value": "services.ntp.get_time_header.leap_indicator"
},
{
"data": {
"category": " NTP"
},
"value": "services.ntp.get_time_header.leap_indicator.type"
},
{
"data": {
"category": " NTP"
},
"value": "services.ntp.get_time_header.mode"
},
{
"data": {
"category": " NTP"
},
"value": "services.ntp.get_time_header.mode.type"
},
{
"data": {
"category": " NTP"
},
"value": "services.ntp.get_time_header.poll"
},
{
"data": {
"category": " NTP"
},
"value": "services.ntp.get_time_header.poll.type"
},
{
"data": {
"category": " NTP"
},
"value": "services.ntp.get_time_header.precision"
},
{
"data": {
"category": " NTP"
},
"value": "services.ntp.get_time_header.precision.type"
},
{
"data": {
"category": " NTP"
},
"value": "services.ntp.get_time_header.reference_id"
},
{
"data": {
"category": " NTP"
},
"value": "services.ntp.get_time_header.stratum"
},
{
"data": {
"category": " NTP"
},
"value": "services.ntp.get_time_header.stratum.type"
},
{
"data": {
"category": " NTP"
},
"value": "services.ntp.get_time_header.version"
},
{
"data": {
"category": " NTP"
},
"value": "services.ntp.get_time_header.version.type"
},
{
"data": {
"category": " OPENVPN"
},
"value": "services.openvpn.accepts_v1"
},
{
"data": {
"category": " OPENVPN"
},
"value": "services.openvpn.accepts_v1.type"
},
{
"data": {
"category": " OPENVPN"
},
"value": "services.openvpn.accepts_v2"
},
{
"data": {
"category": " OPENVPN"
},
"value": "services.openvpn.accepts_v2.type"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.accept_version"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.accept_version.type"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.connect_flags0"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.connect_flags0.type"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.connect_flags0.key"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.connect_flags0.value"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.connect_flags0.value.type"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.connect_flags1"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.connect_flags1.type"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.connect_flags1.key"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.connect_flags1.value"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.connect_flags1.value.type"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.did_resend"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.did_resend.type"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.global_service_options"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.global_service_options.type"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.global_service_options.key"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.global_service_options.value"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.global_service_options.value.type"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.nsn_service_versions"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.nsn_service_versions.type"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.nsn_service_versions.key"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.nsn_service_versions.value"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.nsn_version"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.redirect_target.key"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.redirect_target.value"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.redirect_target_raw"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.refuse_error.key"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.refuse_error.value"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.refuse_error_raw"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.refuse_reason_app"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.refuse_reason_sys"
},
{
"data": {
"category": " ORACLE"
},
"value": "services.oracle.refuse_version"
},
{
"data": {
"category": " PC_ANYWHERE"
},
"value": "services.pc_anywhere.name"
},
{
"data": {
"category": " PC_ANYWHERE"
},
"value": "services.pc_anywhere.nr"
},
{
"data": {
"category": " PC_ANYWHERE"
},
"value": "services.pc_anywhere.status.in_use"
},
{
"data": {
"category": " PC_ANYWHERE"
},
"value": "services.pc_anywhere.status.in_use.type"
},
{
"data": {
"category": " PC_ANYWHERE"
},
"value": "services.pc_anywhere.status.raw"
},
{
"data": {
"category": " POP3"
},
"value": "services.pop3.banner"
},
{
"data": {
"category": " POP3"
},
"value": "services.pop3.start_tls"
},
{
"data": {
"category": " POSTGRES"
},
"value": "services.postgres.authentication_mode.mode"
},
{
"data": {
"category": " POSTGRES"
},
"value": "services.postgres.authentication_mode.payload"
},
{
"data": {
"category": " POSTGRES"
},
"value": "services.postgres.protocol_error"
},
{
"data": {
"category": " POSTGRES"
},
"value": "services.postgres.protocol_error.type"
},
{
"data": {
"category": " POSTGRES"
},
"value": "services.postgres.protocol_error.key"
},
{
"data": {
"category": " POSTGRES"
},
"value": "services.postgres.protocol_error.value"
},
{
"data": {
"category": " POSTGRES"
},
"value": "services.postgres.startup_error"
},
{
"data": {
"category": " POSTGRES"
},
"value": "services.postgres.startup_error.type"
},
{
"data": {
"category": " POSTGRES"
},
"value": "services.postgres.startup_error.key"
},
{
"data": {
"category": " POSTGRES"
},
"value": "services.postgres.startup_error.value"
},
{
"data": {
"category": " POSTGRES"
},
"value": "services.postgres.supported_versions"
},
{
"data": {
"category": " POSTGRES"
},
"value": "services.postgres.transaction_status"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.bearer_message.code"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.bearer_message.code.type"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.bearer_message.meaning"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.error_message.code"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.error_message.code.type"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.error_message.meaning"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.firmware.major"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.firmware.major.type"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.firmware.minor"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.firmware.minor.type"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.framing_message.code"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.framing_message.code.type"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.framing_message.meaning"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.hostname"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.maximum_channels"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.maximum_channels.type"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.protocol.major"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.protocol.major.type"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.protocol.minor"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.protocol.minor.type"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.result_message.code"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.result_message.code.type"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.result_message.meaning"
},
{
"data": {
"category": " PPTP"
},
"value": "services.pptp.vendor"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.http_info.headers"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.http_info.headers.type"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.http_info.headers.key"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.http_info.headers.value.headers"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.http_info.status"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.http_info.status_code"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.http_info.status_code.type"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.active_targets.discovered_labels.address"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.active_targets.discovered_labels.job"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.active_targets.discovered_labels.metrics_path"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.active_targets.discovered_labels.scheme"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.active_targets.health"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.active_targets.labels.instance"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.active_targets.labels.job"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.active_targets.last_error"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.active_targets.last_scrape"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.active_targets.scrape_url"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.all_versions"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.config_exposed"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.config_exposed.type"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.dropped_targets.address"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.dropped_targets.job"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.dropped_targets.metrics_path"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.dropped_targets.scheme"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.go_versions"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.prometheus_versions.go_version"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.prometheus_versions.revision"
},
{
"data": {
"category": " PROMETHEUS"
},
"value": "services.prometheus.response.prometheus_versions.version"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.certificate_info.internal_x509_chain_fps"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.certificate_info.internal_x509_chain_fps.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.certificate_info.proprietary_rsa_key.key_length"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.certificate_info.proprietary_rsa_key.key_length.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.certificate_info.proprietary_rsa_key.magic"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.certificate_info.proprietary_rsa_key.magic.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.certificate_info.proprietary_rsa_key.max_bytes_datalen"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.certificate_info.proprietary_rsa_key.max_bytes_datalen.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.certificate_info.proprietary_rsa_key.modulus"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.certificate_info.proprietary_rsa_key.modulus.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.certificate_info.proprietary_rsa_key.modulus_bitlen"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.certificate_info.proprietary_rsa_key.modulus_bitlen.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.certificate_info.proprietary_rsa_key.public_exponent"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.certificate_info.proprietary_rsa_key.public_exponent.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.certificate_info.proprietary_rsa_key.signature"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.certificate_info.proprietary_rsa_key.signature.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.connect_response.connect_id"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.connect_response.connect_id.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.connect_response.domain_parameters.domain_protocol_version"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.connect_response.domain_parameters.domain_protocol_version.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.connect_response.domain_parameters.max_channel_ids"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.connect_response.domain_parameters.max_channel_ids.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.connect_response.domain_parameters.max_mcspdu_size"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.connect_response.domain_parameters.max_mcspdu_size.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.connect_response.domain_parameters.max_provider_height"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.connect_response.domain_parameters.max_provider_height.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.connect_response.domain_parameters.max_token_ids"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.connect_response.domain_parameters.max_token_ids.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.connect_response.domain_parameters.max_user_id_channels"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.connect_response.domain_parameters.max_user_id_channels.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.connect_response.domain_parameters.min_throughput"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.connect_response.domain_parameters.min_throughput.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.connect_response.domain_parameters.num_priorities"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.connect_response.domain_parameters.num_priorities.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.protocol_flags.dynvc_graphics_pipeline"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.protocol_flags.dynvc_graphics_pipeline.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.protocol_flags.extended_client_data_supported"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.protocol_flags.extended_client_data_supported.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.protocol_flags.neg_resp_reserved"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.protocol_flags.neg_resp_reserved.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.protocol_flags.restricted_admin_mode"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.protocol_flags.restricted_admin_mode.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.protocol_flags.restricted_auth_mode"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.protocol_flags.restricted_auth_mode.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.credssp"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.credssp.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.credssp_early_auth"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.credssp_early_auth.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.error"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.error.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.error_bad_flags"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.error_bad_flags.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.error_hybrid_required"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.error_hybrid_required.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.error_ssl_cert_missing"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.error_ssl_cert_missing.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.error_ssl_forbidden"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.error_ssl_forbidden.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.error_ssl_required"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.error_ssl_required.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.error_ssl_user_auth_required"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.error_ssl_user_auth_required.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.error_unknown"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.error_unknown.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.raw_value"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.raw_value.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.rdstls"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.rdstls.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.standard_rdp"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.standard_rdp.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.tls"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.selected_security_protocol.tls.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.version.major"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.version.major.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.version.minor"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.version.minor.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.version.raw"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.version.raw.type"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.x224_cc_pdu_srcref"
},
{
"data": {
"category": " RDP"
},
"value": "services.rdp.x224_cc_pdu_srcref.type"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.arch_bits"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.auth_response"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.build_id"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.commands"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.commands_processed"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.commands_processed.type"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.connections_received"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.connections_received.type"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.gcc_version"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.git_sha1"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.info_response.key"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.info_response.value"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.major"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.major.type"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.mem_allocator"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.minor"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.minor.type"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.mode"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.nonexistent_response"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.os"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.patch_level"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.patch_level.type"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.ping_response"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.quit_response"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.raw_command_output.output"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.uptime"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.uptime.type"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.used_memory"
},
{
"data": {
"category": " REDIS"
},
"value": "services.redis.used_memory.type"
},
{
"data": {
"category": " S7"
},
"value": "services.s7.copyright"
},
{
"data": {
"category": " S7"
},
"value": "services.s7.cpu_profile"
},
{
"data": {
"category": " S7"
},
"value": "services.s7.firmware"
},
{
"data": {
"category": " S7"
},
"value": "services.s7.hardware"
},
{
"data": {
"category": " S7"
},
"value": "services.s7.location"
},
{
"data": {
"category": " S7"
},
"value": "services.s7.memory_serial_number"
},
{
"data": {
"category": " S7"
},
"value": "services.s7.module"
},
{
"data": {
"category": " S7"
},
"value": "services.s7.module_id"
},
{
"data": {
"category": " S7"
},
"value": "services.s7.module_type"
},
{
"data": {
"category": " S7"
},
"value": "services.s7.oem_id"
},
{
"data": {
"category": " S7"
},
"value": "services.s7.plant_id"
},
{
"data": {
"category": " S7"
},
"value": "services.s7.reserved_for_os"
},
{
"data": {
"category": " S7"
},
"value": "services.s7.serial_number"
},
{
"data": {
"category": " S7"
},
"value": "services.s7.system"
},
{
"data": {
"category": " SIP"
},
"value": "services.sip.code"
},
{
"data": {
"category": " SIP"
},
"value": "services.sip.code.type"
},
{
"data": {
"category": " SIP"
},
"value": "services.sip.server"
},
{
"data": {
"category": " SIP"
},
"value": "services.sip.status"
},
{
"data": {
"category": " SIP"
},
"value": "services.sip.version"
},
{
"data": {
"category": " SKINNY"
},
"value": "services.skinny.response"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.group_name"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.has_ntlm"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.has_ntlm.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.native_os"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.authentication_types"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.capabilities"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.capabilities.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.dialect_revision"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.dialect_revision.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.header_log.command"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.header_log.command.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.header_log.credits"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.header_log.credits.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.header_log.flags"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.header_log.flags.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.header_log.protocol_id"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.header_log.status"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.header_log.status.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.security_mode"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.security_mode.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.server_guid"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.server_start_time"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.server_start_time.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.system_time"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.negotiation_log.system_time.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.ntlm"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.session_setup_log.header_log.command"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.session_setup_log.header_log.command.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.session_setup_log.header_log.credits"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.session_setup_log.header_log.credits.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.session_setup_log.header_log.flags"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.session_setup_log.header_log.flags.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.session_setup_log.header_log.protocol_id"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.session_setup_log.header_log.status"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.session_setup_log.header_log.status.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.session_setup_log.negotiate_flags"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.session_setup_log.negotiate_flags.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.session_setup_log.setup_flags"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.session_setup_log.setup_flags.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.session_setup_log.target_name"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_capabilities.smb_dfs_support"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_capabilities.smb_dfs_support.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_capabilities.smb_directory_leasing_support"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_capabilities.smb_directory_leasing_support.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_capabilities.smb_encryption_support"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_capabilities.smb_encryption_support.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_capabilities.smb_leasing_support"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_capabilities.smb_leasing_support.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_capabilities.smb_multichan_support"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_capabilities.smb_multichan_support.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_capabilities.smb_multicredit_support"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_capabilities.smb_multicredit_support.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_capabilities.smb_persistent_handle_support"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_capabilities.smb_persistent_handle_support.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_version.major"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_version.major.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_version.minor"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_version.minor.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_version.revision"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_version.revision.type"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smb_version.version_string"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smbv1_support"
},
{
"data": {
"category": " SMB"
},
"value": "services.smb.smbv1_support.type"
},
{
"data": {
"category": " SMTP"
},
"value": "services.smtp.banner"
},
{
"data": {
"category": " SMTP"
},
"value": "services.smtp.ehlo"
},
{
"data": {
"category": " SMTP"
},
"value": "services.smtp.start_tls"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_interfaces.num_ifaces"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_interfaces.num_ifaces.type"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_physical.firmware_rev"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_physical.hardware_rev"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_physical.mfg_name"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_physical.model_name"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_physical.name"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_physical.serial_num"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_physical.software_rev"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.contact"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.desc"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.init_time"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.init_time.type"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.location"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.name"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.object_id"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.services.layer_1"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.services.layer_1.type"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.services.layer_2"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.services.layer_2.type"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.services.layer_3"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.services.layer_3.type"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.services.layer_4"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.services.layer_4.type"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.services.layer_5"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.services.layer_5.type"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.services.layer_6"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.services.layer_6.type"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.services.layer_7"
},
{
"data": {
"category": " SNMP"
},
"value": "services.snmp.oid_system.services.layer_7.type"
},
{
"data": {
"category": " SSDP"
},
"value": "services.ssdp.headers"
},
{
"data": {
"category": " SSDP"
},
"value": "services.ssdp.headers.type"
},
{
"data": {
"category": " SSDP"
},
"value": "services.ssdp.headers.key"
},
{
"data": {
"category": " SSDP"
},
"value": "services.ssdp.headers.value.headers"
},
{
"data": {
"category": " SSDP"
},
"value": "services.ssdp.upnp_url"
},
{
"data": {
"category": " TEAM_VIEWER"
},
"value": "services.team_viewer.response"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.device_type"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.friendly_name"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.id"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.id.type"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.manufacturer"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.manufacturer_url"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.model_description"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.model_name"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.model_number"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.model_url"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.parent_id"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.parent_id.type"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.presentation_url"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.serial_number"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.service_list.control_url"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.service_list.event_sub_url"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.service_list.scpd_url"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.service_list.service_id"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.service_list.service_type"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.udn"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.devices.upc"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.endpoint"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.headers"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.headers.type"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.headers.key"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.headers.value.headers"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.spec.major"
},
{
"data": {
"category": " UPNP"
},
"value": "services.upnp.spec.minor"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.connection_failed_reason"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.desktop_name"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.pixel_encoding.name"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.pixel_encoding.value"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.pixel_encoding.value.type"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.height"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.height.type"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.name_len"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.name_len.type"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.big_endian"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.big_endian.type"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.bits_per_pixel"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.bits_per_pixel.type"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.blue_max"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.blue_max.type"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.blue_shift"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.blue_shift.type"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.depth"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.depth.type"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.green_max"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.green_max.type"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.green_shift"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.green_shift.type"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.padding1"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.padding1.type"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.padding2"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.padding2.type"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.padding3"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.padding3.type"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.red_max"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.red_max.type"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.red_shift"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.red_shift.type"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.true_color"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.pixel_format.true_color.type"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.width"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.screen_info.width.type"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.security_types.name"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.security_types.value"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.security_types.value.type"
},
{
"data": {
"category": " VNC"
},
"value": "services.vnc.version"
},
{
"data": {
"category": " X11"
},
"value": "services.x11.refusal_reason"
},
{
"data": {
"category": " X11"
},
"value": "services.x11.requires_authentication"
},
{
"data": {
"category": " X11"
},
"value": "services.x11.requires_authentication.type"
},
{
"data": {
"category": " X11"
},
"value": "services.x11.vendor"
},
{
"data": {
"category": " X11"
},
"value": "services.x11.version"
},
{
"data": {
"category": " MISC"
},
"value": "labels"
},
{
"data": {
"category": " MISC"
},
"value": "last_updated_at"
},
{
"data": {
"category": " MISC"
},
"value": "last_updated_at.type"
},
{
"data": {
"category": " MISC"
},
"value": "service_count"
},
{
"data": {
"category": " MISC"
},
"value": "service_count.type"
},
{
"data": {
"category": " MISC"
},
"value": "services"
},
{
"data": {
"category": " MISC"
},
"value": "services.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.banner_hashes"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.cookie_beacon"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.cookie_beacon.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.crypto_scheme"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.crypto_scheme.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.dns"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.dns.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.http_get.client"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.http_get.uri"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.http_get.verb"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.http_post.client"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.http_post.uri"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.http_post.verb"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.jitter"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.jitter.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.killdate"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.killdate.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.post_ex.x64"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.post_ex.x86"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.public_key"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.sleep_time"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.sleep_time.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.ssl"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.ssl.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.unknown_bytes.key"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.unknown_bytes.key.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.unknown_bytes.value"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.unknown_int.key"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.unknown_int.key.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.unknown_int.value"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.unknown_int.value.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.user_agent"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.watermark"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x64.watermark.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.cookie_beacon"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.cookie_beacon.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.crypto_scheme"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.crypto_scheme.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.dns"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.dns.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.http_get.client"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.http_get.uri"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.http_get.verb"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.http_post.client"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.http_post.uri"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.http_post.verb"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.jitter"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.jitter.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.killdate"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.killdate.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.post_ex.x64"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.post_ex.x86"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.public_key"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.sleep_time"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.sleep_time.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.ssl"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.ssl.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.unknown_bytes.key"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.unknown_bytes.key.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.unknown_bytes.value"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.unknown_int.key"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.unknown_int.key.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.unknown_int.value"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.unknown_int.value.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.user_agent"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.watermark"
},
{
"data": {
"category": " MISC"
},
"value": "services.cobalt_strike.x86.watermark.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.discovery_method"
},
{
"data": {
"category": " MISC"
},
"value": "services.labels"
},
{
"data": {
"category": " MISC"
},
"value": "services.parsed"
},
{
"data": {
"category": " MISC"
},
"value": "services.parsed.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.parsed.dynamic"
},
{
"data": {
"category": " MISC"
},
"value": "services.transport_fingerprint.id"
},
{
"data": {
"category": " MISC"
},
"value": "services.transport_fingerprint.id.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.transport_fingerprint.os"
},
{
"data": {
"category": " MISC"
},
"value": "services.transport_fingerprint.quic.versions"
},
{
"data": {
"category": " MISC"
},
"value": "services.transport_fingerprint.quic.versions.type"
},
{
"data": {
"category": " MISC"
},
"value": "services.transport_fingerprint.raw"
},
{
"data": {
"category": " MISC"
},
"value": "truncated"
},
{
"data": {
"category": " MISC"
},
"value": "truncated.type"
}
]
}
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6711454
censys-2.2.17/censys/cli/utils.py 0000644 0000000 0000000 00000006420 14777466662 013655 0 ustar 00 """Censys CLI utilities."""
import argparse
import datetime
import json
import os.path
import sys
from typing import Any, Dict, List, Optional, Union
from rich.console import Console
from censys.common.config import DEFAULT, get_config
Results = Union[List[dict], Dict[str, Any]]
V2_INDEXES = ["hosts", "certificates"]
config = get_config()
color = config.get(DEFAULT, "color")
color_system = "auto" if color else None
console = Console(color_system=color_system) # type: ignore
err_console = Console(color_system=color_system, file=sys.stderr) # type: ignore
def print_wrote_file(file_path: str):
"""Print wrote file confirmation.
Args:
file_path (str): Name of the file to write to on the disk.
"""
abs_file_path = os.path.abspath(file_path)
console.print(f"Wrote results to file {abs_file_path}", soft_wrap=True)
def _write_json(file_path: str, search_results: Results):
"""Write search results to a new file in JSON format.
Args:
file_path (str): Name of the file to write to on the disk.
search_results (Results): A list of results from the query.
"""
with open(file_path, "w") as output_file:
# Since the results are already in JSON, just write them to a file.
json.dump(search_results, output_file, indent=4)
print_wrote_file(file_path)
def _write_screen(search_results: Results): # pragma: no cover
"""Writes search results to standard output.
Args:
search_results (Results): A list of results from the query.
"""
config = get_config()
if config.get(DEFAULT, "color"):
console.print_json(data=search_results)
else:
print(json.dumps(search_results, indent=4))
def write_file(
results_list: Results,
file_format: Optional[str] = None,
file_path: Optional[str] = None,
csv_fields: Optional[List[str]] = None,
):
"""Maps formats and writes results.
Args:
results_list (Results): A list of results from the API query.
file_format (str): Optional; The format of the output.
file_path (str): Optional; A path to write results to.
csv_fields (List[str]): Optional; A list of fields to write to CSV.
"""
if file_format and isinstance(file_format, str):
file_format = file_format.lower()
if not file_path:
file_path = "temp-out.json"
if file_format == "json":
_write_json(file_path, results_list)
else:
_write_screen(results_list)
def valid_datetime_type(datetime_str: str) -> datetime.datetime:
"""Custom argparse type for user datetime values from arg.
Args:
datetime_str (str): A string representing a datetime.
Raises:
ArgumentTypeError: If the datetime string is invalid.
Returns:
datetime.datetime: A datetime object.
"""
try:
return datetime.datetime.strptime(datetime_str, "%Y-%m-%d %H:%M")
except ValueError:
try:
return datetime.datetime.strptime(datetime_str, "%Y-%m-%d")
except ValueError:
msg = f"Given datetime ({datetime_str}) is not valid! Expected format: 'YYYY-MM-DD' or 'YYYY-MM-DD HH:mm'." # noqa: E231
raise argparse.ArgumentTypeError(msg)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6711454
censys-2.2.17/censys/common/__init__.py 0000644 0000000 0000000 00000000152 14777466662 014771 0 ustar 00 """Common Code for the Censys Python SDK."""
from .version import __version__
__all__ = ["__version__"]
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6711454
censys-2.2.17/censys/common/base.py 0000644 0000000 0000000 00000022506 14777466662 014153 0 ustar 00 """Base for interacting with the Censys APIs."""
import json
import os
import warnings
from functools import wraps
from typing import Any, Callable, Optional, Type
import backoff
import requests
from requests.models import Response
from .exceptions import (
CensysAPIException,
CensysException,
CensysInternalServerErrorException,
CensysInternalServerException,
CensysJSONDecodeException,
CensysRateLimitExceededException,
CensysTooManyRequestsException,
)
from .version import __version__
# Wrapper to make max_retries configurable at runtime
def _backoff_wrapper(method: Callable):
@wraps(method)
def _wrapper(self, *args, **kwargs):
@backoff.on_exception(
backoff.expo,
(
CensysInternalServerException,
CensysInternalServerErrorException,
CensysTooManyRequestsException,
CensysRateLimitExceededException,
requests.exceptions.Timeout,
requests.exceptions.ConnectionError,
),
max_tries=self.max_retries,
max_time=self.timeout,
)
def _impl():
return method(self, *args, **kwargs)
return _impl()
return _wrapper
class CensysAPIBase:
"""This is the base class for API queries."""
DEFAULT_TIMEOUT: int = 30
"""Default API timeout."""
DEFAULT_USER_AGENT: str = f"censys-python/{__version__}"
"""Default API user agent."""
DEFAULT_MAX_RETRIES: int = 5
"""Default max number of API retries."""
def __init__(
self,
url: Optional[str] = None,
timeout: Optional[int] = DEFAULT_TIMEOUT,
max_retries: Optional[int] = DEFAULT_MAX_RETRIES,
user_agent: Optional[str] = DEFAULT_USER_AGENT,
proxies: Optional[dict] = None,
cookies: Optional[dict] = None,
**kwargs,
):
"""Inits CensysAPIBase.
Args:
url (str): Optional; The URL to make API requests.
timeout (int): Optional; Timeout for API requests in seconds.
max_retries (int):
Optional; Max number of times to retry failed API requests.
user_agent (str): Optional; Override User-Agent string.
proxies (dict): Optional; Configure HTTP proxies.
cookies (dict): Optional; Configure cookies.
**kwargs: Arbitrary keyword arguments.
Raises:
CensysException: Base Exception Class for the Censys API.
"""
# Get common request settings
self.timeout = timeout
self.max_retries = max_retries
self._api_url = url or os.getenv("CENSYS_API_URL")
if not self._api_url:
raise CensysException("No API url configured.")
# Create a session and set credentials
self._session = requests.Session()
if proxies:
if "http" in proxies:
warnings.warn("HTTP proxies will not be used.")
proxies.pop("http", None)
self._session.proxies.update(proxies)
if cookies:
self._session.cookies.update(cookies)
self.request_id = kwargs.get("request_id")
if kwargs.get("verify"):
self._session.verify = kwargs.get("verify")
if kwargs.get("cert"):
self._session.cert = kwargs.get("cert")
self._session.headers.update(
{
"accept": "application/json, */8",
"User-Agent": " ".join(
[
requests.utils.default_user_agent(),
user_agent
or kwargs.get("user_agent_identifier")
or self.DEFAULT_USER_AGENT,
]
),
}
)
@property
def request_id(self) -> Optional[str]:
"""The x-request-id header value for API requests.
The x-request-id header is not set when the value is None.
Value is None by default
Returns:
Type[Optional[str]]: The value of the header.
"""
value = self._session.headers.get("x-request-id")
if not isinstance(value, str):
return None
return value
@request_id.setter
def request_id(self, value: Optional[str]):
if value is None:
self._session.headers.pop("x-request-id", None)
return
self._session.headers["x-request-id"] = value
@staticmethod
def _get_exception_class(_: Response) -> Type[CensysAPIException]:
"""Maps HTTP status code or ASM error code to exception.
Must be implemented by child class.
Args:
_ (Response): HTTP requests response object.
Returns:
Type[CensysAPIException]: Exception to raise.
"""
return CensysAPIException
@backoff.on_predicate(
backoff.runtime,
predicate=lambda r: r.status_code in (408, 429, 502, 503)
and r.headers.get("Retry-After"),
value=lambda r: int(r.headers.get("Retry-After", 0)),
)
def _call_method(
self, method: Callable[..., Response], url: str, request_kwargs: dict
) -> Response:
"""Make API call.
Wrapper functions for all our REST API calls checking for errors
and decoding the responses.
Args:
method (Callable): Method to send HTTP request.
url (str): The URL to make API requests.
request_kwargs (dict): Keyword arguments to pass to method.
Returns:
Response: Results from an API request.
"""
return method(url, **request_kwargs)
@_backoff_wrapper
def _make_call(
self,
method: Callable[..., Response],
endpoint: str,
args: Optional[dict] = None,
data: Optional[Any] = None,
**kwargs,
) -> dict:
"""Make API call.
Wrapper functions for all our REST API calls checking for errors
and decoding the responses.
Args:
method (Callable): Method to send HTTP request.
endpoint (str): The path of API endpoint.
args (dict): Optional; URL args that are mapped to params.
data (Any): Optional; JSON data to serialize with request.
**kwargs: Arbitrary keyword arguments to pass to method.
Raises:
censys_exception: Exception Class for the Censys API.
CensysJSONDecodeException: Exception for decoding JSON.
Returns:
dict: Results from an API request.
"""
if endpoint.startswith("/"):
url = f"{self._api_url}{endpoint}"
else:
url = f"{self._api_url}/{endpoint}"
request_kwargs = {
"params": args or {},
"timeout": self.timeout,
**kwargs,
}
if data:
request_kwargs["json"] = data
res = self._call_method(method, url, request_kwargs)
if res.ok:
# Check for a returned json body
try:
json_data = res.json()
if "error" not in json_data:
return json_data
# Successful request returned no json body in response
except ValueError:
return {
"code": res.status_code,
"status": res.reason,
}
try:
json_data = res.json()
message = json_data.get("error") or json_data.get("message")
const = json_data.get("error_type") or json_data.get("status") or res.reason
error_code = json_data.get("errorCode") or json_data.get(
"statusCode", "unknown"
)
details = json_data.get("details", "unknown")
except (ValueError, json.decoder.JSONDecodeError) as error:
raise CensysJSONDecodeException(
status_code=res.status_code,
message=f"Response from {res.url} is not valid JSON and cannot be decoded.",
body=res.text,
const="badjson",
) from error
censys_exception = self._get_exception_class(res)
raise censys_exception(
status_code=res.status_code,
body=res.text,
const=const,
message=message,
error_code=error_code,
details=details,
)
def _get(self, endpoint: str, args: Optional[dict] = None, **kwargs) -> dict:
return self._make_call(self._session.get, endpoint, args, **kwargs)
def _post(
self,
endpoint: str,
args: Optional[dict] = None,
data: Optional[dict] = None,
**kwargs,
) -> dict:
return self._make_call(self._session.post, endpoint, args, data, **kwargs)
def _put(
self,
endpoint: str,
args: Optional[dict] = None,
data: Optional[dict] = None,
**kwargs,
) -> dict:
return self._make_call(self._session.put, endpoint, args, data, **kwargs)
def _patch(
self,
endpoint: str,
args: Optional[dict] = None,
data: Optional[dict] = None,
**kwargs,
) -> dict:
return self._make_call(self._session.patch, endpoint, args, data, **kwargs)
def _delete(self, endpoint: str, args: Optional[dict] = None, **kwargs) -> dict:
return self._make_call(self._session.delete, endpoint, args, **kwargs)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6711454
censys-2.2.17/censys/common/config.py 0000644 0000000 0000000 00000003233 14777466662 014502 0 ustar 00 """Interact with the config file."""
import configparser
import os
from pathlib import Path
DEFAULT = "DEFAULT"
HOME_PATH = str(Path.home())
CENSYS_PATH = os.path.join(HOME_PATH, ".config", "censys")
CONFIG_PATH = os.path.join(CENSYS_PATH, "censys.cfg")
default_config = {
"api_id": "",
"api_secret": "",
"asm_api_key": "",
"color": "auto",
}
def get_config_path() -> str:
"""Returns the path to the config file.
Returns:
str: Path to config file.
"""
alt_path = os.getenv("CENSYS_CONFIG_PATH")
if alt_path:
return alt_path
return CONFIG_PATH
def write_config(config: configparser.ConfigParser) -> None:
"""Writes config to file.
Args:
config (configparser.ConfigParser): Configuration to write.
Raises:
PermissionError: If the config file is not writable.
"""
config_path = get_config_path()
if config_path == CONFIG_PATH:
if not os.access(HOME_PATH, os.W_OK):
raise PermissionError(
"Cannot write to home directory. Please set the `CENSYS_CONFIG_PATH` environmental variable to a writeable location."
)
elif not os.path.isdir(CENSYS_PATH):
os.makedirs(CENSYS_PATH)
with open(config_path, "w") as configfile:
config.write(configfile)
def get_config() -> configparser.ConfigParser:
"""Reads and returns config.
Returns:
configparser.ConfigParser: Config for Censys.
"""
config = configparser.ConfigParser(defaults=default_config, default_section=DEFAULT)
config_path = get_config_path()
if os.path.isfile(config_path):
config.read(config_path)
return config
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6711454
censys-2.2.17/censys/common/deprecation.py 0000644 0000000 0000000 00000002123 14777466662 015527 0 ustar 00 """Warns on deprecated class and functions."""
import functools
import warnings
from typing import Callable, Optional
class DeprecationDecorator:
"""Deprecation Decorator for classes and functions."""
def __init__(self, message: Optional[str] = None):
"""Inits DeprecationDecorator.
Args:
message (str): Optional; Message to display to user.
"""
self.message = message
def __call__(self, func: Callable) -> Callable:
"""Wrapper function.
Args:
func (Callable): Function to wrap.
Returns:
Callable: Wrapped function.
"""
@functools.wraps(func)
def new_func(*args, **kwargs):
# warnings.simplefilter("always", DeprecationWarning)
warnings.warn(
self.message or f"Call to deprecated function {func.__name__}.",
category=DeprecationWarning,
stacklevel=2,
)
# warnings.simplefilter("default", DeprecationWarning)
return func(*args, **kwargs)
return new_func
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6711454
censys-2.2.17/censys/common/exceptions.py 0000644 0000000 0000000 00000030237 14777466662 015422 0 ustar 00 """Exceptions for Censys."""
from typing import Dict, Optional, Type
class CensysException(Exception):
"""Base Exception for Censys."""
class CensysCLIException(CensysException):
"""Exception raised when the CLI is passed invalid arguments."""
class CensysAPIException(CensysException):
"""Base Exception for Censys APIs."""
def __init__(
self,
status_code: int,
message: str,
body: Optional[str] = None,
const: Optional[str] = None,
error_code: Optional[int] = None,
details: Optional[str] = None,
):
"""Inits CensysAPIException.
Args:
status_code (int): HTTP status code.
message (str): HTTP message.
body (str): Optional; HTTP body.
const (str): Optional; Constant for manual errors.
error_code (int): Optional; Error code.
details (str): Optional; Additional details.
"""
self.status_code = status_code
self.message = message
self.body = body
self.const = const
self.error_code = error_code
self.details = details
super().__init__(self.message)
class CensysSearchException(CensysAPIException):
"""Base Exception for the Censys search API."""
def __repr__(self) -> str:
"""Representation of CensysSearchException.
Returns:
str: Printable representation.
"""
return f"{self.status_code} ({self.const}): {self.message or self.body}"
__str__ = __repr__
class CensysAsmException(CensysAPIException):
"""Base Exception for the Censys ASM API."""
def __repr__(self) -> str:
"""Representation of CensysAsmException.
Returns:
str: Printable representation.
"""
return (
f"{self.status_code} (Error Code: {self.error_code}), "
f"{self.message}. {self.details}"
)
__str__ = __repr__
class CensysMissingApiKeyException(CensysAsmException):
"""Exception raised when there is no provided ASM API key."""
class CensysRateLimitExceededException(CensysSearchException):
"""Exception raised when your Censys rate limit has been exceeded."""
class CensysNotFoundException(CensysSearchException):
"""Exception raised when the resource requested is not found."""
class CensysUnauthorizedException(CensysSearchException):
"""Exception raised when you doesn't have access to the requested resource."""
class CensysJSONDecodeException(CensysSearchException):
"""Exception raised when the resource requested is not valid JSON."""
class CensysInternalServerException(CensysSearchException):
"""Exception raised when the server encountered an internal error."""
class CensysInvalidRequestException(CensysAsmException):
"""Exception raised when the HTTP request is invalid."""
class CensysInvalidAuthTokenException(CensysAsmException):
"""Exception raised when the auth token is invalid."""
class CensysAsmUnauthorizedException(CensysAsmException):
"""Exception raised when the ASM API is unauthorized."""
class CensysInvalidAPIKeyException(CensysAsmException):
"""Exception raised when the ASM API key is invalid."""
class CensysTooManyRequestsException(CensysAsmException):
"""Exception raised when the allowed requests bandwidth is exceeded."""
class CensysAppDownForMaintenanceException(CensysAsmException):
"""Exception raised when the ASM API is down for maintenance."""
class CensysInvalidSeedDataException(CensysAsmException):
"""Exception raised when the seed data is invalid."""
class CensysAssociatedAssetsThresholdWarningException(CensysAsmException):
"""Exception raised when the asset count is within the warning threshold."""
class CensysTooManyInputNodesException(CensysAsmException):
"""Exception raised when there are too many input nodes."""
class CensysSeedNotFoundException(CensysAsmException):
"""Exception raised when the requested seed can not be found."""
class CensysNotASeedException(CensysAsmException):
"""Exception raised when the requested resource is not a seed."""
class CensysNeedConfirmationToRemoveParentSeedsException(CensysAsmException):
"""Exception raised when confirmation is needed to remove seeds with children."""
class CensysCannotRemoveNonExistentSeedsException(CensysAsmException):
"""Exception raised when trying to remove non existent seed nodes."""
class CensysCannotRemoveNonSeedsException(CensysAsmException):
"""Exception raised when trying to remove non seed nodes."""
class CensysInvalidSeedTypeException(CensysAsmException):
"""Exception raised when the seed type is invalid."""
class CensysInvalidLogbookCursorException(CensysAsmException):
"""Exception raised when the logbook cursor is invalid."""
class CensysTeamNotFoundException(CensysAsmException):
"""Exception raised when the team is not found."""
class CensysPageNumberOutOfRangeException(CensysAsmException):
"""Exception raised when the page number is out of range [1 - totalPages]."""
class CensysInvalidPageSizeException(CensysAsmException):
"""Exception raised when the page size is invalid."""
class CensysHostNotFoundException(CensysAsmException):
"""Exception raised when the requested host is not found."""
class CensysInvalidIPv4AddressException(CensysAsmException):
"""Exception raised when the IPv4 address is invalid."""
class CensysAssetExcludedException(CensysAsmException):
"""Exception raised when the asset is excluded."""
class CensysInvalidCommentException(CensysAsmException):
"""Exception raised when the comment is invalid."""
class CensysCommentNotFoundException(CensysAsmException):
"""Exception raised when the requested comment is not found."""
class CensysSubdomainNotFoundException(CensysAsmException):
"""Exception raised when the requested subdomain is not found."""
class CensysInvalidColorException(CensysAsmException):
"""Exception raised when the specified color is invalid."""
class CensysTagHasTrailingOrLeadingWhitespaceException(CensysAsmException):
"""Exception raised when the specified tag has trailing or leading whitespace."""
class CensysTagIsEmptyStringException(CensysAsmException):
"""Exception raised when the specified tag is an empty string."""
class CensysTagLabelsDifferOnlyInCasingException(CensysAsmException):
"""Exception raised when the tag differs from an existing tag in only casing."""
class CensysTagLabelTooLongException(CensysAsmException):
"""Exception raised when the specified tag label is too long."""
class CensysTagColorTooLongException(CensysAsmException):
"""Exception raised when the specified tag color is too long."""
class CensysCannotCreateTagWithNewColorException(CensysAsmException):
"""Exception raised when the specified tag cannot be created with a new color."""
class CensysTagColorHasTrailingOrLeadingWhitespaceException(CensysAsmException):
"""Exception raised when the tag color has trailing or leading whitespace."""
class CensysCertificateNotFoundException(CensysAsmException):
"""Exception raised when the certificate is not found."""
class CensysDomainNotFoundException(CensysAsmException):
"""Exception raised when the domain is not found."""
class CensysInvalidCloudAssetDataException(CensysAsmException):
"""Exception raised when invalid cloud asset data is submitted."""
class CensysInvalidObjectStorageAssetIdentifierException(CensysAsmException):
"""Exception raised when object storage name is not a valid asset URL."""
class CensysInvalidObjectStorageAssetNotFoundException(CensysAsmException):
"""Exception raised when no object storage assets with given URL were found."""
class CensysBadJSONBodyException(CensysAsmException):
"""Exception raised when a bad JSON string is in the body."""
class CensysRiskNotFoundException(CensysAsmException):
"""Exception raised when no risks are found with given risk_id."""
class CensysInvalidDateException(CensysAsmException):
"""Exception raised when an invalid date is submitted."""
class CensysInvalidCloudException(CensysAsmException):
"""Exception raised when an invalid cloud is submitted."""
class CensysAssetNotFoundException(CensysAsmException):
"""Exception raised when the asset is not found."""
class CensysInvalidKeywordsInBodyException(CensysAsmException):
"""Exception raised when invalid keywords are in the body."""
class CensysSearchAPITimeoutException(CensysAsmException):
"""Exception raised when the search API times out."""
class CensysSearchAPIErrorException(CensysAsmException):
"""Exception raised when the search API returns an error."""
class CensysInternalServerErrorException(CensysAsmException):
"""Exception raised when the search API returns an error."""
class CensysInvalidCommentHTMLException(CensysAsmException):
"""Exception raised when the comment contains invalid HTML."""
class CensysInvalidSearchAPIResponseException(CensysAsmException):
"""Exception raised when the search API returns an error."""
class CensysTooSoonToResendInviteException(CensysAsmException):
"""Exception raised when it is too soon to resend the invite."""
class CensysExceptionMapper:
"""Map status code to Exception for the ASM and Search API."""
ASM_EXCEPTIONS: Dict[int, Type[CensysAsmException]] = {
10000: CensysMissingApiKeyException,
10001: CensysInvalidAPIKeyException,
10002: CensysInvalidAuthTokenException,
10006: CensysAsmUnauthorizedException,
10007: CensysInvalidSeedDataException,
10008: CensysInvalidRequestException,
10011: CensysCannotRemoveNonSeedsException,
10012: CensysCannotRemoveNonExistentSeedsException,
10013: CensysNeedConfirmationToRemoveParentSeedsException,
10014: CensysSeedNotFoundException,
10015: CensysNotASeedException,
10016: CensysTooManyInputNodesException,
10017: CensysAssociatedAssetsThresholdWarningException,
10018: CensysHostNotFoundException,
10019: CensysDomainNotFoundException,
10020: CensysCertificateNotFoundException,
10021: CensysInvalidIPv4AddressException,
10022: CensysAssetExcludedException,
10025: CensysTagHasTrailingOrLeadingWhitespaceException,
10026: CensysTagIsEmptyStringException,
10027: CensysTagLabelsDifferOnlyInCasingException,
10028: CensysTagLabelTooLongException,
10029: CensysAppDownForMaintenanceException,
10034: CensysTagColorTooLongException,
10035: CensysCannotCreateTagWithNewColorException,
10036: CensysTagColorHasTrailingOrLeadingWhitespaceException,
10037: CensysInvalidColorException,
10038: CensysInvalidSeedTypeException,
10039: CensysTooManyRequestsException,
10040: CensysInvalidLogbookCursorException,
10045: CensysTeamNotFoundException,
10050: CensysInvalidPageSizeException,
10051: CensysPageNumberOutOfRangeException,
10054: CensysInvalidCommentException,
10055: CensysCommentNotFoundException,
10057: CensysSubdomainNotFoundException,
10059: CensysInvalidCloudAssetDataException,
10060: CensysInvalidObjectStorageAssetIdentifierException,
10061: CensysInvalidObjectStorageAssetNotFoundException,
10067: CensysBadJSONBodyException,
10073: CensysRiskNotFoundException,
10078: CensysInvalidDateException,
10082: CensysInvalidCloudException,
10086: CensysAssetNotFoundException,
10091: CensysInvalidKeywordsInBodyException,
10096: CensysSearchAPITimeoutException,
10097: CensysSearchAPIErrorException,
10098: CensysInternalServerErrorException,
10099: CensysInvalidCommentHTMLException,
10107: CensysInvalidSearchAPIResponseException,
10120: CensysTooSoonToResendInviteException,
}
"""Map of status code to ASM Exception."""
SEARCH_EXCEPTIONS: Dict[int, Type[CensysSearchException]] = {
401: CensysUnauthorizedException,
403: CensysUnauthorizedException,
404: CensysNotFoundException,
429: CensysRateLimitExceededException,
500: CensysInternalServerException,
}
"""Map of status code to Search Exception."""
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6711454
censys-2.2.17/censys/common/types.py 0000644 0000000 0000000 00000000221 14777466662 014373 0 ustar 00 """Common types for the Censys Python SDK."""
import datetime
from typing import Union
Datetime = Union[str, datetime.date, datetime.datetime]
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6711454
censys-2.2.17/censys/common/utils.py 0000644 0000000 0000000 00000001435 14777466662 014377 0 ustar 00 """Common utilities for the Censys Python SDK."""
import datetime
from .types import Datetime
def format_rfc3339(time: Datetime) -> str:
"""Formats a datetime object into an RFC3339 string.
Args:
time (Datetime): Datetime object to format.
Returns:
str: RFC3339 formatted string.
"""
if isinstance(time, (datetime.date, datetime.datetime)):
time = time.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
return time
def format_iso8601(time: Datetime) -> str:
"""Formats a datetime object into an ISO8601 string.
Args:
time (Datetime): Datetime object to format.
Returns:
str: ISO8601 formatted string.
"""
if isinstance(time, (datetime.date, datetime.datetime)):
return time.strftime("%Y-%m-%d")
return time
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6711454
censys-2.2.17/censys/common/version.py 0000644 0000000 0000000 00000000145 14777466662 014721 0 ustar 00 """Censys Version."""
import importlib.metadata
__version__ = importlib.metadata.version("censys")
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6711454
censys-2.2.17/censys/py.typed 0000644 0000000 0000000 00000000000 14777466662 013057 0 ustar 00 ././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6711454
censys-2.2.17/censys/search/__init__.py 0000644 0000000 0000000 00000000527 14777466662 014754 0 ustar 00 """An easy-to-use and lightweight API wrapper for Censys Search API (search.censys.io)."""
from .client import SearchClient
from .v1 import CensysData
from .v2 import CensysCerts, CensysHosts
__copyright__ = "Copyright 2024 Censys, Inc."
__all__ = [
"SearchClient",
"CensysData",
"CensysCerts",
"CensysHosts",
]
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6711454
censys-2.2.17/censys/search/client.py 0000644 0000000 0000000 00000003457 14777466662 014500 0 ustar 00 """Interact with all Search APIs."""
from .v1 import CensysData
from .v2 import CensysCerts, CensysHosts
class SearchClient:
"""Client for interacting with all Search APIs.
All indexes are passed the args and kwargs that are provided.
Examples:
Inits SearchClient.
>>> from censys.search import SearchClient
>>> c = SearchClient()
Access both v1 and v2 indexes.
>>> data = c.v1.data # CensysData()
>>> hosts = c.v2.hosts # CensysHosts()
>>> certs = c.v2.certs # CensysCerts()
"""
class _V1:
"""Class for v1 Search APIs."""
data: CensysData
def __init__(self, *args, **kwargs):
"""Inits V1.
Args:
*args: Variable length argument list.
**kwargs: Arbitrary keyword arguments.
"""
self.data = CensysData(*args, **kwargs)
class _V2:
"""Class for v2 Search APIs."""
hosts: CensysHosts
certs: CensysCerts
certificates: CensysCerts
def __init__(self, *args, **kwargs):
"""Inits V2.
Args:
*args: Variable length argument list.
**kwargs: Arbitrary keyword arguments.
"""
self.hosts = CensysHosts(*args, **kwargs)
self.certs = CensysCerts(*args, **kwargs)
self.certificates = self.certs
def __init__(self, *args, **kwargs):
"""Inits SearchClient.
Args:
*args: Variable length argument list.
**kwargs: Arbitrary keyword arguments.
"""
# Backwards compatibility
if len(args) == 2:
kwargs["api_id"] = args[0]
kwargs["api_secret"] = args[1]
self.v1 = self._V1(**kwargs)
self.v2 = self._V2(**kwargs)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6711454
censys-2.2.17/censys/search/v1/__init__.py 0000644 0000000 0000000 00000000147 14777466662 015300 0 ustar 00 """Interact with the Censys Search v1 APIs."""
from .data import CensysData
__all__ = ["CensysData"]
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6711454
censys-2.2.17/censys/search/v1/api.py 0000644 0000000 0000000 00000005230 14777466662 014310 0 ustar 00 """Base for interacting with the Censys Search API."""
import os
from typing import List, Optional, Type
from requests.models import Response
from censys.common.base import CensysAPIBase
from censys.common.config import DEFAULT, get_config
from censys.common.exceptions import (
CensysException,
CensysExceptionMapper,
CensysSearchException,
)
Fields = Optional[List[str]]
class CensysSearchAPIv1(CensysAPIBase):
"""This class is the base class for all v1 API indexes."""
DEFAULT_URL: str = "https://search.censys.io/api/v1"
"""Default Search API base URL."""
INDEX_NAME: Optional[str] = None
"""Name of Censys Index."""
def __init__(
self, api_id: Optional[str] = None, api_secret: Optional[str] = None, **kwargs
):
"""Inits CensysSearchAPIv1.
See CensysAPIBase for additional arguments.
Args:
api_id (str): Optional; The API ID provided by Censys.
api_secret (str): Optional; The API secret provided by Censys.
**kwargs: Arbitrary keyword arguments.
Raises:
CensysException: Base Exception Class for the Censys API.
"""
CensysAPIBase.__init__(self, kwargs.pop("url", self.DEFAULT_URL), **kwargs)
# Gets config file
config = get_config()
# Try to get credentials
self._api_id = (
api_id or os.getenv("CENSYS_API_ID") or config.get(DEFAULT, "api_id")
)
self._api_secret = (
api_secret
or os.getenv("CENSYS_API_SECRET")
or config.get(DEFAULT, "api_secret")
)
if not self._api_id or not self._api_secret:
raise CensysException("No API ID or API secret configured.")
self._session.auth = (self._api_id, self._api_secret)
# Generate concrete paths to be called
self.search_path = f"/search/{self.INDEX_NAME}"
self.view_path = f"/view/{self.INDEX_NAME}/"
self.report_path = f"/report/{self.INDEX_NAME}"
# Confirm setup
# self.account()
def _get_exception_class( # type: ignore
self, res: Response
) -> Type[CensysSearchException]:
return CensysExceptionMapper.SEARCH_EXCEPTIONS.get(
res.status_code, CensysSearchException
)
def account(self) -> dict:
"""Gets the current account information.
This includes email and quota.
Returns:
dict: Account response.
"""
return self._get("account")
def quota(self) -> dict:
"""Gets the current account's query quota.
Returns:
dict: Quota response.
"""
return self.account()["quota"]
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6721454
censys-2.2.17/censys/search/v1/data.py 0000644 0000000 0000000 00000002311 14777466662 014445 0 ustar 00 """Interact with the Censys Search Data API."""
from .api import CensysSearchAPIv1
class CensysData(CensysSearchAPIv1):
"""Interacts with the Data index.
For more details, see our documentation: https://search.censys.io/api
"""
_PREFIX = "/data"
"""Endpoint prefix."""
def get_series(self) -> dict:
"""Get data on the types of scans we regularly perform (series).
Returns:
dict: The result set returned.
"""
return self._get(self._PREFIX)
def view_series(self, series_id: str) -> dict:
"""Get data on a specific series.
Args:
series_id (str): The ID of the series.
Returns:
dict: The result set returned.
"""
path = f"{self._PREFIX}/{series_id}"
return self._get(path)
def view_result(self, series_id: str, result_id: str) -> dict:
"""View a specific result of a specific series.
Args:
series_id (str): The ID of the series.
result_id (str): The ID of the result.
Returns:
dict: The result set returned.
"""
path = f"{self._PREFIX}/{series_id}/{result_id}"
return self._get(path)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6721454
censys-2.2.17/censys/search/v2/__init__.py 0000644 0000000 0000000 00000000230 14777466662 015272 0 ustar 00 """Interact with the Censys Search v2 APIs."""
from .certs import CensysCerts
from .hosts import CensysHosts
__all__ = ["CensysCerts", "CensysHosts"]
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6721454
censys-2.2.17/censys/search/v2/api.py 0000644 0000000 0000000 00000055243 14777466662 014322 0 ustar 00 """Base for interacting with the Censys Search API."""
import os
from concurrent.futures import ThreadPoolExecutor, as_completed
from typing import Any, Dict, Iterable, Iterator, List, Optional, Type, Union
from requests.models import Response
from censys.common.base import CensysAPIBase
from censys.common.config import DEFAULT, get_config
from censys.common.exceptions import (
CensysException,
CensysExceptionMapper,
CensysSearchException,
)
INDEX_TO_KEY = {"hosts": "ip", "certificates": "fingerprint_sha256"}
class CensysSearchAPIv2(CensysAPIBase):
"""This class is the base class for the Hosts index.
Examples:
>>> c = CensysSearchAPIv2()
"""
DEFAULT_URL: str = "https://search.censys.io/api"
"""Default Search API base URL."""
INDEX_NAME: str = ""
"""Name of Censys Index."""
def __init__(
self, api_id: Optional[str] = None, api_secret: Optional[str] = None, **kwargs
):
"""Inits CensysSearchAPIv2.
See CensysAPIBase for additional arguments.
Args:
api_id (str): Optional; The API ID provided by Censys.
api_secret (str): Optional; The API secret provided by Censys.
**kwargs: Arbitrary keyword arguments.
Raises:
CensysException: Base Exception Class for the Censys API.
"""
CensysAPIBase.__init__(self, kwargs.pop("url", self.DEFAULT_URL), **kwargs)
# Gets config file
config = get_config()
# Try to get credentials
self._api_id = (
api_id or os.getenv("CENSYS_API_ID") or config.get(DEFAULT, "api_id")
)
self._api_secret = (
api_secret
or os.getenv("CENSYS_API_SECRET")
or config.get(DEFAULT, "api_secret")
)
if not self._api_id or not self._api_secret:
raise CensysException("No API ID or API secret configured.")
self._session.auth = (self._api_id, self._api_secret)
# Generate concrete paths to be called
self.view_path = f"/v2/{self.INDEX_NAME}/"
self.search_path = f"/v2/{self.INDEX_NAME}/search"
self.aggregate_path = f"/v2/{self.INDEX_NAME}/aggregate"
self.tags_path = "/v2/tags"
self.account_path = "/v1/account"
def _get_exception_class( # type: ignore
self, res: Response
) -> Type[CensysSearchException]:
return CensysExceptionMapper.SEARCH_EXCEPTIONS.get(
res.status_code, CensysSearchException
)
def account(self) -> dict:
"""Gets the current account's query quota.
Returns:
dict: Quota response.
"""
return self._get(self.account_path)
def quota(self) -> dict:
"""Returns metadata of a given search query.
Returns:
dict: The metadata of the result set returned.
"""
return self.account()["quota"]
class Query(Iterable):
"""Query class that is callable and iterable.
Object Searches the given index for all records that match the given query.
For more details, see our documentation: https://search.censys.io/api
"""
# Total number of results (Set after first query)
total: Optional[int] = None
def __init__(
self,
api: "CensysSearchAPIv2",
query: str,
per_page: Optional[int] = None,
cursor: Optional[str] = None,
pages: int = 1,
fields: Optional[List[str]] = None,
sort: Optional[Union[str, List[str]]] = None,
**kwargs: Any,
):
"""Inits Query.
Args:
api (CensysSearchAPIv2): Parent API object.
query (str): The query to be executed.
per_page (int): Optional; The number of results to be returned for each page. Defaults to 100.
cursor (int): Optional; The cursor of the desired result set.
pages (int): Optional; The number of pages returned. Defaults to 1. If you set this to -1, it will return all pages.
fields (List[str]): Optional; The fields to be returned. Defaults to base fields.
sort (Union[str, List[str]]): Optional; The fields to sort by. Defaults to None.
**kwargs (Any): Optional; Additional arguments to be passed to the query.
"""
self.api = api
self.query = query
self.per_page = per_page
self.cursor = cursor
self.nextCursor: Optional[str] = None
self.page = 1
if pages <= 0:
self.pages = float("inf")
else:
self.pages = pages
self.fields = fields
self.sort = sort
self.extra_args = kwargs
def __call__(self, per_page: Optional[int] = None) -> List[dict]:
"""Search current index.
Args:
per_page (int): Optional; The number of results to be returned for each page. Defaults to 100.
Raises:
StopIteration: Raised when pages have been already received.
Returns:
List[dict]: One page worth of result hits.
"""
if self.page > self.pages:
raise StopIteration
payload = self.api.raw_search(
query=self.query,
per_page=per_page or self.per_page or 100,
cursor=self.nextCursor or self.cursor,
fields=self.fields,
sort=self.sort,
**self.extra_args,
)
self.page += 1
result = payload["result"]
self.total = result["total"]
self.nextCursor = result["links"].get("next")
if self.total == 0 or not self.nextCursor:
self.pages = 0
return result["hits"]
def __next__(self) -> List[dict]:
"""Gets next page of search results.
Returns:
List[dict]: One page worth of result hits.
"""
return self.__call__()
def __iter__(self) -> Iterator[List[dict]]:
"""Gets Iterator.
Returns:
Iterable: Returns self.
"""
return self
def view_all(self, max_workers: int = 20) -> Dict[str, dict]:
"""View each document returned from query.
Please note that each result returned by the query will be looked up using the view method.
Args:
max_workers (int): The number of workers to use. Defaults to 20.
Returns:
Dict[str, dict]: Dictionary mapping documents to that document's result set.
"""
results = {}
document_key = INDEX_TO_KEY.get(self.api.INDEX_NAME, "ip")
with ThreadPoolExecutor(max_workers) as executor:
threads = {}
while self.page <= self.pages:
for hit in self.__call__():
hit_key = hit[document_key]
if "name" in hit and self.api.INDEX_NAME == "hosts":
hit_key += "+" + hit["name"]
threads[executor.submit(self.api.view, hit_key)] = hit_key
for task in as_completed(threads):
document_id = threads[task]
try:
results[document_id] = task.result()
except Exception as e:
results[document_id] = {"error": str(e)}
return results
def search(
self,
query: str,
per_page: int = 100,
cursor: Optional[str] = None,
pages: int = 1,
fields: Optional[List[str]] = None,
sort: Optional[Union[str, List[str]]] = None,
**kwargs: Any,
) -> Query:
"""Search current index.
Searches the given index for all records that match the given query.
For more details, see our documentation: https://search.censys.io/api
Args:
query (str): The query to be executed.
per_page (int): Optional; The number of results to be returned for each page. Defaults to 100.
cursor (int): Optional; The cursor of the desired result set.
pages (int): Optional; The number of pages returned. Defaults to 1.
fields (List[str]): Optional; The fields to be returned. Defaults to base fields.
sort (Union[str, List[str]]): Optional; The fields to sort by. Defaults to None.
**kwargs (Any): Optional; Additional arguments to be passed to the query.
Returns:
Query: Query object that can be a callable or an iterable.
"""
return self.Query(self, query, per_page, cursor, pages, fields, sort, **kwargs)
def search_post_raw(
self,
query: str,
per_page: int = 100,
cursor: Optional[str] = None,
fields: Optional[List[str]] = None,
sort: Optional[Union[str, List[str]]] = None,
**kwargs,
) -> dict:
"""Searches the given index for all records that match the given query.
Args:
query (str): The query string to search for.
per_page (int): The number of results to return per page. Defaults to 50.
cursor (str, optional): Cursor token from the API response, which fetches the next page of results when added to the endpoint URL.
fields (List[str], optional): The fields to be returned. Defaults to base fields.
sort (Union[str, List[str]], optional): The fields to sort by. Defaults to None.
**kwargs: Arbitrary keyword arguments.
Returns:
dict: Search results.
"""
data = {
"q": query,
"per_page": per_page,
}
if cursor:
data["cursor"] = cursor
if fields:
data["fields"] = fields
if sort:
data["sort"] = sort
data.update(kwargs)
return self._post(self.search_path, data=data)
def search_post(
self,
query: str,
per_page: int = 100,
cursor: Optional[str] = None,
fields: Optional[List[str]] = None,
sort: Optional[Union[str, List[str]]] = None,
**kwargs,
) -> dict:
"""Searches the Certs index using the POST method.
This method returns the `result` field of the raw response.
If you wish to access the raw response, please use `search_post_raw` instead.
Args:
query (str): The query string to search for.
per_page (int): The number of results to return per page. Defaults to 50.
cursor (str, optional): Cursor token from the API response, which fetches the next page of results when added to the endpoint URL.
fields (List[str], optional): Additional fields to return in the matched documents. Defaults to base fields.
sort (Union[str, List[str]], optional): The fields to sort by. Defaults to None.
**kwargs: Arbitrary keyword arguments.
Returns:
dict: Search results.
"""
return self.search_post_raw(
query=query,
per_page=per_page,
cursor=cursor,
fields=fields,
sort=sort,
**kwargs,
)["result"]
def search_get_raw(
self,
query: str,
per_page: int = 100,
cursor: Optional[str] = None,
fields: Optional[List[str]] = None,
sort: Optional[Union[str, List[str]]] = None,
**kwargs: Any,
) -> dict:
"""Search current index using GET method.
Args:
query (str): The query to be executed.
per_page (int): Optional; The number of results to be returned for each page. Defaults to 100.
cursor (int): Optional; The cursor of the desired result set.
fields (List[str]): Optional; The fields to be returned. Defaults to base fields.
sort (Union[str, List[str]]): Optional; The fields to sort by. Defaults to None.
**kwargs (Any): Optional; Additional arguments to be passed to the query.
Returns:
dict: The raw result set.
"""
args = {
"q": query,
"per_page": per_page,
"cursor": cursor,
"fields": fields,
"sort": sort,
}
args.update(kwargs)
return self._get(self.search_path, args)
def search_get(
self,
query: str,
per_page: int = 100,
cursor: Optional[str] = None,
fields: Optional[List[str]] = None,
sort: Optional[Union[str, List[str]]] = None,
**kwargs: Any,
) -> dict:
"""Search current index using GET method.
Args:
query (str): The query to be executed.
per_page (int): Optional; The number of results to be returned for each page. Defaults to 100.
cursor (int): Optional; The cursor of the desired result set.
fields (List[str]): Optional; The fields to be returned. Defaults to base fields.
sort (Union[str, List[str]]): Optional; The fields to sort by. Defaults to None.
**kwargs (Any): Optional; Additional arguments to be passed to the query.
Returns:
dict: The raw result set.
"""
return self.search_get_raw(
query=query,
per_page=per_page,
cursor=cursor,
fields=fields,
sort=sort,
**kwargs,
)["result"]
def raw_search(
self,
query: str,
per_page: int = 100,
cursor: Optional[str] = None,
fields: Optional[List[str]] = None,
sort: Optional[Union[str, List[str]]] = None,
**kwargs: Any,
) -> dict:
"""Search current index.
Searches the given index for all records that match the given query.
This method does no automatic pagination or post processing.
Args:
query (str): The query to be executed.
per_page (int): Optional; The number of results to be returned for each page. Defaults to 100.
cursor (int): Optional; The cursor of the desired result set.
fields (List[str]): Optional; The fields to be returned. Defaults to base fields.
sort (Union[str, List[str]]): Optional; The fields to sort by. Defaults to None.
**kwargs (Any): Optional; Additional arguments to be passed to the query.
Returns:
dict: The raw result set.
"""
return self.search_post_raw(
query=query,
per_page=per_page,
cursor=cursor,
fields=fields,
sort=sort,
**kwargs,
)
def view(self, document_id: str, **kwargs: Any) -> dict:
"""View document from current index.
View the current structured data we have on a specific document.
For more details, see our documentation: https://search.censys.io/api
Args:
document_id (str): The ID of the document you are requesting.
**kwargs (Any): Optional; Additional arguments to be passed to the query.
Returns:
dict: The result set returned.
"""
return self._get(self.view_path + document_id, args=kwargs)["result"]
def bulk_view(
self,
document_ids: List[str],
max_workers: int = 20,
**kwargs: Any,
) -> Dict[str, dict]:
"""Bulk view documents from current index.
View the current structured data we have on a list of documents.
For more details, see our documentation: https://search.censys.io/api
Args:
document_ids (List[str]): The IDs of the documents you are requesting.
max_workers (int): The number of workers to use. Defaults to 20.
**kwargs (Any): Optional; Additional arguments to be passed to the query.
Returns:
Dict[str, dict]: Dictionary mapping document IDs to that document's result set.
"""
documents = {}
with ThreadPoolExecutor(max_workers) as executor:
threads = {
executor.submit(self.view, document_id, **kwargs): document_id
for document_id in document_ids
}
for task in as_completed(threads):
document_id = threads[task]
try:
documents[document_id] = task.result()
except Exception as e:
documents[document_id] = {"error": str(e)}
return documents
def aggregate(
self, query: str, field: str, num_buckets: int = 50, **kwargs: Any
) -> dict:
"""Aggregate current index.
Creates a report on the breakdown of the values of a field in a result set.
For more details, see our documentation: https://search.censys.io/api
Args:
query (str): The query to be executed.
field (str): The field you are running a breakdown on.
num_buckets (int): Optional; The maximum number of values. Defaults to 50.
**kwargs (Any): Optional; Additional arguments to be passed to the query.
Returns:
dict: The result set returned.
"""
args = {"q": query, "field": field, "num_buckets": num_buckets, **kwargs}
return self._get(self.aggregate_path, args)["result"]
# Comments
def get_comments(self, document_id: str) -> List[dict]:
"""Get comments for a document.
Args:
document_id (str): The ID of the document you are requesting.
Returns:
List[dict]: The list of comments.
"""
return self._get(self.view_path + document_id + "/comments")["result"][
"comments"
]
def get_comment(self, document_id: str, comment_id: str) -> dict:
"""Get comment for a document.
Args:
document_id (str): The ID of the document you are requesting.
comment_id (str): The ID of the comment you are requesting.
Returns:
dict: The result set returned.
"""
return self._get(self.view_path + document_id + "/comments/" + comment_id)[
"result"
]
def add_comment(self, document_id: str, contents: str) -> dict:
"""Add comment to a document.
Args:
document_id (str): The ID of the document you are requesting.
contents (str): The contents of the comment.
Returns:
dict: The result set returned.
"""
return self._post(
self.view_path + document_id + "/comments", data={"contents": contents}
)["result"]
def delete_comment(self, document_id: str, comment_id: str) -> dict:
"""Delete comment from a document.
Args:
document_id (str): The ID of the document you are requesting.
comment_id (str): The ID of the comment you are requesting.
Returns:
dict: The result set returned.
"""
return self._delete(self.view_path + document_id + "/comments/" + comment_id)
def update_comment(self, document_id: str, comment_id: str, contents: str) -> dict:
"""Update comment from a document.
Args:
document_id (str): The ID of the document you are requesting.
comment_id (str): The ID of the comment you are requesting.
contents (str): The contents of the comment.
Returns:
dict: The result set returned.
"""
return self._put(
self.view_path + document_id + "/comments/" + comment_id,
data={"contents": contents},
)
# Tags
def list_all_tags(self) -> List[dict]:
"""List all tags.
Returns:
List[dict]: The list of tags.
"""
return self._get(self.tags_path)["result"]["tags"]
def create_tag(self, name: str, color: Optional[str] = None) -> dict:
"""Create a tag.
Args:
name (str): The name of the tag.
color (str): Optional; The color of the tag.
Returns:
dict: The result set returned.
"""
tag_def: Dict[str, Any] = {"name": name}
if color:
tag_def["metadata"] = {"color": color}
return self._post(self.tags_path, data=tag_def)["result"]
def get_tag(self, tag_id: str) -> dict:
"""Get a tag.
Args:
tag_id (str): The ID of the tag.
Returns:
dict: The result set returned.
"""
return self._get(self.tags_path + "/" + tag_id)["result"]
def update_tag(self, tag_id: str, name: str, color: Optional[str] = None) -> dict:
"""Update a tag.
Args:
tag_id (str): The ID of the tag.
name (str): The name of the tag.
color (str): The color of the tag.
Returns:
dict: The result set returned.
"""
tag_def: Dict[str, Any] = {"name": name}
if color:
tag_def["metadata"] = {"color": color}
return self._put(
self.tags_path + "/" + tag_id,
data=tag_def,
)["result"]
def delete_tag(self, tag_id: str):
"""Delete a tag.
Args:
tag_id (str): The ID of the tag.
"""
self._delete(self.tags_path + "/" + tag_id)
def _list_documents_with_tag(
self, tag_id: str, endpoint: str, keyword: str
) -> List[dict]:
"""List documents by tag.
Args:
tag_id (str): The ID of the tag.
endpoint (str): The endpoint to be called.
keyword (str): The keyword to be used in the endpoint.
Returns:
List[dict]: The list of documents.
"""
return self._get(self.tags_path + "/" + tag_id + "/" + endpoint)["result"][
keyword
]
def list_tags_on_document(self, document_id: str) -> List[dict]:
"""List tags on a document.
Args:
document_id (str): The ID of the document.
Returns:
List[dict]: The list of tags.
"""
return self._get(self.view_path + document_id + "/tags")["result"]["tags"]
def add_tag_to_document(self, document_id: str, tag_id: str):
"""Add a tag to a document.
Args:
document_id (str): The ID of the document.
tag_id (str): The ID of the tag.
"""
self._put(self.view_path + document_id + "/tags/" + tag_id)
def remove_tag_from_document(self, document_id: str, tag_id: str):
"""Remove a tag from a document.
Args:
document_id (str): The ID of the document.
tag_id (str): The ID of the tag.
"""
self._delete(self.view_path + document_id + "/tags/" + tag_id)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6721454
censys-2.2.17/censys/search/v2/certs.py 0000644 0000000 0000000 00000033673 14777466662 014674 0 ustar 00 """Interact with the Censys Search Cert API."""
import warnings
from typing import List, Optional, Union
from ...common.types import Datetime
from ...common.utils import format_rfc3339
from .api import CensysSearchAPIv2
class CensysCerts(CensysSearchAPIv2):
"""Interacts with the Certs index.
Please note that this class represents only the v2 API endpoints.
Examples:
Inits Censys Certs.
>>> from censys.search import CensysCerts
>>> c = CensysCerts()
Search for hosts by sha256fp.
>>> c.get_hosts_by_cert("fb444eb8e68437bae06232b9f5091bccff62a768ca09e92eb5c9c2cf9d17c426")
(
[
{
"ip": "string",
"name": "string",
"observed_at": "2021-08-02T14:56:38.711Z",
"first_observed_at": "2021-08-02T14:56:38.711Z",
}
],
{
"next": "nextCursorToken",
},
)
"""
INDEX_NAME = "certificates"
"""Name of Censys Index."""
def __init__(
self, api_id: Optional[str] = None, api_secret: Optional[str] = None, **kwargs
):
"""Inits CensysCerts.
See CensysSearchAPIv2 for additional arguments.
Args:
api_id (Optional[str], optional): API ID. Defaults to None.
api_secret (Optional[str], optional): API Secret. Defaults to None.
**kwargs: Arbitrary keyword arguments.
"""
super().__init__(api_id=api_id, api_secret=api_secret, **kwargs)
self.bulk_path = f"/v2/{self.INDEX_NAME}/bulk"
def view(self, document_id: str, **kwargs) -> dict:
"""Fetches the certificate record for the specified SHA-256 fingerprint.
Args:
document_id (str): The SHA-256 fingerprint of the requested certificate.
**kwargs: Arbitrary keyword arguments.
Returns:
dict: Certificate details.
"""
return self._get(self.view_path + document_id, args=kwargs)["result"]
def bulk_post(self, fingerprints: List[str]) -> List[dict]:
"""Fetches the certificate records for the specified SHA-256 fingerprints.
Using the POST method allows for a larger number of fingerprints to be queried at once.
Args:
fingerprints (List[str]): List of certificate SHA256 fingerprints.
Returns:
dict: Certificate details.
"""
data = {"fingerprints": fingerprints}
return self._post(self.bulk_path, data=data)["result"]
def bulk_get(self, fingerprints: List[str]) -> List[dict]:
"""Fetches the certificate records for the specified SHA-256 fingerprints.
Using the GET method allows for a smaller number of fingerprints to be queried at once.
Args:
fingerprints (List[str]): List of certificate SHA256 fingerprints.
Returns:
dict: Certificate details.
"""
args = {"fingerprints": fingerprints}
return self._get(self.bulk_path, args=args)["result"]
def bulk(self, fingerprints: List[str]) -> List[dict]:
"""Fetches the certificate records for the specified SHA-256 fingerprints.
By default, this function uses the POST method, which allows for a larger number of fingerprints to be queried at once.
If you wish to use the GET method, please use `CensysCerts.bulk_get` instead.
Args:
fingerprints (List[str]): List of certificate SHA256 fingerprints.
Returns:
dict: Certificate details.
"""
return self.bulk_post(fingerprints)
def bulk_view(self, fingerprints: List[str]) -> List[dict]: # type: ignore[override]
"""Fetches the certificate records for the specified SHA-256 fingerprints.
By default, this function uses the POST method, which allows for a larger number of fingerprints to be queried at once.
If you wish to use the GET method, please use `CensysCerts.bulk_get` instead.
Args:
fingerprints (List[str]): List of certificate SHA256 fingerprints.
Returns:
dict: Certificate details.
"""
return self.bulk_post(fingerprints)
def search_post_raw(
self,
query: str,
per_page: int = 50,
cursor: Optional[str] = None,
fields: Optional[List[str]] = None,
sort: Optional[Union[str, List[str]]] = None,
**kwargs,
) -> dict:
"""Searches the Certs index using the POST method. Returns the raw response.
Args:
query (str): The query string to search for.
per_page (int): The number of results to return per page. Defaults to 50.
cursor (str, optional): Cursor token from the API response, which fetches the next page of results when added to the endpoint URL.
fields (List[str], optional): Additional fields to return in the matched certificates outside of the default returned fields.
sort (List[str], optional): A list of fields to sort on. By default, fields will be sorted in ascending order.
**kwargs: Arbitrary keyword arguments.
Returns:
dict: Search results.
"""
return super().search_post_raw(
query=query,
per_page=per_page,
cursor=cursor,
fields=fields,
sort=sort,
**kwargs,
)
def search_post(
self,
query: str,
per_page: int = 50,
cursor: Optional[str] = None,
fields: Optional[List[str]] = None,
sort: Optional[Union[str, List[str]]] = None,
**kwargs,
) -> dict:
"""Searches the Certs index using the POST method.
This method returns the `result` field of the raw response.
If you wish to access the raw response, please use `CensysCerts.search_post_raw` instead.
Args:
query (str): The query string to search for.
per_page (int): The number of results to return per page. Defaults to 50.
cursor (str, optional): Cursor token from the API response, which fetches the next page of results when added to the endpoint URL.
fields (List[str], optional): Additional fields to return in the matched certificates outside of the default returned fields.
sort (List[str], optional): A list of fields to sort on. By default, fields will be sorted in ascending order.
**kwargs: Arbitrary keyword arguments.
Returns:
dict: Search results.
"""
return super().search_post(
query=query,
per_page=per_page,
cursor=cursor,
fields=fields,
sort=sort,
**kwargs,
)
def search_get(
self,
query: str,
per_page: int = 50,
cursor: Optional[str] = None,
fields: Optional[List[str]] = None,
sort: Optional[Union[str, List[str]]] = None,
**kwargs,
) -> dict:
"""Searches the Certs index using the GET method.
Args:
query (str): The query string to search for.
per_page (int): The number of results to return per page. Defaults to 50.
cursor (str, optional): Cursor token from the API response, which fetches the next page of results when added to the endpoint URL.
fields (List[str], optional): Additional fields to return in the matched certificates outside of the default returned fields.
sort (List[str], optional): A list of fields to sort on. By default, fields will be sorted in ascending order.
**kwargs: Arbitrary keyword arguments.
Returns:
dict: Search results.
"""
return super().search_get(
query=query,
per_page=per_page,
cursor=cursor,
fields=fields,
sort=sort,
**kwargs,
)
def raw_search(
self,
query: str,
per_page: int = 50,
cursor: Optional[str] = None,
fields: Optional[List[str]] = None,
sort: Optional[Union[str, List[str]]] = None,
**kwargs,
) -> dict:
"""Searches the Certs index.
Searches the Certs index for all records that match the given query.
This method does no automatic pagination or post processing.
Args:
query (str): The query string to search for.
per_page (int): The number of results to return per page. Defaults to 50.
cursor (str, optional): Cursor token from the API response, which fetches the next page of results when added to the endpoint URL.
fields (List[str], optional): Additional fields to return in the matched certificates outside of the default returned fields.
sort (List[str], optional): A list of fields to sort on. By default, fields will be sorted in ascending order.
**kwargs: Additional keyword arguments to pass to the underlying HTTP request.
Returns:
dict: Search results.
"""
return super().raw_search(
query=query,
per_page=per_page,
cursor=cursor,
fields=fields,
sort=sort,
**kwargs,
)
def search( # type: ignore[override]
self,
query: str,
per_page: int = 50,
cursor: Optional[str] = None,
pages: int = 1,
fields: Optional[List[str]] = None,
sort: Optional[Union[str, List[str]]] = None,
**kwargs,
) -> CensysSearchAPIv2.Query:
"""Searches the Certs index.
By default, this function uses the POST method, which allows for a larger number of fingerprints to be queried at once.
If you wish to use the GET method, please use `CensysCerts.search_get` instead.
Args:
query (str): The query string to search for.
per_page (int): The number of results to return per page. Defaults to 50.
cursor (str, optional): Cursor token from the API response, which fetches the next page of results when added to the endpoint URL.
pages (int): The number of pages to return. Defaults to 1.
fields (List[str], optional): Additional fields to return in the matched certificates outside of the default returned fields.
sort (List[str], optional): A list of fields to sort on. By default, fields will be sorted in ascending order.
**kwargs: Additional keyword arguments to pass to the underlying HTTP request.
Returns:
Query: A query object that can be used to iterate over the search results.
"""
return super().search(query, per_page, cursor, pages, fields, sort, **kwargs)
def aggregate(
self, query: str, field: str, num_buckets: int = 50, **kwargs
) -> dict:
"""Aggregates certificate records matching a specified query into buckets based on the given field.
Args:
query (str): The query string to search for.
field (str): The field to aggregate on.
num_buckets (int): The number of buckets to return. Defaults to 50.
**kwargs: Additional keyword arguments to pass to the underlying HTTP request.
Returns:
dict: Aggregation results.
"""
args = {"q": query, "field": field, "num_buckets": num_buckets}
args.update(kwargs)
return self._get(self.aggregate_path, args=args)["result"]
def get_hosts_by_cert(self, fingerprint: str, cursor: Optional[str] = None) -> dict:
"""Returns a list of hosts which contain services presenting this certificate, including when the certificate was first observed.
Args:
fingerprint (str): The SHA-256 fingerprint of the requested certificate.
cursor (str): Cursor token from the API response, which fetches the next page of hosts when added to the endpoint URL.
Returns:
dict: A list of hosts which contain services presenting this certificate.
"""
warnings.warn(
"This API endpoint is deprecated and scheduled for removal during a future release. Users should migrate to using the search endpoint on the Host index using the 'services.certificate: {fingerprint}' query to find any hosts currently presenting a certificate.",
category=DeprecationWarning,
stacklevel=2,
)
args = {"cursor": cursor}
return self._get(self.view_path + fingerprint + "/hosts", args)["result"]
def list_certs_with_tag(self, tag_id: str) -> List[dict]:
"""Returns a list of certs which are tagged with the specified tag.
Args:
tag_id (str): The ID of the tag.
Returns:
List[dict]: A list of certs which are tagged with the specified tag.
"""
return self._list_documents_with_tag(tag_id, "certificates", "certs")
def get_observations(
self,
fingerprint: str,
per_page: int = 50,
start_time: Optional[Datetime] = None,
end_time: Optional[Datetime] = None,
cursor: Optional[str] = None,
) -> dict:
"""Returns a list of observations for the specified certificate.
Args:
fingerprint (str): The SHA-256 fingerprint of the requested certificate.
per_page (int): The number of results to return per page. Defaults to 50.
start_time (str): The start time of the observations to return.
end_time (str): The end time of the observations to return.
cursor (str): Cursor token from the API response, which fetches the next page of observations when added to the endpoint URL.
Returns:
dict: A list of observations for the specified certificate.
"""
args = {"per_page": per_page, "cursor": cursor}
if start_time:
args["start_time"] = format_rfc3339(start_time)
if end_time:
args["end_time"] = format_rfc3339(end_time)
return self._get(self.view_path + fingerprint + "/observations", args)["result"]
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6721454
censys-2.2.17/censys/search/v2/hosts.py 0000644 0000000 0000000 00000027151 14777466662 014706 0 ustar 00 """Interact with the Censys Search Host API."""
from typing import Any, Dict, List, Optional, Union
from .api import CensysSearchAPIv2
from censys.common.types import Datetime
from censys.common.utils import format_rfc3339
class CensysHosts(CensysSearchAPIv2):
"""Interacts with the Hosts index.
Examples:
Inits Censys Hosts.
>>> from censys.search import CensysHosts
>>> h = CensysHosts()
Simple host search.
>>> for page in h.search("services.service_name: HTTP"):
>>> print(page)
[
{
'services':
[
{'service_name': 'HTTP', 'port': 80},
{'service_name': 'HTTP', 'port': 443}
],
'ip': '1.0.0.0'
},
...
]
Fetch a specific host and its services
>>> h.view("1.0.0.0")
{
'ip': '8.8.8.8',
'services': [{}],
...
}
Simple host aggregate.
>>> h.aggregate("services.service_name: HTTP", "services.port", num_buckets=5)
{
'total_omitted': 591527370,
'buckets': [
{'count': 56104072, 'key': '80'},
{'count': 43527894, 'key': '443'},
{'count': 23070429, 'key': '7547'},
{'count': 12970769, 'key': '30005'},
{'count': 12825150, 'key': '22'}
],
'potential_deviation': 3985101,
'field': 'services.port',
'query': 'services.service_name: HTTP',
'total': 172588754
}
Fetch a list of host names for the specified IP address.
>>> h.view_host_names("1.1.1.1")
['one.one.one.one']
Fetch a list of events for the specified IP address.
>>> h.view_host_events("1.1.1.1")
[{'timestamp': '2019-01-01T00:00:00.000Z'}]
"""
INDEX_NAME = "hosts"
"""Name of Censys Index."""
def __init__(
self, api_id: Optional[str] = None, api_secret: Optional[str] = None, **kwargs
):
"""Inits CensysHosts.
See CensysSearchAPIv2 for additional arguments.
Args:
api_id (Optional[str], optional): API ID. Defaults to None.
api_secret (Optional[str], optional): API Secret. Defaults to None.
**kwargs: Arbitrary keyword arguments.
"""
super().__init__(api_id=api_id, api_secret=api_secret, **kwargs)
self.metadata_path = f"/v2/metadata/{self.INDEX_NAME}"
def view(
self,
document_id: str,
at_time: Optional[Datetime] = None,
**kwargs: Any,
) -> dict:
"""View document from current index.
View the current structured data we have on a specific document.
For more details, see our documentation: https://search.censys.io/api
Args:
document_id (str): The ID of the document you are requesting.
at_time ([str, datetime.date, datetime.datetime]):
Optional; Fetches a document at a given point in time.
**kwargs (Any): Optional; Additional arguments to be passed to the query.
Returns:
dict: The result set returned.
"""
args = {}
if at_time:
args["at_time"] = format_rfc3339(at_time)
return super().view(document_id, **args)
def bulk_view(
self,
document_ids: List[str],
max_workers: int = 20,
at_time: Optional[Datetime] = None,
**kwargs: Any,
) -> Dict[str, dict]:
"""Bulk view documents from current index.
View the current structured data we have on a list of documents.
Args:
document_ids (List[str]): The IDs of the documents you are requesting.
max_workers (int): Optional; The number of workers to use. Defaults to 20.
at_time ([str, datetime.date, datetime.datetime]):
Optional; Fetches a document at a given point in time.
**kwargs (Any): Optional; Additional arguments to be passed to the query.
Returns:
Dict[str, dict]: The result set returned.
"""
if at_time:
kwargs["at_time"] = format_rfc3339(at_time)
return super().bulk_view(document_ids, max_workers, **kwargs)
def search(
self,
query: str,
per_page: int = 100,
cursor: Optional[str] = None,
pages: int = 1,
fields: Optional[List[str]] = None,
sort: Optional[Union[str, List[str]]] = None,
virtual_hosts: Optional[str] = None,
**kwargs: Any,
) -> CensysSearchAPIv2.Query:
"""Search host index.
Searches the given index for all records that match the given query.
For more details, see our documentation: https://search.censys.io/api
Args:
query (str): The query to be executed.
per_page (int): Optional; The number of results to be returned for each page. Defaults to 100.
cursor (int): Optional; The cursor of the desired result set.
pages (int): Optional; The number of pages returned. Defaults to 1.
fields (List[str]): Optional; The fields to return. Defaults to all fields.
sort (str): Optional; The method used to sort results. Valid values are "RELEVANCE", "DESCENDING", and "ASCENDING".
virtual_hosts (str): Optional; Whether to include virtual hosts in the results. Valid values are "EXCLUDE", "INCLUDE", and "ONLY".
**kwargs (Any): Optional; Additional arguments to be passed to the query.
Returns:
Query: Query object that can be a callable or an iterable.
"""
if virtual_hosts:
kwargs["virtual_hosts"] = virtual_hosts
return super().search(query, per_page, cursor, pages, fields, sort, **kwargs)
def aggregate(
self,
query: str,
field: str,
num_buckets: int = 50,
virtual_hosts: Optional[str] = None,
**kwargs: Any,
) -> dict:
"""Aggregate host index.
Creates a report on the breakdown of the values of a field in a result set.
For more details, see our documentation: https://search.censys.io/api
Args:
query (str): The query to be executed.
field (str): The field you are running a breakdown on.
num_buckets (int): Optional; The maximum number of values. Defaults to 50.
virtual_hosts (str): Optional; Whether to include virtual hosts in the results. Valid values are "EXCLUDE", "INCLUDE", and "ONLY".
**kwargs (Any): Optional; Additional arguments to be passed to the query.
Returns:
dict: The result set returned.
"""
if virtual_hosts:
kwargs["virtual_hosts"] = virtual_hosts
return super().aggregate(query, field, num_buckets, **kwargs)
def metadata(self) -> dict:
"""Get metadata for the host index.
Returns:
dict: The result set returned.
"""
return self._get(self.metadata_path)["result"]
def view_host_names(
self, ip: str, per_page: Optional[int] = None, cursor: Optional[str] = None
) -> List[str]:
"""Fetches a list of host names for the specified IP address.
Args:
ip (str): The IP address of the requested host.
per_page (int): Optional; The number of results to be returned for each page. Defaults to 100.
cursor (int): Optional; The cursor of the desired result set.
Returns:
List[str]: A list of host names.
"""
args = {"per_page": per_page, "cursor": cursor}
return self._get(self.view_path + ip + "/names", args)["result"]["names"]
def view_host_diff(
self,
ip: str,
ip_b: Optional[str] = None,
at_time: Optional[Datetime] = None,
at_time_b: Optional[Datetime] = None,
):
"""Fetches a diff of the specified IP address.
Args:
ip (str): The IP address of the requested host.
ip_b (str): Optional; The IP address of the second host.
at_time (Datetime): Optional; An RFC3339 timestamp which represents
the point-in-time used as the basis for Host A.
at_time_b (Datetime): Optional; An RFC3339 timestamp which represents
the point-in-time used as the basis for Host B.
Returns:
dict: A diff of the hosts.
"""
args: Dict[str, Any] = {}
if ip_b:
args["ip_b"] = ip_b
if at_time:
args["at_time"] = format_rfc3339(at_time)
if at_time_b:
args["at_time_b"] = format_rfc3339(at_time_b)
return self._get(self.view_path + ip + "/diff", args)["result"]
def view_host_events(
self,
ip: str,
start_time: Optional[Datetime] = None,
end_time: Optional[Datetime] = None,
per_page: Optional[int] = None,
cursor: Optional[str] = None,
reversed: Optional[bool] = None,
) -> dict:
"""Fetches a list of events for the specified IP address.
Args:
ip (str): The IP address of the requested host.
start_time (Datetime): Optional; An RFC3339 timestamp which represents
the beginning chronological point-in-time (inclusive) from which events are returned.
end_time (Datetime): Optional; An RFC3339 timestamp which represents
the ending chronological point-in-time (exclusive) from which events are returned.
per_page (int): Optional; The maximum number of hits to return in each response
(minimum of 1, maximum of 50).
cursor (str): Optional; Cursor token from the API response.
reversed (bool): Optional; Reverse the order of the return events,
that is, return events in reversed chronological order.
Returns:
dict: A list of events.
"""
args = {"per_page": per_page, "cursor": cursor, "reversed": reversed}
if start_time:
args["start_time"] = format_rfc3339(start_time)
if end_time:
args["end_time"] = format_rfc3339(end_time)
return self._get(f"/v2/experimental/{self.INDEX_NAME}/{ip}/events", args)[
"result"
]
def view_host_certificates(
self,
ip: str,
per_page: int = 100,
start_time: Optional[Datetime] = None,
cursor: Optional[str] = None,
) -> dict:
"""Returns a list of certificates for the specified host.
Args:
ip (str): The IP address of the requested host.
per_page (int): Optional; The number of results to be returned for each page. Defaults to 100.
start_time (Datetime): Optional; An RFC3339 timestamp which represents
the beginning chronological point-in-time (inclusive) from which events are returned.
cursor (str): Optional; Cursor token from the API response.
Returns:
dict: A list of certificates.
"""
args = {"per_page": per_page, "cursor": cursor}
if start_time:
args["start_time"] = format_rfc3339(start_time)
return self._get(f"/v2/{self.INDEX_NAME}/{ip}/certificates", args)["result"]
def list_hosts_with_tag(self, tag_id: str) -> List[str]:
"""Returns a list of hosts which are tagged with the specified tag.
Args:
tag_id (str): The ID of the tag.
Returns:
List[str]: A list of host IP addresses.
"""
hosts = self._list_documents_with_tag(tag_id, "hosts", "hosts")
return [host["ip"] for host in hosts]
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1744727473.6751454
censys-2.2.17/pyproject.toml 0000644 0000000 0000000 00000006362 14777466662 013011 0 ustar 00 [tool.poetry]
name = "censys"
version = "2.2.17"
description = "An easy-to-use and lightweight API wrapper for Censys APIs (censys.io)."
authors = ["Censys, Inc. "]
license = "Apache-2.0"
readme = "README.md"
include = ["censys/py.typed"]
keywords = ["censys", "api", "search", "attack surface management"]
classifiers = [
"Typing :: Typed",
"Topic :: Internet",
"Topic :: Security",
"Topic :: Documentation :: Sphinx",
"Topic :: Internet :: WWW/HTTP :: HTTP Servers",
"Topic :: Internet :: WWW/HTTP :: Indexing/Search",
"Topic :: Scientific/Engineering :: Information Analysis",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: System :: Networking",
"Topic :: Utilities",
"Environment :: Console",
"Natural Language :: English",
"Intended Audience :: Developers",
"Intended Audience :: Information Technology",
"Intended Audience :: Science/Research",
"Intended Audience :: System Administrators",
"Operating System :: OS Independent",
"Development Status :: 5 - Production/Stable",
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: Implementation :: PyPy",
]
[tool.poetry.urls]
"Censys Homepage" = "https://censys.io/"
"Censys Search" = "https://search.censys.io/"
"Discussions" = "https://github.com/censys/censys-python/discussions"
"Documentation" = "https://censys-python.rtfd.io"
"Changelog" = "https://github.com/censys/censys-python/releases"
"Tracker" = "https://github.com/censys/censys-python/issues"
"Source" = "https://github.com/censys/censys-python"
[tool.poetry.scripts]
censys = "censys.cli:main"
[tool.poetry.dependencies]
python = ">=3.8,<4.0"
requests = ">=2.29.0"
urllib3 = "<3.0.0"
backoff = ">=2.0.0,<3.0.0"
rich = ">=10.16.2"
argcomplete = ">=2.0.0,<4.0.0"
[tool.poetry.group.dev.dependencies]
# Lint
black = ">=23.3,<25.0"
blacken-docs = "^1.13.0"
darglint = "^1.8.1"
flake8 = "^5.0.4"
flake8-black = "^0.3.6"
flake8-comprehensions = "^3.12.0"
flake8-docstrings = "^1.7.0"
flake8-isort = "^6.0.0"
flake8-pytest-style = "^1.7.2"
flake8-simplify = ">=0.20,<0.22"
isort = "^5.11.5"
pep8-naming = ">=0.13.3,<0.15.0"
pyupgrade = "^3.3.1"
# Tests
pytest = ">=7.3,<9.0"
pytest-cov = ">=4,<6"
pytest-mock = "^3.10.0"
responses = ">=0.23.1,<0.26.0"
parameterized = "^0.9.0"
# Types
mypy = "^1.5.1"
types-requests = "^2.29.0.0"
[tool.black]
target-version = ["py38"]
[tool.isort]
profile = "black"
line_length = 88
multi_line_output = 3
known_first_party = ["censys"]
known_local_folder = ["censys"]
sections = ["FUTURE", "STDLIB", "THIRDPARTY", "FIRSTPARTY", "LOCALFOLDER"]
extend_skip = ["setup.py", "conf.py"]
[tool.mypy]
python_version = "3.8"
files = ["censys"]
namespace_packages = true
explicit_package_bases = true
[[tool.mypy.overrides]]
module = ["parameterized", "rich", "attr"]
ignore_missing_imports = true
[build-system]
requires = ["poetry-core>=1.2.0"]
build-backend = "poetry.core.masonry.api"
censys-2.2.17/PKG-INFO 0000644 0000000 0000000 00000016121 00000000000 011074 0 ustar 00 Metadata-Version: 2.1
Name: censys
Version: 2.2.17
Summary: An easy-to-use and lightweight API wrapper for Censys APIs (censys.io).
License: Apache-2.0
Keywords: censys,api,search,attack surface management
Author: Censys, Inc.
Author-email: support@censys.io
Requires-Python: >=3.8,<4.0
Classifier: Development Status :: 5 - Production/Stable
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Information Technology
Classifier: Intended Audience :: Science/Research
Classifier: Intended Audience :: System Administrators
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Natural Language :: English
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Programming Language :: Python :: Implementation :: PyPy
Classifier: Topic :: Documentation :: Sphinx
Classifier: Topic :: Internet
Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
Classifier: Topic :: Scientific/Engineering :: Information Analysis
Classifier: Topic :: Security
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Topic :: System :: Networking
Classifier: Topic :: Utilities
Classifier: Typing :: Typed
Requires-Dist: argcomplete (>=2.0.0,<4.0.0)
Requires-Dist: backoff (>=2.0.0,<3.0.0)
Requires-Dist: requests (>=2.29.0)
Requires-Dist: rich (>=10.16.2)
Requires-Dist: urllib3 (<3.0.0)
Project-URL: Censys Homepage, https://censys.io/
Project-URL: Censys Search, https://search.censys.io/
Project-URL: Changelog, https://github.com/censys/censys-python/releases
Project-URL: Discussions, https://github.com/censys/censys-python/discussions
Project-URL: Documentation, https://censys-python.rtfd.io
Project-URL: Source, https://github.com/censys/censys-python
Project-URL: Tracker, https://github.com/censys/censys-python/issues
Description-Content-Type: text/markdown
# Censys Python Library
[](https://pypi.org/project/censys/)
[](https://www.python.org/downloads/)
[](https://censys-python.readthedocs.io/en/stable/?badge=stable)
[](https://github.com/censys/censys-python/discussions)
[](http://makeapullrequest.com)
[](https://github.com/censys/censys-python/blob/main/LICENSE)
An easy-to-use and lightweight API wrapper for Censys APIs ([censys.io](https://censys.io/)). Python 3.8+ is currently supported. This library has been tested on Python 3.8 and 3.x (Currently version 3.10).
> **Notice:** The Censys Search v1 endpoints are deprecated as of Nov. 30, 2021. Please begin using v2 endpoints to query hosts and certificates and check out our [support center](https://support.censys.io/hc/en-us/sections/360013076551-Censys-Search-2-0) for resources.
> [!IMPORTANT]
> This library does not support the new Censys Platform, however a new set of SDKs that do support the platform are coming soon.
> Please refer to the [platform API refrence docs](https://docs.censys.com/reference/get-started#/) in the mean time.
## Features
- [Search Censys data](https://censys-python.readthedocs.io/en/stable/usage-v2.html)
- [Bulk Certificate lookups](https://censys-python.readthedocs.io/en/stable/usage-v2.html#bulk-view)
- [Download Bulk Data](https://censys-python.readthedocs.io/en/stable/usage-v1.html#data)
- [Manage assets, events, and seeds in Censys ASM](https://censys-python.readthedocs.io/en/stable/usage-asm.html)
- [Command-line interface](https://censys-python.readthedocs.io/en/stable/cli.html)
## Getting Started
The library can be installed using `pip`.
```sh
pip install censys
```
To upgraded using `pip`.
```sh
pip install --upgrade censys
```
Alternatively, you can install the library using `poetry`.
```sh
git clone https://github.com/censys/censys-python.git
cd censys-python/
poetry install
```
Optionally, you can enable tab completion for the CLI by adding this line to your `~/.bashrc`, `~/.zshrc`, or equivalent.
> Please note that autocomplete is supported for field names in the `search` command.
```sh
eval "$(register-python-argcomplete censys)"
```
To configure your search credentials run `censys config` or set both `CENSYS_API_ID` and `CENSYS_API_SECRET` environment variables.
```sh
$ censys config
Censys API ID: XXX
Censys API Secret: XXX
Do you want color output? [y/n]: y
Successfully authenticated for your@email.com
```
If you have a Censys ASM account, you can configure your ASM credentials by running `censys asm config` or set both `CENSYS_ASM_API_KEY` environment variables.
```sh
$ censys asm config
Censys ASM API Key: XXX
Do you want color output? [y/n]: y
Successfully authenticated
```
## Examples
The examples located in the [`examples/`](examples/) directory are a great place to start. You can also find more examples in the [usage documentation](https://censys-python.readthedocs.io/en/stable/usage-v2.html).
## [Documentation](https://censys-python.readthedocs.io/)
[](https://censys-python.readthedocs.io/)
## Resources
- [Source](https://github.com/censys/censys-python)
- [Issue Tracker](https://github.com/censys/censys-python/issues)
- [Changelog](https://github.com/censys/censys-python/releases)
- [Documentation](https://censys-python.rtfd.io)
- [Discussions](https://github.com/censys/censys-python/discussions)
- [Censys Homepage](https://censys.io/)
- [Censys Search](https://search.censys.io/)
## Contributing
All contributions (no matter how small) are always welcome. See [Contributing to Censys Python](.github/CONTRIBUTING.md)
## Development
This project uses [poetry](https://python-poetry.org/) for dependency management. Please ensure you have [installed the latest version](https://python-poetry.org/docs/#installation).
```sh
git clone git@github.com:censys/censys-python.git
cd censys-python/
poetry install
```
## Testing
```sh
# Run tests
poetry run pytest
# With coverage report
poetry run pytest --cov-report html
```
## License
This software is licensed under [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0)
- Copyright (C) 2024 Censys, Inc.