lib/rbot/botuser.rb

   1 #-- vim:sw=2:et\r
   2 #++\r
   3 # :title: User management\r
   4 #\r
   5 # rbot user management\r
   6 # Author:: Giuseppe Bilotta (giuseppe.bilotta@gmail.com)\r
   7 # Copyright:: Copyright (c) 2006 Giuseppe Bilotta\r
   8 # License:: GPLv2\r
   9 \r
  10 require 'singleton'\r
  11 \r
  12 \r
  13 module Irc\r
  14 \r
  15 \r
  16   # This module contains the actual Authentication stuff\r
  17   #\r
  18   module Auth\r
  19 \r
  20     BotConfig.register BotConfigStringValue.new( 'auth.password',\r
  21       :default => 'rbotauth', :wizard => true,\r
  22       :desc => _('Password for the bot owner'))\r
  23     BotConfig.register BotConfigBooleanValue.new( 'auth.login_by_mask',\r
  24       :default => 'true',\r
  25       :desc => _('Set false to prevent new botusers from logging in without a password when the user netmask is known'))\r
  26     BotConfig.register BotConfigBooleanValue.new( 'auth.autologin',\r
  27       :default => 'true',\r
  28       :desc => _('Set false to prevent new botusers from recognizing IRC users without a need to manually login'))\r
  29     # BotConfig.register BotConfigIntegerValue.new( 'auth.default_level',\r
  30     #   :default => 10, :wizard => true,\r
  31     #   :desc => 'The default level for new/unknown users' )\r
  32 \r
  33     # Generate a random password of length _l_\r
  34     #\r
  35     def Auth.random_password(l=8)\r
  36       pwd = ""\r
  37       l.times do\r
  38         pwd << (rand(26) + (rand(2) == 0 ? 65 : 97) ).chr\r
  39       end\r
  40       return pwd\r
  41     end\r
  42 \r
  43 \r
  44     # An Irc::Auth::Command defines a command by its "path":\r
  45     #\r
  46     #   base::command::subcommand::subsubcommand::subsubsubcommand\r
  47     #\r
  48     class Command\r
  49 \r
  50       attr_reader :command, :path\r
  51 \r
  52       # A method that checks if a given _cmd_ is in a form that can be\r
  53       # reduced into a canonical command path, and if so, returns it\r
  54       #\r
  55       def sanitize_command_path(cmd)\r
  56         pre = cmd.to_s.downcase.gsub(/^\*?(?:::)?/,"").gsub(/::$/,"")\r
  57         return pre if pre.empty?\r
  58         return pre if pre =~ /^\S+(::\S+)*$/\r
  59         raise TypeError, "#{cmd.inspect} is not a valid command"\r
  60       end\r
  61 \r
  62       # Creates a new Command from a given string; you can then access\r
  63       # the command as a symbol with the :command method and the whole\r
  64       # path as :path\r
  65       #\r
  66       #   Command.new("core::auth::save").path => [:"*", :"core", :"core::auth", :"core::auth::save"]\r
  67       #\r
  68       #   Command.new("core::auth::save").command => :"core::auth::save"\r
  69       #\r
  70       def initialize(cmd)\r
  71         cmdpath = sanitize_command_path(cmd).split('::')\r
  72         seq = cmdpath.inject(["*"]) { |list, cmd|\r
  73           list << (list.length > 1 ? list.last + "::" : "") + cmd\r
  74         }\r
  75         @path = seq.map { |k|\r
  76           k.to_sym\r
  77         }\r
  78         @command = path.last\r
  79         debug "Created command #{@command.inspect} with path #{@path.pretty_inspect}"\r
  80       end\r
  81 \r
  82       # Returs self\r
  83       def to_irc_auth_command\r
  84         self\r
  85       end\r
  86 \r
  87     end\r
  88 \r
  89   end\r
  90 \r
  91 end\r
  92 \r
  93 \r
  94 class String\r
  95 \r
  96   # Returns an Irc::Auth::Comand from the receiver\r
  97   def to_irc_auth_command\r
  98     Irc::Auth::Command.new(self)\r
  99   end\r
 100 \r
 101 end\r
 102 \r
 103 \r
 104 class Symbol\r
 105 \r
 106   # Returns an Irc::Auth::Comand from the receiver\r
 107   def to_irc_auth_command\r
 108     Irc::Auth::Command.new(self)\r
 109   end\r
 110 \r
 111 end\r
 112 \r
 113 \r
 114 module Irc\r
 115 \r
 116 \r
 117   module Auth\r
 118 \r
 119 \r
 120     # This class describes a permission set\r
 121     class PermissionSet\r
 122 \r
 123       attr_reader :perm\r
 124       # Create a new (empty) PermissionSet\r
 125       #\r
 126       def initialize\r
 127         @perm = {}\r
 128       end\r
 129 \r
 130       # Inspection simply inspects the internal hash\r
 131       def inspect\r
 132         @perm.inspect\r
 133       end\r
 134 \r
 135       # Sets the permission for command _cmd_ to _val_,\r
 136       #\r
 137       def set_permission(str, val)\r
 138         cmd = str.to_irc_auth_command\r
 139         case val\r
 140         when true, false\r
 141           @perm[cmd.command] = val\r
 142         when nil\r
 143           @perm.delete(cmd.command)\r
 144         else\r
 145           raise TypeError, "#{val.inspect} must be true or false" unless [true,false].include?(val)\r
 146         end\r
 147       end\r
 148 \r
 149       # Resets the permission for command _cmd_\r
 150       #\r
 151       def reset_permission(cmd)\r
 152         set_permission(cmd, nil)\r
 153       end\r
 154 \r
 155       # Tells if command _cmd_ is permitted. We do this by returning\r
 156       # the value of the deepest Command#path that matches.\r
 157       #\r
 158       def permit?(str)\r
 159         cmd = str.to_irc_auth_command\r
 160         allow = nil\r
 161         cmd.path.reverse.each { |k|\r
 162           if @perm.has_key?(k)\r
 163             allow = @perm[k]\r
 164             break\r
 165           end\r
 166         }\r
 167         return allow\r
 168       end\r
 169 \r
 170     end\r
 171 \r
 172 \r
 173     # This is the error that gets raised when an invalid password is met\r
 174     #\r
 175     class InvalidPassword < RuntimeError\r
 176     end\r
 177 \r
 178 \r
 179     # This is the basic class for bot users: they have a username, a password,\r
 180     # a list of netmasks to match against, and a list of permissions.\r
 181     #\r
 182     class BotUser\r
 183 \r
 184       attr_reader :username\r
 185       attr_reader :password\r
 186       attr_reader :netmasks\r
 187       attr_reader :perm\r
 188       attr_writer :login_by_mask\r
 189       attr_writer :autologin\r
 190 \r
 191       # Create a new BotUser with given username\r
 192       def initialize(username)\r
 193         @username = BotUser.sanitize_username(username)\r
 194         @password = nil\r
 195         @netmasks = NetmaskList.new\r
 196         @perm = {}\r
 197         reset_login_by_mask\r
 198         reset_autologin\r
 199       end\r
 200 \r
 201       # Inspection\r
 202       def inspect\r
 203         str = "<#{self.class}:#{'0x%08x' % self.object_id}:"\r
 204         str << " @username=#{@username.inspect}"\r
 205         str << " @netmasks=#{@netmasks.inspect}"\r
 206         str << " @perm=#{@perm.inspect}"\r
 207         str << " @login_by_mask=#{@login_by_mask}"\r
 208         str << " @autologin=#{@autologin}"\r
 209         str << ">"\r
 210       end\r
 211 \r
 212       # In strings\r
 213       def to_s\r
 214         @username\r
 215       end\r
 216 \r
 217       # Convert into a hash\r
 218       def to_hash\r
 219         {\r
 220           :username => @username,\r
 221           :password => @password,\r
 222           :netmasks => @netmasks,\r
 223           :perm => @perm,\r
 224           :login_by_mask => @login_by_mask,\r
 225           :autologin => @autologin\r
 226         }\r
 227       end\r
 228 \r
 229       # Do we allow logging in without providing the password?\r
 230       #\r
 231       def login_by_mask?\r
 232         @login_by_mask\r
 233       end\r
 234 \r
 235       # Reset the login-by-mask option\r
 236       #\r
 237       def reset_login_by_mask\r
 238         @login_by_mask = Auth.authmanager.bot.config['auth.login_by_mask'] unless defined?(@login_by_mask)\r
 239       end\r
 240 \r
 241       # Reset the autologin option\r
 242       #\r
 243       def reset_autologin\r
 244         @autologin = Auth.authmanager.bot.config['auth.autologin'] unless defined?(@autologin)\r
 245       end\r
 246 \r
 247       # Do we allow automatic logging in?\r
 248       #\r
 249       def autologin?\r
 250         @autologin\r
 251       end\r
 252 \r
 253       # Restore from hash\r
 254       def from_hash(h)\r
 255         @username = h[:username] if h.has_key?(:username)\r
 256         @password = h[:password] if h.has_key?(:password)\r
 257         @netmasks = h[:netmasks] if h.has_key?(:netmasks)\r
 258         @perm = h[:perm] if h.has_key?(:perm)\r
 259         @login_by_mask = h[:login_by_mask] if h.has_key?(:login_by_mask)\r
 260         @autologin = h[:autologin] if h.has_key?(:autologin)\r
 261       end\r
 262 \r
 263       # This method sets the password if the proposed new password\r
 264       # is valid\r
 265       def password=(pwd=nil)\r
 266         pass = pwd.to_s\r
 267         if pass.empty?\r
 268           reset_password\r
 269         else\r
 270           begin\r
 271             raise InvalidPassword, "#{pass} contains invalid characters" if pass !~ /^[\x21-\x7e]+$/\r
 272             raise InvalidPassword, "#{pass} too short" if pass.length < 4\r
 273             @password = pass\r
 274           rescue InvalidPassword => e\r
 275             raise e\r
 276           rescue => e\r
 277             raise InvalidPassword, "Exception #{e.inspect} while checking #{pass.inspect} (#{pwd.inspect})"\r
 278           end\r
 279         end\r
 280       end\r
 281 \r
 282       # Resets the password by creating a new onw\r
 283       def reset_password\r
 284         @password = Auth.random_password\r
 285       end\r
 286 \r
 287       # Sets the permission for command _cmd_ to _val_ on channel _chan_\r
 288       #\r
 289       def set_permission(cmd, val, chan="*")\r
 290         k = chan.to_s.to_sym\r
 291         @perm[k] = PermissionSet.new unless @perm.has_key?(k)\r
 292         @perm[k].set_permission(cmd, val)\r
 293       end\r
 294 \r
 295       # Resets the permission for command _cmd_ on channel _chan_\r
 296       #\r
 297       def reset_permission(cmd, chan ="*")\r
 298         set_permission(cmd, nil, chan)\r
 299       end\r
 300 \r
 301       # Checks if BotUser is allowed to do something on channel _chan_,\r
 302       # or on all channels if _chan_ is nil\r
 303       #\r
 304       def permit?(cmd, chan=nil)\r
 305         if chan\r
 306           k = chan.to_s.to_sym\r
 307         else\r
 308           k = :*\r
 309         end\r
 310         allow = nil\r
 311         if @perm.has_key?(k)\r
 312           allow = @perm[k].permit?(cmd)\r
 313         end\r
 314         return allow\r
 315       end\r
 316 \r
 317       # Adds a Netmask\r
 318       #\r
 319       def add_netmask(mask)\r
 320         @netmasks << mask.to_irc_netmask\r
 321       end\r
 322 \r
 323       # Removes a Netmask\r
 324       #\r
 325       def delete_netmask(mask)\r
 326         m = mask.to_irc_netmask\r
 327         @netmasks.delete(m)\r
 328       end\r
 329 \r
 330       # Removes all <code>Netmask</code>s\r
 331       #\r
 332       def reset_netmasks\r
 333         @netmasks = NetmaskList.new\r
 334       end\r
 335 \r
 336       # This method checks if BotUser has a Netmask that matches _user_\r
 337       #\r
 338       def knows?(usr)\r
 339         user = usr.to_irc_user\r
 340         known = false\r
 341         @netmasks.each { |n|\r
 342           if user.matches?(n)\r
 343             known = true\r
 344             break\r
 345           end\r
 346         }\r
 347         return known\r
 348       end\r
 349 \r
 350       # This method gets called when User _user_ wants to log in.\r
 351       # It returns true or false depending on whether the password\r
 352       # is right. If it is, the Netmask of the user is added to the\r
 353       # list of acceptable Netmask unless it's already matched.\r
 354       def login(user, password)\r
 355         if password == @password or (password.nil? and (@login_by_mask || @autologin) and knows?(user))\r
 356           add_netmask(user) unless knows?(user)\r
 357           debug "#{user} logged in as #{self.inspect}"\r
 358           return true\r
 359         else\r
 360           return false\r
 361         end\r
 362       end\r
 363 \r
 364       # # This method gets called when User _user_ has logged out as this BotUser\r
 365       # def logout(user)\r
 366       #   delete_netmask(user) if knows?(user)\r
 367       # end\r
 368 \r
 369       # This method sanitizes a username by chomping, downcasing\r
 370       # and replacing any nonalphanumeric character with _\r
 371       #\r
 372       def BotUser.sanitize_username(name)\r
 373         candidate = name.to_s.chomp.downcase.gsub(/[^a-z0-9]/,"_")\r
 374         raise "sanitized botusername #{candidate} too short" if candidate.length < 3\r
 375         return candidate\r
 376       end\r
 377 \r
 378     end\r
 379 \r
 380 \r
 381     # This is the default BotUser: it's used for all users which haven't\r
 382     # identified with the bot\r
 383     #\r
 384     class DefaultBotUserClass < BotUser\r
 385 \r
 386       private :add_netmask, :delete_netmask\r
 387 \r
 388       include Singleton\r
 389 \r
 390       # The default BotUser is named 'everyone'\r
 391       #\r
 392       def initialize\r
 393         reset_login_by_mask\r
 394         reset_autologin\r
 395         super("everyone")\r
 396         @default_perm = PermissionSet.new\r
 397       end\r
 398 \r
 399       # This method returns without changing anything\r
 400       #\r
 401       def login_by_mask=(val)\r
 402         debug "Tried to change the login-by-mask for default bot user, ignoring"\r
 403         return @login_by_mask\r
 404       end\r
 405 \r
 406       # The default botuser allows logins by mask\r
 407       #\r
 408       def reset_login_by_mask\r
 409         @login_by_mask = true\r
 410       end\r
 411 \r
 412       # This method returns without changing anything\r
 413       #\r
 414       def autologin=(val)\r
 415         debug "Tried to change the autologin for default bot user, ignoring"\r
 416         return\r
 417       end\r
 418 \r
 419       # The default botuser doesn't allow autologin (meaningless)\r
 420       #\r
 421       def reset_autologin\r
 422         @autologin = false\r
 423       end\r
 424 \r
 425       # Sets the default permission for the default user (i.e. the ones\r
 426       # set by the BotModule writers) on all channels\r
 427       #\r
 428       def set_default_permission(cmd, val)\r
 429         @default_perm.set_permission(Command.new(cmd), val)\r
 430         debug "Default permissions now: #{@default_perm.pretty_inspect}"\r
 431       end\r
 432 \r
 433       # default knows everybody\r
 434       #\r
 435       def knows?(user)\r
 436         return true if user.to_irc_user\r
 437       end\r
 438 \r
 439       # We always allow logging in as the default user\r
 440       def login(user, password)\r
 441         return true\r
 442       end\r
 443 \r
 444       # Resets the NetmaskList\r
 445       def reset_netmasks\r
 446         super\r
 447         add_netmask("*!*@*")\r
 448       end\r
 449 \r
 450       # DefaultBotUser will check the default_perm after checking\r
 451       # the global ones\r
 452       # or on all channels if _chan_ is nil\r
 453       #\r
 454       def permit?(cmd, chan=nil)\r
 455         allow = super(cmd, chan)\r
 456         if allow.nil? && chan.nil?\r
 457           allow = @default_perm.permit?(cmd)\r
 458         end\r
 459         return allow\r
 460       end\r
 461 \r
 462     end\r
 463 \r
 464     # Returns the only instance of DefaultBotUserClass\r
 465     #\r
 466     def Auth.defaultbotuser\r
 467       return DefaultBotUserClass.instance\r
 468     end\r
 469 \r
 470     # This is the BotOwner: he can do everything\r
 471     #\r
 472     class BotOwnerClass < BotUser\r
 473 \r
 474       include Singleton\r
 475 \r
 476       def initialize\r
 477         @login_by_mask = false\r
 478         @autologin = true\r
 479         super("owner")\r
 480       end\r
 481 \r
 482       def permit?(cmd, chan=nil)\r
 483         return true\r
 484       end\r
 485 \r
 486     end\r
 487 \r
 488     # Returns the only instance of BotOwnerClass\r
 489     #\r
 490     def Auth.botowner\r
 491       return BotOwnerClass.instance\r
 492     end\r
 493 \r
 494 \r
 495     # This is the AuthManagerClass singleton, used to manage User/BotUser connections and\r
 496     # everything\r
 497     #\r
 498     class AuthManagerClass\r
 499 \r
 500       include Singleton\r
 501 \r
 502       attr_reader :everyone\r
 503       attr_reader :botowner\r
 504       attr_reader :bot\r
 505 \r
 506       # The instance manages two <code>Hash</code>es: one that maps\r
 507       # <code>Irc::User</code>s onto <code>BotUser</code>s, and the other that maps\r
 508       # usernames onto <code>BotUser</code>\r
 509       def initialize\r
 510         @everyone = Auth::defaultbotuser\r
 511         @botowner = Auth::botowner\r
 512         bot_associate(nil)\r
 513       end\r
 514 \r
 515       def bot_associate(bot)\r
 516         raise "Cannot associate with a new bot! Save first" if defined?(@has_changes) && @has_changes\r
 517 \r
 518         reset_hashes\r
 519 \r
 520         # Associated bot\r
 521         @bot = bot\r
 522 \r
 523         # This variable is set to true when there have been changes\r
 524         # to the botusers list, so that we know when to save\r
 525         @has_changes = false\r
 526       end\r
 527 \r
 528       def set_changed\r
 529         @has_changes = true\r
 530       end\r
 531 \r
 532       def reset_changed\r
 533         @has_changes = false\r
 534       end\r
 535 \r
 536       def changed?\r
 537         @has_changes\r
 538       end\r
 539 \r
 540       # resets the hashes\r
 541       def reset_hashes\r
 542         @botusers = Hash.new\r
 543         @allbotusers = Hash.new\r
 544         [everyone, botowner].each { |x|\r
 545           @allbotusers[x.username.to_sym] = x\r
 546         }\r
 547       end\r
 548 \r
 549       def load_array(ary, forced)\r
 550         unless ary\r
 551           warn "Tried to load an empty array"\r
 552           return\r
 553         end\r
 554         raise "Won't load with unsaved changes" if @has_changes and not forced\r
 555         reset_hashes\r
 556         ary.each { |x|\r
 557           raise TypeError, "#{x} should be a Hash" unless x.kind_of?(Hash)\r
 558           u = x[:username]\r
 559           unless include?(u)\r
 560             create_botuser(u)\r
 561           end\r
 562           get_botuser(u).from_hash(x)\r
 563         }\r
 564         @has_changes=false\r
 565       end\r
 566 \r
 567       def save_array\r
 568         @allbotusers.values.map { |x|\r
 569           x.to_hash\r
 570         }\r
 571       end\r
 572 \r
 573       # checks if we know about a certain BotUser username\r
 574       def include?(botusername)\r
 575         @allbotusers.has_key?(botusername.to_sym)\r
 576       end\r
 577 \r
 578       # Maps <code>Irc::User</code> to BotUser\r
 579       def irc_to_botuser(ircuser)\r
 580         logged = @botusers[ircuser.to_irc_user]\r
 581         return logged if logged\r
 582         return autologin(ircuser)\r
 583       end\r
 584 \r
 585       # creates a new BotUser\r
 586       def create_botuser(name, password=nil)\r
 587         n = BotUser.sanitize_username(name)\r
 588         k = n.to_sym\r
 589         raise "botuser #{n} exists" if include?(k)\r
 590         bu = BotUser.new(n)\r
 591         bu.password = password\r
 592         @allbotusers[k] = bu\r
 593         return bu\r
 594       end\r
 595 \r
 596       # returns the botuser with name _name_\r
 597       def get_botuser(name)\r
 598         @allbotusers.fetch(BotUser.sanitize_username(name).to_sym)\r
 599       end\r
 600 \r
 601       # Logs Irc::User _user_ in to BotUser _botusername_ with password _pwd_\r
 602       #\r
 603       # raises an error if _botusername_ is not a known BotUser username\r
 604       #\r
 605       # It is possible to autologin by Netmask, on request\r
 606       #\r
 607       def login(user, botusername, pwd=nil)\r
 608         ircuser = user.to_irc_user\r
 609         n = BotUser.sanitize_username(botusername)\r
 610         k = n.to_sym\r
 611         raise "No such BotUser #{n}" unless include?(k)\r
 612         if @botusers.has_key?(ircuser)\r
 613           return true if @botusers[ircuser].username == n\r
 614           # TODO\r
 615           # @botusers[ircuser].logout(ircuser)\r
 616         end\r
 617         bu = @allbotusers[k]\r
 618         if bu.login(ircuser, pwd)\r
 619           @botusers[ircuser] = bu\r
 620           return true\r
 621         end\r
 622         return false\r
 623       end\r
 624 \r
 625       # Tries to auto-login Irc::User _user_ by looking at the known botusers that allow autologin\r
 626       # and trying to login without a password\r
 627       #\r
 628       def autologin(user)\r
 629         ircuser = user.to_irc_user\r
 630         debug "Trying to autlogin #{ircuser}"\r
 631         return @botusers[ircuser] if @botusers.has_key?(ircuser)\r
 632         @allbotusers.each { |n, bu|\r
 633           debug "Checking with #{n}"\r
 634           return bu if bu.autologin? and login(ircuser, n)\r
 635         }\r
 636         return everyone\r
 637       end\r
 638 \r
 639       # Checks if User _user_ can do _cmd_ on _chan_.\r
 640       #\r
 641       # Permission are checked in this order, until a true or false\r
 642       # is returned:\r
 643       # * associated BotUser on _chan_\r
 644       # * associated BotUser on all channels\r
 645       # * everyone on _chan_\r
 646       # * everyone on all channels\r
 647       #\r
 648       def permit?(user, cmdtxt, channel=nil)\r
 649         if user.class <= BotUser\r
 650           botuser = user\r
 651         else\r
 652           botuser = irc_to_botuser(user)\r
 653         end\r
 654         cmd = cmdtxt.to_irc_auth_command\r
 655 \r
 656         chan = channel\r
 657         case chan\r
 658         when User\r
 659           chan = "?"\r
 660         when Channel\r
 661           chan = chan.name\r
 662         end\r
 663 \r
 664         allow = nil\r
 665 \r
 666         allow = botuser.permit?(cmd, chan) if chan\r
 667         return allow unless allow.nil?\r
 668         allow = botuser.permit?(cmd)\r
 669         return allow unless allow.nil?\r
 670 \r
 671         unless botuser == everyone\r
 672           allow = everyone.permit?(cmd, chan) if chan\r
 673           return allow unless allow.nil?\r
 674           allow = everyone.permit?(cmd)\r
 675           return allow unless allow.nil?\r
 676         end\r
 677 \r
 678         raise "Could not check permission for user #{user.inspect} to run #{cmdtxt.inspect} on #{chan.inspect}"\r
 679       end\r
 680 \r
 681       # Checks if command _cmd_ is allowed to User _user_ on _chan_, optionally\r
 682       # telling if the user is authorized\r
 683       #\r
 684       def allow?(cmdtxt, user, chan=nil)\r
 685         if permit?(user, cmdtxt, chan)\r
 686           return true\r
 687         else\r
 688           # cmds = cmdtxt.split('::')\r
 689           # @bot.say chan, "you don't have #{cmds.last} (#{cmds.first}) permissions here" if chan\r
 690           @bot.say chan, _("%{user}, you don't have '%{command}' permissions here") %\r
 691                         {:user=>user, :command=>cmdtxt} if chan\r
 692           return false\r
 693         end\r
 694       end\r
 695 \r
 696     end\r
 697 \r
 698     # Returns the only instance of AuthManagerClass\r
 699     #\r
 700     def Auth.authmanager\r
 701       return AuthManagerClass.instance\r
 702     end\r
 703 \r
 704   end\r
 705 \r
 706 end\r