ws_accept_key.h

Go to the documentation of this file.

/*
 * Copyright (C) Max Dymond, <cmeister2@gmail.com>, et al.
 *
 * SPDX-License-Identifier: curl
 */

 
#ifndef PROTO_FUZZER_WS_ACCEPT_KEY_H_
#define PROTO_FUZZER_WS_ACCEPT_KEY_H_
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <string>
 
namespace proto_fuzzer {
namespace detail {

inline std::array<uint8_t, 20> Sha1(const uint8_t* data, std::size_t len) {
  // Initial hash values.
  uint32_t h0 = 0x67452301, h1 = 0xEFCDAB89, h2 = 0x98BADCFE, h3 = 0x10325476, h4 = 0xC3D2E1F0;
 
  // Pre-processing: build the padded message.
  uint64_t bit_len = static_cast<uint64_t>(len) * 8;
  // Number of bytes after original message: 1 (0x80) + padding + 8 (length).
  std::size_t padded_len = ((len + 8) / 64 + 1) * 64;
  // Use a small stack buffer for typical WebSocket key sizes (< 128 bytes).
  // Fall back to heap for anything larger.
  uint8_t stack_buf[128];
  uint8_t* msg;
  bool heap = padded_len > sizeof(stack_buf);
  if (heap) {
    msg = new uint8_t[padded_len]();
  } else {
    msg = stack_buf;
    std::memset(msg, 0, padded_len);
  }
  std::memcpy(msg, data, len);
  msg[len] = 0x80;
  // Append original length in bits as big-endian 64-bit.
  for (int i = 0; i < 8; ++i) {
    msg[padded_len - 1 - i] = static_cast<uint8_t>(bit_len >> (i * 8));
  }
 
  auto left_rotate = [](uint32_t v, unsigned n) -> uint32_t { return (v << n) | (v >> (32 - n)); };
 
  for (std::size_t offset = 0; offset < padded_len; offset += 64) {
    uint32_t w[80];
    for (int i = 0; i < 16; ++i) {
      w[i] = static_cast<uint32_t>(msg[offset + 4 * i]) << 24 | static_cast<uint32_t>(msg[offset + 4 * i + 1]) << 16 |
             static_cast<uint32_t>(msg[offset + 4 * i + 2]) << 8 | static_cast<uint32_t>(msg[offset + 4 * i + 3]);
    }
    for (int i = 16; i < 80; ++i) {
      w[i] = left_rotate(w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16], 1);
    }
    uint32_t a = h0, b = h1, c = h2, d = h3, e = h4;
    for (int i = 0; i < 80; ++i) {
      uint32_t f, k;
      if (i < 20) {
        f = (b & c) | ((~b) & d);
        k = 0x5A827999;
      } else if (i < 40) {
        f = b ^ c ^ d;
        k = 0x6ED9EBA1;
      } else if (i < 60) {
        f = (b & c) | (b & d) | (c & d);
        k = 0x8F1BBCDC;
      } else {
        f = b ^ c ^ d;
        k = 0xCA62C1D6;
      }
      uint32_t temp = left_rotate(a, 5) + f + e + k + w[i];
      e = d;
      d = c;
      c = left_rotate(b, 30);
      b = a;
      a = temp;
    }
    h0 += a;
    h1 += b;
    h2 += c;
    h3 += d;
    h4 += e;
  }
 
  if (heap) {
    delete[] msg;
  }
 
  std::array<uint8_t, 20> digest;
  auto store = [&](int idx, uint32_t val) {
    digest[idx * 4 + 0] = static_cast<uint8_t>(val >> 24);
    digest[idx * 4 + 1] = static_cast<uint8_t>(val >> 16);
    digest[idx * 4 + 2] = static_cast<uint8_t>(val >> 8);
    digest[idx * 4 + 3] = static_cast<uint8_t>(val);
  };
  store(0, h0);
  store(1, h1);
  store(2, h2);
  store(3, h3);
  store(4, h4);
  return digest;
}

inline std::string Base64Encode(const uint8_t* data, std::size_t len) {
  static const char kTable[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  std::string out;
  out.reserve(4 * ((len + 2) / 3));
  for (std::size_t i = 0; i < len; i += 3) {
    uint32_t n = static_cast<uint32_t>(data[i]) << 16;
    if (i + 1 < len) n |= static_cast<uint32_t>(data[i + 1]) << 8;
    if (i + 2 < len) n |= static_cast<uint32_t>(data[i + 2]);
    out.push_back(kTable[(n >> 18) & 0x3F]);
    out.push_back(kTable[(n >> 12) & 0x3F]);
    out.push_back((i + 1 < len) ? kTable[(n >> 6) & 0x3F] : '=');
    out.push_back((i + 2 < len) ? kTable[n & 0x3F] : '=');
  }
  return out;
}
 
}  // namespace detail

inline std::string ComputeWebSocketAcceptKey(const std::string& key) {
  static const char kGuid[] = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
  std::string combined = key + kGuid;
  auto digest = detail::Sha1(reinterpret_cast<const uint8_t*>(combined.data()), combined.size());
  return detail::Base64Encode(digest.data(), digest.size());
}
 
}  // namespace proto_fuzzer
 
#endif  // PROTO_FUZZER_WS_ACCEPT_KEY_H_