Class: Zxcvbn::Score

Inherits:
Data
  • Object
show all
Defined in:
lib/zxcvbn/score.rb,
sig/zxcvbn/score.rbs

Overview

The result of analysing a password — returned by test.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(calc_time: nil, feedback: nil, **kwargs) ⇒ Score

Returns a new instance of Score.



26
27
28
 
# File 'lib/zxcvbn/score.rb', line 26

def initialize(calc_time: nil, feedback: nil, **kwargs)
  super(calc_time:, feedback:, **kwargs)
end

Instance Attribute Details

#calc_time ⇒ Float? (readonly)

Returns time taken to evaluate, in seconds.

Returns:

  • (Float, nil) —

    time taken to evaluate, in seconds



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/zxcvbn/score.rb', line 22

Score = ::Data.define(
  :password, :guesses, :sequence, :crack_times_seconds,
  :crack_times_display, :score, :calc_time, :feedback
) do
  def initialize(calc_time: nil, feedback: nil, **kwargs)
    super(calc_time:, feedback:, **kwargs)
  end

  # @return [String] a human-readable representation omitting nil fields and password
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :password }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @return [Float, nil] log10 of {#guesses}, or nil if guesses is not set
  def guesses_log10
    ::Math.log10(guesses) if guesses
  end
end

#crack_times_display ⇒ Hash{String => String} (readonly)

Returns human-readable crack times per scenario.

Returns:

  • (Hash{String => String}) —

    human-readable crack times per scenario



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/zxcvbn/score.rb', line 22

Score = ::Data.define(
  :password, :guesses, :sequence, :crack_times_seconds,
  :crack_times_display, :score, :calc_time, :feedback
) do
  def initialize(calc_time: nil, feedback: nil, **kwargs)
    super(calc_time:, feedback:, **kwargs)
  end

  # @return [String] a human-readable representation omitting nil fields and password
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :password }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @return [Float, nil] log10 of {#guesses}, or nil if guesses is not set
  def guesses_log10
    ::Math.log10(guesses) if guesses
  end
end

#crack_times_seconds ⇒ Hash{String => Float} (readonly)

Returns crack time in seconds per attack scenario.

Returns:

  • (Hash{String => Float}) —

    crack time in seconds per attack scenario



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/zxcvbn/score.rb', line 22

Score = ::Data.define(
  :password, :guesses, :sequence, :crack_times_seconds,
  :crack_times_display, :score, :calc_time, :feedback
) do
  def initialize(calc_time: nil, feedback: nil, **kwargs)
    super(calc_time:, feedback:, **kwargs)
  end

  # @return [String] a human-readable representation omitting nil fields and password
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :password }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @return [Float, nil] log10 of {#guesses}, or nil if guesses is not set
  def guesses_log10
    ::Math.log10(guesses) if guesses
  end
end

#feedback ⇒ Feedback? (readonly)

Returns human-readable feedback for low-scoring passwords.

Returns:

  • (Feedback, nil) —

    human-readable feedback for low-scoring passwords



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/zxcvbn/score.rb', line 22

Score = ::Data.define(
  :password, :guesses, :sequence, :crack_times_seconds,
  :crack_times_display, :score, :calc_time, :feedback
) do
  def initialize(calc_time: nil, feedback: nil, **kwargs)
    super(calc_time:, feedback:, **kwargs)
  end

  # @return [String] a human-readable representation omitting nil fields and password
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :password }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @return [Float, nil] log10 of {#guesses}, or nil if guesses is not set
  def guesses_log10
    ::Math.log10(guesses) if guesses
  end
end

#guesses ⇒ Numeric (readonly)

Returns estimated number of guesses to crack the password.

Returns:

  • (Numeric) —

    estimated number of guesses to crack the password



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/zxcvbn/score.rb', line 22

Score = ::Data.define(
  :password, :guesses, :sequence, :crack_times_seconds,
  :crack_times_display, :score, :calc_time, :feedback
) do
  def initialize(calc_time: nil, feedback: nil, **kwargs)
    super(calc_time:, feedback:, **kwargs)
  end

  # @return [String] a human-readable representation omitting nil fields and password
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :password }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @return [Float, nil] log10 of {#guesses}, or nil if guesses is not set
  def guesses_log10
    ::Math.log10(guesses) if guesses
  end
end

#password ⇒ String (readonly)

Returns the password that was evaluated.

Returns:

  • (String) —

    the password that was evaluated



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/zxcvbn/score.rb', line 22

Score = ::Data.define(
  :password, :guesses, :sequence, :crack_times_seconds,
  :crack_times_display, :score, :calc_time, :feedback
) do
  def initialize(calc_time: nil, feedback: nil, **kwargs)
    super(calc_time:, feedback:, **kwargs)
  end

  # @return [String] a human-readable representation omitting nil fields and password
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :password }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @return [Float, nil] log10 of {#guesses}, or nil if guesses is not set
  def guesses_log10
    ::Math.log10(guesses) if guesses
  end
end

#score ⇒ Integer (readonly)

Returns 0–4 score (0 = very weak, 4 = very strong).

Returns:

  • (Integer) —

    0–4 score (0 = very weak, 4 = very strong)



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/zxcvbn/score.rb', line 22

Score = ::Data.define(
  :password, :guesses, :sequence, :crack_times_seconds,
  :crack_times_display, :score, :calc_time, :feedback
) do
  def initialize(calc_time: nil, feedback: nil, **kwargs)
    super(calc_time:, feedback:, **kwargs)
  end

  # @return [String] a human-readable representation omitting nil fields and password
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :password }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @return [Float, nil] log10 of {#guesses}, or nil if guesses is not set
  def guesses_log10
    ::Math.log10(guesses) if guesses
  end
end

#sequence ⇒ Array<Match> (readonly)

Returns the optimal match sequence.

Returns:

  • (Array<Match>) —

    the optimal match sequence



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/zxcvbn/score.rb', line 22

Score = ::Data.define(
  :password, :guesses, :sequence, :crack_times_seconds,
  :crack_times_display, :score, :calc_time, :feedback
) do
  def initialize(calc_time: nil, feedback: nil, **kwargs)
    super(calc_time:, feedback:, **kwargs)
  end

  # @return [String] a human-readable representation omitting nil fields and password
  def inspect
    fields = to_h.reject { |k, v| v.nil? || k == :password }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
    "#<data #{self.class} #{fields}>"
  end

  # @return [Float, nil] log10 of {#guesses}, or nil if guesses is not set
  def guesses_log10
    ::Math.log10(guesses) if guesses
  end
end

Class Method Details

.new ⇒ Object 



3
 
# File 'sig/zxcvbn/score.rbs', line 3

def self.new: (

Instance Method Details

#guesses_log10 ⇒ Float?

Returns log10 of #guesses, or nil if guesses is not set.

Returns:

  • (Float, nil) —

    log10 of #guesses, or nil if guesses is not set



37
38
39
 
# File 'lib/zxcvbn/score.rb', line 37

def guesses_log10
  ::Math.log10(guesses) if guesses
end

#inspect ⇒ String

Returns a human-readable representation omitting nil fields and password.

Returns:

  • (String) —

    a human-readable representation omitting nil fields and password



31
32
33
34
 
# File 'lib/zxcvbn/score.rb', line 31

def inspect
  fields = to_h.reject { |k, v| v.nil? || k == :password }.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
  "#<data #{self.class} #{fields}>"
end

#with ⇒ instance

Parameters:

  • (Object)

Returns:

  • (instance) 


24
 
# File 'sig/zxcvbn/score.rbs', line 24

def with: (**untyped) -> instance