https://.../ckey.git

pod 'CKeySDK',           :git => '...'

AppName.app/root-certs/
    cert_1.crt
    cert_2.cer
    ...
    cert_N.certificate

# SPM
sh ${BUILD_DIR%Build/*}/SourcePackages/checkouts/ckeysdk/Tools/ConfigureApplication

# CocoaPods
tbw

import UIKit
import CKeySDK

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

        // Установка уровня логирования и настройка конфигурации
        #if DEBUG
        CKeySDK.setLogLevel([.debug, .keys])
        let configuration = CKey.Configuration(debugMode: true)
        #else
        let configuration = CKey.Configuration()
        #endif

        do {
            // Инициализация библиотеки
            try CKey.initialize(configuration: configuration)
        } catch {
            ...
        }
        ...

    }

}

let createdUser = try await UsersManager.createUser(
    serviceURL: serverURL,          // Адрес сервера СЭП
    name: name,                     // Имя для сохранения учетной записи
    pushNotificationsData: data,    // Данные для отправки пуш-уведомлений
    deviceName: deviceName,         // Отображаемое дружественное имя устройства
    externalId: externalId,         // Внешний идентификатор
    alias: alias,                   // Человекочитаемый идентификатор устройства
    requirePassword: requirePwd     // Требуется ли установка пароля
)

let updatedUser = try await UsersManager.updateStatus(
    user: user
)

let verifiedUser = try await UsersManager.acceptAccountChanges(
    user: user
)

let createdUser = try await UsersManager.createUserWithInitQR(
    name: name,                     // Имя для сохранения учетной записи
    pushNotificationsData: data,    // Данные для отправки пуш-уведомлений
    deviceName: deviceName,         // Отображаемое дружественное имя устройства
    externalId: externalId,         // Внешний идентификатор
    alias: alias,                   // Человекочитаемый идентификатор устройства
    requirePassword: true           // Требуется ли установка пароля
)

// Идентификатор подтверждённого пользователя, к которому привязываем новое устройство
let uid = user.UserID

let createdUser = try await UsersManager.createUserWithApproval(
    serviceURL: serverURL,          // Адрес сервера СЭП
    uid: uid,                       // Идентификатор пользователя, к которому привязываем устройство
    name: name,                     // Имя для сохранения учетной записи
    pushNotificationsData: data,    // Данные для отправки пуш-уведомлений
    deviceName: deviceName,         // Отображаемое дружественное имя устройства
    externalID: externalID,         // Внешний идентификатор
    alias: alias,                   // Человекочитаемый идентификатор устройства
    requirePassword: true           // Требуется ли установка пароля
)

try await DevicesManager.processAwaitingDevice(
    user: user  // Пользователь к которому привязываем устройство
)

try await UsersManager.checkApprovalStatus(
    user: newUser
)

let createdUser = try await UsersManagerNonQual.createUser(
    serviceURL: serverURL,          // Адрес сервера СЭП
    pushNotificationsData: data,    // Данные для отправки пуш-уведомлений
    deviceName: deviceName,         // Отображаемое дружественное имя устройства
    externalId: externalId,         // Внешний идентификатор
    alias: alias,                   // Человекочитаемый идентификатор устройства
)

let storedUser = try await UsersManagerNonQual.store(
   user: user,        // Новый пользователь 
   name: name,        // Имя для хранения
   password: password // Пароль для хранения
)

//  Обновляем сведения о пользователе
let updatedUser = UsersManager.updateStatus(
    user: user
)
if updatedUser.state == .notVerified {
    ...
}

if !user.isReadyToSign {
    // Предъявляем пароль
    try UsersManagerNonQual.submitPassword(user: user, password: password)
}

if user.verification == .qrRequired {
    // Парсим QR-код
    let qrValue = ...
    // Проверяем
    let verificationQRCode: QRCodeVerification = try CKey.analyzeQR(qrValue)
}

// Присоединяем к УЗ
let acceptedUser = try await UsersManagerNonQual.acceptAccountChanges(
  user: user,                             // Пользователь
  verificationQRCode: verificationQRCode  // QR-код
)

// Парсим QR-код
let registrationQRCode: QRCodeKinit = try CKey.analyzeQR(qrValue)

// Проверяем активацию
if !qrCode.isActivated {
    let activatedQRCode = try CKey.activate(qrCodeKinit: qrCode, code: activationCode)
}

// Регистрируем
let createdUser = try await UsersManagerNonQual.createUserWithInitQR(
    qrCode: qrCode,                               // QR-код
    pushNotificationsData: pushNotificationsData, // Данные для отправки пуш-уведомлений
    deviceName: deviceName,                       // Отображаемое дружественное имя устройства
    externalId: externalId,                       // Внешний идентификатор
    alias: alias,                                 // Человекочитаемый идентификатор устройства
)

let storedUser = try await UsersManagerNonQual.store(
   user: user,        // Новый пользователь 
   name: name,        // Имя для хранения
   password: password // Пароль для хранения
)

let createdUser = try await UsersManagerNonQual.createUserWithApproval(
    serviceURL: serviceURL,                        // Адрес для взаимодействия существующего пользователя
    uid: userId,                                   // UserID существующего пользователя 
    pushNotificationsData: pushNotificationsData,  // Данные для отправки пуш-уведомлений
    deviceName: deviceName,                        // Отображаемое дружественное имя устройства
    externalId: externalId,                        // Внешний идентификатор
    alias: alias,                                  // Человекочитаемый идентификатор устройства
)

let storedUser = try await UsersManagerNonQual.store(
   user: user,        // Новый пользователь 
   name: name,        // Имя для хранения
   password: password // Пароль для хранения
)

// Получаем список устройств
let devices = try await DevicesManager.listDevices(
    user: user // Основной активный пользователь
)

// Находим неподтверждённое устройство
let notApprovedDevice = devices.first(where { $0.state == .approveRequired })

if !user.isReadyToSign {
    // Предъявляем пароль
    try UsersManagerNonQual.submitPassword(user: user, password: password)
}

// Подтверждаем присоединение
try await DevicesManagerNonQual.approve(
   device: notApprovedDevice,   // Устройство, ожидающее подтверждения
   user: user                   // Основной активный пользователь
)

// ... или отклоняем
try await DevicesManagerNonQual.reject(
   device: notApprovedDevice,   // Устройство, ожидающее подтверждения
   user: user                   // Основной активный пользователь
)

do {
    let approvedUser = try await UsersManagerNonQual.checkApprovalStatus(
        user: userToCheck // Новый пользователь
    ) 
} catch SDKError.approveRequired {
    ... // По-прежнему ожидаем подтверждение на основном устройстве
} catch { 
    ...
}

let devices = try await DevicesManager.listDevices(user: user)

// Проходим регистрацию на новом устройстве
let approvedUser = try await UsersManager.createUserWithApproval(
    serviceURL: serverURL,           // Адрес сервера СЭП
    uid: mainDeviceUserId,           // Идентификатор пользователя с основного устройства
    name: name,                      // Имя для сохранения учетной записи
    pushNotificationsData: data,     // Данные для отправки пуш-уведомлений
    deviceName: deviceName,          // Отображаемое дружественное имя устройства
    externalId: externalId,          // Внешний идентификатор
    alias: alias,                    // Человекочитаемый идентификатор устройства
    requirePassword: requirePwd,     // Требуется ли установка пароля
    statusCheckingInterval: interval // Интервал проверки присоединения устройства
)

// На основном устройстве потребуется подтвердить присоединение нового
try await DevicesManager.processAwaitingDevice(
    user: user  // Пользователь, к которому привязывается новое устройство
)

// Получаем массив сертификатов и запросов
let certificates = try await CertificatesManager.listCertificates(
    user: user // Пользователь, запрашивающий информацию
)

// Фильтруем выпущеные сертификаты
let issuedCertificates = certificates.filter { $0.type == .certificate }

// Получаем параметры сервера подписания
let signServerParams = try await PolicyManager.getSignServerParams(
    user: user  // Пользователь, запрашивающий параметры сервера подписания
)

...

// Подготавливаем параметры. Значения даны для примера
let policyId = signServerParams.caPolicies.first(where: { $0.caType == .DSSOutOfBandEnroll }).id
let templateId = policy.ekuTemplates.first?.value.first
let testDN = ["2.5.4.3": "Test"]

// Создаём запрос на сертификат
let certRequest = try await CertificatesManager.createCertificate(
    user: user,             // Пользователь, создающий запрос на сертификат
    dn: testDN,             // Различительное имя субъекта
    templateId: templateId, // Идентификатор шаблона сертификата
    caId: policyId          // Идентификатор обработчика УЦ
)

// Находим неподписаный запрос
let requestToSign = certificates.first {
    $0.type == .request && $0.isClient = true && $0.CertificateId == nil
}

// Подписываем
try await CertificatesManagerNonQual.sign(
    certificateRequest: requestToSign,
    user: user
)

// Отсеиваем сертификаты, недоступные на этом устройстве
// (например, у которых запрос был подписан на другом устройстве)
let availableCertificates = certificates
    .filter { $0.type == .certificate && CertificatesManagerNonQual.checkIfAccessibleOnThisDevice(certificate: $0, for: user) }

// Получаем неустановленные сертификаты
let certificateToInstall = availableCertificates
    .filter { $0.isClient && !CertificatesManagerNonQual.checkIfInstalled(certificate: $0, for: user) }
    .first

// Устанавливаем
try await CertificatesManagerNonQual.install(
    certificate: certificateToInstall,
    user: user
)

let operations = try await OperationsManager.getOperationsList(
    user: user,         // Пользователь, для которого проверяются операции
    operationType: nil, // Фильтр операций по типу
    operationID: nil    // Фильтр по идентификатору
)

let approveRequest = try await OperationsManager.confirmOperation(
    operation: operation,   // Операция для подтверждения
    user: user,             // Пользователь, подтверждающий операцию
    signMode: .online       // Способ подтверждения. В данном случае — online
)

let uploadedDocumentId = try await OperationsManager.uploadDocument(
    documentContent: documentData,      // Бинарные данные документа
    title: documentTitle,               // Заголовок документа
    snippetTemplate: documentSnippet,   // HTML-сниппет документа
    previewTemplate: documentPreview,   // HTML-превью документа
    user: user                          // Пользователь-владелец документа
)

// Формируем параметры подписания
let templateId = signServerParams.processingTemplates.first.id
let certificateId = certificate.CertificateId
let signParams = SignParams(
    signTemplateId: templateId, // Идентификатор шаблона подписи
    certId: certificateId,      // Идентификатор сертификата, которым будем подписывать
    pinCode: ""                 // Пин-код от сертификата. Если пин-код не установлен, то укажите пустую строку
)

// Подписываем и получаем результаты подписания
let signingResults = try await OperationsManager.signDocuments(
    documentsIDs: confirmedDocuments,           // Документы для подписания
    user: user,                                 // Пользователь, подписывающий документы
    signParams: signParams                      // Параметры подписания
)

// Получаем параметры сервера подписания
let signServerParams = try await PolicyManager.getSignServerParams(
    user: user  // Пользователь, запрашивающий параметры сервера подписания
)

...

// Получаем сертификат
let certificates = try await CertificatesManager.listCertificates(
    user: user  // Пользователь, запрашивающий сертификаты
)

...

// Выбираем сертификат, например, первый в списке. Запросы на сертификат игнорируем
let certificate: Certificate = certificates.first(where: {
    $0.type == .certificate
})

// Создание резервной копии
let userBackupData: Data = try UsersManagerNonQual.createBackup(
    user: user,
    recoveryPassword: recoveryPassword
)

// Восстановление
let restoredUser: User = try UsersManagerNonQual.restoreFromBackup(
    backupData: userBackupData,
    recoveryPassword: recoveryPassword
)

UsersManagerNonQual.store(
    user: restoredUser,
    name: username,
    password: password
) { storingResult in
    switch result {
        case let .success(storedUser):  // Сохранённый пользователь
        case let .failure(error): ...
    }
}

// Создание резервной копии
let keyBackupData: Data = try KeysManagerNonQual.createBackup(
    keyInfo: keyInfo,
    recoveryPassword: recoveryPassword
)

// Восстановление
let restoredKeyInfo: KeyInfo = try KeysManagerNonQual.restoreFromBackup(
    backupData: keyBackupData,
    recoveryPassword: recoveryPassword
)

// При подписи сертификата
try await CertificatesManagerNonQual.sign(
    certificateRequest: request,
    user: user,
    isExportable: true
)

// При создании ключей
let keyInfo = try KeysManagerNonQual.createKeyPair(
    for: user,
    pin: pin,
    isExportable: true
)

// Экспорт

// Получаем список сертификатов
let certificates = try await CertificatesManager.listCertificates(
user: user) 

// // Выбираем сертификат для экспорта
let certificateToExport = certificatesList.first {
    $0.type == .certificate &&
    !$0.isArchived &&
    CertificatesManagerNonQual.checkIfAccessibleOnThisDevice(certificate: $0, for: user)
}

// Выгружаем архив
try await CertificatesManagerNonQual.exportPfx(
    user: user,
    certificate: certificateToExport, // Сертификат, ключи которого архивируем
    pin: pin,    // Пин-код от контейнера ключей
    pfxPin: nil // Дополнительный пин-код, на котором будет зашифрован архив (опционально)
)

...

// Импорт

// Получаем список сертификатов
let certificates = try await CertificatesManager.listCertificates(
user: user) 

// Находим доступный для импорта сертификат
let archivedCertificate = certificatesList.first {
    $0.type == .certificate && 
    $0.isArchived
}

// Импортируем. После импорта на устройство будут загружены ключи
try await CertificatesManagerNonQual.importPfx(
    user: user,
    certificate: archivedCertificate,
    pin: newPin, // Новый пин-код для контейнера ключей
    pfxPin: nil // Пин-код для расшифрования архива
)

let userToRenew: User = ... // Пользователь, которого хотим обновить
let renewedUser = try await UsersManagerNonQual.renew(user: userToRenew)

https://.../ckey-nfc.git

pod 'CKey_NFC',           :git => 'https://.../ckey-nfc.git'

// Перечисление доступных сертификатов на карте
let certificatesResults = try await CertificatesManager.listExternalCertificates()

let certificateToImport = ... // Выбираем сертификат для импорта

// Загружаем сертификат на сервер
try await CertificatesManager.setCertificate(
    user: user,
    certificate: certificateToImport
)

// Подписываем запрос на сертификат
try await CertificatesManagerNonQual.sign(
    certificateRequest: certificateRequest,
    user: user,
    keysSource: .rutokenNFC // Используем NFC-токен Рутокен
)

// Получаем список сертификатов
let certificates = CertificatesManager.listCertificates(...)

// Проверяем, выпущен ли сертификат
let certificateToInstall: Certificate = certificates.first {
    // Сертификат активный
    $0.state == .active && 
    // Ключи хранятся на клиенте
    $0.isClient &&
    // Ключи хранятся на текущем устройстве
    CertificatesManagerNonQual.checkIfAccessibleOnThisDevice(certificate: $0, for: user) &&
    // Сертификт не установлен
    !CertificatesManagerNonQual.checkIfInstalled(certificate: $0, for: user)
} 

// Устанавливаем выпущеный сертификат
try await CertificatesManagerNonQual.install(
    certificate: certificateToInstall,
    user: user
)

public protocol LoggerProtocol {

    func debug(_ message: String, category: LoggingCategory)
    func error(_ message: String, category: LoggingCategory)
    func sensitive(_ message: String, category: LoggingCategory)

}


/// Пример логгера

struct MyLogger: LoggerProtocol {

    func debug(_ message: String, category: LoggingCategory) {
        ...
    }

    func error(_ message: String, category: LoggingCategory) {
        ...
    }

    func sensitive(_ message: String, category: LoggingCategory) {
        ...
    }

}

let myLogger = MyLogger()
// CKey.setLogLevels([.debug, .keys]) <- Теперь можно убрать из кода приложения
CKey.setLogger(myLogger, options: [.debug, .sensitive])

import CocoaLumberjack
import CocoaLumberjackSwift

...

// Настраиваем CocoaLumberjack
let fileLogger = DDFileLogger()
fileLogger.logFileManager.maximumNumberOfLogFiles = 2  // Храним только 2 файла
fileLogger.maximumFileSize = 256 * 1024                // не более 256kb каждый
fileLogger.rollingFrequency = 60 * 60 * 24             // с сообщениями за последние 24 часа
DDLog.add(fileLogger)

...

// Описываем методы логгера
final class MyLogger: LoggerProtocol {

    func debug(_ message: String, category: LoggingCategory) {
        DDLogInfo("[SDK][\(category)] \(message)")
    }

    func error(_ message: String, category: LoggingCategory) {
        DDLogError("[SDK][\(category)] \(message)")
    }

    func sensitive(_ message: String, category: LoggingCategory) {
        #if DEBUG
        DDLogInfo("[SDK][Sensitive][\(category)] \(message)")
        #endif
    }

}

...

// Назначаем логгер
CKey.setLogger(MyLogger(), options: [.debug, .sensitive])

fileLogger
    .logFileManager
    .sortedLogFileInfos
    .compactMap { (info: DDInfo) -> Data in
        FileManager.default.contents(atPath: info.filePath) // Читаем логи из файла
    }
    .forEach { (logData: Data) in
        ... // Обрабатываем логи каждого файла
    }