[WebAuthN] Use a real nonce for CTAPHID_INIT
[WebKit-https.git] / Source / WebKit / UIProcess / WebAuthentication / fido / CtapHidDriver.cpp
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 #include "config.h"
27 #include "CtapHidDriver.h"
28
29 #if ENABLE(WEB_AUTHN) && PLATFORM(MAC)
30
31 #include <WebCore/FidoConstants.h>
32 #include <wtf/CryptographicallyRandomNumber.h>
33 #include <wtf/RunLoop.h>
34 #include <wtf/Vector.h>
35 #include <wtf/text/Base64.h>
36
37 namespace WebKit {
38 using namespace fido;
39
40 CtapHidDriver::Worker::Worker(UniqueRef<HidConnection>&& connection)
41     : m_connection(WTFMove(connection))
42 {
43     m_connection->initialize();
44 }
45
46 CtapHidDriver::Worker::~Worker()
47 {
48     m_connection->terminate();
49 }
50
51 void CtapHidDriver::Worker::transact(fido::FidoHidMessage&& requestMessage, MessageCallback&& callback)
52 {
53     ASSERT(m_state == State::Idle);
54     m_state = State::Write;
55     m_requestMessage = WTFMove(requestMessage);
56     m_responseMessage.reset();
57     m_callback = WTFMove(callback);
58
59     // HidConnection could hold data from other applications, and thereofore invalidate it before each transaction.
60     m_connection->invalidateCache();
61     m_connection->send(m_requestMessage->popNextPacket(), [weakThis = makeWeakPtr(*this)](HidConnection::DataSent sent) mutable {
62         ASSERT(RunLoop::isMain());
63         if (!weakThis)
64             return;
65         weakThis->write(sent);
66     });
67 }
68
69 void CtapHidDriver::Worker::write(HidConnection::DataSent sent)
70 {
71     ASSERT(m_state == State::Write);
72     if (sent != HidConnection::DataSent::Yes) {
73         returnMessage(std::nullopt);
74         return;
75     }
76
77     if (!m_requestMessage->numPackets()) {
78         m_state = State::Read;
79         m_connection->registerDataReceivedCallback([weakThis = makeWeakPtr(*this)](Vector<uint8_t>&& data) mutable {
80             ASSERT(RunLoop::isMain());
81             if (!weakThis)
82                 return;
83             weakThis->read(data);
84         });
85         return;
86     }
87
88     m_connection->send(m_requestMessage->popNextPacket(), [weakThis = makeWeakPtr(*this)](HidConnection::DataSent sent) mutable {
89         ASSERT(RunLoop::isMain());
90         if (!weakThis)
91             return;
92         weakThis->write(sent);
93     });
94 }
95
96 void CtapHidDriver::Worker::read(const Vector<uint8_t>& data)
97 {
98     ASSERT(m_state == State::Read);
99     if (!m_responseMessage) {
100         m_responseMessage = FidoHidMessage::createFromSerializedData(data);
101         // The first few reports could be for other applications, and therefore ignore those.
102         if (!m_responseMessage || m_responseMessage->channelId() != m_requestMessage->channelId()) {
103             LOG_ERROR("Couldn't parse a hid init packet: %s", m_responseMessage ? "wrong channel id." : "bad data.");
104             m_responseMessage.reset();
105             return;
106         }
107     } else {
108         if (!m_responseMessage->addContinuationPacket(data)) {
109             LOG_ERROR("Couldn't parse a hid continuation packet.");
110             returnMessage(std::nullopt);
111             return;
112         }
113     }
114
115     if (m_responseMessage->messageComplete()) {
116         // A KeepAlive cmd could be sent between a request and a response to indicate that
117         // the authenticator is waiting for user consent. Keep listening for the response.
118         if (m_responseMessage->cmd() == FidoHidDeviceCommand::kKeepAlive) {
119             m_responseMessage.reset();
120             return;
121         }
122         returnMessage(WTFMove(m_responseMessage));
123         return;
124     }
125 }
126
127 void CtapHidDriver::Worker::returnMessage(std::optional<fido::FidoHidMessage>&& message)
128 {
129     m_state = State::Idle;
130     m_connection->unregisterDataReceivedCallback();
131     m_callback(WTFMove(message));
132 }
133
134 CtapHidDriver::CtapHidDriver(UniqueRef<HidConnection>&& connection)
135     : m_worker(makeUniqueRef<Worker>(WTFMove(connection)))
136     , m_nonce(kHidInitNonceLength)
137 {
138 }
139
140 void CtapHidDriver::transact(Vector<uint8_t>&& data, ResponseCallback&& callback)
141 {
142     ASSERT(m_state == State::Idle);
143     m_state = State::AllocateChannel;
144     m_channelId = kHidBroadcastChannel;
145     m_requestData = WTFMove(data);
146     m_responseCallback = WTFMove(callback);
147
148     // Allocate a channel.
149     ASSERT(m_nonce.size() == kHidInitNonceLength);
150     cryptographicallyRandomValues(m_nonce.data(), m_nonce.size());
151     auto initCommand = FidoHidMessage::create(m_channelId, FidoHidDeviceCommand::kInit, m_nonce);
152     ASSERT(initCommand);
153     m_worker->transact(WTFMove(*initCommand), [weakThis = makeWeakPtr(*this)](std::optional<FidoHidMessage>&& response) mutable {
154         ASSERT(RunLoop::isMain());
155         if (!weakThis)
156             return;
157         weakThis->continueAfterChannelAllocated(WTFMove(response));
158     });
159 }
160
161 void CtapHidDriver::continueAfterChannelAllocated(std::optional<FidoHidMessage>&& message)
162 {
163     ASSERT(m_state == State::AllocateChannel);
164     if (!message) {
165         returnResponse({ });
166         return;
167     }
168     ASSERT(message->channelId() == m_channelId);
169
170     auto payload = message->getMessagePayload();
171     ASSERT(payload.size() == kHidInitResponseSize);
172     // Restart the transaction in the next run loop when nonce mismatches.
173     if (memcmp(payload.data(), m_nonce.data(), m_nonce.size())) {
174         m_state = State::Idle;
175         RunLoop::main().dispatch([weakThis = makeWeakPtr(*this), data = WTFMove(m_requestData), callback = WTFMove(m_responseCallback)]() mutable {
176             if (!weakThis)
177                 return;
178             weakThis->transact(WTFMove(data), WTFMove(callback));
179         });
180         return;
181     }
182
183     m_state = State::Ready;
184     auto index = kHidInitNonceLength;
185     m_channelId = static_cast<uint32_t>(payload[index++]) << 24;
186     m_channelId |= static_cast<uint32_t>(payload[index++]) << 16;
187     m_channelId |= static_cast<uint32_t>(payload[index++]) << 8;
188     m_channelId |= static_cast<uint32_t>(payload[index]);
189     // FIXME(191534): Check the reset of the payload.
190     auto cmd = FidoHidMessage::create(m_channelId, FidoHidDeviceCommand::kCbor, m_requestData);
191     ASSERT(cmd);
192     m_worker->transact(WTFMove(*cmd), [weakThis = makeWeakPtr(*this)](std::optional<FidoHidMessage>&& response) mutable {
193         ASSERT(RunLoop::isMain());
194         if (!weakThis)
195             return;
196         weakThis->continueAfterResponseReceived(WTFMove(response));
197     });
198 }
199
200 void CtapHidDriver::continueAfterResponseReceived(std::optional<fido::FidoHidMessage>&& message)
201 {
202     ASSERT(m_state == State::Ready);
203     ASSERT(!message || message->channelId() == m_channelId);
204     returnResponse(message ? message->getMessagePayload() : Vector<uint8_t>());
205 }
206
207 void CtapHidDriver::returnResponse(Vector<uint8_t>&& response)
208 {
209     // Reset state before calling the response callback to avoid being deleted.
210     m_state = State::Idle;
211     m_responseCallback(WTFMove(response));
212 }
213
214 } // namespace WebKit
215
216 #endif // ENABLE(WEB_AUTHN) && PLATFORM(MAC)