def __init__(self, teacher: Teacher): super().__init__(teacher) # Observation table (S, E, T) # NotifierSets raise a flag once they're modified # This is used to avoid repeating expensive computations self.S = NotifierSet() self.E = NotifierSet() # S starts with the empty string self.S.add(tuple()) self.T = {} # Alphabet A self.A = set([(x, ) for x in teacher.get_alphabet()]) # at the start, E = A for a in self.A: self.E.add(a) # Don't redo expensive computations unless necessary self._mem = {} self._watch = {} # Checkpoints? self._save_checkpoints = False self._checkpointname = None self._checkpointdir = None
def test_lstar_wmethod(self): eqc = WmethodEquivalenceChecker(self.dfa, m=len(self.dfa.get_states())) teacher = Teacher(self.dfa, eqc) learner = LStarDFALearner(teacher) hyp = learner.run() equivalent, _ = eqc.test_equivalence(hyp) self.assertTrue(equivalent) self.assertEqual( len(self.dfa.get_states()), len(hyp.get_states()), )
def test_ttt_bruteforce(self): eqc = BFEquivalenceChecker(self.dfa, max_depth=len(self.dfa.get_states())) teacher = Teacher(self.dfa, eqc) learner = TTTDFALearner(teacher) hyp = learner.run() equivalent, _ = WmethodEquivalenceChecker(self.dfa, m=len(self.dfa.get_states())).test_equivalence(hyp) self.assertTrue(equivalent) self.assertEqual( len(self.dfa.get_states()), len(hyp.get_states()), )
def test_lstar_bruteforce(self): eqc = BFEquivalenceChecker(self.mm, max_depth=len(self.mm.get_states())) teacher = Teacher(self.mm, eqc) learner = LStarMealyLearner(teacher) hyp = learner.run() equivalent, _ = WmethodEquivalenceChecker( self.mm, m=len(self.mm.get_states())).test_equivalence(hyp) self.assertTrue(equivalent) self.assertEqual( len(self.mm.get_states()), len(hyp.get_states()), )
def __init__(self, teacher: Teacher): super().__init__(teacher) # # # Access sequences S + state bookkeeping # self.S = {tuple(): State("s0")} # Discrimination tree self.DTree = DTree(self.S[tuple()]) # Query cache self.T = {} # Alphabet A self.A = set([(x, ) for x in teacher.get_alphabet()])
def __init__(self, teacher: Teacher): super().__init__(teacher) # Observation table (S, E, T) self.S = set() self.E = set() self.S.add(tuple()) self.E.add(tuple()) self.T = {} # Alphabet A self.A = set([(x, ) for x in teacher.get_alphabet()])
def test_lstar_wmethod(self): for name, system in self.systems.items(): n_states = len(system.get_states()) sul = DictCache(system) eqc = WmethodEquivalenceChecker(sul, m=n_states) teacher = Teacher(sul, eqc) learner = LStarMealyLearner(teacher) hyp = learner.run() equivalent, _ = eqc.test_equivalence(hyp) self.assertTrue(equivalent) self.assertEqual( n_states, len(hyp.get_states()), )
def test_TTT_wmethod(self): for name, system in self.systems.items(): n_states = len(system.get_states()) sul = DictCache(system) eqc = SmartWmethodEquivalenceChecker(sul, horizon=6, stop_on={"error"}, order_type='ce count') teacher = Teacher(sul, eqc) learner = TTTMealyLearner(teacher) hyp = learner.run() equivalent, _ = eqc.test_equivalence(hyp) self.assertTrue(equivalent) self.assertEqual( n_states, len(hyp.get_states()), )
from stmlearn.equivalencecheckers import WmethodEquivalenceChecker from stmlearn.learners import TTTMealyLearner from stmlearn.teachers import Teacher from stmlearn.util import MakeRandomMealyMachine ## Randomly generate a mealy machine and learn from it # input alphabet A = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'] # output alphabet O = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10'] # Generate a mealy machine and try to minimize it # Minimization is kinda broken so may sometimes result in non-minimal mealy machines # In this case the assertion below will fail mm = MakeRandomMealyMachine(100, A, O, minimize=True) # Use the W method equivalence checker eqc = WmethodEquivalenceChecker(mm, m=len(mm.get_states())) teacher = Teacher(mm, eqc) learner = TTTMealyLearner(teacher) hyp = learner.run(show_intermediate=False) assert len(hyp.get_states()) == len(mm.get_states()) hyp.render_graph(tempfile.mktemp('.gv')) print("done")
import tempfile from stmlearn.equivalencecheckers import BFEquivalenceChecker from stmlearn.suls import RegexMachine from stmlearn.teachers import Teacher from stmlearn.learners import LStarDFALearner # Set up a SUT using regex sm = RegexMachine('(bb)*(aa)*(bb)*') # We are using the brute force equivalence checker eqc = BFEquivalenceChecker(sm, max_depth=15) # Set up the teacher, with the system under learning and the equivalence checker teacher = Teacher(sm, eqc) # Set up the learner who only talks to the teacher learner = LStarDFALearner(teacher) # Get the learners hypothesis hyp = learner.run() # Draw the learned dfa hyp.render_graph(tempfile.mktemp('.gv'))
import tempfile from stmlearn.equivalencecheckers import WmethodEquivalenceChecker from stmlearn.equivalencecheckers._wmethod import SmartWmethodEquivalenceChecker from stmlearn.learners import LStarMealyLearner, TTTMealyLearner from stmlearn.suls import MealyState, MealyMachine from stmlearn.teachers import Teacher from stmlearn.suls.caches.dictcache import DictCache from TLSSUL import TLSSUL from TLSAttackerMapper import TLSAttackerMapper sul = DictCache( storagepath='cache/1_0_1g', saveinterval=1, sul=TLSSUL( TLSAttackerMapper( tlsa_path= '/home/tom/projects/tlsattacker/TLS-Attacker/apps/TLS-Client.jar') )).load() # Use the W method equivalence checker eqc = SmartWmethodEquivalenceChecker(sul, horizon=2) teacher = Teacher(sul, eqc) # We are learning a mealy machine learner = LStarMealyLearner(teacher) hyp = learner.run(show_intermediate=True) hyp.render_graph(tempfile.mktemp('.gv'))