Wie überprüfe ich, ob APK signiert ist oder ob "Debug Build"?

Soweit ich weiß, ist in Android "Release Build" APK signiert. Wie kann man es anhand des Codes überprüfen oder hat Eclipse eine Art geheime Definition?

Ich benötige dies, um das Auffüllen von ListView-Elementen aus Webdienstdaten zu debuggen (nein, logcat ist keine Option).

Meine Gedanken:

• Anwendungen android:debuggable, aber aus irgendeinem Grund sieht das nicht zuverlässig aus.
• Die Hardcodierung der Geräte-ID ist keine gute Idee, da ich dasselbe Gerät zum Testen signierter APKs verwende.
• Verwenden Sie die manuelle Flagge irgendwo im Code? Plausibel, aber ich werde definitiv vergessen, mich irgendwann zu ändern, und alle Programmierer sind faul.

Es gibt verschiedene Möglichkeiten, um zu überprüfen, ob die Anwendung mithilfe eines Debug- oder Release-Zertifikats erstellt wurde. Die folgende Methode erscheint mir jedoch am besten.

Gemäß den Informationen in der Android-Dokumentation Signing Your Application enthält der Debug-Schlüssel den folgenden Betreffnamen: " CN = Android Debug, O = Android, C = US ". Wir können diese Informationen verwenden, um zu testen, ob das Paket mit dem Debug-Schlüssel signiert ist, ohne die Debug-Schlüsselsignatur in unserem Code fest zu codieren.

Gegeben:

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

Sie können eine isDebuggable-Methode folgendermaßen implementieren:

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;
}

Um das debuggable Flag zu überprüfen, können Sie diesen Code verwenden:

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

Kotlin:

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

Weitere Informationen finden Sie unter Sichern von Android LVL-Anwendungen .

Wenn Sie Gradle richtig verwenden, können Sie alternativ überprüfen, ob BuildConfig.DEBUGes wahr oder falsch ist.

Beantwortet von Mark Murphy

Die einfachste und beste langfristige Lösung ist die Verwendung BuildConfig.DEBUG. Dies ist ein booleanWert, der truefür einen Debug-Build verwendet wird, falseandernfalls:

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

Wenn Sie eine APKstatische überprüfen möchten , können Sie verwenden

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

Dies wird ausgegeben, 0wenn das APKnicht debuggbar ist und 1wenn es ist.

Vielleicht spät, aber iosched verwendet BuildConfig.DEBUG

Fügen Sie dies zuerst zu Ihrer build.gradle-Datei hinzu. Dadurch können auch Debug- und Release-Builds nebeneinander ausgeführt werden:

buildTypes {
    debug {
        applicationIdSuffix ".debug"
    }
}

Fügen Sie diese Methode hinzu:

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

Ein Debug-Build wird ebenfalls signiert, nur mit einem anderen Schlüssel. Es wird automatisch von Eclipse generiert und das Zertifikat ist nur ein Jahr gültig. Was ist das Problem mit android:debuggable? Sie können diesen Wert aus dem Code mit abrufen PackageManager.

Eine weitere erwähnenswerte Option. Wenn Sie Code nur ausführen müssen, wenn der Debugger angehängt ist, verwenden Sie diesen Code:

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

Gelöst mit android:debuggable. Es war ein Fehler beim Lesen eines Elements, bei dem in einigen Fällen das Debug-Flag für ein Element nicht im Datensatz gespeichert wurde und if (m.debug && !App.isDebuggable(getContext()))immer ausgewertet wurde false. Mein Fehler.

Lösung in Kotlin, die ich gerade benutze:

@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
}

Auf diese Weise kann ich mich immer noch beim Debuggen SIGNIEREN und diese werden an Crashlytics gemeldet (Beispiel für den QS-Prozess).