Come verificare se l'APK è firmato o "build di debug"?

Per quanto ne so, in Android "release build" è firmato APK. Come controllarlo dal codice o Eclipse ha una sorta di definizione segreta?

Ho bisogno di questo per eseguire il debug degli elementi ListView che popolano i dati del servizio Web (no, logcat non è un'opzione).

I miei pensieri:

• L'applicazione è android:debuggable, ma per qualche motivo non sembra affidabile.
• L'ID dispositivo hardcoded non è una buona idea, perché utilizzo lo stesso dispositivo per testare gli APK firmati.
• Usando il flag manuale da qualche parte nel codice? Plausibile, ma prima o poi dimenticherò di cambiare, inoltre tutti i programmatori sono pigri.

Esistono diversi modi per verificare se l'applicazione è stata compilata utilizzando il debug o il certificato di rilascio, ma il modo seguente mi sembra il migliore.

Secondo le informazioni nella documentazione di Android Firma dell'applicazione , la chiave di debug contiene il seguente nome distinto del soggetto: " CN = Android Debug, O = Android, C = US ". Possiamo usare queste informazioni per verificare se il pacchetto è firmato con la chiave di debug senza codificare la firma della chiave di debug nel nostro codice.

Dato:

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

Puoi implementare un metodo isDebuggable in questo modo:

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

Per controllare il flag debuggabile, puoi usare questo codice:

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

Kotlin:

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

Per ulteriori informazioni, vedere Protezione delle applicazioni LVL Android .

In alternativa, se stai usando Gradle correttamente, puoi verificare se BuildConfig.DEBUGè vero o falso.

Risposta di Mark Murphy

La soluzione più semplice e migliore a lungo termine è quella di utilizzare BuildConfig.DEBUG. Questo è un booleanvalore che sarà trueper una build di debug, falsealtrimenti:

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

Se vuoi controllare APKstaticamente, puoi usare

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

Questo genera 0se APKnon è possibile eseguire il debug e 1se lo è.

Forse in ritardo, ma iosched usa BuildConfig.DEBUG

Per prima cosa aggiungilo al tuo file build.gradle, questo consentirà anche l'esecuzione fianco a fianco di build di debug e di rilascio:

buildTypes {
    debug {
        applicationIdSuffix ".debug"
    }
}

Aggiungi questo metodo:

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

Anche una build di debug viene firmata, solo con una chiave diversa. Viene generato automaticamente da Eclipse e il suo certificato è valido solo per un anno. Qual è il problema android:debuggable? Puoi ottenere questo valore dal codice usando PackageManager.

Un'altra opzione, degna di nota. Se è necessario eseguire del codice solo quando è collegato il debugger, utilizzare questo codice:

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

Risolto con android:debuggable. Era un bug nella lettura dell'elemento in cui in alcuni casi il flag di debug sull'elemento non veniva memorizzato nel record e veniva if (m.debug && !App.isDebuggable(getContext()))sempre valutato false. Colpa mia.

Soluzione in Kotlin che sto usando al momento:

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

in questo modo posso ancora ACCEDERE al debug e quelli verranno segnalati a Crashlytics (esempio, per il processo di QA)