997 lines
No EOL
28 KiB
Go
997 lines
No EOL
28 KiB
Go
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
|
|
} |