ssl_error_info.cc revision c2e0dbddbe15c98d52c4786dac06cb8952a8ae6d
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 "chrome/browser/ssl/ssl_error_info.h"
6
7#include "base/i18n/time_formatting.h"
8#include "base/utf_string_conversions.h"
9#include "chrome/common/time_format.h"
10#include "content/public/browser/cert_store.h"
11#include "googleurl/src/gurl.h"
12#include "grit/chromium_strings.h"
13#include "grit/generated_resources.h"
14#include "net/base/escape.h"
15#include "net/base/net_errors.h"
16#include "net/cert/cert_status_flags.h"
17#include "net/ssl/ssl_info.h"
18#include "ui/base/l10n/l10n_util.h"
19
20SSLErrorInfo::SSLErrorInfo(const string16& title,
21                           const string16& details,
22                           const string16& short_description,
23                           const std::vector<string16>& extra_info)
24    : title_(title),
25      details_(details),
26      short_description_(short_description),
27      extra_information_(extra_info) {
28}
29
30// static
31SSLErrorInfo SSLErrorInfo::CreateError(ErrorType error_type,
32                                       net::X509Certificate* cert,
33                                       const GURL& request_url) {
34  string16 title, details, short_description;
35  std::vector<string16> extra_info;
36  switch (error_type) {
37    case CERT_COMMON_NAME_INVALID: {
38      title =
39          l10n_util::GetStringUTF16(IDS_CERT_ERROR_COMMON_NAME_INVALID_TITLE);
40      // If the certificate contains multiple DNS names, we choose the most
41      // representative one -- either the DNS name that's also in the subject
42      // field, or the first one.  If this heuristic turns out to be
43      // inadequate, we can consider choosing the DNS name that is the
44      // "closest match" to the host name in the request URL, or listing all
45      // the DNS names with an HTML <ul>.
46      std::vector<std::string> dns_names;
47      cert->GetDNSNames(&dns_names);
48      DCHECK(!dns_names.empty());
49      size_t i = 0;
50      for (; i < dns_names.size(); ++i) {
51        if (dns_names[i] == cert->subject().common_name)
52          break;
53      }
54      if (i == dns_names.size())
55        i = 0;
56      details =
57          l10n_util::GetStringFUTF16(IDS_CERT_ERROR_COMMON_NAME_INVALID_DETAILS,
58                                     UTF8ToUTF16(request_url.host()),
59                                     net::EscapeForHTML(
60                                         UTF8ToUTF16(dns_names[i])),
61                                     UTF8ToUTF16(request_url.host()));
62      short_description = l10n_util::GetStringUTF16(
63          IDS_CERT_ERROR_COMMON_NAME_INVALID_DESCRIPTION);
64      extra_info.push_back(
65          l10n_util::GetStringUTF16(IDS_CERT_ERROR_EXTRA_INFO_1));
66      extra_info.push_back(
67          l10n_util::GetStringFUTF16(
68              IDS_CERT_ERROR_COMMON_NAME_INVALID_EXTRA_INFO_2,
69              net::EscapeForHTML(UTF8ToUTF16(cert->subject().common_name)),
70              UTF8ToUTF16(request_url.host())));
71      break;
72    }
73    case CERT_DATE_INVALID:
74      extra_info.push_back(
75          l10n_util::GetStringUTF16(IDS_CERT_ERROR_EXTRA_INFO_1));
76      if (cert->HasExpired()) {
77        title = l10n_util::GetStringUTF16(IDS_CERT_ERROR_EXPIRED_TITLE);
78        details = l10n_util::GetStringFUTF16(
79            IDS_CERT_ERROR_EXPIRED_DETAILS,
80            UTF8ToUTF16(request_url.host()),
81            UTF8ToUTF16(request_url.host()),
82            base::TimeFormatFriendlyDateAndTime(base::Time::Now()));
83        short_description =
84            l10n_util::GetStringUTF16(IDS_CERT_ERROR_EXPIRED_DESCRIPTION);
85        extra_info.push_back(l10n_util::GetStringUTF16(
86            IDS_CERT_ERROR_EXPIRED_DETAILS_EXTRA_INFO_2));
87      } else {
88        // Then it must be not yet valid.  We don't check that it is not yet
89        // valid as there is still a very unlikely chance that the cert might
90        // have become valid since the error occurred.
91        title = l10n_util::GetStringUTF16(IDS_CERT_ERROR_NOT_YET_VALID_TITLE);
92        details = l10n_util::GetStringFUTF16(
93            IDS_CERT_ERROR_NOT_YET_VALID_DETAILS,
94            UTF8ToUTF16(request_url.host()),
95            UTF8ToUTF16(request_url.host()),
96            base::TimeFormatFriendlyDateAndTime(base::Time::Now()));
97        short_description =
98            l10n_util::GetStringUTF16(IDS_CERT_ERROR_NOT_YET_VALID_DESCRIPTION);
99        extra_info.push_back(
100            l10n_util::GetStringUTF16(
101                IDS_CERT_ERROR_NOT_YET_VALID_DETAILS_EXTRA_INFO_2));
102      }
103      break;
104    case CERT_AUTHORITY_INVALID:
105      title = l10n_util::GetStringUTF16(IDS_CERT_ERROR_AUTHORITY_INVALID_TITLE);
106      details = l10n_util::GetStringFUTF16(
107          IDS_CERT_ERROR_AUTHORITY_INVALID_DETAILS,
108          UTF8ToUTF16(request_url.host()));
109      short_description = l10n_util::GetStringUTF16(
110          IDS_CERT_ERROR_AUTHORITY_INVALID_DESCRIPTION);
111      extra_info.push_back(
112          l10n_util::GetStringUTF16(IDS_CERT_ERROR_EXTRA_INFO_1));
113      extra_info.push_back(l10n_util::GetStringFUTF16(
114          IDS_CERT_ERROR_AUTHORITY_INVALID_EXTRA_INFO_2,
115          UTF8ToUTF16(request_url.host()),
116          UTF8ToUTF16(request_url.host())));
117      extra_info.push_back(l10n_util::GetStringUTF16(
118          IDS_CERT_ERROR_AUTHORITY_INVALID_EXTRA_INFO_3));
119      break;
120    case CERT_CONTAINS_ERRORS:
121      title = l10n_util::GetStringUTF16(IDS_CERT_ERROR_CONTAINS_ERRORS_TITLE);
122      details = l10n_util::GetStringFUTF16(
123          IDS_CERT_ERROR_CONTAINS_ERRORS_DETAILS,
124          UTF8ToUTF16(request_url.host()));
125      short_description =
126          l10n_util::GetStringUTF16(IDS_CERT_ERROR_CONTAINS_ERRORS_DESCRIPTION);
127      extra_info.push_back(
128          l10n_util::GetStringFUTF16(IDS_CERT_ERROR_EXTRA_INFO_1,
129                                     UTF8ToUTF16(request_url.host())));
130      extra_info.push_back(l10n_util::GetStringUTF16(
131          IDS_CERT_ERROR_CONTAINS_ERRORS_EXTRA_INFO_2));
132      break;
133    case CERT_NO_REVOCATION_MECHANISM:
134      title = l10n_util::GetStringUTF16(
135          IDS_CERT_ERROR_NO_REVOCATION_MECHANISM_TITLE);
136      details = l10n_util::GetStringUTF16(
137          IDS_CERT_ERROR_NO_REVOCATION_MECHANISM_DETAILS);
138      short_description = l10n_util::GetStringUTF16(
139          IDS_CERT_ERROR_NO_REVOCATION_MECHANISM_DESCRIPTION);
140      break;
141    case CERT_UNABLE_TO_CHECK_REVOCATION:
142      title = l10n_util::GetStringUTF16(
143          IDS_CERT_ERROR_UNABLE_TO_CHECK_REVOCATION_TITLE);
144      details = l10n_util::GetStringUTF16(
145          IDS_CERT_ERROR_UNABLE_TO_CHECK_REVOCATION_DETAILS);
146      short_description = l10n_util::GetStringUTF16(
147          IDS_CERT_ERROR_UNABLE_TO_CHECK_REVOCATION_DESCRIPTION);
148      break;
149    case CERT_REVOKED:
150      title = l10n_util::GetStringUTF16(IDS_CERT_ERROR_REVOKED_CERT_TITLE);
151      details = l10n_util::GetStringFUTF16(IDS_CERT_ERROR_REVOKED_CERT_DETAILS,
152                                           UTF8ToUTF16(request_url.host()));
153      short_description =
154          l10n_util::GetStringUTF16(IDS_CERT_ERROR_REVOKED_CERT_DESCRIPTION);
155      extra_info.push_back(
156          l10n_util::GetStringUTF16(IDS_CERT_ERROR_EXTRA_INFO_1));
157      extra_info.push_back(
158          l10n_util::GetStringUTF16(IDS_CERT_ERROR_REVOKED_CERT_EXTRA_INFO_2));
159      break;
160    case CERT_INVALID:
161      title = l10n_util::GetStringUTF16(IDS_CERT_ERROR_INVALID_CERT_TITLE);
162      details = l10n_util::GetStringFUTF16(
163          IDS_CERT_ERROR_INVALID_CERT_DETAILS,
164          UTF8ToUTF16(request_url.host()));
165      short_description =
166          l10n_util::GetStringUTF16(IDS_CERT_ERROR_INVALID_CERT_DESCRIPTION);
167      extra_info.push_back(
168          l10n_util::GetStringUTF16(IDS_CERT_ERROR_EXTRA_INFO_1));
169      extra_info.push_back(l10n_util::GetStringUTF16(
170          IDS_CERT_ERROR_INVALID_CERT_EXTRA_INFO_2));
171      break;
172    case CERT_WEAK_SIGNATURE_ALGORITHM:
173      title = l10n_util::GetStringUTF16(
174          IDS_CERT_ERROR_WEAK_SIGNATURE_ALGORITHM_TITLE);
175      details = l10n_util::GetStringFUTF16(
176          IDS_CERT_ERROR_WEAK_SIGNATURE_ALGORITHM_DETAILS,
177          UTF8ToUTF16(request_url.host()));
178      short_description = l10n_util::GetStringUTF16(
179          IDS_CERT_ERROR_WEAK_SIGNATURE_ALGORITHM_DESCRIPTION);
180      extra_info.push_back(
181          l10n_util::GetStringUTF16(IDS_CERT_ERROR_EXTRA_INFO_1));
182      extra_info.push_back(
183          l10n_util::GetStringUTF16(
184              IDS_CERT_ERROR_WEAK_SIGNATURE_ALGORITHM_EXTRA_INFO_2));
185      break;
186    case CERT_WEAK_KEY:
187      title = l10n_util::GetStringUTF16(IDS_CERT_ERROR_WEAK_KEY_TITLE);
188      details = l10n_util::GetStringFUTF16(
189          IDS_CERT_ERROR_WEAK_KEY_DETAILS, UTF8ToUTF16(request_url.host()));
190      short_description = l10n_util::GetStringUTF16(
191          IDS_CERT_ERROR_WEAK_KEY_DESCRIPTION);
192      extra_info.push_back(
193          l10n_util::GetStringUTF16(IDS_CERT_ERROR_EXTRA_INFO_1));
194      extra_info.push_back(
195          l10n_util::GetStringUTF16(
196              IDS_CERT_ERROR_WEAK_KEY_EXTRA_INFO_2));
197      break;
198    case UNKNOWN:
199      title = l10n_util::GetStringUTF16(IDS_CERT_ERROR_UNKNOWN_ERROR_TITLE);
200      details = l10n_util::GetStringUTF16(IDS_CERT_ERROR_UNKNOWN_ERROR_DETAILS);
201      short_description =
202          l10n_util::GetStringUTF16(IDS_CERT_ERROR_UNKNOWN_ERROR_DESCRIPTION);
203      break;
204    default:
205      NOTREACHED();
206  }
207  return SSLErrorInfo(title, details, short_description, extra_info);
208}
209
210SSLErrorInfo::~SSLErrorInfo() {
211}
212
213// static
214SSLErrorInfo::ErrorType SSLErrorInfo::NetErrorToErrorType(int net_error) {
215  switch (net_error) {
216    case net::ERR_CERT_COMMON_NAME_INVALID:
217      return CERT_COMMON_NAME_INVALID;
218    case net::ERR_CERT_DATE_INVALID:
219      return CERT_DATE_INVALID;
220    case net::ERR_CERT_AUTHORITY_INVALID:
221      return CERT_AUTHORITY_INVALID;
222    case net::ERR_CERT_CONTAINS_ERRORS:
223      return CERT_CONTAINS_ERRORS;
224    case net::ERR_CERT_NO_REVOCATION_MECHANISM:
225      return CERT_NO_REVOCATION_MECHANISM;
226    case net::ERR_CERT_UNABLE_TO_CHECK_REVOCATION:
227      return CERT_UNABLE_TO_CHECK_REVOCATION;
228    case net::ERR_CERT_REVOKED:
229      return CERT_REVOKED;
230    case net::ERR_CERT_INVALID:
231      return CERT_INVALID;
232    case net::ERR_CERT_WEAK_SIGNATURE_ALGORITHM:
233      return CERT_WEAK_SIGNATURE_ALGORITHM;
234    case net::ERR_CERT_WEAK_KEY:
235      return CERT_WEAK_KEY;
236    default:
237      NOTREACHED();
238      return UNKNOWN;
239    }
240}
241
242// static
243int SSLErrorInfo::GetErrorsForCertStatus(int cert_id,
244                                         net::CertStatus cert_status,
245                                         const GURL& url,
246                                         std::vector<SSLErrorInfo>* errors) {
247  const net::CertStatus kErrorFlags[] = {
248    net::CERT_STATUS_COMMON_NAME_INVALID,
249    net::CERT_STATUS_DATE_INVALID,
250    net::CERT_STATUS_AUTHORITY_INVALID,
251    net::CERT_STATUS_NO_REVOCATION_MECHANISM,
252    net::CERT_STATUS_UNABLE_TO_CHECK_REVOCATION,
253    net::CERT_STATUS_REVOKED,
254    net::CERT_STATUS_INVALID,
255    net::CERT_STATUS_WEAK_SIGNATURE_ALGORITHM,
256    net::CERT_STATUS_WEAK_KEY
257  };
258
259  const ErrorType kErrorTypes[] = {
260    CERT_COMMON_NAME_INVALID,
261    CERT_DATE_INVALID,
262    CERT_AUTHORITY_INVALID,
263    CERT_NO_REVOCATION_MECHANISM,
264    CERT_UNABLE_TO_CHECK_REVOCATION,
265    CERT_REVOKED,
266    CERT_INVALID,
267    CERT_WEAK_SIGNATURE_ALGORITHM,
268    CERT_WEAK_KEY
269  };
270  DCHECK(arraysize(kErrorFlags) == arraysize(kErrorTypes));
271
272  scoped_refptr<net::X509Certificate> cert = NULL;
273  int count = 0;
274  for (size_t i = 0; i < arraysize(kErrorFlags); ++i) {
275    if (cert_status & kErrorFlags[i]) {
276      count++;
277      if (!cert.get()) {
278        bool r = content::CertStore::GetInstance()->RetrieveCert(
279            cert_id, &cert);
280        DCHECK(r);
281      }
282      if (errors)
283        errors->push_back(SSLErrorInfo::CreateError(kErrorTypes[i], cert, url));
284    }
285  }
286  return count;
287}
288