#!python
# Developed by : niah security inc
 
import time
import warnings
import glob2
from github import Github
import os
import pyfiglet
from os import path
import random
import semantic_version
import ast
import sys
import re
import requests
from pkg_resources import parse_version
import json
import argparse
from tqdm import tqdm
from datetime import datetime
from prettytable import PrettyTable
from termcolor import colored
import socket
from pyfiglet import figlet_format
import platform

__all__ = ["getstatusoutput","getoutput","getstatus"]

def getstatus(file):
    """Return output of "ls -ld <file>" in a string."""
    import warnings
    warnings.warn("commands.getstatus() is deprecated", DeprecationWarning, 2)
    return getoutput('ls -ld' + mkarg(file))

def getoutput(cmd):
    """Return output (stdout or stderr) of executing cmd in a shell."""
    return getstatusoutput(cmd)[1]

def getstatusoutput(cmd):
    """Return (status, output) of executing cmd in a shell."""
    import os
    pipe = os.popen('{ ' + cmd + '; } 2>&1', 'r')
    text = pipe.read()
    sts = pipe.close()
    if sts is None: sts = 0
    if text[-1:] == '\n': text = text[:-1]
    return sts, text

def mk2arg(head, x):
    import os
    return mkarg(os.path.join(head, x))

def mkarg(x):
    if '\'' not in x:
        return ' \'' + x + '\''
    s = ' "'
    for c in x:
        if c in '\\$"`':
            s = s + '\\'
        s = s + c
    s = s + '"'
    return s

class niah_getinventory():
        def __init__(self):
                pass

        def checkrequire(self, devP):
                results = []
                if 'requires' in devP:
                        for reqP in devP['requires']:
                                res = {}
                                product = reqP
                                version = devP['requires'][reqP]
                                res['product'] = product
                                res['version'] = version
                                results.append(res)

                return results


        def checkDependancies(self, devP):
                results = []
                if 'dependencies' in devP:
                        devData = devP['dependencies']
                        for devP in devData:
                                res = {}
                                devPProduct = devP
                                devPVersion = devData[devP]['version']
                                res['product'] = devPProduct
                                res['version'] = devPVersion
                                results.append(res)

                return results

        def getInstallPkgList(self, sourcefolder, language=False):
                    packagesResults = {}
                    if not language or language == "maven":
                        packagesResults['maven'] = {}
                        packagesResults['maven']['inventory'] = []
                        packagesResults['maven']['packages'] = []
                        packagesResults['maven']['testedWidth'] = []
                        packagesResults['maven']['dependancy'] = {}


                        for file in glob2.glob('%s/**/*.jar' % (sourcefolder), recursive=True):
                                res = {}
                                product = ''
                                version = ''
                                file = os.path.abspath(file)
                                filename = os.path.basename(file)

                                cmd = 'unzip -p %s META-INF/MANIFEST.MF' % (file)
                                status, output = getstatusoutput(cmd)
                                if re.findall(r'^(.*)-\d', str(filename)):
                                        product = re.findall(r'^(.*)-\d', str(filename))[0]

                                if re.findall(r'((?:(?:\d+)[.]){1,}(?:\d+).*).jar', str(filename)):
                                        version = re.findall(r'((?:(?:\d+)[.]){1,}(?:\d+).*).jar', str(filename))[0]
                                elif re.findall(r'-(\d+).jar', str(filename)):
                                        version = re.findall(r'-(\d+).jar', str(filename))[0]
                                else:
                                        version = ''


                                bundle_name = ''
                                bundle_version = ''
                                bundle_sym_name = ''

                                if re.findall(r'Bundle-Name:\s+(.*)', str(output)):
                                        bundle_name = re.findall(r'Bundle-Name:\s+(.*)', str(output))[0]
                                        bundle_name = bundle_name.strip()
                                if re.findall(r'Bundle-Version:\s+(.*)', str(output)):
                                        bundle_version = re.findall(r'Bundle-Version:\s+(.*)', str(output))[0]
                                        bundle_version = bundle_version.strip()
                                if re.findall(r'Bundle-SymbolicName:\s+(.*)',  str(output)):
                                        bundle_sym_name = re.findall(r'Bundle-SymbolicName:\s+(.*)',  str(output))[0]
                                        bundle_sym_name = bundle_sym_name.strip()

                                res['location'] = file
                                res['filename'] = filename
                                res['product'] = product
                                res['versions'] = version
                                res['bundle_name'] = bundle_name
                                res['bundle_version'] = bundle_version
                                res['bundle_sym_name'] = bundle_sym_name

                                if res not in packagesResults['maven']['inventory']:
                                        packagesResults['maven']['inventory'].append(res)

                                if product:
                                    if product not in packagesResults['maven']['packages']:
                                        packagesResults['maven']['packages'].append(product)

                                if bundle_name:
                                    if bundle_name not in packagesResults['maven']['packages']:
                                        packagesResults['maven']['packages'].append(bundle_name)

                                if bundle_sym_name:
                                    if bundle_sym_name not in packagesResults['maven']['packages']:
                                        packagesResults['maven']['packages'].append(bundle_sym_name)



                    if not language or language == "python":
                        packagesResults['python'] = {}
                        packagesResults['python']['inventory'] = []
                        packagesResults['python']['packages'] = []
                        packagesResults['python']['testedWidth'] = []
                        packagesResults['python']['dependancy'] = {}

                        for file in glob2.glob('%s/**/require*.txt' % (sourcefolder), recursive=True):
                                file = os.path.abspath(file)
                                filename = os.path.basename(file)

                                if filename not in packagesResults['python']['testedWidth']:
                                        packagesResults['python']['testedWidth'].append(filename)

                                fileData = open(file)

                                for lineFile in fileData.readlines():
                                        for strLine in lineFile.split(";"):
                                                if re.findall(r'(.*)(>=|==)(.*)', str(strLine)):
                                                        details = re.findall(r'(.*)(>=|==)(.*)', str(strLine))[0]
                                                        product = details[0]
                                                        versions = "%s%s" % (details[1].replace("'",""), details[2].replace("'", ""))
                                                        res = {}
                                                        res['product'] = product.strip()
                                                        res['versions'] = versions.replace(" ", "")
                                                        res['location'] = file
                                                        if res not in packagesResults['python']['inventory']:
                                                                packagesResults['python']['inventory'].append(res)
                                                        if product.strip() not in packagesResults['python']['packages']:
                                                                packagesResults['python']['packages'].append(product.strip())


                    if not language or language == "composer":
                        packagesResults['composer'] = {}
                        packagesResults['composer']['inventory'] = []
                        packagesResults['composer']['packages'] = []
                        packagesResults['composer']['testedWidth'] = []
                        packagesResults['composer']['dependancy'] = {}

                        for file in glob2.glob('%s/**/composer.*' % (sourcefolder), recursive=True):
                            file = os.path.abspath(file)
                            filename = os.path.basename(file)


                            if filename == "composer.lock":
                                if os.stat(file).st_size != 0:
                                    with open(file) as f:
                                        data = json.load(f)

                                    if filename not in packagesResults['composer']['testedWidth']:
                                        packagesResults['composer']['testedWidth'].append(filename)

                                    if 'packages' in data:
                                        for pkg in data['packages']:
                                            package_name = pkg['name']

                                            if "/" in package_name:
                                                if package_name not in packagesResults['composer']['packages']:
                                                    packagesResults['composer']['packages'].append(package_name)

                                                vendor = package_name.split("/")[0]
                                                product = package_name.split("/")[1]
                                                versions = pkg['version']

                                                res = {}
                                                res['product'] = product
                                                res['vendor'] = vendor
                                                res['versions'] = versions
                                                res['location'] = file
                                                packagesResults['composer']['inventory'].append(res)


                                                if 'require' in pkg:
                                                    for d in pkg['require']:
                                                        if "/" in d:
                                                            if d not in packagesResults['composer']['packages']:
                                                                packagesResults['composer']['packages'].append(d)

                                                            vendor1 = d.split("/")[0]
                                                            product1 = d.split("/")[1]
                                                            versions1 = pkg['require'][d]

                                                            res = {}
                                                            res['product'] = product1
                                                            res['vendor'] = vendor1
                                                            res['versions'] = versions1
                                                            res['location'] = file
                                                            packagesResults['composer']['inventory'].append(res)

                                                            if d not in packagesResults['composer']['dependancy']:
                                                                packagesResults['composer']['dependancy'][d] = []

                                                            if "%s@%s" % (str(package_name), str(versions)) not in packagesResults['composer']['dependancy'][d]:
                                                                packagesResults['composer']['dependancy'][d].append("%s@%s" % (str(package_name), str(versions)))

                                                if 'require-dev' in pkg:
                                                    for d in pkg['require-dev']:
                                                        if "/" in d:
                                                            if d not in packagesResults['composer']['packages']:
                                                                packagesResults['composer']['packages'].append(d)

                                                            vendor2 = d.split("/")[0]
                                                            product2 = d.split("/")[1]
                                                            versions2 = pkg['require-dev'][d]

                                                            res = {}
                                                            res['product'] = product2
                                                            res['vendor'] = vendor2
                                                            res['versions'] = versions2
                                                            res['location'] = file
                                                            packagesResults['composer']['inventory'].append(res)

                                                            if d not in packagesResults['composer']['dependancy']:
                                                                packagesResults['composer']['dependancy'][d] = []

                                                            if "%s@%s" % (str(package_name), str(versions)) not in packagesResults['composer']['dependancy'][d]:
                                                                packagesResults['composer']['dependancy'][d].append("%s@%s" % (str(package_name), str(versions)))

                            if filename == "composer.json":
                                if os.stat(file).st_size != 0:
                                    with open(file) as f:
                                        data = json.load(f)

                                    if filename not in packagesResults['composer']['testedWidth']:
                                        packagesResults['composer']['testedWidth'].append(filename)

                                    if 'require' in data:
                                        for d in data['require']:
                                            if "/" in d:
                                                if d not in packagesResults['composer']['packages']:
                                                    packagesResults['composer']['packages'].append(d)

                                                vendor3 = d.split("/")[0]
                                                product3 = d.split("/")[1]
                                                versions3 = data['require'][d]

                                                res = {}
                                                res['product'] = product3
                                                res['vendor'] = vendor3
                                                res['versions'] = versions3
                                                res['location'] = file
                                                packagesResults['composer']['inventory'].append(res)


                                    if 'require-dev' in data:
                                        for d in data['require-dev']:
                                            if "/" in d:
                                                if d not in packagesResults['composer']['packages']:
                                                    packagesResults['composer']['packages'].append(d)

                                                vendor4 = d.split("/")[0]
                                                product4 = d.split("/")[1]
                                                versions4 = data['require-dev'][d]

                                                res = {}
                                                res['product'] = product3
                                                res['vendor'] = vendor3
                                                res['versions'] = versions3
                                                res['location'] = file
                                                packagesResults['composer']['inventory'].append(res)


                    if not language or language == "npm":
                        packagesResults['npm'] = {}
                        packagesResults['npm']['inventory'] = []
                        packagesResults['npm']['packages'] = []
                        packagesResults['npm']['testedWidth'] = []
                        packagesResults['npm']['dependancy'] = {}

                        for file in glob2.glob('%s/**/package*.json' % (sourcefolder), recursive=True):
                                file = os.path.abspath(file)
                                filename = os.path.basename(file)

                                if filename not in packagesResults['npm']['testedWidth']:
                                        packagesResults['npm']['testedWidth'].append(filename)


                                with open(file) as f:
                                        data = json.load(f)

                                if 'lockfileVersion' in data:
                                        if 'dependencies' in data:
                                                results = []
                                                devData = data['dependencies']
                                                for devP in devData:
                                                        try:
                                                            devPProduct = devP
                                                            devPVersion = devData[devP]['version']
                                                        except:
                                                            devPProduct = devP
                                                            devPVersion = devData[devP]

                                                        res = {}
                                                        res['product'] = devPProduct
                                                        res['version'] = devPVersion
                                                        results.append(res)

                                                        if '%s@%s' % (devPProduct, devPVersion) not in packagesResults['npm']['dependancy']:
                                                                packagesResults['npm']['dependancy']['%s@%s' % (devPProduct, devPVersion)] = []

                                                        if 'requires' in devData[devP]:
                                                                checkRequires = self.checkrequire(devData[devP])
                                                                for checkreq in checkRequires:
                                                                    try:
                                                                        product = checkreq['product']
                                                                        version = checkreq['version']
                                                                        if '%s@%s' % (product, version) not in packagesResults['npm']['dependancy']:
                                                                                packagesResults['npm']['dependancy']['%s@%s' % (product, version)] = []
                                                                        packagesResults['npm']['dependancy']['%s@%s' % (product, version)].append('%s@%s' % (devPProduct, devPVersion))

                                                                        results.append(checkreq)
                                                                    except:
                                                                           pass

                                                        if 'dependencies' in devData[devP]:
                                                                checkDependancy = self.checkDependancies(devData[devP])
                                                                for checkdep in checkDependancy:
                                                                        devPProduct1 = checkdep['product']
                                                                        devPVersion1 = checkdep['version']
                                                                        results.append(checkdep)
                                                                        if '%s@%s' % (devPProduct1, devPVersion1) not in packagesResults['npm']['dependancy']:
                                                                                packagesResults['npm']['dependancy']['%s@%s' % (devPProduct1, devPVersion1)] = []
                                                                        packagesResults['npm']['dependancy']['%s@%s' % (devPProduct1, devPVersion1)].append('%s@%s' % (devPProduct, devPVersion))

                                                                        if 'requires' in devData[devP]['dependencies'][checkdep['product']]:
                                                                                checkRequires = self.checkrequire(devData[devP]['dependencies'][checkdep['product']])
                                                                                for checkreq in checkRequires:
                                                                                        product = checkreq['product']
                                                                                        version = checkreq['version']
                                                                                        results.append(checkreq)
                                                                                        if '%s@%s' % (product, version) not in packagesResults['npm']['dependancy']:
                                                                                                packagesResults['npm']['dependancy']['%s@%s' % (product, version)] = []
                                                                                        packagesResults['npm']['dependancy']['%s@%s' % (product, version)].append('%s@%s ==> %s@%s' % (devPProduct1, devPVersion1, devPProduct, devPVersion))

                                                                        if 'dependencies' in devData[devP]['dependencies'][checkdep['product']]:
                                                                                checkDependancy1 = self.checkDependancies(devData[devP]['dependencies'][checkdep['product']])
                                                                                for checkdep1 in checkDependancy1:
                                                                                        devPProduct2 = checkdep1['product']
                                                                                        devPVersion2 = checkdep1['version']
                                                                                        results.append(checkdep1)
                                                                                        if '%s@%s' % (devPProduct2, devPVersion2) not in packagesResults['npm']['dependancy']:
                                                                                                packagesResults['npm']['dependancy']['%s@%s' % (devPProduct2, devPVersion2)] = []
                                                                                        packagesResults['npm']['dependancy']['%s@%s' % (devPProduct2, devPVersion2)].append('%s@%s ==> %s@%s' % (devPProduct1, devPVersion1, devPProduct, devPVersion))

                                                                                        if 'requires' in devData[devP]['dependencies'][checkdep['product']]['dependencies'][checkdep1['product']]:
                                                                                                checkRequires1 = self.checkrequire(devData[devP]['dependencies'][checkdep['product']]['dependencies'][checkdep1['product']])
                                                                                                for checkreq1 in checkRequires1:
                                                                                                        product = checkreq1['product']
                                                                                                        version = checkreq1['version']
                                                                                                        results.append(checkreq1)
                                                                                                        if '%s@%s' % (product, version) not in packagesResults['npm']['dependancy']:
                                                                                                                packagesResults['npm']['dependancy']['%s@%s' % (product, version)] = []
                                                                                                        packagesResults['npm']['dependancy']['%s@%s' % (product, version)].append('%s@%s ==> %s@%s ==> %s@%s' % (devPProduct2, devPVersion2, devPProduct1, devPVersion1, devPProduct, devPVersion))

                                                for res in results:
                                                        product = res['product']
                                                        versions = res['version']
                                                        location = file
                                                        res['product'] = product
                                                        res['versions'] = versions
                                                        res['location'] = location
                                                        packagesResults['npm']['inventory'].append(res)
                                                        if product not in packagesResults['npm']['packages']:
                                                                packagesResults['npm']['packages'].append(product)

                                else:
                                        if 'dependencies' in data:
                                                for d in data['dependencies']:
                                                        if "/" in d:
                                                                res = {}
                                                                product = d.split("/")[1]
                                                                versions = data['dependencies'][d]
                                                                res['product'] = product
                                                                res['versions'] = versions
                                                                res['location'] = file
                                                                packagesResults['npm']['inventory'].append(res)
                                                                if product not in packagesResults['npm']['packages']:
                                                                        packagesResults['npm']['packages'].append(product)
                                                        else:
                                                                res = {}
                                                                product = d
                                                                versions = data['dependencies'][d]
                                                                res['product'] = product
                                                                res['versions'] = versions
                                                                res['location'] = file
                                                                packagesResults['npm']['inventory'].append(res)
                                                                if product not in packagesResults['npm']['packages']:
                                                                        packagesResults['npm']['packages'].append(product)

                                        if 'devDependencies' in data:
                                                for d in data['devDependencies']:
                                                        if "/" in d:
                                                                res = {}
                                                                product = d.split("/")[1]
                                                                versions = data['devDependencies'][d]
                                                                res['product'] = product
                                                                res['versions'] = versions
                                                                res['location'] = file
                                                                packagesResults['npm']['inventory'].append(res)
                                                                if product not in packagesResults['npm']['packages']:
                                                                        packagesResults['npm']['packages'].append(product)
                                                        else:
                                                                res = {}
                                                                product = d
                                                                versions = data['devDependencies'][d]
                                                                res['product'] = product
                                                                res['versions'] = versions
                                                                res['location'] = file
                                                                packagesResults['npm']['inventory'].append(res)
                                                                if product not in packagesResults['npm']['packages']:
                                                                        packagesResults['npm']['packages'].append(product)




                    return packagesResults

class niah_connector():
        def __init__(self):
                pass


        def getClone(self, connType, connName, connRepo, connBranch):
            if not path.exists("/tmp/niah.json"):
                    print("[ INFO ] Autentication Failure, use 'niah auth' cli to login")
                    sys.exit(1)

            with open('/tmp/niah.json') as f:
                    configData = json.load(f)

            if 'connector' not in configData:
                print("[ INFO ] Add connector using `niah connector ...`")
                sys.exit(1)
                

            if connType not in configData['connector']:
                print("[ INFO ] connector not found")
                sys.exit(1)
            else:
                if len(configData['connector'][connType]) > 0:
                    check = False
                    resCheck = []
                    for connv in configData['connector'][connType]:
                        url = connv['url']
                        token = connv['token']
                        name = connv['name']
                        uid = connv['uid']
                        resCheck.append(name)
                        if name == connName:
                                check = True
                                break

                    if not check:
                        print("[ INFO ] Connector %s not found, please select connector from availabel lists - %s" % (connName, ','.join(resCheck)))
                else:
                    print("[ INFO ] Connector %s is empty" % connType)
                                
            connRepos = []

            try:
                if url == "github.com":
                        g = Github(token)
                        for repo in g.get_user().get_repos():
                                connRepos.append(repo.name)
                else:
                        g = Github(base_url="https://%s/api/v3" % url, login_or_token=token)
                        for repo in g.get_user().get_repos():
                                connRepos.append(repo.name)
            except:
                print("[ INFO ] github connection error, please check token...")
                sys.exit(1)

            if connRepo != "all" or not connRepo:
                if connRepo not in connRepos:
                        print("[ INFO ] repository %s is not found" % connRepo)
                        sys.exit(1)
                else:
                        connRepos = []
                        connRepos.append(connRepo)

            resLists = []
                
            if len(connRepos) > 0:
                for connRepo in connRepos:
                        status, output = getstatusoutput("rm -rf /tmp/%s" % connRepo)
                        if connBranch:
                                cmd = "git clone --branch %s https://%s:%s@%s/%s/%s.git /tmp/%s" % (connBranch, uid, token, url, uid, connRepo, connRepo)
                        else:
                                cmd = "git clone https://%s:%s@%s/%s/%s.git /tmp/%s" % (uid, token, url, uid, connRepo, connRepo)

                        status, output = getstatusoutput(cmd)
                        res = {}
                        res['repository'] = connRepo
                        res['repoType'] = connType
                        res['branch'] = connBranch
                        res['connector'] = connName
                        res['gitId'] = uid
                        resLists.append(res)
            else:
                print("[ INFO ] Repository not found")

            return resLists
                

class niah_viewreport():
        def __init__(self, reports, upload):
            if not path.exists("/tmp/niah.json"):
                    print("[ INFO ] Autentication Failure, use 'niah auth' cli to login")
                    sys.exit(1)

            with open('/tmp/niah.json') as f:
                    configData = json.load(f)

            headers = {
                'Content-Type': 'application/json',
            }

            data = '{"username": "%s", "password": "%s"}' % (configData['username'], configData['password'])

            try:
                response = requests.post('http://192.168.0.139:8080/api/auth', headers=headers, data=data)
                if response.status_code == 200:
                        res = response.text
                        access_token = json.loads(res)['access_token']
                        self.access_token = access_token
                        configData['access_token'] = access_token

                        with open('/tmp/niah.json', 'w') as f:
                                json.dump(configData, f)
                else:
                        print("[ INFO ] Invalid or Expire Credential/Token")
                        sys.exit(1)
            except:
                    print("[ INFO ] niah.io server connection error! check internet connectivity")
                    sys.exit(1)

            self.headers = {
                'Content-Type': 'application/json',
                'Authorization': 'JWT %s' % access_token,
            }

            self.headersu = {
                'Authorization': 'JWT %s' % access_token,
            }

            response = requests.get('http://192.168.0.139:8080/api/getuserid', headers=self.headers)
            res = response.text
            if response.status_code == 401:
                print("[ INFO ] Invalid or Expire Credential/Token")
                sys.exit(1)

            self.user_id = json.loads(res)['user_id']
            self.company_id = json.loads(res)['company_id']
            self.team_id = json.loads(res)['team_id']

            if len(reports) > 0:
                for report in reports:
                        print("######################## %s ########################" % report)
                        self.genConsoleReport('%s' % (report))

                        if upload.lower() == 'yes':
                                self.reportUpload(report)

        def reportUpload(self, filename):
                with open(filename) as f:
                        data = json.load(f)

                project = data['header']['Project']
                reportType = data['header']['report_type']
                date = data['header']['Date']
                docker = data['header']['docker']
                label = data['header']['tags']
                if 'target' in data['header']:
                        scan_project = data['header']['target']
                elif 'System Name' in data['header']:
                        scan_project = data['header']['System Name']
                else:
                        scan_project = ''
                if 'System Name' in data['header']:
                        system_name = data['header']['System Name']
                else:
                        system_name = ''
                if 'repository' in data['header']:
                        repository = data['header']['repository']
                else:
                        repository = ''
                if 'repository_type' in data['header']:
                        repository_type = data['header']['repository_type']
                else:
                        repository_type = ''
                if 'branch' in data['header']:
                        branch = data['header']['branch']
                else:
                        branch = ''
                if 'gitId' in data['header']:
                        repoId = data['header']['gitId']
                else:
                        repoId = ''
                
                if 'OS Name' in data['header']:
                        system_os = data['header']['OS Name']
                else:
                        system_os = ''
                if 'System IP' in data['header']:
                        system_ip = data['header']['System IP']
                else:
                        system_ip = ''

                if 'language' in data['header']:
                        project_language = data['header']['language']
                else:
                        project_language = ''

                if 'repoType' in data['header']:
                        repoType = data['header']['repoType']
                else:
                        repoType = ''

                resHeader = {}
                resHeader['report_type'] = reportType
                resHeader['projectname'] = project
                resHeader['scan_project'] = scan_project
                resHeader['label'] = label
                resHeader['repository'] = repository
                resHeader['repository_type'] = repository_type
                resHeader['branch'] = branch
                resHeader['repoId'] = repoId
                resHeader['scanner_type' ] = docker
                resHeader['project_language'] = project_language
                resHeader['project_date'] = date
                resHeader['system_os'] = system_os
                resHeader['system_name'] = system_name
                resHeader['system_ip'] = system_ip
                resHeader['repoType'] = repoType
                fname = os.path.basename(filename)
                
                files = [
                        ('file', (fname, open(filename, 'rb'), 'application/octet')),
                        ('data', ('data', json.dumps(resHeader), 'application/json')),
                ]
                url = 'http://192.168.0.139:8080/api/report-upload'
                response = requests.post(url, headers=self.headersu, files=files)
                
                if response.status_code == 201:
                    print("[ INFO ] Report %s uloaded on server" % filename)
                elif response.status_code == 400:
                    print("[ INFO ] User does not exists")
                elif response.status_code == 401:
                    print("[ INFO ] Report %s already exist on server" % filename)
                else:
                    print("[ ERROR ] Report %s Upload Error" % filename)


        def genConsoleReport(self, reportfile):
                end="\033[0m"
                black="\033[0;30m"
                blackb="\033[1;30m"
                white="\033[0;37m"
                whiteb="\033[1;37m"
                red="\033[0;31m"
                redb="\033[1;31m"
                green="\033[0;32m"
                greenb="\033[1;32m"
                yellow="\033[0;33m"
                yellowb="\033[1;33m"
                blue="\033[0;34m"
                blueb="\033[1;34m"
                purple="\033[0;35m"
                purpleb="\033[1;35m"
                lightblue="\033[0;36m"
                lightblueb="\033[1;36m"


                print((colored(figlet_format("NIAH"), color="blue")))

                with open(reportfile) as jsonfile:
                        jsonData = json.load(jsonfile)


                print('*************%sNiah Security%s*************' % (blue, end))
                print("\n")

                x = PrettyTable(border=False, header=False, padding_width=1)
                x.field_names = ["name", "value"]
                x.align["name"] = "l"
                x.align["value"] = "l"
                x.add_row(["Report Type:", jsonData['header']['report_type']])
                x.add_row(["Project name:", jsonData['header']['Project']])
                x.add_row(["Date:", jsonData['header']['Date'].replace("_", " ")])

                if 'Platform Name' in jsonData['header']:
                        x.add_row(["Platform Name:", jsonData['header']['Platform Name']])

                if 'Type' in jsonData['header']:
                        x.add_row(["OS Name:", jsonData['header']['Type']])

                x.add_row(["Tags:", jsonData['header']['tags']])

                if 'Total Scanned Packages' in jsonData['header']:
                        x.add_row(["Total Scanned Packages:", jsonData['header']['Total Scanned Packages']])
                if 'Total Unique Vulnerabilities' in jsonData['header']:
                        x.add_row(["Total Unique Vulnerabilities:", jsonData['header']['Total Unique Vulnerabilities']])
                if 'Total Vulnerable Packages' in jsonData['header']:
                        x.add_row(["Total Vulnerable Packages:", jsonData['header']['Total Vulnerable Packages']])
                if 'Scanned Applications' in jsonData['header']:
                        x.add_row(["Scanned Applications:", jsonData['header']['Scanned Applications']])
                if 'language' in jsonData['header']:
                        x.add_row(["Language:", jsonData['header']['language']])
                if 'target' in jsonData['header']:
                        x.add_row(["Scan Project:", jsonData['header']['target']])
                if 'Total Scanned Dependancies' in jsonData['header']:
                        x.add_row(["Total Scanned Dependancies:", jsonData['header']['Total Scanned Dependancies']])
                if 'Total Vulnerable Dependencies' in jsonData['header']:
                        x.add_row(["Total Vulnerable Dependencies:", jsonData['header']['Total Vulnerable Dependencies']])
                if 'Tested With' in jsonData['header']:
                        x.add_row(["Tested With:", jsonData['header']['Tested With']])

                x.add_row(["Report:", "%s.json" % jsonData['header']['Date']])

                print(x)
                print("\n")


                x = PrettyTable()
                x.field_names = ["High", "Medium", "Low"]

                print('*************%sSeverity%s*************' % (blue, end))
                print("\n")

                if 'HIGH' not in jsonData['header']['Severity']:
                        high = 0
                else:
                        high = "%s%s%s" % (red, jsonData['header']['Severity']['HIGH'], end)

                if 'MEDIUM' not in jsonData['header']['Severity']:
                        med = 0
                else:
                        med = "%s%s%s" % (yellow, jsonData['header']['Severity']['MEDIUM'], end)

                if 'LOW' not in jsonData['header']['Severity']:
                        low = 0
                else:
                        low = "%s%s%s" % (green, jsonData['header']['Severity']['LOW'], end)


                x.add_row([high, med, low])
                print(x)
                print("\n")

                print('*************%sIssues%s*************' % (blue, end))

                print("\n")

                count = 1
                
                for issue in jsonData['Issues']:
                        for data in jsonData['Issues'][issue]['data']:
                                if data['Severity'] == "HIGH":
                                        severityData = "\033[1;31m%s\033[0m" % data['Severity']
                                elif data['Severity'] == "CRITICAL":
                                        severityData = "\033[1;31m%s\033[0m" % data['Severity']
                                elif data['Severity'] == "MEDIUM":
                                        severityData = "\033[1;33m%s\033[0m" % data['Severity']
                                elif data['Severity'] == "LOW":
                                        severityData = "\033[1;32m%s\033[0m" % data['Severity']
                                else:
                                        severityData = "\033[1;32m%s\033[0m" % data['Severity']

                                if data['CVEID'] == "None" or not data['CVEID']:
                                    if jsonData['header']['report_type'] == "system":
                                        rowData = "(\033[1;36m%s\033[0m) %s - %s : %s\n(%s) (%s) (%s) (Product : %s) (Patch : %s%s%s) (Score : %s)\n" % (count, data['usn_id'], data['Name'], severityData, data['Publish Date'], data['CWE'], data['Vector String'], data['Product'], green, data['Patch Version'], end, data['Base Score'])
                                        print(rowData)
                                    if jsonData['header']['report_type'] == "dependancies":
                                        rowData = "(\033[1;36m%s\033[0m) %s - %s\n(%s) (%s) (%s) (Product : %s) (Vendor : %s) (Patch : %s%s%s)\n" % (count, data['Vulnerability Name'], severityData, data['Publish Date'], data['CWE'], data['Vector String'], data['Product'], data['Vendor'], green, data['Patched Version'], end)
                                        print(rowData)
                                    if jsonData['header']['report_type'] == "application":
                                        rowData = "(\033[1;36m%s\033[0m) %s - %s\n(%s) (%s) (%s) (Product : %s) (Patch : %s%s%s)\n" % (count, data['Vulnerability Name'], severityData, data['Publish Date'], data['CWE'], data['Vector String'], data['Product'], green, data['Patched Version'], end)
                                        print(rowData)
                                else:
                                    if jsonData['header']['report_type'] == "system":
                                        rowData = "(\033[1;36m%s\033[0m) %s - %s : %s\n(%s) (%s) (%s) (Product : %s) (Patch : %s%s%s) (Score : %s)\n" % (count, data['usn_id'], data['CVEID'], severityData, data['Publish Date'], data['CWE'], data['Vector String'], data['Product'], green, data['Patch Version'], end, data['Base Score'])
                                        print(rowData)
                                    if jsonData['header']['report_type'] == "dependancies":
                                        rowData = "(\033[1;36m%s\033[0m) %s - %s\n(%s) (%s) (%s) (Product : %s) (Vendor : %s) (Patch : %s%s%s)\n" % (count, data['CVEID'], severityData, data['Publish Date'], data['CWE'], data['Vector String'], data['Product'], data['Vendor'], green, data['Patched Version'], end)
                                        print(rowData)
                                    if jsonData['header']['report_type'] == "application":
                                        rowData = "(\033[1;36m%s\033[0m) %s - %s\n(%s) (%s) (%s) (Product : %s) (Patch : %s%s%s)\n" % (count, data['CVEID'], severityData, data['Publish Date'], data['CWE'], data['Vector String'], data['Product'], green, data['Patched Version'], end)
                                        print(rowData)

                                count = count + 1

                print("\n")
                print('%sDetail report you can find on Niah portal.%s' % (blue, end))
                print("\n")
                print('{:*^20}'.format('To upload report you have to run command with "niah watch -f <reportfile.json>" or "niah watch".'))


class applicationVulnerabilities():
        def __init__(self, reportPath, project, tag, upload):
            if not path.exists("/tmp/niah.json"):
                    print("[ INFO ] Autentication Failure, use 'niah auth' cli to login")
                    sys.exit(1)

            with open('/tmp/niah.json') as f:
                    configData = json.load(f)

            headers = {
                'Content-Type': 'application/json',
            }

            data = '{"username": "%s", "password": "%s"}' % (configData['username'], configData['password'])

            try:
                response = requests.post('http://192.168.0.139:8080/api/auth', headers=headers, data=data)
                if response.status_code == 200:
                        res = response.text
                        access_token = json.loads(res)['access_token']
                        self.access_token = access_token
                        configData['access_token'] = access_token

                        with open('/tmp/niah.json', 'w') as f:
                                json.dump(configData, f)
                else:
                        print("[ INFO ] Invalid or Expire Credential/Token")
                        sys.exit(1)
            except:
                    print("[ INFO ] niah.io server connection error! check internet connectivity")
                    sys.exit(1)
 
            with open('/tmp/niah.json') as f:
                    configData = json.load(f)

            access_token = configData['access_token']
            self.access_token = configData['access_token']

            self.headers = {
                'Content-Type': 'application/json',
                'Authorization': 'JWT %s' % access_token,
            }

            self.headersu = {
                'Authorization': 'JWT %s' % access_token,
            }

            response = requests.get('http://192.168.0.139:8080/api/getuserid', headers=self.headers)
            res = response.text
            if response.status_code == 401:
                print("[ INFO ] Invalid or Expire Credential token")
                sys.exit(1)

            self.user_id = json.loads(res)['user_id']
            self.company_id = json.loads(res)['company_id']
            self.team_id = json.loads(res)['team_id']

            self.report_upload = upload
            self.reportPath = reportPath

            if not project:
                    project = socket.gethostname()

            self.project = project
            self.projectTag = tag


            self.results = {}
            self.resultsDepends = {}
            self.results['header'] = {}
            now = datetime.now()
            self.report_name = now.strftime("%d-%m-%Y_%H:%M:%S")
            self.report_path = reportPath
            self.system_name = socket.gethostname()    

            self.results['header']['Date'] = self.report_name
            self.results['header']['Project'] = self.project
            self.results['header']['owner'] = self.user_id
            self.results['header']['company_id'] = self.company_id
            self.results['header']['team_id'] = self.team_id
            self.results['header']['docker'] = "False"
            self.results['header']['tags'] = self.projectTag
            self.results['header']['report_type'] = 'application'
            self.results['header']['System Name'] = self.system_name
            self.results['header']['System IP'] = self.getsystemip()
            self.results['header']['OS Name']   = platform.platform()
            self.vuln_found = []
            self.scanApplications = []
            self.vuln_product = []

        def getsystemip(self):
                s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
                s.connect(("8.8.8.8", 80))
                system_ip = s.getsockname()[0]
                s.close()
                return system_ip

        def gtEq(self, vers1, mVers):
                if parse_version(mVers) >= parse_version(vers1):
                        return True
                else:
                        return False

        def gt(self, vers1, mVers):
                if parse_version(mVers) > parse_version(vers1):
                        return True
                else:
                        return False

        def ltEq(self, vers1, mVers):
                if parse_version(mVers) <= parse_version(vers1):
                        return True
                else:
                        return False


        def lt(self, vers1, mVers):
                if parse_version(mVers) < parse_version(vers1):
                        return True
                else:
                        return False

        def eq(self, vers1, mVers):
                if parse_version(mVers) == parse_version(vers1):
                        return True
                else:
                        return False


        def matchVer(self, cve_id, product, baseScore, accessVector, vectorString, pub_date, cwe_text, vendor, vuln_name, versions, patch, severity, mVers):
                mVer = mVers

                severity = severity.upper()

                for vers in versions.split(","):
                    if re.findall(r'\[.*:.*\]', str(vers)):
                        vers1 = re.findall(r'\[(.*):', str(vers))[0]
                        vers2 = re.findall(r':(.*)\]', str(vers))[0]

                        if self.gtEq(vers1, mVer) and self.ltEq(vers2, mVer):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Versions'] = str(versions)
                                res['Base Score'] = str(baseScore)
                                res['Access Vector'] = str(accessVector)
                                res['Vector String'] = str(vectorString)
                                res['Publish Date'] = str(pub_date)
                                res['CWE'] = str(cwe_text)
                                res['Severity'] = str(severity)
                                res['Patched Version'] = str(patch)
                                res['Installed Version'] = str(mVers)

                                if res not in self.results['Issues'][severity]['data']:
                                        self.vuln_found.append(product)

                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        if product not in self.vuln_product:
                                                self.vuln_product.append(product)


                    elif re.findall(r'\(.*:.*\]', str(vers)):
                        vers1 = re.findall(r'\((.*):', str(vers))[0]
                        vers2 = re.findall(r':(.*)\]', str(vers))[0]

                        if self.gt(vers1, mVer) and self.ltEq(vers2, mVer):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Versions'] = str(versions)
                                res['Base Score'] = str(baseScore)
                                res['Access Vector'] = str(accessVector)
                                res['Vector String'] = str(vectorString)
                                res['Publish Date'] = str(pub_date)
                                res['CWE'] = str(cwe_text)
                                res['Severity'] = str(severity)
                                res['Patched Version'] = str(patch)
                                res['Installed Version'] = str(mVers)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.vuln_found.append(product)

                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        if product not in self.vuln_product:
                                                self.vuln_product.append(product)


                    elif re.findall(r'\[.*:.*\)', str(vers)):
                        vers1 = re.findall(r'\[(.*):', str(vers))[0]
                        vers2 = re.findall(r':(.*)\)', str(vers))[0]

                        if self.gtEq(vers1, mVer) and self.lt(vers2, mVer):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Versions'] = str(versions)
                                res['Base Score'] = str(baseScore)
                                res['Access Vector'] = str(accessVector)
                                res['Vector String'] = str(vectorString)
                                res['Publish Date'] = str(pub_date)
                                res['CWE'] = str(cwe_text)
                                res['Severity'] = str(severity)
                                res['Patched Version'] = str(patch)
                                res['Installed Version'] = str(mVers)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.vuln_found.append(product)

                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        if product not in self.vuln_product:
                                                self.vuln_product.append(product)


                    elif re.findall(r'\(.*:.*\)', str(vers)):
                        vers1 = re.findall(r'\((.*):', str(vers))[0]
                        vers2 = re.findall(r':(.*)\)', str(vers))[0]

                        if self.gt(vers1, mVer) and self.lt(vers2, mVer):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Versions'] = str(versions)
                                res['Base Score'] = str(baseScore)
                                res['Access Vector'] = str(accessVector)
                                res['Vector String'] = str(vectorString)
                                res['Publish Date'] = str(pub_date)
                                res['CWE'] = str(cwe_text)
                                res['Severity'] = str(severity)
                                res['Patched Version'] = str(patch)
                                res['Installed Version'] = str(mVers)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.vuln_found.append(product)

                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        if product not in self.vuln_product:
                                                self.vuln_product.append(product)

                    elif re.findall(r'\(.*:.*\)', str(vers)):
                        vers1 = re.findall(r'\((.*):', str(vers))[0]
                        vers2 = re.findall(r':(.*)\)', str(vers))[0]

                        if self.gt(vers1, mVer) and self.lt(vers2, mVer):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Versions'] = str(versions)
                                res['Base Score'] = str(baseScore)
                                res['Access Vector'] = str(accessVector)
                                res['Vector String'] = str(vectorString)
                                res['Publish Date'] = str(pub_date)
                                res['CWE'] = str(cwe_text)
                                res['Severity'] = str(severity)
                                res['Patched Version'] = str(patch)
                                res['Installed Version'] = str(mVers)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.vuln_found.append(product)

                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        if product not in self.vuln_product:
                                                self.vuln_product.append(product)

                    else:
                        vers1 = str(vers)
                        if self.eq(vers1, mVer):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Versions'] = str(versions)
                                res['Base Score'] = str(baseScore)
                                res['Access Vector'] = str(accessVector)
                                res['Vector String'] = str(vectorString)
                                res['Publish Date'] = str(pub_date)
                                res['CWE'] = str(cwe_text)
                                res['Severity'] = str(severity)
                                res['Patched Version'] = str(patch)
                                res['Installed Version'] = str(mVers)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.vuln_found.append(product)

                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        if product not in self.vuln_product:
                                                self.vuln_product.append(product)

        def getVulnData(self, productName, mVers):
                if productName in self.responseData:
                    for res in self.responseData[productName]:
                        cve_id = res['cve_id']
                        product = res['product']
                        baseScore = res['baseScore']
                        accessVector = res['accessvector']
                        vectorString = res['vectorString']
                        pub_date = res['publish_date']
                        cwe_text = res['cwe_text']
                        vendor = res['vendor']
                        vuln_name = res['vuln_name']
                        versions = res['versions']
                        patch = res['patch']
                        severity = res['severity']

                        self.matchVer(cve_id, product, baseScore, accessVector, vectorString, pub_date, cwe_text, vendor, vuln_name, versions, patch, severity, mVers)

        def getConfig(self):
                try:
                        url = "http://192.168.0.139:8080/api/getConfig"
                        headers = {
                                'Authorization': 'Basic QWRtaW5pc3RyYXRvcjpWZXJzYUAxMjM=',
                                'Content-Type': 'application/json'
                        }

                        response = requests.request("GET", url, headers=headers)
                        responseData = response.json()
                        return responseData
                except:
                        print("[ OK ] Database sync error! Check internet connectivity")
                        sys.exit(1)


        def getInstallPkgList(self):
                self.results['inventory'] = []
                resultsPackage = []
                resJson = self.getConfig()
                
                for app in resJson["packageRegex"]:         
                        for app1 in resJson["packageRegex"][app]:       
                                location = app1["location"]
                                file_regex = app1["file_regex"]
                                content_version_regex = app1["content_version_regex"]
                                content_product_regex = app1["content_product_regex"]

                                #location = location.encode('utf-8')
                                #file_regex = file_regex.encode('utf-8')
                                print("localtion - %s" % location)
                                print("regex - %s" % file_regex)
                                for filename in glob2.glob('%s/**/%s' % (location, file_regex), recursive=True):
                                        res = {}
                                        product = ''
                                        version = ''
                                        fData = open(filename, "r").read()
                                        if re.findall(r'%s' % content_version_regex, str(fData)):
                                                version = re.findall(r'%s' % content_version_regex, str(fData))[0]
                                        if re.findall(r'%s' % content_product_regex, str(fData)):
                                                product = re.findall(r'%s' % content_product_regex, str(fData))[0]

                                        if product and version:
                                                res['product'] = product.lower()
                                                res['version'] = version
                                                res['filename'] = filename
                                                self.results['inventory'].append(res)
                                                if product not in resultsPackage:
                                                        resultsPackage.append(product)

                return resultsPackage

        def maxValue(self, mVersions):
                ver1 = '0.0'
                for ver in mVersions:
                        if parse_version(ver) > parse_version(ver1):
                                ver1 = ver

                return ver1


        def getUnique(self, lists):
                unique_list = []
                for x in lists:
                        if x not in unique_list:
                                unique_list.append(x)
                return unique_list

        def scanPackage(self):
                print("[ OK ] Preparing..., It's take some time to completed.")
                packageLists = self.getInstallPkgList()
                self.syncData(packageLists)

                self.results['Issues'] = {}

                print("[ OK ] Scanning started")
                print("[ OK ] There are total %s applications are processing" % len(packageLists))
                for app in tqdm(self.results['inventory']):
                        product = app['product']
                        versions = app['version']
                        if product not in self.scanApplications:
                                self.scanApplications.append(product)

                        self.getVulnData(product, versions)

                print("[ OK ] Scannnigg completed")

                self.results['header']['Severity'] = {}
                self.results['header']['Total Unique Vulnerabilities'] = len(self.vuln_found)
                self.results['header']['Total Vulnerable Applications'] = len(self.getUnique(self.vuln_product))
                self.results['header']['Total Scanned Applications'] = len(self.scanApplications)
                self.results['header']['Scanned Applications'] = ','.join(self.scanApplications)

                for severity in self.results['Issues']:
                        self.results['header']['Severity'][severity] = len(self.results['Issues'][severity]['data'])

                with open("%s/%s.json" % (self.report_path, self.report_name), "w") as f:
                        json.dump(self.results, f)

                print("[ OK ] Vulnerabilities Report ready - %s/%s.json" % (self.report_path, self.report_name))

                reportLists = []
                reportLists.append("%s/%s.json" % (self.report_path, self.report_name))

                if self.report_upload.lower() == 'yes':
                        resReport = niah_viewreport(reportLists, 'yes')
                else:
                        resReport = niah_viewreport(reportLists, 'no')


        def syncData(self, productLists):
                try:
                        url = "http://192.168.0.139:8080/api/vulnapp"
                        payload = "{\"data\": \""+ ','.join(productLists) + "\"}"

                        response = requests.request("POST", url, headers=self.headers, data = payload)
                        responseData = response.json()
                        self.responseData = responseData
                except:
                        print("[ ERROR ] Database sync error! Check internet connectivity")
                        sys.exit(1)
        


class niah_platformscan():
        def __init__(self, reportPath, project, tag, upload):
            if not path.exists("/tmp/niah.json"):
                    print("[ INFO ] Autentication Failure, use 'niah auth' cli to login")
                    sys.exit(1)

            with open('/tmp/niah.json') as f:
                    configData = json.load(f)

            headers = {
                'Content-Type': 'application/json',
            }

            data = '{"username": "%s", "password": "%s"}' % (configData['username'], configData['password'])

            try:
                response = requests.post('http://192.168.0.139:8080/api/auth', headers=headers, data=data)
                if response.status_code == 200:
                        res = response.text
                        access_token = json.loads(res)['access_token']
                        self.access_token = access_token
                        configData['access_token'] = access_token

                        with open('/tmp/niah.json', 'w') as f:
                                json.dump(configData, f)
                else:
                        print("[ INFO ] Invalid or Expire Credential/Token")
                        sys.exit(1)
            except:
                    print("[ INFO ] niah.io server connection error! check internet connectivity")
                    sys.exit(1)

            with open('/tmp/niah.json') as f:
                    configData = json.load(f)

            access_token = configData['access_token']
            self.access_token = configData['access_token']

            self.headers = {
                'Content-Type': 'application/json',
                'Authorization': 'JWT %s' % access_token,
            }

            self.headersu = {
                'Authorization': 'JWT %s' % access_token,
            }

            response = requests.get('http://192.168.0.139:8080/api/getuserid', headers=self.headers)
            res = response.text
            if response.status_code == 401:
                print("[ INFO ] Invalid or Expire Credential token")
                sys.exit(1)

            self.user_id = json.loads(res)['user_id']
            self.company_id = json.loads(res)['company_id']
            self.team_id = json.loads(res)['team_id']

            self.report_upload = upload
            self.reportPath = reportPath

            if not project:
                project = socket.gethostname()

            self.system_name = socket.gethostname()
            self.project = project
            self.projectTag = tag


            self.results = {}
            self.resultsDepends = {}
            self.results['header'] = {}
            now = datetime.now()
            self.report_name = now.strftime("%d-%m-%Y_%H:%M:%S")
            self.report_path = reportPath

            self.results['header']['Date'] = self.report_name
            self.results['header']['Project'] = self.project
            self.results['header']['owner'] = self.user_id
            self.results['header']['company_id'] = self.company_id
            self.results['header']['team_id'] = self.team_id
            self.results['header']['docker'] = "False"
            self.results['header']['tags'] = self.projectTag
            self.results['header']['report_type'] = 'system'
            self.results['header']['System Name'] = self.system_name
            self.results['header']['System IP'] = self.getsystemip()

            self.vuln_depe = []
            self.vuln_found = []
            self.testedWith = []
            self.packageCount = []
            self.vuln_product = []

        def getsystemip(self):
                s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
                s.connect(("8.8.8.8", 80))
                system_ip = s.getsockname()[0]
                s.close()
                return system_ip

        def lt(self, vulnVer, installedVer):
                status, output = getstatusoutput('if $(dpkg --compare-versions "%s" "eq" "%s"); then echo true; fi' % (vulnVer, installedVer))
                if output == "true":
                        return False

                status, output = getstatusoutput('if $(dpkg --compare-versions "%s" "lt" "%s"); then echo true; fi' % (vulnVer, installedVer))
                if output == "true":
                        return False

                return True

        def checkVer(self, newVer, oldVer):
                if self.lt(oldVer, newVer):
                        return False
                else:
                        return True
                

        def matchVer(self, cve_id, product, versions, vectorString, baseScore, pub_date, cwe, name, usn_id, reference, mVersions, severity, os_name):
                if not severity:
                        severity = "Medium"

                severity = severity.upper()
                if self.lt(versions, mVersions):
                        if os_name == "debian":
                                if product not in self.results['remediation']:
                                        self.results['remediation'][product] = {}
                                        self.results['remediation'][product]['Product'] = product
                                        self.results['remediation'][product]['CVEs'] = []
                                        self.results['remediation'][product]['DSA-ID'] = []
                                        self.results['remediation'][product]['Patched Version'] = ''
                                        self.results['remediation'][product]['Installed Version'] = mVersions

                        if os_name == "ubuntu":
                                if product not in self.results['remediation']:
                                        self.results['remediation'][product] = {}
                                        self.results['remediation'][product]['Product'] = product
                                        self.results['remediation'][product]['CVEs'] = []
                                        self.results['remediation'][product]['USN-ID'] = []
                                        self.results['remediation'][product]['Patched Version'] = ''

                                        if re.findall(r'[\w+-]+(-\d+.\d+.\d+-\d+)[\w+-]+', str(product)):
                                                mVersion = "%s_%s" % (product, mVersions)
                                                self.results['remediation'][product]['Installed Version'] = mVersion
                                        else:
                                                self.results['remediation'][product]['Installed Version'] = mVersions


                        res = {}
                        res['CVEID'] = cve_id
                        if cve_id not in self.results['remediation'][product]['CVEs']:
                                self.results['remediation'][product]['CVEs'].append(cve_id)
                        res['Product'] = product
                        res['Versions'] = versions
                        res['Vector String'] = vectorString
                        res['Base Score'] = baseScore
                        res['Publish Date'] = pub_date
                        res['CWE'] = cwe
                        res['Vulnerability Name'] = name
                        res['Severity'] = severity


                        res1 = {}
                        res1['CVEID'] = str(cve_id)
                        res1['Product'] = str(product)
                        res1['CWE'] = str(cwe)
                        res1['Severity'] = str(severity)


                        if severity not in self.results['Issues']:
                                self.results['Issues'][severity] = {}
                                self.results['Issues'][severity]['data'] = []
                                self.results['Issues'][severity]['header'] = []

                        if os_name == "ubuntu":
                                res['usn_id'] = usn_id
                                if usn_id not in self.results['remediation'][product]['USN-ID']:
                                        self.results['remediation'][product]['USN-ID'].append(usn_id)

                        if os_name == "debian":
                                res['dsa_id'] = usn_id
                                if usn_id not in self.results['remediation'][product]['DSA-ID']:
                                        self.results['remediation'][product]['DSA-ID'].append(usn_id)

                        res['Reference'] = reference
                        res['Installed Version'] = mVersions
                        res['Patch Version'] = versions

                        if self.results['remediation'][product]['Patched Version']:
                            if self.checkVer(versions, self.results['remediation'][product]['Patched Version']):
                                self.results['remediation'][product]['Patched Version'] = versions
                        else:
                                self.results['remediation'][product]['Patched Version'] = versions

                        if product not in self.vuln_product:
                                self.vuln_product.append(product)

                        if res not in self.results['Issues'][severity]['data']:
                                self.results['Issues'][severity]['data'].append(res)
                                self.results['Issues'][severity]['header'].append(res1)

                                self.vuln_found.append(cve_id)



        def getVulnData(self, product, mVersion, platform, os_name):
                if ":" in product:
                        product = product.split(":")[0]

                if os_name == "ubuntu":
                    product1 = product
                    if re.findall(r'[\w+-]+(-\d+.\d+.\d+-\d+)[\w+-]+', str(product)):
                        product1 = product
                        output = re.findall(r'([\w+-]+)(-\d+.\d+.\d+-\d+)([\w+-]+)', str(product))
                        product = "%s-x-x-x-x%s" % (output[0][0], output[0][2])
                        mVersion = "%s_%s" % (product1, mVersion)


                platformArray = []
                if re.findall(r'Ubuntu\s+(\d+.\d+.\d+)\s+LTS', str(platform)):
                        platform = "%s LTS" % re.findall(r'(Ubuntu\s+\d+.\d+)', str(platform))[0]
                        platformArray.append(platform)
                        platform = "%s ESM" % re.findall(r'(Ubuntu\s+\d+.\d+)', str(platform))[0]
                        platformArray.append(platform)
                elif re.findall(r'Ubuntu\s+(\d+.\d+.\d+)\s+ESM', str(platform)):
                        platform = "%s ESM" % re.findall(r'(Ubuntu\s+\d+.\d+)', str(platform))[0]
                        platformArray.append(platform)
                else:
                        platform = platform
                        platformArray.append(platform)

                for platform in platformArray:
                    if platform in self.responseData:
                        if product in self.responseData[platform]:
                            if os_name == "ubuntu":
                                for row in self.responseData[platform][product]:
                                        cve_id = row['cve_id']
                                        versions = row['version']
                                        vectorString = row['vectorString']
                                        baseScore = row['baseScore']
                                        pub_date = row['pub_date']
                                        cwe = row['cwe_text']
                                        name = row['name']
                                        usn_id = row['usn_id']
                                        severity = row['severity']
                                        reference = "https://usn.ubuntu.com/%s/" % usn_id
                                        self.matchVer(cve_id, product1, versions, vectorString, baseScore, pub_date, cwe, name, usn_id, reference, mVersion, severity, os_name)

                            if os_name == "debian":
                                for row in self.responseData[platform][product]:
                                        cve_id = row['cve_id']
                                        versions = row['version']
                                        vectorString = row['vectorString']
                                        baseScore = row['baseScore']
                                        pub_date = row['pub_date']
                                        cwe = row['cwe_text']
                                        name = row['name']
                                        dsa_id = row['dsa_id']
                                        severity = row['severity']
                                        reference = "https://www.debian.org/security/%s/%s" % (cve_id.split("-")[1], dsa_id)
                                        self.matchVer(cve_id, product, versions, vectorString, baseScore, pub_date, cwe, name, dsa_id, reference, mVersion, severity, os_name)



        def getInstallPkgList(self):
                self.results['inventory'] = []

                cmd = 'cat /etc/os-release'
                status, output = getstatusoutput(cmd)
                data = output

                os_name = re.findall(r'^ID=(.*)', str(data), flags=re.MULTILINE)[0]
                os_version = re.findall(r'^VERSION_ID=(.*)', str(data), flags=re.MULTILINE)[0]
                if os_name.strip() == "debian":
                        os_type = re.findall(r'^VERSION=\"\d+\s+\((.*)\)\"', str(data), flags=re.MULTILINE)[0]
                elif  os_name.strip() == "ubuntu":
                        os_type = re.findall(r'PRETTY_NAME=\"(.*)\"', str(data), flags=re.MULTILINE)[0]
                else:
                        os_type = ''

                self.results['header']['Platform Name'] = str(os_name.strip())
                self.results['header']['Version'] = str(os_version.replace('"', '').strip())
                self.results['header']['OS Name'] = str(os_type.strip())

                if os_name.strip() == "debian" or os_name.strip() == "ubuntu":
                        cmd = 'dpkg -la > t; cat t'
                        status, output = getstatusoutput(cmd)
                        data = output

                        if re.findall(r'ii\s+(.*?)\s+(.*?)\s+(.*?)\s+', str(data)):
                                pkgDetails = re.findall(r'ii\s+(.*?)\s+(.*?)\s+(.*?)\s+', str(data))
                                for pkg in pkgDetails:
                                        res = {}
                                        package = pkg[0]
                                        res['package'] = str(package)
                                        version = pkg[1]
                                        res['version'] = str(version)
                                        archPkg = pkg[2]
                                        res['archPkg'] = str(archPkg)
                                        self.results['inventory'].append(res)

                        
                
        def getUnique(self, lists):
                unique_list = [] 
                for x in lists:
                        if x not in unique_list:
                                unique_list.append(x)
                return unique_list


        def scanPlatformPackage(self):
                print("[ OK ] Preparing.., It's take time to completed")
                self.getInstallPkgList()
                self.results['Issues'] = {}
                self.results['remediation'] = {}

                os_name = self.results['header']['Platform Name']

                if self.results['header']['Platform Name'] == "ubuntu":
                        platform = self.results['header']['OS Name']
                elif self.results['header']['Platform Name'] == "debian":
                        platform = self.results['header']['OS Name']
                else:
                        platform = self.results['header']['Version']

                if len(self.results['inventory']) > 0:
                        print("[ OK ] Database sync started, this process take couple of minutes")
                        self.syncData(os_name)
                        print("[ OK ] Database sync comleted")
                        print("[ OK ] Scanning started")

                        for pkg in tqdm(self.results['inventory']):
                            arch = pkg['archPkg']
                            version = pkg['version']
                            product = pkg['package']

                            if product not in self.packageCount:
                                self.packageCount.append(product) 

                            self.getVulnData(product, version, platform, os_name)



                print("[ OK ] Scanning Completed")

                self.results['header']['Severity'] = {}
                self.results['header']['Total Scanned Packages'] = len(self.packageCount)
                self.results['header']['Total Unique Vulnerabilities'] = len(self.vuln_found)
                self.results['header']['Total Vulnerable Packages'] = len(self.getUnique(self.vuln_product))

                for severity in self.results['Issues']:
                        self.results['header']['Severity'][severity] = len(self.results['Issues'][severity]['data'])
                        
                with open("%s/%s.json" % (self.report_path, self.report_name), "w") as f:
                        json.dump(self.results, f)
                
                print("[ OK ] Vulnerabilities Report ready - %s/%s.json" % (self.report_path, self.report_name))

                reportLists = []
                reportLists.append("%s/%s.json" % (self.report_path, self.report_name))

                if self.report_upload.lower() == 'yes':
                        resReport = niah_viewreport(reportLists, 'yes')
                else:
                        resReport = niah_viewreport(reportLists, 'no')
                

        def syncData(self, os_name):
                try:
                        url = "http://192.168.0.139:8080/api/scan/platform/%s" % (os_name)
                        headers = {
                        'Authorization': 'Basic QWRtaW5pc3RyYXRvcjpWZXJzYUAxMjM=',
                        'Content-Type': 'application/json'
                        }
                        payload = "{\"data\": \""+ os_name + "\"}"

                        response = requests.request("POST", url, headers=self.headers, data = payload)
                        self.responseData = response.json()
                except:
                        print("[ ERROR ] Database sync error! Check internet connectivity")
                        sys.exit(1)



class niah_dependancyscan():
        def __init__(self, reportPath, project, target, tag, upload, resInfo={}):
            if not path.exists("/tmp/niah.json"):
                    print("[ INFO ] Autentication Failure, use 'niah auth' cli to login")
                    sys.exit(1)

            with open('/tmp/niah.json') as f:
                    configData = json.load(f)

            headers = {
                'Content-Type': 'application/json',
            }

            data = '{"username": "%s", "password": "%s"}' % (configData['username'], configData['password'])

            try:
                response = requests.post('http://192.168.0.139:8080/api/auth', headers=headers, data=data)
                if response.status_code == 200:
                        res = response.text
                        access_token = json.loads(res)['access_token']
                        self.access_token = access_token
                        configData['access_token'] = access_token

                        with open('/tmp/niah.json', 'w') as f:
                                json.dump(configData, f)
                else:
                        print("[ INFO ] Invalid or Expire Credential/Token")
                        sys.exit(1)
            except:
                    print("[ INFO ] niah.io server connection error! check internet connectivity")
                    sys.exit(1)

            with open('/tmp/niah.json') as f:
                    configData = json.load(f)

            access_token = configData['access_token']
            self.access_token = configData['access_token']

            self.headers = {
                'Content-Type': 'application/json',
                'Authorization': 'JWT %s' % access_token,
            }

            self.headersu = {
                'Authorization': 'JWT %s' % access_token,
            }

            response = requests.get('http://192.168.0.139:8080/api/getuserid', headers=self.headers)
            res = response.text
            if response.status_code == 401:
                print("[ INFO ] Invalid or Expire Credential token")
                sys.exit(1)

            self.user_id = json.loads(res)['user_id']
            self.company_id = json.loads(res)['company_id']
            self.team_id = json.loads(res)['team_id']

            self.report_upload = upload
            self.reportPath = reportPath
            self.sourcefolder = target

            project_path = os.path.dirname(target)
            self.target = os.path.basename(target)
        
            self.resHeader = {}

            if not project:
                project = self.target

            self.project = project
            self.projectTag = tag

            self.scan_type = "source"

            self.results = {}
            self.resultsDepends = {}
            self.results['header'] = {}
            now = datetime.now()
            self.report_name = now.strftime("%d-%m-%Y_%H:%M:%S")
            self.report_path = reportPath

            self.results['header']['Date'] = self.report_name
            self.results['header']['Project'] = self.project
            self.results['header']['owner'] = self.user_id
            self.results['header']['company_id'] = self.company_id
            self.results['header']['team_id'] = self.team_id
            self.results['header']['repository_type'] = 'source'
            self.results['header']['docker'] = "False"
            self.results['header']['tags'] = self.projectTag
            self.results['header']['target'] = self.target
            self.results['header']['report_type'] = 'dependancies'

            if len(resInfo) > 0:
                for key in resInfo:
                        if key == "repository":
                                self.results['header']['repository'] = resInfo[key]
                        if key == "repoType":
                                self.results['header']['repository_type'] = resInfo[key]
                        if key == "branch":
                                self.results['header']['branch'] = resInfo[key]
                        if key == "connector":
                                self.results['header']['connection name'] = resInfo[key]
                        if key == "gitId":
                                self.results['header']['gitId'] = resInfo[key]
                self.results['header']['repoType'] = "github"
            else:
                self.results['header']['repoType'] = "local"

            self.vuln_depe = []
            self.vuln_found = []
            self.testedWith = []
            self.dependanciesCount = []


        def gtEq(self, vers1, mVers):
                if parse_version(mVers) >= parse_version(vers1):
                        return True
                else:
                        return False

        def gt(self, vers1, mVers):
                if parse_version(mVers) > parse_version(vers1):
                        return True
                else:
                        return False

        def ltEq(self, vers1, mVers):
                if parse_version(mVers) <= parse_version(vers1):
                        return True
                else:
                        return False


        def lt(self, vers1, mVers):
                if parse_version(mVers) < parse_version(vers1):
                        return True
                else:
                        return False

        def eq(self, vers1, mVers):
                if parse_version(mVers) == parse_version(vers1):
                        return True
                else:
                        return False

        def getMatchVersionLists(self, product, vendor, version):
            if self.language == "composer":
                response = requests.get('https://semver.mwl.be/packages/%s/%s/match?constraint=%s&minimum-stability=stable' % (vendor, product, version))
                data = response.text
                data = json.loads(data)
                res = {}
                for d in data:
                        s = d.split(".")[0]
                        if s not in res:
                                res[s] = []
                        res[s].append(d)

                vers = []
                for s in res:
                        vers.append("%s/%s" % (self.minValue(res[s]), self.maxValue(res[s])))

                return vers

            if self.language == "npm":
                response = requests.get('https://cors-proxy-ee2bb0df.internal.npmjs.com/%s' % product)
                data = response.text
                data = json.loads(data)
                versionArray = data['versions']

                versions = []
                for ver in versionArray:
                        versions.append(ver)

                status, output = getstatusoutput("semver -r %s %s" % (version, ' '.join(versions)))
                mVersions = output.split('\n')
                
                res = {}
                for d in mVersions:
                        s = d.split(".")[0]
                        if s not in res:
                                res[s] = []
                        res[s].append(d)


                vers = []
                for s in res:
                        vers.append("%s/%s" % (self.minValue(res[s]), self.maxValue(res[s])))

                return vers
        

        def matchVer(self, product, vendor, cve_id, reference, versions, vuln_name, vectorString, baseScore, patch, pub_date, severity, mVers, cwe_text):
            if self.language == "maven":
                mVer = mVers
                dependsVer = ''

                severity = severity.upper()             

                for vers in versions.split(","):
                        if re.findall(r'\[.*:.*\]', str(vers)):
                            vers1 = re.findall(r'\[(.*):', str(vers))[0]
                            vers2 = re.findall(r':(.*)\]', str(vers))[0]

                            if self.gtEq(vers1, mVer) and self.ltEq(vers2, mVer):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

                        elif re.findall(r'\(.*:.*\]', str(vers)):
                            vers1 = re.findall(r'\((.*):', str(vers))[0]
                            vers2 = re.findall(r':(.*)\]', str(vers))[0]

                            if self.gt(vers1, mVer) and self.ltEq(vers2, mVer):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)



                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

                        elif re.findall(r'\[.*:.*\)', str(vers)):
                            vers1 = re.findall(r'\[(.*):', str(vers))[0]
                            vers2 = re.findall(r':(.*)\)', str(vers))[0]

                            if self.gtEq(vers1, mVer) and self.lt(vers2, mVer):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

                        elif re.findall(r'\(.*:.*\)', str(vers)):
                            vers1 = re.findall(r'\((.*):', str(vers))[0]
                            vers2 = re.findall(r':(.*)\)', str(vers))[0]

                            if self.gt(vers1, mVer) and self.lt(vers2, mVer):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)


                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

                        elif re.findall(r'\(.*:.*\)', str(vers)):
                            vers1 = re.findall(r'\((.*):', str(vers))[0]
                            vers2 = re.findall(r':(.*)\)', str(vers))[0]

                            if self.gt(vers1, mVer) and self.lt(vers2, mVer):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

                        else:
                            vers1 = str(vers)
                            if self.eq(vers1, mVer):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

            if self.language == "python":
                if self.language == "python":
                        mVer = self.checkSemantic(product, mVers)
                        dependsVer = ''
                        

                if str(mVer) != "0.0":
                    severity = severity.upper()         

                    for vers in versions.split(","):
                        if re.findall(r'\[.*:.*\]', str(vers)):
                            vers1 = re.findall(r'\[(.*):', str(vers))[0]
                            vers2 = re.findall(r':(.*)\]', str(vers))[0]

                            if self.gtEq(vers1, mVer) and self.ltEq(vers2, mVer):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

                        elif re.findall(r'\(.*:.*\]', str(vers)):
                            vers1 = re.findall(r'\((.*):', str(vers))[0]
                            vers2 = re.findall(r':(.*)\]', str(vers))[0]

                            if self.gt(vers1, mVer) and self.ltEq(vers2, mVer):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)



                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

                        elif re.findall(r'\[.*:.*\)', str(vers)):
                            vers1 = re.findall(r'\[(.*):', str(vers))[0]
                            vers2 = re.findall(r':(.*)\)', str(vers))[0]

                            if self.gtEq(vers1, mVer) and self.lt(vers2, mVer):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

                        elif re.findall(r'\(.*:.*\)', str(vers)):
                            vers1 = re.findall(r'\((.*):', str(vers))[0]
                            vers2 = re.findall(r':(.*)\)', str(vers))[0]

                            if self.gt(vers1, mVer) and self.lt(vers2, mVer):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)


                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

                        elif re.findall(r'\(.*:.*\)', str(vers)):
                            vers1 = re.findall(r'\((.*):', str(vers))[0]
                            vers2 = re.findall(r':(.*)\)', str(vers))[0]

                            if self.gt(vers1, mVer) and self.lt(vers2, mVer):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

                        else:
                            vers1 = str(vers)
                            if self.eq(vers1, mVer):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

            if self.language == "composer":
                if self.language == "composer":
                        mVers = self.getMatchVersionLists(product, vendor, mVers)
                        if "%s@%s" % (product, mVers) in self.resultsDepends:
                                dependsVer = ','.join(self.resultsDepends["%s@%s" % (product, mVers)])
                        else:
                                dependsVer = ''
                        

                severity = severity.upper()             

                for mVer in mVers:
                    mVer1 = mVer.split("/")[0]
                    mVer2 = mVer.split("/")[1]
                    for vers in versions.split(","):
                        if re.findall(r'\[.*:.*\]', str(vers)):
                            vers1 = re.findall(r'\[(.*):', str(vers))[0]
                            vers2 = re.findall(r':(.*)\]', str(vers))[0]

                            if self.gtEq(vers1, mVer1) and self.ltEq(vers2, mVer2):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

                        elif re.findall(r'\(.*:.*\]', str(vers)):
                            vers1 = re.findall(r'\((.*):', str(vers))[0]
                            vers2 = re.findall(r':(.*)\]', str(vers))[0]

                            if self.gt(vers1, mVer1) and self.ltEq(vers2, mVer2):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)



                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

                        elif re.findall(r'\[.*:.*\)', str(vers)):
                            vers1 = re.findall(r'\[(.*):', str(vers))[0]
                            vers2 = re.findall(r':(.*)\)', str(vers))[0]

                            if self.gtEq(vers1, mVer1) and self.lt(vers2, mVer2):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

                        elif re.findall(r'\(.*:.*\)', str(vers)):
                            vers1 = re.findall(r'\((.*):', str(vers))[0]
                            vers2 = re.findall(r':(.*)\)', str(vers))[0]

                            if self.gt(vers1, mVer1) and self.lt(vers2, mVer2):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)


                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

                        elif re.findall(r'\(.*:.*\)', str(vers)):
                            vers1 = re.findall(r'\((.*):', str(vers))[0]
                            vers2 = re.findall(r':(.*)\)', str(vers))[0]

                            if self.gt(vers1, mVer1) and self.lt(vers2, mVer2):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

                        else:
                            vers1 = str(vers)
                            if self.eq(vers1, mVer2):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

            if self.language == "npm":
                if self.language == "npm":
                        mVers = self.getMatchVersionLists(product, vendor, mVers)
                        if "%s@%s" % (product, mVers) in self.resultsDepends:
                                dependsVer = ','.join(self.resultsDepends["%s@%s" % (product, mVers)])
                        else:
                                dependsVer = ''
                        
                        
                        if "%s@%s" % (product, mVers) in self.resultsDepends:
                                dependsVer = ','.join(self.resultsDepends["%s@%s" % (product, mVers)])
                        else:
                                dependsVer = ''
                        

                severity = severity.upper()             

                for mVer in mVers:
                    mVer1 = mVer.split("/")[0]
                    mVer2 = mVer.split("/")[1]
                    for vers in versions.split(","):
                        if re.findall(r'\[.*:.*\]', str(vers)):
                            vers1 = re.findall(r'\[(.*):', str(vers))[0]
                            vers2 = re.findall(r':(.*)\]', str(vers))[0]

                            if self.gtEq(vers1, mVer1) and self.ltEq(vers2, mVer2):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

                        elif re.findall(r'\(.*:.*\]', str(vers)):
                            vers1 = re.findall(r'\((.*):', str(vers))[0]
                            vers2 = re.findall(r':(.*)\]', str(vers))[0]

                            if self.gt(vers1, mVer1) and self.ltEq(vers2, mVer2):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)



                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

                        elif re.findall(r'\[.*:.*\)', str(vers)):
                            vers1 = re.findall(r'\[(.*):', str(vers))[0]
                            vers2 = re.findall(r':(.*)\)', str(vers))[0]

                            if self.gtEq(vers1, mVer1) and self.lt(vers2, mVer2):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

                        elif re.findall(r'\(.*:.*\)', str(vers)):
                            vers1 = re.findall(r'\((.*):', str(vers))[0]
                            vers2 = re.findall(r':(.*)\)', str(vers))[0]

                            if self.gt(vers1, mVer1) and self.lt(vers2, mVer2):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)


                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

                        elif re.findall(r'\(.*:.*\)', str(vers)):
                            vers1 = re.findall(r'\((.*):', str(vers))[0]
                            vers2 = re.findall(r':(.*)\)', str(vers))[0]

                            if self.gt(vers1, mVer1) and self.lt(vers2, mVer2):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)

                        else:
                            vers1 = str(vers)
                            if self.eq(vers1, mVer2):
                                res = {}
                                if severity not in self.results['Issues']:
                                        self.results['Issues'][severity] = {}
                                        self.results['Issues'][severity]['data'] = []
                                        self.results['Issues'][severity]['header'] = []

                                res1 = {}
                                res1['CVEID'] = str(cve_id)
                                res1['Product'] = str(product)
                                res1['CWE'] = str(cwe_text)
                                res1['Severity'] = str(severity)

                                res['CVEID'] = str(cve_id)
                                res['Product'] = str(product)
                                res['Vendor'] = str(vendor)
                                res['Severity'] = str(severity)
                                res['Vector String'] = str(vectorString)
                                res['Vulnerability Name'] = str(vuln_name)
                                res['Patched Version'] = str(patch)
                                res['Reference'] = str(reference)
                                res['Publish Date'] = str(pub_date)
                                res['Installed Version'] = str(mVers)
                                res['versions'] = str(versions)
                                res['CWE'] = str(cwe_text)
                                res['Depends'] = str(dependsVer)


                                if res not in self.results['Issues'][severity]['data']:
                                        self.results['Issues'][severity]['data'].append(res)
                                        self.results['Issues'][severity]['header'].append(res1)

                                        self.vuln_found.append(product)
                                        if product not in self.vuln_depe:
                                                self.vuln_depe.append(product)


        def getVulnData(self, productName, vendorName, mVers):
            if productName:
                for res in self.responseData['results'][productName]:
                    if 'product' in res:
                        product = res['product']
                        vendor = res['vendor']
                        cve_id = res['cve_id']
                        reference = res['reference']
                        versions = res['versions']
                        vuln_name = res['vuln_name']
                        vectorString = res['vectorString']
                        baseScore = res['baseScore']
                        patch = res['patch']
                        pub_date = res['pub_date']
                        severity = res['severity']
                        cwe_text = res['cwe_text']
        
                        if vendorName:
                                if vendorName == vendor:
                                        self.matchVer(product, vendor, cve_id, reference, versions, vuln_name, vectorString, baseScore, patch, pub_date, severity, mVers, cwe_text)
                        else:
                                self.matchVer(product, vendor, cve_id, reference, versions, vuln_name, vectorString, baseScore, patch, pub_date, severity, mVers, cwe_text)


        def maxValue(self, mVersions):
                ver1 = '0.0'
                for ver in mVersions:
                        if parse_version(ver) > parse_version(ver1):
                                ver1 = ver

                return ver1

        def minValue(self, mVersions):
                ver1 = '999.999.999'
                for ver in mVersions:
                        if parse_version(ver) < parse_version(ver1):
                                ver1 = ver

                return ver1

        def getpipVersions(self, product):
                vers = []
                url = "https://pypi.python.org/pypi/%s/json" % product
                response = requests.get(url, timeout=10)
                if response.status_code == 200:
                        data = response.text
                        data = json.loads(data)
                        for ver in data['releases']:
                                vers.append(str(ver))

                return vers

        def checkSemantic(self, product, versions):
            if self.language == "python":
                try:
                        res = []
                        versions = versions.strip()
                        versions = versions.replace("\\", "")
                        spec = semantic_version.Spec(versions)
                        productVersions = self.getpipVersions(product)

                        for pVersion in productVersions:
                                if re.findall(r'^\d+\.\d+\.\d+', str(pVersion)):
                                        pVersion = re.findall(r'(^\d+\.\d+\.\d+)', str(pVersion))[0]            
                                elif re.findall(r'^\d+\.\d+', str(pVersion)):
                                        pVersion = "%s.0" % re.findall(r'^\d+\.\d+', str(pVersion))[0]
                                else:
                                        pVersion = pVersion

                                if re.findall(r'(\d)\.(0(\d))\.(\d)', str(pVersion)):
                                        fixVer = re.findall(r'(\d)\.(0(\d))\.(\d)', str(pVersion))[0]
                                        pVersion = "%s.%s.%s" % (fixVer[0], fixVer[1].replace('0', ''), fixVer[2])
                                

                                sVersion = semantic_version.Version(pVersion)
                                if sVersion in spec:
                                        res.append(pVersion)

                        return self.maxValue(res)
                except:
                        res = "0.0"
                        return res
                
                

        def getpipDetails(self, product):
                url = "https://pypi.python.org/pypi/%s/json" % product
                response = requests.get(url, timeout=10)
                if response.status_code == 200:
                        data = response.text
                        data = json.loads(data)
                        current_version = data['info']['version']
                        package_url = data['info']['package_url']
                else:
                        current_version = ""
                        package_url = ""

                self.results['vulnerabilities'][product]['latest version'] = current_version
                self.results['vulnerabilities'][product]['package url'] = package_url

        def getUnique(self, lists):
                unique_list = [] 
                for x in lists:
                        if x not in unique_list:
                                unique_list.append(x)
                return unique_list

        def scanPackages(self, inventory, pkgLists, testedWith, dependancy, language):
            self.language = language
            self.results['header']['language'] = language
            if self.language == "python" or self.language == "composer" or self.language == "npm" or self.language == "maven":
                pass
            else:
                print("[ ERROR ] Select language which do you need to scan, user -s <language> option, example -s python")
                sys.exit(1)

            if self.language == "python" or self.language == "composer" or self.language == "npm" or self.language == "maven":
                print("[ INFO ] Preparing..., It's will take time to completed")

                packageLists = pkgLists
                self.results['inventory'] = inventory
                self.testedWith = testedWith
                self.resultsDepends = dependancy
                
                self.syncData(packageLists)

                self.results['Issues'] = {}

                print("[ INFO ] Scanning started")
                for result in tqdm(self.results['inventory']):
                        product = result['product']
                        if 'vendor' in result:
                                vendor = result['vendor']
                        else:
                                vendor = ''
                        versions = result['versions']

                        if product not in self.dependanciesCount:
                                self.dependanciesCount.append(product)

                        self.getVulnData(product, vendor, versions)

                print("[ INFO ] Scanning completed")

                self.results['header']['Tested With'] = ','.join(self.testedWith)
                self.results['header']['Severity'] = {}
                self.results['header']['Total Scanned Dependancies'] = len(self.dependanciesCount)
                self.results['header']['Total Unique Vulnerabilities'] = len(self.vuln_found)
                self.results['header']['Total Vulnerable Dependencies'] = len(self.getUnique(self.vuln_depe))
                for severity in self.results['Issues']:
                        self.results['header']['Severity'][severity] = len(self.results['Issues'][severity]['data'])

                with open("%s/%s.json" % (self.report_path, self.report_name), "w") as f:
                        json.dump(self.results, f)

                print("[ INFO ] Vulnerabilities Report ready - %s/%s.json" % (self.report_path, self.report_name))

                reportLists = []
                reportLists.append("%s/%s.json" % (self.report_path, self.report_name))

                if self.report_upload.lower() == 'yes':
                        resReport = niah_viewreport(reportLists, 'yes')
                else:
                        resReport = niah_viewreport(reportLists, 'no')


        def syncData(self, productLists):
            try:
                if self.language == "python":
                        url = "http://192.168.0.139:8080/api/scan/language/pypi"
                elif self.language == "npm":
                        url = "http://192.168.0.139:8080/api/scan/language/npm"
                elif self.language == "composer":
                        url = "http://192.168.0.139:8080/api/scan/vendor/language/composer"
                elif self.language == "maven":
                        url = "http://192.168.0.139:8080/api/scan/language/maven"
                else:
                        print("[ OK ] Language argument is not correct or not specified")
                        sys.exit(1)
                                

                payload = "{\"data\": \""+ ','.join(productLists) + "\"}"

                response = requests.request("POST", url, headers=self.headers, data = payload)
                responseData = response.json()
                self.responseData = responseData
            except:
                print("[ ERROR ] Database sync error! Check internet connectivity")
                sys.exit(1)


if __name__ == "__main__":
        helpText = """
                        Need four arguments : <connectory type> <connector name> <repo name> <branch name>
                        Example  : 
                                niah scan dependancies github conn1 repo1 branch1 (If you need to pull specific branch)
                                niah scan dependancies github conn1 repo1 '' (If you need to pull latest available code)
                   """

        parser = argparse.ArgumentParser()
        parser.add_argument('-v', '--version', action='version',
                    version='%(prog)s 1.0')

        commandss = parser.add_subparsers(dest='operation')

        cmd1_parser = commandss.add_parser('scan')

        cmd1sub_parser = cmd1_parser.add_subparsers(dest='scan')
        cmd4sys_parser = cmd1sub_parser.add_parser('system')
        cmd4app_parser = cmd1sub_parser.add_parser('application')
        cmd4dep_parser = cmd1sub_parser.add_parser('dependancies')

        cmd1_parser.add_argument('--connector', type=str, help=helpText, nargs=4, metavar=('<type>', '<name>', '<repo name>', '<branch name>'))
        cmd1_parser.add_argument('-r', '--reportpath', type=str,  help='Report path where you need to store.')
        cmd1_parser.add_argument('-n', '--projectname', type=str,  help='Project name.')
        cmd1_parser.add_argument('-up', '--upload', type=str,  help='Upload report yes/no')
        cmd1_parser.add_argument('-l', '--label', type=str,  help='Project label')

        cmd4dep_parser.add_argument('-lang', '--lang', type=str, help='select dependancies `python/composer/npm/maven` which you need to scan.')
        cmd4dep_parser.add_argument('-t', '--target', type=str,  help='Target scan folder')

        cmd2_parser = commandss.add_parser('auth')
        cmd2_parser.add_argument('-u', '--username', type=str,  help='Username')
        cmd2_parser.add_argument('-p', '--password', type=str,  help='Password')

        cmd3_parser = commandss.add_parser('watch')
        cmd3_parser.add_argument('-f', '--file', type=str,  help='Report file, which is you need to be process')
        cmd3_parser.add_argument('-r', '--reportpath', type=str,  help='Report path, where you need to process report file')
        cmd3_parser.add_argument('-ov', '--ov', type=str, help='select option from `list/view/upload`, what operation you need to perform', default='upload')

        cmd4_parser = commandss.add_parser('connector')
        commands4 = cmd4_parser.add_subparsers(title='connectors')

        cmd4a_parser = commands4.add_parser('add')
        commands5a = cmd4a_parser.add_subparsers(title='Add Connector')

        cmd4d_parser = commands4.add_parser('del')
        commands5d = cmd4d_parser.add_subparsers(title='Delete Connector')
        
        cmd41a_parser = commands5a.add_parser('docker')
        cmd41a_parser.add_argument('-name', '--name', help='Connector name.', required=True)
        cmd41a_parser.add_argument('-url', '--url', type=str,  help='Enter docker url', required=True)
        cmd41a_parser.add_argument('-uid', '--uid', type=str,  help='Enter username', required=True)
        cmd41a_parser.add_argument('-secret', '--secret', type=str,  help='Enter secret', required=True)

        cmd41d_parser = commands5d.add_parser('docker')
        cmd41d_parser.add_argument('--name', help='Connector name.', required=True)

        cmd42a_parser = commands5a.add_parser('aws')
        cmd42a_parser.add_argument('-name', '--name', help='Connector name.', required=True)
        cmd42a_parser.add_argument('-url', '--url', type=str,  help='Enter azure url', required=True)
        cmd42a_parser.add_argument('-uid', '--uid', type=str,  help='Enter username', required=True)
        cmd42a_parser.add_argument('-secret', '--secret', type=str,  help='Enter secret', required=True)

        cmd42d_parser = commands5d.add_parser('aws')
        cmd42d_parser.add_argument('--name', '--name', help='Connector name.', required=True)

        cmd43a_parser = commands5a.add_parser('azure')
        cmd43a_parser.add_argument('-name', '--name',  help='Connector name.', required=True)
        cmd43a_parser.add_argument('-url', '--url', type=str,  help='Enter azure url', required=True)
        cmd43a_parser.add_argument('-uid', '--uid', type=str,  help='Enter username', required=True)
        cmd43a_parser.add_argument('-secret', '--secret', type=str,  help='Enter secret', required=True)

        cmd43d_parser = commands5d.add_parser('azure')
        cmd43d_parser.add_argument('--name', '--name', help='Connector name.', required=True)

        cmd44a_parser = commands5a.add_parser('github')
        cmd44a_parser.add_argument('-name', '--name', help='Connector name.', required=True)
        cmd44a_parser.add_argument('-uid', '--uid', type=str, help='Username', required=True)
        cmd44a_parser.add_argument('-token', '--token', type=str, help='Password/Token', required=True)
        cmd44a_parser.add_argument('-url', '--url', type=str, help='URL', default='github.com')

        cmd44d_parser = commands5d.add_parser('github')
        cmd44d_parser.add_argument('-name', '--name', help='Connector name.', required=True)


        results = parser.parse_args()


        if results.operation == "scan":
                if results.scan == "dependancies":
                    if not results.target:
                        target = os.getcwd()
        
                if not results.reportpath:
                        results.reportpath = '.'

                if not results.projectname:
                        results.projectname = ''

                if not results.label:
                        results.label = "latest"        

                if not results.upload:
                        results.upload = 'yes'


                if results.scan == "system":
                        res = niah_platformscan(results.reportpath, results.projectname, results.label, results.upload)
                        res.scanPlatformPackage()

                elif results.scan == "application":
                        res = applicationVulnerabilities(results.reportpath, results.projectname, results.label, results.upload)
                        res.scanPackage()

                elif results.scan == "dependancies":
                        if results.connector:
                                connType = results.connector[0]
                                connName = results.connector[1]
                                connRepo = results.connector[2]
                                connBranch = results.connector[3]

                                resConns = niah_connector()
                                repos = resConns.getClone(connType, connName, connRepo, connBranch)
                                for repo in repos:
                                        target = "/tmp/%s" % repo['repository']
                                        repoType = repo['repoType']
                                        gitId = repo['gitId']
                                        repository = repo['repository']
                                        connector = repo['connector']
                                        branch = repo['branch']
                                        resInfo = {}
                                        resInfo['repoType'] = repoType
                                        resInfo['gitId'] = gitId
                                        resInfo['repository'] = repository
                                        resInfo['connector'] = connector
                                        resInfo['branch'] = branch

                                        resDetails = niah_getinventory()
                                        if results.lang:
                                                resDetails = resDetails.getInstallPkgList(target, results.lang)
                                        else:
                                                resDetails = resDetails.getInstallPkgList(target)

                                        detectLanguage = []
                                        for language in resDetails:
                                                inventory = resDetails[language]['inventory']
                                                pkgLists = resDetails[language]['packages']
                                                testedWidth = resDetails[language]['testedWidth']
                                                dependancy = resDetails[language]['dependancy']

                                                if len(inventory) > 0:
                                                        res = niah_dependancyscan(results.reportpath, results.projectname, target, results.label, results.upload, resInfo)
                                                        res.scanPackages(inventory, pkgLists, testedWidth, dependancy, language)
                                                        detectLanguage.append(language)

                                        if len(detectLanguage) == 0:
                                                print("[ OK ] Supported dependancies language does not found in target source repository %s" % repository)
                                        else:
                                                print("[ INFO ] Report ready for %s languages" % ','.join(detectLanguage))
                        else:
                                resDetails = niah_getinventory()

                                if results.lang:
                                        resDetails = resDetails.getInstallPkgList(target, results.lang)
                                else:
                                        resDetails = resDetails.getInstallPkgList(target)
                                
                                detectLanguage = []
                                for language in resDetails:
                                        inventory = resDetails[language]['inventory']
                                        pkgLists = resDetails[language]['packages']
                                        testedWidth = resDetails[language]['testedWidth']
                                        dependancy = resDetails[language]['dependancy']

                                        if len(inventory) > 0:
                                                res = niah_dependancyscan(results.reportpath, results.projectname, target, results.label, results.upload)
                                                res.scanPackages(inventory, pkgLists, testedWidth, dependancy, language)
                                                detectLanguage.append(language)

                                if len(detectLanguage) == 0:
                                        print("[ OK ] Supported dependancies language does not found in target source")
                                else:
                                        print("[ INFO ] Report ready for %s languages" % ','.join(detectLanguage))
                else:
                        print("[ INFO ] select proper argument, system/application/dependancies")
                        sys.exit(1)

        elif results.operation == "watch":
            if not results.reportpath:
                results.reportpath = '.'
                srcText = '%s/*.json' % (os.getcwd())
            else:
                srcText = '%s/*.json' % results.reportpath

            filelists = []

            if results.file:
                if not results.reportpath:
                        if path.exists('./%s' % results.file):
                                filelists.append(results.file)
                        else:
                                print("[ ERROR ] Report %s file does not exists" % results.file)
                else:
                        if path.exists('%s/%s' % (results.reportpath, results.file)):
                                filelists.append('%s/%s' % (results.reportpath, results.file))
                        else:
                                print("[ ERROR ] Report %s%s file does not exists" % (results.reportpath, results.file))
            else:
                for file in glob2.glob(srcText):
                        file = os.path.abspath(file)
                        filename = os.path.basename(file)
                        if re.findall(r'\d+-\d+-\d+_\d+:\d+:\d+\.json', str(filename)):
                                filelists.append(file)

            if len(filelists) > 0:
                if results.ov == "view":
                        res = niah_viewreport(filelists, 'no')
                elif results.ov == "list":
                        for filename in filelists:
                                print("Report File - %s" % filename)
                else:
                        res = niah_viewreport(filelists, 'yes')
            else:
                print("[ INFO ] Not found any reports, use -r option to set report directory path")
                sys.exit(1)

        elif results.operation == "auth":
            headers = {
                'Content-Type': 'application/json',
            }
                
            if not results.username or not results.password:
                print("[ INFO ] set --username and --password arguments")
                sys.exit(1)

            data = '{"username": "%s", "password": "%s"}' % (results.username, results.password)

            response = requests.post('http://192.168.0.139:8080/api/auth', headers=headers, data=data)
            if response.status_code == 200:
                res = response.text
                access_token = json.loads(res)['access_token']

                if not path.exists("/tmp/niah.json"):
                        configData = {}
                else:
                        with open('/tmp/niah.json') as f:
                                configData = json.load(f)

                configData['access_token'] = access_token
                configData['username'] = results.username
                configData['password'] = results.password

                with open('/tmp/niah.json', 'w') as f:
                        json.dump(configData, f)
                
                print("[ OK ] Login Successfully!")
            else:
                print("[ OK ] Failed login, check credential")
                sys.exit(1)

        elif results.operation == "connector":
                if not path.exists("/tmp/niah.json"):
                    configData = {}
                else:
                    with open('/tmp/niah.json') as f:
                        configData = json.load(f)

                if 'connector' not in configData:
                        configData['connector'] = {}

                if sys.argv[3] == "docker":
                        if sys.argv[2] == "add":
                                name = results.name
                                url = results.url
                                uid = results.uid
                                secret = results.secret

                                res = {}
                                res['name'] = name
                                res['uid'] = uid
                                res['url'] = url
                                res['secret'] = secret

                                if 'docker' not in configData['connector']:
                                        configData['connector']['docker'] = []

                                if res not in configData['connector']['docker']:
                                        configData['connector']['docker'].append(res)
                        elif sys.argv[2] == "del":
                                for res in configData['connector']['docker']:
                                        if res['name'] == results.name:
                                                res1 = {}
                                                res1['name'] = res['name']
                                                res1['uid'] = res['uid']
                                                res1['url'] = res['url']
                                                res1['secret'] = res['secret']
                                                configData['connector']['docker'].remove(res1)
                                                break
                        else:
                                print("[ OK ] Select add/del option")
                                sys.exit(1)

                elif sys.argv[3] == "aws":
                        if sys.argv[2] == "add":
                                name = results.name
                                results['name'] = name
                                url = results.url
                                uid = results.uid
                                secret = results.secret

                                res = {}
                                res['name'] = name
                                res['uid'] = uid
                                res['url'] = url
                                res['secret'] = secret

                                if 'aws' not in configData['connector']:
                                        configData['connector']['aws'] = []

                                if res not in configData['connector']['aws']:
                                        configData['connector']['aws'].append(res)
                        elif sys.argv[2] == "del":
                                for res in configData['connector']['aws']:
                                        if res['name'] == results.name:
                                                res1 = {}
                                                res1['name'] = res['name']
                                                res1['uid'] = res['uid']
                                                res1['url'] = res['url']
                                                res1['secret'] = res['secret']
                                                configData['connector']['aws'].remove(res1)
                                                break
                        else:
                                print("[ OK ] Select add/del option")
                                sys.exit(1)

                elif sys.argv[3] == "azure":
                        if sys.argv[2] == "add":
                                name = results.name
                                url = results.url
                                uid = results.uid
                                secret = results.secret

                                res = {}
                                res['name'] = name
                                res['uid'] = uid
                                res['url'] = url
                                res['secret'] = secret

                                if 'azure' not in configData['connector']:
                                        configData['connector']['azure'] = []

                                if res not in configData['connector']['azure']:
                                        configData['connector']['azure'].append(res)
                        elif sys.argv[2] == "del":
                                for res in configData['connector']['azure']:
                                        if res['name'] == results.name:
                                                res1 = {}
                                                res1['name'] = res['name']
                                                res1['uid'] = res['uid']
                                                res1['url'] = res['url']
                                                res1['secret'] = res['secret']
                                                configData['connector']['azure'].remove(res1)
                                                break
                        else:
                                print("[ OK ] Select add/del option")
                                sys.exit(1)

                elif sys.argv[3] == "github":
                        if sys.argv[2] == "add":
                                name = results.name
                                uid = results.uid
                                token = results.token
                                url = results.url

                                res = {}
                                res['name'] = name
                                res['token'] = token
                                res['uid'] = uid
                                res['url'] = url

                                if 'github' not in configData['connector']:
                                        configData['connector']['github'] = []

                                if res not in configData['connector']['github']:
                                        configData['connector']['github'].append(res)
                        elif sys.argv[2] == "del":
                                for res in configData['connector']['github']:
                                        if res['name'] == results.name:
                                                res1 = {}
                                                res1['name'] = res['name']
                                                res1['uid'] = res['uid']
                                                res1['token'] = res['token']
                                                configData['connector']['github'].remove(res1)
                                                break
                        else:
                                print("[ OK ] Select add/del option")
                                sys.exit(1)

                with open('/tmp/niah.json', 'w') as f:
                        json.dump(configData, f)

        else:
                print("Use argument scan/auth/watch/connector")
                print("         scan - select scan option system/application/dependancies")
                print("         auth - to get auth token")
                print("         watch - to upload reports")
                print("         connector - add aws/auzre/docker/github connector")
                sys.exit(1)
                

