[{"content":"LibreMiddleware испоручује нативни C++ engine за дигитално потписивање који подржава пет формата потписа, четири нивоа усклађености и хардверско потписивање преко PKCS#11. Овај водич показује спољним корисницима како да га интегришу кроз јавни LibreSCRS::Signing API.\nСам engine за потписивање живи у интерној libresign библиотеци испод lib/libresign/ — свако заглавље тамо је закључано преко LIBRESCRS_INTERNAL_BUILD и није део подржане корисничке површине. Спољни код линкује против LibreSCRS::Signing CMake алијаса и укључује само заглавља испод \u0026lt;LibreSCRS/Signing/…\u0026gt;.\nФормати и нивои потписа #Engine производи потписе у складу са EU eIDAS / ETSI baseline профилима:\nФормат Стандард Улаз Излаз Паковање PAdES ETSI EN 319 142 PDF Потписан PDF Enveloped CAdES ETSI EN 319 122 Било која датотека .p7s (PKCS#7/CMS) Detached XAdES ETSI EN 319 132 Било која датотека .xml (XML-DSIG) Enveloped или detached JAdES ETSI EN 319 182 Било која датотека .json (JWS) Detached ASiC-E ETSI EN 319 162 Било која датотека(е) .asice (ZIP контејнер) Detached (XAdES унутра) Сваки формат подржава четири нивоа растуће сигурности:\nНиво Садржај Захтева B-B Основни потпис Само сертификат за потписивање B-T B-B + временски печат TSA сервер B-LT B-T + подаци о опозиву (CRL/OCSP) TSA + извори опозива B-LTA B-LT + архивски временски печат TSA + извори опозива CMake интеграција #LibreMiddleware је дизајниран за коришћење преко CMake FetchContent. Подршка за потписивање је подразумевано укључена. Тагови користе голи X.Y.Z облик (без v префикса):\ninclude(FetchContent) FetchContent_Declare( LibreMiddleware GIT_REPOSITORY https://github.com/LibreSCRS/LibreMiddleware.git GIT_TAG 4.0.0 ) FetchContent_MakeAvailable(LibreMiddleware) target_link_libraries(MyApp PRIVATE LibreSCRS::Signing LibreSCRS::Trust LibreSCRS::Plugin LibreSCRS::SmartCard LibreSCRS::Auth ) За локални развој усмерите на локалну копију уместо преузимања са Git-а:\ncmake -B build -DFETCHCONTENT_SOURCE_DIR_LIBREMIDDLEWARE=/path/to/LibreMiddleware Опције изградње # Опција Подразумевано Опис BUILD_SIGNING ON Укључује подршку за дигитално потписивање (LibreSCRS::Signing) SIGNING_BACKEND native Избор backend-а: native, dss или both. DSS backend је тест оracле и застарео је за продукциону употребу Изградња извози LIBREMIDDLEWARE_HAS_SIGNING тако да спољни пројекти могу условно да компајлирају функционалности потписивања.\nМинималан пример потписивања #Пример испод обавља комплетан PAdES B-T потпис против картице коју је открио регистар додатака. Користи само јавни API — сваки include је из \u0026lt;LibreSCRS/…\u0026gt;.\n#include \u0026lt;LibreSCRS/Auth/CredentialProvider.h\u0026gt; #include \u0026lt;LibreSCRS/Plugin/CardPluginService.h\u0026gt; #include \u0026lt;LibreSCRS/Secure/String.h\u0026gt; #include \u0026lt;LibreSCRS/Signing/SigningRequest.h\u0026gt; #include \u0026lt;LibreSCRS/Signing/SigningResult.h\u0026gt; #include \u0026lt;LibreSCRS/Signing/SigningService.h\u0026gt; #include \u0026lt;LibreSCRS/Signing/TsaProvider.h\u0026gt; #include \u0026lt;LibreSCRS/SmartCard/CardSession.h\u0026gt; #include \u0026lt;LibreSCRS/SmartCard/MonitorService.h\u0026gt; #include \u0026lt;LibreSCRS/Trust/TrustConfig.h\u0026gt; #include \u0026lt;LibreSCRS/Trust/TrustStoreService.h\u0026gt; #include \u0026lt;iostream\u0026gt; namespace lsc = LibreSCRS; int main() { // 1. Конструишите trust store. Фабрика је noexcept и враћа употребљив // сервис чак и када је мрежа недоступна — пакетски и (опционо) // системски анкори су одмах доступни, док eager Trusted-List // преузимања раде на интерним радним нитима. lsc::Trust::TrustConfig trustConfig; trustConfig.cacheDirectory = \u0026#34;/var/cache/myapp/tl-cache\u0026#34;; // trustConfig.sources.push_back({...}); // опционо EU LOTL / национални TL-ови auto trustResult = lsc::Trust::TrustStoreService::create(std::move(trustConfig)); if (!trustResult) { std::cerr \u0026lt;\u0026lt; \u0026#34;Trust store init failed: \u0026#34; \u0026lt;\u0026lt; trustResult.error().userMessage.defaultText \u0026lt;\u0026lt; \u0026#39;\\n\u0026#39;; return 1; } std::shared_ptr\u0026lt;lsc::Trust::TrustStoreService\u0026gt; trust = *trustResult; // 2. Конструишите SigningService. TsaProvider се позива у време // потписивања за нивое B-T / B-LT / B-LTA; staticTsa() је // помоћна фабрика која увек враћа исти URL без аутентификације. // Прослеђивањем подразумевано конструисаног TsaProvider{} се // искључује TSA — B-B потписивање и даље ради, а виши нивои тада // падају са Status::TsaUnreachable. auto tsa = lsc::Signing::staticTsa(\u0026#34;http://timestamp.digicert.com\u0026#34;); auto signingService = std::make_shared\u0026lt;lsc::Signing::SigningService\u0026gt;(trust, std::move(tsa)); // 3. Откријте card plugin + отворите сесију. CardPluginService скенира // конфигурисани директоријум додатака; MonitorService прати PC/SC // догађаје. Праве апликације се претплаћују на MonitorService и // позивају findPluginForCard(atr) када картица стигне; помоћник // испод сажима тај след у један app-specific корак. lsc::Plugin::CardPluginService plugins{\u0026#34;/usr/local/lib/librescrs/plugins\u0026#34;}; lsc::SmartCard::MonitorService monitor; auto session = openFirstSession(monitor, plugins); // помоћник специфичан за апликацију if (!session) { std::cerr \u0026lt;\u0026lt; \u0026#34;No card available\\n\u0026#34;; return 1; } auto atr = session-\u0026gt;atr(); // std::span\u0026lt;const std::uint8_t\u0026gt; auto cardPlugin = plugins.findPluginForCard(atr); if (!cardPlugin) { std::cerr \u0026lt;\u0026lt; \u0026#34;Ниједан додатак не одговара ATR-у ове картице\\n\u0026#34;; return 1; } // 4. Изградите захтев за потписивање. Engine чита из inputFile и // пише потписан излаз у outputFile — не постоји улаз преко // бафера бајтова на јавном API-ју. auto request = lsc::Signing::SigningRequest::Builder{} .inputFile(\u0026#34;document.pdf\u0026#34;) .outputFile(\u0026#34;document-signed.pdf\u0026#34;) .format(lsc::Signing::SignatureFormat::Pades) .level(lsc::Signing::SignatureLevel::B_T) .build(); // 5. PIN провајдер — позива га сервис када картица захтева PIN. // Провајдер прима AuthRequirement који описује шта да прикупи и // враћа CredentialResult. У GUI хосту ово обично отвара PIN // дијалог; у batch алатима чита из сигурног упита или env // променљиве. lsc::Auth::CredentialProvider pinProvider = [](const lsc::Auth::AuthRequirement\u0026amp;) { lsc::Secure::String pin{\u0026#34;1234\u0026#34;}; // хост прикупља, нулира се при уништавању return lsc::Auth::CredentialResult::ok({{\u0026#34;pin\u0026#34;, std::move(pin)}}); }; // 6. Потпишите. Позив блокира за време трајања операције (PIN // верификација + APDU потпис на картици + опционо TSA повратно // путовање). GUI хостови ово покрећу на радној нити. auto result = signingService-\u0026gt;sign(request, std::move(pinProvider), cardPlugin, session); if (result.status != lsc::Signing::SigningResult::Status::Ok) { std::cerr \u0026lt;\u0026lt; \u0026#34;Signing failed: \u0026#34; \u0026lt;\u0026lt; result.userMessage.defaultText \u0026lt;\u0026lt; \u0026#39;\\n\u0026#39;; return 1; } // 7. Успех — потписан документ је на диску на путањи на коју је // engine писао (тј. outputFile() са којим је захтев изграђен). std::cout \u0026lt;\u0026lt; \u0026#34;Signed: \u0026#34; \u0026lt;\u0026lt; result.outputPath-\u0026gt;string() \u0026lt;\u0026lt; \u0026#39;\\n\u0026#39;; return 0; } Референца API-ја #Сви јавни типови живе под LibreSCRS::* PascalCase именским просторима. Сваки тип поменут испод има пуни Doxygen уговор у одговарајућем заглављу испод include/LibreSCRS/.\nLibreSCRS::Signing::SigningService #Јавна улазна тачка. Конструише се једном са власником животног циклуса поверења и TSA callback-ом; поново се користи за више sign() позива.\nКонструкција:\nSigningService(std::shared_ptr\u0026lt;Trust::TrustStoreService\u0026gt; trustService, TsaProvider tsa); Позив потписивања (4 аргумента, [[nodiscard]]):\nSigningResult sign(const SigningRequest\u0026amp; request, Auth::CredentialProvider credentialProvider, std::shared_ptr\u0026lt;Plugin::CardPlugin\u0026gt; cardPlugin, std::shared_ptr\u0026lt;SmartCard::CardSession\u0026gt; session); Позив је блокирајући и thread-safe преко различитих (cardPlugin, session) парова. Null plugin или session, или празан credentialProvider, враћају SigningResult::Status::InvalidRequest уместо бацања изузетка.\nLibreSCRS::Trust::TrustStoreService #Власник животног циклуса trust store-а. Фабрика је noexcept и враћа std::expected\u0026lt;std::shared_ptr\u0026lt;TrustStoreService\u0026gt;, CreateError\u0026gt;. Eager Trusted-List преузимања раде на интерним радним нитима; корисници посматрају завршетак преко status(), addObserver() или блокирајућег waitForEagerFetches().\nLibreSCRS::Signing::SigningRequest #Непроменљиви параметри потписивања, граде се преко угнежденог Builder-а. Engine је заснован на путањама фајлова — проследите inputFile() и outputFile(); не постоји overload са бафером бајтова на јавном API-ју. Кључне методе builder-а:\nМетода builder-а Опис inputFile(std::filesystem::path) Изворни документ на диску outputFile(std::filesystem::path) Одредишна путања на коју engine пише format(SignatureFormat) Pades / Cades / Xades / Jades / AsicE level(SignatureLevel) B_B / B_T / B_LT / B_LTA packaging(PackagingMode) Enveloped или Detached reason / location / contactInfo Поља PDF речника потписа (ISO 32000-1 §12.8.1) certificateLabel(std::string) PKCS#11 алијас кључа када картица носи више од једног visualParams(VisualSignatureParams\u0026amp;\u0026amp;) PAdES визуелни потпис tsaOverride(TsaProvider) TSA override по захтеву; упарите са staticTsa(url) за фиксни URL Builder::build() је rvalue-квалификован; финализујте са std::move(builder).build() и обмотајте позив у try/catch за std::invalid_argument ако поља постављате условно.\nLibreSCRS::Signing::SigningResult # Поље Тип Опис status Status enum Увек постављен; проверите пре читања осталих поља outputPath std::optional\u0026lt;std::filesystem::path\u0026gt; Путања на коју је потписан документ записан при успеху userMessage LocalizedText Translator-friendly порука за корисника; обавезна у 4.0 diagnosticDetail std::optional\u0026lt;std::string\u0026gt; Дијагностика за развојне логове Вредности Status: Ok, InvalidRequest, TrustStoreUnavailable, UserCancelled, PinVerificationFailed, CardBlocked, TsaUnreachable, SigningEngineError. Енумерација је append-only; switch код потрошача мора да укључује default грану.\nLibreSCRS::Auth::CredentialProvider #SyncProvider\u0026lt;CredentialResult, AuthRequirement\u0026gt; — callable који обезбеђује хост, мапира AuthRequirement (шта картица треба) у CredentialResult (попуњени креденцијали, корисничко поништавање или грешка провајдера). Сервис за потписивање позива провајдер највише једном по откључавању картице.\nLibreSCRS::Plugin::CardPlugin и LibreSCRS::SmartCard::CardSession #Plugin покреће операције специфичне за картицу (APDU потписа, проналазак кључа) и добија се из CardPluginService-а. Сесија енкапсулира отворени PC/SC канал и добија се било преко монитора, било директно преко CardSession::open(readerName, plugin). Сервис за потписивање држи дељено власништво над обоје за време трајања позива.\nPKCS#11 подршка #Engine за потписивање приступа приватним кључевима кроз CardPlugin / CardSession апстракцију. Испод хаубе, слој додатака разговара са картицом преко LibreSCRS PKCS#11 модула (librescrs-pkcs11.so) плус одговарајућих драјвера специфичних за картицу — CardEdge, PKCS#15, PIV или OpenSC.\nСпољни корисници који већ директно покрећу PKCS#11 модул могу то да раде независно од LibreSCRS::Signing; јавни API за потписивање у 4.0 намерно је PKCS#11-агностичан на споју (plugin + session).\nPIN никада не опстаје преко sign() позива — испоручује се картици преко CredentialProvider-а (за који се очекује да хост обезбеди подршком за нулирање при уништавању као што су LibreSCRS::Secure::Buffer / LibreSCRS::Secure::String) и одмах одбацује после C_Login-а.\nТолеранција PDF улаза #За PAdES потписивање, engine прати Adobe Acrobat Implementation Notes §H.3 при обради PDF улаза, чиме се понаша исто као Acrobat, Foxit, qpdf и pdfinfo:\nДо 1024 бајта не-PDF префикса пре %PDF- заглавља се толеришу и уклањају (нпр. multipart/form-data омотачи из веб форми). Пратећи подаци после последњег %%EOF се уклањају (опциони један CR/LF се задржава). Када startxref показује на offset на ком се не налази xref кључна реч (често након уклањања префикса или због грешке генератора), engine прелази на резервно скенирање последњих ~10 KB у потрази за самосталном xref кључном речју и поново покушава. Ако првих 1024 бајта не садрже %PDF- заглавље, улаз се и даље одбија са структурираним InvalidRequest резултатом. Нису потребне измене у позивном коду — толеранција се примењује интерно током PAdES обраде.\nРуковање грешкама #SigningService::sign() враћа SigningResult уместо да баца изузетке. Проверите result.status и result.userMessage у случају неуспеха:\nauto result = signingService-\u0026gt;sign(request, pinProvider, cardPlugin, session); if (result.status != LibreSCRS::Signing::SigningResult::Status::Ok) { using S = LibreSCRS::Signing::SigningResult::Status; switch (result.status) { case S::TrustStoreUnavailable: /* TL преузимање / конфиг одбијен */ break; case S::InvalidRequest: /* null plugin/session, празан cb */ break; case S::UserCancelled: /* провајдер је вратио cancel */ break; case S::PinVerificationFailed: /* погрешан PIN */ break; case S::CardBlocked: /* PIN за потписивање је блокиран */ break; case S::TsaUnreachable: /* B-T+ захтеван, TSA није успео */ break; case S::SigningEngineError: /* libresign / APDU цевовод */ break; default: break; // append-only enum; задржите default } log(result.userMessage.defaultText); if (result.diagnosticDetail) { log(*result.diagnosticDetail); } } TrustStoreService::create() је слично [[nodiscard]] noexcept и враћа std::expected\u0026lt;…, CreateError\u0026gt;. Провера резултата унапред чини путеве грешке експлицитним; ниједан изузетак никада не пропагира преко јавне API површине.\n","date":null,"permalink":"https://librescrs.github.io/sr/developer-guide/signing-integration/","section":"Водич за програмере","summary":"","title":"Водич за интеграцију потписивања"},{"content":"Ова страница описује интерну архитектуру LibreMiddleware engine-а за потписивање за контрибуторе који желе да разумеју како систем функционише, додају нове формате потписа или дебагују проблеме са потписивањем.\nЖелите да користите engine за потписивање из сопствене апликације? Јавни спој је LibreSCRS::Signing::SigningService — погледајте Водич за интеграцију потписивања. Остатак ове странице покрива оно што живи иза тог споја.\nЈавни спој: LibreSCRS::Signing #Спољни корисници никада не дотичу libresign::*. Линкују против LibreSCRS::Signing и позивају:\nSigningService(std::shared_ptr\u0026lt;Trust::TrustStoreService\u0026gt;, TsaProvider); SigningResult sign(const SigningRequest\u0026amp;, Auth::CredentialProvider, std::shared_ptr\u0026lt;Plugin::CardPlugin\u0026gt;, std::shared_ptr\u0026lt;SmartCard::CardSession\u0026gt;); LibreSCRS::Signing::SigningService је танка pimpl-подржана фасада која извршава валидацију захтева, резолвује снимак поверења из ињектованог TrustStoreService-а, покреће провајдер креденцијала и прослеђује интерном libresign::SigningService-у. libresign типови описани испод доступни су само кроз ову фасаду.\nЖивотни циклус поверења (4.0): LibreSCRS::Trust::TrustStoreService #Подсистем поверења има сопственог власника животног циклуса, одвојеног од потписивања. TrustStoreService::create(TrustConfig) је [[nodiscard]] noexcept и враћа std::expected\u0026lt;std::shared_ptr\u0026lt;TrustStoreService\u0026gt;, CreateError\u0026gt;. Фабрика синхроно гради локални скуп анкора (пакетски thirdparty/certs/ + опционо системски root store) и покреће сва конфигурисана Trusted-List преузимања на интерним радним нитима. Сервис за потписивање држи shared_ptr\u0026lt;TrustStoreService\u0026gt; за цео свој животни циклус, тако да eager TL преузимања попуњавају исти TrustStore који sign() посматра; лења преузимања током sign() позива се спајају у исти store, обезбеђујући да прегледач сертификата, регистар додатака и сервис за потписивање сви деле исти универзум поверења.\nКорисници посматрају напредак преузимања кроз три ортогонална механизма:\nstatus() враћа снимак AggregateStatus (Loading / Ready / Degraded). addObserver(cb) региструје callback за прелазе стања — пут пријатељски за GUI. waitForEagerFetches(deadline, token) блокира док се сваки eager извор не реши; намењено тестовима, CLI алатима и хеадлес корисницима. Сервис је move-онемогућен и дели се преко референце, тако да исти универзум поверења природно конзумира више сервиса за потписивање или нон-сигнинг алата (прегледач сертификата, регистар додатака) у истом процесу.\nТок потписивања од почетка до краја #Комплетан ток од корисничке акције до потписаног документа:\n1. Корисник кликне „Потпиши\u0026#34; у LibreCelik-у └─ SignPage чаробњак прикупља: документ, формат, ниво, TSA, визуелне параметре 2. LibreCelik гради SigningRequest и позива SigningService::sign() └─ PIN прослеђен као span\u0026lt;const uint8_t\u0026gt; из SecureBuffer-а 3. NativeSigningService::sign() ├─ Отвара Pkcs11Token (учитава PKCS#11 модул, пријављује се PIN-ом) ├─ Чита сертификат за потписивање + ланац са токена └─ Прослеђује format модулу на основу request.format 4. Format модул (нпр. PAdESModule::sign()) ├─ Припрема контејнер потписа (PDF инкрементално чување, CMS, XML, JSON или ZIP) ├─ Рачуна digest документа (SHA-256) ├─ Позива Pkcs11Token::sign(hash) → сирови бајтови потписа са картице ├─ Уграђује потпис + ланац сертификата у контејнер └─ Ако је ниво \u0026gt;= B-T: позива TSAClient::timestamp(hash) └─ Шаље RFC 3161 захтев TSA серверу └─ Уграђује TimeStampToken у потпис 5. Ако је ниво \u0026gt;= B-LT: ├─ RevocationClient преузима CRL + OCSP одговоре за ланац сертификата └─ Format модул уграђује податке о опозиву у потпис 6. Ако је ниво == B-LTA: └─ Архивски временски печат додат преко целокупног потписа + података о опозиву 7. NativeSigningService враћа SigningResult { success, signedDocument } 8. LibreCelik чува потписан документ на диск Структура модула #Engine за потписивање налази се у lib/libresign/ унутар LibreMiddleware-а. Организован је у три слоја.\nЈавна заглавља живе под include/libresign/ (типови највишег нивоа) и include/libresign/native/ (класе native backend-а). Имплементације и интерни помоћници backend-а живе под src/.\nСлој основног сервиса # Фајл Намена include/libresign/signing_service.h SigningService апстрактни интерфејс — configure(), sign(), isAvailable() include/libresign/signing_service_factory.h Фабричка функција createSigningService(Backend) include/libresign/types.h Типови података: SigningRequest, SigningResult, TrustConfig, TSAConfig, енумерације include/libresign/trust_store_manager.h TrustStoreManager — агрегира системске, пакетске и TL-изведене сертификате за различите потрошаче Format модули #Сваки формат потписа имплементиран је као независан модул. Сви модули прате исти образац: примају документ + сертификат + callback за потписивање, производе потписане излазне бајтове.\nМодул Фајл Стандард PAdES src/native/pades_module.cpp PDF инкрементално чување са CMS потписом CAdES src/native/cades_module.cpp Detached CMS/PKCS#7 потпис XAdES src/native/xades_module.cpp XML Digital Signature са XAdES својствима JAdES src/native/jades_module.cpp JSON Web Signature са JAdES заглављем ASiC-E src/native/asic_module.cpp ZIP контејнер са XAdES потписом (користи miniz) Format модули примају Pkcs11Token\u0026amp; референцу за операције потписивања. Token интерно управља PKCS#11 сесијом, претрагом кључева и сировим потписивањем.\nИнфраструктура # Компонента Фајлови Намена Pkcs11Token include/libresign/native/pkcs11_token.h + src/native/pkcs11_token.cpp Управљање PKCS#11 сесијом — учитавање модула, пријава, претрага кључева, сирово потписивање, екстракција сертификата TSAClient include/libresign/native/tsa_client.h + src/native/tsa_client.cpp RFC 3161 захтеви за временске печате преко HTTP-а (libcurl) RevocationClient include/libresign/native/revocation_client.h + src/native/revocation_client.cpp Преузимање CRL-ова и OCSP-а за B-LT/B-LTA нивое SigningProvider include/libresign/native/signing_provider.h + src/native/signing_provider.cpp Апстракција над Pkcs11Token за спољне кориснике TrustedListParser include/libresign/native/trusted_list_parser.h + src/native/trusted_list_parser.cpp XML парсер за EU Trusted Lists (LOTL и TL) TlCache (интерни) src/native/tl_cache.h/.cpp Кеш на диску за преузете Trusted List XML фајлове TlSignatureVerifier (интерни) src/native/tl_signature_verifier.h/.cpp XML-DSIG верификација потписа Trusted List-а PinnedTlCerts (интерни) src/native/pinned_tl_certs.h/.cpp Компајлирани LOTL сертификати за потпис који служе као корен поверења PDF parser (интерни) src/native/pdf_parser.h/.cpp Минималан PDF парсер за PAdES инкрементално чување — проналази xref, додаје речник потписа OpenSSL RAII (интерни) src/native/openssl_raii.h RAII омотачи за OpenSSL типове (BIO, X509, EVP_PKEY, итд.) Модел поверења #Engine за потписивање користи модел поверења са три нивоа за валидацију сертификата:\nНиво 1: Системски сертификати #Подразумевано складиште сертификата оперативног система. Користи се као корен поверења за TLS конекције (TSA, CRL/OCSP крајње тачке) и као резервна опција за изградњу ланца сертификата.\nНиво 2: Пакетски сертификати #Сертификати испоручени са LibreMiddleware-ом у thirdparty/certs/. Укључују корене CA сертификате за српску државну PKI инфраструктуру који можда нису у системским складиштима. Користе се за верификацију ланца сертификата са картице.\nНиво 3: Сертификати изведени из листа поверења #Сертификати екстрактовани из EU Trusted Lists (TL/LOTL). Engine преузима и парсира EU List of Trusted Lists, прати линкове ка националним листама поверења и екстрактује CA сертификате за потписивање. Користе се за B-LT и B-LTA валидацију — обезбеђују сидра поверења која повезују сертификат потписника са EU-признатим пружаоцем услуга поверења.\nЛанац аутентификације: Сам LOTL је потписан. Engine верификује потпис LOTL-а користећи приквачене сертификате (pinned_tl_certs.cpp) који су компајлирани у библиотеку. Национални TL-ови се верификују користећи сертификате пронађене у LOTL-у. Ово ствара ланац: приквачени сертификат верификује потпис LOTL-а, LOTL обезбеђује сертификате који верификују потписе националних TL-ова, национални TL-ови обезбеђују сертификате пружалаца услуга поверења.\nПриквачени LOTL сертификати за потписивање (компајлирани) └─ верификују → потпис EU LOTL XML-а └─ садржи → сертификате за потписивање националних TL-ова └─ верификују → потписе националних TL XML-ова └─ садрже → сертификате пружалаца услуга поверења └─ валидирају → ланац сертификата потписника DSS oracle за валидацију #Пројекат укључује DSS (Digital Signature Services) backend који се може користити као oracle за валидацију у тестовима. DSS је EU референтна имплементација за креирање и валидацију потписа, коју одржава Европска комисија.\nШта ради: DSS backend делегира потписивање покренутом DSS серверу преко REST API-ја. Ово је корисно за унакрсну валидацију да су потписи произведени нативним engine-ом прихваћени од стране EU референтне имплементације.\nКоришћење у тестовима: Када је постављено SIGNING_BACKEND=both, тестови могу креирати потпис нативним backend-ом и валидирати га DSS-ом или обрнуто. Ово открива суптилне проблеме усклађености формата које сами unit тестови не би ухватили.\nНапомена: DSS backend је застарео за продукциону употребу. Постоји искључиво као тест oracle. Native backend је продукциони engine за потписивање.\nТок података: LibreCelik ка LibreMiddleware #LibreCelik (GUI) и LibreMiddleware (engine) су одвојени пројекти са чистом границом. Ево како подаци за потписивање прелазе ту границу:\n┌─────────────────────────────────────────────────┐ │ LibreCelik (GUI) │ │ │ │ ┌────────────┐ ┌──────────────────────────┐ │ │ │ SignPage │───▶│ SigningRequest │ │ │ │ (чаробњак) │ │ ┌─ бајтови документа │ │ │ │ │ │ ├─ формат (PAdES/CAdES/..)│ │ │ │ Прикупља: │ │ ├─ ниво (B-B/B-T/..) │ │ │ │ - путања │ │ ├─ TSA URL │ │ │ │ - формат │ │ ├─ параметри виз. потписа │ │ │ │ - ниво │ │ └─ PIN (SecureBuffer) │ │ │ │ - PIN │ └──────────┬───────────────┘ │ │ └────────────┘ │ │ │ ▼ │ ├───────────────────────────────┬──────────────────┤ │ LibreMiddleware │ │ │ │ │ │ ┌────────────────────────────▼───────────────┐ │ │ │ NativeSigningService │ │ │ │ │ │ │ │ ┌──────────────┐ ┌───────────────────┐ │ │ │ │ │ Pkcs11Token │ │ Format модул │ │ │ │ │ │ (I/O картице)│ │ (PAdES/CAdES/..) │ │ │ │ │ └──────┬───────┘ └────────┬──────────┘ │ │ │ │ │ сирови потпис │ потписан док. │ │ │ │ ▼ ▼ │ │ │ │ ┌──────────────────────────────────────┐ │ │ │ │ │ SigningResult { success, bytes, err } │ │ │ │ │ └──────────────────────────────────────┘ │ │ │ └────────────────────────────────────────────┘ │ └──────────────────────────────────────────────────┘ Кључне пројектне одлуке:\nБез Qt зависности — целокупан engine за потписивање је чист C++23 без Qt типова. LibreCelik конвертује између Qt типова (QString, QByteArray) и стандардних типова (std::string, std::vector\u0026lt;uint8_t\u0026gt;) на граници. Без познавања протокола картице — engine за потписивање не шаље APDU команде и не зна за типове картица. Сав приступ картици иде кроз PKCS#11, који је стандардни интерфејс који сваки компатибилан токен може да задовољи. PIN се никада не чува — PIN путује као span\u0026lt;const uint8_t\u0026gt; који не поседује меморију, од SecureBuffer-а GUI-ја кроз C_Login позив PKCS#11. Ниједна међукопија не опстаје након повратка из позива. Format модули су без стања — сваки sign() позив је самосадржан. Нема стања сесије између позива, што engine чини безбедним за конкурентно коришћење из више нити. Додавање новог формата потписа #За додавање новог format модула:\nКреирајте include/libresign/native/newformat_module.h и src/native/newformat_module.cpp Имплементирајте sign() функцију која прима документ, Pkcs11Token\u0026amp; и параметре специфичне за формат Региструјте формат у NativeSigningService::sign() додавањем случаја за нову SignatureFormat enum вредност Додајте нову enum вредност у SignatureFormat у types.h Додајте изворне фајлове у lib/libresign/CMakeLists.txt Напишите тестове — користите DSS oracle (SIGNING_BACKEND=both) за валидацију усклађености формата ","date":null,"permalink":"https://librescrs.github.io/sr/developer-guide/signing-architecture/","section":"Водич за програмере","summary":"","title":"Архитектура потписивања"},{"content":"LibreSCRS — Libre Smart Card Reader System #Слободни алати за смарт картице за Linux и macOS.\nISO 7816 · PC/SC · PKCS#11 · PKCS#15 · ICAO 9303 · NIST PIV · BSI TR-03110\nПочните овде За програмере Читајте било коју картицу #Графички читач смарт картица са подршком за плагинове. Пасоши, е-пасоши, лична карта, саобраћајна дозвола, PIV и друге PKI картице.\nПроширите плагиновима #Направите middleware и GUI плагинове за нове типове картица. Архитектура заснована на стандардима, писана у савременом C++-у (C++23 middleware, C++20 GUI).\nПодржите LibreSCRS #Помозите да алати за смарт картице остану бесплатни и отворени.\nПодржите пројекат Лиценца # LibreCelik: GPL-3.0-or-later LibreMiddleware: LGPL-2.1-or-later ","date":null,"permalink":"https://librescrs.github.io/sr/","section":"","summary":"","title":""},{"content":"LibreSCRS 4.0.0 је данас објављен. Након два кандидата за издање и опсежног тестирања у заједници на Linux, macOS и Windows платформама, и LibreMiddleware 4.0.0 и LibreCelik 4.0.0 носе GPG-потписане git тагове и cosign-потписане артефакте издања.\nШта 4.0 доноси # C++23 језгро са std::expected API-јем за фабрике које могу да омане, LocalizedText i18n метаподацима, и CancelToken-ом за кооперативно отказивање. Нативно PAdES / XAdES / JAdES / CAdES / ASiC-E потписивање кроз LibreSCRS::Signing::SigningService — без екстерног демона. Аутоматско прилагођавање визуелног потписа (layoutVisualSignature) — преглед у чаробњаку се пиксел-тачно поклапа са уграђеним PAdES излазом. RFC 5280 ланац поверења са eIDAS qcStatements конформацијом. eMRTD PACE за безконтактно читање пасоша; CardEdge, PKCS#15, PIV провајдери; OpenSC фолбек у card-plugin путу. Уграђени CardEdge OpenSC спољни драјвер за OpenSC 0.26.1 и 0.27.1, у одвојеном tarball-у, док upstream OpenSC не угради srbeid драјвер у нумерисано издање. Познат проблем — рутирање PIN-а између вишеструких картица #Када су више српских паметних картица истовремено убачене и корисник покрене ток потписивања, PIN захтев може бити асоциран са другачијим слотом од оног који поседује изабрани сертификат. Конфигурације са једном картицом нису погођене. Поправка је архитектурална — Card+Slot модел — и главна је новина 4.1.0, већ имплементирана на развојној грани.\nПреузимања # LibreMiddleware 4.0.0 издање LibreCelik 4.0.0 издање Сви артефакти долазе са .sigstore.json cosign потписима; провера: cosign verify-blob --bundle \u0026lt;name\u0026gt;.sigstore.json \u0026lt;name\u0026gt;.\n","date":null,"permalink":"https://librescrs.github.io/sr/news/2026-05-librescrs-4-0-0/","section":"News","summary":"LibreMiddleware 4.0.0 + LibreCelik 4.0.0 објављени. C++23 језгро, ABI v6, нативно PAdES/XAdES/JAdES/CAdES/ASiC-E потписивање, RFC 5280 ланац поверења, eMRTD PACE, лична карта Србије + AET SafeSign + ГЕО тестна + PIV + генеричке PKCS#15 картице.","title":"LibreSCRS 4.0.0 — прво стабилно издање 4.0 циклуса"},{"content":"","date":null,"permalink":"https://librescrs.github.io/sr/news/","section":"News","summary":"","title":"News"},{"content":"","date":null,"permalink":"https://librescrs.github.io/sr/categories/","section":"Categories","summary":"","title":"Categories"},{"content":"Нативна OpenSC подршка #srbeid драјвер за српске смарт картице је интегрисан у главну грану OpenSC-а. Српска лична карта (Gemalto 2014+, IF2020 за странце) и ПКС картице Привредне коморе биће подржане из кутије у следећем издању OpenSC-а.\nАко компајлирате OpenSC из изворног кода (main грана), нативна подршка је већ доступна — без екстерног драјвера или конфигурације.\nЕкстерни драјвер #За кориснике на тренутним издањима OpenSC-а (0.26.x, 0.27.x) која још не укључују нативни srbeid драјвер, LibreSCRS пружа екстерни модул. Када се инсталира, свака PKCS#11 апликација може транспарентно користити српске личне картице и ПКС картице преко OpenSC PKCS#11 моста.\nПодржане картице:\nЛична карта Gemalto (2014+) — препознавање по ATR 3B:FF:94 Лична карта IF2020 за странце — препознавање по AID ПКС картица Привредне коморе — препознавање по AID Није подржана: Apollo 2008 лична карта (нема CardEdge аплет).\nПреузимање #Прекомпајлирани пакети за OpenSC 0.26.x и 0.27.x су доступни на страници издања.\nРаспакујте и копирајте:\n# Linux sudo cp librescrs-cardedge-opensc.so /usr/local/lib/ # macOS sudo cp librescrs-cardedge-opensc.dylib /usr/local/lib/ Компајлирање из изворног кода #Linux #sudo apt install libopensc-dev # Debian/Ubuntu # sudo dnf install opensc-devel # Fedora/RHEL cmake -S /path/to/LibreMiddleware -B build -DBUILD_CARDEDGE_OPENSC_DRIVER=ON cmake --build build --target librescrs-cardedge-opensc sudo cp build/lib/cardedge-opensc-driver/librescrs-cardedge-opensc.so /usr/local/lib/ macOS #Homebrew инсталира OpenSC али не и развојна заглавља. Клонирајте OpenSC извор на одговарајућем тагу верзије:\nbrew install opensc opensc-tool --version # забележите верзију, нпр. 0.26.1 git clone --branch 0.26.1 --depth 1 https://github.com/OpenSC/OpenSC /tmp/opensc-src cmake -S /path/to/LibreMiddleware -B build \\ -DBUILD_CARDEDGE_OPENSC_DRIVER=ON \\ -DOPENSC_INCLUDE_DIR=/tmp/opensc-src/src cmake --build build --target librescrs-cardedge-opensc sudo cp build/lib/cardedge-opensc-driver/librescrs-cardedge-opensc.dylib /usr/local/lib/ Конфигурација #Додајте следеће у ваш opensc.conf:\nПлатформа Локација opensc.conf Linux /etc/opensc/opensc.conf · /etc/opensc.conf · ~/.config/opensc/opensc.conf macOS /opt/homebrew/etc/opensc.conf · /Library/Application Support/OpenSC/opensc.conf app default { card_drivers = librescrs, internal; card_driver librescrs { module = /usr/local/lib/librescrs-cardedge-opensc.so; # Linux # module = /usr/local/lib/librescrs-cardedge-opensc.dylib; # macOS } framework pkcs15 { emulate librescrs { module = /usr/local/lib/librescrs-cardedge-opensc.so; # Linux # module = /usr/local/lib/librescrs-cardedge-opensc.dylib; # macOS } } } Верификација #Детекција картице #opensc-tool --list-readers # Gemalto USB SmartCard Reader Slot 0 ATR: 3B FF ... PKCS#15 објекти #pkcs15-tool --list-certificates pkcs15-tool --list-keys pkcs15-tool --list-pins # приказује преостале покушаје За потписивање и верификацију датотека, погледајте страницу Дигитално потписивање.\nДебаговање #Укључите OpenSC логовање у opensc.conf:\napp default { debug = 3; debug_file = /tmp/opensc-debug.txt; ... } Прегледајте /tmp/opensc-debug.txt после покретања било које pkcs15-tool или pkcs11-tool команде.\n","date":null,"permalink":"https://librescrs.github.io/sr/user-guide/opensc-integration/","section":"Водич за кориснике","summary":"","title":"OpenSC интеграција"},{"content":" Напомена: Уграђени драјвер за српске картице (srbeid) је интегрисан у главну грану OpenSC-а. Биће укључен у следеће издање OpenSC-а. До тада, овај модул остаје препоручена опција за PKCS#11 приступ смарт картицама.\nLibreSCRS PKCS#11 модул је универзални криптографски интерфејс који аутоматски препознаје тип картице и користи одговарајући провајдер. Ради са било којом PKCS#11 апликацијом — Firefox, Chrome, SSH, клијенти електронске поште — без потребе да LibreCelik буде отворен.\nТипови картица који се аутоматски препознају:\nCardEdge — Лична карта Gemalto (2014+), IF2020 за странце, ПКС картица Привредне коморе PKCS#15 — било која PKCS#15-компатибилна смарт картица (генерички PKI стандард) PIV — америчке федералне ID картице (NIST SP 800-73) Инсталација #Преузмите пакет за вашу платформу са странице издања и распакујте га.\nLinux #tar -xzf librescrs-pkcs11-*-linux-*.tar.gz sudo cp lib/librescrs-pkcs11.so* /usr/local/lib/ sudo ldconfig Напомена: Аутоматско откривање p11-kit модула на нивоу система (тако да апликације попут Kleopatra, GnuPG-gpgsm, Firefox, Chromium, Thunderbird и Evolution препознају LibreSCRS картице без подешавања по апликацији) долази у следећем издању LibreMiddleware-а. У 4.0.0 и даље је потребно ручно усмерити сваку апликацију на librescrs-pkcs11.so као што је приказано испод.\nmacOS #unzip librescrs-pkcs11-*-macos-universal.zip sudo cp librescrs-pkcs11.dylib /usr/local/lib/ Firefox # Отворите Settings \u0026gt; Privacy \u0026amp; Security \u0026gt; скролујте до Security \u0026gt; Security Devices Кликните Load Унесите име (нпр. LibreSCRS) и путању до модула: Linux: /usr/local/lib/librescrs-pkcs11.so macOS: /usr/local/lib/librescrs-pkcs11.dylib Кликните OK Убаците смарт картицу и освежите — Firefox ће тражити PIN када је сертификат потребан. На овај начин се аутентификујете на сервисе који захтевају аутентификацију клијентским сертификатом, као што је српска еУправа.\nChrome / Chromium #Chrome на Linux-у користи NSS базу. Региструјте модул једном:\n# Инсталирајте modutil ако није присутан sudo apt install libnss3-tools # Debian/Ubuntu sudo dnf install nss-tools # Fedora # Региструјте за тренутног корисника modutil -dbdir sql:$HOME/.pki/nssdb -add \u0026#34;LibreSCRS\u0026#34; \\ -libfile /usr/local/lib/librescrs-pkcs11.so Рестартујте Chrome. Сертификати картице ће се појавити у Settings \u0026gt; Privacy and security \u0026gt; Manage certificates.\nThunderbird #Исто као Firefox — Preferences \u0026gt; Privacy \u0026amp; Security \u0026gt; Security Devices \u0026gt; Load.\nOpenSSH #Листање јавних кључева на картици:\nssh-keygen -D /usr/local/lib/librescrs-pkcs11.so Коришћење модула за SSH аутентификацију:\nssh -I /usr/local/lib/librescrs-pkcs11.so user@host Или додајте у ~/.ssh/config:\nHost myserver PKCS11Provider /usr/local/lib/librescrs-pkcs11.so Компајлирање из изворног кода #Погледајте LibreMiddleware на GitHub-у за упутства за компајлирање.\ncmake -S /path/to/LibreMiddleware -B build cmake --build build --target librescrs-pkcs11 ","date":null,"permalink":"https://librescrs.github.io/sr/user-guide/pkcs11/","section":"Водич за кориснике","summary":"","title":"PKCS#11 модул"},{"content":"","date":null,"permalink":"https://librescrs.github.io/sr/tags/","section":"Tags","summary":"","title":"Tags"},{"content":"Овај одељак покрива све што вам је потребно да почнете да користите LibreSCRS — од инсталације LibreCelik-а до читања смарт картица, аутентификације у прегледачу и потписивања докумената.\nИнсталирајте LibreCelik — преузмите и подесите десктоп апликацију на Linux-у или macOS-у Прочитајте картицу — подржане картице, аутоматска детекција и језичке опције Дигитално потписивање — потписивање докумената и датотека смарт картицом PKCS#11 модул — аутентификација у прегледачу и дигитални потписи преко Firefox-а, Chrome-а, Thunderbird-а, SSH-а OpenSC интеграција — нативна OpenSC подршка за српске картице и екстерни драјвер за тренутна издања ","date":null,"permalink":"https://librescrs.github.io/sr/user-guide/","section":"Водич за кориснике","summary":"","title":"Водич за кориснике"},{"content":"Овај водич је намењен програмерима који желе да разумеју унутрашњост LibreSCRS-а, изграде пројекат из изворног кода или прошире систем новим додацима за картице.\nТеме # Преглед архитектуре — компоненте система, ток података, систем додатака и пројектни обрасци Архитектура потписивања — нативни механизам потписивања, подржани формати и руковање сертификатима Водич за интеграцију потписивања — интеграција дигиталног потписивања у апликације користећи LibreMiddleware Изградња из изворног кода — предуслови, упутства за изградњу и покретање тестова За детаље о плагин API-јима, погледајте CardPlugin и CardWidgetPlugin интерфејсе у Прегледу архитектуре.\n","date":null,"permalink":"https://librescrs.github.io/sr/developer-guide/","section":"Водич за програмере","summary":"","title":"Водич за програмере"},{"content":"Смарт картице са приватним кључевима могу се користити за дигиталне потписе. Најбржи начин да потпишете документ је уграђени чаробњак за потписивање у LibreCelik-у. Ова страница покрива и потписивање из командне линије и PKCS#11 клијенте трећих страна. Примери испод користе српске личне картице и ПКС картице, али исти ток рада важи за сваку картицу коју подржава LibreCelik, OpenSC или LibreSCRS PKCS#11 модул.\nПотписивање у LibreCelik-у (препоручено) #LibreCelik 4.0 испоручује нативни чаробњак за потписивање који производи EU eIDAS / ETSI baseline потписе директно са ваше смарт картице — без спољашњег сервиса, без додатних PDF алата, без ручног рачунања хеша. Чаробњак подржава PAdES (PDF), CAdES (.p7s), XAdES (.xml), JAdES (.json) и ASiC-E (.asice) контејнере у четири нивоа усклађености (B-B, B-T, B-LT, B-LTA).\nДа бисте потписали документ:\nУбаците картицу за потписивање и отворите LibreCelik. Сачекајте да се картица појави у главном прозору. Отворите Датотека → Потпиши документ… (или акцију „Потпиши\u0026quot; на приказу картице). Изаберите документ. Превуците датотеку у зону или кликните Преглед. Изаберите формат потписа (PAdES за PDF, ASiC-E за било који други тип, CAdES / XAdES / JAdES ако имате одређени захтев) и ниво усклађености (B-B за офлајн потпис, B-T за потпис са временским печатом, B-LT / B-LTA за дугорочне архивске потписе — за ова два нивоа додатно је потребна интернет конекција за преузимање података о опозиву преко CRL / OCSP). (само PAdES) Поставите визуелни потпис. Изаберите страницу, превуците правоугаоник, чаробњак аутоматски попуњава простор текстом. Преглед је пиксел-тачан у односу на коначни уграђени PDF. Изаберите сертификат за потписивање — чаробњак приказује све сертификате за потписивање са картице. Статус PIN-а (исправан / блокиран / преостали покушаји) приказује се поред сваког. Унесите PIN када се затражи, затим изаберите путању за чување. Чаробњак производи потписану датотеку и приказује сажетак верификације (потписник, ланац, временски печати). Чаробњак испод хаубе користи LibreSCRS PKCS#11 модул, тако да исти ауторитети поверења и понашање провере опозива важе било да потписујете кроз GUI или кроз неки од доле наведених токова у командној линији.\nПредуслови #Потребно вам је једно од следећег:\nOpenSC са уграђеном подршком за српске картице — само инсталирајте OpenSC, ништа друго није потребно. (srbeid драјвер је интегрисан у главну грану OpenSC-а али још није укључен у издање. Ако компајлирате OpenSC из изворног кода, већ ради.) OpenSC + LibreSCRS екстерни драјвер — користите ово док уграђени драјвер не буде објављен. Даје вам приступ свим OpenSC CLI алатима (pkcs15-crypt, pkcs11-tool, итд.). Погледајте OpenSC интеграција. LibreSCRS PKCS#11 модул — ради без OpenSC-а. За аутентификацију у прегледачу и потписивање преко било које PKCS#11 апликације. Погледајте PKCS#11 подешавање. Потписивање из командне линије са OpenSC #Потписивање датотеке #pkcs15-crypt --sha-256 очекује унапред израчунат бинарни хеш као улаз, не сирову поруку.\n# Израчунај хеш openssl dgst -sha256 -binary /path/to/message.txt \u0026gt; /tmp/hash.bin # Потпиши кључем 02 (Дигитални потпис) pkcs15-crypt --sign --pkcs1 --sha-256 --key 02 \\ --input /tmp/hash.bin --output /tmp/sig.bin Верификација потписа ## Извуци јавни кључ из сертификата # Напомена: pkcs15-tool враћа PEM на Linux-у, DER на macOS-у pkcs15-tool --read-certificate 02 --output /tmp/cert.pem openssl x509 -in /tmp/cert.pem -pubkey -noout \u0026gt; /tmp/pubkey.pem # Верификуј openssl dgst -sha256 -verify /tmp/pubkey.pem \\ -signature /tmp/sig.bin /path/to/message.txt # Verified OK Коришћење pkcs11-tool #Можете такође потписивати користећи pkcs11-tool са LibreSCRS PKCS#11 модулом или OpenSC-овим модулом:\npkcs11-tool --module /usr/local/lib/librescrs-pkcs11.so \\ --sign --mechanism RSA-PKCS --id 02 \\ --input-file /tmp/hash.bin --output-file /tmp/sig.bin Аутентификација у прегледачу (еУправа) #За аутентификацију на државне сервисе као што је еУправа, подесите PKCS#11 модул у Firefox-у. Погледајте PKCS#11 упутство за Firefox.\nКада посетите сајт који захтева аутентификацију клијентским сертификатом, Firefox ће вас питати да изаберете сертификат и унесете PIN.\nПотписивање PDF докумената у читачима трећих страна #Ако користите други PDF читач, већина PKCS#11 читача може да користи вашу смарт картицу преко LibreSCRS PKCS#11 модула. Примери:\nOkular (KDE) — подржава PKCS#11 преко NSS-а Adobe Reader (ако је доступан на вашој платформи) Ови путеви су корисни када вам је потребан ток потписивања интегрисан у сам прегледач, што није покривено LibreCelik чаробњаком. Ако пробате неки од њих са одређеном картицом и имате повратну информацију, молимо поделите своја открића.\nПотписивање електронске поште (S/MIME) #Thunderbird и други клијенти електронске поште који подржавају PKCS#11 безбедносне уређаје могу да користе сертификате са ваше смарт картице за S/MIME потписивање и шифровање поште. Учитајте PKCS#11 модул у Thunderbird-у на исти начин као у Firefox-у — погледајте PKCS#11 подешавање.\nДа ли су сертификати на вашој картици погодни за S/MIME зависи од њихових екстензија за употребу кључа. Ако сте ово тестирали, молимо поделите своје резултате.\n","date":null,"permalink":"https://librescrs.github.io/sr/user-guide/digital-signing/","section":"Водич за кориснике","summary":"","title":"Дигитално потписивање"},{"content":"Пројекат је отвореног кода. Ево како можете да допринесете.\nНачини доприноса # Пријавите грешку — LibreCelik пријаве, LibreMiddleware пријаве Предложите функционалност — отворите issue на одговарајућем репозиторијуму Пошаљите Pull Request — погледајте упутства испод Развојно окружење #Оба пројекта се граде помоћу CMake 3.24+. LibreMiddleware захтева C++23 компајлер (GCC 13+ / Clang 17+); LibreCelik и даље циља C++20 (прелазак на C++23 је на 4.x роадмапи).\n# Клонирајте оба репозиторијума git clone https://github.com/LibreSCRS/LibreCelik.git git clone https://github.com/LibreSCRS/LibreMiddleware.git # Изградња LibreMiddleware cd LibreMiddleware cmake -B build -DCMAKE_BUILD_TYPE=Release cmake --build build # Изградња LibreCelik са локалним LibreMiddleware cd ../LibreCelik cmake -B build -DCMAKE_BUILD_TYPE=Release \\ -DFETCHCONTENT_SOURCE_DIR_LIBREMIDDLEWARE=../LibreMiddleware cmake --build build За детаље, погледајте Изградња из изворног кода.\nСтандарди кодирања # LibreMiddleware: C++23. Користите std::span, std::format, std::expected, паметне показиваче. LibreCelik: C++20. Упозорења компајлера: -Wall -Wextra -Wpedantic Именовање: camelCase за променљиве, PascalCase за типове. Без завршних доњих црта на члановима класе. SPDX заглавља лиценце на свим изворним фајловима. Свака промена мора да укључује тестове. Процес за Pull Request # Fork-ујте репозиторијум Направите feature грану Направите промене са тестовима Push-ујте и отворите Pull Request Опишите шта промена ради и зашто CI мора да прође Code review пре merge-а Додавање подршке за нову картицу #Ако желите да додате подршку за нови тип смарт картице:\nАнализирајте картицу — користите card_mapper CLI алат (део LibreMiddleware-а) за истраживање фајл система картице и APDU одговора. Ово је корисан први корак за разумевање садржаја картице.\nMiddleware плагин — имплементирајте CardPlugin интерфејс у LibreMiddleware-у. Ово обрађује детекцију картице (ATR подударање или провера на живој конекцији) и читање података.\nGUI плагин — имплементирајте CardWidgetPlugin интерфејс у LibreCelik-у. Ово обезбеђује Qt6 widget који приказује податке са картице.\nПогледајте Преглед архитектуре за детаље о систему плагинова и интерфејсима.\nРазвојни процес # Развој уз помоћ вештачке интелигенције — користимо AI алате као део развојног процеса Развој вођен тестовима (TDD) Code review на сваком pull request-у CI pipeline покреће тестове на свим подржаним платформама ","date":null,"permalink":"https://librescrs.github.io/sr/contribute/","section":"Допринесите","summary":"","title":"Допринесите"},{"content":"Предуслови # Зависност Верзија Напомена CMake 3.24+ Систем за изградњу C++ компајлер GCC 13+ или Clang 17+ За LibreMiddleware потребна је подршка за C++23; LibreCelik и даље циља C++20 (прелазак на C++23 је на 4.x роадмапи) Qt 6.6+ Widgets, PrintSupport, LinguistTools Само за LibreCelik PC/SC libpcsclite-dev (Linux) Уграђено на macOS-у OpenSSL 3 — Укључено у LibreMiddleware thirdparty/ UUID uuid-dev (Linux) Генерисање UUID-а Изградња LibreMiddleware-а #LibreMiddleware је самостална C++23 библиотека без зависности од Qt-а.\ngit clone https://github.com/LibreSCRS/LibreMiddleware.git cd LibreMiddleware cmake -B build cmake --build build Покретање тестова:\ncd build \u0026amp;\u0026amp; ctest --output-on-failure Изградња LibreCelik-а #LibreCelik је Qt6 GUI апликација. Аутоматски преузима LibreMiddleware преко CMake FetchContent.\ngit clone https://github.com/LibreSCRS/LibreCelik.git cd LibreCelik cmake -B build -DCMAKE_BUILD_TYPE=Release cmake --build build Локални развој #Када радите на оба пројекта истовремено, усмерите LibreCelik на локалну копију LibreMiddleware-а уместо преузимања са GitHub-а:\ncmake -B build -DFETCHCONTENT_SOURCE_DIR_LIBREMIDDLEWARE=/path/to/LibreMiddleware cmake --build build На овај начин се измене у LibreMiddleware-у одмах преузимају без потребе за commit-овањем или push-овањем.\nПокретање тестова #Оба пројекта користе Google Test (аутоматски преузет преко CMake-а). Покретање свих тестова:\ncd build \u0026amp;\u0026amp; ctest --output-on-failure Покретање појединачног теста:\ncd build \u0026amp;\u0026amp; ctest -R \u0026lt;test_name\u0026gt; --output-on-failure Потпуно искључивање тестова:\ncmake -B build -DBUILD_TESTING=OFF Проблем са LibreCelik покретачем тестова #ctest може пријавити \u0026ldquo;No tests found\u0026rdquo; због проблема са временским усклађивањем gtest_discover_tests. Ако се то деси, покрените тест бинарне датотеке директно:\ncd build ./test/LibreCelikTests ./test/CardWidgetPluginRegistryTests ./test/AsyncCardReaderTests ","date":null,"permalink":"https://librescrs.github.io/sr/developer-guide/building-from-source/","section":"Водич за програмере","summary":"","title":"Изградња из изворног кода"},{"content":"LibreCelik је десктоп апликација за читање и приказивање података са смарт картица на Linux-у и macOS-у. Подржава растући број типова картица кроз своју плагин архитектуру.\nLinux #Преузмите .AppImage са странице издања, дозволите извршавање и покрените:\nchmod +x LibreCelik-*.AppImage ./LibreCelik-*.AppImage Инсталација није потребна. AppImage садржи све зависности укључујући Qt.\nПодршка за PC/SC читач #pcscd сервис мора бити покренут за приступ картици:\n# Debian/Ubuntu sudo apt install pcscd pcsc-tools sudo systemctl enable --now pcscd # Fedora/RHEL sudo dnf install pcsc-lite pcsc-tools sudo systemctl enable --now pcscd # Arch/Manjaro sudo pacman -S ccid pcsc-tools sudo systemctl enable --now pcscd Проверите да ли је ваш читач детектован:\npcsc_scan macOS #Преузмите и отворите .dmg са странице издања, превуците LibreCelik у Applications.\nmacOS има уграђену PC/SC подршку — додатни софтвер није потребан.\nЗахтеви # USB читач смарт картица (контактни или бесконтактни, у зависности од картице) Linux: pcscd сервис мора бити покренут macOS: нема додатних захтева Компајлирање из изворног кода #Погледајте Водич за програмере — Изградња из изворног кода за комплетна упутства.\n","date":null,"permalink":"https://librescrs.github.io/sr/user-guide/install-librecelik/","section":"Водич за кориснике","summary":"","title":"Инсталирајте LibreCelik"},{"content":"LibreSCRS је настао као подухват реверзног инжењеринга са циљем да ослободи српске државне смарт картице од затвореног софтвера везаног искључиво за Windows. Кроз анализу протокола и развој уз помоћ вештачке интелигенције, изградили смо алате отвореног кода који данас подржавају било коју смарт картицу — од националних личних карата до саобраћајних дозвола и eMRTD е-пасоша.\nВременска линија # Средина 2025 — Почетак пројекта: LibreCelik, графички читач за српску личну карту и саобраћајну дозволу Почетак 2026 — LibreMiddleware издвојен као самостална Qt-free библиотека (без Qt зависности) Почетак 2026 — PKCS#11 модул објављен; OpenSC драјвер за српску личну карту интегрисан upstream (PR #3595, merged) Почетак 2026 — Плагин архитектура: и middleware и GUI постају агностични у односу на тип картице 2026 — eMRTD, PKCS#15 и PIV подршка: е-пасоши, било која PKI картица базирана на PKCS#15, PIV смарт картице. PKCS#11 модул генерализован да подржи све типове картица. Универзални toolkit. Мај 2026 — Издање 4.0.0: C++23 језгро, нативно PAdES / XAdES / JAdES / CAdES / ASiC-E потписивање, RFC 5280 валидација ланца поверења, eIDAS qcStatements усклађеност, аутоматско распоређивање визуелног потписа. Прича #Није постојала нативна Linux апликација која може да чита све типове српских државних смарт картица. Постојећи пројекти отвореног кода — JFreesteel (Java) и Bas Celik (Go) — доказали су да је могуће читати податке грађана са еИД картица без пропријетарног софтвера, али су се фокусирали на демографске податке. Нико се није бавио криптографским делом: CardEdge PKI аплетом који управља сертификатима, дигиталним потписима и PIN-ом. LibreSCRS је кренуо да покрије обоје — читање података и пуну PKI подршку — за све типове српских картица, на Linux-у, macOS-у и Windows-у.\nЗа српске електронске личне карте не постоји јавна документација протокола. Приступ је био директан: пратити шта пропријетарни Windows софтвер ради преко PC/SC-а, снимити APDU секвенце и из тога реконструисати протокол. Саобраћајне дозволе прате EU Directive 2003/127/EC стандард, тако да је њихова структура била јасно дефинисана од почетка. Здравствене картице имају свој распоред. ПКС картице Привредне коморе за квалификовани електронски потпис користе CardEdge за криптографске операције, али уопште немају демографске податке. Сваки тип картице значио је тестирање на стварном хардверу док протокол не буде разјашњен.\nКако је код растао, постало је јасно да логика комуникације са картицом мора да стоји самостално. LibreMiddleware је издвојен као чиста савремена C++ библиотека — без Qt-а, без GUI зависности — само протоколи смарт картица, TLV парсирање и чист API. Ово је омогућило изградњу PKCS#11 модула који дозвољава било којој апликацији (Firefox, Chrome, OpenSSL CLI) да користи било коју LM-подржану смарт картицу (српска лична карта, ПКС, PIV, генерички PKCS#15) за аутентификацију и дигитално потписивање без графичког интерфејса.\nСледећи корак била је плагин архитектура. Уместо хардкодиране подршке за одређене картице, и middleware и GUI постали су прошириви. CardPluginRegistry открива руковаоце картицама у рунтајму преко dlopen; CardWidgetPluginRegistry учитава GUI плагине преко QPluginLoader. Додавање новог типа картице своди се на убацивање дељене библиотеке — без рекомпајлирања.\nНајскорије је додата подршка за eMRTD е-пасоше и PKCS#15 генеричке картице. eMRTD је захтевао имплементацију BAC и PACE размене кључева из ICAO 9303 спецификације — Diffie-Hellman над елиптичким кривама, функције извођења кључева и Secure Messaging са сесијским кључевима. PKCS#15 додаје могућност откривања и коришћења сертификата и кључева на било којој компатибилној картици.\nРазвој уз помоћ вештачке интелигенције #Овај пројекат је грађен уз вештачку интелигенцију као развојног партнера — од анализе hex дампова непознатих APDU одговора до генерисања TLV парсера и валидације имплементације PACE криптографије. Свака линија кода је верификована на стварном хардверу.\nПројекти # Пројекат Опис Лиценца LibreCelik Qt6 десктоп GUI читач смарт картица GPL-3.0 LibreMiddleware C++23 middleware библиотеке за смарт картице LGPL-2.1 Сродни пројекти #LibreSCRS није први пројекат отвореног кода који ослобађа српске смарт картице. Стојимо на раменима оних који су дошли пре нас:\nJFreesteel — пионирска библиотека за српске еИД картице отвореног кода, аутор Горан Ракић (Java, 2015). JFreesteel је доказао да је могуће читати српске еИД картице без пропријетарног софтвера и инспирисао друге да крену истим путем. Bas Celik — активно одржаван десктоп читач за српске еИД, саобраћајне и здравствене картице у Go-у, аутор Никола Убавић. Одлична алтернатива ако преферирате алат заснован на Go-у. Доприноси #Погледајте страницу Допринесите за информације о пријави грешака, слању pull request-ова и додавању подршке за нове типове картица.\nПодршка пројекту #LibreSCRS се развија и одржава у слободно време. Ако су вам ови алати корисни, размислите о подршци пројекту.\nДонирајте преко Open Source Collective\n","date":null,"permalink":"https://librescrs.github.io/sr/about/","section":"О пројекту","summary":"","title":"О пројекту"},{"content":" Спонзоришите на GitHub-у Донирајте преко Open Collective LibreSCRS се развија и одржава у слободно време. Пројекат је независан. Ако су вам ови алати корисни, размислите о подршци пројекту.\nКако се користе средства # Хардвер за тестирање (читачи картица, смарт картице из различитих земаља) Време за развој CI/CD инфраструктура ","date":null,"permalink":"https://librescrs.github.io/sr/donate/","section":"Подржите пројекат","summary":"","title":"Подржите пројекат"},{"content":"LibreSCRS се састоји од два главна пројекта који заједно читају, обрађују и приказују податке са смарт картица.\nКомпоненте #LibreMiddleware (LGPL-2.1) #Колекција статичких C++23 библиотека за комуникацију са смарт картицама, без зависности од Qt-а. Обрађује све од APDU команди ниског нивоа до екстракције података са картице. Сва PC/SC комуникација живи искључиво у LibreMiddleware-у — LibreCelik нема директну зависност од PC/SC-а.\nЈавни CMake циљеви #Спољни корисници линкују против LibreSCRS::* алијас површине — стабилног јавног API-ја који скрива интерне библиотеке иза PascalCase именских простора:\nЦиљ Именски простор Намена LibreSCRS::SmartCard LibreSCRS::SmartCard CardSession, MonitorService — PC/SC + монитор LibreSCRS::Plugin LibreSCRS::Plugin CardPlugin, CardPluginService, CardData, ReadResult LibreSCRS::Auth LibreSCRS::Auth CredentialProvider, AuthRequirement, CredentialResult LibreSCRS::Certificate LibreSCRS::Certificate Парсирање и метаподаци X.509 сертификата LibreSCRS::Trust LibreSCRS::Trust TrustStoreService, TrustStore, TrustConfig LibreSCRS::Signing LibreSCRS::Signing SigningService, SigningRequest, SigningResult, VisualSignatureLayout LibreSCRS::Secure LibreSCRS::Secure Secure::Buffer, Secure::String (нулирање при уништавању) Табела испод приказује интерне bucket-B библиотеке које имплементирају ове јавне циљеве. Интерне библиотеке могу да се мењају између издања и спољни код не треба директно да линкује против њих.\nБиблиотека Намена smartcard PCSCConnection, Monitor (детекција картица), APDU команда/одговор, TLV и BER-TLV парсирање (ISO 7816-4), TransmitFilter (транспарентни Secure Messaging слој) plugin CardPlugin интерфејс (са подршком за streaming), CardData модел, CardPluginRegistry (dlopen), AutoReader (мост између Monitor-а и откривања додатака) pkcs15 Генерички PKCS#15/ISO 7816-15 парсер и библиотека — EF.ODF/EF.DIR откривање, енумерација сертификата и кључева. Ради са било којом PKCS#15-компатибилном картицом rs-eid API за српску eID картицу са имплементацијама читача (Apollo 2008, Gemalto 2014+, Foreigner IF2020) eu-vrc ЕУ саобраћајна дозвола (Директива 2003/127/EC) rs-health Картица српског здравственог осигурања (РФЗО) cardedge CardEdge PKI аплет за српске смарт картице — сертификати, управљање PIN-ом, дигитално потписивање emrtd eMRTD комуникација са е-пасошем — читање група података, парсирање MRZ-а emrtd-crypto eMRTD криптографија — BAC, PACE (ECDH-GM), Secure Messaging piv PIV комуникација са картицом (NIST SP 800-73) pkcs11 PKCS#11 дељена библиотека (librescrs-pkcs11) — подржава све типове картица *-plugin Додаци за картице (.so): rs-eid, rs-health, eu-vrc, emrtd, piv, pkcs15, cardedge, opensc LibreCelik (GPL-3.0) #Qt6 десктоп GUI апликација за приказ података са картица. Чист презентацијски слој — без PC/SC-а, без APDU-а, без знања о протоколима картица. Прима CardData од middleware додатака и приказује га кроз GUI додатке.\nМодул Намена smartcard SmartCardReaderListener — Qt адаптер који обавија middleware smartcard::Monitor plugin CardWidgetPlugin интерфејс и CardWidgetPluginRegistry (QPluginLoader) asynccardreader Генерички асинхрони читач картица кроз middleware CardPlugin ланац document Дељени PKI кориснички интерфејс (TokenSection), дијалог за промену PIN-а, штампање certificate Прегледач X.509 сертификата (модел стабла + дијалог) plugins/ GUI додаци (rs-eid, rs-health, eu-vrc, emrtd, piv, token) као Qt MODULE .so датотеке LibreCelik преузима LibreMiddleware преко CMake FetchContent. За локални развој можете усмерити на локалну копију.\nАрхитектура додатака #Цео систем је изграђен око додатака. Постоје два независна слоја — middleware додаци за комуникацију са картицом, GUI додаци за приказ. Повезани су кроз CardData, универзални модел података који сваки middleware додатак производи, а сваки GUI додатак конзумира.\n┌─────────────────────────────────────────────────────────┐ │ LibreCelik (GUI) │ │ │ │ ┌──────────────────────┐ ┌────────────────────────┐ │ │ │SmartCardReaderListener│ │ CardWidgetPluginRegistry│ │ │ │(Qt адаптер за Monitor)│ │ (QPluginLoader) │ │ │ └──────────────────────┘ └──────────┬─────────────┘ │ │ ▲ │ учитава │ │ │ обавија ┌──────▼──────────────┐ │ │ │ │ GUI додаци (.so) │ │ │ │ │ ┌──────┐ ┌────────┐ │ │ │ │ │ │rs-eid│ │eu-vrc │ │ │ │ │ │ ├──────┤ ├────────┤ │ │ │ │ │ │rs- │ │ emrtd │ │ │ │ │ │ │health│ ├────────┤ │ │ │ │ │ ├──────┤ │ piv │ │ │ │ │ │ │token │ └────────┘ │ │ │ │ │ └──────┘ │ │ │ │ └─────────────────────┘ │ │ │ ▲ │ │ │ │ CardData │ ├───────────┼──────────────────────────┼──────────────────┤ │ │ LibreMiddleware│ │ │ │ │ │ │ ┌────────┴─────────┐ ┌─────────────┴──────────┐ │ │ │ smartcard::Monitor│ │ CardPluginRegistry │ │ │ │ (PC/SC polling) │ │ (dlopen) │ │ │ └──────────────────┘ └──────────┬─────────────┘ │ │ │ учитава │ │ ┌───────────────────────────────▼─────────────────┐ │ │ │ Middleware додаци (.so) │ │ │ │ ┌─────────┐ ┌──────────┐ ┌───────────────────┐ │ │ │ │ │ rs-eid │ │ emrtd │ │ opensc │ │ │ │ │ ├─────────┤ ├──────────┤ │ (PKI резервна) │ │ │ │ │ │ eu-vrc │ │ cardedge │ └───────────────────┘ │ │ │ │ ├─────────┤ ├──────────┤ ┌───────────────────┐ │ │ │ │ │rs-health│ │ piv │ │ pkcs15 │ │ │ │ │ └─────────┘ └──────────┘ └───────────────────┘ │ │ │ └─────────────────────────────────────────────────┘ │ │ │ │ │ │ APDU (ISO 7816-4) │ │ ▼ │ │ ┌──────────────┐ │ │ │PCSCConnection│ │ │ │ (PC/SC) │ │ │ └──────┬──────┘ │ └──────────────────────────┼─────────────────────────────┘ │ ┌──────▼──────┐ │ Смарт картица│ └─────────────┘ Детекција картице: smartcard::Monitor #Детекција картице живи у LibreMiddleware-у као smartcard::Monitor — чиста C++23 класа без зависности од Qt-а. На позадинској нити прозива PC/SC за догађаје убацивања/вађења картице и обавештава претплатнике кроз повратне позиве:\nsubscribe(MonitorCallback) — регистрација за MonitorEvent обавештења (картица убачена/извађена, име читача, ATR) unsubscribe(id) — престанак примања догађаја Монитор лењо покреће нит за прозивање при првој претплати и зауставља је када се последњи претплатник одјави. У LibreCelik-у, SmartCardReaderListener обавија монитор и маршалира догађаје на Qt главну нит кроз сигнале.\nMiddleware додаци (CardPlugin) #Middleware додатак је дељена библиотека (.so / .dylib) коју CardPluginRegistry учитава преко dlopen у време извршавања. Сваки додатак имплементира:\ncanHandle(const std::vector\u0026lt;uint8_t\u0026gt;\u0026amp; atr) — брза провера само по ATR-у. Враћа bool — да ли овај додатак препознаје ATR? Без комуникације са картицом. Додаци такође излажу probePriority() (int) тако да регистар може рангирати кандидате. canHandleConnection(PCSCConnection\u0026amp; conn) — провера на живој конекцији. Шаље SELECT команде за познате AID-ове ради потврде подршке. Позива се само на додацима који нису прошли canHandle() — даје им другу шансу да преузму картицу кроз живу комуникацију. readCard(PCSCConnection\u0026amp; conn) — екстрахује све податке са картице. Шаље APDU команде, парсира TLV/BER-TLV одговоре и враћа CardData објекат са типизираним групама поља (лични подаци, подаци документа, фотографије, сертификати). Двофазна провера: Регистар прво позива canHandle(atr) на свим додацима — они који врате true иду одмах у листу кандидата, рангирани по probePriority(). Затим се canHandleConnection(conn) позива само на додацима који су вратили false у Фази 1, дајући генеричким додацима (попут OpenSC-а) шансу да преузму картицу провером живе конекције. Ово избегава непотребну комуникацију за додатке који су већ препознали картицу по ATR-у.\nStreaming подршка: Додаци могу имплементирати readCardStreaming() поред readCard(). Streaming испоручује CardData инкрементално — поља се појављују у GUI-ју док се читају са картице, уместо чекања да се цело читање заврши. Ово је посебно корисно за eMRTD где се групе података читају секвенцијално кроз шифроване канале.\nЛанац резервних опција: Ако readCard() најбоље рангираног додатка не успе, аутоматски се покушава следећи кандидат. OpenSC додатак служи као генеричка резервна опција за сваку картицу коју нема нативно подржану.\nPKI резервна опција: Додаци за податке (еИД, саобраћајна, здравствена) читају демографске податке, али не обрађују PKI операције. Након што додатак за податке заврши, систем може покренути засебан PKI додатак (CardEdge, PKCS#15 или OpenSC) за откривање сертификата, потписивање и управљање PIN-ом. Ово раздвајање значи да додаци за податке не морају знати за PKI.\nДодавање новог типа картице: Напишите класу која наслеђује CardPlugin, имплементирајте canHandle(), canHandleConnection() и readCard() (опционо readCardStreaming()), компајлирајте као дељену библиотеку и поставите је у директоријум за додатке. Регистар је аутоматски открива при следећем покретању.\nGUI додаци (CardWidgetPlugin) #GUI додатак је Qt дељена библиотека коју CardWidgetPluginRegistry учитава преко QPluginLoader. Сваки додатак имплементира:\ncardType() — враћа тип картице који овај додатак може да прикаже (мора да одговара ономе што middleware додатак поставља у CardData). createWidget(const CardData\u0026amp;, QWidget* parent) — гради и враћа Qt виџет који приказује податке са картице. Пуна контрола над распоредом — текстуална поља, фотографије, сертификати, шта год картица садржи. Додавање новог приказа картице: Напишите класу која наслеђује CardWidgetPlugin и Q_PLUGIN_METADATA, имплементирајте cardType() и createWidget(), компајлирајте као Qt MODULE библиотеку.\nКако се повезују #Додавање подршке за потпуно нови тип картице захтева два додатка:\nMiddleware додатак — зна како да комуницира са картицом (SELECT, READ BINARY, парсирање одговора) GUI додатак — зна како да прикаже податке (распоред, ознаке, форматирање) Мост између њих је CardData — мапа група поља, где свака група садржи парове кључ-вредност. Middleware додатак га попуњава, GUI додатак га чита. Ниједан не мора да зна за други. Поновна компилација основне апликације није потребна — само поставите .so датотеке.\neMRTD: Криптографски приступ картици #eMRTD додатак демонстрира најсложенију комуникацију са картицом у систему. Е-пасоши захтевају криптографско договарање кључева пре него што се било који податак може прочитати:\nBAC (Basic Access Control) — изводи сесијске кључеве из машински читљиве зоне (MRZ) штампане на пасошу PACE (Password Authenticated Connection Establishment) — Diffie-Hellman договарање кључева на елиптичним кривама, модерна замена за BAC. Може захтевати од корисника унос CAN броја (Card Access Number) штампаног на пасошу. Secure Messaging — све наредне APDU команде и одговори су шифровани и МАЦ-овани сесијским кључевима. Имплементирано као TransmitFilter на PCSCConnection — једном инсталиран, шифровање је транспарентно за сав код вишег нивоа. Библиотека emrtd-crypto имплементира ове протоколе из ICAO 9303 спецификације, док библиотека emrtd обрађује читање група података и парсирање MRZ-а. emrtd-plugin их повезује као стандардни CardPlugin са streaming подршком — групе података се читају прогресивно и испоручују GUI-ју како постану доступне. Из перспективе остатка система, то је само још један додатак који враћа CardData.\nТок података #Комплетан ток када се смарт картица убаци:\n1. Картица убачена у читач 2. smartcard::Monitor (LibreMiddleware, PC/SC нит за прозивање) └─ SCardGetStatusChange детектује присуство картице └─ креира MonitorEvent { CardInserted, readerName, atr } └─ обавештава претплатнике кроз повратни позив 3. SmartCardReaderListener (LibreCelik, Qt адаптер) └─ прима MonitorEvent на нити монитора └─ маршалира на Qt главну нит преко QMetaObject::invokeMethod └─ емитује сигнал са MonitorEvent 4. Главни прозор прима сигнал, покреће двофазно откривање додатака: Фаза 1 — ATR филтрирање (без комуникације са картицом): └─ CardPluginRegistry::findAllCandidates(atr, connection) ├─ rs-eid-plugin::canHandle(atr) → true (препознат ATR српске еИД) ├─ eu-vrc-plugin::canHandle(atr) → false ├─ emrtd-plugin::canHandle(atr) → false └─ opensc-plugin::canHandle(atr) → false Кандидати до сад: [rs-eid-plugin (приоритет 100)] Фаза 2 — провера на конекцији (само додаци који су вратили false): ├─ eu-vrc-plugin::canHandleConnection(conn) → false ├─ emrtd-plugin::canHandleConnection(conn) → false └─ opensc-plugin::canHandleConnection(conn) → true (нађен PKCS#15) Коначни кандидати: [rs-eid-plugin (100), opensc-plugin (50)] 5. AsyncCardReader::requestData(topCandidate) └─ std::async → позадинска нит └─ rs-eid-plugin::readCard(connection) ├─ SELECT AID, READ BINARY лични подаци ├─ парсирање BER-TLV одговора └─ враћа CardData { type: \u0026#34;rs.eid\u0026#34;, fields: {...} } 6. Резултат маршалиран назад на Qt главну нит (QMetaObject::invokeMethod) 7. CardWidgetPluginRegistry::findByCardType(\u0026#34;rs.eid\u0026#34;) └─ rseid-gui-plugin одговара 8. rseid-gui-plugin::createWidget(cardData, parent) └─ гради виџет: фотографија, име, адреса, број документа, сертификати 9. Виџет приказан у главном прозору Пројектни обрасци #Strategy #CardReaderBase дефинише интерфејс за комуникацију са одређеним чипом читача. Конкретне имплементације — CardReaderApollo (Apollo 2008 чипови) и CardReaderGemalto (Gemalto 2014+ чипови) — енкапсулирају разлике у APDU секвенцама и структурама датотека.\nAsync #AsyncCardReader обавија позиве middleware додатака са std::async да би GUI остао одзиван. Резултати се маршалирају назад на Qt главну нит преко QMetaObject::invokeMethod и Qt сигнала. Подржава и batch (readCard) и streaming (readCardStreaming) режиме. У middleware слоју, AutoReader пружа удобан омотач који повезује smartcard::Monitor догађаје директно са CardPluginRegistry откривањем и читањем картице — корисно за апликације које желе аутоматско руковање картицама без ручног повезивања.\nObserver #smartcard::Monitor користи модел претплате заснован на повратним позивима у middleware слоју. У GUI слоју, SmartCardReaderListener обавија монитор и поново емитује догађаје као Qt сигнале, пропагирајући догађаје убацивања/вађења картице до главног прозора и свих регистрованих слушалаца.\nSingleton #SmartCardReaderListener::instance() пружа јединствену тачку за диспечовање догађаја картице кроз GUI апликацију.\nПростори имена #Јавни API (LibreSCRS::*) #Јавна корисничка површина 4.0 живи испод LibreSCRS:: корена у PascalCase именским просторима. Свако заглавље испод include/LibreSCRS/ припада овој површини; сви други простори су интерни.\nПростор имена Опсег LibreSCRS::SmartCard CardSession, MonitorService — PC/SC + монитор догађаја картице LibreSCRS::Plugin CardPlugin, CardPluginService, CardData, ReadResult, AutoReaderService LibreSCRS::Auth CredentialProvider, AuthRequirement, CredentialResult, FieldDescriptor LibreSCRS::Certificate Парсирање и метаподаци X.509 сертификата LibreSCRS::Trust TrustStoreService, TrustStore, TrustConfig LibreSCRS::Signing SigningService, SigningRequest, SigningResult, VisualSignatureLayout LibreSCRS::Secure Secure::Buffer, Secure::String (нулирање при уништавању) LibreSCRS (корен) CancelToken, LocalizedText, SyncProvider Интерни простори имена (подложни промени) #Простори имена малим словима испод живе у lib/\u0026lt;библиотека\u0026gt;/ и подржавају јавни API. Нису део подржане корисничке површине — имена и потписи могу да се мењају између издања.\nПростор имена Опсег smartcard:: Интерни APDU / TLV / BER-TLV / PCSCConnection помоћници plugin:: Интерни помоћници за учитавање додатака и регистар eidcard:: Интерни типови за српску еИД картицу euvrc:: Интерни типови за ЕУ саобраћајну дозволу healthcard:: Интерни типови за здравствену картицу cardedge:: Интерни типови CardEdge PKI аплета emrtd:: eMRTD интерне структуре података и парсирање MRZ-а emrtd::crypto eMRTD криптографија — BAC, PACE, Secure Messaging piv:: PIV интерни типови pkcs15:: PKCS#15 интерни типови парсера libresign:: Унутрашњи engine за потписивање (PAdES / XAdES / JAdES / CAdES / ASiC-E) Стандарди #Следећи стандарди су релевантни за базу кода:\nСтандард Примена ISO 7816-4 Комуникација са смарт картицом — структура APDU команде/одговора, TLV и BER-TLV кодирање PC/SC Слој за приступ читачу — детекција картице, управљање конекцијом, контрола трансакција PKCS#11 Интерфејс криптографског токена — аутентификација у прегледачу, дигитални потписи PKCS#15 Апликација криптографских информација — откривање сертификата и кључева на смарт картицама ICAO 9303 eMRTD (е-пасоши) — BAC и PACE договарање кључева, Secure Messaging, структура група података NIST SP 800-73 PIV интерфејс картице — откривање сертификата, аутентификација, дигитално потписивање BSI TR-03110 PACE протокол — договарање кључева аутентификованих лозинком за eMRTD ","date":null,"permalink":"https://librescrs.github.io/sr/developer-guide/architecture/","section":"Водич за програмере","summary":"","title":"Преглед архитектуре"},{"content":"LibreCelik #Графичка апликација за читање смарт картица на Linux-у и macOS-у. Чита пасоше, е-пасоше, личну карту, саобраћајну дозволу, PIV и друге PKI картице путем додатака.\nПреузми AppImage (Linux) Преузми DMG (macOS) PKCS#11 модул #Аутентификација у прегледачу и дигитално потписивање за смарт картице са CardEdge PKI аплетом — српске личне карте, здравствене картице и ПКС картице (Привредна комора). Ради са Firefox-ом, Chrome-ом, Thunderbird-ом и SSH-ом.\nИнтегрисан у главну грану OpenSC-а (PR #3595); још увек није у нумерисаном издању OpenSC-а. Овај модул остаје препоручена опција док следеће OpenSC издање не укључи уграђени драјвер.\nПреузми за Linux (tar.gz) Преузми за macOS (zip) OpenSC екстерни драјвер #Драјвер за српске личне карте, здравствене картице и ПКС картице за OpenSC. Омогућава PKCS#11 приступ кроз OpenSC инфраструктуру.\nПривремено — покрива OpenSC 0.26.x / 0.27.x кориснике до следећег OpenSC издања које укључује уграђени драјвер из PR #3595 (интегрисан у главну грану, још увек није у нумерисаном издању).\nПреузми за Linux Преузми за macOS ","date":null,"permalink":"https://librescrs.github.io/sr/downloads/","section":"Преузимања","summary":"","title":"Преузимања"},{"content":"LibreCelik аутоматски детектује тип убачене картице и приказује одговарајуће податке. Ручно подешавање није потребно — само убаците картицу и апликација се побрине за остало.\nПодржане картице # Картица Приказани подаци Лична карта (Apollo 2008, Gemalto 2014+, IF2020 Foreigner) Лични подаци, информације о документу, фотографија. Gemalto и IF2020 такође подржавају сертификате дигиталног потписа и управљање PIN-ом (Apollo 2008 подржава само читање података — без PKI) Саобраћајна дозвола (EU Directive 2003/127/EC) Власник, подаци о возилу, датуми регистрације — сва EU обавезна и опциона поља Српска здравствена картица (РФЗО) Осигураник, послодавац, детаљи осигурања eMRTD е-пасоши Лични подаци, фотографија, MRZ, групе података — захтева BAC или PACE аутентификацију (можда ће бити затражен унос CAN броја са пасоша). Passive, Chip и Active Authentication за верификацију документа PIV (NIST SP 800-73) Сертификати, фотографија, отисци прстију, управљање PIN-ом PKCS#15 компатибилне картице (Gemalto, CardEdge, ПКС, генеричке PKI) Откривање сертификата, верификација и промена PIN-а, подршка за више PIN-ова Плагин архитектура олакшава додавање подршке за нове типове картица — и на нивоу middleware-а (комуникација са картицом) и на нивоу GUI-ја (приказ података).\nКако ради аутоматска детекција #Када се картица убаци у читач, LibreCelik:\nДетектује догађај картице преко smartcard::Monitor (PC/SC анкетирање у LibreMiddleware-у) Испитује све middleware додатке — прво по ATR-у, затим провером на живој конекцији Најбоље рангиран додатак чита податке са картице Приказује податке користећи одговарајући GUI додатак Ако ниједан плагин не препозна картицу, LibreCelik приказује поруку да тип картице није подржан.\nПрогресивно читање картице #Подаци са картице се појављују инкрементално док се читају — не морате чекати да се цела картица обради пре него што видите резултате. Спинер показује напредак читања, а поља се попуњавају како постану доступна. Ово је посебно приметно код eMRTD е-пасоша где се групе података читају секвенцијално кроз шифроване канале.\nУправљање PIN-ом #Картице које подржавају PIN операције (лична карта, ПКС, PKCS#15-компатибилне картице) приказују PKI секцију са детаљима сертификата и контролама за PIN. Картице са више PIN-ова (нпр. засебни PIN-ови за аутентификацију и потписивање) приказују статус сваког PIN-а појединачно и дозвољавају независну промену.\nЈезик #LibreCelik подржава енглески и српски (ћирилица). Промените језик преко менија у горњем десном углу. Подаци са картице се приказују онако како су записани на картици — обично на језику државе која је издала картицу.\nШтампање #Сви прикази података са картице подржавају штампање. Користите File \u0026gt; Print или дугме за штампање да генеришете форматиран испис приказаних података.\n","date":null,"permalink":"https://librescrs.github.io/sr/user-guide/read-your-card/","section":"Водич за кориснике","summary":"","title":"Прочитајте картицу"},{"content":"Подржане картице #eMRTD / е-пасош #Било који пасош или национална лична карта компатибилна са ICAO 9303. PACE и BAC аутентификација, Secure Messaging, биометријски подаци (фотографија, MRZ), групе података. Passive, Chip и Active Authentication за верификацију аутентичности документа.\nЛична карта #Gemalto 2014+, IF2020 Foreigner. Лични подаци, адреса, информације о документу, фотографија. Сертификати дигиталног потписа и управљање PIN-ом преко CardEdge.\nСаобраћајна дозвола (EU VRC) #Компатибилна са EU Directive 2003/127/EC. Власник, подаци о возилу, датуми регистрације — сва EU обавезна и опциона поља. Подршка за штампу.\nСрпска здравствена картица (РФЗО) #Осигураник, послодавац, детаљи осигурања.\nPIV (NIST SP 800-73) #Стандард за америчке федералне идентификационе картице. Сертификати, фотографија, отисци прстију, управљање PIN-ом.\nPKCS#15 компатибилне картице #Генерички PKI стандард за откривање сертификата, управљање PIN-ом и дигитално потписивање. Покрива Gemalto, CardEdge и друге компатибилне картице — укључујући PKI на националним картицама са eMRTD подршком.\nМогућности # Аутоматска детекција картице — убаците картицу, LibreCelik је препознаје и приказује податке. Без ручног избора. Прогресивно читање — подаци се приказују како се читају са картице. Без чекања да се заврши комплетно читање. Штампа — прикази података са картице подржавају форматирани испис. Управљање више PIN-ова — картице са више PIN-ова (нпр. засебни PIN-ови за аутентификацију и потписивање) приказују статус сваког PIN-а и дозвољавају независну промену. Плагин архитектура — додајте подршку за нове типове картица убацивањем дељене библиотеке. И middleware (комуникација са картицом) и GUI (приказ података) су прошириви. Вишејезичност — интерфејс на енглеском и српском (ћирилица). PKCS#11 модул — универзални криптографски интерфејс који подржава CardEdge, PKCS#15 и PIV картице. Коришћење у Firefox-у, Chrome-у, SSH-у и потписивању е-поште. OpenSC интеграција — драјвер за српске CardEdge картице интегрисан у главну грану OpenSC-а. Екстерни драјвер доступан за тренутна издања OpenSC-а. За програмере #LibreMiddleware је скуп C++23 статичких библиотека без Qt зависности. Користите их за изградњу сопствене апликације за смарт картице.\nПлагин API за додавање нових типова картица Streaming API за читање картице SmartCard Monitor за детекцију картица базирану на догађајима Secure Messaging, PACE, BAC имплементације Погледајте Водич за програмере за детаље архитектуре и упутства за изградњу.\n","date":null,"permalink":"https://librescrs.github.io/sr/features/","section":"Функционалности","summary":"","title":"Функционалности"}]