BAB II

PEMBAHASAN

2.1 Penjelasan RBAC ( Role Based Access Control )

Role berorientasi pada group, sekumpulan transaksi dibuat. Transaksi disini dapat
merupakan obyek yang berupa program yang berhubungan dengan data. Seorang
admintrator sekuriti dapat menambah dan menghapus transaksi ke dalam sebuah role atau
bahkan menolak user pada suatu role. Dengan mengelompokkan user kedalam role maka
ada memudahkan pada proses otorisasi dan kemampuan audit. Hal ini bertolak
belakangan dengan access list model pada umumnya yang dilakukan dengan jalan
mencari seluruh otorisasi yang ada kemudian mengalokasi hak dan ijin untuk user
tersebut.

Dalam mengembangkan aplikasi, kita tentu membagi-bagi user sesuai fungsinya. Kita
dapat merancang pembagian user sendiri atau kita belajar dari best practice yang pernah
dilakukan. Best practice untuk pembagian akses aplikasi adalah menggunakan RBAC
atau Role Based Access Control. Dalam RBAC ini kita akan membuat Role untuk
masing-masing tingkatan user. Dalam setiap Role ini terdapat berbagai menu yang
diberikan kepada Role ini lengkap dengan permissionnya.

Misal Role Admin Purchasing akan mendapatkan menu Purchase Order dengan
permission Create.

Kemudian Role Purchasing Manager akan mendapatkan menu Purchase Order dan
Purchase Request masing-masing dengan permission Approve.

Secara relasi tabelnya Role -> Menu -> Permission .

Kemudian setiap user akan diberikan satu atau beberapa Role.

Dengan demikan akan terjadi relasi Many to Many untuk User <-> Role.

Dalam sistem keamanan komputer, role-based access control (RBAC) adalah sebuah
pendekatan untuk membatasi akses sistem untuk pengguna yang berwenang. Hal ini
digunakan oleh sebagian besar perusahaan dengan lebih dari 500 karyawan, dan dapat
 diimplementasikan melalui mandatory access control (MAC) atau discretionary access
control (DAC). RBAC kadang-kadang disebut sebagai role-based security.

2.2 Penerapan RBAC( Role Based Access Control ) Menggunakan SQL

Pada diagram di bawah, hubungan antara Pengguna (u), Grup / Role (g), dan Izin (p)
dengan tiga tabel, yaitu u_g, g_p, dan g_g, cukup fleksibel untuk mencakup semua tree
atau jaringan

Semua pernyataan berikut benar dalam model ini:

 seorang pengguna dapat ditautkan ke banyak grup;

 grup dapat ditautkan ke banyak pengguna;
 izin dapat ditautkan ke banyak grup;
 sebuah grup dapat dihubungkan ke banyak izin;
 sebuah grup dapat dihubungkan ke banyak grup anak;
 sebuah grup dapat ditautkan ke banyak grup induk;

Namun, bagian yang sulit dari model ini adalah bagaimana menangani hierarki role /
grup dalam SQL karena sifat rekursif dari navigasi antara hubungan grup (g_g).

Salah satu solusinya adalah dengan menggunakan SQL stored routines. Berikut ini
adalah desain di MySQL:
 call get_permisions('u2');
 call get_users('p1');

Untuk mendapatkan semua izin pengguna atau semua pengguna yang memiliki izin.

Untuk Syntax Query nya adalah sebagai berikut:

DROP PROCEDURE IF EXISTS test.get_users;

CREATE PROCEDURE test.`get_users`(p VARCHAR(20))
BEGIN
SELECT group_concat(gID)
INTO @groups
FROM g_p
WHERE pID = p;

SELECT DISTINCT uID

FROM u_g
WHERE FIND_IN_SET(gID, parents(@groups)) > 0;
END;

DROP PROCEDURE IF EXISTS test.get_permisions;

CREATE PROCEDURE test.`get_permisions`(u VARCHAR(20))
BEGIN
SELECT group_concat(gID)
INTO @groups
FROM u_g
WHERE uID = u;

SELECT DISTINCT pID

FROM g_p
WHERE FIND_IN_SET(gID, children(@groups)) > 0;
END;

DROP FUNCTION IF EXISTS test.children;

CREATE FUNCTION test.`children`(parents VARCHAR(255)) RETURNS
varchar(255)
CHARSET utf8
BEGIN
DECLARE x VARCHAR(255);
SET @@SESSION.max_sp_recursion_depth = 25;
CALL get_children(parents, x);
RETURN x;
END;

DROP PROCEDURE IF EXISTS test.get_children;

CREATE PROCEDURE test.`get_children`(IN parents VARCHAR(255),
OUT children VARCHAR(255))
BEGIN
DECLARE x VARCHAR(255);
SET children = parents;
 SELECT group_concat(DISTINCT child)
INTO x
FROM g_g
WHERE FIND_IN_SET(parent, parents);

IF (x IS NOT NULL)
THEN
CALL get_children(x, x);
SET children = concat(parents, ',', x);
END IF;
END;

DROP FUNCTION IF EXISTS test.parents;

CREATE FUNCTION test.`parents`(children VARCHAR(255)) RETURNS
varchar(255)
CHARSET utf8
BEGIN
DECLARE x VARCHAR(255);
SET @@SESSION.max_sp_recursion_depth = 25;
CALL get_parents(children, x);
RETURN x;
END;

DROP PROCEDURE IF EXISTS test.get_parents;

CREATE PROCEDURE test.`get_parents`(IN children VARCHAR(255),
OUT parents VARCHAR(255))
BEGIN
DECLARE x VARCHAR(255);
SET parents = children;

SELECT group_concat(DISTINCT parent)

INTO x
FROM g_g
WHERE FIND_IN_SET(child, children);

IF (x IS NOT NULL)
THEN
CALL get_parents(x, x);
SET parents = concat(children, ',', x);
END IF;
END;