Main.java

/*
 * Клиент DNS Lookup API Atlorium — DNS-записи домена и аудит защиты от спуфинга.
 *
 * Запуск (работает сразу, без регистрации — на демо-ключе).
 * Начиная с Java 11 файл запускается напрямую, без компиляции и без зависимостей:
 *
 *     java Main.java
 *     java Main.java example.com
 *
 * Боевой ключ: получить на https://atlorium.com и положить в переменную окружения
 * ATLORIUM_API_KEY. Код при этом не меняется.
 */

import java.io.IOException;
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

    /**
     * Публичный демо-ключ. С ним API отвечает правдоподобными МОКАМИ (не реальными
     * записями DNS) — чтобы можно было встроить и протестировать интеграцию до оплаты.
     * Ответы детерминированы: один и тот же домен всегда даёт один и тот же результат,
     * поэтому на них можно писать стабильные тесты.
     */
    static final String SANDBOX_KEY = "ak_sandbox_demo_mockdata_v1";

    static final String API_KEY = envOr("ATLORIUM_API_KEY", SANDBOX_KEY);
    static final String BASE_URL = envOr("ATLORIUM_BASE_URL", "https://atlorium.com");

    /** 429 — не поломка, а штатный лимит. Ждём и повторяем. */
    static final int RETRY_DELAY_SEC = 20;
    static final int MAX_RETRIES = 2;

    /**
     * Потолок ожидания. Исчерпав ЧАСОВОЙ лимит, сервер честно просит подождать 40+ минут —
     * и клиент, слепо доверяющий заголовку Retry-After, зависнет на все 40 минут (а в CI
     * просто съест бюджет джоба). Дольше потолка не ждём.
     */
    static final int MAX_RETRY_DELAY_SEC = 120;

    static final HttpClient CLIENT = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();

    static String envOr(String key, String fallback) {
        String value = System.getenv(key);
        return (value == null || value.isBlank()) ? fallback : value;
    }

    /** Ошибка API: HTTP-код разложен в человекочитаемую причину. */
    static class AtloriumException extends RuntimeException {
        private static final Map<Integer, String> REASONS = Map.of(
                400, "Домен не передан или задан неверно (нужно чистое имя, без https:// и без IP)",
                401, "API-ключ отсутствует, просрочен или недействителен",
                402, "Недостаточно кредитов на балансе — пополните на https://atlorium.com",
                429, "Превышен лимит запросов — повторите позже",
                500, "DNS-резолвер не ответил или превышен таймаут запроса",
                503, "Сервис временно недоступен (за сбой на своей стороне мы не списываем деньги)");

        final int status;

        AtloriumException(int status, String body) {
            super("HTTP " + status + ": "
                    + REASONS.getOrDefault(status, "Неизвестная ошибка")
                    + ". Ответ сервера: " + body.substring(0, Math.min(200, body.length())));
            this.status = status;
        }
    }

    /**
     * Сколько ждать после 429. Ноль/мусор и слишком большие значения не берём на веру:
     * 0 означал бы busy-loop, 40 минут — зависший клиент. Возвращаем 0, если ждать
     * бессмысленно долго: вызывающий сдастся.
     */
    static int retryAfter(HttpResponse<String> response) {
        int seconds = response.headers().firstValue("Retry-After")
                .map(value -> {
                    try {
                        return Integer.parseInt(value.trim());
                    } catch (NumberFormatException ignored) {
                        return 0;
                    }
                })
                .orElse(0);

        if (seconds <= 0) {
            return RETRY_DELAY_SEC;
        }
        return seconds <= MAX_RETRY_DELAY_SEC ? seconds : 0;
    }

    static String get(String path, String query) throws IOException, InterruptedException {
        String url = BASE_URL + path + (query.isEmpty() ? "" : "?" + query);

        for (int attempt = 0; attempt <= MAX_RETRIES; attempt++) {
            HttpRequest request = HttpRequest.newBuilder(URI.create(url))
                    .header("Authorization", "Bearer " + API_KEY)
                    .header("Accept", "application/json")
                    .timeout(Duration.ofSeconds(30))
                    .GET()
                    .build();

            HttpResponse<String> response = CLIENT.send(request,
                    HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));

            if (response.statusCode() == 429 && attempt < MAX_RETRIES) {
                int delay = retryAfter(response);
                if (delay == 0) {
                    throw new AtloriumException(429, "лимит запросов по IP исчерпан, повторите позже");
                }
                System.err.println("  ... лимит запросов, пауза " + delay + " с");
                Thread.sleep(delay * 1000L);
                continue;
            }

            if (response.statusCode() != 200) {
                throw new AtloriumException(response.statusCode(), response.body());
            }
            return response.body();
        }

        throw new AtloriumException(429, "лимит запросов не отпустил после повторов");
    }

    /**
     * DNS-записи домена: A, AAAA, MX, TXT, CNAME, NS — одним запросом.
     * resolver — IP-адрес резолвера (по умолчанию Cloudflare 1.1.1.1), можно передать null.
     */
    static String lookup(String domain, String resolver) throws IOException, InterruptedException {
        String query = "domain=" + URLEncoder.encode(domain, StandardCharsets.UTF_8);
        if (resolver != null && !resolver.isBlank()) {
            query += "&resolver=" + URLEncoder.encode(resolver, StandardCharsets.UTF_8);
        }
        return get("/api/dns/lookup", query);
    }

    /**
     * Распространение записей по резолверам: одинаково ли они видят домен.
     * Нужно после смены DNS.
     *
     * resolvers — до 8 публичных IP через запятую; повторы схлопываются. Битый или
     * внутренний адрес, как и список длиннее восьми, дают 400, а не молчаливое усечение.
     *
     * Тарифицируется ПОРЕЗОЛВЕРНО: N резолверов = N единиц (по умолчанию их 4).
     * Поэтому в примере функция не вызывается — чтобы прогон не расходовал лишнего.
     */
    static String checkPropagation(String domain, String resolvers) throws IOException, InterruptedException {
        String query = "domain=" + URLEncoder.encode(domain, StandardCharsets.UTF_8);
        if (resolvers != null && !resolvers.isBlank()) {
            query += "&resolvers=" + URLEncoder.encode(resolvers, StandardCharsets.UTF_8);
        }
        return get("/api/dns/propagation", query);
    }

    // ── Разбор JSON ──────────────────────────────────────────────────────────
    // Пример намеренно оставлен без внешних зависимостей, чтобы запускаться одной
    // командой `java Main.java`. В рабочем проекте берите Jackson или Gson и
    // маппьте ответ в полноценную запись — эти регулярки существуют только ради
    // отсутствия pom.xml.
    //
    // Ответ устроен так: records — массив групп {"type":"A","records":[{...},{...}]}.
    // Внутри группы объекты плоские (строки, числа, null), вложенных скобок нет, —
    // поэтому нежадный поиск до первой «]» корректно вырезает группу целиком.

    static final Pattern GROUP = Pattern.compile(
            "\\{\\s*\"type\"\\s*:\\s*\"([^\"]+)\"\\s*,\\s*\"records\"\\s*:\\s*\\[(.*?)]", Pattern.DOTALL);
    static final Pattern ENTRY = Pattern.compile("\\{(.*?)}", Pattern.DOTALL);

    /** Одна DNS-запись. preference заполнен только у MX, ttl — почти всегда. */
    record Record(String type, String value, Integer ttl, Integer preference) {}

    static List<Record> parseRecords(String json) {
        List<Record> records = new ArrayList<>();
        Matcher groups = GROUP.matcher(json);

        while (groups.find()) {
            String type = groups.group(1);
            Matcher entries = ENTRY.matcher(groups.group(2));
            while (entries.find()) {
                String entry = entries.group(1);
                records.add(new Record(type, str(entry, "value"), number(entry, "ttl"), number(entry, "preference")));
            }
        }
        return records;
    }

    static String str(String json, String field) {
        Matcher matcher = Pattern.compile("\"" + field + "\"\\s*:\\s*\"((?:[^\"\\\\]|\\\\.)*)\"").matcher(json);
        return matcher.find() ? matcher.group(1).replace("\\\"", "\"") : null;
    }

    static Integer number(String json, String field) {
        Matcher matcher = Pattern.compile("\"" + field + "\"\\s*:\\s*(-?\\d+)").matcher(json);
        return matcher.find() ? Integer.valueOf(matcher.group(1)) : null;
    }

    static List<Record> ofType(List<Record> records, String type) {
        return records.stream().filter(record -> type.equals(record.type())).toList();
    }

    // ── Применение данных: аудит защиты домена от подделки писем ──────────────
    // Список DNS-записей сам по себе — просто JSON. Ценность появляется, когда из него
    // делают вывод. Ниже — проверка, может ли посторонний слать письма ОТ ИМЕНИ домена.
    //
    // Три кирпича защиты:
    //   MX    — принимает ли домен входящую почту вообще;
    //   SPF   — TXT-запись «v=spf1 ...»: кому разрешено слать от имени домена;
    //   DMARC — TXT-запись на ПОДДОМЕНЕ _dmarc.<домен>: что делать с письмом, которое
    //           проверку не прошло. Это отдельный второй запрос к API.
    //
    // Ровно два запроса за прогон: домен и _dmarc.домен.

    static final String STRICT = "-all";      // hard fail: чужому письму отказать
    static final String SOFT = "~all";        // softfail: пометить, но доставить
    static final String NEUTRAL = "?all";     // neutral: политики фактически нет
    static final String PERMISSIVE = "+all";  // разрешено всем — дыра

    /** level: "!" — критично, "~" — слабое место, "i" — к сведению. */
    record Issue(String level, String text) {}

    record MailSecurity(
            String domain,
            List<Record> root,   // записи домена — печатаем их без третьего запроса
            String resolver,
            List<String> mx,
            String spf,
            String spfPolicy,
            String dmarc,
            String dmarcPolicy,
            String verdict,
            List<Issue> issues) {}

    /** Механизм «all» в конце SPF — это и есть политика. Без него по умолчанию neutral. */
    static String parseSpfPolicy(String spf) {
        for (String policy : List.of(STRICT, SOFT, NEUTRAL, PERMISSIVE)) {
            if (spf.contains(policy)) {
                return policy;
            }
        }
        // Голое «all» без квалификатора равносильно +all.
        return spf.matches(".*\\ball\\b.*") ? PERMISSIVE : null;
    }

    /** Тег p= в DMARC: none (мониторинг) / quarantine (в спам) / reject (отбросить). */
    static String parseDmarcPolicy(String dmarc) {
        for (String tag : dmarc.split(";")) {
            String[] parts = tag.trim().split("=", 2);
            if (parts.length == 2 && "p".equalsIgnoreCase(parts[0].trim())) {
                return parts[1].trim().toLowerCase(Locale.ROOT);
            }
        }
        return null;
    }

    /** Аудит защиты домена от спуфинга. Ровно 2 запроса к API. */
    static MailSecurity auditMailSecurity(String domain) throws IOException, InterruptedException {
        // Запрос 1 — записи самого домена: MX и TXT (в TXT живёт SPF).
        String rootJson = lookup(domain, null);
        List<Record> root = parseRecords(rootJson);
        String resolver = str(rootJson, "resolver");

        List<String> mx = new ArrayList<>();
        for (Record record : ofType(root, "MX")) {
            mx.add(record.preference() != null
                    ? record.value() + " (приоритет " + record.preference() + ")"
                    : record.value());
        }

        String spf = ofType(root, "TXT").stream()
                .map(Record::value)
                .filter(value -> value.toLowerCase(Locale.ROOT).startsWith("v=spf1"))
                .findFirst()
                .orElse(null);

        // Запрос 2 — DMARC лежит НЕ на домене, а на поддомене _dmarc.<домен>.
        // Это отдельная зона, поэтому и запрос отдельный.
        List<Record> dmarcZone = parseRecords(lookup("_dmarc." + domain, null));
        String dmarc = ofType(dmarcZone, "TXT").stream()
                .map(Record::value)
                .filter(value -> value.toLowerCase(Locale.ROOT).startsWith("v=dmarc1"))
                .findFirst()
                .orElse(null);

        List<Issue> issues = new ArrayList<>();

        // ── MX: принимает ли домен почту ──────────────────────────────────────
        if (mx.isEmpty()) {
            issues.add(new Issue("i",
                    "MX-записей нет — домен не принимает входящую почту. От спуфинга это не защищает: "
                            + "слать письма ОТ его имени всё равно можно, и SPF/DMARC нужны."));
        }

        // ── SPF: кому разрешено слать от имени домена ─────────────────────────
        int spfScore;
        String spfPolicy = null;

        if (spf == null) {
            spfScore = 0;
            issues.add(new Issue("!",
                    "SPF не найден: письма от имени домена может слать кто угодно — "
                            + "принимающий сервер не с чем сверить отправителя"));
        } else {
            spfPolicy = parseSpfPolicy(spf);
            if (STRICT.equals(spfPolicy)) {
                spfScore = 3;
            } else if (SOFT.equals(spfPolicy)) {
                spfScore = 2;
                issues.add(new Issue("~",
                        "SPF ~all (softfail): подделку помечают, но письмо всё равно доставляют. "
                                + "Строгая политика — -all"));
            } else if (NEUTRAL.equals(spfPolicy) || PERMISSIVE.equals(spfPolicy)) {
                spfScore = 1;
                issues.add(new Issue("!",
                        "SPF-политика " + spfPolicy + ": запись есть, но разрешает всех — "
                                + "политики фактически нет"));
            } else {
                spfScore = 1;
                issues.add(new Issue("!",
                        "В SPF нет механизма all: по умолчанию действует neutral — политика не работает"));
            }
        }

        // ── DMARC: что делать с письмом, не прошедшим проверку ────────────────
        int dmarcScore;
        String dmarcPolicy = null;

        if (dmarc == null) {
            dmarcScore = 0;
            issues.add(new Issue("!",
                    "DMARC не найден (_dmarc." + domain + "): почтовый сервер получателя не знает, "
                            + "что делать с письмом, не прошедшим SPF/DKIM, — и обычно его доставляет"));
        } else {
            dmarcPolicy = parseDmarcPolicy(dmarc);
            if ("reject".equals(dmarcPolicy)) {
                dmarcScore = 3;
            } else if ("quarantine".equals(dmarcPolicy)) {
                dmarcScore = 2;
                issues.add(new Issue("~",
                        "DMARC p=quarantine: подделки уходят в спам, но не отбрасываются. "
                                + "Максимальная защита — p=reject"));
            } else if ("none".equals(dmarcPolicy)) {
                dmarcScore = 1;
                issues.add(new Issue("~",
                        "DMARC p=none: нарушения только логируются, письма не блокируются — "
                                + "это режим наблюдения, а не защиты"));
            } else {
                dmarcScore = 0;
                issues.add(new Issue("!",
                        "DMARC-запись есть, но тег p= отсутствует или неизвестен — запись недействительна"));
            }
        }

        // Итог по слабейшему звену: дыра в любом из двух механизмов делает домен
        // пригодным для подделки писем.
        int score = Math.min(spfScore, dmarcScore);
        String verdict = score >= 3
                ? "ЗАЩИЩЁН — подделать отправителя не выйдет"
                : score >= 1
                        ? "ЧАСТИЧНО ЗАЩИЩЁН — защита есть, но её можно обойти"
                        : "УЯЗВИМ — от имени домена можно слать поддельные письма";

        return new MailSecurity(domain, root, resolver, mx, spf, spfPolicy, dmarc, dmarcPolicy, verdict, issues);
    }

    public static void main(String[] args) throws Exception {
        if (API_KEY.equals(SANDBOX_KEY)) {
            System.out.println("Демо-ключ: ответы сгенерированы (моки), не реальные записи DNS.\n");
        }

        String domain = args.length > 0 ? args[0] : "atlorium.com";

        MailSecurity audit;
        try {
            // Внутри ровно два запроса к API: сам домен и _dmarc.<домен>.
            audit = auditMailSecurity(domain);
        } catch (AtloriumException error) {
            System.err.println("Ошибка: " + error.getMessage());
            System.exit(1);
            return;
        }

        System.out.println("DNS-записи " + domain + " (резолвер " + audit.resolver() + "):");
        for (Record record : audit.root()) {
            String prefix = record.preference() != null ? record.preference() + " " : "";
            System.out.printf("  %-6s %s%s  (TTL %s)%n", record.type(), prefix, record.value(), record.ttl());
        }

        System.out.println("\nАУДИТ ЗАЩИТЫ ОТ СПУФИНГА — " + domain);
        System.out.println("  MX:    " + (audit.mx().isEmpty() ? "нет" : String.join(", ", audit.mx())));
        System.out.println("  SPF:   " + (audit.spf() != null ? audit.spf() : "не найден"));
        System.out.println("  DMARC: " + (audit.dmarc() != null ? audit.dmarc() : "не найден (_dmarc." + domain + ")"));

        System.out.println("\nВЕРДИКТ: " + audit.verdict());
        if (!audit.issues().isEmpty()) {
            System.out.println("\nПРОБЛЕМЫ:");
            audit.issues().forEach(issue -> System.out.println("  [" + issue.level() + "] " + issue.text()));
        }
    }
}