func main() {
flag.Set("allowUnknownFlags", "true")
iniflags.Parse()
if certPath == nil || len(*certPath) == 0 {
fmt.Fprintln(os.Stderr, "You must specify a Certificate Path")
os.Exit(1)
return
}
certFolderDB, err := utils.NewFolderDatabase(*certPath, 0444, *certsPerFolder)
if err != nil {
fmt.Fprintln(os.Stderr, fmt.Sprintf("unable to open Certificate Path: %s: %s", certPath, err))
os.Exit(1)
return
}
if flag.NArg() < 1 {
fmt.Fprintln(os.Stderr, "Must specify the certificate ID to retrieve")
os.Exit(1)
return
}
id, err := strconv.ParseUint(flag.Arg(0), 10, 64)
if err != nil {
fmt.Fprintln(os.Stderr, fmt.Sprintf("unable to parse as integer: %s", err))
os.Exit(1)
return
}
data, err := certFolderDB.Get(id)
if err != nil {
fmt.Fprintln(os.Stderr, fmt.Sprintf("unable to find CertID: %s", err))
os.Exit(1)
return
}
_, err = os.Stdout.Write(data)
if err != nil {
fmt.Fprintln(os.Stderr, fmt.Sprintf("unable to write out CertID: %s", err))
os.Exit(1)
return
}
}
func main() {
log.SetFlags(0)
log.SetPrefix("")
dbConnectStr, err := sqldb.RecombineURLForDB(*config.DbConnect)
if err != nil {
log.Printf("unable to parse %s: %s", *config.DbConnect, err)
}
if len(dbConnectStr) == 0 || (config.CensysPath == nil && config.LogUrl == nil) {
config.Usage()
os.Exit(2)
}
db, err := sql.Open("mysql", dbConnectStr)
if err != nil {
log.Fatalf("unable to open SQL: %s: %s", dbConnectStr, err)
}
if err = db.Ping(); err != nil {
log.Fatalf("unable to ping SQL: %s: %s", dbConnectStr, err)
}
var certFolderDB *utils.FolderDatabase
if config.CertPath != nil && len(*config.CertPath) > 0 {
certFolderDB, err = utils.NewFolderDatabase(*config.CertPath, 0444, *config.CertsPerFolder)
if err != nil {
log.Fatalf("unable to open Certificate Path: %s: %s", config.CertPath, err)
}
}
dialect := gorp.MySQLDialect{Engine: "InnoDB", Encoding: "UTF8"}
dbMap := &gorp.DbMap{Db: db, Dialect: dialect}
entriesDb := &sqldb.EntriesDatabase{DbMap: dbMap,
Verbose: *config.Verbose, FullCerts: certFolderDB,
KnownIssuers: make(map[string]int)}
err = entriesDb.InitTables()
if err != nil {
log.Fatalf("unable to prepare SQL: %s: %s", dbConnectStr, err)
}
if config.LogUrl != nil && len(*config.LogUrl) > 5 {
ctLogUrl, err := url.Parse(*config.LogUrl)
if err != nil {
log.Fatalf("unable to set Certificate Log: %s", err)
}
ctLog := client.New(*config.LogUrl, nil)
log.Printf("Starting download from log %s, fullCerts=%t\n", ctLogUrl, (certFolderDB != nil))
err = downloadLog(ctLogUrl, ctLog, entriesDb)
if err != nil {
log.Fatalf("error while updating CT entries: %s", err)
}
os.Exit(0)
}
var importer censysdata.Importer
if config.CensysUrl != nil && len(*config.CensysUrl) > 5 {
urlImporter, err := censysdata.OpenURL(*config.CensysUrl)
if err != nil {
log.Fatalf("unable to open Censys URL: %s", err)
}
importer = urlImporter
} else if config.CensysPath != nil && len(*config.CensysPath) > 5 {
fileImporter, err := censysdata.OpenFile(*config.CensysPath)
if err != nil {
log.Fatalf("unable to open Censys file: %s", err)
}
importer = fileImporter
defer fileImporter.Close()
} else if *config.CensysStdin {
stdinImporter, err := censysdata.OpenFileHandle(os.Stdin)
if err != nil {
log.Fatalf("unable to open stdin: %s", err)
}
importer = stdinImporter
defer stdinImporter.Close()
}
if importer != nil {
log.Printf("Starting Censys Import, using %s, fullCerts=%t\n", importer.String(), (certFolderDB != nil))
wg := new(sync.WaitGroup)
err = processImporter(importer, entriesDb, wg)
if err != nil {
log.Fatalf("error while running importer: %s", err)
}
wg.Wait()
os.Exit(0)
}
// Didn't include a mandatory action, so print usage and exit.
config.Usage()
os.Exit(2)
}