<table>
  <tr>
    <td id="cell1">cell1</td>
    <td id="cell2">cell2</td>
  </tr>
  <tr>
    <td id="cell3">cell3</td><td id="cell4">cell4</td></tr>
</table>

Mamy prostą tabele, pierwszy jej wiersz jest ładnie sformatowany by cieszyło nasze oko, drugi jest prosty, w jednym ciągu zapisany. Teraz po pobraniu następnego elementu poprzez nextSibling dla cell1 będziemy mieli text zamiast oczekiwanego przez nas cell2,a po pobraniu następnego elementu (j/w) dla cell3 będziemy mieli cell4.

Teraz za pewne można sobie zadać pytanie i co z tym zrobić? Otóż każdy element w javascript ma coś takiego jak nodeType, nodeType jest niczym innym jak indeksem elementu DOM przypisanym na stałe ustalonym w dokumentacji ECMA-262, zainteresowanych odsyłam do wiki. Nie ma sensu bym tutaj przytaczał wszystkiego odsyłam do w3shools w3schools – nodeTypes. Wracając do sedna sprawy bo troszkę odbiegłem od tematu, aby pobrać następny element trzeba sprawdzić jakiego jest typu. Także funkcja którą poniżej przedstawię nie jest mojego autorstwa, została już trylion razy przedstawiona w internecie,

   /**
    * Metoda zwraca następny obiekt w DOM
    *
    * @param    obj    obiekt elementu
    * @return    obj    następny obiekt w DOM
    */
   nextObject = function( MyObject ) 
   {
      do NextObject = MyObject.nextSibling;
      while (NextObject && NextObject.nodeType != 1);
        return NextObject;
   }

Tadam, proste, szybkie i skuteczne, użycie?

var div = document.getElementById( "jakiesId" );
var nextElement = nextObject( div );

Mam nadzieję że się komuś przyda i uśmierzy ból który spływa na nasze serca podczas pisania kodu js i wyrywania sobie włosów z głowy przy nieoczekiwanych wynikach wykonanego kodu który względnie teoretycznie jest dobry.

Live CD

Pierwsze co powinniśmy zrobić, to zmontować sobie jakąś dystrybucję która nam pozwoli odzyskać gruba, aby tak się stało dystrybucja powinna mieć grub’a w swoich pakietach, nie każda ma ubuntu defaultowo też nie posiada, więc bez dostępu do internetu będziemy w czarnej dziurze. Możemy z windowsa nagrać ubuntu/kubuntu na pendrive za pomocą ultra iso, fajne narzędzie. Inne nie tworzyły mi bootowanego pendriva i nie mogłem nic z tym zrobić. Dobra mamy pendrive/cd z ubuntu co dalej?

Chrootowanie systemu

Otwieramy konsole, wpisujemy

# sudo su

następnie

# aptitude install grub -y

dalej

# mkdir /media/root
# mount /media/root /dev/sdaX

Gdzie X jest to numer naszej partycji
I tutaj zależy jaki mamy dysk, sata, czy też nie oraz w której kolejności jest ustawiony na kablu jeżeli to ata lub mamy dwa dyski na sata, aby wyświetlić jakie mamy dyski należy wykonać to za pomocą:

# fdisk -l

Dobra, mamy zamontowaną partycję z dyskiem, następnie montujemy proc i dev

# mount -t proc none /media/root/proc
# mount -o bind /dev /media/root/dev

Przed chrootem jeszcze jedna akcja:

# grub-install /dev/sda

Teraz chrotujemy dziada:

# chroot /media/root /bin/bash

Ok i teraz tak, mamy już gruba zainstalowanego na dysku, więc możemy się do niego wbić, gdybyśmy go nie zainstalowali nie mogli byśmy zrobić tego co piszą różni blogowicze a chodzi o:

# grub

Ok jedziemy

# grub> find /boot/grub/stage1

Teraz tak jak u innych mamy to samo, powinno nam wywalić numer partycji coś ala

# hd(0,1)

Standardowo lecimy dalej:

# grub> root (hd0,1)

oraz

# grub> setup (hd0)

Ha! I tu jest ficzer, gdybyśmy nie zainstalowal gruba od zera to byśmy dostali błędem po oczach że nie ma pliku stage1, a tak jest. Zainstalowane skonfigurowane i co pewnie myślicie że to już wszystko co? A no nie wszystko, mało kto pisze o tym na blogu, a to jest bardzo ważne, gdyż jak wykonamy restarta po tych operacjach to przywita nas grub a nie wybór systemu

# grub> quit
# grub-udpate

Powinno nas poinformować że nie mamy utworzonego menu.lst potwierdzamy chęć utworzenia listy wciskając y i enter.
Włala, utworzyło nam piknie wszystko, teraz możemy już tylko odmontować partycje

# umount /media/root/dev
# umount /media/root/proc
# umount /media/root

I nie bić reboot z konsoli bo ubuntu się nie zresetuje tylko zawiesi przy próbie restartu, nie wiem też czy poweroff zadziała, najlepiej mu kliknąć myszką żeby się wyłączył.

Po tych operacjach możemy cieszyć się działającym grubem. Amen.

Wzorowane na artykule z thecamels.org

Logika struktury sql

Można by się zapytać po co tyle tabel? A bardzo chętnie na to pytanie odpowiem, otóż baza danych nie jest stworzona po to by trzymać w niej to co się chce i nawet bez sensu, takie rzeczy dyskryminują nas od razu w oczach pracodawcy. Więc dane nie powinny się powtarzać, kolumny powinny być tak tworzone by zawierały jak najmniej wartości NULL chyba że ma to pewien sens. Coś na zasadzie “Dziel i zwyciężaj” tylko tutaj prawda nie mamy żadnych algorytmów

Priorytety w Role Based Access Control

Mamy taki problem: Czy pobrać wszystko za jednym zamachem i sprawdzać dostęp za pomocą tego co mamy, czy sprawdzać pobierając dane po kolei? I odpowiedź bez sprawdzenia tego, które z założeń jest szybsze jest chyba absurdem, niestety nie mam na razie na to czasu by to sprawdzić, lecz chciałbym ustalić kolejność priorytetów. Założenie jest takie: Każdy użytkownik jest przypisany do jakiejś grupy, użytkownik bez grupy też jest w grupie użytkowników a mowa tutaj o osobach które nie są zarejestrowane na naszej stronie, można przyjąć ich za grupę Guest, czyli gości. Taki paradoks. I teraz priorytety wg mnie można by ustalić w ten sposób:

1. Sprawdzanie czy grupa ma dostęp do controllera, czyli naszej grupy zadań.
   1. Ma, sprawdzamy czy grupa ma dostęp do akcji w kontrolerze, czyli naszego zadania
      1. Ma, zezwalamy
      2. Nie ma, przechodzimy do pkt 2
   2. Nie ma, przechodzimy do pkt 2
2. Grupa nie ma uprawnień do zadania w controllerze, sprawdzamy czy użytkownik ma dostęp do controllera
   1. Ma, sprawdzamy czy ma dostęp do akcji w kontrolerze
      1. Ma, zezwalamy
      2. Nie ma, odmawiamy
   2. Nie ma, odmawiamy
3. Amen

Hierarchia, czyli dziedziczenie uprawnień

Szczerze jak sobie pomyślę o takim założeniu to zaczyna mnie głowa boleć, bo już sobie w głowie tworzę taką aplikację w sql która musi to sprawdzać, no daję głowę, szczęka opada… Więc nie wiem czy aby na pewno jest to słuszne by tworzyć to, ale słowo się rzekło, to i się to napisze. Tylko obawiam się że bez rekurencji to nie przejdzie, chociaż nie jestem tego jeszcze do końca pewien, być może nie będzie tak źle na jak to wygląda. Dodatkowe akcje wchodzą w grę, należy sprawdzać czy jeżeli np grupa nie ma uprawnień do akcji, czy nad grupa ma pozwolenie na tą akcję oraz czy pozwala ją dziedziczyć, gdyby ktoś wyjechał z pomysłem komu pozwala ją dziedziczyć to w ogóle jeszcze więcej roboty, więc proszę nie dobijać leżącego Huh chociaż dobrze że nie ma sensu robić hierarchie użytkowników, bo od tego jest rbac właśnie by zrobił to za nas.

Słów kilka na zakończenie

Myślę że jest to optymalne sprawdzanie, chyba że coś pominąłem to mnie poprawcie, trochę z rana mogę być jeszcze nie ogarnięty z wszystkim, więc pisać w komentarzach co i jak.

Struktura SQL Role Based Access Control

Także do dzieła, struktura bazy danych:

BEGIN;
 
DROP TABLE IF EXISTS "rbac_user" CASCADE;
CREATE TABLE "rbac_user"
(
   "idUser" SERIAL PRIMARY KEY,
   "userName" VARCHAR( 255 ) NOT NULL
);
 
DROP TABLE IF EXISTS "rbac_group" CASCADE;
CREATE TABLE "rbac_group"
(
   "idGroup" SERIAL PRIMARY KEY,
   "groupName" VARCHAR( 255 ) UNIQUE NOT NULL
);
 
DROP TABLE IF EXISTS "rbac_user_to_group";
CREATE TABLE "rbac_user_to_group"
(
   "idUser" INT REFERENCES "rbac_user"( "idUser" ) NOT NULL,
   "idGroup" INT REFERENCES "rbac_group"( "idGroup" ) NOT NULL,
   PRIMARY KEY( "idUser", "idGroup" )
);
 
DROP TABLE IF EXISTS "rbac_module" CASCADE;
CREATE TABLE "rbac_module"
(
   "idModule" SERIAL PRIMARY KEY,
   "moduleName" VARCHAR( 255 ) UNIQUE NOT NULL
);
 
DROP TABLE IF EXISTS "rbac_action" CASCADE;
CREATE TABLE "rbac_action"
(
   "idAction" SERIAL PRIMARY KEY,
   "idModule" INT REFERENCES "rbac_module"( "idModule" ) NOT NULL,
   "actionName" VARCHAR( 255 ) NOT NULL,
   "inherited" BOOLEAN DEFAULT FALSE NOT NULL,
   UNIQUE( "actionName", "idModule" )
);
 
DROP TABLE IF EXISTS "rbac_privilages";
CREATE TABLE "rbac_privilages"
(
   "idGroup" INT REFERENCES "rbac_group"( "idGroup" ) NOT NULL,
   "idModule" INT REFERENCES "rbac_module"( "idModule" ) NOT NULL,
   "idAction" INT REFERENCES "rbac_action"( "idAction" ) NOT NULL,
   "allow" BOOLEAN DEFAULT FALSE NOT NULL,
   PRIMARY KEY( "idGroup", "idModule", "idAction" )
);
 
COMMIT;

Użyłem transakcji, w posgresql można W MySQL też, pod warunkiem że typ tabeli to InnoDB. Ale nie teraz o tym rzecz. Co jest co?

rbac_user – tabela przechowująca użytkowników naszego systemu
rbac_group – tabela przechowująca grupy w naszym systemie
rbac_user_to_group – tabela wiążąca użytkowników z grupami, relacja typu many-to-many (wiele do wielu)
rbac_module – tabela przechowująca nazwy naszych modułów, można to rozumieć jako controllery naszej aplikacji
rbac_action – tabela przechowująca nazwy naszych akcji, trzeba to rozumieć jako metody w naszych controllerach, relacja typu many-to-one (wiele do jednego, to samo co jeden do wielu [one-to-many])
rbac_privilages – a to jest tabela wiążąca grupę użytkowników, moduł i akcję.

Demo Role Based Access Control

Teraz jak to ustrojstwo wypełnić danymi? Bardzo proszę:

BEGIN;
 
INSERT INTO "rbac_user" ( "userName" ) VALUES ( 'przemek' ), ( 'maciej' ), ( 'andrzej' ), ( 'grzesiek' );
INSERT INTO "rbac_group" ( "groupName" ) VALUES ( 'admin' ), ( 'user' ), ( 'moderator' );
INSERT INTO "rbac_user_to_group" VALUES ( 1, 1 ), ( 2, 3 ), ( 3, 2 ), ( 4, 2 );
INSERT INTO "rbac_module" ( "moduleName" ) VALUES ( 'news' ), ( 'articles' ), ( 'download' ), ( 'music' );
INSERT INTO "rbac_action" ( "idModule", "actionName", "inherited" ) VALUES
   ( 1, 'index', FALSE ),
   ( 1, 'edit', FALSE ),
   ( 1, 'add', FALSE ),
   ( 1, 'delete', FALSE ),
   ( 1, 'block', FALSE ),
   ( 2, 'index', TRUE ),
   ( 2, 'edit', TRUE ),
   ( 2, 'add', TRUE ),
   ( 2, 'delete', TRUE ),
   ( 2, 'block', TRUE ),
   ( 3, 'index', TRUE ),
   ( 3, 'edit', FALSE ),
   ( 3, 'add', TRUE ),
   ( 3, 'delete', FALSE ),
   ( 3, 'block', FALSE ),
   ( 3, 'download', TRUE ),   
   ( 4, 'index', TRUE ),
   ( 4, 'edit', TRUE ),
   ( 4, 'add', FALSE ),
   ( 4, 'delete', FALSE ),
   ( 4, 'block', FALSE ),
   ( 4, 'download', FALSE ),
   ( 4, 'play', TRUE );
 
INSERT INTO "rbac_privilages" VALUES 
   ( 1, 1, 1, TRUE ),
   ( 1, 1, 2, TRUE ),
   ( 1, 1, 3, TRUE ),
   ( 1, 1, 4, TRUE ),
   ( 1, 1, 5, TRUE ),
   ( 2, 1, 1, TRUE ),
   ( 2, 1, 2, FALSE ),
   ( 2, 1, 3, TRUE ),
   ( 2, 1, 4, FALSE ),
   ( 2, 1, 5, FALSE ),
   ( 3, 1, 1, TRUE ),
   ( 3, 1, 2, TRUE ),
   ( 3, 1, 3, TRUE ),
   ( 3, 1, 4, TRUE ),
   ( 3, 1, 5, FALSE ),
   ( 1, 2, 6, TRUE ),
   ( 1, 2, 7, TRUE ),
   ( 1, 2, 8, TRUE ),
   ( 1, 2, 9, TRUE ),
   ( 1, 2, 10, TRUE ),
   ( 2, 2, 6, TRUE ),
   ( 2, 2, 7, FALSE ),
   ( 2, 2, 8, TRUE ),
   ( 2, 2, 9, FALSE ),
   ( 2, 2, 10, FALSE ),
   ( 3, 2, 6, TRUE ),
   ( 3, 2, 7, TRUE ),
   ( 3, 2, 8, TRUE ),
   ( 3, 2, 9, TRUE ),
   ( 3, 2, 10, FALSE ),
   ( 1, 3, 11, TRUE ),
   ( 1, 3, 12, TRUE ),
   ( 1, 3, 13, TRUE ),
   ( 1, 3, 14, TRUE ),
   ( 1, 3, 15, TRUE ),
   ( 1, 3, 16, TRUE ),
   ( 2, 3, 11, TRUE ),
   ( 2, 3, 12, FALSE ),
   ( 2, 3, 13, TRUE ),
   ( 2, 3, 14, FALSE ),
   ( 2, 3, 15, FALSE ),
   ( 2, 3, 16, TRUE ),
   ( 3, 3, 11, TRUE ),
   ( 3, 3, 12, TRUE ),
   ( 3, 3, 13, TRUE ),
   ( 3, 3, 14, FALSE ),
   ( 3, 3, 15, TRUE ),
   ( 3, 3, 16, TRUE ),
   ( 1, 4, 17, TRUE ),
   ( 1, 4, 18, TRUE ),
   ( 1, 4, 19, TRUE ),
   ( 1, 4, 20, TRUE ),
   ( 1, 4, 21, TRUE ),
   ( 1, 4, 22, TRUE ),
   ( 1, 4, 23, TRUE ),
   ( 2, 4, 17, TRUE ),
   ( 2, 4, 18, FALSE ),
   ( 2, 4, 19, TRUE ),
   ( 2, 4, 20, FALSE ),
   ( 2, 4, 21, FALSE ),
   ( 2, 4, 22, TRUE ),
   ( 2, 4, 23, TRUE ),
   ( 3, 4, 17, TRUE ),
   ( 3, 4, 18, TRUE ),
   ( 3, 4, 19, TRUE ),
   ( 3, 4, 20, FALSE ),
   ( 3, 4, 21, TRUE ),
   ( 3, 4, 22, TRUE ),
   ( 3, 4, 23, TRUE );
 
COMMIT;

Znowu transakcję, jakoś tak szybciej działa to Jak pewnie zdążyliście zauważyć tabela rbac_action posiada kolumnę “inherited” która w późniejszym etapie mojej implementacji tego paradygmatu będzie potrzebna do tego by w hierarchii definiować czy dana akcja ma być dziedziczona dla pod grup. Taki ficzer.

Teraz tak, żeby to działało co jest wyżej przedstawione na gotowca, czyli copy-paste wymagana jest baza danych postgresql > 8.2. Dlaczego? A otóż dlatego że:

DROP "tabela" IF EXISTS;

jest zaimplementowane od tej versji. Oj brakowało tego brakowało… Nie wiem jak z wierszami podawanymi po przecinku, gdyż w 8.1 to nie działa (mowa tutaj o klauzuli INSERT).

Sprawdzanie uprawnień

Pozostało nam już tylko jak to pobrać, dla przykładu nie tworzyłem żadnych testów wydajnościowych, chodź przyznam że łączymy parę tabel ale utworzone indeksy są w pełni wykorzystywane, przykład jak sprawdzić uprawnienia:

SELECT 
  "allow" 
FROM 
  "rbac_privilages" p 
LEFT JOIN 
  "rbac_module" m 
ON 
  ( p."idModule" = m."idModule" ) 
LEFT JOIN 
  "rbac_action" a 
ON 
  ( p."idAction" = a."idAction" ) 
LEFT JOIN 
  "rbac_user_to_group" u2g 
ON 
  ( p."idGroup" = u2g."idGroup" ) 
WHERE 
  u2g."idUser" = 2 
AND 
  m."moduleName" = 'music' 
AND 
  a."actionName" = 'index';

Możemy sobie z tego ładny widoczek utworzyć, ale może o tym kiedy indziej. A teraz co wykazało explain?

 Nested Loop  (cost=8.28..14.17 rows=1 width=1)
   ->  Nested Loop  (cost=8.28..13.19 rows=1 width=5)
         JOIN Filter: (p."idModule" = m."idModule")
         ->  Hash JOIN  (cost=8.28..10.26 rows=3 width=9)
               Hash Cond: (p."idAction" = a."idAction")
               ->  Seq Scan ON rbac_privilages p  (cost=0.00..1.69 rows=69 width=13)
               ->  Hash  (cost=8.27..8.27 rows=1 width=4)
                     ->  INDEX Scan USING "rbac_action_actionName_key" ON rbac_action a  (cost=0.00..8.27 rows=1 width=4)
                           INDEX Cond: (("actionName")::text = 'index'::text)
         ->  INDEX Scan USING "rbac_module_moduleName_key" ON rbac_module m  (cost=0.00..0.97 rows=1 width=4)
               INDEX Cond: ((m."moduleName")::text = 'music'::text)
   ->  INDEX Scan USING rbac_user_to_group_pkey ON rbac_user_to_group u2g  (cost=0.00..0.97 rows=1 width=4)
         INDEX Cond: ((u2g."idUser" = 2) AND (u2g."idGroup" = p."idGroup"))
(13 rows)

A co explain z analyze?

 Nested Loop  (cost=8.28..14.17 rows=1 width=1) (actual time=0.449..0.480 rows=1 loops=1)
   ->  Nested Loop  (cost=8.28..13.19 rows=1 width=5) (actual time=0.355..0.449 rows=3 loops=1)
         JOIN Filter: (p."idModule" = m."idModule")
         ->  Hash JOIN  (cost=8.28..10.26 rows=3 width=9) (actual time=0.083..0.288 rows=12 loops=1)
               Hash Cond: (p."idAction" = a."idAction")
               ->  Seq Scan ON rbac_privilages p  (cost=0.00..1.69 rows=69 width=13) (actual time=0.012..0.099 rows=69 loops=1)
               ->  Hash  (cost=8.27..8.27 rows=1 width=4) (actual time=0.049..0.049 rows=4 loops=1)
                     ->  INDEX Scan USING "rbac_action_actionName_key" ON rbac_action a  (cost=0.00..8.27 rows=1 width=4) (actual time=0.027..0.036 rows=4 loops=1)
                           INDEX Cond: (("actionName")::text = 'index'::text)
         ->  INDEX Scan USING "rbac_module_moduleName_key" ON rbac_module m  (cost=0.00..0.97 rows=1 width=4) (actual time=0.006..0.008 rows=1 loops=12)
               INDEX Cond: ((m."moduleName")::text = 'music'::text)
   ->  INDEX Scan USING rbac_user_to_group_pkey ON rbac_user_to_group u2g  (cost=0.00..0.97 rows=1 width=4) (actual time=0.005..0.006 rows=0 loops=3)
         INDEX Cond: ((u2g."idUser" = 2) AND (u2g."idGroup" = p."idGroup"))
 Total runtime: 0.576 ms
(14 rows)

I skąd te 14 wierszy? Bladego pojęcia nie mam. (Edit już wiem ;p) Także czekam na Wasze konstruktywne opinie, chce zaznaczyć że całość nie jest tylko moim pomysłem ale również kolegi z pracy Maćka.

1. Użytkownik w wielu grupach
2. Grupy użytkowników
3. Zadania
4. Grupy zadań
5. Dostęp grupie użytkowników do zadań
6. Dostęp grupie użytkowników do grupy zadań
7. Dostęp pojedynczemu użytkownikowi do zadań
8. Dostęp pojedynczemu użytkownikowi do grupy zadań
9. Hierarchia grup (dziedziczenie z rodzica grupy)

No i z pomocą przyszło google, a dokładnie strona: link, kolega przedstawił wzór graficzny w jaki sposób wszystko z sobą połączyć:

W tablicy TASK (czyli zadania, będę przechowywał moduły i akcje, w postaci drzewa (tak drzewo, mam już sposób w doctrine na prace z drzewem, opiszę nie długo, albo ltree się zobaczy), po adresie albo routerze, jeżeli będzie przepisany link, będę pobierał moduł i akcję którą w danej chwili wykonuje użytkownik, na samym początku będzie sprawdzanie czy użytkownik ma dostęp do grupy zadań, jeżeli ma, jest szansa na to że będzie miał dostęp do zadania, jeżeli nie, sprawdzimy grupę użytkownika, czy ma dostęp do grupy zadań, biorąc pod uwagę czy ma ojca i jakie on ma uprawnienia do zadań oraz czy pozwala na dziedziczenie tych uprawnień.

Do: Zyx
W ten sposób rozwiązuje nawet problem taki jaki mi przedstawiłeś dotyczący kategorii artykułów dopisując je jako dziecko articles.

Co o Tym sądzicie? Już nie długo przedstawię pełny kod

Dlaczego nie używać md5?

W internecie możemy przeczytać nt używania sumy md5 w certyfikatach SSL przy połączeniach w np. systemach bankowych. Wg NIST (National Institute of Standards and Technology [ang. Narodowy Instytut Standaryzacji i Technologii]), powinno się wycofać używanie jej już w 1999r. I co Wy na to? Zdziwieni zapewne? A proszę bardzo, a to dlaczego? Jest za duża możliwość wygenerowania kolizji sumy, czyli to co pisałem wyżej wygenerowania dwóch identycznych sum.

Co zamiast md5?

Jest dużo algorytmów oferujących sumę kontrolną z stringu, lecz nie wszystkie są zalecane. W kolejności od najsłabszego:

• SHA1
• SHA-224
• SHA-256
• SHA-384
• SHA-512

Wszystko wiąże się z przyrostem miejsca w bazie danych, więc i z czasem dostępu, porównaniem stringu. Szybciej jest pobrać 32 znaki alfanumeryczne z bazy danych niż 512 i je z sobą porównać. Ale na pewno nie jest bezpieczniej.

crypt() dobra alternatywa

Pewnie nie jeden z Was zastanawiał się jak w linuxie hasła są zabezpieczane. Otóż linux i unixowe systemy wykorzystują sól do zapisywania haseł. Tylko to nie polega na tym że wydzielimy sobie string, dorzucimy sól, połączymy ponownie i zrobimy z tego sumę md5 gdyż to nie zwiększy bezpieczeństwa.
W php od wersji > 4 istnieje taka funkcja jak crypt(), link-manual. Funkcja ta ma zaimplementowany algorytm taki jak linuks do zapisywania hasła.

function genSalt($len = 64) {
    $safeChars = '0123456789abcdefghijkmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
    $shuffle = str_shuffle($safeChars); // mieszamy stringami ;)
    $n = strlen($safeChars);
	$p = ''; // na wszelki wypadek
	for ($i = 0; $i < $len; $i++) {
		$p .= $shuffle[rand(0, $n - 1)];
	} 
	return $p;
}
 
$password = $_POST['password'];
$salt = genSalt();
$pwdEncrypted = crypt($password, '$2a$07$'.$salt.'$');
echo $pwdEncrypted;

Problem z crypt()

Jest jeden mały problem z tą funkcją, po przeniesieniu strony wraz z bazą danych na inny hosting, istnieje prawdopodobieństwo iż hasła mimo że są poprawne nie będą pasować. Dlaczego? Nie mam pojęcia, przeczytałem to w jednej z książek ale autor nie wytłumaczył. Możliwe że zauważył ten problem, a mi się szukać nie chce ;] Ale who care? Jak można zawsze sobie hasło zmienić. Nie jestem do końca przekonany co do tej własności z tym że może być wygenerowany różnych suma dla teg samego stringa i soli.

A co z SHA-N?

Tak więc wg NIST do 2010r. SHA1 też ma zostać wycofane z użytku przy certyfikatach ssl. Tak więc pozostało nam parę funkcji.
Nie wszystkie z tych funkcji są “jawnie” dostępne w php, w sensie że są w postaci funkcji tak jak np md5, aby móc użyć np algorytmu SHA-512 musimy wykonać taką operację:

hash('sha512','Jakiś tekst do zsumowania ;)');

W funkcji hash możemy również wywoływać inne algorytmy tworzące sumę kontrolną. link-manual

Ale to nie wszystko, zapewne ktoś z Was słyszał o tęczowych tablicach, a jak nie to zapraszam link-wikipedia. Po przeczytaniu sami dojdziecie do wniosku że używanie sum kontrolnych jest po prostu mało bezpieczne.

Słów kilka na zakończenie

Co byśmy nie zrobili, to i tak się znajdzie ktoś kto nam złamie hasło, to tylko kwestia czasu.

I Zonk

Ale czego się można było dowiedzieć? Że wreszcie poszli po rozum do głowy, bo cały portal jest tak rozpieprzony po łokciach, że stoi bo ma stać. A jak stoi to już trochę ludzi boli. A na pewno tych z branży.
A dlaczego? Największy Polski portal społecznościowy prowadzony przez programistów dla programistów, tworzy go społeczność jak by nie patrzeć. To się chwali. Cieszy mnie że php.pl używa oprogramowania otwartego, gdyby się ktoś nie domyślił to jest to framework Symfony. A wydawało mi się że większość z nich na zendzie jedzie po wpisach na forum, ale jak widać myliłem się.

Taki krótki wpis szału ni ma.

Trochę historii
W 2002 roku, dwóch programistów: Teodor Sigaev oraz Oleg Bartunov, wypuściło na światło dzienne moduł ltree (kiedy zaczęli, brak danych). Podeszli do tego dość ogólnego problemu z wielkim dystansem, za to teraz mamy potężne narzędzie całkowicie za darmo. Następne wydania miały na celu wyeliminowanie błędów zgłoszonych przez użytkowników oraz rozszerzyć możliwości o nowe możliwości w indeksie GIST. Więcej na temat samych wydań jak zwykle w paczce do pobrania z ich strony na dole.

Z czym to się je?
Ltree jak już wyżej wspomniałem jest modułem do PosgreSQL’a mający za zadanie przechowywanie danych w sposób przedstawiający strukturę drzewiastą. Implementacja jak najbardziej wydajna. A więc zacznijmy.

W zależności od dystrybucji z jakiej korzystamy, możemy mieć lub nie dodatkową paczkę dla postgresql’a która powinna się nazywać mniej więcej tak: postgresql-contrib

Po zainstalowaniu tych dodatków mamy masę innych rzeczy, z których nie koniecznie będziemy korzystać. Ale nas interesuje ltree, ścieżka ltree.sql u mnie to:

/usr/share/postgresql/8.4/contrib/

a żeby wyszukać gdzie my to mamy:

locate ltree.sql

po wcześniejszym updatedb.

powinniśmy mieć tam plik ltree.sql, musimy ten plik wrzucić do naszej bazy danych. No to jedziemy:

psql nazwaDB < /usr/share/postgresql/8.4/contrib/ltree.sql

powinniśmy mieć wszystko ładnie wrzucone do bazy danych. Teraz zostało nam już tylko utworzenie tabeli i ogień.

Przykładowa tabela z naszym drzewem.

CREATE TABLE "tree" (
   "id"  SERIAL NOT NULL,
   "path"   LTREE,
   "sort" SMALLINT
);

mamy tutaj tabelę którą nazywamy tree, i teraz nowy typ danych LTREE. Nie ma co tu dużo tłumaczyć zaraz sami zobaczycie jak to działa.

Pozostało nam jeszcze założyć indeksy na kolumny:

CREATE INDEX path_gist_idx ON "tree" USING gist(path);
CREATE INDEX path_idx ON "tree" USING btree(path);

oraz możemy sobie w prosty sposób komentarze na kolumny powrzucać:

COMMENT ON COLUMN "tree"."path" IS 'Scieżka drzewa';

Żeby zobaczyć komentarz w psql należy wykonać polecenie:

\d+ "nazwaTabeli"

A teraz dane przykładowe do drzewa:

INSERT INTO "tree" ( "path", "sort" ) VALUES ('Top', 1);
INSERT INTO "tree" ( "path", "sort" ) VALUES ('Top.Science', 1);
INSERT INTO "tree" ( "path", "sort" ) VALUES ('Top.Science.Astronomy', 1);
INSERT INTO "tree" ( "path", "sort" ) VALUES ('Top.Science.Astronomy.Astrophysics', 1);
INSERT INTO "tree" ( "path", "sort" ) VALUES ('Top.Science.Astronomy.Cosmology', 2);
INSERT INTO "tree" ( "path", "sort" ) VALUES ('Top.Hobbies', 2);
INSERT INTO "tree" ( "path", "sort" ) VALUES ('Top.Hobbies.Amateurs_Astronomy', 2);
INSERT INTO "tree" ( "path", "sort" ) VALUES ('Top.Collections', 3);
INSERT INTO "tree" ( "path", "sort" ) VALUES ('Top.Collections.Pictures', 1);
INSERT INTO "tree" ( "path", "sort" ) VALUES ('Top.Collections.Pictures.Astronomy', 1);
INSERT INTO "tree" ( "path", "sort" ) VALUES ('Top.Collections.Pictures.Astronomy.Stars', 1);
INSERT INTO "tree" ( "path", "sort" ) VALUES ('Top.Collections.Pictures.Astronomy.Galaxies', 2);
INSERT INTO "tree" ( "path", "sort" ) VALUES ('Top.Collections.Pictures.Astronomy.Astronauts', 3);

Jak zauważyliście, dane w ścieżce drzewa nie mogą posiadać wolnej przestrzeni, więc należy ją zamienić na np “_”, co nie jest żadnym problemem.

Ścieżka rysuje się mniej więcej tak:



Pobierzmy sobie teraz całe drzewko:

ltree=> SELECT * FROM tree;
 id |                     path                      | sort
----+-----------------------------------------------+------
  1 | Top                                           |    1
  2 | Top.Science                                   |    1
  3 | Top.Science.Astronomy                         |    1
  4 | Top.Science.Astronomy.Astrophysics            |    1
  5 | Top.Science.Astronomy.Cosmology               |    2
  6 | Top.Hobbies                                   |    2
  7 | Top.Hobbies.Amateurs_Astronomy                |    2
  8 | Top.Collections                               |    3
  9 | Top.Collections.Pictures                      |    1
 10 | Top.Collections.Pictures.Astronomy            |    1
 11 | Top.Collections.Pictures.Astronomy.Stars      |    1
 12 | Top.Collections.Pictures.Astronomy.Galaxies   |    2
 13 | Top.Collections.Pictures.Astronomy.Astronauts |    3
(13 rows)

I wszystko wygląda fajnie co? Ale tu się zaczynają schody z którymi ja sam nie potrafiłem sobie poradzić. I po raz któryś poprosiłem depesz’a o pomoc. Sprawa ma się tak: Jak pobrać drzewo z posortowanymi gałęziami względem głębokości? No i tutaj był mój pies pogrzebany. Ale z pomocą przyszedł depesz, ale do sedna sprawy. Dodajmy sobie z 3 rekordy do naszej tabeli:

 INSERT INTO tree (path,sort) VALUES ('Top.Science.Programing',2);
 INSERT INTO tree (path,sort) VALUES ('Top.Science.Chemia',3);
 INSERT INTO tree (path,sort) VALUES ('Top.Science.Fizyka',4);

Teraz nasze drzewko będzie wyglądało tak:

 id |                     path                      | sort
----+-----------------------------------------------+------
  1 | Top                                           |    1
  2 | Top.Science                                   |    1
  3 | Top.Science.Astronomy                         |    1
  4 | Top.Science.Astronomy.Astrophysics            |    1
  5 | Top.Science.Astronomy.Cosmology               |    2
  6 | Top.Hobbies                                   |    2
  7 | Top.Hobbies.Amateurs_Astronomy                |    2
  8 | Top.Collections                               |    3
  9 | Top.Collections.Pictures                      |    1
 10 | Top.Collections.Pictures.Astronomy            |    1
 11 | Top.Collections.Pictures.Astronomy.Stars      |    1
 12 | Top.Collections.Pictures.Astronomy.Galaxies   |    2
 13 | Top.Collections.Pictures.Astronomy.Astronauts |    3
 14 | Top.Science.Programing                        |    2
 15 | Top.Science.Chemia                            |    3
 16 | Top.Science.Fizyka                            |    4
(16 rows)

Co nas w ogóle nie zadowala, próbowałem na różne sposoby:

1 by depesz:

10:12 < depesz> cojack: i think you will need to sort on subltree(path, 0, nlevel(path)-2), sort;

No to jedziemy

ltree=> SELECT * FROM tree ORDER BY subltree(path, 0, nlevel(path)-2), sort;
ERROR:  invalid positions

A dziwne bo wcześniej działało ^^

2 moja

SELECT id, subpath(path, -1) AS title, nlevel(path) AS depth, sort FROM tree ORDER BY subltree(path, 0, nlevel(path)) ASC;
 id |       title        | depth | sort
----+--------------------+-------+------
  1 | Top                |     1 |    1
  8 | Collections        |     2 |    3
  9 | Pictures           |     3 |    1
 10 | Astronomy          |     4 |    1
 13 | Astronauts         |     5 |    3
 12 | Galaxies           |     5 |    2
 11 | Stars              |     5 |    1
  6 | Hobbies            |     2 |    2
  7 | Amateurs_Astronomy |     3 |    2
  2 | Science            |     2 |    1
  3 | Astronomy          |     3 |    1
  4 | Astrophysics       |     4 |    1
  5 | Cosmology          |     4 |    2
 15 | Chemia             |     3 |    3
 16 | Fizyka             |     3 |    4
 14 | Programing         |     3 |    2
(16 rows)

I tutaj można zauważyć że mamy już względnie posortowane według kategorii ale wciąż brak posortowania względem sort po prostu, no i trzecia ostateczna (chyba) propozycja wg depesza podejście drugie:

WITH RECURSIVE rec AS (
SELECT *, btrim(to_char( sort, '0000000' )) AS ordering FROM tree WHERE nlevel(path) = 1
UNION ALL
SELECT t2.*, t1.ordering || '/' || btrim(to_char( t2.sort, '0000000' )) AS ordering FROM rec t1, tree t2 WHERE t1.path @> t2.path AND nlevel(t1.path) + 1 = nlevel(t2.path)
)
SELECT id, subpath(path, -1) AS title, nlevel(path) AS depth, sort FROM rec ORDER BY ordering;
 
 id |       title        | depth | sort
----+--------------------+-------+------
  1 | Top                |     1 |    1
  2 | Science            |     2 |    1
  3 | Astronomy          |     3 |    1
  4 | Astrophysics       |     4 |    1
  5 | Cosmology          |     4 |    2
 14 | Programing         |     3 |    2
 15 | Chemia             |     3 |    3
 16 | Fizyka             |     3 |    4
  6 | Hobbies            |     2 |    2
  7 | Amateurs_Astronomy |     3 |    2
  8 | Collections        |     2 |    3
  9 | Pictures           |     3 |    1
 10 | Astronomy          |     4 |    1
 11 | Stars              |     5 |    1
 12 | Galaxies           |     5 |    2
 13 | Astronauts         |     5 |    3
(16 rows)

Dziękuje nie mam do Pana więcej pytań, rozwalił mnie jego poziom wiedzy.

To co tutaj przedstawiłem to tylko przedsmak tego co dzięki tej sposobności możemy doświadczyć, a są to:

1. ACL
2. RBAC
3. Hierarchia grup
4. Drzewa ^^

Nie będę opisywał funkcji jakie są dostępne w tym module, a na pewno nie w tym wpisie. Chciałem przedstawić że coś takiego istnieje, gdyż bardzo mało osób wie o tym, nie zdaje sobie sprawy z potężnej mocy jaką to posiada.

“źle inicjujesz zmienne”

Jak pisze mój promotor programowania J. Grębosz, sprawdź sobie czym jest jedno a czym drugie to się uśmiejesz. I rzeczywiście można się uśmiać i jednocześnie zrobić z siebie totalne pośmiewisko. Ale wybaczajmy ludziom upośledzonym umysłowo. Wychodzących z założenia że jak strzeli się pięćdziesiąt wykrzykników i napiszę się tekst za pomocą CapsLock’a to się wszystko wie. A moja domena jest sprzeczna z tym założeniem, oto one:

“jeżeli czegoś nie wiem, to nie myślę że wiem”

Mam nadzieję że gdy ktoś będzie szukał czegoś o inicjacji w programowaniu to trafi na ten wpis i się 3x dobrze zastanowi niczym użyje tego słowa.

Wracając do tematu, bo wydaje mi się że trochę od niego odbiegłem, chciałbym rozwinąć swoją myśl przedstawioną w poprzednim poście (czuje jakbym się powtarzał…). Pisałem o tym że użytkownicy Doctrine dostali narzędzie i ogromnej mocy do utworzenia aplikacji zorientowanej obiektowo oraz o wzorzec MVC, i w cale nie chcę się z tego wycofać a poprzeć tą tezę argumentami.

Do czego bym zachęcał? Otóż by każdy zainteresowany pobrał sobie sandbox’a doctrine z strony projektu, standardowo linki na samym dole. Sandbox jest w pewnym stopniu za nas skonfigurowany, i jeżeli nie czujemy potrzeby modyfikacji jego ustawień proponowałbym zostawić układ taki jaki jest, chociażby dla samego tego artykułu. Ja go osobiście trochę przerobiłem na wzór układu katalogów z symfony ale nie ważne jest to teraz.

Pisałem o tym że nie będziemy musieli ładować w kontrolerach modułów a same widoki (widok), tak zakładam że jeden widok dla jednego kontrolera, jeden model dla jednego kontrolera. Wychodząc z założenia DRY ( Don’t Repeat Yourself ), jedna metoda dla jednej i tej samej akcji, bo po co się powtarzać?

Nie chciałbym by ten topic zszedł do tematu konfiguracji sandboxa, dlatego o konfiguracji Doctrine w innym temacie.

A teraz jak to nam uprzyjemnia życie? A dajmy na to że mamy jakiś kontroler, np HandlerNews

class HandlerNews extends EventHandler  {
 
	private $_tpl;
	private $_handle;
	private $_lang;
 
	public function __construct($tpl,$event,$trans)	{
		$this->_tpl = $tpl;
		$this->_handle = $event;
		$this->_lang = $trans->getLanguage();
 
	}
 
	public function handledEvent($route) {
		if( $route[2] != '' && method_exists($this,$route[2]) ) {
			$this->_{$route[2]}();
		} else 
		  throw new Exception ('Brak akcji');
	}
 
	private function _show()	{
		$news = Doctrine::getTable('News')->getNews(Route::getId(), $this->_lang);
                $this->tpl->assign('news',$news);
	}
}

No i nasza metoda getNews wyglądała by mniej więcej tak (plik NewsTable.php):

class NewsTable extends Doctrine_Table
{
  public function getNews( $id, $lang ) {
    $query = $this->createQuery( 'n' )
                           ->where( 'n.id = ?', $id)
                           ->andWhere( 'n.lang = ?', $lang)
                           ->execute();
    return $query;
  }
}

Oto całe nasze mvc, mamy model, który jest organizowany za pomocą doctrine, mamy plik kontrolera który sobie pobiera z bazy danych dane, wrzuca je do templatki no i jakoś tam musimy wykombinować żeby jeszcze templatke wczytywać, ale to już inna kwestia.

No więc jak widać implementacja takiego wzorca MVC nie jest trudna, i nie uprzykrzajcie sobie ludzie życia wymyślając nie wiadomo co, nie wiadomo jak złożone struktury katalogów jak to jest proste jak budowa cepa

Ja wiem że równie dobrze możemy sobie utworzyć klasę w której będziemy mieli standardowe zapytania do bazy danych np na PDO, z zwykłą składnią SQL’ową. Nikt nie broni, a nawet dlaczego nie? np:

class NewsModel extends Model {
 
  public function __construct () {
    parent::__construct();  
  }
 
  public function getNews ( $id ) {
    $query = $pdo->prepare( 'SELECT * FROM news WHERE id = :id' );
    $query->bindParam( ':id', $id, PDO::PARAM_INT);
    return $query->execute();
  }
}

Dlaczego wybrałem Doctrine zamiast właśnie w ten sposób pisać osobne klasy jako modele z standardową składnią SQL? Bo tak mi jest wygodniej, oraz dla mnie bezpieczniej. Wasz wybór jaką drogę obierzecie, tylko nie modźcie z tym wzorcem… Bo widziałem różne implementację MVC i nie które to mnie po prostu przerażają, tak jak Zyx napisał, prosty wzorzec, ale nie dla wszystkich.