Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "c", "*", "Config", ")", "SetSessionTicketKeys", "(", "keys", "[", "]", "[", "32", "]", "byte", ")", "{", "if", "len", "(", "keys", ")", "==", "0", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "newKeys", ":=", "make", "(", "[", "]", "ticketKey", ",", "len", "(", "keys", ")", ")", "\n", "for", "i", ",", "bytes", ":=", "range", "keys", "{", "newKeys", "[", "i", "]", "=", "ticketKeyFromBytes", "(", "bytes", ")", "\n", "}", "\n\n", "c", ".", "mutex", ".", "Lock", "(", ")", "\n", "c", ".", "sessionTicketKeys", "=", "newKeys", "\n", "c", ".", "mutex", ".", "Unlock", "(", ")", "\n", "}" ]

[ "SetSessionTicketKeys", "updates", "the", "session", "ticket", "keys", "for", "a", "server", ".", "The", "first", "key", "will", "be", "used", "when", "creating", "new", "tickets", "while", "all", "keys", "can", "be", "used", "for", "decrypting", "tickets", ".", "It", "is", "safe", "to", "call", "this", "function", "while", "the", "server", "is", "running", "in", "order", "to", "rotate", "the", "session", "ticket", "keys", ".", "The", "function", "will", "panic", "if", "keys", "is", "empty", "." ]

[ "func", "(", "c", "*", "Config", ")", "mutualVersion", "(", "vers", "uint16", ")", "(", "uint16", ",", "bool", ")", "{", "minVersion", ":=", "c", ".", "minVersion", "(", ")", "\n", "maxVersion", ":=", "c", ".", "maxVersion", "(", ")", "\n\n", "if", "vers", "<", "minVersion", "{", "return", "0", ",", "false", "\n", "}", "\n", "if", "vers", ">", "maxVersion", "{", "vers", "=", "maxVersion", "\n", "}", "\n", "return", "vers", ",", "true", "\n", "}" ]

[ "mutualVersion", "returns", "the", "protocol", "version", "to", "use", "given", "the", "advertised", "version", "of", "the", "peer", "." ]

[ "func", "(", "c", "*", "Config", ")", "getCertificate", "(", "clientHello", "*", "ClientHelloInfo", ")", "(", "*", "Certificate", ",", "error", ")", "{", "if", "c", ".", "GetCertificate", "!=", "nil", "&&", "(", "len", "(", "c", ".", "Certificates", ")", "==", "0", "||", "len", "(", "clientHello", ".", "ServerName", ")", ">", "0", ")", "{", "cert", ",", "err", ":=", "c", ".", "GetCertificate", "(", "clientHello", ")", "\n", "if", "cert", "!=", "nil", "||", "err", "!=", "nil", "{", "return", "cert", ",", "err", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "c", ".", "Certificates", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "len", "(", "c", ".", "Certificates", ")", "==", "1", "||", "c", ".", "NameToCertificate", "==", "nil", "{", "// There's only one choice, so no point doing any work.", "return", "&", "c", ".", "Certificates", "[", "0", "]", ",", "nil", "\n", "}", "\n\n", "name", ":=", "strings", ".", "ToLower", "(", "clientHello", ".", "ServerName", ")", "\n", "for", "len", "(", "name", ")", ">", "0", "&&", "name", "[", "len", "(", "name", ")", "-", "1", "]", "==", "'.'", "{", "name", "=", "name", "[", ":", "len", "(", "name", ")", "-", "1", "]", "\n", "}", "\n\n", "if", "cert", ",", "ok", ":=", "c", ".", "NameToCertificate", "[", "name", "]", ";", "ok", "{", "return", "cert", ",", "nil", "\n", "}", "\n\n", "// try replacing labels in the name with wildcards until we get a", "// match.", "labels", ":=", "strings", ".", "Split", "(", "name", ",", "\"", "\"", ")", "\n", "for", "i", ":=", "range", "labels", "{", "labels", "[", "i", "]", "=", "\"", "\"", "\n", "candidate", ":=", "strings", ".", "Join", "(", "labels", ",", "\"", "\"", ")", "\n", "if", "cert", ",", "ok", ":=", "c", ".", "NameToCertificate", "[", "candidate", "]", ";", "ok", "{", "return", "cert", ",", "nil", "\n", "}", "\n", "}", "\n\n", "// If nothing matches, return the first certificate.", "return", "&", "c", ".", "Certificates", "[", "0", "]", ",", "nil", "\n", "}" ]

[ "getCertificate", "returns", "the", "best", "certificate", "for", "the", "given", "ClientHelloInfo", "defaulting", "to", "the", "first", "element", "of", "c", ".", "Certificates", "." ]

[ "func", "(", "c", "*", "Config", ")", "BuildNameToCertificate", "(", ")", "{", "c", ".", "NameToCertificate", "=", "make", "(", "map", "[", "string", "]", "*", "Certificate", ")", "\n", "for", "i", ":=", "range", "c", ".", "Certificates", "{", "cert", ":=", "&", "c", ".", "Certificates", "[", "i", "]", "\n", "x509Cert", ",", "err", ":=", "x509", ".", "ParseCertificate", "(", "cert", ".", "Certificate", "[", "0", "]", ")", "\n", "if", "err", "!=", "nil", "{", "continue", "\n", "}", "\n", "if", "len", "(", "x509Cert", ".", "Subject", ".", "CommonName", ")", ">", "0", "{", "c", ".", "NameToCertificate", "[", "x509Cert", ".", "Subject", ".", "CommonName", "]", "=", "cert", "\n", "}", "\n", "for", "_", ",", "san", ":=", "range", "x509Cert", ".", "DNSNames", "{", "c", ".", "NameToCertificate", "[", "san", "]", "=", "cert", "\n", "}", "\n", "}", "\n", "}" ]

[ "BuildNameToCertificate", "parses", "c", ".", "Certificates", "and", "builds", "c", ".", "NameToCertificate", "from", "the", "CommonName", "and", "SubjectAlternateName", "fields", "of", "each", "of", "the", "leaf", "certificates", "." ]

[ "func", "NewLRUClientSessionCache", "(", "capacity", "int", ")", "ClientSessionCache", "{", "const", "defaultSessionCacheCapacity", "=", "64", "\n\n", "if", "capacity", "<", "1", "{", "capacity", "=", "defaultSessionCacheCapacity", "\n", "}", "\n", "return", "&", "lruSessionCache", "{", "m", ":", "make", "(", "map", "[", "string", "]", "*", "list", ".", "Element", ")", ",", "q", ":", "list", ".", "New", "(", ")", ",", "capacity", ":", "capacity", ",", "}", "\n", "}" ]

[ "NewLRUClientSessionCache", "returns", "a", "ClientSessionCache", "with", "the", "given", "capacity", "that", "uses", "an", "LRU", "strategy", ".", "If", "capacity", "is", "<", "1", "a", "default", "capacity", "is", "used", "instead", "." ]

[ "func", "(", "c", "*", "Conn", ")", "SayHello", "(", "newSigAls", "[", "]", "SignatureAndHash", ")", "(", "cipherID", ",", "curveType", "uint16", ",", "curveID", "CurveID", ",", "version", "uint16", ",", "certs", "[", "]", "[", "]", "byte", ",", "err", "error", ")", "{", "// Set the supported signatures and hashes to the set `newSigAls`", "supportedSignatureAlgorithms", ":=", "make", "(", "[", "]", "signatureAndHash", ",", "len", "(", "newSigAls", ")", ")", "\n", "for", "i", ":=", "range", "newSigAls", "{", "supportedSignatureAlgorithms", "[", "i", "]", "=", "newSigAls", "[", "i", "]", ".", "internal", "(", ")", "\n", "}", "\n\n", "hello", ":=", "&", "clientHelloMsg", "{", "vers", ":", "c", ".", "config", ".", "maxVersion", "(", ")", ",", "compressionMethods", ":", "[", "]", "uint8", "{", "compressionNone", "}", ",", "random", ":", "make", "(", "[", "]", "byte", ",", "32", ")", ",", "ocspStapling", ":", "true", ",", "serverName", ":", "c", ".", "config", ".", "ServerName", ",", "supportedCurves", ":", "c", ".", "config", ".", "curvePreferences", "(", ")", ",", "supportedPoints", ":", "[", "]", "uint8", "{", "pointFormatUncompressed", "}", ",", "nextProtoNeg", ":", "len", "(", "c", ".", "config", ".", "NextProtos", ")", ">", "0", ",", "secureRenegotiation", ":", "true", ",", "cipherSuites", ":", "c", ".", "config", ".", "cipherSuites", "(", ")", ",", "signatureAndHashes", ":", "supportedSignatureAlgorithms", ",", "}", "\n", "serverHello", ",", "err", ":=", "c", ".", "sayHello", "(", "hello", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "// Prime the connection, if necessary, for key", "// exchange messages by reading off the certificate", "// message and, if necessary, the OCSP stapling", "// message", "var", "msg", "interface", "{", "}", "\n", "msg", ",", "err", "=", "c", ".", "readHandshake", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "certMsg", ",", "ok", ":=", "msg", ".", "(", "*", "certificateMsg", ")", "\n", "if", "!", "ok", "||", "len", "(", "certMsg", ".", "certificates", ")", "==", "0", "{", "err", "=", "unexpectedMessageError", "(", "certMsg", ",", "msg", ")", "\n", "return", "\n", "}", "\n", "certs", "=", "certMsg", ".", "certificates", "\n\n", "if", "serverHello", ".", "ocspStapling", "{", "msg", ",", "err", "=", "c", ".", "readHandshake", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "certStatusMsg", ",", "ok", ":=", "msg", ".", "(", "*", "certificateStatusMsg", ")", "\n", "if", "!", "ok", "{", "err", "=", "unexpectedMessageError", "(", "certStatusMsg", ",", "msg", ")", "\n", "return", "\n", "}", "\n", "}", "\n\n", "if", "CipherSuites", "[", "serverHello", ".", "cipherSuite", "]", ".", "EllipticCurve", "{", "var", "skx", "*", "serverKeyExchangeMsg", "\n", "skx", ",", "err", "=", "c", ".", "exchangeKeys", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "skx", ".", "raw", "[", "0", "]", "!=", "typeServerKeyExchange", "{", "err", "=", "unexpectedMessageError", "(", "skx", ",", "msg", ")", "\n", "return", "\n", "}", "\n", "if", "len", "(", "skx", ".", "key", ")", "<", "4", "{", "err", "=", "unexpectedMessageError", "(", "skx", ",", "msg", ")", "\n", "return", "\n", "}", "\n", "curveType", "=", "uint16", "(", "skx", ".", "key", "[", "0", "]", ")", "\n", "// If we have a named curve, report which one it is.", "if", "curveType", "==", "3", "{", "curveID", "=", "CurveID", "(", "skx", ".", "key", "[", "1", "]", ")", "<<", "8", "|", "CurveID", "(", "skx", ".", "key", "[", "2", "]", ")", "\n", "}", "\n", "}", "\n", "cipherID", ",", "version", "=", "serverHello", ".", "cipherSuite", ",", "serverHello", ".", "vers", "\n\n", "return", "\n", "}" ]

[ "SayHello", "constructs", "a", "simple", "Client", "Hello", "to", "a", "server", "parses", "its", "serverHelloMsg", "response", "and", "returns", "the", "negotiated", "ciphersuite", "ID", "and", "if", "an", "EC", "cipher", "suite", "the", "curve", "ID" ]

[ "func", "(", "c", "*", "Conn", ")", "sayHello", "(", "hello", "*", "clientHelloMsg", ")", "(", "serverHello", "*", "serverHelloMsg", ",", "err", "error", ")", "{", "c", ".", "writeRecord", "(", "recordTypeHandshake", ",", "hello", ".", "marshal", "(", ")", ")", "\n", "msg", ",", "err", ":=", "c", ".", "readHandshake", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "serverHello", ",", "ok", ":=", "msg", ".", "(", "*", "serverHelloMsg", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "unexpectedMessageError", "(", "serverHello", ",", "msg", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "sayHello", "is", "the", "backend", "to", "SayHello", "that", "returns", "a", "full", "serverHelloMsg", "for", "processing", "." ]

[ "func", "(", "c", "*", "Conn", ")", "exchangeKeys", "(", ")", "(", "serverKeyExchange", "*", "serverKeyExchangeMsg", ",", "err", "error", ")", "{", "msg", ",", "err", ":=", "c", ".", "readHandshake", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "serverKeyExchange", ",", "ok", ":=", "msg", ".", "(", "*", "serverKeyExchangeMsg", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "unexpectedMessageError", "(", "serverKeyExchange", ",", "msg", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "exchangeKeys", "continues", "the", "handshake", "to", "receive", "the", "serverKeyExchange", "message", "from", "which", "we", "can", "extract", "elliptic", "curve", "parameters" ]

[ "func", "PemBlockToString", "(", "block", "*", "pem", ".", "Block", ")", "string", "{", "if", "block", ".", "Bytes", "==", "nil", "||", "block", ".", "Type", "==", "\"", "\"", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "string", "(", "bytes", ".", "TrimSpace", "(", "pem", ".", "EncodeToMemory", "(", "block", ")", ")", ")", "\n", "}" ]

[ "PemBlockToString", "turns", "a", "pem", ".", "Block", "into", "the", "string", "encoded", "form", "." ]

[ "func", "(", "b", "*", "Bundle", ")", "buildHostnames", "(", ")", "{", "if", "b", ".", "Cert", "==", "nil", "{", "return", "\n", "}", "\n", "// hset keeps a set of unique hostnames.", "hset", ":=", "make", "(", "map", "[", "string", "]", "bool", ")", "\n", "// insert CN into hset", "if", "b", ".", "Cert", ".", "Subject", ".", "CommonName", "!=", "\"", "\"", "{", "hset", "[", "b", ".", "Cert", ".", "Subject", ".", "CommonName", "]", "=", "true", "\n", "}", "\n", "// insert all DNS names into hset", "for", "_", ",", "h", ":=", "range", "b", ".", "Cert", ".", "DNSNames", "{", "hset", "[", "h", "]", "=", "true", "\n", "}", "\n\n", "// convert hset to an array of hostnames", "b", ".", "Hostnames", "=", "make", "(", "[", "]", "string", ",", "len", "(", "hset", ")", ")", "\n", "i", ":=", "0", "\n", "for", "h", ":=", "range", "hset", "{", "b", ".", "Hostnames", "[", "i", "]", "=", "h", "\n", "i", "++", "\n", "}", "\n", "}" ]

[ "buildHostnames", "sets", "bundle", ".", "Hostnames", "by", "the", "x509", "cert", "s", "subject", "CN", "and", "DNS", "names", "Since", "the", "subject", "CN", "may", "overlap", "with", "one", "of", "the", "DNS", "names", "it", "needs", "to", "handle", "the", "duplication", "by", "a", "set", "." ]

[ "func", "NewCFSSL", "(", "metadata", "map", "[", "string", "]", "string", ")", "(", "[", "]", "*", "x509", ".", "Certificate", ",", "error", ")", "{", "host", ",", "ok", ":=", "metadata", "[", "\"", "\"", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "label", ":=", "metadata", "[", "\"", "\"", "]", "\n", "profile", ":=", "metadata", "[", "\"", "\"", "]", "\n", "cert", ",", "err", ":=", "helpers", ".", "LoadClientCertificate", "(", "metadata", "[", "\"", "\"", "]", ",", "metadata", "[", "\"", "\"", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "remoteCAs", ",", "err", ":=", "helpers", ".", "LoadPEMCertPool", "(", "metadata", "[", "\"", "\"", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "srv", ":=", "client", ".", "NewServerTLS", "(", "host", ",", "helpers", ".", "CreateTLSConfig", "(", "remoteCAs", ",", "cert", ")", ")", "\n", "data", ",", "err", ":=", "json", ".", "Marshal", "(", "info", ".", "Req", "{", "Label", ":", "label", ",", "Profile", ":", "profile", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "resp", ",", "err", ":=", "srv", ".", "Info", "(", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "helpers", ".", "ParseCertificatesPEM", "(", "[", "]", "byte", "(", "resp", ".", "Certificate", ")", ")", "\n", "}" ]

[ "This", "package", "contains", "CFSSL", "integration", ".", "NewCFSSL", "produces", "a", "new", "CFSSL", "root", "." ]

[ "func", "ParseEd25519PublicKey", "(", "der", "[", "]", "byte", ")", "(", "crypto", ".", "PublicKey", ",", "error", ")", "{", "var", "spki", "subjectPublicKeyInfo", "\n", "if", "rest", ",", "err", ":=", "asn1", ".", "Unmarshal", "(", "der", ",", "&", "spki", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "else", "if", "len", "(", "rest", ")", ">", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "!", "spki", ".", "Algorithm", ".", "Algorithm", ".", "Equal", "(", "ed25519OID", ")", "{", "return", "nil", ",", "errEd25519WrongID", "\n", "}", "\n\n", "if", "spki", ".", "PublicKey", ".", "BitLength", "!=", "ed25519", ".", "PublicKeySize", "*", "8", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "ed25519", ".", "PublicKey", "(", "spki", ".", "PublicKey", ".", "Bytes", ")", ",", "nil", "\n", "}" ]

[ "ParseEd25519PublicKey", "returns", "the", "Ed25519", "public", "key", "encoded", "by", "the", "input", "." ]

[ "func", "ParseEd25519PrivateKey", "(", "der", "[", "]", "byte", ")", "(", "crypto", ".", "PrivateKey", ",", "error", ")", "{", "asym", ":=", "new", "(", "oneAsymmetricKey", ")", "\n", "if", "rest", ",", "err", ":=", "asn1", ".", "Unmarshal", "(", "der", ",", "asym", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "else", "if", "len", "(", "rest", ")", ">", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Check that the key type is correct.", "if", "!", "asym", ".", "Algorithm", ".", "Algorithm", ".", "Equal", "(", "ed25519OID", ")", "{", "return", "nil", ",", "errEd25519WrongID", "\n", "}", "\n\n", "// Unmarshal the inner CurvePrivateKey.", "seed", ":=", "new", "(", "curvePrivateKey", ")", "\n", "if", "rest", ",", "err", ":=", "asn1", ".", "Unmarshal", "(", "asym", ".", "PrivateKey", ",", "seed", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "else", "if", "len", "(", "rest", ")", ">", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "ed25519", ".", "NewKeyFromSeed", "(", "*", "seed", ")", ",", "nil", "\n", "}" ]

[ "ParseEd25519PrivateKey", "returns", "the", "Ed25519", "private", "key", "encoded", "by", "the", "input", "." ]

[ "func", "PopFirstArgument", "(", "args", "[", "]", "string", ")", "(", "string", ",", "[", "]", "string", ",", "error", ")", "{", "if", "len", "(", "args", ")", "<", "1", "{", "return", "\"", "\"", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "args", "[", "0", "]", ",", "args", "[", "1", ":", "]", ",", "nil", "\n", "}" ]

[ "PopFirstArgument", "returns", "the", "first", "element", "and", "the", "rest", "of", "a", "string", "slice", "and", "return", "error", "if", "failed", "to", "do", "so", ".", "It", "is", "a", "helper", "function", "to", "parse", "non", "-", "flag", "arguments", "previously", "used", "in", "cfssl", "commands", "." ]

[ "func", "Start", "(", "cmds", "map", "[", "string", "]", "*", "Command", ")", "error", "{", "// cfsslFlagSet is the flag sets for cfssl.", "var", "cfsslFlagSet", "=", "flag", ".", "NewFlagSet", "(", "\"", "\"", ",", "flag", ".", "ExitOnError", ")", "\n", "var", "c", "Config", "\n\n", "registerFlags", "(", "&", "c", ",", "cfsslFlagSet", ")", "\n", "// Initial parse of command line arguments. By convention, only -h/-help is supported.", "if", "flag", ".", "Usage", "==", "nil", "{", "flag", ".", "Usage", "=", "func", "(", ")", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "usage", ")", "\n", "for", "name", ":=", "range", "cmds", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\t", "\\n", "\"", ",", "name", ")", "\n", "}", "\n", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ")", "\n", "flag", ".", "PrintDefaults", "(", ")", "\n", "}", "\n", "}", "\n\n", "flag", ".", "Parse", "(", ")", "\n\n", "if", "flag", ".", "NArg", "(", ")", "<", "1", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ")", "\n", "flag", ".", "Usage", "(", ")", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Clip out the command name and args for the command", "cmdName", "=", "flag", ".", "Arg", "(", "0", ")", "\n", "args", ":=", "flag", ".", "Args", "(", ")", "[", "1", ":", "]", "\n", "cmd", ",", "found", ":=", "cmds", "[", "cmdName", "]", "\n", "if", "!", "found", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "cmdName", ")", "\n", "flag", ".", "Usage", "(", ")", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "// always have flag 'loglevel' for each command", "cmd", ".", "Flags", "=", "append", "(", "cmd", ".", "Flags", ",", "\"", "\"", ")", "\n", "// The usage of each individual command is re-written to mention", "// flags defined and referenced only in that command.", "cfsslFlagSet", ".", "Usage", "=", "func", "(", ")", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\t", "\"", ",", "cmd", ".", "UsageText", ")", "\n", "for", "_", ",", "name", ":=", "range", "cmd", ".", "Flags", "{", "if", "f", ":=", "cfsslFlagSet", ".", "Lookup", "(", "name", ")", ";", "f", "!=", "nil", "{", "printDefaultValue", "(", "f", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// Parse all flags and take the rest as argument lists for the command", "cfsslFlagSet", ".", "Parse", "(", "args", ")", "\n", "args", "=", "cfsslFlagSet", ".", "Args", "(", ")", "\n\n", "var", "err", "error", "\n", "if", "c", ".", "ConfigFile", "!=", "\"", "\"", "{", "c", ".", "CFG", ",", "err", "=", "config", ".", "LoadFile", "(", "c", ".", "ConfigFile", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\"", ",", "err", ")", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "cmd", ".", "Main", "(", "args", ",", "c", ")", ";", "err", "!=", "nil", "{", "fmt", ".", "Fprintln", "(", "os", ".", "Stderr", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Start", "is", "the", "entrance", "point", "of", "cfssl", "command", "line", "tools", "." ]

[ "func", "ReadStdin", "(", "filename", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "filename", "==", "\"", "\"", "{", "return", "ioutil", ".", "ReadAll", "(", "os", ".", "Stdin", ")", "\n", "}", "\n", "return", "ioutil", ".", "ReadFile", "(", "filename", ")", "\n", "}" ]

[ "ReadStdin", "reads", "from", "stdin", "if", "the", "file", "is", "-" ]

[ "func", "PrintCert", "(", "key", ",", "csrBytes", ",", "cert", "[", "]", "byte", ")", "{", "out", ":=", "map", "[", "string", "]", "string", "{", "}", "\n", "if", "cert", "!=", "nil", "{", "out", "[", "\"", "\"", "]", "=", "string", "(", "cert", ")", "\n", "}", "\n\n", "if", "key", "!=", "nil", "{", "out", "[", "\"", "\"", "]", "=", "string", "(", "key", ")", "\n", "}", "\n\n", "if", "csrBytes", "!=", "nil", "{", "out", "[", "\"", "\"", "]", "=", "string", "(", "csrBytes", ")", "\n", "}", "\n\n", "jsonOut", ",", "err", ":=", "json", ".", "Marshal", "(", "out", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "jsonOut", ")", "\n", "}" ]

[ "PrintCert", "outputs", "a", "cert", "key", "and", "csr", "to", "stdout" ]

[ "func", "PrintOCSPResponse", "(", "resp", "[", "]", "byte", ")", "{", "b64Resp", ":=", "base64", ".", "StdEncoding", ".", "EncodeToString", "(", "resp", ")", "\n\n", "out", ":=", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "b64Resp", "}", "\n", "jsonOut", ",", "err", ":=", "json", ".", "Marshal", "(", "out", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "jsonOut", ")", "\n", "}" ]

[ "PrintOCSPResponse", "outputs", "an", "OCSP", "response", "to", "stdout", "ocspResponse", "is", "base64", "encoded" ]

[ "func", "PrintCRL", "(", "certList", "[", "]", "byte", ")", "{", "b64Resp", ":=", "base64", ".", "StdEncoding", ".", "EncodeToString", "(", "certList", ")", "\n\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "b64Resp", ")", "\n", "}" ]

[ "PrintCRL", "outputs", "the", "CRL", "to", "stdout" ]

[ "func", "NewHealthCheck", "(", ")", "http", ".", "Handler", "{", "return", "api", ".", "HTTPHandler", "{", "Handler", ":", "api", ".", "HandlerFunc", "(", "healthHandler", ")", ",", "Methods", ":", "[", "]", "string", "{", "\"", "\"", "}", ",", "}", "\n", "}" ]

[ "NewHealthCheck", "creates", "a", "new", "handler", "to", "serve", "health", "checks", "." ]

[ "func", "bundlerMain", "(", "args", "[", "]", "string", ",", "c", "cli", ".", "Config", ")", "(", "err", "error", ")", "{", "bundler", ".", "IntermediateStash", "=", "c", ".", "IntDir", "\n", "ubiquity", ".", "LoadPlatforms", "(", "c", ".", "Metadata", ")", "\n", "flavor", ":=", "bundler", ".", "BundleFlavor", "(", "c", ".", "Flavor", ")", "\n", "var", "b", "*", "bundler", ".", "Bundler", "\n", "// If it is a force bundle, don't require ca bundle and intermediate bundle", "// Otherwise, initialize a bundler with CA bundle and intermediate bundle.", "if", "flavor", "==", "bundler", ".", "Force", "{", "b", "=", "&", "bundler", ".", "Bundler", "{", "}", "\n", "}", "else", "{", "b", ",", "err", "=", "bundler", ".", "NewBundler", "(", "c", ".", "CABundleFile", ",", "c", ".", "IntBundleFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n\n", "var", "bundle", "*", "bundler", ".", "Bundle", "\n", "if", "c", ".", "CertFile", "!=", "\"", "\"", "{", "if", "c", ".", "CertFile", "==", "\"", "\"", "{", "var", "certPEM", ",", "keyPEM", "[", "]", "byte", "\n", "certPEM", ",", "err", "=", "cli", ".", "ReadStdin", "(", "c", ".", "CertFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "c", ".", "KeyFile", "!=", "\"", "\"", "{", "keyPEM", ",", "err", "=", "cli", ".", "ReadStdin", "(", "c", ".", "KeyFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n", "bundle", ",", "err", "=", "b", ".", "BundleFromPEMorDER", "(", "certPEM", ",", "keyPEM", ",", "flavor", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "else", "{", "// Bundle the client cert", "bundle", ",", "err", "=", "b", ".", "BundleFromFile", "(", "c", ".", "CertFile", ",", "c", ".", "KeyFile", ",", "flavor", ",", "c", ".", "Password", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n", "}", "else", "if", "c", ".", "Domain", "!=", "\"", "\"", "{", "bundle", ",", "err", "=", "b", ".", "BundleFromRemote", "(", "c", ".", "Domain", ",", "c", ".", "IP", ",", "flavor", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "else", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "marshaled", ",", "err", ":=", "bundle", ".", "MarshalJSON", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "fmt", ".", "Printf", "(", "\"", "\"", ",", "marshaled", ")", "\n", "return", "\n", "}" ]

[ "bundlerMain", "is", "the", "main", "CLI", "of", "bundler", "functionality", "." ]

[ "func", "ldapURL", "(", "url", "string", ")", "bool", "{", "u", ",", "err", ":=", "neturl", ".", "Parse", "(", "url", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "url", ",", "err", ")", "\n", "return", "false", "\n", "}", "\n", "if", "u", ".", "Scheme", "==", "\"", "\"", "{", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "We", "can", "t", "handle", "LDAP", "certificates", "so", "this", "checks", "to", "see", "if", "the", "URL", "string", "points", "to", "an", "LDAP", "resource", "so", "that", "we", "can", "ignore", "it", "." ]

[ "func", "fetchCRL", "(", "url", "string", ")", "(", "*", "pkix", ".", "CertificateList", ",", "error", ")", "{", "resp", ",", "err", ":=", "http", ".", "Get", "(", "url", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "else", "if", "resp", ".", "StatusCode", ">=", "300", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "body", ",", "err", ":=", "crlRead", "(", "resp", ".", "Body", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "resp", ".", "Body", ".", "Close", "(", ")", "\n\n", "return", "x509", ".", "ParseCRL", "(", "body", ")", "\n", "}" ]

[ "fetchCRL", "fetches", "and", "parses", "a", "CRL", "." ]

[ "func", "certIsRevokedCRL", "(", "cert", "*", "x509", ".", "Certificate", ",", "url", "string", ")", "(", "revoked", ",", "ok", "bool", ",", "err", "error", ")", "{", "crl", ",", "ok", ":=", "CRLSet", "[", "url", "]", "\n", "if", "ok", "&&", "crl", "==", "nil", "{", "ok", "=", "false", "\n", "crlLock", ".", "Lock", "(", ")", "\n", "delete", "(", "CRLSet", ",", "url", ")", "\n", "crlLock", ".", "Unlock", "(", ")", "\n", "}", "\n\n", "var", "shouldFetchCRL", "=", "true", "\n", "if", "ok", "{", "if", "!", "crl", ".", "HasExpired", "(", "time", ".", "Now", "(", ")", ")", "{", "shouldFetchCRL", "=", "false", "\n", "}", "\n", "}", "\n\n", "issuer", ":=", "getIssuer", "(", "cert", ")", "\n\n", "if", "shouldFetchCRL", "{", "var", "err", "error", "\n", "crl", ",", "err", "=", "fetchCRL", "(", "url", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "false", ",", "false", ",", "err", "\n", "}", "\n\n", "// check CRL signature", "if", "issuer", "!=", "nil", "{", "err", "=", "issuer", ".", "CheckCRLSignature", "(", "crl", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "false", ",", "false", ",", "err", "\n", "}", "\n", "}", "\n\n", "crlLock", ".", "Lock", "(", ")", "\n", "CRLSet", "[", "url", "]", "=", "crl", "\n", "crlLock", ".", "Unlock", "(", ")", "\n", "}", "\n\n", "for", "_", ",", "revoked", ":=", "range", "crl", ".", "TBSCertList", ".", "RevokedCertificates", "{", "if", "cert", ".", "SerialNumber", ".", "Cmp", "(", "revoked", ".", "SerialNumber", ")", "==", "0", "{", "log", ".", "Info", "(", "\"", "\"", ")", "\n", "return", "true", ",", "true", ",", "err", "\n", "}", "\n", "}", "\n\n", "return", "false", ",", "true", ",", "err", "\n", "}" ]

[ "check", "a", "cert", "against", "a", "specific", "CRL", ".", "Returns", "the", "same", "bool", "pair", "as", "revCheck", "plus", "an", "error", "if", "one", "occurred", "." ]

[ "func", "VerifyCertificate", "(", "cert", "*", "x509", ".", "Certificate", ")", "(", "revoked", ",", "ok", "bool", ")", "{", "revoked", ",", "ok", ",", "_", "=", "VerifyCertificateError", "(", "cert", ")", "\n", "return", "revoked", ",", "ok", "\n", "}" ]

[ "VerifyCertificate", "ensures", "that", "the", "certificate", "passed", "in", "hasn", "t", "expired", "and", "checks", "the", "CRL", "for", "the", "server", "." ]

[ "func", "VerifyCertificateError", "(", "cert", "*", "x509", ".", "Certificate", ")", "(", "revoked", ",", "ok", "bool", ",", "err", "error", ")", "{", "if", "!", "time", ".", "Now", "(", ")", ".", "Before", "(", "cert", ".", "NotAfter", ")", "{", "msg", ":=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "cert", ".", "NotAfter", ")", "\n", "log", ".", "Info", "(", "msg", ")", "\n", "return", "true", ",", "true", ",", "fmt", ".", "Errorf", "(", "msg", ")", "\n", "}", "else", "if", "!", "time", ".", "Now", "(", ")", ".", "After", "(", "cert", ".", "NotBefore", ")", "{", "msg", ":=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "cert", ".", "NotBefore", ")", "\n", "log", ".", "Info", "(", "msg", ")", "\n", "return", "true", ",", "true", ",", "fmt", ".", "Errorf", "(", "msg", ")", "\n", "}", "\n", "return", "revCheck", "(", "cert", ")", "\n", "}" ]

[ "VerifyCertificateError", "ensures", "that", "the", "certificate", "passed", "in", "hasn", "t", "expired", "and", "checks", "the", "CRL", "for", "the", "server", "." ]

[ "func", "ParseCertificate", "(", "cert", "*", "x509", ".", "Certificate", ")", "*", "Certificate", "{", "c", ":=", "&", "Certificate", "{", "RawPEM", ":", "string", "(", "helpers", ".", "EncodeCertificatePEM", "(", "cert", ")", ")", ",", "SignatureAlgorithm", ":", "helpers", ".", "SignatureString", "(", "cert", ".", "SignatureAlgorithm", ")", ",", "NotBefore", ":", "cert", ".", "NotBefore", ",", "NotAfter", ":", "cert", ".", "NotAfter", ",", "Subject", ":", "ParseName", "(", "cert", ".", "Subject", ")", ",", "Issuer", ":", "ParseName", "(", "cert", ".", "Issuer", ")", ",", "SANs", ":", "cert", ".", "DNSNames", ",", "AKI", ":", "formatKeyID", "(", "cert", ".", "AuthorityKeyId", ")", ",", "SKI", ":", "formatKeyID", "(", "cert", ".", "SubjectKeyId", ")", ",", "SerialNumber", ":", "cert", ".", "SerialNumber", ".", "String", "(", ")", ",", "}", "\n", "for", "_", ",", "ip", ":=", "range", "cert", ".", "IPAddresses", "{", "c", ".", "SANs", "=", "append", "(", "c", ".", "SANs", ",", "ip", ".", "String", "(", ")", ")", "\n", "}", "\n", "return", "c", "\n", "}" ]

[ "ParseCertificate", "parses", "an", "x509", "certificate", "." ]

[ "func", "ParseCertificateFile", "(", "certFile", "string", ")", "(", "*", "Certificate", ",", "error", ")", "{", "certPEM", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "certFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "ParseCertificatePEM", "(", "certPEM", ")", "\n", "}" ]

[ "ParseCertificateFile", "parses", "x509", "certificate", "file", "." ]

[ "func", "ParseCertificatePEM", "(", "certPEM", "[", "]", "byte", ")", "(", "*", "Certificate", ",", "error", ")", "{", "cert", ",", "err", ":=", "helpers", ".", "ParseCertificatePEM", "(", "certPEM", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "ParseCertificate", "(", "cert", ")", ",", "nil", "\n", "}" ]

[ "ParseCertificatePEM", "parses", "an", "x509", "certificate", "PEM", "." ]

[ "func", "ParseCSRPEM", "(", "csrPEM", "[", "]", "byte", ")", "(", "*", "x509", ".", "CertificateRequest", ",", "error", ")", "{", "csrObject", ",", "err", ":=", "helpers", ".", "ParseCSRPEM", "(", "csrPEM", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "csrObject", ",", "nil", "\n", "}" ]

[ "ParseCSRPEM", "uses", "the", "helper", "to", "parse", "an", "x509", "CSR", "PEM", "." ]

[ "func", "ParseCSRFile", "(", "csrFile", "string", ")", "(", "*", "x509", ".", "CertificateRequest", ",", "error", ")", "{", "csrPEM", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "csrFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "ParseCSRPEM", "(", "csrPEM", ")", "\n", "}" ]

[ "ParseCSRFile", "uses", "the", "helper", "to", "parse", "an", "x509", "CSR", "PEM", "file", "." ]

[ "func", "ParseCertificateDomain", "(", "domain", "string", ")", "(", "cert", "*", "Certificate", ",", "err", "error", ")", "{", "var", "host", ",", "port", "string", "\n", "if", "host", ",", "port", ",", "err", "=", "net", ".", "SplitHostPort", "(", "domain", ")", ";", "err", "!=", "nil", "{", "host", "=", "domain", "\n", "port", "=", "\"", "\"", "\n", "}", "\n\n", "var", "conn", "*", "tls", ".", "Conn", "\n", "conn", ",", "err", "=", "tls", ".", "DialWithDialer", "(", "&", "net", ".", "Dialer", "{", "Timeout", ":", "10", "*", "time", ".", "Second", "}", ",", "\"", "\"", ",", "net", ".", "JoinHostPort", "(", "host", ",", "port", ")", ",", "&", "tls", ".", "Config", "{", "InsecureSkipVerify", ":", "true", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "defer", "conn", ".", "Close", "(", ")", "\n\n", "if", "len", "(", "conn", ".", "ConnectionState", "(", ")", ".", "PeerCertificates", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "cert", "=", "ParseCertificate", "(", "conn", ".", "ConnectionState", "(", ")", ".", "PeerCertificates", "[", "0", "]", ")", "\n", "return", "\n", "}" ]

[ "ParseCertificateDomain", "parses", "the", "certificate", "served", "by", "the", "given", "domain", "." ]

[ "func", "ParseSerialNumber", "(", "serial", ",", "aki", "string", ",", "dbAccessor", "certdb", ".", "Accessor", ")", "(", "*", "Certificate", ",", "error", ")", "{", "normalizedAKI", ":=", "strings", ".", "ToLower", "(", "aki", ")", "\n", "normalizedAKI", "=", "strings", ".", "Replace", "(", "normalizedAKI", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n\n", "certificates", ",", "err", ":=", "dbAccessor", ".", "GetCertificate", "(", "serial", ",", "normalizedAKI", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "certificates", ")", "<", "1", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "len", "(", "certificates", ")", ">", "1", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "ParseCertificatePEM", "(", "[", "]", "byte", "(", "certificates", "[", "0", "]", ".", "PEM", ")", ")", "\n", "}" ]

[ "ParseSerialNumber", "parses", "the", "serial", "number", "and", "does", "a", "lookup", "in", "the", "data", "storage", "used", "for", "certificates", ".", "The", "authority", "key", "is", "required", "for", "the", "lookup", "to", "work", "and", "must", "be", "passed", "as", "a", "hex", "string", "." ]

[ "func", "NewHandler", "(", "s", "signer", ".", "Signer", ")", "(", "http", ".", "Handler", ",", "error", ")", "{", "return", "&", "api", ".", "HTTPHandler", "{", "Handler", ":", "&", "Handler", "{", "sign", ":", "s", ",", "}", ",", "Methods", ":", "[", "]", "string", "{", "\"", "\"", "}", ",", "}", ",", "nil", "\n", "}" ]

[ "NewHandler", "creates", "a", "new", "handler", "to", "serve", "information", "on", "the", "CA", "s", "certificates", "taking", "a", "signer", "to", "use", "." ]

[ "func", "(", "h", "*", "Handler", ")", "Handle", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "error", "{", "req", ":=", "new", "(", "info", ".", "Req", ")", "\n", "body", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "r", ".", "Body", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "errors", ".", "NewBadRequest", "(", "err", ")", "\n", "}", "\n", "r", ".", "Body", ".", "Close", "(", ")", "\n\n", "err", "=", "json", ".", "Unmarshal", "(", "body", ",", "req", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "errors", ".", "NewBadRequest", "(", "err", ")", "\n", "}", "\n\n", "resp", ",", "err", ":=", "h", ".", "sign", ".", "Info", "(", "*", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "response", ":=", "api", ".", "NewSuccessResponse", "(", "resp", ")", "\n", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "enc", ":=", "json", ".", "NewEncoder", "(", "w", ")", "\n", "return", "enc", ".", "Encode", "(", "response", ")", "\n", "}" ]

[ "Handle", "listens", "for", "incoming", "requests", "for", "CA", "information", "and", "returns", "a", "list", "containing", "information", "on", "each", "root", "certificate", "." ]

[ "func", "NewMultiHandler", "(", "signers", "map", "[", "string", "]", "signer", ".", "Signer", ",", "defaultLabel", "string", ")", "(", "http", ".", "Handler", ",", "error", ")", "{", "return", "&", "api", ".", "HTTPHandler", "{", "Handler", ":", "&", "MultiHandler", "{", "signers", ":", "signers", ",", "defaultLabel", ":", "defaultLabel", ",", "}", ",", "Methods", ":", "[", "]", "string", "{", "\"", "\"", "}", ",", "}", ",", "nil", "\n", "}" ]

[ "NewMultiHandler", "constructs", "a", "MultiHandler", "from", "a", "mapping", "of", "labels", "to", "signers", "and", "the", "default", "label", "." ]

[ "func", "(", "h", "*", "MultiHandler", ")", "Handle", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "error", "{", "req", ":=", "new", "(", "info", ".", "Req", ")", "\n", "body", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "r", ".", "Body", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "errors", ".", "NewBadRequest", "(", "err", ")", "\n", "}", "\n", "r", ".", "Body", ".", "Close", "(", ")", "\n\n", "err", "=", "json", ".", "Unmarshal", "(", "body", ",", "req", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "errors", ".", "NewBadRequest", "(", "err", ")", "\n", "}", "\n\n", "log", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "req", ".", "Label", "==", "\"", "\"", "{", "req", ".", "Label", "=", "h", ".", "defaultLabel", "\n", "}", "\n\n", "if", "_", ",", "ok", ":=", "h", ".", "signers", "[", "req", ".", "Label", "]", ";", "!", "ok", "{", "log", ".", "Warningf", "(", "\"", "\"", ")", "\n", "return", "errors", ".", "NewBadRequestString", "(", "\"", "\"", ")", "\n", "}", "\n\n", "log", ".", "Debug", "(", "\"", "\"", ")", "\n", "resp", ",", "err", ":=", "h", ".", "signers", "[", "req", ".", "Label", "]", ".", "Info", "(", "*", "req", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Infof", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "response", ":=", "api", ".", "NewSuccessResponse", "(", "resp", ")", "\n", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "enc", ":=", "json", ".", "NewEncoder", "(", "w", ")", "\n", "return", "enc", ".", "Encode", "(", "response", ")", "\n", "}" ]

[ "Handle", "accepts", "client", "information", "requests", "and", "uses", "the", "label", "to", "look", "up", "the", "signer", "whose", "public", "certificate", "should", "be", "retrieved", ".", "If", "the", "label", "is", "empty", "the", "default", "label", "is", "used", "." ]

[ "func", "ReasonStringToCode", "(", "reason", "string", ")", "(", "reasonCode", "int", ",", "err", "error", ")", "{", "// default to 0", "if", "reason", "==", "\"", "\"", "{", "return", "0", ",", "nil", "\n", "}", "\n\n", "reasonCode", ",", "present", ":=", "revocationReasonCodes", "[", "strings", ".", "ToLower", "(", "reason", ")", "]", "\n", "if", "!", "present", "{", "reasonCode", ",", "err", "=", "strconv", ".", "Atoi", "(", "reason", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "reasonCode", ">=", "ocsp", ".", "AACompromise", "||", "reasonCode", "<=", "ocsp", ".", "Unspecified", "{", "return", "0", ",", "cferr", ".", "New", "(", "cferr", ".", "OCSPError", ",", "cferr", ".", "InvalidStatus", ")", "\n", "}", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "ReasonStringToCode", "tries", "to", "convert", "a", "reason", "string", "to", "an", "integer", "code" ]

[ "func", "NewSignerFromFile", "(", "issuerFile", ",", "responderFile", ",", "keyFile", "string", ",", "interval", "time", ".", "Duration", ")", "(", "Signer", ",", "error", ")", "{", "log", ".", "Debug", "(", "\"", "\"", ",", "issuerFile", ")", "\n", "issuerBytes", ",", "err", ":=", "helpers", ".", "ReadBytes", "(", "issuerFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "log", ".", "Debug", "(", "\"", "\"", ",", "responderFile", ")", "\n", "responderBytes", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "responderFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "log", ".", "Debug", "(", "\"", "\"", ",", "keyFile", ")", "\n", "keyBytes", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "keyFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "cferr", ".", "Wrap", "(", "cferr", ".", "CertificateError", ",", "cferr", ".", "ReadFailed", ",", "err", ")", "\n", "}", "\n\n", "issuerCert", ",", "err", ":=", "helpers", ".", "ParseCertificatePEM", "(", "issuerBytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "responderCert", ",", "err", ":=", "helpers", ".", "ParseCertificatePEM", "(", "responderBytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "key", ",", "err", ":=", "helpers", ".", "ParsePrivateKeyPEM", "(", "keyBytes", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Debug", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "NewSigner", "(", "issuerCert", ",", "responderCert", ",", "key", ",", "interval", ")", "\n", "}" ]

[ "NewSignerFromFile", "reads", "the", "issuer", "cert", "the", "responder", "cert", "and", "the", "responder", "key", "from", "PEM", "files", "and", "takes", "an", "interval", "in", "seconds" ]

[ "func", "NewSigner", "(", "issuer", ",", "responder", "*", "x509", ".", "Certificate", ",", "key", "crypto", ".", "Signer", ",", "interval", "time", ".", "Duration", ")", "(", "Signer", ",", "error", ")", "{", "return", "&", "StandardSigner", "{", "issuer", ":", "issuer", ",", "responder", ":", "responder", ",", "key", ":", "key", ",", "interval", ":", "interval", ",", "}", ",", "nil", "\n", "}" ]

[ "NewSigner", "simply", "constructs", "a", "new", "StandardSigner", "object", "from", "the", "inputs", "taking", "the", "interval", "in", "seconds" ]

[ "func", "(", "s", "StandardSigner", ")", "Sign", "(", "req", "SignRequest", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "req", ".", "Certificate", "==", "nil", "{", "return", "nil", ",", "cferr", ".", "New", "(", "cferr", ".", "OCSPError", ",", "cferr", ".", "ReadFailed", ")", "\n", "}", "\n\n", "// Verify that req.Certificate is issued under s.issuer", "if", "bytes", ".", "Compare", "(", "req", ".", "Certificate", ".", "RawIssuer", ",", "s", ".", "issuer", ".", "RawSubject", ")", "!=", "0", "{", "return", "nil", ",", "cferr", ".", "New", "(", "cferr", ".", "OCSPError", ",", "cferr", ".", "IssuerMismatch", ")", "\n", "}", "\n\n", "err", ":=", "req", ".", "Certificate", ".", "CheckSignatureFrom", "(", "s", ".", "issuer", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "cferr", ".", "Wrap", "(", "cferr", ".", "OCSPError", ",", "cferr", ".", "VerifyFailed", ",", "err", ")", "\n", "}", "\n\n", "var", "thisUpdate", ",", "nextUpdate", "time", ".", "Time", "\n", "if", "req", ".", "ThisUpdate", "!=", "nil", "{", "thisUpdate", "=", "*", "req", ".", "ThisUpdate", "\n", "}", "else", "{", "// Round thisUpdate times down to the nearest hour", "thisUpdate", "=", "time", ".", "Now", "(", ")", ".", "Truncate", "(", "time", ".", "Hour", ")", "\n", "}", "\n", "if", "req", ".", "NextUpdate", "!=", "nil", "{", "nextUpdate", "=", "*", "req", ".", "NextUpdate", "\n", "}", "else", "{", "nextUpdate", "=", "thisUpdate", ".", "Add", "(", "s", ".", "interval", ")", "\n", "}", "\n\n", "status", ",", "ok", ":=", "StatusCode", "[", "req", ".", "Status", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "cferr", ".", "New", "(", "cferr", ".", "OCSPError", ",", "cferr", ".", "InvalidStatus", ")", "\n", "}", "\n\n", "// If the OCSP responder is the same as the issuer, there is no need to", "// include any certificate in the OCSP response, which decreases the byte size", "// of OCSP responses dramatically.", "certificate", ":=", "s", ".", "responder", "\n", "if", "s", ".", "issuer", "==", "s", ".", "responder", "||", "bytes", ".", "Equal", "(", "s", ".", "issuer", ".", "Raw", ",", "s", ".", "responder", ".", "Raw", ")", "{", "certificate", "=", "nil", "\n", "}", "\n\n", "template", ":=", "ocsp", ".", "Response", "{", "Status", ":", "status", ",", "SerialNumber", ":", "req", ".", "Certificate", ".", "SerialNumber", ",", "ThisUpdate", ":", "thisUpdate", ",", "NextUpdate", ":", "nextUpdate", ",", "Certificate", ":", "certificate", ",", "ExtraExtensions", ":", "req", ".", "Extensions", ",", "IssuerHash", ":", "req", ".", "IssuerHash", ",", "}", "\n\n", "if", "status", "==", "ocsp", ".", "Revoked", "{", "template", ".", "RevokedAt", "=", "req", ".", "RevokedAt", "\n", "template", ".", "RevocationReason", "=", "req", ".", "Reason", "\n", "}", "\n\n", "return", "ocsp", ".", "CreateResponse", "(", "s", ".", "issuer", ",", "s", ".", "responder", ",", "template", ",", "s", ".", "key", ")", "\n", "}" ]

[ "Sign", "is", "used", "with", "an", "OCSP", "signer", "to", "request", "the", "issuance", "of", "an", "OCSP", "response", "." ]

[ "func", "(", "e", "*", "Error", ")", "Error", "(", ")", "string", "{", "marshaled", ",", "err", ":=", "json", ".", "Marshal", "(", "e", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "string", "(", "marshaled", ")", "\n\n", "}" ]

[ "The", "error", "interface", "implementation", "which", "formats", "to", "a", "JSON", "object", "string", "." ]

[ "func", "Wrap", "(", "category", "Category", ",", "reason", "Reason", ",", "err", "error", ")", "*", "Error", "{", "errorCode", ":=", "int", "(", "category", ")", "+", "int", "(", "reason", ")", "\n", "if", "err", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// do not double wrap a error", "switch", "err", ".", "(", "type", ")", "{", "case", "*", "Error", ":", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "switch", "category", "{", "case", "CertificateError", ":", "// given VerifyFailed , report the status with more detailed status code", "// for some certificate errors we care.", "if", "reason", "==", "VerifyFailed", "{", "switch", "errorType", ":=", "err", ".", "(", "type", ")", "{", "case", "x509", ".", "CertificateInvalidError", ":", "errorCode", "+=", "certificateInvalid", "+", "int", "(", "errorType", ".", "Reason", ")", "\n", "case", "x509", ".", "UnknownAuthorityError", ":", "errorCode", "+=", "unknownAuthority", "\n", "}", "\n", "}", "\n", "case", "PrivateKeyError", ",", "IntermediatesError", ",", "RootError", ",", "PolicyError", ",", "DialError", ",", "APIClientError", ",", "CSRError", ",", "CTError", ",", "CertStoreError", ",", "OCSPError", ":", "// no-op, just use the error", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "category", ")", ")", "\n", "}", "\n\n", "return", "&", "Error", "{", "ErrorCode", ":", "errorCode", ",", "Message", ":", "err", ".", "Error", "(", ")", "}", "\n\n", "}" ]

[ "Wrap", "returns", "an", "error", "that", "contains", "the", "given", "error", "and", "an", "error", "code", "derived", "from", "the", "given", "category", "reason", "and", "the", "error", ".", "Currently", "to", "avoid", "confusion", "it", "is", "not", "allowed", "to", "create", "an", "error", "of", "category", "Success" ]

[ "func", "multiscan", "(", "host", "string", ",", "scan", "func", "(", "string", ")", "(", "Grade", ",", "Output", ",", "error", ")", ")", "(", "grade", "Grade", ",", "output", "Output", ",", "err", "error", ")", "{", "domain", ",", "port", ",", "_", ":=", "net", ".", "SplitHostPort", "(", "host", ")", "\n", "var", "addrs", "[", "]", "string", "\n", "addrs", ",", "err", "=", "net", ".", "LookupHost", "(", "domain", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "grade", "=", "Good", "\n", "out", ":=", "make", "(", "map", "[", "string", "]", "Output", ")", "\n\n", "for", "_", ",", "addr", ":=", "range", "addrs", "{", "var", "g", "Grade", "\n", "var", "o", "Output", "\n\n", "g", ",", "o", ",", "err", "=", "scan", "(", "net", ".", "JoinHostPort", "(", "addr", ",", "port", ")", ")", "\n", "if", "err", "!=", "nil", "{", "grade", "=", "Bad", "\n", "return", "\n", "}", "\n\n", "if", "g", "<", "grade", "{", "grade", "=", "g", "\n", "}", "\n\n", "out", "[", "addr", "]", "=", "o", "\n", "}", "\n", "output", "=", "out", "\n", "return", "\n", "}" ]

[ "multiscan", "scans", "all", "DNS", "addresses", "returned", "for", "the", "host", "returning", "the", "lowest", "grade", "and", "the", "concatenation", "of", "all", "the", "output", "." ]

[ "func", "(", "s", "*", "Scanner", ")", "Scan", "(", "addr", ",", "hostname", "string", ")", "(", "Grade", ",", "Output", ",", "error", ")", "{", "grade", ",", "output", ",", "err", ":=", "s", ".", "scan", "(", "addr", ",", "hostname", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "grade", ",", "output", ",", "err", "\n", "}", "\n", "return", "grade", ",", "output", ",", "err", "\n", "}" ]

[ "Scan", "performs", "the", "scan", "to", "be", "performed", "on", "the", "given", "host", "and", "stores", "its", "result", "." ]

[ "func", "(", "fs", "FamilySet", ")", "RunScans", "(", "host", ",", "ip", ",", "family", ",", "scanner", "string", ",", "timeout", "time", ".", "Duration", ")", "(", "map", "[", "string", "]", "FamilyResult", ",", "error", ")", "{", "hostname", ",", "port", ",", "err", ":=", "net", ".", "SplitHostPort", "(", "host", ")", "\n", "if", "err", "!=", "nil", "{", "hostname", "=", "host", "\n", "port", "=", "\"", "\"", "\n", "}", "\n\n", "var", "addr", "string", "\n", "if", "net", ".", "ParseIP", "(", "ip", ")", "!=", "nil", "{", "addr", "=", "net", ".", "JoinHostPort", "(", "ip", ",", "port", ")", "\n", "}", "else", "{", "addr", "=", "net", ".", "JoinHostPort", "(", "hostname", ",", "port", ")", "\n", "}", "\n\n", "familyRegexp", ",", "err", ":=", "regexp", ".", "Compile", "(", "family", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "scannerRegexp", ",", "err", ":=", "regexp", ".", "Compile", "(", "scanner", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "ctx", ":=", "newContext", "(", "addr", ",", "hostname", ",", "familyRegexp", ",", "scannerRegexp", ",", "len", "(", "fs", ")", ")", "\n", "for", "familyName", ",", "family", ":=", "range", "fs", "{", "familyCtx", ":=", "ctx", ".", "newfamilyContext", "(", "len", "(", "family", ".", "Scanners", ")", ")", "\n", "for", "scannerName", ",", "scanner", ":=", "range", "family", ".", "Scanners", "{", "go", "familyCtx", ".", "runScanner", "(", "familyName", ",", "scannerName", ",", "scanner", ")", "\n", "}", "\n", "}", "\n\n", "return", "ctx", ".", "copyResults", "(", "timeout", ")", ",", "nil", "\n", "}" ]

[ "RunScans", "iterates", "over", "AllScans", "running", "each", "scan", "that", "matches", "the", "family", "and", "scanner", "regular", "expressions", "concurrently", "." ]

[ "func", "LoadRootCAs", "(", "caBundleFile", "string", ")", "(", "err", "error", ")", "{", "if", "caBundleFile", "!=", "\"", "\"", "{", "log", ".", "Debugf", "(", "\"", "\"", ",", "caBundleFile", ")", "\n", "RootCAs", ",", "err", "=", "helpers", ".", "LoadPEMCertPool", "(", "caBundleFile", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "LoadRootCAs", "loads", "the", "default", "root", "certificate", "authorities", "from", "file", "." ]

[ "func", "NewSigner", "(", "policy", "*", "config", ".", "Signing", ")", "(", "*", "Signer", ",", "error", ")", "{", "if", "policy", "!=", "nil", "{", "if", "!", "policy", ".", "Valid", "(", ")", "{", "return", "nil", ",", "cferr", ".", "New", "(", "cferr", ".", "PolicyError", ",", "cferr", ".", "InvalidPolicy", ")", "\n", "}", "\n", "return", "&", "Signer", "{", "policy", ":", "policy", "}", ",", "nil", "\n", "}", "\n\n", "return", "nil", ",", "cferr", ".", "New", "(", "cferr", ".", "PolicyError", ",", "cferr", ".", "InvalidPolicy", ")", "\n", "}" ]

[ "NewSigner", "creates", "a", "new", "remote", "Signer", "directly", "from", "a", "signing", "policy", "." ]

[ "func", "(", "s", "*", "Signer", ")", "Sign", "(", "req", "signer", ".", "SignRequest", ")", "(", "cert", "[", "]", "byte", ",", "err", "error", ")", "{", "resp", ",", "err", ":=", "s", ".", "remoteOp", "(", "req", ",", "req", ".", "Profile", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "cert", ",", "ok", ":=", "resp", ".", "(", "[", "]", "byte", ")", ";", "ok", "{", "return", "cert", ",", "nil", "\n", "}", "\n", "return", "\n", "}" ]

[ "Sign", "sends", "a", "signature", "request", "to", "the", "remote", "CFSSL", "server", "receiving", "a", "signed", "certificate", "or", "an", "error", "in", "response", ".", "The", "hostname", "csr", "and", "profileName", "are", "used", "as", "with", "a", "local", "signing", "operation", "and", "the", "label", "is", "used", "to", "select", "a", "signing", "root", "in", "a", "multi", "-", "root", "CA", "." ]

[ "func", "(", "s", "*", "Signer", ")", "Info", "(", "req", "info", ".", "Req", ")", "(", "resp", "*", "info", ".", "Resp", ",", "err", "error", ")", "{", "respInterface", ",", "err", ":=", "s", ".", "remoteOp", "(", "req", ",", "req", ".", "Profile", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "resp", ",", "ok", ":=", "respInterface", ".", "(", "*", "info", ".", "Resp", ")", ";", "ok", "{", "return", "resp", ",", "nil", "\n", "}", "\n", "return", "\n", "}" ]

[ "Info", "sends", "an", "info", "request", "to", "the", "remote", "CFSSL", "server", "receiving", "an", "Resp", "struct", "or", "an", "error", "in", "response", "." ]

[ "func", "(", "s", "*", "Signer", ")", "remoteOp", "(", "req", "interface", "{", "}", ",", "profile", ",", "target", "string", ")", "(", "resp", "interface", "{", "}", ",", "err", "error", ")", "{", "jsonData", ",", "err", ":=", "json", ".", "Marshal", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "cferr", ".", "Wrap", "(", "cferr", ".", "APIClientError", ",", "cferr", ".", "JSONError", ",", "err", ")", "\n", "}", "\n\n", "p", ",", "err", ":=", "signer", ".", "Profile", "(", "s", ",", "profile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "server", ":=", "client", ".", "NewServerTLS", "(", "p", ".", "RemoteServer", ",", "helpers", ".", "CreateTLSConfig", "(", "p", ".", "RemoteCAs", ",", "p", ".", "ClientCert", ")", ")", "\n", "if", "server", "==", "nil", "{", "return", "nil", ",", "cferr", ".", "Wrap", "(", "cferr", ".", "PolicyError", ",", "cferr", ".", "InvalidRequest", ",", "errors", ".", "New", "(", "\"", "\"", ")", ")", "\n", "}", "\n\n", "server", ".", "SetReqModifier", "(", "s", ".", "reqModifier", ")", "\n\n", "// There's no auth provider for the \"info\" method", "if", "target", "==", "\"", "\"", "{", "resp", ",", "err", "=", "server", ".", "Info", "(", "jsonData", ")", "\n", "}", "else", "if", "p", ".", "RemoteProvider", "!=", "nil", "{", "resp", ",", "err", "=", "server", ".", "AuthSign", "(", "jsonData", ",", "nil", ",", "p", ".", "RemoteProvider", ")", "\n", "}", "else", "{", "resp", ",", "err", "=", "server", ".", "Sign", "(", "jsonData", ")", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "Helper", "function", "to", "perform", "a", "remote", "sign", "or", "info", "request", "." ]

[ "func", "fileBackedSigner", "(", "root", "*", "Root", ",", "policy", "*", "config", ".", "Signing", ")", "(", "signer", ".", "Signer", ",", "bool", ",", "error", ")", "{", "keyFile", ":=", "root", ".", "Config", "[", "\"", "\"", "]", "\n", "certFile", ":=", "root", ".", "Config", "[", "\"", "\"", "]", "\n\n", "if", "keyFile", "==", "\"", "\"", "{", "return", "nil", ",", "false", ",", "nil", "\n", "}", "\n\n", "signer", ",", "err", ":=", "local", ".", "NewSignerFromFile", "(", "certFile", ",", "keyFile", ",", "policy", ")", "\n", "return", "signer", ",", "true", ",", "err", "\n", "}" ]

[ "fileBackedSigner", "determines", "whether", "a", "file", "-", "backed", "local", "signer", "is", "supported", "." ]

[ "func", "(", "s", "*", "Signer", ")", "getMatchingProfile", "(", "profile", "string", ")", "(", "*", "config", ".", "SigningProfile", ",", "error", ")", "{", "if", "profile", "==", "\"", "\"", "{", "return", "s", ".", "policy", ".", "Default", ",", "nil", "\n", "}", "\n\n", "for", "p", ",", "signingProfile", ":=", "range", "s", ".", "policy", ".", "Profiles", "{", "if", "p", "==", "profile", "{", "return", "signingProfile", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "nil", ",", "cferr", ".", "New", "(", "cferr", ".", "PolicyError", ",", "cferr", ".", "UnknownProfile", ")", "\n", "}" ]

[ "getMatchingProfile", "returns", "the", "SigningProfile", "that", "matches", "the", "profile", "passed", ".", "if", "an", "empty", "profile", "string", "is", "passed", "it", "returns", "the", "default", "profile", "." ]

[ "func", "(", "s", "*", "Signer", ")", "Sign", "(", "req", "signer", ".", "SignRequest", ")", "(", "cert", "[", "]", "byte", ",", "err", "error", ")", "{", "profile", ",", "err", ":=", "s", ".", "getMatchingProfile", "(", "req", ".", "Profile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "cert", ",", "err", "\n", "}", "\n\n", "if", "profile", ".", "RemoteServer", "!=", "\"", "\"", "{", "return", "s", ".", "remote", ".", "Sign", "(", "req", ")", "\n", "}", "\n", "return", "s", ".", "local", ".", "Sign", "(", "req", ")", "\n\n", "}" ]

[ "Sign", "sends", "a", "signature", "request", "to", "either", "the", "remote", "or", "local", "signer", "receiving", "a", "signed", "certificate", "or", "an", "error", "in", "response", "." ]

[ "func", "(", "s", "*", "Signer", ")", "Info", "(", "req", "info", ".", "Req", ")", "(", "resp", "*", "info", ".", "Resp", ",", "err", "error", ")", "{", "profile", ",", "err", ":=", "s", ".", "getMatchingProfile", "(", "req", ".", "Profile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "resp", ",", "err", "\n", "}", "\n\n", "if", "profile", ".", "RemoteServer", "!=", "\"", "\"", "{", "return", "s", ".", "remote", ".", "Info", "(", "req", ")", "\n", "}", "\n", "return", "s", ".", "local", ".", "Info", "(", "req", ")", "\n\n", "}" ]

[ "Info", "sends", "an", "info", "request", "to", "the", "remote", "or", "local", "CFSSL", "server", "receiving", "an", "Resp", "struct", "or", "an", "error", "in", "response", "." ]

[ "func", "(", "s", "*", "Signer", ")", "SetDBAccessor", "(", "dba", "certdb", ".", "Accessor", ")", "{", "s", ".", "local", ".", "SetDBAccessor", "(", "dba", ")", "\n", "}" ]

[ "SetDBAccessor", "sets", "the", "signer", "s", "cert", "db", "accessor", "." ]

[ "func", "(", "s", "*", "Signer", ")", "SigAlgo", "(", ")", "x509", ".", "SignatureAlgorithm", "{", "if", "s", ".", "local", "!=", "nil", "{", "return", "s", ".", "local", ".", "SigAlgo", "(", ")", "\n", "}", "\n\n", "// currently remote.SigAlgo just returns", "// x509.UnknownSignatureAlgorithm.", "return", "s", ".", "remote", ".", "SigAlgo", "(", ")", "\n", "}" ]

[ "SigAlgo", "returns", "the", "RSA", "signer", "s", "signature", "algorithm", "." ]

[ "func", "macSHA1", "(", "version", "uint16", ",", "key", "[", "]", "byte", ")", "macFunction", "{", "if", "version", "==", "VersionSSL30", "{", "mac", ":=", "ssl30MAC", "{", "h", ":", "sha1", ".", "New", "(", ")", ",", "key", ":", "make", "(", "[", "]", "byte", ",", "len", "(", "key", ")", ")", ",", "}", "\n", "copy", "(", "mac", ".", "key", ",", "key", ")", "\n", "return", "mac", "\n", "}", "\n", "return", "tls10MAC", "{", "hmac", ".", "New", "(", "sha1", ".", "New", ",", "key", ")", "}", "\n", "}" ]

[ "macSHA1", "returns", "a", "macFunction", "for", "the", "given", "protocol", "version", "." ]

[ "func", "mutualCipherSuite", "(", "have", "[", "]", "uint16", ",", "want", "uint16", ")", "*", "cipherSuite", "{", "for", "_", ",", "id", ":=", "range", "have", "{", "if", "id", "==", "want", "{", "for", "_", ",", "suite", ":=", "range", "cipherSuites", "{", "if", "suite", ".", "id", "==", "want", "{", "return", "suite", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "mutualCipherSuite", "returns", "a", "cipherSuite", "given", "a", "list", "of", "supported", "ciphersuites", "and", "the", "id", "requested", "by", "the", "peer", "." ]

[ "func", "(", "priv", "*", "PrivateKey", ")", "Validate", "(", ")", "error", "{", "if", "err", ":=", "checkPub", "(", "&", "priv", ".", "PublicKey", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Check that Πprimes == n.", "modulus", ":=", "new", "(", "big", ".", "Int", ")", ".", "Set", "(", "bigOne", ")", "\n", "for", "_", ",", "prime", ":=", "range", "priv", ".", "Primes", "{", "// Any primes ≤ 1 will cause divide-by-zero panics later.", "if", "prime", ".", "Cmp", "(", "bigOne", ")", "<=", "0", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "modulus", ".", "Mul", "(", "modulus", ",", "prime", ")", "\n", "}", "\n", "if", "modulus", ".", "Cmp", "(", "priv", ".", "N", ")", "!=", "0", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Check that de ≡ 1 mod p-1, for each prime.", "// This implies that e is coprime to each p-1 as e has a multiplicative", "// inverse. Therefore e is coprime to lcm(p-1,q-1,r-1,...) =", "// exponent(ℤ/nℤ). It also implies that a^de ≡ a mod p as a^(p-1) ≡ 1", "// mod p. Thus a^de ≡ a mod n for all a coprime to n, as required.", "congruence", ":=", "new", "(", "big", ".", "Int", ")", "\n", "de", ":=", "new", "(", "big", ".", "Int", ")", ".", "SetInt64", "(", "int64", "(", "priv", ".", "E", ")", ")", "\n", "de", ".", "Mul", "(", "de", ",", "priv", ".", "D", ")", "\n", "for", "_", ",", "prime", ":=", "range", "priv", ".", "Primes", "{", "pminus1", ":=", "new", "(", "big", ".", "Int", ")", ".", "Sub", "(", "prime", ",", "bigOne", ")", "\n", "congruence", ".", "Mod", "(", "de", ",", "pminus1", ")", "\n", "if", "congruence", ".", "Cmp", "(", "bigOne", ")", "!=", "0", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "performs", "basic", "sanity", "checks", "on", "the", "key", ".", "It", "returns", "nil", "if", "the", "key", "is", "valid", "or", "else", "an", "error", "describing", "a", "problem", "." ]

[ "func", "incCounter", "(", "c", "*", "[", "4", "]", "byte", ")", "{", "if", "c", "[", "3", "]", "++", ";", "c", "[", "3", "]", "!=", "0", "{", "return", "\n", "}", "\n", "if", "c", "[", "2", "]", "++", ";", "c", "[", "2", "]", "!=", "0", "{", "return", "\n", "}", "\n", "if", "c", "[", "1", "]", "++", ";", "c", "[", "1", "]", "!=", "0", "{", "return", "\n", "}", "\n", "c", "[", "0", "]", "++", "\n", "}" ]

[ "incCounter", "increments", "a", "four", "byte", "big", "-", "endian", "counter", "." ]

[ "func", "(", "priv", "*", "PrivateKey", ")", "Precompute", "(", ")", "{", "if", "priv", ".", "Precomputed", ".", "Dp", "!=", "nil", "{", "return", "\n", "}", "\n\n", "priv", ".", "Precomputed", ".", "Dp", "=", "new", "(", "big", ".", "Int", ")", ".", "Sub", "(", "priv", ".", "Primes", "[", "0", "]", ",", "bigOne", ")", "\n", "priv", ".", "Precomputed", ".", "Dp", ".", "Mod", "(", "priv", ".", "D", ",", "priv", ".", "Precomputed", ".", "Dp", ")", "\n\n", "priv", ".", "Precomputed", ".", "Dq", "=", "new", "(", "big", ".", "Int", ")", ".", "Sub", "(", "priv", ".", "Primes", "[", "1", "]", ",", "bigOne", ")", "\n", "priv", ".", "Precomputed", ".", "Dq", ".", "Mod", "(", "priv", ".", "D", ",", "priv", ".", "Precomputed", ".", "Dq", ")", "\n\n", "priv", ".", "Precomputed", ".", "Qinv", "=", "new", "(", "big", ".", "Int", ")", ".", "ModInverse", "(", "priv", ".", "Primes", "[", "1", "]", ",", "priv", ".", "Primes", "[", "0", "]", ")", "\n\n", "r", ":=", "new", "(", "big", ".", "Int", ")", ".", "Mul", "(", "priv", ".", "Primes", "[", "0", "]", ",", "priv", ".", "Primes", "[", "1", "]", ")", "\n", "priv", ".", "Precomputed", ".", "CRTValues", "=", "make", "(", "[", "]", "CRTValue", ",", "len", "(", "priv", ".", "Primes", ")", "-", "2", ")", "\n", "for", "i", ":=", "2", ";", "i", "<", "len", "(", "priv", ".", "Primes", ")", ";", "i", "++", "{", "prime", ":=", "priv", ".", "Primes", "[", "i", "]", "\n", "values", ":=", "&", "priv", ".", "Precomputed", ".", "CRTValues", "[", "i", "-", "2", "]", "\n\n", "values", ".", "Exp", "=", "new", "(", "big", ".", "Int", ")", ".", "Sub", "(", "prime", ",", "bigOne", ")", "\n", "values", ".", "Exp", ".", "Mod", "(", "priv", ".", "D", ",", "values", ".", "Exp", ")", "\n\n", "values", ".", "R", "=", "new", "(", "big", ".", "Int", ")", ".", "Set", "(", "r", ")", "\n", "values", ".", "Coeff", "=", "new", "(", "big", ".", "Int", ")", ".", "ModInverse", "(", "r", ",", "prime", ")", "\n\n", "r", ".", "Mul", "(", "r", ",", "prime", ")", "\n", "}", "\n", "}" ]

[ "Precompute", "performs", "some", "calculations", "that", "speed", "up", "private", "key", "operations", "in", "the", "future", "." ]

[ "func", "leftPad", "(", "input", "[", "]", "byte", ",", "size", "int", ")", "(", "out", "[", "]", "byte", ")", "{", "n", ":=", "len", "(", "input", ")", "\n", "if", "n", ">", "size", "{", "n", "=", "size", "\n", "}", "\n", "out", "=", "make", "(", "[", "]", "byte", ",", "size", ")", "\n", "copy", "(", "out", "[", "len", "(", "out", ")", "-", "n", ":", "]", ",", "input", ")", "\n", "return", "\n", "}" ]

[ "leftPad", "returns", "a", "new", "slice", "of", "length", "size", ".", "The", "contents", "of", "input", "are", "right", "aligned", "in", "the", "new", "slice", "." ]

[ "func", "getChain", "(", "addr", "string", ",", "config", "*", "tls", ".", "Config", ")", "(", "chain", "[", "]", "*", "x509", ".", "Certificate", ",", "err", "error", ")", "{", "var", "conn", "*", "tls", ".", "Conn", "\n", "conn", ",", "err", "=", "tls", ".", "DialWithDialer", "(", "Dialer", ",", "Network", ",", "addr", ",", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "err", "=", "conn", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "chain", "=", "conn", ".", "ConnectionState", "(", ")", ".", "PeerCertificates", "\n", "if", "len", "(", "chain", ")", "==", "0", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "addr", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "getChain", "is", "a", "helper", "function", "that", "retreives", "the", "host", "s", "certificate", "chain", "." ]

[ "func", "(", "src", "InMemorySource", ")", "Response", "(", "request", "*", "ocsp", ".", "Request", ")", "(", "[", "]", "byte", ",", "http", ".", "Header", ",", "error", ")", "{", "response", ",", "present", ":=", "src", "[", "request", ".", "SerialNumber", ".", "String", "(", ")", "]", "\n", "if", "!", "present", "{", "return", "nil", ",", "nil", ",", "ErrNotFound", "\n", "}", "\n", "return", "response", ",", "nil", ",", "nil", "\n", "}" ]

[ "Response", "looks", "up", "an", "OCSP", "response", "to", "provide", "for", "a", "given", "request", ".", "InMemorySource", "looks", "up", "a", "response", "purely", "based", "on", "serial", "number", "without", "regard", "to", "what", "issuer", "the", "request", "is", "asking", "for", "." ]

[ "func", "(", "src", "DBSource", ")", "Response", "(", "req", "*", "ocsp", ".", "Request", ")", "(", "[", "]", "byte", ",", "http", ".", "Header", ",", "error", ")", "{", "if", "req", "==", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "aki", ":=", "hex", ".", "EncodeToString", "(", "req", ".", "IssuerKeyHash", ")", "\n", "sn", ":=", "req", ".", "SerialNumber", "\n\n", "if", "sn", "==", "nil", "{", "return", "nil", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "strSN", ":=", "sn", ".", "String", "(", ")", "\n\n", "if", "src", ".", "Accessor", "==", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "records", ",", "err", ":=", "src", ".", "Accessor", ".", "GetOCSP", "(", "strSN", ",", "aki", ")", "\n\n", "// Response() logs when there are errors obtaining the OCSP response", "// and returns nil, false.", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "len", "(", "records", ")", "==", "0", "{", "return", "nil", ",", "nil", ",", "ErrNotFound", "\n", "}", "\n\n", "// Response() finds the OCSPRecord with the expiration date furthest in the future.", "cur", ":=", "records", "[", "0", "]", "\n", "for", "_", ",", "rec", ":=", "range", "records", "{", "if", "rec", ".", "Expiry", ".", "After", "(", "cur", ".", "Expiry", ")", "{", "cur", "=", "rec", "\n", "}", "\n", "}", "\n", "return", "[", "]", "byte", "(", "cur", ".", "Body", ")", ",", "nil", ",", "nil", "\n", "}" ]

[ "Response", "implements", "cfssl", ".", "ocsp", ".", "responder", ".", "Source", "which", "returns", "the", "OCSP", "response", "in", "the", "Database", "for", "the", "given", "request", "with", "the", "expiration", "date", "furthest", "in", "the", "future", "." ]

[ "func", "NewSourceFromDB", "(", "DBConfigFile", "string", ")", "(", "Source", ",", "error", ")", "{", "// Load DB from cofiguration file", "db", ",", "err", ":=", "dbconf", ".", "DBFromConfig", "(", "DBConfigFile", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// Create accesor", "accessor", ":=", "sql", ".", "NewAccessor", "(", "db", ")", "\n", "src", ":=", "NewDBSource", "(", "accessor", ")", "\n\n", "return", "src", ",", "nil", "\n", "}" ]

[ "NewSourceFromDB", "reads", "the", "given", "database", "configuration", "file", "and", "creates", "a", "database", "data", "source", "for", "use", "with", "the", "OCSP", "responder" ]

[ "func", "NewResponder", "(", "source", "Source", ",", "stats", "Stats", ")", "*", "Responder", "{", "return", "&", "Responder", "{", "Source", ":", "source", ",", "stats", ":", "stats", ",", "clk", ":", "clock", ".", "New", "(", ")", ",", "}", "\n", "}" ]

[ "NewResponder", "instantiates", "a", "Responder", "with", "the", "give", "Source", "." ]

[ "func", "ParseToRawMap", "(", "fileName", "string", ")", "(", "cfg", "RawMap", ",", "err", "error", ")", "{", "var", "file", "*", "os", ".", "File", "\n\n", "cfg", "=", "make", "(", "RawMap", ",", "0", ")", "\n", "file", ",", "err", "=", "os", ".", "Open", "(", "fileName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "defer", "file", ".", "Close", "(", ")", "\n", "scanner", ":=", "bufio", ".", "NewScanner", "(", "file", ")", "\n\n", "var", "currentSection", "string", "\n", "for", "scanner", ".", "Scan", "(", ")", "{", "line", ":=", "scanner", ".", "Text", "(", ")", "\n\n", "if", "commentLine", ".", "MatchString", "(", "line", ")", "{", "continue", "\n", "}", "else", "if", "blankLine", ".", "MatchString", "(", "line", ")", "{", "continue", "\n", "}", "else", "if", "configSection", ".", "MatchString", "(", "line", ")", "{", "section", ":=", "configSection", ".", "ReplaceAllString", "(", "line", ",", "\"", "\"", ")", "\n", "if", "!", "cfg", ".", "SectionInConfig", "(", "section", ")", "{", "cfg", "[", "section", "]", "=", "make", "(", "map", "[", "string", "]", "string", ",", "0", ")", "\n", "}", "\n", "currentSection", "=", "section", "\n", "}", "else", "if", "configLine", ".", "MatchString", "(", "line", ")", "{", "regex", ":=", "configLine", "\n", "if", "quotedConfigLine", ".", "MatchString", "(", "line", ")", "{", "regex", "=", "quotedConfigLine", "\n", "}", "\n", "if", "currentSection", "==", "\"", "\"", "{", "currentSection", "=", "defaultSection", "\n", "if", "!", "cfg", ".", "SectionInConfig", "(", "currentSection", ")", "{", "cfg", "[", "currentSection", "]", "=", "make", "(", "map", "[", "string", "]", "string", ",", "0", ")", "\n", "}", "\n", "}", "\n", "key", ":=", "regex", ".", "ReplaceAllString", "(", "line", ",", "\"", "\"", ")", "\n", "val", ":=", "regex", ".", "ReplaceAllString", "(", "line", ",", "\"", "\"", ")", "\n", "cfg", "[", "currentSection", "]", "[", "key", "]", "=", "val", "\n", "}", "else", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "break", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "ParseToRawMap", "takes", "the", "filename", "as", "a", "string", "and", "returns", "a", "RawMap", "." ]

[ "func", "(", "c", "*", "RawMap", ")", "SectionInConfig", "(", "section", "string", ")", "bool", "{", "for", "s", ":=", "range", "*", "c", "{", "if", "section", "==", "s", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "SectionInConfig", "determines", "whether", "a", "section", "is", "in", "the", "configuration", "." ]

[ "func", "LoadRoot", "(", "cfg", "map", "[", "string", "]", "string", ")", "(", "*", "Root", ",", "error", ")", "{", "var", "root", "Root", "\n", "var", "err", "error", "\n", "spec", ",", "ok", ":=", "cfg", "[", "\"", "\"", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "ErrMissingPrivateKey", "\n", "}", "\n\n", "certPath", ",", "ok", ":=", "cfg", "[", "\"", "\"", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "ErrMissingCertificatePath", "\n", "}", "\n\n", "configPath", ",", "ok", ":=", "cfg", "[", "\"", "\"", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "ErrMissingConfigPath", "\n", "}", "\n\n", "root", ".", "PrivateKey", ",", "err", "=", "parsePrivateKeySpec", "(", "spec", ",", "cfg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "in", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "certPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "root", ".", "Certificate", ",", "err", "=", "helpers", ".", "ParseCertificatePEM", "(", "in", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "conf", ",", "err", ":=", "config", ".", "LoadFile", "(", "configPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "root", ".", "Config", "=", "conf", ".", "Signing", "\n\n", "nets", ":=", "cfg", "[", "\"", "\"", "]", "\n", "if", "nets", "!=", "\"", "\"", "{", "root", ".", "ACL", ",", "err", "=", "parseACL", "(", "nets", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "dbConfig", ":=", "cfg", "[", "\"", "\"", "]", "\n", "if", "dbConfig", "!=", "\"", "\"", "{", "db", ",", "err", ":=", "dbconf", ".", "DBFromConfig", "(", "dbConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "root", ".", "DB", "=", "db", "\n", "}", "\n\n", "return", "&", "root", ",", "nil", "\n", "}" ]

[ "LoadRoot", "parses", "a", "config", "structure", "into", "a", "Root", "structure" ]

[ "func", "Parse", "(", "filename", "string", ")", "(", "RootList", ",", "error", ")", "{", "cfgMap", ",", "err", ":=", "ParseToRawMap", "(", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "rootList", "=", "RootList", "{", "}", "\n", "for", "label", ",", "entries", ":=", "range", "cfgMap", "{", "root", ",", "err", ":=", "LoadRoot", "(", "entries", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "rootList", "[", "label", "]", "=", "root", "\n", "}", "\n\n", "return", "rootList", ",", "nil", "\n", "}" ]

[ "Parse", "loads", "a", "RootList", "from", "a", "file", "." ]

[ "func", "LoadFile", "(", "path", "string", ")", "(", "cfg", "*", "DBConfig", ",", "err", "error", ")", "{", "log", ".", "Debugf", "(", "\"", "\"", ",", "path", ")", "\n", "if", "path", "==", "\"", "\"", "{", "return", "nil", ",", "cferr", ".", "Wrap", "(", "cferr", ".", "PolicyError", ",", "cferr", ".", "InvalidPolicy", ",", "errors", ".", "New", "(", "\"", "\"", ")", ")", "\n", "}", "\n\n", "var", "body", "[", "]", "byte", "\n", "body", ",", "err", "=", "ioutil", ".", "ReadFile", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "cferr", ".", "Wrap", "(", "cferr", ".", "PolicyError", ",", "cferr", ".", "InvalidPolicy", ",", "errors", ".", "New", "(", "\"", "\"", ")", ")", "\n", "}", "\n\n", "cfg", "=", "&", "DBConfig", "{", "}", "\n", "err", "=", "json", ".", "Unmarshal", "(", "body", ",", "&", "cfg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "cferr", ".", "Wrap", "(", "cferr", ".", "PolicyError", ",", "cferr", ".", "InvalidPolicy", ",", "errors", ".", "New", "(", "\"", "\"", "+", "err", ".", "Error", "(", ")", ")", ")", "\n", "}", "\n\n", "if", "cfg", ".", "DataSourceName", "==", "\"", "\"", "||", "cfg", ".", "DriverName", "==", "\"", "\"", "{", "return", "nil", ",", "cferr", ".", "Wrap", "(", "cferr", ".", "PolicyError", ",", "cferr", ".", "InvalidPolicy", ",", "errors", ".", "New", "(", "\"", "\"", ")", ")", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "LoadFile", "attempts", "to", "load", "the", "db", "configuration", "file", "stored", "at", "the", "path", "and", "returns", "the", "configuration", ".", "On", "error", "it", "returns", "nil", "." ]

[ "func", "DBFromConfig", "(", "path", "string", ")", "(", "db", "*", "sqlx", ".", "DB", ",", "err", "error", ")", "{", "var", "dbCfg", "*", "DBConfig", "\n", "dbCfg", ",", "err", "=", "LoadFile", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "sqlx", ".", "Open", "(", "dbCfg", ".", "DriverName", ",", "dbCfg", ".", "DataSourceName", ")", "\n", "}" ]

[ "DBFromConfig", "opens", "a", "sql", ".", "DB", "from", "settings", "in", "a", "db", "config", "file" ]

[ "func", "New", "(", ")", "hash", ".", "Hash", "{", "d", ":=", "&", "digest", "{", "function", ":", "crypto", ".", "SHA512", "}", "\n", "d", ".", "Reset", "(", ")", "\n", "return", "d", "\n", "}" ]

[ "New", "returns", "a", "new", "hash", ".", "Hash", "computing", "the", "SHA", "-", "512", "checksum", "." ]

[ "func", "New384", "(", ")", "hash", ".", "Hash", "{", "d", ":=", "&", "digest", "{", "function", ":", "crypto", ".", "SHA384", "}", "\n", "d", ".", "Reset", "(", ")", "\n", "return", "d", "\n", "}" ]

[ "New384", "returns", "a", "new", "hash", ".", "Hash", "computing", "the", "SHA", "-", "384", "checksum", "." ]

[ "func", "Sum512", "(", "data", "[", "]", "byte", ")", "[", "Size", "]", "byte", "{", "d", ":=", "digest", "{", "function", ":", "crypto", ".", "SHA512", "}", "\n", "d", ".", "Reset", "(", ")", "\n", "d", ".", "Write", "(", "data", ")", "\n", "return", "d", ".", "checkSum", "(", ")", "\n", "}" ]

[ "Sum512", "returns", "the", "SHA512", "checksum", "of", "the", "data", "." ]

[ "func", "NewHandler", "(", "s", "ocsp", ".", "Signer", ")", "http", ".", "Handler", "{", "return", "&", "api", ".", "HTTPHandler", "{", "Handler", ":", "&", "Handler", "{", "signer", ":", "s", ",", "}", ",", "Methods", ":", "[", "]", "string", "{", "\"", "\"", "}", ",", "}", "\n", "}" ]

[ "NewHandler", "returns", "a", "new", "http", ".", "Handler", "that", "handles", "a", "ocspsign", "request", "." ]

[ "func", "(", "h", "*", "Handler", ")", "Handle", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "error", "{", "body", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "r", ".", "Body", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "r", ".", "Body", ".", "Close", "(", ")", "\n\n", "// Default the status to good so it matches the cli", "req", ":=", "&", "jsonSignRequest", "{", "Status", ":", "\"", "\"", ",", "}", "\n", "err", "=", "json", ".", "Unmarshal", "(", "body", ",", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "NewBadRequestString", "(", "\"", "\"", ")", "\n", "}", "\n\n", "cert", ",", "err", ":=", "helpers", ".", "ParseCertificatePEM", "(", "[", "]", "byte", "(", "req", ".", "Certificate", ")", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Error", "(", "\"", "\"", ",", "err", ")", "\n", "return", "errors", ".", "NewBadRequestString", "(", "\"", "\"", ")", "\n", "}", "\n\n", "signReq", ":=", "ocsp", ".", "SignRequest", "{", "Certificate", ":", "cert", ",", "Status", ":", "req", ".", "Status", ",", "}", "\n", "// We need to convert the time from being a string to a time.Time", "if", "req", ".", "Status", "==", "\"", "\"", "{", "signReq", ".", "Reason", "=", "req", ".", "Reason", "\n", "// \"now\" is accepted and the default on the cli so default that here", "if", "req", ".", "RevokedAt", "==", "\"", "\"", "||", "req", ".", "RevokedAt", "==", "\"", "\"", "{", "signReq", ".", "RevokedAt", "=", "time", ".", "Now", "(", ")", "\n", "}", "else", "{", "signReq", ".", "RevokedAt", ",", "err", "=", "time", ".", "Parse", "(", "\"", "\"", ",", "req", ".", "RevokedAt", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "NewBadRequestString", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "req", ".", "IssuerHash", "!=", "\"", "\"", "{", "issuerHash", ",", "ok", ":=", "nameToHash", "[", "req", ".", "IssuerHash", "]", "\n", "if", "!", "ok", "{", "return", "errors", ".", "NewBadRequestString", "(", "\"", "\"", ")", "\n", "}", "\n", "signReq", ".", "IssuerHash", "=", "issuerHash", "\n", "}", "\n\n", "resp", ",", "err", ":=", "h", ".", "signer", ".", "Sign", "(", "signReq", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "b64Resp", ":=", "base64", ".", "StdEncoding", ".", "EncodeToString", "(", "resp", ")", "\n", "result", ":=", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "b64Resp", "}", "\n", "return", "api", ".", "SendResponse", "(", "w", ",", "result", ")", "\n", "}" ]

[ "Handle", "responds", "to", "requests", "for", "a", "ocsp", "signature", ".", "It", "creates", "and", "signs", "a", "ocsp", "response", "for", "the", "provided", "certificate", "and", "status", ".", "If", "the", "status", "is", "revoked", "then", "it", "also", "adds", "reason", "and", "revoked_at", ".", "The", "response", "is", "base64", "encoded", "." ]

[ "func", "supervisor", "(", "paths", "chan", "string", ",", "bundler", "chan", "*", "x509", ".", "Certificate", ",", "numWorkers", "int", ")", "{", "var", "workerPool", "sync", ".", "WaitGroup", "\n", "for", "i", ":=", "0", ";", "i", "<", "numWorkers", ";", "i", "++", "{", "workerPool", ".", "Add", "(", "1", ")", "\n", "go", "worker", "(", "paths", ",", "bundler", ",", "&", "workerPool", ")", "\n", "}", "\n", "workerPool", ".", "Wait", "(", ")", "\n", "close", "(", "bundler", ")", "\n", "}" ]

[ "supervisor", "sets", "up", "the", "workers", "and", "signals", "the", "bundler", "that", "all", "certificates", "have", "been", "processed", "." ]

[ "func", "makeBundle", "(", "filename", "string", ",", "bundler", "chan", "*", "x509", ".", "Certificate", ")", "{", "file", ",", "err", ":=", "os", ".", "Create", "(", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "defer", "file", ".", "Close", "(", ")", "\n\n", "var", "total", "int", "\n", "for", "{", "cert", ",", "ok", ":=", "<-", "bundler", "\n", "if", "!", "ok", "{", "break", "\n", "}", "\n", "block", ":=", "&", "pem", ".", "Block", "{", "Type", ":", "\"", "\"", ",", "Bytes", ":", "cert", ".", "Raw", ",", "}", "\n", "err", "=", "pem", ".", "Encode", "(", "file", ",", "block", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "break", "\n", "}", "\n", "total", "++", "\n", "}", "\n", "log", ".", "Infof", "(", "\"", "\"", ",", "total", ")", "\n", "}" ]

[ "makeBundle", "opens", "the", "file", "for", "writing", "and", "listens", "for", "incoming", "certificates", ".", "These", "are", "PEM", "-", "encoded", "and", "written", "to", "file", "." ]

[ "func", "scanFiles", "(", "paths", "chan", "string", ")", "{", "walker", ":=", "func", "(", "path", "string", ",", "info", "os", ".", "FileInfo", ",", "err", "error", ")", "error", "{", "log", ".", "Infof", "(", "\"", "\"", ",", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "info", ".", "Mode", "(", ")", ".", "IsRegular", "(", ")", "{", "paths", "<-", "path", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "for", "_", ",", "path", ":=", "range", "flag", ".", "Args", "(", ")", "{", "err", ":=", "filepath", ".", "Walk", "(", "path", ",", "walker", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "close", "(", "paths", ")", "\n", "}" ]

[ "scanFiles", "walks", "the", "files", "listed", "in", "the", "arguments", ".", "These", "files", "may", "be", "either", "certificate", "files", "or", "directories", "containing", "certificates", "." ]

[ "func", "NewHandler", "(", "dbAccessor", "certdb", ".", "Accessor", ",", "signer", "ocsp", ".", "Signer", ")", "http", ".", "Handler", "{", "return", "&", "api", ".", "HTTPHandler", "{", "Handler", ":", "&", "Handler", "{", "dbAccessor", ":", "dbAccessor", ",", "signer", ":", "signer", ",", "}", ",", "Methods", ":", "[", "]", "string", "{", "\"", "\"", "}", ",", "}", "\n", "}" ]

[ "NewHandler", "creates", "a", "new", "Handler", "from", "a", "certdb", ".", "Accessor", "and", "ocsp", ".", "Signer" ]

[ "func", "dnsLookupScan", "(", "addr", ",", "hostname", "string", ")", "(", "grade", "Grade", ",", "output", "Output", ",", "err", "error", ")", "{", "addrs", ",", "err", ":=", "net", ".", "LookupHost", "(", "hostname", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "if", "len", "(", "addrs", ")", "==", "0", "{", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "grade", ",", "output", "=", "Good", ",", "addrs", "\n", "return", "\n", "}" ]

[ "dnsLookupScan", "tests", "that", "DNS", "resolution", "of", "the", "host", "returns", "at", "least", "one", "address" ]

[ "func", "tcpDialScan", "(", "addr", ",", "hostname", "string", ")", "(", "grade", "Grade", ",", "output", "Output", ",", "err", "error", ")", "{", "conn", ",", "err", ":=", "Dialer", ".", "Dial", "(", "Network", ",", "addr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "conn", ".", "Close", "(", ")", "\n", "grade", "=", "Good", "\n", "return", "\n", "}" ]

[ "tcpDialScan", "tests", "that", "the", "host", "can", "be", "connected", "to", "through", "TCP", "." ]

[ "func", "tlsDialScan", "(", "addr", ",", "hostname", "string", ")", "(", "grade", "Grade", ",", "output", "Output", ",", "err", "error", ")", "{", "var", "conn", "*", "tls", ".", "Conn", "\n", "config", ":=", "defaultTLSConfig", "(", "hostname", ")", "\n\n", "if", "conn", ",", "err", "=", "tls", ".", "DialWithDialer", "(", "Dialer", ",", "Network", ",", "addr", ",", "config", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "conn", ".", "Close", "(", ")", "\n\n", "config", ".", "InsecureSkipVerify", "=", "false", "\n", "if", "conn", ",", "err", "=", "tls", ".", "DialWithDialer", "(", "Dialer", ",", "Network", ",", "addr", ",", "config", ")", ";", "err", "!=", "nil", "{", "grade", "=", "Warning", "\n", "return", "\n", "}", "\n", "conn", ".", "Close", "(", ")", "\n\n", "grade", "=", "Good", "\n", "return", "\n", "}" ]

[ "tlsDialScan", "tests", "that", "the", "host", "can", "perform", "a", "TLS", "Handshake", "and", "warns", "if", "the", "server", "s", "certificate", "can", "t", "be", "verified", "." ]

[ "func", "HandleError", "(", "w", "http", ".", "ResponseWriter", ",", "err", "error", ")", "(", "code", "int", ")", "{", "if", "err", "==", "nil", "{", "return", "http", ".", "StatusOK", "\n", "}", "\n", "msg", ":=", "err", ".", "Error", "(", ")", "\n", "httpCode", ":=", "http", ".", "StatusInternalServerError", "\n\n", "// If it is recognized as HttpError emitted from cfssl,", "// we rewrite the status code accordingly. If it is a", "// cfssl error, set the http status to StatusBadRequest", "switch", "err", ":=", "err", ".", "(", "type", ")", "{", "case", "*", "errors", ".", "HTTPError", ":", "httpCode", "=", "err", ".", "StatusCode", "\n", "code", "=", "err", ".", "StatusCode", "\n", "case", "*", "errors", ".", "Error", ":", "httpCode", "=", "http", ".", "StatusBadRequest", "\n", "code", "=", "err", ".", "ErrorCode", "\n", "msg", "=", "err", ".", "Message", "\n", "}", "\n\n", "response", ":=", "NewErrorResponse", "(", "msg", ",", "code", ")", "\n", "jsonMessage", ",", "err", ":=", "json", ".", "Marshal", "(", "response", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "else", "{", "msg", "=", "string", "(", "jsonMessage", ")", "\n", "}", "\n", "http", ".", "Error", "(", "w", ",", "msg", ",", "httpCode", ")", "\n", "return", "code", "\n", "}" ]

[ "HandleError", "is", "the", "centralised", "error", "handling", "and", "reporting", "." ]

[ "func", "(", "h", "HTTPHandler", ")", "ServeHTTP", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "var", "err", "error", "\n", "var", "match", "bool", "\n", "// Throw 405 when requested with an unsupported verb.", "for", "_", ",", "m", ":=", "range", "h", ".", "Methods", "{", "if", "m", "==", "r", ".", "Method", "{", "match", "=", "true", "\n", "}", "\n", "}", "\n", "if", "match", "{", "err", "=", "h", ".", "Handle", "(", "w", ",", "r", ")", "\n", "}", "else", "{", "err", "=", "errors", ".", "NewMethodNotAllowed", "(", "r", ".", "Method", ")", "\n", "}", "\n", "status", ":=", "HandleError", "(", "w", ",", "err", ")", "\n", "log", ".", "Infof", "(", "\"", "\\\"", "\\\"", "\"", ",", "r", ".", "RemoteAddr", ",", "r", ".", "Method", ",", "r", ".", "URL", ",", "status", ")", "\n", "}" ]

[ "ServeHTTP", "encapsulates", "the", "call", "to", "underlying", "Handler", "to", "handle", "the", "request", "and", "return", "the", "response", "with", "proper", "HTTP", "status", "code" ]

[ "func", "NewSuccessResponse", "(", "result", "interface", "{", "}", ")", "Response", "{", "return", "Response", "{", "Success", ":", "true", ",", "Result", ":", "result", ",", "Errors", ":", "[", "]", "ResponseMessage", "{", "}", ",", "Messages", ":", "[", "]", "ResponseMessage", "{", "}", ",", "}", "\n", "}" ]

[ "NewSuccessResponse", "is", "a", "shortcut", "for", "creating", "new", "successul", "API", "responses", "." ]

[ "func", "NewSuccessResponseWithMessage", "(", "result", "interface", "{", "}", ",", "message", "string", ",", "code", "int", ")", "Response", "{", "return", "Response", "{", "Success", ":", "true", ",", "Result", ":", "result", ",", "Errors", ":", "[", "]", "ResponseMessage", "{", "}", ",", "Messages", ":", "[", "]", "ResponseMessage", "{", "{", "code", ",", "message", "}", "}", ",", "}", "\n", "}" ]

[ "NewSuccessResponseWithMessage", "is", "a", "shortcut", "for", "creating", "new", "successul", "API", "responses", "that", "includes", "a", "message", "." ]

[ "func", "NewErrorResponse", "(", "message", "string", ",", "code", "int", ")", "Response", "{", "return", "Response", "{", "Success", ":", "false", ",", "Result", ":", "nil", ",", "Errors", ":", "[", "]", "ResponseMessage", "{", "{", "code", ",", "message", "}", "}", ",", "Messages", ":", "[", "]", "ResponseMessage", "{", "}", ",", "}", "\n", "}" ]

[ "NewErrorResponse", "is", "a", "shortcut", "for", "creating", "an", "error", "response", "for", "a", "single", "error", "." ]

[ "func", "SendResponse", "(", "w", "http", ".", "ResponseWriter", ",", "result", "interface", "{", "}", ")", "error", "{", "response", ":=", "NewSuccessResponse", "(", "result", ")", "\n", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "enc", ":=", "json", ".", "NewEncoder", "(", "w", ")", "\n", "err", ":=", "enc", ".", "Encode", "(", "response", ")", "\n", "return", "err", "\n", "}" ]

[ "SendResponse", "builds", "a", "response", "from", "the", "result", "sets", "the", "JSON", "header", "and", "writes", "to", "the", "http", ".", "ResponseWriter", "." ]

[ "func", "SendResponseWithMessage", "(", "w", "http", ".", "ResponseWriter", ",", "result", "interface", "{", "}", ",", "message", "string", ",", "code", "int", ")", "error", "{", "response", ":=", "NewSuccessResponseWithMessage", "(", "result", ",", "message", ",", "code", ")", "\n", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "enc", ":=", "json", ".", "NewEncoder", "(", "w", ")", "\n", "err", ":=", "enc", ".", "Encode", "(", "response", ")", "\n", "return", "err", "\n", "}" ]

[ "SendResponseWithMessage", "builds", "a", "response", "from", "the", "result", "and", "the", "provided", "message", "sets", "the", "JSON", "header", "and", "writes", "to", "the", "http", ".", "ResponseWriter", "." ]

[ "func", "NewServerTLS", "(", "addr", "string", ",", "tlsConfig", "*", "tls", ".", "Config", ")", "Remote", "{", "addrs", ":=", "strings", ".", "Split", "(", "addr", ",", "\"", "\"", ")", "\n\n", "var", "remote", "Remote", "\n\n", "if", "len", "(", "addrs", ")", ">", "1", "{", "remote", ",", "_", "=", "NewGroup", "(", "addrs", ",", "tlsConfig", ",", "StrategyOrderedList", ")", "\n", "}", "else", "{", "u", ",", "err", ":=", "normalizeURL", "(", "addrs", "[", "0", "]", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", "\n", "}", "\n", "srv", ":=", "newServer", "(", "u", ",", "tlsConfig", ")", "\n", "if", "srv", "!=", "nil", "{", "remote", "=", "srv", "\n", "}", "\n", "}", "\n", "return", "remote", "\n", "}" ]

[ "NewServerTLS", "is", "the", "TLS", "version", "of", "NewServer" ]

[ "func", "(", "srv", "*", "server", ")", "post", "(", "url", "string", ",", "jsonData", "[", "]", "byte", ")", "(", "*", "api", ".", "Response", ",", "error", ")", "{", "var", "resp", "*", "http", ".", "Response", "\n", "var", "err", "error", "\n", "client", ":=", "&", "http", ".", "Client", "{", "}", "\n", "if", "srv", ".", "TLSConfig", "!=", "nil", "{", "client", ".", "Transport", "=", "srv", ".", "createTransport", "(", ")", "\n", "}", "\n", "if", "srv", ".", "RequestTimeout", "!=", "0", "{", "client", ".", "Timeout", "=", "srv", ".", "RequestTimeout", "\n", "}", "\n", "req", ",", "err", ":=", "http", ".", "NewRequest", "(", "\"", "\"", ",", "url", ",", "bytes", ".", "NewReader", "(", "jsonData", ")", ")", "\n", "if", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "url", ",", "err", ")", "\n", "return", "nil", ",", "errors", ".", "Wrap", "(", "errors", ".", "APIClientError", ",", "errors", ".", "ClientHTTPError", ",", "err", ")", "\n", "}", "\n", "req", ".", "Close", "=", "true", "\n", "req", ".", "Header", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "srv", ".", "reqModifier", "!=", "nil", "{", "srv", ".", "reqModifier", "(", "req", ",", "jsonData", ")", "\n", "}", "\n", "resp", ",", "err", "=", "client", ".", "Do", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "url", ",", "err", ")", "\n", "return", "nil", ",", "errors", ".", "Wrap", "(", "errors", ".", "APIClientError", ",", "errors", ".", "ClientHTTPError", ",", "err", ")", "\n", "}", "\n", "defer", "req", ".", "Body", ".", "Close", "(", ")", "\n", "body", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "resp", ".", "Body", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrap", "(", "errors", ".", "APIClientError", ",", "errors", ".", "IOError", ",", "err", ")", "\n", "}", "\n\n", "if", "resp", ".", "StatusCode", "!=", "http", ".", "StatusOK", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "url", ")", "\n", "return", "nil", ",", "errors", ".", "Wrap", "(", "errors", ".", "APIClientError", ",", "errors", ".", "ClientHTTPError", ",", "stderr", ".", "New", "(", "string", "(", "body", ")", ")", ")", "\n", "}", "\n\n", "var", "response", "api", ".", "Response", "\n", "err", "=", "json", ".", "Unmarshal", "(", "body", ",", "&", "response", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Debug", "(", "\"", "\"", ",", "string", "(", "body", ")", ")", "\n", "return", "nil", ",", "errors", ".", "Wrap", "(", "errors", ".", "APIClientError", ",", "errors", ".", "JSONError", ",", "err", ")", "\n", "}", "\n\n", "if", "!", "response", ".", "Success", "||", "response", ".", "Result", "==", "nil", "{", "if", "len", "(", "response", ".", "Errors", ")", ">", "0", "{", "return", "nil", ",", "errors", ".", "Wrap", "(", "errors", ".", "APIClientError", ",", "errors", ".", "ServerRequestFailed", ",", "stderr", ".", "New", "(", "response", ".", "Errors", "[", "0", "]", ".", "Message", ")", ")", "\n", "}", "\n", "return", "nil", ",", "errors", ".", "New", "(", "errors", ".", "APIClientError", ",", "errors", ".", "ServerRequestFailed", ")", "\n", "}", "\n\n", "return", "&", "response", ",", "nil", "\n", "}" ]

[ "post", "connects", "to", "the", "remote", "server", "and", "returns", "a", "Response", "struct" ]

[ "func", "(", "srv", "*", "server", ")", "AuthSign", "(", "req", ",", "id", "[", "]", "byte", ",", "provider", "auth", ".", "Provider", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "srv", ".", "authReq", "(", "req", ",", "id", ",", "provider", ",", "\"", "\"", ")", "\n", "}" ]

[ "AuthSign", "fills", "out", "an", "authenticated", "signing", "request", "to", "the", "server", "receiving", "a", "certificate", "or", "error", "in", "response", ".", "It", "takes", "the", "serialized", "JSON", "request", "to", "send", "remote", "address", "and", "authentication", "provider", "." ]

[ "func", "(", "srv", "*", "server", ")", "Sign", "(", "jsonData", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "srv", ".", "request", "(", "jsonData", ",", "\"", "\"", ")", "\n", "}" ]

[ "Sign", "sends", "a", "signature", "request", "to", "the", "remote", "CFSSL", "server", "receiving", "a", "signed", "certificate", "or", "an", "error", "in", "response", ".", "It", "takes", "the", "serialized", "JSON", "request", "to", "send", "." ]

[ "func", "(", "srv", "*", "server", ")", "Info", "(", "jsonData", "[", "]", "byte", ")", "(", "*", "info", ".", "Resp", ",", "error", ")", "{", "res", ",", "err", ":=", "srv", ".", "getResultMap", "(", "jsonData", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "info", ":=", "new", "(", "info", ".", "Resp", ")", "\n\n", "if", "val", ",", "ok", ":=", "res", "[", "\"", "\"", "]", ";", "ok", "{", "info", ".", "Certificate", "=", "val", ".", "(", "string", ")", "\n", "}", "\n", "var", "usages", "[", "]", "interface", "{", "}", "\n", "if", "val", ",", "ok", ":=", "res", "[", "\"", "\"", "]", ";", "ok", "&&", "val", "!=", "nil", "{", "usages", "=", "val", ".", "(", "[", "]", "interface", "{", "}", ")", "\n", "}", "\n", "if", "val", ",", "ok", ":=", "res", "[", "\"", "\"", "]", ";", "ok", "&&", "val", "!=", "nil", "{", "info", ".", "ExpiryString", "=", "val", ".", "(", "string", ")", "\n", "}", "\n\n", "info", ".", "Usage", "=", "make", "(", "[", "]", "string", ",", "len", "(", "usages", ")", ")", "\n", "for", "i", ",", "s", ":=", "range", "usages", "{", "info", ".", "Usage", "[", "i", "]", "=", "s", ".", "(", "string", ")", "\n", "}", "\n\n", "return", "info", ",", "nil", "\n", "}" ]

[ "Info", "sends", "an", "info", "request", "to", "the", "remote", "CFSSL", "server", "receiving", "a", "response", "or", "an", "error", "in", "response", ".", "It", "takes", "the", "serialized", "JSON", "request", "to", "send", "." ]

[ "func", "(", "srv", "*", "server", ")", "request", "(", "jsonData", "[", "]", "byte", ",", "target", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "result", ",", "err", ":=", "srv", ".", "getResultMap", "(", "jsonData", ",", "target", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "cert", ":=", "result", "[", "\"", "\"", "]", ".", "(", "string", ")", "\n", "if", "cert", "!=", "\"", "\"", "{", "return", "[", "]", "byte", "(", "cert", ")", ",", "nil", "\n", "}", "\n\n", "return", "nil", ",", "errors", ".", "Wrap", "(", "errors", ".", "APIClientError", ",", "errors", ".", "ClientHTTPError", ",", "stderr", ".", "New", "(", "\"", "\"", ")", ")", "\n", "}" ]

[ "request", "performs", "the", "common", "logic", "for", "Sign", "and", "Info", "performing", "the", "actual", "request", "and", "returning", "the", "resultant", "certificate", "." ]

[ "func", "NewAuthServer", "(", "addr", "string", ",", "tlsConfig", "*", "tls", ".", "Config", ",", "provider", "auth", ".", "Provider", ")", "*", "AuthRemote", "{", "return", "&", "AuthRemote", "{", "Remote", ":", "NewServerTLS", "(", "addr", ",", "tlsConfig", ")", ",", "provider", ":", "provider", ",", "}", "\n", "}" ]

[ "NewAuthServer", "sets", "up", "a", "new", "auth", "server", "target", "with", "an", "addr", "in", "the", "same", "format", "at", "NewServer", "and", "a", "default", "authentication", "provider", "to", "use", "for", "Sign", "requests", "." ]