Beispiel #1
0
    def __load_module__(self, scanObject):
        """[summary]
            ScanObject 대상에 맞는 엔진을 로드하고 엔진 내 정의된 클래스 (config.engine_class) 명을 반환한다. 

        Arguments:
            scanObject {instance} -- [description] ScanObject 인스턴스

        Returns:
            {str} -- [description] 모듈 내 클래스 명
        """
        error = False
        err_msg = ""
        try:
            Log.info(scanObject.get_internal_path())

            engine_name = scanObject.get_internal_path()[0]
            mod = utils.load_module("{}.{}".format(config.ole_eng_path,
                                                   engine_name))
            if not mod:
                # 경로내 <엔진명>.py 가 없거나 로드 실패한 경우
                raise KeiEngineError("Failed Load Module")

            # 엔진내 정의된 클래스명을 가져온다.
            clsName = getattr(mod, config.engine_class)
            # 있는 경우
            if clsName:
                return clsName
            else:
                raise KeiEngineError("Not Found {} Engine Class.".format(
                    config.engine_class))

        except KeiEngineError as e:
            # 에러 로그를 저장한다.
            Log.error(e.msg)

            # 에러 결과를 ScanObject에 업데이트할 수 있도록 상태값을 변경한다.
            error = True
            err_msg = e.msg

        except:
            # 에러 로그를 저장한다.
            _, msg, obj = sys.exc_info()
            msg = "{} ({}::{})".format(msg, obj.tb_lineno,
                                       obj.tb_frame.f_globals.get("__file__"))
            Log.error(msg)

            # 에러 결과를 ScanObject에 업데이트할 수 있도록 상태값을 변경한다.
            error = True
            err_msg = msg

        finally:
            scanObject.updateResult(error, err_msg)
Beispiel #2
0
    def __run__(self, scanResult, scanObject):
        """[summary]
            분석 엔진 run() 의 Wrapper

        Arguments:
            scanResult {instance} -- [description] ScanResult 인스턴스
            scanObject {instance} -- [description] ScanObject 인스턴스
        """
        error = False
        err_msg = ""
        try:
            # Log 초기화
            Log.init(log_name=self.__engine__.split(".")[-1],
                     log_level=config.log_level,
                     log_path=config.log_path,
                     log_cmd=config.log_cmd)

            # Log.info("{} : {}".format(self.__engine__, scanObject.get_file_name()))
            Log.info(self.__engine__)

            # 전처리
            # 호출 모듈명을 저장한다.
            scanObject.updateScanModule(self.__engine__)

            # 상태를 변경한다.
            # monitoring.__analyzing__(scanObject)

            # 분석
            self.run(scanResult, scanObject)

            # 후처리

        except:
            # 에러로그를 작성한다.
            _, msg, obj = sys.exc_info()
            msg = "{} ({}::{})".format(msg, obj.tb_lineno,
                                       obj.tb_frame.f_globals.get("__file__"))
            Log.error(msg)

            # 에러 상태를 업데이트한다.
            error = True
            err_msg = msg

        finally:
            scanObject.updateResult(error, err_msg)
Beispiel #3
0
def get_file_list_download(json_list):
    try:
        Log.info("try Download from malwares.com : {}".format(len(json_list)))

        mws_path = os.path.join(config.temp_path, config.mws_save_folder)
        if not utils.makedirectory(mws_path):
            raise MWSError("Failed MakeDirectory() for malwares.com")
        
        complete_list = []
        # failed_list = []
        for i, dict_data in enumerate(json_list):
            file_hash = dict_data["sha256"]
            zip_content = get_file_download(file_hash)
            if not zip_content:
                # failed_list.append(file_hash)
                Log.error("MWS Download Failed : [{}/{}] {}".format(i+1, len(json_list), file_hash))
                continue

            fullName = os.path.join(mws_path, file_hash)
            if utils.unzip(mws_path, zip_content):
                complete_list.append(fullName)
                Log.debug("MWS Download Successed : [{}/{}] {}".format(i+1, len(json_list), file_hash))
            else:
                Log.error("Failed to write or decompress(unzip). ({})".format(file_hash))
            
        return complete_list

    except MWSError as e:
        Log.error(e.msg)
        return []

    except:
        _, msg, obj = sys.exc_info()
        msg = "{} ({}::{})".format(msg, obj.tb_lineno, obj.tb_frame.f_globals.get("__file__"))
        Log.error(msg)
        return []

    finally:
        pass
Beispiel #4
0
def start(args):
    job_manager = None
    try:
        # # Job을 가져온다.
        # # - 폴더/파일에 대한 Job
        # jobs = utils.get_file_list(args.file, args.folder)

        # # - MWS에 대한 Job
        # if config.mws_flag:
        #     mws_jobs_json = mws.get_tag_search(args.mws_tag, args.mws_start_time, args.mws_end_time, args.mws_limit)
        #     if not mws_jobs_json == []:
        #         jobs += mws.get_file_list_download(mws_jobs_json)

        # Job을 가져온다.
        jobs = get_jobs(args)
        total_jobs = len(jobs)
        # Log.info("Jobs: {}".format(total_jobs))

        # 멀티 프로세스를 생성/실행한다.
        proc_num = config.proc_num
        if total_jobs < proc_num:
            proc_num = total_jobs

        job_manager = consumer.Consumer(proc_num=proc_num)
        for i, job in enumerate(jobs):
            # Job을 분배한다.
            Log.info("Job: {}".format(job))
            job_manager.put(job)

    except:
        _, msg, obj = sys.exc_info()
        msg = "{} ({}::{})".format(msg, obj.tb_lineno,
                                   obj.tb_frame.f_globals.get("__file__"))
        Log.error(msg)

    finally:
        # 멀티 프로세스를 종료한다.
        job_manager.stop_all_worker()
Beispiel #5
0

if __name__ == "__main__":
    try:
        # 외부 설정 정보 가져오기
        parser, args = parse_argument()
        if parser is None or args is None:
            raise SystemExit

        # 로그 설정
        Log.init(log_level=config.log_level,
                 log_path=config.log_path,
                 log_cmd=config.log_cmd)

        # 시작 로그
        Log.info("[*] start")

        # 메인함수 시작
        jobs.start(args)

        # 종료 로그
        Log.info("[*] done")

    except SystemExit:
        pass

    except:
        # 에러로그 저장
        _, msg, obj = sys.exc_info()
        msg = "{} ({}::{})".format(msg, obj.tb_lineno,
                                   obj.tb_frame.f_globals.get("__file__"))