Crear un hash md5 de un número, cadena, matriz o hash en Ruby

digest

Question

Necesito crear una cadena de firma para una variable en Ruby, donde la variable puede ser un número, una cadena, un hash o una matriz. Los valores de hash y los elementos de matriz también pueden ser cualquiera de estos tipos.

Esta cadena se usará para comparar los valores en una base de datos (Mongo, en este caso).

Lo primero que pensé fue crear un valor hash MD5 de un valor codificado JSON, así: (body es la variable mencionada anteriormente)

def createsig(body)    
  Digest::MD5.hexdigest(JSON.generate(body))
end

Esto casi funciona, pero JSON.generate no codifica las claves de un hash en el mismo orden cada vez, por lo que createsig({:a=>''a'',:b=>''b''}) no siempre es igual a createsig({:b=>''b'',:a=>''a''}) .

¿Cuál es la mejor manera de crear una cadena de firma que se ajuste a esta necesidad?

Nota: para el detalle orientado entre nosotros, sé que no puede JSON.generate() un número o una cadena. En estos casos, simplemente llamaría a MD5.hexdigest() directamente.

Answer 1

Aquí está mi solución. Camino por la estructura de datos y construyo una lista de piezas que se unen en una sola cadena. Para garantizar que los tipos de clases observados afecten al hash, inyecto un único carácter Unicode que codifica información de tipo básico a lo largo del camino. (Por ejemplo, queremos ["1", "2", "3"]. Objsum! = [1,2,3] .objsum)

Lo hice como un refinamiento en Object, es fácilmente portado a un parche de mono. Para usarlo solo necesita el archivo y ejecuta "usando ObjSum".

module ObjSum
  refine Object do
    def objsum
      parts = []
      queue = [self]

      while queue.size > 0
        item = queue.shift

        if item.kind_of?(Hash)
          parts << "//000"
          item.keys.sort.each do |k| 
            queue << k
            queue << item[k]
          end
        elsif item.kind_of?(Set)
          parts << "//001"
          item.to_a.sort.each { |i| queue << i }
        elsif item.kind_of?(Enumerable)
          parts << "//002"
          item.each { |i| queue << i }
        elsif item.kind_of?(Fixnum)
          parts << "//003"
          parts << item.to_s
        elsif item.kind_of?(Float)
          parts << "//004"
          parts << item.to_s
        else
          parts << item.to_s
        end
      end

      Digest::MD5.hexdigest(parts.join)
    end
  end
end

Answer 2

Dependiendo de tus necesidades, puedes llamar a ary.inspect o ary.to_yaml , incluso.

Answer 3

Estoy codificando lo siguiente bastante rápido y no tengo tiempo para probarlo realmente en el trabajo, pero debería hacer el trabajo. Avíseme si encuentra algún problema y lo revisaré.

Esto debería aplanarse y ordenar las matrices y los hash, y tendrías que tener algunas cuerdas bastante extrañas para que haya colisiones.

def createsig(body)
  Digest::MD5.hexdigest( sigflat body )
end

def sigflat(body)
  if body.class == Hash
    arr = []
    body.each do |key, value|
      arr << "#{sigflat key}=>#{sigflat value}"
    end
    body = arr
  end
  if body.class == Array
    str = ''''
    body.map! do |value|
      sigflat value
    end.sort!.each do |value|
      str << value
    end
  end
  if body.class != String
    body = body.to_s << body.class.to_s
  end
  body
end

> sigflat({:a => {:b => ''b'', :c => ''c''}, :d => ''d''}) == sigflat({:d => ''d'', :a => {:c => ''c'', :b => ''b''}})
=> true

Answer 4

Si solo pudieras obtener una representación de cuerdas del body y no hacer que el hash Ruby 1.8 volviera con diferentes órdenes de una vez a la otra, podrías hash confiablemente esa representación de cadena. Vamos a ensuciarnos las manos con algunos parches de mono:

require ''digest/md5''

class Object
  def md5key
    to_s
  end
end

class Array
  def md5key
    map(&:md5key).join
  end
end

class Hash
  def md5key
    sort.map(&:md5key).join
  end
end

Ahora cualquier objeto (de los tipos mencionados en la pregunta) responde a md5key devolviendo una clave confiable para usarla para crear una suma de comprobación, entonces:

def createsig(o)
  Digest::MD5.hexdigest(o.md5key)
end

Ejemplo:

body = [
  {
    ''bar'' => [
      345,
      "baz",
    ],
    ''qux'' => 7,
  },
  "foo",
  123,
]
p body.md5key        # => "bar345bazqux7foo123"
p createsig(body)    # => "3a92036374de88118faf19483fe2572e"

Nota: Esta representación hash no codifica la estructura, solo la concatenación de los valores. Por lo tanto, ["a", "b", "c"] marcará lo mismo que ["abc"].

Answer 5

Solo mis 2 centavos:

module Ext
  module Hash
    module InstanceMethods
      # Return a string suitable for generating content signature.
      # Signature image does not depend on order of keys.
      #
      #   {:a => 1, :b => 2}.signature_image == {:b => 2, :a => 1}.signature_image                  # => true
      #   {{:a => 1, :b => 2} => 3}.signature_image == {{:b => 2, :a => 1} => 3}.signature_image    # => true
      #   etc.
      #
      # NOTE: Signature images of identical content generated under different versions of Ruby are NOT GUARANTEED to be identical.
      def signature_image
        # Store normalized key-value pairs here.
        ar = []

        each do |k, v|
          ar << [
            k.is_a?(::Hash) ? k.signature_image : [k.class.to_s, k.inspect].join(":"),
            v.is_a?(::Hash) ? v.signature_image : [v.class.to_s, v.inspect].join(":"),
          ]
        end

        ar.sort.inspect
      end
    end
  end
end

class Hash    #:nodoc:
  include Ext::Hash::InstanceMethods
end