2018-09-21 13:54:48 +03:00
package github
import (
"bufio"
"bytes"
"encoding/json"
"fmt"
"io"
"io/ioutil"
"math/rand"
"net/http"
"os"
2018-09-21 19:23:46 +03:00
"regexp"
2019-05-24 22:04:25 +03:00
"strconv"
2018-09-21 13:54:48 +03:00
"strings"
"syscall"
"time"
2019-05-24 22:04:25 +03:00
"golang.org/x/crypto/ssh/terminal"
2018-09-21 19:23:46 +03:00
"github.com/MichaelMure/git-bug/bridge/core"
"github.com/MichaelMure/git-bug/repository"
2018-09-21 13:54:48 +03:00
)
2019-04-27 02:15:02 +03:00
const (
githubV3Url = "https://api.github.com"
2019-05-24 22:04:25 +03:00
keyOwner = "owner"
2019-04-27 02:15:02 +03:00
keyProject = "project"
keyToken = "token"
2019-05-24 22:04:25 +03:00
2019-05-26 13:47:01 +03:00
defaultTimeout = 60 * time . Second
2019-04-27 02:15:02 +03:00
)
2018-09-21 19:23:46 +03:00
2019-05-24 22:04:25 +03:00
var (
2019-05-26 18:35:39 +03:00
rxGithubURL = regexp . MustCompile ( ` github\.com[\/:]([a-zA-Z0-9\-\_]+)\/([a-zA-Z0-9\-\_\.]+) ` )
2019-05-24 22:04:25 +03:00
)
2018-09-21 13:54:48 +03:00
2019-05-24 22:04:25 +03:00
func ( * Github ) Configure ( repo repository . RepoCommon , params core . BridgeParams ) ( core . Configuration , error ) {
conf := make ( core . Configuration )
var err error
var token string
var owner string
var project string
2019-05-25 16:56:52 +03:00
// getting owner and project name
2019-05-24 22:04:25 +03:00
if params . Owner != "" && params . Project != "" {
2019-05-25 18:27:25 +03:00
// first try to use params if both or project and owner are provided
2019-05-24 22:04:25 +03:00
owner = params . Owner
project = params . Project
} else if params . URL != "" {
2019-05-25 18:27:25 +03:00
// try to parse params URL and extract owner and project
2019-05-25 16:20:30 +03:00
_ , owner , project , err = splitURL ( params . URL )
2019-05-24 22:04:25 +03:00
if err != nil {
return nil , err
}
2018-09-21 13:54:48 +03:00
2019-05-24 22:04:25 +03:00
} else {
2019-05-25 16:56:52 +03:00
// remote suggestions
2019-05-25 16:20:30 +03:00
remotes , err := repo . GetRemotes ( )
if err != nil {
return nil , err
}
2019-05-25 18:27:25 +03:00
// terminal prompt
2019-05-25 16:20:30 +03:00
owner , project , err = promptURL ( remotes )
2019-05-24 22:04:25 +03:00
if err != nil {
return nil , err
}
2018-09-21 13:54:48 +03:00
}
2019-05-24 22:04:25 +03:00
// validate project owner
ok , err := validateUsername ( owner )
2018-09-21 13:54:48 +03:00
if err != nil {
return nil , err
}
2019-05-24 22:04:25 +03:00
if ! ok {
return nil , fmt . Errorf ( "invalid parameter owner: %v" , owner )
2018-09-21 13:54:48 +03:00
}
2019-05-25 16:20:30 +03:00
// try to get token from params if provided, else use terminal prompt to either
// enter a token or login and generate a new one
2019-05-24 22:04:25 +03:00
if params . Token != "" {
token = params . Token
2018-09-21 13:54:48 +03:00
2019-05-24 22:04:25 +03:00
} else {
2019-05-25 16:20:30 +03:00
token , err = promptTokenOptions ( owner , project )
2018-09-21 19:23:46 +03:00
if err != nil {
return nil , err
2018-09-21 13:54:48 +03:00
}
}
2019-05-25 16:20:30 +03:00
// verify access to the repository with token
2019-05-24 22:04:25 +03:00
ok , err = validateProject ( owner , project , token )
if err != nil {
return nil , err
}
if ! ok {
return nil , fmt . Errorf ( "project doesn't exist or authentication token has a wrong scope" )
}
conf [ keyToken ] = token
conf [ keyOwner ] = owner
conf [ keyProject ] = project
2018-09-21 13:54:48 +03:00
2019-05-24 22:04:25 +03:00
return conf , nil
2018-09-21 13:54:48 +03:00
}
2018-09-24 18:21:24 +03:00
func ( * Github ) ValidateConfig ( conf core . Configuration ) error {
if _ , ok := conf [ keyToken ] ; ! ok {
return fmt . Errorf ( "missing %s key" , keyToken )
}
2019-05-24 22:04:25 +03:00
if _ , ok := conf [ keyOwner ] ; ! ok {
return fmt . Errorf ( "missing %s key" , keyOwner )
2018-09-24 18:21:24 +03:00
}
if _ , ok := conf [ keyProject ] ; ! ok {
return fmt . Errorf ( "missing %s key" , keyProject )
}
return nil
}
2019-05-24 22:04:25 +03:00
func requestToken ( note , username , password string , scope string ) ( * http . Response , error ) {
return requestTokenWith2FA ( note , username , password , "" , scope )
2018-09-21 15:38:44 +03:00
}
2019-05-24 22:04:25 +03:00
func requestTokenWith2FA ( note , username , password , otpCode string , scope string ) ( * http . Response , error ) {
2018-09-21 15:38:44 +03:00
url := fmt . Sprintf ( "%s/authorizations" , githubV3Url )
params := struct {
Scopes [ ] string ` json:"scopes" `
Note string ` json:"note" `
Fingerprint string ` json:"fingerprint" `
} {
2019-05-24 22:04:25 +03:00
Scopes : [ ] string { scope } ,
2018-09-21 15:38:44 +03:00
Note : note ,
Fingerprint : randomFingerprint ( ) ,
}
data , err := json . Marshal ( params )
if err != nil {
return nil , err
}
req , err := http . NewRequest ( "POST" , url , bytes . NewBuffer ( data ) )
if err != nil {
return nil , err
}
req . SetBasicAuth ( username , password )
req . Header . Set ( "Content-Type" , "application/json" )
if otpCode != "" {
req . Header . Set ( "X-GitHub-OTP" , otpCode )
}
2019-05-24 22:04:25 +03:00
client := & http . Client {
Timeout : defaultTimeout ,
}
2018-09-21 15:38:44 +03:00
return client . Do ( req )
}
2018-09-21 19:23:46 +03:00
func decodeBody ( body io . ReadCloser ) ( string , error ) {
2018-09-21 13:54:48 +03:00
data , _ := ioutil . ReadAll ( body )
aux := struct {
Token string ` json:"token" `
} { }
err := json . Unmarshal ( data , & aux )
if err != nil {
2018-09-21 19:23:46 +03:00
return "" , err
}
if aux . Token == "" {
return "" , fmt . Errorf ( "no token found in response: %s" , string ( data ) )
2018-09-21 13:54:48 +03:00
}
2018-09-21 19:23:46 +03:00
return aux . Token , nil
2018-09-21 13:54:48 +03:00
}
func randomFingerprint ( ) string {
// Doesn't have to be crypto secure, it's just to avoid token collision
rand . Seed ( time . Now ( ) . UnixNano ( ) )
var letterRunes = [ ] rune ( "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" )
b := make ( [ ] rune , 32 )
for i := range b {
b [ i ] = letterRunes [ rand . Intn ( len ( letterRunes ) ) ]
}
return string ( b )
}
2019-05-25 16:20:30 +03:00
func promptTokenOptions ( owner , project string ) ( string , error ) {
for {
fmt . Println ( )
2019-05-26 13:35:53 +03:00
fmt . Println ( "[0]: user provided token" )
2019-05-27 21:26:36 +03:00
fmt . Println ( "[1]: interactive token creation" )
2019-05-25 16:20:30 +03:00
fmt . Print ( "Select option: " )
line , err := bufio . NewReader ( os . Stdin ) . ReadString ( '\n' )
fmt . Println ( )
if err != nil {
return "" , err
}
line = strings . TrimRight ( line , "\n" )
index , err := strconv . Atoi ( line )
if err != nil || ( index != 0 && index != 1 ) {
fmt . Println ( "invalid input" )
continue
}
if index == 0 {
return promptToken ( )
}
return loginAndRequestToken ( owner , project )
}
}
func promptToken ( ) ( string , error ) {
2019-05-26 18:35:39 +03:00
fmt . Println ( "You can generate a new token by visiting https://github.com/settings/tokens." )
fmt . Println ( "Choose 'Generate new token' and set the necessary access scope for your repository." )
fmt . Println ( )
fmt . Println ( "The access scope depend on the type of repository." )
fmt . Println ( "Public:" )
fmt . Println ( " - 'repo:public_repo': to be able to read public repositories" )
fmt . Println ( "Private:" )
fmt . Println ( " - 'repo' : to be able to read private repositories" )
fmt . Println ( )
2019-05-25 16:20:30 +03:00
for {
fmt . Print ( "Enter token: " )
byteToken , err := terminal . ReadPassword ( int ( syscall . Stdin ) )
fmt . Println ( )
if err != nil {
return "" , err
}
if len ( byteToken ) > 0 {
return string ( byteToken ) , nil
}
fmt . Println ( "token is empty" )
}
}
func loginAndRequestToken ( owner , project string ) ( string , error ) {
fmt . Println ( "git-bug will now generate an access token in your Github profile. Your credential are not stored and are only used to generate the token. The token is stored in the repository git config." )
fmt . Println ( )
2019-05-26 13:47:01 +03:00
fmt . Println ( "The access scope depend on the type of repository." )
fmt . Println ( "Public:" )
2019-05-26 18:35:39 +03:00
fmt . Println ( " - 'repo:public_repo': to be able to read public repositories" )
2019-05-26 13:47:01 +03:00
fmt . Println ( "Private:" )
2019-05-26 18:35:39 +03:00
fmt . Println ( " - 'repo' : to be able to read private repositories" )
2019-05-25 16:20:30 +03:00
fmt . Println ( )
// prompt project visibility to know the token scope needed for the repository
isPublic , err := promptProjectVisibility ( )
if err != nil {
return "" , err
}
username , err := promptUsername ( )
if err != nil {
return "" , err
}
password , err := promptPassword ( )
if err != nil {
return "" , err
}
var scope string
if isPublic {
2019-05-26 18:35:39 +03:00
// repo:public_repo is requested to be able to read public repositories
scope = "repo:public_repo"
2019-05-25 16:20:30 +03:00
} else {
// 'repo' is request to be able to read private repositories
// /!\ token will have read/write rights on every private repository you have access to
scope = "repo"
}
// Attempt to authenticate and create a token
note := fmt . Sprintf ( "git-bug - %s/%s" , owner , project )
resp , err := requestToken ( note , username , password , scope )
if err != nil {
return "" , err
}
defer resp . Body . Close ( )
// Handle 2FA is needed
OTPHeader := resp . Header . Get ( "X-GitHub-OTP" )
if resp . StatusCode == http . StatusUnauthorized && OTPHeader != "" {
otpCode , err := prompt2FA ( )
if err != nil {
return "" , err
}
resp , err = requestTokenWith2FA ( note , username , password , otpCode , scope )
if err != nil {
return "" , err
}
defer resp . Body . Close ( )
}
if resp . StatusCode == http . StatusCreated {
2019-05-26 13:47:01 +03:00
return decodeBody ( resp . Body )
2019-05-25 16:20:30 +03:00
}
b , _ := ioutil . ReadAll ( resp . Body )
return "" , fmt . Errorf ( "error creating token %v: %v" , resp . StatusCode , string ( b ) )
}
2018-09-21 13:54:48 +03:00
func promptUsername ( ) ( string , error ) {
for {
2018-09-24 16:25:15 +03:00
fmt . Print ( "username: " )
2018-09-21 13:54:48 +03:00
line , err := bufio . NewReader ( os . Stdin ) . ReadString ( '\n' )
if err != nil {
return "" , err
}
line = strings . TrimRight ( line , "\n" )
ok , err := validateUsername ( line )
if err != nil {
return "" , err
}
if ok {
return line , nil
}
fmt . Println ( "invalid username" )
}
}
2019-05-25 16:20:30 +03:00
func promptURL ( remotes map [ string ] string ) ( string , string , error ) {
2019-05-27 21:26:36 +03:00
validRemotes := getValidGithubRemoteURLs ( remotes )
2019-05-25 16:20:30 +03:00
if len ( validRemotes ) > 0 {
for {
fmt . Println ( "\nDetected projects:" )
// print valid remote github urls
for i , remote := range validRemotes {
fmt . Printf ( "[%d]: %v\n" , i + 1 , remote )
}
fmt . Printf ( "\n[0]: Another project\n\n" )
fmt . Printf ( "Select option: " )
line , err := bufio . NewReader ( os . Stdin ) . ReadString ( '\n' )
if err != nil {
return "" , "" , err
}
line = strings . TrimRight ( line , "\n" )
index , err := strconv . Atoi ( line )
if err != nil || ( index < 0 && index >= len ( validRemotes ) ) {
fmt . Println ( "invalid input" )
continue
}
// if user want to enter another project url break this loop
if index == 0 {
break
}
// get owner and project with index
_ , owner , project , _ := splitURL ( validRemotes [ index - 1 ] )
return owner , project , nil
}
}
// manually enter github url
2018-09-21 19:23:46 +03:00
for {
2018-09-24 16:25:15 +03:00
fmt . Print ( "Github project URL: " )
2018-09-21 19:23:46 +03:00
line , err := bufio . NewReader ( os . Stdin ) . ReadString ( '\n' )
if err != nil {
return "" , "" , err
}
line = strings . TrimRight ( line , "\n" )
if line == "" {
fmt . Println ( "URL is empty" )
continue
}
2019-05-25 16:20:30 +03:00
// get owner and project from url
_ , owner , project , err := splitURL ( line )
2018-09-21 19:23:46 +03:00
if err != nil {
fmt . Println ( err )
continue
}
2019-05-25 16:20:30 +03:00
return owner , project , nil
2018-09-21 19:23:46 +03:00
}
}
2019-05-26 13:47:01 +03:00
func splitURL ( url string ) ( shortURL string , owner string , project string , err error ) {
2019-05-26 18:35:39 +03:00
cleanURL := strings . TrimSuffix ( url , ".git" )
res := rxGithubURL . FindStringSubmatch ( cleanURL )
2018-09-21 19:23:46 +03:00
if res == nil {
2019-05-25 16:20:30 +03:00
return "" , "" , "" , fmt . Errorf ( "bad github project url" )
}
return res [ 0 ] , res [ 1 ] , res [ 2 ] , nil
}
2019-05-27 21:26:36 +03:00
func getValidGithubRemoteURLs ( remotes map [ string ] string ) [ ] string {
2019-05-25 16:20:30 +03:00
urls := make ( [ ] string , 0 , len ( remotes ) )
for _ , url := range remotes {
// split url can work again with shortURL
shortURL , _ , _ , err := splitURL ( url )
if err == nil {
urls = append ( urls , shortURL )
}
2018-09-21 13:54:48 +03:00
}
2019-05-25 16:20:30 +03:00
return urls
2018-09-21 13:54:48 +03:00
}
func validateUsername ( username string ) ( bool , error ) {
url := fmt . Sprintf ( "%s/users/%s" , githubV3Url , username )
resp , err := http . Get ( url )
if err != nil {
return false , err
}
err = resp . Body . Close ( )
if err != nil {
return false , err
}
return resp . StatusCode == http . StatusOK , nil
}
2019-05-24 22:04:25 +03:00
func validateProject ( owner , project , token string ) ( bool , error ) {
url := fmt . Sprintf ( "%s/repos/%s/%s" , githubV3Url , owner , project )
req , err := http . NewRequest ( "GET" , url , nil )
if err != nil {
return false , err
}
2019-05-25 16:20:30 +03:00
// need the token for private repositories
2019-05-24 22:04:25 +03:00
req . Header . Set ( "Authorization" , fmt . Sprintf ( "token %s" , token ) )
client := & http . Client {
Timeout : defaultTimeout ,
}
resp , err := client . Do ( req )
if err != nil {
return false , err
}
err = resp . Body . Close ( )
if err != nil {
return false , err
}
return resp . StatusCode == http . StatusOK , nil
}
2018-09-21 13:54:48 +03:00
func promptPassword ( ) ( string , error ) {
for {
2018-09-24 16:25:15 +03:00
fmt . Print ( "password: " )
2018-09-21 13:54:48 +03:00
bytePassword , err := terminal . ReadPassword ( int ( syscall . Stdin ) )
2018-09-24 16:25:15 +03:00
// new line for coherent formatting, ReadPassword clip the normal new line
// entered by the user
fmt . Println ( )
2018-09-21 13:54:48 +03:00
if err != nil {
return "" , err
}
if len ( bytePassword ) > 0 {
return string ( bytePassword ) , nil
}
fmt . Println ( "password is empty" )
}
}
func prompt2FA ( ) ( string , error ) {
for {
2018-09-24 16:25:15 +03:00
fmt . Print ( "two-factor authentication code: " )
2018-09-21 13:54:48 +03:00
byte2fa , err := terminal . ReadPassword ( int ( syscall . Stdin ) )
2019-05-24 22:04:25 +03:00
fmt . Println ( )
2018-09-21 13:54:48 +03:00
if err != nil {
return "" , err
}
2019-05-26 13:47:01 +03:00
if len ( byte2fa ) > 0 {
return string ( byte2fa ) , nil
2019-05-24 22:04:25 +03:00
}
2019-05-26 13:47:01 +03:00
fmt . Println ( "code is empty" )
2019-05-24 22:04:25 +03:00
}
}
func promptProjectVisibility ( ) ( bool , error ) {
for {
2019-05-25 16:20:30 +03:00
fmt . Println ( "[0]: public" )
fmt . Println ( "[1]: private" )
fmt . Print ( "repository visibility: " )
2019-05-24 22:04:25 +03:00
line , err := bufio . NewReader ( os . Stdin ) . ReadString ( '\n' )
fmt . Println ( )
if err != nil {
return false , err
}
line = strings . TrimRight ( line , "\n" )
index , err := strconv . Atoi ( line )
if err != nil || ( index != 0 && index != 1 ) {
fmt . Println ( "invalid input" )
continue
2018-09-21 13:54:48 +03:00
}
2019-05-25 16:20:30 +03:00
// return true for public repositories, false for private
2019-05-24 22:04:25 +03:00
return index == 0 , nil
2018-09-21 13:54:48 +03:00
}
}