Add specialization for encoding/decoding WebCore::CertificateInfos in the Network...
[WebKit-https.git] / Source / WebKit2 / NetworkProcess / cache / NetworkCacheCoders.cpp
1 /*
2  * Copyright (C) 2011, 2014-2015 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "NetworkCacheCoders.h"
28
29 #if ENABLE(NETWORK_CACHE)
30
31 #include <wtf/text/CString.h>
32 #include <wtf/text/WTFString.h>
33
34 #if PLATFORM(COCOA)
35 #include <Security/SecCertificate.h>
36 #include <Security/SecTrust.h>
37 #include <wtf/spi/cocoa/SecuritySPI.h>
38 #endif
39
40 namespace WebKit {
41 namespace NetworkCache {
42
43 void Coder<AtomicString>::encode(Encoder& encoder, const AtomicString& atomicString)
44 {
45     encoder << atomicString.string();
46 }
47
48 bool Coder<AtomicString>::decode(Decoder& decoder, AtomicString& atomicString)
49 {
50     String string;
51     if (!decoder.decode(string))
52         return false;
53
54     atomicString = string;
55     return true;
56 }
57
58 void Coder<CString>::encode(Encoder& encoder, const CString& string)
59 {
60     // Special case the null string.
61     if (string.isNull()) {
62         encoder << std::numeric_limits<uint32_t>::max();
63         return;
64     }
65
66     uint32_t length = string.length();
67     encoder << length;
68     encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.data()), length);
69 }
70
71 bool Coder<CString>::decode(Decoder& decoder, CString& result)
72 {
73     uint32_t length;
74     if (!decoder.decode(length))
75         return false;
76
77     if (length == std::numeric_limits<uint32_t>::max()) {
78         // This is the null string.
79         result = CString();
80         return true;
81     }
82
83     // Before allocating the string, make sure that the decoder buffer is big enough.
84     if (!decoder.bufferIsLargeEnoughToContain<char>(length))
85         return false;
86
87     char* buffer;
88     CString string = CString::newUninitialized(length, buffer);
89     if (!decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(buffer), length))
90         return false;
91
92     result = string;
93     return true;
94 }
95
96
97 void Coder<String>::encode(Encoder& encoder, const String& string)
98 {
99     // Special case the null string.
100     if (string.isNull()) {
101         encoder << std::numeric_limits<uint32_t>::max();
102         return;
103     }
104
105     uint32_t length = string.length();
106     bool is8Bit = string.is8Bit();
107
108     encoder << length << is8Bit;
109
110     if (is8Bit)
111         encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.characters8()), length * sizeof(LChar));
112     else
113         encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.characters16()), length * sizeof(UChar));
114 }
115
116 template <typename CharacterType>
117 static inline bool decodeStringText(Decoder& decoder, uint32_t length, String& result)
118 {
119     // Before allocating the string, make sure that the decoder buffer is big enough.
120     if (!decoder.bufferIsLargeEnoughToContain<CharacterType>(length))
121         return false;
122
123     CharacterType* buffer;
124     String string = String::createUninitialized(length, buffer);
125     if (!decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(buffer), length * sizeof(CharacterType)))
126         return false;
127     
128     result = string;
129     return true;    
130 }
131
132 bool Coder<String>::decode(Decoder& decoder, String& result)
133 {
134     uint32_t length;
135     if (!decoder.decode(length))
136         return false;
137
138     if (length == std::numeric_limits<uint32_t>::max()) {
139         // This is the null string.
140         result = String();
141         return true;
142     }
143
144     bool is8Bit;
145     if (!decoder.decode(is8Bit))
146         return false;
147
148     if (is8Bit)
149         return decodeStringText<LChar>(decoder, length, result);
150     return decodeStringText<UChar>(decoder, length, result);
151 }
152
153 #if PLATFORM(COCOA)
154 static void encodeCFData(Encoder& encoder, CFDataRef data)
155 {
156     uint64_t length = CFDataGetLength(data);
157     const uint8_t* bytePtr = CFDataGetBytePtr(data);
158
159     encoder << length;
160     encoder.encodeFixedLengthData(bytePtr, length);
161 }
162
163 static bool decodeCFData(Decoder& decoder, RetainPtr<CFDataRef>& data)
164 {
165     uint64_t size = 0;
166     if (!decoder.decode(size))
167         return false;
168
169     Vector<uint8_t> vector(size);
170     if (!decoder.decodeFixedLengthData(vector.data(), vector.size()))
171         return false;
172
173     data = adoptCF(CFDataCreate(nullptr, vector.data(), vector.size()));
174     return true;
175 }
176
177
178 #if HAVE(SEC_TRUST_SERIALIZATION)
179 static void encodeSecTrustRef(Encoder& encoder, SecTrustRef trust)
180 {
181     auto data = adoptCF(SecTrustSerialize(trust, nullptr));
182     if (!data) {
183         encoder << false;
184         return;
185     }
186
187     encoder << true;
188     encodeCFData(encoder, data.get());
189 }
190
191 static bool decodeSecTrustRef(Decoder& decoder, RetainPtr<SecTrustRef>& result)
192 {
193     bool hasTrust;
194     if (!decoder.decode(hasTrust))
195         return false;
196
197     if (!hasTrust)
198         return true;
199
200     RetainPtr<CFDataRef> trustData;
201     if (!decodeCFData(decoder, trustData))
202         return false;
203
204     auto trust = adoptCF(SecTrustDeserialize(trustData.get(), nullptr));
205     if (!trust)
206         return false;
207
208     result = WTFMove(trust);
209     return true;
210 }
211 #endif
212
213 static void encodeCertificateChain(Encoder& encoder, CFArrayRef certificateChain)
214 {
215     CFIndex size = CFArrayGetCount(certificateChain);
216     Vector<CFTypeRef, 32> values(size);
217
218     CFArrayGetValues(certificateChain, CFRangeMake(0, size), values.data());
219
220     encoder << static_cast<uint64_t>(size);
221
222     for (CFIndex i = 0; i < size; ++i) {
223         ASSERT(values[i]);
224         ASSERT(CFGetTypeID(values[i]) != SecCertificateGetTypeID());
225
226         auto data = adoptCF(SecCertificateCopyData((SecCertificateRef)values[i]));
227         encodeCFData(encoder, data.get());
228     }
229 }
230
231 static bool decodeCertificateChain(Decoder& decoder, RetainPtr<CFArrayRef>& certificateChain)
232 {
233     uint64_t size;
234     if (!decoder.decode(size))
235         return false;
236
237     auto array = adoptCF(CFArrayCreateMutable(0, 0, &kCFTypeArrayCallBacks));
238
239     for (size_t i = 0; i < size; ++i) {
240         RetainPtr<CFDataRef> data;
241         if (!decodeCFData(decoder, data))
242             return false;
243
244         auto certificate = adoptCF(SecCertificateCreateWithData(0, data.get()));
245         CFArrayAppendValue(array.get(), certificate.get());
246     }
247
248     certificateChain = WTFMove(array);
249     return true;
250 }
251
252 void Coder<WebCore::CertificateInfo>::encode(Encoder& encoder, const WebCore::CertificateInfo& certificateInfo)
253 {
254     encoder.encodeEnum(certificateInfo.type());
255
256     switch (certificateInfo.type()) {
257 #if HAVE(SEC_TRUST_SERIALIZATION)
258     case WebCore::CertificateInfo::Type::Trust:
259         encodeSecTrustRef(encoder, certificateInfo.trust());
260         break;
261 #endif
262     case WebCore::CertificateInfo::Type::CertificateChain: {
263         encodeCertificateChain(encoder, certificateInfo.certificateChain());
264         break;
265     }
266     case WebCore::CertificateInfo::Type::None:
267         // Do nothing.
268         break;
269     }
270 }
271
272 bool Coder<WebCore::CertificateInfo>::decode(Decoder& decoder, WebCore::CertificateInfo& certificateInfo)
273 {
274     WebCore::CertificateInfo::Type certificateInfoType;
275     if (!decoder.decodeEnum(certificateInfoType))
276         return false;
277
278     switch (certificateInfoType) {
279 #if HAVE(SEC_TRUST_SERIALIZATION)
280     case WebCore::CertificateInfo::Type::Trust: {
281         RetainPtr<SecTrustRef> trust;
282         if (!decodeSecTrustRef(decoder, trust))
283             return false;
284
285         certificateInfo = WebCore::CertificateInfo(WTFMove(trust));
286         return true;
287     }
288 #endif
289     case WebCore::CertificateInfo::Type::CertificateChain: {
290         RetainPtr<CFArrayRef> certificateChain;
291         if (!decodeCertificateChain(decoder, certificateChain))
292             return false;
293
294         certificateInfo = WebCore::CertificateInfo(WTFMove(certificateChain));
295         return true;
296     }    
297     case WebCore::CertificateInfo::Type::None:
298         // Do nothing.
299         break;
300     }
301
302     return true;
303 }
304 #else
305 void Coder<WebCore::CertificateInfo>::encode(Encoder& encoder, const WebCore::CertificateInfo& certificateInfo)
306 {
307     if (!certificateInfo.certificate()) {
308         encoder << false;
309         return;
310     }
311
312     GByteArray* certificateData = 0;
313     g_object_get(G_OBJECT(certificateInfo.certificate()), "certificate", &certificateData, NULL);
314     if (!certificateData) {
315         encoder << false;
316         return;
317     }
318
319     encoder << true;
320
321     GRefPtr<GByteArray> certificate = adoptGRef(certificateData);
322     encoder << static_cast<uint64_t>(certificate->len);
323     encoder.encodeFixedLengthData(certificate->data, certificate->len);
324
325     encoder << static_cast<uint32_t>(certificateInfo.tlsErrors());
326 }
327
328 bool Coder<WebCore::CertificateInfo>::decode(Decoder& decoder, WebCore::CertificateInfo& certificateInfo)
329 {
330     bool hasCertificate;
331     if (!decoder.decode(hasCertificate))
332         return false;
333
334     if (!hasCertificate)
335         return true;
336
337     uint64_t size = 0;
338     if (!decoder.decode(size))
339         return false;
340
341     Vector<uint8_t> vector(size);
342     if (!decoder.decodeFixedLengthData(vector.data(), vector.size()))
343         return false;
344
345     GByteArray* certificateData = g_byte_array_sized_new(vector.size());
346     certificateData = g_byte_array_append(certificateData, vector.data(), vector.size());
347     GRefPtr<GByteArray> certificateBytes = adoptGRef(certificateData);
348
349     GTlsBackend* backend = g_tls_backend_get_default();
350     GRefPtr<GTlsCertificate> certificate = adoptGRef(G_TLS_CERTIFICATE(g_initable_new(
351         g_tls_backend_get_certificate_type(backend), 0, 0, "certificate", certificateBytes.get(), nullptr)));
352     certificateInfo.setCertificate(certificate.get());
353
354     uint32_t tlsErrors;
355     if (!decoder.decode(tlsErrors))
356         return false;
357     certificateInfo.setTLSErrors(static_cast<GTlsCertificateFlags>(tlsErrors));
358
359     return true;
360 }
361 #endif
362
363 void Coder<SHA1::Digest>::encode(Encoder& encoder, const SHA1::Digest& digest)
364 {
365     encoder.encodeFixedLengthData(digest.data(), sizeof(digest));
366 }
367
368 bool Coder<SHA1::Digest>::decode(Decoder& decoder, SHA1::Digest& digest)
369 {
370     return decoder.decodeFixedLengthData(digest.data(), sizeof(digest));
371 }
372
373 // Store common HTTP headers as strings instead of using their value in the HTTPHeaderName enumeration
374 // so that the headers stored in the cache stays valid even after HTTPHeaderName.in gets updated.
375 void Coder<WebCore::HTTPHeaderMap>::encode(Encoder& encoder, const WebCore::HTTPHeaderMap& headers)
376 {
377     encoder << static_cast<uint64_t>(headers.size());
378     for (auto& keyValue : headers) {
379         encoder << keyValue.key;
380         encoder << keyValue.value;
381     }
382 }
383
384 bool Coder<WebCore::HTTPHeaderMap>::decode(Decoder& decoder, WebCore::HTTPHeaderMap& headers)
385 {
386     uint64_t headersSize;
387     if (!decoder.decode(headersSize))
388         return false;
389     for (uint64_t i = 0; i < headersSize; ++i) {
390         String name;
391         if (!decoder.decode(name))
392             return false;
393         String value;
394         if (!decoder.decode(value))
395             return false;
396         headers.add(name, value);
397     }
398     return true;
399 }
400
401 }
402 }
403
404 #endif