class Digest::SHA2


sha2.hexdigest # => “ab530a13e…”
sha2 << “message”
sha2.reset
# Use the same object to compute another digest
sha2.hexdigest # => “ba7816bf8…”
sha2 << “c” # alias for #update
sha2.update “ab”
sha2 = Digest::SHA2.new # =>#<Digest::SHA2:256>
# Compute digest by chunks
Digest::SHA512.hexdigest ‘abc’ # => “ddaf35a19…”
Digest::SHA2.new(512).hexdigest ‘abc’ # => “ddaf35a19…”
Digest::SHA384.hexdigest ‘abc’ # => “cb00753f4…”
Digest::SHA2.new(384).hexdigest ‘abc’ # => “cb00753f4…”
Digest::SHA256.hexdigest ‘abc’ # => “ba7816bf8…”
Digest::SHA2.new(256).hexdigest ‘abc’ # => “ba7816bf8…”
Digest::SHA2.hexdigest ‘abc’ # => “ba7816bf8…”
# Compute a complete digest
require ‘digest’
==Examples
digest (SHA512).
* and one which works on chunks of 1024 bits and returns a 512-bit
digest (SHA384),
* one which works on chunks of 1024 bits and returns a 384-bit
digest (SHA256),
* one which works on chunks of 512 bits and returns a 256-bit
three algorithms:
FIPS 180-2 describes SHA2 family of digest algorithms. It defines
A meta digest provider class for SHA256, SHA384 and SHA512.

def block_length

# => 1024
Digest::SHA512.new.block_length * 8
# => 1024
Digest::SHA384.new.block_length * 8
# => 512
Digest::SHA256.new.block_length * 8

Return the block length of the digest in bytes.

digest_obj.block_length -> Integer
call-seq: 
def block_length
  @sha2.block_length
end

def digest_length

(256 bits) in size.
For example, digests produced by Digest::SHA256 will always be 32 bytes

# => 512
Digest::SHA512.new.digest_length * 8
# => 384
Digest::SHA384.new.digest_length * 8
# => 256
Digest::SHA256.new.digest_length * 8

Return the length of the hash value (the digest) in bytes.

digest_obj.digest_length -> Integer
call-seq: 
def digest_length
  @sha2.digest_length
end

def finish # :nodoc:

:nodoc: 
def finish # :nodoc:
  @sha2.digest!
end

def initialize(bitlen = 256)

Valid bit lengths are 256, 384 and 512.

Create a new SHA2 hash object with a given bit length.

Digest::SHA2.new(bitlen = 256) -> digest_obj
call-seq: 
def initialize(bitlen = 256)
  case bitlen
  when 256
    @sha2 = Digest::SHA256.new
  when 384
    @sha2 = Digest::SHA384.new
  when 512
    @sha2 = Digest::SHA512.new
  else
    raise ArgumentError, "unsupported bit length: %s" % bitlen.inspect
  end
  @bitlen = bitlen
end

def initialize_copy(other) # :nodoc:

:nodoc: 
def initialize_copy(other) # :nodoc:
  @sha2 = other.instance_eval { @sha2.clone }
end

def inspect # :nodoc:

:nodoc: 
def inspect # :nodoc:
  "#<%s:%d %s>" % [self.class.name, @bitlen, hexdigest]
end

def reset

Reset the digest to the initial state and return self.

digest_obj.reset -> digest_obj
call-seq: 
def reset
  @sha2.reset
  self
end

def update(str)

Update the digest using a given _string_ and return self.

digest_obj << string -> digest_obj
digest_obj.update(string) -> digest_obj
call-seq: 
def update(str)
  @sha2.update(str)
  self
end