Lekce 10 - Derby DB - Práva přístupu - Autentizace

V předchozím kvízu, Kvíz - Embedded databáze a práce s tabulkami Derby DB v Javě, jsme si ověřili nabyté zkušenosti z předchozích lekcí.

Dnešní DerbyDB tutoriál bude o autentizaci.

Podrobný popis nastavení práv se nachází v Security guide.pdf (tvz. identity v Derby). Derby má trochu odlišný způsob nastavování přístupu k databázím a tabulkám oproti standardním databázím typu např. MySQL, MS-SQL, PostgreSQL, apod. Dále nedisponuje žádným GUI nástrojem (jako např. WorkBench u MySQL) pro správu práv a vše se musí řešit přes IJ nástroj nebo programově přes Javu, což osobně považuji za velký nedostatek oproti zmíněným databázím.

Pro systém přístupu a práci s Derby databází nepotřebujeme mít více uživatelů. Lze mít jen jednoho, který má přístup ke všemu (tzv. správce databáze = stvořitel databáze). Tento správce má následně přístup do každé tabulky se všemi právy (čtení, zápisu, úpravy, smazání, apod.). Ovšem z důvodu bezpečnosti, správy a kontroly se toto nedoporučuje. Nicméně pokud byste používali embedded databázi jako součást desktop aplikace pro úschovu dat, pak je systém práv v tomto případě naprosto zbytečný.

V následujících lekcích si předvedeme něco o nastavení práv přístupu s více uživateli.

Pro nastavení přístupu k databázi se využívají tyto činnosti:

• Autentizace (Authentification) : Dochází k ověření předtím, než uživatel dostane přístup (např. při přihlašování k databázi).
• Autorizace (Authorization): Po úspěšném ověření dojde k přidělení práv (např. práva přístupu, čtení, zápisu apod...).

Autentizace

Derby DB podporuje 3 typy (módy) autentizace: LDAP, NATIVE a USER-DEFINE.

• LDAP je mód, kdy se o autentizaci stará LDAP directory service. Jedná se o službu běžící na stejném či jiném počítači. Tudíž je nutné provést nakonfigurování Derby Serveru pro tuto službu. Toto je výhodné pokud spravujete ověřování k více přístupům a službám centrálně. Nevýhodou je nižší bezpečnost.
• NATIVE mód je způsob, kdy jsou hesla uživatelů uložena v samotné databázi. Tento mód si předvedeme.
• USER-DEFINE je mód, kdy si spravujeme logiku potřebnou pro ověřování uživatele sami.

Autorizace

Derby Db podporuje 2 typy (módy) autorizací: Coarse-grained authorization, Fine-grained authorization.

• Coarse-grained authorization (tzv. hrubozrnné oprávnění) je, když vlastník databáze rozdělí uživatele do dvou skupin. Jedna skupina má plnou autoritu pro čtení a zápis, druhá skupina má právo pouze číst (vzorový příklad s logikou vysvětlení je přímo v Security guide.pdf). Hrubozrnné dělení není příliš optimální, neboť neumožňuje izolovaný přístup jednotlivých uživatelů.
• Fine-grained authorization (tzv. jemnozrnné oprávnění) známé jako standardní SQL oprávnění. V tom vlastník databáze či jednotliví uživatelé nebo skupiny nastaví podrobnější SQL GRANT/REVOKE příkazy (dotazy). Příkaz GRANT se používá k udělení konkrétních oprávnění uživatelům nebo rolím nebo k udělení rolí k uživatelům nebo k rolím. Příkaz REVOKE se používá k odebrání oprávnění a rolí. Příkazy, které se povolují (GRANT) nebo zakazují (REVOKE), jsou: DELETE/EXECUTE/INSERT/SELECT/REFERENCES/TRIGGER/UPDATE.

Příklad

Jako příklad si provedeme nastavení práv s autentizací NATIVE a s autorizací kombinace COARSE GRAINED + FINE GRAINED. Je to z toho důvodu, že tato kombinace je jako příklad nejvhodnější. Jen připomenu, že stvořitel databáze je její vlastník (tzv. superuživatel), má práva pro přidávání uživatelů a nastavování práv přístupu, pokud si je sám v pozdější části neupraví. V tomto tutoriálu si předvedeme nastavení autentizace, tzn. vytvoříme (přidáme) uživatele do DerbyDB.

Nastavení autentizace (Authentification) přes IJ

Nejdříve si postup předvedeme přes konfigurační příkaz IJ. Přihlásíme se a vytvoříme databázi. Pokud chceme přidat nové uživatele, je nutné nejdříve přidat uživatele, který byl použit při tvorbě databáze a je její vlastník. Po přidání uživatelů je nutné databázi vypnout (restartovat). Poté se již k dané databázi přihlásíme jako nově vytvoření uživatelé.

ij version 10.13
ij>connect 'jdbc:derby:databaze10;create=true;user=uzivatel10;password=heslo10';
ij>call SYSCS_UTIL.SYSCS_CREATE_USER( 'uzivatel10', 'heslo10' );
ij>call SYSCS_UTIL.SYSCS_CREATE_USER( 'uzivatel10a', 'heslo10a' );
ij>call SYSCS_UTIL.SYSCS_CREATE_USER( 'uzivatel10b', 'heslo10b' );
ij>call SYSCS_UTIL.SYSCS_CREATE_USER( 'uzivatel10c', 'heslo10c' );
ij>connect 'jdbc:derby:databaze10;shutdown=true';
ij>disconnect;
ij>exit;

Výsledek:

Vytvoření uživatelů programově

Testovací příklad si vytvoříme jako nový Java SE projekt v našem IDE. V menu vybereme File -> New -> Java Project. Pojmenujeme projekt a nastavíme JRE Java8. Přidáme opět externí knihovny do našeho projektu do CLASSPATH. Jedná se o tyto externí knihovny:

• derbyclient.jar
• derbytools.jar
• derbyoptionaltools.jar

Co v kódu uděláme? Vytvoříme objekt spojení, přes objekt dotazu zavoláme IJ a přes ten uložíme nové uživatele. A pak se odpojíme, čímž vlastně provedeme restart databáze. Poté se můžete zkusit přihlásit přes IJ nástroj jako uživatel uzivatel10c, jak to jde vidět ze screenshotu.

package datab;
import java.sql.*;
public class VytvoreniAutentifikace {

    private static Connection connect = null;
    private static PreparedStatement statement = null;

    static {
        try {
            Class.forName("org.apache.derby.jdbc.ClientDriver").newInstance();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            System.out.println("Problem s nactenim driveru - nutne pridat do CLASSPATH");
        }
    }

    private static void pripojeniDatabaze() {
        try {
            connect = DriverManager.getConnection("jdbc:derby:C:/Program Files/JavaJDK8_144/db/bin/databaze10;create=true;user=uzivatel10;password=heslo10;");
            System.out.println("Podarilo se pripojit k databazi10");
        } catch (Exception e) {
            System.err.println("Nepodarilo se pripojit k databazi10");
            if (connect == null) {
                System.exit(1);
            }
        }
    }

    private static void pridameUzivateleNATIVE(String user, String pass) {
        String prikaz = "CALL SYSCS_UTIL.SYSCS_CREATE_USER(?,?)";
        try {
            statement = connect.prepareStatement(prikaz);
            statement.setString(1,user);
            statement.setString(2,pass);
            statement.executeUpdate();
            System.out.println("Povedlo se pridat uzivatele : "+user);
        } catch (SQLException e) {
            System.out.println("Nepovedlo se pridat uzivatele :"+user);
            e.printStackTrace();
        }

    }

    private static void odpojimeDatabazi() {
        try {
            if (statement != null) {
                statement.close();
            }
            if (connect != null) {
                connect.close();
            }
            System.out.println("Podarilo se odpojit od databaze");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        System.out.println("Start Programu");
        pripojeniDatabaze();
        pridameUzivateleNATIVE("uzivatel10","heslo10");
        pridameUzivateleNATIVE("uzivatel10a","heslo10a");
        pridameUzivateleNATIVE("uzivatel10b","heslo10b");
        pridameUzivateleNATIVE("uzivatel10c","heslo10c");
        odpojimeDatabazi();
        System.out.println("Konec Programu");
    }
}

Proč PreparedStatement a ne Statement? Je to proto, že objekt dotazu Statement způsobí pád programu, má problém se Stringy a volání "CALL" není podporováno. DerbyDB s ním prostě padá (viz. ReferenceDB.pdf).

Nyní hlavně nezapomeňte restartovat Derby Server (tvz. vypnout a zapnout).

Příště, v lekci Derby DB - Práva přístupu - Autorizace, si předvedeme nastavení autorizace.

Měl jsi s čímkoli problém? Stáhni si vzorovou aplikaci níže a porovnej ji se svým projektem, chybu tak snadno najdeš.