Какие знаешь способы обеспечить безопасное взаимодействие между двумя приложениями?

Способы обеспечить безопасное взаимодействие между двумя приложениями

Безопасное взаимодействие между приложениями критично для защиты данных, предотвращения несанкционированного доступа и обеспечения целостности информации. Есть несколько проверенных подходов.

1. HTTPS / TLS (Transport Layer Security)

Это фундамент безопасного общения. Все данные шифруются при передаче.

// Spring Boot приложение с HTTPS
// application.properties
server.port=8443
server.ssl.key-store=classpath:keystore.p12
server.ssl.key-store-password=mypassword
server.ssl.key-store-type=PKCS12
server.ssl.key-alias=tomcat

// REST клиент с HTTPS
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;

RestTemplate restTemplate = new RestTemplate();
httpClient = HttpClients.custom()
    .setSSLContext(createSSLContext())
    .build();

private SSLContext createSSLContext() throws Exception {
    SSLContext sslContext = SSLContext.getInstance("TLS");
    // Загрузить trusted certificates
    sslContext.init(null, getTrustManagers(), new SecureRandom());
    return sslContext;
}

Гарантии:

• ✅ Шифрование данных в пути
• ✅ Аутентификация сервера (SSL сертификат)
• ✅ Защита от MITM (Man-in-the-Middle) атак
• ❌ Не защищает от несанкционированного доступа к API

2. API Key / Token Authentication

Сервер выпускает уникальный ключ или токен, который клиент отправляет с каждым запросом.

Simple API Key:

// Server: провалидировать API key
@RestController
@RequestMapping("/api")
public class SecureController {
    
    @PostMapping("/data")
    public ResponseEntity<?> getData(
            @RequestHeader("X-API-Key") String apiKey) {
        
        if (!isValidApiKey(apiKey)) {
            return ResponseEntity.status(401).body("Invalid API Key");
        }
        
        return ResponseEntity.ok("Secret data");
    }
    
    private boolean isValidApiKey(String apiKey) {
        return apiKeyStore.containsKey(apiKey) && 
               apiKeyStore.get(apiKey).isActive();
    }
}

// Client: отправить API key
RestTemplate restTemplate = new RestTemplate();
HttpHeaders headers = new HttpHeaders();
headers.set("X-API-Key", "abc123def456");

HttpEntity<?> entity = new HttpEntity<>(headers);
ResponseEntity<String> response = restTemplate.exchange(
    "https://api.example.com/data", 
    HttpMethod.POST, 
    entity, 
    String.class
);

Проблемы:

• ❌ API Key может быть украдена
• ❌ Нет истечения срока (обычно)
• ❌ Нет контроля над правами доступа

3. OAuth 2.0 / OpenID Connect

Стандартный протокол для делегированной авторизации. Один сервер (auth server) выпускает токены, другие приложения их проверяют.

// Authorization Server (выпускает токены)
@Configuration
@EnableAuthorizationServer
public class AuthServerConfig extends AuthorizationServerConfigurerAdapter {
    
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients
            .inMemory()
            .withClient("app-client")
            .secret("app-secret")
            .authorizedGrantTypes("client_credentials")
            .scopes("read", "write");
    }
}

// Resource Server (проверяет токены)
@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
    
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/api/**").authenticated()
            .and()
            .oauth2ResourceServer()
            .jwt();
    }
}

// Client Application
@Service
public class OAuth2ClientService {
    
    @Autowired
    private OAuth2RestTemplate restTemplate;
    
    public String getSecureData() {
        return restTemplate.getForObject(
            "https://resource-server.com/api/data", 
            String.class
        );
    }
}

Преимущества:

• ✅ Стандартный протокол
• ✅ Разделение ответственности (auth server отдельно)
• ✅ Refresh tokens, истечение срока
• ✅ Scopes (права доступа)
• ✅ Работает с микросервисной архитектурой

4. JWT (JSON Web Tokens)

Селфконтейнирующиеся токены с подписью. Сервер подписывает, другие приложения проверяют подпись.

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.security.Keys;

// Server: создать JWT
public String generateJWT(String userId) {
    Key key = Keys.hmacShaKeyFor(
        "this-is-a-very-long-secret-key-for-signing".getBytes()
    );
    
    String token = Jwts.builder()
        .setSubject(userId)
        .claim("role", "admin")
        .claim("app", "my-app")
        .setIssuedAt(new Date())
        .setExpiration(new Date(System.currentTimeMillis() + 3600000)) // 1 hour
        .signWith(key, SignatureAlgorithm.HS256)
        .compact();
    
    return token;
}

// Client: отправить JWT
restTemplate.getInterceptors().add((request, body, execution) -> {
    request.getHeaders().set("Authorization", "Bearer " + jwtToken);
    return execution.execute(request, body);
});

// Server 2: валидировать JWT
@Component
public class JwtValidator {
    
    public Claims validateToken(String token) {
        Key key = Keys.hmacShaKeyFor(
            "this-is-a-very-long-secret-key-for-signing".getBytes()
        );
        
        return Jwts.parserBuilder()
            .setSigningKey(key)
            .build()
            .parseClaimsJws(token)
            .getBody();
    }
}

// Spring Security filter
@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    
    @Autowired
    private JwtValidator jwtValidator;
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                    HttpServletResponse response, 
                                    FilterChain filterChain) 
            throws ServletException, IOException {
        
        String token = extractToken(request);
        
        try {
            Claims claims = jwtValidator.validateToken(token);
            UsernamePasswordAuthenticationToken auth = 
                new UsernamePasswordAuthenticationToken(
                    claims.getSubject(), null, getAuthorities(claims)
                );
            SecurityContextHolder.getContext().setAuthentication(auth);
        } catch (Exception e) {
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
            return;
        }
        
        filterChain.doFilter(request, response);
    }
}

Преимущества:

• ✅ Нет необходимости в shared database для хранения токенов
• ✅ Масштабируемый (stateless)
• ✅ Работает с микросервисами
• ⚠️ Токен невозможно отозвать (до истечения срока)

5. Mutual TLS (mTLS)

Оба приложения имеют SSL сертификаты и проверяют друг друга. Максимальная безопасность.

// Server с mTLS
server.ssl.key-store=classpath:server-keystore.p12
server.ssl.key-store-password=serverpass
server.ssl.client-auth=need  // Требовать сертификат клиента
server.ssl.trust-store=classpath:server-truststore.p12
server.ssl.trust-store-password=trustpass

// Client с mTLS
private RestTemplate createMTLSRestTemplate() throws Exception {
    SSLContext sslContext = SSLContext.getInstance("TLS");
    
    // Загрузить клиентский сертификат
    KeyStore keyStore = KeyStore.getInstance("PKCS12");
    keyStore.load(
        new FileInputStream("client-keystore.p12"),
        "clientpass".toCharArray()
    );
    
    // Загрузить trusted сертификаты сервера
    KeyStore trustStore = KeyStore.getInstance("PKCS12");
    trustStore.load(
        new FileInputStream("client-truststore.p12"),
        "trustpass".toCharArray()
    );
    
    KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
    kmf.init(keyStore, "clientpass".toCharArray());
    
    TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
    tmf.init(trustStore);
    
    sslContext.init(
        kmf.getKeyManagers(),
        tmf.getTrustManagers(),
        new SecureRandom()
    );
    
    HttpClient httpClient = HttpClients.custom()
        .setSSLContext(sslContext)
        .build();
    
    return new RestTemplate(new HttpComponentsClientHttpRequestFactory(httpClient));
}

Гарантии:

• ✅ Взаимная аутентификация (оба знают друг о друге)
• ✅ Шифрование в пути
• ✅ Защита от подделки сертификатов
• ❌ Сложнее управлять (нужны сертификаты для каждого приложения)
• ❌ Требует инфраструктуры PKI

6. HMAC (Hash-based Message Authentication Code)

Оба приложения имеют общий секрет. Клиент подписывает запрос, сервер проверяет подпись.

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

// Client: создать HMAC подпись
public String generateHMAC(String data, String secret) throws Exception {
    Mac mac = Mac.getInstance("HmacSHA256");
    SecretKeySpec secretKey = new SecretKeySpec(
        secret.getBytes(),
        0,
        secret.getBytes().length,
        "HmacSHA256"
    );
    mac.init(secretKey);
    byte[] signature = mac.doFinal(data.getBytes());
    return Base64.getEncoder().encodeToString(signature);
}

// Client: отправить с подписью
RestTemplate restTemplate = new RestTemplate();
String payload = "userId=123&action=transfer";
String signature = generateHMAC(payload, "shared-secret");

HttpHeaders headers = new HttpHeaders();
headers.set("X-Signature", signature);
headers.set("X-Timestamp", String.valueOf(System.currentTimeMillis()));

HttpEntity<String> entity = new HttpEntity<>(payload, headers);
restTemplate.postForObject("https://api.example.com/action", entity, String.class);

// Server: проверить подпись
@PostMapping("/action")
public ResponseEntity<?> handleAction(
        @RequestBody String payload,
        @RequestHeader("X-Signature") String signature,
        @RequestHeader("X-Timestamp") String timestamp) {
    
    // Проверить timestamp (защита от replay атак)
    if (System.currentTimeMillis() - Long.parseLong(timestamp) > 300000) {
        return ResponseEntity.status(401).body("Request too old");
    }
    
    // Проверить подпись
    String expectedSignature = generateHMAC(payload, "shared-secret");
    if (!expectedSignature.equals(signature)) {
        return ResponseEntity.status(401).body("Invalid signature");
    }
    
    // Обработать запрос
    return ResponseEntity.ok("OK");
}

Применение:

• Webhook'и от третьих сервисов (GitHub, Stripe)
• Микросервисное взаимодействие
• API интеграции

Сравнение методов

Чеклист безопасности

✅ Всегда использовать HTTPS/TLS ✅ Валидировать SSL сертификаты ✅ Использовать токены вместо пароля ✅ Устанавливать время жизни токена ✅ Использовать strong secrets (>256 bits) ✅ Логировать и мониторить подозрительную активность ✅ Регулярно ротировать ключи ❌ Не хранить секреты в коде ❌ Не отправлять пароли в headers ❌ Не игнорировать SSL ошибки

Выбор метода зависит от архитектуры и требований безопасности вашей системы.