class Digest::SHA2 - Documentation for Ruby 4.1
Description: class Digest::SHA2: A meta digest provider class for SHA256, SHA384 and SHA512. FIPS 180-2 describes SHA2 family of digest algorithms.
Keywords: ruby,class,Digest::SHA2

🔍

No recent searches

# class Digest::SHA2

A meta digest provider class for `SHA256`, `SHA384` and `SHA512`.

FIPS 180-2 describes `SHA2` family of digest algorithms. It defines three algorithms:

- one which works on chunks of 512 bits and returns a 256-bit digest (`SHA256`),

- one which works on chunks of 1024 bits and returns a 384-bit digest (`SHA384`),

- and one which works on chunks of 1024 bits and returns a 512-bit digest (`SHA512`).

## Examples

    require 'digest'

    # Compute a complete digest
    Digest::SHA2.hexdigest 'abc'          # => "ba7816bf8..."
    Digest::SHA2.new(256).hexdigest 'abc' # => "ba7816bf8..."
    Digest::SHA256.hexdigest 'abc'        # => "ba7816bf8..."

    Digest::SHA2.new(384).hexdigest 'abc' # => "cb00753f4..."
    Digest::SHA384.hexdigest 'abc'        # => "cb00753f4..."

    Digest::SHA2.new(512).hexdigest 'abc' # => "ddaf35a19..."
    Digest::SHA512.hexdigest 'abc'        # => "ddaf35a19..."

    # Compute digest by chunks
    sha2 = Digest::SHA2.new               # =>#<Digest::SHA2:256>
    sha2.update "ab"
    sha2 << "c"                           # alias for #update
    sha2.hexdigest                        # => "ba7816bf8..."

    # Use the same object to compute another digest
    sha2.reset
    sha2 << "message"
    sha2.hexdigest                        # => "ab530a13e..."

### Public Class Methods

Digest::SHA2.new(bitlen = 256) → digest_obj
Source

    # File ext/digest/sha2/lib/sha2.rb, line 61
    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

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

Valid bit lengths are 256, 384 and 512.

### Public Instance Methods

digest_obj << string → digest_obj
Alias for: update
block_length → Integer
Source

    # File ext/digest/sha2/lib/sha2.rb, line 112
    def block_length
      @sha2.block_length
    end

Return the block length of the digest in bytes.

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

digest_length → Integer
Source

    # File ext/digest/sha2/lib/sha2.rb, line 130
    def digest_length
      @sha2.digest_length
    end

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

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

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

reset → digest_obj
Source

    # File ext/digest/sha2/lib/sha2.rb, line 79
    def reset
      @sha2.reset
      self
    end

Reset the digest to the initial state and return self.

update(string) → digest_obj
Source

    # File ext/digest/sha2/lib/sha2.rb, line 89
    def update(str)
      @sha2.update(str)
      self
    end

Update the digest using a given string and return self.

Also aliased as: <<

### Private Instance Methods

instance_eval { finish } → digest_obj
Source

    static VALUE
    rb_digest_instance_finish(VALUE self)
    {
        rb_digest_instance_method_unimpl(self, "finish");

        UNREACHABLE;
    }

Finishes the digest and returns the resulting hash value.

This method is overridden by each implementation subclass and often made private, because some of those subclasses may leave internal data uninitialized. Do not call this method from outside. Use `digest!()` instead, which ensures that internal data be reset for security reasons.