pydanfoss-cloud 0.1.0__tar.gz
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pydanfoss_cloud-0.1.0/LICENSE +21 -0
- pydanfoss_cloud-0.1.0/PKG-INFO +71 -0
- pydanfoss_cloud-0.1.0/README.md +115 -0
- pydanfoss_cloud-0.1.0/custom_components/danfoss_ally_cloud/api/README.md +44 -0
- pydanfoss_cloud-0.1.0/custom_components/danfoss_ally_cloud/api/__init__.py +49 -0
- pydanfoss_cloud-0.1.0/custom_components/danfoss_ally_cloud/api/_tuya/__init__.py +10 -0
- pydanfoss_cloud-0.1.0/custom_components/danfoss_ally_cloud/api/_tuya/http.py +246 -0
- pydanfoss_cloud-0.1.0/custom_components/danfoss_ally_cloud/api/_tuya/postdata.py +113 -0
- pydanfoss_cloud-0.1.0/custom_components/danfoss_ally_cloud/api/_tuya/sign.py +80 -0
- pydanfoss_cloud-0.1.0/custom_components/danfoss_ally_cloud/api/client.py +514 -0
- pydanfoss_cloud-0.1.0/custom_components/danfoss_ally_cloud/api/const.py +76 -0
- pydanfoss_cloud-0.1.0/custom_components/danfoss_ally_cloud/api/decode.py +236 -0
- pydanfoss_cloud-0.1.0/custom_components/danfoss_ally_cloud/api/keys.py +49 -0
- pydanfoss_cloud-0.1.0/custom_components/danfoss_ally_cloud/api/local/__init__.py +1 -0
- pydanfoss_cloud-0.1.0/custom_components/danfoss_ally_cloud/api/local/manager.py +98 -0
- pydanfoss_cloud-0.1.0/custom_components/danfoss_ally_cloud/api/local/tunnel.py +727 -0
- pydanfoss_cloud-0.1.0/custom_components/danfoss_ally_cloud/api/rooms.py +70 -0
- pydanfoss_cloud-0.1.0/custom_components/danfoss_ally_cloud/api/schedule.py +250 -0
- pydanfoss_cloud-0.1.0/custom_components/danfoss_ally_cloud/api/writes.py +28 -0
- pydanfoss_cloud-0.1.0/pydanfoss_cloud.egg-info/PKG-INFO +71 -0
- pydanfoss_cloud-0.1.0/pydanfoss_cloud.egg-info/SOURCES.txt +54 -0
- pydanfoss_cloud-0.1.0/pydanfoss_cloud.egg-info/dependency_links.txt +1 -0
- pydanfoss_cloud-0.1.0/pydanfoss_cloud.egg-info/requires.txt +5 -0
- pydanfoss_cloud-0.1.0/pydanfoss_cloud.egg-info/top_level.txt +1 -0
- pydanfoss_cloud-0.1.0/pyproject.toml +77 -0
- pydanfoss_cloud-0.1.0/setup.cfg +4 -0
- pydanfoss_cloud-0.1.0/tests/test_client.py +28 -0
- pydanfoss_cloud-0.1.0/tests/test_client_async.py +265 -0
- pydanfoss_cloud-0.1.0/tests/test_climate.py +156 -0
- pydanfoss_cloud-0.1.0/tests/test_config_flow.py +84 -0
- pydanfoss_cloud-0.1.0/tests/test_coordinator_local.py +74 -0
- pydanfoss_cloud-0.1.0/tests/test_crypto.py +44 -0
- pydanfoss_cloud-0.1.0/tests/test_decode.py +140 -0
- pydanfoss_cloud-0.1.0/tests/test_diagnostics.py +43 -0
- pydanfoss_cloud-0.1.0/tests/test_frontend.py +114 -0
- pydanfoss_cloud-0.1.0/tests/test_http.py +117 -0
- pydanfoss_cloud-0.1.0/tests/test_import_platforms.py +22 -0
- pydanfoss_cloud-0.1.0/tests/test_keys.py +29 -0
- pydanfoss_cloud-0.1.0/tests/test_manager.py +122 -0
- pydanfoss_cloud-0.1.0/tests/test_mqtt.py +149 -0
- pydanfoss_cloud-0.1.0/tests/test_number.py +113 -0
- pydanfoss_cloud-0.1.0/tests/test_operations.py +156 -0
- pydanfoss_cloud-0.1.0/tests/test_rooms.py +47 -0
- pydanfoss_cloud-0.1.0/tests/test_rooms_schedule.py +96 -0
- pydanfoss_cloud-0.1.0/tests/test_schedule.py +49 -0
- pydanfoss_cloud-0.1.0/tests/test_schedule_contract.py +87 -0
- pydanfoss_cloud-0.1.0/tests/test_services_ws.py +175 -0
- pydanfoss_cloud-0.1.0/tests/test_setup.py +105 -0
- pydanfoss_cloud-0.1.0/tests/test_setup_local.py +144 -0
- pydanfoss_cloud-0.1.0/tests/test_smoke.py +19 -0
- pydanfoss_cloud-0.1.0/tests/test_switch.py +128 -0
- pydanfoss_cloud-0.1.0/tests/test_tunnel.py +141 -0
- pydanfoss_cloud-0.1.0/tests/test_tunnel_more.py +263 -0
- pydanfoss_cloud-0.1.0/tests/test_tunnel_parity.py +434 -0
- pydanfoss_cloud-0.1.0/tests/test_writejob.py +54 -0
- pydanfoss_cloud-0.1.0/tests/test_writes.py +61 -0
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
MIT License
|
|
2
|
+
|
|
3
|
+
Copyright (c) 2026 Remi Poittevin
|
|
4
|
+
|
|
5
|
+
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
6
|
+
of this software and associated documentation files (the "Software"), to deal
|
|
7
|
+
in the Software without restriction, including without limitation the rights
|
|
8
|
+
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
9
|
+
copies of the Software, and to permit persons to whom the Software is
|
|
10
|
+
furnished to do so, subject to the following conditions:
|
|
11
|
+
|
|
12
|
+
The above copyright notice and this permission notice shall be included in all
|
|
13
|
+
copies or substantial portions of the Software.
|
|
14
|
+
|
|
15
|
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
16
|
+
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
17
|
+
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
18
|
+
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
19
|
+
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
20
|
+
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
21
|
+
SOFTWARE.
|
|
@@ -0,0 +1,71 @@
|
|
|
1
|
+
Metadata-Version: 2.4
|
|
2
|
+
Name: pydanfoss-cloud
|
|
3
|
+
Version: 0.1.0
|
|
4
|
+
Summary: Accès à l'API cloud non officielle Danfoss Ally (voie 1a) : client, décodage DP, écritures gardées, clés passerelles, tunnel Zigbee local.
|
|
5
|
+
Author: aghulas
|
|
6
|
+
License-Expression: MIT
|
|
7
|
+
Project-URL: Homepage, https://github.com/aghulas/ha-danfoss-ally
|
|
8
|
+
Project-URL: Repository, https://github.com/aghulas/ha-danfoss-ally
|
|
9
|
+
Project-URL: Issues, https://github.com/aghulas/ha-danfoss-ally/issues
|
|
10
|
+
Keywords: danfoss,ally,thermostat,zigbee,tuya,home-assistant,heating
|
|
11
|
+
Classifier: Development Status :: 4 - Beta
|
|
12
|
+
Classifier: Intended Audience :: Developers
|
|
13
|
+
Classifier: Operating System :: OS Independent
|
|
14
|
+
Classifier: Programming Language :: Python :: 3
|
|
15
|
+
Classifier: Programming Language :: Python :: 3.11
|
|
16
|
+
Classifier: Programming Language :: Python :: 3.12
|
|
17
|
+
Classifier: Topic :: Home Automation
|
|
18
|
+
Classifier: Typing :: Typed
|
|
19
|
+
Requires-Python: >=3.11
|
|
20
|
+
Description-Content-Type: text/markdown
|
|
21
|
+
License-File: LICENSE
|
|
22
|
+
Requires-Dist: pycryptodome>=3.20
|
|
23
|
+
Requires-Dist: requests>=2.31
|
|
24
|
+
Provides-Extra: local
|
|
25
|
+
Requires-Dist: tinytuya>=1.15; extra == "local"
|
|
26
|
+
Dynamic: license-file
|
|
27
|
+
|
|
28
|
+
# pydanfoss-cloud
|
|
29
|
+
|
|
30
|
+
Bibliothèque d'accès à l'**API cloud non officielle Danfoss Ally** (voie 1a, celle de
|
|
31
|
+
l'application mobile — sans application développeur ni quota partagé), extraite de l'intégration
|
|
32
|
+
Home Assistant [`danfoss_ally_cloud`](https://github.com/aghulas/ha-danfoss-ally). **Sans dépendance
|
|
33
|
+
Home Assistant.**
|
|
34
|
+
|
|
35
|
+
Elle fournit :
|
|
36
|
+
|
|
37
|
+
- `CloudClient` — login email/mot de passe (+ secrets d'installation), liste des têtes, écritures
|
|
38
|
+
gardées (`tuya.m.custom.wkf.settings.change`), re-authentification robuste.
|
|
39
|
+
- `decode` / `DanfossDevice` — décodage des `dps` Tuya en un modèle normalisé (schéma produit
|
|
40
|
+
`03wvrwpv`), décodage des codes défaut E1–E15.
|
|
41
|
+
- `writes` — validation des valeurs avant envoi et garde-fou par modèle.
|
|
42
|
+
- `keys` — récupération des `localKey` + IP LAN des passerelles depuis le cloud.
|
|
43
|
+
- `local/` — tunnel Zigbee local (DP 198→199, tinytuya) : lecture/écriture d'attributs (pré-chauffage
|
|
44
|
+
0x0025), programme hebdomadaire.
|
|
45
|
+
|
|
46
|
+
## Statut d'extraction (roadmap v0.6)
|
|
47
|
+
|
|
48
|
+
Source **unique** : ce dossier (`custom_components/danfoss_ally_cloud/api/`). Il est packagé sous le
|
|
49
|
+
nom `pydanfoss_cloud` par le `pyproject.toml` du dépôt, **sans déplacement de fichiers** :
|
|
50
|
+
|
|
51
|
+
- l'intégration Home Assistant continue de « vendre » ce code (import relatif `from .api import …`),
|
|
52
|
+
ce qui garde l'installation HACS autonome ;
|
|
53
|
+
- le connecteur MCP (`danfoss-ally-mcp`) pourra en dépendre via `pip install pydanfoss-cloud` une
|
|
54
|
+
fois la bibliothèque **publiée sur PyPI**, puis l'intégration basculera vers une dépendance
|
|
55
|
+
`requirements` du `manifest.json`.
|
|
56
|
+
|
|
57
|
+
Installation en développement :
|
|
58
|
+
|
|
59
|
+
```
|
|
60
|
+
pip install -e . # expose le paquet pydanfoss_cloud
|
|
61
|
+
pip install -e '.[local]' # + tinytuya pour le tunnel local
|
|
62
|
+
```
|
|
63
|
+
|
|
64
|
+
## Dépendances
|
|
65
|
+
|
|
66
|
+
`pycryptodome`, `requests` (cœur) ; `tinytuya` (extra `local`, tunnel Zigbee). Python ≥ 3.12.
|
|
67
|
+
|
|
68
|
+
## Avertissement
|
|
69
|
+
|
|
70
|
+
API non documentée, obtenue par observation du protocole de l'application : elle peut changer ou
|
|
71
|
+
être coupée. Secrets (jeton de session, `localKey`, identifiants) : jamais journalisés ni commités.
|
|
@@ -0,0 +1,115 @@
|
|
|
1
|
+
# Danfoss Ally (Cloud) — intégration Home Assistant
|
|
2
|
+
|
|
3
|
+
Intégration communautaire **non officielle** pour les têtes thermostatiques
|
|
4
|
+
Danfoss Ally, qui parle à la **même API cloud que l'application mobile** — sans
|
|
5
|
+
application développeur ni clé API, sans quota partagé.
|
|
6
|
+
|
|
7
|
+
Objectifs :
|
|
8
|
+
- mise en route simple (identifiants de l'app) ;
|
|
9
|
+
- toutes les fonctions du cloud, y compris celles absentes de l'API publique
|
|
10
|
+
(programme hebdomadaire, détection de fenêtre, verrouillage enfant…) ;
|
|
11
|
+
- récupération automatique des **clés locales des passerelles** pour un accès
|
|
12
|
+
Zigbee direct, sans émulateur ni Frida ;
|
|
13
|
+
- **publication MQTT** des appareils, en deux modes configurables : MQTT
|
|
14
|
+
Discovery de HA, ou structure de topics compatible zigbee2mqtt.
|
|
15
|
+
|
|
16
|
+
## Avertissement
|
|
17
|
+
|
|
18
|
+
Projet indépendant, **non affilié à Danfoss ni à Tuya**. L'API cloud est
|
|
19
|
+
non documentée et obtenue par observation du protocole réseau de l'application.
|
|
20
|
+
Elle peut changer ou être coupée à tout moment, ce qui casserait l'intégration.
|
|
21
|
+
À utiliser à vos risques. Les mots de passe ne sont jamais demandés par Home
|
|
22
|
+
Assistant en dehors de l'écran de connexion de l'intégration.
|
|
23
|
+
|
|
24
|
+
## Installation (dépôt custom)
|
|
25
|
+
|
|
26
|
+
1. HACS → ⋮ → Dépôts personnalisés → ajouter `https://github.com/aghulas/ha-danfoss-ally` (catégorie Intégration).
|
|
27
|
+
2. Installer « Danfoss Ally (Cloud) », redémarrer Home Assistant.
|
|
28
|
+
3. Réglages → Appareils et services → Ajouter une intégration.
|
|
29
|
+
|
|
30
|
+
## Configuration
|
|
31
|
+
|
|
32
|
+
L'écran de configuration demande :
|
|
33
|
+
|
|
34
|
+
- **Identifiant / Mot de passe** : le compte de l'application Danfoss Ally / Smart Life.
|
|
35
|
+
- **Indicatif pays** : ex. `33` pour la France.
|
|
36
|
+
- **Datacenter** : `eu`, `us`, `cn` ou `in` (France → `eu`).
|
|
37
|
+
- **Secrets d'installation** : `sign_key`, `device_id` (`deviceId`), `ch_key` (`chKey`).
|
|
38
|
+
|
|
39
|
+
Les trois secrets d'installation sont propres à une installation de l'application et **se
|
|
40
|
+
capturent une fois** (ils restent stables ensuite). Ils sont indispensables à la signature et au
|
|
41
|
+
chiffrement de l'API mobile Tuya ; le serveur refuse un `chKey` inconnu. La méthode de capture est
|
|
42
|
+
décrite dans `docs/` (hook natif / capture réseau). Ces valeurs, le mot de passe et le matériel de
|
|
43
|
+
session (`sid`/`ecode`) sont des **secrets** : ils ne sont jamais écrits dans les journaux ni les
|
|
44
|
+
diagnostics (voir `diagnostics.py`).
|
|
45
|
+
|
|
46
|
+
> **Un seul client par jeu de secrets.** Côté serveur Tuya, ce triplet identifie une seule
|
|
47
|
+
> installation, donc une seule session active. Si le connecteur MCP `danfoss-ally-mcp` utilise le
|
|
48
|
+
> **même** triplet sur le même compte, les deux se délogent mutuellement : ne pas les faire tourner
|
|
49
|
+
> en parallèle, ou capturer un triplet distinct pour chacun. Détail dans
|
|
50
|
+
> [`docs/architecture.md`](docs/architecture.md) (« Session Tuya partagée avec le connecteur MCP »).
|
|
51
|
+
|
|
52
|
+
## Interface embarquée (carte de tableau de bord)
|
|
53
|
+
|
|
54
|
+
L'intégration **livre sa propre carte Lovelace** `danfoss-ally-schedule-card` (programme d'une
|
|
55
|
+
pièce). Rien à installer de plus : après l'installation par HACS et un redémarrage, la carte
|
|
56
|
+
apparaît directement dans le **sélecteur de cartes** (« Ajouter une carte »).
|
|
57
|
+
|
|
58
|
+

|
|
59
|
+
|
|
60
|
+
La carte affiche, en lecture, pour la pièce choisie : son nom, les consignes **confort** et
|
|
61
|
+
**réduit**, la **grille des sept jours** (plages de confort positionnées sur 24 h), l'**état des
|
|
62
|
+
têtes** (en ligne, programme actif, incohérente, en montage — icônes et infobulles), un bouton
|
|
63
|
+
**« actualiser »** et la **date de dernière lecture**. Thème clair / sombre par les variables de
|
|
64
|
+
Home Assistant, utilisable au clavier, textes traduits `en` / `fr`. L'édition viendra plus tard.
|
|
65
|
+
|
|
66
|
+
Comment ça marche :
|
|
67
|
+
|
|
68
|
+
- l'intégration sert son interface à l'URL `/danfoss_ally_cloud/frontend/` et déclare la ressource
|
|
69
|
+
`…/danfoss-ally-cloud.js?v=<version>` pour les tableaux de bord **en mode stockage** (le mode par
|
|
70
|
+
défaut) — aucune manipulation manuelle n'est nécessaire ;
|
|
71
|
+
- la carte vérifie sa version au chargement et **propose de recharger** la page quand une nouvelle
|
|
72
|
+
version a été installée.
|
|
73
|
+
|
|
74
|
+
### Tableau de bord en mode YAML
|
|
75
|
+
|
|
76
|
+
En mode YAML, les ressources ne sont pas gérées par l'interface : ajoutez-la une fois à la main.
|
|
77
|
+
|
|
78
|
+
```yaml
|
|
79
|
+
# configuration.yaml (ou le fichier de ressources du tableau de bord)
|
|
80
|
+
lovelace:
|
|
81
|
+
mode: yaml
|
|
82
|
+
resources:
|
|
83
|
+
- url: /danfoss_ally_cloud/frontend/danfoss-ally-cloud.js
|
|
84
|
+
type: module
|
|
85
|
+
```
|
|
86
|
+
|
|
87
|
+
Puis, dans une carte manuelle :
|
|
88
|
+
|
|
89
|
+
```yaml
|
|
90
|
+
type: custom:danfoss-ally-schedule-card
|
|
91
|
+
room_id: "13000000" # group_id de la pièce
|
|
92
|
+
```
|
|
93
|
+
|
|
94
|
+
### Développer l'interface
|
|
95
|
+
|
|
96
|
+
Les sources TypeScript + Lit sont dans `frontend/`. Le bundle **est versionné** dans le dépôt
|
|
97
|
+
(`custom_components/danfoss_ally_cloud/frontend/danfoss-ally-cloud.js`) pour que HACS fonctionne
|
|
98
|
+
depuis n'importe quelle branche ou étiquette. Commande de build **exacte** (sortie déterministe,
|
|
99
|
+
vérifiée en CI) :
|
|
100
|
+
|
|
101
|
+
```bash
|
|
102
|
+
npm --prefix frontend ci
|
|
103
|
+
npm --prefix frontend run build # régénère le bundle versionné
|
|
104
|
+
```
|
|
105
|
+
|
|
106
|
+
Autres commandes : `npm --prefix frontend test` (Vitest), `npm --prefix frontend run typecheck`,
|
|
107
|
+
et `npm --prefix frontend run demo` (page de démonstration hors Home Assistant, données d'essai
|
|
108
|
+
synthétiques, sur http://localhost:5173/demo/).
|
|
109
|
+
|
|
110
|
+
## État
|
|
111
|
+
|
|
112
|
+
**v0.1 — lecture seule cloud** : chaque tête apparaît comme un thermostat (température, consigne) ;
|
|
113
|
+
capteurs batterie, ouverture de vanne, code défaut ; capteurs binaires en ligne / fenêtre. Pas
|
|
114
|
+
encore d'écriture. Interface embarquée : carte `danfoss-ally-schedule-card` en **lecture**
|
|
115
|
+
(consignes, grille hebdomadaire, état des têtes, actualisation). Voir `docs/roadmap.md`.
|
|
@@ -0,0 +1,44 @@
|
|
|
1
|
+
# pydanfoss-cloud
|
|
2
|
+
|
|
3
|
+
Bibliothèque d'accès à l'**API cloud non officielle Danfoss Ally** (voie 1a, celle de
|
|
4
|
+
l'application mobile — sans application développeur ni quota partagé), extraite de l'intégration
|
|
5
|
+
Home Assistant [`danfoss_ally_cloud`](https://github.com/aghulas/ha-danfoss-ally). **Sans dépendance
|
|
6
|
+
Home Assistant.**
|
|
7
|
+
|
|
8
|
+
Elle fournit :
|
|
9
|
+
|
|
10
|
+
- `CloudClient` — login email/mot de passe (+ secrets d'installation), liste des têtes, écritures
|
|
11
|
+
gardées (`tuya.m.custom.wkf.settings.change`), re-authentification robuste.
|
|
12
|
+
- `decode` / `DanfossDevice` — décodage des `dps` Tuya en un modèle normalisé (schéma produit
|
|
13
|
+
`03wvrwpv`), décodage des codes défaut E1–E15.
|
|
14
|
+
- `writes` — validation des valeurs avant envoi et garde-fou par modèle.
|
|
15
|
+
- `keys` — récupération des `localKey` + IP LAN des passerelles depuis le cloud.
|
|
16
|
+
- `local/` — tunnel Zigbee local (DP 198→199, tinytuya) : lecture/écriture d'attributs (pré-chauffage
|
|
17
|
+
0x0025), programme hebdomadaire.
|
|
18
|
+
|
|
19
|
+
## Statut d'extraction (roadmap v0.6)
|
|
20
|
+
|
|
21
|
+
Source **unique** : ce dossier (`custom_components/danfoss_ally_cloud/api/`). Il est packagé sous le
|
|
22
|
+
nom `pydanfoss_cloud` par le `pyproject.toml` du dépôt, **sans déplacement de fichiers** :
|
|
23
|
+
|
|
24
|
+
- l'intégration Home Assistant continue de « vendre » ce code (import relatif `from .api import …`),
|
|
25
|
+
ce qui garde l'installation HACS autonome ;
|
|
26
|
+
- le connecteur MCP (`danfoss-ally-mcp`) pourra en dépendre via `pip install pydanfoss-cloud` une
|
|
27
|
+
fois la bibliothèque **publiée sur PyPI**, puis l'intégration basculera vers une dépendance
|
|
28
|
+
`requirements` du `manifest.json`.
|
|
29
|
+
|
|
30
|
+
Installation en développement :
|
|
31
|
+
|
|
32
|
+
```
|
|
33
|
+
pip install -e . # expose le paquet pydanfoss_cloud
|
|
34
|
+
pip install -e '.[local]' # + tinytuya pour le tunnel local
|
|
35
|
+
```
|
|
36
|
+
|
|
37
|
+
## Dépendances
|
|
38
|
+
|
|
39
|
+
`pycryptodome`, `requests` (cœur) ; `tinytuya` (extra `local`, tunnel Zigbee). Python ≥ 3.12.
|
|
40
|
+
|
|
41
|
+
## Avertissement
|
|
42
|
+
|
|
43
|
+
API non documentée, obtenue par observation du protocole de l'application : elle peut changer ou
|
|
44
|
+
être coupée. Secrets (jeton de session, `localKey`, identifiants) : jamais journalisés ni commités.
|
|
@@ -0,0 +1,49 @@
|
|
|
1
|
+
"""Couche d'accès Danfoss Ally — bibliothèque réutilisable, sans dépendance Home Assistant.
|
|
2
|
+
|
|
3
|
+
Ce dossier EST la bibliothèque `pydanfoss-cloud` (cf. README.md ici) : le `pyproject.toml` du dépôt
|
|
4
|
+
le package sous le nom `pydanfoss_cloud` sans déplacer les fichiers. L'intégration le « vend » par
|
|
5
|
+
import relatif (`from .api import …`) pour rester autonome côté HACS ; le connecteur MCP pourra en
|
|
6
|
+
dépendre via PyPI une fois publié, puis l'intégration basculera vers manifest.json -> requirements.
|
|
7
|
+
|
|
8
|
+
Réutilisation (voir docs/reuse.md) :
|
|
9
|
+
- client et signature de l'application : ~/dev/danfoss-ally-signing-re
|
|
10
|
+
- récupération des clés, DP : ~/dev/danfoss-ally-mcp (tuya/pilote_tuya.py)
|
|
11
|
+
- tunnel Zigbee DP 198/199 : ~/dev/danfoss-ally-mcp (local.py)
|
|
12
|
+
"""
|
|
13
|
+
|
|
14
|
+
from __future__ import annotations
|
|
15
|
+
|
|
16
|
+
from . import schedule
|
|
17
|
+
from .client import (
|
|
18
|
+
CloudAuthError,
|
|
19
|
+
CloudClient,
|
|
20
|
+
CloudError,
|
|
21
|
+
CloudWriteError,
|
|
22
|
+
ScheduleValidationError,
|
|
23
|
+
UnknownTargetError,
|
|
24
|
+
)
|
|
25
|
+
from .decode import DanfossDevice, decoder, decoder_operation, etat_tete
|
|
26
|
+
from .keys import GatewayKey, async_fetch_gateway_keys
|
|
27
|
+
from .schedule import Schedule, count_transitions, validate_days
|
|
28
|
+
from .writes import ecriture_autorisee, encode_consigne
|
|
29
|
+
|
|
30
|
+
__all__ = [
|
|
31
|
+
"CloudAuthError",
|
|
32
|
+
"CloudClient",
|
|
33
|
+
"CloudError",
|
|
34
|
+
"CloudWriteError",
|
|
35
|
+
"DanfossDevice",
|
|
36
|
+
"GatewayKey",
|
|
37
|
+
"Schedule",
|
|
38
|
+
"ScheduleValidationError",
|
|
39
|
+
"UnknownTargetError",
|
|
40
|
+
"async_fetch_gateway_keys",
|
|
41
|
+
"count_transitions",
|
|
42
|
+
"decoder",
|
|
43
|
+
"decoder_operation",
|
|
44
|
+
"ecriture_autorisee",
|
|
45
|
+
"encode_consigne",
|
|
46
|
+
"etat_tete",
|
|
47
|
+
"schedule",
|
|
48
|
+
"validate_days",
|
|
49
|
+
]
|
|
@@ -0,0 +1,10 @@
|
|
|
1
|
+
"""Pile Tuya « voie 1a » vendue depuis danfoss-ally-mcp (reverse validé en réel).
|
|
2
|
+
|
|
3
|
+
Trois modules purs (stdlib + requests + pycryptodome), sans l'app ni frida :
|
|
4
|
+
- ``sign`` : signature HMAC-SHA256 du canonical.
|
|
5
|
+
- ``postdata`` : chiffrement AES-GCM du postData (requête et réponse).
|
|
6
|
+
- ``http`` : client HTTP bas niveau des méthodes ``m.*`` et flux de login.
|
|
7
|
+
|
|
8
|
+
À extraire à terme en bibliothèque partagée avec le connecteur MCP (roadmap v0.6).
|
|
9
|
+
Ne jamais logguer sign_key, sid, ecode ni chKey.
|
|
10
|
+
"""
|
|
@@ -0,0 +1,246 @@
|
|
|
1
|
+
"""Client HTTP bas niveau de l'API mobile Tuya (app Danfoss Ally), 100 % hors app.
|
|
2
|
+
|
|
3
|
+
S'appuie sur ``sign`` (HMAC-SHA256) + ``postdata`` (AES-GCM). Endpoint selon le datacenter
|
|
4
|
+
(EU/US/CN/IN). En-tête ``User-Agent: Thing-UA=...`` obligatoire. Matériel requis :
|
|
5
|
+
- SESSION : ``sid`` et ``ecode`` issus du login (stables tant que l'app reste connectée).
|
|
6
|
+
- INSTALLATION : ``sign_key``, ``deviceId``, ``chKey`` (capturés une fois, stables).
|
|
7
|
+
|
|
8
|
+
Reverse et flux de login validés en réel (voir danfoss-ally-mcp/tuya/client_http.py). Appels
|
|
9
|
+
synchrones (requests) : l'intégration HA les exécute dans l'executor.
|
|
10
|
+
"""
|
|
11
|
+
|
|
12
|
+
from __future__ import annotations
|
|
13
|
+
|
|
14
|
+
import hashlib
|
|
15
|
+
import json
|
|
16
|
+
import time
|
|
17
|
+
import uuid
|
|
18
|
+
|
|
19
|
+
import requests
|
|
20
|
+
|
|
21
|
+
from .postdata import build_request_body, decrypt_response
|
|
22
|
+
|
|
23
|
+
ENDPOINT_EU = "https://a1.tuyaeu.com/api.json"
|
|
24
|
+
ENDPOINT_US = "https://a1.tuyaus.com/api.json"
|
|
25
|
+
ENDPOINT_CN = "https://a1.tuyacn.com/api.json"
|
|
26
|
+
ENDPOINT_IN = "https://a1.tuyain.com/api.json"
|
|
27
|
+
DEFAULT_ENDPOINT = ENDPOINT_EU
|
|
28
|
+
|
|
29
|
+
ENDPOINTS = {
|
|
30
|
+
"eu": ENDPOINT_EU,
|
|
31
|
+
"us": ENDPOINT_US,
|
|
32
|
+
"cn": ENDPOINT_CN,
|
|
33
|
+
"in": ENDPOINT_IN,
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
USER_AGENT = "Thing-UA=APP/Android/1.4.3/SDK/6.2.0"
|
|
37
|
+
DEFAULT_CLIENT_ID = "7kypwcaqcvw3uvr7u95a"
|
|
38
|
+
DEFAULT_TTID = "sdk_international@7kypwcaqcvw3uvr7u95a"
|
|
39
|
+
DEFAULT_APP_VERSION = "1.4.3"
|
|
40
|
+
DEFAULT_LANG = "en_US"
|
|
41
|
+
DEFAULT_OS = "Android"
|
|
42
|
+
|
|
43
|
+
|
|
44
|
+
class TuyaApiError(RuntimeError):
|
|
45
|
+
"""Erreur renvoyée par le cloud (enveloppe success=false ou errorCode présent)."""
|
|
46
|
+
|
|
47
|
+
def __init__(self, code, msg, raw):
|
|
48
|
+
super().__init__(f"{code}: {msg}")
|
|
49
|
+
self.code = code
|
|
50
|
+
self.msg = msg
|
|
51
|
+
self.raw = raw
|
|
52
|
+
|
|
53
|
+
|
|
54
|
+
class TuyaHttpClient:
|
|
55
|
+
"""Client bas niveau des méthodes ``m.*`` (lecture/écriture), 100 % hors app."""
|
|
56
|
+
|
|
57
|
+
def __init__(
|
|
58
|
+
self,
|
|
59
|
+
sign_key: str,
|
|
60
|
+
sid: str,
|
|
61
|
+
ecode: str,
|
|
62
|
+
ch_key: str,
|
|
63
|
+
device_id: str,
|
|
64
|
+
*,
|
|
65
|
+
endpoint: str = DEFAULT_ENDPOINT,
|
|
66
|
+
client_id: str = DEFAULT_CLIENT_ID,
|
|
67
|
+
ttid: str = DEFAULT_TTID,
|
|
68
|
+
app_version: str = DEFAULT_APP_VERSION,
|
|
69
|
+
lang: str = DEFAULT_LANG,
|
|
70
|
+
os_name: str = DEFAULT_OS,
|
|
71
|
+
timeout: float = 20.0,
|
|
72
|
+
):
|
|
73
|
+
self.sign_key = sign_key
|
|
74
|
+
self.sid = sid
|
|
75
|
+
self.ecode = ecode
|
|
76
|
+
self.ch_key = ch_key
|
|
77
|
+
self.device_id = device_id
|
|
78
|
+
self.endpoint = endpoint
|
|
79
|
+
self.client_id = client_id
|
|
80
|
+
self.ttid = ttid
|
|
81
|
+
self.app_version = app_version
|
|
82
|
+
self.lang = lang
|
|
83
|
+
self.os_name = os_name
|
|
84
|
+
self.timeout = timeout
|
|
85
|
+
self.http = requests.Session()
|
|
86
|
+
self.http.headers["User-Agent"] = USER_AGENT
|
|
87
|
+
|
|
88
|
+
def _base_params(self, api: str, version: str, et: str) -> dict:
|
|
89
|
+
return {
|
|
90
|
+
"a": api,
|
|
91
|
+
"v": version,
|
|
92
|
+
"et": et,
|
|
93
|
+
"os": self.os_name,
|
|
94
|
+
"lang": self.lang,
|
|
95
|
+
"clientId": self.client_id,
|
|
96
|
+
"ttid": self.ttid,
|
|
97
|
+
"appVersion": self.app_version,
|
|
98
|
+
"deviceId": self.device_id,
|
|
99
|
+
"sid": self.sid,
|
|
100
|
+
"chKey": self.ch_key,
|
|
101
|
+
"requestId": str(uuid.uuid4()),
|
|
102
|
+
"time": str(int(time.time())),
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
def request(
|
|
106
|
+
self,
|
|
107
|
+
api: str,
|
|
108
|
+
version: str,
|
|
109
|
+
body=None,
|
|
110
|
+
*,
|
|
111
|
+
et: str = "3",
|
|
112
|
+
raw: bool = False,
|
|
113
|
+
extra_params: dict | None = None,
|
|
114
|
+
):
|
|
115
|
+
"""Envoie une requête ``m.*`` signée+chiffrée et renvoie le ``result`` déchiffré.
|
|
116
|
+
|
|
117
|
+
`extra_params` : paramètres d'URL non signés (hors SIGN_WHITELIST), p.ex. ``gid``.
|
|
118
|
+
Lève TuyaApiError si le cloud renvoie une erreur.
|
|
119
|
+
"""
|
|
120
|
+
params = self._base_params(api, version, et)
|
|
121
|
+
if extra_params:
|
|
122
|
+
params.update({k: str(v) for k, v in extra_params.items()})
|
|
123
|
+
request_id = params["requestId"]
|
|
124
|
+
if body is not None and not isinstance(body, (str, bytes)):
|
|
125
|
+
body = json.dumps(body, separators=(",", ":"), ensure_ascii=False)
|
|
126
|
+
form = build_request_body(params, body, self.sign_key, self.ecode)
|
|
127
|
+
resp = self.http.post(self.endpoint, data=form, timeout=self.timeout)
|
|
128
|
+
resp.raise_for_status()
|
|
129
|
+
env = resp.json()
|
|
130
|
+
if env.get("errorCode") or env.get("success") is False:
|
|
131
|
+
raise TuyaApiError(env.get("errorCode"), env.get("errorMsg"), env)
|
|
132
|
+
result = env.get("result")
|
|
133
|
+
if isinstance(result, str): # et=3 : result chiffré -> déchiffrer + gunzip
|
|
134
|
+
inner = json.loads(decrypt_response(result, request_id, self.ecode, self.sign_key))
|
|
135
|
+
if inner.get("success") is False or inner.get("errorCode"):
|
|
136
|
+
raise TuyaApiError(inner.get("errorCode"), inner.get("errorMsg"), inner)
|
|
137
|
+
return inner if raw else inner.get("result", inner)
|
|
138
|
+
return env if raw else result
|
|
139
|
+
|
|
140
|
+
def close(self):
|
|
141
|
+
self.http.close()
|
|
142
|
+
|
|
143
|
+
|
|
144
|
+
# --- LOGIN / bootstrap de session -------------------------------------------------------------
|
|
145
|
+
# Flux e-mail + mot de passe, confirmé par capture. 3 requêtes et=3 SANS sid (pré-session) mais
|
|
146
|
+
# AVEC le chKey d'installation. chKey est du matériel d'INSTALLATION (stable), pas de session.
|
|
147
|
+
|
|
148
|
+
|
|
149
|
+
def md5_as_base64(s: str) -> str:
|
|
150
|
+
"""MD5Util.md5AsBase64 — nom trompeur : renvoie en fait le MD5 en HEXADÉCIMAL (32 car.)."""
|
|
151
|
+
return hashlib.md5(s.encode("utf-8")).hexdigest()
|
|
152
|
+
|
|
153
|
+
|
|
154
|
+
def encrypt_password(password: str, public_key_decimal: str, exponent: str) -> str:
|
|
155
|
+
"""passwd du login : HEX(RSA/ECB/PKCS1(md5_hex(password))). Clé publique = module en décimal."""
|
|
156
|
+
from Crypto.Cipher import PKCS1_v1_5
|
|
157
|
+
from Crypto.PublicKey import RSA
|
|
158
|
+
|
|
159
|
+
rsa_key = RSA.construct((int(public_key_decimal), int(exponent)))
|
|
160
|
+
ciph = PKCS1_v1_5.new(rsa_key).encrypt(md5_as_base64(password).encode("utf-8"))
|
|
161
|
+
return ciph.hex()
|
|
162
|
+
|
|
163
|
+
|
|
164
|
+
def login(
|
|
165
|
+
email: str,
|
|
166
|
+
password: str,
|
|
167
|
+
country_code: str,
|
|
168
|
+
sign_key: str,
|
|
169
|
+
device_id: str,
|
|
170
|
+
ch_key: str,
|
|
171
|
+
*,
|
|
172
|
+
endpoint: str = DEFAULT_ENDPOINT,
|
|
173
|
+
client_id: str = DEFAULT_CLIENT_ID,
|
|
174
|
+
ttid: str = DEFAULT_TTID,
|
|
175
|
+
app_version: str = DEFAULT_APP_VERSION,
|
|
176
|
+
lang: str = DEFAULT_LANG,
|
|
177
|
+
timeout: float = 20.0,
|
|
178
|
+
) -> dict:
|
|
179
|
+
"""LOGIN e-mail/mot de passe (flux confirmé par capture).
|
|
180
|
+
|
|
181
|
+
Renvoie {sid, ecode, chKey, deviceId, uid}.
|
|
182
|
+
`ch_key`, `sign_key`, `device_id` = matériel d'installation (capturé une fois). Les identifiants
|
|
183
|
+
sont fournis à l'exécution et ne sont jamais stockés ni journalisés par cette fonction.
|
|
184
|
+
"""
|
|
185
|
+
http = requests.Session()
|
|
186
|
+
http.headers["User-Agent"] = USER_AGENT
|
|
187
|
+
|
|
188
|
+
def _send(api, version, post):
|
|
189
|
+
params = {
|
|
190
|
+
"a": api,
|
|
191
|
+
"v": version,
|
|
192
|
+
"et": "3",
|
|
193
|
+
"os": DEFAULT_OS,
|
|
194
|
+
"lang": lang,
|
|
195
|
+
"clientId": client_id,
|
|
196
|
+
"ttid": ttid,
|
|
197
|
+
"appVersion": app_version,
|
|
198
|
+
"deviceId": device_id,
|
|
199
|
+
"chKey": ch_key,
|
|
200
|
+
"requestId": str(uuid.uuid4()),
|
|
201
|
+
"time": str(int(time.time())),
|
|
202
|
+
}
|
|
203
|
+
request_id = params["requestId"]
|
|
204
|
+
body = json.dumps(post, separators=(",", ":"), ensure_ascii=False)
|
|
205
|
+
form = build_request_body(params, body, sign_key, "") # pré-login : ecode=""
|
|
206
|
+
r = http.post(endpoint, data=form, timeout=timeout)
|
|
207
|
+
r.raise_for_status()
|
|
208
|
+
env = r.json()
|
|
209
|
+
if env.get("errorCode") or env.get("success") is False:
|
|
210
|
+
raise TuyaApiError(env.get("errorCode"), env.get("errorMsg"), env)
|
|
211
|
+
result = env.get("result")
|
|
212
|
+
if isinstance(result, str):
|
|
213
|
+
inner = json.loads(decrypt_response(result, request_id, "", sign_key))
|
|
214
|
+
if inner.get("success") is False or inner.get("errorCode"):
|
|
215
|
+
raise TuyaApiError(inner.get("errorCode"), inner.get("errorMsg"), inner)
|
|
216
|
+
return inner.get("result", inner)
|
|
217
|
+
return result
|
|
218
|
+
|
|
219
|
+
token_bean = _send(
|
|
220
|
+
"thing.m.user.username.token.get",
|
|
221
|
+
"2.0",
|
|
222
|
+
{"countryCode": country_code, "isUid": False, "username": email},
|
|
223
|
+
)
|
|
224
|
+
token = token_bean["token"]
|
|
225
|
+
public_key = token_bean["publicKey"]
|
|
226
|
+
exponent = token_bean.get("exponent", "65537")
|
|
227
|
+
passwd = encrypt_password(password, public_key, exponent)
|
|
228
|
+
user = _send(
|
|
229
|
+
"thing.m.user.email.password.login",
|
|
230
|
+
"3.0",
|
|
231
|
+
{
|
|
232
|
+
"countryCode": country_code,
|
|
233
|
+
"email": email,
|
|
234
|
+
"passwd": passwd,
|
|
235
|
+
"options": '{"group": 1,"mfaCode": ""}',
|
|
236
|
+
"token": token,
|
|
237
|
+
"ifencrypt": 1,
|
|
238
|
+
},
|
|
239
|
+
)
|
|
240
|
+
return {
|
|
241
|
+
"sid": user.get("sid"),
|
|
242
|
+
"ecode": user.get("ecode"),
|
|
243
|
+
"chKey": ch_key,
|
|
244
|
+
"deviceId": device_id,
|
|
245
|
+
"uid": user.get("uid"),
|
|
246
|
+
}
|
|
@@ -0,0 +1,113 @@
|
|
|
1
|
+
"""Chiffrement du champ `postData` de l'API mobile Tuya (Danfoss Ally) — reversé et validé.
|
|
2
|
+
|
|
3
|
+
Pour les requêtes `m.*` (et=3), le postData n'est pas en clair :
|
|
4
|
+
1. SIGNATURE : champ `postData` du canonical = ``swap_sign_string(md5_hex(corps))``.
|
|
5
|
+
2. FIL : ``postData`` = Base64(nonce(12) ∥ AES-128-GCM(clé).encrypt(corps) ∥ tag(16)).
|
|
6
|
+
|
|
7
|
+
Clé AES = HMAC_SHA256(requestId, sign_key + "_" + ecode).hexdigest()[:16] (ecode vide en pré-login).
|
|
8
|
+
La réponse (et=3) est chiffrée avec la même clé puis gzip. sign_key et ecode sont des SECRETS.
|
|
9
|
+
"""
|
|
10
|
+
|
|
11
|
+
from __future__ import annotations
|
|
12
|
+
|
|
13
|
+
import base64
|
|
14
|
+
import gzip
|
|
15
|
+
import hashlib
|
|
16
|
+
import hmac as _hmac
|
|
17
|
+
import os
|
|
18
|
+
|
|
19
|
+
from Crypto.Cipher import AES
|
|
20
|
+
|
|
21
|
+
GCM_NONCE_LEN = 12
|
|
22
|
+
GCM_TAG_LEN = 16
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
def swap_sign_string(s: str) -> str:
|
|
26
|
+
"""Permutation des blocs de 8 hex d'un md5 : B0 B1 B2 B3 -> B1 B0 B3 B2 (involution)."""
|
|
27
|
+
b0, b1, b2, b3 = s[0:8], s[8:16], s[16:24], s[24:32]
|
|
28
|
+
return b1 + b0 + b3 + b2
|
|
29
|
+
|
|
30
|
+
|
|
31
|
+
def post_data_md5(body: str | bytes) -> str:
|
|
32
|
+
"""Valeur du champ `postData` dans le canonical signé = swap_sign_string(md5_hex(corps))."""
|
|
33
|
+
if isinstance(body, str):
|
|
34
|
+
body = body.encode("utf-8")
|
|
35
|
+
return swap_sign_string(hashlib.md5(body).hexdigest())
|
|
36
|
+
|
|
37
|
+
|
|
38
|
+
def derive_encrypto_key(request_id: str, ecode: str, sign_key: str) -> bytes:
|
|
39
|
+
"""Clé AES-128 (16 o ASCII) : HMAC_SHA256(requestId, sign_key[+ "_" + ecode])[:16].
|
|
40
|
+
|
|
41
|
+
En pré-login (ecode vide/None), le message haché est le sign_key seul.
|
|
42
|
+
"""
|
|
43
|
+
msg = (sign_key if not ecode else sign_key + "_" + ecode).encode("utf-8")
|
|
44
|
+
full = _hmac.new(request_id.encode("utf-8"), msg, hashlib.sha256).hexdigest()
|
|
45
|
+
return full[:16].encode("ascii")
|
|
46
|
+
|
|
47
|
+
|
|
48
|
+
def encrypt_post_data(
|
|
49
|
+
body: str | bytes, request_id: str, ecode: str, sign_key: str, nonce: bytes | None = None
|
|
50
|
+
) -> str:
|
|
51
|
+
"""Chiffre le corps en clair -> valeur `postData` envoyée (Base64 de nonce∥ciphertext∥tag)."""
|
|
52
|
+
if isinstance(body, str):
|
|
53
|
+
body = body.encode("utf-8")
|
|
54
|
+
if nonce is None:
|
|
55
|
+
nonce = os.urandom(GCM_NONCE_LEN)
|
|
56
|
+
if len(nonce) != GCM_NONCE_LEN:
|
|
57
|
+
raise ValueError("nonce doit faire 12 octets")
|
|
58
|
+
key = derive_encrypto_key(request_id, ecode, sign_key)
|
|
59
|
+
cipher = AES.new(key, AES.MODE_GCM, nonce=nonce, mac_len=GCM_TAG_LEN)
|
|
60
|
+
ciphertext, tag = cipher.encrypt_and_digest(body)
|
|
61
|
+
return base64.b64encode(nonce + ciphertext + tag).decode("ascii")
|
|
62
|
+
|
|
63
|
+
|
|
64
|
+
def decrypt_post_data(b64: str, request_id: str, ecode: str, sign_key: str) -> bytes:
|
|
65
|
+
"""Inverse de encrypt_post_data : Base64(nonce∥ct∥tag) -> corps en clair (octets)."""
|
|
66
|
+
blob = base64.b64decode(b64)
|
|
67
|
+
nonce = blob[:GCM_NONCE_LEN]
|
|
68
|
+
tag = blob[-GCM_TAG_LEN:]
|
|
69
|
+
ciphertext = blob[GCM_NONCE_LEN:-GCM_TAG_LEN]
|
|
70
|
+
key = derive_encrypto_key(request_id, ecode, sign_key)
|
|
71
|
+
cipher = AES.new(key, AES.MODE_GCM, nonce=nonce, mac_len=GCM_TAG_LEN)
|
|
72
|
+
return cipher.decrypt_and_verify(ciphertext, tag)
|
|
73
|
+
|
|
74
|
+
|
|
75
|
+
def build_request_body(
|
|
76
|
+
url_params: dict,
|
|
77
|
+
body: str | bytes | None,
|
|
78
|
+
sign_key: str,
|
|
79
|
+
ecode: str,
|
|
80
|
+
nonce: bytes | None = None,
|
|
81
|
+
) -> dict:
|
|
82
|
+
"""Assemble le corps POST (form-urlencoded) d'une requête m.* (et=3), 100 % hors ligne.
|
|
83
|
+
|
|
84
|
+
Renvoie url_params + postData chiffré (si corps) + sign. La signature porte sur le postData
|
|
85
|
+
tel qu'envoyé (ciphertext), pas sur le corps en clair.
|
|
86
|
+
"""
|
|
87
|
+
from .sign import canonical_from_request, sign_canonical
|
|
88
|
+
|
|
89
|
+
params = {k: v for k, v in url_params.items() if v is not None}
|
|
90
|
+
request_id = params.get("requestId")
|
|
91
|
+
if not request_id:
|
|
92
|
+
raise ValueError("url_params doit contenir 'requestId'")
|
|
93
|
+
out = dict(params)
|
|
94
|
+
wire = None
|
|
95
|
+
if body is not None and body != "" and body != b"":
|
|
96
|
+
wire = encrypt_post_data(body, request_id, ecode, sign_key, nonce=nonce)
|
|
97
|
+
out["postData"] = wire
|
|
98
|
+
canonical = canonical_from_request(params, wire)
|
|
99
|
+
out["sign"] = sign_canonical(canonical, sign_key)
|
|
100
|
+
return out
|
|
101
|
+
|
|
102
|
+
|
|
103
|
+
def decrypt_response(
|
|
104
|
+
b64_result: str, request_id: str, ecode: str, sign_key: str, gzipped: bool = True
|
|
105
|
+
) -> bytes:
|
|
106
|
+
"""Déchiffre le champ `result` d'une réponse chiffrée (et=3) : GCM puis gunzip."""
|
|
107
|
+
raw = decrypt_post_data(b64_result, request_id, ecode, sign_key)
|
|
108
|
+
if gzipped:
|
|
109
|
+
try:
|
|
110
|
+
return gzip.decompress(raw)
|
|
111
|
+
except (OSError, EOFError):
|
|
112
|
+
return raw
|
|
113
|
+
return raw
|