Coverage Report

Created: 2021-05-04 09:02

/src/botan/src/lib/tls/msg_certificate.cpp
Line
Count
Source (jump to first uncovered line)
1
/*
2
* Certificate Message
3
* (C) 2004-2006,2012,2020 Jack Lloyd
4
*
5
* Botan is released under the Simplified BSD License (see license.txt)
6
*/
7
8
#include <botan/tls_messages.h>
9
#include <botan/tls_extensions.h>
10
#include <botan/tls_exceptn.h>
11
#include <botan/tls_alert.h>
12
#include <botan/internal/tls_reader.h>
13
#include <botan/internal/tls_handshake_io.h>
14
#include <botan/internal/tls_handshake_hash.h>
15
#include <botan/internal/loadstor.h>
16
#include <botan/data_src.h>
17
18
namespace Botan {
19
20
namespace TLS {
21
22
/**
23
* Create a new Certificate message
24
*/
25
Certificate::Certificate(Handshake_IO& io,
26
                         Handshake_Hash& hash,
27
                         const std::vector<X509_Certificate>& cert_list) :
28
   m_certs(cert_list)
29
161
   {
30
161
   hash.update(io.send(*this));
31
161
   }
32
33
/**
34
* Deserialize a Certificate message
35
*/
36
Certificate::Certificate(const std::vector<uint8_t>& buf, const Policy& policy)
37
0
   {
38
0
   if(buf.size() < 3)
39
0
      throw Decoding_Error("Certificate: Message malformed");
40
41
0
   const size_t total_size = make_uint32(0, buf[0], buf[1], buf[2]);
42
43
0
   if(total_size != buf.size() - 3)
44
0
      throw Decoding_Error("Certificate: Message malformed");
45
46
0
   const size_t max_size = policy.maximum_certificate_chain_size();
47
0
   if(max_size > 0 && total_size > max_size)
48
0
      throw Decoding_Error("Certificate chain exceeds policy specified maximum size");
49
50
0
   const uint8_t* certs = buf.data() + 3;
51
52
0
   while(size_t remaining_bytes = buf.data() + buf.size() - certs)
53
0
      {
54
0
      if(remaining_bytes < 3)
55
0
         throw Decoding_Error("Certificate: Message malformed");
56
57
0
      const size_t cert_size = make_uint32(0, certs[0], certs[1], certs[2]);
58
59
0
      if(remaining_bytes < (3 + cert_size))
60
0
         throw Decoding_Error("Certificate: Message malformed");
61
62
0
      DataSource_Memory cert_buf(&certs[3], cert_size);
63
0
      m_certs.push_back(X509_Certificate(cert_buf));
64
65
0
      certs += cert_size + 3;
66
0
      }
67
68
   /*
69
   * TLS 1.0 through 1.2 all seem to require that the certificate be
70
   * precisely a v3 certificate. In fact the strict wording would seem
71
   * to require that every certificate in the chain be v3. But often
72
   * the intermediates are outside of the control of the server.
73
   * But, require that the leaf certificate be v3
74
   */
75
0
   if(m_certs.size() > 0 && m_certs[0].x509_version() != 3)
76
0
      {
77
0
      throw TLS_Exception(Alert::BAD_CERTIFICATE,
78
0
                          "The leaf certificate must be v3");
79
0
      }
80
0
   }
81
82
/**
83
* Serialize a Certificate message
84
*/
85
std::vector<uint8_t> Certificate::serialize() const
86
161
   {
87
161
   std::vector<uint8_t> buf(3);
88
89
322
   for(size_t i = 0; i != m_certs.size(); ++i)
90
161
      {
91
161
      std::vector<uint8_t> raw_cert = m_certs[i].BER_encode();
92
161
      const size_t cert_size = raw_cert.size();
93
644
      for(size_t j = 0; j != 3; ++j)
94
483
         {
95
483
         buf.push_back(get_byte_var(j+1, static_cast<uint32_t>(cert_size)));
96
483
         }
97
161
      buf += raw_cert;
98
161
      }
99
100
161
   const size_t buf_size = buf.size() - 3;
101
644
   for(size_t i = 0; i != 3; ++i)
102
483
      buf[i] = get_byte_var(i+1, static_cast<uint32_t>(buf_size));
103
104
161
   return buf;
105
161
   }
106
107
}
108
109
}