package backend import ( "bufio" "bytes" "encoding/base32" "errors" "fmt" "io/fs" "net" "regexp" "strconv" "strings" "text/template" "time" ou "github.com/pashcovich/openvpn-user/src" log "github.com/sirupsen/logrus" ) func (oAdmin *OvpnAdmin) RegisterMetrics() { oAdmin.PromRegistry.MustRegister(OvpnServerCertExpire) oAdmin.PromRegistry.MustRegister(OvpnServerCaCertExpire) oAdmin.PromRegistry.MustRegister(OvpnClientsTotal) oAdmin.PromRegistry.MustRegister(OvpnClientsRevoked) oAdmin.PromRegistry.MustRegister(OvpnClientsConnected) oAdmin.PromRegistry.MustRegister(OvpnUniqClientsConnected) oAdmin.PromRegistry.MustRegister(OvpnClientsExpired) oAdmin.PromRegistry.MustRegister(OvpnClientCertificateExpire) oAdmin.PromRegistry.MustRegister(OvpnClientConnectionInfo) oAdmin.PromRegistry.MustRegister(OvpnClientConnectionFrom) oAdmin.PromRegistry.MustRegister(OvpnClientBytesReceived) oAdmin.PromRegistry.MustRegister(OvpnClientBytesSent) } func (oAdmin *OvpnAdmin) SetState() { oAdmin.activeClients = oAdmin.mgmtGetActiveClients() oAdmin.clients = oAdmin.usersList() OvpnServerCaCertExpire.Set(float64((getOvpnCaCertExpireDate().Unix() - time.Now().Unix()) / 3600 / 24)) } func (oAdmin *OvpnAdmin) UpdateState() { for { time.Sleep(time.Duration(28) * time.Second) OvpnClientBytesSent.Reset() OvpnClientBytesReceived.Reset() OvpnClientConnectionFrom.Reset() OvpnClientConnectionInfo.Reset() OvpnClientCertificateExpire.Reset() go oAdmin.SetState() } } func IndexTxtParser(txt string) []indexTxtLine { var indexTxt []indexTxtLine txtLinesArray := strings.Split(txt, "\n") for _, v := range txtLinesArray { str := strings.Fields(v) if len(str) > 0 { switch { // case strings.HasPrefix(str[0], "E"): case strings.HasPrefix(str[0], "V"): indexTxt = append(indexTxt, indexTxtLine{Flag: str[0], ExpirationDate: str[1], SerialNumber: str[2], Filename: str[3], DistinguishedName: str[4], Identity: str[4][strings.Index(str[4], "=")+1:]}) case strings.HasPrefix(str[0], "R"): indexTxt = append(indexTxt, indexTxtLine{Flag: str[0], ExpirationDate: str[1], RevocationDate: str[2], SerialNumber: str[3], Filename: str[4], DistinguishedName: str[5], Identity: str[5][strings.Index(str[5], "=")+1:]}) } } } return indexTxt } func renderIndexTxt(data []indexTxtLine) string { indexTxt := "" for _, line := range data { switch { case line.Flag == "V": indexTxt += fmt.Sprintf("%s\t%s\t\t%s\t%s\t%s\n", line.Flag, line.ExpirationDate, line.SerialNumber, line.Filename, line.DistinguishedName) case line.Flag == "R": indexTxt += fmt.Sprintf("%s\t%s\t%s\t%s\t%s\t%s\n", line.Flag, line.ExpirationDate, line.RevocationDate, line.SerialNumber, line.Filename, line.DistinguishedName) // case line.flag == "E": } } return indexTxt } func (oAdmin *OvpnAdmin) getTemplate(name, tplName, path string) *template.Template { if path != "" { return template.Must(template.ParseFiles(path)) } else { tpl, err := fs.ReadFile(oAdmin.Templates, name) if err != nil { log.Errorf("%s not found in templates box: %s", name, err) return nil } return template.Must(template.New(tplName).Parse(string(tpl))) } } //func (oAdmin *OvpnAdmin) getClientConfigTemplate() *template.Template { // if *clientConfigTemplatePath != "" { // return template.Must(template.ParseFiles(*clientConfigTemplatePath)) // } else { // clientConfigFileTpl, ccdTplFileErr := fs.Glob(oAdmin.Templates, "client.conf.tpl") // log.Debug(clientConfigFileTpl) // if ccdTplFileErr != nil { // log.Errorf("clientConfigTpl not found in templates box") // } // log.Debug(len(clientConfigFileTpl)) // if len(clientConfigFileTpl) == 1 { // clientConfigTpl, clientConfigTplErr := fs.ReadFile(oAdmin.Templates, clientConfigFileTpl[0]) // if clientConfigTplErr != nil { // log.Errorf("clientConfigTpl not found in templates box") // } // log.Debug(len(clientConfigTpl)) // return template.Must(template.New("ccd").Parse(string(clientConfigTpl))) // } // return nil // } //} func (oAdmin *OvpnAdmin) renderClientConfig(username string) string { if checkUserExist(username) { var hosts []OpenvpnServer for _, server := range *openvpnServer { parts := strings.SplitN(server, ":", 3) hosts = append(hosts, OpenvpnServer{Host: parts[0], Port: parts[1], Protocol: parts[2]}) } if *openvpnServerBehindLB { var err error hosts, err = getOvpnServerHostsFromKubeApi() if err != nil { log.Error(err) } } conf := openvpnClientConfig{} conf.Hosts = hosts conf.CA = fRead(*EasyrsaDirPath + "/pki/ca.crt") conf.TLS = fRead(*EasyrsaDirPath + "/pki/ta.key") if *StorageBackend == "kubernetes.secrets" { conf.Cert, conf.Key = oAdmin.KubeClient.EasyrsaGetClientCert(username) } else { conf.Cert = fRead(*EasyrsaDirPath + "/pki/issued/" + username + ".crt") conf.Key = fRead(*EasyrsaDirPath + "/pki/private/" + username + ".key") } conf.PasswdAuth = oAdmin.ExtraAuth t := oAdmin.getTemplate("client.conf.tpl", "client-config", *clientConfigTemplatePath) var tmp bytes.Buffer err := t.Execute(&tmp, conf) if err != nil { log.Errorf("something goes wrong during rendering config for %s", username) log.Debugf("rendering config for %s failed with error %v", username, err) } hosts = nil log.Tracef("Rendered config for user %s: %+v", username, tmp.String()) return fmt.Sprintf("%+v", tmp.String()) } log.Warnf("user \"%s\" not found", username) return fmt.Sprintf("user \"%s\" not found", username) } //func (oAdmin *OvpnAdmin) getCcdTemplate() *template.Template { // if *ccdTemplatePath != "" { // return template.Must(template.ParseFiles(*ccdTemplatePath)) // } else { // //ccdTpl, ccdTplErr := oAdmin.Templates.FindString("ccd.tpl") // ccdTplFile, ccdTplFileErr := fs.Glob(oAdmin.Templates, "ccd.tpl") // log.Debug(ccdTplFile) // if ccdTplFileErr != nil { // log.Errorf("ccdTpl not found in templates box") // } // log.Debug(len(ccdTplFile)) // // if len(ccdTplFile) == 1 { // ccdTpl, ccdTplErr := fs.ReadFile(oAdmin.Templates, ccdTplFile[0]) // if ccdTplErr != nil { // log.Errorf("ccdTpl not found in templates box") // } // log.Debug(ccdTpl) // return template.Must(template.New("ccd").Parse(string(ccdTpl))) // } // log.Debug("returning nil") // // return nil // } //} func (oAdmin *OvpnAdmin) parseCcd(username string) CCD { ccd := CCD{} ccd.User = username ccd.ClientAddress = "dynamic" ccd.CustomRoutes = []ccdRoute{} var txtLinesArray []string if *StorageBackend == "kubernetes.secrets" { txtLinesArray = strings.Split(oAdmin.KubeClient.SecretGetCcd(ccd.User), "\n") } else { if fExist(*CcdDir + "/" + username) { txtLinesArray = strings.Split(fRead(*CcdDir+"/"+username), "\n") } } for _, v := range txtLinesArray { str := strings.Fields(v) if len(str) > 0 { switch { case strings.HasPrefix(str[0], "ifconfig-push"): ccd.ClientAddress = str[1] case strings.HasPrefix(str[0], "push"): ccd.CustomRoutes = append(ccd.CustomRoutes, ccdRoute{Address: strings.Trim(str[2], "\""), Mask: strings.Trim(str[3], "\""), Description: strings.Trim(strings.Join(str[4:], ""), "#")}) } } } return ccd } func (oAdmin *OvpnAdmin) modifyCcd(ccd CCD) (bool, string) { ccdValid, err := validateCcd(ccd) if err != "" { return false, err } if ccdValid { t := oAdmin.getTemplate("ccd.tpl", "ccd", *ccdTemplatePath) var tmp bytes.Buffer err := t.Execute(&tmp, ccd) if err != nil { log.Error(err) } if *StorageBackend == "kubernetes.secrets" { oAdmin.KubeClient.SecretUpdateCcd(ccd.User, tmp.Bytes()) } else { err = fWrite(*CcdDir+"/"+ccd.User, tmp.String()) if err != nil { log.Errorf("modifyCcd: fWrite(): %v", err) } } return true, "ccd updated successfully" } return false, "something goes wrong" } func (oAdmin *OvpnAdmin) getCcd(username string) CCD { ccd := CCD{} ccd.User = username ccd.ClientAddress = "dynamic" ccd.CustomRoutes = []ccdRoute{} ccd = oAdmin.parseCcd(username) return ccd } func (oAdmin *OvpnAdmin) usersList() []OpenvpnClient { var users []OpenvpnClient totalCerts := 0 validCerts := 0 revokedCerts := 0 expiredCerts := 0 connectedUniqUsers := 0 totalActiveConnections := 0 apochNow := time.Now().Unix() for _, line := range IndexTxtParser(fRead(*IndexTxtPath)) { if line.Identity != "server" && line.Identity != "ca" && !strings.Contains(line.Identity, "REVOKED") { totalCerts += 1 ovpnClient := OpenvpnClient{Identity: line.Identity, ExpirationDate: parseDateToString(indexTxtDateLayout, line.ExpirationDate, stringDateFormat)} switch { case line.Flag == "V": ovpnClient.AccountStatus = "Active" validCerts += 1 case line.Flag == "R": ovpnClient.AccountStatus = "Revoked" ovpnClient.RevocationDate = parseDateToString(indexTxtDateLayout, line.RevocationDate, stringDateFormat) revokedCerts += 1 case line.Flag == "E": ovpnClient.AccountStatus = "Expired" expiredCerts += 1 } OvpnClientCertificateExpire.WithLabelValues(line.Identity).Set(float64((parseDateToUnix(indexTxtDateLayout, line.ExpirationDate) - apochNow) / 3600 / 24)) if (parseDateToUnix(indexTxtDateLayout, line.ExpirationDate) - apochNow) < 0 { ovpnClient.AccountStatus = "Expired" } ovpnClient.Connections = 0 userConnected, userConnectedTo := isUserConnected(line.Identity, oAdmin.activeClients) if userConnected { ovpnClient.ConnectionStatus = "Connected" for range userConnectedTo { ovpnClient.Connections += 1 totalActiveConnections += 1 } connectedUniqUsers += 1 } if oAdmin.ExtraAuth{ if oAdmin.isSecondFactorConfigured(ovpnClient.Identity) { ovpnClient.SecondFactor = "enabled" } else { ovpnClient.SecondFactor = "disabled" } } users = append(users, ovpnClient) } else { OvpnServerCertExpire.Set(float64((parseDateToUnix(indexTxtDateLayout, line.ExpirationDate) - apochNow) / 3600 / 24)) } } otherCerts := totalCerts - validCerts - revokedCerts - expiredCerts if otherCerts != 0 { log.Warnf("there are %d otherCerts", otherCerts) } OvpnClientsTotal.Set(float64(totalCerts)) OvpnClientsRevoked.Set(float64(revokedCerts)) OvpnClientsExpired.Set(float64(expiredCerts)) OvpnClientsConnected.Set(float64(totalActiveConnections)) OvpnUniqClientsConnected.Set(float64(connectedUniqUsers)) return users } func (oAdmin *OvpnAdmin) userCreate(username, password string) (string, error) { var msg string oAdmin.CreateUserMutex.Lock() defer oAdmin.CreateUserMutex.Unlock() if checkUserExist(username) { msg = fmt.Sprintf("User \"%s\" already exists\n", username) return msg, userAlreadyExistError } if err := validateUsername(username); err != nil { log.Debugf("userCreate: validateUsername(): %s", err.Error()) return err.Error(), err } if oAdmin.ExtraAuth { if err := validatePassword(password); err != nil { log.Debugf("userCreate: authByPassword(): %s", err.Error()) return err.Error(), err } } err := oAdmin.PKI.BuildKeyPairClient(username) if err != nil { log.Error(err) return err.Error(), err } if oAdmin.ExtraAuth { switch *StorageBackend { case "kubernetes.secrets": err = oAdmin.KubeClient.updatePasswordSecret(username, []byte(password)) if err != nil { return err.Error(), err } case "filesystems": _, err := oAdmin.OUser.CreateUser(username, password) if err != nil { return err.Error(), err } } } log.Infof("Certificate for user %s issued", username) return "", nil } func (oAdmin *OvpnAdmin) userChangePassword(username, password string) (error, string) { if checkUserExist(username) { if !oAdmin.OUser.CheckUserExistent(username) { _, err := oAdmin.OUser.CreateUser(username, "") if err != nil { return err, err.Error() } } if err := validatePassword(password); err != nil { log.Warningf("userChangePassword: %s", err.Error()) return err, err.Error() } switch *StorageBackend { case "kubernetes.secrets": err := oAdmin.KubeClient.updatePasswordSecret(username, []byte(password)) if err != nil { return err, err.Error() } case "filesystem": msg, err := oAdmin.OUser.ChangeUserPassword(username, password) if err != nil { return err, msg } } log.Infof("Password for user %s was changed", username) return nil, "Password changed" } return errors.New(fmt.Sprintf("User \"%s\" not found}", username)), fmt.Sprintf("{\"msg\":\"User \"%s\" not found\"}", username) } func (oAdmin *OvpnAdmin) isSecondFactorConfigured(username string) bool { switch *StorageBackend { case "kubernetes.secrets": sfe, err := oAdmin.KubeClient.SecondFactorEnabled(username) if err != nil { return false } return sfe case "filesystem": switch *AuthType { case "TOTP": sfe, err := oAdmin.OUser.IsSecondFactorEnabled(username) if err != nil { return false } return sfe case "PASSWORD": return true //TODO: check if password is exist in db } default: return false } return false } func (oAdmin *OvpnAdmin) getUserSecret(username string) (string, error) { if checkUserExist(username) { var userSecret string var err error if *StorageBackend == "kubernetes.secrets" { userSecret, err = oAdmin.KubeClient.secondFactorSecret(username) if err != nil { return err.Error(), err } } else { if !oAdmin.OUser.CheckUserExistent(username) { _, err = oAdmin.OUser.CreateUser(username, "") if err != nil { return "", err } } userSecret, err = oAdmin.OUser.GetUserOtpSecret(username) if err != nil { return "", err } } val, valErr := base32.StdEncoding.DecodeString(userSecret) if valErr != nil { return "", fmt.Errorf("can`t get user secret") } if string(val) == "" { if *StorageBackend == "kubernetes.secrets" { rndStr := ou.RandStr(20, "number") newSecret := make([]byte, base32.StdEncoding.EncodedLen(len(rndStr))) base32.StdEncoding.Encode(newSecret, []byte(rndStr)) updUserSecretErr := oAdmin.KubeClient.updateSecondFactorSecret(username, newSecret) if updUserSecretErr != nil { return "", updUserSecretErr } userSecret = string(newSecret) } else { _, updUserSecretErr := oAdmin.OUser.RegisterOtpSecret(username, "generate") if updUserSecretErr != nil { return "", updUserSecretErr } userSecret, err = oAdmin.OUser.GetUserOtpSecret(username) if err != nil { return "", err } } _, err = base32.StdEncoding.DecodeString(userSecret) if err != nil { return "", fmt.Errorf("can`t get user secret") } return userSecret, nil } return userSecret, nil } return fmt.Sprintf("{\"msg\":\"User \"%s\" not found\"}", username), fmt.Errorf("user \"%s\" not found", username) } func (oAdmin *OvpnAdmin) registerUserAuthApp(username, totp string) error { if checkUserExist(username) { if *StorageBackend == "kubernetes.secrets" { authOK, authErr := oAdmin.KubeClient.authByTOTP(username, totp) if authErr != nil { return authErr } if authOK { err := oAdmin.KubeClient.addSecondFactorEnabledLabel(username) if err != nil { return err } } } else { if !oAdmin.OUser.CheckUserExistent(username) { _, createErr := oAdmin.OUser.CreateUser(username, "") if createErr != nil { return createErr } } _, registerErr := oAdmin.OUser.RegisterOtpApplication(username, totp) if registerErr != nil { return registerErr } } for i, u := range oAdmin.clients { if u.Identity == username { oAdmin.clients[i].SecondFactor = "enabled" } } log.Infof("TOTP configured for user %s", username) return nil } return fmt.Errorf("user \"%s\" not found", username) } func (oAdmin *OvpnAdmin) resetUserAuthApp(username string) error { if checkUserExist(username) { if *StorageBackend == "kubernetes.secrets" { err := oAdmin.KubeClient.deleteSecondFactorEnabledLabel(username) if err != nil { return err } } else { _, resetErr := oAdmin.OUser.ResetOtpApplication(username) if resetErr != nil { return resetErr } } for i, u := range oAdmin.clients { if u.Identity == username { oAdmin.clients[i].SecondFactor = "disabled" } } return nil } return fmt.Errorf("user \"%s\" not found", username) } func (oAdmin *OvpnAdmin) checkAuth(username, token string) error { if checkUserExist(username) { var auth bool var authErr error if *StorageBackend == "kubernetes.secrets" { auth, authErr = oAdmin.KubeClient.authByTOTP(username, token) if authErr != nil { return authErr } } else { switch *AuthType { case "TOTP": auth, authErr = oAdmin.OUser.AuthUser(username, "", token) case "PASSWORD": auth, authErr = oAdmin.OUser.AuthUser(username, token, "") } if authErr != nil { return authErr } } if auth { return nil } return fmt.Errorf("authorization failed") } return fmt.Errorf("user \"%s\" not found", username) } func (oAdmin *OvpnAdmin) getUserStatistic(username string) []ClientStatus { var userStatistic []ClientStatus for _, u := range oAdmin.activeClients { if u.CommonName == username { userStatistic = append(userStatistic, u) } } return userStatistic } func (oAdmin *OvpnAdmin) userRevoke(username string) (error, string) { log.Infof("Revoke certificate for user %s", username) if checkUserExist(username) { err := oAdmin.PKI.CertificateRevoke(username) if err != nil { log.Error(err) } if *StorageBackend == "filesystem" { if oAdmin.ExtraAuth && oAdmin.OUser.CheckUserExistent(username) { revokeMsg, revokeErr := oAdmin.OUser.RevokedUser(username) log.Debug(revokeMsg) log.Debug(revokeErr) if revokeErr != nil { return revokeErr, "" } } } userConnected, userConnectedTo := isUserConnected(username, oAdmin.activeClients) log.Tracef("User %s connected: %t", username, userConnected) if userConnected { for _, connection := range userConnectedTo { oAdmin.mgmtKillUserConnection(username, connection) log.Infof("Session for user \"%s\" killed", username) } } oAdmin.SetState() return nil, fmt.Sprintf("user \"%s\" revoked", username) } log.Infof("user \"%s\" not found", username) return fmt.Errorf("user \"%s\" not found", username), fmt.Sprintf("User \"%s\" not found", username) } func (oAdmin *OvpnAdmin) userUnrevoke(username string) (error, string) { if checkUserExist(username) { err := oAdmin.PKI.CertificateUnRevoke(username) if err != nil { log.Error(err) } if *StorageBackend == "filesystem" { if oAdmin.ExtraAuth && oAdmin.OUser.CheckUserExistent(username) { restoreMsg, restoreErr := oAdmin.OUser.RestoreUser(username) log.Debug(restoreMsg) log.Debug(restoreErr) if restoreErr != nil { return restoreErr, "" } } } oAdmin.clients = oAdmin.usersList() return nil, fmt.Sprintf("{\"msg\":\"User %s successfully unrevoked\"}", username) } return fmt.Errorf("user \"%s\" not found", username), fmt.Sprintf("{\"msg\":\"User \"%s\" not found\"}", username) } func (oAdmin *OvpnAdmin) userRotate(username, newPassword string) (error, string) { if checkUserExist(username) { err := oAdmin.PKI.CertificateRotate(username) if err != nil { log.Error(err) } if *StorageBackend == "filesystem" { if oAdmin.ExtraAuth && oAdmin.OUser.CheckUserExistent(username) { deleteMsg, deleteErr := oAdmin.OUser.DeleteUser(username, true) log.Debug(deleteMsg) log.Debug(deleteErr) if deleteErr != nil { return deleteErr, "" } log.Debug(deleteMsg) } } oAdmin.clients = oAdmin.usersList() return nil, fmt.Sprintf("{\"msg\":\"User %s successfully rotated\"}", username) } return fmt.Errorf("user \"%s\" not found", username), fmt.Sprintf("{\"msg\":\"User \"%s\" not found\"}", username) } func (oAdmin *OvpnAdmin) userDelete(username string) (error, string) { if checkUserExist(username) { err := oAdmin.PKI.CertificateDelAfterRevoke(username) if err != nil { log.Error(err) } if *StorageBackend == "filesystem" { if oAdmin.ExtraAuth && oAdmin.OUser.CheckUserExistent(username) { deleteMsg, deleteErr := oAdmin.OUser.DeleteUser(username, true) log.Debug(deleteMsg) log.Debug(deleteErr) if deleteErr != nil { return deleteErr, "" } log.Debug(deleteMsg) } } oAdmin.clients = oAdmin.usersList() return nil, fmt.Sprintf("{\"msg\":\"User %s successfully deleted\"}", username) } return fmt.Errorf("user \"%s\" not found", username), fmt.Sprintf("{\"msg\":\"User \"%s\" not found\"}", username) } func (oAdmin *OvpnAdmin) mgmtRead(conn net.Conn) string { recvData := make([]byte, 32768) var out string var n int var err error for { n, err = conn.Read(recvData) if n <= 0 || err != nil { break } else { out += string(recvData[:n]) if strings.Contains(out, "type 'help' for more info") || strings.Contains(out, "END") || strings.Contains(out, "SUCCESS:") || strings.Contains(out, "ERROR:") { break } } } return out } func (oAdmin *OvpnAdmin) mgmtConnectedUsersParser(text, serverName string) []ClientStatus { var u []ClientStatus isClientList := false isRouteTable := false scanner := bufio.NewScanner(strings.NewReader(text)) for scanner.Scan() { txt := scanner.Text() if regexp.MustCompile(`^Common Name,Real Address,Bytes Received,Bytes Sent,Connected Since$`).MatchString(txt) { isClientList = true continue } if regexp.MustCompile(`^ROUTING TABLE$`).MatchString(txt) { isClientList = false continue } if regexp.MustCompile(`^Virtual Address,Common Name,Real Address,Last Ref$`).MatchString(txt) { isRouteTable = true continue } if regexp.MustCompile(`^GLOBAL STATS$`).MatchString(txt) { // isRouteTable = false // ineffectual assignment to isRouteTable (ineffassign) break } if isClientList { user := strings.Split(txt, ",") userName := user[0] userAddress := user[1] userBytesReceived := user[2] userBytesSent := user[3] userConnectedSince := user[4] userStatus := ClientStatus{CommonName: userName, RealAddress: userAddress, BytesReceived: userBytesReceived, BytesSent: userBytesSent, ConnectedSince: userConnectedSince, ConnectedTo: serverName} u = append(u, userStatus) bytesSent, _ := strconv.Atoi(userBytesSent) bytesReceive, _ := strconv.Atoi(userBytesReceived) OvpnClientConnectionFrom.WithLabelValues(userName, userAddress).Set(float64(parseDateToUnix(oAdmin.mgmtStatusTimeFormat, userConnectedSince))) OvpnClientBytesSent.WithLabelValues(userName).Set(float64(bytesSent)) OvpnClientBytesReceived.WithLabelValues(userName).Set(float64(bytesReceive)) } if isRouteTable { user := strings.Split(txt, ",") for i := range u { if u[i].CommonName == user[1] { u[i].VirtualAddress = user[0] u[i].RealAddress = user[2] u[i].LastRef = user[3] OvpnClientConnectionInfo.WithLabelValues(user[1], user[0], user[2]).Set(float64(parseDateToUnix(oAdmin.mgmtStatusTimeFormat, user[3]))) break } } } } return u } func (oAdmin *OvpnAdmin) mgmtKillUserConnection(username, serverName string) { conn, err := net.Dial("tcp", oAdmin.MgmtInterfaces[serverName]) if err != nil { log.Errorf("openvpn mgmt interface for %s is not reachable by addr %s", serverName, oAdmin.MgmtInterfaces[serverName]) return } oAdmin.mgmtRead(conn) // read welcome message conn.Write([]byte(fmt.Sprintf("kill %s\n", username))) fmt.Printf("%v", oAdmin.mgmtRead(conn)) conn.Close() } func (oAdmin *OvpnAdmin) mgmtGetActiveClients() []ClientStatus { var activeClients []ClientStatus for srv, addr := range oAdmin.MgmtInterfaces { conn, err := net.Dial("tcp", addr) if err != nil { log.Warnf("openvpn mgmt interface for %s is not reachable by addr %s", srv, addr) break } oAdmin.mgmtRead(conn) // read welcome message conn.Write([]byte("status 1\n")) activeClients = append(activeClients, oAdmin.mgmtConnectedUsersParser(oAdmin.mgmtRead(conn), srv)...) conn.Close() } return activeClients } func (oAdmin *OvpnAdmin) MgmtSetTimeFormat() { // time format for version 2.5 and may be newer oAdmin.mgmtStatusTimeFormat = "2006-01-02 15:04:05" log.Debugf("mgmtStatusTimeFormat: %s", oAdmin.mgmtStatusTimeFormat) type serverVersion struct { name string version string } var serverVersions []serverVersion for srv, addr := range oAdmin.MgmtInterfaces { var conn net.Conn var err error for connAttempt := 0; connAttempt < 10; connAttempt++ { conn, err = net.Dial("tcp", addr) if err == nil { log.Debugf("mgmtSetTimeFormat: successful connection to %s/%s", srv, addr) break } log.Warnf("mgmtSetTimeFormat: openvpn mgmt interface for %s is not reachable by addr %s", srv, addr) time.Sleep(time.Duration(2) * time.Second) } if err != nil { break } oAdmin.mgmtRead(conn) // read welcome message conn.Write([]byte("version\n")) out := oAdmin.mgmtRead(conn) conn.Close() log.Trace(out) for _, s := range strings.Split(out, "\n") { if strings.Contains(s, "OpenVPN Version:") { serverVersions = append(serverVersions, serverVersion{srv, strings.Split(s, " ")[3]}) break } } } if len(serverVersions) == 0 { return } firstVersion := serverVersions[0].version if strings.HasPrefix(firstVersion, "2.4") { oAdmin.mgmtStatusTimeFormat = time.ANSIC log.Debugf("mgmtStatusTimeFormat changed: %s", oAdmin.mgmtStatusTimeFormat) } warn := "" for _, v := range serverVersions { if firstVersion != v.version { warn = "mgmtSetTimeFormat: servers have different versions of openvpn, user connection status may not work" log.Warn(warn) break } } if warn != "" { for _, v := range serverVersions { log.Infof("server name: %s, version: %s", v.name, v.version) } } } func (oAdmin *OvpnAdmin) downloadCerts() bool { if fExist(certsArchivePath) { err := fDelete(certsArchivePath) if err != nil { log.Error(err) } } err := fDownload(certsArchivePath, *masterHost+DownloadCertsApiUrl+"?token="+oAdmin.MasterSyncToken, oAdmin.MasterHostBasicAuth) if err != nil { log.Error(err) return false } return true } func (oAdmin *OvpnAdmin) downloadCcd() bool { if fExist(ccdArchivePath) { err := fDelete(ccdArchivePath) if err != nil { log.Error(err) } } err := fDownload(ccdArchivePath, *masterHost+DownloadCcdApiUrl+"?token="+oAdmin.MasterSyncToken, oAdmin.MasterHostBasicAuth) if err != nil { log.Error(err) return false } return true } func (oAdmin *OvpnAdmin) SyncDataFromMaster() { retryCountMax := 3 certsDownloadFailed := true ccdDownloadFailed := true for certsDownloadRetries := 0; certsDownloadRetries < retryCountMax; certsDownloadRetries++ { log.Infof("Downloading archive with certificates from master. Attempt %d", certsDownloadRetries) if oAdmin.downloadCerts() { certsDownloadFailed = false log.Info("Decompressing archive with certificates from master") unArchiveCerts() log.Info("Decompression archive with certificates from master completed") break } else { log.Warnf("Something goes wrong during downloading archive with certificates from master. Attempt %d", certsDownloadRetries) } } for ccdDownloadRetries := 0; ccdDownloadRetries < retryCountMax; ccdDownloadRetries++ { log.Infof("Downloading archive with ccd from master. Attempt %d", ccdDownloadRetries) if oAdmin.downloadCcd() { ccdDownloadFailed = false log.Info("Decompressing archive with ccd from master") unArchiveCcd() log.Info("Decompression archive with ccd from master completed") break } else { log.Warnf("Something goes wrong during downloading archive with ccd from master. Attempt %d", ccdDownloadRetries) } } oAdmin.LastSyncTime = time.Now().Format(stringDateFormat) if !ccdDownloadFailed && !certsDownloadFailed { oAdmin.LastSuccessfulSyncTime = time.Now().Format(stringDateFormat) } } func (oAdmin *OvpnAdmin) SyncWithMaster() { for { time.Sleep(time.Duration(*masterSyncFrequency) * time.Second) oAdmin.SyncDataFromMaster() } } func (oAdmin *OvpnAdmin) IsTotpAuth() bool { if IsModuleEnabled("totpAuth", oAdmin.Modules) { return true } return false } func (oAdmin *OvpnAdmin) IsPasswdAuth() bool { if IsModuleEnabled("passwdAuth", oAdmin.Modules) { return true } return false }