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'))
