[WTF] Add makeUnique<T>, which ensures T is fast-allocated, makeUnique / makeUniqueWi...
[WebKit-https.git] / Source / WebCore / platform / network / soup / NetworkStorageSessionSoup.cpp
1 /*
2  * Copyright (C) 2013 Apple Inc. All rights reserved.
3  * Copyright (C) 2013 University of Szeged. All rights reserved.
4  * Copyright (C) 2016 Igalia S.L.
5  * Copyright (C) 2017 Endless Mobile, Inc.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS''
17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
18  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
26  * THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include "config.h"
30 #include "NetworkStorageSession.h"
31
32 #if USE(SOUP)
33
34 #include "Cookie.h"
35 #include "CookieRequestHeaderFieldProxy.h"
36 #include "GUniquePtrSoup.h"
37 #include "ResourceHandle.h"
38 #include "SoupNetworkSession.h"
39 #include "URLSoup.h"
40 #include <libsoup/soup.h>
41 #include <wtf/DateMath.h>
42 #include <wtf/MainThread.h>
43 #include <wtf/NeverDestroyed.h>
44 #include <wtf/glib/GUniquePtr.h>
45
46 #if USE(LIBSECRET)
47 #include "GRefPtrGtk.h"
48 #include <glib/gi18n-lib.h>
49 #define SECRET_WITH_UNSTABLE 1
50 #define SECRET_API_SUBJECT_TO_CHANGE 1
51 #include <libsecret/secret.h>
52 #endif
53
54 namespace WebCore {
55
56 NetworkStorageSession::NetworkStorageSession(PAL::SessionID sessionID)
57     : m_sessionID(sessionID)
58     , m_cookieStorage(adoptGRef(soup_cookie_jar_new()))
59 {
60     soup_cookie_jar_set_accept_policy(m_cookieStorage.get(), SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY);
61     g_signal_connect_swapped(m_cookieStorage.get(), "changed", G_CALLBACK(cookiesDidChange), this);
62 }
63
64 NetworkStorageSession::~NetworkStorageSession()
65 {
66     g_signal_handlers_disconnect_matched(m_cookieStorage.get(), G_SIGNAL_MATCH_DATA, 0, 0, nullptr, nullptr, this);
67 }
68
69 void NetworkStorageSession::cookiesDidChange(NetworkStorageSession* session)
70 {
71     if (session->m_cookieObserverHandler)
72         session->m_cookieObserverHandler();
73 }
74
75 void NetworkStorageSession::setCookieStorage(GRefPtr<SoupCookieJar>&& jar)
76 {
77     g_signal_handlers_disconnect_matched(m_cookieStorage.get(), G_SIGNAL_MATCH_DATA, 0, 0, nullptr, nullptr, this);
78     m_cookieStorage = WTFMove(jar);
79     g_signal_connect_swapped(m_cookieStorage.get(), "changed", G_CALLBACK(cookiesDidChange), this);
80 }
81
82 void NetworkStorageSession::setCookieObserverHandler(Function<void ()>&& handler)
83 {
84     m_cookieObserverHandler = WTFMove(handler);
85 }
86
87 #if USE(LIBSECRET)
88 static const char* schemeFromProtectionSpaceServerType(ProtectionSpaceServerType serverType)
89 {
90     switch (serverType) {
91     case ProtectionSpaceServerHTTP:
92     case ProtectionSpaceProxyHTTP:
93         return SOUP_URI_SCHEME_HTTP;
94     case ProtectionSpaceServerHTTPS:
95     case ProtectionSpaceProxyHTTPS:
96         return SOUP_URI_SCHEME_HTTPS;
97     case ProtectionSpaceServerFTP:
98     case ProtectionSpaceProxyFTP:
99         return SOUP_URI_SCHEME_FTP;
100     case ProtectionSpaceServerFTPS:
101     case ProtectionSpaceProxySOCKS:
102         break;
103     }
104
105     ASSERT_NOT_REACHED();
106     return SOUP_URI_SCHEME_HTTP;
107 }
108
109 static const char* authTypeFromProtectionSpaceAuthenticationScheme(ProtectionSpaceAuthenticationScheme scheme)
110 {
111     switch (scheme) {
112     case ProtectionSpaceAuthenticationSchemeDefault:
113     case ProtectionSpaceAuthenticationSchemeHTTPBasic:
114         return "Basic";
115     case ProtectionSpaceAuthenticationSchemeHTTPDigest:
116         return "Digest";
117     case ProtectionSpaceAuthenticationSchemeNTLM:
118         return "NTLM";
119     case ProtectionSpaceAuthenticationSchemeNegotiate:
120         return "Negotiate";
121     case ProtectionSpaceAuthenticationSchemeHTMLForm:
122     case ProtectionSpaceAuthenticationSchemeClientCertificateRequested:
123     case ProtectionSpaceAuthenticationSchemeServerTrustEvaluationRequested:
124         ASSERT_NOT_REACHED();
125         break;
126     case ProtectionSpaceAuthenticationSchemeOAuth:
127         return "OAuth";
128     case ProtectionSpaceAuthenticationSchemeUnknown:
129         return "unknown";
130     }
131
132     ASSERT_NOT_REACHED();
133     return "unknown";
134 }
135
136 struct SecretServiceSearchData {
137     WTF_MAKE_STRUCT_FAST_ALLOCATED;
138     SecretServiceSearchData(GCancellable* cancellable, Function<void (Credential&&)>&& completionHandler)
139         : cancellable(cancellable)
140         , completionHandler(WTFMove(completionHandler))
141     {
142     }
143
144     ~SecretServiceSearchData() = default;
145
146     GRefPtr<GCancellable> cancellable;
147     Function<void (Credential&&)> completionHandler;
148 };
149 #endif // USE(LIBSECRET)
150
151 void NetworkStorageSession::getCredentialFromPersistentStorage(const ProtectionSpace& protectionSpace, GCancellable* cancellable, Function<void (Credential&&)>&& completionHandler)
152 {
153 #if USE(LIBSECRET)
154     if (m_sessionID.isEphemeral()) {
155         completionHandler({ });
156         return;
157     }
158
159     const String& realm = protectionSpace.realm();
160     if (realm.isEmpty()) {
161         completionHandler({ });
162         return;
163     }
164
165     GRefPtr<GHashTable> attributes = adoptGRef(secret_attributes_build(SECRET_SCHEMA_COMPAT_NETWORK,
166         "domain", realm.utf8().data(),
167         "server", protectionSpace.host().utf8().data(),
168         "port", protectionSpace.port(),
169         "protocol", schemeFromProtectionSpaceServerType(protectionSpace.serverType()),
170         "authtype", authTypeFromProtectionSpaceAuthenticationScheme(protectionSpace.authenticationScheme()),
171         nullptr));
172     if (!attributes) {
173         completionHandler({ });
174         return;
175     }
176
177     auto data = makeUnique<SecretServiceSearchData>(cancellable, WTFMove(completionHandler));
178     secret_service_search(nullptr, SECRET_SCHEMA_COMPAT_NETWORK, attributes.get(),
179         static_cast<SecretSearchFlags>(SECRET_SEARCH_UNLOCK | SECRET_SEARCH_LOAD_SECRETS), cancellable,
180         [](GObject* source, GAsyncResult* result, gpointer userData) {
181             auto data = std::unique_ptr<SecretServiceSearchData>(static_cast<SecretServiceSearchData*>(userData));
182             GUniqueOutPtr<GError> error;
183             GUniquePtr<GList> elements(secret_service_search_finish(SECRET_SERVICE(source), result, &error.outPtr()));
184             if (g_cancellable_is_cancelled(data->cancellable.get()) || error || !elements || !elements->data) {
185                 data->completionHandler({ });
186                 return;
187             }
188
189             GRefPtr<SecretItem> secretItem = static_cast<SecretItem*>(elements->data);
190             g_list_foreach(elements.get(), reinterpret_cast<GFunc>(reinterpret_cast<GCallback>(g_object_unref)), nullptr);
191             GRefPtr<GHashTable> attributes = adoptGRef(secret_item_get_attributes(secretItem.get()));
192             String user = String::fromUTF8(static_cast<const char*>(g_hash_table_lookup(attributes.get(), "user")));
193             if (user.isEmpty()) {
194                 data->completionHandler({ });
195                 return;
196             }
197
198             size_t length;
199             GRefPtr<SecretValue> secretValue = adoptGRef(secret_item_get_secret(secretItem.get()));
200             const char* passwordData = secret_value_get(secretValue.get(), &length);
201             data->completionHandler(Credential(user, String::fromUTF8(passwordData, length), CredentialPersistencePermanent));
202         }, data.release());
203 #else
204     UNUSED_PARAM(protectionSpace);
205     UNUSED_PARAM(cancellable);
206     completionHandler({ });
207 #endif
208 }
209
210 void NetworkStorageSession::saveCredentialToPersistentStorage(const ProtectionSpace& protectionSpace, const Credential& credential)
211 {
212 #if USE(LIBSECRET)
213     if (m_sessionID.isEphemeral())
214         return;
215
216     if (credential.isEmpty())
217         return;
218
219     const String& realm = protectionSpace.realm();
220     if (realm.isEmpty())
221         return;
222
223     GRefPtr<GHashTable> attributes = adoptGRef(secret_attributes_build(SECRET_SCHEMA_COMPAT_NETWORK,
224         "domain", realm.utf8().data(),
225         "server", protectionSpace.host().utf8().data(),
226         "port", protectionSpace.port(),
227         "protocol", schemeFromProtectionSpaceServerType(protectionSpace.serverType()),
228         "authtype", authTypeFromProtectionSpaceAuthenticationScheme(protectionSpace.authenticationScheme()),
229         nullptr));
230     if (!attributes)
231         return;
232
233     g_hash_table_insert(attributes.get(), g_strdup("user"), g_strdup(credential.user().utf8().data()));
234     CString utf8Password = credential.password().utf8();
235     GRefPtr<SecretValue> newSecretValue = adoptGRef(secret_value_new(utf8Password.data(), utf8Password.length(), "text/plain"));
236     secret_service_store(nullptr, SECRET_SCHEMA_COMPAT_NETWORK, attributes.get(), SECRET_COLLECTION_DEFAULT, _("WebKitGTK password"),
237         newSecretValue.get(), nullptr, nullptr, nullptr);
238 #else
239     UNUSED_PARAM(protectionSpace);
240     UNUSED_PARAM(credential);
241 #endif
242 }
243
244 bool NetworkStorageSession::cookiesEnabled() const
245 {
246     auto policy = soup_cookie_jar_get_accept_policy(cookieStorage());
247     return policy == SOUP_COOKIE_JAR_ACCEPT_ALWAYS || policy == SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY;
248 }
249
250 static inline bool httpOnlyCookieExists(const GSList* cookies, const gchar* name, const gchar* path)
251 {
252     for (const GSList* iter = cookies; iter; iter = g_slist_next(iter)) {
253         SoupCookie* cookie = static_cast<SoupCookie*>(iter->data);
254         if (!strcmp(soup_cookie_get_name(cookie), name) 
255             && !g_strcmp0(soup_cookie_get_path(cookie), path)) {
256             if (soup_cookie_get_http_only(cookie))
257                 return true;
258             break;
259         }
260     }
261     return false;
262 }
263
264 void NetworkStorageSession::setCookiesFromDOM(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, const String& value) const
265 {
266     UNUSED_PARAM(frameID);
267     UNUSED_PARAM(pageID);
268     GUniquePtr<SoupURI> origin = urlToSoupURI(url);
269     if (!origin)
270         return;
271
272     GUniquePtr<SoupURI> firstPartyURI = urlToSoupURI(firstParty);
273     if (!firstPartyURI)
274         return;
275
276     // Get existing cookies for this origin.
277     SoupCookieJar* jar = cookieStorage();
278     GSList* existingCookies = soup_cookie_jar_get_cookie_list(jar, origin.get(), TRUE);
279
280     for (auto& cookieString : value.split('\n')) {
281         GUniquePtr<SoupCookie> cookie(soup_cookie_parse(cookieString.utf8().data(), origin.get()));
282
283         if (!cookie)
284             continue;
285
286         // Make sure the cookie is not httpOnly since such cookies should not be set from JavaScript.
287         if (soup_cookie_get_http_only(cookie.get()))
288             continue;
289
290         // Make sure we do not overwrite httpOnly cookies from JavaScript.
291         if (httpOnlyCookieExists(existingCookies, soup_cookie_get_name(cookie.get()), soup_cookie_get_path(cookie.get())))
292             continue;
293
294         soup_cookie_jar_add_cookie_with_first_party(jar, firstPartyURI.get(), cookie.release());
295     }
296
297     soup_cookies_free(existingCookies);
298 }
299
300 void NetworkStorageSession::setCookies(const Vector<Cookie>& cookies, const URL&, const URL&)
301 {
302     for (auto cookie : cookies)
303         soup_cookie_jar_add_cookie(cookieStorage(), cookie.toSoupCookie());
304 }
305
306 void NetworkStorageSession::setCookie(const Cookie& cookie)
307 {
308     soup_cookie_jar_add_cookie(cookieStorage(), cookie.toSoupCookie());
309 }
310
311 void NetworkStorageSession::deleteCookie(const Cookie& cookie)
312 {
313     GUniquePtr<SoupCookie> targetCookie(cookie.toSoupCookie());
314     soup_cookie_jar_delete_cookie(cookieStorage(), targetCookie.get());
315 }
316
317 void NetworkStorageSession::deleteCookie(const URL& url, const String& name) const
318 {
319     GUniquePtr<SoupURI> uri = urlToSoupURI(url);
320     if (!uri)
321         return;
322
323     SoupCookieJar* jar = cookieStorage();
324     GUniquePtr<GSList> cookies(soup_cookie_jar_get_cookie_list(jar, uri.get(), TRUE));
325     if (!cookies)
326         return;
327
328     CString cookieName = name.utf8();
329     bool wasDeleted = false;
330     for (GSList* iter = cookies.get(); iter; iter = g_slist_next(iter)) {
331         SoupCookie* cookie = static_cast<SoupCookie*>(iter->data);
332         if (!wasDeleted && cookieName == cookie->name) {
333             soup_cookie_jar_delete_cookie(jar, cookie);
334             wasDeleted = true;
335         }
336         soup_cookie_free(cookie);
337     }
338 }
339
340 void NetworkStorageSession::deleteAllCookies()
341 {
342     SoupCookieJar* cookieJar = cookieStorage();
343     GUniquePtr<GSList> cookies(soup_cookie_jar_all_cookies(cookieJar));
344     for (GSList* item = cookies.get(); item; item = g_slist_next(item)) {
345         SoupCookie* cookie = static_cast<SoupCookie*>(item->data);
346         soup_cookie_jar_delete_cookie(cookieJar, cookie);
347         soup_cookie_free(cookie);
348     }
349 }
350
351 void NetworkStorageSession::deleteAllCookiesModifiedSince(WallTime timestamp)
352 {
353     // FIXME: Add support for deleting cookies modified since the given timestamp. It should probably be added to libsoup.
354     if (timestamp == WallTime::fromRawSeconds(0))
355         deleteAllCookies();
356     else
357         g_warning("Deleting cookies modified since a given time span is not supported yet");
358 }
359
360 void NetworkStorageSession::deleteCookiesForHostnames(const Vector<String>& hostnames, IncludeHttpOnlyCookies includeHttpOnlyCookies)
361 {
362     // FIXME: Not yet implemented.
363     UNUSED_PARAM(includeHttpOnlyCookies);
364     deleteCookiesForHostnames(hostnames);
365 }
366
367 void NetworkStorageSession::deleteCookiesForHostnames(const Vector<String>& hostnames)
368 {
369     SoupCookieJar* cookieJar = cookieStorage();
370
371     for (const auto& hostname : hostnames) {
372         CString hostNameString = hostname.utf8();
373
374         GUniquePtr<GSList> cookies(soup_cookie_jar_all_cookies(cookieJar));
375         for (GSList* item = cookies.get(); item; item = g_slist_next(item)) {
376             SoupCookie* cookie = static_cast<SoupCookie*>(item->data);
377             if (soup_cookie_domain_matches(cookie, hostNameString.data()))
378                 soup_cookie_jar_delete_cookie(cookieJar, cookie);
379             soup_cookie_free(cookie);
380         }
381     }
382 }
383
384 void NetworkStorageSession::getHostnamesWithCookies(HashSet<String>& hostnames)
385 {
386     GUniquePtr<GSList> cookies(soup_cookie_jar_all_cookies(cookieStorage()));
387     for (GSList* item = cookies.get(); item; item = g_slist_next(item)) {
388         SoupCookie* cookie = static_cast<SoupCookie*>(item->data);
389         if (cookie->domain)
390             hostnames.add(String::fromUTF8(cookie->domain));
391         soup_cookie_free(cookie);
392     }
393 }
394
395 Vector<Cookie> NetworkStorageSession::getAllCookies()
396 {
397     // FIXME: Implement for WK2 to use.
398     return { };
399 }
400
401 Vector<Cookie> NetworkStorageSession::getCookies(const URL& url)
402 {
403     Vector<Cookie> cookies;
404     GUniquePtr<SoupURI> uri = urlToSoupURI(url);
405     if (!uri)
406         return cookies;
407
408     GUniquePtr<GSList> cookiesList(soup_cookie_jar_get_cookie_list(cookieStorage(), uri.get(), TRUE));
409     for (GSList* item = cookiesList.get(); item; item = g_slist_next(item)) {
410         GUniquePtr<SoupCookie> soupCookie(static_cast<SoupCookie*>(item->data));
411         cookies.append(WebCore::Cookie(soupCookie.get()));
412     }
413
414     return cookies;
415 }
416
417 bool NetworkStorageSession::getRawCookies(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, Vector<Cookie>& rawCookies) const
418 {
419     UNUSED_PARAM(firstParty);
420     UNUSED_PARAM(frameID);
421     UNUSED_PARAM(pageID);
422     rawCookies.clear();
423     GUniquePtr<SoupURI> uri = urlToSoupURI(url);
424     if (!uri)
425         return false;
426
427     GUniquePtr<GSList> cookies(soup_cookie_jar_get_cookie_list(cookieStorage(), uri.get(), TRUE));
428     if (!cookies)
429         return false;
430
431     for (GSList* iter = cookies.get(); iter; iter = g_slist_next(iter)) {
432         SoupCookie* soupCookie = static_cast<SoupCookie*>(iter->data);
433         Cookie cookie;
434         cookie.name = String::fromUTF8(soupCookie->name);
435         cookie.value = String::fromUTF8(soupCookie->value);
436         cookie.domain = String::fromUTF8(soupCookie->domain);
437         cookie.path = String::fromUTF8(soupCookie->path);
438         cookie.created = 0;
439         cookie.expires = soupCookie->expires ? static_cast<double>(soup_date_to_time_t(soupCookie->expires)) * 1000 : 0;
440         cookie.httpOnly = soupCookie->http_only;
441         cookie.secure = soupCookie->secure;
442         cookie.session = !soupCookie->expires;
443         rawCookies.append(WTFMove(cookie));
444         soup_cookie_free(soupCookie);
445     }
446
447     return true;
448 }
449
450 static std::pair<String, bool> cookiesForSession(const NetworkStorageSession& session, const URL& url, bool forHTTPHeader, IncludeSecureCookies includeSecureCookies)
451 {
452     GUniquePtr<SoupURI> uri = urlToSoupURI(url);
453     if (!uri)
454         return { { }, false };
455
456     GSList* cookies = soup_cookie_jar_get_cookie_list(session.cookieStorage(), uri.get(), forHTTPHeader);
457     bool didAccessSecureCookies = false;
458
459     // libsoup should omit secure cookies itself if the protocol is not https.
460     if (url.protocolIs("https")) {
461         GSList* item = cookies;
462         while (item) {
463             auto cookie = static_cast<SoupCookie*>(item->data);
464             if (soup_cookie_get_secure(cookie)) {
465                 didAccessSecureCookies = true;
466                 if (includeSecureCookies == IncludeSecureCookies::No) {
467                     GSList* next = item->next;
468                     soup_cookie_free(static_cast<SoupCookie*>(item->data));
469                     cookies = g_slist_remove_link(cookies, item);
470                     item = next;
471                     continue;
472                 }
473             }
474             item = item->next;
475         }
476     }
477
478     if (!cookies)
479         return { { }, false };
480
481     GUniquePtr<char> cookieHeader(soup_cookies_to_cookie_header(cookies));
482     soup_cookies_free(cookies);
483
484     return { String::fromUTF8(cookieHeader.get()), didAccessSecureCookies };
485 }
486
487 std::pair<String, bool> NetworkStorageSession::cookiesForDOM(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies) const
488 {
489     UNUSED_PARAM(firstParty);
490     UNUSED_PARAM(frameID);
491     UNUSED_PARAM(pageID);
492     return cookiesForSession(*this, url, false, includeSecureCookies);
493 }
494
495 std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies) const
496 {
497     UNUSED_PARAM(firstParty);
498     UNUSED_PARAM(frameID);
499     UNUSED_PARAM(pageID);
500     // Secure cookies will still only be included if url's protocol is https.
501     return cookiesForSession(*this, url, true, includeSecureCookies);
502 }
503
504 std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const CookieRequestHeaderFieldProxy& headerFieldProxy) const
505 {
506     return cookieRequestHeaderFieldValue(headerFieldProxy.firstParty, headerFieldProxy.sameSiteInfo, headerFieldProxy.url, headerFieldProxy.frameID, headerFieldProxy.pageID, headerFieldProxy.includeSecureCookies);
507 }
508
509 void NetworkStorageSession::flushCookieStore()
510 {
511     // FIXME: Implement for WK2 to use.
512 }
513
514 } // namespace WebCore
515
516 #endif // USE(SOUP)