/postman - Annotate - CyborgHood - DuckCorp Projects

root/postman @ 591ec1a2

-a68712
+#!/usr/bin/ruby -Ku
 # http://www.ruby-doc.org/stdlib/libdoc/net/imap/rdoc/index.html
 # http://tmail.rubyforge.org/reference/index.html
 # http://tools.ietf.org/html/rfc3156
 $: << "./lib"
 require 'net/imap'
 require 'tmail'
-e0c2
+require 'tmail_extra'
-a68712
+#require 'socket'
 #require 'fileutils'
 #require 'tempfile'
 require 'gpgme'
 require 'active_ldap'
 require 'shellwords'
 require 'cyborghood/base'
-f7a1eee
+class LdapPerson < ActiveLdap::Base
-a68712
+  ldap_mapping :dn_attribute => 'uid', :prefix => '', :classes => ['person', 'extInetOrgPerson']
 end
-ec1a2
+class Person < Delegator
   attr_reader :ldap
   def self.find_by_fingerprint(fingerprint)
     list = LdapPerson.find(:all, :attribute => 'keyFingerPrint', :value => fingerprint)
     case list.size
     when 0
       nil
     when 1
       person = allocate
       person.instance_variable_set("@ldap", list.first)
       person
     else
       logger.warn "Multiple users match in database, so i guess there is a mistake. It is safer to skip..."
       nil
     end
   end
   def __getobj__
     @ldap
   end
 end
-f7a1eee
+class LdapDnsDomain < ActiveLdap::Base
-a68712
+  ldap_mapping :dn_attribute => 'cn', :prefix => '', :classes => ['genericDomain']
   def managers
     list = self.manager
     return [] if list.nil?
     return list.collect{|dn| dn.to_s } if list.is_a? Array
     return [list.to_s]
   end
 end
-f7a1eee
+class DnsDomain < Delegator
-ec1a2
+  attr_reader :ldap, :name
-f7a1eee
+            Marc Dequenes
   def initialize(name)
-ec1a2
+    @name = name
     raise "invalid zone name" unless self.is_valid?
-f7a1eee
+            Marc Dequenes
     # may not exist (if creating a new one)
     begin
       @ldap = LdapDnsDomain.find(name)
     rescue
       @ldap = nil
     end
   end
   def self.is_valid?(name)
     name =~ /^[a-z0-9.-]+\.[a-z]{2,4}$/
   end
-ec1a2
+  def is_valid?
     self.class.is_valid?(@name)
-f7a1eee
+  end
-ec1a2
+  def hosted?
-f7a1eee
+    not @ldap.nil?
   end
-ec1a2
+  def managed_by?(user)
     @ldap.managers.include? user.ldap.dn
   end
-f7a1eee
+  def __getobj__
     @ldap
   end
-ec1a2
+            Marc Dequenes
   def self.find_by_manager(user)
     list = LdapDnsDomain.find(:all, :attribute => 'manager', :value => user.ldap.dn)
     list.collect do |l_dom|
       domain = allocate
       domain.instance_variable_set("@ldap", l_dom)
     end
   end
-f7a1eee
+end
-a68712
+#Socket.gethostname
+#
 # TODO:
 #   - should be able to handle encrypted messages for user to send sensitive data (postman would need a GPG key too)
+#
 class CommandParser
-            df41472b
+  def self.run(user, txt, refs)
-a68712
+    txt.each_line do |line|
       line.chomp!
       sline = line.strip
       # skip empty lines and comments
       next if sline == "" or sline[0, 1] == "#"
       # stop processing when detecting message signature
       break if line == "-- "
-f7a1eee
+      logger.info "Executing command: #{sline}"
       begin
         execute_cmd(user, sline)
       rescue
         logger.info "Command failed: " + $!
       end
-a68712
+    end
   end
   private
   def self.execute_cmd(user, cmdstr)
     cmdline = Shellwords.shellwords(cmdstr)
     subsys = cmdline.shift
     ok = true
     case subsys.upcase
     when "DNS"
       case cmdline.shift.upcase
       when "INFO"
-ec1a2
+        if cmdline.empty?
           list = DnsDomain.find_by_manager(user)
           logger.info "User is manager of the following zones: " + list.collect{|z| z.cn }.sort.join(", ")
         else
           ok = false
         end
-a68712
+      when "GET"
         case cmdline.shift.upcase
         when "ZONE"
           zone = cmdline.shift.downcase
-ec1a2
+          dom = DnsDomain.new(zone)
           logger.info "User requesting zone content for '#{zone}'"
           if dom.hosted?
             if dom.managed_by? user
               logger.info "User is manager of the zone"
             else
               logger.info "User is not allowed to manage the zone"
             end
           else
             logger.info "Zone not hosted"
           end
         else
           ok = false
         end
-a68712
+      when "SET"
       else
         ok = false
       end
     else
       ok = false
     end
     if not ok
-f7a1eee
+      logger.info "Command not recognized: #{cmdstr}"
-a68712
+    end
   end
 end
 module CyborgHood
   # not yet ready to be a real Cyborg
   class Postman #< Cyborg
     def initialize
       # load config
       Config.load(self.human_name.downcase)
       @config = Config.instance
-af9cada
+      ldap_config = @config.ldap
       ldap_config.logger = logger
       ActiveLdap::Base.establish_connection(ldap_config.marshal_dump)
-a68712
+      # setup logs
       unless @config.log.nil?
         logger.output_level(@config.log.console_level) unless @config.log.console_level.nil?
         logger.log_to_file(@config.log.file) unless @config.log.file.nil?
       end
       logger.info "Bot '#{self.human_name}' loaded"
     end
     def run
       # using SSL because TLS does not work in the NET::IMAP library
       #imap = Net::IMAP.new('imap.duckcorp.org', 993, true, "/etc/ssl/certs/duckcorp.crt", true)
       imap = Net::IMAP.new('localhost')
       logger.debug "Connected to IMAP server"
-e0c2
+      logger.debug "IMAP Capabilities: " + imap.capability.join(", ")
-a68712
+      imap.authenticate('LOGIN', @config.imap.login, @config.imap.passwd)
       logger.debug "Logged into IMAP account"
       #p imap.getquotaroot("INBOX")
       imap.select('INBOX')
       imap.search(["ALL"], "UTF-8").each do |message_id|
         msg = imap.fetch(message_id, "RFC822")[0].attr["RFC822"]
         # unquote headers and transform into TMail object
         mail = TMail::Mail.parse(TMail::Unquoter.unquote_and_convert_to(msg, "UTF-8"))
-ec1a2
+        logger.set_prefix()
-a68712
+        logger.debug "######################################"
-ec1a2
+        logger.set_prefix("[#{mail.message_id}] ")
-a68712
+        logger.info "#{mail.from_addrs} -> #{mail.to_addrs}: #{mail.subject}"
         # ignore mails not signed
-ec1a2
+        unless mail.is_pgp_signed?
           logger.info "Mail not signed or not RFC3156 compliant"
-a68712
+          next
-ec1a2
+        end
-a68712
+            Marc Dequenes
         logger.debug "Proper signed content detected"
-ec1a2
+        sig_check = mail.verify_pgp_signature()
-e0c2
+        if sig_check.status == 0
           logger.info "Mail content was properly signed by key #{sig_check.fingerprint}"
-ec1a2
+          user = Person.find_by_fingerprint(sig_check.fingerprint)
           if user.nil?
             logger.info "Mail is from an unknown person"
           else
             logger.info "Mail is from user #{user.uid} (#{user.cn})"
-            df41472b
+            Marc Dequenes
             signed_content = mail.pgp_signed_part()
-ec1a2
+            if signed_content.multipart?
               if signed_content.parts[0].content_type == "text/plain"
                 command_txt = signed_content.parts[0].body
                 command_refs = signed_content.parts.collect{|p| p.dup }
               end
             else
               command_txt = signed_content.body if signed_content.content_type == "text/plain"
               command_refs = []
             end
             if command_txt
               CommandParser.run(user, command_txt, command_refs)
             else
               logger.info "Mail does not contain a proper MIME part for commands"
             end
           end
-e0c2
+        else
           logger.info "Mail content tampered or badly signed: " + sig_check.to_s
-a68712
+        end
       end
       imap.logout
     end
     def ask_to_stop
     end
   end
 end
 bot = CyborgHood::Postman.new
 trap('INT') do
   bot.ask_to_stop
 end
 trap('TERM') do
   bot.ask_to_stop
 end
 bot.run

Project

General

Profile

DuckCorp » CyborgHood