ji2p 0.0.3-java

data/lib/ji2p/cluster/etcd/version3.rb

@@ -0,0 +1,6 @@
+module Ji2p::Cluster
+  module Etcd
+    class Version3
+    end
+  end
+end

data/lib/ji2p/cluster/kubernetes.rb

@@ -0,0 +1,5 @@
+module Ji2p::Cluster
+  module Kubernetes
+    autoload :KubeApi, File.expand_path('kubernetes/kube_api.rb', __dir__)
+  end
+end

data/lib/ji2p/cluster/kubernetes/kube_api.rb

@@ -0,0 +1,6 @@
+module Ji2p::Cluster
+  module Kubernetes
+    class KubeApi
+    end
+  end
+end

data/lib/ji2p/concurrent.rb

@@ -0,0 +1,24 @@
+require 'concurrent'
+
+module Ji2p
+  module Concurrent
+    java_import java.util.concurrent
+
+    def self.getThreadPool
+      @service ||= Executors.new_fixed_thread_pool(10)
+
+      # shutdown our ExecutorService when someone kills us
+      Kernel.trap('SIGINT') { service.shutdown }
+
+    end
+
+
+    def self.getSimpleThredPool
+      @pool ||= Concurrent::ThreadPoolExecutor.new(
+        min_threads: 3, # create up to 3 threads before queueing tasks
+        max_threads: 10, # create at most 10 threads
+        max_queue: 100, # at most 100 jobs waiting in the queue
+    )
+    end
+  end
+end

data/lib/ji2p/concurrent_executor.rb

@@ -0,0 +1,56 @@
+module Ji2p
+  module ConcurrentExecutor
+    class Error < StandardError
+      def initialize(exceptions)
+        @exceptions = exceptions
+        super
+      end
+
+      def message
+        @exceptions.map { | e | e.message }.join "\n"
+      end
+
+      def backtrace
+        traces = @exceptions.map { |e| e.backtrace }
+        ["ConcurrentExecutor::Error START", traces, "END"].flatten
+      end
+    end
+
+    class Future
+      def initialize(pool: nil)
+        @pool = pool || Concurrent::FixedThreadPool.new(20)
+        @exceptions = Concurrent::Array.new
+      end
+
+      # Sample Usage
+      # executor = ConcurrentExecutor::Future.new(pool: pool)
+      # executor.execute(carriers) do | carrier |
+      #   ...
+      # end
+      #
+      # values = executor.resolve
+
+      def execute array, &block
+        @futures = array.map do | element |
+          Concurrent::Future.execute({ executor: @pool }) do
+            yield(element)
+          end.rescue do | exception |
+            @exceptions << exception
+          end
+        end
+
+        self
+      end
+
+      def resolve
+        values = @futures.map(&:value)
+
+        if @exceptions.length > 0
+          raise ConcurrentExecutor::Error.new(@exceptions)
+        end
+
+        values
+      end
+    end
+  end
+end

data/lib/ji2p/config.rb

@@ -0,0 +1,15 @@
+require 'ostruct'
+require 'yaml'
+
+module Ji2p
+  class Config
+    def method_missing(m, *args, &block)
+    end
+
+    def respond_to?(method_name, include_private = false)
+    end
+
+    def respond_to_missing?(method_name, *args)
+    end
+  end
+end

data/lib/ji2p/control.rb

@@ -0,0 +1,15 @@
+require 'digest/sha1'
+
+module Ji2p
+  module Control
+    autoload :ClientManager, File.expand_path('control/client_manager.rb', __dir__)
+    autoload :Dest, File.expand_path('control/dest.rb', __dir__)
+    autoload :Keypair, File.expand_path('control/keypair.rb', __dir__)
+    autoload :SocketManager, File.expand_path('control/socket_manager.rb', __dir__)
+    autoload :TunnelManager, File.expand_path('control/tunnel_manager.rb', __dir__)
+
+    def self.unique_id
+      Digest::SHA1.hexdigest([Time.now, rand].join)
+    end
+  end
+end

data/lib/ji2p/control/client_manager.rb

@@ -0,0 +1,14 @@
+module Ji2p::Control
+  class ClientManager
+    java_import 'net.i2p.client.I2PClient'
+    java_import 'net.i2p.client.I2PClientFactory'
+
+    def self.listClients
+      context.clientManager.listClients.to_a
+    end
+
+    def self.context
+      RouterContext.getCurrentContext
+    end
+  end
+end

data/lib/ji2p/control/dest.rb

@@ -0,0 +1,34 @@
+require 'java'
+
+module Ji2p::Control
+  class Dest
+    java_import 'net.i2p.data.Destination'
+
+    def initialize keypair=nil
+      setKeypair(keypair) unless keypair.nil?
+    end
+
+    def setKeypair keypair
+      return if keypair.nil?
+      @keypair = keypair
+      @dest = Java::NetI2pData::Destination.create keypair.inputstream
+      #@dest.setPublicKey @keypair.pub
+      #@dest.setSigningPublicKey @keypair.spub
+      #@dest.setCertificate @keypair.cert
+      #@dest.setPadding @keypair.padding
+    end
+
+    def base64
+      @dest.toBase64
+    end
+
+    def base32
+      @dest.toBase32
+    end
+
+    def raw
+      @dest
+    end
+
+  end
+end

data/lib/ji2p/control/keypair.rb

@@ -0,0 +1,176 @@
+require 'java'
+require 'thread'
+require File.expand_path('dest.rb', __dir__)
+
+module Ji2p::Control
+  java_import 'net.i2p.crypto.SigType'
+  java_import 'net.i2p.crypto.EncType'
+  java_import 'net.i2p.I2PAppContext'
+  java_import 'net.i2p.data.SigningPublicKey'
+  java_import 'net.i2p.data.SigningPrivateKey'
+  java_import 'net.i2p.data.Certificate'
+  java_import 'net.i2p.data.KeyCertificate'
+  java_import 'net.i2p.data.PublicKey'
+  java_import 'net.i2p.data.PrivateKey'
+  java_import 'net.i2p.data.Destination'
+  java_import 'net.i2p.crypto.KeyGenerator'
+  java_import 'net.i2p.client.I2PClientFactory'
+  java_import 'java.util.Properties'
+  java_import 'java.lang.Thread'
+
+  DEFAULT_SIG_TYPE = Java::NetI2pCrypto::SigType::EdDSA_SHA512_Ed25519 unless defined? DEFAULT_SIG_TYPE
+  DEFAULT_ENC_TYPE = Java::NetI2pCrypto::EncType::ELGAMAL_2048 unless defined? DEFAULT_ENC_TYPE
+
+  VALID_ENC_TYPES = Java::NetI2pCrypto::EncType.constants.map { |c| c.to_s }.freeze unless defined? VALID_ENC_TYPES
+  VALID_SIG_TYPES = Java::NetI2pCrypto::SigType.constants.map { |c| c.to_s }.freeze unless defined? VALID_SIG_TYPES
+
+  module KeyGen
+    def self.genPKIkeys
+      KeyGenerator.getInstance.generatePKIKeypair
+    end
+
+    def self.genSigningKeys(arg=nil)
+      unless arg.nil?
+        KeyGenerator.getInstance.generateSigningKeys arg
+      else
+        KeyGenerator.getInstance.generateSigningKeys
+      end
+    end
+  end
+
+  class Keypair
+    attr_accessor :dest, :cert, :pub, :spub, :priv, :spriv
+
+    def self.generate! sig=DEFAULT_SIG_TYPE
+      ost = StringIO.new
+      c = I2PClientFactory.createClient
+      c.createDestination(ost.to_outputstream, sig)
+      keystream = StringIO.new ost.string
+      load_from_stream! keystream
+    end
+
+    def self.load_from_stream! keystream
+      c = I2PClientFactory.createClient
+      s = c.createSession(keystream.to_inputstream, Java::JavaUtil::Properties.new)
+      pub = s.myDestination.getPublicKey
+      spub = s.myDestination.getSigningPublicKey
+      priv = s.decryptionKey
+      spriv = s.privateKey
+      # This will be equal to the content of a
+      # net.i2p.data.PrivateKeyFile
+      cert = s.myDestination.getCertificate
+      new cert,pub,priv,spub,spriv,keystream.string
+    end
+
+    def initialize cert,pub,priv,spub,spriv,data
+      @cert = cert
+      @pub = pub
+      @priv = priv
+      @spub = spub
+      @spriv = spriv
+      @data = data
+      @dest = Ji2p::Control::Dest.new
+      @dest.setKeypair self
+    end
+
+    def inputstream
+      stream = StringIO.new @data
+      stream.to_inputstream
+    end
+
+    def destination
+      @dest
+    end
+
+    def createSession opts=Java::JavaUtil::Properties.new
+      c = I2PClientFactory.createClient
+      @session = c.createSession(inputstream, opts)
+      @session
+    end
+
+    def private_key_format
+      @data
+    end
+
+    def padding_size
+      ((Java::NetI2pData::SigningPublicKey::KEYSIZE_BYTES - @spub.length)
+        + (Java::NetI2pData::PublicKey::KEYSIZE_BYTES - @pub.length))
+    end
+
+    def padding
+      SecureRandom.random_bytes(padding_size).to_java_bytes
+    end
+
+    def write_file f
+      f = File.open(f, 'wb') unless f.is_a? File
+      f.write(@data)
+      f.close
+    end
+
+    module Old
+      def self.old_generate! sig=DEFAULT_SIG_TYPE, enc=DEFAULT_ENC_TYPE
+        if sig.is_a? String
+          unless VALID_SIG_TYPES.include? sig
+            raise ArgumentError, 'Unknown signature type', caller
+          end
+          sig = Java::NetI2pCrypto::SigType.const_get sig
+        end
+        if enc.is_a? String
+          unless VALID_ENC_TYPES.include? enc
+            raise ArgumentError, 'Unknown encryption type', caller
+          end
+          enc = Java::NetI2pCrypto::EncType.const_get enc
+        end
+        ctx = I2PAppContext.getGlobalContext
+        enckp = ctx.keyGenerator.generatePKIKeys enc
+        pub = enckp.getPublic.to_java(Java::NetI2pData::PublicKey)
+        priv = enckp.getPrivate.to_java(Java::NetI2pData::PrivateKey)
+        if (sig != Java::NetI2pCrypto::SigType::DSA_SHA1) or (enc != Java::NetI2pCrypto::EncType::ELGAMAL_2048)
+          unless sig.getPubkeyLen > 128
+            cert = Java::NetI2pData::KeyCertificate.new sig,enc
+          else
+            raise ArgumentError, 'Wrong combination of enc/sig keys', caller
+          end
+        else
+          cert = Java::NetI2pData::Certificate::NULL_CERT
+        end
+        signingkp = ctx.keyGenerator.generateSigningKeys sig.to_java
+        #signingkp = KeyGen.genSigningKeys sig
+        spub = signingkp[0].to_java(Java::NetI2pData::SigningPublicKey)
+        spriv = signingkp[1].to_java(Java::NetI2pData::SigningPrivateKey)
+        #cert.calculateHash
+        data = old_getPrivateKeyFileFormat cert,pub,priv,spub,spriv
+        new cert,pub,priv,spub,spriv,data
+      end
+
+      def self.old_getPrivateKeyFileFormat cert,pub,priv,spub,spriv
+        out = StringIO.new
+        outs = out.to_outputstream
+        pub.writeBytes outs
+        padding_size = ((Java::NetI2pData::SigningPublicKey::KEYSIZE_BYTES - spub.length)
+                        + (Java::NetI2pData::PublicKey::KEYSIZE_BYTES - pub.length))
+        if padding_size > 0
+          outs.write SecureRandom.random_bytes(padding_size).to_java_bytes
+        end
+        spub.writeBytes outs
+        cert.writeBytes outs
+        priv.writeBytes outs
+        spriv.writeBytes outs
+        outs.flush
+        outs.close
+        StringIO.new out.string
+      end
+
+      def self.old_load_from_obj! obj
+        pub   = Java::NetI2pData::PublicKey.new obj[:enc_type],obj[:public_key].to_java_bytes
+        priv  = Java::NetI2pData::PrivateKey.new obj[:enc_type],obj[:private_key].to_java_bytes
+        spub  = Java::NetI2pData::SigningPublicKey.new obj[:sig_type],obj[:signing_public_key].to_java_bytes
+        spriv = Java::NetI2pData::SigningPrivateKey.new obj[:sig_type],obj[:signing_private_key].to_java_bytes
+        cert  = Java::NetI2pData::KeyCertificate.new spub,pub
+        data = old_getPrivateKeyFileFormat cert,pub,priv,spub,spriv
+        new cert,pub,priv,spub,spriv,data
+      end
+    end
+
+  end
+end

data/lib/ji2p/control/server.rb

@@ -0,0 +1,80 @@
+require 'java'
+require 'thread'
+
+module Ji2p::Control
+
+  class ServerConnection
+    def initialize i2pconn
+      @i2pconn = i2pconn
+    end
+
+    def raw
+      @i2pconn
+    end
+
+    def close
+      @i2pconn.close
+    end
+
+    def is_closed?
+      @i2pconn.is_closed
+    end
+
+    def write data
+      @i2pconn.getOutputStream.write data.to_java_bytes
+    end
+
+    def getPeerDestination
+      @i2pconn.getPeerDestination
+    end
+
+    def readstring n=nil
+      String.from_java_bytes readbytes(n || readybytes)
+    end
+
+    def readline
+      line = ""
+      loop {
+        c = String.from_java_bytes(readbytes(1))
+        break if c=="\n"
+        line += c
+      }
+      line + "\n"
+    end
+
+    def readbytes n=nil
+      return nil if is_closed?
+      num = n || readybytes
+      @i2pconn.getInputStream.readNBytes num
+    end
+
+    def readybytes
+      @i2pconn.getInputStream.totalReadySize
+    end
+
+    alias :read :readstring
+    alias :gets :readline
+    alias :puts :write
+
+    def toString
+      b32 = @i2pconn.getPeerDestination.toBase32
+      "<ServerConnection client=#{b32} is_closed=#{@i2pconn.is_closed}>"
+    end
+  end
+
+  class SocketServer
+
+    def initialize i2psocket
+      @i2psocket = i2psocket
+    end
+
+    def accept
+      ServerConnection.new @i2psocket.accept
+    end
+
+    def raw
+      @i2psocket
+    end
+  end
+
+end