Zwrócenie lokalizacji do zasobu po jego stworzeniu - CreatedAtRoute

Zasoby w WEB API ASP.NET Core tworzy się za pomocą akcji POST. Przykładowy kod tworzący zasób (w tym przypadku książkę):

    [HttpPost]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [ProducesResponseType(StatusCodes.Status500InternalServerError)]
    [ProducesResponseType(StatusCodes.Status200OK)]
    public async Task<ActionResult<BookDto>> CreateBook([FromBody] BookDto bookDto)
    {
        if (bookDto == null)
        {
            return BadRequest(bookDto);
        }

        if (bookDto.Id > 0)
        {
            return StatusCode(StatusCodes.Status500InternalServerError);
        }

        //Code to store book in data storage...

        return Ok(bookDto);
    }

Powyższy kod jest jak najbardziej poprawny i stworzy żądany zasób:

Czasami jednak potrzebujemy zwrócić lokalizację (link) do utworzonego zasobu. Z pomocą przychodzi metoda CreatedAtRoute. Pierwszym parametrem tej metody jest akcja którą chcemy wywołać. W tym przypadku zakładamy, że chcemy odesłać użytkownika do metody pozwalającej pobrać książkę po Id. HttpGet oprócz parametrów wejściowych pozawala nazwać akcję co następnie pozwoli jej użyć przy przekierowaniu. Tak więc nasza metoda GetBook powinna wyglądać następująco:

    [HttpGet("{id:int}", Name = nameof(GetBook))]
    [ProducesResponseType(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<BookDto>> GetBook(int id)
    {
        if (id <= 0)
        {
            return BadRequest();
        }
        //code...
     }

Następnie w metodzie HttpPost dokonujemy dwóch aktualizacji (obsługa HTTP Status Code 201 Created oraz wywołanie metody CreatedAtRoute):

    [HttpPost]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [ProducesResponseType(StatusCodes.Status500InternalServerError)]
    [ProducesResponseType(StatusCodes.Status201Created)]
    public async Task<ActionResult<BookDto>> CreateBook([FromBody] BookDto bookDto)
    {
        if (bookDto == null)
        {
            return BadRequest(bookDto);
        }

        if (bookDto.Id > 0)
        {
            return StatusCode(StatusCodes.Status500InternalServerError);
        }

        //Code to store book in data storage...

        return CreatedAtRoute(nameof(GetBook), new { id = bookDto.Id }, bookDto);
    }

Po uruchomieniu i przetestowaniu kodu w Headerach otrzymamy link do lokalizacji nowo utworzonego zasobu:

Otwierając ten link w przeglądarce możemy potwierdzić, że zasób został poprawnie stworzony:

Swagger Undocumented Status Code - dokumentacja kodów zwracanych przez akcje Controllera

Poniższy kawałek kodu obrazuje prostą metodę zwracającą pojedynczą książkę na podstawie jej identyfikatora. Jeżeli identyfikator jest mniejszy lub równy zero zwracamy błąd Http Status Code 400 (zakładamy w tym przypadku, że w naszej bazie danych książki posiadają identyfikatory od 1 w górę).

    [HttpGet("{id:int}")]
    public async Task<ActionResult<BookDto>> GetBook(int id)
    {
        if (id <= 0)
        {
            return BadRequest();
        }
        //... Code, code...
     }

Kod jest jak najbardziej poprawy. Co może nas zdziwić, to że uruchamiając aplikację i testując ją pojawi nam się dziwny komunikat o braku dokumentacji dla kodu 400:

Powyższy brak można rozwiązać za pomocą atrybutu ProducesResponseType. Za jego pomocą definiujemy możliwe rezultaty z naszej metody jak i możemy jawnie wskazać scheme którą zwraca nasz serwis (w naszym przypadku nie jest to potrzebne ponieważ zwracamy typ ActionResult<BookDto>>):

    [HttpGet("{id:int}")]
    [ProducesResponseType(StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<BookDto>> GetBook(int id)
    {
        if (id <= 0)
        {
            return BadRequest();
        }
        //...code, code...
    }

Uruchamiając ponownie aplikacje z powyższą modyfikacją informacja Undocumented nie pojawi się ponownie. Dodatkowo poniżej otrzymamy listę wszystkich możliwych kodów rezultatów

Różnica między ControllerBase i Controller (MVC vs API)

Tworząc aplikację MVC Core lub API Core możemy nasz Controller dziedziczyć z jednej z dwóch klas ControllerBase lub Controller. 

Ogólna zasada dziedziczenia jest następująca:

• ControllerBase - klasa bazowa dla projektów API
• Controller - klasa bazowa dla projektów MVC

Klasa Controller zawiera składowe specyficzne dla widoków MVC. Zdecydowanie w API nie będą one przydatne. Przykładowo udostępnia takie właściwości jak ViewBag, ViewData, TempData, itp.

Wyjątkiem jest sytuacja, kiedy zamierzamy wykorzystać te same Controllery w aplikacji MVC i API. Dziedziczenie po Controller jest wtedy uzasadnione.  

    public class ApiController : ControllerBase
    {

    }

    public class MvcController : Controller
    {

    }

API ASP.NET Core - Walidacja danych wejściowych

 Dane wejściowe w API możemy sprawdzać na dwa sposoby:

1. Korzystając z atrybutów walidacji na modelu
2. Tworząc własną logikę walidacji w klasie Controllera

1. Stworzenie walidacji jako atrybutu modelu

Jako przykład możemy stworzyć atrybut, który sprawdzi, że wszystkie znaki ciągu teksu są wielkimi literami:

using System.ComponentModel.DataAnnotations;
using System.Globalization;
using static System.String;

namespace BookStoreApi;

[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
public class UpperCaseAttribute : ValidationAttribute
{
    public UpperCaseAttribute() : base("All characters for {0} field must be upper case")
    {
    }

    public override bool IsValid(object? value)
    {
        return (value is string str) && str.All(char.IsUpper);
    }

    public override string FormatErrorMessage(string name)
    {
        return Format(CultureInfo.CurrentCulture, ErrorMessageString, name);
    }
}

Ważniejsze punkty implementacji

• klasa którą implementuje powinna dziedziczyć po ValidationAttribute
• W konstruktorze możemy (anie nie musimy) przekazać error message, który zostanie wyświetlony użytkownikowi jeżeli walidacja się nie powiedzie. Możemy także zostawić miejsce na nazwę pola, która zostanie wstrzyknięta do wiadomości błędu - {0}
• Metoda FormatErrorMessage zawiera parametr name, który reprezentuje sprawdzane pole

Atrybut dodajemy na pole naszego obiektu DTO i możemy sprawdzić jego działanie:

public class BookDto
{
    public int Id { get; set; }

    [Required, MaxLength(250), MinLength(3)]
    public string Name { get; set; }

    [Required, MaxLength(250), MinLength(3), UpperCase]
    public string Author { get; set; }

    public int PublishYear { get; set; }
}

2. Własna logika w klasie Controllera

Logikę walidacji można także zawrzeć bezpośrednio w klasie Controllera:

    public async Task<ActionResult<BookDto>> CreateBook([FromBody] BookDto bookDto)
    {
        if (bookDto == null)
        {
            return BadRequest(bookDto);
        }

        if (bookDto.Id > 0)
        {
            return StatusCode(StatusCodes.Status500InternalServerError);
        }

        if (!bookDto.Author.All(char.IsUpper))
        {
            ModelState.AddModelError("AuthorValidation", "All characters for Author field must be upper case ccc");
            return BadRequest(ModelState);
        }
        //... code....
     }

Po uruchomieniu aplikacji i przetestowaniu, analogicznie jak poprzednio otrzymamy błąd w przypadku gdy pole Author będzie zawierało jakiekolwiek małe litery. 

Obydwa sposoby walidacji są jak najbardziej poprawne. Drugi z jednej strony może wydawać się mniej skomplikowany (mniej kodu), jednak stworzenie atrybutu pozwala na jego łatwe re-używanie.

OWASP 2017 - 10 najczęstszych zagrożeń aplikacji internetowych (web) - A3 - A10

Kolejnymi zagrożeniami na liscie OWASP 2017 są:

A3. Sensitive Data Exposure

Powszechne zagrożenie dla aplikacji internetowych - wyciek danych. Dane te to np. numery PESEL, karty kredytowe etc. Najczęstszą przyczyną wycieków tych danych są słabe zabezpieczenia bazy danych, brak szyfrowania danych czy też użycie słabych algorytmów szyfrowania. 

W jaki sposób zapobiec wyciekowi poufnych danych?

• ogranicz ilość przechowywanych danych. Być może nie potrzebujesz ich w ogóle w aplikacji? Jeżeli jednak są wymagane do poprawnego działania systemu sprawdź regulacje prawne 
• szyfruj dane oraz użyj bezpiecznych protokołów (TLS)
• szyfruj hasła używając silnych algorytmów (Argon2, PBKDF2). Unikaj stosowania MD5, SHA1, SHA256. Bądź na bieżąco z obecnymi standardami - algorytmy zmieniają się, wymyślane są nowe
• kiedy przeglądarka wyświetla poufne dane dodaj dyrektywy, które zapobiegną użycia cache dla poufnych informacji

A4. XML External Entities (XXE)

External Entities to elementy pozwalające budować XML w sposób dynamiczny. Podczas przetwarzania XMLa umożliwiają wstrzykiwanie definicji elementów z zewnętrznych źródeł.

Kiedy aplikacja jest narażona na ten typ ataku?

• aplikacja jako dane wejściowe przyjmuje bezpośrednio XML
• użycie SOAP < 1.2
• SOAPowy serwis używa DTD (document type definitions)

A5. Broken access control

Atakujący uzyskuje dostęp do funkcjonalności, do których normalnie nie miałby dostępu. Może się to odbyć np. poprzez modyfikację adresu url strony i uzyskanie dostępu do panelu administracyjnego, bądź też funkcji która jest normalnie widoczna tylko dla moderatora/administratora. 

W jaki sposób bronić się przed tym typem ataku?

• warstwa autoryzacji powinna być zaimplementowana w jednym komponencie i reużywana przez wszystkie inne składowe systemu
• domyślnie zawsze zabraniamy dostępu do danego zasobu
• logujemy błędne próby logowania i analizujmy incydenty związane z wieloma próbami zalogowania się przy użyciu błędnych uwierzytelnień 
• sesja użytkownika powinna być prawidłowo kończona po jego wylogowaniu z systemu

A6. Security misconfiguration

Ten typ zagrożenia wynika z stosowania domyślnych kont administratora, pozostawianiu niezabezpieczonych folderów na serwerze itp. Atakujący może w ten sposób dowiedzieć się więcej o systemie i poznać jego słabe punkty. Zagrożenia tego typu możemy spodziewać się na każdym poziomie: sieć, system, framework, aplikacja. 

W jaki sposób zapobiegać tego typu atakom?

• automatyzacja manualnej konfiguracji (zwłaszcza powtarzalnej konfiguracji)
• środowiska (testowe, dweloperskie i produkcyjne) powinny mieć taka samą konfigurację
• nie instalujemy na serwerach zbędnego oprogramowania
• cyklicznie aktualizujemy system serwera i oprogramowanie na nim zainstalowane

A7. Cross-Site Scripting (XSS)

Atak ten polega na umieszczeniu niebezpiecznego kodu w treści strony. Nieświadomy użytkownik wchodząc na stronę uruchamia niepożądany kod infekując swój komputer. XSS dzielimy na trzy typy: Reflected XSS, Stored XSS, DOM based XSS. 

Jak się zabezpieczyć przed tego typu atakiem?

• używajmy gotowych narzędzi w frameworkach
• poznajmy słabe strony frameworka, który używamy
• sprawdzamy dane pochodzące od użytkownika
• unikamy pracy z czystym HTMLem/JSptem

A8. Insecure deserialization

Zagrożenie to polega na wprowadzeniu do zserializowanej wiadomości nieuprawnionej treści. Treść ta może wpłynąć na sposób przetwarzania kodu, wywołać funkcje, których w normalnym procesowaniu byśmy nie wywołali. 

Najlepszym sposobem obrony przed tym typem ataku jest nie przyjmowanie zserialozowanej treści z nieznanych źródeł. Innym sposobem walki jest deserializacja obiektów w odizolowanym środowisku z bardzo niskimi uprawnieniami. Nawet jeżeli do naszego systemu przedostanie się niechciany pakiet danych nie będzie on miał uprawnień do wykonania niebezpiecznych operacji. Monitorowania i logowanie błędów deserializacji - bardzo często da nam to informacje z jakiego źródła pochodzą podejrzane wiadomości. 

A9. Using components with known vulnerabilities

Tu sprawa wydaje się dosyć prosta. Oprogramowanie zmienia się. Frameworki zmieniaja się. Wykrywane są nowe błędu i publikowane poprawki do nich. Uruchamiając aplikację w środowisku produkcyjnym musimy mieć świadomość, że po pewnym czasie będziemy musieli uaktualnić działające na nim oprogramowanie, framworki, bazy danych itp. 

Dobrym sposobem zabezpieczenia jest także ograniczenie ilości oprogramowania uruchomionego na środowisku produkcyjnym - instalujemy tylko to co jest niezbędne. Warto także prowadzić i przestrzegać harmonogramu uaktualniania oprogramowania co pozwoli być na bieżąco ze wszystkimi aktualizacjami. Jeżeli instalujemy oprogramowanie - używajmy oficjalnych kanałów. Warto także monitorować serwisy poświęcone tematyce bezpieczeństwa np. https://www.cvedetails.com/version-search.php. 

A10. Insufficient logging and monitoring

To przykład w jaki sposób pominięcie dobrego monitorowania i logowania może zagrozić naszemu systemowi. Atakujący wręcz liczy, że przez źle zaimplementowany monitoring zyska czas potrzebny do przeprowadzenia skutecznego ataku. Można też pójść w drugą stronę - logować zbyt wiele co prowadzi do kompletnego chaosu i uniemożliwia analizę logów. 

Dobre logowanie przechwyci z pewnością wszelkie próby logowania do systemu z błędnymi poświadczeniami (dane te następnie możemy wykorzystać i zablokować potencjalnego atakującego). Logowanie powinno być spójne i przechowywane w centralnym miejscu umożliwiającym analizę danych. Możemy na przykład skorzystać z ELK bądź Splunk w celu magazynowania i przetwarzania logów. Oprócz logowania musimy zadbać też o odpowiednie powiadamianie. 

OWASP 2017 - 10 najczęstszych zagrożeń aplikacji internetowych (web) - A2. Broken Authentication

Drugim najczęściej występującym problemem bezpieczeństwa aplikacji internetowych jest błędnie zaimplementowana autoryzacja użytkowników. 

Kiedy aplikacja może być podatna na ten rodzaj ataku?

• aplikacja zezwala na proste hasła, które są dobrze znane (np. admin123)
• domyślne hasło dla administratora nie zostało zmienione podczas implementacji rozwiązania u klienta
• brak zabezpieczenia przed atakami typu brute-force
• brak możliwości użycia logowania wieloetapowego (np. za pomocą hasła i SMSa)
• odzyskiwanie hasła za pomocą metod pamięciowych (np. pytania typu jak się nazywało Twoje pierwsze zwierze)
• użycie słabych algorytmów szyfrowania haseł w bazie, przechowywanie ich w formie tekstu
• Brak zarządzania sesjami użytkowników. Sesja nie wygasa co powoduje możliwość jej przejęcia przez atakującego.

W jaki sposób można się zabezpieczyć przed tym typem zagrożenia?

• zmień domyślne hasła przed wgraniem systemu na produkcję
• użyj algorytmów sprawdzających siłę i składnię hasła które chce użyć użytkownik, wymuś stosowanie silnych haseł
• wprowadź możliwą ilość błędnych logowań do systemu, bądź też wprowadź czasowy odstęp miedzy ponownymi próbami logowania. Dodaj alerty w systemie monitorującym w przypadku gdy ktoś próbuje w kółko logować się używając błędnego hasła
• zaimplementuj wieloetapową autoryzację
• logika odzyskiwania hasła, podobnie jak autoryzacja może przebiegać wieloetapowo
• zarządzanie sesjami użytkowników powinno odbywać się tylko na serwerze aplikacji. Nie twórz własnych rozwiązań do generowania sesji - użyj gotowych, dopracowanych rozwiązań.

OWASP 2017 - 10 najczęstszych zagrożeń aplikacji internetowych (web) - A1. Injection

OWASP (Open Web Application Security Project) - otwarta społeczność tworząca artykuły, metodologie, narzędzia związane z bezpieczeństwem aplikacji internetowych. W ostatnich dniach miałem okazję wziąć udział w szkoleniu z tego zagadnienia i myślę, że warto się podzielić tą wiedzą.

Szkolenie dotyczyło 10 największych ryzyk bezpieczeństwa w zaktualizowanej wersji (2017). Jak można się domyślić co jakiś czas lista jest aktualizowana. Wynika to ze względu i na postęp technologiczny (frameworki rozwiązują część problemów) jak i nowe metodyki ataków na aplikacje internetowe. 

Jak przedstawia się lista OWASP 2017?

A1. Injection

A2. Broken authentication

A3. Sensitive data exposure

A4. XML External Entities (XXE)

A5. Broken access control

A6. Security disconfiguration

A7. Cross-site scripting (XSS)

A8. Insecure deserialization

A9. Using components with known vulnerabilities 

A10. Insufficient logging and monitoring

Listę rozpoczyna Injection który króluje na niej od 2010 roku. Najłatwiej można go opisać jako możliwość przesłania nieprawidłowych danych do zapytań. Konsekwencje tego zagrożenia:

• dostęp do danych, których nie powinien widzieć atakujący
• uruchamianie komend systemowych

Gdzie możemy spotkać się z tym typem ataków? Zapewne każdy kojarzy możliwość wstrzykiwania niepożądanego kodu do zapytań SQL. Oprócz SQL atakujący może eksplorować także:

• LDAP
• SMTP
• OS Commands
• Enviromental Variables
• NoSQL

W jaki sposób chronić się przed tym atakiem?

• użycie frameworków (np. ORM przy dostępie do danych)
• oddzielenie parametrów zapytań od samego zapytania (użycie parametrów zamiast łączenia zapytania za pomocą stringów)
• jeżeli jest to możliwe, zabronienie używania użytkownikowi systemu specjalnych znaków w zapytaniach
• przeglądanie kodu w poszukiwaniu słabych punktów
• użycie statycznej/dynamicznej analizy kodu na serwerze CI (np. Veracode scan)

W kolejnych postach omówię kolejne typy zagrożeń