pwn 0.5.708 → 0.5.709

data/lib/pwn/cron.rb

@@ -1518,26 +1518,303 @@ module PWN
 
     # Display Usage for this Module
     public_class_method def self.help
-      puts <<~USAGE
-                USAGE:
-                  PWN::Cron.create(schedule: '0 * * * *', prompt: 'Run daily recon on target.com using NmapIt and report', name: 'daily-recon')
-                  PWN::Cron.list
-                  res = PWN::Cron.run(id: 'abc123')
-                  PWN::Cron.enable(id: 'abc123')
-                  PWN::Cron.disable(id: 'abc123')
-                  PWN::Cron.remove(id: 'abc123')
-                  # OS-native persistence (systemd --user / launchd / schtasks / crontab)
-                  PWN::Cron.install_scheduler
-                  PWN::Cron.uninstall_scheduler
-                  PWN::Cron.sync_scheduler
-                  PWN::Cron.scheduler_backend
-        PWN::Cron.install_defaults  # seed S1/P3/W2/M1 curriculum jobs (idempotent)
-        PWN::Cron.ensure_worker     # start/restart the background scheduler
-        PWN::Cron.worker_status
-        PWN::Cron.tick              # fire currently-due jobs once
-
-                  #{self}.authors
-      USAGE
+      puts "USAGE:
+        # Run cron dir and return its result
+        #{self}.cron_dir
+
+        # Run list and return its result
+        #{self}.list
+
+        # Run create and return its result
+        #{self}.create(
+          name: 'optional - binary or identifier name (defaults to job-)',
+          schedule: 'required - required e.g. 0 * * * * or 30m or every 2h',
+          prompt: 'optional - pwn-ai prompt to run',
+          ruby: 'optional - ruby snippet to eval',
+          script: 'optional - path to external script',
+          delivery: 'optional - log|stdout (default log)',
+          enabled: 'optional - enabled value consumed by #create',
+          install_crontab: 'optional - install crontab value consumed by #create'
+        )
+
+        # Executes the job (for pwn-ai prompt it will use current active AI engine
+        #{self}.run(
+          id: 'required - id value consumed by #run'
+        )
+
+        # Run remove and return its result
+        #{self}.remove(
+          id: 'optional - id value consumed by #remove'
+        )
+
+        # Run enable and return its result
+        #{self}.enable(
+          id: 'optional - id value consumed by #enable'
+        )
+
+        # Run disable and return its result
+        #{self}.disable(
+          id: 'optional - id value consumed by #disable'
+        )
+
+        # Install a crontab line that invokes this job via pwn
+        #{self}.install_crontab_entry
+
+        # Run install defaults and return its result
+        #{self}.install_defaults
+
+        # Runtime paths follow cron_dir (and therefore a stubbed CRON_DIR)
+        #{self}.jobs_file
+
+        # Run pid file and return its result
+        #{self}.pid_file
+
+        # Run worker log and return its result
+        #{self}.worker_log
+
+        # Run due and return its result
+        #{self}.due?(
+          schedule: 'required - 5-field cron or relative (30m, every 2h)',
+          last_run: 'optional - Time / iso8601 / nil',
+          now: 'optional - Time (default Time.now)'
+        )
+
+        # Run due jobs and return its result
+        #{self}.due_jobs(
+          now: 'optional - now value consumed by #due_jobs (defaults to Time.now)'
+        )
+
+        # Fires every currently-due enabled job via run(). Returns the list
+        #{self}.run_due(
+          now: 'optional - now value consumed by #run_due (defaults to Time.now)',
+          jobs: 'optional - jobs value consumed by #run_due'
+        )
+
+        # Run worker status and return its result
+        #{self}.worker_status
+
+        # Idempotent. With restart:true (default) a live worker is replaced
+        #{self}.start_worker(
+          interval: 'optional - interval value consumed by #start_worker',
+          foreground: 'optional - foreground value consumed by #start_worker',
+          restart: 'optional - restart value consumed by #start_worker (defaults to foreground)'
+        )
+
+        # Run stop worker and return its result
+        #{self}.stop_worker
+
+        # Single tick used by the loop AND by tests (no sleep)
+        #{self}.tick(
+          now: 'optional - now value consumed by #tick'
+        )
+
+        # Blocking poll loop. `once: true` runs a single tick then returns
+        #{self}.worker_loop(
+          interval: 'optional - interval value consumed by #worker_loop',
+          once: 'optional - once value consumed by #worker_loop'
+        )
+
+        # any setup action so YAML-only default jobs actually fire
+        #{self}.ensure_worker(
+          interval: 'optional - interval value consumed by #ensure_worker (defaults to DEFAULT_INTERVAL)'
+        )
+
+        # Append an @reboot line so the worker comes back after a reboot
+        #{self}.install_worker_crontab
+
+        # Run os type and return its result
+        #{self}.os_type
+
+        # Run windows and return its result
+        #{self}.windows?
+
+        # Run scheduler file and return its result
+        #{self}.scheduler_file
+
+        # Run scheduler config and return its result
+        #{self}.scheduler_config
+
+        # Run cron enabled and return its result
+        #{self}.cron_enabled?
+
+        # Run persist scheduler config and return its result
+        #{self}.persist_scheduler_config(
+          backend: 'optional - backend value consumed by #persist_scheduler_config'
+        )
+
+        # Run apply native and return its result
+        #{self}.apply_native?(
+          apply: 'optional - apply value consumed by #apply_native?'
+        )
+
+        # Run which bin and return its result
+        #{self}.which_bin(
+          name: 'required - binary or identifier name'
+        )
+
+        # Run crontab available and return its result
+        #{self}.crontab_available?
+
+        # Run systemd user available and return its result
+        #{self}.systemd_user_available?
+
+        # Run schtasks available and return its result
+        #{self}.schtasks_available?
+
+        # Run scheduler backend and return its result
+        #{self}.scheduler_backend(
+          backend: 'optional - backend value consumed by #scheduler_backend',
+          os: 'optional - os value consumed by #scheduler_backend'
+        )
+
+        # Run native unit dir and return its result
+        #{self}.native_unit_dir(
+          backend: 'optional - backend value consumed by #native_unit_dir'
+        )
+
+        # Run ruby lib dir and return its result
+        #{self}.ruby_lib_dir
+
+        # Run ruby eval argv and return its result
+        #{self}.ruby_eval_argv(
+          snippet: 'optional - snippet value consumed by #ruby_eval_argv'
+        )
+
+        # Run ruby eval shell and return its result
+        #{self}.ruby_eval_shell(
+          log: 'optional - log value consumed by #ruby_eval_shell'
+        )
+
+        # Convert a 5-field cron expression into a portable calendar hash
+        #{self}.cron_to_calendar(
+          schedule: 'optional - schedule value consumed by #cron_to_calendar'
+        )
+
+        # Run systemd on calendar and return its result
+        #{self}.systemd_on_calendar(
+          calendar: 'optional - calendar value consumed by #systemd_on_calendar',
+          schedule: 'optional - schedule value consumed by #systemd_on_calendar'
+        )
+
+        # Run launchd calendar interval and return its result
+        #{self}.launchd_calendar_interval(
+          calendar: 'optional - calendar value consumed by #launchd_calendar_interval',
+          schedule: 'optional - schedule value consumed by #launchd_calendar_interval'
+        )
+
+        # Run schtasks spec and return its result
+        #{self}.schtasks_spec(
+          calendar: 'optional - calendar value consumed by #schtasks_spec',
+          schedule: 'optional - schedule value consumed by #schtasks_spec'
+        )
+
+        # Run install scheduler and return its result
+        #{self}.install_scheduler(
+          enabled: 'optional - enabled value consumed by #install_scheduler',
+          backend: 'optional - optional force',
+          apply: 'optional - optional (default true unless PWN_CRON_DIR is set',
+          sync_jobs: 'optional - sync jobs value consumed by #install_scheduler'
+        )
+
+        # Run uninstall scheduler and return its result
+        #{self}.uninstall_scheduler(
+          backend: 'optional - backend value consumed by #uninstall_scheduler',
+          persist: 'optional - persist value consumed by #uninstall_scheduler'
+        )
+
+        # Run sync scheduler and return its result
+        #{self}.sync_scheduler
+
+        # Run scheduler status and return its result
+        #{self}.scheduler_status
+
+        # Run install native job and return its result
+        #{self}.install_native_job(
+          job: 'optional - job value consumed by #install_native_job',
+          backend: 'optional - backend value consumed by #install_native_job'
+        )
+
+        # Run remove native job and return its result
+        #{self}.remove_native_job(
+          job: 'optional - job value consumed by #remove_native_job',
+          id: 'optional - id value consumed by #remove_native_job',
+          name: 'optional - binary or identifier name',
+          backend: 'optional - backend value consumed by #remove_native_job'
+        )
+
+        # Run sync native jobs and return its result
+        #{self}.sync_native_jobs(
+          backend: 'optional - backend value consumed by #sync_native_jobs'
+        )
+
+        # ---- crontab -------------------------------------------------------
+        #{self}.install_crontab_worker
+
+        # Run install crontab job and return its result
+        #{self}.install_crontab_job(
+          job: 'optional - job value consumed by #install_crontab_job'
+        )
+
+        # Run uninstall crontab and return its result
+        #{self}.uninstall_crontab
+
+        # Run uninstall crontab job and return its result
+        #{self}.uninstall_crontab_job(
+          job: 'optional - job value consumed by #uninstall_crontab_job'
+        )
+
+        # ---- systemd --user ------------------------------------------------
+        #{self}.install_systemd_user_worker
+
+        # Run install systemd user job and return its result
+        #{self}.install_systemd_user_job(
+          job: 'optional - job value consumed by #install_systemd_user_job'
+        )
+
+        # Run uninstall systemd user and return its result
+        #{self}.uninstall_systemd_user
+
+        # Run uninstall systemd user job and return its result
+        #{self}.uninstall_systemd_user_job(
+          job: 'optional - job value consumed by #uninstall_systemd_user_job'
+        )
+
+        # ---- launchd -------------------------------------------------------
+        #{self}.install_launchd_worker
+
+        # Run install launchd job and return its result
+        #{self}.install_launchd_job(
+          job: 'optional - job value consumed by #install_launchd_job'
+        )
+
+        # Run uninstall launchd and return its result
+        #{self}.uninstall_launchd
+
+        # Run uninstall launchd job and return its result
+        #{self}.uninstall_launchd_job(
+          job: 'optional - job value consumed by #uninstall_launchd_job'
+        )
+
+        # ---- schtasks (Windows) -------------------------------------------
+        #{self}.install_schtasks_worker
+
+        # Run install schtasks job and return its result
+        #{self}.install_schtasks_job(
+          job: 'optional - job value consumed by #install_schtasks_job'
+        )
+
+        # Run uninstall schtasks and return its result
+        #{self}.uninstall_schtasks
+
+        # Run uninstall schtasks job and return its result
+        #{self}.uninstall_schtasks_job(
+          job: 'optional - job value consumed by #uninstall_schtasks_job'
+        )
+
+        # Print the AUTHOR(S) string for this module.
+        #{self}.authors
+      "
+      constants.sort
     end
   end
 end

data/lib/pwn/driver.rb

@@ -69,26 +69,10 @@ module PWN
 
     public_class_method def self.help
       puts "USAGE:
-        # Load default driver options into PWN::Env
-        opts = PWN::Env[:driver_opts]
-        #{self}::Parser.new.parse(&:on).parse!
-
-        # Add more options by passing a block to the parser
-        opts = PWN::Env[:driver_opts]
-        #{self}::Parser.new do |options|
-          # Boolean option
-          options.on('-b', '--boolean') do |o|
-            opts[:boolean] = o
-          end
-
-          # String option
-          options.on('-sSTRING', '--string=STRING') do |o|
-            opts[:string] = o
-          end
-        end.parse!
-
+        # Print the AUTHOR(S) string for this module.
         #{self}.authors
       "
+      constants.sort
     end
   end
 end

data/lib/pwn/ffi/adalm_pluto.rb

@@ -455,22 +455,76 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
+          # Run available and return its result
           #{self}.available?
+
+          # Run info and return its result
           #{self}.info
-          #{self}.list_uris
-          ctx = #{self}.open(uri: 'ip:192.168.2.1')   # or nil for default
-          #{self}.device_info(context: ctx)
-          #{self}.configure(context: ctx, freq_hz:, rate_hz: 2_500_000, gain_db: nil)
-          h = #{self}.start_rx(context: ctx, samples: 262_144)
-          iq = #{self}.read_sync(handle: h)            # cs16le interleaved String
-          #{self}.stop_rx(handle: h)
-          #{self}.close(context: ctx)
-
-          # one-shot
-          cap = #{self}.capture(freq_hz: 1090e6, rate_hz: 2_500_000, bytes: 1_048_576)
 
+          # Run list uris and return its result
+          #{self}.list_uris(
+            backends: 'optional - backends value consumed by #list_uris'
+          )
+
+          # Open a session or connection and return a handle.
+          #{self}.open(
+            uri: 'required - URI or URL string',
+            timeout_ms: 'optional - timeout ms value consumed by #open'
+          )
+
+          # Close a session previously returned by #open.
+          #{self}.close(
+            context: 'optional - context value consumed by #close'
+          )
+
+          # Run device info and return its result
+          #{self}.device_info(
+            context: 'required - context value consumed by #device_info'
+          )
+
+          # Run configure and return its result
+          #{self}.configure(
+            context: 'required - pointer from .open',
+            freq_hz: 'required - RX LO frequency Hz',
+            rate_hz: 'optional - sample rate (default 2_500_000)',
+            bw_hz: 'optional - RF bandwidth (default = rate_hz)',
+            gain_db: 'optional - manual gain dB; nil = slow_attack AGC',
+            gain_mode: 'optional - slow_attack|fast_attack|manual|hybrid'
+          )
+
+          # Run start rx and return its result
+          #{self}.start_rx(
+            context: 'required - pointer from .open',
+            samples: 'optional - samples-per-refill (default 262144)',
+            cyclic: 'optional - cyclic buffer (default false)'
+          )
+
+          # Run read sync and return its result
+          #{self}.read_sync(
+            handle: 'required - handle value consumed by #read_sync'
+          )
+
+          # Run stop rx and return its result
+          #{self}.stop_rx(
+            handle: 'optional - handle value consumed by #stop_rx'
+          )
+
+          # High-level one-shot: open → configure → start_rx → N refills → stop → close
+          #{self}.capture(
+            freq_hz: 'required - freq hz value consumed by #capture',
+            rate_hz: 'optional - rate hz value consumed by #capture',
+            bytes: 'optional - 1_048_576,   # approximate payload size',
+            uri: 'optional - URI or URL string',
+            gain_db: 'optional - gain db value consumed by #capture',
+            timeout_ms: 'optional - timeout ms value consumed by #capture',
+            bw_hz: 'optional - bw hz value consumed by #capture',
+            gain_mode: 'optional - gain mode value consumed by #capture'
+          )
+
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
 
       class << self

data/lib/pwn/ffi/fftw.rb

@@ -178,14 +178,39 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          #{self}.available?                         # => true/false
-          #{self}.rfft(samples:, n: nil)             # real→complex, [[re,im],…]
-          #{self}.rfft_magnitude(samples:, n: nil)   # |X[k]|
-          #{self}.rfft_power_db(samples:, n:, floor: -120.0)
-          #{self}.cfft(iq:, n: nil, sign: :forward)  # complex FFT
-
+          # Run available and return its result
+          #{self}.available?
+
+          # Run rfft and return its result
+          #{self}.rfft(
+            samples: 'required - Array<Float> real input (length = n)',
+            n: 'optional - FFT size (default samples.length; zero-pads/truncates)'
+          )
+
+          # Run rfft magnitude and return its result
+          #{self}.rfft_magnitude(
+            samples: 'required - samples value consumed by #rfft_magnitude',
+            n: 'optional - FFT size'
+          )
+
+          # Run rfft power db and return its result
+          #{self}.rfft_power_db(
+            samples: 'required - samples value consumed by #rfft_power_db',
+            n: 'optional - FFT size',
+            floor: 'optional - dB floor for zeros (default -120.0)'
+          )
+
+          # Run cfft and return its result
+          #{self}.cfft(
+            iq: 'required - interleaved Array<Float> I/Q (even length)',
+            n: 'optional - number of complex samples (default iq.length/2)',
+            sign: 'optional - :forward (default) or :backward'
+          )
+
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/ffi/hack_rf.rb

@@ -282,19 +282,70 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
+          # Run available and return its result
           #{self}.available?
+
+          # Run info and return its result
           #{self}.info
-          dev = #{self}.open(serial: nil)
-          #{self}.configure(device: dev, freq_hz:, rate_hz: 10e6, lna_gain: 16, vga_gain: 20, amp: false)
-          rx = #{self}.start_rx(device: dev)
-          data = #{self}.read_sync(handle: rx)   # cs8 interleaved I/Q
-          #{self}.stop_rx(handle: rx)
-          data = #{self}.capture(freq_hz:, rate_hz: 10e6, samples: 262_144)
-          #{self}.device_info(device: dev)
-          #{self}.close(device: dev)
 
+          # Open a session or connection and return a handle.
+          #{self}.open(
+            serial: 'optional - serial value consumed by #open'
+          )
+
+          # Close a session previously returned by #open.
+          #{self}.close(
+            device: 'optional - device value consumed by #close'
+          )
+
+          # Run configure and return its result
+          #{self}.configure(
+            device: 'required - pointer from .open',
+            freq_hz: 'required - center frequency Hz',
+            rate_hz: 'optional - sample rate (default 10e6)',
+            lna_gain: 'optional - 0..40 step 8 (default 16)',
+            vga_gain: 'optional - 0..62 step 2 (default 20)',
+            amp: 'optional - true/false RF amp (default false)',
+            bb_bw_hz: 'optional - baseband filter BW Hz'
+          )
+
+          # Run device info and return its result
+          #{self}.device_info(
+            device: 'required - device value consumed by #device_info'
+          )
+
+          # Run start rx and return its result
+          #{self}.start_rx(
+            device: 'required - pointer from .open',
+            max_queue: 'optional - max buffered chunks (default 64)'
+          )
+
+          # Run read sync and return its result
+          #{self}.read_sync(
+            handle: 'required - handle from .start_rx',
+            timeout: 'optional - seconds to wait for a chunk (default 1.0)'
+          )
+
+          # Run stop rx and return its result
+          #{self}.stop_rx(
+            handle: 'optional - handle value consumed by #stop_rx'
+          )
+
+          # Run capture and return its result
+          #{self}.capture(
+            freq_hz: 'required - center frequency Hz',
+            rate_hz: 'optional - sample rate (default 10e6)',
+            samples: 'optional - I/Q sample pairs to capture (default 262_144)',
+            lna_gain: 'optional - optional, vga_gain: optional, amp: optional',
+            serial: 'optional - serial value consumed by #capture',
+            vga_gain: 'optional - vga gain value consumed by #capture',
+            amp: 'optional - amp value consumed by #capture'
+          )
+
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
 
       class << self

data/lib/pwn/ffi/liquid.rb

@@ -395,18 +395,71 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          #{self}.available?                              # => true/false
-          #{self}.freq_demod(iq:, kf: 0.5)                # FM I/Q → audio
-          #{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
-
+          # Run available and return its result
+          #{self}.available?
+
+          # Run freq demod and return its result
+          #{self}.freq_demod(
+            iq: 'required - interleaved I/Q Array<Float> (even length)',
+            kf: 'optional - modulation factor (default 0.5)'
+          )
+
+          # Run resample and return its result
+          #{self}.resample(
+            samples: 'required - samples value consumed by #resample',
+            rate: 'required - output/input ratio (>0)',
+            as_db: 'optional - stop-band attenuation dB (default 60.0)'
+          )
+
+          # Run fir kaiser and return its result
+          #{self}.fir_kaiser(
+            samples: 'required - samples value consumed by #fir_kaiser',
+            length: 'optional - filter length (default 51, odd preferred)',
+            fc: 'optional - normalised cutoff 0..0.5 (default 0.1)',
+            as_db: 'optional - stop-band attenuation dB (default 60.0)',
+            mu: 'optional - fractional sample offset (default 0.0)'
+          )
+
+          # Run dc block and return its result
+          #{self}.dc_block(
+            samples: 'required - samples value consumed by #dc_block',
+            m: 'optional - prototype semi-length (default 7 → len 15)',
+            as_db: 'optional - stop-band attenuation dB (default 60.0)'
+          )
+
+          # Run resample iq and return its result
+          #{self}.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)'
+          )
+
+          # Run mix down and return its result
+          #{self}.mix_down(
+            iq: 'required - interleaved I/Q Array<Float>',
+            freq: 'required - normalised angular freq (rad/sample, i.e. 2π·f/fs)'
+          )
+
+          # Run gmsk demod and return its result
+          #{self}.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)'
+          )
+
+          # Run mfsk demod and return its result
+          #{self}.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)'
+          )
+
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
 
       class << self