2014-04-10 13:20:58 -05:00
// Copyright 2014 The Gogs Authors. All rights reserved.
2016-12-21 07:13:17 -05:00
// Copyright 2016 The Gitea Authors. All rights reserved.
2014-04-10 13:20:58 -05:00
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
2014-05-01 20:21:46 -05:00
package cmd
2014-04-10 13:20:58 -05:00
import (
"fmt"
2019-06-01 10:00:21 -05:00
"net/http"
"net/url"
2014-04-10 13:20:58 -05:00
"os"
"os/exec"
2020-02-05 04:40:35 -05:00
"regexp"
2019-06-01 10:00:21 -05:00
"strconv"
2014-04-10 13:20:58 -05:00
"strings"
2014-08-09 17:40:10 -05:00
"time"
2014-04-10 13:20:58 -05:00
2016-11-10 11:24:48 -05:00
"code.gitea.io/gitea/models"
2021-12-10 03:14:24 -05:00
asymkey_model "code.gitea.io/gitea/models/asymkey"
2021-11-28 06:58:28 -05:00
"code.gitea.io/gitea/models/perm"
2021-07-28 04:42:56 -05:00
"code.gitea.io/gitea/modules/git"
2021-07-24 11:03:58 -05:00
"code.gitea.io/gitea/modules/json"
2016-11-10 11:24:48 -05:00
"code.gitea.io/gitea/modules/log"
2018-08-07 13:49:18 -05:00
"code.gitea.io/gitea/modules/pprof"
2017-04-18 22:45:01 -05:00
"code.gitea.io/gitea/modules/private"
2022-06-03 09:36:18 -05:00
"code.gitea.io/gitea/modules/process"
2022-05-08 11:46:32 -05:00
repo_module "code.gitea.io/gitea/modules/repository"
2016-11-10 11:24:48 -05:00
"code.gitea.io/gitea/modules/setting"
2021-04-08 17:25:57 -05:00
"code.gitea.io/gitea/services/lfs"
2017-04-12 02:44:54 -05:00
2022-01-14 10:03:31 -05:00
"github.com/golang-jwt/jwt/v4"
2020-08-28 14:55:25 -05:00
"github.com/kballard/go-shellquote"
2016-11-09 17:18:22 -05:00
"github.com/urfave/cli"
2014-04-10 13:20:58 -05:00
)
2015-02-16 09:38:01 -05:00
const (
2016-12-25 20:16:37 -05:00
lfsAuthenticateVerb = "git-lfs-authenticate"
2015-02-16 09:38:01 -05:00
)
2016-11-04 06:42:18 -05:00
// CmdServ represents the available serv sub-command.
2014-04-10 13:20:58 -05:00
var CmdServ = cli . Command {
2014-05-04 23:55:17 -05:00
Name : "serv" ,
Usage : "This command should only be called by SSH shell" ,
Description : ` Serv provide access auth for repositories ` ,
Action : runServ ,
2015-02-05 05:12:37 -05:00
Flags : [ ] cli . Flag {
2018-08-07 13:49:18 -05:00
cli . BoolFlag {
Name : "enable-pprof" ,
} ,
2019-12-25 10:44:57 -05:00
cli . BoolFlag {
Name : "debug" ,
} ,
2015-02-05 05:12:37 -05:00
} ,
2014-04-10 13:20:58 -05:00
}
2019-12-25 10:44:57 -05:00
func setup ( logPath string , debug bool ) {
2020-08-31 12:12:49 -05:00
_ = log . DelLogger ( "console" )
if debug {
_ = log . NewLogger ( 1000 , "console" , "console" , ` { "level":"trace","stacktracelevel":"NONE","stderr":true} ` )
2020-10-07 15:44:16 -05:00
} else {
_ = log . NewLogger ( 1000 , "console" , "console" , ` { "level":"fatal","stacktracelevel":"NONE","stderr":true} ` )
2019-12-25 10:44:57 -05:00
}
2021-12-01 02:50:01 -05:00
setting . LoadFromExisting ( )
2019-12-25 10:44:57 -05:00
if debug {
2021-01-14 16:17:03 -05:00
setting . RunMode = "dev"
2019-12-25 10:44:57 -05:00
}
2014-05-21 20:37:13 -05:00
}
var (
2021-11-28 06:58:28 -05:00
allowedCommands = map [ string ] perm . AccessMode {
"git-upload-pack" : perm . AccessModeRead ,
"git-upload-archive" : perm . AccessModeRead ,
"git-receive-pack" : perm . AccessModeWrite ,
lfsAuthenticateVerb : perm . AccessModeNone ,
2014-05-21 20:37:13 -05:00
}
2020-02-05 04:40:35 -05:00
alphaDashDotPattern = regexp . MustCompile ( ` [^\w-\.] ` )
2014-05-21 20:37:13 -05:00
)
2021-07-14 09:43:13 -05:00
func fail ( userMessage , logMessage string , args ... interface { } ) error {
// There appears to be a chance to cause a zombie process and failure to read the Exit status
// if nothing is outputted on stdout.
fmt . Fprintln ( os . Stdout , "" )
2016-12-21 07:13:17 -05:00
fmt . Fprintln ( os . Stderr , "Gitea:" , userMessage )
2015-11-08 14:31:49 -05:00
if len ( logMessage ) > 0 {
2021-10-20 09:37:19 -05:00
if ! setting . IsProd {
2015-11-30 10:00:52 -05:00
fmt . Fprintf ( os . Stderr , logMessage + "\n" , args ... )
2015-11-23 22:33:24 -05:00
}
2015-11-08 14:31:49 -05:00
}
2021-07-14 09:43:13 -05:00
ctx , cancel := installSignals ( )
defer cancel ( )
2015-11-08 14:31:49 -05:00
2021-05-21 16:37:16 -05:00
if len ( logMessage ) > 0 {
2021-07-14 09:43:13 -05:00
_ = private . SSHLog ( ctx , true , fmt . Sprintf ( logMessage + ": " , args ... ) )
2021-05-21 16:37:16 -05:00
}
2022-01-16 04:32:32 -05:00
return cli . NewExitError ( "" , 1 )
2015-08-06 09:48:11 -05:00
}
2016-05-12 13:32:28 -05:00
func runServ ( c * cli . Context ) error {
2021-07-14 09:43:13 -05:00
ctx , cancel := installSignals ( )
defer cancel ( )
2019-06-01 10:00:21 -05:00
// FIXME: This needs to internationalised
2019-12-25 10:44:57 -05:00
setup ( "serv.log" , c . Bool ( "debug" ) )
2014-04-10 13:20:58 -05:00
2016-02-27 20:48:39 -05:00
if setting . SSH . Disabled {
2016-12-21 07:13:17 -05:00
println ( "Gitea: SSH has been disabled" )
2016-05-12 13:32:28 -05:00
return nil
2016-02-21 21:55:59 -05:00
}
2015-02-13 00:58:46 -05:00
if len ( c . Args ( ) ) < 1 {
2019-06-12 14:41:28 -05:00
if err := cli . ShowSubcommandHelp ( c ) ; err != nil {
fmt . Printf ( "error showing subcommand help: %v\n" , err )
}
2017-04-12 02:44:54 -05:00
return nil
2015-02-09 05:32:42 -05:00
}
2015-02-16 09:38:01 -05:00
2019-06-01 10:00:21 -05:00
keys := strings . Split ( c . Args ( ) [ 0 ] , "-" )
if len ( keys ) != 2 || keys [ 0 ] != "key" {
2021-07-14 09:43:13 -05:00
return fail ( "Key ID format error" , "Invalid key argument: %s" , c . Args ( ) [ 0 ] )
2019-06-01 10:00:21 -05:00
}
2020-12-25 04:59:32 -05:00
keyID , err := strconv . ParseInt ( keys [ 1 ] , 10 , 64 )
if err != nil {
2021-07-14 09:43:13 -05:00
return fail ( "Key ID format error" , "Invalid key argument: %s" , c . Args ( ) [ 1 ] )
2020-12-25 04:59:32 -05:00
}
2019-06-01 10:00:21 -05:00
2014-04-10 13:20:58 -05:00
cmd := os . Getenv ( "SSH_ORIGINAL_COMMAND" )
2015-08-04 22:14:17 -05:00
if len ( cmd ) == 0 {
2021-07-14 09:43:13 -05:00
key , user , err := private . ServNoCommand ( ctx , keyID )
2019-06-01 10:00:21 -05:00
if err != nil {
2021-07-14 09:43:13 -05:00
return fail ( "Internal error" , "Failed to check provided key: %v" , err )
2019-06-01 10:00:21 -05:00
}
2020-10-10 19:38:09 -05:00
switch key . Type {
2021-12-10 03:14:24 -05:00
case asymkey_model . KeyTypeDeploy :
2019-06-01 10:00:21 -05:00
println ( "Hi there! You've successfully authenticated with the deploy key named " + key . Name + ", but Gitea does not provide shell access." )
2021-12-10 03:14:24 -05:00
case asymkey_model . KeyTypePrincipal :
2020-10-10 19:38:09 -05:00
println ( "Hi there! You've successfully authenticated with the principal " + key . Content + ", but Gitea does not provide shell access." )
default :
2019-08-11 07:15:58 -05:00
println ( "Hi there, " + user . Name + "! You've successfully authenticated with the key named " + key . Name + ", but Gitea does not provide shell access." )
2019-06-01 10:00:21 -05:00
}
2016-12-21 07:13:17 -05:00
println ( "If this is unexpected, please log in with password and setup Gitea under another user." )
2016-05-12 13:32:28 -05:00
return nil
2020-08-31 12:12:49 -05:00
} else if c . Bool ( "debug" ) {
log . Debug ( "SSH_ORIGINAL_COMMAND: %s" , os . Getenv ( "SSH_ORIGINAL_COMMAND" ) )
2014-04-10 13:20:58 -05:00
}
2020-08-28 14:55:25 -05:00
words , err := shellquote . Split ( cmd )
if err != nil {
2021-07-14 09:43:13 -05:00
return fail ( "Error parsing arguments" , "Failed to parse arguments: %v" , err )
2020-08-28 14:55:25 -05:00
}
if len ( words ) < 2 {
2021-07-28 04:42:56 -05:00
if git . CheckGitVersionAtLeast ( "2.29" ) == nil {
// for AGit Flow
if cmd == "ssh_info" {
fmt . Print ( ` { "type":"gitea","version":1} ` )
return nil
}
}
2021-07-14 09:43:13 -05:00
return fail ( "Too few arguments" , "Too few arguments in cmd: %s" , cmd )
2020-08-28 14:55:25 -05:00
}
verb := words [ 0 ]
repoPath := words [ 1 ]
if repoPath [ 0 ] == '/' {
repoPath = repoPath [ 1 : ]
}
2016-12-25 20:16:37 -05:00
var lfsVerb string
if verb == lfsAuthenticateVerb {
if ! setting . LFS . StartServer {
2021-07-14 09:43:13 -05:00
return fail ( "Unknown git command" , "LFS authentication request over SSH denied, LFS support is disabled" )
2016-12-25 20:16:37 -05:00
}
2020-08-28 14:55:25 -05:00
if len ( words ) > 2 {
lfsVerb = words [ 2 ]
2016-12-25 20:16:37 -05:00
}
}
2020-08-31 12:12:49 -05:00
// LowerCase and trim the repoPath as that's how they are stored.
repoPath = strings . ToLower ( strings . TrimSpace ( repoPath ) )
2014-04-10 13:20:58 -05:00
rr := strings . SplitN ( repoPath , "/" , 2 )
if len ( rr ) != 2 {
2021-07-14 09:43:13 -05:00
return fail ( "Invalid repository path" , "Invalid repository path: %v" , repoPath )
2014-04-10 13:20:58 -05:00
}
2017-02-25 09:54:40 -05:00
2015-11-30 20:45:55 -05:00
username := strings . ToLower ( rr [ 0 ] )
reponame := strings . ToLower ( strings . TrimSuffix ( rr [ 1 ] , ".git" ) )
2020-02-05 04:40:35 -05:00
if alphaDashDotPattern . MatchString ( reponame ) {
2021-07-14 09:43:13 -05:00
return fail ( "Invalid repo name" , "Invalid repo name: %s" , reponame )
2020-02-05 04:40:35 -05:00
}
2021-12-22 11:48:12 -05:00
if c . Bool ( "enable-pprof" ) {
2018-08-07 13:49:18 -05:00
if err := os . MkdirAll ( setting . PprofDataPath , os . ModePerm ) ; err != nil {
2021-07-14 09:43:13 -05:00
return fail ( "Error while trying to create PPROF_DATA_PATH" , "Error while trying to create PPROF_DATA_PATH: %v" , err )
2018-08-07 13:49:18 -05:00
}
2019-06-01 10:00:21 -05:00
stopCPUProfiler , err := pprof . DumpCPUProfileForUsername ( setting . PprofDataPath , username )
if err != nil {
2021-07-14 09:43:13 -05:00
return fail ( "Internal Server Error" , "Unable to start CPU profile: %v" , err )
2019-06-01 10:00:21 -05:00
}
2018-08-07 13:49:18 -05:00
defer func ( ) {
stopCPUProfiler ( )
2019-06-01 10:00:21 -05:00
err := pprof . DumpMemProfileForUsername ( setting . PprofDataPath , username )
if err != nil {
2021-07-14 09:43:13 -05:00
_ = fail ( "Internal Server Error" , "Unable to dump Mem Profile: %v" , err )
2019-06-01 10:00:21 -05:00
}
2018-08-07 13:49:18 -05:00
} ( )
}
2015-11-23 22:32:07 -05:00
requestedMode , has := allowedCommands [ verb ]
2015-02-16 09:38:01 -05:00
if ! has {
2021-07-14 09:43:13 -05:00
return fail ( "Unknown git command" , "Unknown git command %s" , verb )
2015-02-16 09:38:01 -05:00
}
2014-04-10 13:20:58 -05:00
2016-12-25 20:16:37 -05:00
if verb == lfsAuthenticateVerb {
if lfsVerb == "upload" {
2021-11-28 06:58:28 -05:00
requestedMode = perm . AccessModeWrite
2017-03-22 05:43:28 -05:00
} else if lfsVerb == "download" {
2021-11-28 06:58:28 -05:00
requestedMode = perm . AccessModeRead
2017-03-22 05:43:28 -05:00
} else {
2021-07-14 09:43:13 -05:00
return fail ( "Unknown LFS verb" , "Unknown lfs verb %s" , lfsVerb )
2016-12-25 20:16:37 -05:00
}
}
2021-07-14 09:43:13 -05:00
results , err := private . ServCommand ( ctx , keyID , username , reponame , requestedMode , verb , lfsVerb )
2019-06-01 10:00:21 -05:00
if err != nil {
if private . IsErrServCommand ( err ) {
errServCommand := err . ( private . ErrServCommand )
if errServCommand . StatusCode != http . StatusInternalServerError {
2021-07-14 09:43:13 -05:00
return fail ( "Unauthorized" , "%s" , errServCommand . Error ( ) )
2015-08-04 22:14:17 -05:00
}
2021-07-14 09:43:13 -05:00
return fail ( "Internal Server Error" , "%s" , errServCommand . Error ( ) )
2014-04-10 13:20:58 -05:00
}
2021-07-14 09:43:13 -05:00
return fail ( "Internal Server Error" , "%s" , err . Error ( ) )
2014-04-10 13:20:58 -05:00
}
2022-05-08 11:46:32 -05:00
os . Setenv ( repo_module . EnvRepoIsWiki , strconv . FormatBool ( results . IsWiki ) )
os . Setenv ( repo_module . EnvRepoName , results . RepoName )
os . Setenv ( repo_module . EnvRepoUsername , results . OwnerName )
os . Setenv ( repo_module . EnvPusherName , results . UserName )
os . Setenv ( repo_module . EnvPusherEmail , results . UserEmail )
os . Setenv ( repo_module . EnvPusherID , strconv . FormatInt ( results . UserID , 10 ) )
os . Setenv ( repo_module . EnvRepoID , strconv . FormatInt ( results . RepoID , 10 ) )
os . Setenv ( repo_module . EnvPRID , fmt . Sprintf ( "%d" , 0 ) )
os . Setenv ( repo_module . EnvDeployKeyID , fmt . Sprintf ( "%d" , results . DeployKeyID ) )
os . Setenv ( repo_module . EnvKeyID , fmt . Sprintf ( "%d" , results . KeyID ) )
os . Setenv ( repo_module . EnvAppURL , setting . AppURL )
2014-04-10 13:20:58 -05:00
2022-01-20 12:46:10 -05:00
// LFS token authentication
2016-12-25 20:16:37 -05:00
if verb == lfsAuthenticateVerb {
2019-06-01 10:00:21 -05:00
url := fmt . Sprintf ( "%s%s/%s.git/info/lfs" , setting . AppURL , url . PathEscape ( results . OwnerName ) , url . PathEscape ( results . RepoName ) )
2016-12-25 20:16:37 -05:00
now := time . Now ( )
2020-03-09 14:56:18 -05:00
claims := lfs . Claims {
2022-01-20 16:52:56 -05:00
RegisteredClaims : jwt . RegisteredClaims {
ExpiresAt : jwt . NewNumericDate ( now . Add ( setting . LFS . HTTPAuthExpiry ) ) ,
NotBefore : jwt . NewNumericDate ( now ) ,
2020-03-09 14:56:18 -05:00
} ,
RepoID : results . RepoID ,
Op : lfsVerb ,
UserID : results . UserID ,
2018-01-27 11:48:15 -05:00
}
token := jwt . NewWithClaims ( jwt . SigningMethodHS256 , claims )
2016-12-25 20:16:37 -05:00
// Sign and get the complete encoded token as a string using the secret
tokenString , err := token . SignedString ( setting . LFS . JWTSecretBytes )
if err != nil {
2021-07-14 09:43:13 -05:00
return fail ( "Internal error" , "Failed to sign JWT token: %v" , err )
2016-12-25 20:16:37 -05:00
}
tokenAuthentication := & models . LFSTokenResponse {
Header : make ( map [ string ] string ) ,
Href : url ,
}
tokenAuthentication . Header [ "Authorization" ] = fmt . Sprintf ( "Bearer %s" , tokenString )
enc := json . NewEncoder ( os . Stdout )
err = enc . Encode ( tokenAuthentication )
if err != nil {
2021-07-14 09:43:13 -05:00
return fail ( "Internal error" , "Failed to encode LFS json response: %v" , err )
2016-12-25 20:16:37 -05:00
}
return nil
}
2015-11-23 22:32:07 -05:00
// Special handle for Windows.
if setting . IsWindows {
verb = strings . Replace ( verb , "-" , " " , 1 )
}
2014-10-01 06:40:48 -05:00
var gitcmd * exec . Cmd
verbs := strings . Split ( verb , " " )
if len ( verbs ) == 2 {
2021-06-30 15:07:23 -05:00
gitcmd = exec . CommandContext ( ctx , verbs [ 0 ] , verbs [ 1 ] , repoPath )
2014-10-01 06:40:48 -05:00
} else {
2021-06-30 15:07:23 -05:00
gitcmd = exec . CommandContext ( ctx , verb , repoPath )
2014-10-01 06:40:48 -05:00
}
2017-03-16 23:59:42 -05:00
2022-04-05 15:28:10 -05:00
// Check if setting.RepoRootPath exists. It could be the case that it doesn't exist, this can happen when
// `[repository]` `ROOT` is a relative path and $GITEA_WORK_DIR isn't passed to the SSH connection.
if _ , err := os . Stat ( setting . RepoRootPath ) ; err != nil {
if os . IsNotExist ( err ) {
return fail ( "Incorrect configuration." ,
2022-05-30 17:47:55 -05:00
"Directory `[repository]` `ROOT` %s was not found, please check if $GITEA_WORK_DIR is passed to the SSH connection or make `[repository]` `ROOT` an absolute value." , setting . RepoRootPath )
2022-04-05 15:28:10 -05:00
}
}
2022-06-03 09:36:18 -05:00
process . SetSysProcAttribute ( gitcmd )
2014-05-25 19:11:25 -05:00
gitcmd . Dir = setting . RepoRootPath
2014-04-10 13:20:58 -05:00
gitcmd . Stdout = os . Stdout
gitcmd . Stdin = os . Stdin
gitcmd . Stderr = os . Stderr
2014-07-25 23:24:27 -05:00
if err = gitcmd . Run ( ) ; err != nil {
2021-07-14 09:43:13 -05:00
return fail ( "Internal error" , "Failed to execute git command: %v" , err )
2014-04-10 13:20:58 -05:00
}
2014-06-28 10:56:41 -05:00
2015-08-06 09:48:11 -05:00
// Update user key activity.
2019-06-01 10:00:21 -05:00
if results . KeyID > 0 {
2021-07-14 09:43:13 -05:00
if err = private . UpdatePublicKeyInRepo ( ctx , results . KeyID , results . RepoID ) ; err != nil {
return fail ( "Internal error" , "UpdatePublicKeyInRepo: %v" , err )
2015-08-04 22:14:17 -05:00
}
2014-08-09 17:40:10 -05:00
}
2016-05-12 13:32:28 -05:00
return nil
2014-04-10 13:20:58 -05:00
}