Coverage Report

Created: 2020-11-21 08:34

/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
154
   {
30
154
   hash.update(io.send(*this));
31
154
   }
32
33
/**
34
* Deserialize a Certificate message
35
*/
36
Certificate::Certificate(const std::vector<uint8_t>& buf, const Policy& policy)
37
2.90k
   {
38
2.90k
   if(buf.size() < 3)
39
1
      throw Decoding_Error("Certificate: Message malformed");
40
41
2.90k
   const size_t total_size = make_uint32(0, buf[0], buf[1], buf[2]);
42
43
2.90k
   if(total_size != buf.size() - 3)
44
20
      throw Decoding_Error("Certificate: Message malformed");
45
46
2.88k
   const size_t max_size = policy.maximum_certificate_chain_size();
47
2.88k
   if(max_size > 0 && total_size > max_size)
48
0
      throw Decoding_Error("Certificate chain exceeds policy specified maximum size");
49
50
2.88k
   const uint8_t* certs = buf.data() + 3;
51
52
7.53k
   while(size_t remaining_bytes = buf.data() + buf.size() - certs)
53
4.82k
      {
54
4.82k
      if(remaining_bytes < 3)
55
1
         throw Decoding_Error("Certificate: Message malformed");
56
57
4.82k
      const size_t cert_size = make_uint32(0, certs[0], certs[1], certs[2]);
58
59
4.82k
      if(remaining_bytes < (3 + cert_size))
60
170
         throw Decoding_Error("Certificate: Message malformed");
61
62
4.65k
      DataSource_Memory cert_buf(&certs[3], cert_size);
63
4.65k
      m_certs.push_back(X509_Certificate(cert_buf));
64
65
4.65k
      certs += cert_size + 3;
66
4.65k
      }
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
2.71k
   if(m_certs.size() > 0 && m_certs[0].x509_version() != 3)
76
109
      {
77
109
      throw TLS_Exception(Alert::BAD_CERTIFICATE,
78
109
                          "The leaf certificate must be v3");
79
109
      }
80
2.71k
   }
81
82
/**
83
* Serialize a Certificate message
84
*/
85
std::vector<uint8_t> Certificate::serialize() const
86
154
   {
87
154
   std::vector<uint8_t> buf(3);
88
89
302
   for(size_t i = 0; i != m_certs.size(); ++i)
90
148
      {
91
148
      std::vector<uint8_t> raw_cert = m_certs[i].BER_encode();
92
148
      const size_t cert_size = raw_cert.size();
93
592
      for(size_t j = 0; j != 3; ++j)
94
444
         {
95
444
         buf.push_back(get_byte(j+1, static_cast<uint32_t>(cert_size)));
96
444
         }
97
148
      buf += raw_cert;
98
148
      }
99
100
154
   const size_t buf_size = buf.size() - 3;
101
616
   for(size_t i = 0; i != 3; ++i)
102
462
      buf[i] = get_byte(i+1, static_cast<uint32_t>(buf_size));
103
104
154
   return buf;
105
154
   }
106
107
}
108
109
}