PHPackages gymadarasz/auth - PHPackages - PHPackages [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register) 1. [Directory](/) 2. / 3. [Authentication & Authorization](/categories/authentication) 4. / 5. gymadarasz/auth ActiveLibrary[Authentication & Authorization](/categories/authentication) gymadarasz/auth =============== Authentication and level based authorization v1.0.0-beta9(10y ago)07MITPHP >=5.4.0 Since Oct 7Compare [ Source](https://github.com/gymadarasz/auth)[ Packagist](https://packagist.org/packages/gymadarasz/auth)[ Docs](http://jasny.github.com/auth)[ RSS](/packages/gymadarasz-auth/feed)WikiDiscussions Synced 3w ago READMEChangelogDependenciesVersions (11)Used By (0) Auth ==== [](#auth) Authentication and level based authorization for PHP. Installation ------------ [](#installation) Install using composer ``` composer require jasny\auth ``` Setup ----- [](#setup) `Jasny\Auth` is an abstract class. You need to extend it and implement the abstract methods `fetchUserById` and `fetchUserByUsername`. Also set the `$secret` property to a [randomly selected](https://www.random.org/passwords/)string. You also need to specify how the current user is persisted across requests. If you want to use normal PHP sessions, you can simply use the `Auth\Sessions` trait. ``` class Auth extends Jasny\Auth { use Auth\Sessions; /** * Secret word for creating a verification hash * @var string */ protected static $secret = "A random string"; /** * Fetch a user by ID * * @param int $id * @return User */ public static function fetchUserById($id) { // Database action that fetches a User object } /** * Fetch a user by username * * @param string $username * @return User */ public static function fetchUserByUsername($username) { // Database action that fetches a User object } } ``` The fetch methods need to return a object that implements the `Jasny\Auth\User` interface. ``` class User implements Jasny\Auth\User { /** * Get the user ID * * @return int */ public function getId() { return $this->id; } /** * Get the usermame * * @return string */ public function getUsername() { return $this->username; } /** * Get the hashed password * * @return string */ public function getPassword() { return $this->password; } /** * Event called on login. * * @return boolean false cancels the login */ public function onLogin() { if (!$this->active) return false; $this->last_login = new DateTime(); $this->save(); return true; } /** * Event called on logout. */ public function onLogout() { $this->last_logout = new DateTime(); $this->save(); } } ``` ### Authorization [](#authorization) By default the `Auth` class only does authentication. Authorization can be added by impelmenting the `authorize`method. Two traits are predefined to do Authorization: `Authz\byLevel` and `Authz\byGroup`. #### by level [](#by-level) The `Authz\byLevel` traits implements authorization based on access levels. Each user get permissions for it's level and all levels below. ``` class Auth extends Jasny\Auth implements Jasny\Auth\Authorization { use Jasny\Authz\byLevel; /** * Authorization levels * @var array */ protected static $levels = [ 1 => 'user', 10 => 'moderator', 20 => 'admin', 50 => 'superadmin' ]; } ``` For authorization the user object also needs to implement `Jasny\Authz\User`, adding the `hasRole()` method. ``` /** * Check if the user has the specified security level * * @param int $level * @return boolean */ public function hasRole($level) { return $this->security_level >= $level; } ``` #### by group [](#by-group) The `Auth\byGroup` traits implements authorization using access groups. An access group may supersede other groups. ``` class Auth extends Jasny\Auth implements Jasny\Auth\Authorization { use Jasny\Authz\byGroup; /** * Authorization groups and each group is supersedes. * @var array */ protected static $groups = [ 'users' => [], 'managers' => [], 'employees' => ['user'], 'developers' => ['employees'], 'paralegals' => ['employees'], 'lawyers' => ['paralegals'], 'lead-developers' => ['developers', 'managers'], 'firm-partners' => ['lawyers', 'managers'] ]; } ``` For authorization the user object also needs to implement `Jasny\Authz\User`, adding the `hasRole()` method. ``` /** * Check if the user is in the specified security group * * @param string $group * @return boolean */ public function hasRole($group) { return in_array($group, Auth::expandGroup($this->group)); } ``` Usage ----- [](#usage) ### Authentication [](#authentication) Verify username and password ``` Auth::verify($username, $password); ``` Login with username and password ``` Auth::login($username, $password); ``` Set user without verification ``` Auth::setUser($user); ``` Logout ``` Auth::logout(); ``` Get current user ``` Auth::user(); ``` ### Authorization [](#authorization-1) Check if user is allowed to do something ``` if (!Auth::authorized('admin')) die("Not allowed"); ``` ### Signup confirmation [](#signup-confirmation) Get a verification hash. Use it in an url and set that url in an e-mail to the user ``` // Create a new $user $confirmHash = generateConfirmationHash($user); $url = 'http://' . $_SERVER['HTTP_HOST'] . '/confirm.php?hash=' . $hash; // send email with $url to $user ``` Use the confirmation hash to fetch and verify the user ``` // --- confirm.php $user = Auth::fetchForConfirmation($_GET['hash']); ``` ### Forgot password [](#forgot-password) Forgot password works the same as the signup confirmation. ``` // Fetch $user by e-mail $confirmHash = generatePasswordResetHash($user); $url = 'http://' . $_SERVER['HTTP_HOST'] . '/reset.php?hash=' . $hash; // send email with $url to $user ``` Use the confirmation hash to fetch and verify the user ``` // --- reset.php $user = Auth::fetchForPasswordReset($_GET['hash']); ``` ### Health Score 22 — LowBetter than 21% of packages Maintenance20 Infrequent updates — may be unmaintained Popularity4 Limited adoption so far Community2 Small or concentrated contributor base Maturity50 Maturing project, gaining track record How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window. **Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores. **Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement. **Maturity (30%)** — Project age, version count, PHP version support, and release stability. ### Release Activity Cadence Every ~52 days Recently: every ~15 days Total 9 Last Release 3893d ago ### Community Maintainers ![](https://www.gravatar.com/avatar/13c92c5505e1a310ea7dddc4729341489d5a4dd91d3bae20b43c01fd753db45b?d=identicon)[gymadarasz](/maintainers/gymadarasz) --- Tags auth ### Embed Badge ![Health badge](/badges/gymadarasz-auth/health.svg) ``` [![Health](https://phpackages.com/badges/gymadarasz-auth/health.svg)](https://phpackages.com/packages/gymadarasz-auth) ``` ### Alternatives [tymon/jwt-auth JSON Web Token Authentication for Laravel and Lumen 11.5k51.8M375](/packages/tymon-jwt-auth)[league/oauth2-server A lightweight and powerful OAuth 2.0 authorization and resource server library with support for all the core specification grants. This library will allow you to secure your API with OAuth and allow your applications users to approve apps that want to access their data from your API. 6.7k147.0M304](/packages/league-oauth2-server)[lab404/laravel-impersonate Laravel Impersonate is a plugin that allows to you to authenticate as your users. 2.3k18.6M66](/packages/lab404-laravel-impersonate)[auth0/auth0-php PHP SDK for Auth0 Authentication and Management APIs. 41121.9M94](/packages/auth0-auth0-php)[kreait/firebase-tokens A library to work with Firebase tokens 23945.4M18](/packages/kreait-firebase-tokens) PHPackages © 2026 [Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)