dkimverify 0.0.1

data/dkim-query/spec/parser_spec.rb

@@ -0,0 +1,300 @@
+require 'spec_helper'
+require 'dkim/query/parser'
+
+describe Parser do
+  describe ".parse" do
+    subject { described_class }
+
+    let(:dkim) do
+      %{k=rsa;  p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDrEee0Ri4Juz+QfiWYui/E9UGSXau/2P8LjnTD8V4Unn+2FAZVGE3kL23bzeoULYv4PeleB3gfmJiDJOKU3Ns5L4KJAUUHjFwDebt0NP+sBK0VKeTATL2Yr/S3bT/xhy+1xtj4RkdV7fVxTn56Lb4udUnwuxK4V5b5PdOKj/+XcwIDAQAB; n=A 1024 bit key;}
+    end
+
+    it "should parse a DKIM record into a Hash" do
+      expect(subject.parse(dkim)).to be == {
+        k: :rsa,
+        p: %{MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDrEee0Ri4Juz+QfiWYui/E9UGSXau/2P8LjnTD8V4Unn+2FAZVGE3kL23bzeoULYv4PeleB3gfmJiDJOKU3Ns5L4KJAUUHjFwDebt0NP+sBK0VKeTATL2Yr/S3bT/xhy+1xtj4RkdV7fVxTn56Lb4udUnwuxK4V5b5PdOKj/+XcwIDAQAB},
+        n: "A 1024 bit key;"
+      }
+    end
+  end
+
+  describe "tags" do
+    describe "v" do
+      subject { super().key_v_tag }
+
+      it "should parse v=DKIM1" do
+        expect(subject.parse('v=DKIM1')).to be == {
+          name: 'v',
+          value: {symbol: 'DKIM1'}
+        }
+      end
+    end
+
+    describe "g" do
+      subject { super().key_g_tag }
+    end
+
+    describe "h" do
+      subject { super().key_h_tag }
+
+      it "should parse h=sha1" do
+        expect(subject.parse('h=sha1')).to be == {
+          name: 'h',
+          value: {symbol: 'sha1'}
+        }
+      end
+
+      it "should parse h=sha256" do
+        expect(subject.parse('h=sha256')).to be == {
+          name: 'h',
+          value: {symbol: 'sha256'}
+        }
+      end
+
+      it "should parse h=sha1:sha256" do
+        expect(subject.parse('h=sha1:sha256')).to be == {
+          name: 'h',
+          value: [
+            {symbol: 'sha1'},
+            {symbol: 'sha256'}
+          ]
+        }
+      end
+
+      it "should parse h=abc-123-xyz" do
+        expect(subject.parse('h=abc-123-xyz')).to be == {
+          name: 'h',
+          value: {string: 'abc-123-xyz'}
+        }
+      end
+    end
+
+    describe "k" do
+      subject { super().key_k_tag }
+
+      it "should parse k=rsa" do
+        expect(subject.parse('k=rsa')).to be == {
+          name: 'k',
+          value: {symbol: 'rsa'}
+        }
+      end
+
+      it "should parse k=abc-123-xyz" do
+        expect(subject.parse('k=abc-123-xyz')).to be == {
+          name: 'k',
+          value: {string: 'abc-123-xyz'}
+        }
+      end
+    end
+
+    describe "n" do
+      subject { super().key_n_tag }
+
+      let(:notes) { %{A 1024 bit key} }
+
+      it "should parse n=..." do
+        expect(subject.parse("n=#{notes}")).to be == {
+          name: 'n',
+          value: {string: notes}
+        }
+      end
+    end
+
+    describe "p" do
+      subject { super().key_p_tag }
+
+      let(:base64) { %{MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDrEee0Ri4Juz+QfiWYui/E9UGSXau/2P8LjnTD8V4Unn+2FAZVGE3kL23bzeoULYv4PeleB3gfmJiDJOKU3Ns5L4KJAUUHjFwDebt0NP+sBK0VKeTATL2Yr/S3bT/xhy+1xtj4RkdV7fVxTn56Lb4udUnwuxK4V5b5PdOKj/+XcwIDAQAB} }
+
+      it "should parse p=..." do
+        expect(subject.parse("p=#{base64}")).to be == {
+          name: 'p',
+          value: {asn1: base64}
+        }
+      end
+    end
+
+    describe "s" do
+      subject { super().key_s_tag }
+
+      it "should parse s=email" do
+        expect(subject.parse('s=email')).to be == {
+          name: 's',
+          value: {symbol: 'email'}
+        }
+      end
+
+      it "should parse s=*" do
+        expect(subject.parse('s=*')).to be == {
+          name: 's',
+          value: {symbol: '*'}
+        }
+      end
+
+      it "should parse s=email:*" do
+        expect(subject.parse('s=email:*')).to be == {
+          name: 's',
+          value: [{symbol: 'email'}, {symbol: '*'}]
+        }
+      end
+
+      it "should parse s=abc-123-xyz" do
+        expect(subject.parse('s=abc-123-xyz')).to be == {
+          name: 's',
+          value: {string: 'abc-123-xyz'}
+        }
+      end
+    end
+
+    describe "t" do
+      subject { super().key_t_tag }
+
+      it "should parse t=y" do
+        expect(subject.parse('t=y')).to be == {
+          name: 't',
+          value: {symbol: 'y'}
+        }
+      end
+
+      it "should parse t=s" do
+        expect(subject.parse('t=s')).to be == {
+          name: 't',
+          value: {symbol: 's'}
+        }
+      end
+
+      it "should parse t=abc-123-xyz" do
+        expect(subject.parse('t=abc-123-xyz')).to be == {
+          name: 't',
+          value: {string: 'abc-123-xyz'}
+        }
+      end
+    end
+  end
+
+  describe "rules" do
+    describe "dkim_quoted_printable" do
+    end
+
+    describe "dkim_safe_char" do
+    end
+
+    describe "hyphenated_word" do
+      subject { super().hyphenated_word }
+
+      it "should parse abc" do
+        expect(subject.parse('abc')).to be == 'abc'
+      end
+
+      it "should parse abc123" do
+        expect(subject.parse('abc123')).to be == 'abc123'
+      end
+
+      it "should parse a-b-c" do
+        expect(subject.parse('a-b-c')).to be == 'a-b-c'
+      end
+
+      it "should parse a---b---c" do
+        expect(subject.parse('a---b---c')).to be == 'a---b---c'
+      end
+
+      it "should not parse -a" do
+        expect { subject.parse('-a') }.to raise_error(Parslet::ParseFailed)
+      end
+
+      it "should not parse a-" do
+        expect { subject.parse('a-') }.to raise_error(Parslet::ParseFailed)
+      end
+
+      it "should not parse -" do
+        expect { subject.parse('-') }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+
+    describe "base64string" do
+    end
+
+    describe "qp_section" do
+      subject { super().qp_section }
+
+      it "should parse \"A\"" do
+        expect(subject.parse('A')).to be == 'A'
+      end
+
+      it "should parse \"AAA\"" do
+        expect(subject.parse('AAA')).to be == 'AAA'
+      end
+
+      it "should parse \" A\"" do
+        expect(subject.parse(' A')).to be == ' A'
+      end
+
+      it "should parse \"A B\"" do
+        expect(subject.parse('A B')).to be == 'A B'
+      end
+
+      it "should not parse \" \"" do
+        expect {
+          subject.parse(' ')
+        }.to raise_error(Parslet::ParseFailed)
+      end
+
+      it "should not parse \"A \"" do
+        expect {
+          subject.parse('A ')
+        }.to raise_error(Parslet::ParseFailed)
+      end
+    end
+
+    describe "hex_octet" do
+    end
+  end
+
+  describe Parser::Transform do
+    context "when given {symbol: ...}" do
+      let(:string) { 'foo' }
+
+      it "should convert the string into a Symbol" do
+        expect(subject.apply(symbol: string)).to be == string.to_sym
+      end
+    end
+
+    context "when given {tag: {name: ..., value: ...}}" do
+      let(:name)  { 'foo' }
+      let(:value) { 'bar' }
+
+      it "should convert the string into Hash" do
+        expect(subject.apply(
+          {tag: {name: name, value: value}}
+        )).to be == {name.to_sym => value}
+      end
+    end
+
+    context "when given {tag: {name: ..., value: [...]}}" do
+      let(:name)  { 'foo' }
+      let(:value) { ['a', 'b'] }
+
+      it "should convert the string into Hash" do
+        expect(subject.apply(
+          {tag: {name: name, value: value}}
+        )).to be == {name.to_sym => value}
+      end
+    end
+
+    context "when {tag_list: {...}}" do
+      let(:hash) { {foo: 'bar'} }
+
+      it "should return the single Hash" do
+        expect(subject.apply({tag_list: hash})).to be == hash
+      end
+    end
+
+    context "when {tag_list: [{...}, ...]}" do
+      let(:hashes) { [{foo: 'bar'}, {baz: 'quix'}] }
+      let(:hash)   { {foo: 'bar', baz: 'quix'} }
+
+      it "should merge the Hashes together" do
+        expect(subject.apply({tag_list: hashes})).to be == hash
+      end
+    end
+  end
+end

data/dkim-query/spec/query_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'dkim/query/query'
+
+describe DKIM::Query do
+  subject { described_class }
+
+  let(:domain) { 'yahoo.com' }
+
+  describe ".host_without_tld" do
+    let(:tld) { ".com" }
+
+    it "should strip the last component of the domain" do
+      expect(subject.host_without_tld(domain)).to be == domain.chomp(tld)
+    end
+
+    context "when given a host with no tld" do
+      let(:domain) { 'test' }
+
+      it "should return the full host" do
+        expect(subject.host_without_tld(domain)).to be == domain
+      end
+    end
+  end
+
+  describe ".selectors_for" do
+    subject { described_class.selectors_for(domain) }
+
+    described_class::SELECTORS.each do |selector|
+      it "should include '#{selector}'" do
+        expect(subject).to include(selector)
+      end
+    end
+
+    it "should include the domain without the TLD" do
+      expect(subject).to include('yahoo')
+    end
+  end
+
+  describe ".query" do
+    it "should return all found DKIM keys" do
+      expect(subject.query(domain)).to be == {
+        's1024' => 'k=rsa;  p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDrEee0Ri4Juz+QfiWYui/E9UGSXau/2P8LjnTD8V4Unn+2FAZVGE3kL23bzeoULYv4PeleB3gfmJiDJOKU3Ns5L4KJAUUHjFwDebt0NP+sBK0VKeTATL2Yr/S3bT/xhy+1xtj4RkdV7fVxTn56Lb4udUnwuxK4V5b5PdOKj/+XcwIDAQAB; n=A 1024 bit key;'
+      }
+    end
+
+    context "with custom selectors" do
+      let(:selectors) { ['google', 's1024'] }
+
+      it "should query those selectors only" do
+        expect(subject.query(domain, selectors: selectors)).to have_key('s1024')
+      end
+    end
+
+    context "with no selectors" do
+      it "should not find any keys" do
+        expect(subject.query(domain, selectors: [])).to be_empty
+      end
+    end
+
+    context "when given an invalid domain" do
+      let(:domain) { 'foo.bar.com' }
+
+      it "should return {}" do
+        expect(subject.query(domain)).to be == {}
+      end
+    end
+  end
+end

data/dkim-query/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+if ENV['CODECLIMATE_REPO_TOKEN']
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
+end
+
+require 'rspec'
+require 'dkim/query'
+
+include DKIM::Query
+
+RSpec.configure do |specs|
+  specs
+end

data/dkim-query/tasks/alexa.rb

@@ -0,0 +1,43 @@
+##
+# Adapted from gist: https://gist.github.com/zerothabhishek/3015666
+# Orginal author: zerothabhishek
+##
+
+require 'nokogiri'
+require 'open-uri'
+require 'resolv'
+require 'csv'
+
+namespace :alexa do
+  desc 'Scrapes the Alexa Top 500 and updates spec/data/alexa.csv'
+  task :scrape do
+    resolver = Resolv::DNS.new
+
+    CSV.open("spec/data/alexa.csv","w") do |csv|
+      (0..19).each do |i|
+        url = "http://www.alexa.com/topsites/global;#{i} "
+        doc = Nokogiri::HTML(open(url))
+
+        doc.css(".site-listing").each do |li|
+          begin
+            site_name = li.css(".desc-container .desc-paragraph a")[0].content
+            site_rank = li.css(".count")[0].content
+
+            puts "Resolving #{site_name} ..."
+            dmarc = begin
+                      resolver.getresource(
+                        "_dmarc.#{site_name.downcase}",
+                        Resolv::DNS::Resource::IN::TXT
+                      ).strings.join
+                    rescue Resolv::ResolvError
+                    end
+
+            csv << [site_rank, site_name, dmarc]
+          rescue => exception
+            warn exception.message
+          end
+        end
+      end
+    end
+  end
+end

data/dkimverify.gemspec

@@ -0,0 +1,16 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |gem|
+  gem.name          = "dkimverify"
+  gem.version       = '0.0.1'
+  gem.authors       = ["Jeremy B. Merrill"]
+  gem.license       = "MIT"
+  gem.email         = ["jeremybmerrill@gmail.com"]
+  gem.description   = %q{ A pure-Ruby library for validating/verifying DKIM signatures. }
+  gem.summary       = %q{ A pure-Ruby library for validating/verifying DKIM signatures. }
+  gem.homepage      = "https://github.com/jeremybmerrill/dkimverify"
+  gem.files         = `git ls-files`.split($/)
+  gem.require_paths = ["dkim-query"]
+  gem.add_dependency "mail", "2.6.4"
+  gem.add_dependency "parslet", "~> 1.6"
+end