Implement crypto signature verification routines using OpenSSL.

extensions/browser/api/cast_channel/logger.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "extensions/browser/api/cast_channel/logger.h"
 
 #include <string>
 
 #include "base/strings/string_util.h"
 #include "base/time/tick_clock.h"
@@ skipping 28 matching lines @@
     case AuthResult::ERROR_NO_PAYLOAD:
       return proto::CHALLENGE_REPLY_ERROR_NO_PAYLOAD;
     case AuthResult::ERROR_PAYLOAD_PARSING_FAILED:
       return proto::CHALLENGE_REPLY_ERROR_PAYLOAD_PARSING_FAILED;
     case AuthResult::ERROR_MESSAGE_ERROR:
       return proto::CHALLENGE_REPLY_ERROR_MESSAGE_ERROR;
     case AuthResult::ERROR_NO_RESPONSE:
       return proto::CHALLENGE_REPLY_ERROR_NO_RESPONSE;
     case AuthResult::ERROR_FINGERPRINT_NOT_FOUND:
       return proto::CHALLENGE_REPLY_ERROR_FINGERPRINT_NOT_FOUND;
-    case AuthResult::ERROR_NSS_CERT_PARSING_FAILED:
-      return proto::CHALLENGE_REPLY_ERROR_NSS_CERT_PARSING_FAILED;
-    case AuthResult::ERROR_NSS_CERT_NOT_SIGNED_BY_TRUSTED_CA:
-      return proto::CHALLENGE_REPLY_ERROR_NSS_CERT_NOT_SIGNED_BY_TRUSTED_CA;
-    case AuthResult::ERROR_NSS_CANNOT_EXTRACT_PUBLIC_KEY:
-      return proto::CHALLENGE_REPLY_ERROR_NSS_CANNOT_EXTRACT_PUBLIC_KEY;
-    case AuthResult::ERROR_NSS_SIGNED_BLOBS_MISMATCH:
-      return proto::CHALLENGE_REPLY_ERROR_NSS_SIGNED_BLOBS_MISMATCH;
+    case AuthResult::ERROR_CERT_PARSING_FAILED:
+      return proto::CHALLENGE_REPLY_ERROR_CERT_PARSING_FAILED;
+    case AuthResult::ERROR_CERT_NOT_SIGNED_BY_TRUSTED_CA:
+      return proto::CHALLENGE_REPLY_ERROR_CERT_NOT_SIGNED_BY_TRUSTED_CA;
+    case AuthResult::ERROR_CANNOT_EXTRACT_PUBLIC_KEY:
+      return proto::CHALLENGE_REPLY_ERROR_CANNOT_EXTRACT_PUBLIC_KEY;
+    case AuthResult::ERROR_SIGNED_BLOBS_MISMATCH:
+      return proto::CHALLENGE_REPLY_ERROR_SIGNED_BLOBS_MISMATCH;
     default:
       NOTREACHED();
       return proto::CHALLENGE_REPLY_ERROR_NONE;
   }
 }
 
 scoped_ptr<char[]> Compress(const std::string& input, size_t* length) {
   *length = 0;
   z_stream stream = {0};
   int result = deflateInit2(&stream,
@@ skipping 190 matching lines @@
   LogSocketEvent(channel_id, event);
 }
 
 void Logger::LogSocketChallengeReplyEvent(int channel_id,
                                           const AuthResult& auth_result) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   SocketEvent event = CreateEvent(proto::AUTH_CHALLENGE_REPLY);
   event.set_challenge_reply_error_type(
       ChallegeReplyErrorToProto(auth_result.error_type));
-  if (auth_result.nss_error_code != 0)
+  if (auth_result.nss_error_code != 0) {
     event.set_nss_error_code(auth_result.nss_error_code);
+  }
+  if (!auth_result.openssl_errors.empty()) {
+    for (const auto & next_error : auth_result.openssl_errors) {
+      proto::OpenSSLError* new_error = event.add_openssl_error();
+      new_error->set_filename(next_error.first);
+      new_error->set_line(next_error.second);
+    }
+  }
 
   LogSocketEvent(channel_id, event);
 }
 
 SocketEvent Logger::CreateEvent(EventType event_type) {
   SocketEvent event;
   event.set_type(event_type);
   event.set_timestamp_micros(clock_->NowTicks().ToInternalValue() -
                              unix_epoch_time_ticks_.ToInternalValue());
   return event;
@@ skipping 83 matching lines @@
   if (it != aggregated_socket_events_.end()) {
     return it->second->last_errors;
   } else {
     return LastErrors();
   }
 }
 
 }  // namespace cast_channel
 }  // namespace core_api
 }  // namespace extensions