From: sam jam <lists@...>
Date: 2012-05-11T16:20:21+09:00
Subject: Re: passing via instance variable or regular ()

Using @ does have advantages as well though. Using () to pass variables
internally within the class leads to less readable code I think. For one
you need to pass variables down the chain even if you are not using them
at each point down the chain. That makes for very ugly code versus using
@ to leap frog methods.

I do see the benefit you mention about needing to call first before you
call last. In the following case

  def first
    name = "sam"
    last(name)
  end

   def last(first)
     name = first + " " + "jam"
   end

I could call last from some other class or method. But in some cases I
see no advantage here. Sometimes when I make classes they are for very
specific tasks, a bunch of methods that make up a larger system. The
steps for that system always need to be called in order. I suppose if I
wanted to reuse the steps in other places it would be best to use ().

I also noticed Robert mentioning that he would avoid using the name
variable as it is only used once. This brings me to a second question.
Sometimes I find that using variables in this way can improve code
readability as well. Perhaps I am writing a Feistel cipher and it makes
sense to name parts @l and @r during the encryption rounds. The
resulting cipher or plaintext is then @l + @r. I then need to remove the
padding from the resulting plaintext, so even though I pass @l and @r
only once to the remove padding method, it makes sense to say

ciphertext = @l + @r
remove_padding(ciphertext)

or is this needlessly cluttering my code with variables? I see a lot of
times in my code I use an = sign like this, to make it read more
clearly, but sometimes I also find myself doing it needlessly. How do
you feel about this?

Also in my code I did this instead

@ciphertext = @l + @r
remove_padding(@ciphertext)

I find that using instance variables helped me make the following code
look nicer

[code]

require 'openssl'
require 'narray'


class Lioness

  def initialize
    @block_size_in_kb = 100
    @hash_algorithm = OpenSSL::Digest::SHA256.new
  end

  def xor_strings(string1, string2)
    string1 = NArray.to_na(string1, "byte")
    string2 = NArray.to_na(string2, "byte")
    (string1 ^ string2).to_s
  end

  def generate_subkeys(key)

    @subkeys = Hash.new

    4.times do |i|
      @subkeys.store("key#{i}", @hash_algorithm.digest("#{i} #{key}"))
      @hash_algorithm.reset

    end
  end


  def pad_message(message)

    if message.bytesize == (@block_size_in_kb * 1000) then
    @padded_plaintext = message
    else
    bytes_to_pad = (@block_size_in_kb * 1000) - message.bytesize
    @padded_plaintext = message + 128.chr + ("\0" * (bytes_to_pad - 1))
    end
  end

  def remove_padding(message)
    if message.index("#{128.chr}") then
    padding_starts = message.index("#{128.chr}")
    @plaintext = message.byteslice(0...padding_starts)
    else
    @plaintext = message
    end
  end

  def encrypt(plaintext, key)

    if plaintext.bytesize > (@block_size_in_kb * 1000) then
    puts "Message size must be below #{@block_size_in_kb} kilobytes"
    end


    if plaintext.bytesize <= (@block_size_in_kb * 1000) then

    pad_message(plaintext)
    generate_subkeys(key)

    @l, @r = @padded_plaintext.byteslice(0..(@sha256.digest_length -
1)), @padded_plaintext.byteslice(@sha256.digest_length..-1)

    r_operation(@subkeys["key0"])
    l_operation(@subkeys["key1"])
    r_operation(@subkeys["key2"])
    l_operation(@subkeys["key3"])

    @ciphertext = @l + @r
    end
  end

  def decrypt(plaintext, key)

    generate_subkeys(key)
    @l, @r = plaintext.byteslice(0..(@hash_algorithm.digest_length -
1)), plaintext.byteslice(@hash_algorithm.digest_length..-1)

    l_operation(@subkeys["key3"])
    r_operation(@subkeys["key2"])
    l_operation(@subkeys["key1"])
    r_operation(@subkeys["key0"])

    padded_plaintext = @l + @r
    remove_padding(padded_plaintext)
  end

  def r_operation(subkey)
    cipher = OpenSSL::Cipher::Cipher.new 'AES-256-CTR'
    cipher.encrypt
    cipher.key = xor_strings(@l, subkey)
    ciphertext = cipher.update(@r)
    ciphertext << cipher.final
    @r = ciphertext
  end

  def l_operation(subkey)
    @l = xor_strings(@l, @hash_algorithm.digest(subkey + @r + subkey))
    @hash_algorithm.reset
  end

end
[/code]

-- 
Posted via http://www.ruby-forum.com/.