encryptbot 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c11220ad68f23896f0b736d977e06a569ca4552746d99793f59efda46bc88a6
-  data.tar.gz: 0172a1b4a558e2ca2d59b48a99f79c543ad6ef7ad42758ff4bbccca4c72e71be
+  metadata.gz: 9e7e74780b62f252a70d355c14303aae026fecf987687b9029e363d1f956278a
+  data.tar.gz: 15c849942b0be5615dfcd12ba47b77d457a8b6a116ebe2f4ca8ca4cfb5612930
 SHA512:
-  metadata.gz: cf7fd9ebd8e1710fbe9c1a56f1dc560b2d9603b53e9e0a403aedbd094dc37d8e69e415e4b3b58116f28e5a12dc0b0d2651fafd9a3b12ec4346ff8eceeb2598c1
-  data.tar.gz: facab7606bf80df0bdf6ad391c68787bc3e030181cc984b67c50d039cb23ab8cbf406f5f3efaf09025263a872adf1bf7178eba3f8eb9af10a0542ce865117c9c
+  metadata.gz: b1c8059dcabce152577657c3125678e604caaebd5fd04d4b1b7b82f7be0ab38c274180facf8b7b0f442ed9a6afcd11378bedcb0bfb360daa1adacb23935032fc
+  data.tar.gz: 816ec380875e437679a8f82831ace056ea77d8dddd7c72e26ae255065db9e24b51ea9d4880a7e1101c33d9219dcf66f813d67714262621395554e4b46dc95bb8

data/Gemfile.lock

@@ -1,12 +1,11 @@
 PATH
   remote: .
   specs:
-    encryptbot (0.1.7)
+    encryptbot (0.1.8)
       acme-client
       aws-sdk-route53
       faraday
       platform-api
-      slack-notifier
 
 GEM
   remote: https://rubygems.org/
@@ -14,21 +13,24 @@ GEM
     acme-client (2.0.6)
       faraday (>= 0.17, < 2.0.0)
     aws-eventstream (1.0.3)
-    aws-partitions (1.281.0)
-    aws-sdk-core (3.90.1)
+    aws-partitions (1.292.0)
+    aws-sdk-core (3.92.0)
       aws-eventstream (~> 1.0, >= 1.0.2)
       aws-partitions (~> 1, >= 1.239.0)
       aws-sigv4 (~> 1.1)
       jmespath (~> 1.0)
-    aws-sdk-route53 (1.30.0)
+    aws-sdk-route53 (1.32.0)
       aws-sdk-core (~> 3, >= 3.71.0)
       aws-sigv4 (~> 1.1)
     aws-sigv4 (1.1.1)
       aws-eventstream (~> 1.0, >= 1.0.2)
     erubis (2.7.0)
-    excon (0.72.0)
-    faraday (1.0.0)
+    excon (0.79.0)
+    faraday (1.3.0)
+      faraday-net_http (~> 1.0)
       multipart-post (>= 1.2, < 3)
+      ruby2_keywords
+    faraday-net_http (1.0.1)
     heroics (0.0.25)
       erubis (~> 2.0)
       excon
@@ -36,13 +38,13 @@ GEM
       multi_json (>= 1.9.2)
     jmespath (1.4.0)
     moneta (1.0.0)
-    multi_json (1.14.1)
+    multi_json (1.15.0)
     multipart-post (2.1.1)
     platform-api (2.2.0)
       heroics (~> 0.0.25)
       moneta (~> 1.0.0)
     rake (13.0.1)
-    slack-notifier (2.3.2)
+    ruby2_keywords (0.0.4)
 
 PLATFORMS
   ruby

data/README.md

@@ -5,9 +5,8 @@ Encryptbot creates and renews your Let's Encrypt SSL certificate on Heroku allow
 The gem will:
 
 - Create Let's Encrypt
-- Add Let's Encrypt DNS Challenge TXT records to your DNS provider (Cloudflare and Dyn supported)
+- Add Let's Encrypt DNS Challenge TXT records to DNS provider Route 53
 - Add certificate to your Heroku SNI endpoint
-- Send Slack notifications if the process fails.
 
 ## Installation
 
@@ -34,23 +33,12 @@ Add an initializer file to your rails application and all applicable config sett
 Encryptbot.configure do |config|
   config.heroku_app = "heroku_app_name"
   config.heroku_token = "heroku_api_token"
-  config.cloudflare_api_key = "cloudflare_api_key"
-  config.cloudflare_email = "cloudflare_account_email"
   config.acme_email = "letsencrypt_account_email"
-  config.dyn_customer_name = "dyn_customer_name"
-  config.dyn_username = "dyn_username"
-  config.dyn_password = "dyn_password"
-  config.slack_webhook = "slack_webhook_url"
-  config.slack_bot_username = "name_for_slack_bot"
   config.route53_hosted_zone_id = "Z123456"
   config.route53_acme_record_name = "_acme-challenge.acme.domain.com"
   config.route53_access_key_id = "aws_api_key"
   config.route53_secret_access_key = "aws_api_secret"
-  config.domains = [
-    {domain: "*.domain1.com", service: "cloudflare"},
-    {domain: "*.domain2.com", service: "dyn"},
-    {domain: "domain3.com", service: "cloudflare"},
-  ]
+  config.domains = ["*.domain1.com", "*.domain2.com"]
 end
 ```
 

data/encryptbot.gemspec

@@ -24,7 +24,6 @@ Gem::Specification.new do |spec|
   spec.add_dependency "acme-client"
   spec.add_dependency "platform-api"
   spec.add_dependency "faraday"
-  spec.add_dependency "slack-notifier"
   spec.add_dependency "aws-sdk-route53"
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", ">= 12.3.3"

data/lib/encryptbot.rb

@@ -1,8 +1,6 @@
 require "encryptbot/configuration"
 require "encryptbot/cert"
 require "encryptbot/version"
-require "encryptbot/services/cloudflare"
-require "encryptbot/services/dyn"
 require "encryptbot/services/route53"
 
 if defined?(Rails)

data/lib/encryptbot/cert.rb

@@ -2,17 +2,15 @@ require "platform-api"
 require "acme-client"
 require "encryptbot/heroku"
 require "encryptbot/exceptions"
-require "encryptbot/slacker"
 require "resolv"
 
 module Encryptbot
   class Cert
 
-    attr_reader :domain_list, :domain_names, :account_email, :test_mode
+    attr_reader :domains, :account_email, :test_mode
 
     def initialize
-      @domain_list = Encryptbot.configuration.domains
-      @domain_names = @domain_list.map{|d| d[:domain] }
+      @domains = Encryptbot.configuration.domains
       @account_email = Encryptbot.configuration.acme_email
       @test_mode = Encryptbot.configuration.test_mode
     end
@@ -35,27 +33,22 @@ module Encryptbot
       )
 
       # create order
-      order = client.new_order(identifiers: @domain_names)
+      order = client.new_order(identifiers: @domains)
 
+      puts "Start Authorization"
       # authorization of domains
       order.authorizations.each do |authorization|
         dns_challenge = authorization.dns
         domain = authorization.domain
+        puts "Start Authorization of #{domain}"
         dns_entry = {
           name: dns_challenge.record_name,
           type: dns_challenge.record_type,
           content: dns_challenge.record_content
         }
-        case @domain_list.detect{|t| t[:domain].gsub("*.", "") == domain }[:service]
-        when "route53"
-          Encryptbot::Services::Route53.new(domain, dns_entry).add_challenge
-        when "cloudflare"
-          Encryptbot::Services::Cloudflare.new(domain, dns_entry).add_challenge
-        when "dyn"
-          Encryptbot::Services::Dyn.new(domain, dns_entry).add_challenge
-        else
-          raise Encryptbot::Error::UnknownServiceError, "#{domain} service unknown"
-        end
+
+        Encryptbot::Services::Route53.new(domain, dns_entry).add_challenge
+
         # check if the DNS service has updated
         sleep(8)
 
@@ -73,6 +66,7 @@ module Encryptbot
           sleep(2)
           dns_challenge.reload
         end
+        puts "Completed authorization of #{domain}. Status: #{dns_challenge.status}"
 
       end # end auth loop
 
@@ -81,14 +75,17 @@ module Encryptbot
       end
 
       # Generate certificate
+      puts "Generate Certificate"
       csr = Acme::Client::CertificateRequest.new(names: @domain_names)
       order.finalize(csr: csr)
       sleep(1) while order.status == "processing"
 
       # add certificate to heroku
+      puts "Adding Certificate to heroku"
       certificate = order.certificate
       private_key = csr.private_key.to_pem
       Encryptbot::Heroku.new.add_certificate(order.certificate, private_key)
+      puts "Completed"
     end
 
     # Check if TXT value has been set correctly
@@ -104,4 +101,4 @@ module Encryptbot
 
   end
 
-end
+end

data/lib/encryptbot/configuration.rb

@@ -1,36 +1,25 @@
 module Encryptbot
   class Configuration
     attr_accessor :heroku_app, :heroku_token,
-    :cloudflare_api_key, :cloudflare_email,
-    :dyn_customer_name, :dyn_username, :dyn_password,
     :route53_hosted_zone_id, :route53_acme_record_name,
     :route53_access_key_id, :route53_secret_access_key,
-    :acme_email, :domains, :test_mode,
-    :slack_webhook, :slack_bot_username
+    :acme_email, :domains, :test_mode
 
     def initialize
       @heroku_app = nil
       @heroku_token = nil
-      @cloudflare_api_key = nil
-      @cloudflare_email = nil
-      @dyn_customer_name = nil
-      @dyn_username = nil
-      @dyn_password = nil
       @route53_hosted_zone_id = nil
       @route53_acme_record_name = nil
       @route53_access_key_id = nil
       @route53_secret_access_key = nil
       @acme_email = nil
-      @slack_webhook = nil
-      @slack_bot_username = "encryptbot"
       @test_mode = false # use lets encrypt staging
-      @domains = [] #[{domain: "*.domain.com", service: "cloudflare"}, {domain: "*.domain.com", service: "dyn"}]
+      @domains = [] #["*.domain1.com","*.domain2.com"]
     end
 
     def valid?
-      heroku_app && heroku_token && acme_email && domains.any? &&
-      (cloudflare_api_key || dyn_customer_name || route53_access_key_id)
+      heroku_app && heroku_token && acme_email && domains.any? && route53_access_key_id
     end
 
   end
-end
+end

data/lib/encryptbot/exceptions.rb

@@ -1,12 +1,9 @@
-require "encryptbot/slacker"
-
 module Encryptbot
   module Error
 
     class EncryptbotError < StandardError
 
       def initialize(msg = "")
-        Encryptbot::Slacker.post_message("Unable to autorenew SSL certificate. #{self.class.name} #{msg}")
         super(msg)
       end
 
@@ -27,4 +24,4 @@ module Encryptbot
     # Exception raised as order was failed - this happens when the DNS Challenge failed
     class InvalidOrderError < EncryptbotError; end
   end
-end
+end

data/lib/encryptbot/version.rb

@@ -1,3 +1,3 @@
 module Encryptbot
-  VERSION = "0.1.7"
+  VERSION = "0.1.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: encryptbot
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - danlewis
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-03-08 00:00:00.000000000 Z
+date: 2021-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: acme-client
@@ -52,20 +52,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: slack-notifier
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: aws-sdk-route53
   requirement: !ruby/object:Gem::Requirement
@@ -131,17 +117,14 @@ files:
 - lib/encryptbot/exceptions.rb
 - lib/encryptbot/heroku.rb
 - lib/encryptbot/railtie.rb
-- lib/encryptbot/services/cloudflare.rb
-- lib/encryptbot/services/dyn.rb
 - lib/encryptbot/services/route53.rb
-- lib/encryptbot/slacker.rb
 - lib/encryptbot/version.rb
 - lib/tasks/encryptbot.rake
 homepage: https://github.com/danlewis/encryptbot
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -157,7 +140,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.3
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Manage Let's Encrypt wildcard certificates on Heroku
 test_files: []

data/lib/encryptbot/services/cloudflare.rb

@@ -1,111 +0,0 @@
-# a=Encryptbot::Services::Cloudflare.new("*.domain.com", {type: "TXT", name: "_acme-challenge.adventist.place", content: "test-3"});a.add_challenge
-require "faraday"
-require "json"
-
-module Encryptbot
-  module Services
-    class Cloudflare
-
-      attr_accessor :domain, :api_key, :api_email, :zone_id, :dns_entry, :dns_record_id, :dns_record
-
-      def initialize(domain, dns_entry)
-        @domain = domain.to_s.gsub("*.", "") # cleanup wildcard by removing *. infront
-        @api_key = Encryptbot.configuration.cloudflare_api_key
-        @api_email = Encryptbot.configuration.cloudflare_email
-        @dns_entry = dns_entry # {content: "txt-record-content", type: "TXT", name: "_acme-challenge.domain.com"}
-        @dns_record = "#{dns_entry[:name]}.#{@domain}"
-      end
-
-      def add_challenge
-        begin
-          get_zone_id
-          setup_dns_record
-        rescue => e
-          raise Encryptbot::Error::CloudflareDNSError, e
-        end
-      end
-
-      def get_zone_id
-        response = get("/zones?name=#{@domain}")
-        if response["result"].any?
-          @zone_id = response["result"].first["id"]
-        end
-      end
-
-      def setup_dns_record
-        find_dns_record
-        return false if @zone_id.nil?
-
-        if @dns_record_id
-          update_dns_record
-        else
-          add_dns_record
-        end
-      end
-
-      def find_dns_record
-        response = get("/zones/#{@zone_id}/dns_records?name=#{@dns_record}&type=#{@dns_entry[:type]}")
-        if response["result"].any?
-          @dns_record_id = response["result"].first["id"]
-        end
-      end
-
-      def add_dns_record
-        response = post("/zones/#{@zone_id}/dns_records", {
-          type: @dns_entry[:type],
-          name: @dns_record,
-          content: @dns_entry[:content],
-          ttl: 120
-        })
-        response["success"]
-      end
-
-      def update_dns_record
-        response = put("/zones/#{@zone_id}/dns_records/#{@dns_record_id}", {
-          type: @dns_entry[:type],
-          name: @dns_record,
-          content: @dns_entry[:content],
-          ttl: 120
-        })
-        response["success"]
-      end
-
-      private
-
-      def post(endpoint_path, payload)
-        response = connection.post "https://api.cloudflare.com/client/v4#{endpoint_path}", payload.to_json
-        format_response(response)
-      end
-
-      def put(endpoint_path, payload)
-        response = connection.put "https://api.cloudflare.com/client/v4#{endpoint_path}", payload.to_json
-        format_response(response)
-      end
-
-      def get(endpoint_path)
-        response = connection.get "https://api.cloudflare.com/client/v4#{endpoint_path}"
-        format_response(response)
-      end
-
-      def connection
-        @connection ||= begin
-          headers = {
-            "X-Auth-Key" => @api_key,
-            "X-Auth-Email" => @api_email,
-            "Content-Type" => "application/json"
-          }
-          Faraday.new(url: "https://api.cloudflare.com", headers: headers)
-        end
-      end
-
-      def format_response(response)
-        if response.success?
-          JSON.parse(response.body)
-        else
-          nil
-        end
-      end
-
-    end
-  end
-end

data/lib/encryptbot/services/dyn.rb

@@ -1,145 +0,0 @@
-# a=Encryptbot::Services::Dyn.new("*.domain.com", {type: "TXT", name: "_acme-challenge", content: "test-3"});a.add_challenge
-require "faraday"
-require "json"
-
-module Encryptbot
-  module Services
-    class Dyn
-
-      attr_accessor :domain, :dns_entry, :full_domain_name, :api_token, :customer_name, :username, :password
-
-      def initialize(domain, dns_entry)
-        @domain = domain.to_s.gsub("*.", "") # cleanup wildcard by removing *. infront
-        @dns_entry = dns_entry # {content: "txt-record-content", type: "TXT", name: "_acme-challenge.domain.com"}
-        @full_domain_name = "#{dns_entry[:name]}.#{@domain}"
-        @api_token = nil
-        @customer_name = Encryptbot.configuration.dyn_customer_name
-        @username = Encryptbot.configuration.dyn_username
-        @password = Encryptbot.configuration.dyn_password
-      end
-
-      # sign in
-      # check for txt record, update if already exists, otherwise create new one
-      # publish changes
-      # sign out
-      def add_challenge
-        begin
-          sign_in
-          success = setup_dns_record
-          sign_out
-          success
-        rescue => e
-          raise Encryptbot::Error::DynDNSError, e
-        end
-
-      end
-
-      def sign_in
-        response = post("/REST/Session/", {
-          customer_name: customer_name,
-          user_name: username,
-          password: password
-        })
-        if response && response["status"] == "success"
-          @api_token = response["data"]["token"]
-        end
-        if @api_token.nil?
-          raise Encryptbot::Error::DynDNSError, "Unable to get Dyn API Token"
-        end
-      end
-
-      def sign_out
-        response = delete("/REST/Session/")
-      end
-
-      def setup_dns_record
-        txt_endpoint = find_dns_record
-
-        if txt_endpoint
-          update_dns_record(txt_endpoint)
-        else
-          add_dns_record
-        end
-      end
-
-      def find_dns_record
-        response = get("/REST/TXTRecord/#{domain}/#{full_domain_name}/")
-        if response && response["status"] == "success"
-          return response["data"][0]
-        end
-        nil
-      end
-
-      def add_dns_record
-        response = post("/REST/TXTRecord/#{domain}/#{full_domain_name}/", {
-          rdata: {
-            txtdata: dns_entry[:content]
-          },
-          ttl: "30"
-        })
-        if response && response["status"] == "success"
-          return publish_changes
-        end
-        false
-      end
-
-      def update_dns_record(txt_endpoint)
-        response = put(txt_endpoint, {
-          rdata: {
-            txtdata: dns_entry[:content]
-          },
-          ttl: "30"
-        })
-        if response && response["status"] == "success"
-          return publish_changes
-        end
-        false
-      end
-
-      def publish_changes
-        response = put("/REST/Zone/#{domain}/", {publish: true})
-        response && response["status"] == "success"
-      end
-
-      private
-
-      def post(endpoint_path, payload)
-        response = connection.post "https://api2.dynect.net#{endpoint_path}", payload.to_json
-        format_response(response)
-      end
-
-      def put(endpoint_path, payload)
-        response = connection.put "https://api2.dynect.net#{endpoint_path}", payload.to_json
-        format_response(response)
-      end
-
-      def delete(endpoint_path)
-        response = connection.delete "https://api2.dynect.net#{endpoint_path}"
-        format_response(response)
-      end
-
-      def get(endpoint_path)
-        response = connection.get "https://api2.dynect.net#{endpoint_path}"
-        format_response(response)
-      end
-
-      # Api token if set for requests after sign in completed
-      def connection
-        headers = {
-          "Auth-Token" => api_token.to_s,
-          "Content-Type" => "application/json"
-        }
-        Faraday.new(url: "https://api2.dynect.net", headers: headers)
-      end
-
-      def format_response(response)
-        if response.success?
-          JSON.parse(response.body)
-        else
-          nil
-        end
-      end
-
-    end
-  end
-end

data/lib/encryptbot/slacker.rb

@@ -1,16 +0,0 @@
-require "slack-notifier"
-
-module Encryptbot
-  class Slacker
-
-    def self.post_message(message)
-      unless Encryptbot.configuration.slack_webhook.nil?
-        notifier.ping message
-      end
-    end
-
-    def self.notifier
-      @notifier ||= Slack::Notifier.new Encryptbot.configuration.slack_webhook, username: Encryptbot.configuration.slack_bot_username
-    end
-  end
-end