number_station 0.2.0 → 0.3.0

data/lib/number_station/config_reader.rb

@@ -19,25 +19,102 @@
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 =end
 
+require 'yaml'
+require 'fileutils'
+require 'date'
+
 module NumberStation
   class ConfigReader
+    def self.read_config
+      config_path = user_config_path || default_config_path
+      load_config(config_path)
+    end
+
+    def self.user_config_path
+      yaml_path = File.join(Dir.home, "number_station", "conf.yaml")
+      json_path = File.join(Dir.home, "number_station", "conf.json")
+      
+      # Prefer YAML, but support JSON for backward compatibility
+      return yaml_path if File.exist?(yaml_path)
+      return json_path if File.exist?(json_path)
+      nil
+    end
+
+    def self.default_config_path
+      yaml_path = File.join(File.dirname(__FILE__), "../../resources/conf.yaml")
+      json_path = File.join(File.dirname(__FILE__), "../../resources/conf.json")
+      
+      # Prefer YAML, but support JSON for backward compatibility
+      return yaml_path if File.exist?(yaml_path)
+      return json_path if File.exist?(json_path)
+      yaml_path  # Default to YAML path
+    end
+
+    def self.load_config(config_path)
+      config_data = if config_path.end_with?('.yaml') || config_path.end_with?('.yml')
+        # Use safe_load with permitted classes to handle Date objects
+        YAML.safe_load(File.read(config_path), permitted_classes: [Date, Time], aliases: true)
+      else
+        require 'json'
+        JSON.parse(File.read(config_path))
+      end
+      
+      NumberStation.set_data(config_data)
+      setup_logger(config_data["logging"]["level"])
+      NumberStation.log.debug "Reading in config file: #{config_path}"
+    rescue StandardError => e
+      # Ensure logger exists before trying to log
+      unless NumberStation.log
+        setup_logger(Logger::WARN)
+      end
+      NumberStation.log.error "Failed to load config: #{e.message}"
+      raise
+    end
+
+    def self.setup_logger(level)
+      NumberStation.set_log(Logger.new(STDOUT))
+      NumberStation.log.level = level
+    end
+
+    def self.save_config(config_data = nil)
+      config_data ||= NumberStation.data
+      config_path = user_config_path || File.join(Dir.home, "number_station", "conf.yaml")
+      
+      # Ensure directory exists
+      FileUtils.mkdir_p(File.dirname(config_path))
+      
+      # Convert Date/Time objects to strings before saving
+      sanitized_data = sanitize_for_yaml(config_data.dup)
+      
+      # Save as YAML
+      File.write(config_path, sanitized_data.to_yaml)
+      NumberStation.set_data(config_data)  # Update in-memory data (keep original format)
+      NumberStation.log.debug "Saved config file: #{config_path}"
+      config_path
+    rescue StandardError => e
+      # Ensure logger exists before trying to log
+      unless NumberStation.log
+        setup_logger(Logger::WARN)
+      end
+      NumberStation.log.error "Failed to save config: #{e.message}"
+      raise
+    end
 
-    def self.read_config()
-      begin
-        config_file_path = File.join(Dir.home, "number_station/conf.json")
-        NumberStation.set_data( JSON.parse(File.read(config_file_path)) )
-        NumberStation.set_log( Logger.new(STDOUT) )
-        NumberStation.log.level = NumberStation.data["logging"]["level"]
-        NumberStation.log.debug "Reading in config file: #{config_file_path}"
-      rescue Exception => e
-        config_file_path = File.join(File.dirname(__FILE__), "../../config/conf.json")
-        NumberStation.set_data( JSON.parse(File.read(config_file_path)) )
-        NumberStation.set_log( Logger.new(STDOUT) )
-        NumberStation.log.level = NumberStation.data["logging"]["level"]
-        NumberStation.log.debug "Reading in default config file: #{config_file_path}"
+    def self.sanitize_for_yaml(data)
+      case data
+      when Hash
+        data.each_with_object({}) do |(key, value), result|
+          result[key] = sanitize_for_yaml(value)
+        end
+      when Array
+        data.map { |item| sanitize_for_yaml(item) }
+      when Date, Time
+        data.to_s
+      else
+        data
       end
-      NumberStation.log.debug "NumberStation::ConfigReader#read_config"
     end
 
+    private
   end
 end

data/lib/number_station/decrypt_message.rb

@@ -18,47 +18,91 @@
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 =end
-require "securerandom"
 require "json"
 
 module NumberStation
-  
-  def self.decrypt_message(message, pad_path, pad_num)
-    NumberStation.log.debug "message length: #{message.size}"
-    message_byte_array = message.scan(/.{1}/).each_slice(2).map { |f, l| (Integer(f,16) << 4) + Integer(l,16) } 
+  def self.decrypt_message(message, pad_path, pad_num, message_file_path = nil)
+    # Strip whitespace and newlines to handle formatted input (groups of 5)
+    cleaned_message = message.gsub(/[\s\n\r]/, '')
+    NumberStation.log.debug "original message length: #{message.size}, cleaned length: #{cleaned_message.size}"
+    
+    pad_data = load_pad_data(pad_path)
+    pad_key = pad_data["pads"][pad_num]["key"]
+    
+    validate_message_length(cleaned_message.size, pad_key.size)
 
-    begin
-      pad_data = JSON.parse(File.read(pad_path))
-    rescue Exception => e
-      raise e
-    end
+    message_bytes = hex_string_to_bytes(cleaned_message)
+    pad_bytes = hex_string_to_bytes(pad_key)
+    decrypted_bytes = xor_decrypt(message_bytes, pad_bytes)
+    decrypted_string = bytes_to_string(decrypted_bytes)
 
-    crypto_hex_str = pad_data["pads"][pad_num]["key"]
-    if message.size > crypto_hex_str.size
-      NumberStation.log.error "Error: The message length is greater than pad length. Unable to continue decryption."
-      exit
-    end
-    NumberStation.log.debug "message length less than pad length: #{message.size <= crypto_hex_str.size}"
+    # Extract encrypted filename if message_file_path is provided
+    encrypted_filename = message_file_path ? File.basename(message_file_path) : nil
+    write_decrypted_file(pad_data["id"], pad_num, decrypted_string, encrypted_filename)
+    decrypted_string
+  end
 
-    crypto_byte_array = crypto_hex_str.scan(/.{1}/).each_slice(2).map { |f, l| (Integer(f,16) << 4) + Integer(l,16) }
+  private
 
-    decrypted_byte_array = []
-    message_byte_array.each_with_index do |i, index|
-      decrypted_byte_array << (i ^ crypto_byte_array[index])
+  def self.load_pad_data(pad_path)
+    JSON.parse(File.read(pad_path))
+  rescue StandardError => e
+    NumberStation.log.error "Failed to load pad file: #{e.message}"
+    raise
+  end
+
+  def self.validate_message_length(message_size, pad_size)
+    if message_size > pad_size
+      NumberStation.log.error "Message length (#{message_size}) is greater than pad length (#{pad_size}). Unable to continue decryption."
+      raise ArgumentError, "Message too long for pad"
     end
+    NumberStation.log.debug "message length less than pad length: #{message_size <= pad_size}"
+  end
 
-    decrypted_string = decrypted_byte_array.pack('U*').force_encoding('utf-8')
+  def self.hex_string_to_bytes(hex_string)
+    hex_string.scan(/.{2}/).map { |pair| pair.to_i(16) }
+  end
 
-    begin
-      f_name = "#{pad_data["id"]}_#{pad_num}_#{Time.now.to_i}_decrypted.txt"
-      NumberStation.log.info "Writing decrypted message to file #{f_name}"
-      f = File.open(f_name, "w")
-      f.write(decrypted_string)
-      f.close
-    rescue Exception => e
-      raise e
-    end
-    return decrypted_string
+  def self.xor_decrypt(message_bytes, pad_bytes)
+    message_bytes.map.with_index { |byte, index| byte ^ pad_bytes[index] }
+  end
+
+  def self.bytes_to_string(bytes)
+    bytes.pack('U*').force_encoding('utf-8')
   end
 
+  def self.write_decrypted_file(pad_id, pad_num, decrypted_content, encrypted_filename = nil)
+    # Only write to file if decrypting from a file (not from string)
+    unless encrypted_filename
+      NumberStation.log.debug "Decrypted message (not saving to file)"
+      return
+    end
+    
+    # Try to extract agent name and pad info from encrypted filename if provided
+    if encrypted_filename && !encrypted_filename.empty?
+      # Parse encrypted filename format: agentname_name-of-the-pad-file_padnumber_encrypted.txt
+      # Example: Abyss_Abyss-2026-01-12-001_pad2_encrypted.txt
+      if encrypted_filename.match(/^(.+?)_(.+?)_pad(\d+)_encrypted\.txt$/)
+        agent_name = $1
+        pad_filename = $2
+        pad_num_from_filename = $3
+        
+        # Use the same format but with _decrypted.txt
+        filename = "#{agent_name}_#{pad_filename}_pad#{pad_num_from_filename}_decrypted.txt"
+        NumberStation.log.info "Writing decrypted message to file #{filename}"
+        File.write(filename, decrypted_content)
+        return
+      end
+    end
+    
+    # Fallback: extract agent name from pad_path if available
+    # For now, use pad_id and pad_num as fallback
+    filename = "#{pad_id}_pad#{pad_num}_decrypted.txt"
+    
+    NumberStation.log.info "Writing decrypted message to file #{filename}"
+    File.write(filename, decrypted_content)
+  rescue StandardError => e
+    NumberStation.log.error "Failed to write decrypted file: #{e.message}"
+    raise
+  end
 end

data/lib/number_station/encrypt_message.rb

@@ -18,62 +18,133 @@
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 =end
-require "securerandom"
 require "json"
 
 module NumberStation
-  
-  def self.encrypt_message(message, pad_path, pad_num)
+  def self.encrypt_message(message, pad_path, pad_num, message_file_path = nil)
     NumberStation.log.debug "message length: #{message.size}"
-    message_byte_array = message.unpack('U*')
+    
+    pad_data = load_pad_data(pad_path)
+    pad_key = pad_data["pads"][pad_num]["key"]
+    
+    validate_message_length(message.size, pad_key.size)
+    mark_pad_as_consumed(pad_data, pad_path, pad_num)
 
-    begin
-      pad_data = JSON.parse(File.read(pad_path))
-    rescue Exception => e
-      raise e
-    end
+    message_bytes = message.unpack('U*')
+    pad_bytes = hex_string_to_bytes(pad_key)
+    encrypted_bytes = xor_encrypt(message_bytes, pad_bytes)
+    encrypted_hex = bytes_to_hex_string(encrypted_bytes)
+    formatted_hex = format_hex_in_groups(encrypted_hex, 5)
+
+    write_encrypted_file(pad_path, pad_num, formatted_hex, message_file_path)
+    formatted_hex
+  end
 
-    crypto_hex_str = pad_data["pads"][pad_num]["key"]
+  private
 
-    if message.size > crypto_hex_str.size
-      NumberStation.log.error "Exception: message length is larger than pad length. Break the message into smaller parts."
-      exit
+  def self.load_pad_data(pad_path)
+    JSON.parse(File.read(pad_path))
+  rescue StandardError => e
+    NumberStation.log.error "Failed to load pad file: #{e.message}"
+    raise
+  end
+
+  def self.validate_message_length(message_size, pad_size)
+    if message_size > pad_size
+      NumberStation.log.error "Message length (#{message_size}) is larger than pad length (#{pad_size}). Break the message into smaller parts."
+      raise ArgumentError, "Message too long for pad"
     end
     NumberStation.log.debug "message length less than pad length"
+  end
 
-    unless pad_data["pads"][pad_num]["consumed"]
-      NumberStation.log.debug "Marking key as consumed"
-      pad_data["pads"][pad_num]["epoch_date"] = Time.now.to_i
-      pad_data["pads"][pad_num]["consumed"] = true
-      f = File.open(pad_path, "w")
-      f.write(pad_data.to_json)
-      f.close
-    else
-       msg = "Warning pad #{pad_num} has been consumed on #{Time.at(pad_data["pads"][pad_num]["epoch_date"])}"
-       NumberStation.log.error msg
-       exit
+  def self.mark_pad_as_consumed(pad_data, pad_path, pad_num)
+    pad = pad_data["pads"][pad_num]
+    
+    if pad["consumed"]
+      consumed_date = Time.at(pad["epoch_date"])
+      error_msg = "Pad #{pad_num} has already been consumed on #{consumed_date}"
+      NumberStation.log.error error_msg
+      raise ArgumentError, error_msg
     end
 
-    crypto_byte_array = crypto_hex_str.scan(/.{1}/).each_slice(2).map { |f, l| (Integer(f,16) << 4) + Integer(l,16) }
+    NumberStation.log.debug "Marking key as consumed"
+    pad["epoch_date"] = Time.now.to_i
+    pad["consumed"] = true
+    File.write(pad_path, pad_data.to_json)
+  end
+
+  def self.hex_string_to_bytes(hex_string)
+    hex_string.scan(/.{2}/).map { |pair| pair.to_i(16) }
+  end
+
+  def self.xor_encrypt(message_bytes, pad_bytes)
+    message_bytes.map.with_index { |byte, index| byte ^ pad_bytes[index] }
+  end
+
+  def self.bytes_to_hex_string(bytes)
+    bytes.map { |byte| '%02x' % (byte & 0xFF) }.join
+  end
 
-    encrypted_byte_array = []
-    message_byte_array.each_with_index do |i, index|
-      encrypted_byte_array << (i ^ crypto_byte_array[index])
+  def self.format_hex_in_groups(hex_string, group_size)
+    hex_string.scan(/.{1,#{group_size}}/).join(' ')
+  end
+
+  def self.write_encrypted_file(pad_path, pad_num, encrypted_content, message_file_path = nil)
+    # Extract agent name from pad path if it's in an agent subdirectory
+    # Path format: ~/number_station/pads/AGENTNAME/padfile.json
+    agent_name = extract_agent_name_from_path(pad_path)
+    
+    # Extract pad filename without extension
+    pad_basename = File.basename(pad_path, ".json")
+    
+    # Build filename: agentname_name-of-the-pad-file_padnumber_encrypted.txt
+    if agent_name && !agent_name.empty?
+      filename = "#{agent_name}_#{pad_basename}_pad#{pad_num}_encrypted.txt"
+    else
+      # Fallback if no agent name found
+      filename = "#{pad_basename}_pad#{pad_num}_encrypted.txt"
     end
-         
-    encrypted_byte_str = encrypted_byte_array.map { |n| '%02X' % (n & 0xFF) }.join.downcase
-
-    begin
-      f_name = "#{pad_data["id"]}_#{pad_num}_#{Time.now.to_i}.txt"
-      NumberStation.log.info "Writing encrypted message to file #{f_name}"
-      f = File.open(f_name, "w")
-      f.write(encrypted_byte_str)
-      f.close
-    rescue Exception => e
-      raise e
+    
+    # Write to file if:
+    # 1. Encrypting from a file (message_file_path is actual file path), OR
+    # 2. Encrypting from string but agent was specified (message_file_path is "string_input")
+    if message_file_path
+      NumberStation.log.info "Writing encrypted message to file #{filename}"
+      File.write(filename, encrypted_content)
+    else
+      NumberStation.log.debug "Encrypted message (not saving to file): #{filename}"
     end
-
-    return encrypted_byte_str
+  rescue StandardError => e
+    NumberStation.log.error "Failed to write encrypted file: #{e.message}"
+    raise
   end
 
+  def self.extract_agent_name_from_path(pad_path)
+    # Extract agent name from path like: ~/number_station/pads/AGENTNAME/padfile.json
+    # or: /path/to/pads/AGENTNAME/padfile.json
+    normalized_path = File.expand_path(pad_path)
+    pads_dir = File.expand_path(File.join(Dir.home, "number_station", "pads"))
+    
+    # Check if pad is in a subdirectory of pads directory
+    if normalized_path.start_with?(pads_dir + File::SEPARATOR)
+      relative_path = normalized_path.sub(pads_dir + File::SEPARATOR, "")
+      path_parts = relative_path.split(File::SEPARATOR)
+      
+      # If path has multiple parts, first part is likely agent name
+      if path_parts.length > 1
+        agent_name = path_parts.first
+        # Verify it's not just the pad filename (should be a directory)
+        return agent_name if File.directory?(File.join(pads_dir, agent_name))
+      end
+    end
+    
+    # Try to extract from filename if it starts with agent name pattern
+    # Format: agentname-YYYY-MM-DD.json
+    pad_basename = File.basename(pad_path, ".json")
+    if pad_basename.match?(/^([\w-]+)-\d{4}-\d{2}-\d{2}(-\d{3})?$/)
+      return $1
+    end
+    
+    nil
+  end
 end

data/lib/number_station/examine_pads.rb

@@ -0,0 +1,171 @@
+=begin
+ Ruby Number Station
+ Author: David Kirwan https://gitub.com/davidkirwan
+ Licence: GPL 3.0
+ NumberStation is a collection of utilities to aid in the running of a number station
+    Copyright (C) 2018  David Kirwan
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+=end
+
+require "json"
+
+module NumberStation
+  def self.examine_pads(pads_directory = nil)
+    pads_dir = pads_directory || File.join(Dir.home, "number_station", "pads")
+    
+    unless Dir.exist?(pads_dir)
+      NumberStation.log.warn "Pads directory does not exist: #{pads_dir}"
+      return []
+    end
+
+    # Look for pad files in various formats:
+    # - Old format: one_time_pad_XXXXX.json (random number)
+    # - New format: agentname-YYYY-MM-DD.json or one_time_pad-YYYY-MM-DD.json (date-based)
+    # - New format with counter: agentname-YYYY-MM-DD-001.json
+    pad_files = Dir.glob(File.join(pads_dir, "*.json")).select do |file|
+      basename = File.basename(file)
+      # Match old format: one_time_pad_XXXXX.json
+      # Match new format: agentname-YYYY-MM-DD.json or one_time_pad-YYYY-MM-DD.json
+      # Match new format with counter: agentname-YYYY-MM-DD-001.json
+      basename.match?(/^(one_time_pad|[\w-]+)[_-]\d{4}-\d{2}-\d{2}(-\d{3})?\.json$/) ||
+      basename.match?(/^one_time_pad_\d+\.json$/) ||
+      basename.match?(/^[\w-]+_\d+\.json$/)
+    end
+    
+    if pad_files.empty?
+      NumberStation.log.info "No pad files found in #{pads_dir}"
+      return []
+    end
+
+    pad_files.map { |file| examine_pad_file(file) }
+  end
+
+  def self.find_next_available_pad(pads_directory = nil, min_length = nil, require_unconsumed = true, agent_name = nil)
+    # Determine pads directory based on agent name
+    if agent_name && !agent_name.empty?
+      pads_dir = File.join(Dir.home, "number_station", "pads", agent_name)
+    else
+      pads_dir = pads_directory || File.join(Dir.home, "number_station", "pads")
+    end
+    
+    unless Dir.exist?(pads_dir)
+      error_msg = agent_name ? "Agent pad directory does not exist: #{pads_dir}" : "Pads directory does not exist: #{pads_dir}"
+      raise ArgumentError, error_msg
+    end
+
+    # Look for pad files in various formats:
+    # - Old format: one_time_pad_XXXXX.json (random number)
+    # - New format: agentname-YYYY-MM-DD.json or one_time_pad-YYYY-MM-DD.json (date-based)
+    # - New format with counter: agentname-YYYY-MM-DD-001.json
+    pad_files = Dir.glob(File.join(pads_dir, "*.json")).select do |file|
+      basename = File.basename(file)
+      # Match old format: one_time_pad_XXXXX.json
+      # Match new format: agentname-YYYY-MM-DD.json or one_time_pad-YYYY-MM-DD.json
+      # Match new format with counter: agentname-YYYY-MM-DD-001.json
+      basename.match?(/^(one_time_pad|[\w-]+)[_-]\d{4}-\d{2}-\d{2}(-\d{3})?\.json$/) ||
+      basename.match?(/^one_time_pad_\d+\.json$/) ||
+      basename.match?(/^[\w-]+_\d+\.json$/)
+    end
+    
+    if pad_files.empty?
+      error_msg = agent_name ? "No pad files found for agent '#{agent_name}' in #{pads_dir}" : "No pad files found in #{pads_dir}"
+      raise ArgumentError, error_msg
+    end
+
+    # Sort pads to find the oldest one
+    # For date-based filenames, alphabetical sort works (YYYY-MM-DD format)
+    # For old format (random numbers), sort alphabetically still works
+    pad_files.sort!
+    
+    # Find the oldest pad file that has at least one unconsumed pad
+    pad_files.each do |file_path|
+      pad_data = JSON.parse(File.read(file_path))
+      pads_hash = pad_data["pads"]
+      
+      next if pads_hash.nil? || pads_hash.empty?
+      
+      # Check if this pad file has any unconsumed pads
+      has_unconsumed = pads_hash.values.any? { |pad| !pad["consumed"] }
+      next if require_unconsumed && !has_unconsumed
+      
+      # Find first pad (unconsumed if require_unconsumed is true)
+      pads_hash.each do |pad_num_str, pad|
+        next if require_unconsumed && pad["consumed"]
+        
+        # Check if pad is long enough if min_length is specified
+        if min_length
+          pad_key_length = pad["key"].length / 2  # Convert hex length to byte length
+          next if pad_key_length < min_length
+        end
+        
+        return {
+          pad_path: file_path,
+          pad_num: pad_num_str,
+          pad_id: pad_data["id"].to_s
+        }
+      end
+    end
+    
+    error_msg = require_unconsumed ? "No available (unconsumed) pads found" : "No pads found"
+    error_msg += agent_name ? " for agent '#{agent_name}'" : ""
+    raise ArgumentError, "#{error_msg} in #{pads_dir}"
+  rescue JSON::ParserError => e
+    NumberStation.log.error "Failed to parse pad file: #{e.message}"
+    raise
+  rescue StandardError => e
+    NumberStation.log.error "Error finding pad: #{e.message}"
+    raise
+  end
+
+  def self.examine_pad_file(file_path)
+    pad_data = JSON.parse(File.read(file_path))
+    filename = File.basename(file_path)
+    
+    # Pad data structure: { "id" => "...", "pads" => { "0" => {...}, "1" => {...}, ... } }
+    pads_hash = pad_data["pads"]
+    
+    if pads_hash.nil? || pads_hash.empty?
+      return {
+        filename: filename,
+        error: "No pads found in file"
+      }
+    end
+    
+    # Get max message length from first pad's key length
+    # Key is hex string, so bytes = hex_length / 2
+    # Max message length in characters equals pad length in bytes
+    first_pad_key = pads_hash.values.first["key"]
+    max_message_length = first_pad_key.length / 2
+    
+    # Count unconsumed pads
+    unconsumed_count = pads_hash.values.count { |pad| !pad["consumed"] }
+    total_pads = pads_hash.size
+    
+    {
+      filename: filename,
+      pad_id: pad_data["id"].to_s,
+      max_message_length: max_message_length,
+      total_pads: total_pads,
+      unconsumed_pads: unconsumed_count,
+      consumed_pads: total_pads - unconsumed_count
+    }
+  rescue StandardError => e
+    NumberStation.log.error "Failed to examine pad file #{file_path}: #{e.message}"
+    {
+      filename: File.basename(file_path),
+      error: e.message
+    }
+  end
+end