Program.cs

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

using System.Net;
using System.Net.Http.Headers;
using System.Text.Json;
using System.Text.Json.Serialization;

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

var apiKey = Environment.GetEnvironmentVariable("ATLORIUM_API_KEY") ?? SandboxKey;
var baseUrl = Environment.GetEnvironmentVariable("ATLORIUM_BASE_URL") ?? "https://atlorium.com";

using var http = new HttpClient
{
    BaseAddress = new Uri(baseUrl),
    Timeout = TimeSpan.FromSeconds(30),
};
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
http.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

var client = new DnsClient(http);

if (apiKey == SandboxKey)
{
    Console.WriteLine("Демо-ключ: ответы сгенерированы (моки), не реальные записи DNS.\n");
}

var domain = args.Length > 0 ? args[0] : "atlorium.com";

MailSecurity audit;
try
{
    // Внутри ровно два запроса к API: сам домен и _dmarc.<домен>.
    // Ответ по домену возвращается в audit.Root — печатаем его без третьего запроса.
    audit = await MailSecurityAudit.AuditAsync(client, domain);
}
catch (AtloriumException error)
{
    Console.Error.WriteLine($"Ошибка: {error.Message}");
    return 1;
}

var root = audit.Root;

Console.WriteLine($"DNS-записи {root.Domain} (резолвер {root.Resolver}):");
foreach (var group in root.Records)
{
    foreach (var record in group.Records)
    {
        var prefix = record.Preference is { } preference ? $"{preference} " : "";
        Console.WriteLine($"  {group.Type,-6} {prefix}{record.Value}  (TTL {record.Ttl})");
    }
}

foreach (var message in root.Errors)
{
    Console.WriteLine($"  [!] {message}");
}

Console.WriteLine($"\nАУДИТ ЗАЩИТЫ ОТ СПУФИНГА — {domain}");
Console.WriteLine($"  MX:    {(audit.Mx.Count > 0 ? string.Join(", ", audit.Mx) : "нет")}");
Console.WriteLine($"  SPF:   {audit.Spf ?? "не найден"}");
Console.WriteLine($"  DMARC: {audit.Dmarc ?? $"не найден (_dmarc.{domain})"}");

Console.WriteLine($"\nВЕРДИКТ: {audit.Verdict}");
if (audit.Issues.Count > 0)
{
    Console.WriteLine("\nПРОБЛЕМЫ:");
    foreach (var issue in audit.Issues)
    {
        Console.WriteLine($"  [{issue.Level}] {issue.Text}");
    }
}

return 0;

// ── Клиент ───────────────────────────────────────────────────────────────────

/// <summary>Ошибка API: HTTP-код разложен в человекочитаемую причину.</summary>
public sealed class AtloriumException(HttpStatusCode status, string body)
    : Exception($"HTTP {(int)status}: {Explain(status)}. Ответ сервера: {body[..Math.Min(200, body.Length)]}")
{
    public HttpStatusCode Status { get; } = status;

    private static string Explain(HttpStatusCode status) => (int)status switch
    {
        400 => "Домен не передан или задан неверно (нужно чистое имя, без https:// и без IP)",
        401 => "API-ключ отсутствует, просрочен или недействителен",
        402 => "Недостаточно кредитов на балансе — пополните на https://atlorium.com",
        429 => "Превышен лимит запросов — повторите позже",
        500 => "DNS-резолвер не ответил или превышен таймаут запроса",
        503 => "Сервис временно недоступен (за сбой на своей стороне мы не списываем деньги)",
        _ => "Неизвестная ошибка",
    };
}

public sealed class DnsClient(HttpClient http)
{
    private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web);

    // 429 — не поломка, а штатный лимит. Ждём и повторяем.
    private static readonly TimeSpan RetryDelay = TimeSpan.FromSeconds(20);
    private const int MaxRetries = 2;

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

    /// <summary>
    /// DNS-записи домена: A, AAAA, MX, TXT, CNAME, NS — одним запросом.
    /// <paramref name="resolver"/> — IP-адрес резолвера (по умолчанию Cloudflare 1.1.1.1).
    /// </summary>
    public async Task<DnsLookupResponse> LookupAsync(string domain, string? resolver = null)
    {
        var path = $"/api/dns/lookup?domain={Uri.EscapeDataString(domain)}";
        if (!string.IsNullOrWhiteSpace(resolver))
        {
            path += $"&resolver={Uri.EscapeDataString(resolver)}";
        }

        var json = await GetAsync(path);
        return JsonSerializer.Deserialize<DnsLookupResponse>(json, JsonOptions)
               ?? throw new InvalidOperationException("Пустой ответ API.");
    }

    /// <summary>
    /// Распространение записей по резолверам: одинаково ли они видят домен.
    /// Нужно после смены DNS. В примере не вызывается — чтобы не тратить лишний запрос.
    /// </summary>
    public async Task<string> CheckPropagationAsync(string domain, string? resolvers = null)
    {
        var path = $"/api/dns/propagation?domain={Uri.EscapeDataString(domain)}";
        if (!string.IsNullOrWhiteSpace(resolvers))
        {
            path += $"&resolvers={Uri.EscapeDataString(resolvers)}";
        }

        return await GetAsync(path);
    }

    private async Task<string> GetAsync(string path)
    {
        for (var attempt = 0; attempt <= MaxRetries; attempt++)
        {
            using var response = await http.GetAsync(path);

            if (response.StatusCode == HttpStatusCode.TooManyRequests && attempt < MaxRetries)
            {
                var delay = RetryAfter(response);
                if (delay == TimeSpan.Zero)
                {
                    throw new AtloriumException(HttpStatusCode.TooManyRequests,
                        "лимит запросов по IP исчерпан, повторите позже");
                }

                Console.Error.WriteLine($"  ... лимит запросов, пауза {delay.TotalSeconds:0} с");
                await Task.Delay(delay);
                continue;
            }

            if (!response.IsSuccessStatusCode)
            {
                throw new AtloriumException(response.StatusCode, await response.Content.ReadAsStringAsync());
            }

            return await response.Content.ReadAsStringAsync();
        }

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

    /// <summary>
    /// Сколько ждать после 429. Ноль/мусор и слишком большие значения не берём на веру:
    /// 0 означал бы busy-loop, 40 минут — зависший клиент. Возвращаем ноль, если ждать
    /// бессмысленно долго: вызывающий сдастся.
    /// </summary>
    private static TimeSpan RetryAfter(HttpResponseMessage response)
    {
        var seconds = response.Headers.RetryAfter?.Delta?.TotalSeconds ?? 0;
        if (seconds <= 0)
        {
            return RetryDelay;
        }

        var delay = TimeSpan.FromSeconds(seconds);
        return delay <= MaxRetryDelay ? delay : TimeSpan.Zero;
    }
}

// ── Модель ответа ────────────────────────────────────────────────────────────

/// <summary>Одна DNS-запись. Preference заполняется только у MX.</summary>
public sealed record DnsRecordEntry
{
    public string Name { get; init; } = "";
    public string Value { get; init; } = "";
    public int? Ttl { get; init; }
    public int? Preference { get; init; }
    public string? Details { get; init; }
}

/// <summary>Записи одного типа: A, AAAA, MX, TXT, CNAME, NS.</summary>
public sealed record DnsRecordGroup
{
    public string Type { get; init; } = "";
    public IReadOnlyList<DnsRecordEntry> Records { get; init; } = [];
}

public sealed record DnsLookupResponse
{
    public string Domain { get; init; } = "";
    public string Resolver { get; init; } = "";

    [JsonPropertyName("requestedAtUtc")]
    public DateTime RequestedAtUtc { get; init; }

    public IReadOnlyList<DnsRecordGroup> Records { get; init; } = [];
    public IReadOnlyList<string> Errors { get; init; } = [];

    /// <summary>Записи одного типа: ответ приходит группами по типу.</summary>
    public IReadOnlyList<DnsRecordEntry> Of(string type) =>
        Records.FirstOrDefault(group => group.Type == type)?.Records ?? [];
}

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

/// <summary>Level: «!» — критично, «~» — слабое место, «i» — к сведению.</summary>
public sealed record Issue(string Level, string Text);

public sealed record MailSecurity
{
    public required string Domain { get; init; }

    /// <summary>Полный ответ по домену — чтобы напечатать записи, не делая третий запрос.</summary>
    public required DnsLookupResponse Root { get; init; }

    public IReadOnlyList<string> Mx { get; init; } = [];
    public string? Spf { get; init; }
    public string? SpfPolicy { get; init; }
    public string? Dmarc { get; init; }
    public string? DmarcPolicy { get; init; }
    public string Verdict { get; init; } = "";
    public IReadOnlyList<Issue> Issues { get; init; } = [];
}

public static class MailSecurityAudit
{
    private const string Strict = "-all";      // hard fail: чужому письму отказать
    private const string Soft = "~all";        // softfail: пометить, но доставить
    private const string Neutral = "?all";     // neutral: политики фактически нет
    private const string Permissive = "+all";  // разрешено всем — дыра

    /// <summary>Механизм «all» в конце SPF — это и есть политика. Без него по умолчанию neutral.</summary>
    public static string? ParseSpfPolicy(string spf)
    {
        foreach (var policy in new[] { Strict, Soft, Neutral, Permissive })
        {
            if (spf.Contains(policy, StringComparison.Ordinal))
            {
                return policy;
            }
        }

        // Голое «all» без квалификатора равносильно +all.
        return spf.Split(' ').Contains("all") ? Permissive : null;
    }

    /// <summary>Тег p= в DMARC: none (мониторинг) / quarantine (в спам) / reject (отбросить).</summary>
    public static string? ParseDmarcPolicy(string dmarc)
    {
        foreach (var tag in dmarc.Split(';'))
        {
            var parts = tag.Trim().Split('=', 2);
            if (parts.Length == 2 && parts[0].Trim().Equals("p", StringComparison.OrdinalIgnoreCase))
            {
                return parts[1].Trim().ToLowerInvariant();
            }
        }

        return null;
    }

    /// <summary>Аудит защиты домена от спуфинга. Ровно 2 запроса к API.</summary>
    public static async Task<MailSecurity> AuditAsync(DnsClient client, string domain)
    {
        // Запрос 1 — записи самого домена: MX и TXT (в TXT живёт SPF).
        var root = await client.LookupAsync(domain);

        var mx = root.Of("MX")
            .Select(record => record.Preference is { } preference
                ? $"{record.Value} (приоритет {preference})"
                : record.Value)
            .ToList();

        var spf = root.Of("TXT")
            .Select(record => record.Value)
            .FirstOrDefault(value => value.StartsWith("v=spf1", StringComparison.OrdinalIgnoreCase));

        // Запрос 2 — DMARC лежит НЕ на домене, а на поддомене _dmarc.<домен>.
        // Это отдельная зона, поэтому и запрос отдельный.
        var dmarcZone = await client.LookupAsync($"_dmarc.{domain}");
        var dmarc = dmarcZone.Of("TXT")
            .Select(record => record.Value)
            .FirstOrDefault(value => value.StartsWith("v=DMARC1", StringComparison.OrdinalIgnoreCase));

        var issues = new List<Issue>();

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

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

        if (spf is null)
        {
            spfScore = 0;
            issues.Add(new Issue("!",
                "SPF не найден: письма от имени домена может слать кто угодно — " +
                "принимающий сервер не с чем сверить отправителя"));
        }
        else
        {
            spfPolicy = ParseSpfPolicy(spf);
            switch (spfPolicy)
            {
                case Strict:
                    spfScore = 3;
                    break;
                case Soft:
                    spfScore = 2;
                    issues.Add(new Issue("~",
                        "SPF ~all (softfail): подделку помечают, но письмо всё равно доставляют. " +
                        "Строгая политика — -all"));
                    break;
                case Neutral or Permissive:
                    spfScore = 1;
                    issues.Add(new Issue("!",
                        $"SPF-политика {spfPolicy}: запись есть, но разрешает всех — политики фактически нет"));
                    break;
                default:
                    spfScore = 1;
                    issues.Add(new Issue("!",
                        "В SPF нет механизма all: по умолчанию действует neutral — политика не работает"));
                    break;
            }
        }

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

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

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

        return new MailSecurity
        {
            Domain = domain,
            Root = root,
            Mx = mx,
            Spf = spf,
            SpfPolicy = spfPolicy,
            Dmarc = dmarc,
            DmarcPolicy = dmarcPolicy,
            Verdict = verdict,
            Issues = issues,
        };
    }
}