Хабр·Russia·Tuesday, November 3, 2026 at 01:28 PM UTC

Лечим ошибки SSL на старых Windows: пишем утилиту обновления корневых сертификатов на C#

Translate

BELPORTAL16 минут назад

Сегодня хочу рассказать про боль, которая, думаю, знакома многим, кто хоть раз сталкивался с поддержкой устаревших Windows-систем. А также про то, как небольшая консольная утилита на C# решила проблему, которая годами заставляла меня и моих пользователей хвататься за голову.

С чего всё началось

Всё началось с проекта BELPORTAL — набора решений для работы с государственными порталами Беларуси. Среди прочего там есть клиент для доступа к порталам, и вот с ним-то и возникла проблема.

Пользователи ставили BELPORTAL на Windows 7, Windows XP, на терминальные серверы — словом, туда, где всё ещё жил старый добрый софт. И примерно через одного получали вот такую картину:

Не удается установить защищенное соединение с сервером

или на более свежих системах:

Ошибка 0x800B0101

или классическое:

Сертификат сервера не является доверенным

При этом HTTP-сайты открывались, интернет работал, антивирус молчал. Но HTTPS — ни в какую.

Диагностика: в чём оказалась проблема

Копнув глубже, я выяснил банальную вещь: устаревшее хранилище корневых сертификатов. Windows хранит список доверенных корневых сертификатов в реестре по пути:

HKLM\SOFTWARE\Microsoft\SystemCertificates\ROOT\Certificates

Microsoft регулярно обновляет этот список через Windows Update. Проблема в том, что:

На Windows XP Windows Update для сертификатов уже давно не работает.
На Windows 7 обновления сертификатов прекратились с окончанием поддержки.
На корпоративных машинах политиками часто отключён Windows Update целиком.
На терминальных серверах обновление сертификатов — это отдельный квест.
На изолированных системах (POS-терминалы, банкоматы, медицинское оборудование) интернета нет вообще.

В результате в системе хранится «замороженный» набор сертификатов примерно 2014–2017 года. А сайты с тех пор давно перешли на новые УЦ и новые цепочки сертификации. Отсюда и ошибки.

Что я решил сделать

Идея простая до безобразия: скачать актуальный список доверенных корневых сертификатов напрямую с серверов Microsoft и установить их в реестр, минуя Windows Update.

Microsoft, к счастью, хранит всё в открытом доступе. Есть два файла:

authrootstl.cab — CAB-архив со списком доверенных сертификатов (файл .stl, он же CTL).
<thumbprint>.crt — Сами сертификаты по их SHA-1 отпечаткам.

То есть весь алгоритм сводится к четырём шагам:

Скачать authrootstl.cab.
Распаковать его (внутри лежит authroot.stl).
Распарсить CTL и вытащить SHA-1 отпечатки всех сертификатов.
Скачать недостающие сертификаты и записать их в реестр в нужном формате.

Технические детали

Парсинг CTL
Самая нетривиальная часть. .stl — это Certificate Trust List, по сути ASN.1-структура с вложенными SEQUENCE. SHA-1 отпечатки хранятся как OCTET STRING длиной 20 байт внутри вложенных SEQUENCE.

Вот упрощённая версия парсера из утилиты (выдели этот код и нажми кнопку </> в редакторе):

static List<string> ParseCtlThumbprints(byte[] stlData)
{
var thumbprints = new List<string>();
int offset = 0;

while (offset < stlData.Length - 30)
{
if (stlData[offset] != 0x30) { offset++; continue; }

// Разбираем длину SEQUENCE (поддерживаем short и long form)
int seqLen, dataOffset;
if ((stlData[offset + 1] & 0x80) != 0)
{
int lenBytes = stlData[offset + 1] & 0x7F;
seqLen = 0;
for (int i = 0; i < lenBytes; i++)
seqLen = (seqLen << 8) | stlData[offset + 2 + i];
dataOffset = offset + 2 + lenBytes;
}
else
{
seqLen = stlData[offset + 1];
dataOffset = offset + 2;
}

// Внутри ищем вложенный SEQUENCE с OCTET STRING длиной 20 байт
// ... (проверки опущены для краткости, полный код в конце статьи)

offset = dataOffset + seqLen;
}

return thumbprints;
}

Плюс есть запасной метод FindSha1Hashes, который просто сканирует файл, ищет паттерн 0x04 0x14 (OCTET STRING длиной 20) и проверяет энтропию хеша — на случай, если ASN.1-парсер не справится с каким-то экзотическим вариантом .stl.

Многопоточная загрузка
Сертификатов в списке обычно порядка 130 штук. Скачивать их по одному — долго. Поэтому утилита разбивает список на чанки и запускает 16 потоков, каждый из которых качает свою порцию:

int threadCount = Math.Min(ThreadCount, total);
int chunkSize = (total + threadCount - 1) / threadCount;

for (int t = 0; t < threadCount; t++)
{
int start = t * chunkSize;
int end = Math.Min(start + chunkSize, total);

В результате время работы утилиты сокращается до 1–3 минут даже на слабых машинах.

Запись в реестр
Тут есть один неочевидный момент. Формат значения Blob — это не просто DER-байты сертификата. Это структура:
DWORD dwCertEncodingType = 0x20 (X509_ASN_ENCODING)
DWORD cbCertEncoded = 1
DWORD cbCertEncoded = длина DER
BYTE[] pbCertEncoded = DER-байты

Соответствующий код:

static void WriteCertToRegistry(string thumbprintUpper, byte[] derBytes)
{
string keyPath = @"SOFTWARE\Microsoft\SystemCertificates\ROOT\Certificates" + thumbprintUpper;

byte[] blob = new byte[12 + derBytes.Length];
Buffer.BlockCopy(BitConverter.GetBytes(0x20), 0, blob, 0, 4);
Buffer.BlockCopy(BitConverter.GetBytes(1), 0, blob, 4, 4);
Buffer.BlockCopy(BitConverter.GetBytes(derBytes.Length), 0, blob, 8, 4);
Buffer.BlockCopy(derBytes, 0, blob, 12, derBytes.Length);

using (RegistryKey key = Registry.LocalMachine.CreateSubKey(keyPath))
{
key.SetValue("Blob", blob, RegistryValueKind.Binary);
}
}

Оптимизация: ставим только недостающее
Очень быстро пришло понимание: если ставить все сертификаты каждый раз — это медленно и некрасиво. Поэтому утилита сначала читает уже установленные отпечатки из реестра и качает только недостающие:

var installed = GetInstalledThumbprints();
foreach (var thumb in thumbprints)
{
if (installed.Contains(thumb.ToLower()))
alreadyInstalled++;
else
needToDownload.Add(thumb);
}

На системах, где уже что-то обновлялось, разница может быть в разы.

Что видит пользователь

Я не стал делать GUI — незачем. Всё в консоли, но с цветным выводом, рамками и понятным прогрессом:

╔══════════════════════════════════════════════════════════╗
║ ║
║ BELPORTAL ║
║ Обновление корневых сертификатов v1.1 ║
║ ║
╚══════════════════════════════════════════════════════════╝

─── ДОВЕРЕННЫЕ КОРНЕВЫЕ СЕРТИФИКАТЫ ───
ℹ Загрузка списка доверенных сертификатов...
✔ Скачан authroot.cab (45 678 байт)
✔ Извлечен: authroot.stl
ℹ Найдено 128 сертификатов в списке Microsoft
ℹ Уже установлено: 12, требуется загрузить: 116
ℹ Загрузка 116 недостающих сертификатов...
⏳ Загрузка сертификатов: 116/116
✔ Загружено 116/116 сертификатов
ℹ Установка сертификатов в реестр...

─── ИТОГИ ───
✔ Уже было установлено: 12
✔ Установлено новых: 116

Запустил от администратора, дождался завершения, перезагрузился. Всё.

Что насчёт безопасности

Естественный вопрос: «А не подсунет ли мне эта утилита левые сертификаты?»

Отвечаю честно:
Утилита скачивает только с официальных серверов Microsoft.
Список сертификатов (CTL) подписан Microsoft, но утилита, если честно, не проверяет подпись CTL — она опирается на транспортную безопасность загрузки с официального домена. Это осознанный компромисс ради совместимости с Windows XP, где проверка подписи CTL средствами .NET 2.0 — это отдельная боль.
Никакой телеметрии, никакой отправки данных наружу.

Если для вас это критично — вы можете легко добавить проверку подписи CTL на своей стороне, исходники открыты.

Кому это нужно

Утилита реально выручает в таких сценариях:
Старые Windows XP / 7 / 8 без обновлений.
Корпоративные ПК с заблокированным Windows Update.
Терминальные серверы и RDS.
POS-терминалы, банкоматы, киоски.
Медицинское и промышленное оборудование с Windows Embedded.
Изолированные системы, куда сертификаты нужно принести «на флешке».

«А почему не использовать готовое?»

Резонный вопрос. Готовые решения есть, но:
certutil -generateSSTFromWU — есть только начиная с Windows 10 / Server 2016.
rootsupd.exe от Microsoft — обновлялся последний раз в районе 2013 года, сертификатов там мало и они устаревшие.
Ручное обновление через Windows Update — на XP и 7 уже не работает.

Так что ниша пустовала, а теперь — занята.

Где взять

Утилита распространяется бесплатно как портативный EXE (~100 КБ), не требует .NET Framework выше 2.0 (а он есть даже на XP) и работает как на x86, так и на x64.

Страница загрузки: https://belportal.by/utilita-obnovleniya-kornevyh-sertifikatov-belportal

Полный исходный код утилиты:

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Text;
using System.Threading;
using Microsoft.Win32;

namespace UpdateRootCertificates
{
class Program
{
// --- Константы ---
private static readonly string LogFile = Path.Combine(Environment.GetEnvironmentVariable("TEMP") ?? "C:\", "UpdateRootCertificates.log");
private static readonly object LogLock = new object();
private static readonly string AuthRootCabUrl = "http://ctldl.windowsupdate.com/msdownload/update/v3/static/trustedr/en/authrootstl.cab";
private static readonly string CertCdnUrl = "http://ctldl.windowsupdate.com/msdownload/update/v3/static/trustedr/en/{0}.crt";
private static readonly string RootRegPath = @"SOFTWARE\Microsoft\SystemCertificates\ROOT\Certificates";
private static readonly int ThreadCount = 16;
private static bool Verbose = false;

static void Main(string[] args)
{
Console.OutputEncoding = Encoding.UTF8;

foreach (var arg in args)
{
if (arg == "-v" arg == "--verbose")
Verbose = true;
if (arg == "-V" arg == "--version")
{
Console.WriteLine("UpdateRootCertificates v1.1");
return;
}
}

PrintHeader();

try
{
Log("=== СТАРТ ===");
WriteSuccess("Инициализация...");

string workDir = Path.Combine(Path.GetTempPath(), "UpdateRootCertificates_tmp");
if (Directory.Exists(workDir))
Directory.Delete(workDir, true);
Directory.CreateDirectory(workDir);
WriteInfo($"Рабочая папка: {workDir}");

try
{
ProcessAuthRoot(workDir);
}
finally
{
if (Directory.Exists(workDir))
Directory.Delete(workDir, true);
Log("Рабочая папка удалена");
}

Log("ГОТОВО");
WriteSuccess("\n✓ Операция успешно завершена!");
WriteInfo("Рекомендуется перезагрузить компьютер для применения изменений.");
WriteInfo("Файл лога: {LogFile}"); } catch (Exception ex) { Log("КРИТИЧЕСКАЯ ОШИБКА: {ex.Message}");
WriteError("\n✗ КРИТИЧЕСКАЯ ОШИБКА: {ex.Message}"); WriteInfo("Файл лога: {LogFile}");
}

if (Environment.UserInteractive)
{
Console.WriteLine();
WriteInfo("Нажмите любую клавишу для выхода...");
Console.ReadKey();
}
}

static void PrintHeader()
{
Console.Clear();
string title = "BELPORTAL";
string subtitle = "Обновление корневых сертификатов v1.1";

Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("╔newstring(′═′,58)╗");Console.WriteLine("╔newstring(′═′,58)╗");Console.WriteLine("║{new string(' ', 58)}║");

Console.ForegroundColor = ConsoleColor.Yellow;
int leftPadding = (58 - title.Length) / 2;
Console.WriteLine($"║{new string(' ', leftPadding)}{title}{new string(' ', 58 - leftPadding - title.Length)}║");

Console.ForegroundColor = ConsoleColor.White;
leftPadding = (58 - subtitle.Length) / 2;
Console.WriteLine($"║{new string(' ', leftPadding)}{subtitle}{new string(' ', 58 - leftPadding - subtitle.Length)}║");

Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine(║║"╚{new string('═', 58)}╝");

Console.ResetColor();
Console.WriteLine();
}

static void WriteInfo(string message)
{
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine($" ℹ {message}");
Console.ResetColor();
}

static void WriteSuccess(string message)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine($" ✔ {message}");
Console.ResetColor();
}

static void WriteError(string message)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($" ✗ {message}");
Console.ResetColor();
}

static void WriteWarning(string message)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($" ⚠ {message}");
Console.ResetColor();
}

static void WriteProgress(string message)
{
Console.ForegroundColor = ConsoleColor.DarkCyan;
Console.Write($"\r ⏳ {message}");
Console.ResetColor();
}

static void WriteSection(string message)
{
Console.ForegroundColor = ConsoleColor.Magenta;
Console.WriteLine($"\n ─── {message} ───");
Console.ResetColor();
}

static void Log(string message)
{
lock (LogLock)
{
try { File.AppendAllText(LogFile, $"{DateTime.Now:yyyy-MM-dd HH:mm:ss} - {message}{Environment.NewLine}"); }
catch { }
}
}

static void DownloadFile(string url, string destPath, int retries = 3)
{
WriteProgress($"Скачивание {Path.GetFileName(destPath)}...");

for (int attempt = 1; attempt <= retries; attempt++)
{
try
{
using (WebClient client = new WebClient())
{
client.DownloadFile(url, destPath);
}

if (File.Exists(destPath) && new FileInfo(destPath).Length > 0)
{
WriteSuccess("Скачан {Path.GetFileName(destPath)} ({new FileInfo(destPath).Length:N0} байт)"); return; } } catch (Exception ex) { if (attempt < retries) { WriteWarning("Попытка {attempt} не удалась, повтор...");
Thread.Sleep(1000);
}
else
{
throw new Exception($"Не удалось скачать {url}: {ex.Message}");
}
}
}
}

static byte[] DownloadBytes(string url)
{
try
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
request.Timeout = 30000;
request.ReadWriteTimeout = 30000;

using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
using (Stream stream = response.GetResponseStream())
{
using (MemoryStream ms = new MemoryStream())
{
byte[] buffer = new byte[4096];
int bytesRead;
while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) > 0)
{
ms.Write(buffer, 0, bytesRead);
}
return ms.ToArray();
}
}
}
}
catch
{
return null;
}
}

static string ExtractCab(string cabPath, string destDir)
{
if (!Directory.Exists(destDir))
Directory.CreateDirectory(destDir);

WriteProgress("Извлечение CAB архива...");

string expandPath = Path.Combine(Environment.SystemDirectory, "expand.exe");
if (!File.Exists(expandPath))
throw new Exception("expand.exe не найден в системной папке");

ProcessStartInfo psi = new ProcessStartInfo
{
FileName = expandPath,
Arguments = $""{cabPath}" -F:* "{destDir}"",
UseShellExecute = false,
CreateNoWindow = true,
RedirectStandardOutput = true,
RedirectStandardError = true
};

using (Process process = Process.Start(psi))
{
process.WaitForExit();
if (process.ExitCode != 0)
throw new Exception($"expand.exe завершился с кодом {process.ExitCode}");
}

string[] files = Directory.GetFiles(destDir);
if (files.Length == 0)
throw new Exception("Из CAB архива не извлечено ни одного файла");

string extracted = files[0];
if (!extracted.ToLower().EndsWith(".stl"))
{
string renamed = Path.ChangeExtension(extracted, ".stl");
File.Move(extracted, renamed);
extracted = renamed;
}

WriteSuccess($"Извлечен: {Path.GetFileName(extracted)}");
return extracted;
}

// --- ПРАВИЛЬНЫЙ ПАРСЕР CTL (работает с реальным STL) ---
static List<string> ParseCtlThumbprints(byte[] stlData)
{
var thumbprints = new List<string>();

try
{
int offset = 0;
while (offset < stlData.Length - 30)
{
if (stlData[offset] == 0x30)
{
int seqLen;
int dataOffset;

if ((stlData[offset + 1] & 0x80) != 0)
{
int lenBytes = stlData[offset + 1] & 0x7F;
if (lenBytes > 0 && offset + 1 + lenBytes < stlData.Length)
{
seqLen = 0;
for (int i = 0; i < lenBytes; i++)
{
seqLen = (seqLen << 8) | stlData[offset + 2 + i];
}
dataOffset = offset + 2 + lenBytes;
}
else
{
offset++;
continue;
}
}
else
{
seqLen = stlData[offset + 1];
dataOffset = offset + 2;
}

if (dataOffset + seqLen > stlData.Length || seqLen < 22)
{
offset++;
continue;
}

int innerOffset = dataOffset;
if (innerOffset + 2 < stlData.Length && stlData[innerOffset] == 0x30)
{
int innerLen;
int innerDataOffset;

if ((stlData[innerOffset + 1] & 0x80) != 0)
{
int lenBytes = stlData[innerOffset + 1] & 0x7F;
if (lenBytes > 0 && innerOffset + 1 + lenBytes < stlData.Length)
{
innerLen = 0;
for (int i = 0; i < lenBytes; i++)
{
innerLen = (innerLen << 8) | stlData[innerOffset + 2 + i];
}
innerDataOffset = innerOffset + 2 + lenBytes;
}
else
{
offset++;
continue;
}
}
else
{
innerLen = stlData[innerOffset + 1];
innerDataOffset = innerOffset + 2;
}

if (innerDataOffset + 22 <= stlData.Length &&
stlData[innerDataOffset] == 0x04 &&
stlData[innerDataOffset + 1] == 0x14)
{
byte[] hash = new byte[20];
Array.Copy(stlData, innerDataOffset + 2, hash, 0, 20);

bool valid = false;
foreach (byte b in hash)
{
if (b != 0 && b != 0xFF)
{
valid = true;
break;
}
}

if (valid)
{
string thumbprint = BitConverter.ToString(hash).Replace("-", "").ToLower();
if (!thumbprints.Contains(thumbprint))
{
thumbprints.Add(thumbprint);
}
}
}
}

offset = dataOffset + seqLen;
}
else
{
offset++;
}
}

if (thumbprints.Count == 0)
{
thumbprints = FindSha1Hashes(stlData);
}
}
catch (Exception ex)
{
WriteWarning($"Ошибка при парсинге CTL: {ex.Message}");
thumbprints = FindSha1Hashes(stlData);
}

return thumbprints;
}

// --- ЗАПАСНОЙ МЕТОД: поиск SHA-1 хешей напрямую ---
static List<string> FindSha1Hashes(byte[] data)
{
var thumbprints = new List<string>();

for (int i = 0; i <= data.Length - 22; i++)
{
if (data[i] == 0x04 && data[i + 1] == 0x14)
{
int hashStart = i + 2;
byte[] potentialHash = new byte[20];
Array.Copy(data, hashStart, potentialHash, 0, 20);

int zeroCount = 0;
int ffCount = 0;
int uniqueCount = 0;
var seen = new HashSet<byte>();

foreach (byte b in potentialHash)
{
if (b == 0) zeroCount++;
if (b == 0xFF) ffCount++;
if (!seen.Contains(b)) { seen.Add(b); uniqueCount++; }
}

if (zeroCount < 10 && ffCount < 10 && uniqueCount > 5)
{
string thumbprint = BitConverter.ToString(potentialHash).Replace("-", "").ToLower();
if (!thumbprints.Contains(thumbprint))
{
thumbprints.Add(thumbprint);
}
}
}
}

return thumbprints;
}

static HashSet<string> GetInstalledThumbprints()
{
var installed = new HashSet<string>();
try
{
string regPath = @"SOFTWARE\Microsoft\SystemCertificates\ROOT\Certificates";
using (RegistryKey key = Registry.LocalMachine.OpenSubKey(regPath))
{
if (key != null)
{
foreach (string subKeyName in key.GetSubKeyNames())
{
installed.Add(subKeyName.ToLower());
}
}
}
}
catch { }
return installed;
}

static void WriteCertToRegistry(string thumbprintUpper, byte[] derBytes)
{
string keyPath = RootRegPath + "\" + thumbprintUpper;

using (RegistryKey key = Registry.LocalMachine.CreateSubKey(keyPath))
{
key.SetValue("Blob", blob, RegistryValueKind.Binary);
}
}

static void ProcessAuthRoot(string workDir)
{
WriteSection("ДОВЕРЕННЫЕ КОРНЕВЫЕ СЕРТИФИКАТЫ");

string cabPath = Path.Combine(workDir, "authroot.cab");
string stlDir = Path.Combine(workDir, "authroot");

WriteInfo("Загрузка списка доверенных сертификатов...");
DownloadFile(AuthRootCabUrl, cabPath);

string stlPath = ExtractCab(cabPath, stlDir);

byte[] stlData = File.ReadAllBytes(stlPath);

List<string> thumbprints = ParseCtlThumbprints(stlData);

if (thumbprints.Count == 0)
{
WriteWarning("Не найдено сертификатов в списке. Проверьте файл authroot.stl.");
return;
}

WriteInfo($"Найдено {thumbprints.Count} сертификатов в списке Microsoft");

WriteInfo("Проверка установленных сертификатов...");
var installed = GetInstalledThumbprints();

var needToDownload = new List<string>();
int alreadyInstalled = 0;

foreach (var thumb in thumbprints)
{
if (installed.Contains(thumb.ToLower()))
{
alreadyInstalled++;
if (Verbose)
WriteInfo($"Уже установлен: {thumb.ToUpper()}");
}
else
{
needToDownload.Add(thumb);
}
}

WriteInfo($"Уже установлено: {alreadyInstalled}, требуется загрузить: {needToDownload.Count}");

if (needToDownload.Count == 0)
{
WriteSuccess("Все сертификаты уже установлены. Ничего не делаем.");
return;
}

int total = needToDownload.Count;
var results = new Dictionary<string, byte[]>();
var resultsLock = new object();
int completed = 0;

WriteInfo($"Загрузка {total} недостающих сертификатов...");

var threads = new List<Thread>();
int threadCount = Math.Min(ThreadCount, total);
int chunkSize = (total + threadCount - 1) / threadCount;

for (int t = 0; t < threadCount; t++)
{
int start = t * chunkSize;
int end = Math.Min(start + chunkSize, total);
if (start >= end) break;

foreach (var thread in threads)
thread.Join();

Console.WriteLine();
WriteSuccess($"Загружено {results.Count}/{total} сертификатов");

WriteInfo("Установка сертификатов в реестр...");

int regAdded = 0;
int regFailed = 0;

foreach (var kvp in results)
{
string thumb = kvp.Key;
byte[] der = kvp.Value;
if (der == null) { regFailed++; continue; }

try
{
WriteCertToRegistry(thumb.ToUpper(), der);
regAdded++;
if (Verbose)
WriteSuccess("Установлен: {thumb.ToUpper()}"); } catch (Exception ex) { WriteError("Ошибка установки {thumb.ToUpper()}: {ex.Message}");
regFailed++;
}
}

int miss = total - results.Count;

WriteSection("ИТОГИ");
WriteSuccess("✔Ужебылоустановлено:alreadyInstalled");WriteSuccess("✔Ужебылоустановлено:alreadyInstalled");WriteSuccess("✔ Установлено новых: {regAdded}");
if (regFailed > 0) WriteError("✗Ошибокустановки:regFailed");if(miss>0)WriteWarning("✗Ошибокустановки:regFailed");if(miss>0)WriteWarning("⚠ Недоступно на сервере: {miss}");
}
}
}

Итоги и планы

Что сделано:
Утилита, которая лечит SSL-ошибки на старых Windows.
Работает на XP–11, включая серверные редакции.
Не требует .NET выше 2.0.
Не требует установки.
Бесплатна.

Что в планах:
Поддержка проверки подписи CTL (для параноиков).
Режим «офлайн-пакет» — с возможностью скачать сертификаты на одной машине и установить на другой.
Опциональный GUI для тех, кто боится консоли.

Если у вас есть старые машины, которые вдруг перестали открывать HTTPS-сайты, или вы поддерживаете парк устаревших Windows — попробуйте. Буду рад фидбеку, баг-репортам и идеям по улучшению.

Ссылки:
🌐 Страница проекта (https://belportal.by/utilita-obnovleniya-kornevyh-sertifikatov-belportal )
💬 Telegram (https://t.me/BelPortal)

View the original on Хабр →

KioskNews shows a cleaned-up reading view extracted from the publisher’s page — the original always lives on their site, not ours.