web-push 1.0.0

data/bin/rake

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/bin/rspec

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rspec-core", "rspec")

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/tasks/web_push.rake

@@ -0,0 +1,14 @@
+namespace :web_push do
+  desc 'Generate VAPID public/private key pair'
+  task :generate_keys do
+    require 'web_push'
+
+    WebPush.generate_key.tap do |keypair|
+      puts <<-KEYS
+Generated VAPID keypair:
+Public  -> #{keypair.public_key}
+Private -> #{keypair.private_key}
+      KEYS
+    end
+  end
+end

data/lib/web-push.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'web_push'

data/lib/web_push/encryption.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module WebPush
+  module Encryption
+    extend self
+
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def encrypt(message, p256dh, auth)
+      assert_arguments(message, p256dh, auth)
+
+      group_name = 'prime256v1'
+      salt = Random.new.bytes(16)
+
+      server = OpenSSL::PKey::EC.new(group_name)
+      server.generate_key
+      server_public_key_bn = server.public_key.to_bn
+
+      group = OpenSSL::PKey::EC::Group.new(group_name)
+      client_public_key_bn = OpenSSL::BN.new(WebPush.decode64(p256dh), 2)
+      client_public_key = OpenSSL::PKey::EC::Point.new(group, client_public_key_bn)
+
+      shared_secret = server.dh_compute_key(client_public_key)
+
+      client_auth_token = WebPush.decode64(auth)
+
+      info = "WebPush: info\0" + client_public_key_bn.to_s(2) + server_public_key_bn.to_s(2)
+      content_encryption_key_info = "Content-Encoding: aes128gcm\0"
+      nonce_info = "Content-Encoding: nonce\0"
+
+      prk = HKDF.new(shared_secret, salt: client_auth_token, algorithm: 'SHA256', info: info).next_bytes(32)
+
+      content_encryption_key = HKDF.new(prk, salt: salt, info: content_encryption_key_info).next_bytes(16)
+
+      nonce = HKDF.new(prk, salt: salt, info: nonce_info).next_bytes(12)
+
+      ciphertext = encrypt_payload(message, content_encryption_key, nonce)
+
+      serverkey16bn = convert16bit(server_public_key_bn)
+      rs = ciphertext.bytesize
+      raise ArgumentError, "encrypted payload is too big" if rs > 4096
+
+      aes128gcmheader = "#{salt}" + [rs].pack('N*') + [serverkey16bn.bytesize].pack('C*') + serverkey16bn
+
+      aes128gcmheader + ciphertext
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    private
+
+    def encrypt_payload(plaintext, content_encryption_key, nonce)
+      cipher = OpenSSL::Cipher.new('aes-128-gcm')
+      cipher.encrypt
+      cipher.key = content_encryption_key
+      cipher.iv = nonce
+      text = cipher.update(plaintext)
+      padding = cipher.update("\2\0")
+      e_text = text + padding + cipher.final
+      e_tag = cipher.auth_tag
+
+      e_text + e_tag
+    end
+
+    def convert16bit(key)
+      [key.to_s(16)].pack('H*')
+    end
+
+    def assert_arguments(message, p256dh, auth)
+      raise ArgumentError, 'message cannot be blank' if blank?(message)
+      raise ArgumentError, 'p256dh cannot be blank' if blank?(p256dh)
+      raise ArgumentError, 'auth cannot be blank' if blank?(auth)
+    end
+
+    def blank?(value)
+      value.nil? || value.empty?
+    end
+  end
+end

data/lib/web_push/errors.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module WebPush
+  class Error < RuntimeError; end
+
+  class ConfigurationError < Error; end
+
+  class ResponseError < Error
+    attr_reader :response, :host
+
+    def initialize(response, host)
+      @response = response
+      @host = host
+      super "host: #{host}, #{@response.inspect}\nbody:\n#{@response.body}"
+    end
+  end
+
+  class InvalidSubscription < ResponseError; end
+
+  class ExpiredSubscription < ResponseError; end
+
+  class Unauthorized < ResponseError; end
+
+  class PayloadTooLarge < ResponseError; end
+
+  class TooManyRequests < ResponseError; end
+
+  class PushServiceError < ResponseError; end
+end

data/lib/web_push/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module WebPush
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load 'tasks/web_push.rake'
+    end
+  end
+end

data/lib/web_push/request.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'jwt'
+require 'base64'
+
+module WebPush
+  # It is temporary URL until supported by the GCM server.
+  GCM_URL = 'https://android.googleapis.com/gcm/send'.freeze
+  TEMP_GCM_URL = 'https://fcm.googleapis.com/fcm'.freeze
+
+  # rubocop:disable Metrics/ClassLength
+  class Request
+    def initialize(message: '', subscription:, vapid:, **options)
+      endpoint = subscription.fetch(:endpoint)
+      @endpoint = endpoint.gsub(GCM_URL, TEMP_GCM_URL)
+      @payload = build_payload(message, subscription)
+      @vapid_options = vapid
+      @options = default_options.merge(options)
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def perform
+      http = Net::HTTP.new(uri.host, uri.port, *proxy_options)
+      http.use_ssl = true
+      http.ssl_timeout = @options[:ssl_timeout] unless @options[:ssl_timeout].nil?
+      http.open_timeout = @options[:open_timeout] unless @options[:open_timeout].nil?
+      http.read_timeout = @options[:read_timeout] unless @options[:read_timeout].nil?
+
+      req = Net::HTTP::Post.new(uri.request_uri, headers)
+      req.body = body
+
+      resp = http.request(req)
+      verify_response(resp)
+
+      resp
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def proxy_options
+      return [] unless @options[:proxy]
+
+      proxy_uri = URI.parse(@options[:proxy])
+
+      [proxy_uri.host, proxy_uri.port, proxy_uri.user, proxy_uri.password]
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def headers
+      headers = {}
+      headers['Content-Type'] = 'application/octet-stream'
+      headers['Ttl']          = ttl
+      headers['Urgency']      = urgency
+
+      if @payload
+        headers['Content-Encoding'] = 'aes128gcm'
+        headers["Content-Length"] = @payload.length.to_s
+      end
+
+      if api_key?
+        headers['Authorization'] = "key=#{api_key}"
+      elsif vapid?
+        headers["Authorization"] = build_vapid_header
+      end
+
+      headers
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def build_vapid_header
+      # https://tools.ietf.org/id/draft-ietf-webpush-vapid-03.html
+
+      vapid_key = vapid_pem ? VapidKey.from_pem(vapid_pem) : VapidKey.from_keys(vapid_public_key, vapid_private_key)
+      jwt = JWT.encode(jwt_payload, vapid_key.curve, 'ES256', jwt_header_fields)
+      p256ecdsa = vapid_key.public_key_for_push_header
+
+       "vapid t=#{jwt},k=#{p256ecdsa}"
+    end
+
+    def body
+      @payload || ''
+    end
+
+    private
+
+    def uri
+      @uri ||= URI.parse(@endpoint)
+    end
+
+    def ttl
+      @options.fetch(:ttl).to_s
+    end
+
+    def urgency
+      @options.fetch(:urgency).to_s
+    end
+
+    def jwt_payload
+      {
+        aud: audience,
+        exp: Time.now.to_i + expiration,
+        sub: subject
+      }
+    end
+
+    def jwt_header_fields
+      { "typ": "JWT", "alg": "ES256" }
+    end
+
+    def audience
+      uri.scheme + '://' + uri.host
+    end
+
+    def expiration
+      @vapid_options.fetch(:expiration, 24 * 60 * 60)
+    end
+
+    def subject
+      @vapid_options.fetch(:subject, 'sender@example.com')
+    end
+
+    def vapid_public_key
+      @vapid_options.fetch(:public_key, nil)
+    end
+
+    def vapid_private_key
+      @vapid_options.fetch(:private_key, nil)
+    end
+
+    def vapid_pem
+      @vapid_options.fetch(:pem, nil)
+    end
+
+    def default_options
+      {
+        ttl: 60 * 60 * 24 * 7 * 4, # 4 weeks
+        urgency: 'normal'
+      }
+    end
+
+    def build_payload(message, subscription)
+      return nil if message.nil? || message.empty?
+
+      encrypt_payload(message, **subscription.fetch(:keys))
+    end
+
+    def encrypt_payload(message, p256dh:, auth:)
+      Encryption.encrypt(message, p256dh, auth)
+    end
+
+    def api_key
+      @options.fetch(:api_key, nil)
+    end
+
+    def api_key?
+      !(api_key.nil? || api_key.empty?) && @endpoint =~ %r{\Ahttps://(android|gcm-http|fcm)\.googleapis\.com}
+    end
+
+    def vapid?
+      @vapid_options.any?
+    end
+
+    def trim_encode64(bin)
+      WebPush.encode64(bin).delete('=')
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Style/GuardClause
+    def verify_response(resp)
+      if resp.is_a?(Net::HTTPGone) # 410
+        raise ExpiredSubscription.new(resp, uri.host)
+      elsif resp.is_a?(Net::HTTPNotFound) # 404
+        raise InvalidSubscription.new(resp, uri.host)
+      elsif resp.is_a?(Net::HTTPUnauthorized) || resp.is_a?(Net::HTTPForbidden) || # 401, 403
+            resp.is_a?(Net::HTTPBadRequest) && resp.message == 'UnauthorizedRegistration' # 400, Google FCM
+        raise Unauthorized.new(resp, uri.host)
+      elsif resp.is_a?(Net::HTTPRequestEntityTooLarge) # 413
+        raise PayloadTooLarge.new(resp, uri.host)
+      elsif resp.is_a?(Net::HTTPTooManyRequests) # 429, try again later!
+        raise TooManyRequests.new(resp, uri.host)
+      elsif resp.is_a?(Net::HTTPServerError) # 5xx
+        raise PushServiceError.new(resp, uri.host)
+      elsif !resp.is_a?(Net::HTTPSuccess) # unknown/unhandled response error
+        raise ResponseError.new(resp, uri.host)
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Style/GuardClause
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/lib/web_push/vapid_key.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module WebPush
+  # Class for abstracting the generation and encoding of elliptic curve public and private keys for use with the VAPID protocol
+  #
+  # @attr_reader [OpenSSL::PKey::EC] :curve the OpenSSL elliptic curve instance
+  class VapidKey
+    # Create a VapidKey instance from encoded elliptic curve public and private keys
+    #
+    # @return [WebPush::VapidKey] a VapidKey instance for the given public and private keys
+    def self.from_keys(public_key, private_key)
+      key = new
+      key.public_key = public_key
+      key.private_key = private_key
+
+      key
+    end
+
+    # Create a VapidKey instance from pem encoded elliptic curve public and private keys
+    #
+    # @return [WebPush::VapidKey] a VapidKey instance for the given public and private keys
+    def self.from_pem(pem)
+      key = new
+      src = OpenSSL::PKey.read pem
+      key.curve.public_key = src.public_key
+      key.curve.private_key = src.private_key
+
+      key
+    end
+
+    attr_reader :curve
+
+    def initialize
+      @curve = OpenSSL::PKey::EC.new('prime256v1')
+      @curve.generate_key
+    end
+
+    # Retrieve the encoded elliptic curve public key for VAPID protocol
+    #
+    # @return [String] encoded binary representation of 65-byte VAPID public key
+    def public_key
+      encode64(curve.public_key.to_bn.to_s(2))
+    end
+
+    # Retrieve the encoded elliptic curve public key suitable for the Web Push request
+    #
+    # @return [String] the encoded VAPID public key for us in 'Encryption' header
+    def public_key_for_push_header
+      trim_encode64(curve.public_key.to_bn.to_s(2))
+    end
+
+    # Retrive the encoded elliptic curve private key for VAPID protocol
+    #
+    # @return [String] base64 urlsafe-encoded binary representation of 32-byte VAPID private key
+    def private_key
+      encode64(curve.private_key.to_s(2))
+    end
+
+    def public_key=(key)
+      curve.public_key = OpenSSL::PKey::EC::Point.new(group, to_big_num(key))
+    end
+
+    def private_key=(key)
+      curve.private_key = to_big_num(key)
+    end
+
+    def curve_name
+      group.curve_name
+    end
+
+    def group
+      curve.group
+    end
+
+    def to_h
+      { public_key: public_key, private_key: private_key }
+    end
+    alias to_hash to_h
+
+    def to_pem
+      public_key = OpenSSL::PKey::EC.new curve
+      public_key.private_key = nil
+
+      curve.to_pem + public_key.to_pem
+    end
+
+    def inspect
+      "#<#{self.class}:#{object_id.to_s(16)} #{to_h.map { |k, v| ":#{k}=#{v}" }.join(' ')}>"
+    end
+
+    private
+
+    def to_big_num(key)
+      OpenSSL::BN.new(WebPush.decode64(key), 2)
+    end
+
+    def encode64(bin)
+      WebPush.encode64(bin)
+    end
+
+    def trim_encode64(bin)
+      encode64(bin).delete('=')
+    end
+  end
+end

data/lib/web_push/version.rb

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

data/lib/web_push.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'openssl'
+require 'base64'
+require 'hkdf'
+require 'net/http'
+require 'json'
+
+require 'web_push/version'
+require 'web_push/errors'
+require 'web_push/vapid_key'
+require 'web_push/encryption'
+require 'web_push/request'
+require 'web_push/railtie' if defined?(Rails)
+
+# Push API implementation
+#
+# https://tools.ietf.org/html/rfc8030
+# https://www.w3.org/TR/push-api/
+module WebPush
+  class << self
+    # Deliver the payload to the required endpoint given by the JavaScript
+    # PushSubscription. Including an optional message requires p256dh and
+    # auth keys from the PushSubscription.
+    #
+    # @param endpoint [String] the required PushSubscription url
+    # @param message [String] the optional payload
+    # @param p256dh [String] the user's public ECDH key given by the PushSubscription
+    # @param auth [String] the user's private ECDH key given by the PushSubscription
+    # @param vapid [Hash<Symbol,String>] options for VAPID
+    # @option vapid [String] :subject contact URI for the app server as a "mailto:" or an "https:"
+    # @option vapid [String] :public_key the VAPID public key
+    # @option vapid [String] :private_key the VAPID private key
+    # @param options [Hash<Symbol,String>] additional options for the notification
+    # @option options [#to_s] :ttl Time-to-live in seconds
+    # @option options [#to_s] :urgency Urgency can be very-low, low, normal, high
+    # rubocop:disable Metrics/ParameterLists
+    def payload_send(message: '', endpoint:, p256dh: '', auth: '', vapid: {}, **options)
+      WebPush::Request.new(
+        message: message,
+        subscription: subscription(endpoint, p256dh, auth),
+        vapid: vapid,
+        **options
+      ).perform
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    # Generate a VapidKey instance to obtain base64 encoded public and private keys
+    # suitable for VAPID protocol JSON web token signing
+    #
+    # @return [WebPush::VapidKey] a new VapidKey instance
+    def generate_key
+      VapidKey.new
+    end
+
+    def encode64(bytes)
+      Base64.urlsafe_encode64(bytes)
+    end
+
+    def decode64(str)
+      # For Ruby < 2.3, Base64.urlsafe_decode64 strict decodes and will raise errors if encoded value is not properly padded
+      # Implementation: http://ruby-doc.org/stdlib-2.3.0/libdoc/base64/rdoc/Base64.html#method-i-urlsafe_decode64
+      str = str.ljust((str.length + 3) & ~3, '=') if !str.end_with?('=') && str.length % 4 != 0
+
+      Base64.urlsafe_decode64(str)
+    end
+
+    private
+
+    def subscription(endpoint, p256dh, auth)
+      {
+        endpoint: endpoint,
+        keys: {
+          p256dh: p256dh,
+          auth: auth
+        }
+      }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+require 'pry'
+require 'web_push'
+require 'webmock/rspec'
+require 'simplecov'
+WebMock.disable_net_connect!(allow_localhost: true)
+SimpleCov.start
+
+def vapid_options
+  {
+    subject: 'mailto:sender@example.com',
+    public_key: vapid_public_key,
+    private_key: vapid_private_key
+  }
+end
+
+def vapid_public_key
+  'BB37UCyc8LLX4PNQSe-04vSFvpUWGrENubUaslVFM_l5TxcGVMY0C3RXPeUJAQHKYlcOM2P4vTYmkoo0VZGZTM4='
+end
+
+def vapid_private_key
+  'OPrw1Sum3gRoL4-DXfSCC266r-qfFSRZrnj8MgIhRHg='
+end

data/spec/web_push/encryption_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe WebPush::Encryption do
+  describe '#encrypt' do
+    let(:curve) do
+      group = 'prime256v1'
+      curve = OpenSSL::PKey::EC.new(group)
+      curve.generate_key
+      curve
+    end
+
+    let(:p256dh) do
+      ecdh_key = curve.public_key.to_bn.to_s(2)
+      Base64.urlsafe_encode64(ecdh_key)
+    end
+
+    let(:auth) { Base64.urlsafe_encode64(Random.new.bytes(16)) }
+
+    it 'returns ECDH encrypted cipher text, salt, and server_public_key' do
+      payload = WebPush::Encryption.encrypt('Hello World', p256dh, auth)
+      expect(decrypt(payload)).to eq('Hello World')
+    end
+
+    it 'returns error when message is blank' do
+      expect { WebPush::Encryption.encrypt(nil, p256dh, auth) }.to raise_error(ArgumentError)
+      expect { WebPush::Encryption.encrypt('', p256dh, auth) }.to raise_error(ArgumentError)
+    end
+
+    it 'returns error when p256dh is blank' do
+      expect { WebPush::Encryption.encrypt('Hello world', nil, auth) }.to raise_error(ArgumentError)
+      expect { WebPush::Encryption.encrypt('Hello world', '', auth) }.to raise_error(ArgumentError)
+    end
+
+    it 'returns error when auth is blank' do
+      expect { WebPush::Encryption.encrypt('Hello world', p256dh, '') }.to raise_error(ArgumentError)
+      expect { WebPush::Encryption.encrypt('Hello world', p256dh, nil) }.to raise_error(ArgumentError)
+    end
+
+    # Bug fix for https://github.com/zaru/webpush/issues/22
+    it 'handles unpadded base64 encoded subscription keys' do
+      unpadded_p256dh = p256dh.gsub(/=*\Z/, '')
+      unpadded_auth = auth.gsub(/=*\Z/, '')
+
+      payload = WebPush::Encryption.encrypt('Hello World', unpadded_p256dh, unpadded_auth)
+      expect(decrypt(payload)).to eq('Hello World')
+    end
+
+    def decrypt payload
+      salt = payload.byteslice(0, 16)
+      rs = payload.byteslice(16, 4).unpack("N*").first
+      idlen = payload.byteslice(20).unpack("C*").first
+      serverkey16bn = payload.byteslice(21, idlen)
+      ciphertext = payload.byteslice(21 + idlen, rs)
+
+      expect(payload.bytesize).to eq(21 + idlen + rs)
+
+      group_name = 'prime256v1'
+      group = OpenSSL::PKey::EC::Group.new(group_name)
+      server_public_key_bn = OpenSSL::BN.new(serverkey16bn.unpack('H*').first, 16)
+      server_public_key = OpenSSL::PKey::EC::Point.new(group, server_public_key_bn)
+      shared_secret = curve.dh_compute_key(server_public_key)
+
+      client_public_key_bn = curve.public_key.to_bn
+      client_auth_token = WebPush.decode64(auth)
+
+      info = "WebPush: info\0" + client_public_key_bn.to_s(2) + server_public_key_bn.to_s(2)
+      content_encryption_key_info = "Content-Encoding: aes128gcm\0"
+      nonce_info = "Content-Encoding: nonce\0"
+
+      prk = HKDF.new(shared_secret, salt: client_auth_token, algorithm: 'SHA256', info: info).next_bytes(32)
+
+      content_encryption_key = HKDF.new(prk, salt: salt, info: content_encryption_key_info).next_bytes(16)
+      nonce = HKDF.new(prk, salt: salt, info: nonce_info).next_bytes(12)
+
+      decrypt_ciphertext(ciphertext, content_encryption_key, nonce)
+    end
+
+    def decrypt_ciphertext(ciphertext, content_encryption_key, nonce)
+      secret_data = ciphertext.byteslice(0, ciphertext.bytesize-16)
+      auth = ciphertext.byteslice(ciphertext.bytesize-16, ciphertext.bytesize)
+      decipher = OpenSSL::Cipher.new('aes-128-gcm')
+      decipher.decrypt
+      decipher.key = content_encryption_key
+      decipher.iv = nonce
+      decipher.auth_tag = auth
+
+      decrypted = decipher.update(secret_data) + decipher.final
+
+      e = decrypted.byteslice(-2, decrypted.bytesize)
+      expect(e).to eq("\2\0")
+
+      decrypted.byteslice(0, decrypted.bytesize-2)
+    end
+  end
+end