_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q24000 | MarshalServers | train | func (*TeleportServerMarshaler) MarshalServers(s []Server) ([]byte, error) {
bytes, err := utils.FastMarshal(s)
if err != nil {
return nil, trace.Wrap(err)
}
return bytes, nil
} | go | {
"resource": ""
} |
q24001 | NewAvailableClusters | train | func NewAvailableClusters(currentClusterName string, remoteClusters []reversetunnel.RemoteSite) *AvailableClusters {
out := AvailableClusters{}
for _, item := range remoteClusters {
cluster := Cluster{
Name: item.GetName(),
LastConnected: item.GetLastConnected(),
Status: item.GetStatus(),
... | go | {
"resource": ""
} |
q24002 | Import | train | func Import(ctx context.Context, importer Importer, newExporter NewExporterFunc) error {
log := logrus.WithFields(logrus.Fields{
trace.Component: teleport.Component(teleport.ComponentMigrate),
})
err := func() error {
imported, err := importer.Imported(ctx)
if err != nil {
return trace.Wrap(err)
}
if im... | go | {
"resource": ""
} |
q24003 | writeDebugInfo | train | func writeDebugInfo(w io.Writer) {
fmt.Fprintf(w, "Runtime stats\n")
runtimeStats(w)
fmt.Fprintf(w, "Memory stats\n")
memStats(w)
fmt.Fprintf(w, "Goroutines\n")
goroutineDump(w)
} | go | {
"resource": ""
} |
q24004 | Read | train | func (c *Conn) Read(p []byte) (int, error) {
return c.reader.Read(p)
} | go | {
"resource": ""
} |
q24005 | LocalAddr | train | func (c *Conn) LocalAddr() net.Addr {
if c.proxyLine != nil {
return &c.proxyLine.Destination
}
return c.Conn.LocalAddr()
} | go | {
"resource": ""
} |
q24006 | RemoteAddr | train | func (c *Conn) RemoteAddr() net.Addr {
if c.proxyLine != nil {
return &c.proxyLine.Source
}
return c.Conn.RemoteAddr()
} | go | {
"resource": ""
} |
q24007 | Accept | train | func (l *Listener) Accept() (net.Conn, error) {
select {
case <-l.context.Done():
return nil, trace.ConnectionProblem(nil, "listener is closed")
case conn := <-l.connC:
if conn == nil {
return nil, trace.ConnectionProblem(nil, "listener is closed")
}
return conn, nil
}
} | go | {
"resource": ""
} |
q24008 | Equals | train | func (i *ExternalIdentity) Equals(other *ExternalIdentity) bool {
return i.ConnectorID == other.ConnectorID && i.Username == other.Username
} | go | {
"resource": ""
} |
q24009 | Check | train | func (r *GithubAuthRequest) Check() error {
if r.ConnectorID == "" {
return trace.BadParameter("missing ConnectorID")
}
if r.StateToken == "" {
return trace.BadParameter("missing StateToken")
}
if len(r.PublicKey) != 0 {
_, _, _, _, err := ssh.ParseAuthorizedKey(r.PublicKey)
if err != nil {
return trace... | go | {
"resource": ""
} |
q24010 | Swap | train | func (s SortedLoginAttempts) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
} | go | {
"resource": ""
} |
q24011 | LastFailed | train | func LastFailed(x int, attempts []LoginAttempt) bool {
var failed int
for i := len(attempts) - 1; i >= 0; i-- {
if !attempts[i].Success {
failed++
} else {
return false
}
if failed >= x {
return true
}
}
return false
} | go | {
"resource": ""
} |
q24012 | NewTerminal | train | func NewTerminal(req TerminalRequest, authProvider AuthProvider, ctx *SessionContext) (*TerminalHandler, error) {
// Make sure whatever session is requested is a valid session.
_, err := session.ParseID(string(req.SessionID))
if err != nil {
return nil, trace.BadParameter("sid: invalid session id")
}
if req.Lo... | go | {
"resource": ""
} |
q24013 | Close | train | func (t *TerminalHandler) Close() error {
// Close the websocket connection to the client web browser.
if t.ws != nil {
t.ws.Close()
}
// Close the SSH connection to the remote node.
if t.sshSession != nil {
t.sshSession.Close()
}
// If the terminal handler was closed (most likely due to the *SessionContex... | go | {
"resource": ""
} |
q24014 | handler | train | func (t *TerminalHandler) handler(ws *websocket.Conn) {
// Create a Teleport client, if not able to, show the reason to the user in
// the terminal.
tc, err := t.makeClient(ws)
if err != nil {
er := t.writeError(err, ws)
if er != nil {
t.log.Warnf("Unable to send error to terminal: %v: %v.", err, er)
}
r... | go | {
"resource": ""
} |
q24015 | streamTerminal | train | func (t *TerminalHandler) streamTerminal(ws *websocket.Conn, tc *client.TeleportClient) {
defer t.terminalCancel()
// Establish SSH connection to the server. This function will block until
// either an error occurs or it completes successfully.
err := tc.SSH(t.terminalContext, t.params.InteractiveCommand, false)
... | go | {
"resource": ""
} |
q24016 | streamEvents | train | func (t *TerminalHandler) streamEvents(ws *websocket.Conn, tc *client.TeleportClient) {
for {
select {
// Send push events that come over the events channel to the web client.
case event := <-tc.EventsChannel():
data, err := json.Marshal(event)
if err != nil {
t.log.Errorf("Unable to marshal audit even... | go | {
"resource": ""
} |
q24017 | windowChange | train | func (t *TerminalHandler) windowChange(params *session.TerminalParams) error {
if t.sshSession == nil {
return nil
}
_, err := t.sshSession.SendRequest(
sshutils.WindowChangeRequest,
false,
ssh.Marshal(sshutils.WinChangeReqParams{
W: uint32(params.W),
H: uint32(params.H),
}))
if err != nil {
t.lo... | go | {
"resource": ""
} |
q24018 | writeError | train | func (t *TerminalHandler) writeError(err error, ws *websocket.Conn) error {
// Replace \n with \r\n so the message correctly aligned.
r := strings.NewReplacer("\r\n", "\r\n", "\n", "\r\n")
errMessage := r.Replace(err.Error())
_, err = t.write([]byte(errMessage), ws)
if err != nil {
return trace.Wrap(err)
}
re... | go | {
"resource": ""
} |
q24019 | resolveServerHostPort | train | func resolveServerHostPort(servername string, existingServers []services.Server) (string, int, error) {
// If port is 0, client wants us to figure out which port to use.
var defaultPort = 0
if servername == "" {
return "", defaultPort, trace.BadParameter("empty server name")
}
// Check if servername is UUID.
... | go | {
"resource": ""
} |
q24020 | Write | train | func (w *terminalStream) Write(data []byte) (n int, err error) {
return w.terminal.write(data, w.ws)
} | go | {
"resource": ""
} |
q24021 | SetReadDeadline | train | func (w *terminalStream) SetReadDeadline(t time.Time) error {
return w.ws.SetReadDeadline(t)
} | go | {
"resource": ""
} |
q24022 | NewForwarder | train | func NewForwarder(cfg ForwarderConfig) (*Forwarder, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
creds, err := getKubeCreds(cfg.KubeconfigPath)
if err != nil {
return nil, trace.Wrap(err)
}
clusterSessions, err := ttlmap.New(defaults.ClientCacheSize)
if err != ni... | go | {
"resource": ""
} |
q24023 | authenticate | train | func (f *Forwarder) authenticate(req *http.Request) (*authContext, error) {
const accessDeniedMsg = "[00] access denied"
var isRemoteUser bool
userTypeI := req.Context().Value(auth.ContextUser)
switch userTypeI.(type) {
case auth.LocalUser:
case auth.RemoteUser:
isRemoteUser = true
default:
f.Warningf("Den... | go | {
"resource": ""
} |
q24024 | portForward | train | func (f *Forwarder) portForward(ctx *authContext, w http.ResponseWriter, req *http.Request, p httprouter.Params) (interface{}, error) {
f.Debugf("Port forward: %v. req headers: %v", req.URL.String(), req.Header)
sess, err := f.getOrCreateClusterSession(*ctx)
if err != nil {
return nil, trace.Wrap(err)
}
if err ... | go | {
"resource": ""
} |
q24025 | catchAll | train | func (f *Forwarder) catchAll(ctx *authContext, w http.ResponseWriter, req *http.Request) (interface{}, error) {
sess, err := f.getOrCreateClusterSession(*ctx)
if err != nil {
return nil, trace.Wrap(err)
}
if err := f.setupForwardingHeaders(ctx, sess, req); err != nil {
return nil, trace.Wrap(err)
}
sess.forwa... | go | {
"resource": ""
} |
q24026 | UpdateClientActivity | train | func (t *trackingConn) UpdateClientActivity() {
t.Lock()
defer t.Unlock()
t.lastActive = t.clock.Now().UTC()
} | go | {
"resource": ""
} |
q24027 | getOrCreateRequestContext | train | func (f *Forwarder) getOrCreateRequestContext(key string) (context.Context, context.CancelFunc) {
f.Lock()
defer f.Unlock()
ctx, ok := f.activeRequests[key]
if ok {
return ctx, nil
}
ctx, cancel := context.WithCancel(context.TODO())
f.activeRequests[key] = ctx
return ctx, func() {
cancel()
f.Lock()
defe... | go | {
"resource": ""
} |
q24028 | String | train | func (p *ProxyLine) String() string {
return fmt.Sprintf("PROXY %s %s %s %d %d\r\n", p.Protocol, p.Source.IP.String(), p.Destination.IP.String(), p.Source.Port, p.Destination.Port)
} | go | {
"resource": ""
} |
q24029 | ReadProxyLine | train | func ReadProxyLine(reader *bufio.Reader) (*ProxyLine, error) {
line, err := reader.ReadString('\n')
if err != nil {
return nil, trace.Wrap(err)
}
if !strings.HasSuffix(line, proxyCRLF) {
return nil, trace.BadParameter("expected CRLF in proxy protocol, got something else")
}
tokens := strings.Split(line[:len(l... | go | {
"resource": ""
} |
q24030 | newProcessState | train | func newProcessState(process *TeleportProcess) *processState {
return &processState{
process: process,
recoveryTime: process.Clock.Now(),
currentState: stateOK,
}
} | go | {
"resource": ""
} |
q24031 | Process | train | func (f *processState) Process(event Event) {
switch event.Name {
// Ready event means Teleport has started successfully.
case TeleportReadyEvent:
atomic.StoreInt64(&f.currentState, stateOK)
f.process.Infof("Detected that service started and joined the cluster successfully.")
// If a degraded event was received... | go | {
"resource": ""
} |
q24032 | Host | train | func (a *NetAddr) Host() string {
host, _, err := net.SplitHostPort(a.Addr)
if err != nil {
return a.Addr
}
return host
} | go | {
"resource": ""
} |
q24033 | Port | train | func (a *NetAddr) Port(defaultPort int) int {
_, port, err := net.SplitHostPort(a.Addr)
if err != nil {
return defaultPort
}
porti, err := strconv.Atoi(port)
if err != nil {
return defaultPort
}
return porti
} | go | {
"resource": ""
} |
q24034 | Equals | train | func (a *NetAddr) Equals(other NetAddr) bool {
return a.Addr == other.Addr && a.AddrNetwork == other.AddrNetwork && a.Path == other.Path
} | go | {
"resource": ""
} |
q24035 | IsLocal | train | func (a *NetAddr) IsLocal() bool {
host, _, err := net.SplitHostPort(a.Addr)
if err != nil {
return false
}
return IsLocalhost(host)
} | go | {
"resource": ""
} |
q24036 | IsEmpty | train | func (a *NetAddr) IsEmpty() bool {
return a.Addr == "" && a.AddrNetwork == "" && a.Path == ""
} | go | {
"resource": ""
} |
q24037 | MarshalYAML | train | func (a *NetAddr) MarshalYAML() (interface{}, error) {
url := url.URL{Scheme: a.AddrNetwork, Host: a.Addr, Path: a.Path}
return strings.TrimLeft(url.String(), "/"), nil
} | go | {
"resource": ""
} |
q24038 | UnmarshalYAML | train | func (a *NetAddr) UnmarshalYAML(unmarshal func(interface{}) error) error {
var addr string
err := unmarshal(&addr)
if err != nil {
return err
}
parsedAddr, err := ParseAddr(addr)
if err != nil {
return err
}
*a = *parsedAddr
return nil
} | go | {
"resource": ""
} |
q24039 | MustParseAddr | train | func MustParseAddr(a string) *NetAddr {
addr, err := ParseAddr(a)
if err != nil {
panic(fmt.Sprintf("failed to parse %v: %v", a, err))
}
return addr
} | go | {
"resource": ""
} |
q24040 | FromAddr | train | func FromAddr(a net.Addr) NetAddr {
return NetAddr{AddrNetwork: a.Network(), Addr: a.String()}
} | go | {
"resource": ""
} |
q24041 | JoinAddrSlices | train | func JoinAddrSlices(a []NetAddr, b []NetAddr) []NetAddr {
if len(a)+len(b) == 0 {
return nil
}
out := make([]NetAddr, 0, len(a)+len(b))
out = append(out, a...)
out = append(out, b...)
return out
} | go | {
"resource": ""
} |
q24042 | DialAddrFromListenAddr | train | func DialAddrFromListenAddr(listenAddr NetAddr) NetAddr {
if listenAddr.IsEmpty() {
return listenAddr
}
return NetAddr{Addr: ReplaceLocalhost(listenAddr.Addr, "127.0.0.1")}
} | go | {
"resource": ""
} |
q24043 | Addresses | train | func (nl *NetAddrList) Addresses() []string {
var ns []string
for _, n := range *nl {
ns = append(ns, n.FullAddress())
}
return ns
} | go | {
"resource": ""
} |
q24044 | Set | train | func (nl *NetAddrList) Set(s string) error {
v, err := ParseAddr(s)
if err != nil {
return err
}
*nl = append(*nl, *v)
return nil
} | go | {
"resource": ""
} |
q24045 | String | train | func (nl *NetAddrList) String() string {
var ns []string
for _, n := range *nl {
ns = append(ns, n.FullAddress())
}
return strings.Join(ns, " ")
} | go | {
"resource": ""
} |
q24046 | IsLocalhost | train | func IsLocalhost(host string) bool {
if host == "localhost" {
return true
}
ip := net.ParseIP(host)
return ip.IsLoopback() || ip.IsUnspecified()
} | go | {
"resource": ""
} |
q24047 | IsLoopback | train | func IsLoopback(host string) bool {
if strings.Contains(host, ":") {
var err error
host, _, err = net.SplitHostPort(host)
if err != nil {
return false
}
}
ips, err := net.LookupIP(host)
if err != nil {
return false
}
for _, ip := range ips {
if ip.IsLoopback() {
return true
}
}
return false
... | go | {
"resource": ""
} |
q24048 | GuessHostIP | train | func GuessHostIP() (ip net.IP, err error) {
ifaces, err := net.Interfaces()
if err != nil {
return nil, trace.Wrap(err)
}
adrs := make([]net.Addr, 0)
for _, iface := range ifaces {
ifadrs, err := iface.Addrs()
if err != nil {
log.Warn(err)
} else {
adrs = append(adrs, ifadrs...)
}
}
return guessH... | go | {
"resource": ""
} |
q24049 | decodeBase64 | train | func decodeBase64(s string) ([]byte, error) {
for i := 0; i < len(s)%4; i++ {
s += "="
}
return base64.URLEncoding.DecodeString(s)
} | go | {
"resource": ""
} |
q24050 | newClusterPeer | train | func newClusterPeer(srv *server, connInfo services.TunnelConnection) (*clusterPeer, error) {
clusterPeer := &clusterPeer{
srv: srv,
connInfo: connInfo,
log: log.WithFields(log.Fields{
trace.Component: teleport.ComponentReverseTunnelServer,
trace.ComponentFields: map[string]string{
"cluster": connI... | go | {
"resource": ""
} |
q24051 | GenerateQRCode | train | func GenerateQRCode(u string) ([]byte, error) {
otpKey, err := otp.NewKeyFromURL(u)
if err != nil {
return nil, trace.Wrap(err)
}
otpImage, err := otpKey.Image(450, 450)
if err != nil {
return nil, trace.Wrap(err)
}
var otpQR bytes.Buffer
err = png.Encode(&otpQR, otpImage)
if err != nil {
return nil, t... | go | {
"resource": ""
} |
q24052 | changePassword | train | func (h *Handler) changePassword(w http.ResponseWriter, r *http.Request, p httprouter.Params, ctx *SessionContext) (interface{}, error) {
var req *changePasswordReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
clt, err := ctx.GetClient()
if err != nil {
return nil, trace.Wra... | go | {
"resource": ""
} |
q24053 | u2fChangePasswordRequest | train | func (h *Handler) u2fChangePasswordRequest(w http.ResponseWriter, r *http.Request, _ httprouter.Params, ctx *SessionContext) (interface{}, error) {
var req *client.U2fSignRequestReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
clt, err := ctx.GetClient()
if err != nil {
retu... | go | {
"resource": ""
} |
q24054 | NewStaticFileSystem | train | func NewStaticFileSystem(debugMode bool) (http.FileSystem, error) {
if debugMode {
assetsToCheck := []string{"index.html", "/app"}
if debugAssetsPath == "" {
exePath, err := osext.ExecutableFolder()
if err != nil {
return nil, trace.Wrap(err)
}
debugAssetsPath = path.Join(exePath, "../web/dist")
... | go | {
"resource": ""
} |
q24055 | isDebugMode | train | func isDebugMode() bool {
v, _ := strconv.ParseBool(os.Getenv(teleport.DebugEnvVar))
return v
} | go | {
"resource": ""
} |
q24056 | loadZippedExeAssets | train | func loadZippedExeAssets() (ResourceMap, error) {
// open ourselves (teleport binary) for reading:
// NOTE: the file stays open to serve future Read() requests
myExe, err := osext.Executable()
if err != nil {
return nil, trace.Wrap(err)
}
return readZipArchive(myExe)
} | go | {
"resource": ""
} |
q24057 | LocalRegister | train | func LocalRegister(id IdentityID, authServer *AuthServer, additionalPrincipals, dnsNames []string, remoteAddr string) (*Identity, error) {
// If local registration is happening and no remote address was passed in
// (which means no advertise IP was set), use localhost.
if remoteAddr == "" {
remoteAddr = defaults.L... | go | {
"resource": ""
} |
q24058 | Register | train | func Register(params RegisterParams) (*Identity, error) {
// Read in the token. The token can either be passed in or come from a file
// on disk.
token, err := readToken(params.Token)
if err != nil {
return nil, trace.Wrap(err)
}
// Attempt to register through the auth server, if it fails, try and
// register... | go | {
"resource": ""
} |
q24059 | registerThroughProxy | train | func registerThroughProxy(token string, params RegisterParams) (*Identity, error) {
log.Debugf("Attempting to register through proxy server.")
keys, err := params.CredsClient.HostCredentials(context.Background(),
RegisterUsingTokenRequest{
Token: token,
HostID: params.ID.HostUUID... | go | {
"resource": ""
} |
q24060 | registerThroughAuth | train | func registerThroughAuth(token string, params RegisterParams) (*Identity, error) {
log.Debugf("Attempting to register through auth server.")
var client *Client
var err error
// Build a client to the Auth Server. If a CA pin is specified require the
// Auth Server is validated. Otherwise attempt to use the CA fil... | go | {
"resource": ""
} |
q24061 | insecureRegisterClient | train | func insecureRegisterClient(params RegisterParams) (*Client, error) {
tlsConfig := utils.TLSConfig(params.CipherSuites)
cert, err := readCA(params)
if err != nil && !trace.IsNotFound(err) {
return nil, trace.Wrap(err)
}
// If no CA was found, then create a insecure connection to the Auth Server,
// otherwise ... | go | {
"resource": ""
} |
q24062 | readCA | train | func readCA(params RegisterParams) (*x509.Certificate, error) {
certBytes, err := utils.ReadPath(params.CAPath)
if err != nil {
return nil, trace.Wrap(err)
}
cert, err := tlsca.ParseCertificatePEM(certBytes)
if err != nil {
return nil, trace.Wrap(err, "failed to parse certificate at %v", params.CAPath)
}
ret... | go | {
"resource": ""
} |
q24063 | pinRegisterClient | train | func pinRegisterClient(params RegisterParams) (*Client, error) {
// Build a insecure client to the Auth Server. This is safe because even if
// an attacker were to MITM this connection the CA pin will not match below.
tlsConfig := utils.TLSConfig(params.CipherSuites)
tlsConfig.InsecureSkipVerify = true
client, err... | go | {
"resource": ""
} |
q24064 | ReRegister | train | func ReRegister(params ReRegisterParams) (*Identity, error) {
hostID, err := params.ID.HostID()
if err != nil {
return nil, trace.Wrap(err)
}
keys, err := params.Client.GenerateServerKeys(GenerateServerKeysRequest{
HostID: hostID,
NodeName: params.ID.NodeName,
Roles: ... | go | {
"resource": ""
} |
q24065 | ReadFromFile | train | func ReadFromFile(filePath string) (*FileConfig, error) {
f, err := os.Open(filePath)
if err != nil {
return nil, trace.Wrap(err, fmt.Sprintf("failed to open file: %v", filePath))
}
defer f.Close()
return ReadConfig(f)
} | go | {
"resource": ""
} |
q24066 | ReadFromString | train | func ReadFromString(configString string) (*FileConfig, error) {
data, err := base64.StdEncoding.DecodeString(configString)
if err != nil {
return nil, trace.BadParameter(
"confiugraion should be base64 encoded: %v", err)
}
return ReadConfig(bytes.NewBuffer(data))
} | go | {
"resource": ""
} |
q24067 | ReadConfig | train | func ReadConfig(reader io.Reader) (*FileConfig, error) {
// read & parse YAML config:
bytes, err := ioutil.ReadAll(reader)
if err != nil {
return nil, trace.Wrap(err, "failed reading Teleport configuration")
}
var fc FileConfig
if err = yaml.Unmarshal(bytes, &fc); err != nil {
return nil, trace.BadParameter("... | go | {
"resource": ""
} |
q24068 | MakeSampleFileConfig | train | func MakeSampleFileConfig() (fc *FileConfig) {
conf := service.MakeDefaultConfig()
// sample global config:
var g Global
g.NodeName = conf.Hostname
g.AuthToken = "cluster-join-token"
g.Logger.Output = "stderr"
g.Logger.Severity = "INFO"
g.AuthServers = []string{defaults.AuthListenAddr().Addr}
g.Limits.MaxConn... | go | {
"resource": ""
} |
q24069 | DebugDumpToYAML | train | func (conf *FileConfig) DebugDumpToYAML() string {
bytes, err := yaml.Marshal(&conf)
if err != nil {
panic(err)
}
return string(bytes)
} | go | {
"resource": ""
} |
q24070 | Parse | train | func (c *CachePolicy) Parse() (*service.CachePolicy, error) {
out := service.CachePolicy{
Enabled: c.Enabled(),
NeverExpires: c.NeverExpires(),
}
if out.NeverExpires {
return &out, nil
}
var err error
if c.TTL != "" {
out.TTL, err = time.ParseDuration(c.TTL)
if err != nil {
return nil, trace.Bad... | go | {
"resource": ""
} |
q24071 | Parse | train | func (p *PAM) Parse() *pam.Config {
serviceName := p.ServiceName
if serviceName == "" {
serviceName = defaults.ServiceName
}
enabled, _ := utils.ParseBool(p.Enabled)
return &pam.Config{
Enabled: enabled,
ServiceName: serviceName,
}
} | go | {
"resource": ""
} |
q24072 | ConvertAndValidate | train | func (t *ReverseTunnel) ConvertAndValidate() (services.ReverseTunnel, error) {
for i := range t.Addresses {
addr, err := utils.ParseHostPortAddr(t.Addresses[i], defaults.SSHProxyTunnelListenPort)
if err != nil {
return nil, trace.Wrap(err, "Invalid address for tunnel %v", t.DomainName)
}
t.Addresses[i] = ad... | go | {
"resource": ""
} |
q24073 | Parse | train | func (a *Authority) Parse() (services.CertAuthority, services.Role, error) {
ca := &services.CertAuthorityV1{
AllowedLogins: a.AllowedLogins,
DomainName: a.DomainName,
Type: a.Type,
}
for _, path := range a.CheckingKeyFiles {
keyBytes, err := utils.ReadPath(path)
if err != nil {
return nil,... | go | {
"resource": ""
} |
q24074 | Parse | train | func (o *OIDCConnector) Parse() (services.OIDCConnector, error) {
if o.Display == "" {
o.Display = o.ID
}
var mappings []services.ClaimMapping
for _, c := range o.ClaimsToRoles {
var roles []string
if len(c.Roles) > 0 {
roles = append(roles, c.Roles...)
}
mappings = append(mappings, services.ClaimMap... | go | {
"resource": ""
} |
q24075 | Parse | train | func (u *U2F) Parse() (*services.U2F, error) {
// If no appID specified, default to hostname
appID := u.AppID
if appID == "" {
hostname, err := os.Hostname()
if err != nil {
return nil, trace.Wrap(err, "failed to automatically determine U2F AppID from hostname")
}
appID = fmt.Sprintf("https://%s:%d", stri... | go | {
"resource": ""
} |
q24076 | NewSigner | train | func NewSigner(keyBytes, certBytes []byte) (ssh.Signer, error) {
keySigner, err := ssh.ParsePrivateKey(keyBytes)
if err != nil {
return nil, trace.Wrap(err, "failed to parse SSH private key")
}
pubkey, _, _, _, err := ssh.ParseAuthorizedKey(certBytes)
if err != nil {
return nil, trace.Wrap(err, "failed to par... | go | {
"resource": ""
} |
q24077 | CryptoPublicKey | train | func CryptoPublicKey(publicKey []byte) (crypto.PublicKey, error) {
// reuse the same RSA keys for SSH and TLS keys
pubKey, _, _, _, err := ssh.ParseAuthorizedKey(publicKey)
if err != nil {
return nil, trace.Wrap(err)
}
cryptoPubKey, ok := pubKey.(ssh.CryptoPublicKey)
if !ok {
return nil, trace.BadParameter("e... | go | {
"resource": ""
} |
q24078 | ClusterName | train | func ClusterName(subject pkix.Name) (string, error) {
if len(subject.Organization) == 0 {
return "", trace.BadParameter("missing subject organization")
}
return subject.Organization[0], nil
} | go | {
"resource": ""
} |
q24079 | GenerateRSAPrivateKeyPEM | train | func GenerateRSAPrivateKeyPEM() ([]byte, error) {
priv, err := rsa.GenerateKey(rand.Reader, teleport.RSAKeySize)
if err != nil {
return nil, trace.Wrap(err)
}
return pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(priv)}), nil
} | go | {
"resource": ""
} |
q24080 | ParsePublicKeyPEM | train | func ParsePublicKeyPEM(bytes []byte) (interface{}, error) {
block, _ := pem.Decode(bytes)
if block == nil {
return nil, trace.BadParameter("expected PEM-encoded block")
}
return ParsePublicKeyDER(block.Bytes)
} | go | {
"resource": ""
} |
q24081 | ParsePublicKeyDER | train | func ParsePublicKeyDER(der []byte) (crypto.PublicKey, error) {
generalKey, err := x509.ParsePKIXPublicKey(der)
if err != nil {
return nil, trace.Wrap(err)
}
return generalKey, nil
} | go | {
"resource": ""
} |
q24082 | MarshalPublicKeyFromPrivateKeyPEM | train | func MarshalPublicKeyFromPrivateKeyPEM(privateKey crypto.PrivateKey) ([]byte, error) {
rsaPrivateKey, ok := privateKey.(*rsa.PrivateKey)
if !ok {
return nil, trace.BadParameter("expected RSA key")
}
rsaPublicKey := rsaPrivateKey.Public()
derBytes, err := x509.MarshalPKIXPublicKey(rsaPublicKey)
if err != nil {
... | go | {
"resource": ""
} |
q24083 | isFirstStart | train | func isFirstStart(authServer *AuthServer, cfg InitConfig) (bool, error) {
// check if the CA exists?
_, err := authServer.GetCertAuthority(
services.CertAuthID{
DomainName: cfg.ClusterName.GetClusterName(),
Type: services.HostCA,
}, false)
if err != nil {
if !trace.IsNotFound(err) {
return false... | go | {
"resource": ""
} |
q24084 | GenerateIdentity | train | func GenerateIdentity(a *AuthServer, id IdentityID, additionalPrincipals, dnsNames []string) (*Identity, error) {
keys, err := a.GenerateServerKeys(GenerateServerKeysRequest{
HostID: id.HostUUID,
NodeName: id.NodeName,
Roles: teleport.Roles{id.Role},
AdditionalPrincipal... | go | {
"resource": ""
} |
q24085 | String | train | func (i *Identity) String() string {
var out []string
if i.XCert != nil {
out = append(out, fmt.Sprintf("cert(%v issued by %v:%v)", i.XCert.Subject.CommonName, i.XCert.Issuer.CommonName, i.XCert.Issuer.SerialNumber))
}
for j := range i.TLSCACertsBytes {
cert, err := tlsca.ParseCertificatePEM(i.TLSCACertsBytes[j... | go | {
"resource": ""
} |
q24086 | CertInfo | train | func CertInfo(cert *x509.Certificate) string {
return fmt.Sprintf("cert(%v issued by %v:%v)", cert.Subject.CommonName, cert.Issuer.CommonName, cert.Issuer.SerialNumber)
} | go | {
"resource": ""
} |
q24087 | TLSCertInfo | train | func TLSCertInfo(cert *tls.Certificate) string {
x509cert, err := x509.ParseCertificate(cert.Certificate[0])
if err != nil {
return err.Error()
}
return CertInfo(x509cert)
} | go | {
"resource": ""
} |
q24088 | CertAuthorityInfo | train | func CertAuthorityInfo(ca services.CertAuthority) string {
var out []string
for _, keyPair := range ca.GetTLSKeyPairs() {
cert, err := tlsca.ParseCertificatePEM(keyPair.Cert)
if err != nil {
out = append(out, err.Error())
} else {
out = append(out, fmt.Sprintf("trust root(%v:%v)", cert.Subject.CommonName,... | go | {
"resource": ""
} |
q24089 | HasTLSConfig | train | func (i *Identity) HasTLSConfig() bool {
return len(i.TLSCACertsBytes) != 0 && len(i.TLSCertBytes) != 0
} | go | {
"resource": ""
} |
q24090 | HasPrincipals | train | func (i *Identity) HasPrincipals(additionalPrincipals []string) bool {
set := utils.StringsSet(i.Cert.ValidPrincipals)
for _, principal := range additionalPrincipals {
if _, ok := set[principal]; !ok {
return false
}
}
return true
} | go | {
"resource": ""
} |
q24091 | HasDNSNames | train | func (i *Identity) HasDNSNames(dnsNames []string) bool {
if i.XCert == nil {
return false
}
set := utils.StringsSet(i.XCert.DNSNames)
for _, dnsName := range dnsNames {
if _, ok := set[dnsName]; !ok {
return false
}
}
return true
} | go | {
"resource": ""
} |
q24092 | TLSConfig | train | func (i *Identity) TLSConfig(cipherSuites []uint16) (*tls.Config, error) {
tlsConfig := utils.TLSConfig(cipherSuites)
if !i.HasTLSConfig() {
return nil, trace.NotFound("no TLS credentials setup for this identity")
}
tlsCert, err := tls.X509KeyPair(i.TLSCertBytes, i.KeyBytes)
if err != nil {
return nil, trace.B... | go | {
"resource": ""
} |
q24093 | SSHClientConfig | train | func (i *Identity) SSHClientConfig() *ssh.ClientConfig {
return &ssh.ClientConfig{
User: i.ID.HostUUID,
Auth: []ssh.AuthMethod{
ssh.PublicKeys(i.KeySigner),
},
HostKeyCallback: i.hostKeyCallback,
Timeout: defaults.DefaultDialTimeout,
}
} | go | {
"resource": ""
} |
q24094 | hostKeyCallback | train | func (i *Identity) hostKeyCallback(hostname string, remote net.Addr, key ssh.PublicKey) error {
cert, ok := key.(*ssh.Certificate)
if !ok {
return trace.BadParameter("only host certificates supported")
}
// Loop over all CAs and see if any of them signed the certificate.
for _, k := range i.SSHCACertBytes {
p... | go | {
"resource": ""
} |
q24095 | HostID | train | func (id *IdentityID) HostID() (string, error) {
parts := strings.Split(id.HostUUID, ".")
if len(parts) < 2 {
return "", trace.BadParameter("expected 2 parts in %q", id.HostUUID)
}
return parts[0], nil
} | go | {
"resource": ""
} |
q24096 | Equals | train | func (id *IdentityID) Equals(other IdentityID) bool {
return id.Role == other.Role && id.HostUUID == other.HostUUID
} | go | {
"resource": ""
} |
q24097 | ReadIdentityFromKeyPair | train | func ReadIdentityFromKeyPair(keys *PackedKeys) (*Identity, error) {
identity, err := ReadSSHIdentityFromKeyPair(keys.Key, keys.Cert)
if err != nil {
return nil, trace.Wrap(err)
}
if len(keys.SSHCACerts) != 0 {
identity.SSHCACertBytes = keys.SSHCACerts
}
if len(keys.TLSCACerts) != 0 {
// Parse the key pair... | go | {
"resource": ""
} |
q24098 | ReadTLSIdentityFromKeyPair | train | func ReadTLSIdentityFromKeyPair(keyBytes, certBytes []byte, caCertsBytes [][]byte) (*Identity, error) {
if len(keyBytes) == 0 {
return nil, trace.BadParameter("missing private key")
}
if len(certBytes) == 0 {
return nil, trace.BadParameter("missing certificate")
}
cert, err := tlsca.ParseCertificatePEM(certB... | go | {
"resource": ""
} |
q24099 | ReadSSHIdentityFromKeyPair | train | func ReadSSHIdentityFromKeyPair(keyBytes, certBytes []byte) (*Identity, error) {
if len(keyBytes) == 0 {
return nil, trace.BadParameter("PrivateKey: missing private key")
}
if len(certBytes) == 0 {
return nil, trace.BadParameter("Cert: missing parameter")
}
pubKey, _, _, _, err := ssh.ParseAuthorizedKey(cert... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.