Tutorial - Inero Software - Rozwiązania IT i Konsulting

Przewodnik krok po kroku- Uwierzytelnianie wieloskładnikowe (MFA) w Keycloak

Marceli Formela — Wed, 05 Jun 2024 13:03:04 +0000

Wzrost liczby ataków i zagrożeń cyfrowych sprawił, że zabezpieczanie danych stało się koniecznością. Oszuści wciąż udoskonalają swoje narzędzia, dlatego tradycyjna metoda polegająca na hasłach okazuje się niewystarczająca do ochrony wrażliwych informacji. Ta eskalacja cyberzagrożeń podkreśliła konieczność wprowadzenia bardziej zaawansowanych środków bezpieczeństwa, co doprowadziło upowszechnienia uwierzytelniania wieloskładnikowego (MFA). W tym wpisie omówimy pojawiające się zagrożenia online i to jak MFA może stać się skutecznym mechanizmem obronnym dla naszych aplikacji.

Czym jest MFA?

Uwierzytelnianie wieloskładnikowe (MFA) zwiększa bezpieczeństwo Twoich aplikacji, wymagając od użytkowników podania wielu form identyfikacji przed przyznaniem dostępu. Oczywiście, narzędzia takie jak Keycloak wspierają MFA i pozwalają administratorom na łatwe skonfigurowanie tego rozwiązania. Ten przewodnik opisuje krok po kroku procedurę włączania MFA w Keycloak, zapewniając, że procesy uwierzytelniania użytkowników staną się bezpieczniejsze,

MFA zostało zaprojektowane, aby chronić użytkowników przed zagrożeniami związanymi z uwierzytelnianiem jednoskładnikowym, gdzie użytkownik musi podać tylko jedną formę uwierzytelnienia, zazwyczaj hasło. MFA dodaje warstwy bezpieczeństwa, wymagając od użytkowników przedstawienia wielu dowodów (czynników) potwierdzających ich tożsamość.

Czynniki uwierzytelniania użytkownika w MFA są zazwyczaj klasyfikowane w trzy typy:

1. Czynniki wiedzy (coś, co wiesz)
– Hasła
– PIN-y
– Pytania bezpieczeństwa
2. Czynniki posiadania (coś, co masz)
– Jednorazowe hasło (OTP) generowane przez aplikację uwierzytelniającą
– Kody SMS
– Kody e-mail
– Tokeny sprzętowe
3. Czynniki inherentne (coś, czym jesteś)
– Weryfikacja biometryczna (rozpoznawanie twarzy, odcisk palca itp.)

Pierwszym krokiem jest zawsze początkowe uwierzytelnienie, kiedy użytkownik wprowadza swoją nazwę i hasło (tak zwany czynnik wiedzy). Po początkowym uwierzytelnieniu proszony jest o podanie drugiej formy uwierzytelnienia, która może być jednorazowym hasłem (OTP) wysłanym na telefon, skanem biometrycznym lub inną formą czynnika posiadania/inherentnego. Jeśli oba czynniki zostaną pomyślnie zweryfikowane, użytkownik uzyskuje dostęp do aplikacji. Teraz przyjrzyjmy się kilku przykładowym typom uwierzytelniania oraz ich zaletom i wadom.

OTP wysyłane na e-mail

W tej metodzie tymczasowy kod jest wysyłany na zarejestrowany adres e-mail użytkownika, który musi go wprowadzić, aby zakończyć proces logowania. Użytkownicy otrzymują OTP bezpośrednio na e-mail, co nie wymaga instalacji ani konfiguracji dodatkowych aplikacji. Należy jednak pamiętać, że konta e-mail mogą zostać skompromitowane, a przechwycone e-maile mogą stanowić znaczące zagrożenie dla bezpieczeństwa.

OTP wysyłane SMS-em

Otrzymywanie OTP za pomocą SMS-a jest proste i znane większości użytkowników oraz także nie wymaga instalacji dodatkowych aplikacji. Powinno działać na każdym telefonie komórkowym, co czyni go dostępnym dla szerszej grupy użytkowników. Jednakże, i one mogą być podatne na przechwycenie i ataki polegające na zamianie kart SIM, co sprawia, że są mniej bezpieczne w porównaniu do innych metod. Dostarczanie SMS-ów może być również opóźnione lub nawet zawieść z powodu problemów z siecią. Przyjrzymy się bliżej jego zaletom i wadom w kolejnym poście, który obejmuje rozwój niestandardowych narzędzi uwierzytelniających.

Powiadomienia push

Powiadomienia push polegają na wysyłaniu w czasie rzeczywistym alertu na zarejestrowane urządzenie mobilne użytkownika, prosząc go o zatwierdzenie lub odrzucenie próby uwierzytelnienia. Użytkownicy są natychmiast powiadamiani o wszelkich próbach logowania, co pozwala im szybko reagować na wszelkie nieautoryzowane próby dostępu. Nie muszą także wprowadzać jednorazowego hasła (OTP), co upraszcza proces uwierzytelniania. Ta metoda oczywiście wymaga aktywnego połączenia internetowego. Należy jednak pamiętać, że zainfekowane urządzenia mogą potencjalnie zagrozić bezpieczeństwu tej funkcji, a użytkownicy muszą być edukowani w zakresie rozpoznawania autentycznych powiadomień push, aby uniknąć przypadkowego zatwierdzenia prób ataku.

OTP za pomocą aplikacji uwierzytelniających

OTP generowane przez aplikacje uwierzytelniające, takie jak Google Authenticator, są bardzo bezpieczne, ponieważ są oparte na czasie i trudne do przewidzenia. Mogą generować OTP bez połączenia z internetem, co czyni je niezawodnymi nawet wtedy, gdy użytkownicy są offline. W tym przypadku użytkownicy muszą mieć dostęp do swojego urządzenia mobilnego, aby wygenerować OTP, a początkowa konfiguracja często wymaga zeskanowania kodu QR i skonfigurowania aplikacji uwierzytelniającej, co może być trudne dla użytkowników nietechnicznych.

Jak skonfigurować OTP (przez mobilną aplikację uwierzytelniającą) w Keycloak

Teraz możemy przejść do konsoli Keycloak i spróbować skonfigurować podstawowe OTP w naszym realm. Przed próbą włączenia MFA w Keycloak upewnij się, że masz działającą instancję Keycloak, dostęp administracyjny do serwera oraz podstawową znajomość koncepcji realm, klienta i zarządzania użytkownikami z poprzednich postów.

Krok 1: Polityka OTP
Z menu bocznego wybierz realm, w którym chcesz włączyć MFA. W ustawieniach przejdź do sekcji Uwierzytelnianie i wybierz kartę Polityka OTP. Skonfiguruj ustawienia zgodnie z wymaganiami bezpieczeństwa. Możesz wybrać wartości domyślne, które są dostarczane przez serwer.

Krok 2: Wymagane działania
W ustawieniach uwierzytelniania przejdź do karty Wymagane działania. Teraz możesz aktywować OTP jako domyślne działanie dla każdego nowego użytkownika.

Skonfigurowaliśmy już MFA i każdy nowo zarejestrowany użytkownik będzie musiał z niego korzystać. Oczywiście, tę konfigurację można zmodyfikować w ustawieniach konta aplikacji, aby użytkownicy korzystali z MFA tylko wtedy, gdy specjalnie o to poproszą.

Jak widzimy, MFA to potężne narzędzie do ochrony wrażliwych informacji i zwiększania bezpieczeństwa aplikacji internetowych. Wymagając wielu form weryfikacji, znacznie utrudnia dostęp nieautoryzowanym użytkownikom do kont i systemów, zmniejszając ryzyko związane z uwierzytelnianiem opartym wyłącznie na hasłach. Wdrożenie tego mechanizmu z pewnością pomaga organizacjom w spełnianiu wymogów regulacyjnych i ochronie przed ciągle ewoluującymi zagrożeniami w sieci.

W następnym artykule przyjrzymy się bliżej niestandardowemu uwierzytelnianiu za pomocą SMS dla Keycloak, omawiając jego zalety i wady.

Artykuł Przewodnik krok po kroku- Uwierzytelnianie wieloskładnikowe (MFA) w Keycloak pochodzi z serwisu Inero Software - Rozwiązania IT i Konsulting.

Budowa systemu rozpoznawania komend głosowych w języku polskim

Andrzej Chybicki — Mon, 04 Apr 2022 10:08:58 +0000

Budowa systemu rozpoznawania komend głosowych w języku polskim

System rozpoznawania komend głosowych został stworzony po to, aby usprawnić życie człowieka. Pełni on rolę pomocnika, który wyszuka dla nas odpowiednie informacje, ułatwi zakupy w Internecie czy umożliwi obsługę różnych urządzeń bez wykorzystywania zewnętrznych przycisków czy regulacji. Jednak stworzenie takiego systemu od podstaw może być trudnym wyzwaniem. W szczególności, jeśli chcemy zbudować go w języku polskim.

Istnieją ogólne modele sieci neuronowych, które dedykowane są rozpoznawaniu języka mówionego, czyli transkrypcji nagrania audio do tekstu. Wszystko jednak uwarunkowane jest od tego, ile danych posiadamy. Obecnie istnieje wiele zbiorów nagrań z języka angielskiego, które są odpowiednio przygotowane. Same dane jednak nie wystarczą. Muszą być do nich dołączone transkrypcje. Niestety w języku polskim nie mamy dużej ilości próbek głosowych razem z transkrypcjami. Na dzień dzisiejszy nie jesteśmy więc w stanie tak dobrze wyuczyć modeli, jak to jest robione w języku angielskim.

Jak na razie nie możemy wyuczyć asystentów wykorzystując modele open source’owe z zadowalającą skutecznością, jednak możemy sprawdzić co jesteśmy w stanie zbudować z ogólnie dostępnych danych. Celem naszej pracy jest stworzenie systemu rozpoznawania mowy, który działa w ograniczonym zbiorze komend.

Główne źródła zbierania danych dla systemu rozpoznawania komend głosowych

W ostatnich miesiącach pojawiły się zbiory danych: Common Voice i Zasoby Nauki, które są odpowiednio przygotowane pod modele ASR (Automatic Speech Recognition). Oznacza to, że nagrania dźwiękowe zawierają również transkrypcje. Są to tak naprawdę dwa największe zbiory danych, które można użyć. Do zbudowania własnego systemu wykorzystaliśmy więc je i złączyliśmy w jedno.

Common Voice jest ciekawym zbiorem danych. Jeżeli chcemy aby ich ilość była jeszcze większa, możemy kontrybuować w tym działaniu. Każdy z nas może wejść na stronę i nagrać swój głos, który zostanie zapisany, a następnie sprawdzony przez innych użytkowników. W ten sposób będziemy mogli przyczynić się do powiększenia ilości danych z języka polskiego, dzięki czemu budowanie systemów rozpoznawania komend głosowych będzie łatwiejsze.

W przyszłości istnieje możliwość, że YouTube udostępni do wykorzystania swoje nagrania audio razem z automatycznie generowanymi transkrypcjami. Jest to jednak rozwiązanie, które (być może) powstanie dopiero później. Dodatkowym źródłem danych mogą również być audiobooki, które zawierają transkrypcję książek i nagrania audio. W takim przypadku musimy jednak wykonać pracę przygotowania danych polegającą na pofragmentowaniu danych na krótsze nagrania. Dodatkowo zmienna intonacja lektora może wpływać na dokładność wyuczonych przez nas modeli.

Przygotowanie i ujednolicenie danych

Przede wszystkim musimy zapewnić minimalną i maksymalną długość nagrania. Muszą one znajdować się w określonych ramach czasowych. Zbyt długie nagrania mogą być problemem podczas uczenia modelu, natomiast krótkie nagrania mogą nie nieść ze sobą żadnej istotnej informacji. Musimy także zapewnić jednakową częstotliwość próbkowania sygnału. Jest to bardzo ważna kwestia przy uczeniu modeli opartych na dźwięk.

Fala dźwiękowa czystego tonu, rozchodząca się w przestrzeni, ma charakter sinusoidalny. Zmiana częstotliwości takiego dźwięku oznacza zmianę okresu sinusoidy, więc zmieniają się odległości między jej grzbietami. Jednak dźwięk w komputerze również musi być w jakiś sposób zaprezentowany. Sinusoida jest przebiegiem ciągłym, natomiast komputer zapisuje pojedyncze wartości. Częstotliwość próbkowania mówi nam o tym, ile razy na sekundę została zapisana wartość rejestrowanej fali dźwiękowej. Bardzo ważne jest to, żeby każdy dźwięk, który wchodzi do naszego modelu miał taką samą częstotliwość próbkowania.

Poprzez nieprawidłowe próbkowanie rekonstruowany dźwięk może być zniekształcony lub całkowicie niesłyszalny. Trzeba więc pamiętać o odpowiednim dobraniu częstotliwości próbkowania, aby zminimalizować rozmiar zapisywanych danych przy jednoczesnym braku utraty informacji. Zbyt rzadkie próbkowanie może spowodować pojawienie się zjawiska aliasingu, czyli nakładania się wyższych częstotliwości na niższe.

Źródło: Reprezentacje danych dźwiękowych w kontekście metod uczenia maszynowego, s. 134, Tymoteusz Cejrowski

Zapobieganie takiemu zjawisku polega na próbkowaniu sygnału z częstotliwością co najmniej dwa razy większą od najwyższej częstotliwości występującej w sygnale. Częstotliwość ta nazywana jest częstotliwością Nyqiusta. Dla przykładu, nagrania na płytach CD są zapisywane z częstotliwością próbkowania 44100 Hz. Natomiast maksymalna poprawnie zrekonstruowana częstotliwość będzie wynosiła 22050 Hz, co odpowiada górnemu zakresowi dźwięków słyszalnych przez człowieka.

Opis i uczenie modelu deepspeech w systemie rozpoznawania komend głosowych

Sieci neuronowe w pewien sposób przypominają układ nerwowy. Podstawowymi jednostkami w takich sieciach są neurony, które rozmieszczone są w warstwach. Jest to uproszczony model procesu przetwarzania informacji przez ludzki umysł.

Zazwyczaj sieć neuronowa składa się z trzech części. Pierwsza to warstwa wejściowa, która posiada jednostki reprezentujące zmienne wejściowe. Następna część to warstwy ukryte, które zawierają jednostki nieobserwowane i są ukrytym stanem sieci neuronowej. To właśnie od tych warstw w dużej mierze zależy efektywność modelu. Natomiast ostatnią częścią jest oczywiście warstwa wyjściowa, która posiada jednostki reprezentujące zmienne przewidywane. Wszystkie jednostki złączone są konkretnymi połączeniami o różnej wadze. Dane wejściowe znajdują się na pierwszej warstwie, przechodzą one przez kolejne, a ostatecznie z warstwy wyjściowej otrzymujemy wynik.

Sieć neuronowa uczy się przez porównywanie rekordów. Generuje ona predykcje dla konkretnych danych (nagrań audio) i wprowadza korekty wag, jeśli generują one niepoprawną predykcję (złą transkrypcję). Cały proces powtarzany jest wiele razy do uzyskania satysfakcjonującej dokładności. Wszystkie wagi na początku mają charakter losowy, a odpowiedzi wychodzące nie mają dużo sensu, z czasem natomiast sieć poprawia swoje predykcje. Dzieje się tak, ponieważ sieć dopasowuje się do danych w procesie uczenia wykorzystując algorytm wstecznej propagacji błędu.

Jednym z najprostszych modeli Sieci Neuronowych jest Perceptron wielowarstwowy. Składa się on z wielu warstw neuronowych. Neurony poprzedniej warstwy tworzą konkretny wektor, który jest podawany na wejście neuronów do warstwy następnej. Pojedynczy neuron w warstwie następnej ma liczbę wejść równej liczbie neuronów z warstwy poprzedniej +1. Jednak w ramach jednej warstwy, neurony między sobą nie mają żadnych połączeń. Taki typ modelu nazywany jest również modelem „Feed-Forward” i jest jedną z podstawowych architektur sieci neuronowych.

Rysunek przedstawiający model „Feed-Forward”

Sieci rekurencyjne różnią się od sieci typu „Feed-Forward” w wielu aspektach. Jedną z głównych różnic jest sposób propagacji danych wejściowych na wyjście sieci. W najprostszym modelu wyjście sieci jest niczym innym kombinacją wag i wejścia modelu (pojedynczego rekordu). W przypadku sieci rekurencyjnych wyjście modelu zależy również od poprzedniego wyjścia. Wynik działania modelu dla rekordu X jest brany pod uwagę przy wyliczaniu wyjścia dla kolejnego rekordu Y.

Konwolucyjna sieć neuronowa jest typem sieci najczęściej stosowanej do analizy obrazów wizualnych z uwagi na swój charakter procesowania wejścia. Podobnie jak człowiek, sieć ta nie analizuje obrazu piksel po pikselu ale wyłapuje wzorce obecne w danych wejściowych dzięki zastosowaniu tzw. Kerneli czyli filtrów. Każda warstwa w sieci neuronowej uczy się cech obrazu takich jak kontury czy nasycenie światłem. Złożenie tych informacji poprawia efektywność modelu.

Poza neuronowymi modelami rozpoznawania mowy, warto pochylić się nad open source’owymi systemami, które umożliwiają zbudowanie systemu rozpoznawania komend głosowych. Jednym z nich jest Kaldi, który został napisany w C++. Powstał on w 2009 roku, a jego głównymi cechami jest to, że system ten jest rozszerzalny i cały czas rozwijany. Udostępnia on m.in. narzędzia do pre-procesowania nagrań audio czy modeli opartych o Ukryte Modele Markowa (HMM). Sama społeczność udostępnia wiele innych modułów, które można wykorzystać do własnych zadań. Kaldi, poza modelami statystycznymi, obsługuje także głębokie sieci neuronowe. Pomimo tego, że jest napisany głównie w C++, to posiada on skrypty w jezyku Bash czy Python.

W naszej pracy skupiliśmy się jednak na konkretnym modelu ASR: deepspeech 2. Jest to model, który wykorzystuje głębokie uczenie (ang. Deep Learning), składa się on z 3 warstw konwolucyjnych, 8 rekurencyjnych i jednej Fully-Connected. Deepspeech 2 można z powodzeniem wyuczyć na dowolnym języku, trzeba jednak pamiętać, że takie uczenie wymaga wydajnego systemu komputerowego/serwerowego wyposażonego w odpowiednią ilość kart graficznych lub akceleratorów obliczeń.

W przypadku popularnych języków takich jak angielski czy mandaryński można znaleźć przetrenowane modele gotowe do użycia. W naszym zadaniu wybraliśmy deepspeech 2 z implementacją w PyTorchu, ponieważ jest on lekki, ma stosunkowo mało parametrów (wag do wyuczenia) i wybrana przez nas implementacja jest aktywnie utrzymywana. W tym modelu oprócz przygotowania odpowiednich częstotliwości próbkowania o których pisaliśmy wyżej, musieliśmy również przygotować odpowiednio dane pod sam model deepspeech. Wiązało się to z zapewnieniem odpowiedniej struktury katalogów.

Wnioskowanie z użyciem modeli ASR i dodatkowego modelu językowego

Wykorzystując deepspeech jesteśmy w stanie zastosować dodatkowy model językowy (model n-gramowy). Opiera się on na statystykach i pomaga w przewidywaniu kolejnego elementu sekwencji w wynikowej transkrypcji. Trzeba pamiętać, że zastosowanie takiego modelu wymaga zgromadzenia dużego zasobu danych statystycznych. N-gramy pomagają maszynom w zrozumieniu słowa w konkretnym kontekście. Dzięki temu mogą one lepiej zrozumieć jego przeznaczenie.

Jeśli chcemy utworzyć taki model, zaczynamy od zliczania wystąpień sekwencji o ustalonej długości n w istniejących już zasobach językowych. Analizuje się więc całe teksty i zlicza się pojedyncze wystąpienia (1-gram), dwójki (2-gramy) i trójki (3-gramy). Możemy również uzyskać model 4-gramowy, jednak tutaj potrzebne są już ogromne zbiory danych, przez co dla języka polskiego jest to niezwykle trudne do zrealizowania. W kolejnym kroku zamienia się liczbę wystąpień na prawdopodobieństwo poprzez normalizację. W ten sposób zyskujemy predykcję kolejnego elementu na podstawie dotychczasowych sekwencji. Warto zaznaczyć, że im więcej przeanalizowanego tekstu, tym wyższa jakość modelu. Dane te są głównie wykorzystywane w aplikacjach przetwarzania języka naturalnego (NLP). Model n-gramowy dla języka polskiego można znaleźć tutaj.

Użycie modelu n-gramowego na etapie wnioskowania pozwala na skorygowanie wyjścia sieci neuronowej (transkrypcji modelu deepspeech 2) zgodnie z regułami zawartymi w modelu n-gramowym.

Działanie w ograniczonym zbiorze komend

Niestety budowane modele nie mogą być wystarczająco dokładne ze względu na małą ilość danych w języku polskim. W naszym przypadku możemy jednak działać w ograniczonym zbiorze komend. Oznacza to, że rozpoznawaniu podlega konkretna ilość komend głosowych. Nasze zadanie polegało na tym, żeby dopasować odpowiednią komendę ze zbioru z tym co dostarczył nam model. Ważne jest tutaj określenie najwyższego podobieństwa pomiędzy komendą, a tym co zwrócił nam model.

Do tego zadania wykorzystaliśmy miarę zwaną odległością Levenshteina, która wskazuje na podobieństwo pomiędzy transkrypcją, a daną komendą. Polega ona na zliczaniu pozycji lub liter, które się nie zgadzają. Przykładowo, odległość Levenshteina pomiędzy wyrazami:

drzwi
drzwi

Jest zerowa. Są to wyrazy identyczne, więc nie potrzeba tutaj żadnych działań.

Natomiast odległość Levenshteina pomiędzy wyrazami:

kołacz
połać

wynosi 3, ponieważ potrzeba co najmniej 3 działań: zamiany k na p, zamiany c na ć i usunięcia litery z.

Tam, gdzie jest najmniej podstawień, posiadamy największe prawdopodobieństwo, że komendy są takie same.

Podsumowanie

Celem systemów rozpoznawania głosu jest zapewnienie łatwości w komunikacji między urządzeniem a człowiekiem. Podejście wykorzystujące narzędzia Open-Source w zadaniu uczenia modeli ASR na razie ogranicza się do rozpoznawania ograniczonego zbioru komend. Budowanie takiego sytemu w oparciu o dane w języku polskim jest trudnym zadaniem, ze względu na małą ilość danych dźwiękowych połączonych z transkrypcjami. Zastosowanie miary podobieństwa pomiędzy transkrypcją a zbiorem komend pozwala na zbudowanie użytecznego systemu ASR działającego w trybie offline. Biorąc pod uwagę aktualne trendy w wykorzystaniu inteligentnych urządzeń oraz możliwości techniczne, warto obserwować dalszy rozwój tych systemów i pojawiające się nowe zbiory danych.

Inero Software oferuje wiedzę i doświadczenie w zakresie skutecznego wykorzystywania najnowocześniejszych technologii i danych do kształtowania korporacyjnych produktów cyfrowych przyszłości.

W sekcji BLOG można znaleźć inne artykuły dotyczące nowoczesnych rozwiązań dla przedsiębiorstw.

Redakcja: Tymoteusz Cejrowski, Software Developer.

Artykuł Budowa systemu rozpoznawania komend głosowych w języku polskim pochodzi z serwisu Inero Software - Rozwiązania IT i Konsulting.

Skoruba dla Identity Server – przegląd modułu autoryzacyjnego dla Aplikacji .NET

Andrzej Chybicki — Mon, 07 Feb 2022 11:11:36 +0000

.NET Core daje nam wiele możliwości w zakresie budowania rozwiązań biznesowych w sektorze logistycznym, finansowym czy bankowym. Do najważniejszych zalet tego środowiska należą wbudowane mechanizmy uwierzytelniania i autoryzacji użytkowników czy umożliwienie budowania obiegu zgłoszeń w oparciu o moduły zwane middleware. Moduły te można wymienić w taki sposób, żeby zmienić zachowanie naszej aplikacji.

.NET Core pozwala nam także chronić naszą aplikację przed atakami typu: XSS, SQL Injection, CSRF czy Open Redirect Attack. Ponadto możemy łatwo wymusić na aplikacji używanie HTTPS zamiast mniej bezpiecznego HTTP. Dzięki .NET Core programiści mogą realizować proces autoryzacji na wiele sposobów, m.in.: autoryzacja oparta na rolach, oparta na oświadczeniach czy oparta na zasadach.

Z powyższych powodów rozwiązania .NET Core są często wykorzystywane w dużych organizacjach korporacyjnych i przedsiębiorstwach. Ze względu na ogromną liczbę użytkowników i skomplikowane procesy biznesowe systemy te wymagają złożonych i solidnych mechanizmów ochrony kont użytkowników oraz zarządzania tożsamościami w naszych aplikacjach.

Dlatego w tym krótkim poście przeglądowym udostępnimy jedno z narzędzi, które wykorzystaliśmy do bezpiecznej autoryzacji, zbudowane dla jednego z naszych klientów korporacyjnych, a mianowicie oparty na .NET projekt Skoruba.IdentityServer4.Admin.

Czym jest Skoruba?

Skoruba to projekt typu open source zapewniający interfejs użytkownika, który umożliwia administrowanie funkcjami IdentityServer4 i ASP.NET Core Identity. Dzięki temu projektowi jesteśmy w pewien sposób zwolnieni z tworzenia wizualnej strony funkcjonalności związanej z zarządzaniem użytkownikami. Główną zaletą tego projektu jest przyjazny interfejs użytkownika, który opiera się na Bootstrap i pozwala nam w bardzo efektywny sposób zarządzać użytkownikami, hasłami, uwierzytelnianiem dwuskładnikowym, rolami, klientami, zasobami czy strukturą tokenów dostępu i ich roszczeniami.

Źródło: https://github.com/skoruba/IdentityServer4.Admin

Dodatkowo Skoruba udostępnia również API, które możemy w dowolny sposób konsumować i na jego podstawie budować logikę związaną z zarządzaniem kontem w sposób, który będzie lepiej odpowiadał naszym wymaganiom biznesowym. Cała dokumentacja API jest dostępna dzięki Swagget, co pozwala nam testować poszczególne działania API.

Możliwość zmiany dostawcy bazy danych, w którym przechowujemy wszystkie informacje o tożsamości, jest również łatwiejsza i domyślnie mamy do wyboru takich dostawców, jak SQLServer, MySql i PostgreSQL.

Kolejną zaletą Skoruby jest bardzo dobrze rozwinięty mechanizm rejestrowania zdarzeń w naszej aplikacji oparty na bibliotece Serilog, co pozwala na bardzo sprawną identyfikację potencjalnych problemów występujących podczas działania aplikacji. Poniżej możesz zobaczyć wizualizację aplikacji Skoruby:

Źródło: https://github.com/skoruba/IdentityServer4.Admin

Jak Skoruba radzi sobie z rolami użytkowników? Przykład

W tym przykładzie widzimy, jak wygląda sekcja interfejsu, w której można modyfikować role użytkowników:

Gdybyśmy nie korzystali ze Skoruby, musielibyśmy to wszystko stworzyć sami, łącznie z logiką i sposobem, jak to dobrze zaprezentować. Daje nam to wiele funkcji, których nie musimy tworzyć, przez co możemy skupiać się bardziej na naszych wymaganiach biznesowych, zamiast tworzyć zupełnie nowy interfejs użytkownika do obsługi usług IdentityServer4 i ASP.NET Core Identity. Przykładowa logika, która pokazuje nam, w jaki sposób Skoruba generuje role użytkowników, jak przedstawiono powyżej, jest pokazana w poniższym bloku kodu:

public virtual async Task BuildUserRolesViewModel(TKey id, int? page)
{s
    var roles = await GetRolesAsync();
    var userRoles = await GetUserRolesAsync(id.ToString(), page ?? 1);
    userRoles.UserId = id;
    userRoles.RolesList = roles.Select(x => new SelectItemDto(x.Id.ToString(), x.Name)).ToList();

    return userRoles;
}

public virtual async Task GetUserRolesAsync(string userId, int page = 1, int pageSize = 10)
{
    var userExists = await IdentityRepository.ExistsUserAsync(userId);
    if (!userExists) throw new UserFriendlyErrorPageException(string.Format(IdentityServiceResources.UserDoesNotExist().Description, userId), 
    IdentityServiceResources.UserDoesNotExist().Description);

    var userIdentityRoles = await IdentityRepository.GetUserRolesAsync(userId, page, pageSize);
    var roleDtos = Mapper.Map(userIdentityRoles);

    var user = await IdentityRepository.GetUserAsync(userId);
    roleDtos.UserName = user.UserName;

    await AuditEventLogger.LogEventAsync(new UserRolesRequestedEvent(roleDtos));

    return roleDtos;
}

Co więcej? Jeśli chcemy, możemy zmienić wygląd interfejsu. Możemy również modyfikować zawartość witryny, zmieniając logikę, która będzie adekwatna do naszych potrzeb biznesowych.

Jeśli potrzebujesz więcej informacji o projekcie Skoruba i jego możliwości, wejdź na stronę projektu na GitHub: https://github.com/skoruba/IdentityServer4.Admin

Podsumowanie

W Inero Software zajmujemy się ambitnymi i wymagającymi projektami rozwoju oprogramowania. W tym wpisie na blogu pokazaliśmy, jak szybko można wykorzystać gotowe do użycia, istniejące rozwiązania open-source, aby zapewnić efektywny sposób wdrażania zabezpieczeń oprogramowania. Poza przedstawionym przypadkiem użycia, Skoruba i Identity Server mogą być wykorzystywane do pracy z urządzeniami mobilnymi, systemami IoT lub w ramach komunikacji M2M między maszynami lub robotami.

W sekcji BLOG można znaleźć inne artykuły dotyczące nowoczesnych rozwiązań dla przedsiębiorstw.

Artykuł Skoruba dla Identity Server – przegląd modułu autoryzacyjnego dla Aplikacji .NET pochodzi z serwisu Inero Software - Rozwiązania IT i Konsulting.

Repozytoria dokumentów w chmurze – jak rozpoznać odręczne podpisy w zeskanowanych dokumentach PDF

Adrian Chojnacki — Mon, 07 Feb 2022 09:56:58 +0000

Widzenie komputerowe i detekcja obiektów są coraz częściej wykorzystywane w automatyzacji procesów biznesowych. Wraz z dynamicznym rozwojem technologii, zwłaszcza sztucznej inteligencji, pojawia się wiele nowych innowacyjnych aplikacji biznesowych dla tego typu algorytmów. W tym artykule pokażemy Ci, jak zrobić to z YOLO v5, które w ostatnich latach stało się bardziej popularne. Jednym z ważnych aspektów ponad innymi rozwiązaniami jest szybkość wnioskowania. W ramach tego artykułu przedstawimy określony przypadek użycia i wszystkie etapy jego realizacji. Życzymy miłej lektury!

Studium przypadku

Podpisy są nadal jedną z najczęstszych metod uwierzytelniania dokumentów. Szczególnie w przypadku aplikacji korporacyjnych, identyfikacja podpisanych i niepodpisanych kopii dokumentów w repozytoriach cyfrowych może być czasochłonna i wymagająca. Jednak automatyzacja wspierana przez uczenie maszynowe może to ułatwić. W tym kontekście opiszemy możliwości detektora YOLO v5 oraz omówimy kwestie wykrywania podpisów na fakturach. Zacznijmy od przykładu pokazanego na poniższym rysunku. Na potrzeby tego badania przygotowaliśmy fałszywą fakturę, dane sprzedawcy, kupującego i samego produktu. Zbadajmy teraz, jak możemy skupić się na odręcznych podpisach (które też są fałszywe).

Zbieranie danych

Jednym z pierwszych kroków jest zebranie zestawu obrazów do trenowania modelu. Dla naszego przypadku przygotowaliśmy mały zestaw 10 przykładowych szkoleń z fakturami wypełnionymi różnymi danymi i rozszerzyliśmy ten zbiór o dedykowany skrypt w języku Python. Aby to ułatwić, użyliśmy Roboflow, który jest przydatnym narzędziem do tagowania danych. Tutaj możesz przesłać swój zbiór danych i wykonać szybki proces dodawania adnotacji, dokładnie jak na tym GIF-ie.

Dodatkowo możemy wygenerować więcej obrazów wyjściowych z losowymi wartościami obrotu, nasycenia, ekspozycji, szumu, rozmycia i innego rodzaju przekształceń. Co więcej, za pomocą tego narzędzia możemy określić nasz podział danych treningowych, walidacyjnych i testowych – domyślnie 70%, 10%, 10%. Jest to ważne, ponieważ dzięki temu zapobiegniemy przesunięciu naszego modelu (więcej o tym dowiesz się na tym blogu). Dzięki opisanemu narzędziu możemy wyeksportować nasz zbiór danych w formacie YOLO v5 Pytorch i umieścić go w katalogu naszego projektu. Poniższy rysunek przedstawia drzewo selekcji i drzewo docelowe, gdzie jednym z najważniejszych plików jest data.yml, który zostanie użyty do uczenia.

W naszym przypadku po pierwszym kroku augmentacji o skrypt Pythona generujemy 69 obrazów. Dodatkowo używamy opcji szumu w Roboflow, która pozwala nam ostatecznie wyeksportować 169 przykładów z adnotacjami. Nasze obrazy zostały ostatecznie podzielone, jak pokazano na poniższym rysunku.

Poniżej możesz zobaczyć kilka przykładów:

Konfiguracja i architektura modelu

Kolejnym krokiem w tym procesie jest zdefiniowanie konfiguracji i architektury modelu YOLO. Możemy zbudować własną strukturę sieciową, chociaż w wersji 5 mamy do dyspozycji jeden z następujących modeli:

YOLOv5s,
YOLOv5m,
YOLOv5l,
YOLOv5x.

Możemy użyć dowolnego z nich, ale pamiętajmy o przypisaniu do pliku docelowego odpowiedniej wartości parametru zwanej nc – liczba klas. W naszym przypadku jest to 1. Modele różnią się między sobą ilością użytych parametrów, szybkością klatek na sekundę (FPS), dokładnością itd.. Na poniższym rysunku widać, jak radzą sobie one z tym samym zbiorem danych COCO. Kliknij na obrazek, aby dowiedzieć się więcej.

Szkolenie

Co ważne, firma Ultralytics udostępnia nam YOLO v5 opracowany w PyTorch. Jest to framework wyspecjalizowany w uczeniu maszynowym. Dzięki temu możemy pobrać ich repozytorium z GitHub i wyszkolić własny detektor. Czego jeszcze potrzebujemy, aby wszystko działało dobrze?

Aby uruchomić każdy ze skryptów musimy zainstalować zależności zawarte w pliku requirements.txt. Jeśli używamy pip, możemy użyć następującego polecenia w terminalu. Pamiętaj, że musisz znajdować się w katalogu projektu.

pip install -r requirements.txt

W procesie instalacji problemem może być jedna rzecz. Mianowicie biblioteka PyTorch…

Inny system operacyjny, używany pakiet, język programowania itp. mogą wymagać określonego polecenia. W tym samouczku znajdziesz wszystko, czego potrzebujesz.

Załóżmy, że spełniłeś wszystkie wymagania. Możesz już rozpocząć szkolenie!

Do uruchomienia tego procesu wystarczy jedna linijka kodu, ale musimy się upewnić, że przygotowaliśmy dwa ważne pliki – data.yaml i np. yolov5l.yaml. Pierwszą powinieneś mieć z etapu zbierania danych, a drugą znajdziesz w repozytorium YOLO v5, w katalogu Models.

Przeprowadźmy szkolenie następującą komendą:

python train.py --data dataset/data.yaml --cfg models/yolov5l.yaml --weights ''

Powyższe polecenie jest najprostsze z możliwych. Dodatkowo można zdefiniować następujące opcje lub parametry:

img-size,
batch-size,
epochs,
name,
no-save,
cache…

Na potrzeby tego artykułu przeprowadziliśmy stosunkowo krótkie szkolenie dla obrazów o rozmiarze zmienionym do 416×416, wielkości partii 32 i 1500 epok. Po zakończeniu procesu wynikiem będzie plik o nazwie best.pt.

Możesz przerwać proces uczenia się, jeśli w danym momencie Twoje wagi są dla Ciebie optymalne. Szkolenie przerwaliśmy po 650 epokach, co w sumie trwało około 15 godzin. Trzeba pamiętać, że używany komputer nie posiada dedykowanej karty graficznej.

Szczegółowe metryki naszego szkolenia:

precision – 0.93507,
recall – 0.96429,
mAP_0.5 – 0.94755,
mAP_0.5:0.95 – 0.48702,

gdzie:

precision – mierzy, jak trafne są Twoje przewidywania,

recall – mierzy, jak dobrze oceniasz wszystkie pozytywy,

mAP_0.5 – średnia precyzja dla IoU* – 0,5

mAP_0.5:0.95 – średnia precyzja dla IoU* od 0,5 do 0,95 z krokiem 0,005,

* IoU (Intersection over Union) – mierzy nakładanie się dwóch granic. Dowiedz się więcej o wskaźnikach tutaj.

Wnioskowanie

Teraz, możemy przejść do wnioskowania na obrazach testowych. Jak pamiętasz, jeden z katalogów wyeksportowanych z Roboflow nazywał się test. Możemy z niego skorzystać, wstawiając w terminalu następującą linię.

python detect.py --weights best.pt --source dataset/test --conf 0.6 --img-size 600

gdzie conf jest ufnością modelu – wyższy oznacza mniej przewidywań.

Na koniec możemy zobaczyć wizualizację wyniku. Przybliżony czas wnioskowania na jednym obrazie testowym 416×416 wyniósł ~0,3s, natomiast dla 700×700 ~0,8s.

Podsumowanie

Do implementacji opisywanego detektora wykorzystaliśmy tylko 10 obrazów, rozszerzając zbiór danych o proces augmentacji. Dzięki narzędziu Roboflow możliwe było szybkie opisywanie i eksportowanie danych do formatu YOLO. Proces uczenia pozwolił nam uzyskać detektor celu, który skutecznie rozpoznaje podpisy na fakturach.

Należy pamiętać, że przy tak małym zbiorze danych jest on przystosowany tylko do rozpoznawania podobnych faktur. Gdybyśmy chcieli rozszerzyć możliwości naszego detektora, musielibyśmy wyposażyć się w lepszą kartę graficzną i więcej danych.

Aby uzyskać więcej informacji, odwiedź nas na naszej stronie internetowej lub śledź nas na LinkedIn.

Artykuł Repozytoria dokumentów w chmurze – jak rozpoznać odręczne podpisy w zeskanowanych dokumentach PDF pochodzi z serwisu Inero Software - Rozwiązania IT i Konsulting.

Adroid Kiosk Mode – jak zmienić urządzenie z Androidem w urządzenie do dedykowanego użytku

Andrzej Chybicki — Thu, 03 Feb 2022 14:08:19 +0000

Systemu Android nie trzeba przedstawiać. Obecnie jest to najbardziej popularny system operacyjny dla smartfonów. Jednak Android nie jest już używany tylko w elektronice użytkowej. Dziś urządzenia z Androidem możemy spotkać na każdym kroku. System ten jest coraz częściej stosowany w takich branżach jak: bezpieczeństwo, automatyzacja, logistyka, sprzedaż, hotelarstwo itp. Ze względu na łatwość użytkowania, poziom dostosowania i niższe koszty, urządzenia z Androidem są wybierane przez wiele przedsiębiorstw. Jednak dla wielu firm systemy Android nie są uważane za wystarczająco bezpieczne do użytku w miejscu pracy. Jednym z najlepszych rozwiązań dla powyższych problemów jest narzędzie Kiosk Mode, które pozwala przekonwertować Twoje urządzenie z Androidem w dedykowaną aplikację, zapewniając jednocześnie dodatkowe bezpieczeństwo i redukując dodatkowe elementy rozpraszające uwagę. Życzymy miłej lektury!

COSU – corporate-owned single use device (urządzenie do dedykowanego użytku dla firm)

W pełni zarządzane, dedykowane urządzenia służą określonemu celu. Dzięki temu możliwe jest maksymalne wykorzystanie urządzenia, przy jednoczesnym ograniczeniu korzystania z funkcji osobistych takich jak np. komunikatory. Z wieloma takimi urządzeniami mamy do czynienia na co dzień. Są to między innymi automaty, drukarki biletów czy parkomaty. COSU umożliwia administratorom IT zdalne sterowanie wszystkimi tymi urządzeniami i blokowanie urządzeń dla określonej aplikacji. Uniemożliwia to użytkownikom korzystanie z innych aplikacji lub wykonywanie innych czynności na tych urządzeniach.

Kiosk Mode

Kiosk Mode pozwala zamienić urządzenia z Androidem w urządzenia do dedykowanego użytku (Single-Use Device), uruchamiając tylko jedną aplikację lub określony zestaw aplikacji. Począwszy od Androida 5.0 Lollipop, system oferuje dwa sposoby blokowania urządzenia w określonym celu:

App pinning – korzystając z funkcji przypinania aplikacji, użytkownicy mogą tymczasowo przypiąć dowolną zainstalowaną aplikację na ekranie. Przyciski nawigacyjne są widoczne, ale nieaktywne. Użytkownik może wyjść z tego trybu, przytrzymując jednocześnie przycisk „Home” i „Recent apps”.
Lock task mode – jest to jeszcze skuteczniejszy sposób na przekształcenie urządzenia z Androidem w dedykowane urządzenie o tylko jednym przeznaczeniu. Tylko aplikacje umieszczone na białej liście przez Device Policy Controller (DPC) mogą być blokowane. Przyciski nawigacyjne są ukryte. Jest to tryb dostępny tylko dla właścicieli urządzeń.

Uruchomienie aplikacji w trybie Kiosk Mode daje nam szereg korzyści:

urządzenie działa jako pojedyncza platforma,
ukryte przyciski nawigacyjne (lock task mode),
nieaktywny pasek stanu,
automatyczne uruchamianie aplikacji wraz ze startem systemu,
wyłączone powiadomienia,
zablokowane połączenia przychodzące,
nieaktywne przejście do ustawień,
praca w trybie pełnoekranowym,

Jak włączyć tryb Android Kiosk Mode?

Pierwszym krokiem jest zaimplementowanie klasy dziedziczącej po klasie DeviceAdminReceiver:

class MyDeviceAdminReceiver : DeviceAdminReceiver() {
    companion object {
        fun getComponentName(context: Context): ComponentName {
            return ComponentName(context.applicationContext, MyDeviceAdminReceiver::class.java)
        }
    }
}

DeviceAdminReceiver to klasa, która zapewnia wygodę w interpretacji surowych działań intencji, które są wysyłane przez system.

Następnie musimy poinformować system, że nasza aplikacja ma zostać administratorem urządzenia. Możemy to zrobić dodając odbiornik w pliku AndroidManifest.xml:


          ...
      
            android:name=".MyDeviceAdminReceiver"
            android:description="@string/app_desc"
            android:label="@string/app_name"
            android:permission="android.permission.BIND_DEVICE_ADMIN">
            
                android:name="android.app.device_admin" />

W tym momencie możemy przystąpić do instalacji aplikacji. Pamiętaj, że jeśli chcesz przyznać uprawnienia administracyjne do aplikacji, musisz usunąć wszystkich istniejących użytkowników. Najprostszym sposobem jest przywrócenie fabrycznych ustawień urządzenia. Ważne jest, aby podczas pierwszego uruchomienia po resecie nie dodawać konta Google do urządzenia. Lista kroków do poprawnej konfiguracji jest następująca:

przywrócenie ustawień fabrycznych na urządzeniu mobilnym,
pominięcie dodawanie konta Google,
włączenie trybu deweloperskiego i debugowania USB na urządzeniu mobilnym,
zainstalowanie adb (Android Device Bridge) na swoim komputerze – jest on automatycznie instalowany z Android Studio,
zainstalowanie aplikacji na urządzeniu mobilnym za pomocą Android Studio lub wpisując w konsoli następujące polecenia:
1. ```
adb install path / to / kiosk / application.apk
```

nadanie uprawnień administratora urządzenia aplikacji:

adb shell dpm set-device-owner pl.inero.deliverM8 / .MyDeviceAdminReceiver

Użyj następującego fragmentu kodu, aby sprawdzić czy proces przyznawania się powiódł:

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        mDevicePolicyManager = getSystemService(Context.DEVICE_POLICY_SERVICE) as DevicePolicyManager
        val isAdmin = mDevicePolicyManager.isDeviceOwnerApp(packageName)
        if (isAdmin) {
            println("You are an admin")
        } else {
            println("You are not an admin")
        }
    }

W zależności od potrzeb możemy umożliwić użytkownikowi wyłączenie Kiosk Mode poprzez interfejs (np. poprzez potwierdzenie hasłem) lub całkowicie zablokować wyjście z aplikacji. Za pomocą poniższych fragmentów kodu postaram się wyjaśnić, w jaki sposób możesz kontrolować ustawienia, aby uzyskać rozwiązanie najlepiej odpowiadające Twoim potrzebom.

Jednym z parametrów, które możemy kontrolować jest to, czy utrzymujemy urządzenie włączone, gdy jest ono podłączone. „0” oznacza, że nigdy nie pozostaje włączone, gdy jest podłączone.

private fun enableStayOnWhilePluggedIn(active: Boolean) = if (active) {
        mDevicePolicyManager.setGlobalSetting(mAdminComponentName,
                Settings.Global.STAY_ON_WHILE_PLUGGED_IN,
                (BatteryManager.BATTERY_PLUGGED_AC
                        or BatteryManager.BATTERY_PLUGGED_USB
                        or BatteryManager.BATTERY_PLUGGED_WIRELESS).toString())
    } else {
        mDevicePolicyManager.setGlobalSetting(mAdminComponentName, Settings.Global.STAY_ON_WHILE_PLUGGED_IN, "0")
    }

Jeżeli chcemy nałożyć ograniczenia na użytkownika, możemy skorzystać z metody addUserRestrictrion (ComponentName admin, String key). Użytkownik urządzenia musi mieć uprawnienia administratora, w przeciwnym razie zostanie zgłoszony wyjątek bezpieczeństwa. Tę metodę można wywołać na instancji DevicePolicyManager.

mDevicePolicyManager = getSystemService (Context.DEVICE_POLICY_SERVICE) as DevicePolicyManager

W naszym przypadku zablokowaliśmy użytkownikowi przywracanie ustawień fabrycznych, dodawanie nowych użytkowników, podłączanie nośników zewnętrznych, kontrolowanie głośności urządzenia i wyłączanie paska statusu:

private fun setRestrictions(disallow: Boolean) {
        setUserRestriction(UserManager.DISALLOW_FACTORY_RESET, disallow)
        setUserRestriction(UserManager.DISALLOW_ADD_USER, disallow)
        setUserRestriction(UserManager.DISALLOW_MOUNT_PHYSICAL_MEDIA, disallow)
        setUserRestriction(UserManager.DISALLOW_ADJUST_VOLUME, disallow)
        mDevicePolicyManager.setStatusBarDisabled(mAdminComponentName, disallow)
    }
private fun setUserRestriction(restriction: String, disallow: Boolean) = if (disallow) {
        mDevicePolicyManager.addUserRestriction(mAdminComponentName, restriction)
    } else {
        mDevicePolicyManager.clearUserRestriction(mAdminComponentName, restriction)
    }

Jeżeli chcemy, aby nasza aplikacja startowała wraz ze startem systemu, to musimy dodać odpowiednie filtry:

private fun setAsHomeApp(enable: Boolean) {
        if (enable) {
            val intentFilter = IntentFilter(Intent.ACTION_MAIN).apply {
                addCategory(Intent.CATEGORY_HOME)
                addCategory(Intent.CATEGORY_DEFAULT)
            }
            mDevicePolicyManager.addPersistentPreferredActivity(
                    mAdminComponentName, intentFilter, ComponentName(packageName, MainActivity::class.java.name))
        } else {
            mDevicePolicyManager.clearPackagePersistentPreferredActivities(
                    mAdminComponentName, packageName)
        }
    }

W celu uruchomienia aplikacji w trybie pełnoekranowym należy dodać odpowiednie flagi:

private fun setImmersiveMode(enable: Boolean) {
        if (enable) {
            val flags = (View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                    or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                    or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                    or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                    or View.SYSTEM_UI_FLAG_FULLSCREEN
                    or View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
                    )
            window.decorView.systemUiVisibility = flags
            window.decorView.setOnSystemUiVisibilityChangeListener {
                window.decorView.systemUiVisibility = flags;
            }
        } else {
            val flags = (View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                    or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                    or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN)
            window.decorView.systemUiVisibility = flags
        }
    }

Na koniec używamy metod startLockTask() i stopLockTask(), aby włączyć/wyłączyć tryb blokady zadań:

private fun setLockTask(start: Boolean, isAdmin: Boolean) {
        if (isAdmin) {
            mDevicePolicyManager.setLockTaskPackages(
                    mAdminComponentName, if (start) arrayOf(packageName) else arrayOf())
        }
        if (start) {
            startLockTask()
        } else {
            stopLockTask()
        }
    }

Wynik

Powyższe operacje pozwalają zmienić urządzenie z systemem Android w urządzenie dedykowane, działające w trybie pełnoekranowym i uniemożliwiające użytkownikowi korzystanie z innych funkcjonalności. Na potrzeby egzemplifikacji naszej sprawy wykorzystaliśmy opracowaną w naszej firmie aplikację mobilną do zarządzania łańcuchem dostaw. Aplikacja ta jest częścią platformy DeliverM8, którą opracowaliśmy w celu optymalizacji i planowania zadań związanych z zarządzaniem łańcuchem dostaw dla Dostawy Ostatniej Mili. Wracając do tematu, efekt końcowy wygląda następująco:

Podsumowanie

W tym wpisie pokazaliśmy jak szybko skonfigurować aplikację mobilną, aby uzyskać jednocelowe urządzenie, które w jak największym stopniu spełnia nasze potrzeby. Korzystanie z Kiosk Mode niesie za sobą wiele korzyści, takich jak zwiększenie bezpieczeństwa czy ograniczenie dostępu do niepożądanych funkcjonalności, stworzenie rozwiązania dostosowanego zarówno do potrzeb pracowników (zarządzanie zasobami, zarządzanie transportem i logistyką) jak i klientów.

W sekcji BLOG można znaleźć inne artykuły dotyczące nowoczesnych rozwiązań dla przedsiębiorstw.

Artykuł Adroid Kiosk Mode – jak zmienić urządzenie z Androidem w urządzenie do dedykowanego użytku pochodzi z serwisu Inero Software - Rozwiązania IT i Konsulting.