Yii is a very powerful PHP framework, and among other PHP frameworks it is distinguished by its great object-oriented design, MVC support, speed, flexibility and many other virtues. Recently I had some experience with the PRADO framework and chose Yii to build my image processing web application demo. It took some time for my app to stay in my home server sandbox and now it's matured enough to be revealed to public. And at this point I came close to setting up my app's security.
Yii is also known for its comprehensive documentation and well-written tutorials.
Authentication and Authorization is a good tutorial too. Among other topics, it describes basic aspects of Yii's RBAC implementation. That's what I needed to understand in order to start building my own primitive authorization system. But however hard I read the tutorial, I couldn't understand
how exactly the hierarchy works. I found how to define authorization hierarchy, how business rules are evaluated, how to configure authManager, but almost nothing about how I should build my hierarchy, in what sequence its nodes are checked, when the checking process stops and what would be the checking result.
There was no other way for me but to dig into Yii's code and I would like to present my findings in this post. I have to mention that digging in Yii's code is not difficult at all, it's well-structured and everyone can do it, but the following info can save you a bit of time when you're a Yii newbie.
I must say it would be much easier for you to understand the article if you got familiar with the above-mentioned tutorial especially with the topics starting from
Role-Based Access Control.
Let's consider the hierarchy example from the tutorial (this example illustrates how security can be built for some blog system):
$auth=Yii::app()->authManager;
$auth->createOperation('createPost','create a post');
$auth->createOperation('readPost','read a post');
$auth->createOperation('updatePost','update a post');
$auth->createOperation('deletePost','delete a post');
$bizRule='return Yii::app()->user->id==$params["post"]->authID;';
$task=$auth->createTask('updateOwnPost','update a post by author himself',$bizRule);
$task->addChild('updatePost');
$role=$auth->createRole('reader');
$role->addChild('readPost');
$role=$auth->createRole('author');
$role->addChild('reader');
$role->addChild('createPost');
$role->addChild('updateOwnPost');
$role=$auth->createRole('editor');
$role->addChild('reader');
$role->addChild('updatePost');
$role=$auth->createRole('admin');
$role->addChild('editor');
$role->addChild('author');
$role->addChild('deletePost');
First of all I'd like to convert this to a more human-readable form:
 |
| Sample blog system authorization hierarchy |
The
turquoise boxes represent roles, the
yellow box is a task, and the most fine-grained level of the authorization hierarchy - operations - are
tan. Collectively roles, tasks and operations are called
authorization items. You should keep in mind that functionally all auth item types are equal. It's completely up to you to make some auth item a role or a task - still it would do the same thing. Different types of auth items are introduced solely for the purpose of naming convenience. You are not limited to the three authorization levels: there can be multiple levels of roles, tasks and operations. (Getting back to our diagram, you can see this point illustrated by multiple levels of roles.) Also you may skip any of these levels (the role
author has immediate child operation
create). The only restriction is that in the auth hierarchy roles should stay higher than tasks and tasks should stay higher than operations.
Now let's take a quick look at what was on blog system creator's mind. Everything seems to be quite logical. The weakest role is
reader: the only thing he is allowed to do is to
read. An
author has a bit more power: he also can
create posts and
update his own posts.
Editors can read posts and
update (edit)
all posts, not own ones (in fact, according to the hierarchy, editors can't create posts and that's why editors haven't got any
own posts at all). And of course, the most powerful role is
admin which can do anything.
If you are familiar with the principles of object-oriented hierarchy, your former knowledge may lead you to a confusion. In every subsequent level of an object tree, objects obtain (inherit) all (or part) of the features of their parent (base) objects. This results in that bottommost objects are most "loaded" with features, while the root objects have only basic features. The opposite happens with RBAC hierarchy in Yii. The bottommost items in the authorization hierarchy represent basic operations, while the topmost authorization items (usually roles) are the most powerful and compound ones in the whole authorization system.
So now that the idea behind the hierarchy is clear, let's understand how the access checking works. To check if the current user as allowed to perform a particular action, you should call the the
checkAccess method, for example:
if(Yii::app()->user->checkAccess('createPost'))
{
// create post
}
How our hierarchy is used by Yii to check the access? Although you are not required to read this to understand the rest of the article, I provide here an example piece of Yii's code responsible for access checking (an implementation of CAuthManager for databases - CDbAutManager) for your reference:
if(($item=$this->getAuthItem($itemName))===null)
return false;
Yii::trace('Checking permission "'.$item->getName().'"','system.web.auth.CDbAuthManager');
if($this->executeBizRule($item->getBizRule(),$params,$item->getData()))
{
if(in_array($itemName,$this->defaultRoles))
return true;
if(isset($assignments[$itemName]))
{
$assignment=$assignments[$itemName];
if($this->executeBizRule($assignment->getBizRule(),$params,$assignment->getData()))
return true;
}
$sql="SELECT parent FROM {$this->itemChildTable} WHERE child=:name";
foreach($this->db->createCommand($sql)->bindValue(':name',$itemName)->queryColumn() as $parent)
{
if($this->checkAccessRecursive($parent,$userId,$params,$assignments))
return true;
}
}
return false;
When you call
checkAccess, Yii begins to recursively climb along the authorization hierarchy and check each item's business rule. For instance, when you make a call like this
Yii::app()->user->checkAccess('readPost')
Yii first checks the
readPost's business rule (recall that an empty business rule is equivalent to a business rule always returning
true). Then it searches for all
readPost's parents - these are
author and
editor - and checks their business rules as well. The process doesn't stop when a business rule has been evaluated to
true; it only stops when some rule returned
false or we have reached the top of the hierarchy and there are no more parents to check.
So what are ways for the
checkAccess method to return
true? They are two. First, the iteration can stop with a positive result when Yii encounters in the hierarchy a so-called
default role - a role that is assigned by default to all authenticated users. For our blog system this can be the
reader role. Default roles can be set up in the web app configuration file; how this is done is described thoroughly in the
Using Default Roles section of the tutorial.
The second way to make
checkAccess return
true is explicitly creating an
authorization assignment which is basically defining an <auth item>-<user> pair. In code, this can be done like this:
$auth->assign('reader','Pete');
$auth->assign('author','Bob');
$auth->assign('editor','Alice');
$auth->assign('admin','John');
which is semantically equivalent to assigning roles to users. You're not limited to assigning roles; individual tasks and operations can be assigned to users as well. In real life, it is more practical not to hard code all auth assignments but to store them in a database. You can implement this scenario using the
CDbAuthManager component which is described in the Yii tutorial.
Let's get back to the
checkAccess discussion. Before hierarchy iteration begins, Yii collects all authorization items assigned to the current user and at each iteration step checks if current hierarchy's auth item is in the assignment list. If it is, the iteration stops and returns a positive result.
Assume we are implementing security for the "update post" user action. Whoever is logged in into our blog system should pass our authorization check before he is able to edit a post. Therefore the most appropriate place to check the access is the beginning of the respective controller action:
public function actionUpdatePost()
{
if(!Yii::app()->user->checkAccess('updatePost'))
Yii::app()->end();
// ... more code
}
Suppose the current user is
Alice. Let's see how Yii processes the auth hierarchy. Although
updateOwnPost is an immediate parent of
updatePost and returns
false, Yii quickly finds another parent auth item which returns
true - the
editor role. As a result, Alice gets a permission to do a post update. What happens if
Bob logs in? In this case the branch of the hierarchy going through the
editor item is also processed but no item along it returns
true. The only possible way for the access check to succeed is then to go through the
updateOwnPost item.
But instead of an empty "always-true" business rule
updateOwnPost has a more complex one (see the first code snippet at the beginning of the article) and for the evaluation it requires the post creator's ID. How can we supply it to the business rule? In the form of
checkAccess's parameter. To achieve this we need to modify our controller action handler in the following way:
public function actionUpdatePost()
{
// here we obtain $post, probably via active record ...
if(!Yii::app()->user->checkAccess('updatePost', array('post'=>$post)))
Yii::app()->end();
// ... more code
}
Note that despite
updateOwnPost returns
true for
Bob, the iteration through auth hierarchy still goes on. It only stops and returns success when it reaches the
author item.
I think now you're able to figure out how Yii would check access given that
Pete or
John logged in.
Returning to the above code snippet, it may seem that we're providing the
post parameter to the
updatePost operation whose business rule is empty and requires no parameters at all. This is truth but not all of it. In fact Yii passes the same parameter set (there can be several parameters as they are passed as an array) to every hierarchy item at every iteration. If item's business rule requires no parameters, it simply ignores them. If it does require them, it takes only those that it needs.
This leads to the two possible parameter passing strategies. The first one is to remember for every auth item what other auth items can be reached from it in the hierarchy and provide each call to
checkAccess with the exact number of parameters. The advantage of this strategy is code brevity and probably efficiency. The other strategy is to always pass all parameters to every auth item, no matter if they would actually be used for business rule evaluation. This is a "fire-and-forget" method which can help to avoid much of trial and error while implementing you app's security. Its downside is possible code clutter and maybe drop in script performance.
This is only basic information about the RBAC authorization model in Yii; much more advanced security models can be built using it. Please refer to
The Definitive Guide to Yii and
Class Reference for more details. Also there's a number of web interfaces implemented as
extensions which can help you do the Yii RBAC administration.
The main debug window should look like this:
All baselines seem to be found perfectly:
For more complex images things go worse. Here I've taken an photographic image of a restaurant receipt. In the image the receipt appears to be inclined and perspectively distorted. The paper is a bit curved, just like it usually happens with receipts. The image is precooked by my image processor (only done binarization and noise cleanup) so that Tesseract is able process it, at some degree of success.
The main debug window already shows several segmentation failures. Some characters are grayed out and some are missing completely:
In BlnWords one can see that many baselines are good but some are determined incorrectly, for instance:
Also there are some epic failures, like these (meaning that characters from adjacent rows get segmented into a single word):
So why would you want to use this debugging method? It can be of use when you're investigating the reasons of some Tesseract failure. Baseline viewer can help you to see that an additional preprocessing is required to cope with the image or a set of images, either programmatic or by means of 3rd party software such as ImageMagick. Passing image block by block (i.e. full or partial pre-segmentation) might also help. Another approach is tweaking internal Tesseract segmentation and baseline finding parameters via config files. Yet another approach is source code changes.
