1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "net/spdy/spdy_test_utils.h"
6
7#include <cstring>
8#include <vector>
9
10#include "base/base64.h"
11#include "base/logging.h"
12#include "base/memory/scoped_ptr.h"
13#include "base/strings/string_number_conversions.h"
14#include "base/sys_byteorder.h"
15#include "net/http/transport_security_state.h"
16#include "net/ssl/ssl_info.h"
17#include "testing/gtest/include/gtest/gtest.h"
18
19namespace net {
20
21namespace test {
22
23std::string HexDumpWithMarks(const unsigned char* data, int length,
24                             const bool* marks, int mark_length) {
25  static const char kHexChars[] = "0123456789abcdef";
26  static const int kColumns = 4;
27
28  const int kSizeLimit = 1024;
29  if (length > kSizeLimit || mark_length > kSizeLimit) {
30    LOG(ERROR) << "Only dumping first " << kSizeLimit << " bytes.";
31    length = std::min(length, kSizeLimit);
32    mark_length = std::min(mark_length, kSizeLimit);
33  }
34
35  std::string hex;
36  for (const unsigned char* row = data; length > 0;
37       row += kColumns, length -= kColumns) {
38    for (const unsigned char *p = row; p < row + 4; ++p) {
39      if (p < row + length) {
40        const bool mark =
41            (marks && (p - data) < mark_length && marks[p - data]);
42        hex += mark ? '*' : ' ';
43        hex += kHexChars[(*p & 0xf0) >> 4];
44        hex += kHexChars[*p & 0x0f];
45        hex += mark ? '*' : ' ';
46      } else {
47        hex += "    ";
48      }
49    }
50    hex = hex + "  ";
51
52    for (const unsigned char *p = row; p < row + 4 && p < row + length; ++p)
53      hex += (*p >= 0x20 && *p <= 0x7f) ? (*p) : '.';
54
55    hex = hex + '\n';
56  }
57  return hex;
58}
59
60void CompareCharArraysWithHexError(
61    const std::string& description,
62    const unsigned char* actual,
63    const int actual_len,
64    const unsigned char* expected,
65    const int expected_len) {
66  const int min_len = std::min(actual_len, expected_len);
67  const int max_len = std::max(actual_len, expected_len);
68  scoped_ptr<bool[]> marks(new bool[max_len]);
69  bool identical = (actual_len == expected_len);
70  for (int i = 0; i < min_len; ++i) {
71    if (actual[i] != expected[i]) {
72      marks[i] = true;
73      identical = false;
74    } else {
75      marks[i] = false;
76    }
77  }
78  for (int i = min_len; i < max_len; ++i) {
79    marks[i] = true;
80  }
81  if (identical) return;
82  ADD_FAILURE()
83      << "Description:\n"
84      << description
85      << "\n\nExpected:\n"
86      << HexDumpWithMarks(expected, expected_len, marks.get(), max_len)
87      << "\nActual:\n"
88      << HexDumpWithMarks(actual, actual_len, marks.get(), max_len);
89}
90
91void SetFrameFlags(SpdyFrame* frame,
92                   uint8 flags,
93                   SpdyMajorVersion spdy_version) {
94  switch (spdy_version) {
95    case SPDY2:
96    case SPDY3:
97    case SPDY4:
98    case SPDY5:
99      frame->data()[4] = flags;
100      break;
101    default:
102      LOG(FATAL) << "Unsupported SPDY version.";
103  }
104}
105
106void SetFrameLength(SpdyFrame* frame,
107                    size_t length,
108                    SpdyMajorVersion spdy_version) {
109  switch (spdy_version) {
110    case SPDY2:
111    case SPDY3:
112      CHECK_EQ(0u, length & ~kLengthMask);
113      {
114        int32 wire_length = base::HostToNet32(length);
115        // The length field in SPDY 2 and 3 is a 24-bit (3B) integer starting at
116        // offset 5.
117        memcpy(frame->data() + 5, reinterpret_cast<char*>(&wire_length) + 1, 3);
118      }
119      break;
120    case SPDY4:
121    case SPDY5:
122      CHECK_GT(1u<<14, length);
123      {
124        int32 wire_length = base::HostToNet32(length);
125        memcpy(frame->data(),
126               reinterpret_cast<char*>(&wire_length) + 1,
127               3);
128      }
129      break;
130    default:
131      LOG(FATAL) << "Unsupported SPDY version.";
132  }
133}
134
135std::string a2b_hex(const char* hex_data) {
136  std::vector<uint8> output;
137  std::string result;
138  if (base::HexStringToBytes(hex_data, &output))
139    result.assign(reinterpret_cast<const char*>(&output[0]), output.size());
140  return result;
141}
142
143HashValue GetTestHashValue(uint8_t label) {
144  HashValue hash_value(HASH_VALUE_SHA256);
145  memset(hash_value.data(), label, hash_value.size());
146  return hash_value;
147}
148
149std::string GetTestPin(uint8_t label) {
150  HashValue hash_value = GetTestHashValue(label);
151  std::string base64;
152  base::Base64Encode(base::StringPiece(
153      reinterpret_cast<char*>(hash_value.data()), hash_value.size()), &base64);
154
155  return std::string("pin-sha256=\"") + base64 + "\"";
156}
157
158void AddPin(TransportSecurityState* state,
159            const std::string& host,
160            uint8_t primary_label,
161            uint8_t backup_label) {
162  std::string primary_pin = GetTestPin(primary_label);
163  std::string backup_pin = GetTestPin(backup_label);
164  std::string header = "max-age = 10000; " + primary_pin + "; " + backup_pin;
165
166  // Construct a fake SSLInfo that will pass AddHPKPHeader's checks.
167  SSLInfo ssl_info;
168  ssl_info.is_issued_by_known_root = true;
169  ssl_info.public_key_hashes.push_back(GetTestHashValue(primary_label));
170  EXPECT_TRUE(state->AddHPKPHeader(host, header, ssl_info));
171}
172
173}  // namespace test
174
175}  // namespace net
176