Messages récents51
Actus SFR Altice / Installation de Connect TV d'SFR sur box Android TV
« Dernier message par SuperBaobab le 24 juillet 2026 à 18:05:35 »
Post de la flemme, 100% IA (désolé).
J'ai testé le script sur la 8.1.10 avec succès, c'est fait pour essayer de supporter les prochaines versions aussi.
Vous devriez pouvoir être autonomes entre ce script et celui pour récupérer les derniers APK ici : https://lafibre.info/sfr-les-news/installation-de-connect-tv-dsfr-sur-box-android-tv-60183/msg1146711/#msg1146711
build_and_sign.sh
J'ai testé le script sur la 8.1.10 avec succès, c'est fait pour essayer de supporter les prochaines versions aussi.
Vous devriez pouvoir être autonomes entre ce script et celui pour récupérer les derniers APK ici : https://lafibre.info/sfr-les-news/installation-de-connect-tv-dsfr-sur-box-android-tv-60183/msg1146711/#msg1146711
Code: [Sélectionner]
# Guide : retirer la vérification de matériel supporté sur l'APK Connect TV (SFR)
> **Contexte.** L'application Android TV « Connect TV » de SFR vérifie au
> démarrage/à la connexion que l'appareil sur lequel elle tourne est une
> des box officielles SFR (Sagemcom, SDMC, etc.). Si ce n'est pas le cas
> (Chromecast avec Google TV, Nvidia Shield, box Android générique...),
> l'app se bloque même si le compte SFR et la ligne sont valides. Ce
> guide explique comment identifier et retirer cette vérification dans
> l'APK, pour un usage personnel sur votre propre matériel.
>
> **Avertissement.** Ceci modifie un exécutable qui ne vous appartient
> pas légalement (il reste la propriété de SFR) : vous le faites sous
> votre propre responsabilité, pour un usage strictement personnel et
> non redistribué. Ce guide ne concerne QUE la vérification de modèle de
> box. Il existe une autre vérification, séparée, qui teste que la ligne
> est bien raccordée au réseau SFR (test multicast FTTH/ADSL) : ce n'est
> **pas** une vérification matérielle et ce guide ne la contourne pas —
> sans un vrai abonnement/ligne SFR, l'app ne fonctionnera de toute façon
> pas complètement.
Ce dossier contient deux scripts qui automatisent la partie répétitive :
- `find_hardware_check.py` : repère automatiquement, dans le code
décompilé, la méthode qui fait la vérification de modèle — même si les
noms de classes changent à chaque version de l'APK (obfuscation).
- `build_and_sign.sh` : recompile, aligne et signe l'APK patché.
Aucun des deux scripts ne dépend d'un environnement particulier ; ils
détectent automatiquement les outils installés sur votre machine.
---
## 1. Prérequis
Il vous faut, sous Linux/macOS (sous Windows, utilisez WSL) :
1. **Java (JDK) 11 ou plus récent** — fournit `keytool` (signature).
- Debian/Ubuntu : `sudo apt install openjdk-17-jdk`
- Fedora : `sudo dnf install java-17-openjdk`
- macOS (Homebrew) : `brew install openjdk`
- Vérifier : `java -version`
2. **apktool** — décompile/recompile l'APK (smali + ressources).
- Documentation officielle : https://apktool.org/docs/install
- Sur beaucoup de distributions il est aussi packagé :
`sudo apt install apktool` / `sudo dnf install apktool` / `brew install apktool`.
- Vérifier : `apktool --version` (ce guide a été testé avec apktool 3.x)
3. **Android SDK Build-Tools** — fournit `zipalign` et `apksigner`.
- Le plus simple : installer *Android Studio*, puis dans le
SDK Manager cocher « Android SDK Build-Tools ».
- Ou en ligne de commande seule, via les *command line tools* :
https://developer.android.com/studio#command-tools puis
`sdkmanager "build-tools;34.0.0"`.
- Définissez ensuite la variable d'environnement `ANDROID_HOME` (ou
`ANDROID_SDK_ROOT`) vers le dossier du SDK — les scripts de ce
guide s'en servent pour retrouver `zipalign`/`apksigner`
automatiquement. Exemple (à mettre dans votre `~/.bashrc`) :
```bash
export ANDROID_HOME="$HOME/Android/Sdk"
```
4. **ADB** (Android Debug Bridge) — pour installer l'APK patché sur
votre appareil.
- `sudo apt install android-tools-adb` / `sudo dnf install android-tools`
/ `brew install android-platform-tools`
- Ou fourni avec le SDK Android (`$ANDROID_HOME/platform-tools/adb`).
5. **Python 3** (déjà présent sur la plupart des systèmes Linux/macOS) —
pour lancer `find_hardware_check.py`. Aucune bibliothèque externe
requise.
6. **L'APK de Connect TV** que vous voulez patcher (récupéré depuis
votre propre appareil ou une source de confiance — ce guide ne
fournit pas l'APK).
---
## 2. Activer le débogage USB sur votre appareil Android TV
1. Paramètres → À propos → cliquer 7 fois sur « Build » / « Numéro de
build » pour activer le mode développeur.
2. Paramètres → Options pour les développeurs → activer « Débogage USB ».
3. Branchez l'appareil en USB à votre ordinateur (le débogage sans-fil
ADB nécessite que l'appareil soit déjà connecté en Wi-Fi, ce qui n'est
pas toujours pratique au premier essai — préférez l'USB).
4. `adb devices` — la première fois, une popup apparaît sur la TV pour
autoriser l'ordinateur : acceptez avec la télécommande.
---
## 3. Décompiler l'APK
```bash
apktool d --no-res -f -o connect_tv_decompiled Connect_TV_original.apk
```
**Important : l'option `--no-res` est nécessaire.** Sans elle, apktool
décode aussi `resources.arsc` (les ressources Android), et sur les
versions récentes de cette app (compileSdk 35 / Android 15), le
ré-encodage de ce fichier lors du rebuild (étape 6) corrompt l'APK
("le paquet semble ne pas être valide" à l'installation) — même sans
aucune modification du code. `--no-res` laisse `resources.arsc` intact
(copié tel quel), ce qui évite complètement ce problème puisqu'on n'a de
toute façon rien à modifier dans les ressources pour ce patch.
---
## 4. Repérer automatiquement la vérification à patcher
```bash
python3 find_hardware_check.py connect_tv_decompiled
```
Le script affiche quelque chose comme :
```
=== Hiérarchie candidate : LNg/g; ===
Sous-classes (6): LNg/a;, LNg/b;, LNg/c;, LNg/d;, LNg/e;, LNg/f;
-> smali_classes2/Mg/a.smali méthode c()Z (lignes 155-263, 5 comparaisons)
-> smali_classes2/Mg/a.smali méthode e()Z (lignes 292-352, 2 comparaisons)
```
(Les noms de classes/méthodes réels varient à chaque version de l'APK à
cause de l'obfuscation — c'est normal et attendu, le script est fait pour
s'adapter à ça.)
### Comment lire ce résultat
- La **hiérarchie candidate** est une classe abstraite (ici `LNg/g;`)
avec plusieurs sous-classes qui représentent chacune un modèle de box
connu (Sagemcom, SDMC...) plus un cas générique "Other" pour le
matériel non reconnu.
- Les **méthodes candidates** sont celles qui comparent le modèle
détecté à cette liste et retournent vrai/faux. La méthode avec le plus
de comparaisons (`hits`) est généralement la bonne — dans l'exemple
ci-dessus, `c()Z` avec 5 comparaisons contre `e()Z` avec seulement 2.
### Vérification manuelle (obligatoire avant de patcher)
1. Ouvrez le fichier indiqué (ex : `smali_classes2/Mg/a.smali`) et
regardez le corps de la méthode candidate. Vous devez voir une suite
de comparaisons (`sget-object` + `invoke-static ... Z`) qui, si l'une
d'elles matche, saute vers un `return` avec `1` (vrai), et sinon
retourne `0` (faux). C'est la signature typique d'une fonction
`isSupportedDevice()`.
2. Cherchez qui appelle cette méthode, pour confirmer sa pertinence :
```bash
grep -rn "Mg/a;->c()Z" connect_tv_decompiled --include=*.smali
```
(remplacez `Mg/a;->c()Z` par la classe/méthode réelle trouvée par le
script). Si un des appelants a un nom qui évoque l'authentification
ou le compte (ex : `ConnectAccountWorker`, `AuthWorker`, `LoginX`...),
c'est un bon signe que vous avez la bonne méthode.
3. Si plusieurs méthodes candidates sont listées, privilégiez toujours
celle avec le plus de comparaisons ET la plus utilisée par des
classes liées à l'authentification.
### Si le script ne trouve rien
L'obfuscation peut avoir changé de forme d'une version à l'autre. Dans ce
cas, cherchez manuellement :
```bash
grep -rln "Landroid/os/Build;->MODEL\|Landroid/os/Build;->PRODUCT" connect_tv_decompiled --include=*.smali
```
puis remontez à la main vers la classe abstraite dont héritent ces
fichiers (`.super` en haut du fichier `.smali`), et vers les méthodes qui
utilisent cette hiérarchie.
### Piège à éviter
Ne patchez **pas** la classe qui *résout* le modèle de l'appareil (celle
qui lit `Build.MODEL`/`Build.PRODUCT` et choisit quelle sous-classe
instancier). Elle gère déjà correctement le cas "matériel inconnu" en
retournant l'objet générique "Other" — ce n'est pas une erreur/exception.
Si vous forcez cette résolution à renvoyer un modèle de box connu (par
exemple en essayant de "se faire passer pour" une SDMC), l'app croira
tourner sur une vraie box SFR et essaiera d'utiliser une logique réseau
spécifique à cette box, ce qui casse la détection de ligne/connexion. Le
bon patch est bien la méthode "isSupportedDevice" (`c()Z` dans notre
exemple), pas le résolveur de modèle.
---
## 5. Patcher la méthode
Une fois la bonne méthode confirmée (par exemple
`smali_classes2/Mg/a.smali`, méthode `c()Z`), ouvrez le fichier et
remplacez **tout le corps de la méthode** (de `.method ... c()Z` à
`.end method` inclus) par une version qui retourne toujours vrai :
```smali
.method public final c()Z
.locals 1
const/4 v0, 0x1
return v0
.end method
```
Adaptez le nom de la méthode (`c`), les modificateurs (`public final`)
et les éventuels paramètres à ce que vous avez trouvé dans votre version
— gardez la signature `.method` identique à l'originale, seul le corps
change.
---
## 6. Recompiler, aligner et signer
```bash
./build_and_sign.sh connect_tv_decompiled Connect_TV_patched
```
Ce script :
1. Recompile le dossier décompilé en APK (`apktool b`).
2. Aligne l'APK avec `zipalign` — **avant** la signature (sinon vous
obtiendrez `INSTALL_FAILED_INTERNAL_ERROR: Failed to extract native
libraries` à l'installation).
3. Signe l'APK avec `apksigner`, en générant automatiquement un
keystore auto-signé (`patch_key.jks`) si vous n'en avez pas encore un
dans le dossier courant.
À la fin, vous obtenez `Connect_TV_patched_aligned.apk`.
Si vous préférez faire les étapes à la main :
```bash
apktool b connect_tv_decompiled -o Connect_TV_patched.apk
zipalign -f -p 4 Connect_TV_patched.apk Connect_TV_patched_aligned.apk
apksigner sign --ks patch_key.jks Connect_TV_patched_aligned.apk
```
---
## 7. Installer sur l'appareil
```bash
adb install -r Connect_TV_patched_aligned.apk
```
- `-r` réinstalle par-dessus une version existante en gardant les
données (si l'app originale est déjà installée avec la même
signature — sinon désinstallez-la d'abord :
`adb uninstall com.sfr.androidtv.gen8` puis installez la version
patchée).
- Si `adb` renvoie `unauthorized`, vérifiez la popup d'autorisation sur
l'écran de la TV.
---
## 8. Dépannage
| Symptôme | Cause probable | Solution |
|---|---|---|
| "Le paquet semble ne pas être valide" à l'installation | Ressources corrompues au rebuild | Redécompilez avec `apktool d --no-res` |
| `INSTALL_FAILED_INTERNAL_ERROR` / `Failed to extract native libraries` | Mauvais ordre alignement/signature | `zipalign` doit toujours passer **avant** `apksigner sign` |
| `INSTALL_FAILED_UPDATE_INCOMPATIBLE` | Signature différente de l'app déjà installée | `adb uninstall <package>` puis réinstallez |
| L'app s'ouvre mais bloque toujours "matériel non supporté" | Mauvaise méthode patchée, ou méthode annexe (`e()Z`, etc.) plutôt que la principale | Revérifiez les appelants (étape 4.3), essayez le candidat suivant dans la liste |
| L'app se connecte mais échoue à détecter la ligne/le login après patch | Vous avez patché le *résolveur* de modèle au lieu de la méthode "isSupported" | Revenez à l'APK décompilé original pour ce fichier et ne patchez que la méthode booléenne (étape 4, piège à éviter) |
| `adb devices` montre l'appareil en `unauthorized` | Popup d'autorisation pas acceptée | Débranchez/rebranchez l'USB, acceptez la popup sur la TV |
| `zipalign`/`apksigner` introuvables par `build_and_sign.sh` | SDK Android non détecté | Définissez `ANDROID_HOME` vers votre SDK, ou passez `ZIPALIGN_BIN=/chemin/... APKSIGNER_BIN=/chemin/...` en variables d'environnement avant d'appeler le script |
---
## 9. Résumé rapide (pour ceux qui ont déjà fait ça une fois)
```bash
apktool d --no-res -f -o decomp Connect_TV.apk
python3 find_hardware_check.py decomp # note la classe/méthode candidate
# éditer decomp/.../Xx/y.smali -> forcer la méthode isSupportedDevice à `return 1`
./build_and_sign.sh decomp Connect_TV_patched
adb install -r Connect_TV_patched_aligned.apk
```
build_and_sign.sh
Code: [Sélectionner]
#!/usr/bin/env bash
#
# build_and_sign.sh — Recompile, aligne et signe un dossier décompilé
# apktool (générique, ne dépend d'aucun chemin personnel).
#
# Usage:
# ./build_and_sign.sh <dossier_decompile> [nom_sortie]
#
# Exemple:
# ./build_and_sign.sh connect_tv_patched Connect_TV_patched
#
# Le script essaie de localiser automatiquement :
# - apktool (PATH)
# - zipalign/apksigner (PATH, ou $ANDROID_HOME/$ANDROID_SDK_ROOT/build-tools/<dernière version>)
# - un keystore de signature (créé automatiquement si absent)
#
# Variables d'environnement optionnelles pour surcharger la détection :
# APKTOOL_BIN, ZIPALIGN_BIN, APKSIGNER_BIN, KEYSTORE, KEY_ALIAS, KEYSTORE_PASS
#
# Etapes : apktool build -> zipalign (AVANT signature, sinon erreur
# "Failed to extract native libraries" / INSTALL_FAILED_INTERNAL_ERROR à
# l'installation) -> apksigner sign.
set -euo pipefail
DECOMPILE_DIR="${1:?Usage: $0 <dossier_decompile> [nom_sortie]}"
OUT_NAME="${2:-Connect_TV_patched}"
# --- 1. Localiser apktool -----------------------------------------------
find_bin() {
local name="$1"
local override_var="$2"
if [[ -n "${!override_var:-}" ]]; then
echo "${!override_var}"
return 0
fi
if command -v "$name" >/dev/null 2>&1; then
command -v "$name"
return 0
fi
return 1
}
# Cherche zipalign/apksigner dans les build-tools du SDK Android.
find_build_tool() {
local name="$1"
local override_var="$2"
if [[ -n "${!override_var:-}" ]]; then
echo "${!override_var}"
return 0
fi
if command -v "$name" >/dev/null 2>&1; then
command -v "$name"
return 0
fi
local sdk_root="${ANDROID_HOME:-${ANDROID_SDK_ROOT:-}}"
if [[ -n "$sdk_root" && -d "$sdk_root/build-tools" ]]; then
# Prend la version la plus récente disponible.
local candidate
candidate=$(find "$sdk_root/build-tools" -maxdepth 2 -name "$name" -print 2>/dev/null | sort -V | tail -n1)
if [[ -n "$candidate" ]]; then
echo "$candidate"
return 0
fi
fi
return 1
}
APKTOOL_BIN="$(find_bin apktool APKTOOL_BIN || true)"
if [[ -z "$APKTOOL_BIN" ]]; then
echo "ERREUR: apktool introuvable dans le PATH." >&2
echo "Installe-le (voir GUIDE.md, section Prérequis) ou définis APKTOOL_BIN=/chemin/vers/apktool." >&2
exit 1
fi
ZIPALIGN_BIN="$(find_build_tool zipalign ZIPALIGN_BIN || true)"
if [[ -z "$ZIPALIGN_BIN" ]]; then
echo "ERREUR: zipalign introuvable." >&2
echo "Installe les 'Android SDK Build-Tools' (via Android Studio / sdkmanager)," >&2
echo "assure-toi que \$ANDROID_HOME (ou \$ANDROID_SDK_ROOT) pointe vers le SDK," >&2
echo "ou définis ZIPALIGN_BIN=/chemin/vers/zipalign." >&2
exit 1
fi
APKSIGNER_BIN="$(find_build_tool apksigner APKSIGNER_BIN || true)"
if [[ -z "$APKSIGNER_BIN" ]]; then
echo "ERREUR: apksigner introuvable (même remarque que pour zipalign)." >&2
echo "Définis APKSIGNER_BIN=/chemin/vers/apksigner si besoin." >&2
exit 1
fi
echo "apktool : $APKTOOL_BIN"
echo "zipalign : $ZIPALIGN_BIN"
echo "apksigner : $APKSIGNER_BIN"
# --- 2. Keystore ---------------------------------------------------------
# Un keystore de signature "auto-signé" suffit : Android accepte n'importe
# quelle signature valide à l'installation tant qu'elle est cohérente
# (l'app n'est pas republiée sur le Play Store, juste réinstallée en local).
KEYSTORE="${KEYSTORE:-$PWD/patch_key.jks}"
KEY_ALIAS="${KEY_ALIAS:-patch_key}"
KEYSTORE_PASS="${KEYSTORE_PASS:-changeit}"
if [[ ! -f "$KEYSTORE" ]]; then
echo "[0/3] Aucun keystore trouvé, création de '$KEYSTORE'..."
if ! command -v keytool >/dev/null 2>&1; then
echo "ERREUR: keytool introuvable (fourni avec un JDK). Installe un JDK (voir GUIDE.md)." >&2
exit 1
fi
keytool -genkeypair -v \
-keystore "$KEYSTORE" \
-alias "$KEY_ALIAS" \
-keyalg RSA -keysize 2048 -validity 10000 \
-storepass "$KEYSTORE_PASS" -keypass "$KEYSTORE_PASS" \
-dname "CN=patch, OU=patch, O=patch, L=patch, ST=patch, C=FR"
fi
# --- 3. Build --------------------------------------------------------------
echo "[1/3] apktool build..."
"$APKTOOL_BIN" b "$DECOMPILE_DIR" -o "${OUT_NAME}.apk"
echo "[2/3] zipalign..."
"$ZIPALIGN_BIN" -f -p 4 "${OUT_NAME}.apk" "${OUT_NAME}_aligned.apk"
echo "[3/3] apksigner sign..."
"$APKSIGNER_BIN" sign \
--ks "$KEYSTORE" \
--ks-key-alias "$KEY_ALIAS" \
--ks-pass "pass:$KEYSTORE_PASS" \
--key-pass "pass:$KEYSTORE_PASS" \
"${OUT_NAME}_aligned.apk"
echo
echo "APK prêt : ${OUT_NAME}_aligned.apk"
echo "Installer avec : adb install -r \"${OUT_NAME}_aligned.apk\""
Actus Orange
Présentations
Attaques informatiques