| % Regression tests for the UDS layer |
| |
| # More information at http://www.secdev.org/projects/UTscapy/ |
| |
| |
| ############ |
| ############ |
| |
| + Basic operations |
| |
| = Load module |
| load_contrib("automotive.uds", globals_dict=globals()) |
| load_contrib("automotive.ecu", globals_dict=globals()) |
| |
| from scapy.contrib.automotive.uds_ecu_states import * |
| |
| = Check if positive response answers |
| |
| dsc = UDS(b'\x10') |
| dscpr = UDS(b'\x50') |
| assert dscpr.answers(dsc) |
| |
| = Check hashret |
| dsc.hashret() == dscpr.hashret() |
| |
| = Check if negative response answers |
| |
| dsc = UDS(b'\x10') |
| neg = UDS(b'\x7f\x10\x00') |
| assert neg.answers(dsc) |
| |
| = CHECK hashret NEG |
| dsc.hashret() == neg.hashret() |
| |
| = Check if negative response answers not |
| |
| dsc = UDS(b'\x10') |
| neg = UDS(b'\x7f\x11\x00') |
| assert not neg.answers(dsc) |
| |
| = Check if positive response answers not |
| |
| dsc = UDS(b'\x10') |
| somePacket = UDS(b'\x49') |
| assert not somePacket.answers(dsc) |
| |
| = Check UDS_DSC |
| |
| dsc = UDS(b'\x10\x01') |
| assert dsc.service == 0x10 |
| assert dsc.diagnosticSessionType == 0x01 |
| |
| = Check UDS_DSC |
| |
| dsc = UDS()/UDS_DSC(b'\x01') |
| assert dsc.service == 0x10 |
| assert dsc.diagnosticSessionType == 0x01 |
| |
| = Check UDS_DSCPR |
| |
| dscpr = UDS(b'\x50\x02beef') |
| assert dscpr.service == 0x50 |
| assert dscpr.diagnosticSessionType == 0x02 |
| |
| assert not dscpr.answers(dsc) |
| |
| = Check UDS_DSCPR |
| |
| dscpr = UDS()/UDS_DSCPR(b'\x01beef') |
| assert dscpr.service == 0x50 |
| assert dscpr.diagnosticSessionType == 0x01 |
| assert dscpr.sessionParameterRecord == b"beef" |
| |
| assert dscpr.answers(dsc) |
| |
| = Check UDS_DSC |
| |
| dsc = UDS()/UDS_DSC(b'\x01') |
| assert dsc.service == 0x10 |
| assert dsc.diagnosticSessionType == 0x01 |
| |
| = Check UDS_DSCPR |
| |
| dscpr = UDS()/UDS_DSCPR(b'\x01beef') |
| assert dscpr.service == 0x50 |
| assert dscpr.diagnosticSessionType == 0x01 |
| assert dscpr.sessionParameterRecord == b"beef" |
| |
| assert dscpr.answers(dsc) |
| |
| = Check UDS_DSC modifies ecu state |
| |
| dsc = UDS()/UDS_DSC(b'\x09') |
| assert dsc.service == 0x10 |
| assert dsc.diagnosticSessionType == 0x09 |
| |
| = Check UDS_DSCPR modifies ecu state |
| |
| dscpr = UDS()/UDS_DSCPR(b'\x09beef') |
| assert dscpr.service == 0x50 |
| assert dscpr.diagnosticSessionType == 0x09 |
| assert dscpr.sessionParameterRecord == b"beef" |
| |
| ecu = Ecu() |
| ecu.update(dsc) |
| ecu.update(dscpr) |
| assert ecu.state.session == 9 |
| |
| = Check UDS_ER |
| |
| er = UDS(b'\x11\x01') |
| assert er.service == 0x11 |
| assert er.resetType == 0x01 |
| |
| = Check UDS_ER |
| |
| er = UDS()/UDS_ER(resetType="hardReset") |
| assert er.service == 0x11 |
| assert er.resetType == 0x01 |
| |
| = Check UDS_ERPR |
| |
| erpr = UDS(b'\x51\x01') |
| assert erpr.service == 0x51 |
| assert erpr.resetType == 0x01 |
| |
| assert erpr.answers(er) |
| |
| = Check UDS_ERPR |
| |
| erpr = UDS(b'\x51\x04\x10') |
| assert erpr.service == 0x51 |
| assert erpr.resetType == 0x04 |
| assert erpr.powerDownTime == 0x10 |
| |
| = Check UDS_ERPR modifies ecu state |
| |
| erpr = UDS(b'\x51\x01') |
| assert erpr.service == 0x51 |
| assert erpr.resetType == 0x01 |
| |
| ecu = Ecu() |
| ecu.state.security_level = 5 |
| ecu.state.session = 3 |
| ecu.state.communication_control = 4 |
| ecu.update(er) |
| ecu.update(erpr) |
| |
| assert ecu.state.session == 1 |
| |
| = Check UDS_SA |
| |
| sa = UDS(b'\x27\x00c0ffee') |
| assert sa.service == 0x27 |
| assert sa.securityAccessType == 0x0 |
| assert sa.securityKey == b'c0ffee' |
| |
| = Check UDS_SAPR |
| |
| sapr = UDS(b'\x67\x00') |
| assert sapr.service == 0x67 |
| assert sapr.securityAccessType == 0x0 |
| |
| assert sapr.answers(sa) |
| |
| = Check UDS_SA |
| |
| sa = UDS(b'\x27\x01c0ffee') |
| assert sa.service == 0x27 |
| assert sa.securityAccessType == 0x1 |
| assert sa.securityAccessDataRecord == b'c0ffee' |
| |
| = Check UDS_SAPR |
| |
| sapr = UDS(b'\x67\x01c0ffee') |
| assert sapr.service == 0x67 |
| assert sapr.securityAccessType == 0x1 |
| assert sapr.securitySeed == b'c0ffee' |
| |
| assert sapr.answers(sa) |
| |
| = Check UDS_SA |
| |
| sa = UDS(b'\x27\x06c0ffee') |
| assert sa.service == 0x27 |
| assert sa.securityAccessType == 0x6 |
| assert sa.securityKey == b'c0ffee' |
| |
| |
| = Check UDS_SAPR modifies ecu state |
| |
| sapr = UDS(b'\x67\x06') |
| assert sapr.service == 0x67 |
| assert sapr.securityAccessType == 0x6 |
| |
| ecu = Ecu() |
| ecu.update(sa) |
| ecu.update(sapr) |
| assert ecu.state.security_level == 6 |
| |
| = Check UDS_SA |
| |
| sa = UDS(b'\x27\x01c0ffee') |
| assert sa.service == 0x27 |
| assert sa.securityAccessType == 0x1 |
| assert sa.securityAccessDataRecord == b'c0ffee' |
| |
| = Check UDS_SAPR |
| |
| sapr = UDS(b'\x67\x01c0ffee') |
| assert sapr.service == 0x67 |
| assert sapr.securityAccessType == 0x1 |
| assert sapr.securitySeed == b'c0ffee' |
| |
| |
| = Check UDS_CC |
| |
| cc = UDS(b'\x28\x01\xff') |
| assert cc.service == 0x28 |
| assert cc.controlType == 0x1 |
| assert cc.communicationType0 == 0x3 |
| assert cc.communicationType1 == 0x3 |
| assert cc.communicationType2 == 0xf |
| |
| = Check UDS_CCPR |
| |
| ccpr = UDS(b'\x68\x01') |
| assert ccpr.service == 0x68 |
| assert ccpr.controlType == 0x1 |
| |
| assert ccpr.answers(cc) |
| |
| = Check UDS_CCPR modifies ecu state |
| |
| ccpr = UDS(b'\x68\x01') |
| assert ccpr.service == 0x68 |
| assert ccpr.controlType == 0x1 |
| |
| ecu = Ecu() |
| ecu.update(cc) |
| ecu.update(ccpr) |
| assert ecu.state.communication_control == 1 |
| |
| = Check UDS_AUTH |
| |
| auth = UDS(b"\x29\x00") |
| assert auth.service == 0x29 |
| assert auth.subFunction == 0x0 |
| |
| = Build UDS_AUTH |
| |
| auth_build = UDS()/UDS_AUTH(subFunction=0x0) |
| assert bytes(auth_build) == bytes(auth) |
| |
| = Check UDS_AUTHPR |
| |
| authpr = UDS(b"\x69\x00\x00") |
| assert authpr.service == 0x69 |
| assert authpr.subFunction == 0x0 |
| assert authpr.returnValue == 0x0 |
| |
| assert authpr.answers(auth) |
| |
| = Build UDS_AUTHPR |
| |
| authpr_build = UDS()/UDS_AUTHPR(subFunction=0x0, returnValue=0x0) |
| assert bytes(authpr_build) == bytes(authpr) |
| |
| = Check UDS_AUTH |
| |
| auth = UDS(b"\x29\x01\x01\x00\x01\xFF\x00\x01\xFF") |
| assert auth.service == 0x29 |
| assert auth.subFunction == 0x1 |
| assert auth.communicationConfiguration == 0x1 |
| assert auth.lengthOfCertificateClient == 0x1 |
| assert auth.certificateClient == b"\xFF" |
| assert auth.lengthOfChallengeClient == 0x1 |
| assert auth.challengeClient == b"\xFF" |
| |
| = Build UDS_AUTH |
| |
| auth_build = UDS()/UDS_AUTH(subFunction=0x1, communicationConfiguration=0x1, |
| certificateClient=b"\xFF", challengeClient=b"\xFF") |
| assert bytes(auth_build) == bytes(auth) |
| |
| = Check UDS_AUTHPR |
| |
| authpr = UDS(b"\x69\x01\x00\x00\x01\xFF\x00\x01\xFE") |
| assert authpr.service == 0x69 |
| assert authpr.subFunction == 0x1 |
| assert authpr.returnValue == 0x0 |
| assert authpr.lengthOfChallengeServer == 0x1 |
| assert authpr.challengeServer == b"\xFF" |
| assert authpr.lengthOfEphemeralPublicKeyServer == 0x1 |
| assert authpr.ephemeralPublicKeyServer == b"\xFE" |
| |
| assert authpr.answers(auth) |
| |
| = Build UDS_AUTHPR |
| |
| authpr_build = UDS()/UDS_AUTHPR(subFunction=0x1, returnValue=0x0, |
| challengeServer=b"\xFF", |
| ephemeralPublicKeyServer=b"\xFE") |
| assert bytes(authpr_build) == bytes(authpr) |
| |
| = Check UDS_AUTH |
| |
| auth = UDS(b"\x29\x02\x01\x00\x01\xFF\x00\x01\xFF") |
| assert auth.service == 0x29 |
| assert auth.subFunction == 0x2 |
| assert auth.communicationConfiguration == 0x1 |
| assert auth.lengthOfCertificateClient == 0x1 |
| assert auth.certificateClient == b"\xFF" |
| assert auth.lengthOfChallengeClient == 0x1 |
| assert auth.challengeClient == b"\xFF" |
| |
| = Build UDS_AUTH |
| |
| auth_build = UDS()/UDS_AUTH(subFunction=0x2, communicationConfiguration=0x1, |
| certificateClient=b"\xFF", challengeClient=b"\xFF") |
| assert bytes(auth_build) == bytes(auth) |
| |
| = Check UDS_AUTHPR |
| |
| authpr = UDS(b"\x69\x02\x00\x00\x01\xFF\x00\x03\xC0\xFF\xEE\x00\x01\x56\x00" + |
| b"\x01\xFE") |
| assert authpr.service == 0x69 |
| assert authpr.subFunction == 0x2 |
| assert authpr.returnValue == 0x0 |
| assert authpr.lengthOfChallengeServer == 0x1 |
| assert authpr.challengeServer == b"\xFF" |
| assert authpr.lengthOfCertificateServer == 0x3 |
| assert authpr.certificateServer == b"\xC0\xFF\xEE" |
| assert authpr.lengthOfProofOfOwnershipServer == 0x1 |
| assert authpr.proofOfOwnershipServer == b"\x56" |
| assert authpr.lengthOfEphemeralPublicKeyServer == 0x1 |
| assert authpr.ephemeralPublicKeyServer == b"\xFE" |
| |
| assert authpr.answers(auth) |
| |
| = Build UDS_AUTHPR |
| |
| authpr_build = UDS()/UDS_AUTHPR(subFunction=0x2, returnValue=0x0, |
| challengeServer=b"\xFF", |
| certificateServer=b"\xC0\xFF\xEE", |
| proofOfOwnershipServer=b"\x56", |
| ephemeralPublicKeyServer=b"\xFE") |
| assert bytes(authpr_build) == bytes(authpr) |
| |
| = Check UDS_AUTH |
| |
| auth = UDS(b"\x29\x03\x00\x01\xFF\x00\x02\xFF\xFE") |
| assert auth.service == 0x29 |
| assert auth.subFunction == 0x3 |
| assert auth.lengthOfProofOfOwnershipClient == 0x1 |
| assert auth.proofOfOwnershipClient == b"\xFF" |
| assert auth.lengthOfEphemeralPublicKeyClient == 0x2 |
| assert auth.ephemeralPublicKeyClient == b"\xFF\xFE" |
| |
| = Build UDS_AUTH |
| |
| auth_build = UDS()/UDS_AUTH(subFunction=0x3, proofOfOwnershipClient=b"\xFF", |
| ephemeralPublicKeyClient=b"\xFF\xFE") |
| assert bytes(auth_build) == bytes(auth) |
| |
| = Check UDS_AUTHPR |
| |
| authpr = UDS(b"\x69\x03\x00\x00\x01\xFE") |
| assert authpr.service == 0x69 |
| assert authpr.subFunction == 0x3 |
| assert authpr.returnValue == 0x0 |
| assert authpr.lengthOfSessionKeyInfo == 0x1 |
| assert authpr.sessionKeyInfo == b"\xFE" |
| |
| assert authpr.answers(auth) |
| |
| = Build UDS_AUTHPR |
| |
| authpr_build = UDS()/UDS_AUTHPR(subFunction=0x3, returnValue=0x0, |
| sessionKeyInfo=b"\xFE") |
| assert bytes(authpr_build) == bytes(authpr) |
| |
| = Check UDS_AUTH |
| |
| auth = UDS(b"\x29\x04\x00\x03\x00\x05\xFF\x00\x02\xFF\xFE") |
| assert auth.service == 0x29 |
| assert auth.subFunction == 0x4 |
| assert auth.certificateEvaluationId == 0x3 |
| assert auth.lengthOfCertificateData == 0x5 |
| assert auth.certificateData == b"\xFF\x00\x02\xFF\xFE" |
| |
| = Build UDS_AUTH |
| |
| auth_build = UDS()/UDS_AUTH(subFunction=0x4, certificateEvaluationId=0x3, |
| certificateData=b"\xFF\x00\x02\xFF\xFE") |
| assert bytes(auth_build) == bytes(auth) |
| |
| = Check UDS_AUTHPR |
| |
| authpr = UDS(b"\x69\x04\x00") |
| assert authpr.service == 0x69 |
| assert authpr.subFunction == 0x4 |
| assert authpr.returnValue == 0x0 |
| |
| assert authpr.answers(auth) |
| |
| = Build UDS_AUTHPR |
| |
| authpr_build = UDS()/UDS_AUTHPR(subFunction=0x4, returnValue=0x0) |
| assert bytes(authpr_build) == bytes(authpr) |
| |
| = Check UDS_AUTH |
| |
| auth = UDS(b"\x29\x05\x01\x03\x00\x05\xFF\x00\x02\xFF\xFE\xBE\x34\x56\x03" + |
| b"\xFF\xEE\x20\x01") |
| assert auth.service == 0x29 |
| assert auth.subFunction == 0x5 |
| assert auth.communicationConfiguration == 0x1 |
| assert auth.algorithmIndicator == (b"\x03\x00\x05\xFF\x00\x02\xFF\xFE\xBE" + |
| b"\x34\x56\x03\xFF\xEE\x20\x01") |
| |
| = Build UDS_AUTH |
| |
| auth_build = UDS()/UDS_AUTH(subFunction=0x5, communicationConfiguration=0x1, |
| algorithmIndicator=(b"\x03\x00\x05\xFF\x00\x02" + |
| b"\xFF\xFE\xBE\x34\x56\x03" + |
| b"\xFF\xEE\x20\x01")) |
| assert bytes(auth_build) == bytes(auth) |
| |
| = Check UDS_AUTHPR |
| |
| authpr = UDS(b"\x69\x05\x00\x03\x00\x05\xFF\x00\x02\xFF\xFE\xBE\x34\x56\x03" + |
| b"\xFF\xEE\x20\x01\x00\x01\xFF\x00\x00") |
| assert authpr.service == 0x69 |
| assert authpr.subFunction == 0x5 |
| assert authpr.returnValue == 0x0 |
| assert authpr.algorithmIndicator == (b"\x03\x00\x05\xFF\x00\x02\xFF\xFE\xBE" + |
| b"\x34\x56\x03\xFF\xEE\x20\x01") |
| assert authpr.lengthOfChallengeServer == 0x1 |
| assert authpr.challengeServer == b"\xFF" |
| assert authpr.lengthOfNeededAdditionalParameter == 0x0 |
| assert authpr.neededAdditionalParameter == b"" |
| |
| assert authpr.answers(auth) |
| |
| = Build UDS_AUTHPR |
| |
| authpr_build = UDS()/UDS_AUTHPR(subFunction=0x5, returnValue=0x0, |
| algorithmIndicator=(b"\x03\x00\x05\xFF\x00" + |
| b"\x02\xFF\xFE\xBE\x34" + |
| b"\x56\x03\xFF\xEE\x20" + |
| b"\x01"), |
| challengeServer=b"\xFF") |
| assert bytes(authpr_build) == bytes(authpr) |
| |
| = Check UDS_AUTH |
| |
| auth = UDS(b"\x29\x06\x03\x00\x05\xFF\x00\x02\xFF\xFE\xBE\x34\x56\x03\xFF" + |
| b"\xEE\x20\x01\x00\x01\xFF\x00\x01\xFF\x00\x00") |
| assert auth.service == 0x29 |
| assert auth.subFunction == 0x6 |
| assert auth.algorithmIndicator == (b"\x03\x00\x05\xFF\x00\x02\xFF\xFE\xBE" + |
| b"\x34\x56\x03\xFF\xEE\x20\x01") |
| assert auth.lengthOfProofOfOwnershipClient == 0x1 |
| assert auth.proofOfOwnershipClient == b"\xFF" |
| assert auth.lengthOfChallengeClient == 0x1 |
| assert auth.challengeClient == b"\xFF" |
| assert auth.lengthOfAdditionalParameter == 0x0 |
| assert auth.additionalParameter == b"" |
| |
| = Build UDS_AUTH |
| |
| auth_build = UDS()/UDS_AUTH(subFunction=0x6, |
| algorithmIndicator=(b"\x03\x00\x05\xFF\x00\x02" + |
| b"\xFF\xFE\xBE\x34\x56\x03" + |
| b"\xFF\xEE\x20\x01"), |
| proofOfOwnershipClient=b"\xFF", |
| challengeClient=b"\xFF") |
| assert bytes(auth_build) == bytes(auth) |
| |
| = Check UDS_AUTHPR |
| |
| authpr = UDS(b"\x69\x06\x00\x03\x00\x05\xFF\x00\x02\xFF\xFE\xBE\x34\x56\x03" + |
| b"\xFF\xEE\x20\x01\x00\x01\xFE") |
| assert authpr.service == 0x69 |
| assert authpr.subFunction == 0x6 |
| assert authpr.returnValue == 0x0 |
| assert auth.algorithmIndicator == (b"\x03\x00\x05\xFF\x00\x02\xFF\xFE\xBE" + |
| b"\x34\x56\x03\xFF\xEE\x20\x01") |
| assert authpr.lengthOfSessionKeyInfo == 0x1 |
| assert authpr.sessionKeyInfo == b"\xFE" |
| |
| assert authpr.answers(auth) |
| |
| = Build UDS_AUTHPR |
| |
| authpr_build = UDS()/UDS_AUTHPR(subFunction=0x6, returnValue=0x0, |
| algorithmIndicator=(b"\x03\x00\x05\xFF\x00" + |
| b"\x02\xFF\xFE\xBE\x34" + |
| b"\x56\x03\xFF\xEE\x20\x01" |
| ), |
| sessionKeyInfo=b"\xFE") |
| assert bytes(authpr_build) == bytes(authpr) |
| |
| = Check UDS_AUTH |
| |
| auth = UDS(b"\x29\x07\x03\x00\x05\xFF\x00\x02\xFF\xFE\xBE\x34\x56\x03\xFF" + |
| b"\xEE\x20\x01\x00\x01\xFF\x00\x01\xFF\x00\x02\xC0\xCA") |
| assert auth.service == 0x29 |
| assert auth.subFunction == 0x7 |
| assert auth.algorithmIndicator == (b"\x03\x00\x05\xFF\x00\x02\xFF\xFE\xBE" + |
| b"\x34\x56\x03\xFF\xEE\x20\x01") |
| assert auth.lengthOfProofOfOwnershipClient == 0x1 |
| assert auth.proofOfOwnershipClient == b"\xFF" |
| assert auth.lengthOfChallengeClient == 0x1 |
| assert auth.challengeClient == b"\xFF" |
| assert auth.lengthOfAdditionalParameter == 0x2 |
| assert auth.additionalParameter == b"\xC0\xCA" |
| |
| = Build UDS_AUTH |
| |
| auth_build = UDS()/UDS_AUTH(subFunction=0x7, |
| algorithmIndicator=(b"\x03\x00\x05\xFF\x00\x02" + |
| b"\xFF\xFE\xBE\x34\x56\x03" + |
| b"\xFF\xEE\x20\x01"), |
| proofOfOwnershipClient=b"\xFF", |
| challengeClient=b"\xFF", |
| additionalParameter=b"\xC0\xCA") |
| assert bytes(auth_build) == bytes(auth) |
| |
| = Check UDS_AUTHPR |
| |
| authpr = UDS(b"\x69\x07\x00\x03\x00\x05\xFF\x00\x02\xFF\xFE\xBE\x34\x56\x03" + |
| b"\xFF\xEE\x20\x01\x00\x02\xFE\x20\x00\x01\xFE") |
| assert authpr.service == 0x69 |
| assert authpr.subFunction == 0x7 |
| assert authpr.returnValue == 0x0 |
| assert auth.algorithmIndicator == (b"\x03\x00\x05\xFF\x00\x02\xFF\xFE\xBE" + |
| b"\x34\x56\x03\xFF\xEE\x20\x01") |
| assert authpr.lengthOfProofOfOwnershipServer == 0x2 |
| assert authpr.proofOfOwnershipServer == b"\xFE\x20" |
| assert authpr.lengthOfSessionKeyInfo == 0x1 |
| assert authpr.sessionKeyInfo == b"\xFE" |
| |
| assert authpr.answers(auth) |
| |
| = Build UDS_AUTHPR |
| |
| authpr_build = UDS()/UDS_AUTHPR(subFunction=0x7, returnValue=0x0, |
| algorithmIndicator=(b"\x03\x00\x05\xFF\x00" + |
| b"\x02\xFF\xFE\xBE\x34" + |
| b"\x56\x03\xFF\xEE\x20\x01" |
| ), |
| proofOfOwnershipServer=b"\xFE\x20", |
| sessionKeyInfo=b"\xFE") |
| assert bytes(authpr_build) == bytes(authpr) |
| |
| = Check UDS_AUTH |
| |
| auth = UDS(b"\x29\x08") |
| assert auth.service == 0x29 |
| assert auth.subFunction == 0x8 |
| |
| = Build UDS_AUTH |
| |
| auth_build = UDS()/UDS_AUTH(subFunction=0x8) |
| assert bytes(auth_build) == bytes(auth) |
| |
| = Check UDS_AUTHPR |
| |
| authpr = UDS(b"\x69\x08\x00") |
| assert authpr.service == 0x69 |
| assert authpr.subFunction == 0x8 |
| assert authpr.returnValue == 0x0 |
| |
| assert authpr.answers(auth) |
| |
| = Build UDS_AUTHPR |
| |
| authpr_build = UDS()/UDS_AUTHPR(subFunction=0x8) |
| assert bytes(authpr_build) == bytes(authpr) |
| |
| = Check UDS_TP |
| |
| tp = UDS(b'\x3E\x01') |
| assert tp.service == 0x3e |
| assert tp.subFunction == 0x1 |
| |
| = Check UDS_TPPR |
| |
| tppr = UDS(b'\x7E\x01') |
| assert tppr.service == 0x7e |
| assert tppr.zeroSubFunction == 0x1 |
| |
| assert tppr.answers(tp) |
| |
| = Check UDS_ATP |
| |
| atp = UDS(b'\x83\x01') |
| assert atp.service == 0x83 |
| assert atp.timingParameterAccessType == 0x1 |
| |
| = Check UDS_ATPPR |
| |
| atppr = UDS(b'\xc3\x01') |
| assert atppr.service == 0xc3 |
| assert atppr.timingParameterAccessType == 0x1 |
| |
| assert atppr.answers(atp) |
| |
| = Check UDS_ATP |
| |
| atp = UDS(b'\x83\x04coffee') |
| assert atp.service == 0x83 |
| assert atp.timingParameterAccessType == 0x4 |
| assert atp.timingParameterRequestRecord == b'coffee' |
| |
| = Check UDS_ATPPR |
| |
| atppr = UDS(b'\xc3\x03coffee') |
| assert atppr.service == 0xc3 |
| assert atppr.timingParameterAccessType == 0x3 |
| assert atppr.timingParameterResponseRecord == b'coffee' |
| |
| = Check UDS_SDT |
| |
| sdt = UDS(b'\x84\x80\x00\x01\x12\x34\x13\x37\x01coffee') |
| assert sdt.service == 0x84 |
| assert sdt.requestMessage == 0x1 |
| assert sdt.preEstablishedKeyUsed == 0x0 |
| assert sdt.encryptedMessage == 0x0 |
| assert sdt.signedMessage == 0x0 |
| assert sdt.signedResponseRequested == 0x0 |
| assert sdt.signatureEncryptionCalculation == 0x1 |
| assert sdt.signatureLength == 0x1234 |
| assert sdt.antiReplayCounter == 0x1337 |
| assert sdt.internalMessageServiceRequestId == 0x1 |
| assert sdt.dataRecord == b'coffee' |
| |
| = Build UDS_SDT |
| |
| sdt = UDS()/UDS_SDT(requestMessage=0x1, signatureEncryptionCalculation=0x1, |
| signatureLength=0x1234, antiReplayCounter=0x1337, |
| internalMessageServiceRequestId=0x1, dataRecord=b'coffee') |
| assert sdt.service == 0x84 |
| assert sdt.requestMessage == 0x1 |
| assert sdt.preEstablishedKeyUsed == 0x0 |
| assert sdt.encryptedMessage == 0x0 |
| assert sdt.signedMessage == 0x0 |
| assert sdt.signedResponseRequested == 0x0 |
| assert sdt.signatureEncryptionCalculation == 0x1 |
| assert sdt.signatureLength == 0x1234 |
| assert sdt.antiReplayCounter == 0x1337 |
| assert sdt.internalMessageServiceRequestId == 0x1 |
| assert sdt.dataRecord == b'coffee' |
| |
| = Check UDS_SDTPR |
| |
| sdtpr = UDS(b'\xC4\x04\x00\x01\x12\x34\x13\x37\x01coffee') |
| assert sdtpr.service == 0xC4 |
| assert sdtpr.requestMessage == 0x0 |
| assert sdtpr.preEstablishedKeyUsed == 0x0 |
| assert sdtpr.encryptedMessage == 0x0 |
| assert sdtpr.signedMessage == 0x1 |
| assert sdtpr.signedResponseRequested == 0x0 |
| assert sdtpr.signatureEncryptionCalculation == 0x1 |
| assert sdtpr.signatureLength == 0x1234 |
| assert sdtpr.antiReplayCounter == 0x1337 |
| assert sdtpr.internalMessageServiceResponseId == 0x1 |
| assert sdtpr.dataRecord == b'coffee' |
| |
| assert sdtpr.answers(sdt) |
| |
| = Check UDS_CDTCS |
| |
| cdtcs = UDS(b'\x85\x00coffee') |
| assert cdtcs.service == 0x85 |
| assert cdtcs.DTCSettingType == 0 |
| assert cdtcs.DTCSettingControlOptionRecord == b'coffee' |
| |
| = Check UDS_CDTCSPR |
| |
| cdtcspr = UDS(b'\xC5\x00') |
| assert cdtcspr.service == 0xC5 |
| assert cdtcspr.DTCSettingType == 0 |
| |
| assert cdtcspr.answers(cdtcs) |
| |
| = Check UDS_ROE |
| |
| roe = UDS(b'\x86\x00\x10coffee') |
| assert roe.service == 0x86 |
| assert roe.eventType == 0 |
| assert roe.eventWindowTime == 16 |
| assert roe.eventTypeRecord == b'coffee' |
| |
| = Check UDS_ROEPR |
| |
| roepr = UDS(b'\xC6\x00\x01\x10coffee') |
| assert roepr.service == 0xC6 |
| assert roepr.eventType == 0 |
| assert roepr.numberOfIdentifiedEvents == 1 |
| assert roepr.eventWindowTime == 16 |
| assert roepr.eventTypeRecord == b'coffee' |
| |
| assert roepr.answers(roe) |
| |
| = Check UDS_LC |
| |
| lc = UDS(b'\x87\x01\x02') |
| assert lc.service == 0x87 |
| assert lc.linkControlType == 0x01 |
| assert lc.baudrateIdentifier == 0x02 |
| |
| = Check UDS_LCPR |
| |
| lcpr = UDS(b'\xC7\x01') |
| assert lcpr.service == 0xC7 |
| assert lcpr.linkControlType == 0x01 |
| |
| assert lcpr.answers(lc) |
| |
| = Check UDS_LC |
| |
| lc = UDS(b'\x87\x02\x02\x03\x04') |
| assert lc.service == 0x87 |
| assert lc.linkControlType == 0x02 |
| assert lc.baudrateHighByte == 0x02 |
| assert lc.baudrateMiddleByte == 0x03 |
| assert lc.baudrateLowByte == 0x04 |
| |
| = Check UDS_RDBI |
| |
| rdbi = UDS(b'\x22\x01\x02') |
| assert rdbi.service == 0x22 |
| assert rdbi.identifiers[0] == 0x0102 |
| |
| = Build UDS_RDBI |
| |
| rdbi = UDS()/UDS_RDBI(identifiers=[0x102]) |
| assert rdbi.service == 0x22 |
| assert rdbi.identifiers[0] == 0x0102 |
| assert bytes(rdbi) == b'\x22\x01\x02' |
| |
| = Check UDS_RDBI2 |
| |
| rdbi = UDS(b'\x22\x01\x02\x03\x04') |
| assert rdbi.service == 0x22 |
| assert rdbi.identifiers[0] == 0x0102 |
| assert rdbi.identifiers[1] == 0x0304 |
| assert raw(rdbi) == b'\x22\x01\x02\x03\x04' |
| |
| = Build UDS_RDBI2 |
| |
| rdbi = UDS()/UDS_RDBI(identifiers=[0x102, 0x304]) |
| assert rdbi.service == 0x22 |
| assert rdbi.identifiers[0] == 0x0102 |
| assert rdbi.identifiers[1] == 0x0304 |
| assert raw(rdbi) == b'\x22\x01\x02\x03\x04' |
| |
| = Test observable dict used in UDS_RDBI, setter |
| |
| UDS_RDBI.dataIdentifiers[0x102] = "turbo" |
| UDS_RDBI.dataIdentifiers[0x103] = "fullspeed" |
| |
| rdbi = UDS()/UDS_RDBI(identifiers=[0x102, 0x103]) |
| |
| assert "turbo" in plain_str(repr(rdbi)) |
| assert "fullspeed" in plain_str(repr(rdbi)) |
| |
| = Test observable dict used in UDS_RDBI, deleter |
| |
| UDS_RDBI.dataIdentifiers[0x102] = "turbo" |
| |
| rdbi = UDS()/UDS_RDBI(identifiers=[0x102, 0x103]) |
| assert "turbo" in plain_str(repr(rdbi)) |
| |
| del UDS_RDBI.dataIdentifiers[0x102] |
| UDS_RDBI.dataIdentifiers[0x103] = "slowspeed" |
| |
| rdbi = UDS()/UDS_RDBI(identifiers=[0x102, 0x103]) |
| |
| assert "turbo" not in plain_str(repr(rdbi)) |
| assert "slowspeed" in plain_str(repr(rdbi)) |
| |
| = Check UDS_RDBIPR |
| |
| rdbipr = UDS(b'\x62\x01\x02dieselgate') |
| assert rdbipr.service == 0x62 |
| assert rdbipr.dataIdentifier == 0x0102 |
| assert rdbipr.load == b'dieselgate' |
| |
| assert rdbipr.answers(rdbi) |
| |
| = Check UDS_RMBA |
| |
| rmba = UDS(b'\x23\x11\x02\x02') |
| assert rmba.service == 0x23 |
| assert rmba.memorySizeLen == 1 |
| assert rmba.memoryAddressLen == 1 |
| assert rmba.memoryAddress1 == 2 |
| assert rmba.memorySize1 == 2 |
| |
| = Check UDS_RMBA |
| |
| rmba = UDS(b'\x23\x22\x02\x02\x03\x03') |
| assert rmba.service == 0x23 |
| assert rmba.memorySizeLen == 2 |
| assert rmba.memoryAddressLen == 2 |
| assert rmba.memoryAddress2 == 0x202 |
| assert rmba.memorySize2 == 0x303 |
| |
| = Check UDS_RMBA |
| |
| rmba = UDS(b'\x23\x33\x02\x02\x02\x03\x03\x03') |
| assert rmba.service == 0x23 |
| assert rmba.memorySizeLen == 3 |
| assert rmba.memoryAddressLen == 3 |
| assert rmba.memoryAddress3 == 0x20202 |
| assert rmba.memorySize3 == 0x30303 |
| |
| = Check UDS_RMBA |
| |
| rmba = UDS(b'\x23\x44\x02\x02\x02\x02\x03\x03\x03\x03') |
| assert rmba.service == 0x23 |
| assert rmba.memorySizeLen == 4 |
| assert rmba.memoryAddressLen == 4 |
| assert rmba.memoryAddress4 == 0x2020202 |
| assert rmba.memorySize4 == 0x3030303 |
| |
| = Check UDS_RMBAPR |
| |
| rmbapr = UDS(b'\x63muchData') |
| assert rmbapr.service == 0x63 |
| assert rmbapr.dataRecord == b'muchData' |
| |
| assert rmbapr.answers(rmba) |
| |
| = Check UDS_RSDBI |
| |
| rsdbi = UDS(b'\x24\x12\x34') |
| assert rsdbi.service == 0x24 |
| assert rsdbi.dataIdentifier == 0x1234 |
| |
| = Check UDS_RSDBIPR |
| |
| rsdbipr = UDS(b'\x64\x12\x34\xffmuchData') |
| assert rsdbipr.service == 0x64 |
| assert rsdbipr.dataIdentifier == 0x1234 |
| assert rsdbipr.scalingByte == 255 |
| assert rsdbipr.dataRecord == b'muchData' |
| |
| assert rsdbipr.answers(rsdbi) |
| |
| = Check UDS_RSDBPI |
| |
| rsdbpi = UDS(b'\x2a\x12\x34coffee') |
| assert rsdbpi.service == 0x2a |
| assert rsdbpi.transmissionMode == 0x12 |
| assert rsdbpi.periodicDataIdentifier == 0x34 |
| assert rsdbpi.furtherPeriodicDataIdentifier == b'coffee' |
| |
| = Check UDS_RSDBPIPR |
| |
| rsdbpipr = UDS(b'\x6a\xff\x12\x34') |
| assert rsdbpipr.service == 0x6a |
| assert rsdbpipr.periodicDataIdentifier == 255 |
| assert rsdbpipr.dataRecord == b'\x12\x34' |
| |
| assert not rsdbpipr.answers(rsdbpi) |
| |
| = Check UDS_RSDBPIPR |
| |
| rsdbpipr = UDS(b'\x6a\x34\x12\x34') |
| assert rsdbpipr.service == 0x6a |
| assert rsdbpipr.periodicDataIdentifier == 0x34 |
| assert rsdbpipr.dataRecord == b'\x12\x34' |
| |
| assert rsdbpipr.answers(rsdbpi) |
| |
| = Check UDS_DDDI |
| |
| dddi = UDS(b'\x2c\x12coffee') |
| assert dddi.service == 0x2c |
| assert dddi.subFunction == 0x12 |
| assert dddi.dataRecord == b'coffee' |
| |
| = Check UDS_DDDIPR |
| |
| dddipr = UDS(b'\x6c\x12\x44\x55') |
| assert dddipr.service == 0x6c |
| assert dddipr.subFunction == 0x12 |
| assert dddipr.dynamicallyDefinedDataIdentifier == 0x4455 |
| |
| assert dddipr.answers(dddi) |
| |
| = Check UDS_WDBI |
| |
| wdbi = UDS(b'\x2e\x01\x02dieselgate') |
| assert wdbi.service == 0x2e |
| assert wdbi.dataIdentifier == 0x0102 |
| assert wdbi.load == b'dieselgate' |
| |
| = Build UDS_WDBI |
| |
| wdbi = UDS()/UDS_WDBI(dataIdentifier=0x0102)/Raw(load=b'dieselgate') |
| assert wdbi.service == 0x2e |
| assert wdbi.dataIdentifier == 0x0102 |
| assert wdbi.load == b'dieselgate' |
| assert bytes(wdbi) == b'\x2e\x01\x02dieselgate' |
| |
| = Check UDS_WDBI |
| |
| wdbi = UDS(b'\x2e\x01\x02dieselgate') |
| assert wdbi.service == 0x2e |
| assert wdbi.dataIdentifier == 0x0102 |
| assert wdbi.load == b'dieselgate' |
| |
| wdbi = UDS(b'\x2e\x02\x02benzingate') |
| assert wdbi.service == 0x2e |
| assert wdbi.dataIdentifier == 0x0202 |
| assert wdbi.load == b'benzingate' |
| |
| |
| = Check UDS_WDBIPR |
| |
| wdbipr = UDS(b'\x6e\x02\x02') |
| assert wdbipr.service == 0x6e |
| assert wdbipr.dataIdentifier == 0x0202 |
| |
| assert wdbipr.answers(wdbi) |
| |
| = Check UDS_WMBA |
| |
| wmba = UDS(b'\x3d\x11\x02\x02muchData') |
| assert wmba.service == 0x3d |
| assert wmba.memorySizeLen == 1 |
| assert wmba.memoryAddressLen == 1 |
| assert wmba.memoryAddress1 == 2 |
| assert wmba.memorySize1 == 2 |
| assert wmba.dataRecord == b'muchData' |
| |
| = Check UDS_WMBAPR |
| |
| wmbapr = UDS(b'\x7d\x11\x02\x02') |
| assert wmbapr.service == 0x7d |
| assert wmbapr.memorySizeLen == 1 |
| assert wmbapr.memoryAddressLen == 1 |
| assert wmbapr.memoryAddress1 == 2 |
| assert wmbapr.memorySize1 == 2 |
| |
| assert wmbapr.answers(wmba) |
| |
| = Check UDS_WMBA |
| |
| wmba = UDS(b'\x3d\x22\x02\x02\x03\x03muchData') |
| assert wmba.service == 0x3d |
| assert wmba.memorySizeLen == 2 |
| assert wmba.memoryAddressLen == 2 |
| assert wmba.memoryAddress2 == 0x202 |
| assert wmba.memorySize2 == 0x303 |
| assert wmba.dataRecord == b'muchData' |
| |
| = Check UDS_WMBAPR |
| |
| wmbapr = UDS(b'\x7d\x22\x02\x02\x03\x03') |
| assert wmbapr.service == 0x7d |
| assert wmbapr.memorySizeLen == 2 |
| assert wmbapr.memoryAddressLen == 2 |
| assert wmbapr.memoryAddress2 == 0x202 |
| assert wmbapr.memorySize2 == 0x303 |
| |
| assert wmbapr.answers(wmba) |
| |
| = Check UDS_WMBA |
| |
| wmba = UDS(b'\x3d\x33\x02\x02\x02\x03\x03\x03muchData') |
| assert wmba.service == 0x3d |
| assert wmba.memorySizeLen == 3 |
| assert wmba.memoryAddressLen == 3 |
| assert wmba.memoryAddress3 == 0x20202 |
| assert wmba.memorySize3 == 0x30303 |
| assert wmba.dataRecord == b'muchData' |
| |
| = Check UDS_WMBA |
| |
| wmba = UDS(b'\x3d\x44\x02\x02\x02\x02\x03\x03\x03\x03muchData') |
| assert wmba.service == 0x3d |
| assert wmba.memorySizeLen == 4 |
| assert wmba.memoryAddressLen == 4 |
| assert wmba.memoryAddress4 == 0x2020202 |
| assert wmba.memorySize4 == 0x3030303 |
| assert wmba.dataRecord == b'muchData' |
| |
| = Check UDS_WMBAPR |
| |
| wmbapr = UDS(b'\x7d\x33\x02\x02\x02\x03\x03\x03') |
| assert wmbapr.service == 0x7d |
| assert wmbapr.memorySizeLen == 3 |
| assert wmbapr.memoryAddressLen == 3 |
| assert wmbapr.memoryAddress3 == 0x20202 |
| assert wmbapr.memorySize3 == 0x30303 |
| |
| assert not wmbapr.answers(wmba) |
| |
| = Check UDS_WMBAPR |
| |
| wmbapr = UDS(b'\x7d\x44\x02\x02\x02\x02\x03\x03\x03\x03') |
| assert wmbapr.service == 0x7d |
| assert wmbapr.memorySizeLen == 4 |
| assert wmbapr.memoryAddressLen == 4 |
| assert wmbapr.memoryAddress4 == 0x2020202 |
| assert wmbapr.memorySize4 == 0x3030303 |
| |
| assert wmbapr.answers(wmba) |
| |
| = Check UDS_CDTCI |
| |
| cdtci = UDS(b'\x14\x44\x02\x03') |
| assert cdtci.service == 0x14 |
| assert cdtci.groupOfDTCHighByte == 0x44 |
| assert cdtci.groupOfDTCMiddleByte == 0x02 |
| assert cdtci.groupOfDTCLowByte == 0x3 |
| |
| = Check UDS_RDTCI |
| |
| rdtci = UDS(b'\x19\x44') |
| assert rdtci.service == 0x19 |
| assert rdtci.reportType == 0x44 |
| |
| = Check UDS_RDTCI |
| |
| rdtci = UDS(b'\x19\x01\xff') |
| assert rdtci.service == 0x19 |
| assert rdtci.reportType == 0x01 |
| assert rdtci.DTCStatusMask == 0xff |
| |
| = Check UDS_RDTCIPR |
| |
| rdtcipr = UDS(b'\x59\x01\xff\xee\xdd\xaa') |
| assert rdtcipr.service == 0x59 |
| assert rdtcipr.reportType == 1 |
| assert rdtcipr.DTCStatusAvailabilityMask == 0xff |
| assert rdtcipr.DTCFormatIdentifier == 0xee |
| assert rdtcipr.DTCCount == 0xddaa |
| |
| assert rdtcipr.answers(rdtci) |
| |
| rdtcipr1 = UDS(b'\x59\x02\xff\x11\x07\x11\'\x022\x12\'\x01\x07\x11\'\x01\x18\x12\'\x01\x13\x12\'\x01"\x11\'\x06C\x00\'\x06S\x00\'\x161\x00\'\x14\x03\x12\'') |
| |
| assert len(rdtcipr1.DTCAndStatusRecord) == 10 |
| assert rdtcipr1.DTCAndStatusRecord[0].dtc.system == 0 |
| assert rdtcipr1.DTCAndStatusRecord[0].dtc.type == 1 |
| assert rdtcipr1.DTCAndStatusRecord[0].dtc.numeric_value_code == 263 |
| assert rdtcipr1.DTCAndStatusRecord[0].dtc.additional_information_code == 17 |
| assert rdtcipr1.DTCAndStatusRecord[0].status == 0x27 |
| assert rdtcipr1.DTCAndStatusRecord[-1].dtc.system == 0 |
| assert rdtcipr1.DTCAndStatusRecord[-1].dtc.type == 1 |
| assert rdtcipr1.DTCAndStatusRecord[-1].dtc.numeric_value_code == 1027 |
| assert rdtcipr1.DTCAndStatusRecord[-1].dtc.additional_information_code == 18 |
| assert rdtcipr1.DTCAndStatusRecord[-1].status == 0x27 |
| |
| = Check UDS_RDTCI |
| |
| rdtci = UDS(b'\x19\x02\xff') |
| assert rdtci.service == 0x19 |
| assert rdtci.reportType == 0x02 |
| assert rdtci.DTCStatusMask == 0xff |
| |
| = Check UDS_RDTCI |
| |
| rdtci = UDS(b'\x19\x0f\xff') |
| assert rdtci.service == 0x19 |
| assert rdtci.reportType == 0x0f |
| assert rdtci.DTCStatusMask == 0xff |
| |
| = Check UDS_RDTCI |
| |
| rdtci = UDS(b'\x19\x11\xff') |
| assert rdtci.service == 0x19 |
| assert rdtci.reportType == 0x11 |
| assert rdtci.DTCStatusMask == 0xff |
| |
| = Check UDS_RDTCI |
| |
| rdtci = UDS(b'\x19\x12\xff') |
| assert rdtci.service == 0x19 |
| assert rdtci.reportType == 0x12 |
| assert rdtci.DTCStatusMask == 0xff |
| |
| = Check UDS_RDTCI |
| |
| rdtci = UDS(b'\x19\x13\xff') |
| assert rdtci.service == 0x19 |
| assert rdtci.reportType == 0x13 |
| assert rdtci.DTCStatusMask == 0xff |
| |
| = Check UDS_RDTCI |
| |
| rdtci = UDS(b'\x19\x03\xff\xee\xdd\xaa') |
| assert rdtci.service == 0x19 |
| assert rdtci.reportType == 0x03 |
| assert rdtci.dtc == DTC(bytes.fromhex("ffeedd")) |
| assert rdtci.DTCSnapshotRecordNumber == 0xaa |
| |
| = Check UDS_RDTCI |
| |
| rdtci = UDS(b'\x19\x04\xff\xee\xdd\xaa') |
| assert rdtci.service == 0x19 |
| assert rdtci.reportType == 0x04 |
| assert rdtci.dtc == DTC(bytes.fromhex("ffeedd")) |
| assert rdtci.DTCSnapshotRecordNumber == 0xaa |
| |
| = Check UDS_RDTCI |
| |
| rdtci = UDS(b'\x19\x05\xaa') |
| assert rdtci.service == 0x19 |
| assert rdtci.reportType == 0x05 |
| assert rdtci.DTCSnapshotRecordNumber == 0xaa |
| |
| = Check UDS_RDTCI |
| |
| rdtci = UDS(b'\x19\x06\xff\xee\xdd\xaa') |
| assert rdtci.service == 0x19 |
| assert rdtci.reportType == 0x06 |
| assert rdtci.dtc == DTC(bytes.fromhex("ffeedd")) |
| assert rdtci.DTCExtendedDataRecordNumber == 0xaa |
| |
| = Check UDS_RDTCI |
| |
| rdtci = UDS(b'\x19\x07\xaa\xbb') |
| assert rdtci.service == 0x19 |
| assert rdtci.reportType == 0x07 |
| assert rdtci.DTCSeverityMask == 0xaa |
| assert rdtci.DTCStatusMask == 0xbb |
| |
| = Check UDS_RDTCI |
| |
| rdtci = UDS(b'\x19\x08\xaa\xbb') |
| assert rdtci.service == 0x19 |
| assert rdtci.reportType == 0x08 |
| assert rdtci.DTCSeverityMask == 0xaa |
| assert rdtci.DTCStatusMask == 0xbb |
| |
| = Check UDS_RDTCI |
| |
| rdtci = UDS(b'\x19\x09\xff\xee\xdd') |
| assert rdtci.service == 0x19 |
| assert rdtci.reportType == 0x09 |
| assert rdtci.dtc == DTC(bytes.fromhex("ffeedd")) |
| |
| = Check UDS_RDTCI |
| |
| rdtci = UDS(b'\x19\x10\xff\xee\xdd\xaa') |
| assert rdtci.service == 0x19 |
| assert rdtci.reportType == 0x10 |
| assert rdtci.dtc == DTC(bytes.fromhex("ffeedd")) |
| assert rdtci.DTCExtendedDataRecordNumber == 0xaa |
| |
| |
| = Check UDS_RDTCIPR |
| |
| rdtcipr = UDS(b'\x59\x02\xff\xee\xdd\xaa\x02') |
| rdtcipr.show() |
| assert rdtcipr.service == 0x59 |
| assert rdtcipr.reportType == 2 |
| assert rdtcipr.DTCStatusAvailabilityMask == 0xff |
| assert rdtcipr.DTCAndStatusRecord[0].dtc.system == 3 |
| assert rdtcipr.DTCAndStatusRecord[0].dtc.type == 2 |
| assert rdtcipr.DTCAndStatusRecord[0].dtc.numeric_value_code == 3805 |
| assert rdtcipr.DTCAndStatusRecord[0].dtc.additional_information_code == 170 |
| assert rdtcipr.DTCAndStatusRecord[0].status == 2 |
| |
| assert not rdtcipr.answers(rdtci) |
| |
| = Check UDS_RDTCIPR |
| |
| rdtcipr = UDS(b'\x59\x03\xff\xee\xdd\xaa') |
| assert rdtcipr.service == 0x59 |
| assert rdtcipr.reportType == 3 |
| assert rdtcipr.dataRecord == b'\xff\xee\xdd\xaa' |
| |
| |
| = Check UDS_RDTCIPR 2 |
| req = UDS(bytes.fromhex("1904480a46ff")) |
| resp = UDS(bytes.fromhex("5904480a46af000b170002ff6417010a8278fa170c2ff1800000800104800200028003400a8004808005054002400a400004010b170002ff6417010a82ec69170c2f2c800000800100800200028003400a80048080050540024017400004")) |
| |
| assert resp.answers(req) |
| |
| req = UDS(bytes.fromhex("1904480a47ff")) |
| resp = UDS(bytes.fromhex("5904480a46af000b170002ff6417010a8278fa170c2ff1800000800104800200028003400a8004808005054002400a400004010b170002ff6417010a82ec69170c2f2c800000800100800200028003400a80048080050540024017400004")) |
| |
| assert not resp.answers(req) |
| |
| req = UDS(bytes.fromhex("1906480a46ff")) |
| resp = UDS(bytes.fromhex("5906480a46af010002070328")) |
| |
| assert resp.answers(req) |
| |
| = Check UDS_RC |
| |
| rc = UDS(b'\x31\x03\xff\xee\xdd\xaa') |
| assert rc.service == 0x31 |
| assert rc.routineControlType == 3 |
| assert rc.routineIdentifier == 0xffee |
| assert rc.load == b'\xdd\xaa' |
| |
| = Check UDS_RC |
| |
| rc = UDS(b'\x31\x03\xff\xee\xdd\xaa') |
| assert rc.service == 0x31 |
| assert rc.routineControlType == 3 |
| assert rc.routineIdentifier == 0xffee |
| assert rc.load == b'\xdd\xaa' |
| |
| |
| = Check UDS_RCPR |
| |
| rcpr = UDS(b'\x71\x03\xff\xee\xdd\xaa') |
| assert rcpr.service == 0x71 |
| assert rcpr.routineControlType == 3 |
| assert rcpr.routineIdentifier == 0xffee |
| assert rcpr.load == b'\xdd\xaa' |
| |
| = Check UDS_RD |
| |
| rd = UDS(b'\x34\xaa\x11\x02\x02') |
| assert rd.service == 0x34 |
| assert rd.dataFormatIdentifier == 0xaa |
| assert rd.memorySizeLen == 1 |
| assert rd.memoryAddressLen == 1 |
| assert rd.memoryAddress1 == 2 |
| assert rd.memorySize1 == 2 |
| |
| |
| = Check UDS_RD |
| |
| rd = UDS(b'\x34\xaa\x22\x02\x02\x03\x03') |
| assert rd.service == 0x34 |
| assert rd.dataFormatIdentifier == 0xaa |
| assert rd.memorySizeLen == 2 |
| assert rd.memoryAddressLen == 2 |
| assert rd.memoryAddress2 == 0x202 |
| assert rd.memorySize2 == 0x303 |
| |
| = Check UDS_RD |
| |
| rd = UDS(b'\x34\xaa\x33\x02\x02\x02\x03\x03\x03') |
| assert rd.service == 0x34 |
| assert rd.dataFormatIdentifier == 0xaa |
| assert rd.memorySizeLen == 3 |
| assert rd.memoryAddressLen == 3 |
| assert rd.memoryAddress3 == 0x20202 |
| assert rd.memorySize3 == 0x30303 |
| |
| = Check UDS_RD |
| |
| rd = UDS(b'\x34\xaa\x44\x02\x02\x02\x02\x03\x03\x03\x03') |
| assert rd.service == 0x34 |
| assert rd.dataFormatIdentifier == 0xaa |
| assert rd.memorySizeLen == 4 |
| assert rd.memoryAddressLen == 4 |
| assert rd.memoryAddress4 == 0x2020202 |
| assert rd.memorySize4 == 0x3030303 |
| |
| |
| = Check UDS_RDPR |
| |
| rdpr = UDS(b'\x74\x40\x02\x02\x02\x02\x03\x03\x03\x03') |
| assert rdpr.service == 0x74 |
| assert rdpr.memorySizeLen == 4 |
| assert rdpr.reserved == 0 |
| assert rdpr.maxNumberOfBlockLength == b'\x02\x02\x02\x02\x03\x03\x03\x03' |
| |
| assert rdpr.answers(rd) |
| |
| = Check UDS_RU |
| |
| ru = UDS(b'\x35\xaa\x11\x02\x02') |
| assert ru.service == 0x35 |
| assert ru.dataFormatIdentifier == 0xaa |
| assert ru.memorySizeLen == 1 |
| assert ru.memoryAddressLen == 1 |
| assert ru.memoryAddress1 == 2 |
| assert ru.memorySize1 == 2 |
| |
| = Check UDS_RU |
| |
| ru = UDS(b'\x35\xaa\x22\x02\x02\x03\x03') |
| assert ru.service == 0x35 |
| assert ru.dataFormatIdentifier == 0xaa |
| assert ru.memorySizeLen == 2 |
| assert ru.memoryAddressLen == 2 |
| assert ru.memoryAddress2 == 0x202 |
| assert ru.memorySize2 == 0x303 |
| |
| |
| = Check UDS_RU |
| |
| ru = UDS(b'\x35\xaa\x33\x02\x02\x02\x03\x03\x03') |
| assert ru.service == 0x35 |
| assert ru.dataFormatIdentifier == 0xaa |
| assert ru.memorySizeLen == 3 |
| assert ru.memoryAddressLen == 3 |
| assert ru.memoryAddress3 == 0x20202 |
| assert ru.memorySize3 == 0x30303 |
| |
| |
| = Check UDS_RU |
| |
| ru = UDS(b'\x35\xaa\x44\x02\x02\x02\x02\x03\x03\x03\x03') |
| assert ru.service == 0x35 |
| assert ru.dataFormatIdentifier == 0xaa |
| assert ru.memorySizeLen == 4 |
| assert ru.memoryAddressLen == 4 |
| assert ru.memoryAddress4 == 0x2020202 |
| assert ru.memorySize4 == 0x3030303 |
| |
| |
| = Check UDS_RUPR |
| |
| rupr = UDS(b'\x75\x40\x02\x02\x02\x02\x03\x03\x03\x03') |
| assert rupr.service == 0x75 |
| assert rupr.memorySizeLen == 4 |
| assert rupr.reserved == 0 |
| assert rupr.maxNumberOfBlockLength == b'\x02\x02\x02\x02\x03\x03\x03\x03' |
| |
| assert rupr.answers(ru) |
| |
| = Check UDS_TD |
| |
| td = UDS(b'\x36\xaapayload') |
| assert td.service == 0x36 |
| assert td.blockSequenceCounter == 0xaa |
| assert td.transferRequestParameterRecord == b'payload' |
| |
| = Check UDS_TD |
| |
| td = UDS(b'\x36\xaapayload') |
| assert td.service == 0x36 |
| assert td.blockSequenceCounter == 0xaa |
| assert td.transferRequestParameterRecord == b'payload' |
| |
| = Check UDS_TDPR |
| |
| tdpr = UDS(b'\x76\xaapayload') |
| assert tdpr.service == 0x76 |
| assert tdpr.blockSequenceCounter == 0xaa |
| assert tdpr.transferResponseParameterRecord == b'payload' |
| |
| assert tdpr.answers(td) |
| |
| = Check UDS_RTE |
| |
| rte = UDS(b'\x37payload') |
| assert rte.service == 0x37 |
| assert rte.transferRequestParameterRecord == b'payload' |
| |
| = Check UDS_RTEPR |
| |
| rtepr = UDS(b'\x77payload') |
| assert rtepr.service == 0x77 |
| assert rtepr.transferResponseParameterRecord == b'payload' |
| |
| assert rtepr.answers(rte) |
| |
| = Check UDS_IOCBI |
| |
| iocbi = UDS(b'\x2f\x23\x34\xffcoffee') |
| assert iocbi.service == 0x2f |
| assert iocbi.dataIdentifier == 0x2334 |
| assert iocbi.load == b'\xffcoffee' |
| |
| = Check UDS_RFT |
| |
| rft = UDS(b'\x38\x01\x00\x1ED:\\mapdata\\europe\\germany1.yxz\x11\x02\xC3\x50\x75\x30') |
| assert rft.service == 0x38 |
| assert rft.modeOfOperation == 0x01 |
| assert rft.filePathAndNameLength == 0x001e |
| assert rft.filePathAndName == b'D:\\mapdata\\europe\\germany1.yxz' |
| assert rft.compressionMethod == 1 |
| assert rft.encryptingMethod == 1 |
| assert rft.fileSizeParameterLength == 0x02 |
| assert rft.fileSizeUnCompressed == b'\xc3\x50' |
| assert rft.fileSizeCompressed == b'\x75\x30' |
| |
| = Build UDS_RFT |
| |
| rft_build = UDS()/UDS_RFT(modeOfOperation=0x1, |
| filePathAndName=(b'D:\\mapdata\\europe\\' + |
| b'germany1.yxz'), |
| compressionMethod=1, encryptingMethod=1, |
| fileSizeUnCompressed=b'\xc3\x50', |
| fileSizeCompressed=b'\x75\x30') |
| assert bytes(rft_build) == bytes(rft) |
| |
| = Check UDS_RFTPR |
| |
| rftpr = UDS(b'\x78\x01\x02\xc3\x50\x11') |
| assert rftpr.service == 0x78 |
| assert rftpr.modeOfOperation == 0x01 |
| assert rftpr.lengthFormatIdentifier == 0x02 |
| assert rftpr.maxNumberOfBlockLength == b'\xc3\x50' |
| assert rftpr.compressionMethod == 1 |
| assert rftpr.encryptingMethod == 1 |
| |
| assert rftpr.answers(rft) |
| |
| = Build UDS_RFTPR |
| rftpr_build = UDS()/UDS_RFTPR(modeOfOperation=0x1, |
| maxNumberOfBlockLength=b'\xc3\x50', |
| compressionMethod=1, encryptingMethod=1) |
| assert bytes(rftpr_build) == bytes(rftpr) |
| |
| = Check (invalid) UDS_NRC, no reply-to service |
| |
| nrc = UDS(b'\x7f') |
| assert nrc.service == 0x7f |
| |
| = Check UDS_NRC |
| |
| nrc = UDS(b'\x7f\x22\x33') |
| assert nrc.service == 0x7f |
| assert nrc.requestServiceId == 0x22 |
| assert nrc.negativeResponseCode == 0x33 |
