lib/google/api_client/service_account.rb

   1 # Copyright 2010 Google Inc.
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #      http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 require 'jwt'
  16 require 'signet/oauth_2/client'
  17
  18 module Google
  19   class APIClient
  20     ##
  21     # Helper for loading keys from the PKCS12 files downloaded when
  22     # setting up service accounts at the APIs Console.
  23     #
  24
  25     module PKCS12
  26
  27       ##
  28       # Loads a key from PKCS12 file, assuming a single private key
  29       # is present.
  30       #
  31       # @param [String] keyfile
  32       #    Path of the PKCS12 file to load. If not a path to an actual file,
  33       #    assumes the string is the content of the file itself.
  34       # @param [String] passphrase
  35       #   Passphrase for unlocking the private key
  36       #
  37       # @return [OpenSSL::PKey] The private key for signing assertions.
  38       def self.load_key(keyfile, passphrase)
  39         begin
  40           if File.exists?(keyfile)
  41             content = File.read(keyfile)
  42           else
  43             content = keyfile
  44           end
  45           pkcs12 = OpenSSL::PKCS12.new(content, passphrase)
  46           return pkcs12.key
  47         rescue OpenSSL::PKCS12::PKCS12Error
  48           raise ArgumentError.new("Invalid keyfile or passphrase")
  49         end
  50       end
  51     end
  52
  53     ##
  54     # Generates access tokens using the JWT assertion profile. Requires a
  55     # service account & access to the private key.
  56     #
  57     # @example
  58     #
  59     #    client = Google::APIClient.new
  60     #    key = Google::APIClient::PKCS12.load_key('client.p12', 'notasecret')
  61     #    service_account = Google::APIClient::JWTAsserter(
  62     #        '123456-abcdef@developer.gserviceaccount.com',
  63     #        'https://www.googleapis.com/auth/prediction',
  64     #        key)
  65     #    client.authorization = service_account.authorize
  66     #    client.execute(...)
  67     class JWTAsserter
  68       attr_accessor :issuer, :expiry, :skew
  69       attr_reader :scope
  70       attr_writer :key
  71
  72       ##
  73       # Initializes the asserter for a service account.
  74       #
  75       # @param [String] issuer
  76       #    Name/ID of the client issuing the assertion
  77       # @param [String or Array] scope
  78       #   Scopes to authorize. May be a space delimited string or array of strings
  79       # @param [OpenSSL::PKey] key
  80       #   RSA private key for signing assertions
  81       def initialize(issuer, scope, key)
  82         self.issuer = issuer
  83         self.scope = scope
  84         self.expiry = 60 # 1 min default
  85         self.skew = 60
  86         self.key = key
  87       end
  88
  89       ##
  90       # Set the scopes to authorize
  91       #
  92       # @param [String, Array] new_scope
  93       #   Scopes to authorize. May be a space delimited string or array of strings
  94       def scope=(new_scope)
  95         case new_scope
  96         when Array
  97           @scope = new_scope.join(' ')
  98         when String
  99           @scope = new_scope
 100         when nil
 101           @scope = ''
 102         else
 103           raise TypeError, "Expected Array or String, got #{new_scope.class}"
 104         end
 105       end
 106
 107       ##
 108       # Builds & signs the assertion.
 109       #
 110       # @param [String] person
 111       #   Email address of a user, if requesting a token to act on their behalf
 112       # @return [String] Encoded JWT
 113       def to_jwt(person=nil)
 114         now = Time.new
 115         assertion = {
 116           "iss" => @issuer,
 117           "scope" => self.scope,
 118           "aud" => "https://accounts.google.com/o/oauth2/token",
 119           "exp" => (now + expiry).to_i,
 120           "iat" => (now - skew).to_i
 121         }
 122         assertion['prn'] = person unless person.nil?
 123         return JWT.encode(assertion, @key, "RS256")
 124       end
 125
 126       ##
 127       # Request a new access token.
 128       #
 129       # @param [String] person
 130       #   Email address of a user, if requesting a token to act on their behalf
 131       # @param [Hash] options
 132       #   Pass through to Signet::OAuth2::Client.fetch_access_token
 133       # @return [Signet::OAuth2::Client] Access token
 134       #
 135       # @see Signet::OAuth2::Client.fetch_access_token
 136       def authorize(person = nil, options={})
 137         assertion = self.to_jwt(person)
 138         authorization = Signet::OAuth2::Client.new(
 139           :token_credential_uri => 'https://accounts.google.com/o/oauth2/token'
 140         )
 141         authorization.grant_type = 'urn:ietf:params:oauth:grant-type:jwt-bearer'
 142         authorization.extension_parameters = { :assertion => assertion }
 143         authorization.fetch_access_token!(options)
 144         return authorization
 145       end
 146     end
 147   end
 148 end