Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "rd", "*", "Redirector", ")", "callback", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "(", "*", "auth", ".", "SSHLoginResponse", ",", "error", ")", "{", "if", "r", ".", "URL", ".", "Path", "!=", "\"", "\"", "{", "return", "nil", ",", "trace", ".", "NotFound", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Decrypt ciphertext to get login response.", "plaintext", ",", "err", ":=", "rd", ".", "key", ".", "Open", "(", "[", "]", "byte", "(", "r", ".", "URL", ".", "Query", "(", ")", ".", "Get", "(", "\"", "\"", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "r", ".", "URL", ".", "String", "(", ")", ",", "err", ")", "\n", "}", "\n\n", "var", "re", "*", "auth", ".", "SSHLoginResponse", "\n", "err", "=", "json", ".", "Unmarshal", "(", "plaintext", ",", "&", "re", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "r", ".", "URL", ".", "String", "(", ")", ",", "err", ")", "\n", "}", "\n\n", "return", "re", ",", "nil", "\n", "}" ]

[ "callback", "is", "used", "by", "Teleport", "proxy", "to", "send", "back", "credentials", "issued", "by", "Teleport", "proxy" ]

[ "func", "(", "rd", "*", "Redirector", ")", "Close", "(", ")", "error", "{", "rd", ".", "cancel", "(", ")", "\n", "if", "rd", ".", "server", "!=", "nil", "{", "rd", ".", "server", ".", "Close", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Close", "closes", "redirector", "and", "releases", "all", "resources" ]

[ "func", "(", "rd", "*", "Redirector", ")", "wrapCallback", "(", "fn", "func", "(", "http", ".", "ResponseWriter", ",", "*", "http", ".", "Request", ")", "(", "*", "auth", ".", "SSHLoginResponse", ",", "error", ")", ")", "http", ".", "Handler", "{", "clone", ":=", "*", "rd", ".", "proxyURL", "\n", "clone", ".", "Path", "=", "\"", "\"", "\n", "errorURL", ":=", "clone", ".", "String", "(", ")", "\n", "clone", ".", "Path", "=", "\"", "\"", "\n", "successURL", ":=", "clone", ".", "String", "(", ")", "\n\n", "return", "http", ".", "HandlerFunc", "(", "func", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "response", ",", "err", ":=", "fn", "(", "w", ",", "r", ")", "\n", "if", "err", "!=", "nil", "{", "if", "trace", ".", "IsNotFound", "(", "err", ")", "{", "http", ".", "NotFound", "(", "w", ",", "r", ")", "\n", "return", "\n", "}", "\n", "select", "{", "case", "rd", ".", "errorC", "<-", "err", ":", "case", "<-", "rd", ".", "context", ".", "Done", "(", ")", ":", "http", ".", "Redirect", "(", "w", ",", "r", ",", "errorURL", ",", "http", ".", "StatusFound", ")", "\n", "return", "\n", "}", "\n", "http", ".", "Redirect", "(", "w", ",", "r", ",", "errorURL", ",", "http", ".", "StatusFound", ")", "\n", "return", "\n", "}", "\n", "select", "{", "case", "rd", ".", "responseC", "<-", "response", ":", "case", "<-", "rd", ".", "context", ".", "Done", "(", ")", ":", "http", ".", "Redirect", "(", "w", ",", "r", ",", "errorURL", ",", "http", ".", "StatusFound", ")", "\n", "return", "\n", "}", "\n", "http", ".", "Redirect", "(", "w", ",", "r", ",", "successURL", ",", "http", ".", "StatusFound", ")", "\n", "}", ")", "\n", "}" ]

[ "wrapCallback", "is", "a", "helper", "wrapper", "method", "that", "wraps", "callback", "HTTP", "handler", "and", "sends", "a", "result", "to", "the", "channel", "and", "redirect", "users", "to", "error", "page" ]

[ "func", "NewLicense", "(", "name", "string", ",", "spec", "LicenseSpecV3", ")", "(", "License", ",", "error", ")", "{", "return", "&", "LicenseV3", "{", "Kind", ":", "KindLicense", ",", "Version", ":", "V3", ",", "Metadata", ":", "Metadata", "{", "Name", ":", "name", ",", "Namespace", ":", "defaults", ".", "Namespace", ",", "}", ",", "Spec", ":", "spec", ",", "}", ",", "nil", "\n", "}" ]

[ "NewLicense", "is", "a", "convenience", "method", "to", "to", "create", "LicenseV3", "." ]

[ "func", "(", "c", "*", "LicenseV3", ")", "SetLabels", "(", "labels", "map", "[", "string", "]", "string", ")", "{", "c", ".", "Metadata", ".", "Labels", "=", "labels", "\n", "}" ]

[ "SetLabels", "sets", "metadata", "labels" ]

[ "func", "(", "c", "*", "LicenseV3", ")", "String", "(", ")", "string", "{", "var", "features", "[", "]", "string", "\n", "if", "!", "c", ".", "Expiry", "(", ")", ".", "IsZero", "(", ")", "{", "features", "=", "append", "(", "features", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "Expiry", "(", ")", ")", ")", "\n", "}", "\n", "if", "c", ".", "Spec", ".", "ReportsUsage", ".", "Value", "(", ")", "{", "features", "=", "append", "(", "features", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "Spec", ".", "SupportsKubernetes", ".", "Value", "(", ")", "{", "features", "=", "append", "(", "features", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "Spec", ".", "AWSProductID", "!=", "\"", "\"", "{", "features", "=", "append", "(", "features", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "Spec", ".", "AWSProductID", ")", ")", "\n", "}", "\n", "if", "c", ".", "Spec", ".", "AWSAccountID", "!=", "\"", "\"", "{", "features", "=", "append", "(", "features", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "Spec", ".", "AWSAccountID", ")", ")", "\n", "}", "\n", "if", "len", "(", "features", ")", "==", "0", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "features", ",", "\"", "\"", ")", "\n", "}" ]

[ "String", "represents", "a", "human", "readable", "version", "of", "license", "enabled", "features" ]

[ "func", "UnmarshalLicense", "(", "bytes", "[", "]", "byte", ")", "(", "License", ",", "error", ")", "{", "if", "len", "(", "bytes", ")", "==", "0", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n\n", "schema", ":=", "fmt", ".", "Sprintf", "(", "V2SchemaTemplate", ",", "MetadataSchema", ",", "LicenseSpecV3Template", ",", "DefaultDefinitions", ")", "\n\n", "var", "license", "LicenseV3", "\n", "err", ":=", "utils", ".", "UnmarshalWithSchema", "(", "schema", ",", "&", "license", ",", "bytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "if", "license", ".", "Version", "!=", "V3", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "license", ".", "Version", ",", "V3", ")", "\n", "}", "\n\n", "if", "err", ":=", "license", ".", "CheckAndSetDefaults", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "&", "license", ",", "nil", "\n", "}" ]

[ "UnmarshalLicense", "unmarshals", "License", "from", "JSON", "or", "YAML", "and", "validates", "schema" ]

[ "func", "MarshalLicense", "(", "license", "License", ",", "opts", "...", "MarshalOption", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "cfg", ",", "err", ":=", "collectOptions", "(", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "switch", "resource", ":=", "license", ".", "(", "type", ")", "{", "case", "*", "LicenseV3", ":", "if", "!", "cfg", ".", "PreserveResourceID", "{", "// avoid modifying the original object", "// to prevent unexpected data races", "copy", ":=", "*", "resource", "\n", "copy", ".", "SetResourceID", "(", "0", ")", "\n", "resource", "=", "&", "copy", "\n", "}", "\n", "return", "utils", ".", "FastMarshal", "(", "resource", ")", "\n", "default", ":", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "license", ")", "\n", "}", "\n", "}" ]

[ "MarshalLicense", "marshals", "role", "to", "JSON", "or", "YAML", "." ]

[ "func", "NewAgentPool", "(", "cfg", "AgentPoolConfig", ")", "(", "*", "AgentPool", ",", "error", ")", "{", "if", "err", ":=", "cfg", ".", "CheckAndSetDefaults", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "cfg", ".", "Context", ")", "\n", "pool", ":=", "&", "AgentPool", "{", "agents", ":", "make", "(", "map", "[", "agentKey", "]", "[", "]", "*", "Agent", ")", ",", "cfg", ":", "cfg", ",", "ctx", ":", "ctx", ",", "cancel", ":", "cancel", ",", "discoveryC", ":", "make", "(", "chan", "*", "discoveryRequest", ")", ",", "}", "\n", "pool", ".", "Entry", "=", "log", ".", "WithFields", "(", "log", ".", "Fields", "{", "trace", ".", "Component", ":", "teleport", ".", "ComponentReverseTunnelAgent", ",", "trace", ".", "ComponentFields", ":", "log", ".", "Fields", "{", "\"", "\"", ":", "cfg", ".", "Cluster", ",", "}", ",", "}", ")", "\n", "return", "pool", ",", "nil", "\n", "}" ]

[ "NewAgentPool", "returns", "new", "isntance", "of", "the", "agent", "pool" ]

[ "func", "(", "m", "*", "AgentPool", ")", "reportStats", "(", ")", "{", "var", "logReport", "bool", "\n", "if", "m", ".", "cfg", ".", "Clock", ".", "Now", "(", ")", ".", "Sub", "(", "m", ".", "lastReport", ")", ">", "defaults", ".", "ReportingPeriod", "{", "m", ".", "lastReport", "=", "m", ".", "cfg", ".", "Clock", ".", "Now", "(", ")", "\n", "logReport", "=", "true", "\n", "}", "\n\n", "for", "key", ",", "agents", ":=", "range", "m", ".", "agents", "{", "m", ".", "Debugf", "(", "\"", "\"", ",", "key", ".", "tunnelID", ",", "len", "(", "agents", ")", ")", "\n\n", "countPerState", ":=", "map", "[", "string", "]", "int", "{", "agentStateConnecting", ":", "0", ",", "agentStateDiscovering", ":", "0", ",", "agentStateConnected", ":", "0", ",", "agentStateDiscovered", ":", "0", ",", "agentStateDisconnected", ":", "0", ",", "}", "\n", "for", "_", ",", "a", ":=", "range", "agents", "{", "countPerState", "[", "a", ".", "getState", "(", ")", "]", "++", "\n", "}", "\n", "for", "state", ",", "count", ":=", "range", "countPerState", "{", "gauge", ",", "err", ":=", "trustedClustersStats", ".", "GetMetricWithLabelValues", "(", "key", ".", "tunnelID", ",", "state", ")", "\n", "if", "err", "!=", "nil", "{", "m", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "gauge", ".", "Set", "(", "float64", "(", "count", ")", ")", "\n", "}", "\n", "if", "logReport", "{", "m", ".", "WithFields", "(", "log", ".", "Fields", "{", "\"", "\"", ":", "key", ".", "tunnelID", ",", "\"", "\"", ":", "countPerState", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "reportStats", "submits", "report", "about", "agents", "state", "once", "in", "a", "while", "at", "info", "level", ".", "Always", "logs", "more", "detailed", "information", "at", "debug", "level", "." ]

[ "func", "(", "m", "*", "AgentPool", ")", "removeDisconnected", "(", ")", "{", "for", "agentKey", ",", "agentSlice", ":=", "range", "m", ".", "agents", "{", "// Filter and close all disconnected agents.", "validAgents", ":=", "filterAndClose", "(", "agentSlice", ",", "func", "(", "agent", "*", "Agent", ")", "bool", "{", "if", "agent", ".", "getState", "(", ")", "==", "agentStateDisconnected", "{", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}", ")", "\n\n", "// Update (or delete) agent key with filter applied.", "if", "len", "(", "validAgents", ")", ">", "0", "{", "m", ".", "agents", "[", "agentKey", "]", "=", "validAgents", "\n", "}", "else", "{", "delete", "(", "m", ".", "agents", ",", "agentKey", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "removeDisconnected", "removes", "disconnected", "agents", "from", "the", "list", "of", "agents", ".", "This", "function", "should", "be", "called", "under", "a", "lock", "." ]

[ "func", "(", "fs", "*", "FileAddrStorage", ")", "SetAddresses", "(", "addrs", "[", "]", "NetAddr", ")", "error", "{", "bytes", ",", "err", ":=", "json", ".", "Marshal", "(", "addrs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "err", "=", "ioutil", ".", "WriteFile", "(", "fs", ".", "filePath", ",", "bytes", ",", "0666", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Error", "(", "err", ")", "\n", "return", "trace", ".", "ConvertSystemError", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "SetAddresses", "updates", "storage", "with", "new", "address", "list" ]

[ "func", "(", "fs", "*", "FileAddrStorage", ")", "GetAddresses", "(", ")", "(", "[", "]", "NetAddr", ",", "error", ")", "{", "bytes", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "fs", ".", "filePath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "ConvertSystemError", "(", "err", ")", "\n", "}", "\n", "var", "addrs", "[", "]", "NetAddr", "\n", "if", "len", "(", "bytes", ")", ">", "0", "{", "err", "=", "json", ".", "Unmarshal", "(", "bytes", ",", "&", "addrs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "addrs", ",", "nil", "\n", "}" ]

[ "GetAddresses", "returns", "saved", "address", "list" ]

[ "func", "TLSDial", "(", "ctx", "context", ".", "Context", ",", "dial", "DialWithContextFunc", ",", "network", ",", "addr", "string", ",", "tlsConfig", "*", "tls", ".", "Config", ")", "(", "*", "tls", ".", "Conn", ",", "error", ")", "{", "if", "tlsConfig", "==", "nil", "{", "tlsConfig", "=", "&", "tls", ".", "Config", "{", "}", "\n", "}", "\n\n", "plainConn", ",", "err", ":=", "dial", "(", "ctx", ",", "network", ",", "addr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "colonPos", ":=", "strings", ".", "LastIndex", "(", "addr", ",", "\"", "\"", ")", "\n", "if", "colonPos", "==", "-", "1", "{", "colonPos", "=", "len", "(", "addr", ")", "\n", "}", "\n", "hostname", ":=", "addr", "[", ":", "colonPos", "]", "\n\n", "// If no ServerName is set, infer the ServerName", "// from the hostname we're connecting to.", "if", "tlsConfig", ".", "ServerName", "==", "\"", "\"", "{", "// Make a copy to avoid polluting argument or default.", "c", ":=", "tlsConfig", ".", "Clone", "(", ")", "\n", "c", ".", "ServerName", "=", "hostname", "\n", "tlsConfig", "=", "c", "\n", "}", "\n\n", "conn", ":=", "tls", ".", "Client", "(", "plainConn", ",", "tlsConfig", ")", "\n", "errC", ":=", "make", "(", "chan", "error", ",", "1", ")", "\n", "go", "func", "(", ")", "{", "err", ":=", "conn", ".", "Handshake", "(", ")", "\n", "errC", "<-", "err", "\n", "}", "(", ")", "\n\n", "select", "{", "case", "err", ":=", "<-", "errC", ":", "if", "err", "!=", "nil", "{", "plainConn", ".", "Close", "(", ")", "\n", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "plainConn", ".", "Close", "(", ")", "\n", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "tlsConfig", ".", "InsecureSkipVerify", "{", "return", "conn", ",", "nil", "\n", "}", "\n\n", "if", "err", ":=", "conn", ".", "VerifyHostname", "(", "tlsConfig", ".", "ServerName", ")", ";", "err", "!=", "nil", "{", "plainConn", ".", "Close", "(", ")", "\n", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "conn", ",", "nil", "\n", "}" ]

[ "TLSDial", "dials", "and", "establishes", "TLS", "connection", "using", "custom", "dialer", "is", "similar", "to", "tls", ".", "DialWithDialer" ]

[ "func", "NewUserContext", "(", "user", "services", ".", "User", ",", "userRoles", "services", ".", "RoleSet", ")", "(", "*", "userContext", ",", "error", ")", "{", "ctx", ":=", "&", "services", ".", "Context", "{", "User", ":", "user", "}", "\n", "sessionAccess", ":=", "newAccess", "(", "userRoles", ",", "ctx", ",", "services", ".", "KindSession", ")", "\n", "roleAccess", ":=", "newAccess", "(", "userRoles", ",", "ctx", ",", "services", ".", "KindRole", ")", "\n", "authConnectors", ":=", "newAccess", "(", "userRoles", ",", "ctx", ",", "services", ".", "KindAuthConnector", ")", "\n", "trustedClusterAccess", ":=", "newAccess", "(", "userRoles", ",", "ctx", ",", "services", ".", "KindTrustedCluster", ")", "\n", "logins", ":=", "getLogins", "(", "userRoles", ")", "\n\n", "acl", ":=", "userACL", "{", "AuthConnectors", ":", "authConnectors", ",", "TrustedClusters", ":", "trustedClusterAccess", ",", "Sessions", ":", "sessionAccess", ",", "Roles", ":", "roleAccess", ",", "SSHLogins", ":", "logins", ",", "}", "\n\n", "// local user", "authType", ":=", "authLocal", "\n\n", "// check for any SSO identities", "isSSO", ":=", "len", "(", "user", ".", "GetOIDCIdentities", "(", ")", ")", ">", "0", "||", "len", "(", "user", ".", "GetGithubIdentities", "(", ")", ")", ">", "0", "||", "len", "(", "user", ".", "GetSAMLIdentities", "(", ")", ")", ">", "0", "\n\n", "if", "isSSO", "{", "// SSO user", "authType", "=", "authSSO", "\n", "}", "\n\n", "return", "&", "userContext", "{", "Name", ":", "user", ".", "GetName", "(", ")", ",", "ACL", ":", "acl", ",", "AuthType", ":", "authType", ",", "Version", ":", "teleport", ".", "Version", ",", "}", ",", "nil", "\n", "}" ]

[ "NewUserContext", "constructs", "user", "context", "from", "roles", "assigned", "to", "user" ]

[ "func", "(", "t", "*", "TLSServer", ")", "Serve", "(", "listener", "net", ".", "Listener", ")", "error", "{", "return", "t", ".", "Server", ".", "Serve", "(", "tls", ".", "NewListener", "(", "listener", ",", "t", ".", "TLS", ")", ")", "\n", "}" ]

[ "Serve", "takes", "TCP", "listener", "upgrades", "to", "TLS", "using", "config", "and", "starts", "serving" ]

[ "func", "(", "a", "*", "AuthMiddleware", ")", "GetUser", "(", "r", "*", "http", ".", "Request", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "peers", ":=", "r", ".", "TLS", ".", "PeerCertificates", "\n", "if", "len", "(", "peers", ")", ">", "1", "{", "// when turning intermediaries on, don't forget to verify", "// https://github.com/kubernetes/kubernetes/pull/34524/files#diff-2b283dde198c92424df5355f39544aa4R59", "return", "nil", ",", "trace", ".", "AccessDenied", "(", "\"", "\"", ")", "\n", "}", "\n", "localClusterName", ",", "err", ":=", "a", ".", "AccessPoint", ".", "GetClusterName", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "// with no client authentication in place, middleware", "// assumes not-privileged Nop role.", "// it theoretically possible to use bearer token auth even", "// for connections without auth, but this is not active use-case", "// therefore it is not allowed to reduce scope", "if", "len", "(", "peers", ")", "==", "0", "{", "return", "BuiltinRole", "{", "GetClusterConfig", ":", "a", ".", "AccessPoint", ".", "GetClusterConfig", ",", "Role", ":", "teleport", ".", "RoleNop", ",", "Username", ":", "string", "(", "teleport", ".", "RoleNop", ")", ",", "ClusterName", ":", "localClusterName", ".", "GetClusterName", "(", ")", ",", "}", ",", "nil", "\n", "}", "\n", "clientCert", ":=", "peers", "[", "0", "]", "\n", "certClusterName", ",", "err", ":=", "tlsca", ".", "ClusterName", "(", "clientCert", ".", "Issuer", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "trace", ".", "AccessDenied", "(", "\"", "\"", ")", "\n", "}", "\n\n", "identity", ",", "err", ":=", "tlsca", ".", "FromSubject", "(", "clientCert", ".", "Subject", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "// If there is any restriction on the certificate usage", "// reject the API server request. This is done so some classes", "// of certificates issued for kubernetes usage by proxy, can not be used", "// against auth server. Later on we can extend more", "// advanced cert usage, but for now this is the safest option.", "if", "len", "(", "identity", ".", "Usage", ")", "!=", "0", "&&", "!", "utils", ".", "StringSlicesEqual", "(", "a", ".", "AcceptedUsage", ",", "identity", ".", "Usage", ")", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "identity", ".", "Username", ",", "identity", ".", "Usage", ",", "a", ".", "AcceptedUsage", ")", "\n", "return", "nil", ",", "trace", ".", "AccessDenied", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// this block assumes interactive user from remote cluster", "// based on the remote certificate authority cluster name encoded in", "// x509 organization name. This is a safe check because:", "// 1. Trust and verification is established during TLS handshake", "// by creating a cert pool constructed of trusted certificate authorities", "// 2. Remote CAs are not allowed to have the same cluster name", "// as the local certificate authority", "if", "certClusterName", "!=", "localClusterName", ".", "GetClusterName", "(", ")", "{", "// make sure that this user does not have system role", "// the local auth server can not truste remote servers", "// to issue certificates with system roles (e.g. Admin),", "// to get unrestricted access to the local cluster", "systemRole", ":=", "findSystemRole", "(", "identity", ".", "Groups", ")", "\n", "if", "systemRole", "!=", "nil", "{", "return", "RemoteBuiltinRole", "{", "Role", ":", "*", "systemRole", ",", "Username", ":", "identity", ".", "Username", ",", "ClusterName", ":", "certClusterName", ",", "}", ",", "nil", "\n", "}", "\n", "return", "RemoteUser", "{", "ClusterName", ":", "certClusterName", ",", "Username", ":", "identity", ".", "Username", ",", "Principals", ":", "identity", ".", "Principals", ",", "KubernetesGroups", ":", "identity", ".", "KubernetesGroups", ",", "RemoteRoles", ":", "identity", ".", "Groups", ",", "}", ",", "nil", "\n", "}", "\n", "// code below expects user or service from local cluster, to distinguish between", "// interactive users and services (e.g. proxies), the code below", "// checks for presence of system roles issued in certificate identity", "systemRole", ":=", "findSystemRole", "(", "identity", ".", "Groups", ")", "\n", "// in case if the system role is present, assume this is a service", "// agent, e.g. Proxy, connecting to the cluster", "if", "systemRole", "!=", "nil", "{", "return", "BuiltinRole", "{", "GetClusterConfig", ":", "a", ".", "AccessPoint", ".", "GetClusterConfig", ",", "Role", ":", "*", "systemRole", ",", "Username", ":", "identity", ".", "Username", ",", "ClusterName", ":", "localClusterName", ".", "GetClusterName", "(", ")", ",", "}", ",", "nil", "\n", "}", "\n", "// otherwise assume that is a local role, no need to pass the roles", "// as it will be fetched from the local database", "return", "LocalUser", "{", "Username", ":", "identity", ".", "Username", ",", "}", ",", "nil", "\n", "}" ]

[ "GetUser", "returns", "authenticated", "user", "based", "on", "request", "metadata", "set", "by", "HTTP", "server" ]

[ "func", "(", "a", "*", "AuthMiddleware", ")", "ServeHTTP", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "baseContext", ":=", "r", ".", "Context", "(", ")", "\n", "if", "baseContext", "==", "nil", "{", "baseContext", "=", "context", ".", "TODO", "(", ")", "\n", "}", "\n", "user", ",", "err", ":=", "a", ".", "GetUser", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "trace", ".", "WriteError", "(", "w", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "// determine authenticated user based on the request parameters", "requestWithContext", ":=", "r", ".", "WithContext", "(", "context", ".", "WithValue", "(", "baseContext", ",", "ContextUser", ",", "user", ")", ")", "\n", "a", ".", "Handler", ".", "ServeHTTP", "(", "w", ",", "requestWithContext", ")", "\n", "}" ]

[ "ServeHTTP", "serves", "HTTP", "requests" ]

[ "func", "ClientCertPool", "(", "client", "AccessCache", ",", "clusterName", "string", ")", "(", "*", "x509", ".", "CertPool", ",", "error", ")", "{", "pool", ":=", "x509", ".", "NewCertPool", "(", ")", "\n", "var", "authorities", "[", "]", "services", ".", "CertAuthority", "\n", "if", "clusterName", "==", "\"", "\"", "{", "hostCAs", ",", "err", ":=", "client", ".", "GetCertAuthorities", "(", "services", ".", "HostCA", ",", "false", ",", "services", ".", "SkipValidation", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "userCAs", ",", "err", ":=", "client", ".", "GetCertAuthorities", "(", "services", ".", "UserCA", ",", "false", ",", "services", ".", "SkipValidation", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "authorities", "=", "append", "(", "authorities", ",", "hostCAs", "...", ")", "\n", "authorities", "=", "append", "(", "authorities", ",", "userCAs", "...", ")", "\n", "}", "else", "{", "hostCA", ",", "err", ":=", "client", ".", "GetCertAuthority", "(", "services", ".", "CertAuthID", "{", "Type", ":", "services", ".", "HostCA", ",", "DomainName", ":", "clusterName", "}", ",", "false", ",", "services", ".", "SkipValidation", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "userCA", ",", "err", ":=", "client", ".", "GetCertAuthority", "(", "services", ".", "CertAuthID", "{", "Type", ":", "services", ".", "UserCA", ",", "DomainName", ":", "clusterName", "}", ",", "false", ",", "services", ".", "SkipValidation", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "authorities", "=", "append", "(", "authorities", ",", "hostCA", ")", "\n", "authorities", "=", "append", "(", "authorities", ",", "userCA", ")", "\n", "}", "\n\n", "for", "_", ",", "auth", ":=", "range", "authorities", "{", "for", "_", ",", "keyPair", ":=", "range", "auth", ".", "GetTLSKeyPairs", "(", ")", "{", "cert", ",", "err", ":=", "tlsca", ".", "ParseCertificatePEM", "(", "keyPair", ".", "Cert", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "CertInfo", "(", "cert", ")", ")", "\n", "pool", ".", "AddCert", "(", "cert", ")", "\n", "}", "\n", "}", "\n", "return", "pool", ",", "nil", "\n", "}" ]

[ "ClientCertPool", "returns", "trusted", "x509", "cerificate", "authority", "pool" ]

[ "func", "applySSHConfig", "(", "fc", "*", "FileConfig", ",", "cfg", "*", "service", ".", "Config", ")", "error", "{", "if", "fc", ".", "SSH", ".", "ListenAddress", "!=", "\"", "\"", "{", "addr", ",", "err", ":=", "utils", ".", "ParseHostPortAddr", "(", "fc", ".", "SSH", ".", "ListenAddress", ",", "int", "(", "defaults", ".", "SSHServerListenPort", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "cfg", ".", "SSH", ".", "Addr", "=", "*", "addr", "\n", "}", "\n", "if", "fc", ".", "SSH", ".", "Labels", "!=", "nil", "{", "cfg", ".", "SSH", ".", "Labels", "=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "for", "k", ",", "v", ":=", "range", "fc", ".", "SSH", ".", "Labels", "{", "cfg", ".", "SSH", ".", "Labels", "[", "k", "]", "=", "v", "\n", "}", "\n", "}", "\n", "if", "fc", ".", "SSH", ".", "Commands", "!=", "nil", "{", "cfg", ".", "SSH", ".", "CmdLabels", "=", "make", "(", "services", ".", "CommandLabels", ")", "\n", "for", "_", ",", "cmdLabel", ":=", "range", "fc", ".", "SSH", ".", "Commands", "{", "cfg", ".", "SSH", ".", "CmdLabels", "[", "cmdLabel", ".", "Name", "]", "=", "&", "services", ".", "CommandLabelV2", "{", "Period", ":", "services", ".", "NewDuration", "(", "cmdLabel", ".", "Period", ")", ",", "Command", ":", "cmdLabel", ".", "Command", ",", "Result", ":", "\"", "\"", ",", "}", "\n", "}", "\n", "}", "\n", "if", "fc", ".", "SSH", ".", "Namespace", "!=", "\"", "\"", "{", "cfg", ".", "SSH", ".", "Namespace", "=", "fc", ".", "SSH", ".", "Namespace", "\n", "}", "\n", "if", "fc", ".", "SSH", ".", "PermitUserEnvironment", "{", "cfg", ".", "SSH", ".", "PermitUserEnvironment", "=", "true", "\n", "}", "\n", "if", "fc", ".", "SSH", ".", "PAM", "!=", "nil", "{", "cfg", ".", "SSH", ".", "PAM", "=", "fc", ".", "SSH", ".", "PAM", ".", "Parse", "(", ")", "\n\n", "// If PAM is enabled, make sure that Teleport was built with PAM support", "// and the PAM library was found at runtime.", "if", "cfg", ".", "SSH", ".", "PAM", ".", "Enabled", "{", "if", "!", "pam", ".", "BuildHasPAM", "(", ")", "{", "errorMessage", ":=", "\"", "\\n", "\"", "+", "\"", "\\n", "\"", "+", "\"", "\\n", "\"", "+", "\"", "\"", "\n", "return", "trace", ".", "BadParameter", "(", "errorMessage", ")", "\n", "}", "\n", "if", "!", "pam", ".", "SystemHasPAM", "(", ")", "{", "errorMessage", ":=", "\"", "\\n", "\"", "+", "\"", "\\n", "\"", "+", "\"", "\"", "\n", "return", "trace", ".", "BadParameter", "(", "errorMessage", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "len", "(", "fc", ".", "SSH", ".", "PublicAddr", ")", "!=", "0", "{", "addrs", ",", "err", ":=", "fc", ".", "SSH", ".", "PublicAddr", ".", "Addrs", "(", "defaults", ".", "SSHServerListenPort", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "cfg", ".", "SSH", ".", "PublicAddrs", "=", "addrs", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "applySSHConfig", "applies", "file", "configuration", "for", "the", "ssh_service", "section", "." ]

[ "func", "parseAuthorizedKeys", "(", "bytes", "[", "]", "byte", ",", "allowedLogins", "[", "]", "string", ")", "(", "services", ".", "CertAuthority", ",", "services", ".", "Role", ",", "error", ")", "{", "pubkey", ",", "comment", ",", "_", ",", "_", ",", "err", ":=", "ssh", ".", "ParseAuthorizedKey", "(", "bytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "comments", ",", "err", ":=", "url", ".", "ParseQuery", "(", "comment", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "clusterName", ":=", "comments", ".", "Get", "(", "\"", "\"", ")", "\n", "if", "clusterName", "==", "\"", "\"", "{", "return", "nil", ",", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// create a new certificate authority", "ca", ":=", "services", ".", "NewCertAuthority", "(", "services", ".", "UserCA", ",", "clusterName", ",", "nil", ",", "[", "]", "[", "]", "byte", "{", "ssh", ".", "MarshalAuthorizedKey", "(", "pubkey", ")", "}", ",", "nil", ")", "\n\n", "// transform old allowed logins into roles", "role", ":=", "services", ".", "RoleForCertAuthority", "(", "ca", ")", "\n", "role", ".", "SetLogins", "(", "services", ".", "Allow", ",", "allowedLogins", ")", "\n", "ca", ".", "AddRole", "(", "role", ".", "GetName", "(", ")", ")", "\n\n", "return", "ca", ",", "role", ",", "nil", "\n", "}" ]

[ "parseAuthorizedKeys", "parses", "keys", "in", "the", "authorized_keys", "format", "and", "returns", "a", "services", ".", "CertAuthority", "." ]

[ "func", "parseKnownHosts", "(", "bytes", "[", "]", "byte", ",", "allowedLogins", "[", "]", "string", ")", "(", "services", ".", "CertAuthority", ",", "services", ".", "Role", ",", "error", ")", "{", "marker", ",", "options", ",", "pubKey", ",", "comment", ",", "_", ",", "err", ":=", "ssh", ".", "ParseKnownHosts", "(", "bytes", ")", "\n", "if", "marker", "!=", "\"", "\"", "{", "return", "nil", ",", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "teleportOpts", ",", "err", ":=", "url", ".", "ParseQuery", "(", "comment", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "comment", ")", "\n", "}", "\n", "authType", ":=", "services", ".", "CertAuthType", "(", "teleportOpts", ".", "Get", "(", "\"", "\"", ")", ")", "\n", "if", "authType", "!=", "services", ".", "HostCA", "&&", "authType", "!=", "services", ".", "UserCA", "{", "return", "nil", ",", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "authType", ")", "\n", "}", "\n", "if", "len", "(", "options", ")", "==", "0", "{", "return", "nil", ",", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "const", "prefix", "=", "\"", "\"", "\n", "domainName", ":=", "strings", ".", "TrimPrefix", "(", "options", "[", "0", "]", ",", "prefix", ")", "\n\n", "v1", ":=", "&", "services", ".", "CertAuthorityV1", "{", "AllowedLogins", ":", "utils", ".", "CopyStrings", "(", "allowedLogins", ")", ",", "DomainName", ":", "domainName", ",", "Type", ":", "authType", ",", "CheckingKeys", ":", "[", "]", "[", "]", "byte", "{", "ssh", ".", "MarshalAuthorizedKey", "(", "pubKey", ")", "}", ",", "}", "\n", "ca", ",", "role", ":=", "services", ".", "ConvertV1CertAuthority", "(", "v1", ")", "\n", "return", "ca", ",", "role", ",", "nil", "\n", "}" ]

[ "parseKnownHosts", "parses", "keys", "in", "known_hosts", "format", "and", "returns", "a", "services", ".", "CertAuthority", "." ]

[ "func", "certificateAuthorityFormat", "(", "bytes", "[", "]", "byte", ")", "(", "string", ",", "error", ")", "{", "_", ",", "_", ",", "_", ",", "_", ",", "err", ":=", "ssh", ".", "ParseAuthorizedKey", "(", "bytes", ")", "\n", "if", "err", "!=", "nil", "{", "_", ",", "_", ",", "_", ",", "_", ",", "_", ",", "err", ":=", "ssh", ".", "ParseKnownHosts", "(", "bytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "teleport", ".", "KnownHosts", ",", "nil", "\n", "}", "\n", "return", "teleport", ".", "AuthorizedKeys", ",", "nil", "\n", "}" ]

[ "certificateAuthorityFormat", "parses", "bytes", "and", "determines", "if", "they", "are", "in", "known_hosts", "format", "or", "authorized_keys", "format", "." ]

[ "func", "parseCAKey", "(", "bytes", "[", "]", "byte", ",", "allowedLogins", "[", "]", "string", ")", "(", "services", ".", "CertAuthority", ",", "services", ".", "Role", ",", "error", ")", "{", "caFormat", ",", "err", ":=", "certificateAuthorityFormat", "(", "bytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "if", "caFormat", "==", "teleport", ".", "AuthorizedKeys", "{", "return", "parseAuthorizedKeys", "(", "bytes", ",", "allowedLogins", ")", "\n", "}", "\n", "return", "parseKnownHosts", "(", "bytes", ",", "allowedLogins", ")", "\n", "}" ]

[ "parseCAKey", "parses", "bytes", "either", "in", "known_hosts", "or", "authorized_keys", "format", "and", "returns", "a", "services", ".", "CertAuthority", "." ]

[ "func", "readTrustedClusters", "(", "clusters", "[", "]", "TrustedCluster", ",", "conf", "*", "service", ".", "Config", ")", "error", "{", "if", "len", "(", "clusters", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "// go over all trusted clusters:", "for", "i", ":=", "range", "clusters", "{", "tc", ":=", "&", "clusters", "[", "i", "]", "\n", "// parse \"allow_logins\"", "var", "allowedLogins", "[", "]", "string", "\n", "for", "_", ",", "login", ":=", "range", "strings", ".", "Split", "(", "tc", ".", "AllowedLogins", ",", "\"", "\"", ")", "{", "login", "=", "strings", ".", "TrimSpace", "(", "login", ")", "\n", "if", "login", "!=", "\"", "\"", "{", "allowedLogins", "=", "append", "(", "allowedLogins", ",", "login", ")", "\n", "}", "\n", "}", "\n", "// open the key file for this cluster:", "log", ".", "Debugf", "(", "\"", "\"", ",", "tc", ".", "KeyFile", ")", "\n", "if", "tc", ".", "KeyFile", "==", "\"", "\"", "{", "return", "trace", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "f", ",", "err", ":=", "os", ".", "Open", "(", "tc", ".", "KeyFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n", "// read the keyfile for this cluster and get trusted CA keys:", "var", "authorities", "[", "]", "services", ".", "CertAuthority", "\n", "var", "roles", "[", "]", "services", ".", "Role", "\n", "scanner", ":=", "bufio", ".", "NewScanner", "(", "f", ")", "\n", "for", "line", ":=", "0", ";", "scanner", ".", "Scan", "(", ")", ";", "{", "ca", ",", "role", ",", "err", ":=", "parseCAKey", "(", "scanner", ".", "Bytes", "(", ")", ",", "allowedLogins", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "tc", ".", "KeyFile", ",", "line", ",", "err", ")", "\n", "}", "\n", "if", "ca", ".", "GetType", "(", ")", "==", "services", ".", "UserCA", "&&", "len", "(", "allowedLogins", ")", "==", "0", "&&", "len", "(", "tc", ".", "TunnelAddr", ")", ">", "0", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "ca", ".", "GetClusterName", "(", ")", ")", "\n", "}", "\n", "authorities", "=", "append", "(", "authorities", ",", "ca", ")", "\n", "if", "role", "!=", "nil", "{", "roles", "=", "append", "(", "roles", ",", "role", ")", "\n", "}", "\n", "}", "\n", "conf", ".", "Auth", ".", "Authorities", "=", "append", "(", "conf", ".", "Auth", ".", "Authorities", ",", "authorities", "...", ")", "\n", "conf", ".", "Auth", ".", "Roles", "=", "append", "(", "conf", ".", "Auth", ".", "Roles", ",", "roles", "...", ")", "\n", "clusterName", ":=", "authorities", "[", "0", "]", ".", "GetClusterName", "(", ")", "\n", "// parse \"tunnel_addr\"", "var", "tunnelAddresses", "[", "]", "string", "\n", "for", "_", ",", "ta", ":=", "range", "strings", ".", "Split", "(", "tc", ".", "TunnelAddr", ",", "\"", "\"", ")", "{", "ta", ":=", "strings", ".", "TrimSpace", "(", "ta", ")", "\n", "if", "ta", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "addr", ",", "err", ":=", "utils", ".", "ParseHostPortAddr", "(", "ta", ",", "defaults", ".", "SSHProxyTunnelListenPort", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ",", "\"", "\"", ",", "ta", ",", "clusterName", ")", "\n", "}", "\n", "tunnelAddresses", "=", "append", "(", "tunnelAddresses", ",", "addr", ".", "FullAddress", "(", ")", ")", "\n", "}", "\n", "if", "len", "(", "tunnelAddresses", ")", ">", "0", "{", "conf", ".", "ReverseTunnels", "=", "append", "(", "conf", ".", "ReverseTunnels", ",", "services", ".", "NewReverseTunnel", "(", "clusterName", ",", "tunnelAddresses", ")", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "readTrustedClusters", "parses", "the", "content", "of", "trusted_clusters", "YAML", "structure", "and", "modifies", "Teleport", "conf", "by", "adding", "authorities", "and", "reverse", "tunnels", "to", "it" ]

[ "func", "applyString", "(", "src", "string", ",", "target", "*", "string", ")", "bool", "{", "if", "src", "!=", "\"", "\"", "{", "*", "target", "=", "src", "\n", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "applyString", "takes", "src", "and", "overwrites", "target", "with", "it", "unless", "src", "is", "empty", "returns", "True", "if", "src", "was", "not", "empty" ]

[ "func", "applyListenIP", "(", "ip", "net", ".", "IP", ",", "cfg", "*", "service", ".", "Config", ")", "{", "listeningAddresses", ":=", "[", "]", "*", "utils", ".", "NetAddr", "{", "&", "cfg", ".", "Auth", ".", "SSHAddr", ",", "&", "cfg", ".", "Auth", ".", "SSHAddr", ",", "&", "cfg", ".", "Proxy", ".", "SSHAddr", ",", "&", "cfg", ".", "Proxy", ".", "WebAddr", ",", "&", "cfg", ".", "SSH", ".", "Addr", ",", "&", "cfg", ".", "Proxy", ".", "ReverseTunnelListenAddr", ",", "}", "\n", "for", "_", ",", "addr", ":=", "range", "listeningAddresses", "{", "replaceHost", "(", "addr", ",", "ip", ".", "String", "(", ")", ")", "\n", "}", "\n", "}" ]

[ "applyListenIP", "replaces", "all", "listen", "addr", "settings", "for", "all", "services", "with", "a", "given", "IP" ]

[ "func", "replaceHost", "(", "addr", "*", "utils", ".", "NetAddr", ",", "newHost", "string", ")", "{", "_", ",", "port", ",", "err", ":=", "net", ".", "SplitHostPort", "(", "addr", ".", "Addr", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "addr", ".", "Addr", ")", "\n", "}", "\n", "addr", ".", "Addr", "=", "net", ".", "JoinHostPort", "(", "newHost", ",", "port", ")", "\n", "}" ]

[ "replaceHost", "takes", "utils", ".", "NetAddr", "and", "replaces", "the", "hostname", "in", "it", "preserving", "the", "original", "port" ]

[ "func", "(", "d", "Duration", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "json", ".", "Marshal", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "d", ".", "Duration", ")", ")", "\n", "}" ]

[ "MarshalJSON", "marshals", "Duration", "to", "string" ]

[ "func", "(", "s", "*", "AuthServer", ")", "initializeTOTP", "(", "accountName", "string", ")", "(", "key", "string", ",", "qr", "[", "]", "byte", ",", "err", "error", ")", "{", "// create totp key", "otpKey", ",", "err", ":=", "totp", ".", "Generate", "(", "totp", ".", "GenerateOpts", "{", "Issuer", ":", "\"", "\"", ",", "AccountName", ":", "accountName", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// create QR code", "var", "otpQRBuf", "bytes", ".", "Buffer", "\n", "otpImage", ",", "err", ":=", "otpKey", ".", "Image", "(", "456", ",", "456", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "png", ".", "Encode", "(", "&", "otpQRBuf", ",", "otpImage", ")", "\n\n", "return", "otpKey", ".", "Secret", "(", ")", ",", "otpQRBuf", ".", "Bytes", "(", ")", ",", "nil", "\n", "}" ]

[ "initializeTOTP", "creates", "TOTP", "algorithm", "and", "returns", "the", "key", "and", "QR", "code", "." ]

[ "func", "(", "s", "*", "AuthServer", ")", "rotateAndFetchSignupToken", "(", "token", "string", ")", "(", "*", "services", ".", "SignupToken", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// Fetch original signup token.", "st", ",", "err", ":=", "s", ".", "GetSignupToken", "(", "token", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// Generate and set new OTP code for user in *services.SignupToken.", "accountName", ":=", "st", ".", "User", ".", "V2", "(", ")", ".", "GetName", "(", ")", "+", "\"", "\"", "+", "s", ".", "AuthServiceName", "\n", "st", ".", "OTPKey", ",", "st", ".", "OTPQRCode", ",", "err", "=", "s", ".", "initializeTOTP", "(", "accountName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// Upsert token into backend.", "err", "=", "s", ".", "UpsertSignupToken", "(", "token", ",", "*", "st", ",", "st", ".", "Expires", ".", "Sub", "(", "s", ".", "clock", ".", "Now", "(", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "st", ",", "nil", "\n", "}" ]

[ "rotateAndFetchSignupToken", "rotates", "the", "signup", "token", "everytime", "it", "s", "fetched", ".", "This", "ensures", "that", "an", "attacker", "that", "gains", "the", "signup", "link", "can", "not", "view", "it", "extract", "the", "OTP", "key", "from", "the", "QR", "code", "then", "allow", "the", "user", "to", "signup", "with", "the", "same", "OTP", "token", "." ]

[ "func", "(", "s", "*", "AuthServer", ")", "CreateUserWithOTP", "(", "token", "string", ",", "password", "string", ",", "otpToken", "string", ")", "(", "services", ".", "WebSession", ",", "error", ")", "{", "tokenData", ",", "err", ":=", "s", ".", "GetSignupToken", "(", "token", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "trace", ".", "AccessDenied", "(", "\"", "\"", ")", "\n", "}", "\n\n", "err", "=", "s", ".", "UpsertTOTP", "(", "tokenData", ".", "User", ".", "Name", ",", "tokenData", ".", "OTPKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "err", "=", "s", ".", "CheckOTP", "(", "tokenData", ".", "User", ".", "Name", ",", "otpToken", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "trace", ".", "AccessDenied", "(", "\"", "\"", ")", "\n", "}", "\n\n", "err", "=", "s", ".", "UpsertPassword", "(", "tokenData", ".", "User", ".", "Name", ",", "[", "]", "byte", "(", "password", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// create services.User and services.WebSession", "webSession", ",", "err", ":=", "s", ".", "createUserAndSession", "(", "tokenData", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "webSession", ",", "nil", "\n", "}" ]

[ "CreateUserWithOTP", "creates", "account", "with", "provided", "token", "and", "password", ".", "Account", "username", "and", "hotp", "generator", "are", "taken", "from", "token", "data", ".", "Deletes", "token", "after", "account", "creation", "." ]

[ "func", "(", "s", "*", "AuthServer", ")", "CreateUserWithoutOTP", "(", "token", "string", ",", "password", "string", ")", "(", "services", ".", "WebSession", ",", "error", ")", "{", "authPreference", ",", "err", ":=", "s", ".", "GetAuthPreference", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "authPreference", ".", "GetSecondFactor", "(", ")", "!=", "teleport", ".", "OFF", "{", "return", "nil", ",", "trace", ".", "AccessDenied", "(", "\"", "\"", ")", "\n", "}", "\n", "tokenData", ",", "err", ":=", "s", ".", "GetSignupToken", "(", "token", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "trace", ".", "AccessDenied", "(", "\"", "\"", ")", "\n", "}", "\n\n", "err", "=", "s", ".", "UpsertPassword", "(", "tokenData", ".", "User", ".", "Name", ",", "[", "]", "byte", "(", "password", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// create services.User and services.WebSession", "webSession", ",", "err", ":=", "s", ".", "createUserAndSession", "(", "tokenData", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "webSession", ",", "nil", "\n", "}" ]

[ "CreateUserWithoutOTP", "creates", "an", "account", "with", "the", "provided", "password", "and", "deletes", "the", "token", "afterwards", "." ]

[ "func", "NewStaticTokens", "(", "spec", "StaticTokensSpecV2", ")", "(", "StaticTokens", ",", "error", ")", "{", "st", ":=", "StaticTokensV2", "{", "Kind", ":", "KindStaticTokens", ",", "Version", ":", "V2", ",", "Metadata", ":", "Metadata", "{", "Name", ":", "MetaNameStaticTokens", ",", "Namespace", ":", "defaults", ".", "Namespace", ",", "}", ",", "Spec", ":", "spec", ",", "}", "\n", "if", "err", ":=", "st", ".", "CheckAndSetDefaults", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "&", "st", ",", "nil", "\n", "}" ]

[ "NewStaticTokens", "is", "a", "convenience", "wrapper", "to", "create", "a", "StaticTokens", "resource", "." ]

[ "func", "GetStaticTokensSchema", "(", "extensionSchema", "string", ")", "string", "{", "var", "staticTokensSchema", "string", "\n", "if", "staticTokensSchema", "==", "\"", "\"", "{", "staticTokensSchema", "=", "fmt", ".", "Sprintf", "(", "StaticTokensSpecSchemaTemplate", ",", "\"", "\"", ")", "\n", "}", "else", "{", "staticTokensSchema", "=", "fmt", ".", "Sprintf", "(", "StaticTokensSpecSchemaTemplate", ",", "\"", "\"", "+", "extensionSchema", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "V2SchemaTemplate", ",", "MetadataSchema", ",", "staticTokensSchema", ",", "DefaultDefinitions", ")", "\n", "}" ]

[ "GetStaticTokensSchema", "returns", "the", "schema", "with", "optionally", "injected", "schema", "for", "extensions", "." ]

[ "func", "(", "t", "*", "TeleportStaticTokensMarshaler", ")", "Unmarshal", "(", "bytes", "[", "]", "byte", ",", "opts", "...", "MarshalOption", ")", "(", "StaticTokens", ",", "error", ")", "{", "var", "staticTokens", "StaticTokensV2", "\n\n", "if", "len", "(", "bytes", ")", "==", "0", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n\n", "cfg", ",", "err", ":=", "collectOptions", "(", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "if", "cfg", ".", "SkipValidation", "{", "if", "err", ":=", "utils", ".", "FastUnmarshal", "(", "bytes", ",", "&", "staticTokens", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "else", "{", "err", "=", "utils", ".", "UnmarshalWithSchema", "(", "GetStaticTokensSchema", "(", "\"", "\"", ")", ",", "&", "staticTokens", ",", "bytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "err", "=", "staticTokens", ".", "CheckAndSetDefaults", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "if", "cfg", ".", "ID", "!=", "0", "{", "staticTokens", ".", "SetResourceID", "(", "cfg", ".", "ID", ")", "\n", "}", "\n", "if", "!", "cfg", ".", "Expires", ".", "IsZero", "(", ")", "{", "staticTokens", ".", "SetExpiry", "(", "cfg", ".", "Expires", ")", "\n", "}", "\n", "return", "&", "staticTokens", ",", "nil", "\n", "}" ]

[ "Unmarshal", "unmarshals", "StaticTokens", "from", "JSON", "." ]

[ "func", "(", "t", "*", "TeleportStaticTokensMarshaler", ")", "Marshal", "(", "c", "StaticTokens", ",", "opts", "...", "MarshalOption", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "cfg", ",", "err", ":=", "collectOptions", "(", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "switch", "resource", ":=", "c", ".", "(", "type", ")", "{", "case", "*", "StaticTokensV2", ":", "if", "!", "cfg", ".", "PreserveResourceID", "{", "// avoid modifying the original object", "// to prevent unexpected data races", "copy", ":=", "*", "resource", "\n", "copy", ".", "SetResourceID", "(", "0", ")", "\n", "resource", "=", "&", "copy", "\n", "}", "\n", "return", "utils", ".", "FastMarshal", "(", "resource", ")", "\n", "default", ":", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "c", ")", "\n", "}", "\n", "}" ]

[ "Marshal", "marshals", "StaticTokens", "to", "JSON", "." ]

[ "func", "(", "s", "*", "CA", ")", "DeleteAllCertAuthorities", "(", "caType", "services", ".", "CertAuthType", ")", "error", "{", "startKey", ":=", "backend", ".", "Key", "(", "authoritiesPrefix", ",", "string", "(", "caType", ")", ")", "\n", "return", "s", ".", "DeleteRange", "(", "context", ".", "TODO", "(", ")", ",", "startKey", ",", "backend", ".", "RangeEnd", "(", "startKey", ")", ")", "\n", "}" ]

[ "DeleteAllCertAuthorities", "deletes", "all", "certificate", "authorities", "of", "a", "certain", "type" ]

[ "func", "(", "s", "*", "CA", ")", "CreateCertAuthority", "(", "ca", "services", ".", "CertAuthority", ")", "error", "{", "if", "err", ":=", "ca", ".", "Check", "(", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "value", ",", "err", ":=", "services", ".", "GetCertAuthorityMarshaler", "(", ")", ".", "MarshalCertAuthority", "(", "ca", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "item", ":=", "backend", ".", "Item", "{", "Key", ":", "backend", ".", "Key", "(", "authoritiesPrefix", ",", "string", "(", "ca", ".", "GetType", "(", ")", ")", ",", "ca", ".", "GetName", "(", ")", ")", ",", "Value", ":", "value", ",", "Expires", ":", "ca", ".", "Expiry", "(", ")", ",", "}", "\n\n", "_", ",", "err", "=", "s", ".", "Create", "(", "context", ".", "TODO", "(", ")", ",", "item", ")", "\n", "if", "err", "!=", "nil", "{", "if", "trace", ".", "IsAlreadyExists", "(", "err", ")", "{", "return", "trace", ".", "AlreadyExists", "(", "\"", "\"", ",", "ca", ".", "GetName", "(", ")", ")", "\n", "}", "\n", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CreateCertAuthority", "updates", "or", "inserts", "a", "new", "certificate", "authority" ]

[ "func", "(", "s", "*", "CA", ")", "UpsertCertAuthority", "(", "ca", "services", ".", "CertAuthority", ")", "error", "{", "if", "err", ":=", "ca", ".", "Check", "(", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "value", ",", "err", ":=", "services", ".", "GetCertAuthorityMarshaler", "(", ")", ".", "MarshalCertAuthority", "(", "ca", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "item", ":=", "backend", ".", "Item", "{", "Key", ":", "backend", ".", "Key", "(", "authoritiesPrefix", ",", "string", "(", "ca", ".", "GetType", "(", ")", ")", ",", "ca", ".", "GetName", "(", ")", ")", ",", "Value", ":", "value", ",", "Expires", ":", "ca", ".", "Expiry", "(", ")", ",", "ID", ":", "ca", ".", "GetResourceID", "(", ")", ",", "}", "\n\n", "_", ",", "err", "=", "s", ".", "Put", "(", "context", ".", "TODO", "(", ")", ",", "item", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "UpsertCertAuthority", "updates", "or", "inserts", "a", "new", "certificate", "authority" ]

[ "func", "(", "s", "*", "CA", ")", "CompareAndSwapCertAuthority", "(", "new", ",", "existing", "services", ".", "CertAuthority", ")", "error", "{", "if", "err", ":=", "new", ".", "Check", "(", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "newValue", ",", "err", ":=", "services", ".", "GetCertAuthorityMarshaler", "(", ")", ".", "MarshalCertAuthority", "(", "new", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "newItem", ":=", "backend", ".", "Item", "{", "Key", ":", "backend", ".", "Key", "(", "authoritiesPrefix", ",", "string", "(", "new", ".", "GetType", "(", ")", ")", ",", "new", ".", "GetName", "(", ")", ")", ",", "Value", ":", "newValue", ",", "Expires", ":", "new", ".", "Expiry", "(", ")", ",", "}", "\n\n", "existingValue", ",", "err", ":=", "services", ".", "GetCertAuthorityMarshaler", "(", ")", ".", "MarshalCertAuthority", "(", "existing", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "existingItem", ":=", "backend", ".", "Item", "{", "Key", ":", "backend", ".", "Key", "(", "authoritiesPrefix", ",", "string", "(", "existing", ".", "GetType", "(", ")", ")", ",", "existing", ".", "GetName", "(", ")", ")", ",", "Value", ":", "existingValue", ",", "Expires", ":", "existing", ".", "Expiry", "(", ")", ",", "}", "\n\n", "_", ",", "err", "=", "s", ".", "CompareAndSwap", "(", "context", ".", "TODO", "(", ")", ",", "existingItem", ",", "newItem", ")", "\n", "if", "err", "!=", "nil", "{", "if", "trace", ".", "IsCompareFailed", "(", "err", ")", "{", "return", "trace", ".", "CompareFailed", "(", "\"", "\"", ",", "new", ".", "GetName", "(", ")", ")", "\n", "}", "\n", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CompareAndSwapCertAuthority", "updates", "the", "cert", "authority", "value", "if", "the", "existing", "value", "matches", "existing", "parameter", "returns", "nil", "if", "succeeds", "trace", ".", "CompareFailed", "otherwise", "." ]

[ "func", "(", "s", "*", "CA", ")", "DeleteCertAuthority", "(", "id", "services", ".", "CertAuthID", ")", "error", "{", "if", "err", ":=", "id", ".", "Check", "(", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "// when removing a services.CertAuthority also remove any deactivated", "// services.CertAuthority as well if they exist.", "err", ":=", "s", ".", "Delete", "(", "context", ".", "TODO", "(", ")", ",", "backend", ".", "Key", "(", "authoritiesPrefix", ",", "deactivatedPrefix", ",", "string", "(", "id", ".", "Type", ")", ",", "id", ".", "DomainName", ")", ")", "\n", "if", "err", "!=", "nil", "{", "if", "!", "trace", ".", "IsNotFound", "(", "err", ")", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "}", "\n", "err", "=", "s", ".", "Delete", "(", "context", ".", "TODO", "(", ")", ",", "backend", ".", "Key", "(", "authoritiesPrefix", ",", "string", "(", "id", ".", "Type", ")", ",", "id", ".", "DomainName", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "DeleteCertAuthority", "deletes", "particular", "certificate", "authority" ]

[ "func", "(", "s", "*", "CA", ")", "ActivateCertAuthority", "(", "id", "services", ".", "CertAuthID", ")", "error", "{", "item", ",", "err", ":=", "s", ".", "Get", "(", "context", ".", "TODO", "(", ")", ",", "backend", ".", "Key", "(", "authoritiesPrefix", ",", "deactivatedPrefix", ",", "string", "(", "id", ".", "Type", ")", ",", "id", ".", "DomainName", ")", ")", "\n", "if", "err", "!=", "nil", "{", "if", "trace", ".", "IsNotFound", "(", "err", ")", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "id", ".", "DomainName", ")", "\n", "}", "\n", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "certAuthority", ",", "err", ":=", "services", ".", "GetCertAuthorityMarshaler", "(", ")", ".", "UnmarshalCertAuthority", "(", "item", ".", "Value", ",", "services", ".", "WithResourceID", "(", "item", ".", "ID", ")", ",", "services", ".", "WithExpires", "(", "item", ".", "Expires", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "err", "=", "s", ".", "UpsertCertAuthority", "(", "certAuthority", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "err", "=", "s", ".", "Delete", "(", "context", ".", "TODO", "(", ")", ",", "backend", ".", "Key", "(", "authoritiesPrefix", ",", "deactivatedPrefix", ",", "string", "(", "id", ".", "Type", ")", ",", "id", ".", "DomainName", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "ActivateCertAuthority", "moves", "a", "CertAuthority", "from", "the", "deactivated", "list", "to", "the", "normal", "list", "." ]

[ "func", "(", "s", "*", "CA", ")", "DeactivateCertAuthority", "(", "id", "services", ".", "CertAuthID", ")", "error", "{", "certAuthority", ",", "err", ":=", "s", ".", "GetCertAuthority", "(", "id", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "if", "trace", ".", "IsNotFound", "(", "err", ")", "{", "return", "trace", ".", "NotFound", "(", "\"", "\"", ",", "id", ".", "DomainName", ")", "\n", "}", "\n", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "err", "=", "s", ".", "DeleteCertAuthority", "(", "id", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "value", ",", "err", ":=", "services", ".", "GetCertAuthorityMarshaler", "(", ")", ".", "MarshalCertAuthority", "(", "certAuthority", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "item", ":=", "backend", ".", "Item", "{", "Key", ":", "backend", ".", "Key", "(", "authoritiesPrefix", ",", "deactivatedPrefix", ",", "string", "(", "id", ".", "Type", ")", ",", "id", ".", "DomainName", ")", ",", "Value", ":", "value", ",", "Expires", ":", "certAuthority", ".", "Expiry", "(", ")", ",", "ID", ":", "certAuthority", ".", "GetResourceID", "(", ")", ",", "}", "\n\n", "_", ",", "err", "=", "s", ".", "Put", "(", "context", ".", "TODO", "(", ")", ",", "item", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "DeactivateCertAuthority", "moves", "a", "CertAuthority", "from", "the", "normal", "list", "to", "the", "deactivated", "list", "." ]

[ "func", "newSession", "(", "client", "*", "NodeClient", ",", "joinSession", "*", "session", ".", "Session", ",", "env", "map", "[", "string", "]", "string", ",", "stdin", "io", ".", "Reader", ",", "stdout", "io", ".", "Writer", ",", "stderr", "io", ".", "Writer", ")", "(", "*", "NodeSession", ",", "error", ")", "{", "if", "stdin", "==", "nil", "{", "stdin", "=", "os", ".", "Stdin", "\n", "}", "\n", "if", "stdout", "==", "nil", "{", "stdout", "=", "os", ".", "Stdout", "\n", "}", "\n", "if", "stderr", "==", "nil", "{", "stderr", "=", "os", ".", "Stderr", "\n", "}", "\n", "if", "env", "==", "nil", "{", "env", "=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "}", "\n\n", "var", "err", "error", "\n", "ns", ":=", "&", "NodeSession", "{", "env", ":", "env", ",", "nodeClient", ":", "client", ",", "stdin", ":", "stdin", ",", "stdout", ":", "stdout", ",", "stderr", ":", "stderr", ",", "namespace", ":", "client", ".", "Namespace", ",", "closer", ":", "utils", ".", "NewCloseBroadcaster", "(", ")", ",", "}", "\n", "// if we're joining an existing session, we need to assume that session's", "// existing/current terminal size:", "if", "joinSession", "!=", "nil", "{", "ns", ".", "id", "=", "joinSession", ".", "ID", "\n", "ns", ".", "namespace", "=", "joinSession", ".", "Namespace", "\n", "tsize", ":=", "joinSession", ".", "TerminalParams", ".", "Winsize", "(", ")", "\n", "if", "ns", ".", "isTerminalAttached", "(", ")", "{", "err", "=", "term", ".", "SetWinsize", "(", "0", ",", "tsize", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Error", "(", "err", ")", "\n", "}", "\n", "os", ".", "Stdout", ".", "Write", "(", "[", "]", "byte", "(", "fmt", ".", "Sprintf", "(", "\"", "\\x1b", "\"", ",", "tsize", ".", "Height", ",", "tsize", ".", "Width", ")", ")", ")", "\n", "}", "\n", "// new session!", "}", "else", "{", "sid", ",", "ok", ":=", "ns", ".", "env", "[", "sshutils", ".", "SessionEnvVar", "]", "\n", "if", "!", "ok", "{", "sid", "=", "string", "(", "session", ".", "NewID", "(", ")", ")", "\n", "}", "\n", "ns", ".", "id", "=", "session", ".", "ID", "(", "sid", ")", "\n", "}", "\n", "ns", ".", "env", "[", "sshutils", ".", "SessionEnvVar", "]", "=", "string", "(", "ns", ".", "id", ")", "\n", "return", "ns", ",", "nil", "\n", "}" ]

[ "newSession", "creates", "a", "new", "Teleport", "session", "with", "the", "given", "remote", "node", "if", "joinSessin", "is", "given", "the", "session", "will", "join", "the", "existing", "session", "of", "another", "user" ]

[ "func", "(", "ns", "*", "NodeSession", ")", "interactiveSession", "(", "callback", "interactiveCallback", ")", "error", "{", "// determine what kind of a terminal we need", "termType", ":=", "os", ".", "Getenv", "(", "\"", "\"", ")", "\n", "if", "termType", "==", "\"", "\"", "{", "termType", "=", "teleport", ".", "SafeTerminalType", "\n", "}", "\n", "// create the server-side session:", "sess", ",", "err", ":=", "ns", ".", "createServerSession", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "// allocate terminal on the server:", "remoteTerm", ",", "err", ":=", "ns", ".", "allocateTerminal", "(", "termType", ",", "sess", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "defer", "remoteTerm", ".", "Close", "(", ")", "\n\n", "// call the passed callback and give them the established", "// ssh session:", "if", "err", ":=", "callback", "(", "sess", ",", "remoteTerm", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// Catch term signals, but only if we're attached to a real terminal", "if", "ns", ".", "isTerminalAttached", "(", ")", "{", "ns", ".", "watchSignals", "(", "remoteTerm", ")", "\n", "}", "\n\n", "// start piping input into the remote shell and pipe the output from", "// the remote shell into stdout:", "ns", ".", "pipeInOut", "(", "remoteTerm", ")", "\n\n", "// switch the terminal to raw mode (and switch back on exit!)", "if", "ns", ".", "isTerminalAttached", "(", ")", "{", "ts", ",", "err", ":=", "term", ".", "SetRawTerminal", "(", "0", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warn", "(", "err", ")", "\n", "}", "else", "{", "defer", "term", ".", "RestoreTerminal", "(", "0", ",", "ts", ")", "\n", "}", "\n", "}", "\n", "// wait for the session to end", "<-", "ns", ".", "closer", ".", "C", "\n", "return", "nil", "\n", "}" ]

[ "interactiveSession", "creates", "an", "interactive", "session", "on", "the", "remote", "node", "executes", "the", "given", "callback", "on", "it", "and", "waits", "for", "the", "session", "to", "end" ]

[ "func", "(", "ns", "*", "NodeSession", ")", "runShell", "(", "callback", "ShellCreatedCallback", ")", "error", "{", "return", "ns", ".", "interactiveSession", "(", "func", "(", "s", "*", "ssh", ".", "Session", ",", "shell", "io", ".", "ReadWriteCloser", ")", "error", "{", "// start the shell on the server:", "if", "err", ":=", "s", ".", "Shell", "(", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "// call the client-supplied callback", "if", "callback", "!=", "nil", "{", "exit", ",", "err", ":=", "callback", "(", "s", ",", "ns", ".", "NodeClient", "(", ")", ".", "Client", ",", "shell", ")", "\n", "if", "exit", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "runShell", "executes", "user", "s", "shell", "on", "the", "remote", "node", "under", "an", "interactive", "session" ]

[ "func", "(", "ns", "*", "NodeSession", ")", "watchSignals", "(", "shell", "io", ".", "Writer", ")", "{", "exitSignals", ":=", "make", "(", "chan", "os", ".", "Signal", ",", "1", ")", "\n", "// catch SIGTERM", "signal", ".", "Notify", "(", "exitSignals", ",", "syscall", ".", "SIGTERM", ")", "\n", "go", "func", "(", ")", "{", "defer", "ns", ".", "closer", ".", "Close", "(", ")", "\n", "<-", "exitSignals", "\n", "}", "(", ")", "\n", "// Catch Ctrl-C signal", "ctrlCSignal", ":=", "make", "(", "chan", "os", ".", "Signal", ",", "1", ")", "\n", "signal", ".", "Notify", "(", "ctrlCSignal", ",", "syscall", ".", "SIGINT", ")", "\n", "go", "func", "(", ")", "{", "for", "{", "<-", "ctrlCSignal", "\n", "_", ",", "err", ":=", "shell", ".", "Write", "(", "[", "]", "byte", "{", "3", "}", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "// Catch Ctrl-Z signal", "ctrlZSignal", ":=", "make", "(", "chan", "os", ".", "Signal", ",", "1", ")", "\n", "signal", ".", "Notify", "(", "ctrlZSignal", ",", "syscall", ".", "SIGTSTP", ")", "\n", "go", "func", "(", ")", "{", "for", "{", "<-", "ctrlZSignal", "\n", "_", ",", "err", ":=", "shell", ".", "Write", "(", "[", "]", "byte", "{", "26", "}", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "}" ]

[ "watchSignals", "register", "UNIX", "signal", "handlers", "and", "properly", "terminates", "a", "remote", "shell", "session", "must", "be", "called", "as", "a", "goroutine", "right", "after", "a", "remote", "shell", "is", "created" ]

[ "func", "(", "c", "*", "Config", ")", "CheckAndSetDefaults", "(", ")", "error", "{", "if", "c", ".", "Listener", "==", "nil", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "Context", "==", "nil", "{", "c", ".", "Context", "=", "context", ".", "TODO", "(", ")", "\n", "}", "\n", "if", "c", ".", "ReadDeadline", "==", "0", "{", "c", ".", "ReadDeadline", "=", "defaults", ".", "ReadHeadersTimeout", "\n", "}", "\n", "if", "c", ".", "Clock", "==", "nil", "{", "c", ".", "Clock", "=", "clockwork", ".", "NewRealClock", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CheckAndSetDefaults", "verifies", "configuration", "and", "sets", "defaults" ]

[ "func", "New", "(", "cfg", "Config", ")", "(", "*", "Mux", ",", "error", ")", "{", "if", "err", ":=", "cfg", ".", "CheckAndSetDefaults", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "cfg", ".", "Context", ")", "\n", "waitContext", ",", "waitCancel", ":=", "context", ".", "WithCancel", "(", "context", ".", "TODO", "(", ")", ")", "\n", "return", "&", "Mux", "{", "Entry", ":", "log", ".", "WithFields", "(", "log", ".", "Fields", "{", "trace", ".", "Component", ":", "teleport", ".", "Component", "(", "\"", "\"", ",", "cfg", ".", "ID", ")", ",", "}", ")", ",", "Config", ":", "cfg", ",", "context", ":", "ctx", ",", "cancel", ":", "cancel", ",", "sshListener", ":", "newListener", "(", "ctx", ",", "cfg", ".", "Listener", ".", "Addr", "(", ")", ")", ",", "tlsListener", ":", "newListener", "(", "ctx", ",", "cfg", ".", "Listener", ".", "Addr", "(", ")", ")", ",", "waitContext", ":", "waitContext", ",", "waitCancel", ":", "waitCancel", ",", "}", ",", "nil", "\n", "}" ]

[ "New", "returns", "a", "new", "instance", "of", "multiplexer" ]

[ "func", "(", "m", "*", "Mux", ")", "Serve", "(", ")", "error", "{", "defer", "m", ".", "waitCancel", "(", ")", "\n", "backoffTimer", ":=", "time", ".", "NewTicker", "(", "5", "*", "time", ".", "Second", ")", "\n", "defer", "backoffTimer", ".", "Stop", "(", ")", "\n", "for", "{", "conn", ",", "err", ":=", "m", ".", "Listener", ".", "Accept", "(", ")", "\n", "if", "err", "==", "nil", "{", "if", "tcpConn", ",", "ok", ":=", "conn", ".", "(", "*", "net", ".", "TCPConn", ")", ";", "ok", "{", "tcpConn", ".", "SetKeepAlive", "(", "true", ")", "\n", "tcpConn", ".", "SetKeepAlivePeriod", "(", "3", "*", "time", ".", "Minute", ")", "\n", "}", "\n", "go", "m", ".", "detectAndForward", "(", "conn", ")", "\n", "continue", "\n", "}", "\n", "if", "m", ".", "isClosed", "(", ")", "{", "return", "nil", "\n", "}", "\n", "select", "{", "case", "<-", "backoffTimer", ".", "C", ":", "m", ".", "Debugf", "(", "\"", "\"", ",", "trace", ".", "DebugReport", "(", "err", ")", ")", "\n", "case", "<-", "m", ".", "context", ".", "Done", "(", ")", ":", "return", "nil", "\n", "}", "\n", "}", "\n", "}" ]

[ "Serve", "is", "a", "blocking", "function", "that", "serves", "on", "the", "listening", "socket", "and", "accepts", "requests", ".", "Every", "request", "is", "served", "in", "a", "separate", "goroutine" ]

[ "func", "(", "g", "*", "GRPCServer", ")", "SendKeepAlives", "(", "stream", "proto", ".", "AuthService_SendKeepAlivesServer", ")", "error", "{", "defer", "stream", ".", "SendAndClose", "(", "&", "empty", ".", "Empty", "{", "}", ")", "\n", "auth", ",", "err", ":=", "g", ".", "authenticate", "(", "stream", ".", "Context", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trail", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n", "g", ".", "Debugf", "(", "\"", "\"", ",", "auth", ".", "User", ".", "GetName", "(", ")", ")", "\n", "for", "{", "keepAlive", ",", "err", ":=", "stream", ".", "Recv", "(", ")", "\n", "if", "err", "==", "io", ".", "EOF", "{", "g", ".", "Debugf", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "g", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "trail", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n", "err", "=", "auth", ".", "KeepAliveNode", "(", "stream", ".", "Context", "(", ")", ",", "*", "keepAlive", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trail", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "SendKeepAlives", "allows", "node", "to", "send", "a", "stream", "of", "keep", "alive", "requests" ]

[ "func", "(", "g", "*", "GRPCServer", ")", "WatchEvents", "(", "watch", "*", "proto", ".", "Watch", ",", "stream", "proto", ".", "AuthService_WatchEventsServer", ")", "error", "{", "auth", ",", "err", ":=", "g", ".", "authenticate", "(", "stream", ".", "Context", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trail", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n", "servicesWatch", ":=", "services", ".", "Watch", "{", "Name", ":", "auth", ".", "User", ".", "GetName", "(", ")", ",", "}", "\n", "for", "_", ",", "kind", ":=", "range", "watch", ".", "Kinds", "{", "servicesWatch", ".", "Kinds", "=", "append", "(", "servicesWatch", ".", "Kinds", ",", "services", ".", "WatchKind", "{", "Name", ":", "kind", ".", "Name", ",", "Kind", ":", "kind", ".", "Kind", ",", "LoadSecrets", ":", "kind", ".", "LoadSecrets", ",", "}", ")", "\n", "}", "\n", "watcher", ",", "err", ":=", "auth", ".", "NewWatcher", "(", "stream", ".", "Context", "(", ")", ",", "servicesWatch", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trail", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n", "defer", "watcher", ".", "Close", "(", ")", "\n\n", "for", "{", "select", "{", "case", "<-", "stream", ".", "Context", "(", ")", ".", "Done", "(", ")", ":", "return", "nil", "\n", "case", "<-", "watcher", ".", "Done", "(", ")", ":", "return", "trail", ".", "ToGRPC", "(", "watcher", ".", "Error", "(", ")", ")", "\n", "case", "event", ":=", "<-", "watcher", ".", "Events", "(", ")", ":", "out", ",", "err", ":=", "eventToGRPC", "(", "event", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trail", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "stream", ".", "Send", "(", "out", ")", ";", "err", "!=", "nil", "{", "return", "trail", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "WatchEvents", "returns", "a", "new", "stream", "of", "cluster", "events" ]

[ "func", "(", "g", "*", "GRPCServer", ")", "UpsertNode", "(", "ctx", "context", ".", "Context", ",", "server", "*", "services", ".", "ServerV2", ")", "(", "*", "services", ".", "KeepAlive", ",", "error", ")", "{", "auth", ",", "err", ":=", "g", ".", "authenticate", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trail", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n", "keepAlive", ",", "err", ":=", "auth", ".", "UpsertNode", "(", "server", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trail", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n", "return", "keepAlive", ",", "nil", "\n", "}" ]

[ "UpsertNode", "upserts", "node" ]

[ "func", "(", "g", "*", "GRPCServer", ")", "authenticate", "(", "ctx", "context", ".", "Context", ")", "(", "*", "grpcContext", ",", "error", ")", "{", "// HTTPS server expects auth context to be set by the auth middleware", "authContext", ",", "err", ":=", "g", ".", "Authorizer", ".", "Authorize", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "// propagate connection problem error so we can differentiate", "// between connection failed and access denied", "if", "trace", ".", "IsConnectionProblem", "(", "err", ")", "{", "return", "nil", ",", "trace", ".", "ConnectionProblem", "(", "err", ",", "\"", "\"", ")", "\n", "}", "else", "if", "trace", ".", "IsAccessDenied", "(", "err", ")", "{", "// don't print stack trace, just log the warning", "log", ".", "Warn", "(", "err", ")", "\n", "}", "else", "{", "log", ".", "Warn", "(", "trace", ".", "DebugReport", "(", "err", ")", ")", "\n", "}", "\n", "return", "nil", ",", "trace", ".", "AccessDenied", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "&", "grpcContext", "{", "AuthContext", ":", "authContext", ",", "AuthWithRoles", ":", "&", "AuthWithRoles", "{", "authServer", ":", "g", ".", "AuthServer", ",", "user", ":", "authContext", ".", "User", ",", "checker", ":", "authContext", ".", "Checker", ",", "sessions", ":", "g", ".", "SessionService", ",", "alog", ":", "g", ".", "AuthServer", ".", "IAuditLog", ",", "}", ",", "}", ",", "nil", "\n", "}" ]

[ "authenticate", "extracts", "authentication", "context", "and", "returns", "initialized", "auth", "server" ]

[ "func", "NewGRPCServer", "(", "cfg", "APIConfig", ")", "http", ".", "Handler", "{", "authServer", ":=", "&", "GRPCServer", "{", "APIConfig", ":", "cfg", ",", "Entry", ":", "logrus", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "trace", ".", "Component", ":", "teleport", ".", "Component", "(", "teleport", ".", "ComponentAuth", ",", "teleport", ".", "ComponentGRPC", ")", ",", "}", ")", ",", "httpHandler", ":", "NewAPIServer", "(", "&", "cfg", ")", ",", "grpcHandler", ":", "grpc", ".", "NewServer", "(", ")", ",", "}", "\n", "proto", ".", "RegisterAuthServiceServer", "(", "authServer", ".", "grpcHandler", ",", "authServer", ")", "\n", "return", "authServer", "\n", "}" ]

[ "NewGRPCServer", "returns", "a", "new", "instance", "of", "GRPC", "server" ]

[ "func", "(", "g", "*", "GRPCServer", ")", "ServeHTTP", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "// magic combo match signifying GRPC request", "// https://grpc.io/blog/coreos", "if", "r", ".", "ProtoMajor", "==", "2", "&&", "strings", ".", "Contains", "(", "r", ".", "Header", ".", "Get", "(", "\"", "\"", ")", ",", "\"", "\"", ")", "{", "g", ".", "grpcHandler", ".", "ServeHTTP", "(", "w", ",", "r", ")", "\n", "}", "else", "{", "g", ".", "httpHandler", ".", "ServeHTTP", "(", "w", ",", "r", ")", "\n", "}", "\n", "}" ]

[ "ServeHTTP", "dispatches", "requests", "based", "on", "the", "request", "type" ]

[ "func", "(", "t", "*", "proxySitesSubsys", ")", "Start", "(", "sconn", "*", "ssh", ".", "ServerConn", ",", "ch", "ssh", ".", "Channel", ",", "req", "*", "ssh", ".", "Request", ",", "ctx", "*", "srv", ".", "ServerContext", ")", "error", "{", "log", ".", "Debugf", "(", "\"", "\"", ",", "ctx", ")", "\n", "remoteSites", ":=", "t", ".", "srv", ".", "proxyTun", ".", "GetSites", "(", ")", "\n\n", "// build an arary of services.Site structures:", "retval", ":=", "make", "(", "[", "]", "services", ".", "Site", ",", "0", ",", "len", "(", "remoteSites", ")", ")", "\n", "for", "_", ",", "s", ":=", "range", "remoteSites", "{", "retval", "=", "append", "(", "retval", ",", "services", ".", "Site", "{", "Name", ":", "s", ".", "GetName", "(", ")", ",", "Status", ":", "s", ".", "GetStatus", "(", ")", ",", "LastConnected", ":", "s", ".", "GetLastConnected", "(", ")", ",", "}", ")", "\n", "}", "\n", "// serialize them into JSON and write back:", "data", ",", "err", ":=", "json", ".", "Marshal", "(", "retval", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "_", ",", "err", ":=", "ch", ".", "Write", "(", "data", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Start", "serves", "a", "request", "for", "proxysites", "custom", "SSH", "subsystem", ".", "It", "builds", "an", "array", "of", "service", ".", "Site", "structures", "and", "writes", "it", "serialized", "as", "JSON", "back", "to", "the", "SSH", "client" ]

[ "func", "(", "m", "*", "MultiLog", ")", "Close", "(", ")", "error", "{", "var", "errors", "[", "]", "error", "\n", "for", "_", ",", "log", ":=", "range", "m", ".", "loggers", "{", "errors", "=", "append", "(", "errors", ",", "log", ".", "Close", "(", ")", ")", "\n", "}", "\n", "return", "trace", ".", "NewAggregate", "(", "errors", "...", ")", "\n", "}" ]

[ "Closer", "releases", "connections", "and", "resources", "associated", "with", "logs", "if", "any" ]

[ "func", "(", "proxy", "*", "ProxyClient", ")", "FindServersByLabels", "(", "ctx", "context", ".", "Context", ",", "namespace", "string", ",", "labels", "map", "[", "string", "]", "string", ")", "(", "[", "]", "services", ".", "Server", ",", "error", ")", "{", "if", "namespace", "==", "\"", "\"", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "auth", ".", "MissingNamespaceError", ")", "\n", "}", "\n", "nodes", ":=", "make", "(", "[", "]", "services", ".", "Server", ",", "0", ")", "\n", "site", ",", "err", ":=", "proxy", ".", "CurrentClusterAccessPoint", "(", "ctx", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "siteNodes", ",", "err", ":=", "site", ".", "GetNodes", "(", "namespace", ",", "services", ".", "SkipValidation", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// look at every node on this site and see which ones match:", "for", "_", ",", "node", ":=", "range", "siteNodes", "{", "if", "node", ".", "MatchAgainst", "(", "labels", ")", "{", "nodes", "=", "append", "(", "nodes", ",", "node", ")", "\n", "}", "\n", "}", "\n", "return", "nodes", ",", "nil", "\n", "}" ]

[ "FindServersByLabels", "returns", "list", "of", "the", "nodes", "which", "have", "labels", "exactly", "matching", "the", "given", "label", "set", ".", "A", "server", "is", "matched", "when", "ALL", "labels", "match", ".", "If", "no", "labels", "are", "passed", "ALL", "nodes", "are", "returned", "." ]

[ "func", "(", "proxy", "*", "ProxyClient", ")", "CurrentClusterAccessPoint", "(", "ctx", "context", ".", "Context", ",", "quiet", "bool", ")", "(", "auth", ".", "AccessPoint", ",", "error", ")", "{", "// get the current cluster:", "cluster", ",", "err", ":=", "proxy", ".", "currentCluster", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "proxy", ".", "ClusterAccessPoint", "(", "ctx", ",", "cluster", ".", "Name", ",", "quiet", ")", "\n", "}" ]

[ "CurrentClusterAccessPoint", "returns", "cluster", "access", "point", "to", "the", "currently", "selected", "cluster", "and", "is", "used", "for", "discovery", "and", "could", "be", "cached", "based", "on", "the", "access", "policy" ]

[ "func", "(", "proxy", "*", "ProxyClient", ")", "ClusterAccessPoint", "(", "ctx", "context", ".", "Context", ",", "clusterName", "string", ",", "quiet", "bool", ")", "(", "auth", ".", "AccessPoint", ",", "error", ")", "{", "if", "clusterName", "==", "\"", "\"", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "clt", ",", "err", ":=", "proxy", ".", "ConnectToCluster", "(", "ctx", ",", "clusterName", ",", "quiet", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "proxy", ".", "teleportClient", ".", "accessPoint", "(", "clt", ",", "proxy", ".", "proxyAddress", ",", "clusterName", ")", "\n", "}" ]

[ "ClusterAccessPoint", "returns", "cluster", "access", "point", "used", "for", "discovery", "and", "could", "be", "cached", "based", "on", "the", "access", "policy" ]

[ "func", "(", "proxy", "*", "ProxyClient", ")", "ConnectToCurrentCluster", "(", "ctx", "context", ".", "Context", ",", "quiet", "bool", ")", "(", "auth", ".", "ClientI", ",", "error", ")", "{", "cluster", ",", "err", ":=", "proxy", ".", "currentCluster", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "proxy", ".", "ConnectToCluster", "(", "ctx", ",", "cluster", ".", "Name", ",", "quiet", ")", "\n", "}" ]

[ "ConnectToCurrentCluster", "connects", "to", "the", "auth", "server", "of", "the", "currently", "selected", "cluster", "via", "proxy", ".", "It", "returns", "connected", "and", "authenticated", "auth", "server", "client", "if", "quiet", "is", "set", "to", "true", "no", "errors", "will", "be", "printed", "to", "stdout", "otherwise", "any", "connection", "errors", "are", "visible", "to", "a", "user", "." ]

[ "func", "(", "proxy", "*", "ProxyClient", ")", "ConnectToCluster", "(", "ctx", "context", ".", "Context", ",", "clusterName", "string", ",", "quiet", "bool", ")", "(", "auth", ".", "ClientI", ",", "error", ")", "{", "dialer", ":=", "func", "(", "ctx", "context", ".", "Context", ",", "network", ",", "_", "string", ")", "(", "net", ".", "Conn", ",", "error", ")", "{", "return", "proxy", ".", "dialAuthServer", "(", "ctx", ",", "clusterName", ")", "\n", "}", "\n\n", "if", "proxy", ".", "teleportClient", ".", "SkipLocalAuth", "{", "return", "auth", ".", "NewTLSClient", "(", "auth", ".", "ClientConfig", "{", "DialContext", ":", "dialer", ",", "TLS", ":", "proxy", ".", "teleportClient", ".", "TLS", ",", "}", ")", "\n", "}", "\n\n", "// Because Teleport clients can't be configured (yet), they take the default", "// list of cipher suites from Go.", "tlsConfig", ":=", "utils", ".", "TLSConfig", "(", "nil", ")", "\n", "localAgent", ":=", "proxy", ".", "teleportClient", ".", "LocalAgent", "(", ")", "\n", "pool", ",", "err", ":=", "localAgent", ".", "GetCerts", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "tlsConfig", ".", "RootCAs", "=", "pool", "\n", "key", ",", "err", ":=", "localAgent", ".", "GetKey", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ",", "\"", "\"", ",", "proxy", ".", "teleportClient", ".", "Username", ")", "\n", "}", "\n", "if", "len", "(", "key", ".", "TLSCert", ")", "!=", "0", "{", "tlsCert", ",", "err", ":=", "tls", ".", "X509KeyPair", "(", "key", ".", "TLSCert", ",", "key", ".", "Priv", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "tlsConfig", ".", "Certificates", "=", "append", "(", "tlsConfig", ".", "Certificates", ",", "tlsCert", ")", "\n", "}", "\n", "if", "len", "(", "tlsConfig", ".", "Certificates", ")", "==", "0", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "proxy", ".", "teleportClient", ".", "Username", ")", "\n", "}", "\n", "clt", ",", "err", ":=", "auth", ".", "NewTLSClient", "(", "auth", ".", "ClientConfig", "{", "DialContext", ":", "dialer", ",", "TLS", ":", "tlsConfig", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "clt", ",", "nil", "\n", "}" ]

[ "ConnectToCluster", "connects", "to", "the", "auth", "server", "of", "the", "given", "cluster", "via", "proxy", ".", "It", "returns", "connected", "and", "authenticated", "auth", "server", "client", "if", "quiet", "is", "set", "to", "true", "no", "errors", "will", "be", "printed", "to", "stdout", "otherwise", "any", "connection", "errors", "are", "visible", "to", "a", "user", "." ]

[ "func", "(", "c", "*", "closerConn", ")", "addCloser", "(", "closer", "io", ".", "Closer", ")", "{", "c", ".", "closers", "=", "append", "(", "c", ".", "closers", ",", "closer", ")", "\n", "}" ]

[ "addCloser", "adds", "any", "closer", "in", "ctx", "that", "will", "be", "called", "whenever", "server", "closes", "session", "channel" ]

[ "func", "nodeName", "(", "node", "string", ")", "string", "{", "n", ",", "_", ",", "err", ":=", "net", ".", "SplitHostPort", "(", "node", ")", "\n", "if", "err", "!=", "nil", "{", "return", "node", "\n", "}", "\n", "return", "n", "\n", "}" ]

[ "nodeName", "removes", "the", "port", "number", "from", "the", "hostname", "if", "present" ]

[ "func", "(", "proxy", "*", "ProxyClient", ")", "isRecordingProxy", "(", ")", "(", "bool", ",", "error", ")", "{", "responseCh", ":=", "make", "(", "chan", "proxyResponse", ")", "\n\n", "// we have to run this in a goroutine because older version of Teleport handled", "// global out-of-band requests incorrectly: Teleport would ignore requests it", "// does not know about and never reply to them. So if we wait a second and", "// don't hear anything back, most likley we are trying to connect to an older", "// version of Teleport and we should not try and forward our agent.", "go", "func", "(", ")", "{", "ok", ",", "responseBytes", ",", "err", ":=", "proxy", ".", "Client", ".", "SendRequest", "(", "teleport", ".", "RecordingProxyReqType", ",", "true", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "responseCh", "<-", "proxyResponse", "{", "isRecord", ":", "false", ",", "err", ":", "trace", ".", "Wrap", "(", "err", ")", "}", "\n", "return", "\n", "}", "\n", "if", "!", "ok", "{", "responseCh", "<-", "proxyResponse", "{", "isRecord", ":", "false", ",", "err", ":", "trace", ".", "AccessDenied", "(", "\"", "\"", ")", "}", "\n", "return", "\n", "}", "\n\n", "recordingProxy", ",", "err", ":=", "strconv", ".", "ParseBool", "(", "string", "(", "responseBytes", ")", ")", "\n", "if", "err", "!=", "nil", "{", "responseCh", "<-", "proxyResponse", "{", "isRecord", ":", "false", ",", "err", ":", "trace", ".", "Wrap", "(", "err", ")", "}", "\n", "return", "\n", "}", "\n\n", "responseCh", "<-", "proxyResponse", "{", "isRecord", ":", "recordingProxy", ",", "err", ":", "nil", "}", "\n", "}", "(", ")", "\n\n", "select", "{", "case", "resp", ":=", "<-", "responseCh", ":", "if", "resp", ".", "err", "!=", "nil", "{", "return", "false", ",", "trace", ".", "Wrap", "(", "resp", ".", "err", ")", "\n", "}", "\n", "return", "resp", ".", "isRecord", ",", "nil", "\n", "case", "<-", "time", ".", "After", "(", "1", "*", "time", ".", "Second", ")", ":", "// probably the older version of the proxy or at least someone that is", "// responding incorrectly, don't forward agent to it", "return", "false", ",", "nil", "\n", "}", "\n", "}" ]

[ "isRecordingProxy", "returns", "true", "if", "the", "proxy", "is", "in", "recording", "mode", ".", "Note", "this", "function", "can", "only", "be", "called", "after", "authentication", "has", "occurred", "and", "should", "be", "called", "before", "the", "first", "session", "is", "created", "." ]

[ "func", "(", "proxy", "*", "ProxyClient", ")", "dialAuthServer", "(", "ctx", "context", ".", "Context", ",", "clusterName", "string", ")", "(", "net", ".", "Conn", ",", "error", ")", "{", "log", ".", "Debugf", "(", "\"", "\"", ",", "proxy", ".", "clientAddr", ",", "clusterName", ")", "\n\n", "address", ":=", "\"", "\"", "+", "clusterName", "\n\n", "// parse destination first:", "localAddr", ",", "err", ":=", "utils", ".", "ParseAddr", "(", "\"", "\"", "+", "proxy", ".", "proxyAddress", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "fakeAddr", ",", "err", ":=", "utils", ".", "ParseAddr", "(", "\"", "\"", "+", "address", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "proxySession", ",", "err", ":=", "proxy", ".", "Client", ".", "NewSession", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "proxyWriter", ",", "err", ":=", "proxySession", ".", "StdinPipe", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "proxyReader", ",", "err", ":=", "proxySession", ".", "StdoutPipe", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "proxyErr", ",", "err", ":=", "proxySession", ".", "StderrPipe", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "err", "=", "proxySession", ".", "RequestSubsystem", "(", "\"", "\"", "+", "address", ")", "\n", "if", "err", "!=", "nil", "{", "// read the stderr output from the failed SSH session and append", "// it to the end of our own message:", "serverErrorMsg", ",", "_", ":=", "ioutil", ".", "ReadAll", "(", "proxyErr", ")", "\n", "return", "nil", ",", "trace", ".", "ConnectionProblem", "(", "err", ",", "\"", "\"", ",", "nodeName", "(", "strings", ".", "Split", "(", "address", ",", "\"", "\"", ")", "[", "0", "]", ")", ",", "serverErrorMsg", ")", "\n", "}", "\n", "return", "utils", ".", "NewPipeNetConn", "(", "proxyReader", ",", "proxyWriter", ",", "proxySession", ",", "localAddr", ",", "fakeAddr", ",", ")", ",", "nil", "\n", "}" ]

[ "dialAuthServer", "returns", "auth", "server", "connection", "forwarded", "via", "proxy" ]

[ "func", "newClientConn", "(", "ctx", "context", ".", "Context", ",", "conn", "net", ".", "Conn", ",", "nodeAddress", "string", ",", "config", "*", "ssh", ".", "ClientConfig", ")", "(", "ssh", ".", "Conn", ",", "<-", "chan", "ssh", ".", "NewChannel", ",", "<-", "chan", "*", "ssh", ".", "Request", ",", "error", ")", "{", "type", "response", "struct", "{", "conn", "ssh", ".", "Conn", "\n", "chanCh", "<-", "chan", "ssh", ".", "NewChannel", "\n", "reqCh", "<-", "chan", "*", "ssh", ".", "Request", "\n", "err", "error", "\n", "}", "\n\n", "respCh", ":=", "make", "(", "chan", "response", ",", "1", ")", "\n", "go", "func", "(", ")", "{", "conn", ",", "chans", ",", "reqs", ",", "err", ":=", "ssh", ".", "NewClientConn", "(", "conn", ",", "nodeAddress", ",", "config", ")", "\n", "respCh", "<-", "response", "{", "conn", ",", "chans", ",", "reqs", ",", "err", "}", "\n", "}", "(", ")", "\n\n", "select", "{", "case", "resp", ":=", "<-", "respCh", ":", "if", "resp", ".", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "resp", ".", "err", ",", "\"", "\"", ",", "nodeAddress", ")", "\n", "}", "\n", "return", "resp", ".", "conn", ",", "resp", ".", "chanCh", ",", "resp", ".", "reqCh", ",", "nil", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "errClose", ":=", "conn", ".", "Close", "(", ")", "\n", "if", "errClose", "!=", "nil", "{", "log", ".", "Error", "(", "errClose", ")", "\n", "}", "\n", "// drain the channel", "resp", ":=", "<-", "respCh", "\n", "return", "nil", ",", "nil", ",", "nil", ",", "trace", ".", "ConnectionProblem", "(", "resp", ".", "err", ",", "\"", "\"", ",", "nodeAddress", ")", "\n", "}", "\n", "}" ]

[ "newClientConn", "is", "a", "wrapper", "around", "ssh", ".", "NewClientConn" ]

[ "func", "(", "c", "*", "NodeClient", ")", "listenAndForward", "(", "ctx", "context", ".", "Context", ",", "ln", "net", ".", "Listener", ",", "remoteAddr", "string", ")", "{", "defer", "ln", ".", "Close", "(", ")", "\n", "defer", "c", ".", "Close", "(", ")", "\n\n", "for", "{", "// Accept connections from the client.", "conn", ",", "err", ":=", "ln", ".", "Accept", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "break", "\n", "}", "\n\n", "// Proxy the connection to the remote address.", "go", "func", "(", ")", "{", "err", ":=", "c", ".", "proxyConnection", "(", "ctx", ",", "conn", ",", "remoteAddr", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "(", ")", "\n", "}", "\n", "}" ]

[ "listenAndForward", "listens", "on", "a", "given", "socket", "and", "forwards", "all", "incoming", "commands", "to", "the", "remote", "address", "through", "the", "SSH", "tunnel", "." ]

[ "func", "(", "c", "*", "NodeClient", ")", "dynamicListenAndForward", "(", "ctx", "context", ".", "Context", ",", "ln", "net", ".", "Listener", ")", "{", "defer", "ln", ".", "Close", "(", ")", "\n", "defer", "c", ".", "Close", "(", ")", "\n\n", "for", "{", "// Accept connection from the client. Here the client is typically", "// something like a web browser or other SOCKS5 aware application.", "conn", ",", "err", ":=", "ln", ".", "Accept", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "break", "\n", "}", "\n\n", "// Perform the SOCKS5 handshake with the client to find out the remote", "// address to proxy.", "remoteAddr", ",", "err", ":=", "socks", ".", "Handshake", "(", "conn", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "break", "\n", "}", "\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "remoteAddr", ")", "\n\n", "// Proxy the connection to the remote address.", "go", "func", "(", ")", "{", "err", ":=", "c", ".", "proxyConnection", "(", "ctx", ",", "conn", ",", "remoteAddr", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "(", ")", "\n", "}", "\n", "}" ]

[ "dynamicListenAndForward", "listens", "for", "connections", "performs", "a", "SOCKS5", "handshake", "and", "then", "proxies", "the", "connection", "to", "the", "requested", "address", "." ]

[ "func", "(", "proxy", "*", "ProxyClient", ")", "currentCluster", "(", ")", "(", "*", "services", ".", "Site", ",", "error", ")", "{", "sites", ",", "err", ":=", "proxy", ".", "GetSites", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "len", "(", "sites", ")", "==", "0", "{", "return", "nil", ",", "trace", ".", "NotFound", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "proxy", ".", "siteName", "==", "\"", "\"", "{", "return", "&", "sites", "[", "0", "]", ",", "nil", "\n", "}", "\n", "for", "_", ",", "site", ":=", "range", "sites", "{", "if", "site", ".", "Name", "==", "proxy", ".", "siteName", "{", "return", "&", "site", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "trace", ".", "NotFound", "(", "\"", "\"", ",", "proxy", ".", "siteName", ")", "\n", "}" ]

[ "currentCluster", "returns", "the", "connection", "to", "the", "API", "of", "the", "current", "cluster" ]

[ "func", "CreateDownloadCommand", "(", "cfg", "Config", ")", "(", "Command", ",", "error", ")", "{", "cfg", ".", "Flags", ".", "Sink", "=", "true", "\n", "cfg", ".", "Flags", ".", "Source", "=", "false", "\n", "cmd", ",", "err", ":=", "CreateCommand", "(", "cfg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "cmd", ",", "nil", "\n", "}" ]

[ "CreateDownloadCommand", "configures", "and", "returns", "a", "command", "used", "to", "download", "a", "file" ]

[ "func", "CreateCommand", "(", "cfg", "Config", ")", "(", "Command", ",", "error", ")", "{", "err", ":=", "cfg", ".", "CheckAndSetDefaults", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "cmd", ":=", "command", "{", "Config", ":", "cfg", ",", "}", "\n\n", "cmd", ".", "log", "=", "log", ".", "WithFields", "(", "log", ".", "Fields", "{", "trace", ".", "Component", ":", "\"", "\"", ",", "trace", ".", "ComponentFields", ":", "log", ".", "Fields", "{", "\"", "\"", ":", "cfg", ".", "Flags", ".", "LocalAddr", ",", "\"", "\"", ":", "cfg", ".", "Flags", ".", "RemoteAddr", ",", "\"", "\"", ":", "cfg", ".", "Flags", ".", "Target", ",", "\"", "\"", ":", "cfg", ".", "User", ",", "\"", "\"", ":", "cfg", ".", "RunOnServer", ",", "\"", "\"", ":", "cfg", ".", "RemoteLocation", ",", "}", ",", "}", ")", "\n\n", "return", "&", "cmd", ",", "nil", "\n", "}" ]

[ "CreateCommand", "creates", "and", "returns", "a", "new", "Command" ]

[ "func", "(", "cmd", "*", "command", ")", "sendError", "(", "ch", "io", ".", "ReadWriter", ",", "err", "error", ")", "error", "{", "if", "err", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "cmd", ".", "log", ".", "Error", "(", "err", ")", "\n", "message", ":=", "err", ".", "Error", "(", ")", "\n", "bytes", ":=", "make", "(", "[", "]", "byte", ",", "0", ",", "len", "(", "message", ")", "+", "2", ")", "\n", "bytes", "=", "append", "(", "bytes", ",", "ErrByte", ")", "\n", "bytes", "=", "append", "(", "bytes", ",", "message", "...", ")", "\n", "bytes", "=", "append", "(", "bytes", ",", "[", "]", "byte", "{", "'\\n'", "}", "...", ")", "\n", "_", ",", "writeErr", ":=", "ch", ".", "Write", "(", "bytes", ")", "\n", "if", "writeErr", "!=", "nil", "{", "cmd", ".", "log", ".", "Error", "(", "writeErr", ")", "\n", "}", "\n", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}" ]

[ "sendError", "gets", "called", "during", "all", "errors", "during", "SCP", "transmission", ".", "It", "writes", "it", "back", "to", "the", "SCP", "client" ]

[ "func", "(", "r", "*", "reader", ")", "read", "(", ")", "error", "{", "n", ",", "err", ":=", "r", ".", "r", ".", "Read", "(", "r", ".", "b", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "n", "<", "1", "{", "return", "trace", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "switch", "r", ".", "b", "[", "0", "]", "{", "case", "OKByte", ":", "return", "nil", "\n", "case", "WarnByte", ",", "ErrByte", ":", "r", ".", "s", ".", "Scan", "(", ")", "\n", "if", "err", ":=", "r", ".", "s", ".", "Err", "(", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "trace", ".", "Errorf", "(", "r", ".", "s", ".", "Text", "(", ")", ")", "\n", "}", "\n", "return", "trace", ".", "Errorf", "(", "\"", "\"", ",", "r", ".", "b", ")", "\n", "}" ]

[ "read", "is", "used", "to", "ask", "for", "response", "messages", "after", "each", "SCP", "transmission", "it", "only", "reads", "text", "data", "until", "a", "newline", "and", "returns", "nil", "for", "OK", "responses", "and", "errors", "for", "everything", "else" ]

[ "func", "(", "fs", "*", "FSLocalKeyStore", ")", "AddKey", "(", "host", ",", "username", "string", ",", "key", "*", "Key", ")", "error", "{", "dirPath", ",", "err", ":=", "fs", ".", "dirFor", "(", "host", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "writeBytes", ":=", "func", "(", "fname", "string", ",", "data", "[", "]", "byte", ")", "error", "{", "fp", ":=", "filepath", ".", "Join", "(", "dirPath", ",", "fname", ")", "\n", "err", ":=", "ioutil", ".", "WriteFile", "(", "fp", ",", "data", ",", "keyFilePerms", ")", "\n", "if", "err", "!=", "nil", "{", "fs", ".", "log", ".", "Error", "(", "err", ")", "\n", "}", "\n", "return", "err", "\n", "}", "\n", "if", "err", "=", "writeBytes", "(", "username", "+", "fileExtCert", ",", "key", ".", "Cert", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "err", "=", "writeBytes", "(", "username", "+", "fileExtTLSCert", ",", "key", ".", "TLSCert", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "err", "=", "writeBytes", "(", "username", "+", "fileExtPub", ",", "key", ".", "Pub", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "err", "=", "writeBytes", "(", "username", ",", "key", ".", "Priv", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "AddKey", "adds", "a", "new", "key", "to", "the", "session", "store", ".", "If", "a", "key", "for", "the", "host", "is", "already", "stored", "overwrites", "it", "." ]

[ "func", "(", "fs", "*", "FSLocalKeyStore", ")", "DeleteKey", "(", "host", "string", ",", "username", "string", ")", "error", "{", "dirPath", ",", "err", ":=", "fs", ".", "dirFor", "(", "host", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "files", ":=", "[", "]", "string", "{", "filepath", ".", "Join", "(", "dirPath", ",", "username", "+", "fileExtCert", ")", ",", "filepath", ".", "Join", "(", "dirPath", ",", "username", "+", "fileExtTLSCert", ")", ",", "filepath", ".", "Join", "(", "dirPath", ",", "username", "+", "fileExtPub", ")", ",", "filepath", ".", "Join", "(", "dirPath", ",", "username", ")", ",", "}", "\n", "for", "_", ",", "fn", ":=", "range", "files", "{", "if", "err", "=", "os", ".", "Remove", "(", "fn", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "DeleteKey", "deletes", "a", "key", "from", "the", "local", "store" ]

[ "func", "(", "fs", "*", "FSLocalKeyStore", ")", "DeleteKeys", "(", ")", "error", "{", "dirPath", ":=", "filepath", ".", "Join", "(", "fs", ".", "KeyDir", ",", "sessionKeyDir", ")", "\n\n", "err", ":=", "os", ".", "RemoveAll", "(", "dirPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "DeleteKeys", "removes", "all", "session", "keys", "from", "disk", "." ]

[ "func", "(", "fs", "*", "FSLocalKeyStore", ")", "GetKey", "(", "proxyHost", "string", ",", "username", "string", ")", "(", "*", "Key", ",", "error", ")", "{", "dirPath", ",", "err", ":=", "fs", ".", "dirFor", "(", "proxyHost", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "_", ",", "err", "=", "ioutil", ".", "ReadDir", "(", "dirPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "NotFound", "(", "\"", "\"", ",", "username", ",", "proxyHost", ")", "\n", "}", "\n\n", "certFile", ":=", "filepath", ".", "Join", "(", "dirPath", ",", "username", "+", "fileExtCert", ")", "\n", "cert", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "certFile", ")", "\n", "if", "err", "!=", "nil", "{", "fs", ".", "log", ".", "Error", "(", "err", ")", "\n", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "tlsCertFile", ":=", "filepath", ".", "Join", "(", "dirPath", ",", "username", "+", "fileExtTLSCert", ")", "\n", "tlsCert", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "tlsCertFile", ")", "\n", "if", "err", "!=", "nil", "{", "fs", ".", "log", ".", "Error", "(", "err", ")", "\n", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "pub", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "filepath", ".", "Join", "(", "dirPath", ",", "username", "+", "fileExtPub", ")", ")", "\n", "if", "err", "!=", "nil", "{", "fs", ".", "log", ".", "Error", "(", "err", ")", "\n", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "priv", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "filepath", ".", "Join", "(", "dirPath", ",", "username", ")", ")", "\n", "if", "err", "!=", "nil", "{", "fs", ".", "log", ".", "Error", "(", "err", ")", "\n", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "key", ":=", "&", "Key", "{", "Pub", ":", "pub", ",", "Priv", ":", "priv", ",", "Cert", ":", "cert", ",", "ProxyHost", ":", "proxyHost", ",", "TLSCert", ":", "tlsCert", "}", "\n\n", "// Validate the key loaded from disk.", "err", "=", "key", ".", "CheckCert", "(", ")", "\n", "if", "err", "!=", "nil", "{", "// KeyStore should return expired certificates as well", "if", "!", "utils", ".", "IsCertExpiredError", "(", "err", ")", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "}", "\n", "sshCertExpiration", ",", "err", ":=", "key", ".", "CertValidBefore", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "tlsCertExpiration", ",", "err", ":=", "key", ".", "TLSCertValidBefore", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// Note, we may be returning expired certificates here, that is okay. If the", "// certificates is expired, it's the responsibility of the TeleportClient to", "// perform cleanup of the certificates and the profile.", "fs", ".", "log", ".", "Debugf", "(", "\"", "\"", ",", "certFile", ",", "sshCertExpiration", ",", "tlsCertFile", ",", "tlsCertExpiration", ")", "\n\n", "return", "key", ",", "nil", "\n", "}" ]

[ "GetKey", "returns", "a", "key", "for", "a", "given", "host", ".", "If", "the", "key", "is", "not", "found", "returns", "trace", ".", "NotFound", "error", "." ]

[ "func", "(", "fs", "*", "FSLocalKeyStore", ")", "SaveCerts", "(", "proxy", "string", ",", "cas", "[", "]", "auth", ".", "TrustedCerts", ")", "error", "{", "dir", ",", "err", ":=", "fs", ".", "dirFor", "(", "proxy", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "fp", ",", "err", ":=", "os", ".", "OpenFile", "(", "filepath", ".", "Join", "(", "dir", ",", "fileNameTLSCerts", ")", ",", "os", ".", "O_CREATE", "|", "os", ".", "O_RDWR", "|", "os", ".", "O_TRUNC", ",", "0640", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "defer", "fp", ".", "Sync", "(", ")", "\n", "defer", "fp", ".", "Close", "(", ")", "\n", "for", "_", ",", "ca", ":=", "range", "cas", "{", "for", "_", ",", "cert", ":=", "range", "ca", ".", "TLSCertificates", "{", "_", ",", "err", ":=", "fp", ".", "Write", "(", "cert", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "ConvertSystemError", "(", "err", ")", "\n", "}", "\n", "_", ",", "err", "=", "fp", ".", "WriteString", "(", "\"", "\\n", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "ConvertSystemError", "(", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "SaveCerts", "saves", "trusted", "TLS", "certificates", "of", "certificate", "authorities" ]

[ "func", "(", "fs", "*", "FSLocalKeyStore", ")", "GetCertsPEM", "(", "proxy", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "dir", ",", "err", ":=", "fs", ".", "dirFor", "(", "proxy", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "ioutil", ".", "ReadFile", "(", "filepath", ".", "Join", "(", "dir", ",", "fileNameTLSCerts", ")", ")", "\n", "}" ]

[ "GetCertsPEM", "returns", "trusted", "TLS", "certificates", "of", "certificate", "authorities", "PEM", "block" ]

[ "func", "(", "fs", "*", "FSLocalKeyStore", ")", "GetCerts", "(", "proxy", "string", ")", "(", "*", "x509", ".", "CertPool", ",", "error", ")", "{", "dir", ",", "err", ":=", "fs", ".", "dirFor", "(", "proxy", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "bytes", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "filepath", ".", "Join", "(", "dir", ",", "fileNameTLSCerts", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "ConvertSystemError", "(", "err", ")", "\n", "}", "\n", "pool", ":=", "x509", ".", "NewCertPool", "(", ")", "\n", "for", "len", "(", "bytes", ")", ">", "0", "{", "var", "block", "*", "pem", ".", "Block", "\n", "block", ",", "bytes", "=", "pem", ".", "Decode", "(", "bytes", ")", "\n", "if", "block", "==", "nil", "{", "break", "\n", "}", "\n", "if", "block", ".", "Type", "!=", "\"", "\"", "||", "len", "(", "block", ".", "Headers", ")", "!=", "0", "{", "fs", ".", "log", ".", "Debugf", "(", "\"", "\"", ",", "block", ".", "Type", ",", "block", ".", "Headers", ")", "\n", "continue", "\n", "}", "\n\n", "cert", ",", "err", ":=", "x509", ".", "ParseCertificate", "(", "block", ".", "Bytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "fs", ".", "log", ".", "Debugf", "(", "\"", "\"", ",", "cert", ".", "Issuer", ")", "\n", "pool", ".", "AddCert", "(", "cert", ")", "\n", "}", "\n", "return", "pool", ",", "nil", "\n", "}" ]

[ "GetCerts", "returns", "trusted", "TLS", "certificates", "of", "certificate", "authorities" ]

[ "func", "(", "fs", "*", "FSLocalKeyStore", ")", "AddKnownHostKeys", "(", "hostname", "string", ",", "hostKeys", "[", "]", "ssh", ".", "PublicKey", ")", "error", "{", "fp", ",", "err", ":=", "os", ".", "OpenFile", "(", "filepath", ".", "Join", "(", "fs", ".", "KeyDir", ",", "fileNameKnownHosts", ")", ",", "os", ".", "O_CREATE", "|", "os", ".", "O_RDWR", ",", "0640", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "defer", "fp", ".", "Sync", "(", ")", "\n", "defer", "fp", ".", "Close", "(", ")", "\n", "// read all existing entries into a map (this removes any pre-existing dupes)", "entries", ":=", "make", "(", "map", "[", "string", "]", "int", ")", "\n", "output", ":=", "make", "(", "[", "]", "string", ",", "0", ")", "\n", "scanner", ":=", "bufio", ".", "NewScanner", "(", "fp", ")", "\n", "for", "scanner", ".", "Scan", "(", ")", "{", "line", ":=", "scanner", ".", "Text", "(", ")", "\n", "if", "_", ",", "exists", ":=", "entries", "[", "line", "]", ";", "!", "exists", "{", "output", "=", "append", "(", "output", ",", "line", ")", "\n", "entries", "[", "line", "]", "=", "1", "\n", "}", "\n", "}", "\n", "// add every host key to the list of entries", "for", "i", ":=", "range", "hostKeys", "{", "fs", ".", "log", ".", "Debugf", "(", "\"", "\"", ",", "hostname", ",", "sshutils", ".", "Fingerprint", "(", "hostKeys", "[", "i", "]", ")", ")", "\n", "bytes", ":=", "ssh", ".", "MarshalAuthorizedKey", "(", "hostKeys", "[", "i", "]", ")", "\n", "line", ":=", "strings", ".", "TrimSpace", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "hostname", ",", "bytes", ")", ")", "\n", "if", "_", ",", "exists", ":=", "entries", "[", "line", "]", ";", "!", "exists", "{", "output", "=", "append", "(", "output", ",", "line", ")", "\n", "}", "\n", "}", "\n", "// re-create the file:", "_", ",", "err", "=", "fp", ".", "Seek", "(", "0", ",", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "err", "=", "fp", ".", "Truncate", "(", "0", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "for", "_", ",", "line", ":=", "range", "output", "{", "fmt", ".", "Fprintf", "(", "fp", ",", "\"", "\\n", "\"", ",", "line", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "AddKnownHostKeys", "adds", "a", "new", "entry", "to", "known_hosts", "file" ]

[ "func", "(", "fs", "*", "FSLocalKeyStore", ")", "GetKnownHostKeys", "(", "hostname", "string", ")", "(", "[", "]", "ssh", ".", "PublicKey", ",", "error", ")", "{", "bytes", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "filepath", ".", "Join", "(", "fs", ".", "KeyDir", ",", "fileNameKnownHosts", ")", ")", "\n", "if", "err", "!=", "nil", "{", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "var", "(", "pubKey", "ssh", ".", "PublicKey", "\n", "retval", "[", "]", "ssh", ".", "PublicKey", "=", "make", "(", "[", "]", "ssh", ".", "PublicKey", ",", "0", ")", "\n", "hosts", "[", "]", "string", "\n", "hostMatch", "bool", "\n", ")", "\n", "for", "err", "==", "nil", "{", "_", ",", "hosts", ",", "pubKey", ",", "_", ",", "bytes", ",", "err", "=", "ssh", ".", "ParseKnownHosts", "(", "bytes", ")", "\n", "if", "err", "==", "nil", "{", "hostMatch", "=", "(", "hostname", "==", "\"", "\"", ")", "\n", "if", "!", "hostMatch", "{", "for", "i", ":=", "range", "hosts", "{", "if", "hosts", "[", "i", "]", "==", "hostname", "{", "hostMatch", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "hostMatch", "{", "retval", "=", "append", "(", "retval", ",", "pubKey", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "err", "!=", "io", ".", "EOF", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "retval", ",", "nil", "\n", "}" ]

[ "GetKnownHostKeys", "returns", "all", "known", "public", "keys", "from", "known_hosts" ]

[ "func", "(", "c", "*", "NodeCommand", ")", "Initialize", "(", "app", "*", "kingpin", ".", "Application", ",", "config", "*", "service", ".", "Config", ")", "{", "c", ".", "config", "=", "config", "\n\n", "// add node command", "nodes", ":=", "app", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "c", ".", "nodeAdd", "=", "nodes", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "c", ".", "nodeAdd", ".", "Flag", "(", "\"", "\"", ",", "\"", "\"", ")", ".", "Default", "(", "\"", "\"", ")", ".", "StringVar", "(", "&", "c", ".", "roles", ")", "\n", "c", ".", "nodeAdd", ".", "Flag", "(", "\"", "\"", ",", "\"", "\"", ")", ".", "Default", "(", "defaults", ".", "ProvisioningTokenTTL", ".", "String", "(", ")", ")", ".", "DurationVar", "(", "&", "c", ".", "ttl", ")", "\n", "c", ".", "nodeAdd", ".", "Flag", "(", "\"", "\"", ",", "\"", "\"", ")", ".", "StringVar", "(", "&", "c", ".", "token", ")", "\n", "c", ".", "nodeAdd", ".", "Flag", "(", "\"", "\"", ",", "\"", "\"", ")", ".", "Hidden", "(", ")", ".", "Default", "(", "\"", "\"", ")", ".", "StringVar", "(", "&", "c", ".", "format", ")", "\n", "c", ".", "nodeAdd", ".", "Alias", "(", "AddNodeHelp", ")", "\n\n", "c", ".", "nodeList", "=", "nodes", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "c", ".", "nodeList", ".", "Flag", "(", "\"", "\"", ",", "\"", "\"", ")", ".", "Default", "(", "defaults", ".", "Namespace", ")", ".", "StringVar", "(", "&", "c", ".", "namespace", ")", "\n", "c", ".", "nodeList", ".", "Alias", "(", "ListNodesHelp", ")", "\n", "}" ]

[ "Initialize", "allows", "NodeCommand", "to", "plug", "itself", "into", "the", "CLI", "parser" ]

[ "func", "(", "c", "*", "NodeCommand", ")", "Invite", "(", "client", "auth", ".", "ClientI", ")", "error", "{", "// parse --roles flag", "roles", ",", "err", ":=", "teleport", ".", "ParseRoles", "(", "c", ".", "roles", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "token", ",", "err", ":=", "client", ".", "GenerateToken", "(", "auth", ".", "GenerateTokenRequest", "{", "Roles", ":", "roles", ",", "TTL", ":", "c", ".", "ttl", ",", "Token", ":", "c", ".", "token", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// Calculate the CA pin for this cluster. The CA pin is used by the client", "// to verify the identity of the Auth Server.", "caPin", ",", "err", ":=", "calculateCAPin", "(", "client", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "authServers", ",", "err", ":=", "client", ".", "GetAuthServers", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "len", "(", "authServers", ")", "==", "0", "{", "return", "trace", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// output format swtich:", "if", "c", ".", "format", "==", "\"", "\"", "{", "if", "roles", ".", "Include", "(", "teleport", ".", "RoleTrustedCluster", ")", "||", "roles", ".", "Include", "(", "teleport", ".", "LegacyClusterTokenType", ")", "{", "fmt", ".", "Printf", "(", "trustedClusterMessage", ",", "token", ",", "int", "(", "c", ".", "ttl", ".", "Minutes", "(", ")", ")", ")", "\n", "}", "else", "{", "fmt", ".", "Printf", "(", "nodeMessage", ",", "token", ",", "int", "(", "c", ".", "ttl", ".", "Minutes", "(", ")", ")", ",", "strings", ".", "ToLower", "(", "roles", ".", "String", "(", ")", ")", ",", "token", ",", "caPin", ",", "authServers", "[", "0", "]", ".", "GetAddr", "(", ")", ",", "int", "(", "c", ".", "ttl", ".", "Minutes", "(", ")", ")", ",", "authServers", "[", "0", "]", ".", "GetAddr", "(", ")", ",", ")", "\n", "}", "\n", "}", "else", "{", "// Always return a list, otherwise we'll break users tooling. See #1846 for", "// more details.", "tokens", ":=", "[", "]", "string", "{", "token", "}", "\n", "out", ",", "err", ":=", "json", ".", "Marshal", "(", "tokens", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "fmt", ".", "Printf", "(", "string", "(", "out", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Invite", "generates", "a", "token", "which", "can", "be", "used", "to", "add", "another", "SSH", "node", "to", "a", "cluster" ]

[ "func", "(", "c", "*", "NodeCommand", ")", "ListActive", "(", "client", "auth", ".", "ClientI", ")", "error", "{", "nodes", ",", "err", ":=", "client", ".", "GetNodes", "(", "c", ".", "namespace", ",", "services", ".", "SkipValidation", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "coll", ":=", "&", "serverCollection", "{", "servers", ":", "nodes", "}", "\n", "coll", ".", "writeText", "(", "os", ".", "Stdout", ")", "\n", "return", "nil", "\n", "}" ]

[ "ListActive", "retreives", "the", "list", "of", "nodes", "who", "recently", "sent", "heartbeats", "to", "to", "a", "cluster", "and", "prints", "it", "to", "stdout" ]

[ "func", "GetTokenFromHOTPMockFile", "(", "path", "string", ")", "(", "token", "string", ",", "e", "error", ")", "{", "otp", ",", "err", ":=", "LoadHOTPMockFromFile", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "token", "=", "otp", ".", "OTP", "(", ")", "\n\n", "err", "=", "otp", ".", "SaveToFile", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "token", ",", "nil", "\n", "}" ]

[ "GetTokenFromHOTPMockFile", "opens", "HOTPMock", "from", "file", "gets", "token", "value", "increases", "hotp", "and", "saves", "it", "to", "the", "file", ".", "Returns", "hotp", "token", "value", "." ]

[ "func", "useProxy", "(", "addr", "string", ")", "bool", "{", "if", "len", "(", "addr", ")", "==", "0", "{", "return", "true", "\n", "}", "\n", "var", "noProxy", "string", "\n", "for", "_", ",", "env", ":=", "range", "[", "]", "string", "{", "teleport", ".", "NoProxy", ",", "strings", ".", "ToLower", "(", "teleport", ".", "NoProxy", ")", "}", "{", "noProxy", "=", "os", ".", "Getenv", "(", "env", ")", "\n", "if", "noProxy", "!=", "\"", "\"", "{", "break", "\n", "}", "\n", "}", "\n\n", "if", "noProxy", "==", "\"", "\"", "{", "return", "true", "\n", "}", "\n", "if", "noProxy", "==", "\"", "\"", "{", "return", "false", "\n", "}", "\n\n", "addr", "=", "strings", ".", "ToLower", "(", "strings", ".", "TrimSpace", "(", "addr", ")", ")", "\n", "if", "hasPort", "(", "addr", ")", "{", "addr", "=", "addr", "[", ":", "strings", ".", "LastIndex", "(", "addr", ",", "\"", "\"", ")", "]", "\n", "}", "\n", "for", "_", ",", "p", ":=", "range", "strings", ".", "Split", "(", "noProxy", ",", "\"", "\"", ")", "{", "p", "=", "strings", ".", "ToLower", "(", "strings", ".", "TrimSpace", "(", "p", ")", ")", "\n", "if", "len", "(", "p", ")", "==", "0", "{", "continue", "\n", "}", "\n", "if", "hasPort", "(", "p", ")", "{", "p", "=", "p", "[", ":", "strings", ".", "LastIndex", "(", "p", ",", "\"", "\"", ")", "]", "\n", "}", "\n", "if", "addr", "==", "p", "{", "return", "false", "\n", "}", "\n", "if", "len", "(", "p", ")", "==", "0", "{", "// There is no host part, likely the entry is malformed; ignore.", "continue", "\n", "}", "\n", "if", "p", "[", "0", "]", "==", "'.'", "&&", "(", "strings", ".", "HasSuffix", "(", "addr", ",", "p", ")", "||", "addr", "==", "p", "[", "1", ":", "]", ")", "{", "// no_proxy \".foo.com\" matches \"bar.foo.com\" or \"foo.com\"", "return", "false", "\n", "}", "\n", "if", "p", "[", "0", "]", "!=", "'.'", "&&", "strings", ".", "HasSuffix", "(", "addr", ",", "p", ")", "&&", "addr", "[", "len", "(", "addr", ")", "-", "len", "(", "p", ")", "-", "1", "]", "==", "'.'", "{", "// no_proxy \"foo.com\" matches \"bar.foo.com\"", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "useProxy", "reports", "whether", "requests", "to", "addr", "should", "use", "a", "proxy", "according", "to", "the", "NO_PROXY", "or", "no_proxy", "environment", "variable", ".", "addr", "is", "always", "a", "canonicalAddr", "with", "a", "host", "and", "port", "." ]

[ "func", "Dial", "(", "socket", "string", ")", "(", "net", ".", "Conn", ",", "error", ")", "{", "conn", ",", "err", ":=", "winio", ".", "DialPipe", "(", "defaults", ".", "WindowsOpenSSHNamedPipe", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "conn", ",", "nil", "\n", "}" ]

[ "Dial", "creates", "net", ".", "Conn", "to", "a", "SSH", "agent", "listening", "on", "a", "Windows", "named", "pipe", ".", "This", "is", "behind", "a", "build", "flag", "because", "winio", ".", "DialPipe", "is", "only", "available", "on", "Windows", "." ]

[ "func", "(", "g", "*", "GLogger", ")", "Infoln", "(", "args", "...", "interface", "{", "}", ")", "{", "// GRPC is very verbose, so this is intentionally", "// pushes info level statements as Teleport's debug level ones", "g", ".", "Entry", ".", "Debug", "(", "fmt", ".", "Sprintln", "(", "args", "...", ")", ")", "\n", "}" ]

[ "Infoln", "logs", "to", "INFO", "log", ".", "Arguments", "are", "handled", "in", "the", "manner", "of", "fmt", ".", "Println", "." ]

[ "func", "(", "g", "*", "GLogger", ")", "Infof", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "// GRPC is very verbose, so this is intentionally", "// pushes info level statements as Teleport's debug level ones", "g", ".", "Entry", ".", "Debugf", "(", "format", ",", "args", "...", ")", "\n", "}" ]

[ "Infof", "logs", "to", "INFO", "log", ".", "Arguments", "are", "handled", "in", "the", "manner", "of", "fmt", ".", "Printf", "." ]

[ "func", "(", "g", "*", "GLogger", ")", "Warningln", "(", "args", "...", "interface", "{", "}", ")", "{", "g", ".", "Entry", ".", "Warning", "(", "fmt", ".", "Sprintln", "(", "args", "...", ")", ")", "\n", "}" ]

[ "Warningln", "logs", "to", "WARNING", "log", ".", "Arguments", "are", "handled", "in", "the", "manner", "of", "fmt", ".", "Println", "." ]

[ "func", "(", "g", "*", "GLogger", ")", "Warningf", "(", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "g", ".", "Entry", ".", "Warningf", "(", "format", ",", "args", "...", ")", "\n", "}" ]

[ "Warningf", "logs", "to", "WARNING", "log", ".", "Arguments", "are", "handled", "in", "the", "manner", "of", "fmt", ".", "Printf", "." ]

[ "func", "(", "g", "*", "GLogger", ")", "Errorln", "(", "args", "...", "interface", "{", "}", ")", "{", "g", ".", "Entry", ".", "Error", "(", "fmt", ".", "Sprintln", "(", "args", "...", ")", ")", "\n", "}" ]

[ "Errorln", "logs", "to", "ERROR", "log", ".", "Arguments", "are", "handled", "in", "the", "manner", "of", "fmt", ".", "Println", "." ]

[ "func", "Handshake", "(", "conn", "net", ".", "Conn", ")", "(", "string", ",", "error", ")", "{", "// Read in the version and reject anything other than SOCKS5.", "version", ",", "err", ":=", "readByte", "(", "conn", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "version", "!=", "socks5Version", "{", "return", "\"", "\"", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Read in the authentication method requested by the client and write back", "// the method that was selected. At the moment only \"no authentication", "// required\" is supported.", "authMethods", ",", "err", ":=", "readAuthenticationMethod", "(", "conn", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "!", "byteSliceContains", "(", "authMethods", ",", "socks5AuthNotRequired", ")", "{", "return", "\"", "\"", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "err", "=", "writeMethodSelection", "(", "conn", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// Read in the request from the client and make sure the requested command", "// is supported and extract the remote address. If everything is good, write", "// out a success response.", "remoteAddr", ",", "err", ":=", "readRequest", "(", "conn", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "err", "=", "writeReply", "(", "conn", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "remoteAddr", ",", "nil", "\n", "}" ]

[ "Handshake", "performs", "a", "SOCKS5", "handshake", "with", "the", "client", "and", "returns", "the", "remote", "address", "to", "proxy", "the", "connection", "to", "." ]

[ "func", "readAuthenticationMethod", "(", "conn", "net", ".", "Conn", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "// Read in the number of authentication methods supported.", "nmethods", ",", "err", ":=", "readByte", "(", "conn", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// Read nmethods number of bytes from the connection return the list of", "// supported authentication methods to the caller.", "authMethods", ":=", "make", "(", "[", "]", "byte", ",", "nmethods", ")", "\n", "for", "i", ":=", "byte", "(", "0", ")", ";", "i", "<", "nmethods", ";", "i", "++", "{", "method", ",", "err", ":=", "readByte", "(", "conn", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "authMethods", "=", "append", "(", "authMethods", ",", "method", ")", "\n", "}", "\n\n", "return", "authMethods", ",", "nil", "\n", "}" ]

[ "readAuthenticationMethod", "reads", "in", "the", "authentication", "methods", "the", "client", "supports", "." ]

[ "func", "writeMethodSelection", "(", "conn", "net", ".", "Conn", ")", "error", "{", "message", ":=", "[", "]", "byte", "{", "socks5Version", ",", "socks5AuthNotRequired", "}", "\n\n", "n", ",", "err", ":=", "conn", ".", "Write", "(", "message", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "n", "!=", "len", "(", "message", ")", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "n", ",", "len", "(", "message", ")", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "writeMethodSelection", "writes", "out", "the", "response", "to", "the", "authentication", "methods", ".", "Right", "now", "only", "SOCKS5", "and", "no", "authentication", "methods", "is", "supported", "." ]

[ "func", "readAddrType", "(", "conn", "net", ".", "Conn", ")", "(", "int", ",", "error", ")", "{", "// Read in the type of the remote host.", "addrType", ",", "err", ":=", "readByte", "(", "conn", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// Based off the type, determine how many more bytes to read in for the", "// remote address. For IPv4 it's 4 bytes, for IPv6 it's 16, and for domain", "// names read in another byte to determine the length of the field.", "switch", "addrType", "{", "case", "socks5AddressTypeIPv4", ":", "return", "net", ".", "IPv4len", ",", "nil", "\n", "case", "socks5AddressTypeIPv6", ":", "return", "net", ".", "IPv6len", ",", "nil", "\n", "case", "socks5AddressTypeDomainName", ":", "len", ",", "err", ":=", "readByte", "(", "conn", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "int", "(", "len", ")", ",", "nil", "\n", "default", ":", "return", "0", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "addrType", ")", "\n", "}", "\n", "}" ]

[ "readAddrType", "reads", "in", "the", "address", "type", "and", "returns", "the", "length", "of", "the", "dest", "addr", "field", "." ]