pastehub 0.2.6

data/lib/pastehub.rb

@@ -0,0 +1,43 @@
+#
+# pastehub.rb - PasteHub's top-level library file
+#
+#
+#   Copyright (c) 2012  Kiyoka Nishiyama  <kiyoka@sumibi.org>
+#
+#   Redistribution and use in source and binary forms, with or without
+#   modification, are permitted provided that the following conditions
+#   are met:
+#
+#   1. Redistributions of source code must retain the above copyright
+#      notice, this list of conditions and the following disclaimer.
+#
+#   2. Redistributions in binary form must reproduce the above copyright
+#      notice, this list of conditions and the following disclaimer in the
+#      documentation and/or other materials provided with the distribution.
+#
+#   3. Neither the name of the authors nor the names of its contributors
+#      may be used to endorse or promote products derived from this
+#      software without specific prior written permission.
+#
+#   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+#   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+#   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+#   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+#   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+#   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+#   TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+#   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+#   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+#   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+#   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#
+require 'pastehub/config'
+require 'pastehub/util'
+require 'pastehub/crypt'
+require 'pastehub/auth'
+require 'pastehub/localdb'
+require 'pastehub/store'
+require 'pastehub/client'
+require 'pastehub/clientsync'
+require 'pastehub/clipboard'

data/lib/pastehub/auth.rb

@@ -0,0 +1,171 @@
+#
+# auth.rb - PasteHub's authentication library file
+#  
+#   Copyright (c) 2009-2011  Kiyoka Nishiyama  <kiyoka@sumibi.org>
+#   
+#   Redistribution and use in source and binary forms, with or without
+#   modification, are permitted provided that the following conditions
+#   are met:
+#   
+#   1. Redistributions of source code must retain the above copyright
+#      notice, this list of conditions and the following disclaimer.
+#  
+#   2. Redistributions in binary form must reproduce the above copyright
+#      notice, this list of conditions and the following disclaimer in the
+#      documentation and/or other materials provided with the distribution.
+#  
+#   3. Neither the name of the authors nor the names of its contributors
+#      may be used to endorse or promote products derived from this
+#      software without specific prior written permission.
+#  
+#   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+#   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+#   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+#   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+#   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+#   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+#   TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+#   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+#   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+#   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+#   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#  
+#
+require "openssl"
+require "base64"
+require 'pp'
+
+module PasteHub
+  MANDATORY_KEYS = [
+                    'x-pastehub-username',
+                    'x-pastehub-date',
+                    'x-pastehub-version'
+                   ]
+
+
+  class Auth
+    def initialize()
+      @elements = Hash.new
+    end
+
+    def addElement( key, value )
+      @elements[key.downcase] = value
+    end
+
+    def calcSignature( secretKey )
+      a = Set.new( @elements.keys )
+      b = Set.new( MANDATORY_KEYS )
+      if a.superset?( b )
+        message = MANDATORY_KEYS.sort.map {|k|
+          k + ':' + @elements[k]
+        }.join( ',' ).downcase
+
+        h = OpenSSL::HMAC::digest(OpenSSL::Digest::SHA256.new, secretKey, message)
+        Base64.encode64(h).chomp
+      else
+        # not enough keys
+        :NotEnoughKeys
+      end
+    end
+
+    def getAuthHash( )
+      @elements
+    end
+
+    def username()
+      @elements['x-pastehub-username']
+    end
+
+    def curTime()
+      @elements['x-pastehub-date']
+    end
+  end
+
+  class AuthForClient
+    def initialize( username, secretKey )
+      util = Util.new
+      @token = Auth.new( )
+      @token.addElement( 'x-pastehub-username', username )
+      @token.addElement( 'x-pastehub-date',     util.key_seconds( util.currentTime( )).to_s )
+      @token.addElement( 'x-pastehub-version',  '2012-06-16' )
+      @secretKey = secretKey
+    end
+
+    def getAuthHash( )
+      sign = @token.calcSignature( @secretKey )
+      #pp ["sign", sign ]
+      if sign.is_a? String
+        @token.addElement( 'Authorization',        sign )
+        @token.getAuthHash()
+      else
+        raise RuntimeError, "Error: can't create AuthForClient instance."
+      end
+    end
+
+    # for Testing with RSpec.
+    def _addElement( key, value )
+      @token.addElement( key, value )
+    end
+
+    def username()
+      @token.username
+    end
+  end
+
+  class AuthForServer
+    def initialize( users )
+      # db connecter of Users table
+      @users = users
+    end
+
+    def expired?( clientTime, serverTime )
+      (60*5) < ( clientTime.to_i - serverTime.to_i ).abs
+    end
+
+    # return:
+    #  [ true/false, "username", :reason ]
+    def invoke( hash, serverTime )
+      auth = Auth.new
+      client_sign = ""
+      hash.each { |k,v|
+        k = k.downcase
+        #pp [ "invoke", k, v ]
+        if MANDATORY_KEYS.include?( k )
+          auth.addElement( k, v )
+        end
+        if 'authorization' == k
+          client_sign = v
+        end
+      }
+
+      #pp [ "auth.getAuthHash()", auth.getAuthHash() ]
+      #pp [ "client_sign", client_sign ]
+      #pp [ "auth.username", auth.username ]
+
+      if not auth.username
+        # fail... username was unspecified
+        [ false, 'UNSPECIFIED', :unspecified_user ]
+      else
+        if @users.getSecretKey(auth.username)
+          server_sign = auth.calcSignature( @users.getSecretKey(auth.username) )
+          #pp [ "server_sign", server_sign ]
+          if server_sign == client_sign
+
+            if expired?( auth.curTime, serverTime )
+              # authentication success
+              [ false, auth.username, :expired_client_request ]
+            else
+              [ true,  auth.username, :ok ]
+            end
+          else
+            # fail...
+            [ false, auth.username, :illegal_signature ]
+          end
+        else
+          # unknown user
+          [ false, auth.username, :unknown_user ]
+        end
+      end
+    end
+  end
+end

data/lib/pastehub/client.rb

@@ -0,0 +1,453 @@
+#
+# client.rb - PasteHub's client main library
+#  
+#   Copyright (c) 2009-2011  Kiyoka Nishiyama  <kiyoka@sumibi.org>
+#   
+#   Redistribution and use in source and binary forms, with or without
+#   modification, are permitted provided that the following conditions
+#   are met:
+#   
+#   1. Redistributions of source code must retain the above copyright
+#      notice, this list of conditions and the following disclaimer.
+#  
+#   2. Redistributions in binary form must reproduce the above copyright
+#      notice, this list of conditions and the following disclaimer in the
+#      documentation and/or other materials provided with the distribution.
+#  
+#   3. Neither the name of the authors nor the names of its contributors
+#      may be used to endorse or promote products derived from this
+#      software without specific prior written permission.
+#  
+#   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+#   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+#   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+#   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+#   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+#   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+#   TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+#   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+#   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+#   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+#   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#  
+#
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'open-uri'
+require 'fileutils'
+
+module PasteHub
+
+  def self.signfilePath
+    signfile = PasteHub::Config.instance.localDbPath + "authinfo.txt"
+  end
+
+  def self.loadUsername
+    signfile = self.signfilePath
+
+    # load authenticate information
+    if not File.exist?( signfile )
+      return nil
+    else
+      begin
+        open( signfile ) {|f|
+          # first line is email (is username)
+          username = f.readline.chomp
+          if username.match( /^[a-z]+/ )
+            return username
+          end
+        }
+      rescue Exception => e
+        STDERR.puts( "Error: can't load #{signfile}: #{e.to_s}" )
+        raise e
+      end
+      return nil
+    end
+  end
+
+  # setup user's directory
+  #   result: true ... success / false ... fail
+  def self.setupDirectory
+    localdb_path = PasteHub::Config.instance.localDbPath
+    # Create directory
+    if not File.exist?(  localdb_path )
+      if 0 == Dir.mkdir( localdb_path, 0700 )
+        STDERR.puts( "Info:  created directory #{localdb_path}" )
+      else
+        STDERR.puts( "Error: can't create directory #{localdb_path}" )
+        return false
+      end
+    end
+    return true
+  end
+
+  def self.signIn
+    signfile = self.signfilePath
+    util = Util.new
+
+    # authenticate information
+    if not File.exist?( signfile )
+      3.times { |n|
+        util.say( "Please input your account information" )
+        username  = util.inputText("       email: ")
+        secretKey = util.inputText("  secret-key: " )
+        auth = AuthForClient.new( username, secretKey )
+        client = Client.new( auth )
+        if client.authTest()
+          # save authinfo with gpg
+          begin
+            password = util.inputPasswordTwice(
+                            "Please input password for crypted file",
+                            "  password            : ",
+                            "  password(for verify): " )
+            if password
+              crypt = PasteHub::Crypt.new( password )
+              open( signfile, "w" ) {|f|
+                f.puts(           username  )
+                f.puts( crypt.en( secretKey ))
+              }
+              # auth OK
+              return [ username, secretKey, password ]
+            end
+            STDERR.puts( "Error: password setting failed..." )
+          rescue Exception => e
+            STDERR.puts( "Error: can't save #{signfile}: #{e.to_s}" )
+          end
+        else
+          STDERR.puts( "your email or secret key is not registerd..." )
+        end
+      }
+    else
+      begin
+        open( signfile ) {|f|
+          util.say( "Please input password for crypted file" )
+          username = f.readline.chomp
+          signStr = f.read
+          3.times { |n|
+            password  = util.inputPassword("  crypt password: ")
+            crypt = PasteHub::Crypt.new( password )
+            secretKey= crypt.de( signStr )
+            if secretKey
+              auth = AuthForClient.new( username, secretKey )
+              client = Client.new( auth )
+              if client.authTest()
+                return [ username, secretKey, password ]
+              else
+                STDERR.puts( "Error: your secretKey may be old." )
+              end
+            end
+            STDERR.puts( "Error: missing password." )
+          }
+        }
+      rescue Exception => e
+        STDERR.puts( "Error: can't load #{signfile}: #{e.to_s}" )
+        raise e
+      end
+    end
+    return [ nil, nil, nil ]
+  end
+
+  def self.savePid( pid )
+    pidFile = PasteHub::Config.instance.localDbPath + "pid"
+    open( pidFile, "w" ) {|f|
+      f.puts pid
+    }
+  end
+
+  def self.loadPid
+    pidFile = PasteHub::Config.instance.localDbPath + "pid"
+    pid = 0
+    begin
+      pid = open( pidFile ) {|f|
+        f.readline.chomp.to_i
+      }
+    rescue Exception => e
+      STDERR.puts( "Warning: can't load #{pidFile}: #{e.to_s}" )
+      pid = 0
+    end
+    return pid
+  end
+
+
+  class ClientBase
+
+    # return:  Net::HTTPResponse
+    def httpGet( uriStr, headerHash, errorMessage )
+      uri = URI.parse( uriStr )
+      begin
+        https = Net::HTTP.new(uri.host, uri.port)
+        if ( Net::HTTP.https_default_port == uri.port ) or ( "https" == uri.scheme )
+          https.use_ssl     = true
+          https.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+        https.start {|http|
+          resp = http.get(uri.request_uri, headerHash)
+          if "200" == resp.code
+            return resp
+          end
+        }
+      rescue Exception => e
+        STDERR.puts errorMessage + ":" + e.to_s
+      end
+      return nil
+    end
+
+    # return:  Net::HTTPResponse
+    def httpPost( uriStr, bodyStr, headerHash, errorMessage )
+      uri = URI.parse( uriStr )
+      begin
+        https = Net::HTTP.new(uri.host, uri.port)
+        if ( Net::HTTP.https_default_port == uri.port ) or ( "https" == uri.scheme )
+          https.use_ssl     = true
+          https.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+        https.start {|http|
+          resp = http.post(uri.request_uri, bodyStr, headerHash)
+          if "200" == resp.code
+            return resp
+          end
+        }
+      rescue Exception => e
+        STDERR.puts errorMessage + ":" + e.to_s
+      end
+      return nil
+    end
+
+    # return:  [ Net::HTTP, Net::HTTP::Get ]
+    def httpGetRequest( uriStr, headerHash, errorMessage )
+      uri = URI.parse( uriStr )
+      begin
+        https = Net::HTTP.new(uri.host, uri.port)
+        if ( Net::HTTP.https_default_port == uri.port ) or ( "https" == uri.scheme )
+          https.use_ssl     = true
+          https.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+        return [ https, Net::HTTP::Get.new(uri.request_uri, headerHash) ]
+      rescue Exception => e
+        STDERR.puts errorMessage + ":" + e.to_s
+      end
+      return nil
+    end
+
+  end
+
+
+  class Client < ClientBase
+    def initialize( auth, password = nil )
+      @auth = auth
+      ins = PasteHub::Config.instance
+      @localdb_path         = ins.localDbPath
+      @server_api_url       = ins.targetApiURL
+      @server_notifier_url  = ins.targetNotifierURL
+      @list_items           = ins.listItems
+      @syncTrigger          = []
+      @crypt                = if password
+                                Crypt.new( password )
+                              else
+                                nil
+                              end
+    end
+
+    def authTest
+      httpGet( "#{@server_api_url}authTest", @auth.getAuthHash(), "Error: can't connect to server for auth test" )
+    end
+
+
+    def getList( limit = nil )
+      h = {"content-type" => "plain/text"}
+      if limit
+        h[ 'X-Pastehub-Limit' ] = limit.to_i
+      end
+
+      resp = httpGet( "#{@server_api_url}getList", @auth.getAuthHash().merge( h ), "Error: fails 'getList' from server." )
+      str = resp.read_body()
+      masterList = str.split( /\n/ )
+      STDERR.puts "Info: masterList lines = #{masterList.size}  #{str.size}Bytes"
+      masterList = masterList.select { |x|
+        okSize = "1340542369=2012-06-24.12:52:49=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".size
+        if okSize != x.size
+          STDERR.puts "Info: masterList(NG): " + x
+          false
+        else
+          x
+        end
+      }
+      masterList
+    end
+
+    def getValue( key )
+      raise RuntimeError, "Error: no encrypt password." unless @crypt
+
+      resp = httpPost( "#{@server_api_url}getValue", key, @auth.getAuthHash().merge( {"content-type" => "plain/text"} ), "Error: fails 'getValue' from server." )
+      ret = @crypt.de( resp.read_body() )
+      unless ret
+        STDERR.puts( "Warning: encrypt password is wrong. getValue missing..." )
+        ret = "error..."
+      end
+      ret
+    end
+
+    def putValue( key, data )
+      ret = ""
+      if not key
+        key = "_"
+      end
+      raise RuntimeError, "Error: no encrypt password." unless @crypt
+      _data = @crypt.en( data )
+      unless _data
+        STDERR.puts( "Warning: encrypt password is wrong. putValue missing..." )
+        ret = nil
+      else
+        resp = httpPost( "#{@server_api_url}putValue", _data,
+               @auth.getAuthHash().merge(
+                                   {
+                                           "content-type" => "plain/text",
+                                           "x-pastehub-key" => key    }),
+               "Error: fails 'putValue' from server." )
+        if resp
+          ret = resp.read_body()
+        end
+      end
+      ret
+    end
+
+    def wait_notify( auth )
+      begin
+        pair = httpGetRequest("#{@server_notifier_url}", auth.getAuthHash(), "Error: fails 'notifier' api on server." )
+        https       = pair[0]
+        getRequest  = pair[1]
+        https.start() { |http|
+          http.request(getRequest) do |response|
+            raise 'Response is not chuncked' unless response.chunked?
+            response.read_body do |chunk|
+              serverValue = chunk.chomp
+              if serverHasNew?( serverValue )
+                puts "Info: server has new data: #{serverValue}"
+                return chunk.chomp.clone()
+              else
+                puts "Info: server is stable:    #{serverValue}"
+              end
+              if localHasNew?( )
+                puts "Info: local  has new data"
+                return :local
+              end
+            end
+            if "200" != response.code
+              STDERR.puts "Error: request error result=[#{response.code}]"
+              return :retry
+            end
+          end
+        }
+      rescue EOFError => e
+        STDERR.puts "Error: disconnected by server."
+        return :retry
+      rescue Errno::ECONNREFUSED => e
+        STDERR.puts "Error: can't connect to server(ConnectionRefused)."
+        return :retry
+      rescue SocketError => e
+        STDERR.puts "Error: can't connect to server(SocketError)."
+        return :retry
+      rescue Errno::ETIMEDOUT => e
+        STDERR.puts "Error: can't connect to server(Timeout1)."
+        return :retry
+      rescue Timeout::Error => e
+        # ONLINE and notifier has no INFO.
+        return :timeout
+      end
+    end
+
+    def serverHasNew?( serverValue )
+      # open local db
+      localdb = PasteHub::LocalDB.new( @localdb_path )
+      localdb.open( @auth.username )
+      localValue = localdb.getValue( PasteHub::SERVER_DATE_KEY )
+      ret = (localValue != serverValue)
+      if ret
+        localdb.insertValue( PasteHub::SERVER_DATE_KEY, serverValue )
+      end
+      localdb.close()
+      return ret
+    end
+
+    def localHasNew?( )
+      localdb = PasteHub::LocalDB.new( @localdb_path )
+      localdb.open( @auth.username )
+      localValue  = localdb.getValue( PasteHub::LOCAL_DATE_KEY )
+      serverValue = localdb.getValue( PasteHub::SERVER_DATE_KEY )
+      ret = if localValue and serverValue
+              (localValue > serverValue)
+            else
+              false
+            end
+      if ret
+        localdb.insertValue( PasteHub::LOCAL_DATE_KEY, serverValue )
+      end
+      localdb.close()
+      return ret
+    end
+
+    def setOnlineState( online )
+      # open local db
+      if online
+        if online?() == false
+          @syncTrigger.unshift( true )
+        end
+      end
+      localdb = PasteHub::LocalDB.new( @localdb_path )
+      localdb.open( @auth.username )
+      localdb.insertValue( PasteHub::ONLINE_STATE_KEY, online ? "1" : "0" )
+      localdb.close()
+    end
+
+    def online?( )
+      # open local db
+      localdb = PasteHub::LocalDB.new( @localdb_path )
+      localdb.open( @auth.username, true )
+      # printf( "[%s]", localdb.getValue( PasteHub::ONLINE_STATE_KEY ))
+      ret = ("1" == localdb.getValue( PasteHub::ONLINE_STATE_KEY ))
+      localdb.close()
+      ret
+    end
+
+    def getTrigger()
+      if 0 < @syncTrigger.size
+        return @syncTrigger.pop
+      end
+      return false
+    end
+
+    def localSaveValue( argKey = nil, data )
+      # open local db
+      util = PasteHub::Util.new( )
+      if argKey
+        key = argKey
+      else
+        key = util.currentTime( ) + "=" + util.digest( data )
+      end
+
+      localdb = PasteHub::LocalDB.new( @localdb_path )
+      localdb.open( @auth.username )
+      list = localdb.getList( )
+      if util.key_digest( list[0] ) == util.digest( data )
+        # duplicate
+        localdb.close()
+        list[0]
+      else
+        localdb.insertValue( key, data.dup )
+        localdb.insertValue( PasteHub::LOCAL_DATE_KEY, util.currentTime( ) )
+        localdb.close()
+        key
+      end
+    end
+
+    def setServerFlags( keys )
+      localdb = PasteHub::LocalDB.new( @localdb_path )
+      localdb.open( @auth.username )
+      keys.each { |key|
+        localdb.setServerFlag( key )
+      }
+      localdb.close()
+    end
+  end
+end