Comment vérifier si l'APK est signé ou "debug build"?

Autant que je sache, dans Android "release build" est signé APK. Comment le vérifier à partir du code ou Eclipse a-t-il une sorte de définition secrète?

J'en ai besoin pour déboguer le remplissage des éléments ListView à partir des données du service Web (non, logcat pas une option).

Mes pensées:

• Application android:debuggable, mais pour une raison qui ne semble pas fiable.
• Le codage en dur de l'identifiant d'appareil n'est pas une bonne idée, car j'utilise le même appareil pour tester les APK signés.
• Vous utilisez un indicateur manuel quelque part dans le code? Plausible, mais je vais certainement oublier de changer à un moment donné, et tous les programmeurs sont paresseux.

Il existe différentes manières de vérifier si l'application est construite à l'aide du débogage ou du certificat de version, mais la méthode suivante me semble la meilleure.

Selon les informations de la documentation Android Signing Your Application , la clé de débogage contient le nom distinctif du sujet suivant: " CN = Android Debug, O = Android, C = US ". Nous pouvons utiliser ces informations pour tester si le package est signé avec une clé de débogage sans codage en dur de la signature de clé de débogage dans notre code.

Donné:

import android.content.pm.Signature;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

Vous pouvez implémenter une méthode isDebuggable de cette façon:

private static final X500Principal DEBUG_DN = new X500Principal("CN=Android Debug,O=Android,C=US");
private boolean isDebuggable(Context ctx)
{
    boolean debuggable = false;

    try
    {
        PackageInfo pinfo = ctx.getPackageManager().getPackageInfo(ctx.getPackageName(),PackageManager.GET_SIGNATURES);
        Signature signatures[] = pinfo.signatures;

        CertificateFactory cf = CertificateFactory.getInstance("X.509");

        for ( int i = 0; i < signatures.length;i++)
        {   
            ByteArrayInputStream stream = new ByteArrayInputStream(signatures[i].toByteArray());
            X509Certificate cert = (X509Certificate) cf.generateCertificate(stream);       
            debuggable = cert.getSubjectX500Principal().equals(DEBUG_DN);
            if (debuggable)
                break;
        }
    }
    catch (NameNotFoundException e)
    {
        //debuggable variable will remain false
    }
    catch (CertificateException e)
    {
        //debuggable variable will remain false
    }
    return debuggable;
}

Pour vérifier l'indicateur déboguable, vous pouvez utiliser ce code:

boolean isDebuggable =  ( 0 != ( getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE ) );

Kotlin:

val isDebuggable = 0 != applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE

Pour plus d'informations, consultez Sécurisation des applications LVL Android .

Sinon, si vous utilisez correctement Gradle, vous pouvez vérifier si BuildConfig.DEBUGest vrai ou faux.

Répondue par Mark Murphy

La solution la plus simple et la meilleure à long terme consiste à utiliser BuildConfig.DEBUG. C'est une booleanvaleur qui sera truepour une compilation de débogage, falsesinon:

if (BuildConfig.DEBUG) {
  // do something for a debug build
}

Si vous souhaitez vérifier un APKstatiquement, vous pouvez utiliser

aapt dump badging /path/to/apk | grep -c application-debuggable

Cela génère 0si le APKn'est pas déboguable et 1s'il l'est.

Peut-être en retard, mais des utilisations iosched BuildConfig.DEBUG

Ajoutez d'abord ceci à votre fichier build.gradle, cela permettra également d'exécuter côte à côte les versions de débogage et de publication:

buildTypes {
    debug {
        applicationIdSuffix ".debug"
    }
}

Ajoutez cette méthode:

public static boolean isDebug(Context context) {
    String pName = context.getPackageName();
    if (pName != null && pName.endsWith(".debug")) {
        return true;
    } else {
        return false;
    }
}

Une version de débogage est également signée, juste avec une clé différente. Il est généré automatiquement par Eclipse et son certificat n'est valable qu'un an. Quel est le problème android:debuggable? Vous pouvez obtenir cette valeur à partir du code en utilisant PackageManager.

Une autre option, à mentionner. Si vous devez exécuter du code uniquement lorsque le débogueur est attaché, utilisez ce code:

if (Debug.isDebuggerConnected() || Debug.waitingForDebugger()) { 
    //code to be executed 
}

Résolu avec android:debuggable. C'était un bogue dans la lecture de l'élément où, dans certains cas, l'indicateur de débogage sur l'élément n'était pas stocké dans l'enregistrement, if (m.debug && !App.isDebuggable(getContext()))toujours évalué false. Ma faute.

Solution dans Kotlin que j'utilise en ce moment:

@SuppressLint("PackageManagerGetSignatures")
@Suppress("DEPRECATION")
fun isSigned(context: Context?): Boolean {
    return (context?.packageManager?.getPackageInfo(context.packageName, PackageManager.GET_SIGNATURES)?.signatures?.firstOrNull()?.toByteArray()
            ?.let {
                return@let CertificateFactory.getInstance("X.509").generateCertificate(ByteArrayInputStream(it))
            } as? X509Certificate)
            ?.issuerDN
            ?.name
            ?.contains("O=Android", ignoreCase = false) ?: true
}

de cette façon, je peux toujours SIGNER en débogage et ceux-ci seront signalés à Crashlytics (exemple, pour le processus d'assurance qualité)