[WebAuthn] Move the mock testing entrance to Internals
[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
87         template<class Encoder> void encode(Encoder&) const;
88         template<class Decoder> static Optional<HidConfiguration> decode(Decoder&);
89     };
90
91     struct NfcConfiguration {
92         NfcError error { NfcError::Success };
93         Vector<String> payloadBase64;
94         bool multipleTags { false };
95
96         template<class Encoder> void encode(Encoder&) const;
97         template<class Decoder> static Optional<NfcConfiguration> decode(Decoder&);
98     };
99
100     bool silentFailure { false };
101     Optional<LocalConfiguration> local;
102     Optional<HidConfiguration> hid;
103     Optional<NfcConfiguration> nfc;
104
105     template<class Encoder> void encode(Encoder&) const;
106     template<class Decoder> static Optional<MockWebAuthenticationConfiguration> decode(Decoder&);
107 };
108
109 template<class Encoder>
110 void MockWebAuthenticationConfiguration::LocalConfiguration::encode(Encoder& encoder) const
111 {
112     encoder << acceptAuthentication << acceptAttestation << privateKeyBase64 << userCertificateBase64 << intermediateCACertificateBase64 << preferredUserhandleBase64;
113 }
114
115 template<class Decoder>
116 Optional<MockWebAuthenticationConfiguration::LocalConfiguration> MockWebAuthenticationConfiguration::LocalConfiguration::decode(Decoder& decoder)
117 {
118     MockWebAuthenticationConfiguration::LocalConfiguration result;
119
120     Optional<bool> acceptAuthentication;
121     decoder >> acceptAuthentication;
122     if (!acceptAuthentication)
123         return WTF::nullopt;
124     result.acceptAuthentication = *acceptAuthentication;
125
126     Optional<bool> acceptAttestation;
127     decoder >> acceptAttestation;
128     if (!acceptAttestation)
129         return WTF::nullopt;
130     result.acceptAttestation = *acceptAttestation;
131
132     Optional<String> privateKeyBase64;
133     decoder >> privateKeyBase64;
134     if (!privateKeyBase64)
135         return WTF::nullopt;
136     result.privateKeyBase64 = WTFMove(*privateKeyBase64);
137
138     Optional<String> userCertificateBase64;
139     decoder >> userCertificateBase64;
140     if (!userCertificateBase64)
141         return WTF::nullopt;
142     result.userCertificateBase64 = WTFMove(*userCertificateBase64);
143
144     Optional<String> intermediateCACertificateBase64;
145     decoder >> intermediateCACertificateBase64;
146     if (!intermediateCACertificateBase64)
147         return WTF::nullopt;
148     result.intermediateCACertificateBase64 = WTFMove(*intermediateCACertificateBase64);
149
150     Optional<String> preferredUserhandleBase64;
151     decoder >> preferredUserhandleBase64;
152     if (!preferredUserhandleBase64)
153         return WTF::nullopt;
154     result.preferredUserhandleBase64 = WTFMove(*preferredUserhandleBase64);
155
156     return result;
157 }
158
159 template<class Encoder>
160 void MockWebAuthenticationConfiguration::HidConfiguration::encode(Encoder& encoder) const
161 {
162     encoder << payloadBase64 << stage << subStage << error << isU2f << keepAlive << fastDataArrival << continueAfterErrorData << canDowngrade;
163 }
164
165 template<class Decoder>
166 Optional<MockWebAuthenticationConfiguration::HidConfiguration> MockWebAuthenticationConfiguration::HidConfiguration::decode(Decoder& decoder)
167 {
168     MockWebAuthenticationConfiguration::HidConfiguration result;
169     if (!decoder.decode(result.payloadBase64))
170         return WTF::nullopt;
171     if (!decoder.decodeEnum(result.stage))
172         return WTF::nullopt;
173     if (!decoder.decodeEnum(result.subStage))
174         return WTF::nullopt;
175     if (!decoder.decodeEnum(result.error))
176         return WTF::nullopt;
177     if (!decoder.decode(result.isU2f))
178         return WTF::nullopt;
179     if (!decoder.decode(result.keepAlive))
180         return WTF::nullopt;
181     if (!decoder.decode(result.fastDataArrival))
182         return WTF::nullopt;
183     if (!decoder.decode(result.continueAfterErrorData))
184         return WTF::nullopt;
185     if (!decoder.decode(result.canDowngrade))
186         return WTF::nullopt;
187     return result;
188 }
189
190 template<class Encoder>
191 void MockWebAuthenticationConfiguration::NfcConfiguration::encode(Encoder& encoder) const
192 {
193     encoder << error << payloadBase64 << multipleTags;
194 }
195
196 template<class Decoder>
197 Optional<MockWebAuthenticationConfiguration::NfcConfiguration> MockWebAuthenticationConfiguration::NfcConfiguration::decode(Decoder& decoder)
198 {
199     MockWebAuthenticationConfiguration::NfcConfiguration result;
200     if (!decoder.decodeEnum(result.error))
201         return WTF::nullopt;
202     if (!decoder.decode(result.payloadBase64))
203         return WTF::nullopt;
204     if (!decoder.decode(result.multipleTags))
205         return WTF::nullopt;
206     return result;
207 }
208
209 template<class Encoder>
210 void MockWebAuthenticationConfiguration::encode(Encoder& encoder) const
211 {
212     encoder << silentFailure << local << hid << nfc;
213 }
214
215 template<class Decoder>
216 Optional<MockWebAuthenticationConfiguration> MockWebAuthenticationConfiguration::decode(Decoder& decoder)
217 {
218     MockWebAuthenticationConfiguration result;
219
220     Optional<bool> silentFailure;
221     decoder >> silentFailure;
222     if (!silentFailure)
223         return WTF::nullopt;
224     result.silentFailure = *silentFailure;
225
226     Optional<Optional<LocalConfiguration>> local;
227     decoder >> local;
228     if (!local)
229         return WTF::nullopt;
230     result.local = WTFMove(*local);
231
232     Optional<Optional<HidConfiguration>> hid;
233     decoder >> hid;
234     if (!hid)
235         return WTF::nullopt;
236     result.hid = WTFMove(*hid);
237
238     Optional<Optional<NfcConfiguration>> nfc;
239     decoder >> nfc;
240     if (!nfc)
241         return WTF::nullopt;
242     result.nfc = WTFMove(*nfc);
243
244     return result;
245 }
246
247 } // namespace WebCore
248
249 namespace WTF {
250
251 template<> struct EnumTraits<WebCore::MockWebAuthenticationConfiguration::HidStage> {
252     using values = EnumValues<
253         WebCore::MockWebAuthenticationConfiguration::HidStage,
254         WebCore::MockWebAuthenticationConfiguration::HidStage::Info,
255         WebCore::MockWebAuthenticationConfiguration::HidStage::Request
256     >;
257 };
258
259 template<> struct EnumTraits<WebCore::MockWebAuthenticationConfiguration::HidSubStage> {
260     using values = EnumValues<
261         WebCore::MockWebAuthenticationConfiguration::HidSubStage,
262         WebCore::MockWebAuthenticationConfiguration::HidSubStage::Init,
263         WebCore::MockWebAuthenticationConfiguration::HidSubStage::Msg
264     >;
265 };
266
267 template<> struct EnumTraits<WebCore::MockWebAuthenticationConfiguration::HidError> {
268     using values = EnumValues<
269         WebCore::MockWebAuthenticationConfiguration::HidError,
270         WebCore::MockWebAuthenticationConfiguration::HidError::Success,
271         WebCore::MockWebAuthenticationConfiguration::HidError::DataNotSent,
272         WebCore::MockWebAuthenticationConfiguration::HidError::EmptyReport,
273         WebCore::MockWebAuthenticationConfiguration::HidError::WrongChannelId,
274         WebCore::MockWebAuthenticationConfiguration::HidError::MaliciousPayload,
275         WebCore::MockWebAuthenticationConfiguration::HidError::UnsupportedOptions,
276         WebCore::MockWebAuthenticationConfiguration::HidError::WrongNonce
277     >;
278 };
279
280 template<> struct EnumTraits<WebCore::MockWebAuthenticationConfiguration::NfcError> {
281     using values = EnumValues<
282         WebCore::MockWebAuthenticationConfiguration::NfcError,
283         WebCore::MockWebAuthenticationConfiguration::NfcError::Success,
284         WebCore::MockWebAuthenticationConfiguration::NfcError::NoTags,
285         WebCore::MockWebAuthenticationConfiguration::NfcError::WrongTagType,
286         WebCore::MockWebAuthenticationConfiguration::NfcError::NoConnections,
287         WebCore::MockWebAuthenticationConfiguration::NfcError::MaliciousPayload
288     >;
289 };
290
291 } // namespace WTF
292
293 #endif // ENABLE(WEB_AUTHN)