From 1836551047997a2d11d342198d7374be2d84c1c3 Mon Sep 17 00:00:00 2001 From: Kostis Sagonas Date: Sat, 1 Mar 2025 09:15:46 +0100 Subject: [PATCH] Update to the latest protocol-state-fuzzer which uses generics (#107) * Update inputs, outputs and add two new classes * Update mapper related classes * Update sul related classes * Update alphabet pojo * Update outer classes * Update setup_fuzzer pointing to generics branch * Update according to generic machine model * Introduce EdhocMapperComposer and simplify some things * Simplify EdhocSul * Use anonymous classes for empty SulAdapterConfig * Update protocol-state-fuzzer setup * Bump to the latest commit (21/2/2025) of PSF --------- Co-authored-by: actyp --- scripts/setup_fuzzer.sh | 5 +- .../edhocfuzzer/EdhocDotProcessor.java | 6 +- .../protocolfuzzing/edhocfuzzer/Main.java | 2 +- .../edhocfuzzer/MultiBuilder.java | 30 +++-- .../learner/EdhocAlphabetPojoXml.java | 15 ++- .../components/sul/core/EdhocSul.java | 105 +++++++++++------- .../components/sul/core/EdhocSulBuilder.java | 8 +- .../sul/core/config/EdhocSulClientConfig.java | 11 +- .../sul/core/config/EdhocSulServerConfig.java | 11 +- .../messages/EdhocProtocolMessage.java | 3 +- .../config/EdhocMapperConnectionConfig.java | 3 +- .../sul/mapper/context/ClientMapperState.java | 7 +- .../mapper/context/EdhocExecutionContext.java | 19 ++++ .../sul/mapper/context/EdhocMapperState.java | 18 +-- .../sul/mapper/context/ServerMapperState.java | 7 +- .../sul/mapper/mappers/EdhocInputMapper.java | 21 ++-- .../mapper/mappers/EdhocMapperComposer.java | 26 +++++ .../sul/mapper/mappers/EdhocOutputMapper.java | 87 +++++++++------ .../symbols/inputs/CoapAppMessageInput.java | 8 +- .../symbols/inputs/CoapEmptyMessageInput.java | 8 +- .../inputs/EdhocErrorMessageInput.java | 8 +- .../sul/mapper/symbols/inputs/EdhocInput.java | 31 +++--- .../symbols/inputs/EdhocMessage1Input.java | 17 +-- .../symbols/inputs/EdhocMessage2Input.java | 8 +- .../symbols/inputs/EdhocMessage3Input.java | 8 +- .../inputs/EdhocMessage3OscoreAppInput.java | 12 +- .../symbols/inputs/EdhocMessage4Input.java | 8 +- .../symbols/inputs/OscoreAppMessageInput.java | 8 +- .../mapper/symbols/outputs/EdhocOutput.java | 26 +++++ .../symbols/outputs/EdhocOutputBuilder.java | 10 ++ .../symbols/outputs/EdhocOutputChecker.java | 33 ++++-- .../symbols/outputs/MessageOutputType.java | 12 +- 32 files changed, 361 insertions(+), 220 deletions(-) create mode 100644 src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/context/EdhocExecutionContext.java create mode 100644 src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/mappers/EdhocMapperComposer.java create mode 100644 src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/outputs/EdhocOutput.java create mode 100644 src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/outputs/EdhocOutputBuilder.java diff --git a/scripts/setup_fuzzer.sh b/scripts/setup_fuzzer.sh index 34bf1479..7db1cbc8 100755 --- a/scripts/setup_fuzzer.sh +++ b/scripts/setup_fuzzer.sh @@ -8,15 +8,14 @@ readonly BASE_DIR setup_psf() { # setup protocol-state-fuzzer library - # this is the commit _just_ before Generics were introduced - CHECKOUT="398c9bc526c94294569e46286d43692b5171c175" + CHECKOUT="d4d5730bbd9f7f93d8e9eee5165592586e03c833" set -e cd "${BASE_DIR}" git clone "https://github.com/protocol-fuzzing/protocol-state-fuzzer.git" cd protocol-state-fuzzer git checkout ${CHECKOUT} - mvn install -DskipTests + bash ./install.sh cd "${BASE_DIR}" rm -rf ./protocol-state-fuzzer/ diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/EdhocDotProcessor.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/EdhocDotProcessor.java index 753cab2a..d45b0b9d 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/EdhocDotProcessor.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/EdhocDotProcessor.java @@ -14,7 +14,11 @@ public class EdhocDotProcessor { private static final Logger LOGGER = LogManager.getLogger(); - public static void beautify(LearnerResult learnerResult) { + public static void beautify(LearnerResult learnerResult) { + if (learnerResult.isFromTest()) { + return; + } + if (learnerResult.isEmpty()) { LOGGER.warn("Provided empty LearnerResult"); return; diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/Main.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/Main.java index 065b69c0..62e97580 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/Main.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/Main.java @@ -9,7 +9,7 @@ public static void main(String[] args) { MultiBuilder mb = new MultiBuilder(); String[] parentLoggers = {Main.class.getPackageName()}; - CommandLineParser commandLineParser = new CommandLineParser(mb, mb, mb, mb); + CommandLineParser commandLineParser = new CommandLineParser<>(mb, mb, mb, mb); commandLineParser.setExternalParentLoggers(parentLoggers); commandLineParser.parse(args, true, List.of(EdhocDotProcessor::beautify)); diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/MultiBuilder.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/MultiBuilder.java index 4b190ca0..9e78a23b 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/MultiBuilder.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/MultiBuilder.java @@ -5,10 +5,14 @@ import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.config.EdhocSulClientConfig; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.config.EdhocSulServerConfig; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.config.EdhocMapperConfig; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.EdhocExecutionContext; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.inputs.EdhocInput; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs.EdhocOutput; import com.github.protocolfuzzing.protocolstatefuzzer.components.learner.alphabet.AlphabetBuilder; import com.github.protocolfuzzing.protocolstatefuzzer.components.learner.alphabet.AlphabetBuilderStandard; import com.github.protocolfuzzing.protocolstatefuzzer.components.learner.alphabet.xml.AlphabetSerializerXml; import com.github.protocolfuzzing.protocolstatefuzzer.components.learner.config.LearnerConfigStandard; +import com.github.protocolfuzzing.protocolstatefuzzer.components.learner.statistics.MealyMachineWrapper; import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.SulBuilder; import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.SulWrapper; import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.SulWrapperStandard; @@ -24,21 +28,27 @@ import com.github.protocolfuzzing.protocolstatefuzzer.statefuzzer.core.config.StateFuzzerServerConfigStandard; import com.github.protocolfuzzing.protocolstatefuzzer.statefuzzer.testrunner.core.TestRunner; import com.github.protocolfuzzing.protocolstatefuzzer.statefuzzer.testrunner.core.TestRunnerBuilder; +import com.github.protocolfuzzing.protocolstatefuzzer.statefuzzer.testrunner.core.TestRunnerStandard; import com.github.protocolfuzzing.protocolstatefuzzer.statefuzzer.testrunner.core.config.TestRunnerConfigStandard; import com.github.protocolfuzzing.protocolstatefuzzer.statefuzzer.testrunner.core.config.TestRunnerEnabler; import com.github.protocolfuzzing.protocolstatefuzzer.statefuzzer.testrunner.timingprobe.TimingProbe; import com.github.protocolfuzzing.protocolstatefuzzer.statefuzzer.testrunner.timingprobe.TimingProbeBuilder; +import com.github.protocolfuzzing.protocolstatefuzzer.statefuzzer.testrunner.timingprobe.TimingProbeStandard; import com.github.protocolfuzzing.protocolstatefuzzer.statefuzzer.testrunner.timingprobe.config.TimingProbeConfigStandard; import com.github.protocolfuzzing.protocolstatefuzzer.statefuzzer.testrunner.timingprobe.config.TimingProbeEnabler; -public class MultiBuilder implements StateFuzzerConfigBuilder, StateFuzzerBuilder, TestRunnerBuilder, TimingProbeBuilder { +public class MultiBuilder implements + StateFuzzerConfigBuilder, + StateFuzzerBuilder>, + TestRunnerBuilder, + TimingProbeBuilder { - protected AlphabetBuilder alphabetBuilder = new AlphabetBuilderStandard( - new AlphabetSerializerXml<>(EdhocAlphabetPojoXml.class) + protected AlphabetBuilder alphabetBuilder = new AlphabetBuilderStandard<>( + new AlphabetSerializerXml(EdhocInput.class, EdhocAlphabetPojoXml.class) ); - protected SulBuilder sulBuilder = new EdhocSulBuilder(); - protected SulWrapper sulWrapper = new SulWrapperStandard(); + protected SulBuilder sulBuilder = new EdhocSulBuilder(); + protected SulWrapper sulWrapper = new SulWrapperStandard<>(); @Override public StateFuzzerClientConfig buildClientConfig() { @@ -61,19 +71,19 @@ public StateFuzzerServerConfig buildServerConfig() { } @Override - public StateFuzzer build(StateFuzzerEnabler stateFuzzerEnabler) { - return new StateFuzzerStandard( - new StateFuzzerComposerStandard(stateFuzzerEnabler, alphabetBuilder, sulBuilder, sulWrapper).initialize() + public StateFuzzer> build(StateFuzzerEnabler stateFuzzerEnabler) { + return new StateFuzzerStandard<>( + new StateFuzzerComposerStandard<>(stateFuzzerEnabler, alphabetBuilder, sulBuilder, sulWrapper).initialize() ); } @Override public TestRunner build(TestRunnerEnabler testRunnerEnabler) { - return new TestRunner(testRunnerEnabler, alphabetBuilder, sulBuilder, sulWrapper).initialize(); + return new TestRunnerStandard<>(testRunnerEnabler, alphabetBuilder, sulBuilder, sulWrapper).initialize(); } @Override public TimingProbe build(TimingProbeEnabler timingProbeEnabler) { - return new TimingProbe(timingProbeEnabler, alphabetBuilder, sulBuilder, sulWrapper).initialize(); + return new TimingProbeStandard<>(timingProbeEnabler, alphabetBuilder, sulBuilder, sulWrapper).initialize(); } } diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/learner/EdhocAlphabetPojoXml.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/learner/EdhocAlphabetPojoXml.java index 15747b9f..964aaecd 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/learner/EdhocAlphabetPojoXml.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/learner/EdhocAlphabetPojoXml.java @@ -2,14 +2,17 @@ import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.inputs.*; import com.github.protocolfuzzing.protocolstatefuzzer.components.learner.alphabet.xml.AlphabetPojoXml; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.abstractsymbols.AbstractInput; -import jakarta.xml.bind.annotation.*; +import jakarta.xml.bind.annotation.XmlAccessType; +import jakarta.xml.bind.annotation.XmlAccessorType; +import jakarta.xml.bind.annotation.XmlElement; +import jakarta.xml.bind.annotation.XmlElements; +import jakarta.xml.bind.annotation.XmlRootElement; import java.util.List; @XmlRootElement(name = "alphabet") @XmlAccessorType(XmlAccessType.FIELD) -public class EdhocAlphabetPojoXml extends AlphabetPojoXml { +public class EdhocAlphabetPojoXml extends AlphabetPojoXml { @XmlElements(value = { @XmlElement(type = EdhocMessage1Input.class, name = "EdhocMessage1Input"), @XmlElement(type = EdhocMessage2Input.class, name = "EdhocMessage2Input"), @@ -21,16 +24,16 @@ public class EdhocAlphabetPojoXml extends AlphabetPojoXml { @XmlElement(type = CoapAppMessageInput.class, name = "CoapAppMessageInput"), @XmlElement(type = CoapEmptyMessageInput.class, name = "CoapEmptyMessageInput") }) - protected List inputs; + protected List inputs; public EdhocAlphabetPojoXml() {} - public EdhocAlphabetPojoXml(List inputs) { + public EdhocAlphabetPojoXml(List inputs) { this.inputs = inputs; } @Override - public List getInputs(){ + public List getInputs(){ return inputs; } } diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/core/EdhocSul.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/core/EdhocSul.java index 0c31d25b..002690ea 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/core/EdhocSul.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/core/EdhocSul.java @@ -3,25 +3,25 @@ import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.config.EdhocSulClientConfig; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.config.EdhocMapperConfig; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.config.EdhocMapperConnectionConfig; -import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.config.ProtocolVersion; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.connectors.ClientMapperConnector; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.connectors.EdhocMapperConnector; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.connectors.ServerMapperConnector; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.ClientMapperState; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.EdhocExecutionContext; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.EdhocMapperState; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.ServerMapperState; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.mappers.EdhocInputMapper; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.mappers.EdhocMapperComposer; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.mappers.EdhocOutputMapper; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.inputs.EdhocInput; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs.EdhocOutput; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs.EdhocOutputBuilder; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs.EdhocOutputChecker; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs.MessageOutputType; import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.AbstractSul; +import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.SulAdapter; import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.config.SulConfig; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.Mapper; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.abstractsymbols.AbstractInput; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.abstractsymbols.AbstractOutput; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.config.MapperConfig; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.context.ExecutionContextStepped; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.mappers.MapperComposer; +import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.sulwrappers.DynamicPortProvider; import com.github.protocolfuzzing.protocolstatefuzzer.utils.CleanupTasks; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; @@ -30,18 +30,23 @@ import java.io.IOException; import java.util.concurrent.TimeUnit; -public class EdhocSul extends AbstractSul { +public class EdhocSul implements AbstractSul { private static final Logger LOGGER = LogManager.getLogger(); - protected ExecutionContextStepped executionContextStepped; - protected ProtocolVersion protocolVersion; + + protected SulConfig sulConfig; + protected CleanupTasks cleanupTasks; + protected EdhocMapperConfig edhocMapperConfig; + protected EdhocMapperComposer edhocMapperComposer; + protected EdhocExecutionContext edhocExecutionContext; protected Long originalTimeout; protected EdhocMapperState edhocMapperState; protected EdhocMapperConnector edhocMapperConnector; protected boolean serverWaitForInitialMessageDone; public EdhocSul(SulConfig sulConfig, CleanupTasks cleanupTasks) { - super(sulConfig, cleanupTasks); - this.protocolVersion = ((EdhocMapperConfig) sulConfig.getMapperConfig()).getProtocolVersion(); + this.sulConfig = sulConfig; + this.cleanupTasks = cleanupTasks; + this.edhocMapperConfig = (EdhocMapperConfig) sulConfig.getMapperConfig(); this.originalTimeout = sulConfig.getResponseWait(); } @@ -68,7 +73,6 @@ public EdhocSul initialize() { } // The connector uses the californium standard configuration - EdhocMapperConfig edhocMapperConfig = (EdhocMapperConfig) sulConfig.getMapperConfig(); if (sulConfig.isFuzzingClient()){ this.edhocMapperConnector = new ServerMapperConnector(edhocMapperConfig.getHostCoapUri(), edhocMapperConfig.getEdhocCoapResource(), edhocMapperConfig.getAppCoapResource(), @@ -78,28 +82,51 @@ public EdhocSul initialize() { edhocMapperConfig.getAppCoapUri(), this.originalTimeout); } - this.mapper = buildMapper(sulConfig.getMapperConfig(), this.edhocMapperConnector); + this.edhocMapperComposer = new EdhocMapperComposer ( + new EdhocInputMapper(edhocMapperConfig, new EdhocOutputChecker(), edhocMapperConnector), + new EdhocOutputMapper(edhocMapperConfig, new EdhocOutputBuilder(), new EdhocOutputChecker(), edhocMapperConnector) + ); return this; } - protected Mapper buildMapper(MapperConfig mapperConfig, EdhocMapperConnector edhocMapperConnector) { - return new MapperComposer( - new EdhocInputMapper(mapperConfig, new EdhocOutputChecker(), edhocMapperConnector), - new EdhocOutputMapper(mapperConfig, edhocMapperConnector) - ); + @Override + public SulConfig getSulConfig() { + return sulConfig; + } + + @Override + public CleanupTasks getCleanupTasks() { + return cleanupTasks; + } + + @Override + public EdhocMapperComposer getMapper() { + return edhocMapperComposer; + } + + @Override + public void setDynamicPortProvider(DynamicPortProvider dynamicPortProvider) { + throw new RuntimeException("No dynamic port provider available"); + } + + @Override + public DynamicPortProvider getDynamicPortProvider() { + throw new RuntimeException("No dynamic port provider available"); + } + + @Override + public SulAdapter getSulAdapter() { + throw new RuntimeException("No sul adapter available"); } @Override public void pre() { LOGGER.debug("SUL 'pre' start"); - // mapper config - EdhocMapperConfig edhocMapperConfig = (EdhocMapperConfig) sulConfig.getMapperConfig(); - if (sulConfig.isFuzzingClient()) { ServerMapperConnector serverMapperConnector = (ServerMapperConnector) edhocMapperConnector; - edhocMapperState = new ServerMapperState(protocolVersion, edhocMapperConfig, cleanupTasks).initialize(serverMapperConnector); + edhocMapperState = new ServerMapperState(edhocMapperConfig, cleanupTasks).initialize(serverMapperConnector); serverWaitForInitialMessageDone = false; cleanupTasks.submit(serverMapperConnector::shutdown); @@ -115,10 +142,10 @@ public void pre() { } } else { ClientMapperConnector clientMapperConnector = (ClientMapperConnector) edhocMapperConnector; - edhocMapperState = new ClientMapperState(protocolVersion, edhocMapperConfig, cleanupTasks).initialize(clientMapperConnector); + edhocMapperState = new ClientMapperState(edhocMapperConfig, cleanupTasks).initialize(clientMapperConnector); } - this.executionContextStepped = new ExecutionContextStepped(edhocMapperState); + this.edhocExecutionContext = new EdhocExecutionContext(edhocMapperState); long startWait = sulConfig.getStartWait(); if (startWait > 0) { @@ -139,27 +166,23 @@ public void post() { } @Override - public AbstractOutput step(AbstractInput abstractInput) { + public EdhocOutput step(EdhocInput abstractInput) { // In case of server mapper, wait for initial message from client serverWaitForInitialMessage(); LOGGER.debug("SUL 'step' start"); - executionContextStepped.addStepContext(); - Mapper preferredMapper = abstractInput.getPreferredMapper(sulConfig); - if (preferredMapper == null) { - preferredMapper = this.mapper; - } + edhocExecutionContext.addStepContext(); - if (!executionContextStepped.isExecutionEnabled()) { - return ((MapperComposer) this.mapper).getOutputMapper().disabled(); + if (!edhocExecutionContext.isExecutionEnabled()) { + return edhocMapperComposer.getOutputMapper().disabled(); } - AbstractOutput abstractOutput = executeInput(abstractInput, preferredMapper); + EdhocOutput abstractOutput = executeInput(abstractInput); - if (abstractOutput.equals(AbstractOutput.disabled()) || !executionContextStepped.isExecutionEnabled()) { + if (edhocMapperComposer.getOutputChecker().isDisabled(abstractOutput) || !edhocExecutionContext.isExecutionEnabled()) { // this should lead to a disabled sink state - executionContextStepped.disableExecution(); + edhocExecutionContext.disableExecution(); } LOGGER.debug("SUL 'step' end"); @@ -167,7 +190,7 @@ public AbstractOutput step(AbstractInput abstractInput) { return abstractOutput; } - protected AbstractOutput executeInput(AbstractInput abstractInput, Mapper mapper) { + protected EdhocOutput executeInput(EdhocInput abstractInput) { boolean timeoutChanged = false; // handle timeout from extendedWait and from inputResponse @@ -180,7 +203,7 @@ protected AbstractOutput executeInput(AbstractInput abstractInput, Mapper mapper timeoutChanged = true; } - AbstractOutput abstractOutput = mapper.execute(abstractInput, executionContextStepped); + EdhocOutput abstractOutput = edhocMapperComposer.execute(abstractInput, edhocExecutionContext); // reset timeout if (timeoutChanged) { @@ -200,12 +223,11 @@ protected void serverWaitForInitialMessage() { return; } - MapperComposer mapperComposer = (MapperComposer) mapper; ServerMapperConnector serverMapperConnector = (ServerMapperConnector) edhocMapperConnector; - EdhocOutputChecker edhocOutputChecker = (EdhocOutputChecker) mapperComposer.getAbstractOutputChecker(); + EdhocOutputChecker edhocOutputChecker = edhocMapperComposer.getOutputChecker(); serverMapperConnector.waitForClientMessage(); - AbstractOutput abstractOutput = mapperComposer.getOutputMapper().receiveOutput(executionContextStepped); + EdhocOutput abstractOutput = edhocMapperComposer.getOutputMapper().receiveOutput(edhocExecutionContext); boolean isExpectedMessage = edhocOutputChecker.isMessage(abstractOutput, expectedMessageType); if (!isExpectedMessage) { @@ -216,4 +238,5 @@ protected void serverWaitForInitialMessage() { LOGGER.debug("Received {} from client", expectedMessageType); serverWaitForInitialMessageDone = true; } + } diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/core/EdhocSulBuilder.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/core/EdhocSulBuilder.java index 26e3a79b..17405bd5 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/core/EdhocSulBuilder.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/core/EdhocSulBuilder.java @@ -1,13 +1,17 @@ package com.github.protocolfuzzing.edhocfuzzer.components.sul.core; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.EdhocExecutionContext; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.inputs.EdhocInput; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs.EdhocOutput; import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.AbstractSul; import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.SulBuilder; import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.config.SulConfig; import com.github.protocolfuzzing.protocolstatefuzzer.utils.CleanupTasks; -public class EdhocSulBuilder implements SulBuilder { +public class EdhocSulBuilder implements SulBuilder{ @Override - public AbstractSul build(SulConfig sulConfig, CleanupTasks cleanupTasks) { + public AbstractSul + build(SulConfig sulConfig, CleanupTasks cleanupTasks) { return new EdhocSul(sulConfig, cleanupTasks).initialize(); } } diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/core/config/EdhocSulClientConfig.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/core/config/EdhocSulClientConfig.java index c5354e37..fb2d431d 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/core/config/EdhocSulClientConfig.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/core/config/EdhocSulClientConfig.java @@ -2,15 +2,14 @@ import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.config.EdhocMapperConfig; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.config.EdhocMapperConnectionConfig; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.config.SulAdapterConfigEmpty; +import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.config.SulAdapterConfig; import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.config.SulClientConfigStandard; import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.config.MapperConfig; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.config.MapperConnectionConfig; import org.eclipse.californium.elements.config.Configuration; public class EdhocSulClientConfig extends SulClientConfigStandard { public EdhocSulClientConfig(EdhocMapperConfig edhocMapperConfig) { - super(edhocMapperConfig, new SulAdapterConfigEmpty()); + super(edhocMapperConfig, new SulAdapterConfig(){}); } @Override @@ -20,7 +19,9 @@ public MapperConfig getMapperConfig() { } @Override - public void applyDelegate(MapperConnectionConfig config) { - Configuration.setStandard(((EdhocMapperConnectionConfig) config).getConfiguration()); + public void applyDelegate(MC config) { + if (config instanceof EdhocMapperConnectionConfig) { + Configuration.setStandard(EdhocMapperConnectionConfig.class.cast(config).getConfiguration()); + } } } diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/core/config/EdhocSulServerConfig.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/core/config/EdhocSulServerConfig.java index 28e34da1..4ae3ad46 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/core/config/EdhocSulServerConfig.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/core/config/EdhocSulServerConfig.java @@ -2,15 +2,14 @@ import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.config.EdhocMapperConfig; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.config.EdhocMapperConnectionConfig; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.config.SulAdapterConfigEmpty; +import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.config.SulAdapterConfig; import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.config.SulServerConfigStandard; import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.config.MapperConfig; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.config.MapperConnectionConfig; import org.eclipse.californium.elements.config.Configuration; public class EdhocSulServerConfig extends SulServerConfigStandard { public EdhocSulServerConfig(EdhocMapperConfig edhocMapperConfig) { - super(edhocMapperConfig, new SulAdapterConfigEmpty()); + super(edhocMapperConfig, new SulAdapterConfig(){}); } @Override @@ -20,7 +19,9 @@ public MapperConfig getMapperConfig() { } @Override - public void applyDelegate(MapperConnectionConfig config) { - Configuration.setStandard(((EdhocMapperConnectionConfig) config).getConfiguration()); + public void applyDelegate(MC config) { + if (config instanceof EdhocMapperConnectionConfig) { + Configuration.setStandard(EdhocMapperConnectionConfig.class.cast(config).getConfiguration()); + } } } diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/core/protocol/messages/EdhocProtocolMessage.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/core/protocol/messages/EdhocProtocolMessage.java index 7a7d8e37..0b793767 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/core/protocol/messages/EdhocProtocolMessage.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/core/protocol/messages/EdhocProtocolMessage.java @@ -1,11 +1,10 @@ package com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.MessageProcessorPersistent; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.protocol.ProtocolMessage; import org.eclipse.californium.core.coap.CoAP; import org.eclipse.californium.edhoc.Constants; -public abstract class EdhocProtocolMessage implements ProtocolMessage { +public abstract class EdhocProtocolMessage { // payload of the message protected byte[] payload; diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/config/EdhocMapperConnectionConfig.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/config/EdhocMapperConnectionConfig.java index 7f4d3966..5741f6a1 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/config/EdhocMapperConnectionConfig.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/config/EdhocMapperConnectionConfig.java @@ -1,12 +1,11 @@ package com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.config; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.config.MapperConnectionConfig; import org.eclipse.californium.core.config.CoapConfig; import org.eclipse.californium.elements.config.Configuration; import java.io.InputStream; -public class EdhocMapperConnectionConfig implements MapperConnectionConfig { +public class EdhocMapperConnectionConfig { private static boolean registered = false; private static void register() { if (!registered) { diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/context/ClientMapperState.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/context/ClientMapperState.java index 53370741..9bfeb9f1 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/context/ClientMapperState.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/context/ClientMapperState.java @@ -1,15 +1,12 @@ package com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.config.EdhocMapperConfig; -import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.config.ProtocolVersion; import com.github.protocolfuzzing.protocolstatefuzzer.utils.CleanupTasks; public class ClientMapperState extends EdhocMapperState { - public ClientMapperState(ProtocolVersion protocolVersion, EdhocMapperConfig edhocMapperConfig, - CleanupTasks cleanupTasks) { - super(protocolVersion, edhocMapperConfig, edhocMapperConfig.getEdhocCoapUri(), - edhocMapperConfig.getEdhocCoapUri(), cleanupTasks); + public ClientMapperState(EdhocMapperConfig edhocMapperConfig, CleanupTasks cleanupTasks) { + super(edhocMapperConfig, edhocMapperConfig.getEdhocCoapUri(), edhocMapperConfig.getEdhocCoapUri(), cleanupTasks); } @Override diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/context/EdhocExecutionContext.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/context/EdhocExecutionContext.java new file mode 100644 index 00000000..b17c8b58 --- /dev/null +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/context/EdhocExecutionContext.java @@ -0,0 +1,19 @@ +package com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context; + +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.inputs.EdhocInput; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs.EdhocOutput; +import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.context.ExecutionContextStepped; +import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.context.StepContext; + +public class EdhocExecutionContext +extends ExecutionContextStepped> { + + public EdhocExecutionContext(EdhocMapperState state) { + super(state); + } + + @Override + protected StepContext buildStepContext() { + return new StepContext<>(stepContexts.size()); + } +} diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/context/EdhocMapperState.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/context/EdhocMapperState.java index ce0481e4..10a20213 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/context/EdhocMapperState.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/context/EdhocMapperState.java @@ -12,7 +12,6 @@ import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.config.authentication.TestVectorAuthenticationConfig; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.connectors.CoapExchanger; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.connectors.EdhocMapperConnector; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.context.State; import com.github.protocolfuzzing.protocolstatefuzzer.utils.CleanupTasks; import com.upokecenter.cbor.CBORObject; import net.i2p.crypto.eddsa.EdDSASecurityProvider; @@ -26,13 +25,7 @@ import java.util.*; /** Adapted from test files EdhocClient / EdhocServer from edhoc repo */ -public abstract class EdhocMapperState implements State { - - // The protocol version of edhoc used for the session of this state - protected ProtocolVersion protocolVersion; - - // The combined message (EDHOC+OSCORE) version used for the session of this state - protected CombinedMessageVersion combinedMessageVersion; +public abstract class EdhocMapperState { // The authentication method to include in EDHOC message_1 (relevant only when Initiator) protected int authenticationMethod; @@ -98,12 +91,9 @@ public abstract class EdhocMapperState implements State { protected CleanupTasks cleanupTasks; - public EdhocMapperState(ProtocolVersion protocolVersion, EdhocMapperConfig edhocMapperConfig, - String edhocSessionUri, String oscoreUri, CleanupTasks cleanupTasks) { + public EdhocMapperState(EdhocMapperConfig edhocMapperConfig, String edhocSessionUri, String oscoreUri, CleanupTasks cleanupTasks) { - this.protocolVersion = protocolVersion; this.edhocMapperConfig = edhocMapperConfig; - this.combinedMessageVersion = edhocMapperConfig.getCombinedMessageVersion(); this.cleanupTasks = cleanupTasks; // Insert security providers @@ -198,11 +188,11 @@ public CleanupTasks getCleanupTasks() { } public ProtocolVersion getProtocolVersion() { - return protocolVersion; + return edhocMapperConfig.getProtocolVersion(); } public CombinedMessageVersion getCombinedMessageVersion() { - return combinedMessageVersion; + return edhocMapperConfig.getCombinedMessageVersion(); } public EdhocSessionPersistent getEdhocSessionPersistent() { diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/context/ServerMapperState.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/context/ServerMapperState.java index 8f9c0275..f80b237c 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/context/ServerMapperState.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/context/ServerMapperState.java @@ -1,15 +1,12 @@ package com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.config.EdhocMapperConfig; -import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.config.ProtocolVersion; import com.github.protocolfuzzing.protocolstatefuzzer.utils.CleanupTasks; public class ServerMapperState extends EdhocMapperState { - public ServerMapperState(ProtocolVersion protocolVersion, EdhocMapperConfig edhocMapperConfig, - CleanupTasks cleanupTasks) { - super(protocolVersion, edhocMapperConfig, edhocMapperConfig.getEdhocCoapUri(), - edhocMapperConfig.getHostCoapUri(), cleanupTasks); + public ServerMapperState(EdhocMapperConfig edhocMapperConfig, CleanupTasks cleanupTasks) { + super(edhocMapperConfig, edhocMapperConfig.getEdhocCoapUri(), edhocMapperConfig.getHostCoapUri(), cleanupTasks); } @Override diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/mappers/EdhocInputMapper.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/mappers/EdhocInputMapper.java index c65bd403..27c8ab36 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/mappers/EdhocInputMapper.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/mappers/EdhocInputMapper.java @@ -3,37 +3,34 @@ import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.EdhocProtocolMessage; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.config.EdhocMapperConfig; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.connectors.EdhocMapperConnector; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.protocol.ProtocolMessage; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.abstractsymbols.AbstractOutputChecker; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.EdhocExecutionContext; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.inputs.EdhocInput; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs.EdhocOutput; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs.EdhocOutputChecker; import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.config.MapperConfig; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.context.ExecutionContext; import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.mappers.InputMapper; import org.eclipse.californium.core.coap.MediaTypeRegistry; -public class EdhocInputMapper extends InputMapper { +public class EdhocInputMapper extends InputMapper { EdhocMapperConnector edhocMapperConnector; - public EdhocInputMapper(MapperConfig mapperConfig, AbstractOutputChecker outputChecker, - EdhocMapperConnector edhocMapperConnector) { + public EdhocInputMapper(MapperConfig mapperConfig, EdhocOutputChecker outputChecker, EdhocMapperConnector edhocMapperConnector) { super(mapperConfig, outputChecker); this.edhocMapperConnector = edhocMapperConnector; } @Override - protected void sendMessage(ProtocolMessage message, ExecutionContext context) { + protected void sendMessage(EdhocProtocolMessage message, EdhocExecutionContext context) { if (message == null) { throw new RuntimeException("Null message provided to EdhocInputMapper in sendMessage"); } - EdhocProtocolMessage edhocProtocolMessage = (EdhocProtocolMessage) message; - // enable or disable content format EdhocMapperConfig edhocMapperConfig = (EdhocMapperConfig) mapperConfig; int contentFormat = edhocMapperConfig.useContentFormat() ? - edhocProtocolMessage.getContentFormat(edhocMapperConfig.useOldContentFormat()) : + message.getContentFormat(edhocMapperConfig.useOldContentFormat()) : MediaTypeRegistry.UNDEFINED; - edhocMapperConnector.send(edhocProtocolMessage.getPayload(), edhocProtocolMessage.getPayloadType(), - edhocProtocolMessage.getMessageCode(), contentFormat); + edhocMapperConnector.send(message.getPayload(), message.getPayloadType(), message.getMessageCode(), contentFormat); } } diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/mappers/EdhocMapperComposer.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/mappers/EdhocMapperComposer.java new file mode 100644 index 00000000..f688f2ac --- /dev/null +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/mappers/EdhocMapperComposer.java @@ -0,0 +1,26 @@ +package com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.mappers; + +import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.EdhocProtocolMessage; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.EdhocExecutionContext; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.EdhocMapperState; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.inputs.EdhocInput; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs.EdhocOutput; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs.EdhocOutputBuilder; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs.EdhocOutputChecker; +import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.mappers.MapperComposer; + +public class EdhocMapperComposer extends MapperComposer { + public EdhocMapperComposer(EdhocInputMapper edhocInputMapper, EdhocOutputMapper edhocOutputMapper) { + super(edhocInputMapper, edhocOutputMapper); + } + + @Override + public EdhocOutputChecker getOutputChecker() { + return (EdhocOutputChecker) super.getOutputChecker(); + } + + @Override + public EdhocOutputBuilder getOutputBuilder() { + return (EdhocOutputBuilder) super.getOutputBuilder(); + } +} diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/mappers/EdhocOutputMapper.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/mappers/EdhocOutputMapper.java index efce1020..979d9a92 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/mappers/EdhocOutputMapper.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/mappers/EdhocOutputMapper.java @@ -2,32 +2,41 @@ import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.EdhocUtil; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.MessageProcessorPersistent; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.EdhocProtocolMessage; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.config.EdhocMapperConfig; -import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.connectors.*; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.connectors.EdhocMapperConnector; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.connectors.GenericErrorException; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.connectors.TimeoutException; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.connectors.UnsuccessfulMessageException; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.connectors.UnsupportedMessageException; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.EdhocExecutionContext; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.EdhocMapperState; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs.EdhocOutput; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs.EdhocOutputBuilder; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs.EdhocOutputChecker; import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs.MessageOutputType; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.abstractsymbols.AbstractOutput; import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.config.MapperConfig; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.context.ExecutionContext; import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.mappers.OutputMapper; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import java.nio.charset.StandardCharsets; +import java.util.List; -public class EdhocOutputMapper extends OutputMapper { +public class EdhocOutputMapper extends OutputMapper { private static final Logger LOGGER = LogManager.getLogger(); EdhocMapperConnector edhocMapperConnector; - public EdhocOutputMapper(MapperConfig mapperConfig, EdhocMapperConnector edhocMapperConnector) { - super(mapperConfig); + public EdhocOutputMapper(MapperConfig mapperConfig, EdhocOutputBuilder edhocOutputBuilder, + EdhocOutputChecker edhocOutputChecker, EdhocMapperConnector edhocMapperConnector) { + super(mapperConfig, edhocOutputBuilder, edhocOutputChecker); this.edhocMapperConnector = edhocMapperConnector; } @Override - public AbstractOutput receiveOutput(ExecutionContext context) { - EdhocMapperState edhocMapperState = (EdhocMapperState) context.getState(); + public EdhocOutput receiveOutput(EdhocExecutionContext context) { + EdhocMapperState edhocMapperState = context.getState(); byte[] responsePayload; try { @@ -39,15 +48,15 @@ public AbstractOutput receiveOutput(ExecutionContext context) { } catch (UnsupportedMessageException e) { // special output to demonstrate that the input message the learner requested // was unable to be sent and deemed unsupported - return new AbstractOutput(MessageOutputType.UNSUPPORTED_MESSAGE.name()); + return edhocOutput(MessageOutputType.UNSUPPORTED_MESSAGE); } catch (UnsuccessfulMessageException e) { // special output to demonstrate that the received message evoked an error // in a middle layer and did not reach the upper resource in the case of // server mapper - return new AbstractOutput(MessageOutputType.UNSUCCESSFUL_MESSAGE.name()); + return edhocOutput(MessageOutputType.UNSUCCESSFUL_MESSAGE); } - AbstractOutput abstractOutput; + EdhocOutput abstractOutput; // Check for application related message // including message 3 combined with oscore @@ -71,10 +80,10 @@ public AbstractOutput receiveOutput(ExecutionContext context) { return abstractOutput; } - return AbstractOutput.unknown(); + return outputBuilder.buildUnknown(); } - protected AbstractOutput appOutput(EdhocMapperState edhocMapperState, byte[] responsePayload) { + protected EdhocOutput appOutput(EdhocMapperState edhocMapperState, byte[] responsePayload) { String messageType = edhocMapperState.isCoapClient() ? "response" : "request"; if (edhocMapperConnector.receivedMsg3WithOscoreApp()) { @@ -83,7 +92,7 @@ protected AbstractOutput appOutput(EdhocMapperState edhocMapperState, byte[] res messageType, EdhocUtil.byteArrayToString(responsePayload), new String(responsePayload, StandardCharsets.UTF_8)); - return new AbstractOutput(MessageOutputType.EDHOC_MESSAGE_3_OSCORE_APP.name()); + return edhocOutput(MessageOutputType.EDHOC_MESSAGE_3_OSCORE_APP); } if (edhocMapperConnector.receivedOscoreAppMessage()) { @@ -101,30 +110,30 @@ protected AbstractOutput appOutput(EdhocMapperState edhocMapperState, byte[] res messageType, EdhocUtil.byteArrayToString(responsePayload), new String(responsePayload, StandardCharsets.UTF_8)); - return new AbstractOutput(MessageOutputType.OSCORE_APP_MESSAGE.name()); + return edhocOutput(MessageOutputType.OSCORE_APP_MESSAGE); } return null; } - protected AbstractOutput edhocOutput(EdhocMapperState edhocMapperState, byte[] responsePayload) { + protected EdhocOutput edhocOutput(EdhocMapperState edhocMapperState, byte[] responsePayload) { MessageProcessorPersistent messageProcessorPersistent = new MessageProcessorPersistent(edhocMapperState); boolean ok; switch(messageProcessorPersistent.messageTypeFromStructure(responsePayload)) { case EDHOC_ERROR_MESSAGE -> { ok = messageProcessorPersistent.readErrorMessage(responsePayload); - return abstractOutputAfterCheck(ok, MessageOutputType.EDHOC_ERROR_MESSAGE.name()); + return edhocOutputAfterCheck(ok, MessageOutputType.EDHOC_ERROR_MESSAGE); } case EDHOC_MESSAGE_1 -> { ok = messageProcessorPersistent.readMessage1(responsePayload); - return abstractOutputAfterCheck(ok, MessageOutputType.EDHOC_MESSAGE_1.name()); + return edhocOutputAfterCheck(ok, MessageOutputType.EDHOC_MESSAGE_1); } case EDHOC_MESSAGE_2 -> { ok = messageProcessorPersistent.readMessage2(responsePayload); - return abstractOutputAfterCheck(ok, MessageOutputType.EDHOC_MESSAGE_2.name()); + return edhocOutputAfterCheck(ok, MessageOutputType.EDHOC_MESSAGE_2); } case EDHOC_MESSAGE_3_OR_4 -> { @@ -132,11 +141,11 @@ protected AbstractOutput edhocOutput(EdhocMapperState edhocMapperState, byte[] r LOGGER.info("Reading as EDHOC Message 3 or 4"); ok = messageProcessorPersistent.readMessage3(responsePayload); if (ok) { - return new AbstractOutput(MessageOutputType.EDHOC_MESSAGE_3.name()); + return edhocOutput(MessageOutputType.EDHOC_MESSAGE_3); } ok = messageProcessorPersistent.readMessage4(responsePayload); - return abstractOutputAfterCheck(ok, MessageOutputType.EDHOC_MESSAGE_4.name()); + return edhocOutputAfterCheck(ok, MessageOutputType.EDHOC_MESSAGE_4); } case EDHOC_MESSAGE_2_OR_3_OR_4 -> { @@ -144,16 +153,16 @@ protected AbstractOutput edhocOutput(EdhocMapperState edhocMapperState, byte[] r LOGGER.info("Reading as EDHOC Message 2 or 3 or 4"); ok = messageProcessorPersistent.readMessage2(responsePayload); if (ok) { - return new AbstractOutput(MessageOutputType.EDHOC_MESSAGE_2.name()); + return edhocOutput(MessageOutputType.EDHOC_MESSAGE_2); } ok = messageProcessorPersistent.readMessage3(responsePayload); if (ok) { - return new AbstractOutput(MessageOutputType.EDHOC_MESSAGE_3.name()); + return edhocOutput(MessageOutputType.EDHOC_MESSAGE_3); } ok = messageProcessorPersistent.readMessage4(responsePayload); - return abstractOutputAfterCheck(ok, MessageOutputType.EDHOC_MESSAGE_4.name()); + return edhocOutputAfterCheck(ok, MessageOutputType.EDHOC_MESSAGE_4); } default -> { @@ -162,7 +171,7 @@ protected AbstractOutput edhocOutput(EdhocMapperState edhocMapperState, byte[] r } } - protected AbstractOutput coapOutput(EdhocMapperState edhocMapperState, byte[] responsePayload) { + protected EdhocOutput coapOutput(EdhocMapperState edhocMapperState, byte[] responsePayload) { String messageType = edhocMapperState.isCoapClient() ? "response" : "request"; // Check for coap error message @@ -183,7 +192,7 @@ protected AbstractOutput coapOutput(EdhocMapperState edhocMapperState, byte[] re Server Mapper: received empty coap request for some reason */ - return new AbstractOutput(MessageOutputType.COAP_EMPTY_MESSAGE.name()); + return edhocOutput(MessageOutputType.COAP_EMPTY_MESSAGE); } // Check for unprotected coap message @@ -193,24 +202,32 @@ protected AbstractOutput coapOutput(EdhocMapperState edhocMapperState, byte[] re LOGGER.info("COAP_APP_MESSAGE ({}): {} ~ {}", messageType, EdhocUtil.byteArrayToString(responsePayload), new String(responsePayload, StandardCharsets.UTF_8)); - return new AbstractOutput(MessageOutputType.COAP_APP_MESSAGE.name()); + return edhocOutput(MessageOutputType.COAP_APP_MESSAGE); } // if payload was not empty then a coap message is received // because no other transport protocol than coap is supported yet - return abstractOutputAfterCheck(responsePayload != null, MessageOutputType.COAP_MESSAGE.name()); + return edhocOutputAfterCheck(responsePayload != null, MessageOutputType.COAP_MESSAGE); } - protected AbstractOutput abstractOutputAfterCheck(boolean successfulCheck, String outputName) { - return successfulCheck ? new AbstractOutput(outputName) : null; - } - - protected AbstractOutput coapError() { + protected EdhocOutput coapError() { if (((EdhocMapperConfig) mapperConfig).isCoapErrorAsEdhocError()) { - return new AbstractOutput(MessageOutputType.EDHOC_ERROR_MESSAGE.name()); + return edhocOutput(MessageOutputType.EDHOC_ERROR_MESSAGE); } else { - return new AbstractOutput(MessageOutputType.COAP_ERROR_MESSAGE.name()); + return edhocOutput(MessageOutputType.COAP_ERROR_MESSAGE); } } + protected EdhocOutput edhocOutputAfterCheck(boolean successfulCheck, MessageOutputType type) { + return successfulCheck ? edhocOutput(type) : null; + } + + protected EdhocOutput edhocOutput(MessageOutputType type) { + return new EdhocOutput(type.name()); + } + + @Override + protected EdhocOutput buildOutput(String name, List messages) { + return new EdhocOutput(name, messages); + } } diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/CoapAppMessageInput.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/CoapAppMessageInput.java index 88ed5498..2e05295c 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/CoapAppMessageInput.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/CoapAppMessageInput.java @@ -1,15 +1,15 @@ package com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.inputs; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.MessageProcessorPersistent; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.EdhocProtocolMessage; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.common.CoapAppMessage; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.protocol.ProtocolMessage; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.context.ExecutionContext; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.EdhocExecutionContext; public class CoapAppMessageInput extends EdhocInput { @Override - public ProtocolMessage generateProtocolMessage(ExecutionContext context) { - return new CoapAppMessage(new MessageProcessorPersistent(getEdhocMapperState(context))); + public EdhocProtocolMessage generateProtocolMessage(EdhocExecutionContext context) { + return new CoapAppMessage(new MessageProcessorPersistent(context.getState())); } @Override diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/CoapEmptyMessageInput.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/CoapEmptyMessageInput.java index 6cf78822..e2228a4d 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/CoapEmptyMessageInput.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/CoapEmptyMessageInput.java @@ -1,15 +1,15 @@ package com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.inputs; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.MessageProcessorPersistent; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.EdhocProtocolMessage; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.common.CoapEmptyMessage; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.protocol.ProtocolMessage; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.context.ExecutionContext; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.EdhocExecutionContext; public class CoapEmptyMessageInput extends EdhocInput { @Override - public ProtocolMessage generateProtocolMessage(ExecutionContext context) { - return new CoapEmptyMessage(new MessageProcessorPersistent(getEdhocMapperState(context))); + public EdhocProtocolMessage generateProtocolMessage(EdhocExecutionContext context) { + return new CoapEmptyMessage(new MessageProcessorPersistent(context.getState())); } @Override diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocErrorMessageInput.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocErrorMessageInput.java index bb9d5aa1..87cd84d8 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocErrorMessageInput.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocErrorMessageInput.java @@ -1,15 +1,15 @@ package com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.inputs; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.MessageProcessorPersistent; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.EdhocProtocolMessage; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.common.EdhocErrorMessage; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.protocol.ProtocolMessage; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.context.ExecutionContext; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.EdhocExecutionContext; public class EdhocErrorMessageInput extends EdhocInput { @Override - public ProtocolMessage generateProtocolMessage(ExecutionContext context) { - return new EdhocErrorMessage(new MessageProcessorPersistent(getEdhocMapperState(context))); + public EdhocProtocolMessage generateProtocolMessage(EdhocExecutionContext context) { + return new EdhocErrorMessage(new MessageProcessorPersistent(context.getState())); } @Override diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocInput.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocInput.java index 64656a1b..3e661794 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocInput.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocInput.java @@ -1,28 +1,23 @@ package com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.inputs; -import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.EdhocSessionPersistent; -import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.EdhocMapperState; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.abstractsymbols.AbstractOutput; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.abstractsymbols.AbstractOutputChecker; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.abstractsymbols.xml.AbstractInputXml; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.context.ExecutionContext; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.EdhocProtocolMessage; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.EdhocExecutionContext; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs.EdhocOutput; +import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.abstractsymbols.AbstractInputXml; +import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.abstractsymbols.OutputChecker; -public abstract class EdhocInput extends AbstractInputXml { - public EdhocMapperState getEdhocMapperState(ExecutionContext context) { - return (EdhocMapperState) context.getState(); - } - - public EdhocSessionPersistent getEdhocSessionPersistent(ExecutionContext context) { - return getEdhocMapperState(context).getEdhocSessionPersistent(); - } +public abstract class EdhocInput extends AbstractInputXml { + public abstract Enum getInputType(); @Override - public void preSendUpdate(ExecutionContext context) {} + public void preSendUpdate(EdhocExecutionContext context) {} @Override - public void postSendUpdate(ExecutionContext context) {} + public void postSendUpdate(EdhocExecutionContext context) {} @Override - public void postReceiveUpdate(AbstractOutput output, AbstractOutputChecker abstractOutputChecker, - ExecutionContext context) {} + public void postReceiveUpdate( + EdhocOutput output, + OutputChecker abstractOutputChecker, + EdhocExecutionContext context) {} } diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocMessage1Input.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocMessage1Input.java index 14c291b6..79cff749 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocMessage1Input.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocMessage1Input.java @@ -1,24 +1,27 @@ package com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.inputs; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.EdhocSessionPersistent; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.MessageProcessorPersistent; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.EdhocProtocolMessage; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.initiator.EdhocMessage1; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.protocol.ProtocolMessage; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.context.ExecutionContext; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.EdhocExecutionContext; public class EdhocMessage1Input extends EdhocInput { @Override - public void preSendUpdate(ExecutionContext context) { - if (getEdhocSessionPersistent(context).isInitiator()) { + public void preSendUpdate(EdhocExecutionContext context) { + EdhocSessionPersistent session = context.getState().getEdhocSessionPersistent(); + + if (session.isInitiator()) { // Initiator by sending message 1 starts a new key exchange session // so previous session state must be cleaned unless reset is disabled - getEdhocSessionPersistent(context).resetIfEnabled(); + session.resetIfEnabled(); } } @Override - public ProtocolMessage generateProtocolMessage(ExecutionContext context) { - return new EdhocMessage1(new MessageProcessorPersistent(getEdhocMapperState(context))); + public EdhocProtocolMessage generateProtocolMessage(EdhocExecutionContext context) { + return new EdhocMessage1(new MessageProcessorPersistent(context.getState())); } @Override diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocMessage2Input.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocMessage2Input.java index b7c32ded..202e7420 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocMessage2Input.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocMessage2Input.java @@ -1,15 +1,15 @@ package com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.inputs; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.MessageProcessorPersistent; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.EdhocProtocolMessage; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.responder.EdhocMessage2; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.protocol.ProtocolMessage; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.context.ExecutionContext; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.EdhocExecutionContext; public class EdhocMessage2Input extends EdhocInput { @Override - public ProtocolMessage generateProtocolMessage(ExecutionContext context) { - return new EdhocMessage2(new MessageProcessorPersistent(getEdhocMapperState(context))); + public EdhocProtocolMessage generateProtocolMessage(EdhocExecutionContext context) { + return new EdhocMessage2(new MessageProcessorPersistent(context.getState())); } @Override diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocMessage3Input.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocMessage3Input.java index eb10f033..ec6ebd0c 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocMessage3Input.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocMessage3Input.java @@ -1,15 +1,15 @@ package com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.inputs; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.MessageProcessorPersistent; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.EdhocProtocolMessage; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.initiator.EdhocMessage3; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.protocol.ProtocolMessage; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.context.ExecutionContext; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.EdhocExecutionContext; public class EdhocMessage3Input extends EdhocInput { @Override - public ProtocolMessage generateProtocolMessage(ExecutionContext context) { - return new EdhocMessage3(new MessageProcessorPersistent(getEdhocMapperState(context))); + public EdhocProtocolMessage generateProtocolMessage(EdhocExecutionContext context) { + return new EdhocMessage3(new MessageProcessorPersistent(context.getState())); } @Override diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocMessage3OscoreAppInput.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocMessage3OscoreAppInput.java index a0509d16..224b8fb2 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocMessage3OscoreAppInput.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocMessage3OscoreAppInput.java @@ -1,22 +1,22 @@ package com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.inputs; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.MessageProcessorPersistent; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.EdhocProtocolMessage; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.initiator.EdhocMessage3OscoreApp; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.protocol.ProtocolMessage; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.context.ExecutionContext; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.EdhocExecutionContext; public class EdhocMessage3OscoreAppInput extends EdhocInput { @Override - public void preSendUpdate(ExecutionContext context) { + public void preSendUpdate(EdhocExecutionContext context) { // construct Message3 in order to store it in session 'message3' field, // derive new oscore context and make Message3 available to oscore layer - new MessageProcessorPersistent(getEdhocMapperState(context)).writeMessage3(); + new MessageProcessorPersistent(context.getState()).writeMessage3(); } @Override - public ProtocolMessage generateProtocolMessage(ExecutionContext context) { - return new EdhocMessage3OscoreApp(new MessageProcessorPersistent(getEdhocMapperState(context))); + public EdhocProtocolMessage generateProtocolMessage(EdhocExecutionContext context) { + return new EdhocMessage3OscoreApp(new MessageProcessorPersistent(context.getState())); } @Override diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocMessage4Input.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocMessage4Input.java index 6e3aed74..3f51ae68 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocMessage4Input.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/EdhocMessage4Input.java @@ -1,15 +1,15 @@ package com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.inputs; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.MessageProcessorPersistent; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.EdhocProtocolMessage; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.responder.EdhocMessage4; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.protocol.ProtocolMessage; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.context.ExecutionContext; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.EdhocExecutionContext; public class EdhocMessage4Input extends EdhocInput { @Override - public ProtocolMessage generateProtocolMessage(ExecutionContext context) { - return new EdhocMessage4(new MessageProcessorPersistent(getEdhocMapperState(context))); + public EdhocProtocolMessage generateProtocolMessage(EdhocExecutionContext context) { + return new EdhocMessage4(new MessageProcessorPersistent(context.getState())); } @Override diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/OscoreAppMessageInput.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/OscoreAppMessageInput.java index 7362c063..b3f026a4 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/OscoreAppMessageInput.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/inputs/OscoreAppMessageInput.java @@ -1,15 +1,15 @@ package com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.inputs; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.MessageProcessorPersistent; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.EdhocProtocolMessage; import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.common.OscoreAppMessage; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.core.protocol.ProtocolMessage; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.context.ExecutionContext; +import com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.context.EdhocExecutionContext; public class OscoreAppMessageInput extends EdhocInput { @Override - public ProtocolMessage generateProtocolMessage(ExecutionContext context) { - return new OscoreAppMessage(new MessageProcessorPersistent(getEdhocMapperState(context))); + public EdhocProtocolMessage generateProtocolMessage(EdhocExecutionContext context) { + return new OscoreAppMessage(new MessageProcessorPersistent(context.getState())); } @Override diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/outputs/EdhocOutput.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/outputs/EdhocOutput.java new file mode 100644 index 00000000..7e158e43 --- /dev/null +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/outputs/EdhocOutput.java @@ -0,0 +1,26 @@ +package com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs; + +import com.github.protocolfuzzing.edhocfuzzer.components.sul.core.protocol.messages.EdhocProtocolMessage; +import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.abstractsymbols.AbstractOutput; + +import java.util.List; + +public class EdhocOutput extends AbstractOutput { + public EdhocOutput(String name) { + super(name); + } + + public EdhocOutput(String name, List messages) { + super(name, messages); + } + + @Override + protected EdhocOutput buildOutput(String name) { + return new EdhocOutput(name); + } + + @Override + protected EdhocOutput convertOutput() { + return new EdhocOutput(name, messages); + } +} diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/outputs/EdhocOutputBuilder.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/outputs/EdhocOutputBuilder.java new file mode 100644 index 00000000..7571e2cd --- /dev/null +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/outputs/EdhocOutputBuilder.java @@ -0,0 +1,10 @@ +package com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs; + +import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.abstractsymbols.OutputBuilder; + +public class EdhocOutputBuilder implements OutputBuilder { + @Override + public EdhocOutput buildOutput(String name) { + return new EdhocOutput(name); + } +} diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/outputs/EdhocOutputChecker.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/outputs/EdhocOutputChecker.java index 7c4843ca..05191463 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/outputs/EdhocOutputChecker.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/outputs/EdhocOutputChecker.java @@ -1,18 +1,37 @@ package com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.abstractsymbols.AbstractOutput; -import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.abstractsymbols.AbstractOutputChecker; +import com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.abstractsymbols.OutputChecker; import java.util.Objects; -public class EdhocOutputChecker implements AbstractOutputChecker { +public class EdhocOutputChecker implements OutputChecker { - public boolean isMessage(AbstractOutput abstractOutput, MessageOutputType messageOutputType) { - return Objects.equals(abstractOutput.getName(), messageOutputType.name()); + public boolean isMessage(EdhocOutput output, MessageOutputType messageOutputType) { + return Objects.equals(output.getName(), messageOutputType.name()); } @Override - public boolean hasInitialClientMessage(AbstractOutput abstractOutput) { - return isMessage(abstractOutput, MessageOutputType.EDHOC_MESSAGE_1); + public boolean hasInitialClientMessage(EdhocOutput output) { + return isMessage(output, MessageOutputType.EDHOC_MESSAGE_1); + } + + @Override + public boolean isTimeout(EdhocOutput output) { + return isMessage(output, MessageOutputType.TIMEOUT); + } + + @Override + public boolean isUnknown(EdhocOutput output) { + return isMessage(output, MessageOutputType.UNKNOWN); + } + + @Override + public boolean isSocketClosed(EdhocOutput output) { + return isMessage(output, MessageOutputType.SOCKET_CLOSED); + } + + @Override + public boolean isDisabled(EdhocOutput output) { + return isMessage(output, MessageOutputType.DISABLED); } } diff --git a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/outputs/MessageOutputType.java b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/outputs/MessageOutputType.java index a89f7f7a..7f834f91 100644 --- a/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/outputs/MessageOutputType.java +++ b/src/main/java/com/github/protocolfuzzing/edhocfuzzer/components/sul/mapper/symbols/outputs/MessageOutputType.java @@ -1,10 +1,8 @@ package com.github.protocolfuzzing.edhocfuzzer.components.sul.mapper.symbols.outputs; /** Messages that can be received. - * Possible additional messages not included are those generated from - * {@link com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.abstractsymbols.AbstractOutput#unknown() AbstractOutput.unknown()}, - * {@link com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.abstractsymbols.AbstractOutput#socketClosed() AbstractOutput.socketClosed()}, - * {@link com.github.protocolfuzzing.protocolstatefuzzer.components.sul.mapper.abstractsymbols.AbstractOutput#timeout() AbstractOutput.timeout()} */ + * The last four are from the OutputBuilder. + */ public enum MessageOutputType { EDHOC_MESSAGE_1, EDHOC_MESSAGE_2, @@ -18,5 +16,9 @@ public enum MessageOutputType { COAP_ERROR_MESSAGE, COAP_EMPTY_MESSAGE, UNSUPPORTED_MESSAGE, - UNSUCCESSFUL_MESSAGE + UNSUCCESSFUL_MESSAGE, + TIMEOUT, + UNKNOWN, + SOCKET_CLOSED, + DISABLED }