¿Cómo comprobar si el APK está firmado o "depurar compilación"?

Por lo que yo sé, en Android "versión de compilación" está firmado APK. ¿Cómo verificarlo desde el código o Eclipse tiene algún tipo de definición secreta?

Necesito esto para depurar elementos de ListView de llenado de datos de servicios web (no, logcat no es una opción).

Mis pensamientos:

• Aplicación android:debuggable, pero por alguna razón no parece confiable.
• Codificar el ID del dispositivo no es una buena idea, porque estoy usando el mismo dispositivo para probar APK firmados.
• ¿Utiliza la bandera manual en algún lugar del código? Plausible, pero definitivamente me olvidaré de cambiar en algún momento, además de que todos los programadores son vagos.

Hay diferentes formas de verificar si la aplicación se compila mediante depuración o certificado de liberación, pero la siguiente forma me parece la mejor.

De acuerdo con la información en la documentación de Android Firma de su aplicación , la clave de depuración contiene el siguiente nombre distinguido del sujeto: " CN = Android Debug, O = Android, C = US ". Podemos usar esta información para probar si el paquete está firmado con la clave de depuración sin codificar la firma de la clave de depuración en nuestro código.

Dado:

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

Puede implementar un método isDebuggable de esta manera:

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 la bandera depurable, puede usar este código:

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

Kotlin:

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

Para obtener más información, consulte Protección de aplicaciones LVL de Android .

Alternativamente, si está usando Gradle correctamente, puede verificar si BuildConfig.DEBUGes verdadero o falso.

Respondido por Mark Murphy

La solución más simple y mejor a largo plazo es usar BuildConfig.DEBUG. Este es un booleanvalor que será truepara una compilación de depuración, de lo falsecontrario:

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

Si desea verificar APKestáticamente, puede usar

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

Esto genera 0si APKno se puede depurar y 1si lo es.

Quizás tarde, pero iosched usa BuildConfig.DEBUG

Primero agregue esto a su archivo build.gradle, esto también permitirá la ejecución en paralelo de versiones de depuración y liberación:

buildTypes {
    debug {
        applicationIdSuffix ".debug"
    }
}

Agrega este método:

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

También se firma una compilación de depuración, solo que con una clave diferente. Eclipse lo genera automáticamente y su certificado es válido solo por un año. ¿Cuál es el problema android:debuggable? Puede obtener este valor del código usando PackageManager.

Otra opción digna de mención. Si necesita ejecutar algún código solo cuando se adjunta el depurador, use este código:

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

Resuelto con android:debuggable. Hubo un error en la lectura del elemento donde, en algunos casos, el indicador de depuración en el elemento no se almacenaba en el registro y if (m.debug && !App.isDebuggable(getContext()))siempre se evaluaba false. Culpa mía.

Solución en Kotlin que estoy usando en este 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
}

de esa manera todavía puedo FIRMAR en la depuración y se informará a Crashlytics (por ejemplo, para el proceso de control de calidad)