Autentykacja przy użyciu tokena

[info] Jeśli pracujesz na laboratorium, aby rozpocząć realizację kolejnego modułu, musisz wykonać poniższe operacje

• sklonuj repozytorium ze swoim kodem (git clone ŚCIEŻKA_DO_REPOZYTORIUM),

• zainstaluj potrzebne gemy (bundle install --path vendor/bundle),

• dokonaj migracji bazy danych (rails db:migrate)

• uruchom serwer (rails server)

Autentykacja użytkownika w naszej aplikacji jest dotąd realizowane przez ciasteczko sesji, które przeglądarka uzyskuje od serwera po wysłaniu mu w formularzu odpowiednich danych logowania. W wypadku komunikacji z poziomu interfejsu programistycznego, wygodniejszym rozwiązaniem jest uzyskanie w tym samym procesie tak zwanego tokena, który będziemy mogli dodawać jako nagłówek do każdego zapytania wymagającego autentykacji.

Dla wersji 5 frameworka Ruby on Rails jest to operacja relatywnie łatwa i zbliżona do procesu dodawania do użytkownika bezpiecznego hasła. W podobny sposób dodajemy więc do modelu studenta (Student.rb) informację o wyposażeniu go w token.

has_secure_token

Niestety, metoda usuwania tokena nie jest domyślne zaimplementowana. Szalenie przyda się ona przy wylogowywaniu (deautentykacji) użytkownika, więc zaimplementujmy ją w modelu studenta ręcznie.

def invalidate_token
  self.update_columns(token: nil)
end

Deklaracja istnienia tokena jeszcze nie dodaje go do bazy, więc musimy stworzyć odpowiednią migrację.

• rails generate migration AddTokenToStudents token:string

class AddTokenToStudents < ActiveRecord::Migration[5.1]
  def change
    add_column :students, :token, :string
    add_index :students, :token
  end
end

Nie zapomnijmy o zmigrowaniu bazy.

• rails db:migrate

Logowanie jako uzyskiwanie tokena

Teoretycznie moglibyśmy w tej chwili stworzyć nowy kontroler, odpowiedzialny wyłącznie za uzyskiwanie i deautentykowanie tokena. Jeśli jednak spojrzymy na niego jak na odpowiednik ciasteczka przewidziany dla innej reprezentacji danych (json zamiast html), możemy utożsamić uzyskiwanie tokena z logowaniem, a pozbywanie się go z wylogowywaniem. Możliwa więc będzie wspólna implementacja dla wszystkich reprezentacji w kontrolerze sesji.

Poprawiamy metodę create w kontrolerze sesji, aby jej zachowanie zależało od oczekiwanej przez klienta reprezentacji. Chwilowo uznajmy, że przy html zachowywać się będzie tak samo jak dotąd, a przy wymaganym json nie będzie wykonywać żadnej logiki poza wysłaniem odpowiedzi w formacie json z komunikatem o próbie logowania.

  def create
   respond_to do |format|
     student = Student.find_by(index: params[:session][:index])
     if student && student.authenticate(params[:session][:password])
       format.html {
         log_in student
         redirect_to student
       }
       format.json {
         render json: { message: 'Poprawne dane' }
       }
     else
       format.html {
         render 'new'
       }
       format.json {
         render json: { message: 'Niepoprawne dane' }
       }
     end
   end
 end

Przy generowaniu formularzy, Ruby on Rails domyślnie ukrywa w nich parametr, który weryfikuje później po wysłaniu, aby upewnić serwer, że dane pochodzą z wygenerowanego w widoku formularza. W wypadku danych wysłanych bezpośredniu do API, nie dysponujemy tym parametrem. Aby nie kłopotać się tym w tej chwili, wyłączamy zabezpieczenie w kontrolerze.

class SessionsController < ApplicationController
  skip_before_action :verify_authenticity_token
  ...
end

Spróbujmy wysłać zapytanie z próbą logowania.

• curl -X POST -d '{"index": 123456, "password": "haslo123"}' -H "Accept: application/json" -H "Content-Type: application/json" http://localhost:3000/login

Otrzymamy zaplanowany plik json, w zależności od poprawności danych.

{"message":"Poprawne dane"}

lub

{"message":"Niepoprawne dane"}

Przy wprowadzeniu poprawnych danych, zamiast komunikatu, powinniśmy otrzymać token. Poprawmy więc kod, renderując plik JSON z jednoelementowym słownikiem zawierającym token.

if student && student.authenticate(params[:session][:password])
  format.html {
    log_in student
    redirect_to student
  }
  format.json {
    render json: { token: student.token }
  }
  else
  ...
  end
end

Wyślijmy raz jeszcze poprawne zapytanie logowania.

{"token":null}

Otrzymujemy token, ale jest on pusty. To całkowicie logiczne, ponieważ jeszcze go nie wygenerowaliśmy. Będzie to jednak możliwe jedynie, jeśli po autentykacji, do obiektu student przypiszemy hasło. Wydaje się to nielogiczne, ale cóż, inaczej walidator hasła odrzuci zapytanie i wygeneruje wewnętrzny błąd aplikacji.

format.json {
  student.password = params[:session][:password]
  student.regenerate_token
  render json: { token: student.token }
}

Po kolejnej próbie autentykacji powinniśmy już otrzymać token. Udało się nam obsłużyć generowanie tokenów.

Autentykacja przy użyciu tokena

Tokeny mają służyć nam za narzędzie do autentykacji użytkowników. Musimy więc być w stanie określić, które metody wymagają podania go, a które nie. Uzupełnijmy więc helper sesji o metodę require_token, która będzie określać to wymaganie.

  def require_token
    respond_to do |format|
      format.json {
        authenticate_token || render_unauthorized("Access denied")
      }
      format.html { }
    end
  end

W wypadku, kiedy żądanym formatem jest html, nie dzieje się nic szczególnego. W wypadku, kiedy wymaganym formatem jest json, uruchamiamy komendę authenticate_token, a jeśli niczego nie zwróci, komendę render_unauthorized z odpowiednim komunikatem błędu.

Potrzebujemy więc jeszcze dwóch metod. Najpierw authenticate_token, która weryfikuje token podany w nagłówku zapytania i jeśli znajdzie jakieś dopasowanie wśród studentów, ustawia odpowiednio pole @current_student.

  def authenticate_token
    authenticate_with_http_token do |token, options|
      @current_student ||= Student.find_by(token: token)
    end
  end

Drugą metodą jest render_unauthorized(), przyjmujące żądany komunikat błędu i renderujące go użytkownikowi.

  def render_unauthorized(message)
    errors = { errors: [ { detail: message } ] }
    render json: errors, status: :unauthorized
  end

Dokonajmy logowania i zanotujmy sobie token.

• curl -X POST -d '{"index": 123456, "password": "haslo123"}' -H "Accept: application/json" -H "Content-Type: application/json" http://localhost:3000/login

{"token":"UZYSKANY_TOKEN"}

Potrzebujemy jeszcze akcji, którą zabezpieczymy autentykacją. Na te potrzeby, stworzymy nową metodę kontrolera static. Będzie to metoda feed, listująca nam wszystkie informacje o kursach, do których zapisany jest autentykowany student. Rozpoczniemy od odpowiedniego wpisu w routes.

get    '/feed',   to: 'static#feed'

Następnie uzupełnimy kontroler static o pustą metodę feed.

class StaticController < ApplicationController
  def index
    @students = Student.all
    @courses = Course.all
  end

  def feed

  end
end

Spróbujmy przygotować widok app/views/static/feed.html.erb, w którym zmieścimy pożądane informacje w formacie html..

<ul>
<% for course in current_student.courses do %>
  <li><%= course.name %></li>
  <ul>
  <% for topic in course.topics do %>
    <li><%= topic.title %></li>
    <ul>
      <% for post in topic.posts %>
        <li><%= post.body %></li>
      <% end %>
    </ul>
  <% end %>
  </ul>
<% end %>
</ul>

Iterujemy wszystkie kursy aktualnie zalogowanego studenta. Wyświetlamy nazwę kursu i iterjujemy wszystkie tematy. Wyświetlamy tytuł tematu i listujemy wszystkie posty, wyświetlając ich ciała. Upewnijmy się, że jesteśmy zalogowani i odwiedźmy adres http://localhost:3000/feed.

Faktycznie udało nam się przygotować widok, którego oczekiwaliśmy.

Zajmiemy się teraz przygotowaniem widoku w formacie json. Posłuży nam do tego jbuilder. Utwórzmy pusty plik app/views/static/feed.json.jbuilder. Nie zmieniając niczego odwiedźmy http://localhost:3000/feed.json.

Wygenerował się pusty słownik w formacie json. Możemy teraz Spróbujmy więc odtworzyć widok, który stworzyliśmy już w html, tym razem w formacie json.

Zacznijmy od małych kroków. Wypełnianie słownika JSON działa na poniższej zasadzie.

json.klucz 'wartosc'

Jeśli wypełnimy tak nasz widok, na widoku uzyskamy poniższą zawartość.

{"klucz":"wartosc"}

Załóżmy, że jako wartość dla klucza courses chcemy wypisać wszystkie informacje z kursów.

json.courses current_student.courses

Otrzymamy poniższy widok.

{
   "courses":[
      {
         "id":1,
         "name":"Aplikacje mobilne",
         "code":"1234",
         "description":"Opis kursu",
         "created_at":"2017-11-12T22:21:11.497Z",
         "updated_at":"2017-11-12T22:21:11.497Z"
      },
      {
         "id":2,
         "name":"Inny kurs",
         "code":"4321",
         "description":"Opis innego kursu",
         "created_at":"2017-11-12T22:21:11.500Z",
         "updated_at":"2017-11-12T22:21:11.500Z"
      }
   ]
}

Nie są nam niezbędne wszystkie dane. Szczęśliwie możemy wybrać konkretne pola. Przykładowo:

• identyfikator kursu,

• nazwę kursu,

• opis kursu.

json.courses current_student.courses do |course|
  json.id course.id
  json.name course.name
  json.description course.description
end

{
   "courses":[
      {
         "id":1,
         "name":"Aplikacje mobilne",
         "description":"Opis kursu"
      },
      {
         "id":2,
         "name":"Inny kurs",
         "description":"Opis innego kursu"
      }
   ]
}

Możemy także wyświetlić w słowniku kursu, pod kluczem topics informacje o wszystkich tematach.

json.courses current_student.courses do |course|
  json.id course.id
  json.name course.name
  json.description course.description
  json.topics course.topics
end

Oczywiście, i je możemy zagnieździć, żądając jedynie określonych danych. Tak samo, w tematach, możemy wyświetlić opisane posty.

json.courses current_student.courses do |course|
  json.id course.id
  json.name course.name
  json.description course.description
  json.topics course.topics do |topic|
    json.id topic.id
    json.title topic.title
    json.student_id topic.student.id
    json.posts topic.posts do |post|
      json.id post.id
      json.body post.body
      json.student_id post.student.id
    end
  end
end

W przeglądarce wszystko działa należycie, ponieważ jesteśmy aktualnie zalogowani. Co jednak z interfejsem programistycznym? Na początek ustalamy w kontrolerze statycznym wymaganie, aby przy uruchamianiu metody feed, przez metodę require_token weryfikowany był token.

class StaticController < ApplicationController
  ...
  before_action :require_token, only: [:feed]
  ...
end

Możemy teraz spróbować wysłać zapytanie. Zostanie odrzucone z braku tokena.

• curl -X GET http://localhost:3000/feed.json

{"errors":[{"detail":"Access denied"}]}

Wyślijmy je więc z tokenem. Musimy w tym celu umieścić w zapytaniu nagłówek (-H) o kluczu Authentication i wartości Token token=WARTOŚĆ_TOKENA. Na początek wyślijmy w nim bzdurę.

• curl -H "Authorization: Token token=bzdura" http://localhost:3000/feed.json

{"errors":[{"detail":"Access denied"}]}

Zapytanie zostało ponownie odrzucone. Teraz wyślijmy poprawny token.

• curl -H "Authorization: Token token=UZYSKANY_TOKEN" http://localhost:3000/feed.json

{
   "courses":[
      {
         "id":1,
         "name":"Aplikacje mobilne",
         "description":"Opis kursu",
         "topics":[
            {
               "id":1,
               "title":"Co z tą Polską?",
               "student_id":1,
               "posts":[
                  {
                     "id":1,
                     "body":"Sam nie wiem",
                     "student_id":1
                  },
                  {
                     "id":2,
                     "body":"Ja też",
                     "student_id":2
                  }
               ]
            },
            {
               "id":2,
               "title":"Jak żyć?",
               "student_id":2,
               "posts":[

               ]
            }
         ]
      },
      {
         "id":2,
         "name":"Inny kurs",
         "description":"Opis innego kursu",
         "topics":[

         ]
      }
   ]
}

Wygląda na to, że mamy działającą autentykację. Przydatne będzie jeszcze dodanie deautentykacji. Uzupełnijmy więc metodę destroy kontrolera sesji, aby przy formacie json dewalidował token aktualnego studenta.

  def destroy
    respond_to do |format|
      format.html do
        log_out
        redirect_to root_url
      end
      format.json do
        require_token
        if current_student
          current_student.invalidate_token
          head :ok
        end
      end
    end
  end

Spróbujmy wysłać zapytanie deautentykacji.

• curl -X DELETE -H "Authorization: Token token=UZYSKANY_TOKEN" http://localhost:3000/logout.json

Token powinien zostać usunięty. Powtórna próba uzyskania zasobu /feed z tokenem nie powinna już zadziałać.

[info] Aktualny kod

Na koniec każdego modułu znajduje się łącze do pełnej wersji kodu, który powinien być jego wynikiem.

• Wprowadzone zmiany

• Pełen kod