id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c24000 | != nil {
return nil, trace.Wrap(err)
}
return bytes, nil
} | |
c24001 | } else {
out.Trusted = append(out.Trusted, cluster)
}
}
sort.Slice(out.Trusted, func(i, j int) bool {
return out.Trusted[i].Name < out.Trusted[j].Name
})
return &out
} | |
c24002 | return nil
}
log.Infof("Importing data from legacy backend.")
exporter, err := newExporter()
if err != nil {
return trace.Wrap(err)
}
defer exporter.Close()
items, err := exporter.Export()
if err != nil {
return trace.Wrap(err)
}
if err := importer.Import(ctx, items); err != nil {
return ... | |
c24003 | stats\n")
memStats(w)
fmt.Fprintf(w, "Goroutines\n")
goroutineDump(w)
} | |
c24004 | return c.reader.Read(p)
} | |
c24005 | return &c.proxyLine.Destination
}
return c.Conn.LocalAddr()
} | |
c24006 | return &c.proxyLine.Source
}
return c.Conn.RemoteAddr()
} | |
c24007 | return nil, trace.ConnectionProblem(nil, "listener is closed")
}
return conn, nil
}
} | |
c24008 | i.ConnectorID == other.ConnectorID && i.Username == other.Username
} | |
c24009 | {
return trace.BadParameter("bad PublicKey: %v", err)
}
if (r.CertTTL > defaults.MaxCertDuration) || (r.CertTTL < defaults.MinCertDuration) {
return trace.BadParameter("wrong CertTTL")
}
}
return nil
} | |
c24010 |
s[i], s[j] = s[j], s[i]
} | |
c24011 | else {
return false
}
if failed >= x {
return true
}
}
return false
} | |
c24012 | != nil {
return nil, trace.BadParameter("invalid server name %q: %v", req.Server, err)
}
return &TerminalHandler{
log: logrus.WithFields(logrus.Fields{
trace.Component: teleport.ComponentWebsocket,
}),
params: req,
ctx: ctx,
hostName: hostName,
hostPort: hostPort,
authProvi... | |
c24013 | If the terminal handler was closed (most likely due to the *SessionContext
// closing) then the stream should be closed as well.
t.terminalCancel()
return nil
} | |
c24014 | a context for signaling when the terminal session is over.
t.terminalContext, t.terminalCancel = context.WithCancel(context.Background())
t.log.Debugf("Creating websocket stream for %v.", t.params.SessionID)
// Pump raw terminal in/out and audit events into the websocket.
go t.streamTerminal(ws, tc)
go t.stream... | |
c24015 | er != nil {
t.log.Warnf("Unable to send error to terminal: %v: %v.", err, er)
}
return
}
// Send close envelope to web terminal upon exit without an error.
envelope := &Envelope{
Version: defaults.WebsocketVersion,
Type: defaults.WebsocketClose,
Payload: "",
}
envelopeBytes, err := proto.Marshal(... | |
c24016 | if err != nil {
t.log.Debugf("Unable to send audit event %v to web client: %v.", event.GetType(), err)
continue
}
// Send bytes over the websocket to the web client.
err = websocket.Message.Send(ws, envelopeBytes)
if err != nil {
t.log.Errorf("Unable to send audit event %v to web client: %v."... | |
c24017 |
W: uint32(params.W),
H: uint32(params.H),
}))
if err != nil {
t.log.Error(err)
}
return trace.Wrap(err)
} | |
c24018 | := r.Replace(err.Error())
_, err = t.write([]byte(errMessage), ws)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c24019 | nil
}
// Check for explicitly specified port.
host, portString, err := utils.SplitHostPort(servername)
if err != nil {
return "", defaultPort, trace.Wrap(err)
}
port, err := strconv.Atoi(portString)
if err != nil {
return "", defaultPort, trace.BadParameter("invalid port: %v", err)
}
return host, port,... | |
c24020 | (n int, err error) {
return w.terminal.write(data, w.ws)
} | |
c24021 | return w.ws.SetReadDeadline(t)
} | |
c24022 |
}
fwd.POST("/api/:ver/namespaces/:podNamespace/pods/:podName/exec", fwd.withAuth(fwd.exec))
fwd.GET("/api/:ver/namespaces/:podNamespace/pods/:podName/exec", fwd.withAuth(fwd.exec))
fwd.POST("/api/:ver/namespaces/:podNamespace/pods/:podName/attach", fwd.withAuth(fwd.exec))
fwd.GET("/api/:ver/namespaces/:podNames... | |
c24023 | on, don't forget to verify
// https://github.com/kubernetes/kubernetes/pull/34524/files#diff-2b283dde198c92424df5355f39544aa4R59
return nil, trace.AccessDenied("access denied: intermediaries are not supported")
}
if len(peers) == 0 {
return nil, trace.AccessDenied("access denied: only mutual TLS authentication... | |
c24024 | sess.cluster.targetAddr,
events.RemoteAddr: req.RemoteAddr,
})
}
q := req.URL.Query()
request := portForwardRequest{
podNamespace: p.ByName("podNamespace"),
podName: p.ByName("podName"),
ports: q["ports"],
context: req.Context(),
httpRequest: ... | |
c24025 | sess, req); err != nil {
return nil, trace.Wrap(err)
}
sess.forwarder.ServeHTTP(w, req)
return nil, nil
} | |
c24026 | {
t.Lock()
defer t.Unlock()
t.lastActive = t.clock.Now().UTC()
} | |
c24027 | if ok {
return ctx, nil
}
ctx, cancel := context.WithCancel(context.TODO())
f.activeRequests[key] = ctx
return ctx, func() {
cancel()
f.Lock()
defer f.Unlock()
delete(f.activeRequests, key)
}
} | |
c24028 | p.Destination.IP.String(), p.Source.Port, p.Destination.Port)
} | |
c24029 | switch tokens[1] {
case TCP4:
ret.Protocol = TCP4
case TCP6:
ret.Protocol = TCP6
default:
ret.Protocol = UNKNOWN
}
sourceIP, err := parseIP(ret.Protocol, tokens[2])
if err != nil {
return nil, trace.Wrap(err)
}
destIP, err := parseIP(ret.Protocol, tokens[3])
if err != nil {
return nil, trace.Wrap(er... | |
c24030 | process,
recoveryTime: process.Clock.Now(),
currentState: stateOK,
}
} | |
c24031 | is degraded, and a OK event has been
// received, change the state to recovering. If the current state is
// recovering and a OK events is received, if it's been longer
// than the recovery time (2 time the server keep alive ttl), change
// state to OK.
case TeleportOKEvent:
switch atomic.LoadInt64(&f.currentSt... | |
c24032 | != nil {
return a.Addr
}
return host
} | |
c24033 | if err != nil {
return defaultPort
}
porti, err := strconv.Atoi(port)
if err != nil {
return defaultPort
}
return porti
} | |
c24034 | == other.AddrNetwork && a.Path == other.Path
} | |
c24035 |
if err != nil {
return false
}
return IsLocalhost(host)
} | |
c24036 | a.AddrNetwork == "" && a.Path == ""
} | |
c24037 | a.Path}
return strings.TrimLeft(url.String(), "/"), nil
} | |
c24038 | if err != nil {
return err
}
parsedAddr, err := ParseAddr(addr)
if err != nil {
return err
}
*a = *parsedAddr
return nil
} | |
c24039 |
if err != nil {
panic(fmt.Sprintf("failed to parse %v: %v", a, err))
}
return addr
} | |
c24040 | NetAddr{AddrNetwork: a.Network(), Addr: a.String()}
} | |
c24041 | make([]NetAddr, 0, len(a)+len(b))
out = append(out, a...)
out = append(out, b...)
return out
} | |
c24042 | NetAddr{Addr: ReplaceLocalhost(listenAddr.Addr, "127.0.0.1")}
} | |
c24043 | ns = append(ns, n.FullAddress())
}
return ns
} | |
c24044 | return err
}
*nl = append(*nl, *v)
return nil
} | |
c24045 | = append(ns, n.FullAddress())
}
return strings.Join(ns, " ")
} | |
c24046 | := net.ParseIP(host)
return ip.IsLoopback() || ip.IsUnspecified()
} | |
c24047 | := net.LookupIP(host)
if err != nil {
return false
}
for _, ip := range ips {
if ip.IsLoopback() {
return true
}
}
return false
} | |
c24048 | if err != nil {
log.Warn(err)
} else {
adrs = append(adrs, ifadrs...)
}
}
return guessHostIP(adrs), nil
} | |
c24049 | += "="
}
return base64.URLEncoding.DecodeString(s)
} | |
c24050 |
trace.ComponentFields: map[string]string{
"cluster": connInfo.GetClusterName(),
},
}),
}
return clusterPeer, nil
} | |
c24051 |
var otpQR bytes.Buffer
err = png.Encode(&otpQR, otpImage)
if err != nil {
return nil, trace.Wrap(err)
}
return otpQR.Bytes(), nil
} | |
c24052 | OldPassword: req.OldPassword,
NewPassword: req.NewPassword,
SecondFactorToken: req.SecondFactorToken,
U2FSignResponse: req.U2FSignResponse,
}
err = clt.ChangePassword(servicedReq)
if err != nil {
return nil, trace.Wrap(err)
}
return ok(), nil
} | |
c24053 | ctx.GetClient()
if err != nil {
return nil, trace.Wrap(err)
}
u2fReq, err := clt.GetU2FSignRequest(ctx.GetUser(), []byte(req.Pass))
if err != nil && trace.IsAccessDenied(err) {
// logout in case of access denied
logoutErr := h.logout(w, ctx)
if logoutErr != nil {
return nil, trace.Wrap(logoutErr)
}
... | |
c24054 | return nil, trace.Wrap(err)
}
}
log.Infof("[Web] Using filesystem for serving web assets: %s", debugAssetsPath)
return http.Dir(debugAssetsPath), nil
}
// otherwise, lets use the zip archive attached to the executable:
return loadZippedExeAssets()
} | |
c24055 | Getenv(teleport.DebugEnvVar))
return v
} | |
c24056 | myExe, err := osext.Executable()
if err != nil {
return nil, trace.Wrap(err)
}
return readZipArchive(myExe)
} | |
c24057 | HostID: id.HostUUID,
NodeName: id.NodeName,
Roles: teleport.Roles{id.Role},
AdditionalPrincipals: additionalPrincipals,
RemoteAddr: remoteAddr,
DNSNames: dnsNames,
NoCache: true,
})
if err != nil {
return nil, trace.Wrap(err)
... | |
c24058 | failing with error from Auth Server: %v.", err)
return nil, trace.Wrap(err)
}
ident, er := registerThroughProxy(token, params)
if er != nil {
return nil, trace.NewAggregate(err, er)
}
log.Debugf("Successfully registered through proxy server.")
return ident, nil
}
log.Debugf("Successfully registe... | |
c24059 | params.DNSNames,
PublicTLSKey: params.PublicTLSKey,
PublicSSHKey: params.PublicSSHKey,
})
if err != nil {
return nil, trace.Wrap(err)
}
keys.Key = params.PrivateKey
return ReadIdentityFromKeyPair(keys)
} | |
c24060 | params.ID.HostUUID,
NodeName: params.ID.NodeName,
Role: params.ID.Role,
AdditionalPrincipals: params.AdditionalPrincipals,
DNSNames: params.DNSNames,
PublicTLSKey: params.PublicTLSKey,
PublicSSHKey: params.PublicSSHKey,
})
if err != nil {
re... | |
c24061 | certPool := x509.NewCertPool()
certPool.AddCert(cert)
tlsConfig.RootCAs = certPool
log.Infof("Joining remote cluster %v, validating connection with certificate on disk.", cert.Subject.CommonName)
}
client, err := NewTLSClient(ClientConfig{Addrs: params.Servers, TLS: tlsConfig})
if err != nil {
return nil... | |
c24062 | trace.Wrap(err)
}
cert, err := tlsca.ParseCertificatePEM(certBytes)
if err != nil {
return nil, trace.Wrap(err, "failed to parse certificate at %v", params.CAPath)
}
return cert, nil
} | |
c24063 | {
return nil, trace.Wrap(err)
}
log.Infof("Joining remote cluster %v with CA pin.", tlsCA.Subject.CommonName)
// Create another client, but this time with the CA provided to validate
// that the Auth Server was issued a certificate by the same CA.
tlsConfig = utils.TLSConfig(params.CipherSuites)
certPool := ... | |
c24064 | params.DNSNames,
PublicTLSKey: params.PublicTLSKey,
PublicSSHKey: params.PublicSSHKey,
Rotation: ¶ms.Rotation,
})
if err != nil {
return nil, trace.Wrap(err)
}
keys.Key = params.PrivateKey
return ReadIdentityFromKeyPair(keys)
} | |
c24065 | fmt.Sprintf("failed to open file: %v", filePath))
}
defer f.Close()
return ReadConfig(f)
} | |
c24066 | if err != nil {
return nil, trace.BadParameter(
"confiugraion should be base64 encoded: %v", err)
}
return ReadConfig(bytes.NewBuffer(data))
} | |
c24067 | return trace.BadParameter("unrecognized configuration key: '%v'", key)
}
if recursive {
if m2, ok := v.(YAMLMap); ok {
if err := validateKeys(m2); err != nil {
return err
}
}
}
}
}
return nil
}
// validate configuration keys:
var tmp YAMLMap
if err = yaml.Unmarshal(b... | |
c24068 | // sample Auth config:
var a Auth
a.ListenAddress = conf.Auth.SSHAddr.Addr
a.EnabledFlag = "yes"
a.StaticTokens = []StaticToken{"proxy,node:cluster-join-token"}
// sample proxy config:
var p Proxy
p.EnabledFlag = "yes"
p.ListenAddress = conf.Proxy.SSHAddr.Addr
p.WebAddr = conf.Proxy.WebAddr.Addr
p.TunAddr =... | |
c24069 | err := yaml.Marshal(&conf)
if err != nil {
panic(err)
}
return string(bytes)
} | |
c24070 |
out.TTL, err = time.ParseDuration(c.TTL)
if err != nil {
return nil, trace.BadParameter("cache.ttl invalid duration: %v, accepted format '10h'", c.TTL)
}
}
return &out, nil
} | |
c24071 |
return &pam.Config{
Enabled: enabled,
ServiceName: serviceName,
}
} | |
c24072 | if err != nil {
return nil, trace.Wrap(err, "Invalid address for tunnel %v", t.DomainName)
}
t.Addresses[i] = addr.String()
}
out := services.NewReverseTunnel(t.DomainName, t.Addresses)
if err := out.Check(); err != nil {
return nil, trace.Wrap(err)
}
return out, nil
} | |
c24073 | := utils.ReadPath(path)
if err != nil {
return nil, nil, trace.Wrap(err)
}
ca.SigningKeys = append(ca.SigningKeys, keyBytes)
}
for _, val := range a.SigningKeys {
ca.SigningKeys = append(ca.SigningKeys, []byte(val))
}
new, role := services.ConvertV1CertAuthority(ca)
return new, role, nil
} | |
c24074 | ClientID: o.ClientID,
ClientSecret: o.ClientSecret,
RedirectURL: o.RedirectURL,
Scope: o.Scope,
ClaimsToRoles: mappings,
}
v2 := other.V2()
v2.SetACR(o.ACR)
v2.SetProvider(o.Provider)
if err := v2.Check(); err != nil {
return nil, trace.Wrap(err)
}
return v2, nil
} | |
c24075 |
// If no facets specified, default to AppID
facets := u.Facets
if len(facets) == 0 {
facets = []string{appID}
}
return &services.U2F{
AppID: appID,
Facets: facets,
}, nil
} | |
c24076 | to parse SSH certificate")
}
cert, ok := pubkey.(*ssh.Certificate)
if !ok {
return nil, trace.BadParameter("expected SSH certificate, got %T ", pubkey)
}
return ssh.NewCertSigner(cert, keySigner)
} | |
c24077 |
if !ok {
return nil, trace.BadParameter("expected ssh.CryptoPublicKey, got %T", pubKey)
}
return cryptoPubKey.CryptoPublicKey(), nil
} | |
c24078 | == 0 {
return "", trace.BadParameter("missing subject organization")
}
return subject.Organization[0], nil
} | |
c24079 | if err != nil {
return nil, trace.Wrap(err)
}
return pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(priv)}), nil
} | |
c24080 | nil, trace.BadParameter("expected PEM-encoded block")
}
return ParsePublicKeyDER(block.Bytes)
} | |
c24081 |
return nil, trace.Wrap(err)
}
return generalKey, nil
} | |
c24082 | key")
}
rsaPublicKey := rsaPrivateKey.Public()
derBytes, err := x509.MarshalPKIXPublicKey(rsaPublicKey)
if err != nil {
return nil, trace.Wrap(err)
}
return pem.EncodeToMemory(&pem.Block{Type: "RSA PUBLIC KEY", Bytes: derBytes}), nil
} | |
c24083 | err != nil {
if !trace.IsNotFound(err) {
return false, trace.Wrap(err)
}
// CA not found? --> first start!
return true, nil
}
return false, nil
} | |
c24084 | teleport.Roles{id.Role},
AdditionalPrincipals: additionalPrincipals,
DNSNames: dnsNames,
})
if err != nil {
return nil, trace.Wrap(err)
}
return ReadIdentityFromKeyPair(keys)
} | |
c24085 | i.TLSCACertsBytes {
cert, err := tlsca.ParseCertificatePEM(i.TLSCACertsBytes[j])
if err != nil {
out = append(out, err.Error())
} else {
out = append(out, fmt.Sprintf("trust root(%v:%v)", cert.Subject.CommonName, cert.Subject.SerialNumber))
}
}
return fmt.Sprintf("Identity(%v, %v)", i.ID.Role, strings.... | |
c24086 | cert.Issuer.CommonName, cert.Issuer.SerialNumber)
} | |
c24087 | nil {
return err.Error()
}
return CertInfo(x509cert)
} | |
c24088 |
}
}
return fmt.Sprintf("cert authority(state: %v, phase: %v, roots: %v)", ca.GetRotation().State, ca.GetRotation().Phase, strings.Join(out, ", "))
} | |
c24089 | 0 && len(i.TLSCertBytes) != 0
} | |
c24090 | if _, ok := set[principal]; !ok {
return false
}
}
return true
} | |
c24091 | {
if _, ok := set[dnsName]; !ok {
return false
}
}
return true
} | |
c24092 | nil, trace.Wrap(err, "failed to parse CA certificate")
}
certPool.AddCert(parsedCert)
}
tlsConfig.Certificates = []tls.Certificate{tlsCert}
tlsConfig.RootCAs = certPool
tlsConfig.ClientCAs = certPool
tlsConfig.ServerName = EncodeClusterName(i.ClusterName)
return tlsConfig, nil
} | |
c24093 | },
HostKeyCallback: i.hostKeyCallback,
Timeout: defaults.DefaultDialTimeout,
}
} | |
c24094 | CAs and see if any of them signed the certificate.
for _, k := range i.SSHCACertBytes {
pubkey, _, _, _, err := ssh.ParseAuthorizedKey(k)
if err != nil {
return trace.Wrap(err)
}
if sshutils.KeysEqual(cert.SignatureKey, pubkey) {
return nil
}
}
return trace.BadParameter("no matching keys found")
} | |
c24095 | return "", trace.BadParameter("expected 2 parts in %q", id.HostUUID)
}
return parts[0], nil
} | |
c24096 | == other.Role && id.HostUUID == other.HostUUID
} | |
c24097 |
if len(keys.TLSCACerts) != 0 {
// Parse the key pair to verify that identity parses properly for future use.
i, err := ReadTLSIdentityFromKeyPair(keys.Key, keys.TLSCert, keys.TLSCACerts)
if err != nil {
return nil, trace.Wrap(err)
}
identity.XCert = i.XCert
identity.TLSCertBytes = keys.TLSCert
ident... | |
c24098 | if len(cert.Issuer.Organization) == 0 {
return nil, trace.BadParameter("missing CA organization")
}
clusterName := cert.Issuer.Organization[0]
if clusterName == "" {
return nil, trace.BadParameter("misssing cluster name")
}
identity := &Identity{
ID: IdentityID{HostUUID: id.Username, Role: tel... | |
c24099 | {
return nil, trace.BadParameter("extensions: misssing needed extensions for host roles")
}
roleString := cert.Permissions.Extensions[utils.CertExtensionRole]
if roleString == "" {
return nil, trace.BadParameter("misssing cert extension %v", utils.CertExtensionRole)
}
roles, err := teleport.ParseRoles(roleStr... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.