Feststellen, ob ein gerootetes Gerät verwendet wird

Question

Meine App hat eine bestimmte Funktionalität, die nur auf einem Gerät funktioniert, auf dem Root verfügbar ist. Anstatt diese Funktion bei der Verwendung fehlschlagen zu lassen (und dem Benutzer dann eine entsprechende Fehlermeldung anzuzeigen), würde ich eine Möglichkeit bevorzugen, zuerst stillschweigend zu prüfen, ob Root verfügbar ist, und wenn nicht, die entsprechenden Optionen von vornherein auszublenden.

Gibt es eine Möglichkeit, dies zu tun?

Answer 1

Vergessen Sie die Erkennung von Root-Anwendungen und su-Binärdateien. Suchen Sie nach dem Root-Daemon-Prozess. Dies kann vom Terminal aus geschehen und Sie können Terminalbefehle innerhalb einer Anwendung ausführen. Versuchen Sie diesen Einzeiler.

if [ ! "$(/system/bin/ps -A | grep -v grep | grep -c daemonsu)" = "0" ]; then echo "device is rooted"; else echo "device is not rooted"; fi

Sie brauchen dazu auch keine Erlaubnis von Root.

Edit: Jetzt mit dieser Methode für eine bessere Erkennung!

if [ $(ps -A | grep -e ^shell -e ^root | grep -v "\[" | tr -s ' ' | cut -d ' ' -f 9 | grep -c su) ] || [ $(which su) ]; then echo 'rooted'; else echo 'not rooted'; fi

Answer 2

Mit der Google SafetyNet Attestation API können Sie leicht überprüfen, ob Ihr Gerät verwurzelt ist oder nicht:

1. Hinzufügen von Abhängigkeiten in build.gradle(:app)

   Implementierung 'com.google.Android.gms:play-services-safetynet:17.0.0'

2. Api-Schlüssel abrufen und Android Device Verification API aktivieren mit リンク

3. public static void sendSafetyNetRequest(Activity context) {

    if(GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(context, 13000000) == ConnectionResult.SUCCESS) {
        Log.e(TAG, "The SafetyNet Attestation API is available");
   
        // TODO(developer): Change the nonce generation to include your own, used once value,
        // ideally from your remote server.
   
        String nonceData = "Safety Net Sample: " + System.currentTimeMillis();
        ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
        Random mRandom = new SecureRandom();
   
        byte[] bytes = new byte[24];
        mRandom.nextBytes(bytes);
        try {
            byteStream.write(bytes);
            byteStream.write(nonceData.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
   
        byte[] nonce = byteStream.toByteArray();
   
        SafetyNetClient client = SafetyNet.getClient(context);
        Task<SafetyNetApi.AttestationResponse> task = client.attest(nonce, API_KEY_FROM_STEP_2_LINK);
   
        task.addOnSuccessListener(context, attestationResponse -> {
   
          /*
                 TODO(developer): Forward this result to your server together with
                 the nonce for verification.
                 You can also parse the JwsResult locally to confirm that the API
                 returned a response by checking for an 'error' field first and before
                 retrying the request with an exponential backoff.
                 NOTE: Do NOT rely on a local, client-side only check for security, you
                 must verify the response on a remote server!
                */
   
            String jwsResult = attestationResponse.getJwsResult();
   
            Log.e(TAG, "Success! SafetyNet result:\n" + jwsResult + "\n");
   
            if (jwsResult == null) {
                Log.e(TAG, "jwsResult Null");
   
            }
            final String[] jwtParts = jwsResult.split("\\.");
   
            if (jwtParts.length == 3) {
                String decodedPayload = new String(Base64.decode(jwtParts[1], Base64.DEFAULT));
                Log.e(TAG, "decodedPayload :     " + decodedPayload);
            }
   
        });
   
        task.addOnFailureListener(context, e -> {
            // An error occurred while communicating with the service.
            String mResult = null;
   
            if (e instanceof ApiException) {
                // An error with the Google Play Services API contains some additional details.
                ApiException apiException = (ApiException) e;
   
                Util.showLog(TAG, "Error: " +
                        CommonStatusCodes.getStatusCodeString(apiException.getStatusCode()) + ": " +
                        apiException.getStatusMessage());
            } else {
                // A different, unknown type of error occurred.
               Log.e(TAG, "ERROR! " + e.getMessage());
            }
   
        });
   
    } else {
     Log.e(TAG, "Prompt user to update Google Play services.";
   
    }

   } `

4. Überprüfen Sie Ihre Protokolle auf decodedPayload, wenn ctsProfileMatch und basicIntegrity beide falsch sind, bedeutet dies, dass Ihr Gerät verwurzelt ist. Die Attestation API gibt eine JWS-Antwort zurück, die wie folgt aussieht:

{ "nonce": "6pLrr9zWyl6TNzj+kpbR4LZcfPY3U2FmZXR5IE5ldCBTYW1wbGU6IDE2MTQ2NzkwMTIzNjc=", "timestampMs": 9860437986543, "apkPackageName": " your package name will be displayed here", "ctsProfileMatch": true, "apkDigestSha256": [ "base64 encoded, SHA-256 hash of the certificate used to sign requesting app" ], "basicIntegrity": true, "evaluationType": "BASIC" }

Für mehr Infos überprüfen Sie diesen Link.

Answer 3

Es gibt Sicherheitsnetz-Bescheinigungs-API de Google Play-Dienste mit dem wir das Gerät bewerten und feststellen können, ob es verwurzelt/manipuliert ist.

Bitte lesen Sie meine Antwort zum Umgang mit verwurzelten Geräten:
https://stackoverflow.com/a/58304556/3908895

Answer 4

Sie können dies mit folgendem Code tun:

public boolean getRootInfo() {
    if (checkRootFiles() || checkTags()) {
        return true;
    }
    return false;
}

private boolean checkRootFiles() {
    boolean root = false;
    String[] paths = {"/system/app/Superuser.apk", "/sbin/su", "/system/bin/su", "/system/xbin/su", "/data/local/xbin/su", "/data/local/bin/su", "/system/sd/xbin/su",
            "/system/bin/failsafe/su", "/data/local/su", "/su/bin/su"};
    for (String path : paths) {
        root = new File(path).exists();
        if (root)
            break;
    }
    return root;
}

private boolean checkTags() {
    String tag = Build.TAGS;
    return tag != null && tag.trim().contains("test-keys");
}

Sie können auch in dieser Bibliothek nachsehen RootBeer.

Answer 5

Wenn Sie keine Bibliothek eines Drittanbieters oder eine zufällige Lösung verwenden möchten, verwenden Sie einfach die Google-Lib zur Erkennung.

Android-Geräteüberprüfung

Antwort :

{
  "timestampMs": 9860437986543,
  "nonce": "R2Rra24fVm5xa2Mg",
  "apkPackageName": "com.package.name.of.requesting.app",
  "apkCertificateDigestSha256": ["base64 encoded, SHA-256 hash of the
                                  certificate used to sign requesting app"],
  "ctsProfileMatch": true,
  "basicIntegrity": true,
}

ctsProfileMatch gibt es false, wenn das Gerät verwurzelt ist.

ref link: [1]: https://developer.Android.com/training/safetynet/attestation