Como verificar se o APK está assinado ou "compilação de depuração"?

Tanto quanto eu sei, no Android "release build" é assinado APK. Como verificá-lo a partir do código ou o Eclipse tem algum tipo de definição secreta?

Eu preciso disso para depurar o preenchimento de itens do ListView a partir de dados de serviço da web (não, logcat não é uma opção).

Meus pensamentos:

• Aplicativo android:debuggable, mas por algum motivo que não parece confiável.
• O código do dispositivo de codificação não é uma boa ideia, porque estou usando o mesmo dispositivo para testar APKs assinados.
• Usando sinalizador manual em algum lugar no código? Plausível, mas com certeza vou esquecer de mudar em algum momento, além de todos os programadores serem preguiçosos.

Há uma maneira diferente de verificar se o aplicativo é compilado usando o certificado de depuração ou liberação, mas a seguinte maneira me parece melhor.

De acordo com as informações na documentação do Android, Signing Your Application , a chave de depuração contém o seguinte nome distinto do assunto: " CN = Android Debug, O = Android, C = US ". Podemos usar essas informações para testar se o pacote está assinado com chave de depuração sem a assinatura da chave de depuração codificada em nosso código.

Dado:

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

Você pode implementar um método isDebuggable desta maneira:

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

Para verificar o sinalizador depurável, você pode usar este código:

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

Kotlin:

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

Para mais informações, consulte Protegendo aplicativos Android LVL .

Como alternativa, se você estiver usando o Gradle corretamente, poderá verificar se BuildConfig.DEBUGé verdadeiro ou falso.

Respondida por Mark Murphy

A solução mais simples e melhor a longo prazo é usar BuildConfig.DEBUG. Este é um booleanvalor que será truepara uma compilação de depuração, falsecaso contrário:

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

Se você deseja verificar APKestaticamente, pode usar

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

Isso gera 0se APKnão for depurável e 1se for.

Talvez atrasado, mas o iosched usa BuildConfig.DEBUG

Primeiro adicione isso ao seu arquivo build.gradle, isso também permitirá a execução lado a lado das versões de depuração e lançamento:

buildTypes {
    debug {
        applicationIdSuffix ".debug"
    }
}

Adicione este método:

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

Uma compilação de depuração também é assinada, apenas com uma chave diferente. É gerado automaticamente pelo Eclipse e seu certificado é válido por apenas um ano. Qual é o problema android:debuggable? Você pode obter esse valor do código usando PackageManager.

Outra opção, vale a pena mencionar. Se você precisar executar algum código apenas quando o depurador estiver conectado, use este código:

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

Resolvido com android:debuggable. Foi um erro na leitura do item, onde, em alguns casos, o sinalizador de depuração no item não estava sendo armazenado no registro, sendo if (m.debug && !App.isDebuggable(getContext()))sempre avaliado false. Foi mal.

Solução em Kotlin que estou usando no 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
}

Dessa forma, ainda posso ASSINAR na depuração e eles serão relatados ao Crashlytics (exemplo, para o processo de controle de qualidade)