Planeta Código

Blog Bitix

Validar documentos JSON con JSON Schema

noviembre 25, 2021 07:00

Los documentos JSON son una forma de intercambiar información entre aplicaciones. Como en cualquier intercambio de información es conveniente validar los datos recibidos antes de realizar ninguna acción. En Java dependiendo de la librería o framework utilizada aunque los datos se transmiten en formato JSON estos son transformados y recibidos como objetos Java en los cuales se realizan validaciones de tipos y conversiones de tipos y restricciones a los valores con Bean Validation o Spring Validation. La especificación JSON Schema permite definir un esquema para los documentos JSON independiente del lenguaje con la que realizar validaciones y realizar las validaciones a través de implementaciones en los diferentes lenguajes de programación incluido Java.

Java

Una tarea fundamental en toda aplicación es validar los datos de entrada. Validar los datos evita errores al procesar los datos, generar datos erróneos como resultado o realizar acciones en base a datos no válidos con consecuencias como realizar acciones no deseadas o crear inconsistencias en la base de datos. También hay que validar los datos por motivos de seguridad.

Los datos de entrada de un programa se proporcionan en función de la naturaleza de la aplicación, en una aplicación web o REST es a través de los datos de la petición, en una aplicación que procesa mensajes de servicios como Kafka o RabbitMQ los datos se incluyen en los datos del mensaje y en una aplicación de procesos batch los datos quizá estén en archivos.

Los formatos más comunes para el intercambio de datos son XML, JSON y CSV. El formato de documentos XML permite comprobar está bien formado en cuanto a balanceo de etiquetas junto a otros requerimientos, los esquemas XML permiten validar además si un documento XML cumple con el esquema incluyendo las etiquetas requeridas. JSON es una especificación que de por si no define ningún esquema, esto hace que los documentos JSON puedan tener cualesquiera datos mientras utilicen una sintaxis correcta o tengan un formato correcto. Sin embargo, en la validación de datos el que un documento JSON tenga una sintaxis correcta no es suficiente que se considere válido. Un esquema permite definir que un documento incluya ciertas propiedades, que estás se ajusten a unos valores predeterminados, que cumplan ciertas reglas de validación como un tipo o rango de valores.

La especificación JSON Schema es el equivalente para los documentos JSON de XML Schema para los documentos XML. JSON Schema permite validar que un documento JSON se ajusta a un esquema conteniendo los datos y valores definidos en el esquema.

Contenido del artículo

La especificación JSON Schema

La especificación de JSON Schema tiene varias definiciones formales y versiones. En la guía de inicio paso a paso se incluye una descripción más sencilla y práctica para un primer inicio.

Un esquema de JSON contiene a qué versión de la especificación se ajusta, el identificador o la ubicación del esquema, un título, una descripción y el tipo de objeto del documento raíz. Además define qué propiedades junto con sus tipos ha de contener el documento JSON al que se aplica, cuáles de esas propiedades son requeridas y las validaciones sobre los datos como restricciones en los valores de los datos o elementos de un array. Además de propiedades un documento permite la anidación de estructuras en las que también se definen que propiedades contienen y cuáles son requeridas. Finalmente, un esquema JSON permite referenciar un esquema JSON externo.

En el siguiente esquema $schema define la versión del esquema que implementa, $id define el identificador del esquema. Las propiedades title, description proporcionan una descripción del esquema y type el tipo de objeto raíz. En la propiedad properties se definen las propiedades del documento JSON y en la propiedad required cuáles de esas propiedades son requeridas. En la propiedad dimensions están las estructuras JSON anidadas. Y con la propiedad $ref se referencia otro esquema JSON.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

{
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "$id": "https://example.com/product.schema.json",
    "title": "Product",
    "description": "A product from Acme's catalog",
    "type": "object",
    "properties": {
      "productId": {
        "description": "The unique identifier for a product",
        "type": "integer"
      },
      "productName": {
        "description": "Name of the product",
        "type": "string"
      },
      "price": {
        "description": "The price of the product",
        "type": "number",
        "exclusiveMinimum": 0
      },
      "tags": {
        "description": "Tags for the product",
        "type": "array",
        "items": {
          "type": "string"
        },
        "minItems": 1,
        "uniqueItems": true
      },
      "dimensions": {
        "type": "object",
        "properties": {
          "length": {
            "type": "number"
          },
          "width": {
            "type": "number"
          },
          "height": {
            "type": "number"
          }
        },
        "required": [
          "length",
          "width",
          "height"
        ]
      },
      "warehouseLocation": {
        "description": "Coordinates of the warehouse where the product is located.",
        "$ref": "https://example.com/geographical-location.schema.json"
      }
    },
    "required": [
      "productId",
      "productName",
      "price"
    ]
  }

product.schema.json

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

{
    "$id": "https://example.com/geographical-location.schema.json",
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "title": "Longitude and Latitude",
    "description": "A geographical coordinate on a planet (most commonly Earth).",
    "required": [
      "latitude",
      "longitude"
    ],
    "type": "object",
    "properties": {
      "latitude": {
        "type": "number",
        "minimum": -90,
        "maximum": 90
      },
      "longitude": {
        "type": "number",
        "minimum": -180,
        "maximum": 180
      }
    }
  }

geographical-location.schema.json

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

{
  "productId": 1,
  "productName": "An ice sculpture",
  "price": 12.5,
  "tags": [
    "cold",
    "ice"
  ],
  "dimensions": {
    "length": 7,
    "width": 12,
    "height": 9.5
  },
  "warehouseLocation": {
    "latitude": -78.75,
    "longitude": 20.4
  }
}

product.json

1
2

{
}

product-invalid.json

Librerías JSON Schema en Java

Hay varias librerías Java que implementan validación de JSON con la especificación de JSON Schema, junto a otras implementaciones en otros lenguajes. De entre las implementaciones Java una de ellas es JSON Schema Validator de networknt en la que los errores que se detectan son devueltos en una estructura de datos en vez de lanzar una excepción en caso de que la validación falle.

Otra de sus funcionalidades es que permite hacer una correspondencia entre los identificadores de los esquemas JSON a recursos locales, útil en caso de que los esquemas no estén publicados en sus direcciones, en aplicaciones en las que no tengan conexión a internet o no se desea que estas realicen conexiones externas.

Hay que tener en cuenta que varias de estas librerías están implementadas por personas sin seguramente el respaldo de una organización, hay que tenerlo en cuenta como criterio de decisión en el caso de añadir como dependencia de un proyecto una de las implementaciones.

Ejemplo con Java de validar un JSON con JSON Schema

Este es un ejemplo que a partir de un documento JSON se valida que cumple el esquema contra el que se valida. En el caso de que el documento JSON no cumpla el esquema se devuelven los errores como resultado del método de validación, en el caso del ejemplo los errores son emitidos a la salida estándar donde se aprecia que en el caso de la validación del JSON inválido faltan las tres propiedades requeridas.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

package io.github.picodotdev.blogbitix.jsonschema;

import java.net.URI;
import java.util.Map;
import java.util.Set;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.networknt.schema.JsonSchema;
import com.networknt.schema.JsonSchemaFactory;
import com.networknt.schema.SpecVersion;
import com.networknt.schema.ValidationMessage;

public class Main {

    public static void main(String[] args) throws Exception {
        Map<String, String> urlMappings = Map.of("https://picodotdev.github.io/blog-bitix/misc/json/product.schema.json", "resource:/product.schema.json",
                "https://picodotdev.github.io/blog-bitix/misc/json/geographical-location.schema.json", "resource:/geographical-location.schema.json");
        ObjectMapper mapper = new ObjectMapper();
        JsonSchemaFactory factory = JsonSchemaFactory.builder(JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V201909))
                .objectMapper(mapper)
                .addUriMappings(urlMappings)
                .build();

        JsonSchema schema = factory.getSchema(URI.create("resource:/product.schema.json"));

        {
            JsonNode json = mapper.readTree(Main.class.getResourceAsStream("/product.json"));
            Set<ValidationMessage> errors = schema.validate(json);
            System.out.printf("Valid JSON errors: %d5n", errors.size());
        }

        {
            JsonNode json = mapper.readTree(Main.class.getResourceAsStream("/product-invalid.json"));
            Set<ValidationMessage> errors = schema.validate(json);
            System.out.printf("Valid JSON errors: %d%n", errors.size());
            errors.stream().forEach(it -> {
                System.out.printf("Type: %s%n", it.getType());
                System.out.printf("Message: %s%n", it.getMessage());
            });
        }
    }
}

Main.java

1
2
3
4
5
6
7
8

Valid JSON errors: 0
Invalid JSON errors: 3
Type: required
Message: $.productId: is missing but it is required
Type: required
Message: $.productName: is missing but it is required
Type: required
Message: $.price: is missing but it is required

System.out

La librería de JSON Schema Validator además de su propia dependencia requiere incluir otras en el archivo de construcción, en este caso de Gradle.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

plugins {
    id 'application'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'com.networknt:json-schema-validator:1.0.64'
    implementation 'com.fasterxml.jackson.core:jackson-databind:2.13.0'
    implementation 'org.slf4j:slf4j-api:1.7.32'
    implementation 'org.apache.commons:commons-lang3:3.12.0'
}

application {
    mainClass = 'io.github.picodotdev.blogbitix.jsonschema.Main'
}

build.gradle

Otras formas de validación con Bean Validation y Spring Validation

Otra forma de validar un JSON es cargarlo en un objeto Java y validar el objeto con Bean Validation o Spring Validation. La diferencia en este caso respeto a JSON Schema es que Bean Validation y Spring Validation es una solución específica de Java, requiere cargar los datos en objetos y más importante no se define ningún esquema sino que el esquema está implícito en las validaciones ya se definan con anotaciones o con validadores personalizados.

Validar objetos con Spring Validation, ejemplo registros de jOOQ

El código fuente completo del ejemplo puedes descargarlo del repositorio de ejemplos de Blog Bitix alojado en GitHub y probarlo en tu equipo ejecutando siguiente comando:
./gradlew run

» Leer más, comentarios, etc...

Arragonán

Documental sobre Squads

noviembre 24, 2021 12:00

Squads es un documental de Invision sobre el popularizado término squads, en el que se explica su origen y se muestran unas pinceladas de cómo trabajan algunos equipos que crean productos de digitales.

Mi resumen sobre el término sería algo como tener equipos multidisciplinares donde se mezclan personas con habilidades complementarias que estén alineadas para alcanzar un objetivo común, o como mínimo aspirar a ello.

El documental se centra principalmente en la parte de descubrimiento y diseño de producto (siendo Invision una compañía de diseño tampoco sorprende :)). Aparecen personas de compañías conocidas mundialmente como Atlassian, Airbnb, Youtube… y algunas startups de menor tamaño. Además de Jeff Sutherland, uno de los creadores de Scrum; y Henrik Kniberg, el de los famosos vídeos de Spotify Engineering Culture que tanto se viralizaron y terminaron en el boom del “modelo spotify” que se ha intentado replicar tantas veces, al parecer sin demasiado éxito.

Creo que es un documental interesante para cualquiera que trabaje en el mundo de producto digital, sea cual sea su perfil. Aunque también creo que idealiza y simplifica el conseguir trabajar de ese modo.

Digo esto porque, aunque creo que tener equipos multidisciplinares es la mejor estrategia para construir producto (que los llamen squads, células, scrum teams… es irrelevante), no es algo que ocurra diciéndole a un grupo de personas que tienen que trabajar en lo mismo y eso haga que se alineen mágicamente. Hay que trabajarlo e iterarlo, y aún así puede que nunca se consiga convertir a un grupo de personas en un equipo.

» Leer más, comentarios, etc...

Variable not found

Cómo evitar que entren argumentos nulos en métodos de C#: un recorrido histórico (y lo que nos trae el futuro)

noviembre 23, 2021 11:32

Estamos muy acostumbrados a comenzar nuestros métodos realizando comprobaciones para evitar que pasen a nuestro código valores nulos que pudieran romper la aplicación.

Desde el principio de los tiempos, estas guardas han presentado el siguiente aspecto:

public class MyService
{
    public void MyMethod(object first, object second)
    {
        if(first == null) 
        {
            throw new ArgumentNullException("first");
        }
        if(second == null) 
        {
            throw new ArgumentNullException("second");
        }        
        // ...
    }
}

¿Todo bien, verdad? El código es aparentemente correcto y fácil de comprender, pero... ¡demasiado extenso! Hemos consumido casi diez líneas de código sólo realizando comprobaciones de "fontanería", y ni siquiera hemos empezado a plantear la funcionalidad real del método.

Afortunadamente, con el tiempo C# ha ido evolucionando y mejorando sucesivamente este escenario tan frecuente.

C# 6: el operador `nameof`

Aunque no iba en la línea de simplificar el código, el operador nameof, introducido en C# 6, permitió solucionar un pequeño problema que tenían esas comprobaciones, potencial causante de problemas o confusiones. Estábamos creando una sutil y frágil dependencia entre el nombre del parámetro a nivel de código y la cadena que estamos enviando al constructor de la excepción ArgumentNullException:

if(first == null) 
{
    throw new ArgumentNullException("first");
}

Esto se puede entender rápidamente si refactorizamos el método para renombrar el parámetro first a one. El código resultante sería el siguiente, donde podemos ver que el valor enviado al instanciar la excepción no se corresponde con el nombre real del parámetro, pues al tratarse de una cadena de texto no se ha visto afectada por el renombrado:

public void MyMethod(object one, object second)
{
    if(one == null) 
    {
        throw new ArgumentNullException("first"); // Debería ser "one"!
    }
    ...
}

Si bien no es un error, ciertamente podría despistar al ver la excepción, pues haría referencia a un parámetro inexistente (o, en el peor de los casos, a un parámetro incorrecto):

Unhandled exception. System.ArgumentNullException: Value cannot be null. Parameter name: first

El operador nameof permite obtener en tiempo de ejecución el nombre asignado a nivel de código fuente a cualquier tipo de elemento (variables, parámetros, propiedades, métodos, etc.), de forma que evitamos estas dependencias:

public class MyService
{
    public void MyMethod(object first, object second)
    {
        if(first == null) 
        {
            throw new ArgumentNullException(nameof(first));
        }
        if(second == null) 
        {
            throw new ArgumentNullException(nameof(second));
        }        
        // ...
    }
}

Bueno, hemos mejorado en algo, pero seguimos teniendo que escribir demasiado, ¿verdad? Por suerte, C# 7 no tardó en llegar :)

C# 7: expresiones `throw`

El compilador de C# 7 comenzó a mirar las instrucciones throw con otros ojos, tratándolas a todos los efectos como si fueran expresiones, gracias a la introducción de las throw expressions.

Recordemos que, en la práctica, esta característica permite introducir un throw en cualquier punto del código donde pueda ir una expresión, como en el siguiente ejemplo:

public static int Divide(int a, int b)
{
    return a / (b != 0 ? b: throw new ArgumentOutOfRangeException(nameof(b)));
}

Pues bien, uniendo esto al null coalescing operator (??) introducido años atrás, en los tiempos de C# 2, permite simplificar considerablemente el código de comprobación de nulos:

public class MyService
{
    public void MyMethod(object first, object second)
    {
        first = first ?? throw new ArgumentNullException(nameof(first));
        second = second ?? throw new ArgumentNullException(nameof(second));
        // ...
    }
}

Vamos mejorando, pero aún el lenguaje podía darnos algo más...

C# 8: null coalescing assignment

No soy capaz de traducir el nombre de esta característica, pero intentaré explicar para qué sirve 😁. Suponed un código como el siguiente, que seguro que habéis implementado más de una vez, en el que asignamos una variable sólo si ésta contiene un nulo:

// Usando un if:
if(myObject == null)
{
    myObject = new MyClass();
}

// O bien, usando el operador "??":
myObject = myObject ?? new MyClass();

El null coalescing operator permite asignar una variable cuando ésta sea null en un único paso:

myObject ??= new MyClass();

Ahora, si recordamos el punto en el que C# 7 dejó nuestro código de comprobación de argumentos nulos, vemos que la idea puede encajar bastante y ayudarnos a simplificarlo aún más:

public class MyService
{
    public void MyMethod(object first, object second)
    {
        first ??= throw new ArgumentNullException(nameof(first));
        second ??= throw new ArgumentNullException(nameof(second));
        // ...
    }
}

Parece difícilmente mejorable... ¿o no?

.NET 6: empoderando `ArgumentNullException`

Con .NET 6/C# 10 nos llega un interesante método estático en la clase ArgumentNullException que simplifica aún más el código necesario para lanzar esa excepción si el valor recibido es nulo.

public class MyService
{
    public void MyMethod(object first, object second)
    {
        ArgumentNullException.ThrowIfNull(first);
        ArgumentNullException.ThrowIfNull(second);
        // ...
    }
}

Imposible de mejorar, ¿verdad? Después veremos que no ;)

En cualquier caso, esta mejora es posible gracias al uso de otra novedad de C# 10, el atributo [CallerArgumentExpression]. A esto dedicaremos un post en el futuro, pero de momento basta con saber que es un atributo al estilo de [CallerMemberName], [CallerFilePath] y [CallerLineNumber], introducidos en C# 5, cuyo objetivo es obtener información sobre el consumidor de un método.

Podemos ver su utilización en el código fuente de ArgumentNullException, e intuir cómo funciona:

public class ArgumentNullException : ArgumentException
{
    ...
    public static void ThrowIfNull(
             [NotNull] object? argument, 
             [CallerArgumentExpression("argument")] string? paramName = null)
    {
        ...
    }
}

Si realizamos una invocación como ArgumentNullException.ThrowIfNull(first), el valor recibido en argument será el valor de first, mientras que en paramName recibiremos la cadena "first". Esto permitirá mostrar el error exactamente con la expresión utilizada en el punto de la llamada.

.NET 6 / C# 10: doble salto mortal con los `global using static`

Pues sí, aunque suene un poco a feature abuse, podemos darle una vuelta más al asunto haciendo uso de las directivas globales. Aunque en un post ya vimos cómo usar usings globales para importar espacios de nombres, también podemos utilizarla para facilitar el acceso a miembros estáticos.

En la práctica, podemos añadir el cualquier archivo del proyecto una directiva como la siguiente (aunque también podemos hacerlo en el .csproj):

global using static System.ArgumentNullException

Y de esta forma, podemos reducir aún más nuestro código de partida:

public class MyService
{
    public void MyMethod(object first, object second)
    {
        ThrowIfNull(first);
        ThrowIfNull(second);
        // ...
    }
}

Esto ya sí que no lo mejora nadie. ¿O sí?

C# vNext: simplificando el chequeo de argumentos nulos

Se está cociendo una nueva mejora en el lenguaje que probablemente será el golpe definitivo al código de chequeo de nulos al inicio de nuestros métodos.

Aunque de momento está en desarrollo y las cosas podrían cambiar, las comprobaciones simplificadas de argumentos nulos o Simplified Null Argument Checking, nos permitirán eliminar totalmente estas comprobaciones.

En su lugar, simplemente definiremos los parámetros que queremos comprobar usando una exclamación, de la siguiente forma:

public class MyService
{
    public void MyMethod(object first!!, object second!!)
    {
        // ...
    }
}

¡Voila! El único hecho de añadir esas exclamaciones al nombre del parámetro hará que en tiempo de ejecución se comprueben los valores, y se lance de forma automática una excepción ArgumentNullException cuando el valor sea nulo.

Fijaos que las exclamaciones están en el parámetro, no en su tipo: esto es así porque se trata de que el sistema añada una comprobación en tiempo de ejecución, pero no afecta al tipo del parámetro.

Punto extra: recordad que usar "==" no es la mejor forma de comprobar los nulos

Si aún con estas novedades del lenguaje y la plataforma preferís utilizar la clásica sentencia if para comprobar los nulos, es interesante que tengáis en cuenta dos cosas.

En primer lugar, ya hablamos hace tiempo de usar el operador "==" para comparar con valores nulos no era la forma más correcta de hacerlo, pues dicho operador podía ser sobrecargado para otorgarle un comportamiento distinto del esperado.

De hecho, la forma recomendable de comprobar la nulidad de un objeto es utilizar el operador is:

if(myObj is null)
{
    ...
}

De la misma forma, si queremos comprobar justamente lo contrario, es decir, que un objeto no sea nulo, podemos aprovechar los patrones combinacionales introducidos por C# 9 y hacerlo de esta forma tan elegante:

if(myObj is not null)
{
    ...
}

¡Y esto es todo! Espero que este recorrido por las diferentes opciones que tenemos y tendremos para evitar la entrada de argumentos nulos en los métodos os haya resultado interesante :)

Publicado en Variable not found.

» Leer más, comentarios, etc...

Variable not found

Enlaces interesantes 463

noviembre 22, 2021 07:05

Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)

Variable not found

Generación de rutas con parámetros de query string en Blazor 6

noviembre 16, 2021 07:05

Hasta Blazor 6, daba la impresión de que la query string era un ciudadano de segunda clase en el sistema de routing, pues no se ofrecían mecanismos sencillos para la obtención de parámetros suministrados a través de esta vía, ni tampoco para la generación de URI que los utilizaran. De hecho, estas tareas teníamos que solucionarlas manualmente, aunque fuera con ayuda de paquetes externos como Microsoft.AspNetCore.WebUtilities.

Ya con la llegada de esta versión, Blazor incorpora de serie herramientas que nos harán esto más llevadero, como su integración con el binding o, lo que veremos en este post, la posibilidad de generar direcciones que incluyan este tipo de parámetros.

Para generar rutas con parámetros de query string debemos utilizar el servicio NavigationManager que ya conocemos, al que se se han añadido los métodos GetUriWithQueryParameters() y GetUriWithQueryParameter() para tal fin.

El método GetUriWithQueryParameters() genera una URI, incluyendo en su query string los parámetros que le suministremos en forma de diccionario clave-valor. En el siguiente código, por ejemplo, vemos cómo utilizar este método para generar una URI apuntando hacia la misma página actual, estableciéndole valores para tres parámetros de query string Search, Page y PageSize, y luego usando el método NavigateTo() para mover al usuario a ella:

@page "/search"

<ul>
    <li>Search: @Search</li>
    <li>Page: @Page</li>
    <li>PageSize: @PageSize</li>
</ul>
<button @onclick="SearchComputersClick">Search computers</button>

@code {
    [Parameter, SupplyParameterFromQuery]
    public string? Search { get; set; }

    [Parameter, SupplyParameterFromQuery]
    public int? Page { get; set; }

    [Parameter, SupplyParameterFromQuery]
    public int? PageSize { get; set; }

    void SearchComputersClick()
    {
        var dict = new Dictionary<string, object>()
        {
            { "search", "computers" },
            { "sage", 1 },
            { "sageSize", 20 },
        };
        var uri = NavManager.GetUriWithQueryParameters(dict);
        NavManager.NavigateTo(uri);
    }
}

Observad también el uso de [SupplyParameterFromQuery] para recuperar estos parámetros de forma muy sencilla en las propiedades del componente.

Aunque GetUriWithQueryParameters() por defecto tomará como punto de partida la URI de la página actual (NavigationManager.Uri), es posible indicarle una distinta usando otra de sus sobrecargas, como en el siguiente ejemplo:

var dict = new Dictionary<string, object>()
{
    { "search", "computers" },
    ... // Otras entradas del diccionario
};

// Podemos usar como base direcciones relativas al sitio:
var uri = NavManager.GetUriWithQueryParameters("/catalog", dict);
// O incluso direcciones absolutas externas:
var uri = NavManager.GetUriWithQueryParameters("https://google.es", dict);
...

Por supuesto, este método lidiará internamente con aspectos como la codificación URL, que se realizará de forma automática:

var dict = new Dictionary<string, object>()
{
    { "search", "Tom & Jerry" },
};
var uri = NavManager.GetUriWithQueryParameters("/catalog", dict);
// Returns: /catalog?search=Tom%20%26%20Jerry

El método GetUriWithParameters() no sólo añade parámetros de query string. También puede modificarlos o eliminarlos cuando partimos de una ruta que ya contenía parámetros de este tipo, aplicando una lógica bastante útil:

Si el diccionario añade parámetros que no se encontraban previamente en la URI original, se añaden a la dirección resultante:

var dict = new Dictionary<string, object>()
{
    { "search", "computers" }
};
var initial = "/catalog";
var uri = NavManager.GetUriWithQueryParameters(initial, dict);
// uri => /catalog?search=computers

Si la URL original incluye parámetros que no son sobrescritos en el diccionario, se mantienen:

var dict = new Dictionary<string, object>()
{
    { "page", "12" }
};
var initial = "/catalog?search=computers";
var uri = NavManager.GetUriWithQueryParameters(initial, dict);
// uri => /catalog?search=computers&page=12

Si la URI original incluye parámetros que son sobrescritos en el diccionario, se machaca el valor:

var dict = new Dictionary<string, object>()
{
    { "search", "computers" },
    { "page", "12" },
};
var initial = "/catalog?search=tv&page=1&pageSize=20";
var uri = NavManager.GetUriWithQueryParameters(initial, dict);
// uri => /catalog?search=computers&page=12&pageSize=20

Si la URI original incluye parámetros que son establecidos con valores nulos en el diccionario, se eliminan de la query string:

var dict = new Dictionary<string, object>()
{
    { "page", null },
    { "pageSize", null}
};
var initial = "/catalog?search=computers&page=1&pageSize=20";
var uri = NavManager.GetUriWithQueryParameters(initial, dict);
// uri => /catalog?search=computers

Por último, cabe destacar que, para evitar el uso de un diccionario cuando únicamente queremos modificar uno de los parámetros, podemos utilizar el método GetUriWithQueryParameter():

<button @onclick="IncrementPage">Next page</button>
@code {
    [Parameter, SupplyParameterFromQuery]
    public int Page { get; set; }

    void IncrementPage()
    {
        Page++;
        // Actualizamos solo el parámetro "page", dejando el resto intacto:
        var uri = NavManager.GetUriWithQueryParameter("page", Page);

        // Y navegamos a la nueva URI:
        NavManager.NavigateTo(uri);
    }

}

Publicado en Variable not found.

» Leer más, comentarios, etc...

Variable not found

Enlaces interesantes 462

noviembre 15, 2021 07:05

Ahí van los enlaces recopilados durante la semana pasada, obviamente muy condicionados por la oleada de lanzamientos de nuevas versiones de casi todo. Espero que os resulten interesantes. :-)

Por si te lo perdiste...

Si las shadow properties no existen como propiedades en la entidad, ¿cómo podemos inicializarlas en el seed de Entity Framework Core?
José María Aguilar
CRUD en Blazor usando el componente DataGrid de Syncfusion
José María Aguilar

.NET Core / .NET

Announcing .NET 6 - The Fastest .NET Yet
Richard Lander
Welcome to C# 10
Kathleen Dollard
What’s New for Visual Basic in Visual Studio 2022
Kathleen Dollard
F# is officially here!
Kathleen Dollard
Announcing dotnet monitor in .NET 6
Sourabh Shirhatti
How to Fully Cover .NET C# Console Application With Unit Tests
Ahmed Tarek
Executing ad hoc C# code snippets
Dominique St-Amand
Bite-Size .NET 6 - UnionBy, IntersectBy, ExceptBy, and DistinctBy
Matthew Jones
Asynchronous Programming in .NET Core C#
Pro Code Guide
Top 6 Features in the new .NET Version & Top 5 Features in the new C# Version
Nikola M. Zivkovic
Source generator updates: incremental generators: Exploring .NET Core 6
Andrew Lock
GIFs in Console Output Using ImageSharp and Spectre.Console
Khalid Abuhakmeh
C# Delegates
Marinko Spasojevic
WhenAny and Pattern Matching with Different Types of Task
Bryan Hogan
C# 10 Falls Just a Bit Short
Matthew MacDonald
Single File Apps In .NET 6
Wade Gausden
How C# 10.0 and .NET 6.0 improve ArgumentExceptions
Ian Griffiths
Dissecting Interpolated Strings Improvements in C# 10
Sergey Teplyakov
Building a project that target .NET Framework 4.5 in Visual Studio 2022
Thomas Levesque
Why Does x = ++x + x++ Give Me the Wrong Answer?
OriginalGriff
Overriding Sealed Methods in C#
Adam Furmanek

ASP.NET Core / ASP.NET / Blazor

Announcing ASP.NET Core in .NET 6
Daniel Roth
Announcing YARP 1.0 Release
Sam Spencer
ASP.NET Core scheduling with Quartz.NET and SignalR monitoring
Damien Bowden
Server-Sent Events and ASP.NET Core
Tomasz Pęczek
File upload with progress bar in Blazor
Gérald Barré
How to resolve dependencies in .NET APIs based on current HTTP Request
Davide Bellone
How to use JSONPatch in .net core
Gary Woodfine
Back to Basics: Add an ASP.NET Runtime Information Startup Banner
Rick Strahl
Fixing Error NETSDK1152 after upgrading to .NET 6
Mark Downie
4 Easy Steps to Embed a JavaScript Control into a Blazor App
Hari Venkatesh E

Azure / Cloud

Introducing Azure Container Apps: a serverless container service for running modern apps at scale
Daria Grigoriu
General Availability of Azure Functions OpenAPI Extension
Justin Yoo
Using AutoFac with .NET 6 Isolated Azure Functions
Adam Storr

Conceptos / Patrones / Buenas prácticas

Reader as a profunctor
Mark Seemann
Publishing Events from CRUD or Commands?
Derek Comartin
The strong and weak forces of architecture
Evan Bottcher

Web / HTML / CSS / Javascript

Un ciberataque basado en caracteres invisibles o ambiguos permite introducir puertas traseras en código JavaScript
Marcos Merino
The HTTP QUERY Method
Julian Reschke
Icon Glassmorphism Effect in CSS
Ana Tudor
Quick browser Developer Tools tip: define and test interaction states in CSS using state simulation
Christian Heilmann
Converting JavaScript to TypeScript
Jason Gaylord
React Suspense: Lessons Learned While Loading Data
Adam Rackis
Localizing Your Next.js App
Átila Fassina
Why We Have To Unsubscribe An Observable In An Angular Application?
Naveen Bommidi
Quick and Dirty Bootstrap Overrides at Runtime
Meredith Matthews
What to do if your Development Site gets Indexed in Google
Colin McDermott
How to Support IE11 Users as You Move to Angular 13
Mark Thompson
The EyeDropper API: Pick colors from anywhere on your screen
Kilian Valkhof
Easy Dark Mode (and Multiple Color Themes!) in React
Abram Thau
View-Source
Eric Lawrence
Quickly Get Alerted to Front-End Errors and Performance Issues
Chris Coyier
Semantic <menu> context
Scott O'Hara
Does ES6 make JavaScript frameworks obsolete?
Theodoros ‘Theo’ Karasavvas
What You Need to Know about Angular v13
Alisa Duncan
Other Looks at the Conditional Border Radius Trick
Chris Coyier
What is PostCSS & Why should we care?
Mainak Das
How to Destructure Nested JavaScript Objects
Jay Cruz

Visual Studio / Complementos / Herramientas

La manera correcta de ejecutar scripts PowerShell en el programador de tareas de Windows
José Manuel Alarcón
Migrar un repositorio de un BitBucket Server local a GitHub
Gisela Torres
Visual Studio 2022 now available
Amanda Silver
Visual Studio Code 1.62 (October 2021 Update) is now available for download
Kunal Chowdhury
Announcing NuGet 6.0 - Source Mapping, Package Vulnerabilities, Faster Solution Load, Oh My!
Jon Douglas
MSBuild and 64-bit Visual Studio 2022
Rainer Sigwald
Visual Studio 2022 for Mac Preview 3, and Upcoming Native M1 Processor Support
Jordan Matthiesen
General Availability of PowerShell 7.2
Steve Lee
Notebooks, Visual Studio Code style
Tanna Kabir
Solution to Visual Studio 2022 messing up Visual Studio 2019
Patrick Smacchia
Visual Studio : How to solve missing ASP.NET template for .NET Framework
HowToSolutions
Hello World from ContextKeeper!
Piotr Karczmarz
10 VS Code Extensions to Fight Technical Debt
Alex Omeyer
Removing a .env file from Git history
Chris Bongers

Xamarin / .NET MAUI

What's New in Xamarin and Visual Studio 2022
David Ortinau
Announcing .NET MAUI Preview 10
David Ortinau
Xamarin.Forms: Clear cookies in WebViews - András Tóth's professional blog
András Tóth
Xamarin.Forms - Validation using Xamarin Community Toolkit
Delpin Susai Raj
.NET MAUI – Blazor
Vijay Anand
Invoke platform code in .NET MAUI
David Britch
Xamarin.Forms: Use converters with binding objects which can have null as value.
András Tóth

Publicado en Variable not found.

» Leer más, comentarios, etc...

Arragonán

Píldora. Acceder a variables de entorno desde plantillas Thymeleaf

noviembre 13, 2021 12:00

Es una buena práctica depender de variables de entorno para las configuraciones, tanto secretos como cualquier otra configuración que puede cambiar entre los entornos de despliegue de nuestro software. De ese modo tenemos control granular de cada configuración en cada despliegue que hagamos, y en caso de tener que cambiar alguna configuración no es necesario hacer ningún commit en nuestro repositorio.

A veces es algo que hay que montar un poco más a mano, pero trabajando con Spring Boot es algo que ya está resuelto y da flexibilidad al respecto. A nivel del código de infraestructura en código dependiente de Spring simplemente usando la anotación @Value ya nos inyectará el valor que haya en el application context.

Lo que hasta hace poco no había tenido que resolver es acceder a esas variables de entorno directamente desde plantillas de Thymeleaf, en este caso para evitar tener hardcoded la configuración de Firebase Authentication.

Buscando información encontré que, como parte de la integración con Spring, es posible acceder a los beans del application context utilizando @ en las plantillas.

Así que podemos acceder al bean que representa el Environment, por ejemplo:

${@environment.getProperty("FIREBASE_API_KEY")}

» Leer más, comentarios, etc...

Blog Bitix

Ejemplo de un potencial ataque informático de phishing, El caso de El Gatico Biever

noviembre 11, 2021 06:00

A estas alturas la mayoría de la gente seguramente ya haya recibido a través de un medio u otro algún intento de tipo de ataque informático, ya sea a través del correo electrónico, mensajes SMS con enlaces o a través de aplicaciones de mensajería instantánea. Los ataques informáticos cada vez van a ir a más y serán más peligrosos a medida que más operaciones se realicen a través de internet, surgirán medidas adicionales de seguridad para evitarlos como el segundo factor de autenticación pero también surgirán nuevas formas de ataque, donde el componente humano seguramente siga siendo la parte más débil del sistema de seguridad. Este artículo es el relato de la historia de un potencial ataque informático de phishing.

Los ataques informáticos ya no se producen solo por descargar de una una fuente no confiable y ejecutar un programa en el ordenador, ni siquiera estos son los más peligrosos. Un virus informático requiere conocimientos avanzados de programación, tiempo para desarrollar un programa con la función maliciosa que no sea bloqueada por las medidas de seguridad del sistema operativo y distribuirla de alguna forma entre las potenciales víctimas para que se lo descarguen, los virus informáticos son una forma muy elaborada de realizar un ataque informático.

Aparte de los virus hay otras formas de ataque informático mucho más sencillas de desarrollar y de distribuir. Una ataque de phishing simplemente requiere desarrollar una página en la que la víctima introduzca los datos que se deseen robar que van desde información personal hasta credenciales de inicio de sesión en la banca online, servicios como Gmail o PayPal o los datos de la tarjeta de crédito con los que robar el límite de saldo diariamente que la tarjeta permita hasta que el usuario o el banco la bloqueen.

Una vez está desarrollada la página de phising el siguiente paso es hacer que las víctimas accedan a ella, tan simple como enviar un enlace por algún medio como un mensaje de correo electrónico, mensaje SMS o una aplicación de mensajería instantánea a través del móvil.

Contenido del artículo

El caso de El Gatico Biever

En este artículo comento un potencial caso como ejemplo y una vez leído me puedes comentar si crees que este era un ataque informático. En el que denominaré El caso del Gatico Biever está basado en una conversación real que mantuve por correo electrónico a la que he cambiado el nombre real del contacto y comentado los hechos relevantes del contenido de los mensajes.

Sin más, os dejo con la narración de El caso del Gatico Biever.

El contacto

Tengo un blog con ya casi una década de vida y más de 600 artículos publicados algunos posicionados en las primeras posiciones de las páginas de resultados por algunas combinaciones de palabras clave. El blog tiene casi 2.5K páginas vistas diariamente y unas 65K páginas mensuales.

Por algún motivo que desconozco pero supongo por el buen posicionamiento de algunas páginas y la autoridad del dominio, me sorprende la buena cantidad de comerciales que me contactan solicitando publicar algún artículo a cambio de una pequeña compensación económica. Quizá no todas las semanas recibo una oferta para publicar un artículo pero si cada uno o dos meses, algunas llegan a buen fin otras simplemente se quedan en el conocimiento de las condiciones.

El interés de estos comerciales al publicar el artículo es incluir algún enlace en los artículos hacia alguna página o servicio por motivos de SEO, a veces el interés es simplemente insertar un enlace en un artículo ya posicionado. Dar a conocer una página web o servicio desde cero o hacerlo crecer es difícil y requiere tiempo, para reducir este tiempo están dispuestos a pagar a sitios web existentes.

Uno de estos meses recibí un correo electrónico como remitente el Gatico Biever utilizando una dirección de Gmail precisamente proponiendome una oferta de colaboración para el blog con la intención de publicar hasta seis artículos al mes durante varios meses. Una oferta extraordinaria fuera de lo normal que suele ser exclusivamente de un artículo. El correo electrónico estaba redactado en inglés pero haciendo referencia al dominio de mi blog en el asunto del mensaje y diciendo que era un lector asiduo de mi blog.

El primer paso en estos contactos comerciales suele ser la negociación de las condiciones.

La negociación y la propuesta

Una oferta de seis artículos al mes y durante varios meses parece una oferta muy atractiva. Los primeros puntos a conocer es en qué consiste el acuerdo si en la inserción de enlaces, publicar un artículo ya redactado o que escriba yo un artículo original en función de lo cual se determina el precio ya que cada una me requiere menos o más tiempo.

Una vez conocida en qué consiste la colaboración está en la aceptación de las condiciones como que la temática de los artículos esté relacionado la programación, tecnología o software libre así como vetar algunas temáticas de artículos como apuestas, juegos de azar y otras temáticas controvertidas. Otras condiciones es que en el caso de los artículos deben ser únicos para evitar penalizaciones por contenido de publicar y ser detectado como un sitio de contenido no deseado. Comprar artículos y enlaces es una actividad que en caso de que Google la detecte la penaliza ya que es una forma de alternar y algoritmo de posicionamiento de una forma no permitida por Google.

Seis artículos patrocinados al mes son muchos artículos, casi más de los que escribo como contenido del blog. Para limitar el contenido patrocinado le propongo que solo acepto uno o dos artículos al mes.

Otro asunto importante de la colaboración es llegar a un acuerdo en el tema económico, poner un precio por publicar el artículo. Yo suelo ser claro y aunque puedo dejar ver que oferta me hacen suelo ir directo al tema para acabar negociar este punto sin mucha demora. Casi siempre empiezo con mi propuesta de oferta económica.

Hecha mi primera oferta económica al Gatito Biever este me responde con que esta le parece demasiado alta diciendo que su artículos son de calidad y la colaboración serán varios, no me indica en qué precio a él le parece bien el acuerdo económico sino que me deja en una pregunta abierta a que le haga otra oferta. Le hago una segunda oferta económica, que también rechaza y me propone su oferta económica que si fuera por un único artículo probablemente no aceptaría.

Como la colaboración iba a ser de varios artículos acepto su oferta con la condición de que los dos primeros fueran a un precio intermedio entre lo que ambos proponíamos, en los siguientes artículos al precio de lo que él proponía.

Las sospechas

Acordados los términos de la colaboración y el precio comienza la colaboración que en este caso es simplemente que el Gatico Biever me proporcione el contenido del artículo, yo lo publique lo cual no suelo tardar más de uno o dos días y procedamos al pago en los términos acordados.

Pasa casi una semana sin que sepa nada del Gatico Biever con lo que me pongo en contacto con él para ver qué hay del asunto. Me responde al cabo de unos días diciendo que está trabajando en ello y me pide que elimine la página el publicidad en la que detallo que mi blog ofrece la posibilidad de este tipo de colaboraciones, en el correo me incluye la dirección de la página que quiere que elimine con el texto el de la dirección de la página pero el enlace tiene una dirección de un dominio que desconozco, le hago un curl a esa URL y parece simplemente una redirección a la página de mi blog pero a través de un dominio extraño.

El motivo para solicitar la eliminación de esta página es para evitar penalizaciones por SEO ya que este tipo de colaboraciones no es algo aceptado por Google y seguramente lo penalice en casos extremos. La página de publicidad la tengo desde hace mucho tiempo y no he notado estar penalizado por Google.

Aquí es donde empiezo a sospechar ya que en sus correos utiliza el típico lenguaje de acción rápida como hazlo lo más pronto posible, respondeme hoy cuando él tarda en contestar varios días. Le insisto en que esa página de publicidad no es ningún problema y que me proporcione el contenido del artículo ya poniéndome un poco borde saludándose con un Hola Gatico y para finalizar su misma urgencia con un ASAP.

Él tarda nuevamente en responder un par de días. Me pongo de nuevo en contacto con él siendo nuevamente borde con que su actitud no es nada profesional. Si alguien me contesta en los mismos términos en los que yo lo hago inmediatamente termino con la colaboración, pero él no, no cae en la provocación me dice que él es un experto en SEO y que eliminar esa página es un requisito indispensable para su cliente.

Me doy cuenta que en realidad se poco de el Gatico Biever, me escribe en inglés y el dominio oculto del enlace de redirección parece de UK. Le pregunto que si es de UK y que tal van las cosas por UK con la situación que tienen del Brexit con un tono burlesco porque en un primer momento pienso que es alguien gastando una broma. Nuevamente si alguien se dirige a mi en los mismos términos que yo lo hago yo terminaría la colaboración. Pero él no, él responde con un «Sí, sí, lo has entendido bien» a lo de que él es de UK y que hablaremos más adelante cuando tenga un poco más de tiempo.

Otro correo me responde con un «Seguro querido», un ¿querido?, me dice que nos centremos en los negocios y que su cliente «Indulgente» está esperando a que elimine la página de publicidad.

Me doy cuenta de que en realidad se poco de el Gatico Biever, su «sí, sí» parece irónico y condescendiente y el «indulgente» parece muy… no se como definirlo ¿sacro? ¿de practicante, creyente, fiel religioso?, hacer colaboraciones profesionales con una cuenta que como nombre tiene Gatico Biever con una foto de catálogo que se encuentra y he encontrado fácilmente en una búsqueda por imágenes no parece profesional.

Llega la trampa, mi pequeña trampa.

La trampa

No estoy dispuesto a eliminar esa página de publicidad y ya estoy sospechando de que este sea un ataque informático aunque aún no se qué forma tendrá el ataque.

Me doy cuenta de que en realidad se poco del Gatico Biever, no es una cuenta profesional ni pone de que empresa de consultoría SEO pertenece, simplemente se identifica con un equipo SEO como organización en la despedida del mensaje.

Preparo un enlace a una página que tiene un enlace similar a la página de publicidad pero algo modificada que si uno no se fija en detalle pasa desapercibido que las páginas son diferentes. Si la página de publicidad es /publicidad le preparo una página /publiciidad que simula un error de página no encontrada como desea el Gatico Biever que haga.

Le envío en un nuevo correo electrónico el enlace de la página de publicidad trucado esperando que él haga clic en él. Esta es la misma técnica para realizar un ataque de phishing en vez de utilizando otro dominio añadiendo simplemente un caracter de una nueva URL parecida a la original, como el dominio y sus URLs lo controlo yo puedo hacerlo y lo hago.

¿Caerá en la trampa? Necesita hacer clic en el enlace que le he enviado yo, si entra directamente a la página para comprobar si he eliminado la página de publicidad no es de mucha utilidad.

Pues Gatico Biever cae en la trampa hace clic en enlace directamente desde el correo electrónico y como se que ese enlace solo lo tiene él sé que ha sido él, ahora analizo los datos que me proporciona Google Analytics para conocer algo más de el Gatico Biever.

La exploración

Los datos de Analytics me permiten ver unos datos básicos anónimos pero algo más de quien es el Gatico Biever como su país de origen, que navegador utiliza y que sistema operativo utiliza. Veo que su país de origen es Pakistan, su sistema operativo es Windows 10 y el navegador web que utiliza es Google Chrome actualizado a la última versión.

El país de origen me pone en alerta ya que es un país de oriente medio en una zona posiblemente en conflictos armados. Seguramente no tenga muchos visitantes de Pakistan asi que creo un segmento con los visitantes de este país y miro qué páginas ha visitado. No ha visitado muchas páginas pero veo que se ha parado alguna algo más de tiempo en la que hablaba de PayPal, la hemeroteca donde también hablaba de dinero y otra donde mencionaba la aplicación autenticador de Google. Otro dato que veo es que además de visitar la página preparada por mi ha visitado la página de publicidad original después de proporcionarle el enlace, asi que sé que sabe que en realidad no he eliminado la página de publicidad.

El primer correo ya me debería haber hecho sospechar, por el mismo nombre del remitente, parecer una plantilla, decir que me visita regularmente alguien que habla en inglés. Ahora con estos datos tengo aún más sospechas. Aún no sé de qué forma será el ataque ni qué interés tiene esta yincana de eliminar la página de publicidad en todo ello, igual es un filtro para discriminar a usuarios fáciles de los difíciles o de adoctrinar a la víctima para que haga lo que se le dice.

El Gatico Biever ignora que en realidad no he eliminado la página de publicidad y me envía el contenido del artículo. Analizó el contenido del artículo que está en buen español, no parece un artículo que esté obteniendo de internet ni esté ya publicado en otro sitio web. Me dice que lo publique cuanto antes porque tiene varios artículos más.

Le digo que mientras lo publico me conteste de qué forma me va a pagar con una pregunta abierta. Me contesta que me paga con PayPal pero no cuál será el procedimiento, así que le insisto con cual es el procedimiento que suele utilizar para hacer el pago. Me responde con un «querido» y me dice con un tono imperativo en lo que yo haré que su procedimiento es que yo le proporcione mi dirección de PayPal en la que hacerme el pago y que me envía un enlace para que compruebe que me ha hecho el pago.

Vale ahora tengo claro cual es su forma de ataque si es que es un ataque, un ataque de phishing sobre la página de PayPal. Pobre Gatico Biever que si este es su ataque no sabe que tengo activado el segundo factor de autenticación, no es infalible pero si no lo impide al menos limita el tiempo en el que es posible el ataque, concretamente tienen unos 30 segundos en caso de que sea víctima si su ataque de phishing soporta el segundo factor de autenticación que no creo.

Le pido más información con la excusa de que por razones legales le tengo que emitir una factura para pagar impuestos, con lo que le pido cierta información como nombre y apellidos, dirección y nombre de la compañía.

Parece que se ha cansado de esta pequeña yincana que le estoy haciendo y me propone sin yo haber publicado el artículo todavía hacerme el pago por adelantado con lo que me pide mi dirección de correo asociada a PayPal y nuevamente me repite que me proporcionará un enlace que podré usar para comprobar el pago.

Aquí ya tengo la intención de dejarlo pasar, podría ir más lejos para que me envíe el enlace de la página de phishing, podría inventarme cualquier dirección de correo electrónico como por ejemplo felipin.demaritxalar.yvorvon[at]gmail.com a ver si es capaz de hacer el pago y enviarme el enlace para que lo compruebe que sospecho es de phishing. ¿O será ese nombre demasiado evidente que se de cuenta? Posiblemente para alguien de Pakistan no sea tan evidente. Si le doy una dirección de PayPal, supongo que me insistirá en que me ha hecho el pago y que lo compruebe.

Como ve que ya no respondo me envía un nuevo correo al cabo de una semana con unos datos para atender a mi petición. Me dice que es de Reino Unido y me da como nombre real Ethan Biever. Busco por el nombre que me da y las primeras referencias son los nombres de dos personajes de un película.

Llegar hasta el punto de que me de el enlace de phishing tampoco tiene ninguna utilidad, no soy policía, muy posiblemente ni ellos podrían hacer algo aunque fuese víctima del ataque y aunque le denuncie ante Google es seguro que será capaz de crearse una nueva dirección de correo electrónico con la que seguir haciendo ataques.

El final, ¿tú que crees?

Bueno, la mayoría sois lectores, otras personas equivalentes a mi serán youtubers, podcasters o streamers pero todavía quedamos algunos bloggers de la vieja escuela, en cualquier caso este es solo un ejemplo, podría llegar en realidad a cualquiera persona ni siquiera estar englobada en ningún colectivo y podría ser de otra forma con alguna excusa que un delincuente tenga su correo electrónico y una forma de contactarte por el ordenador o con teléfono inteligente.

Los indicios que parecen indicar ser un ataque informático son el nombre de la cuenta, la forma de dirigirse a mí con un «querido», una oferta de colaboración muy atractiva respecto de lo que suele ser lo habitualmente, algunas respuestas que me da condescendientes, ignora mi mala educación y falta de respeto, ignora que no he hecho lo que me ha pedido de eliminar la página de publicidad, su país de origen, utilizar lenguaje imperativo, pedir inmediatez y se ofrece a hacerme el pago por adelantado sin yo haber publicado el artículo.

El perfil de la persona que me hago del tipo de Gatico Biever es el siguiente. Aceptan tus insultos y faltas de respeto mientras te están esperando a que cometas un error, tus insultos los soportan hasta que cometes el error, disfrutan de tu desorientación como cuando le pregunto si es de UK y me responde con un «si, si». Es como si buscarán duelos o peleas, pero no son duelos cara a cara son duelos de engaño, en los que dan la imagen de ir todo bien, pierde es el que cae en la trampa. Se burlan a su modo, de forma velada con lo de «Indulgente», igual que yo con lo de «froilin» o su propio nombre sacado de una película.

No se que criterio ha elegido para realizar un ataque, no sé si entenderá algo de español y habrá investigado algo sobre la víctima en este caso yo con lo que he publicado en en blog y mi cuenta de Twitter, posiblemente haya recopilado un conjunto de direcciones de correo electrónico públicas y enviado un mensaje a ver cuantos responden. Porque elegir como víctima de un ataque informático a un usuario que es informático y que usa GNU/Linux no parece la víctima ideal, es como intentar ir a robar la casa de un cerrajero. Qué lo puede intentar pero ambos sabemos mucho más de las técnicas que utilizan los delincuentes para cometer sus delitos y seguramente las medidas de seguridad que tenemos son mucho mejores. El cerrajero utilizando una puerta acorazada, una cerradura que evite las técnicas conocidas de apertura sin forzado, técnicas para detectar si una casa está habitada o un escudo en la cerradura que evite ciertas técnicas de forzado. Yo por mi parte como informático es posible que conozco y conozco el segundo factor de autenticación y tengo las nociones básicas de ataques informáticos.

Parece un ataque de phishing ¿tu que crees? Porque claro no voy a seguir hasta el final para comprobarlo. Al menos le he hecho perder un poco de tiempo, he marcado sus correos como no deseados o spam y le he denunciado en Gmail como ataque de phishing que no sé si servirá de algo o será suficiente para que Google tome alguna acción.

Fin.

Cómo denunciar el intento o ataque informático

Cómo comentaba en el artículo nociones básicas para detectar un ataque y evitarlo en caso de ser víctima de un ataque conviene denunciarlo. La unidad de delitos informáticos de los diferentes cuerpos de policía y un perito judicial informático seguro que os podría contar cientos de casos, pero seguramente el mejor consejo que den sea evitar ser víctima de un ataque informático. Ellos están para ayudar, proteger, minimizar daños, prevenir nuevos delitos, obtener pruebas y poner a disposición de la justicia a delincuentes pero muchas veces tras haber ocurrido los hechos el grave daño causado ya no es reparable. Y a veces les será muy difícil por estar los delincuentes en otros países. Muchos ataques informáticos como este ejemplo no son difíciles de detectar con las nociones básicas.

En los términos y condiciones del correo electrónico de Gmail no permite utilizarlo para realizar actividades ilegales incluyendo el phishing y ofrecen herramientas para denunciarlo, desde el propio Gmail y desde páginas específicas. Para denunciar una cuenta de correo que esté siendo utilizada para realizar actividades ilegales es posible tomar dos medidas, una marcar el correo como spam que Gmail tiene en cuenta, si son varios usuarios lo que lo hacen los correos del remitente a los usuarios les llegará a la carpeta de spam en vez de a la bandeja de entrada. La segunda opción es denunciar un mensaje como suplantación de identidad, aunque en realidad el Gatico Biever no me ha enviado el enlace de phishing.

En caso de recibir el enlace es posible además denunciar la página de phishing para que esta sea incluida en la lista negra de páginas identificadas maliciosas. Supongo una persona que trabaje para Google analizará estas peticiones y en caso de corroborarlo la página será añadida a la lista negra. Esta lista negra es utilizada por los navegadores para mostrar un mensaje de advertencia cuando un usuario intente entrar en ella, poniendo sobre aviso al usuario y aconsejando no entrar.

Minimizar daños de posibles ataques informáticos

Nadie está exento de ataques, ni alguien como yo que tiene conocimientos en informática y conozco las nociones básicas de los ataques, que inicialmente me resultó extraño el correo pero que hasta bastante avanzada la conversación con unos cuantos correos electrónicos enviados no empecé a realmente sospechar.

Por ello conviene tomar una serie de medidas como establecer límites transferencias y tarjeta de crédito más bajos que los que establecen por defecto los bancos que suelen ser muy generosos, activar el segundo factor de autenticación para que aunque roben las credenciales de una cuenta evitar el ataque o permitirlo únicamente durante un breve periodo de tiempo si la página de phishing fuera tan avanzada como para estar preparada para obtener también el segundo factor de autenticación.

En una de estas situaciones de ataque informático conviene que el atacante sepa lo menos posible de uno, por ello conviene proteger tu privacidad y minimizar la información tuya se puede encontrar con una búsqueda en internet.

No hay otra opción de que quede impune, si es un delincuente y parece serlo por los varios indicios va a continuar haciendo su actividad y algún usuario más incauto sea su víctima, está claro que si realizan esta actividad es porque obtienen algún beneficio. La conclusión en cualquier caso es, se bueno pero ten un poco de joputismo para conocer a los malos, hay una buena cantidad de joputas malos por ahí.

» Leer más, comentarios, etc...

Blog Bitix

Ejemplo de un potencial ataque de phishing, El caso de El Gatico Biever