terminalwire 0.1.12 → 0.1.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ffa1e8b55e7c09d41b9a57fc645e950e65f6658767022cf67cac994823fb760
-  data.tar.gz: 32fb995746b753eeed71543b954aa2376c2af4b1e61721b14eac8704c9f555f6
+  metadata.gz: 75d01d183f7babe341773fad359c35f4ea478430792a2f292f3e1bce52b6b0ec
+  data.tar.gz: 4634c87d3d66e1553d7ae6ddf6198b9a5da72c1a9a2eb597e9bb1c9556effe8b
 SHA512:
-  metadata.gz: cb3ca0210a84eb64c924522d4eeb04f75a59bf8d785581a232216c8c417ecc837a66001947449e4da91127ebe942c12bce6ea07f8de1be2fe1fc69e5dcfdc332
-  data.tar.gz: e9e0ea45f77040fc503acf2c09f22671d2a09f26315cad69ce1de8e62d4d0578b96663db13414446b7e99ce4abd3dd792ccb6b9191462ae6f67ff8789750856a
+  metadata.gz: c0588f7064884a7e76b111aee494dd6ee0d694766afac82cf7aee8c420fd5b9b108991ecee6e57f5800fb54752e580ed240129aa2085b2f6134ac85478845ebe
+  data.tar.gz: afb0912cdc926020e32a6976562dfe59ff66365a90c17b3b3a35cf45ccd408a41182ba69403b07f10fdcd7538e7bc120379c58fc10f8fc64cca5576980e8b470

data/LICENSE.txt

@@ -2,7 +2,7 @@ Copyright (c) 2024 Brad Gessler.
 
 License is propietary. Here's the deal:
 
-* You need to pay for Terminalwire if your business has more than $1m in assets or makes more than $100k/year in revenue.
+* You need to pay for Terminalwire if your organization has more than $1m in assets or makes more than $100k/year in revenue.
 * Terminalwire is free for personal use, hobbyists, or businesses that are just starting out, but server licenses still need to be registered at https://terminalwire.com/developers/licenses.
 * You can only use the Terminalwire client with licensed Terminalwire servers.
 

data/lib/terminalwire/client.rb

@@ -28,13 +28,15 @@ module Terminalwire
       end
 
       def connect
-        @adapter.write(event: "initialization",
-         protocol: { version: VERSION },
-         entitlement: @entitlement.serialize,
-         program: {
-           name: @program_name,
-           arguments: @program_arguments
-         })
+        @adapter.write(
+          event: "initialization",
+          protocol: { version: VERSION },
+          entitlement: @entitlement.serialize,
+          program: {
+            name: @program_name,
+            arguments: @program_arguments
+          }
+        )
 
         loop do
           handle @adapter.read
@@ -51,20 +53,6 @@ module Terminalwire
       end
     end
 
-    def self.tcp(...)
-      socket = TCPSocket.new(...)
-      transport = Terminalwire::Transport::Socket.new(socket)
-      adapter = Terminalwire::Adapter::Socket.new(transport)
-      Terminalwire::Client::Handler.new(adapter)
-    end
-
-    def self.socket(...)
-      socket = UNIXSocket.new(...)
-      transport = Terminalwire::Transport::Socket.new(socket)
-      adapter = Terminalwire::Adapter::Socket.new(transport)
-      Terminalwire::Client::Handler.new(adapter)
-    end
-
     # Extracted from HTTP. This is so we can
     def self.authority(url)
       if url.port == url.default_port

data/lib/terminalwire/licensing.rb

@@ -0,0 +1,187 @@
+require "msgpack"
+require "openssl"
+require "base64"
+require "uri"
+
+module Terminalwire::Licensing
+  PRIVATE_KEY_LENGTH = 2048
+
+  def self.generate_private_key
+    OpenSSL::PKey::RSA.new(PRIVATE_KEY_LENGTH)
+  end
+
+  def self.generate_private_pem
+    generate_private_key.to_pem
+  end
+
+  def self.time
+    Time.now.utc
+  end
+
+  # Handles encoding data into a license key with prefixes that can be packed and unpacked.
+  module Key
+    # Mix into classes that need to generate or read keys
+    module Serialization
+      # This is called when the module is included in a class
+      def self.included(base)
+        # Extend the class with the class methods when the module is included
+        base.extend(ClassMethods)
+      end
+
+      def serialize(...)
+        self.class.serialize(...)
+      end
+
+      # Define the class methods that will be available on the including class
+      module ClassMethods
+        def serializer
+          Key::Serializer.new(prefix: self::PREFIX)
+        end
+
+        def serialize(...)
+          serializer.serialize(...)
+        end
+
+        def deserialize(...)
+          serializer.deserialize(...)
+        end
+      end
+    end
+
+    class Serializer
+      attr_reader :prefix
+
+      def initialize(prefix:)
+        @prefix = prefix
+      end
+
+      def serialize(data)
+        prepend_prefix Base64.urlsafe_encode64 MessagePack.pack data
+      end
+
+      def deserialize(data)
+        MessagePack.unpack Base64.urlsafe_decode64 unshift_prefix data
+      end
+
+      protected
+
+      def prepend_prefix(key)
+        [prefix, key].join
+      end
+
+      def unshift_prefix(key)
+        head, prefix, tail = key.partition(@prefix)
+        # Check if partition successfully split the string with the correct prefix
+        raise RuntimeError, "Expected prefix #{@prefix.inspect} on #{key.inspect}" if prefix.empty?
+        tail
+      end
+    end
+  end
+
+  # This code all runs on Terminalwire servers.
+  module Issuer
+    # Generates license keys that developers use to activate their software.
+    class ServerKeyGenerator
+      include Key::Serialization
+
+      PREFIX = "server_key_".freeze
+
+      VERSION = "1.0".freeze
+
+      def initialize(public_key:, license_url:, generated_at: Terminalwire::Licensing.time)
+        @public_key = public_key
+        @license_url = URI(license_url)
+        @generated_at = generated_at
+      end
+
+      def to_h
+        {
+          version: VERSION,
+          generated_at: @generated_at.iso8601,
+          public_key: @public_key.to_pem,
+          license_url: @license_url.to_s
+        }
+      end
+
+      def server_key
+        serialize to_h
+      end
+      alias :to_s :server_key
+    end
+
+    class ClientKeyVerifier
+      # Time variance the server will tolerate from the client.
+      DRIFT_SECONDS = 600 # 600 seconds, or 10 minutes.
+
+      # This means the server will tolerate a 10 minute drift in the generated_at time.
+      def self.drift
+        now = Terminalwire::Licensing.time
+        (now - DRIFT_SECONDS)...(now + DRIFT_SECONDS)
+      end
+
+      def initialize(client_key:, private_key:, drift: self.class.drift)
+        @data = Server::ClientKeyGenerator.deserialize client_key
+        @private_key = private_key
+        @drift = drift
+      end
+
+      def server_attestation
+        @server_attestation ||= decrypt @data.fetch("server_attestation")
+      end
+
+      def decrypt(data)
+        MessagePack.unpack @private_key.private_decrypt Base64.urlsafe_decode64 data
+      end
+
+      def generated_at
+        @generated_at ||= Time.parse(server_attestation.fetch("generated_at"))
+      end
+
+      def valid?
+        @drift.include? generated_at
+      end
+    end
+  end
+
+  # Those code runs on customer servers
+  module Server
+    class ClientKeyGenerator
+      VERSION = "1.0".freeze
+
+      include Key::Serialization
+      PREFIX = "client_key_".freeze
+
+      def initialize(server_key:, generated_at: Terminalwire::Licensing.time)
+        @data = Issuer::ServerKeyGenerator.deserialize server_key
+        @license_url = URI(@data.fetch("license_url"))
+        @generated_at = generated_at
+      end
+
+      def to_h
+        {
+          version: VERSION,
+          license_url: @license_url.to_s,
+          server_attestation: attest(
+            version: VERSION,
+            generated_at: @generated_at.iso8601,
+          )
+        }
+      end
+
+      def client_key
+        serialize to_h
+      end
+      alias :to_s :client_key
+
+      protected
+
+      def attest(data)
+        Base64.urlsafe_encode64 public_key.public_encrypt MessagePack.pack data
+      end
+
+      def public_key
+        @public_key ||= OpenSSL::PKey::RSA.new(@data.fetch("public_key"))
+      end
+    end
+  end
+end

data/lib/terminalwire/logging.rb

@@ -2,7 +2,7 @@ require 'logger'
 
 module Terminalwire
   module Logging
-    DEVICE = Logger.new($stdout, level: ENV.fetch("LOG_LEVEL", "info"))
+    DEVICE = Logger.new($stdout, level: ENV.fetch("TERMINALWIRE_LOG_LEVEL", "info"))
     def logger = DEVICE
   end
 end

data/lib/terminalwire/server.rb

@@ -2,57 +2,16 @@ require "thor"
 
 module Terminalwire
   module Server
-    class MyCLI < ::Thor
-      include Terminalwire::Thor
-
-      desc "greet NAME", "Greet a person"
-      def greet(name)
-        name = ask "What's your name?"
-        say "Hello, #{name}!"
-      end
-    end
-
-    class Socket
-      include Logging
-
-      def initialize(server_socket)
-        @server_socket = server_socket
-      end
-
-      def listen
-        logger.info "Socket: Listening..."
-        loop do
-          client_socket = @server_socket.accept
-          logger.debug "Socket: Client #{client_socket.inspect} connected"
-          handle_client(client_socket)
-        end
-      end
-
-      private
-
-      def handle_client(socket)
-        transport = Transport::Socket.new(socket)
-        adapter = Adapter.new(transport)
-
-        Thread.new do
-          handler = Handler.new(adapter)
-          handler.run
-        end
-      end
-    end
-
     class WebSocket
       include Logging
 
       def call(env)
         Async::WebSocket::Adapters::Rack.open(env, protocols: ['ws']) do |connection|
-          run(Adapter::Socket.new(Terminalwire::Transport::WebSocket.new(connection)))
+          handle(Adapter::Socket.new(Terminalwire::Transport::WebSocket.new(connection)))
         end or [200, { "Content-Type" => "text/plain" }, ["Connect via WebSockets"]]
       end
 
-      private
-
-      def run(adapter)
+      def handle(adapter)
         while message = adapter.read
           puts message
         end
@@ -76,7 +35,7 @@ module Terminalwire
         "An error occurred. Please try again."
       end
 
-      def run(adapter)
+      def handle(adapter)
         logger.info "ThorServer: Running #{@cli_class.inspect}"
         while message = adapter.read
           case message
@@ -100,38 +59,5 @@ module Terminalwire
         end
       end
     end
-
-    class Handler
-      include Logging
-
-      def initialize(adapter)
-        @adapter = adapter
-      end
-
-      def run
-        logger.info "Server Handler: Running"
-        loop do
-          message = @adapter.read
-          case message
-          in { event: "initialization", protocol:, program: { arguments: }, entitlement: }
-            Context.new(adapter: @adapter) do |context|
-              MyCLI.start(arguments, context:)
-            end
-          end
-        end
-      rescue EOFError, Errno::ECONNRESET
-        logger.info "Server Handler: Client disconnected"
-      ensure
-        @adapter.close
-      end
-    end
-
-    def self.tcp(...)
-      Server::Socket.new(TCPServer.new(...))
-    end
-
-    def self.socket(...)
-      Server::Socket.new(UNIXServer.new(...))
-    end
   end
 end

data/lib/terminalwire/transport.rb

@@ -1,5 +1,4 @@
 require 'uri'
-require 'socket'
 require 'async/websocket/client'
 
 module Terminalwire
@@ -26,70 +25,6 @@ module Terminalwire
       end
     end
 
-    class TCP < Base
-      def self.connect(url)
-        uri = URI(url)
-        new(TCPSocket.new(uri.host, uri.port))
-      end
-
-      def self.listen(url)
-        uri = URI(url)
-        new(TCPServer.new(uri.host, uri.port))
-      end
-
-      def initialize(socket)
-        @socket = socket
-      end
-
-      def read
-        length = @socket.read(4)
-        return nil if length.nil?
-        length = length.unpack('L>')[0]
-        @socket.read(length)
-      end
-
-      def write(data)
-        length = [data.bytesize].pack('L>')
-        @socket.write(length + data)
-      end
-
-      def close
-        @socket.close
-      end
-    end
-
-    class Unix < Base
-      def self.connect(url)
-        uri = URI(url)
-        new(UNIXSocket.new(uri.path))
-      end
-
-      def self.listen(url)
-        uri = URI(url)
-        new(UNIXServer.new(uri.path))
-      end
-
-      def initialize(socket)
-        @socket = socket
-      end
-
-      def read
-        length = @socket.read(4)
-        return nil if length.nil?
-        length = length.unpack('L>')[0]
-        @socket.read(length)
-      end
-
-      def write(data)
-        length = [data.bytesize].pack('L>')
-        @socket.write(length + data)
-      end
-
-      def close
-        @socket.close
-      end
-    end
-
     class WebSocket < Base
       def self.connect(url)
         uri = URI(url)

data/lib/terminalwire/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Terminalwire
-  VERSION = "0.1.12"
+  VERSION = "0.1.14"
 end

data/lib/terminalwire.rb

@@ -2,7 +2,6 @@
 
 require_relative "terminalwire/version"
 
-require 'socket'
 require 'forwardable'
 require 'uri'
 require 'zeitwerk'
@@ -40,10 +39,6 @@ module Terminalwire
         respond(status: "success", response:, **data)
       end
 
-      def self.protocol_key
-        name.split("::").last.downcase
-      end
-
       private
 
       def respond(**response)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: terminalwire
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.14
 platform: ruby
 authors:
 - Brad Gessler
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-14 00:00:00.000000000 Z
+date: 2024-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-websocket
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.25'
+        version: '0.30'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.25'
+        version: '0.30'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -165,6 +165,7 @@ files:
 - lib/terminalwire/client/entitlement.rb
 - lib/terminalwire/client/exec.rb
 - lib/terminalwire/client/resource.rb
+- lib/terminalwire/licensing.rb
 - lib/terminalwire/logging.rb
 - lib/terminalwire/rails.rb
 - lib/terminalwire/server.rb