At the Forge

Authenticating to a Rails Application

Reuven M. Lerner

Issue #170, June 2008

Do you wish that Rails came with more built-in functionality? Plugins bridge this gap, offering solutions to many common problems.

Last month, we began to look at OpenID, the open standard for distributed identification on the Internet. OpenID allows you to have a single user profile, authenticated against a provider you trust, and to use that profile with many different Web sites and Internet applications. OpenID has been growing in popularity during the past few years, after it was first developed and used by blogging company LiveJournal. Since then, it has become a more popular and open standard, and is now supported by many Web sites, as well as all popular programming languages.

I was hoping to use this month's column to show how easy it is to make a Web application compliant with OpenID—or in OpenID terminology, to make it into an OpenID consumer. It turns out that adding OpenID capabilities isn't actually that complicated or difficult, particularly with a popular framework like Ruby on Rails, for which there are many established plugins.

However, I also found that the OpenID plugin for Rails works especially well with a plugin called acts_as_authenticated. This plugin provides a simple, secure and highly customizable authentication system for Rails applications. So this month, we are taking a slight detour, looking at how we can use acts_as_authenticated in Rails applications. Along the way, we can see how to download and use Rails plugins, an important part of Web development with Rails. Next month, we'll build on what we have created, adding OpenID to our application for a truly flexible set of login options for our users.

Rails Plugins

Although Rails provides a great deal of functionality for developers, it offers few application-level features. Rather, most of its functionality is in the form of objects and methods that programmers can use to create new applications. But, there are no built-in applications, or application fragments, or even a centralized database schema that developers can expect to find in every Rails installation.

The Rails core developers have said that this is done on purpose, because every application has different needs, and it would be impossible to please everyone. And indeed, I understand their point. Each of my applications always has needed to keep a slightly different type of information about users, let alone other types of data. Any choice the developers might make will be wrong for some people.

I happen to think there is a middle ground here. Perhaps the Rails core doesn't need to include a complete solution for users, groups and permissions. But, given the overwhelming number of applications that do define and use such objects, it would make sense to include an easily extensible skeleton within the framework itself.

Such extensions are unlikely to appear in the near future, given the strong feelings the Rails core team has expressed about them in the past. However, all is not lost. Rails includes a “plugin” system that makes it possible to download collections of code—including models, views, controllers and more—and to install them into an application. If you can find and install an appropriate plugin, you get something of a compromise solution. Once installed, the code acts as if it were an integral part of your application. And, of course, you can add only those plugins that are important to your particular application.

Because so many applications require users to register and authenticate, it should come as no surprise that there are a number of available plugins. One of the most popular is acts_as_authenticated, a plugin written by Rails core team member Rick Olson. The name does not refer to an actual declaration, but is rather a playful way of saying that it was designed to work with Rails. And, although the README file (displayed when you install the plugin) indicates that it has been deprecated (in favor of restful_authentication), acts_as_authenticated is popular and stable enough, and plays well enough with OpenID, that it is worth a look.

Rails plugins are installed with the built-in plugin tool, located in script/plugin. You can list the plugins that are available:

script/plugin list

But, this will list only those plugins located at one of the sources known to the system. To see a list of these sources, simply type:

script/plugin sources

To add a new source to the list, simply say:

script/plugin source http://svn.techno-weenie.net/projects/plugins/

Sure enough, after doing this, running script/plugin sources shows the new URL. And, of course, now typing script/plugin list shows many new plugins, from both the old source and the new one.

Installing acts_as_authenticated

To install a new plugin—say, acts_as_authenticated—we must provide its URL to script/plugin. This is as easy as the following:

script/plugin install
http://svn.techno-weenie.net/projects/plugins/acts_as_authenticated

Now, what happens when you install a plugin? Rails installs it into the vendor/plugins directory, under a new directory named after the plugin. Thus, my installation of acts_as_authenticated installed a number of files into vendor/plugins/acts_as_authenticated.

In and of itself, installing the plugin doesn't change my Rails installation or add any new functionality. Rather, a plugin typically creates one or more generators, which are used to create or modify files used by the application.

In the case of acts_as_authenticated, it comes with two different generators, which we can see by going into the generators subdirectory. Here, there are two generators, named authenticated and authenticated_mailer. If we go into the authenticated directory, we see authenticated_generator, which is what defines the generator. This allows us to go to the root directory of our Rails application and type:

script/generate authenticated user account

The above tells Rails that we want to use the authenticated plugin, which it finds in the plugin directory. The other arguments to this command indicate the model (and table name) we will use (user in this case), and the controller that should be generated to handle accounts.

The generator creates a migration file, defining the columns of the Users table using Ruby for greater database independence. In order to create the columns of the database, we must run the migration:

rake db:migration

Using my PostgreSQL database client, I now can see that the migration did its job:

atf_development=# \d users
                     Table "public.users"
          Column           |            Type             |
---------------------------+-----------------------------+
 id                        | integer                     |
 login                     | character varying(255)      |
 email                     | character varying(255)      |
 crypted_password          | character varying(40)       |
 salt                      | character varying(40)       |
 created_at                | timestamp without time zone |
 updated_at                | timestamp without time zone |
 remember_token            | character varying(255)      |
 remember_token_expires_at | timestamp without time zone |

Using the Plugin

Now that I have incorporated acts_as_authenticated into my application, I should be able to do several simple things:

  1. Mark pages as open to the public.

  2. Mark pages as private—that is, open only to registered users.

  3. Allow people to register.

  4. Allow users to log in.

  5. Allow users to log out.

All of this is not only possible with acts_as_authenticated, but it's also quite easy. To make pages require authentication by default, we can say:

before_filter :login_required

Of course, if we require that people log in before they use the login page, users will find themselves in an infinite loop. So, we can add an exception for that at the top of account_controller.rb:

before_filter :login_required, :except => [:login, :signup]

Once this filter is in place, trying to visit any page other than login or :signup bounces us back to the login page.

I'm going to register, by entering my login name, my e-mail address and my password (twice) into the registration form. Once I click on the submit button, the application inserts my data into the database. I'm in there, with ID #1, and my plain-text data as well as my encrypted data.

Moreover, after registering with the site, I am now signed in as well. I can view any page I want, without having to log in again. My login will last until I go to the /account/logout URL. Unfortunately, the default index.rhtml page that comes with acts_as_authenticated does not make it clear when you have logged out. We can check that easily by adding a line to the top, showing the contents of non-blank notices:


<p><%= flash[:notice] if not flash[:notice].blank? %></p>

We now have a basically working version of an authenticated Web server. People can register (and log in if they are already registered), and we can add both restricted and unrestricted pages via the controller and the before_filter :login_required command.

Modifying the Default Behavior

acts_as_authenticated is good enough for many sites as it currently stands. However, there are a number of plugins, suggestions and modifications that you can use with acts_as_authenticated.

For example, many registrations systems want to stop bots from automatically creating user names or e-mail addresses, which can be used to send spam. Thus, it's common for the registration system to ask that users confirm their membership requests via e-mail. So, you enter your information at the site and receive a message that asks you to click on a link. Only after clicking on that link is your account actually activated.

This functionality, although not an obvious part of the core acts_as_authenticated plugin, comes with it and is easy to use. Basically, we use the other generator that comes with acts_as_authenticated. This creates the templates and most of the logic that we need for people to confirm their login status.

There are a wide variety of other things you can do with acts_as_authenticated. For example, you can set it so that passwords are encrypted, but in a way such that it would be reversible. Another common task is to let users change their personal information, such as e-mail addresses and telephone numbers.

Conclusion

This whole discussion of acts_as_authenticated began because I wanted to use OpenID in a Rails application. However, I also wanted to integrate OpenID with an existing authentication mechanism, which brought me to acts_as_authenticated. Now that we have a working, if bare-bones, authentication system on our Web site, we can move on to the next step.

Even if you are not using acts_as_authenticated in your Rails application, it's useful to see how plugins work, how you interact with them and how you can use them to build your Rails application out of parts that have been contributed by other programmers.

Next month, we will look at how we can integrate OpenID into our login system—namely, allowing people to log in using either a user name/password combination or OpenID.

Reuven M. Lerner, a longtime Web/database developer and consultant, is a PhD candidate in learning sciences at Northwestern University, studying on-line learning communities. He recently returned (with his wife and three children) to their home in Modi'in, Israel, after four years in the Chicago area.