Supongamos que alguien se apodera de su clave de API. De repente, tienen acceso a todo dentro de sus microservicios internos - roaming gratuito, sin preguntas planteadas. Hasta el momento en que incluso se da cuenta de que algo está mal, ya han desechado los datos, ejercido cada permiso que nunca pretendía conceder, y le han dejado con una factura pesada y una tarea aún más pesada: reconstruir la confianza del cliente. En gran parte, es porque la mayoría de los microservicios suponen que pueden confiar unos en otros simplemente porque se sienten en la misma red. No porque sea una seguridad real, sino porque tratamos la proximidad como protección. In simple terms: 
 
 Una llave de confianza se convierte en el pasaporte del ladrón. Una llave de confianza se convierte en el pasaporte del ladrón. En el pasado, con una sola aplicación y un único almacenamiento de datos, así como un único perímetro de red, la seguridad era mucho más simple, ya que todo se ejecutaba en el lugar con un centro de datos local. Ahora tienes muchas (decenas) de aplicaciones/servicios, cientos de APIs, y muchos equipos diferentes están liberando código cada día. Además, la mayoría de los servicios comunicarán con otros servicios y asumirán que ya que están comunicando a través de una red común, deberían poder confiar en cada servicio. Su diseño arquitectónico ha crecido y evolucionado; sin embargo, su pensamiento de "seguridad" no lo ha hecho.Su casa ahora parece que está abierta.Cualquiera que pueda obtener una llave para la puerta delantera puede entrar en cada habitación, abrir cada armario y desbloquear cada armario seguro en el edificio. The Philosophy That Changed The Way Of Thinking About Architecture: Zero Trust La filosofía que cambió la forma de pensar sobre la arquitectura: confianza cero La confianza cero es un cambio en la forma en que piensas sobre la confianza, no una mejora en las tendencias de seguridad. Este principio se puede resumir simplemente como: “Nunca confíes; siempre verificas”. Todas las conexiones (usuario, servicio y red interna) deben identificarse, indicar qué pueden hacer y decir si la conexión es segura. Básicamente, se veía así para los microservicios Mutual TLS todo el camino: Toda la comunicación de una conexión de servicio es confirmada por el uso de TLS mutual (mTLS) antes de que cualquiera de las partes pueda comunicarse entre sí. Los permisos basados en API están reemplazando los permisos basados en firewall. Cada llamada/transacción está siendo verificada. Hemos tenido que repensar cómo construimos y cómo confiamos en cualquier cosa dentro de nuestra arquitectura para cumplir con los principios de Zero Trust, pero al hacerlo, hemos terminado con un sistema mucho más seguro. 
 
 Nuestros sistemas son ahora mucho más seguros gracias a Zero Trust, y ha cambiado la forma en que diseñamos, comunicamos y confiamos en otros servicios en nuestra arquitectura, ya sea interna o externa. Nuestros sistemas son ahora mucho más seguros gracias a Zero Trust, y ha cambiado la forma en que diseñamos, comunicamos y confiamos en otros servicios en nuestra arquitectura, ya sea interna o externa. Zero Trust: Not Optional — Not Anymore Confianza cero: no es opcional - ya no ¿Estás ejecutando microservicios sin Zero Trust? Si esperas demasiado tiempo, tu negocio no solo caerá atrás – puede golpear un muro. Ahora es el momento de comenzar, mucho antes de que tus sistemas estén estancados. Nuestro propio despliegue no fue infalible. Hemos tratado con interrupciones, empujado a través de la resistencia de los desarrolladores, y aprendimos algunas lecciones difíciles a lo largo del camino. Pero después de seis meses, lo enviamos – y demostramos que la seguridad no es algo en lo que te tocas. Es algo para lo que diseñas, deliberadamente, desde el primer día. Solution/Tools Aquí están algunas de las tecnologías que usamos para pasar nuestro modelo de confianza, que se basa en las redes, a un modelo de confianza basado en la identidad: 
 
 
 
 
 
 
 Identidad de servicio: SPIFFE/SPIRE Comunicaciones encriptadas de servicio a servicio: Istio mTLS Código de políticas: Agente de políticas abiertas (openpolicyagent.org) Gestión activa de secretos, Gestión dinámica de secretos: HashiCorp Vault Análisis de amenazas dinámicas: Falco. Rate-Limiting, Logging de auditoría, OAuth2: Kong API Gateway Optimization 
 
 
 
 Las decisiones tomadas por la OPA se almacenan en caché (Redis/Caffeine). Conexión para mTLS Los registros de auditoría de Kafka se reescriben de forma asíncrona. A continuación, describiré la implementación de un modelo de confianza cero para mis aplicaciones de microservicio basados en Java, incluyendo cómo se verifican las identidades, se utiliza mTLS y se rotan los secretos dentro de la aplicación, así como proporcionar ejemplos del mundo real de código y configuraciones utilizadas. JWT utiliza el servicio de identidad Cada servicio adquiere su identidad.Generamos y firmamos un JWT utilizando las claves RSA-256 package com.zero.trust.common;
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import java.security.*;
import java.security.interfaces.*;
import java.util.*;
public class IdentityServiceManager {

    private final String serviceName;
    private final Algorithm algorithm;

    public IdentityServiceManager(String serviceName) {
        this.serviceName = serviceName;
        try {
            KeyPairGenerator gen = KeyPairGenerator.getInstance("RSA");
            gen.initialize(2048);
            KeyPair pair = gen.generateKeyPair();
            this.algorithm = Algorithm.RSA256(
                    (RSAPublicKey) pair.getPublic(),
                    (RSAPrivateKey) pair.getPrivate());
        } catch (Exception e) {
            throw new RuntimeException("KeyPair creation failed", e);
        }
    }

    public String generateTokenData() {
        return JWT.create()
                .withIssuer(serviceName)
                .withClaim("service", serviceName)
                .withExpiresAt(new Date(System.currentTimeMillis() + 3600_000))
                .sign(algorithm);
    }

    public boolean verifyTokenData(String token) {
        try { JWT.require(algorithm).build().verify(token); return true; }
        catch (Exception e) { return false; }
    }
}
 Servicio Auth utilizando SpringSecuirty Filter Cada solicitud se valida para comprobar si el token es válido o no. No hay token / token inválido: es 401. package com.zero.trust.demo.config;
 import org.springframework.web.filter.OncePerRequestFilter;
 import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.*;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
 //few importing missing refer git hub as i am getting error to copy the all imports 
 
@Configuration
public class ZeroTrustSecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.csrf(AbstractHttpConfigurer::disable)
                .authorizeHttpRequests(req -> req
                        .requestMatchers("/health").permitAll()
                        .anyRequest().authenticated())
                .addFilterBefore((Filter) new TokenFilter(), UsernamePasswordAuthenticationFilter.class);
        return http.build();
    }

    static class TokenFilter extends OncePerRequestFilter {
        @Override
        protected void doFilterInternal(HttpServletRequest req,
                                        HttpServletResponse res,
                                        FilterChain chain)
                throws ServletException, IOException {

            String auth = req.getHeader("Authorization");
            if (auth == null || !auth.startsWith("Bearer ")) {
                res.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Missing token");
                return;
            }
            String jwt = auth.substring(7);
            IdentityServiceManager manager = new IdentityServiceManager("user-service");
            if (!manager.verifyTokenData(jwt)) {
                res.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Invalid token");
                return;
            }
            Authentication a = new UsernamePasswordAuthenticationToken("service", null, List.of());
            SecurityContextHolder.getContext().setAuthentication(a);
            chain.doFilter(req, res);
        }
    }
}
 Desarrollo dinámico con Vault Simulator En el mundo real, usaremos HashiCorp Vault, pero localmente, simulamos la rotación de las credenciales de DB en memoria cada minuto. package com.zero.trust.valut;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.UUID;

@Component
public class VaultServ {
    private String username = "dbuser";
    private String password = UUID.randomUUID().toString();

    @Scheduled(fixedRate = 60000)
    public void rotate() {
        password = UUID.randomUUID().toString();
        System.out.println("[VaultSim] Rotated password -> " + password);
    }

    public String getUsername() { return username; }
    public String getPassword() { return password; }
}
 Código Gateway El Gateway genera un JWT con su propia identidad y se conecta al Servicio de Usuario a través de TLS mutuo.El Servicio de Usuario luego autentica tanto el token como el certificado, asegurándose de que sólo los servicios confiables y verificados pueden comunicarse. package com.damu;

import com.zero.trust.common.IdentityServiceManager;
import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;
import org.springframework.http.*;

@SpringBootApplication
@RestController
public class Main {

    public static void main(String[] args) {
        SpringApplication.run(Main.class, args);
    }

    @Bean
    public RestTemplate restTemplate() { return new RestTemplate(); }

    private final IdentityServiceManager identity = new IdentityServiceManager("gateway-service");
    private final RestTemplate rest = new RestTemplate();

    @GetMapping("/gatewaytest")
    public String test() {
        String token = identity.generateTokenData();
        HttpHeaders h = new HttpHeaders();
        h.set("Authorization","Bearer "+token);
        HttpEntity<Void> entity = new HttpEntity<>(h);
        ResponseEntity<String> res = rest.exchange(
                "https://localhost:8443/api/users/1",
                HttpMethod.GET, entity, String.class);
        return "Gateway → " + res.getBody();
    }
}
 Compruebe nuestro para un flujo más completo. GitHub 
 
 Zero-Trust no es una tendencia actual, sino más bien una actitud.Esta demostración de extremo a extremo te mostrará cómo implementar esto con Java pura y Spring Boot. Esta demostración de extremo a extremo te mostrará cómo implementar esto con Java pura y inicio de primavera. Zero-Trust no es una tendencia actual, sino más bien una actitud.Esta demostración de extremo a extremo te mostrará cómo implementar esto con Java pura y Spring Boot. Esta demostración de extremo a extremo te mostrará cómo implementar esto con Java pura y inicio de primavera.

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Read My Stories

Este audio es producido en el idioma original de la historia!

Seguridad de los microservicios Java con la arquitectura de confianza cero

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

Nómadas digitales escuchen: lo que necesitan saber sobre la nueva visa DTV de Tailandia

Toque para ganar: Telegram puede incorporar a los próximos 10 mil millones de usuarios de criptomonedas antes de Solana

Creación de productos criptográficos centrados en el usuario: la importancia de los comentarios de los clientes

Telegram: el puente de Crypto Island hacia el continente

Nómadas digitales escuchen: lo que necesitan saber sobre la nueva visa DTV de Tailandia

Toque para ganar: Telegram puede incorporar a los próximos 10 mil millones de usuarios de criptomonedas antes de Solana

Creación de productos criptográficos centrados en el usuario: la importancia de los comentarios de los clientes

Telegram: el puente de Crypto Island hacia el continente

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps