model push

ASG.API/AModelScenoariotree.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Mar 10 23:13:18 2023
+
+@author:
+"""
+from ModelTEC import *
+from  MScenoariotree  import *
+from  MCheakscenario  import Cheakscenario
+
+
+
+class ModelScenoariotree:
+
+    def __init__(self,obTECSoft=None,obTEC=None,obG=None,Base=None,isForm=False):
+
+
+        self.cks=Cheakscenario(ob=obTECSoft)
+#         obTEC.nlp=Base.nlp
+#         obTECSoft.nlp=Base.nlp
+        self.Base=Base
+        self.obGroup=obG
+        self.Base.setModels(ObTEC=obTEC,ObTECSodft=obTECSoft,obchk=self.cks,isForm=isForm)
+
+
+    def search(self,inputstate=[''],rateerror=0,PrintFuri=True,type_search='Max',ThresholdTechnique=0.0,istrans=False):
+
+        Cheakscenario.PrintFuri=PrintFuri
+        Cheakscenario.rateerror=rateerror
+
+        self.Base.Predict(Description=inputstate,WF=type_search,ThresholdTechnique=ThresholdTechnique,istrans=istrans)
+        print ('all  scenario : end')
+
+
+
+
+
+
+
+

ASG.API/ASGModels.py

@@ -0,0 +1,61 @@
+from ModelTEC import *
+
+import pickle
+from TypeModels import TypeModel
+from BasePath import BASEPATH
+from threading import Thread
+from MScenoariotree import *
+from AModelScenoariotree import ModelScenoariotree
+
+from  MCheakscenario  import Cheakscenario
+class ASG:
+    def readobsoft(self):
+        self.Soft=TEC(typemodel="svmL",model_setting=TypeModel['software'])
+        self.Soft.loadmodel()
+        self.Index+=1
+
+    def readobgroup(self):
+        self.Group=TEC(typemodel="svmL",model_setting=TypeModel['group'])
+        self.Group.loadmodel()
+        self.Index+=1
+
+    def readobtec(self):
+        self.Tec=TEC(typemodel="svmL",model_setting=TypeModel['technique'])
+        self.Tec.loadmodel()
+        self.Index+=1
+
+    def readmstree(self):
+        self.SGT=Scenoariotree('TTs.pkl','tecbyTectics.pkl')
+        self.SGT.Fit()
+        self.Index+=1
+    def __init__(self):
+        self.Index=0
+        self.SGT=None
+        # Thread(target=self.readmstree).start()
+        # Thread(target=self.readobsoft).start()
+        # Thread(target=self.readobtec).start()
+        # Thread(target=self.readobgroup).start()
+        self.readmstree()
+        self.readobsoft()
+        self.readobtec()
+        self.readobgroup()
+
+
+        self.Soft.setPipeline(model=self.Tec)
+        self.Group.setPipeline(model=self.Soft)
+        self.cks=Cheakscenario(ob=self.Soft)
+        self.MST=ModelScenoariotree(obTECSoft=self.Soft,obTEC=self.Tec,obG=self.Group,Base=self.SGT,isForm=True)
+        self.Tec.obMP
+        self.SGT.setModels(ObTEC=self.Tec,ObTECSodft=self.Soft,obchk=self.cks,isForm=False)
+
+
+
+    def search(self,inputstate=[''],rateerror=0,PrintFuri=True,type_search='Max',ThresholdTechnique=0.5,istrans=False,numstop=-1):
+
+        Cheakscenario.PrintFuri=PrintFuri
+        Cheakscenario.rateerror=rateerror
+
+        outputs=self.SGT.Predict(Description=inputstate,WF=type_search,ThresholdTechnique=ThresholdTechnique,istrans=istrans,numstop=numstop)
+        print ('all  scenario : end')
+        return outputs
+

ASG.API/BasePath.py

@@ -0,0 +1,4 @@
+import sys
+path="/home/asgmodel/django-rest-api/DjangoRestApi/tutorials/ASG"
+BASEPATH=path+'/'
+sys.path.insert(0, path)

ASG.API/MCheakscenario.py

@@ -0,0 +1,134 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Sun Dec 18 21:43:54 2022
+
+@author: amaer
+"""
+import numpy as np
+
+from ModelTEC import *
+
+
+class  Cheakscenario:
+    rateerror=0
+    PrintFuri=True
+
+    def __init__(self,ob=None,sequensed=None):
+        self.obTECSoft=ob
+        self.lensoft=len(ob.obMP.Classes)
+        self.inintlist()
+        self.onsequens=sequensed
+
+
+    def inintlist(self):
+        self.listsoftware=np.zeros((self.lensoft,5))
+        self.Counter=0
+
+
+
+    def  createtable(self,row,stat,index=0):
+        st='<table border="1" style="" ><tr  style="background-color:'+stat[0]+'; color:#fff"><th  style="text-align:center" >Tactic  Name</th><th  style="text-align:center" >Technique Name</th></tr>'
+
+
+
+        for ob in row:
+            st+='<tr><td  style="text-align:center"  >'+ob[0]+'</td><td style="text-align:center"  >'+ob[1]+'</td></tr>'
+
+        st+='<tr style="background-color:'+stat[0]+'; color:#fff"><td colspan = "2" style="text-align:center" >attack scenario status ('
+
+        st+=''+ stat[1] +' )  </td></tr>'
+        return st+'</table>'
+
+
+
+
+    def getScenario(self,itmes,k=0,index=0):
+        stat=self.getAStatescenario(k,index)
+        if Cheakscenario.PrintFuri==False and stat[1]=='Failure':return None
+        rowd=[]
+        for ob in itmes:
+            if ob.strip() !='':
+
+                itms=ob.split("*->")
+                rowd.append([itms[0],itms[1]])
+        return rowd,stat,k
+
+
+
+
+    def  process(self,path,cinput,isclean=True):
+        itmes=path.split("=> ")
+
+        pathT=self.getpathTech(itmes)
+        if isclean:
+            da=self.obTECSoft.clean_dataT([pathT+' ' +cinput+" use  "])
+        else:
+            da=[cinput]
+
+
+
+       # print(pathT,da)
+        if(len(da)>0):
+            try:
+                feat=self.obTECSoft.obMP.obVec.transform(da)
+                pyd=self.obTECSoft.Model.predict_proba(feat)
+                self.listsoftware[:,4]+=np.array(pyd[0])
+               #for i in range(self.lensoft):
+              #      self.listsoftware[i,4]=pyd[0][i]
+                index=np.argmax(pyd)
+                k=pyd[0][index]*100+Cheakscenario.rateerror
+
+                row=self.getScenario(itmes,k,index)
+                if row is not None and len(row[0])>0:
+                    self.Counter+=1
+                    if self.onsequens is not None:
+                        self.onsequens((row,pyd[0]))
+
+
+                    return row,pyd[0]
+
+
+            except: pass
+
+        return None
+
+    def print_table(self,path,cinput):
+       # self.obTECSoft.ChangeModel(ob='svmL')
+        rows=self.process(path, cinput)
+
+        if rows is not None :
+            row,pa=rows
+            td=self.createtable(row[0],row[1],self.Counter)
+            print('---------------------------scenario (',self.Counter,')------------------------------')
+            # display(HTML(td))
+
+            return rows
+
+
+    def getAStatescenario(self,k,index):
+        if k>=70:
+            self.listsoftware[index][0]+=1
+            return ('#04AA6D','Success')
+        if k>=60:
+            self.listsoftware[index][1]+=1
+            return ('#1ec7c3','close to success')
+
+        if k>=30:
+            self.listsoftware[index][2]+=1
+            return ('#fb4bd1','Initi')
+        self.listsoftware[index][3]+=1
+        return ('#e91c07','Failure')
+    def getpathTech(self,items):
+        path=' use '
+        for ob in items:
+             if ob.strip() !='':
+
+                itms=ob.split("*->")
+                path+=' '+itms[1]
+        return path
+
+
+
+
+
+

ASG.API/MScenoariotree.py

@@ -0,0 +1,335 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Dec  6 22:13:12 2022
+
+@author: amaer
+"""
+
+import numpy as np
+
+
+
+import copy
+from ModelTEC import *
+
+import pickle
+
+from  threading import Thread
+class Graph:
+
+    def __init__(self,root,name=None,idtactic=0):
+        self.Root=root
+        self.Name=name
+        self.Idtactic=idtactic
+
+        self.Tactics=[]
+    #........................
+
+    def Filter(self):
+        for i in range(self.Idtactic,len(Scenoariotree.Basetree)):
+            self.Tactics.append(copy.deepcopy(Scenoariotree.Basetree[i]))
+
+    #........................
+
+    def Run(self,path="",state=" ",Cinput="",listAttackGod=[],numstop=-1):
+
+        self.Filter()
+        for tactic in self.Tactics:
+            tactic.Run(self.Root,path=path+"=> "+tactic.Name,state=state,Cinput=Cinput,listAttackGod=listAttackGod,numstop=numstop)
+#             thread=Thread(target = tactic.Run, args = (self.Root,path+"->"+tactic.Name))
+#             thread.start()
+#             thread.join()
+
+
+    #........................
+
+
+class Technique:
+
+    PreprocessingFunc=None
+    ExtractFeaturesFunc=None
+    objFile=None
+    Counter=0
+    Cinput=' '
+    listAttackGod=[]
+    PrintScenoario=print
+
+
+
+    def __init__(self,name,description,weight=None):
+
+        self.Name=name
+        self.Description=description
+        self.Weight=weight
+        self.CleanDescription=None
+        self.FeaturesDescription=None
+        self.Graph=None
+
+    #........................................
+
+    def Preprocessing(self):
+        if Technique.PreprocessingFunc:
+            return Technique.PreprocessingFunc([self.Description])
+        return self.Description
+
+    #........................................
+
+    def ExtractFeatures(self):
+        if Technique.ExtractFeaturesFunc:
+            return Technique.ExtractFeaturesFunc(self.CleanDescription if self.CleanDescription else self.Description)
+        return np.zeros((1,10))
+
+    #........................................
+
+    def Fit(self):
+        self.CleanDescription=self.Preprocessing()
+        #self.FeaturesDescription=self.ExtractFeatures()
+
+    #........................................
+
+    def Run(self,id,path="",state=" ",Cinput="",listAttackGod=[],numstop=-1):
+
+        if (numstop ==-1 or len(listAttackGod)<numstop):
+            if id<len(Scenoariotree.Basetree) :
+               # Technique.objFile.write("=")
+
+               # print('=',end='')
+
+                path=path+" *-> "+self.Name+" "
+                row=Technique.PrintScenoario(path,Cinput)
+                if row is not None:
+                    listAttackGod.append(row)
+
+                self.Graph=Graph(root=self,name=self.Name,idtactic=id+1)
+                self.Graph.Run(path=path,state=state,Cinput=Cinput,listAttackGod=listAttackGod,numstop=numstop)
+        else :
+            try:
+                row=Technique.PrintScenoario(path,Cinput)
+                if row is not None:
+                    listAttackGod.append(row)
+
+            except:
+                pass
+
+
+    #........................................
+
+    def __str__(self):
+        return f"(Name: {self.Name} , Weights: {self.Weight})"
+
+
+
+class Tactic():
+    dataMS=None
+    WF="thrshold"
+
+
+
+    def __init__(self,name,id=0,description=None,weight=None,techniques=None,wfilter="thrshold"):
+        self.Name=name
+        self.Id=id
+        self.Weight=weight
+        self.Techniques=techniques if techniques else []
+
+
+    #........................................
+
+    def Filter1(self,root,path=""):
+        i=0
+        while i<len(self.Techniques):
+
+            sim=Tactic.dataMS[root.Name][self.Techniques[i].Name]
+
+            if sim>=Scenoariotree.ThresholdTechnique:
+                self.Techniques[i].Weight=sim
+
+
+            else:
+
+#                 row=Technique.PrintScenoario(path,Technique.Cinput)
+#                 if row is not None:
+#                     Technique.listAttackGod.append(row)
+#                     Technique.Counter+=1
+                self.Techniques.remove(self.Techniques[i])
+                i-=1
+
+
+
+            i+=1
+
+    #........................................
+    def Filter2(self,root,path=""):
+
+        listd=[]
+        max=0
+        for i in range(len(self.Techniques)):
+            sim=Tactic.dataMS[root.Name][self.Techniques[i].Name]
+            if sim>max and  sim>=Scenoariotree.ThresholdTechnique:
+                listd=[self.Techniques[i]]
+                max=sim
+#             Scenoariotree.CurrentSoft.predict()
+
+
+        self.Techniques=listd
+
+    #........................................
+    def Filter(self,root,path=""):
+        if Tactic.WF=="thrshold":
+            self.Filter1(root,path)
+        else:
+            self.Filter2(root,path)
+
+
+    def Run(self,root,path="",state="",Cinput="",listAttackGod=[],numstop=-1):
+
+        self.Filter(root,path)
+
+        for technique in self.Techniques:
+            technique.Run(self.Id,path=path,state=state,Cinput=Cinput,listAttackGod=listAttackGod,numstop=numstop)
+#             thread=Thread(target=technique.Run,args=(self.Id,path))
+#             thread.start()
+#             thread.join()
+
+    #........................................
+
+    def __str__(self):
+        return f"(Name: {self.Name}, Weight: {self.Weight})"
+
+
+
+from BasePath import BASEPATH
+
+class Scenoariotree:
+
+    obTEC=None
+    obTECSodft=None
+    ThresholdTechnique=0.3
+    ThresholdTactic=0.3
+    Basetree=None
+    CurrentSoft=None
+    indecisT={}
+    CurrentInput=''
+
+
+    #....................................................
+
+
+
+
+
+
+
+    #....................................................
+
+
+    def __init__(self,file1,file2,Ntactics=None):
+
+        self.TacticsOrder=pickle.load(open(BASEPATH+file1,'rb'))
+        self.indecisT=pickle.load(open(BASEPATH+file2,'rb'))
+        self.Ntactics=len(self.TacticsOrder)
+        self.nlp=None#spacy.load('en_core_web_lg')
+        """
+
+        """
+
+    def setModels(self,ObTEC=None,ObTECSodft=None,obchk=None,isForm=False):
+        self.obTEC=ObTEC
+        self.obTECSodft=ObTECSodft
+        self.obTEC.ChangeModel(ob="svmK")
+        self.obTECSodft.ChangeModel(ob="svmK")
+        self.obchk=obchk
+        Technique.PrintScenoario=obchk.print_table if isForm==False else obchk.process
+
+    #....................................................
+
+    def InitBasetree(self):
+        tree=[]
+        i=0
+        for key  in self.TacticsOrder:
+            tactic=key
+            tree.append(Tactic(name=tactic,id=i))
+            group=self.TacticsOrder[key]
+            i+=1
+            for j in range(len(group)):
+                tree[-1].Techniques.append(Technique(name=group[j],
+                                                     description=" ",
+                                                     ))
+
+
+        return tree
+
+    #..............................................
+
+    def getordertactics(self):
+        return ''
+    def Fit(self,file="dataSM.pkl",wtype='ALL'):
+
+
+
+
+
+        Tactic.dataMS=pickle.load(open(BASEPATH+file,'rb'))
+        Scenoariotree.Basetree=self.InitBasetree()
+
+
+#        Scenoariotree.Basetree[6].Techniques.append(Technique(name="Exploitation of Remote Services",description="Exploitation of Remote Services")
+
+
+
+    #..............................................
+
+    def Predict(self,Description,ThresholdTechnique=0.5,ThresholdTactic=0.0,WF="thrshold",istrans=False,numstop=-1):
+        Technique.Counter=0
+        Technique.listAttackGod=[]
+        self.obchk.inintlist()
+        Tactic.WF=WF
+        Scenoariotree.ThresholdTechnique=ThresholdTechnique
+        Scenoariotree.ThresholdTactic=ThresholdTactic
+        if istrans:
+            Description=[self.obTEC.to_tran(Description)]
+
+        tech=self.obTEC.predict(Description)
+
+        if tech!="No":
+            print('-------------------------------------------')
+            print('Technique : ', tech)
+            tact=self.indecisT[tech]
+
+            print(' Tactic :',tact)
+            self.obTECSodft.ChangeModel(ob="svmK")
+            CurrentSoft=self.obTECSodft.predict(Description+[" "+tech])
+
+            print('input  same as Software is  : ',CurrentSoft)
+            self.obTECSodft.ChangeModel(ob="svmL")
+            print('-------------------------------------------')
+            print('---------------------senarios----------------------')
+            listofs=[]
+
+            self.Root=Technique(name=tech,description=Description)
+
+            idt=-1
+            for key in self.TacticsOrder:
+                if key==tact:
+                    break
+                idt+=1
+
+            self.Root.Run(id=idt+1,path="=>  "+tact,state="",Cinput=Description[0],listAttackGod=listofs,numstop=numstop)
+            if idt==self.Ntactics-1:
+                self.obchk.process(tact+" *-> "+ tech,Description[0],isclean=False)
+
+
+
+
+
+
+
+
+        else :
+            print( "no found  any thing........")
+
+        return listofs
+    #..............................................
+
+
+
+

ASG.API/ModelTEC.py

@@ -0,0 +1,388 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Dec 17 11:27:28 2022
+
+@author: amaer
+"""
+
+import pickle
+import  numpy as np
+
+
+from sklearn.feature_extraction.text import TfidfVectorizer
+import regex as re
+# import spacy
+# from spacy import displacy
+from sklearn.model_selection import train_test_split
+
+from sklearn.metrics import confusion_matrix, classification_report, accuracy_score,f1_score, precision_score, recall_score
+
+from googletrans import Translator
+
+from django.urls import ModelPums
+import requests
+
+class TEC:
+    __Outs={'svmL':None,'svmK':None,'logstick':None,'target':None}
+
+    def createOuts():
+        ob=TEC.__Outs.copy()
+        for key in ob:
+            ob[key]=[]
+        return ob
+    def __init__(self,typemodel="svmL",model_setting=None,spt=0.3,nlp=None):
+
+        self.model_setting=model_setting
+        self.isLoad=False
+        self.nlp=nlp
+
+
+    def toclean(self,txt):
+        try:
+            url="https://ansaltwyl256.pythonanywhere.com/api/nlp/"+txt
+            response = requests.get(url)
+
+            return response.json()['description']
+        except:
+            return "$"
+    def loadmodel(self):
+        mm=ModelPums()
+        matrck=pickle.load(open(self.model_setting.path_model,'rb'))
+        self.DES=pickle.load(open(self.model_setting.path_Qwords,'rb'))
+        mm.obData=matrck['obData']
+        mm.obVec=matrck['obVec']
+        mm.obSVML=matrck['obSVML']
+        mm.obSVMK=matrck['obSVMK']
+        mm.oblogict=matrck['oblogict']
+        mm.X=matrck['X']
+        mm.Y=matrck['Y']
+        mm.Classes=matrck['Classes']
+        self.obMP=mm
+        if self.model_setting.path_Qwords!="":
+            self.Qwords={}#pickle.load(open(model_setting.path_Qwords,'rb'))
+        else:
+            self.Qwords={}
+        self.detector = Translator()
+        # self.Splits(spt)
+        self.Model=self.obMP.obSVML
+
+        self.name=self.model_setting.name
+        self.pipeline= None
+        self.isLoad=True
+
+    def getLables(self):
+        return self.obMP.Classes
+
+    def is_found(self,words,ob):
+        sms=[]
+
+        ob=ob.lower().strip()
+        for w in words:
+            if w==ob:
+                return 1,w
+            sms.append(self.similarity(w,ob))
+        index=np.argmax(sms)
+        if sms[index]>0.7:
+            return 2, list(words)[index]
+
+        return 0,''
+
+    def is_found_K(self,words,ob):
+
+        ob=ob.lower().strip()
+        for w in words:
+            if w==ob:
+                return 1,w
+
+        return -1,''
+
+
+    def Training(self):
+        self.obMP.obSVMK.fit(self.obMP.X,self.obMP.Y)
+
+
+    def clean_dataT(self,data,typw='',is_input=False):
+        d,_=self.clean_dataAPI(data)
+        return d
+        datac=data
+        dock=[]
+        is_found= self.is_found if is_input==True else self.is_found_K
+
+        reg=r"([0-9])|(@\[A-Za-z0-9]+)|([^0-9A-Za-z \t])|(\w+:\/\/\S+)|^rt|http.+?"
+        for datac in data:
+            strr=str(datac)
+            strr=re.sub(reg, "", strr)
+            doc=self.nlp(strr)
+            disc=""
+            for token in doc:
+                if not token.is_punct and not token.is_stop and not token.is_space and token.is_alpha:
+                    if token.pos_=='ADJ' or  token.pos_=='NOUN' or token.pos_=='VERB':#token.pos_== typw:
+                        qk,key=is_found(self.Qwords,token.lemma_)
+                        if qk==1:
+                            disc=disc+self.Qwords[token.lemma_]+" "
+                        elif qk==2:
+                            disc=disc+self.Qwords[key]+" "
+                        elif qk==-1:
+                            disc=disc+token.lemma_+" "
+
+            disc=disc.lower().strip()
+            if len(disc)>0:
+                dock.append(disc)
+
+        return dock
+
+    def similarity(self,ob1,ob2):
+        ob1=ob1
+        ob2=ob2
+        nob1=self.nlp(ob1)
+        return nob1.similarity(self.nlp(ob2))
+
+    #-----------------#
+    def clean_data(self,data,typw='',is_input=False):
+        return self.clean_dataAPI(data)
+        datac=data
+        dock=[]
+        labels=[]
+        is_found= self.is_found if is_input==True else self.is_found_K
+        reg=r"([0-9])|(@\[A-Za-z0-9]+)|([^0-9A-Za-z \t])|(\w+:\/\/\S+)|^rt|http.+?"
+        for (datac,label) in data:
+            strr=str(datac)
+
+            strr=re.sub(reg, "", strr)
+            doc=self.nlp(strr)
+            disc=""
+            for token in doc:
+                if not token.is_punct and not token.is_stop and not token.is_space and token.is_alpha:
+                    if True: # token.pos_=='ADJ' or  token.pos_=='NOUN' or token.pos_=='VERB' :
+#                         disc=disc+token.lemma_+" "
+                        qk,key=is_found(self.Qwords,token.lemma_)
+#                         print(qk,key)
+                        if qk==1:
+                            disc=disc+self.Qwords[key]+" "
+                        elif qk==2:
+                            disc=disc+self.Qwords[key]+" "
+                        elif qk==-1:
+                            disc=disc+token.lemma_+" "
+
+            if len(disc)>2:
+                dock.append(disc.strip())
+                labels.append(label)
+        return dock,labels
+ #-----------------#
+    def clean_dataAPI(self,data,typw='',is_input=False):
+        txt=self.toclean(data)
+        if txt !="$":
+            return [txt],6
+
+
+        reg=r"([0-9])|(@\[A-Za-z0-9]+)|([^0-9A-Za-z \t])|(\w+:\/\/\S+)|^rt|http.+?"
+
+        strr=str(data)
+
+        strr=re.sub(reg, "", strr)
+        return [strr],6
+    def setPipeline(self,model=None):
+        self.pipeline=model
+    def to_tran(self,text,dest='en'):
+        ff=True
+        c=0
+
+        while ff:
+
+
+            try:
+                t=self.detector.translate(str(text),dest=dest)
+                ff=False
+                text=t.text
+            except:
+                c+=1
+                if c==20:
+                    ff=False
+                    print(' no connenet  Tr')
+
+        return text
+
+    def Predict_ALL(self,description,istrans=False):
+        if istrans:
+            description=self.to_tran(description)
+
+
+        if self.pipeline is not None:
+            text_output,_,outs=self.pipeline.Predict_ALL(description)
+            for key in outs:
+                text_output=text_output+'--'+ outs[key]
+        else:
+            text_output=''
+
+
+
+
+        mx,outs=self.get_ptedict_proba(description+' '+text_output)
+
+        return text_output,mx,outs
+
+
+    def predictAPI(self,description,is_input=False,istrans=False):
+        if istrans:
+            description=self.to_tran(description)
+
+        clean_description,_=self.clean_dataAPI(description,'',is_input=is_input)
+
+        try:
+            features=self.obMP.obVec.transform(clean_description)
+            yp=self.Model.predict(features)
+            txttec=self.obMP.Classes[yp[0]]
+            dis=self.DES[txttec]
+        except:
+            txttec='No'
+            dis=" ....."
+        return txttec,dis
+    def predict(self,description,is_input=False,istrans=False):
+        if istrans:
+            description=self.to_tran(description)
+
+        clean_description,_=self.clean_data([(description,' ')],'',is_input=is_input)
+
+        try:
+            features=self.obMP.obVec.transform(clean_description)
+            yp=self.Model.predict(features)
+            txttec=self.obMP.Classes[yp[0]]
+        except:
+            txttec='No'
+        return txttec
+
+    def ptedict_proba(self,description,mx=[],is_input=False,istrans=False):
+        if istrans:
+            description=self.to_tran(description)
+
+        clean_description,_=self.clean_data([(description,' ')],'',is_input=is_input)
+        try:
+            features=self.obMP.obVec.transform(clean_description)
+            mx=self.Model.predict_proba(features)
+            print(np.int16(mx*100))
+            yp=np.argmax(mx)
+            print(yp)
+
+            txttec='Technique : '+ self.obMP.Classes[yp]
+        except:
+            txttec='No Found technique ...! (^_^)'
+        return txttec
+
+
+
+    def get_ptedict_proba(self,description,mx=[]):
+        clean_description,_=self.clean_data([(description,' ')],'')
+
+        try:
+            features=self.obMP.obVec.transform(clean_description)
+            mx=self.obMP.obSVML.predict_proba(features)
+            yk=self.obMP.obSVMK.predict(features)
+
+
+         #   yp=np.argmax(mx)
+
+
+            outputs={'svmK':self.obMP.Classes[yk[0]]}
+        except:
+            txttec='No Found technique ...! (^_^)'
+            outputs={}
+        return mx,outputs
+
+    def get_ptedict_threemodel(self,description):
+        clean_description,_=self.clean_data([(description,' ')],'')
+
+        try:
+            features=self.obMP.obVec.transform(clean_description)
+            yl=self.obMP.obSVML.predict(features)
+            yk=self.obMP.obSVMK.predict(features)
+            ym=self.obMP.oblogict.predict(features)
+
+
+            outputs={'svmL':self.obMP.Classes[yl[0]],
+                     'svmK':self.obMP.Classes[yk[0]],
+                      'logstick':self.obMP.Classes[ym[0]]
+                    }
+        except:
+            print('No Found technique ...! (^_^)' )
+            outputs={}
+        return outputs
+
+
+    def verification(self,inputs=[],outputs=[]):
+        out_prodect=TEC.createOuts()
+        unprocess=0
+        meta={"tf":TEC.createOuts(),"num":TEC.createOuts()}
+        names=list(self.obMP.Classes)
+        for i in range(len(outputs)):
+            try:
+                outs=self.get_ptedict_threemodel(inputs[i])
+                target=outputs[i].strip()
+                names.index(target)
+                outs['target']=target
+
+
+                for  key in outs:
+
+                    out_prodect[key].append(outs[key])
+                    meta['tf'][key].append(int(outs[key]==target))
+                    meta['num'][key].append(names.index(outs[key]))
+
+
+
+
+            except :
+                unprocess+=1
+
+        scores={}
+        for key in  meta['num']:
+            if key!='target':
+                scores[key]=self.valmodel(meta['num']['target'],meta['num'][key],' model '+key)
+
+
+        return out_prodect,meta,scores
+    def valmodel(self,y,yp,titel=" "):
+        print('---------------'+titel+'------------------------' )
+        cr=classification_report(y, yp)
+        print(cr)
+        scores={}
+        scores['accuracy']=accuracy_score(y, yp)
+        scores['f1_score']=f1_score(y, yp, average="macro")
+        scores['precision']=precision_score(y, yp, average="macro")
+        scores['recall']=recall_score(y, yp, average="macro")
+        return {'smmray':cr,'scores':scores}
+    #----------------------
+    def ChangeModel(self,ob=None):
+        if ob==None:return
+        if type(ob) is not str:
+            self.Model=ob
+        else :
+            if ob=='svmL':
+                self.Model=self.obMP.obSVML
+            elif ob=='svmK':
+                self.Model=self.obMP.obSVMK
+            else:
+                self.Model=self.obMP.oblogict
+
+   #------------------------------
+
+    def Search(self):
+        txt=input('Enter any text :')
+        print('Technique:'+ self.predict(txt))
+
+
+    def Info_Models(self):
+        print('Number Data is ',self.obMP.X.shape)
+        print('Number of classes :',len(self.obMP.Classes))
+        print ('---------simples -------------------')
+        n=len(self.obMP.Classes)
+        f=n%2
+        n=n-f
+        for i in range(0,n,2):
+            print( (self.obMP.Classes[i],  np.sum(np.int16(self.obMP.Y==i))),'------------------',(self.obMP.Classes[i+1],  np.sum(np.int16(self.obMP.Y==i+1))))
+
+        if f==1: print( (self.obMP.Classes[i+2],  np.sum(np.int16(self.obMP.Y==i+2))))
+
+    def DlistModel(self):
+        print ('SVC(kernel=\'linear\')-> svmL')
+        print('LinearSVC(C=1.0) -> svmK ')
+        print('LogisticRegression() -> logic')

ASG.API/ModelsObs.py

@@ -0,0 +1,8 @@
+from ModelTEC import *
+
+import pickle
+from TypeModels import TypeModel
+from BasePath import BASEPATH
+
+
+MST=TEC(typemodel="svmL",model_setting=TypeModel['technique'])

ASG.API/TTs.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e6d068bd7128bf11f9d539266ecf0510582bef0a1f4a1c79e8be750765454359
+size 2075

ASG.API/TecModel_API.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38cc340c52bdad72ec621acfee3dbc7e0dd9c276f19be4c8837c8d582225320a
+size 22410842

ASG.API/TypeModels.py

@@ -0,0 +1,80 @@
+class ModelSetting:
+    def __init__(self,name="",path_model="",path_Qwords=""):
+        self.name=name
+        self.path_model=path_model
+        self.path_Qwords=path_Qwords
+
+from BasePath import BASEPATH
+
+TypeModel={
+    'group':ModelSetting(name='Group',path_model=BASEPATH+"groupModel_API.pkl",path_Qwords=BASEPATH+"listdesgroupModel_API.pkl"),
+    'technique':ModelSetting(name='Technique',path_model=BASEPATH+"TecModel_API.pkl",path_Qwords=BASEPATH+"listdesTecModel_API.pkl"),
+    'software':ModelSetting(name='Software',path_model=BASEPATH+"sofwareModel_API.pkl",path_Qwords=BASEPATH+"listdessofwareModel_API.pkl")
+}
+
+
+
+FormModels={TypeModel['group'].name:
+             {'name':'FormGroupS',
+               'coldata' : [
+                            {"text": "num", "stretch": False,"width":50},
+
+                            "Tactic Name"
+                            ,
+                            "Technique Name",
+                            "Group Name",
+                            "Score "
+                            ]
+             ,
+             'msgs':['''• Refers to the search for the highest technique similar to the nature of the specific input.''',
+                  '''• Determining the threshold, which is a value between 0 and 1 that allows the width of more than one technique that can be similar to the nature of the input.  ''',
+                  ''' Techniques can be searched in two ways''',
+                  '''The table shows each technique with the tactic to which it belongs and the score that determines the good prediction probability value in percentage. ''',
+                  '''The interface allows the user to enter a description of a technique or a group of techniques that serve the same purpose. The user can also enter the program that uses the technique and predicts the most appropriate technique.'''
+                 ]
+               ,'placeholder':' , softwares and groups '
+             },
+            #2
+            TypeModel['technique'].name:
+             {'name':'FormTechniqueS',
+               'coldata' : [
+                            {"text": "num", "stretch": False,"width":50},
+
+                            "Tactic Name"
+                            ,
+                            "Technique Name",
+
+                            "Score "
+                            ]
+             ,
+             'msgs':['''• Refers to the search for the highest technique similar to the nature of the specific input.''',
+                  '''• Determining the threshold, which is a value between 0 and 1 that allows the width of more than one technique that can be similar to the nature of the input.  ''',
+                  ''' Techniques can be searched in two ways''',
+                  '''The table shows each technique with the tactic to which it belongs and the score that determines the good prediction probability value in percentage. ''',
+                  '''The interface allows the user to enter a description of a technique or a group of techniques that serve the same purpose. The user can also enter the program that uses the technique and predicts the most appropriate technique.'''
+                 ]
+              ,'placeholder':'.'
+             }
+
+
+
+         #3
+            ,TypeModel['software'].name:
+             {'name':'FormTechniqueS',
+               'coldata' : [
+                        {"text": "num", "stretch": False,"width":50},
+                        "Software Name"
+                        ,
+                        "Score "
+                    ]
+             ,
+             'msgs':['''• Refers to the search for the highest program similar to the nature of the selected input text.''',
+                  '''• Setting the threshold, which is a value between 0 and 1 that allows the display of more than one program that can be similar to the nature of the text entered. ''',
+                 '''The program can be searched in two ways ''',
+                 '''The table shows the name of the program and the score that determines the probability value of a good forecast, which is a percentage value''',
+                 '''The interface allows the user to enter a description of a program or a group of programs within the MITER ATT & CK that serves the same purpose. The user can also enter techniques that may be within the series of program scenarios.''']
+
+             ,'placeholder':' and softwares'
+             },
+
+    }

ASG.API/dataSM.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a4bd82ccd036a2882a34ab3f15b0d946c552968d424993b76c91290d9758280d
+size 133931

ASG.API/groupModel_API.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62fdd85ebbf478200e5b62e6d4d0d14b0e277d4246529fcb1000e570f6da8d80
+size 661391

ASG.API/listdesTecModel_API.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d922166eea668091cece614ed1d70ccd76de977bbe36e4631def93c11746b617
+size 81302

ASG.API/listdesgroupModel_API.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f83dd8e6e08e1a184113379461dc9fe9f9b9b2071e8165c03435ef1d27d0e1e
+size 10576

ASG.API/listdessofwareModel_API.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33ec00988f89fa6d4a76ea2e08fa580daf2230f2c4d61a21e06f7c1c64ed38a2
+size 9525

ASG.API/sofwareModel_API.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df5fa4fa7d4879c0c6bc3effb79e7231749f550203a2242bf00218e50181bc78
+size 1199576

ASG.API/tecbyTectics.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1eef0005b2f4ad1c2053c1a1052353b25ed20e358821e2ca474791f189655f72
+size 2160