aws_public_ips 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 91231fd301e6aec59763e203fd32c2d985974a4b
+  data.tar.gz: 340477b64151aeba0a89115b9f507ecd9283c9cc
+SHA512:
+  metadata.gz: dc5775856d160fdfb16b6f2cb141ea242cedf35468e47889ad2b1b9f86c2d82825d3bc6aa1fb1aec0299a75e1954930d5af12f3b726245140fd82e934cbc7625
+  data.tar.gz: f02119924a590ce33d2999143217592071f7fb65cd2632222a5c36d99fa18fcb005460bbb5c208fce16b913a5586ab66931b295f9315d4abb67c6d1cfd3ef5e0

data/bin/aws_public_ips

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path(File.join('..', '..', 'lib'), __FILE__))
+
+require 'bundler/setup'
+require 'aws_public_ips/cli'
+
+AwsPublicIps::CLI.new.run(ARGV)

data/lib/aws_public_ips.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module AwsPublicIps
+end
+
+require 'aws_public_ips/checks'
+require 'aws_public_ips/cli'
+require 'aws_public_ips/formatters'
+require 'aws_public_ips/utils'
+require 'aws_public_ips/version'

data/lib/aws_public_ips/checks.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module AwsPublicIps
+  module Checks
+  end
+end
+
+require 'aws_public_ips/checks/apigateway'
+require 'aws_public_ips/checks/cloudfront'
+require 'aws_public_ips/checks/ec2'
+require 'aws_public_ips/checks/elasticsearch'
+require 'aws_public_ips/checks/elb'
+require 'aws_public_ips/checks/elbv2'
+require 'aws_public_ips/checks/lightsail'
+require 'aws_public_ips/checks/rds'
+require 'aws_public_ips/checks/redshift'

data/lib/aws_public_ips/checks/apigateway.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-apigateway'
+require 'aws_public_ips/utils'
+
+module AwsPublicIps
+  module Checks
+    module Apigateway
+      def self.run
+        client = Aws::APIGateway::Client.new
+
+        # TODO(arkadiy) https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-private-integration.html
+
+        # APIGateway doesn't return the full domain in the response, we have to build
+        # it using the api id and region
+        client.get_rest_apis.flat_map do |response|
+          response.items.map do |api|
+            hostname = "#{api.id}.execute-api.#{client.config.region}.amazonaws.com"
+            {
+              id: api.id,
+              hostname: hostname,
+              ip_addresses: Utils.resolve_hostname(hostname)
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws_public_ips/checks/cloudfront.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-cloudfront'
+require 'aws_public_ips/utils'
+
+module AwsPublicIps
+  module Checks
+    module Cloudfront
+      def self.run
+        client = Aws::CloudFront::Client.new
+
+        client.list_distributions.flat_map do |response|
+          response.distribution_list.items.flat_map do |distribution|
+            {
+              id: distribution.id,
+              hostname: distribution.domain_name,
+              ip_addresses: Utils.resolve_hostname(distribution.domain_name)
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws_public_ips/checks/ec2.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-ec2'
+
+module AwsPublicIps
+  module Checks
+    module Ec2
+      def self.run
+        client = Aws::EC2::Client.new
+
+        # TODO(arkadiy) confirm this covers Batch, Fargate
+        # Iterate over all EC2 instances. This will include those from EC2, ECS, EKS, Fargate, Batch,
+        # Beanstalk, and NAT Instances
+        # It will not include NAT Gateways (IPv4) or Egress Only Internet Gateways (IPv6), but they do not allow
+        # ingress traffic so we skip them anyway
+        client.describe_instances.flat_map do |response|
+          response.reservations.flat_map do |reservation|
+            reservation.instances.map do |instance|
+              # EC2-Classic instances have a `public_ip_address` and no `network_interfaces`
+              # EC2-VPC instances both set, so we uniq the ip addresses
+              ip_addresses = [instance.public_ip_address].compact + instance.network_interfaces.flat_map do |interface|
+                public_ip = interface.association ? [interface.association.public_ip].compact : []
+                public_ip + interface.ipv_6_addresses.map(&:ipv_6_address)
+              end
+
+              # If hostname is empty string, canonicalize to nil
+              hostname = instance.public_dns_name.empty? ? nil : instance.public_dns_name
+              {
+                id: instance.instance_id,
+                hostname: hostname,
+                ip_addresses: ip_addresses.uniq
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws_public_ips/checks/elasticsearch.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-elasticsearchservice'
+require 'aws_public_ips/utils'
+
+module AwsPublicIps
+  module Checks
+    module Elasticsearch
+      def self.run
+        client = Aws::ElasticsearchService::Client.new
+
+        # ElasticSearch instances can be launched publicly or into VPCs. Public instances have a
+        # `domain_status.endpoint` hostname and VPC instances have a `domain_status.endpoints['vpc']` hostname.
+        # However VPC ElasticSearch instances create their own Network Interface and AWS will not allow you
+        # to associate an Elastic IP to it. As a result VPC ElasticSearch instances are always private, even with an
+        # internet gateway.
+
+        client.list_domain_names.flat_map do |response|
+          response.domain_names.flat_map do |domain_name|
+            client.describe_elasticsearch_domain(domain_name: domain_name.domain_name).map do |domain|
+              hostname = domain.domain_status.endpoint
+              next unless hostname
+              {
+                id: domain.domain_status.domain_id,
+                hostname: hostname,
+                ip_addresses: Utils.resolve_hostname(hostname)
+              }
+            end.compact
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws_public_ips/checks/elb.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-elasticloadbalancing'
+require 'aws_public_ips/utils'
+
+module AwsPublicIps
+  module Checks
+    module Elb
+      def self.run
+        client = Aws::ElasticLoadBalancing::Client.new
+
+        # EC2-Classic load balancers are only returned by the 'elasticloadbalancing' API, and
+        # EC2-VPC ALBs/NLBs are only returned by the 'elasticloadbalancingv2' API
+        client.describe_load_balancers.flat_map do |response|
+          response.load_balancer_descriptions.flat_map do |load_balancer|
+            next [] unless load_balancer.scheme == 'internet-facing'
+            {
+              id: load_balancer.canonical_hosted_zone_name_id,
+              hostname: load_balancer.dns_name,
+              # EC2-Classic load balancers get IPv6 DNS records created but they are not returned by the API
+              ip_addresses: Utils.resolve_hostnames([load_balancer.dns_name, "ipv6.#{load_balancer.dns_name}"])
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws_public_ips/checks/elbv2.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-elasticloadbalancingv2'
+require 'aws_public_ips/utils'
+
+module AwsPublicIps
+  module Checks
+    module Elbv2
+      def self.run
+        client = Aws::ElasticLoadBalancingV2::Client.new
+
+        # EC2-Classic load balancers are only returned by the 'elasticloadbalancing' API, and
+        # EC2-VPC ALBs/NLBs are only returned by the 'elasticloadbalancingv2' API
+
+        # NLBs only support IPv4
+        # ALBs support IPv4 or dualstack. Unlike Classic ELBs which have a separate IPv6 DNS name,
+        # dualstack ALBs only have a single DNS name
+        client.describe_load_balancers.flat_map do |response|
+          response.load_balancers.flat_map do |load_balancer|
+            next [] unless load_balancer.scheme == 'internet-facing'
+            {
+              id: load_balancer.canonical_hosted_zone_id,
+              hostname: load_balancer.dns_name,
+              ip_addresses: Utils.resolve_hostname(load_balancer.dns_name)
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws_public_ips/checks/lightsail.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-lightsail'
+require 'aws_public_ips/utils'
+
+module AwsPublicIps
+  module Checks
+    module Lightsail
+      def self.run
+        client = Aws::Lightsail::Client.new
+
+        # Lightsail instances are always exposed directly, and can also be put behind a load balancer
+
+        instances = client.get_instances.flat_map do |response|
+          response.instances.map do |instance|
+            {
+              # Names are unique
+              id: instance.name,
+              hostname: nil,
+              ip_addresses: [instance.public_ip_address]
+            }
+          end
+        end
+
+        load_balancers = client.get_load_balancers.flat_map do |response|
+          response.load_balancers.map do |load_balancer|
+            {
+              # Names are unique
+              id: load_balancer.name,
+              hostname: load_balancer.dns_name,
+              ip_addresses: Utils.resolve_hostname(load_balancer.dns_name)
+            }
+          end
+        end
+
+        instances + load_balancers
+      end
+    end
+  end
+end

data/lib/aws_public_ips/checks/rds.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-rds'
+require 'aws_public_ips/utils'
+
+module AwsPublicIps
+  module Checks
+    module Rds
+      def self.run
+        client = Aws::RDS::Client.new
+
+        # TODO(arkadiy) not sure if this is true anymore after redshift, do more testing
+        # RDS instances can be:
+        # - launched into classic
+        # - launched into VPC
+        # - launched into a VPC but marked as `publicly_accessible`, in which case the VPC must have an Internet
+        # Gateway attached, and the DNS endpoint will resolve to a public ip address
+        client.describe_db_instances.flat_map do |response|
+          response.db_instances.flat_map do |instance|
+            next [] unless instance.publicly_accessible
+            {
+              id: instance.dbi_resource_id,
+              hostname: instance.endpoint.address,
+              ip_addresses: Utils.resolve_hostname(instance.endpoint.address)
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws_public_ips/checks/redshift.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-redshift'
+
+module AwsPublicIps
+  module Checks
+    module Redshift
+      def self.run
+        client = Aws::Redshift::Client.new
+
+        # TODO(arkadiy) update copy from RDS
+        # Redshift clusters can only be launched into VPCs. They can be marked as `publicly_accessible`,
+        # in which case the VPC must have an Internet Gateway attached, and the DNS endpoint will
+        # resolve to a public ip address
+        client.describe_clusters.flat_map do |response|
+          response.clusters.flat_map do |cluster|
+            next [] unless cluster.publicly_accessible
+            {
+              id: cluster.cluster_identifier,
+              hostname: cluster.endpoint.address,
+              ip_addresses: cluster.cluster_nodes.map(&:public_ip_address)
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws_public_ips/cli.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module AwsPublicIps
+  class CLI
+    # Supported services:
+    # EC2 (and as a result: ECS, EKS, Beanstalk, Fargate, Batch, & NAT Instances)
+    # ELB (Classic ELB)
+    # ELBv2 (ALB/NLB)
+    # RDS
+    # Redshift
+    # APIGateway
+    # CloudFront
+    # Lightsail
+    # ElasticSearch
+
+    # Services that don't need to be supported:
+    # S3 - all s3 buckets resolve to the same ip addresses
+    # SQS - there's a single AWS-owned domain per region (i.e. sqs.us-east-1.amazonaws.com/<account_id>/<queue_name>)
+    # NAT Gateways - these do not allow ingress traffic
+    # ElastiCache - all elasticache instances are private. You can make one public by using a NAT instance with an EIP:
+    # https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/accessing-elasticache.html#access-from-outside-aws
+    # but NAT instances are EC2 machines, so this will be caught by the EC2 check.
+    # DynamoDB - no public endpoints
+    # SNS - no public endpoints
+    # Elastic Transcoder - no public endpoints
+    # Athena - no public endpoints
+
+    # Services that maybe have public endpoints / still need testing:
+    # fargate
+    # amazonmq
+    # directory service (AD)
+    # emr
+    # Directconnect
+    # Kinesis
+    # SES
+    # https://aws.amazon.com/products/
+    # AWS Neptune (still in preview / not GA yet)
+
+    def all_services
+      @all_services ||= Dir['lib/aws_public_ips/checks/*.rb'].map { |path| File.basename(path, '.rb') }.sort
+    end
+
+    def all_formats
+      @all_formats ||= Dir['lib/aws_public_ips/formatters/*.rb'].map { |path| File.basename(path, '.rb') }.sort
+    end
+
+    def parse(args)
+      options = {
+        format: 'text',
+        services: all_services,
+        verbose: false
+      }
+
+      OptionParser.new do |opts|
+        opts.banner = 'Usage: aws_public_ips [options]'
+
+        opts.on('-s', '--services <s1>,<s2>,<s3>', Array, 'List of AWS services to check. Available services: ' \
+          "#{all_services.join(',')}. Defaults to all.") do |services|
+          services.map(&:downcase!).uniq!
+          invalid_services = services - all_services
+          raise ArgumentError, "Invalid service(s): #{invalid_services.join(',')}" unless invalid_services.empty?
+          options[:services] = services
+        end
+
+        opts.on('-f', '--format <format>', String, 'Set output format. Available formats: ' \
+          "#{all_formats.join(',')}. Defaults to text.") do |fmt|
+          unless all_formats.include?(fmt)
+            raise ArgumentError, "Invalid format '#{fmt}'. Valid formats are: #{all_formats.join(',')}"
+          end
+          options[:format] = fmt
+        end
+
+        opts.on('-v', '--[no-]verbose', 'Enable debug/trace output') do |verbose|
+          options[:verbose] = verbose
+        end
+      end.parse(args)
+
+      options
+    end
+
+    def check_service(service)
+      require "aws_public_ips/checks/#{service}.rb"
+      AwsPublicIps::Checks.const_get(service.capitalize).run
+    end
+
+    def output(formatter, results)
+      require "aws_public_ips/formatters/#{formatter}.rb"
+      formatter_klass = AwsPublicIps::Formatters.const_get(formatter.capitalize)
+      output = formatter_klass.new(results).format
+      puts output unless output.empty?
+    end
+
+    def run(args)
+      options = parse(args)
+
+      results = options[:services].map do |service|
+        [service.to_sym, check_service(service)]
+      end.to_h
+
+      output(options[:format], results)
+    rescue StandardError, Interrupt => ex
+      puts ex.inspect
+      puts ex.backtrace if options[:verbose]
+      Process.exit(1)
+    end
+  end
+end

data/lib/aws_public_ips/formatters.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module AwsPublicIps
+  module Formatters
+  end
+end
+
+require 'aws_public_ips/formatters/json'
+require 'aws_public_ips/formatters/prettyjson'
+require 'aws_public_ips/formatters/text'

data/lib/aws_public_ips/formatters/json.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module AwsPublicIps
+  module Formatters
+    class Json
+      def initialize(results)
+        @results = results
+      end
+
+      def format
+        @results.to_json
+      end
+    end
+  end
+end

data/lib/aws_public_ips/formatters/prettyjson.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module AwsPublicIps
+  module Formatters
+    class Prettyjson
+      def initialize(results)
+        @results = results
+      end
+
+      def format
+        JSON.pretty_generate(@results)
+      end
+    end
+  end
+end

data/lib/aws_public_ips/formatters/text.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module AwsPublicIps
+  module Formatters
+    class Text
+      def initialize(results)
+        @results = results
+      end
+
+      def format
+        @results.values.flatten.flat_map do |hash|
+          hash[:ip_addresses]
+        end.uniq.join("\n")
+      end
+    end
+  end
+end

data/lib/aws_public_ips/utils.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'resolv'
+
+module AwsPublicIps
+  module Utils
+    def self.resolve_hostnames(hostnames)
+      hostnames.flat_map(&method(:resolve_hostname))
+    end
+
+    def self.resolve_hostname(hostname)
+      # Default Resolv.getaddresses doesn't seem to return IPv6 results
+      resources = Resolv::DNS.open do |dns|
+        dns.getresources(hostname, Resolv::DNS::Resource::IN::A) +
+          dns.getresources(hostname, Resolv::DNS::Resource::IN::AAAA)
+      end
+
+      resources.map do |resource|
+        resource.address.to_s.downcase
+      end
+    end
+  end
+end

data/lib/aws_public_ips/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module AwsPublicIps
+  VERSION = '1.0.0'.freeze
+end

metadata

@@ -0,0 +1,259 @@
+--- !ruby/object:Gem::Specification
+name: aws_public_ips
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Arkadiy Tetelman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-apigateway
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-cloudfront
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-ec2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.33.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.33.0
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-elasticloadbalancing
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-elasticloadbalancingv2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-elasticsearchservice
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-lightsail
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-rds
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.18.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.18.0
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-redshift
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: bundler-audit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.12
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.12
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.7.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.55.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.55.0
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.1
+description: A library/cli to fetch all public IP addresses associated with an AWS
+  account
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/aws_public_ips
+- lib/aws_public_ips.rb
+- lib/aws_public_ips/checks.rb
+- lib/aws_public_ips/checks/apigateway.rb
+- lib/aws_public_ips/checks/cloudfront.rb
+- lib/aws_public_ips/checks/ec2.rb
+- lib/aws_public_ips/checks/elasticsearch.rb
+- lib/aws_public_ips/checks/elb.rb
+- lib/aws_public_ips/checks/elbv2.rb
+- lib/aws_public_ips/checks/lightsail.rb
+- lib/aws_public_ips/checks/rds.rb
+- lib/aws_public_ips/checks/redshift.rb
+- lib/aws_public_ips/cli.rb
+- lib/aws_public_ips/formatters.rb
+- lib/aws_public_ips/formatters/json.rb
+- lib/aws_public_ips/formatters/prettyjson.rb
+- lib/aws_public_ips/formatters/text.rb
+- lib/aws_public_ips/utils.rb
+- lib/aws_public_ips/version.rb
+homepage: https://github.com/arkadiyt/aws_public_ips
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: A library/cli to fetch all public IP addresses associated with an AWS account
+test_files: []