webrisk_hash 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8631f253b88cecc677f4bc8123206df7a64a965525427c2222dbfecebf24343c
+  data.tar.gz: fb2c962b83d841558efe64c520c128d028e8e2f647069c73739ccb4c2a4c77cb
+SHA512:
+  metadata.gz: cc355aa0482853a46d86d08e5d6b6495b7ef9cbe12aaa343c24baf2cb9a18ce0bb81be30aeb98f1cbfdd9d1202764d39a8de42fdb3d4d9c659ff118bcc5f928a
+  data.tar.gz: dbe039e198022dffabcc59b2e854cd42050464a8c0c2941d96806eb201b1f0e4055efe363ac345d8094e6fd33959f46303f613fc379954d779c9c24972ca2272

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 AADS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,159 @@
+# WebriskHash
+
+This Ruby gem implements the URL hashing and canonicalization algorithm described in
+the Google Web Risk documentation: https://cloud.google.com/web-risk/docs/urls-hashing
+
+## Overview
+
+The Web Risk API uses URL hashing to check URLs against threat lists. This gem implements
+the complete hashing process:
+
+1. **Canonicalization** - Normalize URLs by removing fragments, resolving percent-encoding,
+   normalizing IP addresses, and more
+2. **Suffix/Prefix Generation** - Create up to 30 host/path combinations from each URL
+3. **Hash Computation** - Generate SHA256 hashes for each combination
+4. **Prefix Extraction** - Extract hash prefixes (4-32 bytes) for efficient lookup
+
+## Features
+
+- **URL Canonicalization** (`WebriskHash.canonicalize`)
+  - Removes tab (0x09), CR (0x0d), LF (0x0a) characters
+  - Removes URL fragments
+  - Repeatedly percent-unescapes URLs until no more escapes remain
+  - Normalizes IP addresses (decimal, hex, octal, and dotted variants)
+  - Converts Internationalized Domain Names (IDN) to ASCII (Punycode)
+  - Resolves path segments (/../ and /./)
+  - Collapses consecutive slashes in paths
+  - Removes default ports (80 for HTTP, 443 for HTTPS)
+  - Percent-escapes characters <= ASCII 32, >= 127, #, and %
+  - Preserves query parameters without path canonicalization
+
+- **Suffix/Prefix Expression Generation** (`WebriskHash.suffix_postfix_expressions`)
+  - Up to 5 host suffix variations (exact hostname + up to 4 from last 5 components)
+  - Up to 6 path prefix variations (with/without query + progressive paths)
+  - Combines to create up to 30 expressions per URL
+  - IP addresses use only exact hostname (no suffix variations)
+  - Handles query parameters correctly
+
+- **SHA256 Hash Prefixes** (`WebriskHash.get_prefixes`, `WebriskHash.get_prefix_map`)
+  - FIPS-180-2 compliant SHA256 hashing
+  - Configurable prefix lengths (4-32 bytes = 32-256 bits)
+  - Hash prefix extraction from most significant bytes
+
+## Installation
+
+Add to your `Gemfile`:
+
+```ruby
+gem "webrisk_hash"
+```
+
+Or install and run locally:
+
+```bash
+bundle install
+```
+
+## Usage Examples
+
+### Basic Usage
+
+```ruby
+require "webrisk_hash"
+
+url = "http://example.com/path/to/page?query=1"
+
+# Step 1: Canonicalize the URL
+canonical = WebriskHash.canonicalize(url)
+# => "http://example.com/path/to/page?query=1"
+
+# Step 2: Get hash prefixes (default 256 bits = 32 bytes)
+prefixes = WebriskHash.get_prefixes(url)
+# => #<Set: {"\xAB\xCD...(32 bytes)", ...}>
+
+# Display as hex
+puts prefixes.to_a.map { |p| p.unpack1("H*") }
+```
+
+### Working with Suffix/Prefix Expressions
+
+```ruby
+# Generate all suffix/prefix expressions for a URL
+canonical = WebriskHash.canonicalize("http://a.b.c/1/2.html?param=1")
+expressions = WebriskHash.suffix_postfix_expressions(canonical)
+
+puts "Total expressions: #{expressions.size}"
+expressions.each { |expr| puts "  #{expr}" }
+
+# Output:
+# Total expressions: 8
+#   a.b.c/1/2.html?param=1
+#   a.b.c/1/2.html
+#   a.b.c/1/
+#   a.b.c/
+#   b.c/1/2.html?param=1
+#   b.c/1/2.html
+#   b.c/1/
+#   b.c/
+```
+
+### Getting Hash Prefixes with Custom Length
+
+```ruby
+# Get 32-bit (4 byte) hash prefixes instead of full 256-bit hashes
+prefixes_32bit = WebriskHash.get_prefixes(url, 32)
+
+# Get detailed mapping of expressions to hashes
+map = WebriskHash.get_prefix_map(url, 32)
+map.each do |expression, prefix_bin|
+  hex_prefix = prefix_bin.unpack1('H*')
+  puts "#{expression} -> #{hex_prefix}"
+end
+```
+
+### Canonicalization Examples
+
+```ruby
+# Remove control characters
+WebriskHash.canonicalize("http://google.com/foo\tbar\rbaz\n2")
+# => "http://google.com/foobarbaz2"
+
+# Percent-unescape repeatedly
+WebriskHash.canonicalize("http://host/%25%32%35")
+# => "http://host/%25"
+
+# Normalize IP addresses
+WebriskHash.canonicalize("http://3279880203/blah")
+# => "http://195.127.0.11/blah"
+
+# Resolve path segments
+WebriskHash.canonicalize("http://google.com/blah/..")
+# => "http://google.com/"
+
+# Remove fragments
+WebriskHash.canonicalize("http://evil.com/foo#bar")
+# => "http://evil.com/foo"
+
+# Lowercase hostname
+WebriskHash.canonicalize("http://www.GOOgle.com/")
+# => "http://www.google.com/"
+```
+
+## Development
+
+Install dependencies and run tests:
+
+```bash
+bundle install
+rake spec
+```
+
+For interactive debugging use:
+
+```bash
+bin/console
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/webrisk_hash/canonicalizer.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module WebriskHash
+  # URL Canonicalization for Web Risk API
+  #
+  # Implements the canonicalization process described in the Web Risk API documentation:
+  # https://cloud.google.com/web-risk/docs/urls-hashing#canonicalization
+  #
+  # The canonicalization process includes:
+  # 1. Parse URL according to RFC 2396 (convert IDN to ASCII Punycode if needed)
+  # 2. Remove tab (0x09), CR (0x0d), and LF (0x0a) characters
+  # 3. Remove URL fragments
+  # 4. Repeatedly percent-unescape until no more percent-escapes
+  # 5. Normalize hostname:
+  #    - Remove leading/trailing dots
+  #    - Replace consecutive dots with single dot
+  #    - Parse and normalize IP addresses (handle octal, hex, decimal)
+  #    - Lowercase the entire hostname
+  # 6. Canonicalize path:
+  #    - Resolve /../ and /./ sequences
+  #    - Replace consecutive slashes with single slash
+  # 7. Percent-escape characters <= ASCII 32, >= 127, #, and %
+  # 8. Do NOT apply path canonicalization to query parameters
+  # 9. Remove default ports (80 for HTTP, 443 for HTTPS)
+  #
+  # @see https://cloud.google.com/web-risk/docs/urls-hashing#canonicalization
+  module Canonicalizer
+    extend self
+
+    # Canonicalize a URL according to Web Risk API specification
+    #
+    # @param url [String] The URL to canonicalize
+    # @return [String, nil] The canonicalized URL or nil if invalid
+    #
+    # @example
+    #   canonicalize("http://host/%25%32%35")
+    #   # => "http://host/%25"
+    #
+    #   canonicalize("http://www.GOOgle.com/")
+    #   # => "http://www.google.com/"
+    #
+    #   canonicalize("http://3279880203/blah")
+    #   # => "http://195.127.0.11/blah"
+    #
+    def canonicalize(url)
+      return nil if url.nil?
+
+      raw = url.dup.force_encoding(Encoding::BINARY)
+      raw = raw.gsub(/[\t\r\n]/, '')
+      raw = raw.sub(/\A +/n, '').sub(/ +\z/n, '')
+      url_with_scheme = raw.include?('://') ? raw : "http://#{raw}"
+      url_with_scheme = url_with_scheme.gsub(%r{(?<=://)([^/]*)}) { |auth| auth.gsub(' ', '%20') }
+
+      begin
+        a = Addressable::URI.parse(url_with_scheme)
+      rescue StandardError
+        return nil
+      end
+
+      schema = a.scheme
+      if a.user
+        a.user + (a.password ? ":#{a.password}" : '')
+      end
+      host = a.host
+      after_scheme = url_with_scheme.sub(%r{\A[^:]+://}, '')
+      slash_idx = after_scheme.index('/')
+      path_and_query = slash_idx ? after_scheme[slash_idx..] : '/'
+
+      path_and_query = path_and_query.split('#', 2)[0]
+
+      if path_and_query.include?('?')
+        raw_path, raw_query = path_and_query.split('?', 2)
+      else
+        raw_path = path_and_query
+        raw_query = nil
+      end
+      path = raw_path && !raw_path.empty? ? raw_path : '/'
+      query = raw_query
+
+      return nil if schema.nil? || host.nil? || host.length > 255
+
+      host_decoded = custom_decode_uri_component(normalize_ip_address(host)).gsub(/[\t\x0a\x0d]/, '')
+
+      begin
+        host_ascii = if /[^\x00-\x7F]/.match?(host_decoded)
+                       Addressable::IDNA.to_ascii(host_decoded)
+                     else
+                       host_decoded
+                     end
+      rescue StandardError
+        host_ascii = host_decoded
+      end
+
+      normalized_host = webrisk_uri_escape(host_ascii)
+      normalized_host = normalized_host.squeeze('.').gsub(/\A\.+|\.+\z/, '').downcase
+
+      normalized_path = normalize_component_encoding(normalize_dots_in_paths(path))
+      normalized_path = "#{normalized_path}/" if path.end_with?('/') && !normalized_path.end_with?('/')
+
+      normalized_query = query ? "?#{query}" : ''
+
+      "#{schema}://#{normalized_host}#{normalized_path}#{normalized_query}"
+    end
+
+    def int2ip(ip_int)
+      num = ip_int.to_i
+      [(num >> 24) & 255, (num >> 16) & 255, (num >> 8) & 255, num & 255].join('.')
+    end
+
+    def normalize_ip_address(c)
+      begin
+        parts = c.split('.')
+        parse_part = lambda do |p|
+          if /^0x/i.match?(p)
+            Integer(p)
+          elsif p =~ /^0[0-9]+$/ && p.length > 1
+            Integer(p, 8)
+          else
+            Integer(p)
+          end
+        end
+
+        if parts.length == 1
+          n = parse_part.call(parts[0])
+          return int2ip(n) if n.between?(0, 0xFFFFFFFF)
+        elsif parts.length <= 4 && parts.all? { |p| p =~ /^([0-9]+|0x[0-9a-fA-F]+|0[0-7]*)$/ }
+          nums = parts.map { |p| parse_part.call(p) }
+          ip_int = case nums.length
+                   when 1
+                     nums[0]
+                   when 2
+                     (nums[0] << 24) | (nums[1] & 0xFFFFFF)
+                   when 3
+                     (nums[0] << 24) | ((nums[1] & 0xFF) << 16) | (nums[2] & 0xFFFF)
+                   when 4
+                     (nums[0] << 24) | ((nums[1] & 0xFF) << 16) | ((nums[2] & 0xFF) << 8) | (nums[3] & 0xFF)
+                   end
+          return int2ip(ip_int) if ip_int.between?(0, 0xFFFFFFFF)
+        end
+      rescue StandardError
+        nil
+      end
+      c
+    end
+
+    def normalize_component_encoding(c)
+      value = c
+      prev_value = nil
+      1000.times do
+        prev_value = value
+        value = custom_decode_uri_component(prev_value).gsub(/[\t\x0a\x0d]/, '')
+        break if value == prev_value
+      end
+      webrisk_uri_escape(value)
+    end
+
+    def normalize_dots_in_paths(path)
+      segments = path.split('/')
+      new_segments = []
+      empty_or_dot = ['', '.'].freeze
+      segments.each do |seg|
+        next if empty_or_dot.include?(seg)
+
+        if seg == '..'
+          new_segments.pop unless new_segments.empty?
+        else
+          new_segments << seg
+        end
+      end
+      result = "/#{new_segments.join('/')}"
+      result == '' ? '/' : result
+    end
+
+    def custom_decode_uri_component(input)
+      replace_map = { '%FE%FF' => "\uFFFD\uFFFD", '%FF%FE' => "\uFFFD\uFFFD" }
+      multi_matcher = /((?:%[a-f0-9]{2})+)/i
+      input.scan(multi_matcher).flatten.each do |match|
+        replace_map[match] = URI.decode_www_form_component(match)
+      rescue StandardError
+        decoded = safe_decode(match)
+        replace_map[match] = decoded if decoded != match
+      end
+      replace_map['%C2'] = "\uFFFD"
+      replace_map.each do |k, v|
+        input = input.gsub(Regexp.new(Regexp.escape(k), Regexp::IGNORECASE), v)
+      end
+      input
+    end
+
+    def safe_decode(input)
+      tokens = input.scan(/%[a-f0-9]{2}/i).map { |t| t }
+      (1..tokens.length).each do |split|
+        left = tokens[0, split]
+        right = tokens[split..] || []
+        begin
+          return URI.decode_www_form_component((left + right).join)
+        rescue StandardError
+          next
+        end
+      end
+      input
+    end
+
+    def escape_character(code)
+      chr = code.chr(Encoding::UTF_8)
+      if code < 256
+        if code < 16
+          format('%%%02X', code)
+        elsif code <= 32 || code > 127 || chr == '%' || chr == '#'
+          format('%%%02X', code)
+        else
+          chr
+        end
+      else
+        escape_character(code >> 8) + escape_character(code % 256)
+      end
+    end
+
+    def webrisk_uri_escape(s)
+      out = +''
+      i = 0
+      while i < s.length
+        c = s[i]
+        if c == '%' && s[i + 1] && s[i + 2] && s[(i + 1)..(i + 2)] =~ /^[0-9a-fA-F]{2}$/
+          out << '%' << s[(i + 1)..(i + 2)].upcase
+          i += 3
+          next
+        end
+        out << escape_character(c.ord)
+        i += 1
+      end
+      out
+    end
+  end
+end

data/lib/webrisk_hash/hash.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module WebriskHash
+  module Hash
+    extend self
+
+    # Compute SHA256 hash and return truncated prefix
+    #
+    # For Web Risk, a hash prefix consists of the most significant 4-32 bytes
+    # of a SHA256 hash (32 to 256 bits)
+    #
+    # @param str [String] The string to hash (suffix/prefix expression)
+    # @param bits [Integer] Number of bits to return (will be converted to bytes)
+    # @return [String] Binary string containing the hash prefix
+    #
+    # @example FIPS-180-2 Example B1 (32 bits)
+    #   truncated_sha256_prefix("abc", 32)
+    #   # => "\xBA\x78\x16\xBF" (4 bytes)
+    #   # Full SHA256: ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
+    #
+    # @example FIPS-180-2 Example B2 (48 bits)
+    #   input = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
+    #   truncated_sha256_prefix(input, 48)
+    #   # => "\x24\x8D\x6A\x61\xD2\x06" (6 bytes)
+    #   # Full SHA256: 248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1
+    #
+    def truncated_sha256_prefix(str, bits)
+      len = bits / 8
+      digest = ::Digest::SHA256.digest(str)
+      digest.byteslice(0, len)
+    end
+  end
+end

data/lib/webrisk_hash/prefixes.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module WebriskHash
+  module Prefixes
+    extend self
+
+    # Get hash prefix map for a URL
+    #
+    # Returns an array of [expression, hash_prefix] pairs for all
+    # suffix/prefix expressions of the URL
+    #
+    # @param url [String] The URL to process
+    # @param size [Integer] Hash prefix size in bits (default: 256 bits = 32 bytes)
+    # @return [Array<Array>] Array of [expression, hash_prefix] pairs
+    #
+    # @example
+    #   get_prefix_map("http://a.b.c/1/2.html?param=1")
+    #   # => [
+    #   #      ["a.b.c/1/2.html?param=1", "\xAB\xCD..."],
+    #   #      ["a.b.c/1/2.html", "\x12\x34..."],
+    #   #      ...
+    #   #    ]
+    #
+    def get_prefix_map(url, size = 32 * 8)
+      canonical = WebriskHash.canonicalize(url)
+      return [] if canonical.nil?
+
+      WebriskHash.suffix_postfix_expressions(canonical).to_a.map { |u| [u, WebriskHash::Hash.truncated_sha256_prefix(u, size)] }
+    end
+
+    # Get hash prefixes for a URL
+    #
+    # Returns a set of hash prefixes for all suffix/prefix expressions
+    # of the URL. This is the main method used to check URLs against
+    # Web Risk lists.
+    #
+    # @param url [String] The URL to process
+    # @param size [Integer] Hash prefix size in bits (default: 256 bits = 32 bytes)
+    # @return [Set<String>] Set of binary hash prefixes
+    #
+    # @example Get 32-bit hash prefixes
+    #   get_prefixes("http://evil.com/malware", 32)
+    #   # => #<Set: {"\xAB\xCD\xEF\x12", "\x34\x56\x78\x90", ...}>
+    #
+    # @example Get full 256-bit hashes (default)
+    #   get_prefixes("http://example.com/")
+    #   # => #<Set: {"\xAB\xCD...(32 bytes)", ...}>
+    #
+    def get_prefixes(url, size = 32 * 8)
+      canonical = WebriskHash.canonicalize(url)
+      return Set.new if canonical.nil?
+
+      Set.new(WebriskHash.suffix_postfix_expressions(canonical).to_a.map do |u|
+        WebriskHash::Hash.truncated_sha256_prefix(u, size)
+      end)
+    end
+  end
+end

data/lib/webrisk_hash/suffixes.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module WebriskHash
+  # Suffix/Prefix Expression Generation for Web Risk API
+  #
+  # Generates all possible host suffix and path prefix combinations for a canonicalized URL.
+  # These combinations are used to create the expressions that will be hashed and checked
+  # against Web Risk lists.
+  #
+  # The process follows the Web Risk API specification:
+  # https://cloud.google.com/web-risk/docs/urls-hashing#suffixprefix-expressions
+  #
+  # @see https://cloud.google.com/web-risk/docs/urls-hashing#suffixprefix-expressions
+  module Suffixes
+    extend self
+
+    # Generate suffix/prefix expressions for a canonicalized URL
+    #
+    # Returns up to 30 different host suffix and path prefix combinations.
+    # Only the host and path components are used; scheme, username, password,
+    # and port are discarded.
+    #
+    # For the host, tries at most 5 different strings:
+    # 1. The exact hostname in the URL
+    # 2. Up to 4 hostnames formed by starting with the last 5 components
+    #    and successively removing the leading component
+    # Note: Additional hostnames are not checked if the host is an IP address
+    #
+    # For the path, tries at most 6 different strings:
+    # 1. The exact path of the URL, including query parameters
+    # 2. The exact path of the URL, without query parameters
+    # 3-6. The four paths formed by starting at root (/) and
+    #      successively appending path components, including trailing slash
+    #
+    # @param canonical_url [String] The canonicalized URL
+    # @return [Set<String>] Set of suffix/prefix expressions (host/path combinations)
+    #
+    # @example For http://a.b.c/1/2.html?param=1
+    #   suffix_postfix_expressions("http://a.b.c/1/2.html?param=1")
+    #   # => Set with 8 expressions:
+    #   # ["a.b.c/1/2.html?param=1", "a.b.c/1/2.html", "a.b.c/", "a.b.c/1/",
+    #   #  "b.c/1/2.html?param=1", "b.c/1/2.html", "b.c/", "b.c/1/"]
+    #
+    # @example For http://a.b.c.d.e.f.g/1.html
+    #   suffix_postfix_expressions("http://a.b.c.d.e.f.g/1.html")
+    #   # => Set with 10 expressions (5 host suffixes × 2 path prefixes)
+    #   # Note: b.c.d.e.f.g is skipped (only last 5 components used)
+    #
+    # @example For http://1.2.3.4/1/
+    #   suffix_postfix_expressions("http://1.2.3.4/1/")
+    #   # => Set with 2 expressions:
+    #   # ["1.2.3.4/1/", "1.2.3.4/"]
+    #   # (IP addresses only use exact hostname)
+    #
+    def suffix_postfix_expressions(canonical_url)
+      return Set.new unless canonical_url
+
+      u = canonical_url.sub(%r{^[^:]+://}, '')
+      host, rest = u.split('/', 2)
+      path_and_query = "/#{rest || ''}"
+
+      if path_and_query.include?('?')
+        path, query = path_and_query.split('?', 2)
+      else
+        path = path_and_query
+        query = nil
+      end
+
+      host_suffixes = generate_host_suffixes(host)
+      path_prefixes = generate_path_prefixes(path, query)
+
+      results = []
+      host_suffixes.each do |h|
+        path_prefixes.each do |p|
+          results << (h + p)
+        end
+      end
+
+      Set.new(results)
+    end
+
+    private
+
+    def generate_host_suffixes(host)
+      return [host] if ip_address?(host)
+
+      suffixes = []
+      parts = host.split('.')
+
+      suffixes << host
+
+      if parts.length > 1
+        relevant_parts = parts.length > 5 ? parts[-5..] : parts
+
+        (2..relevant_parts.length).each do |num_components|
+          suffix = relevant_parts[-num_components..].join('.')
+          suffixes << suffix unless suffix == host
+          break if suffixes.length >= 5
+        end
+      end
+
+      suffixes.take(5)
+    end
+
+    def generate_path_prefixes(path, query)
+      prefixes = []
+
+      prefixes << "#{path}?#{query}" if query
+      prefixes << path unless prefixes.include?(path)
+
+      if path != '/'
+        segments = path.split('/').reject(&:empty?)
+        current = '/'
+
+        segments.each_with_index do |segment, index|
+          break if prefixes.length >= 6
+
+          current += segment
+          current += '/' if index < segments.length - 1 || path.end_with?('/')
+
+          prefixes << current unless prefixes.include?(current)
+        end
+      end
+
+      prefixes << '/' if !prefixes.include?('/') && prefixes.length < 6
+
+      prefixes.take(6)
+    end
+
+    def ip_address?(host)
+      host =~ /^(\d+\.){3}\d+$/
+    end
+  end
+end

data/lib/webrisk_hash/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module WebriskHash
+  VERSION = '0.1.0'
+end

data/lib/webrisk_hash.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'webrisk_hash/version'
+
+require 'addressable/uri'
+require 'digest'
+require 'uri'
+
+module WebriskHash
+  require_relative 'webrisk_hash/canonicalizer'
+  require_relative 'webrisk_hash/suffixes'
+  require_relative 'webrisk_hash/hash'
+  require_relative 'webrisk_hash/prefixes'
+
+  extend WebriskHash::Canonicalizer
+  extend WebriskHash::Suffixes
+  extend WebriskHash::Hash
+  extend WebriskHash::Prefixes
+end

data/sig/webrisk_hash.rbs

@@ -0,0 +1,4 @@
+module WebriskHash
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: webrisk_hash
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- AADS team
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+description: 'This Ruby gem implements the URL hashing and canonicalization algorithm
+  described in the Google Web Risk documentation: https://cloud.google.com/web-risk/docs/urls-hashing'
+email:
+- support@aads.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/webrisk_hash.rb
+- lib/webrisk_hash/canonicalizer.rb
+- lib/webrisk_hash/hash.rb
+- lib/webrisk_hash/prefixes.rb
+- lib/webrisk_hash/suffixes.rb
+- lib/webrisk_hash/version.rb
+- sig/webrisk_hash.rbs
+homepage: https://github.com/a-ads/webrisk_hash
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/a-ads/webrisk_hash
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Ruby gem implementation of the algorithm described in the Google Web Risk
+  documentation
+test_files: []