rubyment 0.5.25438564 → 0.5.25471659

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 48ff8673daa5f0bdc353736e8b1ebd82ba436312
-  data.tar.gz: cd2ceb4fdb4a87d4667d80682253f015476da63d
+  metadata.gz: 048e8eae5ac557122a9a5e74a3019c29768cf1c5
+  data.tar.gz: 7ad419465aab2718f75be44c706f435a326313ab
 SHA512:
-  metadata.gz: abcc1cf7ccf4709fe475ec83ec190902db808fd59c73a0fc6abc96c249a2e183298ed19b6881e680ed67e68d8191ec3052aa8a840eabfef258340f253e48b245
-  data.tar.gz: cb1a504fb9333de2961a5f272bc8d36d61b676a8bb1b0ddec5fa4cd024b341458e0f24d6160865ccabeffd0362202897b4660cb994fe16ed5de15d8aa93fbc18
+  metadata.gz: 218c7e8b2b10503986b12b7a0d0b0411f4dfb9c910614b8535e9608241884bbe57efbd0cb558347c057d4bf3580a6dd6e1fcc719ed0d8288bd84f86eda17deba
+  data.tar.gz: 398b1b171d911c3f79e9040e05e10429f34265690b3749acd44ec32aaa757ce380dfd6ff768c872599d6a8bff2af1804a7ed6ad5ee600b0382bdbc138a994aa8

data/lib/rubyment.rb

@@ -67,8 +67,9 @@ class Rubyment
       :home_dir => Dir.home,
       :system_user => ENV['USER'] || ENV['USERNAME'],
       :system_user_is_super => ENV['USER']  == "root", # changed plan: platform indenpend.
-      :static_separator_key => "strings_having_this_string_not_guaranteed_to_work",
-      :static_end_key => "strings_havinng_this_string_also_not_guaranteed_to_work",
+      :static_separator_key => "strings_having_this"  +  "_string_not_guaranteed_to_work",
+      :static_end_key => "strings_havinng_this_string" + "_also_not_guaranteed_to_work",
+      :static_separator_key_per_execution => "strings_having_this"  +  "_string_not_guaranteed_to_work" + (Proc.new {}).to_s + Time.now.to_s,
     }
     @memory.update memory.to_h
     invoke @memory[:invoke].to_a
@@ -138,6 +139,11 @@ class Rubyment
   end
 
 
+  # returns a string having the current backtrace, for debugging.
+  def backtrace
+    Thread.current.backtrace.join("\n")
+  end
+
   # returns a Class object out of class_name (or itself if it is already
   # a class)
   def to_class args=ARGV
@@ -236,6 +242,24 @@ class Rubyment
   end
 
 
+  # returns the contents of file.
+  # file can be a url, if 'open-uri' is available.
+  # can throw exceptions
+  def file_or_url_contents file
+    contents = nil
+    stderr = @memory[:stderr]
+    (require 'open-uri') && open_uri = true
+    require 'fileutils'
+    file = file.to_s
+    file_is_filename = true
+    open_uri && (
+      contents = open(file).read
+    ) || (
+      contents = File.read
+    )
+    contents
+  end
+
   # returns the contents of file (or empty, or a default
   # if a second parameter is given).
   # if file is a nonexisting filepath, or by any reason
@@ -278,6 +302,8 @@ class Rubyment
 
 
   # opens an echoing prompt, if arg1 is nil or empty
+  # not prepared to work with binary input (which can contain \0)
+  # closed for extensions
   # args:
   # [ arg1 (String or nil)]
   def input_single_line args=ARGV
@@ -289,6 +315,8 @@ class Rubyment
 
 
   # opens a non-echoing prompt, if arg1 is nil or empty
+  # not prepared to work with binary input (which can contain \0)
+  # closed for extensions
   # args:
   # [ arg1 (String or nil)]
   def input_single_line_non_echo args=ARGV
@@ -301,6 +329,8 @@ class Rubyment
 
 
   # opens an echoing multiline prompt, if arg1 is nil or empty
+  # not prepared to work with binary input (which can contain \0)
+  # closed for extensions
   # args:
   # [ arg1 (String or nil)]
   def input_multi_line args=ARGV
@@ -312,6 +342,8 @@ class Rubyment
 
 
   # opens a non-echoing multiline prompt, if arg1 is nil or empty
+  # not prepared to work with binary input (which can contain \0)
+  # closed for extensions
   # args:
   # [ arg1 (String or nil)]
   def input_multi_line_non_echo args=ARGV
@@ -323,6 +355,62 @@ class Rubyment
   end
 
 
+  # opens an echoing prompt, if arg1 is nil or empty
+  # better prepared to work with binary input
+  # args:
+  # [ arg1 (String or nil)]
+  def binary_input_single_line args=ARGV
+    stderr = @memory[:stderr]
+    stdin  = @memory[:stdin]
+    stderr.print "single line:"
+    static_separator_key_per_execution = @memory[:static_separator_key_per_execution]
+    args.shift.to_s.b.split(static_separator_key_per_execution).first || stdin.gets.chomp
+  end
+
+
+  # opens a non-echoing prompt, if arg1 is nil or empty
+  # better prepared to work with binary input (which can contain \0)
+  # args:
+  # [ arg1 (String or nil)]
+  def binary_input_single_line_non_echo args=ARGV
+    stderr = @memory[:stderr]
+    stdin  = @memory[:stdin]
+    static_separator_key_per_execution = @memory[:static_separator_key_per_execution]
+    require "io/console"
+    stderr.print "non echo single line:"
+    args.shift.to_s.b.split(static_separator_key_per_execution).first || stdin.noecho{ stdin.gets}.chomp
+  end
+
+
+  # opens an echoing multiline prompt, if arg1 is nil or empty
+  # better prepared to work with binary input
+  # args:
+  # [ arg1 (String or nil)]
+  def binary_input_multi_line args=ARGV
+    stderr = @memory[:stderr]
+    stdin  = @memory[:stdin]
+    static_separator_key_per_execution = @memory[:static_separator_key_per_execution]
+    stderr.print "multiline[enter + control-D to stop]:"
+    args.shift.to_s.b.split(static_separator_key_per_execution).first || stdin.readlines.join
+  end
+
+
+  # opens a non-echoing multiline prompt, if arg1 is nil or empty
+  # better prepared to work with binary input (which can contain \0)
+  # args:
+  # [ arg1 (String or nil)]
+  def binary_input_multi_line_non_echo args=ARGV
+    stderr = @memory[:stderr]
+    stdin  = @memory[:stdin]
+    static_separator_key_per_execution = @memory[:static_separator_key_per_execution]
+    require "io/console"
+    # puts backtrace
+    # p args.map {|e| e.to_s[0..15] }
+    stderr.print "multiline[enter + control-D to stop]:"
+    args.shift.to_s.b.split(static_separator_key_per_execution).first || stdin.noecho{ stdin.readlines}.join.chomp
+  end
+
+
   def input_shift_or_empty_string args=ARGV, default = ''
     args.shift || default
   end
@@ -440,6 +528,7 @@ class Rubyment
   # +ending+:: [nil] deprecated
   # +base64_salt+:: [String, nil] #generate_pbkdf2_key salt encoded with Base64
   # +base64_iter+:: [String, nil] #generate_pbkdf2_key iterations encoded with Base64
+  # +data_not_base64+:: [true, false, nil] don't return base64 data -- the same +data_not_base64+ given for enc should be used.
   #
   # @return [String] decoded data
   def dec args=ARGV
@@ -447,7 +536,7 @@ class Rubyment
     require 'base64'
     memory = @memory
     static_end_key = memory[:static_end_key]
-    password, base64_iv, base64_encrypted, ending, base64_salt, base64_iter = args
+    password, base64_iv, base64_encrypted, ending, base64_salt, base64_iter, data_not_base64 = args
     salt = Base64.decode64 base64_salt
     iter = Base64.decode64 base64_iter
     ending = ending.to_s.split("\0").first || static_end_key
@@ -461,7 +550,8 @@ class Rubyment
 
     decipher.key = key || (Digest::SHA256.hexdigest password)
     decipher.iv = Base64.decode64 base64_iv
-    plain = decipher.update(Base64.decode64 base64_encrypted) + decipher.final
+    base64_plain = decipher.update(Base64.decode64 base64_encrypted) + decipher.final
+    plain = data_not_base64 && (Base64.decode64 base64_plain) || base64_plain
     # split is not the ideal, if ever ending is duplicated it won't
     # work. also may be innefficient.
     (plain.split ending).first
@@ -550,6 +640,8 @@ class Rubyment
 
   # encode data into aes-128-cbc cipher protected by a key generated
   # by #generate_pbkdf2_key, using given +password+, +salt+, +iter+
+  # By default, may not work with binary data. Set +data_not_base64+ to
+  # true (or give data already as base64) to make it work.
   #
   # @param [Array] args, an +Array+ whose elements are expected to be:
   # +password+:: [String, nil] password to be used to encryption.
@@ -557,6 +649,7 @@ class Rubyment
   # +ending+:: [nil] deprecated
   # +salt+:: [String, nil] #generate_pbkdf2_key salt argument
   # +iter+:: [String, nil] #generate_pbkdf2_key iterations argument
+  # +data_not_base64+:: [true, false, nil] data not yet in base64
   #
   # @return @param [Array] an +Array+ whose elements are expected to be:
   # +base64_encrypted+:: [String, nil] ciphered data (without metadata) encoded with Base64
@@ -570,7 +663,7 @@ class Rubyment
     require 'base64'
     memory = @memory
     static_end_key = memory[:static_end_key]
-    password, data, ending, salt, iter = args
+    password, data, ending, salt, iter, data_not_base64 = args
     ending ||= static_end_key
     key, password, salt, iter = (
       generate_pbkdf2_key [password, salt, iter]
@@ -581,7 +674,8 @@ class Rubyment
 
     cipher.key = key || (Digest::SHA256.hexdigest password)
     iv = cipher.random_iv
-    encrypted = cipher.update(data + ending) + cipher.final
+    base64_data = data_not_base64 && (Base64.encode64 data) || data
+    encrypted = cipher.update(base64_data + ending) + cipher.final
 
     base64_iv = Base64.encode64 iv
     base64_encrypted = Base64.encode64  encrypted
@@ -776,15 +870,16 @@ class Rubyment
   # echo) from @memory[:stdin], which defaults to STDIN
   # * +password+ [String, nil] password to be used to encryption.
   # If empty or nil, read (without echo) from @memory[:stdin], which defaults to STDIN
+  # +data_not_base64+:: [true, false, nil] don't return base64 data -- the same +data_not_base64+ given for enc should be used.
   #
   # @return [TrueClass, FalseClass] depending on whether test succeeds.
   def dec_interactive args=ARGV
     stderr = @memory[:stderr]
-    iv, encrypted, base64_salt, base64_iter, password  = args
+    iv, encrypted, base64_salt, base64_iter, password, data_not_base64  = args
     stderr.print "[password]"
     password = (input_single_line_non_echo [password])
     stderr.puts
-    dec [password, iv, encrypted, nil, base64_salt, base64_iter]
+    dec [password, iv, encrypted, nil, base64_salt, base64_iter, data_not_base64]
   end
 
 
@@ -839,7 +934,7 @@ class Rubyment
     stderr.puts "# programmatically:"
     stderr.puts "dec " + dec_args.to_s
     stderr.puts "# shell: "
-    stderr.puts "rubyment invoke_double p dec " + (output_array_to_shell dec_args).to_s
+    stderr.puts "#{$0} invoke_double p dec " + (output_array_to_shell dec_args).to_s
     data_plain = dec [password, base64_iv, base64_encrypted, nil, base64_salt, base64_iter]
     judgement =
       [
@@ -848,18 +943,60 @@ class Rubyment
   end
 
 
+  # output encrypted data (and data required to
+  # decrypt) into encrypted_base64_filename
+  def output_enc_file args=ARGV
+    stderr = @memory[:stderr]
+    require 'json'
+    require 'base64'
+    base64_iv, base64_encrypted, base64_salt, base64_iter, encrypted_base64_filename = args
+    metadata = {
+      "metadata"  => "Metadata",
+      "base64_iv" => base64_iv,
+      "base64_encrypted" => base64_encrypted,
+      "base64_salt" => base64_salt,
+      "base64_iter" => base64_iter,
+    }
+    base64_json_serialized_data =  Base64.encode64 JSON.pretty_generate metadata
+    File.write encrypted_base64_filename, base64_json_serialized_data
+    stderr.puts "# File written: \n# #{encrypted_base64_filename}"
+  end
+
+
+  # output encrypted data (and data required to
+  # decrypt) into encrypted_base64_filename
+  def output_dec_file args=ARGV
+    stderr = @memory[:stderr]
+    require 'json'
+    require 'base64'
+    enc_filename_or_url, out_filename, password, data_is_base64 = args
+    base64_json_serialized_data = file_or_url_contents enc_filename_or_url
+
+    metadata = JSON.parse Base64.decode64 base64_json_serialized_data
+    base64_iv = metadata["base64_iv"]
+    base64_encrypted = metadata["base64_encrypted"]
+    base64_salt = metadata["base64_salt"]
+    base64_iter = metadata["base64_iter"]
+    base64_key  = metadata["base64_key" ]
+    ending = nil
+    pw_plain = binary_dec [password, base64_iv, base64_encrypted, ending, base64_salt, base64_iter, data_is_base64]
+    File.write out_filename, pw_plain
+    stderr.puts "# File written: \n# #{out_filename}"
+  end
+
+
   # test for enc and dec_interactive.
   # good idea is to use this function once with the desired
   # data, password, and use the stderr output
   def test__enc_dec_interactive args=ARGV
     stderr = @memory[:stderr]
-    data, password = args
+    data, password, encrypted_base64_filename, data_not_base64 = args
     stderr.print "[data]"
     data = input_multi_line_non_echo [data]
     stderr.print "[password]"
     password = input_single_line_non_echo [password]
     stderr.puts
-    base64_encrypted, base64_iv, base64_salt, base64_iter, base64_key = enc [password, data]
+    base64_encrypted, base64_iv, base64_salt, base64_iter, base64_key = enc [password, data, nil, nil, nil, data_not_base64 ]
     # the output is supposed to be safe to store,
     # so password is not placed in from dec_interactive_args:
     dec_interactive_args = [base64_iv, base64_encrypted, base64_salt, base64_iter]
@@ -869,7 +1006,8 @@ class Rubyment
     stderr.puts "#{$0} invoke_double puts dec_interactive " + (output_array_to_shell dec_interactive_args).to_s
     stderr.puts "#or shell var:"
     stderr.puts "my_secret=$(#{$0} invoke_double puts dec_interactive " + (output_array_to_shell dec_interactive_args).to_s + ")\necho $my_secret\nunset mysecret"
-    data_plain = dec_interactive(dec_interactive_args + [password])
+    encrypted_base64_filename && output_enc_file(dec_interactive_args  + [encrypted_base64_filename])
+    data_plain = dec_interactive(dec_interactive_args + [password, data_not_base64])
     judgement =
       [
         [data, data_plain, "data"]
@@ -877,6 +1015,272 @@ class Rubyment
   end
 
 
+  # similar to
+  # test__enc_dec_interactive,
+  # just that the data is ready from a file instead
+  # note that there is an extra argument between
+  # the args, the enc_out_filename.
+  def test__enc_dec_file_interactive args=ARGV
+    stderr = @memory[:stderr]
+    filename_or_url, enc_out_filename, password, data_not_base64 = args
+    stderr.print "[filename_or_url]"
+    filename_or_url = input_multi_line_non_echo [filename_or_url]
+    stderr.print "[output_filename_encrypted_data]"
+    enc_out_filename = input_multi_line_non_echo [enc_out_filename ]
+    data =  file_or_url_contents filename_or_url
+    test__enc_dec_interactive [ data, password, enc_out_filename, data_not_base64 ]
+  end
+
+
+  # basically the reverse of test__enc_dec_file_interactive
+  # planned improvements: still outputs to stdout
+  def test__dec_file_interactive args=ARGV
+    stderr = @memory[:stderr]
+    enc_filename_or_url, out_filename, password, data_not_base64 = args
+    stderr.print "[enc_filename_or_url]"
+    enc_filename_or_url = input_multi_line_non_echo [enc_filename_or_url]
+    stderr.print "[output_filename_plain_data]"
+    out_filename = input_multi_line_non_echo [out_filename ]
+    stderr.print "[password]"
+    password = input_single_line_non_echo [password]
+    data =  file_or_url_contents enc_filename_or_url
+    require 'json'
+    require 'base64'
+    base64_json_serialized_data = data
+    metadata = JSON.parse Base64.decode64 base64_json_serialized_data
+    base64_iv = metadata["base64_iv"]
+    base64_encrypted = metadata["base64_encrypted"]
+    base64_salt = metadata["base64_salt"]
+    base64_iter = metadata["base64_iter"]
+    base64_key  = metadata["base64_key" ]
+    ending = nil
+    pw_plain = dec [password, base64_iv, base64_encrypted, ending, base64_salt, base64_iter, data_not_base64]
+    shell_dec_output [pw_plain]
+  end
+
+
+  # encode data into aes-128-cbc cipher protected by a key generated
+  # by #generate_pbkdf2_key, using given +password+, +salt+, +iter+
+  # By default, must work with binary data. Set +data_is_base64+ to
+  # true (or give data already as base64) to achieve the original
+  # behavior of enc(), and avoid one encoding operation on data.
+  #
+  # @param [Array] args, an +Array+ whose elements are expected to be:
+  # +password+:: [String, nil] password to be used to encryption.
+  # +data+:: [String, nil] data to be encoded data
+  # +ending+:: [nil] deprecated
+  # +salt+:: [String, nil] #generate_pbkdf2_key salt argument
+  # +iter+:: [String, nil] #generate_pbkdf2_key iterations argument
+  # +data_is_base64+:: [true, false, nil] data already in base64 
+  # 
+  #
+  # @return @param [Array] an +Array+ whose elements are expected to be:
+  # +base64_encrypted+:: [String, nil] ciphered data (without metadata) encoded with Base64
+  # +base64_iv+:: [String] initialization vectors encoded with Base64
+  # +base64_salt+:: [String] #generate_pbkdf2_key salt encoded with Base64
+  # +base64_iter+:: [String] #generate_pbkdf2_key iterations encoded with Base64
+  # +base64_key+::  [String] #generate_pbkdf2_key return value
+  #
+  def binary_enc args=ARGV
+    require 'openssl'
+    require 'base64'
+    memory = @memory
+    static_end_key = memory[:static_end_key] + "_binary"
+    password, data, ending, salt, iter, data_is_base64 = args
+    ending ||= static_end_key
+    key, password, salt, iter = (
+      generate_pbkdf2_key [password, salt, iter]
+    )|| [nil, password, salt, iter]
+
+    cipher = OpenSSL::Cipher.new('aes-128-cbc')
+    cipher.encrypt
+
+    cipher.key = key || (Digest::SHA256.hexdigest password)
+    iv = cipher.random_iv
+    base64_data = data_is_base64 && (Base64.encode64 data) || data
+    encrypted = cipher.update(base64_data + ending) + cipher.final
+
+    base64_iv = Base64.encode64 iv
+    base64_encrypted = Base64.encode64  encrypted
+    base64_salt = Base64.encode64 salt.to_s
+    base64_iter = Base64.encode64 iter.to_s
+    base64_key = Base64.encode64 key.to_s
+
+    [base64_encrypted, base64_iv,  base64_salt, base64_iter, base64_key]
+  end
+
+
+  # decipher the data encoded by binary_enc
+  #
+  # @param [Array] args, an +Array+ whose elements are expected to be:
+  # +password+:: [String, nil] password to be used to encryption.
+  # +base64_iv+:: [String, nil] initialization vectors encoded with Base64
+  # +base64_encrypted+:: [String, nil] ciphered data (without metadata) encoded with Base64
+  # +ending+:: [nil] deprecated
+  # +base64_salt+:: [String, nil] #generate_pbkdf2_key salt encoded with Base64
+  # +base64_iter+:: [String, nil] #generate_pbkdf2_key iterations encoded with Base64
+  # +data_is_base64+:: [true, false, nil] return base64 data -- the same +data_is_base64+ given for enc should be used.
+  #
+  # @return [String] decoded data
+  def binary_dec args=ARGV
+    require 'openssl'
+    require 'base64'
+    memory = @memory
+    static_end_key = memory[:static_end_key] + "_binary"
+    password, base64_iv, base64_encrypted, ending, base64_salt, base64_iter, data_is_base64 = args
+    salt = Base64.decode64 base64_salt
+    iter = Base64.decode64 base64_iter
+    # FIXME: don't split on \0
+    ending = ending.to_s.split("\0").first || static_end_key
+    key, password, salt, iter =  (
+      generate_pbkdf2_key [password, salt, iter]
+    )|| [nil, password, salt, iter]
+
+    decipher = OpenSSL::Cipher.new('aes-128-cbc')
+    decipher.decrypt
+    decipher.padding = 0
+
+    decipher.key = key || (Digest::SHA256.hexdigest password)
+    decipher.iv = Base64.decode64 base64_iv
+    base64_plain = decipher.update(Base64.decode64 base64_encrypted) + decipher.final
+    plain = data_is_base64 && (Base64.decode64 base64_plain) || base64_plain
+    # split is not the ideal, if ever ending is duplicated it won't
+    # work. also may be innefficient.
+    (plain.split ending).first
+
+  end
+
+
+  # an alternative interface to binary_dec -- reads password if
+  # nil or empty.
+  #
+  # @param [Array] args Defaults to +ARGV+. Elements:
+  # * +data+ [String, nil] data to be encrypted, If empty or nil, read (without
+  # echo) from @memory[:stdin], which defaults to STDIN
+  # * +password+ [String, nil] password to be used to encryption.
+  # If empty or nil, read (without echo) from @memory[:stdin], which defaults to STDIN
+  # +data_is_base64+:: [true, false, nil] return base64 data -- the same +data_is_base64+ given for enc should be used.
+  #
+  # @return [TrueClass, FalseClass] depending on whether test succeeds.
+  def binary_dec_interactive args=ARGV
+    stderr = @memory[:stderr]
+    iv, encrypted, base64_salt, base64_iter, password, data_is_base64  = args
+    stderr.print "[password]"
+    password = (input_single_line_non_echo [password])
+    stderr.puts
+    binary_dec [password, iv, encrypted, nil, base64_salt, base64_iter, data_is_base64]
+  end
+
+
+  # test for binary_enc and binary_dec.
+  # "" and nil are expected to be treated
+  # as the same.
+  def test__binary_enc_dec_nil args=ARGV
+    nil_case = binary_dec [nil, "ltUQIxgRAeUNXPNTTps8FQ==\n", "xyeqxw/TzkyXtOxpDqAl58SNAvXPyNZ89B5JGtwDkcbjo0vObgPsh5FrgZJs\nHPjofsyXnljnTrHpDoQeDVezo9wBZ74NU+TSi/GssX605oE=\n", nil, "TU4o3IKiFWki3rZ3lMchLQ==\n", "MjAwMDA=\n"]
+    empty = binary_dec ["", "ltUQIxgRAeUNXPNTTps8FQ==\n", "xyeqxw/TzkyXtOxpDqAl58SNAvXPyNZ89B5JGtwDkcbjo0vObgPsh5FrgZJs\nHPjofsyXnljnTrHpDoQeDVezo9wBZ74NU+TSi/GssX605oE=\n", "", "TU4o3IKiFWki3rZ3lMchLQ==\n", "MjAwMDA=\n"]
+    judgement =
+      [
+        [nil_case, empty, "empty_nil_equality"]
+      ].map(&method("expect_equal")).all?
+  end
+
+
+  # test for binary_enc and binary_dec.
+  #
+  # @param [Array] args, an +Array+ whose elements are expected to be:
+  # +data+:: [String, nil] data to be encrypted.
+  # If empty or nil, read (without echo) from @memory[:stdin], which defaults to STDIN
+  # +password+:: [String, nil] password to be used to encryption.
+  # If empty or nil, read (without echo) from @memory[:stdin], which defaults to STDIN
+  #
+  # @return [TrueClass, FalseClass] depending on whether test succeeds.
+  def test__binary_enc_dec args=ARGV
+    stderr = @memory[:stderr]
+    data, password = args
+    stderr.print "[data]"
+    data = binary_input_multi_line_non_echo [data]
+    stderr.print "[password]"
+    password = binary_input_single_line_non_echo [password]
+    base64_encrypted, base64_iv, base64_salt, base64_iter, base64_key = binary_enc [password, data]
+    dec_args = [password, base64_iv, base64_encrypted, nil, base64_salt, base64_iter]
+    stderr.puts "# WARNING: secrets, including password are printed here. Storing them may be a major security incident."
+    stderr.puts "# programmatically:"
+    stderr.puts "binary_dec " + dec_args.to_s
+    stderr.puts "# shell: "
+    stderr.puts "#{$0} invoke_double p binary_dec " + (output_array_to_shell dec_args).to_s
+    data_plain = binary_dec [password, base64_iv, base64_encrypted, nil, base64_salt, base64_iter]
+    judgement =
+      [
+        [data, data_plain, "data"]
+      ].map(&method("expect_equal")).all?
+  end
+
+
+  # test for binary_enc and binary_dec_interactive.
+  # good idea is to use this function once with the desired
+  # data, password, and use the stderr output
+  def test__binary_enc_dec_interactive args=ARGV
+    stderr = @memory[:stderr]
+    data, password, encrypted_base64_filename, data_is_base64 = args
+    stderr.print "[data]"
+    data =  binary_input_multi_line_non_echo [data]
+    stderr.print "[password]"
+    password = binary_input_single_line_non_echo [password]
+    stderr.puts
+    base64_encrypted, base64_iv, base64_salt, base64_iter, base64_key = binary_enc [password, data, nil, nil, nil, data_is_base64 ]
+    # the output is supposed to be safe to store,
+    # so password is not placed in from binary_dec_interactive_args:
+    dec_interactive_args = [base64_iv, base64_encrypted, base64_salt, base64_iter]
+    stderr.puts "# programmatically:"
+    stderr.puts "dec_interactive " + dec_interactive_args.to_s
+    stderr.puts "# shell: "
+    stderr.puts "#{$0} invoke_double puts binary_dec_interactive " + (output_array_to_shell dec_interactive_args).to_s
+    stderr.puts "#or shell var:"
+    stderr.puts "my_secret=$(#{$0} invoke_double puts binary_dec_interactive " + (output_array_to_shell dec_interactive_args).to_s + ")\necho $my_secret\nunset mysecret"
+    encrypted_base64_filename && output_enc_file(dec_interactive_args  + [encrypted_base64_filename])
+    data_plain = binary_dec_interactive(dec_interactive_args + [password, data_is_base64])
+    judgement =
+      [
+        [data.size, data_plain.size, "data.size"],
+        [data, data_plain, "data"],
+      ].map(&method("expect_equal")).all?
+  end
+
+
+  # similar to
+  # test__binary_enc_dec_interactive,
+  # just that the data is ready from a file instead
+  # note that there is an extra argument between
+  # the args, the enc_out_filename.
+  def test__binary_enc_dec_file_interactive args=ARGV
+    stderr = @memory[:stderr]
+    filename_or_url, enc_out_filename, password, data_is_base64 = args
+    stderr.print "[filename_or_url]"
+    filename_or_url = binary_input_multi_line_non_echo [filename_or_url]
+    stderr.print "[output_filename_encrypted_data]"
+    enc_out_filename = binary_input_multi_line_non_echo [enc_out_filename ]
+    data =  file_or_url_contents filename_or_url
+    test__binary_enc_dec_interactive [ data, password, enc_out_filename, data_is_base64 ]
+  end
+
+
+  # basically the reverse of test__binary_enc_dec_file_interactive
+  # planned improvements: still outputs to stdout
+  def test__binary_dec_file_interactive args=ARGV
+    stderr = @memory[:stderr]
+    stdout = @memory[:stdout]
+    enc_filename_or_url, out_filename, password, data_is_base64 = args
+    stderr.print "[enc_filename_or_url]"
+    enc_filename_or_url = binary_input_multi_line_non_echo [enc_filename_or_url]
+    stderr.print "[output_filename_plain_data]"
+    out_filename = binary_input_multi_line_non_echo [out_filename ]
+    stderr.print "[password]"
+    password = binary_input_single_line_non_echo [password]
+
+    output_dec_file [enc_filename_or_url, out_filename, password, data_is_base64]
+  end
+
+
   # gem_spec
   # args (Array like the one returned by rubyment_gem_defaults)
   # returns: a gem spec string accordingly to args

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubyment
 version: !ruby/object:Gem::Version
-  version: 0.5.25438564
+  version: 0.5.25471659
 platform: ruby
 authors:
 - Ribamar Santarosa