ValedoMotion: как найти лицензионный ключ и как он проверяется

1

C:\ProgramData\Hocoma_AG\ValedoMotion\Configuration.xml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

<ValedoConfiguration>
  <HasMotion>true</HasMotion>
  <HasShape>false</HasShape>
  <License Key="GEspqbSBJMnc4WN">
    <LicensedSensorIds>
      <LicensedSensor>00:11:22:33:44:55</LicensedSensor>
      <LicensedSensor>AA:BB:CC:DD:EE:FF</LicensedSensor>
      <LicensedSensor>11:22:33:44:55:66</LicensedSensor>
    </LicensedSensorIds>
  </License>
  <Signature xmlns="http://www.w3.org/2000/09/xmldsig#">
    <SignedInfo>...</SignedInfo>
    <SignatureValue>...</SignatureValue>
    <KeyInfo>...</KeyInfo>
  </Signature>
</ValedoConfiguration>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

ValedoMotion (GUI)          IMUSensorAPI.ServiceHost (консольный процесс, ПК)       BLE-датчики
       │                              │                                                 │
       │  1. ValidateLicenseKey(key)  │                                                 │
       │  ──── Named Pipe WCF ──────► │                                                 │
       │                              │                                                 │
       │                              │  2. Сканирует BLE-эфир через донгл               │
       │                              │     Получает MAC-адреса датчиков                 │
       │                              │◄────────────────────────────────────────────────│
       │                              │                                                 │
       │                              │  3. Вызывает нативную C++ DLL (на ПК):            │
       │                              │     validateSensors_C(mac[], key)                │
       │                              │     (Hocoma.Common.SensorValidation.dll)         │
       │                              │                                                 │
       │                              │  4. DLL декодирует ключ в 3 шаблона              │
       │                              │     Сравнивает с MAC-адресами датчиков           │
       │                              │                                                 │
       │  5. OnLicenseKeyValidated()  │                                                 │
       │  ◄──── Named Pipe WCF ────── │                                                 │
       │                              │                                                 │
       │  6. sensors.Length == 3 ?    │                                                 │
       │     ок : ошибка              │                                                 │
       │     MAC-адреса → Configuration.xml (whitelist)                                 │

1
2
3
4

Ключ:         G  E  s  p  q  |  b  S  B  J  M  |  n  c  4  W  N
Позиция:      0  1  2  3  4  |  5  6  7  8  9  | 10 11 12 13 14
Таблица №:    0  1  2  3  4  |  0  1  2  3  4  |  0  1  2  3  4
Hex-цифра:    3  9  9  a  a  |  b  d  e  b  c  |  8  e  f  f  f

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

"""
Реализация алгоритма лицензионного ключа ValedoMotion на Python.
Основана на реверс-инжиниринге Hocoma.Common.SensorValidation.dll (Hex-Rays).
"""

# Таблицы подстановки (codes[5][16]) — 5 перестановок 16 символов, соответствующих hex-цифрам 0..f
CODES = [
    "627GDFMKnp5bxPuY",
    "Zv4K9p5jAEWTUScB",
    "Nf5ryP78Hsk3WSB4",
    "HCa7xR64uhpJZKAW",
    "tJTdS9rYghqpM5PN",
]

# Карта позиций: какие индексы 12-символьного шаблона заполняются для каждого из 3 сенсоров
INDICES = [
    [0, 1, 2, 3, 6],   # сенсор 0: байты 0-1 + старший полубайт байта 3
    [0, 1, 2, 3, 7],   # сенсор 1: байты 0-1 + младший полубайт байта 3
    [0, 1, 2, 3, 8],   # сенсор 2: байты 0-1 + старший полубайт байта 4
]

def invmap(char, code_num):
    """
    Поиск символа в таблице CODES[code_num].
    Позиция (0..15) → hex-цифра: 0→'0'...9→'9', 10→'a'...15→'f'.
    Не найден → '-'.
    """
    table = CODES[code_num]
    for pos, c in enumerate(table):
        if c == char:
            return "0123456789abcdef"[pos]
    return "-"


def generate_license_key(sensor_macs):
    """
    Генерация 15-символьного лицензионного ключа по трём MAC-адресам датчиков.
    
    Аргументы:
        sensor_macs: список 3 строк, каждая — MAC без разделителей (12 hex-цифр), 
                     например ["AABBCCDDEEFF", "112233445566", "001122334455"]
    
    Возвращает:
        15-символьный лицензионный ключ
    """
    assert len(sensor_macs) == 3, "Нужно ровно 3 MAC-адреса"
    for mac in sensor_macs:
        assert len(mac) == 12 and all(c in "0123456789abcdefABCDEF" for c in mac), \
            f"Некорректный MAC: {mac}"
    
    key_chars = []
    for slot, mac in enumerate(sensor_macs):
        mac_lower = mac.lower()
        for col in range(5):
            # Извлекаем hex-цифру из MAC по индексу INDICES[slot][col]
            mac_pos = INDICES[slot][col]
            hex_char = mac_lower[mac_pos]
            # Преобразуем hex-цифру в позицию (0..15)
            hex_val = int(hex_char, 16)
            # Берём символ из соответствующей таблицы
            key_char = CODES[col][hex_val]
            key_chars.append(key_char)
    return "".join(key_chars)


def validate_license_key(key, discovered_macs):
    """
    Проверка лицензионного ключа против обнаруженных MAC-адресов датчиков.
    
    Аргументы:
        key: 15-символьный лицензионный ключ
        discovered_macs: список MAC-адресов без разделителей (12 hex-цифр каждый),
                         полученных через BLE-сканирование
    
    Возвращает:
        (is_valid, validated_macs) — кортеж:
        - is_valid: bool, True если найдено ровно 3 совпадения
        - validated_macs: список ID валидированных датчиков (пустые строки для несовпавших)
    """
    assert len(key) == 15, f"Ключ должен быть 15 символов, получено {len(key)}"
    
    # Очищаем MAC-адреса от пробелов, двоеточий, тире
    clean_macs = []
    for mac in discovered_macs:
        clean = mac.replace(":", "").replace("-", "").replace(" ", "").lower()
        if len(clean) == 12:
            clean_macs.append(clean)
    
    # Декодируем ключ в 3 шаблона по 12 hex-цифр
    invkeys = [list("000000000000") for _ in range(3)]
    for slot in range(3):
        for col in range(5):
            key_char = key[slot * 5 + col]
            hex_digit = invmap(key_char, col)
            invkeys[slot][INDICES[slot][col]] = hex_digit
    
    # Сравниваем каждый шаблон со всеми обнаруженными MAC
    validated = ["------------------", "------------------", "------------------"]
    for slot in range(3):
        positions = INDICES[slot]
        for mac in clean_macs:
            if all(invkeys[slot][pos] == mac[pos] for pos in positions):
                validated[slot] = mac
                break
    
    valid_count = sum(1 for v in validated if v != "------------------")
    is_valid = valid_count == 3
    return is_valid, validated


# ─── Пример использования ─────────────────────────────────────────────

if __name__ == "__main__":
    # Три MAC-адреса датчиков Valedo (вымышленные)
    sensors = ["AABBCCDDEEFF", "112233445566", "001122334455"]
    
    # Генерация ключа
    license_key = generate_license_key(sensors)
    print(f"Сгенерированный ключ: {license_key}")
    # Пример вывода: 15 символов, каждый из своей таблицы подстановки
    
    # Проверка ключа (имитация BLE-сканирования — все 3 датчика в эфире)
    ok, validated = validate_license_key(license_key, sensors)
    print(f"Все три датчика: valid={ok}, sensors={validated}")
    
    # Проверка с чужими датчиками
    ok, validated = validate_license_key(license_key, ["FFEEDDCCBBAA", "000000000000", "DEADBEEF1234"])
    print(f"Чужие датчики:  valid={ok}, sensors={validated}")
    
    # Проверка с неполным набором (только 2 из 3)
    ok, validated = validate_license_key(license_key, sensors[:2])
    print(f"Только 2 датчика: valid={ok}, sensors={validated}")

1
2
3

// SensorService2.cs:998
bool isEqual = sensors.Length == 3;
// Если не 3 — лицензия не валидна

1
2
3
4
5
6
7
8
9

// Hocoma.Valedo.Startup/LicensePresenter.cs:39-41 — полная логика:
private bool CheckNextButtonState()
{
    return (HasMotion || HasShape) && (
        (HasShape && !HasMotion)                              // ValedoShape без Motion → ок
        || (HasMotion && !string.IsNullOrEmpty(LicenseKey)    // ValedoMotion → нужен ключ
            && SensorIds.Any())                                // и минимум 1 сенсор
        );
}

1
2

BeforeTimeOutActions  →  StopExternalServices  →  IMUSensorAPI убит  →  индикаторы пропали
AfterTimeOutActions   →  диалог «Error logging in»

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

ValedoMotion.exe                      Hocoma.ExerciseHost.Main.exe (GAL)
      │                                           │
      │  WebSocket ws://localhost:46544            │
      │  «<ExerciseHostServiceReady/>» ◄────────── │  я запустился
      │  «<ControlRunning>ValedoMotion» ──────────►│  бери управление
      │  «<Hide/>» ───────────────────────────────►│  спрячь окно
      │                                           │
      │  WCF Named Pipe                            │
      │  net.pipe://localhost/Hocoma/ExerciseHost/ │
      │  GetAvailableExercises() ─────────────────►│
      │  GetGameVersions() ───────────────────────►│
      │  StopApplication() ───────────────────────►│