cul-handles 0.1.0 → 0.2.0

data/lib/cul/handles/resolution_response.rb

@@ -0,0 +1,168 @@
+module Cul
+  module Handles
+    class ResolutionResponse < BaseResponse
+      def parseBody(data)
+        offset = 0
+        @packet.concat(data)
+        # parse return digest
+        if self.returnRequestDigest()
+          self.digestAlg = data[offset]
+          if (@digestLength)
+            @messageDigest = data[1..(@digestLength)]
+            offset = 1 + @digestLength
+          else
+            @messageDigest = []
+          end
+        end
+        @body = data[offset...@bodyLength]
+        arrayInfo = readByteArray(data,offset)
+        offset = offset + arrayInfo[0]
+        @handle = arrayInfo[1]
+        numVals = fromBytes(data[offset...offset+4])
+        offset = offset + 4
+        @handleValues = []
+        for i in (1..numVals)
+          valLen = calculateValueLen(data,offset)
+          value = HandleValue.new(data[offset...offset+valLen])
+          @handleValues.push(value)
+          puts value
+          offset = offset + valLen
+        end
+      end
+      def handle
+        if(@handle)
+          return @handle.pack('c*')
+        else
+          return ''
+        end
+      end  
+      def handleValue(type='URL')
+        @handleValues.each{|value|
+          if value.type == type
+            return value.data
+          end
+        }
+        return nil
+      end
+    end
+    class HandleValue
+      include Hdl
+      PERM_ADMIN_READ = 0x8
+      PERM_ADMIN_WRITE = 0x4
+      PERM_PUBLIC_READ = 0x2
+      PERM_PUBLIC_WRITE = 0x1
+      TTL_TYPE_RELATIVE = 0
+      TTL_TYPE_ABSOLUTE = 1
+      MAX_RECOGNIZED_TTL = 86400*2 # 2 days
+      def initialize(data=[],handle="")
+        super()
+        @handle=handle
+        @refs = []
+        @data = []
+        @type = []
+        @perm = 14 # admin r/w; public r
+        @ttlType = TTL_TYPE_RELATIVE # default
+        @ttl = asBytes(86400) # default is 86400 seconds = 1440 minutes = 24 hours
+        @timestamp = asBytes(Time.new().to_i) # number of seconds since computing era
+        deserialize(data) unless data.length == 0
+      end
+      def deserialize(data)
+        @index = data[0..3]
+        @timestamp = data[4..7]
+        @ttlType = data[8]
+        @ttl = data[9..12]
+        @perm = data[13]
+        typeLen = fromBytes(data[14..17])
+        offset = 18
+        @type = data[18...18+typeLen]
+        offset = offset + typeLen
+        dataLen = fromBytes(data[offset...offset+4])
+        offset = offset + 4
+        @data = data[offset...offset+dataLen]
+        offset = offset + dataLen
+        refsLen = fromBytes(data[offset...offset+4])
+        offset = offset + 4
+        @refs = []    
+        (1..refsLen).each{
+          @refs.push(fromBytes(data[offset...offset+4]))
+          offset = offset + 4  
+        }
+      end
+      def serialize()
+        result = [].concat(@index)
+        result.concat(@timestamp)
+        result.concat([@ttlType])
+        result.concat(@ttl)
+        result.concat([@perm])
+        result.concat(asBytes(@type.length))
+        result.concat(@type)
+        result.concat(asBytes(@data.length))
+        result.concat(@data)
+        result.concat(asBytes(@refs.length))
+        if(@refs.length > 0)
+          @refs.each{ | ref|
+            result.concat(asBytes(ref))
+          }
+        end
+        return result
+      end
+      def handle
+        @handle
+      end
+      def index=(val)
+        @index= val
+      end
+      def index
+        fromBytes(@index)
+      end  
+      def timestamp=(val)
+        @timestamp=val
+      end
+      def ttlType=(val)
+        @ttlType = val
+      end
+      def ttl=(val)
+        @ttl = val
+      end
+      def perm=(val)
+        @perm = val
+      end
+      def adminRead
+        @perm & PERM_ADMIN_READ
+      end
+      def adminWrite
+        @perm & PERM_ADMIN_WRITE
+      end
+      def publicRead
+        @perm & PERM_PUBLIC_READ
+      end
+      def publicWrite
+        @perm & PERM_PUBLIC_WRITE
+      end
+      def type=(val)
+        @type=val
+      end
+      def type
+        return @type.pack('U*')
+      end
+      def data=(val)
+        @data=val
+      end
+      def data
+        @data.pack('U*')
+      end  
+      def refs=(val)
+        @refs = val  
+      end
+      def to_s
+        if (type == "HS_ADMIN")
+          return "admin handle data: ttl= " + fromBytes(@ttl).to_s + " ; ttlType= " + @ttlType.to_s + "; index = " + index.to_s +  "; " + decodeAdminData(@data).to_s + "; permissions = " + @perm.to_s
+        end
+        return "type: " + type + "; index=" + index.to_s + "; data.length: " + @data.length.to_s + " ; data: " + data + "; data(hex): " + @data.collect { |element| "%02x" % element }.join+ "; permissions = " + @perm.to_s
+      end
+  
+  
+   
+    end
+  end
+end

data/lib/cul/handles/session_request.rb

@@ -0,0 +1,126 @@
+module Cul
+  module Handles
+    class SessionSetupRequest < BaseRequest
+      include Hdl
+      attr_reader :dh
+      KEYMAX = (2**513)-1
+      def initialize(authHandle, authIndex)
+        super()
+        @opCode = asBytes(OC_SESSION_SETUP)
+        @sessionId = [0,0,0,0]
+        @requestId = [0,0,0,0]
+        @siteInfoSerial = [0,0,0,0]
+        self.responseCode = 0
+        self.authoritative=true
+        self.returnRequestDigest=true
+        self.encrypt=false
+        self.publicOnly=false
+        self.certify=true
+        self.cacheCertify=true
+        self.recursive=true
+        self.continuous=false
+        self.keepAlive=false
+        self.expirationTime=0
+        @dh = DH.new(53,5,KEYMAX)
+        while(not @dh.valid?)
+          @dh.generate
+        end
+        self.body= getAttributes(authHandle, authIndex)
+      end
+      def getAttributes(authHandle, authIndex)
+        # identity att
+        identity = toProtocolString("HS_SESSION_IDENTITIY")
+        identity.concat(toProtocolString(authHandle))
+        identity.concat(asBytes(authIndex))
+        # key exchange att
+        exchange = toProtocolString("HS_SESSION_KEY_EXCHANGE")
+        exchange.concat(toProtocolString("DIFFIE_HELLMAN"))
+        exchange.concat(@dh.encodeKeyParms)
+        # timeout att
+        timeout = toProtocolString("HS_SESSION_TIMEOUT")
+        timeout.concat([0,0,0,120])
+        [0,0,0,2].concat(identity).concat(timeout)
+      end
+      def indexList
+        [0,0,0,0] 
+      end
+      def typeList
+        [0,0,0,0]
+      end
+      def credentialVersion()
+        return []
+      end
+      def credentialReserved()
+        return []
+      end
+      def credentialOptions()
+        return []
+      end
+      def credentialSigner()
+        return []
+      end
+      def credentialType()
+        return []
+      end
+      def credentialDigestAlg()
+        return []
+      end
+  
+    end
+    class DH
+      include Hdl
+      attr_reader :prime, :generator, :maxrand, :publickey
+    #  def DH.miller_rabin(a, n)
+    #    
+    #  end
+    #  def DH.prime
+    #    
+    #  end
+      def DH.mod_exp start, e, m
+        result = 1
+        b = start
+        while e > 0
+          result = (result * b) % m if e[0] == 1
+          e = e >> 1
+          b = (b*b) %m
+        end
+        return result
+      end
+      def initialize(prime, generator, maxrand)
+        @prime = prime
+        @generator = generator
+        @maxrand = maxrand
+        @publickey = 0 #public key
+        @key = 0 #shared secret
+        @private = 0 #private key
+      end
+      def generate tries=16 # shared key
+        tries.times do
+          @private = rand(@maxrand)
+          @publickey = DH.mod_exp(@generator, @private, @prime)
+          return @publickey if self.valid?
+        end
+      end
+      def secret f # private key
+        @key = DH.mod_exp(f,@private,@prime)
+        @key
+      end
+      def valid? _e = self.publickey
+        _e and _e.between?(2,self.prime-2) and _e != 0
+      end
+      def encodeKeyParms
+        result = []
+        publicBytes = asBytes(@publickey)
+        result.concat(asBytes(publicBytes.length))
+        result.concat(publicBytes)
+        primeBytes = asBytes(@prime)
+        result.concat(asBytes(primeBytes.length))
+        result.concat(primeBytes)
+        genBytes = asBytes(@generator)
+        result.concat(asBytes(genBytes.length))
+        result.concat(genBytes)
+        result
+      end
+    end
+  end
+end

data/lib/cul/handles/session_setup_response.rb

@@ -0,0 +1,25 @@
+module Cul
+  module Handles
+    class SessionSetupResponse < BaseResponse
+      attr_reader :serverKey
+      def parseBody(data)
+        puts "parseBody"
+        @digestAlg = data[0]
+        if(@digestAlg == 2)
+          @digest = data[1..20]
+          offset = 21
+        else
+          @digest =data[1..16]
+          offset = 17
+        end
+        keyLen = fromBytes(data[offset...offset+4])
+        offset = offset + 4
+        @serverKey = fromBytes(data[offset...offset+keyLen])
+        @body = []
+      end
+      def to_s
+        super() + "; serverKey: " + @serverKey.to_s
+      end
+    end
+  end
+end

data/lib/cul/handles/set_value_request.rb

@@ -0,0 +1,6 @@
+module Cul
+  module Handles
+    class SetValueRequest < BaseRequest
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: cul-handles
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - James Stuart
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-10 00:00:00 -05:00
+date: 2009-11-11 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -38,9 +38,31 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
+- cul-handles.gemspec
 - lib/cul-handles.rb
+- lib/cul/handles/base_message.rb
+- lib/cul/handles/base_request.rb
+- lib/cul/handles/base_response.rb
+- lib/cul/handles/challenge_answer_request.rb
+- lib/cul/handles/challenge_response.rb
+- lib/cul/handles/client.rb
+- lib/cul/handles/create_handle_request.rb
+- lib/cul/handles/delete_handle_request.rb
+- lib/cul/handles/delete_value_request.rb
+- lib/cul/handles/handle_value_request.rb
+- lib/cul/handles/hdl.rb
+- lib/cul/handles/modify_value_request.rb
+- lib/cul/handles/resolution_request.rb
+- lib/cul/handles/resolution_response.rb
+- lib/cul/handles/session_request.rb
+- lib/cul/handles/session_setup_response.rb
+- lib/cul/handles/set_value_request.rb
+- test/authn_test.rb
 - test/cul-handles_test.rb
+- test/dh_test.rb
+- test/resolution_test.rb
 - test/test_helper.rb
+- test/unsigned_integer_test.rb
 has_rdoc: true
 homepage: http://github.com/tastyhat/cul-handles
 licenses: []