eris.py

#!/usr/bin/env python
# Elasticsearch Recon Ingestion Scripts (ERIS) - Developed by Acidvegas (https://git.acid.vegas/eris)
# eris.py

import asyncio
import argparse
import logging
import logging.handlers
import os
import stat
import sys
import json

sys.dont_write_bytecode = True # FUCKOFF __pycache__

try:
	from elasticsearch            import AsyncElasticsearch
	from elasticsearch.exceptions import NotFoundError
	from elasticsearch.helpers    import async_streaming_bulk
except ImportError:
	raise ImportError('Missing required \'elasticsearch\' library. (pip install elasticsearch)')


class ElasticIndexer:
	def __init__(self, args: argparse.Namespace):
		'''
		Initialize the Elastic Search indexer.

		:param args: Parsed arguments from argparse
		'''

		self.chunk_max  = args.chunk_max * 1024 * 1024 # MB
		self.chunk_size = args.chunk_size
		self.es_index   = args.index

		# Sniffing disabled due to an issue with the elasticsearch 8.x client (https://github.com/elastic/elasticsearch-py/issues/2005)
		es_config = {
			'hosts'               : [f'{args.host}:{args.port}'],
			#'hosts'                : [f'{args.host}:{port}' for port in ('9200',)], # Temporary alternative to sniffing
			'verify_certs'         : args.self_signed,
			'ssl_show_warn'        : args.self_signed,
			'request_timeout'      : args.timeout,
			'max_retries'          : args.retries,
			'retry_on_timeout'     : True,
			'http_compress'        : True,
			'connections_per_node' : 3 # Experiment with this value
			#'sniff_on_start': True,
			#'sniff_on_node_failure': True,
			#'min_delay_between_sniffing': 60
		}

		if args.api_key:
			es_config['api_key'] = (args.api_key, '') # Verify this is correct
		else:
			es_config['basic_auth'] = (args.user, args.password)

		self.es = AsyncElasticsearch(**es_config)


	async def close_connect(self):
		'''Close the Elasticsearch connection.'''

		await self.es.close()


	async def create_index(self, map_body: dict, pipeline: str = None, replicas: int = 1, shards: int = 1):
		'''
		Create the Elasticsearch index with the defined mapping.

		:param map_body: Mapping for the index
		:param pipeline: Name of the ingest pipeline to use for the index
		:param replicas: Number of replicas for the index
		:param shards: Number of shards for the index
		'''

		if await self.es.indices.exists(index=self.es_index):
			logging.info(f'Index \'{self.es_index}\' already exists.')
			return

		mapping = map_body

		mapping['settings'] = {
			'number_of_shards'   : shards,
			'number_of_replicas' : replicas
		}

		if pipeline:
			try:
				await self.es.ingest.get_pipeline(id=pipeline)
				logging.info(f'Using ingest pipeline \'{pipeline}\' for index \'{self.es_index}\'')
				mapping['settings']['index.default_pipeline'] = pipeline
			except NotFoundError:
				raise ValueError(f'Ingest pipeline \'{pipeline}\' does not exist.')

		response = await self.es.indices.create(index=self.es_index, body=mapping)

		if response.get('acknowledged') and response.get('shards_acknowledged'):
			logging.info(f'Index \'{self.es_index}\' successfully created.')
		else:
			raise Exception(f'Failed to create index. ({response})')


	async def process_data(self, file_path: str, data_generator: callable):
		'''
		Index records in chunks to Elasticsearch.

		:param file_path: Path to the file
		:param data_generator: Generator for the records to index
		'''

		count  = 0
		total  = 0
		errors = []

		try:
			async for ok, result in async_streaming_bulk(self.es, actions=data_generator(file_path), chunk_size=self.chunk_size, max_chunk_bytes=self.chunk_max,raise_on_error=False):
				action, result = result.popitem()

				if not ok:
					error_type   = result.get('error', {}).get('type',   'unknown')
					error_reason = result.get('error', {}).get('reason', 'unknown')
					logging.error('FAILED DOCUMENT:')
					logging.error(f'Error Type   : {error_type}')
					logging.error(f'Error Reason : {error_reason}')
					logging.error('Document     : ')
					logging.error(json.dumps(result, indent=2))
					input('Press Enter to continue...')
					errors.append(result)
					continue

				count += 1
				total += 1

				if count == self.chunk_size:
					logging.info(f'Successfully indexed {self.chunk_size:,} ({total:,} processed) records to {self.es_index} from {file_path}')
					count = 0

			if errors:
				raise Exception(f'{len(errors):,} document(s) failed to index. Check the logs above for details.')

		except Exception as e:
			raise Exception(f'Failed to index records to {self.es_index} from {file_path} ({e})')


def setup_logger(console_level: int = logging.INFO, file_level: int = None, log_file: str = 'debug.json', max_file_size: int = 10*1024*1024, backups: int = 5, ecs_format: bool = False):
	'''
	Setup the global logger for the application.

	:param console_level: Minimum level to capture logs to the console.
	:param file_level: Minimum level to capture logs to the file.
	:param log_file: File to write logs to.
	:param max_file_size: Maximum size of the log file before it is rotated.
	:param backups: Number of backup log files to keep.
	:param ecs_format: Use the Elastic Common Schema (ECS) format for logs.
	'''

	# Configure the root logger
	logger = logging.getLogger()
	logger.setLevel(logging.DEBUG) # Minimum level to capture all logs

	# Clear existing handlers
	logger.handlers = []

	# Setup console handler
	console_handler = logging.StreamHandler()
	console_handler.setLevel(console_level)
	console_formatter = logging.Formatter('%(asctime)s | %(levelname)9s | %(message)s', '%I:%M:%S')
	console_handler.setFormatter(console_formatter)
	logger.addHandler(console_handler)

	# Setup rotating file handler if file logging is enabled
	if file_level is not None:
		file_handler = logging.handlers.RotatingFileHandler(log_file, maxBytes=max_file_size, backupCount=backups)
		file_handler.setLevel(file_level)
  
		# Setup formatter to use ECS format if enabled or default format
		if ecs_format:
			try:
				from ecs_logging import StdlibFormatter
			except ImportError:
				raise ImportError('Missing required \'ecs-logging\' library. (pip install ecs-logging)')
			file_formatter = StdlibFormatter() # ECS formatter
		else:
			file_formatter = logging.Formatter('%(asctime)s | %(levelname)9s | %(message)s', '%Y-%m-%d %H:%M:%S')
        
		file_handler.setFormatter(file_formatter)
		logger.addHandler(file_handler)


async def main():
	'''Main function when running this script directly.'''

	parser = argparse.ArgumentParser(description='Elasticsearch Recon Ingestion Scripts (ERIS)')

	# General arguments
	parser.add_argument('input_path', help='Path to the input file or directory') # Required
	parser.add_argument('--watch', action='store_true', help='Create or watch a FIFO for real-time indexing')
	parser.add_argument('--log', choices=['debug', 'info', 'warning', 'error', 'critical'], help='Logging file level (default: disabled)')
	parser.add_argument('--ecs', action='store_true', default=False, help='Use the Elastic Common Schema (ECS) for logging')

	# Elasticsearch arguments
	parser.add_argument('--host', default='http://localhost', help='Elasticsearch host')
	parser.add_argument('--port', type=int, default=9200, help='Elasticsearch port')
	parser.add_argument('--user', default='elastic', help='Elasticsearch username')
	parser.add_argument('--password', default=os.getenv('ES_PASSWORD'), help='Elasticsearch password (if not provided, check environment variable ES_PASSWORD)')
	parser.add_argument('--api-key', default=os.getenv('ES_APIKEY'), help='Elasticsearch API Key for authentication (if not provided, check environment variable ES_APIKEY)')
	parser.add_argument('--self-signed', action='store_false', help='Elasticsearch is using self-signed certificates')

	# Elasticsearch indexing arguments
	parser.add_argument('--index', help='Elasticsearch index name')
	parser.add_argument('--pipeline', help='Use an ingest pipeline for the index')
	parser.add_argument('--replicas', type=int, default=1, help='Number of replicas for the index')
	parser.add_argument('--shards', type=int, default=1, help='Number of shards for the index')

	# Performance arguments
	parser.add_argument('--chunk-size', type=int, default=5000, help='Number of records to index in a chunk')
	parser.add_argument('--chunk-max', type=int, default=10485760, help='Maximum size of a chunk in bytes (default 10mb)')
	parser.add_argument('--retries', type=int, default=30, help='Number of times to retry indexing a chunk before failing')
	parser.add_argument('--timeout', type=int, default=60, help='Number of seconds to wait before retrying a chunk')

	# Ingestion arguments
	parser.add_argument('--certstream', action='store_true', help='Index Certstream records')
	parser.add_argument('--httpx', action='store_true', help='Index Httpx records')
	parser.add_argument('--masscan', action='store_true', help='Index Masscan records')
	parser.add_argument('--massdns', action='store_true', help='Index Massdns records')
	parser.add_argument('--zone', action='store_true', help='Index Zone records')
	parser.add_argument('--rir-delegations', action='store_true', help='Index RIR Delegations records')
	parser.add_argument('--rir-transfers', action='store_true', help='Index RIR Transfers records')

	args = parser.parse_args()

	if args.log:
		levels = {'debug': logging.DEBUG, 'info': logging.INFO, 'warning': logging.WARNING, 'error': logging.ERROR, 'critical': logging.CRITICAL}
		setup_logger(file_level=levels[args.log], log_file='eris.log', ecs_format=args.ecs)
	else:
		setup_logger()

	if args.host.endswith('/'):
		args.host = args.host[:-1]

	if args.watch:
		if not os.path.exists(args.input_path):
			os.mkfifo(args.input_path)
		elif not stat.S_ISFIFO(os.stat(args.input_path).st_mode):
			raise ValueError(f'Path {args.input_path} is not a FIFO')
	elif not os.path.isdir(args.input_path) and not os.path.isfile(args.input_path):
		raise FileNotFoundError(f'Input path {args.input_path} does not exist or is not a file or directory')

	logging.info(f'Connecting to Elasticsearch at {args.host}:{args.port}')

	edx = ElasticIndexer(args)

	if args.certstream:
		from ingestors import ingest_certstream      as ingestor
	elif args.httpx:
		from ingestors import ingest_httpx           as ingestor
	elif args.masscan:
		from ingestors import ingest_masscan         as ingestor
	elif args.massdns:
		from ingestors import ingest_massdns         as ingestor
	elif args.rir_delegations:
		from ingestors import ingest_rir_delegations as ingestor
	elif args.rir_transfers:
		from ingestors import ingest_rir_transfers   as ingestor
	elif args.zone:
		from ingestors import ingest_zone            as ingestor
	else:
		raise ValueError('No ingestor specified')

	health = await edx.es.cluster.health()
	logging.info(health)

	#await asyncio.sleep(5) # Delay to allow time for sniffing to complete (Sniffer temporarily disabled)

	if not edx.es_index:
		edx.es_index = ingestor.default_index

	map_body = ingestor.construct_map()
	await edx.create_index(map_body, args.pipeline, args.replicas, args.shards)

	if os.path.isfile(args.input_path):
		logging.info(f'Processing file: {args.input_path}')
		await edx.process_data(args.input_path, ingestor.process_data)

	elif stat.S_ISFIFO(os.stat(args.input_path).st_mode):
		logging.info(f'Watching FIFO: {args.input_path}')
		await edx.process_data(args.input_path, ingestor.process_data)

	elif os.path.isdir(args.input_path):
		count = 1
		total = len(os.listdir(args.input_path))
		logging.info(f'Processing {total:,} files in directory: {args.input_path}')
		for file in sorted(os.listdir(args.input_path)):
			file_path = os.path.join(args.input_path, file)
			if os.path.isfile(file_path):
				logging.info(f'[{count:,}/{total:,}] Processing file: {file_path}')
				await edx.process_data(file_path, ingestor.process_data)
				count += 1
			else:
				logging.warning(f'[{count:,}/{total:,}] Skipping non-file: {file_path}')

	await edx.close_connect() # Close the Elasticsearch connection to stop "Unclosed client session" warnings



if __name__ == '__main__':
	print('')
	print('┏┓┳┓┳┏┓   Elasticsearch Recon Ingestion Scripts')
	print('┣ ┣┫┃┗┓        Developed by Acidvegas in Python')
	print('┗┛┛┗┻┗┛             https://git.acid.vegas/eris')
	print('')
	asyncio.run(main())