@fails-components/webtransport-transport-http3-quiche 1.3.1 → 1.4.0

package/CMakeLists.txt

@@ -743,8 +743,12 @@ third_party/quiche/quiche/quic/core/quic_stream_id_manager.cc
 third_party/quiche/quiche/quic/core/quic_stream_id_manager.h
 third_party/quiche/quiche/quic/core/quic_stream_priority.cc
 third_party/quiche/quiche/quic/core/quic_stream_priority.h
+third_party/quiche/quiche/quic/core/quic_stream_send_buffer_base.cc
+third_party/quiche/quiche/quic/core/quic_stream_send_buffer_base.h
 third_party/quiche/quiche/quic/core/quic_stream_send_buffer.cc
 third_party/quiche/quiche/quic/core/quic_stream_send_buffer.h
+third_party/quiche/quiche/quic/core/quic_stream_send_buffer_inlining.cc
+third_party/quiche/quiche/quic/core/quic_stream_send_buffer_inlining.h
 third_party/quiche/quiche/quic/core/quic_stream_sequencer.cc
 third_party/quiche/quiche/quic/core/quic_stream_sequencer.h
 third_party/quiche/quiche/quic/core/quic_stream_sequencer_buffer.cc

package/dist/lib/socket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"socket.d.ts","sourceRoot":"","sources":["../../lib/socket.js"],"names":[],"mappings":"AAqEA;IACE;;OAEG;IAEH,kBAHW,OAAO,4BAA4B,EAAE,oBAAoB,GAAC,SAAS,EAc7E;IAVC,0CAA0C;IAE1C,WAFW,OAAO,YAAY,EAAE,MAAM,CAEZ;IAE1B,UAAqB;IACrB,oBAAuB;IAgCzB,qBASC;IAlCD,+BAGC;IAPC,iBAAoB;IACpB,gBAAmB;IAQrB;;OAEG;IAEH,mDAHW,OAAO,SAAS,EAAE,mBAAmB,WAiB/C;CAYF"}
+{"version":3,"file":"socket.d.ts","sourceRoot":"","sources":["../../lib/socket.js"],"names":[],"mappings":"AAkFA;IACE;;OAEG;IAEH,kBAHW,OAAO,4BAA4B,EAAE,oBAAoB,GAAC,SAAS,EAc7E;IAVC,0CAA0C;IAE1C,WAFW,OAAO,YAAY,EAAE,MAAM,CAEZ;IAE1B,UAAqB;IACrB,oBAAuB;IAgCzB,qBASC;IAlCD,+BAGC;IAPC,iBAAoB;IACpB,gBAAmB;IAQrB;;OAEG;IAEH,mDAHW,OAAO,SAAS,EAAE,mBAAmB,WAiB/C;CAYF"}

package/lib/socket.js

@@ -10,12 +10,24 @@ globalThis.FAILSsetTimeoutAlarm = (
   return setTimeout(alarm.fireJS.bind(alarm), delay)
 }
 
+function convertToPem(/** @type {ArrayBuffer} */ cert) {
+  return (
+    '-----BEGIN CERTIFICATE-----\n' +
+    Buffer.from(new Uint8Array(cert)).toString('base64') +
+    '\n-----END CERTIFICATE-----\n'
+  )
+}
+
 globalThis.FAILSVerifyProof = (
-  /** @type {{ certs: string[]; hostname: string; server_config?: string; signature?: string; }} */ obj
+  /** @type {{ certs: ArrayBuffer[]; hostname: string; server_config?: string; signature?: string; }} */ obj
 ) => {
   try {
+    console.warn(
+      'Non serverCertificateHashes certificate verification is an experimental feature for webtransport node client and not covered by tests and thus may be broken (DO NOT USE IN PRODUCTION)'
+    )
     if (obj.certs.length < 1) return false
-    const leafcert = new X509Certificate(obj.certs[0])
+    const pem = convertToPem(obj.certs[0])
+    const leafcert = new X509Certificate(pem)
     if (!leafcert.checkHost(obj.hostname)) return false
 
     if (obj.server_config) {
@@ -36,7 +48,8 @@ globalThis.FAILSVerifyProof = (
 
     let curcert = leafcert
     for (let certnum = 1; certnum < obj.certs.length; certnum++) {
-      const nextcert = new X509Certificate(obj.certs[certnum])
+      const nextpem = convertToPem(obj.certs[certnum])
+      const nextcert = new X509Certificate(nextpem)
 
       if (
         new Date(nextcert.validFrom) > curdate ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fails-components/webtransport-transport-http3-quiche",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "A component to add webtransport support (server and client) to node.js, transport using libquiche",
   "exports": {
     ".": {

package/src/http3client.cc

@@ -38,6 +38,7 @@
 #include "quiche/quic/core/quic_udp_socket.h"
 #include "quiche/quic/tools/quic_url.h"
 #include "quiche/common/quiche_text_utils.h"
+#include "quiche/web_transport/web_transport_headers.h"
 
 using quiche::HttpHeaderBlock;
 
@@ -91,12 +92,14 @@ namespace quic
                 retObj.Set("hostname", hostname);
                 retObj.Set("port", port);
                 retObj.Set("serverconfig", server_config);
-                // todo certs
 
                 Napi::Array jscerts = Napi::Array::New(env, certs.size());
                 for (size_t i = 0; i < certs.size(); i++) {
-                    jscerts.Set(i, certs[i]);
+                    jscerts.Set(i, Napi::Buffer<uint8_t>::Copy(env,
+                            reinterpret_cast<const uint8_t*>(certs[i].data()),
+                             certs[i].size()));
                 }
+                retObj.Set("certs", jscerts);
                 retObj.Set("signature", signature);
 
                 Napi::Value verifyres = env.Global().Get("FAILSVerifyProof").As<Napi::Function>().Call({
@@ -125,13 +128,15 @@ namespace quic
 
                 Napi::Array jscerts = Napi::Array::New(env, certs.size());
                 for (size_t i = 0; i < certs.size(); i++) {
-                    jscerts.Set(i, certs[i]);
+                    jscerts.Set(i, Napi::Buffer<uint8_t>::Copy(env,
+                            reinterpret_cast<const uint8_t*>(certs[i].data()),
+                             certs[i].size()));
                 }
+                retObj.Set("certs", jscerts);
                 Napi::Value verifyres = env.Global().Get("FAILSVerifyProof").As<Napi::Function>().Call({
                     retObj });
                 if (verifyres.As<Napi::Boolean>().Value()) {
                     return QUIC_SUCCESS;
-
                 } else {
                     return QUIC_FAILURE;
                 }
@@ -616,7 +621,7 @@ namespace quic
         return finish_stream_open_.size() > 0;
     }
 
-    void Http3Client::openWTSessionInt(absl::string_view path)
+    bool Http3Client::openWTSessionInt(absl::string_view path)
     {
         quiche::HttpHeaderBlock headers;
         headers[":scheme"] = "https";
@@ -624,17 +629,15 @@ namespace quic
         headers[":path"] = path;
         headers[":method"] = "CONNECT";
         headers[":protocol"] = "webtransport";
-        if (protocols_.size() > 0) { // not very efficient
-            std::string protocols = "";
-            for (size_t i=0; i < protocols_.size(); i++) {
-                protocols += protocols_[i];
-                if (i!= protocols_.size()-1) {
-                    protocols += ',';
-                }
+        if (protocols_.size() > 0) {
+            absl::StatusOr<std::string> wtavail = webtransport::SerializeSubprotocolRequestHeader(protocols_);
+            if (!wtavail.ok()) {
+                return false;
             }
-            headers["wt-available-protocols"] = protocols;
+            headers["wt-available-protocols"] = *wtavail;
         }
         SendMessageAsync(headers, "", /*fin=*/false);
+        return true;
     }
 
     void Http3Client::StartConnect()
@@ -1376,7 +1379,9 @@ namespace quic
         {
             std::string lpath(info[0].ToString().Utf8Value());
 
-            obj->openWTSessionInt(lpath);
+            if (!obj->openWTSessionInt(lpath)) {
+                Napi::Error::New(info.Env(), "openWTSessionInt failed, invalid protocols?").ThrowAsJavaScriptException();
+            }
         }
         else
         {

package/src/http3client.h

@@ -365,7 +365,7 @@ namespace quic
         // tracking its state.
         void SetLatestCreatedStream(QuicSpdyClientStream *stream);
 
-        void openWTSessionInt(absl::string_view path);
+        bool openWTSessionInt(absl::string_view path);
 
         bool closeClientInt();
 

package/src/http3server.cc

@@ -17,6 +17,7 @@
 #include "quiche/quic/tools/quic_simple_crypto_server_stream_helper.h"
 #include "quiche/quic/core/crypto/proof_source_x509.h"
 #include "quiche/common/platform/api/quiche_reference_counted.h"
+#include "quiche/web_transport/web_transport_headers.h"
 
 using namespace Napi;
 
@@ -448,6 +449,17 @@ namespace quic
     for (auto pair : reqhead)
     {
       // we iterate over all header fields
+      if (pair.first.compare("wt-available-protocols") == 0) {
+        absl::StatusOr<std::vector<std::string>> prots = webtransport::ParseSubprotocolRequestHeader(pair.second);
+        if (prots.ok()) {
+          Napi::Array protArray = Napi::Array::New(Env(), (*prots).size());
+          for (size_t i = 0; i < (*prots).size(); i++) {
+            protArray.Set(i, std::string((*prots)[i]));
+          }
+          headObj.Set(std::string("wt-available-protocols"), protArray);
+          continue;
+        } // otherwise fall through to default
+      }
       headObj.Set(std::string(pair.first), std::string(pair.second));
     }
     retObj.Set("header", headObj);
@@ -586,7 +598,11 @@ namespace quic
             std::unique_ptr<Http3ServerBackend::WebTransportResponse> response = std::make_unique<Http3ServerBackend::WebTransportResponse>();
             response->response_headers[":status"] = std::to_string(status);
             if (selectedProtocol != "") {
-              response->response_headers["wt-protocol"] = selectedProtocol;
+              absl::StatusOr<std::string> selprot = webtransport::SerializeSubprotocolResponseHeader(selectedProtocol);
+              if (!selprot.ok()) {
+                 return Napi::Error::New(Env(), "Selected protocol is invalid").ThrowAsJavaScriptException();
+              }
+              response->response_headers["wt-protocol"] = *selprot;
             }
             Http3WTSession *wtsession = new Http3WTSession();
             wtsession->init(session);

package/src/http3wtsessionvisitor.h

@@ -25,7 +25,7 @@
 #include "quiche/quic/core/web_transport_interface.h"
 #include "quiche/quic/platform/api/quic_logging.h"
 #include "quiche/common/quiche_circular_deque.h"
-#include "quiche/common/platform/api/quiche_mem_slice.h"
+#include "quiche/common/quiche_mem_slice.h"
 
 namespace quic
 {