Jak sprawdzić, czy plik APK jest podpisany, czy „kompilacja do debugowania”?

O ile mi wiadomo, w Androidzie „wydanie kompilacji” jest podpisanym plikiem APK. Jak to sprawdzić z kodu, czy Eclipse ma jakieś tajne definicje?

Potrzebuję tego do debugowania wypełniania elementów ListView z danych usługi internetowej (nie, logcat nie jest opcją).

Moje myśli:

• Aplikacje android:debuggable, ale z jakiegoś powodu nie wyglądają na wiarygodne.
• Zakodowanie identyfikatora urządzenia nie jest dobrym pomysłem, ponieważ używam tego samego urządzenia do testowania podpisanych plików APK.
• Używasz ręcznej flagi gdzieś w kodzie? Prawdopodobne, ale na pewno zapomnę kiedyś o zmianie, a wszyscy programiści są leniwi.

Istnieją różne sposoby sprawdzenia, czy aplikacja jest zbudowana przy użyciu certyfikatu debugowania lub wydania, ale następujący sposób wydaje mi się najlepszy.

Zgodnie z informacją w dokumentacji systemu Android. Podpisywanie aplikacji , klucz debugowania zawiera nazwę wyróżniającą podmiotu: „ CN = Android Debug, O = Android, C = US ”. Możemy użyć tych informacji do sprawdzenia, czy pakiet jest podpisany kluczem debugowania bez zakodowania podpisu klucza debugowania na stałe w naszym kodzie.

Dany:

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

Możesz zaimplementować metodę isDebuggable w ten sposób:

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

Aby sprawdzić flagę debugowalną, możesz użyć tego kodu:

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

Kotlin:

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

Aby uzyskać więcej informacji, zobacz Zabezpieczanie aplikacji Android LVL .

Alternatywnie, jeśli poprawnie używasz Gradle, możesz sprawdzić, czy BuildConfig.DEBUGjest to prawda, czy fałsz.

Odpowiedział Mark Murphy

Najprostszym i najlepszym długoterminowym rozwiązaniem jest użycie BuildConfig.DEBUG. To jest booleanwartość, która będzie truedotyczyła kompilacji do debugowania, w falseprzeciwnym razie:

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

Jeśli chcesz sprawdzić APKstatycznie, możesz użyć

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

Te wyjścia 0, jeśli APKnie jest debuggable i 1jeśli to jest.

Może późno, ale iosched używa BuildConfig.DEBUG

Najpierw dodaj to do pliku build.gradle, pozwoli to również na równoległe uruchamianie kompilacji debugowania i wydania:

buildTypes {
    debug {
        applicationIdSuffix ".debug"
    }
}

Dodaj tę metodę:

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

Kompilacja debugowania jest również podpisywana, tylko z innym kluczem. Jest generowany automatycznie przez Eclipse, a jego certyfikat jest ważny tylko przez rok. O co chodzi android:debuggable? Możesz uzyskać tę wartość z kodu za pomocą PackageManager.

Inna opcja, o której warto wspomnieć. Jeśli chcesz wykonać jakiś kod tylko wtedy, gdy dołączony jest debugger, użyj tego kodu:

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

Rozwiązany z android:debuggable. Był to błąd w odczycie elementu, w którym w niektórych przypadkach flaga debugowania elementu nie była zapisywana w rekordzie i if (m.debug && !App.isDebuggable(getContext()))zawsze była oceniana false. Mój błąd.

Rozwiązanie w Kotlinie, którego w tej chwili używam:

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

w ten sposób nadal mogę ZALOGOWAĆ się w debugowaniu, a te zostaną zgłoszone do Crashlytics (na przykład w przypadku procesu kontroli jakości)