pwn 0.5.627 → 0.5.628

data/lib/pwn/ffi/liquid.rb

@@ -65,6 +65,36 @@ module PWN
         attach_function :firfilt_rrrf_execute_block,
                         %i[pointer pointer uint pointer],
                         :int
+
+        # ── msresamp_crcf (complex arbitrary resampler) ───────────────
+        attach_function :msresamp_crcf_create, %i[float float], :pointer
+        attach_function :msresamp_crcf_destroy, [:pointer], :int
+        attach_function :msresamp_crcf_execute,
+                        %i[pointer pointer uint pointer pointer],
+                        :int
+
+        # ── nco_crcf (numerically-controlled oscillator / mixer) ──────
+        LIQUID_NCO = 0
+        LIQUID_VCO = 1
+        attach_function :nco_crcf_create, [:int], :pointer
+        attach_function :nco_crcf_destroy, [:pointer], :int
+        attach_function :nco_crcf_set_frequency, %i[pointer float], :int
+        attach_function :nco_crcf_mix_block_down,
+                        %i[pointer pointer pointer uint],
+                        :int
+
+        # ── gmskdem (GMSK demodulator: k samp/sym → bit) ──────────────
+        attach_function :gmskdem_create, %i[uint uint float], :pointer
+        attach_function :gmskdem_destroy, [:pointer], :int
+        attach_function :gmskdem_reset, [:pointer], :int
+        attach_function :gmskdem_demodulate,
+                        %i[pointer pointer pointer],
+                        :int
+
+        # ── fskdem (M-FSK demodulator: k samp/sym → symbol) ───────────
+        attach_function :fskdem_create, %i[uint uint float uint], :pointer
+        attach_function :fskdem_destroy, [:pointer], :int
+        attach_function :fskdem_demodulate, %i[pointer pointer], :uint
       end
 
       # Supported Method Parameters::
@@ -210,6 +240,151 @@ module PWN
         end
       end
 
+      # Supported Method Parameters::
+      # out = PWN::FFI::Liquid.resample_iq(
+      #   iq:    'required - interleaved I/Q Array<Float>',
+      #   rate:  'required - output/input ratio (>0)',
+      #   as_db: 'optional - stop-band attenuation dB (default 60.0)'
+      # )
+      # Returns interleaved Array<Float> [I0,Q0,…] resampled by `rate`.
+
+      public_class_method def self.resample_iq(opts = {})
+        raise 'ERROR: libliquid not available' unless available?
+
+        iq    = opts[:iq]
+        rate  = opts[:rate].to_f
+        as_db = (opts[:as_db] || 60.0).to_f
+        n     = iq.length / 2
+        raise 'ERROR: rate must be > 0' unless rate.positive?
+        return iq.dup if n.zero?
+
+        q = msresamp_crcf_create(rate, as_db)
+        raise 'ERROR: msresamp_crcf_create failed' if q.null?
+
+        begin
+          ny_max = [1, (2 + (2 * rate * n)).ceil].max
+          in_ptr = float_ptr(iq.first(n * 2))
+          out_ptr = PubFFI::MemoryPointer.new(:float, ny_max * 2)
+          ny_ptr  = PubFFI::MemoryPointer.new(:uint, 1)
+          rc = msresamp_crcf_execute(q, in_ptr, n, out_ptr, ny_ptr)
+          raise "ERROR: msresamp_crcf_execute rc=#{rc}" unless rc.zero?
+
+          ny = ny_ptr.read_uint
+          out_ptr.read_array_of_float(ny * 2)
+        ensure
+          msresamp_crcf_destroy(q)
+        end
+      end
+
+      # Supported Method Parameters::
+      # out = PWN::FFI::Liquid.mix_down(
+      #   iq:   'required - interleaved I/Q Array<Float>',
+      #   freq: 'required - normalised angular freq (rad/sample, i.e. 2π·f/fs)'
+      # )
+      # Returns interleaved Array<Float> shifted down by `freq`.
+
+      public_class_method def self.mix_down(opts = {})
+        raise 'ERROR: libliquid not available' unless available?
+
+        iq   = opts[:iq]
+        freq = opts[:freq].to_f
+        n    = iq.length / 2
+        return [] if n.zero?
+
+        q = nco_crcf_create(LIQUID_NCO)
+        raise 'ERROR: nco_crcf_create failed' if q.null?
+
+        begin
+          nco_crcf_set_frequency(q, freq)
+          in_ptr  = float_ptr(iq.first(n * 2))
+          out_ptr = PubFFI::MemoryPointer.new(:float, n * 2)
+          rc = nco_crcf_mix_block_down(q, in_ptr, out_ptr, n)
+          raise "ERROR: nco_crcf_mix_block_down rc=#{rc}" unless rc.zero?
+
+          out_ptr.read_array_of_float(n * 2)
+        ensure
+          nco_crcf_destroy(q)
+        end
+      end
+
+      # Supported Method Parameters::
+      # bits = PWN::FFI::Liquid.gmsk_demod(
+      #   iq:  'required - interleaved I/Q Array<Float>, length = k·sym·2',
+      #   sps: 'required - samples per symbol (integer ≥ 2)',
+      #   m:   'optional - filter delay (default 3)',
+      #   bt:  'optional - Gaussian BT (default 0.35)'
+      # )
+      # Returns Array<0|1> (one bit per symbol, floor(n/sps) bits).
+
+      public_class_method def self.gmsk_demod(opts = {})
+        raise 'ERROR: libliquid not available' unless available?
+
+        iq  = opts[:iq]
+        k   = opts[:sps].to_i
+        m   = (opts[:m] || 3).to_i
+        bt  = (opts[:bt] || 0.35).to_f
+        raise 'ERROR: sps must be ≥ 2' if k < 2
+
+        n = iq.length / 2
+        nsym = n / k
+        return [] if nsym.zero?
+
+        q = gmskdem_create(k, m, bt)
+        raise 'ERROR: gmskdem_create failed' if q.null?
+
+        begin
+          in_ptr  = float_ptr(iq.first(nsym * k * 2))
+          bit_ptr = PubFFI::MemoryPointer.new(:uint, 1)
+          bits = Array.new(nsym)
+          i = 0
+          while i < nsym
+            gmskdem_demodulate(q, in_ptr + (i * k * 2 * 4), bit_ptr)
+            bits[i] = bit_ptr.read_uint & 1
+            i += 1
+          end
+          bits
+        ensure
+          gmskdem_destroy(q)
+        end
+      end
+
+      # Supported Method Parameters::
+      # syms = PWN::FFI::Liquid.mfsk_demod(
+      #   iq:  'required - interleaved I/Q Array<Float>',
+      #   m:   'required - bits per symbol (1=2FSK, 2=4FSK, …)',
+      #   sps: 'required - samples per symbol (integer ≥ 2^m)',
+      #   bw:  'optional - normalised bandwidth 0..0.5 (default 0.25)'
+      # )
+      # Returns Array<Integer> of demodulated symbols (0..2^m-1).
+
+      public_class_method def self.mfsk_demod(opts = {})
+        raise 'ERROR: libliquid not available' unless available?
+
+        iq  = opts[:iq]
+        mb  = opts[:m].to_i
+        k   = opts[:sps].to_i
+        bw  = (opts[:bw] || 0.25).to_f
+        n   = iq.length / 2
+        nsym = n / k
+        return [] if nsym.zero?
+
+        q = fskdem_create(mb, k, bw, 0)
+        raise 'ERROR: fskdem_create failed' if q.null?
+
+        begin
+          in_ptr = float_ptr(iq.first(nsym * k * 2))
+          syms = Array.new(nsym)
+          i = 0
+          while i < nsym
+            syms[i] = fskdem_demodulate(q, in_ptr + (i * k * 2 * 4))
+            i += 1
+          end
+          syms
+        ensure
+          fskdem_destroy(q)
+        end
+      end
+
       # Author(s):: 0day Inc. <support@0dayinc.com>
 
       public_class_method def self.authors
@@ -225,6 +400,10 @@ module PWN
           #{self}.resample(samples:, rate:, as_db: 60.0)  # arbitrary rate
           #{self}.fir_kaiser(samples:, length: 51, fc: 0.1, as_db: 60.0)
           #{self}.dc_block(samples:, m: 7, as_db: 60.0)
+#{self}.resample_iq(iq:, rate:, as_db: 60.0)     # complex resample
+#{self}.mix_down(iq:, freq:)                     # NCO mix (rad/samp)
+#{self}.gmsk_demod(iq:, sps:, m: 3, bt: 0.35)    # I/Q → bits
+#{self}.mfsk_demod(iq:, m:, sps:, bw: 0.25)      # I/Q → symbols
 
           #{self}.authors
         "

data/lib/pwn/memory.rb

@@ -82,6 +82,20 @@ module PWN
       results.to_a.first(limit).to_h
     end
 
+    # Supported Method Parameters::
+    #   hits = PWN::Memory.recall_semantic(query: 'nmap sweep', limit: 6)
+    #
+    # Relevance-ranked recall via PWN::MemoryIndex (local Ollama embeddings
+    # + cosine over ~/.pwn/memory.idx). Falls back to substring .recall
+    # when no embedding backend is configured.
+    public_class_method def self.recall_semantic(opts = {})
+      return recall(query: opts[:query], limit: opts[:limit]) unless defined?(PWN::MemoryIndex) && PWN::MemoryIndex.available?
+
+      PWN::MemoryIndex.recall_semantic(query: opts[:query], limit: opts[:limit])
+    rescue StandardError
+      recall(query: opts[:query], limit: opts[:limit])
+    end
+
     # Supported Method Parameters::
     #   PWN::Memory.forget(key: :some_key)
     public_class_method def self.forget(opts = {}) # rubocop:disable Naming/PredicateMethod
@@ -127,6 +141,7 @@ module PWN
           mem = PWN::Memory.load
           PWN::Memory.remember(key: :user_prefers_ruby, value: 'Always prefer pure Ruby + RestClient patterns', category: :preference)
           facts = PWN::Memory.recall(query: 'recon', category: :fact, limit: 10)
+          hits  = PWN::Memory.recall_semantic(query: 'recon', limit: 6)  # embedding-ranked
           PWN::Memory.forget(key: :some_key)
           PWN::Memory.clear
           context_str = PWN::Memory.to_context

data/lib/pwn/memory_index.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require 'digest'
+
+module PWN
+  # PWN::MemoryIndex is a lightweight local embedding index over
+  # PWN::Memory (~/.pwn/memory.json) so PromptBuilder can inject the N
+  # MOST-RELEVANT memories for the current request instead of the N
+  # newest. Embeddings come from the local Ollama instance
+  # (PWN::Env[:ai][:ollama][:embed_model], default 'nomic-embed-text') via
+  # its native /api/embed endpoint — everything stays on-box.
+  #
+  # Index layout (~/.pwn/memory.idx):
+  #   { "<key>": { "sha": "<sha16 of value>", "vec": [Float,…] }, … }
+  #
+  # Rebuilds are incremental: only entries whose value-sha changed are
+  # (re)embedded, so a warm index costs one embed call (the query).
+  module MemoryIndex
+    INDEX_FILE = File.join(Dir.home, '.pwn', 'memory.idx')
+    DEFAULT_EMBED_MODEL = 'nomic-embed-text'
+
+    # Supported Method Parameters::
+    #   bool = PWN::MemoryIndex.available?
+    #
+    # True when a local Ollama base_uri is configured. All public methods
+    # degrade to substring recall when this is false.
+
+    public_class_method def self.available?
+      !ollama_base.nil?
+    rescue StandardError
+      false
+    end
+
+    # Supported Method Parameters::
+    #   hits = PWN::MemoryIndex.recall_semantic(
+    #     query: 'required - user request / search text',
+    #     limit: 'optional - top-K by cosine similarity (default 6)'
+    #   )
+    #
+    # Returns [{ key:, value:, category:, timestamp:, score: }, …]
+    # (newest-first Memory.recall shape + :score) or falls back to
+    # PWN::Memory.recall(query:) when embedding is unavailable.
+
+    public_class_method def self.recall_semantic(opts = {})
+      query = opts[:query].to_s
+      limit = (opts[:limit] || 6).to_i
+      mem   = PWN::Memory.load
+      return [] if mem.empty? || query.strip.empty?
+
+      qv = embed(texts: [query]).first
+      return fallback(query: query, limit: limit) unless qv
+
+      idx = refresh(mem: mem)
+      scored = mem.map do |k, v|
+        vec = idx.dig(k, :vec)
+        next unless vec
+
+        { key: k, value: v[:value], category: v[:category], timestamp: v[:timestamp], score: cosine(a: qv, b: vec) }
+      end
+      scored.compact.sort_by { |h| -h[:score] }.first(limit)
+    rescue StandardError
+      fallback(query: query, limit: limit)
+    end
+
+    # Supported Method Parameters::
+    #   ctx = PWN::MemoryIndex.to_context(query:, limit: 6)
+    #
+    # Drop-in replacement for PWN::Memory.to_context that ranks by
+    # relevance to +query+ instead of insertion order. Emitted format is
+    # identical so PromptBuilder needs no special-casing.
+
+    public_class_method def self.to_context(opts = {})
+      hits = recall_semantic(query: opts[:query], limit: opts[:limit] || 6)
+      return PWN::Memory.to_context(limit: opts[:limit] || 6) if hits.empty?
+
+      ctx = "\n\nPERSISTENT MEMORY (relevance-ranked for this request - use PWN::Memory.remember to store new ones):\n"
+      hits.each do |h|
+        ctx += "- #{h[:key]} [#{h[:category]} @ #{h[:timestamp]}]: #{h[:value].to_s[0, 300]}\n"
+      end
+      ctx
+    end
+
+    # Supported Method Parameters::
+    #   idx = PWN::MemoryIndex.refresh(mem: 'optional - preloaded PWN::Memory hash')
+    #
+    # Incrementally (re)embed changed entries and prune deleted keys.
+    # Returns the in-memory index Hash keyed by memory key (Symbol).
+
+    public_class_method def self.refresh(opts = {})
+      mem = opts[:mem] || PWN::Memory.load
+      idx = load_index
+      idx.delete_if { |k, _| !mem.key?(k) }
+
+      todo = mem.reject { |k, v| idx.dig(k, :sha) == sha(text: v[:value].to_s) }
+      unless todo.empty?
+        vecs = embed(texts: todo.values.map { |v| "#{v[:category]}: #{v[:value]}" })
+        todo.keys.each_with_index do |k, i|
+          next unless vecs[i]
+
+          idx[k] = { sha: sha(text: mem[k][:value].to_s), vec: vecs[i] }
+        end
+        save_index(idx: idx)
+      end
+      idx
+    rescue StandardError
+      idx || {}
+    end
+
+    # Supported Method Parameters::
+    #   vecs = PWN::MemoryIndex.embed(texts: ['a', 'b'])
+    #
+    # POST /api/embed on the local Ollama; returns Array<Array<Float>> (one
+    # vector per input, nil on per-item failure). Batches of 32.
+
+    public_class_method def self.embed(opts = {})
+      texts = Array(opts[:texts]).map(&:to_s)
+      base  = ollama_base
+      return Array.new(texts.length) unless base && !texts.empty?
+
+      model = (PWN::Env.dig(:ai, :ollama, :embed_model) if defined?(PWN::Env)) || DEFAULT_EMBED_MODEL
+      browser = PWN::Plugins::TransparentBrowser.open(browser_type: :rest)
+      rest    = browser[:browser]::Request
+      headers = { content_type: 'application/json; charset=UTF-8' }
+      token   = PWN::Env.dig(:ai, :ollama, :key) if defined?(PWN::Env)
+      headers[:authorization] = "Bearer #{token}" if token
+
+      out = []
+      texts.each_slice(32) do |batch|
+        resp = rest.execute(
+          method: :post,
+          url: "#{base}/ollama/api/embed",
+          headers: headers,
+          payload: { model: model, input: batch }.to_json,
+          verify_ssl: false,
+          timeout: 120
+        )
+        j = JSON.parse(resp, symbolize_names: true)
+        out.concat(Array(j[:embeddings]))
+      end
+      out
+    rescue StandardError
+      Array.new(texts.length)
+    end
+
+    # Supported Method Parameters::
+    #   PWN::MemoryIndex.reset
+
+    public_class_method def self.reset
+      FileUtils.rm_f(INDEX_FILE)
+      {}
+    end
+
+    # -----------------------------------------------------------------
+    # privates
+    # -----------------------------------------------------------------
+
+    private_class_method def self.load_index
+      return {} unless File.exist?(INDEX_FILE)
+
+      JSON.parse(File.read(INDEX_FILE), symbolize_names: true)
+    rescue StandardError
+      {}
+    end
+
+    private_class_method def self.save_index(opts = {})
+      FileUtils.mkdir_p(File.dirname(INDEX_FILE))
+      File.write(INDEX_FILE, JSON.generate(opts[:idx] || {}))
+    end
+
+    private_class_method def self.cosine(opts = {})
+      a = opts[:a]
+      b = opts[:b]
+      return 0.0 unless a && b && a.length == b.length
+
+      dot = na = nb = 0.0
+      a.each_with_index do |x, i|
+        y = b[i]
+        dot += x * y
+        na  += x * x
+        nb  += y * y
+      end
+      return 0.0 if na.zero? || nb.zero?
+
+      dot / (Math.sqrt(na) * Math.sqrt(nb))
+    end
+
+    private_class_method def self.sha(opts = {})
+      Digest::SHA256.hexdigest(opts[:text].to_s)[0, 16]
+    end
+
+    private_class_method def self.ollama_base
+      return nil unless defined?(PWN::Env) && PWN::Env.is_a?(Hash)
+
+      b = PWN::Env.dig(:ai, :ollama, :base_uri).to_s
+      b.start_with?('http') ? b.chomp('/') : nil
+    end
+
+    private_class_method def self.fallback(opts = {})
+      PWN::Memory.recall(query: opts[:query], limit: opts[:limit]).map do |k, v|
+        { key: k, value: v[:value], category: v[:category], timestamp: v[:timestamp], score: 0.0 }
+      end
+    rescue StandardError
+      []
+    end
+
+    # Author(s):: 0day Inc. <support@0dayinc.com>
+
+    public_class_method def self.authors
+      "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
+    end
+
+    # Display Usage for this Module
+
+    public_class_method def self.help
+      puts <<~USAGE
+        USAGE:
+          PWN::MemoryIndex.available?
+          PWN::MemoryIndex.recall_semantic(query: 'nmap sweep', limit: 6)
+          PWN::MemoryIndex.to_context(query: 'nmap sweep', limit: 6)  # PromptBuilder drop-in
+          PWN::MemoryIndex.refresh                                    # incremental (re)embed
+          PWN::MemoryIndex.embed(texts: ['a', 'b'])                   # raw vectors
+          PWN::MemoryIndex.reset
+
+          Config:
+            PWN::Env[:ai][:ollama][:embed_model] = 'nomic-embed-text'  # or bge-m3, mxbai-embed-large
+
+          #{self}.authors
+      USAGE
+    end
+  end
+end