629558f7fbdf012f1e6413f79e54775a3ced2541
[WebKit-https.git] / Source / WebCore / testing / MockWebAuthenticationConfiguration.h
1 /*
2  * Copyright (C) 2018 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 #pragma once
27
28 #if ENABLE(WEB_AUTHN)
29
30 #include <wtf/Forward.h>
31 #include <wtf/text/WTFString.h>
32
33 namespace WebCore {
34
35 struct MockWebAuthenticationConfiguration {
36     enum class HidStage : bool {
37         Info,
38         Request
39     };
40
41     enum class HidSubStage : bool {
42         Init,
43         Msg
44     };
45
46     enum class HidError : uint8_t {
47         Success,
48         DataNotSent,
49         EmptyReport,
50         WrongChannelId,
51         MaliciousPayload,
52         UnsupportedOptions,
53         WrongNonce
54     };
55
56     enum class NfcError : uint8_t {
57         Success,
58         NoTags,
59         WrongTagType,
60         NoConnections,
61         MaliciousPayload
62     };
63
64     struct LocalConfiguration {
65         bool acceptAuthentication { false };
66         bool acceptAttestation { false };
67         String privateKeyBase64;
68         String userCertificateBase64;
69         String intermediateCACertificateBase64;
70         String preferredUserhandleBase64;
71
72         template<class Encoder> void encode(Encoder&) const;
73         template<class Decoder> static Optional<LocalConfiguration> decode(Decoder&);
74     };
75
76     struct HidConfiguration {
77         Vector<String> payloadBase64;
78         HidStage stage { HidStage::Info };
79         HidSubStage subStage { HidSubStage::Init };
80         HidError error { HidError::Success };
81         bool isU2f { false };
82         bool keepAlive { false };
83         bool fastDataArrival { false };
84         bool continueAfterErrorData { false };
85         bool canDowngrade { false };
86         bool expectCancel { false };
87         bool supportClientPin { false };
88
89         template<class Encoder> void encode(Encoder&) const;
90         template<class Decoder> static Optional<HidConfiguration> decode(Decoder&);
91     };
92
93     struct NfcConfiguration {
94         NfcError error { NfcError::Success };
95         Vector<String> payloadBase64;
96         bool multipleTags { false };
97         bool multiplePhysicalTags { false };
98
99         template<class Encoder> void encode(Encoder&) const;
100         template<class Decoder> static Optional<NfcConfiguration> decode(Decoder&);
101     };
102
103     bool silentFailure { false };
104     Optional<LocalConfiguration> local;
105     Optional<HidConfiguration> hid;
106     Optional<NfcConfiguration> nfc;
107
108     template<class Encoder> void encode(Encoder&) const;
109     template<class Decoder> static Optional<MockWebAuthenticationConfiguration> decode(Decoder&);
110 };
111
112 template<class Encoder>
113 void MockWebAuthenticationConfiguration::LocalConfiguration::encode(Encoder& encoder) const
114 {
115     encoder << acceptAuthentication << acceptAttestation << privateKeyBase64 << userCertificateBase64 << intermediateCACertificateBase64 << preferredUserhandleBase64;
116 }
117
118 template<class Decoder>
119 Optional<MockWebAuthenticationConfiguration::LocalConfiguration> MockWebAuthenticationConfiguration::LocalConfiguration::decode(Decoder& decoder)
120 {
121     MockWebAuthenticationConfiguration::LocalConfiguration result;
122
123     Optional<bool> acceptAuthentication;
124     decoder >> acceptAuthentication;
125     if (!acceptAuthentication)
126         return WTF::nullopt;
127     result.acceptAuthentication = *acceptAuthentication;
128
129     Optional<bool> acceptAttestation;
130     decoder >> acceptAttestation;
131     if (!acceptAttestation)
132         return WTF::nullopt;
133     result.acceptAttestation = *acceptAttestation;
134
135     Optional<String> privateKeyBase64;
136     decoder >> privateKeyBase64;
137     if (!privateKeyBase64)
138         return WTF::nullopt;
139     result.privateKeyBase64 = WTFMove(*privateKeyBase64);
140
141     Optional<String> userCertificateBase64;
142     decoder >> userCertificateBase64;
143     if (!userCertificateBase64)
144         return WTF::nullopt;
145     result.userCertificateBase64 = WTFMove(*userCertificateBase64);
146
147     Optional<String> intermediateCACertificateBase64;
148     decoder >> intermediateCACertificateBase64;
149     if (!intermediateCACertificateBase64)
150         return WTF::nullopt;
151     result.intermediateCACertificateBase64 = WTFMove(*intermediateCACertificateBase64);
152
153     Optional<String> preferredUserhandleBase64;
154     decoder >> preferredUserhandleBase64;
155     if (!preferredUserhandleBase64)
156         return WTF::nullopt;
157     result.preferredUserhandleBase64 = WTFMove(*preferredUserhandleBase64);
158
159     return result;
160 }
161
162 template<class Encoder>
163 void MockWebAuthenticationConfiguration::HidConfiguration::encode(Encoder& encoder) const
164 {
165     encoder << payloadBase64 << stage << subStage << error << isU2f << keepAlive << fastDataArrival << continueAfterErrorData << canDowngrade << expectCancel << supportClientPin;
166 }
167
168 template<class Decoder>
169 Optional<MockWebAuthenticationConfiguration::HidConfiguration> MockWebAuthenticationConfiguration::HidConfiguration::decode(Decoder& decoder)
170 {
171     MockWebAuthenticationConfiguration::HidConfiguration result;
172     if (!decoder.decode(result.payloadBase64))
173         return WTF::nullopt;
174     if (!decoder.decodeEnum(result.stage))
175         return WTF::nullopt;
176     if (!decoder.decodeEnum(result.subStage))
177         return WTF::nullopt;
178     if (!decoder.decodeEnum(result.error))
179         return WTF::nullopt;
180     if (!decoder.decode(result.isU2f))
181         return WTF::nullopt;
182     if (!decoder.decode(result.keepAlive))
183         return WTF::nullopt;
184     if (!decoder.decode(result.fastDataArrival))
185         return WTF::nullopt;
186     if (!decoder.decode(result.continueAfterErrorData))
187         return WTF::nullopt;
188     if (!decoder.decode(result.canDowngrade))
189         return WTF::nullopt;
190     if (!decoder.decode(result.expectCancel))
191         return WTF::nullopt;
192     if (!decoder.decode(result.supportClientPin))
193         return WTF::nullopt;
194     return result;
195 }
196
197 template<class Encoder>
198 void MockWebAuthenticationConfiguration::NfcConfiguration::encode(Encoder& encoder) const
199 {
200     encoder << error << payloadBase64 << multipleTags << multiplePhysicalTags;
201 }
202
203 template<class Decoder>
204 Optional<MockWebAuthenticationConfiguration::NfcConfiguration> MockWebAuthenticationConfiguration::NfcConfiguration::decode(Decoder& decoder)
205 {
206     MockWebAuthenticationConfiguration::NfcConfiguration result;
207     if (!decoder.decodeEnum(result.error))
208         return WTF::nullopt;
209     if (!decoder.decode(result.payloadBase64))
210         return WTF::nullopt;
211     if (!decoder.decode(result.multipleTags))
212         return WTF::nullopt;
213     if (!decoder.decode(result.multiplePhysicalTags))
214         return WTF::nullopt;
215     return result;
216 }
217
218 template<class Encoder>
219 void MockWebAuthenticationConfiguration::encode(Encoder& encoder) const
220 {
221     encoder << silentFailure << local << hid << nfc;
222 }
223
224 template<class Decoder>
225 Optional<MockWebAuthenticationConfiguration> MockWebAuthenticationConfiguration::decode(Decoder& decoder)
226 {
227     MockWebAuthenticationConfiguration result;
228
229     Optional<bool> silentFailure;
230     decoder >> silentFailure;
231     if (!silentFailure)
232         return WTF::nullopt;
233     result.silentFailure = *silentFailure;
234
235     Optional<Optional<LocalConfiguration>> local;
236     decoder >> local;
237     if (!local)
238         return WTF::nullopt;
239     result.local = WTFMove(*local);
240
241     Optional<Optional<HidConfiguration>> hid;
242     decoder >> hid;
243     if (!hid)
244         return WTF::nullopt;
245     result.hid = WTFMove(*hid);
246
247     Optional<Optional<NfcConfiguration>> nfc;
248     decoder >> nfc;
249     if (!nfc)
250         return WTF::nullopt;
251     result.nfc = WTFMove(*nfc);
252
253     return result;
254 }
255
256 } // namespace WebCore
257
258 namespace WTF {
259
260 template<> struct EnumTraits<WebCore::MockWebAuthenticationConfiguration::HidStage> {
261     using values = EnumValues<
262         WebCore::MockWebAuthenticationConfiguration::HidStage,
263         WebCore::MockWebAuthenticationConfiguration::HidStage::Info,
264         WebCore::MockWebAuthenticationConfiguration::HidStage::Request
265     >;
266 };
267
268 template<> struct EnumTraits<WebCore::MockWebAuthenticationConfiguration::HidSubStage> {
269     using values = EnumValues<
270         WebCore::MockWebAuthenticationConfiguration::HidSubStage,
271         WebCore::MockWebAuthenticationConfiguration::HidSubStage::Init,
272         WebCore::MockWebAuthenticationConfiguration::HidSubStage::Msg
273     >;
274 };
275
276 template<> struct EnumTraits<WebCore::MockWebAuthenticationConfiguration::HidError> {
277     using values = EnumValues<
278         WebCore::MockWebAuthenticationConfiguration::HidError,
279         WebCore::MockWebAuthenticationConfiguration::HidError::Success,
280         WebCore::MockWebAuthenticationConfiguration::HidError::DataNotSent,
281         WebCore::MockWebAuthenticationConfiguration::HidError::EmptyReport,
282         WebCore::MockWebAuthenticationConfiguration::HidError::WrongChannelId,
283         WebCore::MockWebAuthenticationConfiguration::HidError::MaliciousPayload,
284         WebCore::MockWebAuthenticationConfiguration::HidError::UnsupportedOptions,
285         WebCore::MockWebAuthenticationConfiguration::HidError::WrongNonce
286     >;
287 };
288
289 template<> struct EnumTraits<WebCore::MockWebAuthenticationConfiguration::NfcError> {
290     using values = EnumValues<
291         WebCore::MockWebAuthenticationConfiguration::NfcError,
292         WebCore::MockWebAuthenticationConfiguration::NfcError::Success,
293         WebCore::MockWebAuthenticationConfiguration::NfcError::NoTags,
294         WebCore::MockWebAuthenticationConfiguration::NfcError::WrongTagType,
295         WebCore::MockWebAuthenticationConfiguration::NfcError::NoConnections,
296         WebCore::MockWebAuthenticationConfiguration::NfcError::MaliciousPayload
297     >;
298 };
299
300 } // namespace WTF
301
302 #endif // ENABLE(WEB_AUTHN)