13561: Avoid old versions to be updated, with test.
[arvados.git] / services / api / app / models / api_client_authorization.rb
1 # Copyright (C) The Arvados Authors. All rights reserved.
2 #
3 # SPDX-License-Identifier: AGPL-3.0
4
5 class ApiClientAuthorization < ArvadosModel
6   include HasUuid
7   include KindAndEtag
8   include CommonApiTemplate
9   extend CurrentApiClient
10
11   belongs_to :api_client
12   belongs_to :user
13   after_initialize :assign_random_api_token
14   serialize :scopes, Array
15
16   api_accessible :user, extend: :common do |t|
17     t.add :owner_uuid
18     t.add :user_id
19     t.add :api_client_id
20     # NB the "api_token" db column is a misnomer in that it's only the
21     # "secret" part of a token: a v1 token is just the secret, but a
22     # v2 token is "v2/uuid/secret".
23     t.add :api_token
24     t.add :created_by_ip_address
25     t.add :default_owner_uuid
26     t.add :expires_at
27     t.add :last_used_at
28     t.add :last_used_by_ip_address
29     t.add :scopes
30   end
31
32   UNLOGGED_CHANGES = ['last_used_at', 'last_used_by_ip_address', 'updated_at']
33
34   def assign_random_api_token
35     self.api_token ||= rand(2**256).to_s(36)
36   end
37
38   def owner_uuid
39     self.user.andand.uuid
40   end
41   def owner_uuid_was
42     self.user_id_changed? ? User.where(id: self.user_id_was).first.andand.uuid : self.user.andand.uuid
43   end
44   def owner_uuid_changed?
45     self.user_id_changed?
46   end
47
48   def modified_by_client_uuid
49     nil
50   end
51   def modified_by_client_uuid=(x) end
52
53   def modified_by_user_uuid
54     nil
55   end
56   def modified_by_user_uuid=(x) end
57
58   def modified_at
59     nil
60   end
61   def modified_at=(x) end
62
63   def scopes_allow?(req_s)
64     scopes.each do |scope|
65       return true if (scope == 'all') or (scope == req_s) or
66         ((scope.end_with? '/') and (req_s.start_with? scope))
67     end
68     false
69   end
70
71   def scopes_allow_request?(request)
72     method = request.request_method
73     if method == 'HEAD'
74       (scopes_allow?(['HEAD', request.path].join(' ')) ||
75        scopes_allow?(['GET', request.path].join(' ')))
76     else
77       scopes_allow?([method, request.path].join(' '))
78     end
79   end
80
81   def logged_attributes
82     super.except 'api_token'
83   end
84
85   def self.default_orders
86     ["#{table_name}.id desc"]
87   end
88
89   def self.remote_host(uuid_prefix:)
90     Rails.configuration.remote_hosts[uuid_prefix] ||
91       (Rails.configuration.remote_hosts_via_dns &&
92        uuid_prefix+".arvadosapi.com")
93   end
94
95   def self.validate(token:, remote: nil)
96     return nil if !token
97     remote ||= Rails.configuration.uuid_prefix
98
99     case token[0..2]
100     when 'v2/'
101       _, uuid, secret = token.split('/')
102       unless uuid.andand.length == 27 && secret.andand.length.andand > 0
103         return nil
104       end
105
106       auth = ApiClientAuthorization.
107              includes(:user, :api_client).
108              where('uuid=? and (expires_at is null or expires_at > CURRENT_TIMESTAMP)', uuid).
109              first
110       if auth && auth.user &&
111          (secret == auth.api_token ||
112           secret == OpenSSL::HMAC.hexdigest('sha1', auth.api_token, remote))
113         return auth
114       end
115
116       uuid_prefix = uuid[0..4]
117       if uuid_prefix == Rails.configuration.uuid_prefix
118         # If the token were valid, we would have validated it above
119         return nil
120       elsif uuid_prefix.length != 5
121         # malformed
122         return nil
123       end
124
125       host = remote_host(uuid_prefix: uuid_prefix)
126       if !host
127         Rails.logger.warn "remote authentication rejected: no host for #{uuid_prefix.inspect}"
128         return nil
129       end
130
131       # Token was issued by a different cluster. If it's expired or
132       # missing in our database, ask the originating cluster to
133       # [re]validate it.
134       begin
135         clnt = HTTPClient.new
136         if Rails.configuration.sso_insecure
137           clnt.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
138         end
139         remote_user = SafeJSON.load(
140           clnt.get_content('https://' + host + '/arvados/v1/users/current',
141                            {'remote' => Rails.configuration.uuid_prefix},
142                            {'Authorization' => 'Bearer ' + token}))
143       rescue => e
144         Rails.logger.warn "remote authentication with token #{token.inspect} failed: #{e}"
145         return nil
146       end
147       if !remote_user.is_a?(Hash) || !remote_user['uuid'].is_a?(String) || remote_user['uuid'][0..4] != uuid[0..4]
148         Rails.logger.warn "remote authentication rejected: remote_user=#{remote_user.inspect}"
149         return nil
150       end
151       act_as_system_user do
152         # Add/update user and token in our database so we can
153         # validate subsequent requests faster.
154
155         user = User.find_or_create_by(uuid: remote_user['uuid']) do |user|
156           # (this block runs for the "create" case, not for "find")
157           user.is_admin = false
158           user.email = remote_user['email']
159           if remote_user['username'].andand.length.andand > 0
160             user.set_initial_username(requested: remote_user['username'])
161           end
162         end
163
164         if Rails.configuration.new_users_are_active ||
165            Rails.configuration.auto_activate_users_from.include?(remote_user['uuid'][0..4])
166           # Update is_active to whatever it is at the remote end
167           user.is_active = remote_user['is_active']
168         elsif !remote_user['is_active']
169           # Remote user is inactive; our mirror should be, too.
170           user.is_active = false
171         end
172
173         %w[first_name last_name email prefs].each do |attr|
174           user.send(attr+'=', remote_user[attr])
175         end
176
177         user.save!
178
179         auth = ApiClientAuthorization.find_or_create_by(uuid: uuid) do |auth|
180           auth.user = user
181           auth.api_token = secret
182           auth.api_client_id = 0
183         end
184
185         # Accept this token (and don't reload the user record) for
186         # 5 minutes. TODO: Request the actual api_client_auth
187         # record from the remote server in case it wants the token
188         # to expire sooner.
189         auth.update_attributes!(user: user,
190                                 api_token: secret,
191                                 api_client_id: 0,
192                                 expires_at: Time.now + 5.minutes)
193       end
194       return auth
195     else
196       auth = ApiClientAuthorization.
197              includes(:user, :api_client).
198              where('api_token=? and (expires_at is null or expires_at > CURRENT_TIMESTAMP)', token).
199              first
200       if auth && auth.user
201         return auth
202       end
203     end
204     return nil
205   end
206
207   protected
208
209   def permission_to_create
210     current_user.andand.is_admin or (current_user.andand.id == self.user_id)
211   end
212
213   def permission_to_update
214     permission_to_create && !uuid_changed? &&
215       (current_user.andand.is_admin || !user_id_changed?)
216   end
217
218   def log_update
219     super unless (changed - UNLOGGED_CHANGES).empty?
220   end
221 end