ji2p 0.0.1-jruby

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a76e69bb6162a5892246ae3d5561a43c256a9a9195631519c18a96359ee21ab5
+  data.tar.gz: d4b84142f919db7da78742ad5c9879a2bc21288d534a944c736daab293dd325e
+SHA512:
+  metadata.gz: ea76df63c6be7214beda44ab6f88c9408b1f4077d880b2232f77268024f2b9ac665d71ad8f23c2e9ef2c245f2fcb8a345c5abb8d14ca513b023b3e319ce709a4
+  data.tar.gz: 371982f7bded249a77101c3d9655e005ec81d5d525217c536d3a0ec10056f4dba6c6fb8b4f69f8c9024d0ecb55b252fb73c7a4188bd8298a6aef4d67e700f0ea

data/bin/ctxirb

@@ -0,0 +1,114 @@
+#!/usr/bin/env jruby
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+require 'bundler/setup'
+lib = File.expand_path("../lib", __dir__)
+$:.unshift(lib) unless $LOAD_PATH.include?(lib)
+puts $:
+
+require 'irb'
+require 'irb/completion'
+require 'irb/ext/save-history'
+
+# Method to pretty-print object methods
+# Coded by sebastian delmont
+# http://snippets.dzone.com/posts/show/2916
+class Object
+  ANSI_BOLD       = "\033[1m"
+  ANSI_RESET      = "\033[0m"
+  ANSI_LGRAY    = "\033[0;37m"
+  ANSI_GRAY     = "\033[1;30m"
+  # Print object's methods
+  def pm(*options)
+    methods = self.methods
+    methods -= Object.methods unless options.include? :more
+    filter = options.select {|opt| opt.kind_of? Regexp}.first
+    methods = methods.select {|name| name =~ filter} if filter
+
+    data = methods.sort.collect do |name|
+      method = self.method(name)
+      if method.arity == 0
+        args = "()"
+      elsif method.arity > 0
+        n = method.arity
+        args = "(#{(1..n).collect {|i| "arg#{i}"}.join(", ")})"
+      elsif method.arity < 0
+        n = -method.arity
+        args = "(#{(1..n).collect {|i| "arg#{i}"}.join(", ")}, ...)"
+      end
+      klass = $1 if method.inspect =~ /Method: (.*?)#/
+        [name, args, klass]
+    end
+    max_name = data.collect {|item| item[0].size}.max
+    max_args = data.collect {|item| item[1].size}.max
+    data.each do |item|
+      print " #{ANSI_BOLD}#{item[0].to_s.rjust(max_name)}#{ANSI_RESET}"
+      print "#{ANSI_GRAY}#{item[1].ljust(max_args)}#{ANSI_RESET}"
+      print "   #{ANSI_LGRAY}#{item[2]}#{ANSI_RESET}\n"
+    end
+    data.size
+  end
+end
+
+module IRB # :nodoc:
+  def self.start_session(binding)
+    unless @__initialized
+      args = ARGV
+      ARGV.replace(ARGV.dup)
+      IRB.setup(nil)
+      ARGV.replace(args)
+      @__initialized = true
+    end
+
+    workspace = WorkSpace.new(binding)
+
+    irb = Irb.new(workspace)
+
+    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+    @CONF[:MAIN_CONTEXT] = irb.context
+    @CONF[:SAVE_HISTORY] = 10000
+    @CONF[:HISTORY_FILE] = File.join(ENV['PWD'], '.irb-history')
+    @CONF[:BACK_TRACE_LIMIT] = 16
+    @CONF[:USE_READLINE] = true
+    @CONF[:AUTO_INDENT] = true
+    histfile = @CONF[:HISTORY_FILE]
+
+    #puts @CONF
+    maxsize = @CONF[:SAVE_HISTORY]
+
+    if File::exists?(histfile)
+      lines = IO::readlines(histfile).collect { |line| line.chomp }
+      puts "Read #{lines.nitems} saved history commands from '#{histfile}'." if $VERBOSE
+      Readline::HISTORY.push(*lines)
+    end
+
+    Kernel::at_exit do
+      lines = Readline::HISTORY.to_a.reverse.uniq.reverse
+      lines = lines[-maxsize, maxsize] if lines.length > maxsize
+      puts "Saving #{lines.length} history lines to '#{histfile}'."
+      File::open(histfile, File::WRONLY|File::CREAT|File::TRUNC) { |io| io.puts lines.join("\n") }
+    end
+
+    catch(:IRB_EXIT) do
+      irb.eval_input
+    end
+  end
+end
+
+require 'ji2p'
+
+def reload!(print = true)
+  puts 'Reloading ...' if print
+  # Main project directory.
+  root_dir = File.expand_path('..', __dir__)
+  # Directories within the project that should be reloaded.
+  reload_dirs = %w{lib}
+  # Loop through and reload every file in all relevant project directories.
+  reload_dirs.each do |dir|
+    Dir.glob("#{root_dir}/#{dir}/**/*.rb").each { |f| load(f) }
+  end
+  # Return true when complete.
+  true
+end
+
+IRB.start_session(binding)
+

data/bin/simple_http_server

@@ -0,0 +1,20 @@
+#!/usr/bin/env jruby
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+require 'bundler/setup'
+lib = File.expand_path("../lib", __dir__)
+$:.unshift(lib) unless $LOAD_PATH.include?(lib)
+#puts $:
+
+require 'ji2p'
+
+app = Proc.new { |env| ['200', {'Content-Type' => 'text/html'}, ['get rack\'d']] }
+
+kp = Ji2p::Control::Keypair.generate!
+ssmgr = Ji2p::Control::SocketManager.defineManager! "testing", kp
+ssmgr.connectTunnel
+socket = ssmgr.getServerSocket
+server = Ji2p::Server::HttpServer.new(app, socket)
+
+puts "Your destination: #{kp.dest.base32}"
+
+server.run

data/bin/simple_outproxy

@@ -0,0 +1,96 @@
+#!/usr/bin/env jruby
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+require 'bundler/setup'
+lib = File.expand_path("../lib", __dir__)
+$:.unshift(lib) unless $LOAD_PATH.include?(lib)
+#puts $:
+
+require 'socket'
+require 'uri'
+require 'ji2p'
+
+class Proxy
+  def run socket
+    begin
+      @socket = socket
+
+      # Handle every request in another thread
+      loop do
+        s = @socket.accept
+        Thread.new s, &method(:handle_request)
+      end
+
+    # CTRL-C
+    rescue Interrupt
+      puts 'Got Interrupt..'
+    # Ensure that we release the socket on errors
+    ensure
+      if @socket
+        @socket.close
+        puts 'Socked closed..'
+      end
+      puts 'Quitting.'
+    end
+  end
+
+  def handle_request to_client
+    request_line = to_client.readline
+
+    verb    = request_line[/^\w+/]
+    url     = request_line[/^\w+\s+(\S+)/, 1]
+    version = request_line[/HTTP\/(1\.\d)\s*$/, 1]
+    uri     = URI::parse url
+
+    # Show what got requested
+    puts((" %4s "%verb) + url)
+
+    to_server = TCPSocket.new(uri.host, (uri.port.nil? ? 80 : uri.port))
+    to_server.write("#{verb} #{uri.path}?#{uri.query} HTTP/#{version}\r\n")
+
+    content_len = 0
+
+    loop do
+      line = to_client.readline
+
+      if line =~ /^Content-Length:\s+(\d+)\s*$/
+        content_len = $1.to_i
+      end
+
+      # Strip proxy headers
+      if line =~ /^proxy/i
+        next
+      elsif line.strip.empty?
+        to_server.write("Connection: close\r\n\r\n")
+
+        if content_len >= 0
+          to_server.write(to_client.read(content_len))
+        end
+
+        break
+      else
+        to_server.write(line)
+      end
+    end
+
+    buff = ""
+    loop do
+      to_server.read(4048, buff)
+      to_client.write(buff)
+      break if buff.size < 4048
+    end
+
+    # Close the sockets
+    to_client.close
+    to_server.close
+  end
+
+end
+
+
+kp = Ji2p::Control::Keypair.generate!
+ssmgr = Ji2p::Control::SocketManager.defineManager! "testing", kp
+ssmgr.connectTunnel
+socket = ssmgr.getServerSocket
+puts "Your destination: #{kp.dest.base32}"
+
+Proxy.new.run socket

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/etcd.rb

@@ -0,0 +1,5 @@
+module Ji2p::Cluster
+  module Etcd
+    autoload :Version3, File.expand_path('etcd/version3.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/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.rb

@@ -0,0 +1,6 @@
+module Ji2p
+  module Cluster
+    autoload :Etcd, File.expand_path('cluster/etcd.rb', __dir__)
+    autoload :Kubernetes, File.expand_path('cluster/kubernetes.rb', __dir__)
+  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

data/lib/ji2p/control/socket_manager.rb

@@ -0,0 +1,74 @@
+require 'java'
+require 'thread'
+require_relative 'server.rb'
+
+module Ji2p::Control
+  java_import 'net.i2p.I2PAppContext'
+  java_import 'net.i2p.client.I2PClientFactory'
+  java_import 'net.i2p.client.streaming.I2PSocketManager'
+  java_import 'net.i2p.client.streaming.I2PSocketManagerFactory'
+  java_import 'net.i2p.client.streaming.impl.I2PSocketManagerFull'
+  java_import 'net.i2p.client.streaming.IncomingConnectionFilter'
+  java_import 'java.util.Properties'
+  java_import 'java.lang.Thread'
+
+  class SocketManager
+
+    def self.defineManager! name, kp, opts=Java::JavaUtil::Properties.new, filter=IncomingConnectionFilter::ALLOW
+      ctx = I2PAppContext.getGlobalContext
+      session = kp.createSession opts
+      new Java::NetI2pClientStreamingImpl::I2PSocketManagerFull.new(ctx,session,opts,name,filter)
+    end
+
+    def connectTunnel
+      @smgr.getSession.connect
+    end
+
+    def myDestination
+      @smgr.getSession.myDestination
+    end
+
+    def leaseSet
+      @smgr.getSession.leaseSet
+    end
+
+    def sessionId
+      @smgr.getSession.sessionId
+    end
+
+    def supports_ls2?
+      @smgr.getSession.supports_ls2?
+    end
+
+    def is_closed?
+      @smgr.getSession.closed?
+    end
+
+    def session
+      @smgr.session
+    end
+
+    def destroy
+      @smgr.getSession.destroySession
+    end
+
+    def lookupDest dest
+      @smgr.getSession.lookupDest dest
+    end
+
+    def getServerSocket
+      SocketServer.new @smgr.getServerSocket
+    end
+
+    def raw
+      @smgr
+    end
+
+    private
+
+    def initialize smgr
+      @smgr = smgr
+    end
+
+  end
+end

data/lib/ji2p/control/tunnel_ctrl.rb

@@ -0,0 +1,48 @@
+require 'java'
+require 'base64'
+
+module Ji2p::Control
+  class TunnelCtrl
+    def initialize obj, conf
+      @tunnel = obj
+      @conf = conf
+    end
+
+    def start!
+      @tunnel.startTunnelBackground
+    end
+
+    def stop!
+      @tunnel.stopTunnel
+    end
+
+    def base32
+      @tunnel.myDestHashBase32
+    end
+
+    def base64
+      @tunnel.myDestination
+    end
+
+    def destination
+      @tunnel.myDestination
+    end
+
+    def raw
+      @tunnel
+    end
+
+    def raw_conf
+      @conf
+    end
+
+    def privateKey base64_armored = true
+      d = I2PAppContext.getGlobalContext.getRouterDir.to_s
+      filename = File.join d, @conf['privKeyFile']
+      f = File.open filename, 'rb'
+      data = f.read
+      data = Base64.encode64(data) if base64_armored
+      data
+    end
+  end
+end