[wpr-go] Use a dummy cert if no cert is recorded

web_page_replay_go/src/webpagereplay/legacyformatconvertor.go

 // Copyright 2017 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.
 
 package webpagereplay
 
 // Converts an old archive format to the new format. This file is
 // temporary until crbug.com/730036 is fixed) and is used in
 // tools/perf/convert_legacy_wpr_archive.
 
 import (
         "bytes"
-        "crypto"
-        "crypto/rand"
         "crypto/tls"
         "crypto/x509"
         "encoding/base64"
         "encoding/json"
         "fmt"
-        "io"
         "io/ioutil"
         "net"
         "net/http"
         "net/url"
         "os"
         "strconv"
 
         "github.com/codegangsta/cli"
 )
 
@@ skipping 37 matching lines @@
                 },
                 cli.IntFlag{
                         Name:        "http_port",
                         Value:       -1,
                         Usage:       "Python WPR's http port.",
                         Destination: &cfg.httpPort,
                 },
         }
 }
 
-// Mints a dummy server cert to be used when the real server is not reachable.
-// This is used in the transition from the python wpr format to the new wprgo format where servers
-// from the old recordings (especially CDNs) have since become unreachable. crbug.com/730036
-func mintDummyCertificate(serverName string, rootCert *x509.Certificate, rootKey crypto.PrivateKey) ([]byte, string, error) {
-        template := rootCert
-        if ip := net.ParseIP(serverName); ip != nil {
-                template.IPAddresses = []net.IP{ip}
-        } else {
-                template.DNSNames = []string{serverName}
-        }
-        var buf [20]byte
-        if _, err := io.ReadFull(rand.Reader, buf[:]); err != nil {
-                return nil, "", fmt.Errorf("create cert failed: %v", err)
-        }
-        template.SerialNumber.SetBytes(buf[:])
-        template.Issuer = template.Subject
-        derBytes, err := x509.CreateCertificate(rand.Reader, template, template, template.PublicKey, rootKey)
-        if err != nil {
-                return nil, "", fmt.Errorf("create cert failed: %v", err)
-        }
-        return derBytes, "", err
-}
-
 func (r *ConvertorConfig) recordServerCert(scheme string, serverName string, archive *WritableArchive) error {
         if scheme != "https" {
                 return nil
         }
         derBytes, negotiatedProtocol, err := archive.Archive.FindHostTlsConfig(serverName)
         if err == nil && derBytes != nil {
                 return err
         }
         derBytes, negotiatedProtocol, err = MintServerCert(serverName, r.x509Cert, r.tlsCert.PrivateKey)
         if err != nil {
-                derBytes, negotiatedProtocol, err = mintDummyCertificate(serverName, r.x509Cert, r.tlsCert.PrivateKey)
+                derBytes, negotiatedProtocol, err = MintDummyCertificate(serverName, r.x509Cert, r.tlsCert.PrivateKey)
                 if err != nil {
                         return err
                 }
         }
         archive.RecordTlsConfig(serverName, derBytes, negotiatedProtocol)
         return nil
 }
 
 func (r *ConvertorConfig) Convert(c *cli.Context) {
         if r.httpPort == -1 || r.httpsPort == -1 {
@@ skipping 97 matching lines @@
                         // If cert fails to record, it usually because the host
                         // is no longer reachable. Do not error out here.
                         fmt.Printf("failed recording cert: %v", err)
                 }
         }
 
         if err := archive.Close(); err != nil {
                 fmt.Printf("Error flushing archive: %v", err)
         }
 }