Safety Detect qué es y cómo implementarlo.
Tags: android, hmscore, huaweimobileservices, huawei
Published: 2020-09-21 22:43:41

Safety Detect proporciona cuatro elementos que brindan opciones de seguridad para nuestra aplicación:


**Integridad del sistema:** Verifica la integridad del sistema, es útil cuando se trata de pagos financieros o datos confidenciales, por lo que debemos asegurarnos de que nuestro dispositivo sea seguro y confiable. Así obtendremos la integridad de nuestro dispositivo mientras ejecutamos nuestra aplicación. Podemos comprobar si el dispositivo está rooteado o contiene caballos de Troya.

**Verificación de aplicaciones:** verifica que la seguridad de las aplicaciones nos ayudará a buscar virus o aplicaciones maliciosas.


**URLCheck:** para verificar URLs externas y verificar si son seguras
User Detect: para detectar usuarios falsos, podremos detectar si la aplicación está interactuando con un usuario falso, por ejemplo, un robot o un rastreador.


#Entonces tenemos dos niveles de seguridad
**Nivel del sistema:** significa que podremos verificar la seguridad del sistema, como el dispositivo rooteado y los caballos de Troya.
**App Level:** Significa que podremos verificar la seguridad del comportamiento y URL de nuestras aplicaciones.
Pasos
1. Creación de una aplicación en AGC
2. Conecte Android Studio Project a nuestra aplicación en AGC
3. Implementar el SDK de Safety Detect
4. Cree tu interfaz de usuario
5. Obtener un valor nonce
6. Solicita la API
7. Verifica el resultado de la verificación
8. Notifica a la UI el resultado.

#Crear una aplicación en AGC
Como la mayoría de las integraciones con HMS tenemos que crear una aplicación en la consola AGC, completar la información adecuada de la aplicación y activar el kit de detección de seguridad. Si no es la primera vez que usas un kit HMS, no será difícil seguir estos pasos; de lo contrario, sigue este enlace que te guiará paso a paso.

https://developer.huawei.com/consumer/en/codelab/HMSPreparation/index.html#0


Conecta Android Studio Project a nuestra aplicación en AGC
Crea el proyecto de Android Studio, ten en cuenta el nombre del paquete si es la primera vez que realizas este proceso sigue este enlace.

https://developer.huawei.com/consumer/en/codelab/HMSPreparation/index.html#1

Agrega la huella digital a tu aplicación AGC, la forma más fácil de lograr esto es usando Android Studio, en el lado derecho de la pantalla, ve a Gradle y haz clic en lo siguiente, en la pantalla de output obtendrás el mensaje con el SHA256 el cual deberás copiar a AGC.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/elruj3gcco2mqmj7ls06.png)

#Implementar el SDK de detección de seguridad
¡Bien! Agreguemos el SDK de detección de seguridad y editemos el archivo proguard-rules. Para agregar el SDK de detección de seguridad, debemos agregarlo como en esta imagen.
```
dependencies {
// Add the following line
implementation 'com.huawei.hms:safetydetect:5.0.2.300'
}
```

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/ac818yupc2k22yb3nlg4.png)

#Crea tu interfaz de usuario
Creé una interfaz de usuario simple con un botón de llamada a la acción responsable de inicializar el proceso de conexión con la API. Puedes crear el tuyo propio pero si quieres copiar el mío aquí tienes el XML
```
<?xml version="1.0" encoding="utf-8"?>
 <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
     xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
     android:background="@color/emui_color_gray_1"
     tools:context=".MainActivity">
 
     <TextView
         android:id="@+id/textView"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:layout_marginBottom="316dp"
         android:text="Result:"
         app:layout_constraintBottom_toBottomOf="parent"
         app:layout_constraintEnd_toEndOf="parent"
         app:layout_constraintHorizontal_bias="0.29"
         app:layout_constraintStart_toStartOf="parent" />
 
     <Button
         android:id="@+id/check_button"
         android:layout_width="155dp"
         android:layout_height="71dp"
         android:background="@color/colorPrimary"
         android:text="Check"
         android:textColor="@android:color/holo_blue_bright"
         android:textSize="18sp"
         android:textStyle="bold"
         app:layout_constraintBottom_toTopOf="@+id/textView"
         app:layout_constraintEnd_toEndOf="parent"
         app:layout_constraintStart_toStartOf="parent"
         app:layout_constraintTop_toBottomOf="@+id/textView2"
         app:layout_constraintVertical_bias="0.631" />
 
     <TextView
         android:id="@+id/textView2"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:layout_marginTop="120dp"
         android:fontFamily="sans-serif"
         android:text="Safety Detection"
         android:textColor="@color/colorAccent"
         android:textSize="30sp"
         android:textStyle="bold"
         android:typeface="sans"
         app:layout_constraintEnd_toEndOf="parent"
         app:layout_constraintStart_toStartOf="parent"
         app:layout_constraintTop_toTopOf="parent" />
 
 </androidx.constraintlayout.widget.ConstraintLayout>
```
Deberíamos ver algo como esto
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/098uc8wcpzyq1260ljao.png)

#Obtener un valor nonce

Tenemos que obtener un valor nonce, pero ¿qué significa un valor nonce? En criptografía, un nonce es un número arbitrario que se puede usar solo una vez en una comunicación criptográfica. Es similar en espíritu a una palabra nonce, de ahí el nombre. A menudo es un número aleatorio o pseudoaleatorio emitido en un protocolo de autenticación para garantizar que las comunicaciones antiguas no se puedan reutilizar en ataques de repetición.
El valor de nonce debe contener de 16 a 66 bytes y solo se puede usar una vez.
La API sysIntegrity tiene dos parámetros, uno es el valor nonce y el otro es el ID de la aplicación. Para recuperar su aplicación, puede obtenerla desde la consola AGC.

Vamos a codificar

```
byte[] nonce = ("ADX2099" + System.currentTimeMillis()).getBytes();
     SafetyDetect.getClient(this)
             .sysIntegrity(nonce,APP_ID)
             .addOnFailureListener(new OnFailureListener() {
                 @Override
                 public void onFailure(Exception e) {
                     e.printStackTrace();
                 }
             })
             .addOnSuccessListener(new OnSuccessListener<SysIntegrityResp>() {
                 @Override
                 public void onSuccess(SysIntegrityResp sysIntegrityResp) {
                     String sysResult = sysIntegrityResp.getResult();
                     String[] respoSplit = sysResult.split("\\.");
                     String jwsPayLoadStr =respoSplit[1];
                     String payloadDetail = new String(Base64.decode(jwsPayLoadStr.getBytes(), Base64.URL_SAFE));
                     Log.d("TAG1", sysResult);
                 }
             });
 
 }
```
Permíteme explicarte lo que estoy haciendo aquí.
Primero, como deberías notar, este código debería estar dentro de un método, pero te dejaré decidir cómo resolver esa parte.

En primer lugar, debemos notar que estamos usando el patrón builder  para usar la detección de seguridad. Entonces estos son los pasos que estamos siguiendo


Pasa el contexto como parámetro
Pase su ID de aplicación
Implemente un oyente para el éxito y un oyente para el fracaso.
Si la llamada es exitosa, recibiremos el resultado de la verificación de integridad del sistema, esta respuesta es una cadena codificada en Base64 y consta de 3 partes
a) Encabezado
b) Carga útil
c) Firma
Las tres partes se separan con \\ barras

¡Ahora! Convirtamos nuestra respuesta en un objeto JSON, por supuesto, no olvide crear una instancia de su TextView

```
try{
     JSONObject theObject = new JSONObject(payloadDetail);
     final boolean basicIntegrity = theObject.getBoolean(BASIC_INTEGRITY);
     resultTV.setText("" + basicIntegrity);
 
 }catch (JSONException ex){
     ex.printStackTrace();
 }
```
#Conclusión
Con este ejemplo aprendimos cómo usar Safety Detect.