Add files using upload-large-folder tool

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/packages/auth/classes/auth/acl/driver.php

@@ -0,0 +1,97 @@
+<?php
+/**
+ * Fuel
+ *
+ * Fuel is a fast, lightweight, community driven PHP5 framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Auth;
+
+
+abstract class Auth_Acl_Driver extends \Auth_Driver
+{
+
+	/**
+	 * @var	Auth_Driver	default instance
+	 */
+	protected static $_instance = null;
+
+	/**
+	 * @var	array	contains references if multiple were loaded
+	 */
+	protected static $_instances = array();
+
+	public static function forge(array $config = array())
+	{
+		// default driver id to driver name when not given
+		! array_key_exists('id', $config) && $config['id'] = $config['driver'];
+
+		$class = \Inflector::get_namespace($config['driver']).'Auth_Acl_'.\Str::ucwords(\Inflector::denamespace($config['driver']));
+		$driver = new $class($config);
+		static::$_instances[$driver->get_id()] = $driver;
+		is_null(static::$_instance) and static::$_instance = $driver;
+
+		foreach ($driver->get_config('drivers', array()) as $type => $drivers)
+		{
+			foreach ($drivers as $d => $custom)
+			{
+				$custom = is_int($d)
+					? array('driver' => $custom)
+					: array_merge($custom, array('driver' => $d));
+				$class = 'Auth_'.\Str::ucwords($type).'_Driver';
+				$class::forge($custom);
+			}
+		}
+
+		return $driver;
+	}
+
+	/**
+	 * Parses a conditions string into it's array equivalent
+	 *
+	 * @rights	mixed	conditions array or string
+	 * @return	array	conditions array formatted as array(area, rights)
+	 *
+	 */
+	public static function _parse_conditions($rights)
+	{
+		if (is_array($rights))
+		{
+			return $rights;
+		}
+
+		if ( ! is_string($rights) or strpos($rights, '.') === false)
+		{
+			throw new \InvalidArgumentException('Given rights where not formatted proppery. Formatting should be like area.right or area.[right, other_right]. Received: '.$rights);
+		}
+
+		list($area, $rights) = explode('.', $rights);
+
+		if (substr($rights, 0, 1) == '[' and substr($rights, -1, 1) == ']')
+		{
+			$rights = preg_split('#( *)?,( *)?#', trim(substr($rights, 1, -1)));
+		}
+
+		return array($area, $rights);
+	}
+
+	// ------------------------------------------------------------------------
+
+	/**
+	 * Check access rights
+	 *
+	 * @param	mixed	condition to check for access
+	 * @param	mixed	user or group identifier in the form of array(driver_id, id)
+	 * @return	bool
+	 */
+	abstract public function has_access($condition, Array $entity);
+}
+
+/* end of file driver.php */

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/packages/auth/classes/auth/acl/ormacl.php

@@ -0,0 +1,254 @@
+<?php
+/**
+ * Fuel is a fast, lightweight, community driven PHP5 framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Auth;
+
+/**
+ * OrmAuth ORM driven acl driver
+ *
+ * @package     Fuel
+ * @subpackage  Auth
+ */
+class Auth_Acl_Ormacl extends \Auth_Acl_Driver
+{
+	/*
+	 * @var  array  list of valid roles
+	 */
+	protected static $_valid_roles = array();
+
+	/*
+	 * class init
+	 */
+	public static function _init()
+	{
+		// get the list of valid roles
+		try
+		{
+			static::$_valid_roles = \Cache::get(\Config::get('ormauth.cache_prefix', 'auth').'.roles');
+		}
+		catch (\CacheNotFoundException $e)
+		{
+			static::$_valid_roles = \Model\Auth_Role::find('all');
+			\Cache::set(\Config::get('ormauth.cache_prefix', 'auth').'.roles', static::$_valid_roles);
+		}
+	}
+
+	/*
+	 * Return the list of defined roles
+	 */
+	public function roles()
+	{
+		return static::$_valid_roles;
+	}
+
+	/*
+	 * Check if the user has the required permissions
+	 */
+	public function has_access($condition, Array $entity)
+	{
+		// get the group driver instance
+		$group_driver = \Auth::group($entity[0]);
+
+		// parse the requested permissions so we can check them
+		$condition = static::_parse_conditions($condition);
+
+		// if we couldn't parse the conditions, don't have a driver, or the driver doesn't export roles, bail out
+		if ( ! is_array($condition) || empty($group_driver) || ! is_callable(array($group_driver, 'get_roles')))
+		{
+			return false;
+		}
+
+		// get the permission area and the permission rights to be checked
+		$area    = $condition[0];
+
+		// any actions defined?
+		if ( ! is_array($condition[1]) and preg_match('#(.*)?\[(.*)?\]#', $condition[1], $matches))
+		{
+			$rights = (array) $matches[1];
+			$actions = explode(',', $matches[2]);
+		}
+		else
+		{
+			$rights  = (array) $condition[1];
+			$actions = array();
+		}
+
+		// fetch the current user object
+		$user = Auth::get_user();
+
+		// some storage to collect the current rights and revoked rights, and the global flag
+		$current_rights = array();
+		$revoked_rights = array();
+		$global_access = null;
+
+		// assemble the current users effective rights
+		$cache_key = \Config::get('ormauth.cache_prefix', 'auth').'.permissions.user_'.($user ? $user->id : 0);
+		try
+		{
+			list($current_rights, $revoked_rights, $global_access) = \Cache::get($cache_key);
+		}
+		catch (\CacheNotFoundException $e)
+		{
+			// get the role objects assigned to this group
+			$current_roles  = $entity[1]->roles;
+
+			// if we have a user, add the roles directly assigned to the user
+			if ($user)
+			{
+				$current_roles = \Arr::merge($current_roles, Auth::get_user()->roles);
+			}
+
+			foreach ($current_roles as $role)
+			{
+				// role grants all access
+				if ($role->filter == 'A')
+				{
+					$global_access = true;
+				}
+
+				// role denies all access
+				elseif ($role->filter == 'D')
+				{
+					$global_access = false;
+				}
+
+				// role defines a permission revocation
+				elseif ($role->filter == 'R')
+				{
+					// fetch the permissions of this role
+					foreach ($role->permissions as $permission)
+					{
+						isset($revoked_rights[$permission->area][$permission->permission]) or $revoked_rights[$permission->area][$permission->permission] = array();
+						$revoked_rights[$permission->area][$permission->permission] = array_merge(
+							$revoked_rights[$permission->area][$permission->permission],
+							array_intersect_key(
+								$role->rolepermission['['.$role->id.']['.$permission->id.']']->permission->actions,
+								array_flip($role->rolepermission['['.$role->id.']['.$permission->id.']']->actions)
+							)
+						);
+					}
+				}
+
+				// standard role, add it to the current rights set
+				else
+				{
+					// fetch the permissions of this role
+					foreach ($role->permissions as $permission)
+					{
+						isset($current_rights[$permission->area][$permission->permission]) or $current_rights[$permission->area][$permission->permission] = array();
+						$current_rights[$permission->area][$permission->permission] = array_merge(
+							$current_rights[$permission->area][$permission->permission],
+							array_intersect_key(
+								$role->rolepermission['['.$role->id.']['.$permission->id.']']->permission->actions,
+								array_flip($role->rolepermission['['.$role->id.']['.$permission->id.']']->actions)
+							)
+						);
+					}
+				}
+			}
+
+			// if this user doesn't have a global filter applied...
+			if (is_array($current_rights))
+			{
+				if ($user)
+				{
+					// add the users group rights
+					foreach ($user->group->permissions as $permission)
+					{
+						isset($current_rights[$permission->area][$permission->permission]) or $current_rights[$permission->area][$permission->permission] = array();
+						$current_rights[$permission->area][$permission->permission] = array_merge(
+							$current_rights[$permission->area][$permission->permission],
+							array_intersect_key(
+								$user->group->grouppermission['['.$user->group_id.']['.$permission->id.']']->permission->actions,
+								array_flip($user->group->grouppermission['['.$user->group_id.']['.$permission->id.']']->actions)
+							)
+						);
+					}
+
+					// add the users personal rights
+					if ($user)
+					{
+						foreach ($user->permissions as $permission)
+						{
+							isset($current_rights[$permission->area][$permission->permission]) or $current_rights[$permission->area][$permission->permission] = array();
+							$current_rights[$permission->area][$permission->permission] = array_merge(
+								$current_rights[$permission->area][$permission->permission],
+								array_intersect_key(
+									$user->userpermission['['.$user->id.']['.$permission->id.']']->permission->actions,
+									array_flip($user->userpermission['['.$user->id.']['.$permission->id.']']->actions)
+								)
+							);
+						}
+					}
+				}
+			}
+
+			// save the rights in the cache
+			\Cache::set($cache_key, array($current_rights, $revoked_rights, $global_access));
+		}
+
+		// check for a revocation first
+		foreach ($rights as $right)
+		{
+			// check revocation permissions
+			if ( isset($revoked_rights[$area]) and array_key_exists($right, $revoked_rights[$area]))
+			{
+				$revoked = true;
+
+				// need to check any actions?
+				foreach ($actions as $action)
+				{
+					if ( ! in_array($action, $revoked_rights[$area][$right]))
+					{
+						$revoked = false;
+						break;
+					}
+				}
+
+				// right revoked?
+				if ($revoked)
+				{
+					return false;
+				}
+			}
+		}
+
+		// was a global filter applied?
+		if (is_bool($global_access))
+		{
+			// we're done here
+			return $global_access;
+		}
+
+		// start checking rights, terminate false when right not found
+		foreach ($rights as $right)
+		{
+			// check basic permissions
+			if ( ! isset($current_rights[$area]) or ! array_key_exists($right, $current_rights[$area]))
+			{
+				return false;
+			}
+
+			// need to check any actions?
+			foreach ($actions as $action)
+			{
+				if ( ! in_array($action, $current_rights[$area][$right]))
+				{
+					return false;
+				}
+			}
+		}
+
+		// all necessary rights were found, return true
+		return true;
+	}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/packages/auth/classes/auth/driver.php

@@ -0,0 +1,125 @@
+<?php
+/**
+ * Fuel
+ *
+ * Fuel is a fast, lightweight, community driven PHP5 framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Auth;
+
+
+abstract class Auth_Driver
+{
+
+	/**
+	 * @var	Auth_Driver
+	 * THIS MUST BE DEFINED IN THE BASE EXTENSION
+	 */
+	// protected static $_instance = null;
+
+	/**
+	 * @var	array	contains references if multiple were loaded
+	 * THIS MUST BE DEFINED IN THE BASE EXTENSION
+	 */
+	// protected static $_instances = array();
+
+	public static function forge(array $config = array())
+	{
+		throw new \AuthException('Driver must have a factory method extension.');
+	}
+
+	/**
+	 * Return a specific driver, or the default instance
+	 *
+	 * @param	string	driver id
+	 * @return	Auth_Driver
+	 */
+	public static function instance($instance = null)
+	{
+		if ($instance === true)
+		{
+			return static::$_instances;
+		}
+		elseif ($instance !== null)
+		{
+			if ( ! array_key_exists($instance, static::$_instances))
+			{
+				return false;
+			}
+
+			return static::$_instances[$instance];
+		}
+
+		return static::$_instance;
+	}
+
+	// ------------------------------------------------------------------------
+
+	/**
+	 * @var	string	instance identifier
+	 */
+	protected $id;
+
+	/**
+	 * @var	array	given configuration array
+	 */
+	protected $config = array();
+
+	protected function __construct(Array $config)
+	{
+		$this->id = $config['id'];
+		$this->config = array_merge($this->config, $config);
+	}
+
+	/**
+	 * Get driver instance ID
+	 *
+	 * @return string
+	 */
+	public function get_id()
+	{
+		return (string) $this->id;
+	}
+
+	/**
+	 * Create or change config value
+	 *
+	 * @param	string
+	 * @param	mixed
+	 */
+	public function set_config($key, $value)
+	{
+		$this->config[$key] = $value;
+	}
+
+	/**
+	 * Retrieve config value
+	 *
+	 * @param	string
+	 * @param	mixed	return when key doesn't exist
+	 * @return	mixed
+	 */
+	public function get_config($key, $default = null)
+	{
+		return array_key_exists($key, $this->config) ? $this->config[$key] : $default;
+	}
+
+	/**
+	 * Whether this driver supports guest login
+	 *
+	 * @return  bool
+	 */
+	public function guest_login()
+	{
+		return false;
+	}
+}
+
+/* end of file driver.php */

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/packages/auth/classes/auth/exceptions.php

@@ -0,0 +1,20 @@
+<?php
+/**
+ * Fuel is a fast, lightweight, community driven PHP5 framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Auth;
+
+
+class SimpleUserUpdateException extends \FuelException {}
+
+class SimpleUserWrongPassword extends \FuelException {}
+
+class OpauthException extends \FuelException {}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/packages/auth/classes/auth/opauth.php

@@ -0,0 +1,407 @@
+<?php
+/**
+ * Fuel
+ *
+ * Fuel is a fast, lightweight, community driven PHP5 framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Auth;
+
+class Auth_Opauth
+{
+	/**
+	 * @var  string  name of the providers table
+	 */
+	protected static $provider_table = null;
+
+	/**
+	 * Class initialisation
+	 */
+	public static function _init()
+	{
+		// just checkin', do we have Opauth installed?
+		if ( ! class_exists('Opauth'))
+		{
+			throw new \OpauthException('Opauth composer package not installed. Add "opauth/opauth" to composer.json and run a composer update.');
+		}
+
+		// load the auth and opauth config
+		\Config::load('auth', true);
+		\Config::load('opauth', true);
+
+		// determine the auth driver we're going to use
+		$drivers = \Config::get('auth.driver', array());
+		is_array($drivers) or $drivers = array($drivers);
+
+		if (in_array('Simpleauth', $drivers))
+		{
+			// get the tablename
+			\Config::load('simpleauth', true);
+			static::$provider_table = \Config::get('simpleauth.table_name', 'users').'_providers';
+		}
+
+		elseif (in_array('Ormauth', $drivers))
+		{
+			// get the tablename
+			\Config::load('ormauth', true);
+			static::$provider_table = \Config::get('ormauth.table_name', 'users').'_providers';
+		}
+	}
+
+	/**
+	 * Create an OpAuth instance
+	 *
+	 * @param  array any call-time configuration to be used
+	 * @param  bool  whether or not Opauth should run automatically
+	 */
+	public static function forge($config = array(), $autorun = true)
+	{
+		// deal with passing only the autorun value
+		if (func_num_args() == 1 and is_bool($config))
+		{
+			$autorun = $config;
+			$config = array();
+		}
+
+		// merge the default config with the runtime config
+		$config = \Arr::merge(\Config::get('opauth'), $config);
+
+		// define the transport system we use
+		$config['callback_transport'] = 'get';
+
+		// make sure we have a remotes table
+		if ( ! isset($config['table']) and ($config['table'] = static::$provider_table) === null)
+		{
+			throw new \OpauthException('No providers table configured. At the moment, only SimpleAuth and OrmAuth can be auto-detected.');
+		}
+
+		// and a security salt
+		if (empty($config['security_salt']))
+		{
+			throw new \OpauthException('There is no "security_salt" defined in the opauth.php configuration file.');
+		}
+
+		// set some defaults, just in case
+		isset($config['security_iteration']) or $config['security_iteration'] = 300;
+		isset($config['security_timeout']) or $config['security_timeout'] = '2 minutes';
+
+		if (empty($config['path']))
+		{
+			$parsed_url = parse_url(\Uri::base().\Request::main()->uri->get());
+			$path = explode('/', trim($parsed_url['path'], '/'));
+
+			// construct the path if needed
+//			$path = \Request::main()->uri->get_segments();
+			$params = count(\Request::active()->route->method_params);
+
+			while ($params-- > 0)
+			{
+				array_pop($path);
+			}
+			$config['path'] = '/'.(implode('/', $path)).'/';
+		}
+
+		// and construct the callback URL if needed
+		if (empty($config['callback_url']))
+		{
+			// pop the method name from the path
+			$path = explode('/', trim($config['path'], '/'));
+			array_pop($path);
+
+			// and add 'callback' as the controller callback action
+			$config['callback_url'] = '/'.implode('/', $path).'/callback/';
+		}
+
+		// determine the name of the provider we want to call
+		if ( ! $autorun)
+		{
+			// we're processing a callback
+			$config['provider'] = 'Callback';
+		}
+		else
+		{
+			if (empty($config['provider']))
+			{
+				$parsed_url = parse_url(\Uri::base().\Request::main()->uri->get());
+				$provider = explode('/', substr($parsed_url['path'], strlen($config['path'])));
+				$config['provider'] = ucfirst($provider[0]);
+			}
+
+			// check if we have a strategy defined for this provider
+			$strategies = \Config::get('opauth.Strategy', array());
+			if ( ! array_key_exists(strtolower($config['provider']), array_change_key_case($strategies)))
+			{
+				throw new \OpauthException('Opauth strategy "'.$config['provider'].'" is not supported');
+			}
+		}
+
+		// return the created Auth_Opauth object
+		return new static($config, $autorun);
+	}
+
+	// -------------------------------------------------------------------------
+
+	/**
+	 * Opauth configuration
+	 */
+	protected $config = array();
+
+	/**
+	 * Opauth instance
+	 */
+	protected $opauth = null;
+
+	/**
+	 * Opauth response
+	 */
+	protected $response = array();
+
+	/**
+	 * Construct the Auth_Opauth object
+	 */
+	public function __construct(Array $config, $autorun = true)
+	{
+		// store the config
+		$this->config = $config;
+
+		// construct the Opauth object
+		$this->opauth = new \Opauth($config, $autorun);
+	}
+
+	/**
+	 * New Opauth login. If we know this user, we can perform a login, if
+	 * not, we need to register the user first
+	 */
+	public function login_or_register()
+	{
+		// process the callback data
+		$this->callback();
+
+		// if there is no UID we don't know who this is
+		if ($this->get('auth.uid', null) === null)
+		{
+			throw new \OpauthException('No uid in response from the provider, so we have no idea who you are.');
+		}
+
+		// we have a UID and logged in? Just attach this authentication to a user
+		if (\Auth::check())
+		{
+			list(, $user_id) = \Auth::instance()->get_user_id();
+
+			$result = \DB::select(\DB::expr('COUNT(*) as count'))->from($this->config['table'])->where('parent_id', '=', $user_id)->execute();
+			$num_linked = ($result and $result = $result->current()) ? $result['count'] : 0;
+
+			// allowed multiple providers, or not authed yet?
+			if ($num_linked === 0 or \Config::get('opauth.link_multiple_providers') === true)
+			{
+				// attach this account to the logged in user
+				$this->link_provider(array(
+					'parent_id'		=> $user_id,
+					'provider' 		=> $this->get('auth.provider'),
+					'uid' 			=> $this->get('auth.uid'),
+					'access_token' 	=> $this->get('auth.credentials.token', null),
+					'secret' 		=> $this->get('auth.credentials.secret', null),
+					'expires' 		=> $this->get('auth.credentials.expires', null),
+					'refresh_token' => $this->get('auth.credentials.refresh_token', null),
+					'created_at' 	=> time(),
+				));
+
+				// attachment went ok so we'll redirect
+				return 'linked';
+			}
+
+			else
+			{
+				$result = \DB::select()->from($this->config['table'])->where('parent_id', '=', $user_id)->limit(1)->as_object()->execute();
+				$auth = $result ? $result->current() : null;
+				throw new \OpauthException(sprintf('This user is already linked to "%s" and can\'t be linked to another provider.', $auth->provider));
+			}
+		}
+
+		// the user exists, so send him on his merry way as a user
+		elseif ($authentication = \DB::select()->from($this->config['table'])->where('uid', '=', $this->get('auth.uid'))->where('provider', '=', $this->get('auth.provider'))->as_object()->execute() and $authentication->count())
+		{
+			// force a login with this username
+			$authentication = $authentication->current();
+			if (\Auth::instance()->force_login((int) $authentication->parent_id))
+			{
+			    // credentials ok, go right in
+			    return 'logged_in';
+			}
+
+			throw new \OpauthException('This user could not be logged in.');
+		}
+
+		// not an existing user of any type, so we need to create a user somehow
+		else
+		{
+			// generate a dummy password if we don't have one, and want auto registration for this user
+			if ($this->config['auto_registration'])
+			{
+				$this->get('auth.info.password') or $this->response['auth']['info']['password'] = \Str::random('sha1');
+			}
+
+			// did the provider return enough information to log the user in?
+			if ($this->get('auth.info.nickname') and $this->get('auth.info.email') and $this->get('auth.info.password'))
+			{
+				// make a user with what we have
+				$user_id = $this->create_user($this->response['auth']['info']);
+
+				// attach this authentication to the new user
+				$insert_id = $this->link_provider(array(
+					'parent_id'		=> $user_id,
+					'provider' 		=> $this->get('auth.provider'),
+					'uid' 			=> $this->get('auth.uid'),
+					'access_token' 	=> $this->get('auth.credentials.token', null),
+					'secret' 		=> $this->get('auth.credentials.secret', null),
+					'expires' 		=> $this->get('auth.credentials.expires', null),
+					'refresh_token' => $this->get('auth.credentials.refresh_token', null),
+					'created_at' 	=> time(),
+				));
+
+				// force a login with this users id
+				if ($insert_id and \Auth::instance()->force_login((int) $user_id))
+				{
+				    // credentials ok, go right in
+				    return 'registered';
+				}
+
+				throw new \OpauthException('We tried automatically creating a user but that just really did not work. Not sure why...');
+			}
+
+			// they aren't a user and cant be automatically registerd, so redirect to registration page
+			else
+			{
+				\Session::set('auth-strategy', array(
+					'user' => $this->get('auth.info'),
+					'authentication' => array(
+						'provider' 		=> $this->get('auth.provider'),
+						'uid' 			=> $this->get('auth.uid'),
+						'access_token' 	=> $this->get('auth.credentials.token', null),
+						'secret' 		=> $this->get('auth.credentials.secret', null),
+						'expires' 		=> $this->get('auth.credentials.expires', null),
+						'refresh_token' => $this->get('auth.credentials.refresh_token', null),
+					),
+				));
+
+				return 'register';
+			}
+		}
+	}
+
+	/**
+	 * create a remote entry for this login
+	 */
+	public function link_provider(array $data)
+	{
+		// do some validation
+		if ( ! is_numeric($data['expires']))
+		{
+			if ($date = \DateTime::createFromFormat(\DateTime::ISO8601, $data['expires']))
+			{
+				$data['expires'] = $date->getTimestamp();
+			}
+			elseif ($date = \DateTime::createFromFormat('Y-m-d H:i:s', $data['expires']))
+			{
+				$data['expires'] = $date->getTimestamp();
+			}
+			else
+			{
+				$data['expires'] = time();
+			}
+		}
+
+		// get rid of old registrations to prevent duplicates
+		\DB::delete($this->config['table'])->where('uid', '=', $data['uid'])->where('provider', '=', $data['provider'])->execute();
+
+		// insert the new provider UID
+		list($insert_id, $rows_affected) = \DB::insert($this->config['table'])->set($data)->execute();
+		return $rows_affected ? $insert_id : false;
+	}
+
+	/**
+	 * Get a response value
+	 */
+	public function get($key, $default = null)
+	{
+		return is_array($this->response) ? \Arr::get($this->response, $key, $default) : $default;
+	}
+
+	/**
+	 * fetch the callback response
+	 */
+	protected function callback()
+	{
+		// fetch the response and decode it
+		$this->response = \Input::get('opauth', false) and $this->response = unserialize(base64_decode($this->response));
+
+		// did we receive a response at all?
+		if ( ! $this->response)
+		{
+			throw new \OpauthException('no valid response received in the callback');
+		}
+
+		// did we receive one, but was it an error
+		if (array_key_exists('error', $this->response))
+		{
+			throw new \OpauthException('Authentication error: the callback returned an error auth response');
+		}
+
+		// validate the response
+		if ($this->get('auth') === null or $this->get('timestamp') === null or
+			$this->get('signature') === null or $this->get('auth.provider') === null or $this->get('auth.uid') === null)
+		{
+			throw new \OpauthException('Invalid auth response: Missing key auth response components');
+		}
+		elseif ( ! $this->opauth->validate(sha1(print_r($this->get('auth'), true)), $this->get('timestamp'), $this->get('signature'), $reason))
+		{
+			throw new \OpauthException('Invalid auth response: '.$reason);
+		}
+	}
+
+	/**
+	 * use Auth to create a new user, in case we've received enough information to do so
+	 *
+	 * @param  array  array with the raw Opauth response user fields
+	 *
+	 * @return  mixed  id of the user record created, or false if the create failed
+	 */
+	protected function create_user(array $user)
+	{
+		$user_id = \Auth::create_user(
+
+			// username
+			isset($user['nickname']) ? $user['nickname'] : null,
+
+			// password (random string will do if none provided)
+			isset($user['password']) ? $user['password'] : \Str::random(),
+
+			// email address
+			isset($user['email']) ? $user['email'] : null,
+
+			// which group are they in?
+			\Config::get('opauth.default_group', -1),
+
+			// extra information
+			array(
+
+				// got their name? full name? or first and last to make up a full name?
+				'fullname' => isset($user['name']) ? $user['name'] : (
+					isset($user['full_name']) ? $user['full_name'] : (
+						isset($user['first_name'], $user['last_name']) ? $user['first_name'].' '.$user['last_name'] : null
+					)
+				),
+			)
+		);
+
+		return $user_id ?: false;
+	}
+
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/packages/auth/classes/model/auth/group.php

@@ -0,0 +1,155 @@
+<?php
+/**
+ * Fuel is a fast, lightweight, community driven PHP5 framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Auth\Model;
+
+class Auth_Group extends \Orm\Model
+{
+	/**
+	 * @var  string  connection to use
+	 */
+	protected static $_connection = null;
+
+	/**
+	 * @var  string  table name to overwrite assumption
+	 */
+	protected static $_table_name;
+
+	/**
+	 * @var array	model properties
+	 */
+	protected static $_properties = array(
+		'id',
+		'name'     => array(
+			'label'		  => 'auth_model_group.name',
+			'default' 	  => '',
+			'null'		  => false,
+			'validation'  => array('required', 'max_length' => array(255))
+		),
+		'user_id'         => array(
+			'default' 	  => 0,
+			'null'		  => false,
+			'form'  	  => array('type' => false),
+		),
+		'created_at'      => array(
+			'default' 	  => 0,
+			'null'		  => false,
+			'form'  	  => array('type' => false),
+		),
+		'updated_at'      => array(
+			'default' 	  => 0,
+			'null'		  => false,
+			'form'  	  => array('type' => false),
+		),
+	);
+
+	/**
+	 * @var array	defined observers
+	 */
+	protected static $_observers = array(
+		'Orm\\Observer_CreatedAt' => array(
+			'events' => array('before_insert'),
+			'property' => 'created_at',
+			'mysql_timestamp' => false
+		),
+		'Orm\\Observer_UpdatedAt' => array(
+			'events' => array('before_update'),
+			'property' => 'updated_at',
+			'mysql_timestamp' => false
+		),
+		'Orm\\Observer_Typing' => array(
+			'events' => array('after_load', 'before_save', 'after_save')
+		),
+		'Orm\\Observer_Self' => array(
+			'events' => array('before_insert', 'before_update'),
+			'property' => 'user_id'
+		),
+	);
+
+	/**
+	 * @var array	has_many relationships
+	 */
+	protected static $_has_many = array(
+		'users' => array(
+			'model_to' => 'Model\\Auth_User',
+			'key_from' => 'id',
+			'key_to'   => 'group_id',
+		),
+		'grouppermission' => array(
+			'model_to' => 'Model\\Auth_Grouppermission',
+			'key_from' => 'id',
+			'key_to'   => 'group_id',
+			'cascade_delete' => false,
+		),
+	);
+
+	/**
+	 * @var array	many_many relationships
+	 */
+	protected static $_many_many = array(
+		'roles' => array(
+			'key_from' => 'id',
+			'model_to' => 'Model\\Auth_Role',
+			'key_to' => 'id',
+			'table_through' => null,
+			'key_through_from' => 'group_id',
+			'key_through_to' => 'role_id',
+		),
+		'permissions' => array(
+			'key_from' => 'id',
+			'model_to' => 'Model\\Auth_Permission',
+			'key_to' => 'id',
+			'table_through' => null,
+			'key_through_from' => 'group_id',
+			'key_through_to' => 'perms_id',
+		),
+	);
+
+	/**
+	 * init the class
+	 */
+   	public static function _init()
+	{
+		// auth config
+		\Config::load('ormauth', true);
+
+		// set the connection this model should use
+		static::$_connection = \Config::get('ormauth.db_connection');
+
+		// set the models table name
+		static::$_table_name = \Config::get('ormauth.table_name', 'users').'_groups';
+
+		// set the relations through table names
+		static::$_many_many['roles']['table_through'] = \Config::get('ormauth.table_name', 'users').'_group_roles';
+		static::$_many_many['permissions']['table_through'] = \Config::get('ormauth.table_name', 'users').'_group_permissions';
+
+		// model language file
+		\Lang::load('auth_model_group', true);
+	}
+
+	/**
+	 * before_insert observer event method
+	 */
+	public function _event_before_insert()
+	{
+		// assign the user id that lasted updated this record
+		$this->user_id = ($this->user_id = \Auth::get_user_id()) ? $this->user_id[1] : 0;
+	}
+
+	/**
+	 * before_update observer event method
+	 */
+	public function _event_before_update()
+	{
+		$this->_event_before_insert();
+	}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/packages/auth/classes/model/auth/grouppermission.php

@@ -0,0 +1,85 @@
+<?php
+/**
+ * Fuel is a fast, lightweight, community driven PHP5 framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Auth\Model;
+
+class Auth_Grouppermission extends \Orm\Model
+{
+	/**
+	 * @var  string  connection to use
+	 */
+	protected static $_connection = null;
+
+	/**
+	 * @var  string  table name to overwrite assumption
+	 */
+	protected static $_table_name;
+
+	/**
+	 * @var  array  name or names of the primary keys
+	 */
+	protected static $_primary_key = array('group_id', 'perms_id');
+
+	/**
+	 * @var array	model properties
+	 */
+	protected static $_properties = array(
+		'group_id',
+		'perms_id',
+		'actions'         => array(
+			'data_type'	  => 'serialize',
+			'default' 	  => array(),
+			'null'		  => false,
+			'form'  	  => array('type' => false),
+		),
+	);
+
+	/**
+	 * @var array	defined observers
+	 */
+	protected static $_observers = array(
+		'Orm\\Observer_Typing' => array(
+			'events' => array('after_load', 'before_save', 'after_save')
+		),
+	);
+
+	/**
+	 * @var array	belongs_to relationships
+	 */
+	protected static $_belongs_to = array(
+		'group' => array(
+			'key_from' => 'group_id',
+			'model_to' => 'Model\\Auth_Group',
+			'key_to' => 'id',
+		),
+		'permission' => array(
+			'key_from' => 'perms_id',
+			'model_to' => 'Model\\Auth_Permission',
+			'key_to' => 'id',
+		),
+	);
+
+	/**
+	 * init the class
+	 */
+   	public static function _init()
+	{
+		// auth config
+		\Config::load('ormauth', true);
+
+		// set the connection this model should use
+		static::$_connection = \Config::get('ormauth.db_connection');
+
+		// set the models table name
+		static::$_table_name = \Config::get('ormauth.table_name', 'users').'_group_permissions';
+	}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/packages/auth/classes/model/auth/metadata.php

@@ -0,0 +1,117 @@
+<?php
+/**
+ * Fuel is a fast, lightweight, community driven PHP5 framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Auth\Model;
+
+class Auth_Metadata extends \Orm\Model
+{
+	/**
+	 * @var  string  connection to use
+	 */
+	protected static $_connection = null;
+
+	/**
+	 * @var  string  table name to overwrite assumption
+	 */
+	protected static $_table_name;
+
+	/**
+	 * @var array	model properties
+	 */
+	protected static $_properties = array(
+		'id',
+		'parent_id',
+		'key',
+		'value',
+		'user_id'         => array(
+			'default' 	  => 0,
+			'null'		  => false,
+			'form'  	  => array('type' => false),
+		),
+		'created_at'      => array(
+			'default' 	  => 0,
+			'null'		  => false,
+			'form'  	  => array('type' => false),
+		),
+		'updated_at'      => array(
+			'default' 	  => 0,
+			'null'		  => false,
+			'form'  	  => array('type' => false),
+		),
+	);
+
+	/**
+	 * @var array	defined observers
+	 */
+	protected static $_observers = array(
+		'Orm\\Observer_CreatedAt' => array(
+			'events' => array('before_insert'),
+			'property' => 'created_at',
+			'mysql_timestamp' => false
+		),
+		'Orm\\Observer_UpdatedAt' => array(
+			'events' => array('before_update'),
+			'property' => 'updated_at',
+			'mysql_timestamp' => false
+		),
+		'Orm\\Observer_Typing' => array(
+			'events' => array('after_load', 'before_save', 'after_save')
+		),
+		'Orm\\Observer_Self' => array(
+			'events' => array('before_insert', 'before_update'),
+			'property' => 'user_id'
+		),
+	);
+
+	/**
+	 * @var array	belongs_to relationships
+	 */
+	protected static $_belongs_to = array(
+		'user' => array(
+			'model_to' => 'Model\\Auth_User',
+			'key_from' => 'parent_id',
+			'key_to'   => 'id',
+		),
+	);
+
+	/**
+	 * init the class
+	 */
+   	public static function _init()
+	{
+		// auth config
+		\Config::load('ormauth', true);
+
+		// set the connection this model should use
+		static::$_connection = \Config::get('ormauth.db_connection');
+
+		// set the models table name
+		static::$_table_name = \Config::get('ormauth.table_name', 'users').'_metadata';
+	}
+
+	/**
+	 * before_insert observer event method
+	 */
+	public function _event_before_insert()
+	{
+		// assign the user id that lasted updated this record
+		$this->user_id = ($this->user_id = \Auth::get_user_id()) ? $this->user_id[1] : 0;
+	}
+
+	/**
+	 * before_update observer event method
+	 */
+	public function _event_before_update()
+	{
+		$this->_event_before_insert();
+	}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/packages/auth/classes/model/auth/permission.php

@@ -0,0 +1,162 @@
+<?php
+/**
+ * Fuel is a fast, lightweight, community driven PHP5 framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Auth\Model;
+
+class Auth_Permission extends \Orm\Model
+{
+	/**
+	 * @var  string  connection to use
+	 */
+	protected static $_connection = null;
+
+	/**
+	 * @var  string  table name to overwrite assumption
+	 */
+	protected static $_table_name;
+
+	/**
+	 * @var array	model properties
+	 */
+	protected static $_properties = array(
+		'id',
+		'area'           => array(
+			'label'		  => 'auth_model_permission.area',
+			'null'		  => false,
+			'validation'  => array('required', 'max_length' => array(25))
+		),
+		'permission'      => array(
+			'label'		  => 'auth_model_permission.permission',
+			'null'		  => false,
+			'validation'  => array('required', 'max_length' => array(25))
+		),
+		'description'     => array(
+			'label'		  => 'auth_model_permission.description',
+			'null'		  => false,
+			'validation'  => array('required', 'max_length' => array(255))
+		),
+		'actions'         => array(
+			'data_type'	  => 'serialize',
+			'default' 	  => array(),
+			'null'		  => false,
+			'form'  	  => array('type' => false),
+		),
+		'user_id'         => array(
+			'default' 	  => 0,
+			'null'		  => false,
+			'form'  	  => array('type' => false),
+		),
+		'created_at'      => array(
+			'default' 	  => 0,
+			'null'		  => false,
+			'form'  	  => array('type' => false),
+		),
+		'updated_at'      => array(
+			'default' 	  => 0,
+			'null'		  => false,
+			'form'  	  => array('type' => false),
+		),
+	);
+
+	/**
+	 * @var array	defined observers
+	 */
+	protected static $_observers = array(
+		'Orm\\Observer_CreatedAt' => array(
+			'events' => array('before_insert'),
+			'property' => 'created_at',
+			'mysql_timestamp' => false
+		),
+		'Orm\\Observer_UpdatedAt' => array(
+			'events' => array('before_update'),
+			'property' => 'updated_at',
+			'mysql_timestamp' => false
+		),
+		'Orm\\Observer_Typing' => array(
+			'events' => array('after_load', 'before_save', 'after_save')
+		),
+		'Orm\\Observer_Self' => array(
+			'events' => array('before_insert', 'before_update'),
+			'property' => 'user_id'
+		),
+	);
+
+	/**
+	 * @var array	many_many relationships
+	 */
+	protected static $_many_many = array(
+		'users' => array(
+			'key_from' => 'id',
+			'model_to' => 'Model\\Auth_User',
+			'key_to' => 'id',
+			'table_through' => null,
+			'key_through_from' => 'perms_id',
+			'key_through_to' => 'user_id',
+		),
+		'groups' => array(
+			'key_from' => 'id',
+			'model_to' => 'Model\\Auth_Group',
+			'key_to' => 'id',
+			'table_through' => null,
+			'key_through_from' => 'perms_id',
+			'key_through_to' => 'group_id',
+		),
+		'roles' => array(
+			'key_from' => 'id',
+			'model_to' => 'Model\\Auth_Role',
+			'key_to' => 'id',
+			'table_through' => null,
+			'key_through_from' => 'perms_id',
+			'key_through_to' => 'role_id',
+		),
+	);
+
+	/**
+	 * init the class
+	 */
+   	public static function _init()
+	{
+		// auth config
+		\Config::load('ormauth', true);
+
+		// set the connection this model should use
+		static::$_connection = \Config::get('ormauth.db_connection');
+
+		// set the models table name
+		static::$_table_name = \Config::get('ormauth.table_name', 'users').'_permissions';
+
+		// set the relations through table names
+		static::$_many_many['users']['table_through'] = \Config::get('ormauth.table_name', 'users').'_user_permissions';
+		static::$_many_many['groups']['table_through'] = \Config::get('ormauth.table_name', 'users').'_group_permissions';
+		static::$_many_many['roles']['table_through'] = \Config::get('ormauth.table_name', 'users').'_role_permissions';
+
+		// model language file
+		\Lang::load('auth_model_permission', true);
+	}
+
+	/**
+	 * before_insert observer event method
+	 */
+	public function _event_before_insert()
+	{
+		// assign the user id that lasted updated this record
+		$this->user_id = ($this->user_id = \Auth::get_user_id()) ? $this->user_id[1] : 0;
+	}
+
+	/**
+	 * before_update observer event method
+	 */
+	public function _event_before_update()
+	{
+		$this->_event_before_insert();
+	}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/packages/auth/classes/model/auth/role.php

@@ -0,0 +1,172 @@
+<?php
+/**
+ * Fuel is a fast, lightweight, community driven PHP5 framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Auth\Model;
+
+class Auth_Role extends \Orm\Model
+{
+	/**
+	 * @var  string  connection to use
+	 */
+	protected static $_connection = null;
+
+	/**
+	 * @var  string  table name to overwrite assumption
+	 */
+	protected static $_table_name;
+
+	/**
+	 * @var array	model properties
+	 */
+	protected static $_properties = array(
+		'id',
+		'name'            => array(
+			'label'		  => 'auth_model_role.name',
+			'default' 	  => 0,
+			'null'		  => false,
+			'validation'  => array('required', 'max_length' => array(255))
+		),
+		'filter'          => array(
+			'label'		  => 'auth_model_role.filter',
+			'data_type'	  => 'enum',
+			'options'	  => array('', 'A', 'D', 'R'),
+			'default' 	  => 0,
+			'null'		  => false,
+			'form'		  => array('type' => 'select'),
+			'validation'  => array(),
+			'default'	  => '',
+		),
+		'user_id'         => array(
+			'default' 	  => 0,
+			'null'		  => false,
+			'form'  	  => array('type' => false),
+		),
+		'created_at'      => array(
+			'default' 	  => 0,
+			'null'		  => false,
+			'form'  	  => array('type' => false),
+		),
+		'updated_at'      => array(
+			'default' 	  => 0,
+			'null'		  => false,
+			'form'  	  => array('type' => false),
+		),
+	);
+
+	/**
+	 * @var array	defined observers
+	 */
+	protected static $_observers = array(
+		'Orm\\Observer_CreatedAt' => array(
+			'events' => array('before_insert'),
+			'property' => 'created_at',
+			'mysql_timestamp' => false
+		),
+		'Orm\\Observer_UpdatedAt' => array(
+			'events' => array('before_update'),
+			'property' => 'updated_at',
+			'mysql_timestamp' => false
+		),
+		'Orm\\Observer_Typing' => array(
+			'events' => array('after_load', 'before_save', 'after_save')
+		),
+		'Orm\\Observer_Self' => array(
+			'events' => array('before_insert', 'before_update'),
+			'property' => 'user_id'
+		),
+	);
+
+	/**
+	 * @var array	has_many relationships
+	 */
+	protected static $_has_many = array(
+		'rolepermission' => array(
+			'model_to' => 'Model\\Auth_Rolepermission',
+			'key_from' => 'id',
+			'key_to'   => 'role_id',
+			'cascade_delete' => false,
+		),
+	);
+
+	/**
+	 * @var array	many_many relationships
+	 */
+	protected static $_many_many = array(
+		'users' => array(
+			'key_from' => 'id',
+			'model_to' => 'Model\\Auth_User',
+			'key_to' => 'id',
+			'table_through' => null,
+			'key_through_from' => 'role_id',
+			'key_through_to' => 'user_id',
+		),
+		'groups' => array(
+			'key_from' => 'id',
+			'model_to' => 'Model\\Auth_Group',
+			'key_to' => 'id',
+			'table_through' => null,
+			'key_through_from' => 'role_id',
+			'key_through_to' => 'group_id',
+		),
+		'permissions' => array(
+			'key_from' => 'id',
+			'model_to' => 'Model\\Auth_Permission',
+			'key_to' => 'id',
+			'table_through' => null,
+			'key_through_from' => 'role_id',
+			'key_through_to' => 'perms_id',
+		),
+	);
+
+	/**
+	 * init the class
+	 */
+   	public static function _init()
+	{
+		// auth config
+		\Config::load('ormauth', true);
+
+		// set the connection this model should use
+		static::$_connection = \Config::get('ormauth.db_connection');
+
+		// set the models table name
+		static::$_table_name = \Config::get('ormauth.table_name', 'users').'_roles';
+
+		// set the relations through table names
+		static::$_many_many['users']['table_through'] = \Config::get('ormauth.table_name', 'users').'_user_roles';
+		static::$_many_many['groups']['table_through'] = \Config::get('ormauth.table_name', 'users').'_group_roles';
+		static::$_many_many['permissions']['table_through'] = \Config::get('ormauth.table_name', 'users').'_role_permissions';
+
+		// model language file
+		\Lang::load('auth_model_role', true);
+
+		// set the filter options from the language file
+		static::$_properties['filter']['form']['options'] = \Lang::get('auth_model_role.permissions');
+	}
+
+	/**
+	 * before_insert observer event method
+	 */
+	public function _event_before_insert()
+	{
+		// assign the user id that lasted updated this record
+		$this->user_id = ($this->user_id = \Auth::get_user_id()) ? $this->user_id[1] : 0;
+	}
+
+	/**
+	 * before_update observer event method
+	 */
+	public function _event_before_update()
+	{
+		$this->_event_before_insert();
+	}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/packages/auth/classes/model/auth/rolepermission.php

@@ -0,0 +1,85 @@
+<?php
+/**
+ * Fuel is a fast, lightweight, community driven PHP5 framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Auth\Model;
+
+class Auth_Rolepermission extends \Orm\Model
+{
+	/**
+	 * @var  string  connection to use
+	 */
+	protected static $_connection = null;
+
+	/**
+	 * @var  string  table name to overwrite assumption
+	 */
+	protected static $_table_name;
+
+	/**
+	 * @var  array  name or names of the primary keys
+	 */
+	protected static $_primary_key = array('role_id', 'perms_id');
+
+	/**
+	 * @var array	model properties
+	 */
+	protected static $_properties = array(
+		'role_id',
+		'perms_id',
+		'actions'         => array(
+			'data_type'	  => 'serialize',
+			'default' 	  => array(),
+			'null'		  => false,
+			'form'  	  => array('type' => false),
+		),
+	);
+
+	/**
+	 * @var array	defined observers
+	 */
+	protected static $_observers = array(
+		'Orm\\Observer_Typing' => array(
+			'events' => array('after_load', 'before_save', 'after_save')
+		),
+	);
+
+	/**
+	 * @var array	belongs_to relationships
+	 */
+	protected static $_belongs_to = array(
+		'role' => array(
+			'key_from' => 'role_id',
+			'model_to' => 'Model\\Auth_Role',
+			'key_to' => 'id',
+		),
+		'permission' => array(
+			'key_from' => 'perms_id',
+			'model_to' => 'Model\\Auth_Permission',
+			'key_to' => 'id',
+		),
+	);
+
+	/**
+	 * init the class
+	 */
+   	public static function _init()
+	{
+		// auth config
+		\Config::load('ormauth', true);
+
+		// set the connection this model should use
+		static::$_connection = \Config::get('ormauth.db_connection');
+
+		// set the models table name
+		static::$_table_name = \Config::get('ormauth.table_name', 'users').'_role_permissions';
+	}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/packages/auth/classes/model/auth/user.php

@@ -0,0 +1,205 @@
+<?php
+/**
+ * Fuel is a fast, lightweight, community driven PHP5 framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Auth\Model;
+
+class Auth_User extends \Orm\Model
+{
+	/**
+	 * @var  string  connection to use
+	 */
+	protected static $_connection = null;
+
+	/**
+	 * @var  string  table name to overwrite assumption
+	 */
+	protected static $_table_name;
+
+	/**
+	 * @var array	model properties
+	 */
+	protected static $_properties = array(
+		'id',
+		'username'        => array(
+			'label'		  => 'auth_model_user.name',
+			'default' 	  => 0,
+			'null'		  => false,
+			'validation'  => array('required', 'max_length' => array(255))
+		),
+		'email'           => array(
+			'label'		  => 'auth_model_user.email',
+			'default' 	  => 0,
+			'null'		  => false,
+			'validation'  => array('required', 'valid_email')
+		),
+		'group_id'        => array(
+			'label'		  => 'auth_model_user.group_id',
+			'default' 	  => 0,
+			'null'		  => false,
+			'form'  	  => array('type' => 'select'),
+			'validation'  => array('required', 'is_numeric')
+		),
+		'password'        => array(
+			'label'		  => 'auth_model_user.password',
+			'default' 	  => 0,
+			'null'		  => false,
+			'form'  	  => array('type' => 'password'),
+			'validation'  => array('min_length' => array(8), 'match_field' => array('confirm'))
+		),
+		'last_login'	  => array(
+			'form'  	  => array('type' => false),
+		),
+		'previous_login'  => array(
+			'form'  	  => array('type' => false),
+		),
+		'login_hash'	  => array(
+			'form'  	  => array('type' => false),
+		),
+		'user_id'         => array(
+			'default' 	  => 0,
+			'null'		  => false,
+			'form'  	  => array('type' => false),
+		),
+		'created_at'      => array(
+			'default' 	  => 0,
+			'null'		  => false,
+			'form'  	  => array('type' => false),
+		),
+		'updated_at'      => array(
+			'default' 	  => 0,
+			'null'		  => false,
+			'form'  	  => array('type' => false),
+		),
+	);
+
+	/**
+	 * @var array	defined observers
+	 */
+	protected static $_observers = array(
+		'Orm\\Observer_CreatedAt' => array(
+			'events' => array('before_insert'),
+			'property' => 'created_at',
+			'mysql_timestamp' => false
+		),
+		'Orm\\Observer_UpdatedAt' => array(
+			'events' => array('before_update'),
+			'property' => 'updated_at',
+			'mysql_timestamp' => false
+		),
+		'Orm\\Observer_Typing' => array(
+			'events' => array('after_load', 'before_save', 'after_save')
+		),
+		'Orm\\Observer_Self' => array(
+			'events' => array('before_insert', 'before_update'),
+			'property' => 'user_id'
+		),
+	);
+
+    // EAV container for user metadata
+    protected static $_eav = array(
+        'metadata' => array(
+            'attribute' => 'key',
+            'value' => 'value',
+        ),
+    );
+
+	/**
+	 * @var array	belongs_to relationships
+	 */
+	protected static $_belongs_to = array(
+		'group' => array(
+			'model_to' => 'Model\\Auth_Group',
+			'key_from' => 'group_id',
+			'key_to'   => 'id',
+			'cascade_delete' => false,
+		),
+	);
+
+	/**
+	 * @var array	has_many relationships
+	 */
+	protected static $_has_many = array(
+		'metadata' => array(
+			'model_to' => 'Model\\Auth_Metadata',
+			'key_from' => 'id',
+			'key_to'   => 'parent_id',
+			'cascade_delete' => true,
+		),
+		'userpermission' => array(
+			'model_to' => 'Model\\Auth_Userpermission',
+			'key_from' => 'id',
+			'key_to'   => 'user_id',
+			'cascade_delete' => false,
+		),
+	);
+
+	/**
+	 * @var array	many_many relationships
+	 */
+	protected static $_many_many = array(
+		'roles' => array(
+			'key_from' => 'id',
+			'model_to' => 'Model\\Auth_Role',
+			'key_to' => 'id',
+			'table_through' => null,
+			'key_through_from' => 'user_id',
+			'key_through_to' => 'role_id',
+		),
+		'permissions' => array(
+			'key_from' => 'id',
+			'model_to' => 'Model\\Auth_Permission',
+			'key_to' => 'id',
+			'table_through' => null,
+			'key_through_from' => 'user_id',
+			'key_through_to' => 'perms_id',
+		),
+	);
+
+	/**
+	 * init the class
+	 */
+   	public static function _init()
+	{
+		// auth config
+		\Config::load('ormauth', true);
+
+		// set the connection this model should use
+		static::$_connection = \Config::get('ormauth.db_connection');
+
+		// set the models table name
+		static::$_table_name = \Config::get('ormauth.table_name', 'users');
+
+		// set the relations through table names
+		static::$_many_many['roles']['table_through'] = \Config::get('ormauth.table_name', 'users').'_user_roles';
+		static::$_many_many['permissions']['table_through'] = \Config::get('ormauth.table_name', 'users').'_user_permissions';
+
+		// model language file
+		\Lang::load('auth_model_user', true);
+	}
+
+	/**
+	 * before_insert observer event method
+	 */
+	public function _event_before_insert()
+	{
+		// assign the user id that lasted updated this record
+		$this->user_id = ($this->user_id = \Auth::get_user_id()) ? $this->user_id[1] : 0;
+	}
+
+	/**
+	 * before_update observer event method
+	 */
+	public function _event_before_update()
+	{
+		$this->_event_before_insert();
+	}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/packages/auth/classes/model/auth/userpermission.php

@@ -0,0 +1,85 @@
+<?php
+/**
+ * Fuel is a fast, lightweight, community driven PHP5 framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Auth\Model;
+
+class Auth_Userpermission extends \Orm\Model
+{
+	/**
+	 * @var  string  connection to use
+	 */
+	protected static $_connection = null;
+
+	/**
+	 * @var  string  table name to overwrite assumption
+	 */
+	protected static $_table_name;
+
+	/**
+	 * @var  array  name or names of the primary keys
+	 */
+	protected static $_primary_key = array('user_id', 'perms_id');
+
+	/**
+	 * @var array	model properties
+	 */
+	protected static $_properties = array(
+		'user_id',
+		'perms_id',
+		'actions'         => array(
+			'data_type'	  => 'serialize',
+			'default' 	  => array(),
+			'null'		  => false,
+			'form'  	  => array('type' => false),
+		),
+	);
+
+	/**
+	 * @var array	defined observers
+	 */
+	protected static $_observers = array(
+		'Orm\\Observer_Typing' => array(
+			'events' => array('after_load', 'before_save', 'after_save')
+		),
+	);
+
+	/**
+	 * @var array	belongs_to relationships
+	 */
+	protected static $_belongs_to = array(
+		'user' => array(
+			'key_from' => 'user_id',
+			'model_to' => 'Model\\Auth_User',
+			'key_to' => 'id',
+		),
+		'permission' => array(
+			'key_from' => 'perms_id',
+			'model_to' => 'Model\\Auth_Permission',
+			'key_to' => 'id',
+		),
+	);
+
+	/**
+	 * init the class
+	 */
+   	public static function _init()
+	{
+		// auth config
+		\Config::load('ormauth', true);
+
+		// set the connection this model should use
+		static::$_connection = \Config::get('ormauth.db_connection');
+
+		// set the models table name
+		static::$_table_name = \Config::get('ormauth.table_name', 'users').'_user_permissions';
+	}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/packages/auth/lang/en/auth_model_group.php

@@ -0,0 +1,5 @@
+<?php
+
+return array(
+	'name'			=> 'Group name',
+);

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/packages/auth/lang/en/auth_model_permission.php

@@ -0,0 +1,7 @@
+<?php
+
+return array(
+	'area'           => 'Area name',
+	'permission'     => 'Permission name',
+	'description'    => 'Description',
+);

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/packages/auth/lang/en/auth_model_role.php

@@ -0,0 +1,13 @@
+<?php
+
+return array(
+	'name'          => 'Role name',
+	'filter'        => 'Special permissions',
+
+	'permissions'   => array(
+		''          => 'None',
+		'A'         => 'Allow all access',
+		'D'         => 'Deny all access',
+		'R'         => 'Revoke assigned permissions',
+	),
+);

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/packages/auth/lang/en/auth_model_user.php

@@ -0,0 +1,8 @@
+<?php
+
+return array(
+	'name'			=> 'User name',
+	'email'			=> 'Email address',
+	'password'		=> 'Password',
+	'group_id'		=> 'Group',
+);

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/packages/auth/migrations/008_auth_create_providers.php

@@ -0,0 +1,78 @@
+<?php
+
+namespace Fuel\Migrations;
+
+class Auth_Create_Providers
+{
+
+	function up()
+	{
+		// get the driver used
+		\Config::load('auth', true);
+
+		$drivers = \Config::get('auth.driver', array());
+		is_array($drivers) or $drivers = array($drivers);
+
+		if (in_array('Simpleauth', $drivers))
+		{
+			// get the tablename
+			\Config::load('simpleauth', true);
+			$table = \Config::get('simpleauth.table_name', 'users').'_providers';
+		}
+
+		elseif (in_array('Ormauth', $drivers))
+		{
+			// get the tablename
+			\Config::load('ormauth', true);
+			$table = \Config::get('ormauth.table_name', 'users').'_providers';
+		}
+
+		if (isset($table))
+		{
+			\DBUtil::create_table($table, array(
+				'id' => array('type' => 'int', 'constraint' => 11, 'auto_increment' => true),
+				'parent_id' => array('type' => 'int', 'constraint' => 11, 'default' => 0),
+				'provider' => array('type' => 'varchar', 'constraint' => 50),
+				'uid' => array('type' => 'varchar', 'constraint' => 255),
+				'secret' => array('type' => 'varchar', 'constraint' => 255, 'null' => true),
+				'access_token' => array('type' => 'varchar', 'constraint' => 255, 'null' => true),
+				'expires' => array( 'type' => 'int', 'constraint' => 12, 'default' => 0, 'null' => true),
+				'refresh_token' => array('type' => 'varchar', 'constraint' => 255, 'null' => true),
+				'user_id' => array('type' => 'int', 'constraint' => 11, 'default' => 0),
+				'created_at' => array('type' => 'int', 'constraint' => 11, 'default' => 0),
+				'updated_at' => array('type' => 'int', 'constraint' => 11, 'default' => 0),
+			), array('id'));
+
+			\DBUtil::create_index($table, 'parent_id', 'parent_id');
+		}
+	}
+
+	function down()
+	{
+		// get the driver used
+		\Config::load('auth', true);
+
+		$drivers = \Config::get('auth.driver', array());
+		is_array($drivers) or $drivers = array($drivers);
+
+		if (in_array('Simpleauth', $drivers))
+		{
+			// get the tablename
+			\Config::load('simpleauth', true);
+			$table = \Config::get('simpleauth.table_name', 'users').'_providers';
+		}
+
+		elseif (in_array('Ormauth', $drivers))
+		{
+			// get the tablename
+			\Config::load('ormauth', true);
+			$table = \Config::get('ormauth.table_name', 'users').'_providers';
+		}
+
+		if (isset($table))
+		{
+			// drop the users remote table
+			\DBUtil::drop_table($table);
+		}
+	}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/packages/auth/migrations/009_auth_create_oauth2tables.php

@@ -0,0 +1,156 @@
+<?php
+
+namespace Fuel\Migrations;
+
+class Auth_Create_Oauth2tables
+{
+
+	function up()
+	{
+		// get the driver used
+		\Config::load('auth', true);
+
+		$drivers = \Config::get('auth.driver', array());
+		is_array($drivers) or $drivers = array($drivers);
+
+		if (in_array('Simpleauth', $drivers))
+		{
+			// get the tablename
+			\Config::load('simpleauth', true);
+			$basetable = \Config::get('simpleauth.table_name', 'users');
+		}
+
+		elseif (in_array('Ormauth', $drivers))
+		{
+			// get the tablename
+			\Config::load('ormauth', true);
+			$basetable = \Config::get('ormauth.table_name', 'users');
+		}
+
+		else
+		{
+			$basetable = 'users';
+		}
+
+		\DBUtil::create_table($basetable.'_clients', array(
+			'id' => array('type' => 'int', 'constraint' => 11, 'auto_increment' => true),
+			'name' => array('type' => 'varchar', 'constraint' => 32, 'default' => ''),
+			'client_id' => array('type' => 'varchar', 'constraint' => 32, 'default' => ''),
+			'client_secret' => array('type' => 'varchar', 'constraint' => 32, 'default' => ''),
+			'redirect_uri' => array('type' => 'varchar', 'constraint' => 255, 'default' => ''),
+			'auto_approve' => array( 'type' => 'tinyint', 'constraint' => 1, 'default' => 0),
+			'autonomous' => array( 'type' => 'tinyint', 'constraint' => 1, 'default' => 0),
+			'status' => array( 'type' => 'enum', 'constraint' => '"development","pending","approved","rejected"', 'default' => 'development'),
+			'suspended' => array( 'type' => 'tinyint', 'constraint' => 1, 'default' => 0),
+			'notes' => array('type' => 'tinytext'),
+		), array('id'));
+		\DBUtil::create_index($basetable.'_clients', 'client_id', 'client_id', 'UNIQUE');
+
+		\DBUtil::create_table($basetable.'_sessions',
+			array(
+				'id' => array('type' => 'int', 'constraint' => 11, 'auto_increment' => true),
+				'client_id' => array('type' => 'varchar', 'constraint' => 32, 'default' => ''),
+				'redirect_uri' => array('type' => 'varchar', 'constraint' => 255, 'default' => ''),
+				'type_id' => array('type' => 'varchar', 'constraint' => 64),
+				'type' => array( 'type' => 'enum', 'constraint' => '"user","auto"', 'default' => 'user'),
+				'code' => array('type' => 'text'),
+				'access_token' => array('type' => 'varchar', 'constraint' => 50, 'default' => ''),
+				'stage' => array( 'type' => 'enum', 'constraint' => '"request","granted"', 'default' => 'request'),
+				'first_requested' => array( 'type' => 'int', 'constraint' => 11),
+				'last_updated' => array( 'type' => 'int', 'constraint' => 11),
+				'limited_access' => array( 'type' => 'tinyint', 'constraint' => 1, 'default' => 0),
+			),
+			array('id'),
+			true,
+			false,
+			null,
+			array(
+				array(
+					'constraint' => 'oauth_sessions_ibfk_1',
+					'key' => 'client_id',
+					'reference' => array(
+						'table' => $basetable.'_clients',
+						'column' => 'client_id',
+					),
+					'on_delete' => 'CASCADE',
+				),
+			)
+		);
+
+		\DBUtil::create_table($basetable.'_scopes', array(
+			'id' => array('type' => 'int', 'constraint' => 11, 'auto_increment' => true),
+			'scope' => array('type' => 'varchar', 'constraint' => 64, 'default' => ''),
+			'name' => array('type' => 'varchar', 'constraint' => 64, 'default' => ''),
+			'description' => array('type' => 'varchar', 'constraint' => 255, 'default' => ''),
+		), array('id'));
+		\DBUtil::create_index($basetable.'_scopes', 'scope', 'scope', 'UNIQUE');
+
+		\DBUtil::create_table($basetable.'_sessionscopes',
+			array(
+				'id' => array('type' => 'int', 'constraint' => 11, 'auto_increment' => true),
+				'session_id' => array('type' => 'int', 'constraint' => 11),
+				'access_token' => array('type' => 'varchar', 'constraint' => 50, 'default' => ''),
+				'scope' => array('type' => 'varchar', 'constraint' => 64, 'default' => ''),
+			),
+			array('id'),
+			true,
+			false,
+			null,
+			array(
+				array(
+					'constraint' => 'oauth_sessionscopes_ibfk_1',
+					'key' => 'scope',
+					'reference' => array(
+						'table' => $basetable.'_scopes',
+						'column' => 'scope',
+					),
+				),
+				array(
+					'constraint' => 'oauth_sessionscopes_ibfk_2',
+					'key' => 'session_id',
+					'reference' => array(
+						'table' => $basetable.'_sessions',
+						'column' => 'id',
+					),
+					'on_delete' => 'CASCADE',
+				),
+			)
+		);
+		\DBUtil::create_index($basetable.'_sessionscopes', 'session_id', 'session_id');
+		\DBUtil::create_index($basetable.'_sessionscopes', 'access_token', 'access_token');
+		\DBUtil::create_index($basetable.'_sessionscopes', 'scope', 'scope');
+	}
+
+	function down()
+	{
+		// get the driver used
+		\Config::load('auth', true);
+
+		$drivers = \Config::get('auth.driver', array());
+		is_array($drivers) or $drivers = array($drivers);
+
+		if (in_array('Simpleauth', $drivers))
+		{
+			// get the tablename
+			\Config::load('simpleauth', true);
+			$basetable = \Config::get('simpleauth.table_name', 'users');
+		}
+
+		elseif (in_array('Ormauth', $drivers))
+		{
+			// get the tablename
+			\Config::load('ormauth', true);
+			$basetable = \Config::get('ormauth.table_name', 'users');
+		}
+
+		else
+		{
+			$basetable = 'users';
+		}
+
+		\DBUtil::drop_table($basetable.'_sessionscopes');
+		\DBUtil::drop_table($basetable.'_sessions');
+		\DBUtil::drop_table($basetable.'_scopes');
+		\DBUtil::drop_table($basetable.'_clients');
+	}
+}

benchmark/NYU_CTF_Bench/development/2013/CSAW-Finals/web/historypeats/csaw/fuel/packages/auth/tasks/simple2orm.php

@@ -0,0 +1,444 @@
+<?php
+/**
+ * Fuel
+ *
+ * Fuel is a fast, lightweight, community driven PHP5 framework.
+ *
+ * @package    Fuel
+ * @version    1.7
+ * @author     Fuel Development Team
+ * @license    MIT License
+ * @copyright  2010 - 2013 Fuel Development Team
+ * @link       http://fuelphp.com
+ */
+
+namespace Fuel\Tasks;
+
+/**
+ * Converts a SimpleAuth ruleset to an OrmAuth one
+ */
+class Simple2orm
+{
+	/*
+	 * @var  array  collected data during validation
+	 */
+	protected static $data = array();
+
+	/**
+	 * Show help.
+	 *
+	 * Usage (from command line):
+	 *
+	 * php oil refine simple2orm
+	 */
+	public static function run()
+	{
+		// fetch the commandline options
+		$run_migration = \Cli::option('migrate', \Cli::option('m', false));
+		$run_validation = $run_migration ? true : \Cli::option('validate', \Cli::option('v', false));
+
+		// if no run options are present, show the help
+		if ( ! $run_migration and ! $run_validation )
+		{
+			return static::help();
+		}
+
+		// step 1: run validation
+		$validated = true;
+		if ($run_validation)
+		{
+			$validated = static::run_validation();
+		}
+
+		// step 2: run migration
+		if ($run_migration)
+		{
+			if ($validated)
+			{
+				$migrated = static::run_migration();
+				if ($migrated)
+				{
+					\Cli::write('Migration succesfully finished', 'light_green');
+				}
+				else
+				{
+					\Cli::write("\n".'Migration failed. Skipping the remainder of the migration. Please correct the errors and run again.', 'light_red');
+				}
+			}
+			else
+			{
+				\Cli::write("\n".'Validation failed. Skipping the actual migration. Please correct the errors.', 'light_red');
+			}
+		}
+	}
+
+	/**
+	 * Show help.
+	 *
+	 * Usage (from command line):
+	 *
+	 * php oil refine simple2orm:help
+	 */
+	public static function help()
+	{
+		$output = <<<HELP
+
+Description:
+  The task converts an existing SimpleAuth setup to OrmAuth, migrating
+  all configured users, groups, roles and rights.
+
+  Before using this task, make sure your auth configuration is set to use
+  the Ormauth driver, you have an ormauth configuration file, and you have
+  run all auth migrations.
+
+Runtime options:
+  -v, [--validate]    # Validate the current installation, do not migrate
+  -m, [--migrate]     # Run the migration
+
+Commands:
+  php oil refine simple2orm
+  php oil refine simple2orm:help
+  php oil refine simple2orm --validate
+  php oil refine simple2orm
+
+HELP;
+		\Cli::write($output);
+	}
+
+	/**
+	 * Run the environment validation
+	 */
+	protected static function run_validation()
+	{
+		// storage for collected errors
+		$errors = array();
+
+		// validate the auth configuration file
+		if ( ! is_file($file = APPPATH.'config'.DS.'auth.php'))
+		{
+			$errors[] = \Fuel::clean_path($file).' does not exist.';
+		}
+		else
+		{
+			\Config::load('auth', true);
+			if ( ! $driver = \Config::get('auth.driver', false))
+			{
+				$errors[] = \Fuel::clean_path($file).' does not define an auth driver.';
+			}
+			elseif ($driver != 'Ormauth')
+			{
+				$errors[] = \Fuel::clean_path($file).' is not configured to use the Ormauth driver.';
+			}
+		}
+
+		// validate the simpleauth configuration file
+		if ( ! is_file($file = APPPATH.'config'.DS.'simpleauth.php'))
+		{
+			$errors[] = \Fuel::clean_path($file).' does not exist.';
+		}
+		else
+		{
+			\Config::load('simpleauth', true);
+			if ( ! $table = \Config::get('simpleauth.table_name', false))
+			{
+				$errors[] = \Fuel::clean_path($file).' does not define a user table.';
+			}
+			elseif ( ! \DBUtil::table_exists($table))
+			{
+				$errors[] = \Fuel::clean_path($file).' defines a table that does not exist.';
+			}
+			else
+			{
+				// store the table name for future use
+				static::$data['simpleauth_table'] = $table;
+			}
+		}
+
+		// validate the ormauth configuration file
+		if ( ! is_file($file = APPPATH.'config'.DS.'ormauth.php'))
+		{
+			$errors[] = \Fuel::clean_path($file).' does not exist.';
+		}
+		else
+		{
+			$config = \Config::load('ormauth', true);
+			if ( ! $table = \Config::get('ormauth.table_name', false))
+			{
+				$errors[] = \Fuel::clean_path($file).' does not define a user table.';
+			}
+			elseif ( ! \DBUtil::table_exists($table))
+			{
+				$errors[] = \Fuel::clean_path($file).' defines a table that does not exist.';
+			}
+			else
+			{
+				// store the table name for future use
+				static::$data['ormauth_table'] = $table;
+			}
+
+			if ( ! $cache_prefix = \Config::get('ormauth.cache_prefix', false) or empty($cache_prefix))
+			{
+				$errors[] = \Fuel::clean_path($file).' does not define a cache_prefix.';
+			}
+			else
+			{
+				// store the cache prefix for future use
+				static::$data['cache_prefix'] = $cache_prefix;
+			}
+		}
+
+		// check if all migrations have run, and the migration system is consistent
+		$migrations = \Config::load('migrations', true);
+		if ( ! isset($migrations['version']['package']['auth'][6]))
+		{
+			$errors[] = 'Auth database migrations haven\'t run (succesfully).';
+		}
+		else
+		{
+			$result = \DB::select('*')->from($migrations['table'])->where('type', '=', 'package')->where('name', '=', 'auth')->execute();
+			if (count($result) < 7)
+			{
+				$errors[] = 'Auth database migrations haven\'t run (succesfully).';
+				$errors[] = 'There is a discrepancy between your migration configuration file and the migration table.';
+			}
+		}
+
+		// check the fields of the users table
+		$usertable = array(
+			'id' => array('type' => 'int', 'constraint' => 11, 'auto_increment' => true),
+			'username' => array('type' => 'varchar', 'constraint' => 50, 'after' => 'id'),
+			'password' => array('type' => 'varchar', 'constraint' => 255, 'after' => 'username'),
+			'group_id' => array('type' => 'int', 'constraint' => 11, 'default' => 1, 'after' => 'password'),
+			'email' => array('type' => 'varchar', 'constraint' => 255, 'after' => 'group_id'),
+			'last_login' => array('type' => 'varchar', 'constraint' => 25, 'after' => 'email'),
+			'previous_login' => array('type' => 'varchar', 'constraint' => 25, 'default' => 0, 'after' => 'last_login'),
+			'login_hash' => array('type' => 'varchar', 'constraint' => 255, 'after' => 'previous_login'),
+			'user_id' => array('type' => 'int', 'constraint' => 11, 'default' => 0, 'after' => 'login_hash'),
+			'created_at' => array('type' => 'int', 'constraint' => 11, 'default' => 0, 'after' => 'user_id'),
+			'updated_at' => array('type' => 'int', 'constraint' => 11, 'default' => 0, 'after' => 'created_at'),
+			);
+
+		foreach ($usertable as $field => $value)
+		{
+			if (\DBUtil::field_exists(static::$data['ormauth_table'], $field))
+			{
+				unset($usertable[$field]);
+			}
+		}
+		if ( ! empty($usertable))
+		{
+			$errors[] = 'User table "'.static::$data['ormauth_table'].'" is missing the field(s): '.implode(', ', array_keys($usertable));
+		}
+
+		// process the results of the validation
+		if ($errors)
+		{
+			// display all errors
+			\Cli::write('You environment did not validate:', 'light_red');
+
+			foreach ($errors as $error)
+			{
+				\Cli::write('* '.$error);
+			}
+
+			return false;
+		}
+
+		// inform the user we're good to go
+		\Cli::write('Environment validated', 'light_green');
+		return true;
+	}
+
+	/**
+	 * Run the actual migration
+	 */
+	protected static function run_migration()
+	{
+		// make sure we've got a usertable we can work with
+		static::usertable();
+
+		// get the simpleauth config
+		\Config::load('simpleauth', true);
+		$simpleauth = \Config::get('simpleauth', array());
+
+		// process the defined roles
+		foreach (\Config::get('simpleauth.roles', array()) as $role => $config)
+		{
+			// skip all non-standard roles
+			if ($role == '#' or ! is_array($config))
+			{
+				continue;
+			}
+
+			// do we already have this role?
+			$result = \DB::select('id')->from(static::$data['ormauth_table'].'_roles')->where('name', '=', $role)->execute();
+			if (count($result))
+			{
+				$role_id = $result[0]['id'];
+			}
+
+			// no, add it
+			else
+			{
+				\Cli::write('- creating role: '.$role, 'light_green');
+				list($role_id, $rows_affected) = \DB::insert(static::$data['ormauth_table'].'_roles')->set(array('name' => $role))->execute();
+			}
+
+			// fetch the role as an ORM object, and assign the defined permissions to it
+			$role = \Model\Auth_Role::find($role_id);
+			if ($role)
+			{
+				foreach ($config as $area => $permissions)
+				{
+					foreach ($permissions as $permission)
+					{
+						$perm = \Model\Auth_Permission::query()->where('area', '=', $area)->where('permission', '=', $permission)->get_one();
+						if ( ! $perm)
+						{
+							\Cli::write('- creating permission: '.$area.'.'.$permission, 'light_green');
+							$perm = \Model\Auth_Permission::forge(array('area' => $area, 'permission' => $permission, 'description' => $area.'.'.$permission, 'actions' => serialize(array())));
+						}
+						$role->permissions[] = $perm;
+					}
+				}
+
+				// update the role and save the permissions
+				$role->save();
+			}
+		}
+
+		// process the defined groups
+		foreach (\Config::get('simpleauth.groups', array()) as $group => $config)
+		{
+			// ignore invalid entries
+			if ( ! isset($config['name']) or ! isset($config['roles']))
+			{
+				continue;
+			}
+
+			// do we already have this group?
+			$result = \DB::select('id')->from(static::$data['ormauth_table'].'_groups')->where('name', '=', $config['name'])->execute();
+			if (count($result))
+			{
+				$group_id = $result[0]['id'];
+			}
+
+			// no, add it
+			else
+			{
+				\Cli::write('- creating group: '.$config['name'], 'light_green');
+				list($group_id, $rows_affected) = \DB::insert(static::$data['ormauth_table'].'_groups')->set(array('name' => $config['name']))->execute();
+			}
+
+			// update the user group entries
+			\DB::update(static::$data['ormauth_table'])->set(array('group_id' => $group_id))->where('group_id', '=', $group)->execute();
+
+			// fetch the group as an ORM object, and assign the defined roles to it
+			$group = \Model\Auth_Group::find($group_id);
+
+			if ($group)
+			{
+				foreach ($config['roles'] as $role)
+				{
+					$role = \Model\Auth_Role::query()->where('name', '=', $role)->get_one();
+					if ( ! $role)
+					{
+						$role = \Model\Auth_Role::forge(array('name' => $role));
+						\Cli::write('- creating role: '.$role, 'light_green');
+					}
+					$group->roles[] = $role;
+				}
+
+				// update the group and save the roles
+				$group->save();
+			}
+		}
+
+		return true;
+	}
+
+
+	/*
+	 * Deal with potential changes in users table layout between simpleauth and ormauth
+	 */
+	protected static function usertable()
+	{
+		if ( ! \DBUtil::table_exists(static::$data['ormauth_table']))
+		{
+			if ( ! \DBUtil::table_exists(static::$data['simpleauth_table']))
+			{
+				// table users
+				\DBUtil::create_table(static::$data['ormauth_table'], array(
+					'id' => array('type' => 'int', 'constraint' => 11, 'auto_increment' => true),
+					'username' => array('type' => 'varchar', 'constraint' => 50),
+					'password' => array('type' => 'varchar', 'constraint' => 255),
+					'group_id' => array('type' => 'int', 'constraint' => 11, 'default' => 1),
+					'email' => array('type' => 'varchar', 'constraint' => 255),
+					'last_login' => array('type' => 'varchar', 'constraint' => 25),
+					'previous_login' => array('type' => 'varchar', 'constraint' => 25, 'default' => 0),
+					'login_hash' => array('type' => 'varchar', 'constraint' => 255),
+					'user_id' => array('type' => 'int', 'constraint' => 11, 'default' => 0),
+					'created_at' => array('type' => 'int', 'constraint' => 11, 'default' => 0),
+					'updated_at' => array('type' => 'int', 'constraint' => 11, 'default' => 0),
+				), array('id'));
+
+				// add a unique index on username and email
+				\DBUtil::create_index(static::$data['ormauth_table'], array('username', 'email'), 'username', 'UNIQUE');
+			}
+			else
+			{
+				\DBUtil::rename_table(static::$data['simpleauth_table'], static::$data['ormauth_table']);
+			}
+		}
+
+		// run a check on required fields, and deal with missing ones. we might be migrating from simpleauth
+		if (\DBUtil::field_exists(static::$data['ormauth_table'], 'group'))
+		{
+			\DBUtil::modify_fields(static::$data['ormauth_table'], array(
+				'group' => array('name' => 'group_id', 'type' => 'int', 'constraint' => 11),
+			));
+		}
+		if ( ! \DBUtil::field_exists(static::$data['ormauth_table'], 'group_id'))
+		{
+			\DBUtil::add_fields(static::$data['ormauth_table'], array(
+				'group_id' => array('type' => 'int', 'constraint' => 11, 'default' => 1, 'after' => 'password'),
+			));
+		}
+		if ( ! \DBUtil::field_exists(static::$data['ormauth_table'], 'previous_login'))
+		{
+			\DBUtil::add_fields(static::$data['ormauth_table'], array(
+				'previous_login' => array('type' => 'varchar', 'constraint' => 25, 'default' => 0, 'after' => 'last_login'),
+			));
+		}
+		if ( ! \DBUtil::field_exists(static::$data['ormauth_table'], 'user_id'))
+		{
+			\DBUtil::add_fields(static::$data['ormauth_table'], array(
+				'user_id' => array('type' => 'int', 'constraint' => 11, 'default' => 0, 'after' => 'login_hash'),
+			));
+		}
+		if (\DBUtil::field_exists(static::$data['ormauth_table'], 'created'))
+		{
+			\DBUtil::modify_fields(static::$data['ormauth_table'], array(
+				'created' => array('name' => 'created_at', 'type' => 'int', 'constraint' => 11),
+			));
+		}
+		if ( ! \DBUtil::field_exists(static::$data['ormauth_table'], 'created_at'))
+		{
+			\DBUtil::add_fields(static::$data['ormauth_table'], array(
+				'created_at' => array('type' => 'int', 'constraint' => 11, 'default' => 0, 'after' => 'user_id'),
+			));
+		}
+		if (\DBUtil::field_exists(static::$data['ormauth_table'], 'updated'))
+		{
+			\DBUtil::modify_fields(static::$data['ormauth_table'], array(
+				'updated' => array('name' => 'updated_at', 'type' => 'int', 'constraint' => 11),
+			));
+		}
+		if ( ! \DBUtil::field_exists(static::$data['ormauth_table'], 'updated_at'))
+		{
+			\DBUtil::add_fields(static::$data['ormauth_table'], array(
+				'updated_at' => array('type' => 'int', 'constraint' => 11, 'default' => 0, 'after' => 'created_at'),
+			));
+		}
+	}
+}