Exemplo n.º 1
0
class TestFwFingerprint(unittest.TestCase):
    def assertFingerprints(self, candidates, expected):
        candidates = list(candidates)
        self.assertEqual(len(candidates), 1,
                         f"got more than one candidate: {candidates}")
        self.assertEqual(candidates[0], expected)

    @parameterized.expand([(k, v) for k, v in FW_VERSIONS.items()])
    def test_fw_fingerprint(self, car_model, ecus):
        CP = car.CarParams.new_message()
        for _ in range(200):
            fw = []
            for ecu, fw_versions in ecus.items():
                ecu_name, addr, sub_addr = ecu
                fw.append({
                    "ecu": ecu_name,
                    "fwVersion": random.choice(fw_versions),
                    "address": addr,
                    "subAddress": 0 if sub_addr is None else sub_addr
                })
            CP.carFw = fw
            _, matches = match_fw_to_car(CP.carFw)
            self.assertFingerprints(matches, car_model)

    def test_no_duplicate_fw_versions(self):
        passed = True
        for car_model, ecus in FW_VERSIONS.items():
            for ecu, ecu_fw in ecus.items():
                duplicates = {fw for fw in ecu_fw if ecu_fw.count(fw) > 1}
                if len(duplicates):
                    print(car_model, ECU_NAME[ecu[0]], duplicates)
                    passed = False

        self.assertTrue(passed, "Duplicate FW versions found")
Exemplo n.º 2
0
  def test_no_duplicate_fw_versions(self):
    passed = True
    for car_model, ecus in FW_VERSIONS.items():
      for ecu, ecu_fw in ecus.items():
        duplicates = set([fw for fw in ecu_fw if ecu_fw.count(fw) > 1])
        if len(duplicates):
          print(car_model, ECU_NAME[ecu[0]], duplicates)
          passed = False

    self.assertTrue(passed, "Duplicate FW versions found")
Exemplo n.º 3
0
  def test_blacklisted_ecus(self):
    passed = True
    blacklisted_addrs = (0x7c4, 0x7d0)  # includes A/C ecu and an unknown ecu
    for car_model, ecus in FW_VERSIONS.items():
      CP = interfaces[car_model][0].get_params(car_model)
      if CP.carName == 'subaru':
        for ecu in ecus.keys():
          if ecu[1] in blacklisted_addrs:
            print(f'{car_model}: Blacklisted ecu: (Ecu.{ECU_NAME[ecu[0]]}, {hex(ecu[1])})')
            passed = False

    self.assertTrue(passed, "Blacklisted FW versions found")
Exemplo n.º 4
0
def match_fw_to_car_fuzzy(fw_versions_dict, log=True, exclude=None):
    """Do a fuzzy FW match. This function will return a match, and the number of firmware version
  that were matched uniquely to that specific car. If multiple ECUs uniquely match to different cars
  the match is rejected."""

    # These ECUs are known to be shared between models (EPS only between hybrid/ICE version)
    # Getting this exactly right isn't crucial, but excluding camera and radar makes it almost
    # impossible to get 3 matching versions, even if two models with shared parts are released at the same
    # time and only one is in our database.
    exclude_types = [Ecu.fwdCamera, Ecu.fwdRadar, Ecu.eps, Ecu.debug]

    # Build lookup table from (addr, sub_addr, fw) to list of candidate cars
    all_fw_versions = defaultdict(list)
    for candidate, fw_by_addr in FW_VERSIONS.items():
        if candidate == exclude:
            continue

        for addr, fws in fw_by_addr.items():
            if addr[0] in exclude_types:
                continue
            for f in fws:
                all_fw_versions[(addr[1], addr[2], f)].append(candidate)

    match_count = 0
    candidate = None
    for addr, versions in fw_versions_dict.items():
        for version in versions:
            # All cars that have this FW response on the specified address
            candidates = all_fw_versions[(addr[0], addr[1], version)]

            if len(candidates) == 1:
                match_count += 1
                if candidate is None:
                    candidate = candidates[0]
                # We uniquely matched two different cars. No fuzzy match possible
                elif candidate != candidates[0]:
                    return set()

    if match_count >= 2:
        if log:
            cloudlog.error(
                f"Fingerprinted {candidate} using fuzzy match. {match_count} matching ECUs"
            )
        return {candidate}
    else:
        return set()
Exemplo n.º 5
0
class TestFwFingerprint(unittest.TestCase):
  def assertFingerprints(self, candidates, expected):
    candidates = list(candidates)
    self.assertEqual(len(candidates), 1)
    self.assertEqual(candidates[0], expected)

  def test_rav4_tss2(self):
    CP = car.CarParams.new_message()
    CP.carFw = [
      {"ecu": Ecu.esp,
       "fwVersion": b"\x01F15260R210\x00\x00\x00\x00\x00\x00",
       "address": 1968,
       "subAddress": 0},
      {"ecu": Ecu.engine,
       "fwVersion": b"\x028966342Y8000\x00\x00\x00\x00897CF1201001\x00\x00\x00\x00",
       "address": 1792,
       "subAddress": 0},
      {"ecu": Ecu.eps,
       "fwVersion": b"\x028965B0R01200\x00\x00\x00\x008965B0R02200\x00\x00\x00\x00",
       "address": 1953,
       "subAddress": 0},
      {"ecu": Ecu.fwdRadar,
       "fwVersion": b"\x018821F3301200\x00\x00\x00\x00",
       "address": 1872,
       "subAddress": 15},
      {"ecu": Ecu.fwdCamera,
       "fwVersion": b"\x028646F4203300\x00\x00\x00\x008646G26011A0\x00\x00\x00\x00",
       "address": 1872,
       "subAddress": 109}
    ]

    self.assertFingerprints(match_fw_to_car(CP.carFw), TOYOTA.RAV4_TSS2)

  @parameterized.expand([(k, v) for k, v in FW_VERSIONS.items()])
  def test_fw_fingerprint_all(self, car_model, ecus):
    # TODO: this is too slow, so don't run for now
    return

    ecu_fw_lists = []  # pylint: disable=W0101
    for ecu, fw_versions in ecus.items():
      ecu_name, addr, sub_addr = ecu
      ecu_fw_lists.append([])
      for fw in fw_versions:
        ecu_fw_lists[-1].append({"ecu": ecu_name, "fwVersion": fw, "address": addr,
                                 "subAddress": 0 if sub_addr is None else sub_addr})
    CP = car.CarParams.new_message()
    for car_fw in product(*ecu_fw_lists):
      CP.carFw = car_fw
      self.assertFingerprints(match_fw_to_car(CP.carFw), car_model)

  @parameterized.expand([(k, v) for k, v in FW_VERSIONS.items()])
  def test_fw_fingerprint(self, car_model, ecus):
    CP = car.CarParams.new_message()
    for _ in range(20):
      fw = []
      for ecu, fw_versions in ecus.items():
        ecu_name, addr, sub_addr = ecu
        fw.append({"ecu": ecu_name, "fwVersion": random.choice(fw_versions),
                         "address": addr, "subAddress": 0 if sub_addr is None else sub_addr})
      CP.carFw = fw
      self.assertFingerprints(match_fw_to_car(CP.carFw), car_model)

  def test_no_duplicate_fw_versions(self):
    passed = True
    for car_model, ecus in FW_VERSIONS.items():
      for ecu, ecu_fw in ecus.items():
        duplicates = set([fw for fw in ecu_fw if ecu_fw.count(fw) > 1])
        if len(duplicates):
          print(car_model, ECU_NAME[ecu[0]], duplicates)
          passed = False

    self.assertTrue(passed, "Duplicate FW versions found")
Exemplo n.º 6
0
class TestFwFingerprint(unittest.TestCase):
    def assertFingerprints(self, candidates, expected):
        candidates = list(candidates)
        self.assertEqual(len(candidates), 1,
                         f"got more than one candidate: {candidates}")
        self.assertEqual(candidates[0], expected)

    @parameterized.expand([(k, v) for k, v in FW_VERSIONS.items()])
    def test_fw_fingerprint(self, car_model, ecus):
        CP = car.CarParams.new_message()
        for _ in range(200):
            fw = []
            for ecu, fw_versions in ecus.items():
                ecu_name, addr, sub_addr = ecu
                fw.append({
                    "ecu": ecu_name,
                    "fwVersion": random.choice(fw_versions),
                    "address": addr,
                    "subAddress": 0 if sub_addr is None else sub_addr
                })
            CP.carFw = fw
            _, matches = match_fw_to_car(CP.carFw)
            self.assertFingerprints(matches, car_model)

    def test_no_duplicate_fw_versions(self):
        passed = True
        for car_model, ecus in FW_VERSIONS.items():
            for ecu, ecu_fw in ecus.items():
                duplicates = {fw for fw in ecu_fw if ecu_fw.count(fw) > 1}
                if len(duplicates):
                    print(car_model, ECU_NAME[ecu[0]], duplicates)
                    passed = False

        self.assertTrue(passed, "Duplicate FW versions found")

    def test_blacklisted_ecus(self):
        passed = True
        blacklisted_addrs = (0x7c4, 0x7d0
                             )  # includes A/C ecu and an unknown ecu
        for car_model, ecus in FW_VERSIONS.items():
            CP = interfaces[car_model][0].get_params(car_model)
            if CP.carName == 'subaru':
                for ecu in ecus.keys():
                    if ecu[1] in blacklisted_addrs:
                        print(
                            f'{car_model}: Blacklisted ecu: (Ecu.{ECU_NAME[ecu[0]]}, {hex(ecu[1])})'
                        )
                        passed = False

        self.assertTrue(passed, "Blacklisted FW versions found")

    def test_fw_request_ecu_whitelist(self):
        passed = True
        brands = set(r.brand for r in REQUESTS)
        versions = get_interface_attr('FW_VERSIONS')
        for brand in brands:
            whitelisted_ecus = [
                ecu for r in REQUESTS for ecu in r.whitelist_ecus
                if r.brand == brand
            ]
            brand_ecus = set([
                fw[0] for car_fw in versions[brand].values() for fw in car_fw
            ])

            # each ecu in brand's fw versions needs to be whitelisted at least once
            ecus_not_whitelisted = set(brand_ecus) - set(whitelisted_ecus)
            if len(whitelisted_ecus) and len(ecus_not_whitelisted):
                ecu_strings = ", ".join(
                    [f'Ecu.{ECU_NAME[ecu]}' for ecu in ecus_not_whitelisted])
                print(
                    f'{brand.title()}: FW query whitelist missing ecus: {ecu_strings}'
                )
                passed = False

        self.assertTrue(
            passed, "Not all ecus in FW versions found in query whitelists")