Ejemplo n.º 1
0
func main() {
	cloudy, _ := ioutil.ReadFile("cloudy")
	if cloudy != nil {
		fmt.Println(string(cloudy))
	}

	login, err := speakeasy.Ask("enter your apple id: ")
	if err != nil {
		panic(err)
	}

	pass, err := speakeasy.Ask("enter your icloud pass: "******"root")
	if err != nil {
		panic(err)
	}

	fitems_links, err := drive.GetFileItemsUrls(fitems, eng, cookie, token)
	if err != nil {
		panic(err)
	}
	fmt.Println("================================================================")
	fmt.Println("================================================================")
	fmt.Println("================================================================")
	for i := range fitems_links.Items {
		fmt.Println("name: ", fitems.Items[i].Name)
		fmt.Println("type: ", fitems.Items[i].Type)
		fmt.Println("url: ", fitems.Items[i].Url)
		fmt.Println("id: ", fitems.Items[i].Id)
	}

	/*
		iclouddrive, err2 := drive.NewD(eng)
		if err2 != nil {
			panic(err2)
		}

		fmt.Println(iclouddrive.Urls)

		if err := photos.PrintContent(total); err != nil {
			panic(err)
		}

			if err := photos.DownloadContent(total); err != nil {
				panic(err)
			}
	*/
}
Ejemplo n.º 2
0
// walletloadseedcmd adds a seed to the wallet's list of seeds
func walletloadseedcmd() {
	password, err := speakeasy.Ask("Wallet password: "******"Reading password failed:", err)
	}
	seed, err := speakeasy.Ask("New Seed: ")
	if err != nil {
		die("Reading seed failed:", err)
	}
	qs := fmt.Sprintf("encryptionpassword=%s&seed=%s&dictionary=%s", password, seed, "english")
	err = post("/wallet/seed", qs)
	if err != nil {
		die("Could not add seed:", err)
	}
	fmt.Println("Added Key")
}
Ejemplo n.º 3
0
func actionUserPasswd(c *cli.Context) {
	api, user := mustUserAPIAndName(c)
	ctx, cancel := context.WithTimeout(context.Background(), client.DefaultRequestTimeout)
	currentUser, err := api.GetUser(ctx, user)
	cancel()
	if currentUser == nil {
		fmt.Fprintln(os.Stderr, err.Error())
		os.Exit(1)
	}
	pass, err := speakeasy.Ask("New password: "******"Error reading password:"******"Password updated\n")
}
Ejemplo n.º 4
0
func preDecrypt(cmd *cobra.Command, args []string) {
	p := path.Dir(params.SettingsFile)
	diaryStore, err := ioutil.ReadFile(path.Join(p, "diary.md"))
	if err != nil {
		log.Printf("Unable to load stored diary")
		os.Exit(1)
	}
	tmp, err := ioutil.TempFile("", "diary")
	if err != nil {
		log.Printf("Unable to open a temp file")
		os.Exit(1)
	}
	tmpFile = tmp.Name()

	if set.Encrypt {
		pwd, err := speakeasy.Ask("Password: "******"Unable to read password.")
			os.Exit(1)
		}
		tmpPass = pwd

		if len(diaryStore) > 0 {
			o := openssl.New()
			diaryStore, err = o.DecryptString(tmpPass, string(diaryStore))
			if err != nil {
				log.Printf("Unable to decrypt diary")
				os.Exit(1)
			}
		}
	}

	fmt.Fprintf(tmp, string(diaryStore))
	tmp.Close()
}
Ejemplo n.º 5
0
func authCfgFromCmd(cmd *cobra.Command) *authCfg {
	userFlag, err := cmd.Flags().GetString("user")
	if err != nil {
		ExitWithError(ExitBadArgs, err)
	}

	if userFlag == "" {
		return nil
	}

	var cfg authCfg

	splitted := strings.SplitN(userFlag, ":", 2)
	if len(splitted) < 2 {
		cfg.username = userFlag
		cfg.password, err = speakeasy.Ask("Password: ")
		if err != nil {
			ExitWithError(ExitError, err)
		}
	} else {
		cfg.username = splitted[0]
		cfg.password = splitted[1]
	}

	return &cfg
}
Ejemplo n.º 6
0
func main() {
	prog := os.Args[0]

	if len(os.Args) != 3 {
		usage(prog)
		os.Exit(1)
	}

	verb := os.Args[1]
	object := os.Args[2]

	password, err := speakeasy.Ask("Password: "******"upload":
		upload(object, password)
	case "download":
		download(object, password)
	default:
		usage(prog)
		os.Exit(1)
	}
}
Ejemplo n.º 7
0
// apiGet wraps a GET request with a status code check, such that if the GET does
// not return 2xx, the error will be read and returned. The response body is
// not closed.
func apiGet(call string) (*http.Response, error) {
	if host, port, _ := net.SplitHostPort(addr); host == "" {
		addr = net.JoinHostPort("localhost", port)
	}
	resp, err := api.HttpGET("http://" + addr + call)
	if err != nil {
		return nil, errors.New("no response from daemon")
	}
	// check error code
	if resp.StatusCode == http.StatusUnauthorized {
		resp.Body.Close()
		// Prompt for password and retry request with authentication.
		password, err := speakeasy.Ask("API password: "******"http://"+addr+call, password)
		if err != nil {
			return nil, errors.New("no response from daemon - authentication failed")
		}
	}
	if resp.StatusCode == http.StatusNotFound {
		resp.Body.Close()
		return nil, errors.New("API call not recognized: " + call)
	}
	if non2xx(resp.StatusCode) {
		err := decodeError(resp)
		resp.Body.Close()
		return nil, err
	}
	return resp, nil
}
Ejemplo n.º 8
0
func (l *login) populateCreds(e *env) error {
	if l.credentials.email != "" && l.credentials.password != "" {
		return nil
	}

	fmt.Fprint(e.Out, "Email: ")
	fmt.Fscanf(e.In, "%s\n", &l.credentials.email)

	var (
		password string
		err      error
	)
	if e.In == os.Stdin {
		password, err = speakeasy.Ask("Password (will be hidden): ")
		if err != nil {
			return err
		}
	} else {
		// NOTE: only for testing
		fmt.Fscanf(e.In, "%s\n", &password)
	}

	if password != "" {
		l.credentials.password = password
	}
	return nil
}
Ejemplo n.º 9
0
func runLogin(cmd *Command, args []string) {
	var endpoint ForceEndpoint = EndpointProduction

	currentEndpoint, customUrl, err := CurrentEndpoint()
	if err == nil && &currentEndpoint != nil {
		endpoint = currentEndpoint
		if currentEndpoint == EndpointCustom && customUrl != "" {
			*instance = customUrl
		}
	}

	switch *instance {
	case "login":
		endpoint = EndpointProduction
	case "test":
		endpoint = EndpointTest
	case "pre":
		endpoint = EndpointPrerelease
	default:
		if *instance != "" {
			//need to determine the form of the endpoint
			uri, err := url.Parse(*instance)
			if err != nil {
				ErrorAndExit("no such endpoint: %s", *instance)
			}
			// Could be short hand?
			if uri.Host == "" {
				uri, err = url.Parse(fmt.Sprintf("https://%s", *instance))
				//fmt.Println(uri)
				if err != nil {
					ErrorAndExit("no such endpoint: %s", *instance)
				}
			}
			CustomEndpoint = uri.Scheme + "://" + uri.Host
			endpoint = EndpointCustom

			fmt.Println("Loaded Endpoint: (" + CustomEndpoint + ")")
		}
	}

	if len(*userName) != 0 { // Do SOAP login
		if len(*password) == 0 {
			var err error
			*password, err = speakeasy.Ask("Password: ")
			if err != nil {
				ErrorAndExit(err.Error())
			}
		}
		_, err := ForceLoginAndSaveSoap(endpoint, *userName, *password)
		if err != nil {
			ErrorAndExit(err.Error())
		}
	} else { // Do OAuth login
		_, err := ForceLoginAndSave(endpoint)
		if err != nil {
			ErrorAndExit(err.Error())
		}
	}
}
Ejemplo n.º 10
0
func readPassword(prompt string) (password string, err error) {
	if acceptPasswordFromStdin && !isTerminalIn {
		_, err = fmt.Scanln(&password)
		return
	}
	// NOTE: speakeasy may not support multi-byte chars on Windows
	return speakeasy.Ask("Enter password: ")
}
Ejemplo n.º 11
0
func getPassword(question string) string {
	password, err := speakeasy.Ask(fmt.Sprintf("%s", question))
	if err != nil {
		fmt.Printf("\nERROR: %s\n", err.Error())
		return getPassword(question)
	}
	return password
}
Ejemplo n.º 12
0
func main() {
	password, err := speakeasy.Ask("Please enter a password: "******"Password result: %q\n", password)
	fmt.Printf("Password len: %d\n", len(password))
}
Ejemplo n.º 13
0
func (ctx *SecureContext) GetPassword() (string, error) {
	var password string
	var err error
	if password, err = speakeasy.Ask(DefaultPrompt); err != nil {
		return "", err
	}
	ctx.Password = password
	return ctx.Password, nil
}
Ejemplo n.º 14
0
func (cred *Credentials) FetchPassWord() {
	// Grab password
	password, err := speakeasy.Ask("Enter password: ")
	if err != nil {
		log.Fatal(err)
		os.Exit(1)
	}

	cred.Password = password
}
Ejemplo n.º 15
0
func main() {
	var (
		secret string
		pin    string
		err    error
		nowStr string
		hash   string
	)

	secret, err = speakeasy.Ask("Secret (not echoed): ")
	if err != nil {
		fmt.Println(err.Error())
		os.Exit(2)
	}
	pin, err = speakeasy.Ask("PIN (not echoed): ")
	if err != nil {
		fmt.Println(err.Error())
		os.Exit(2)
	}

	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt)

	go func() {
		for _ = range c {
			terminal.Stdout.Reset()
			os.Exit(3)
		}
	}()

	for {
		// 10-sec granularity
		nowStr = strconv.FormatInt(time.Now().Unix()/10, 10)

		hash = fmt.Sprintf("%x\n", md5.Sum([]byte(nowStr+secret+pin)))

		//fmt.Printf("OTP: %s\n", hash[:6])
		refresh("OTP", hash[:6])

		time.Sleep(10 * time.Second)
	}
}
Ejemplo n.º 16
0
func loadPrivateKey(path string) (ssh.AuthMethod, error) {
	// Read file
	keyData, err := ioutil.ReadFile(path)
	if err != nil {
		log.Printf("error: could not read key file '%s': %s", path, err)
		return nil, err
	}

	// Get first PEM block
	block, _ := pem.Decode(keyData)
	if err != nil {
		log.Printf("error: no key found in file '%s': %s", path, err)
		return nil, err
	}

	// If it's encrypted...
	var (
		signer    ssh.Signer
		signerErr error
	)

	if x509.IsEncryptedPEMBlock(block) {
		// Get the passphrase
		prompt := fmt.Sprintf("Enter passphrase for key '%s': ", path)
		pass, err := speakeasy.Ask(prompt)
		if err != nil {
			log.Printf("error: error getting passphrase: %s", err)
			return nil, err
		}

		block.Bytes, err = x509.DecryptPEMBlock(block, []byte(pass))
		if err != nil {
			log.Printf("error: error decrypting key: %s", err)
			return nil, err
		}

		key, err := ParsePEMBlock(block)
		if err != nil {
			log.Printf("error: could not parse PEM block: %s", err)
			return nil, err
		}

		signer, signerErr = ssh.NewSignerFromKey(key)
	} else {
		signer, signerErr = ssh.ParsePrivateKey(keyData)
	}

	if signerErr != nil {
		log.Printf("error: error parsing private key '%s': %s", path, signerErr)
		return nil, signerErr
	}

	return ssh.PublicKeys(signer), nil
}
Ejemplo n.º 17
0
// walletloadsiagcmd loads a siag key set into the wallet.
func walletloadsiagcmd(keyfiles string) {
	password, err := speakeasy.Ask("Wallet password: "******"Reading password failed:", err)
	}
	qs := fmt.Sprintf("keyfiles=%s&encryptionpassword=%s", keyfiles, password)
	err = post("/wallet/siagkey", qs)
	if err != nil {
		die("Loading siag key failed:", err)
	}
	fmt.Println("Wallet loading successful.")
}
Ejemplo n.º 18
0
// walletunlockcmd unlocks a saved wallet
func walletunlockcmd() {
	password, err := speakeasy.Ask("Wallet password: "******"Reading password failed:", err)
	}
	qs := fmt.Sprintf("encryptionpassword=%s&dictonary=%s", password, "english")
	err = post("/wallet/unlock", qs)
	if err != nil {
		die("Could not unlock wallet:", err)
	}
	fmt.Println("Wallet unlocked")
}
Ejemplo n.º 19
0
func getAccount(r io.Reader) (string, string, error) {
	scanner := bufio.NewScanner(r)
	for {
		fmt.Print("User: "******"Password: ")
	return username, password, err
}
Ejemplo n.º 20
0
// walletload033xcmd loads a v0.3.3.x wallet into the current wallet.
func walletload033xcmd(source string) {
	password, err := speakeasy.Ask("Wallet password: "******"Reading password failed:", err)
	}
	qs := fmt.Sprintf("source=%s&encryptionpassword=%s", abs(source), password)
	err = post("/wallet/033x", qs)
	if err != nil {
		die("Loading wallet failed:", err)
	}
	fmt.Println("Wallet loading successful.")
}
Ejemplo n.º 21
0
func main() {
	var (
		currentUser *user.User
		outFile     string
		output      string
		vpnUser     string
		hash        string
		otp         string
		secret      string
		pin         string
		err         error
		nowStr      string
	)

	currentUser, _ = user.Current()

	flag.StringVar(&vpnUser, "u", currentUser.Name, "OpenVPN user")
	flag.StringVar(&outFile, "o", "", "Output file path")
	flag.Parse()

	if outFile == "" {
		fmt.Println("Must provide output file path to write OTP to.")
		os.Exit(1)
	}

	if secret, err = speakeasy.Ask("Secret (not echoed): "); err != nil {
		fmt.Println(err.Error())
		os.Exit(1)
	}
	if pin, err = speakeasy.Ask("PIN (not echoed): "); err != nil {
		fmt.Println(err.Error())
		os.Exit(1)
	}

	nowStr = strconv.FormatInt(time.Now().Unix()/10, 10)
	hash = fmt.Sprintf("%x", md5.Sum([]byte(nowStr+secret+pin)))
	otp = hash[:6]
	output = fmt.Sprintf("%s\n%s", vpnUser, otp)
	ioutil.WriteFile(outFile, []byte(output), 0644)
}
Ejemplo n.º 22
0
func registerUser(ctx *app.Context) {
	username := ctx.RequireIndexValue(0)
	userVal, _ := newEmptyUser(ctx)
	updating := false
	if ctx.Orm().MustOne(ByUsername(username), userVal.Interface()) {
		// Updating existing user
		updating = true
	} else {
		// Creating a new one
		userVal = newUser(ctx, username)
	}
	var askPassword bool
	ctx.ParseParamValue("p", &askPassword)
	if !updating || askPassword {
		password1, err := speakeasy.Ask("Password:"******"Confirm Password:"******"passwords don't match"))
		}
		setUserValue(userVal, "Password", password.New(password1))
	}
	var admin bool
	ctx.ParseParamValue("s", &admin)
	setUserValue(userVal, "Admin", admin)

	var email string
	ctx.ParseParamValue("e", &email)
	if email != "" {
		setUserValue(userVal, "Email", email)
	}

	ctx.Orm().MustSave(userVal.Interface())
	ctx.Logger().Infof("saved user as %+v", userVal.Interface())
}
Ejemplo n.º 23
0
func InputPassword() (passwd string, err error) {
	passwd, err = speakeasy.Ask("Enter password: "******"" {
		return passwd, errors.New("Empty password")
	}

	return passwd, err
}
Ejemplo n.º 24
0
func makePassphraseFn(passphrase string, out *string) func() (string, error) {
	return func() (val string, err error) {
		if passphrase == "" {
			val, err = speakeasy.Ask("Passphrase: ")
		} else {
			val, err = passphrase, nil
		}
		if out != nil {
			*out = val
		}
		return val, err
	}
}
Ejemplo n.º 25
0
// walletload033xcmd loads a v0.3.3.x wallet into the current wallet.
func walletload033xcmd(filepath string) {
	password, err := speakeasy.Ask("Wallet password: "******"Reading password failed")
		return
	}
	qs := fmt.Sprintf("filepath=%s&encryptionpassword=%s", filepath, password)
	err = post("/wallet/load/033x", qs)
	if err != nil {
		fmt.Println("loading error:", err)
		return
	}
	fmt.Println("Wallet loading successful.")
}
Ejemplo n.º 26
0
// walletloadsiagcmd loads a siag key set into the wallet.
func walletloadsiagcmd(keyfiles string) {
	password, err := speakeasy.Ask("Wallet password: "******"Reading password failed")
		return
	}
	qs := fmt.Sprintf("keyfiles=%s&encryptionpassword=%s", keyfiles, password)
	err = post("/wallet/load/siag", qs)
	if err != nil {
		fmt.Println("loading error:", err)
		return
	}
	fmt.Println("Wallet loading successful.")
}
Ejemplo n.º 27
0
func readPasswordInteractive(name string) string {
	prompt1 := fmt.Sprintf("Password of %s: ", name)
	password1, err1 := speakeasy.Ask(prompt1)
	if err1 != nil {
		ExitWithError(ExitBadArgs, fmt.Errorf("failed to ask password: %s.", err1))
	}

	if len(password1) == 0 {
		ExitWithError(ExitBadArgs, fmt.Errorf("empty password"))
	}

	prompt2 := fmt.Sprintf("Type password of %s again for confirmation: ", name)
	password2, err2 := speakeasy.Ask(prompt2)
	if err2 != nil {
		ExitWithError(ExitBadArgs, fmt.Errorf("failed to ask password: %s.", err2))
	}

	if strings.Compare(password1, password2) != 0 {
		ExitWithError(ExitBadArgs, fmt.Errorf("given passwords are different."))
	}

	return password1
}
Ejemplo n.º 28
0
// userAddCommandFunc executes the "user add" command.
func userAddCommandFunc(cmd *cobra.Command, args []string) {
	if len(args) != 1 {
		ExitWithError(ExitBadArgs, fmt.Errorf("user add command requires user name as its argument."))
	}

	var password string

	if !passwordInteractive {
		fmt.Scanf("%s", &password)
	} else {
		prompt1 := fmt.Sprintf("Password of %s: ", args[0])
		password1, err1 := speakeasy.Ask(prompt1)
		if err1 != nil {
			ExitWithError(ExitBadArgs, fmt.Errorf("failed to ask password: %s.", err1))
		}

		if len(password1) == 0 {
			ExitWithError(ExitBadArgs, fmt.Errorf("empty password"))
		}

		prompt2 := fmt.Sprintf("Type password of %s again for confirmation: ", args[0])
		password2, err2 := speakeasy.Ask(prompt2)
		if err2 != nil {
			ExitWithError(ExitBadArgs, fmt.Errorf("failed to ask password: %s.", err2))
		}

		if strings.Compare(password1, password2) != 0 {
			ExitWithError(ExitBadArgs, fmt.Errorf("given passwords are different."))
		}
		password = password1
	}

	_, err := mustClientFromCmd(cmd).Auth.UserAdd(context.TODO(), args[0], password)
	if err != nil {
		ExitWithError(ExitError, err)
	}
}
Ejemplo n.º 29
0
func getUsernamePassword(prompt, usernameFlag string) (username string, password string, err error) {
	colon := strings.Index(usernameFlag, ":")
	if colon == -1 {
		username = usernameFlag
		// Prompt for the password.
		password, err = speakeasy.Ask(prompt)
		if err != nil {
			return "", "", err
		}
	} else {
		username = usernameFlag[:colon]
		password = usernameFlag[colon+1:]
	}
	return username, password, nil
}
Ejemplo n.º 30
0
func readParameter(reader *bufio.Reader, prompt string, private bool) string {
	var str string

	if stdinIsatty() {
		if private {
			str, _ = speakeasy.Ask(prompt)
		} else {
			fmt.Print(prompt)
			str, _ = reader.ReadString('\n')
		}
	} else {
		str, _ = reader.ReadString('\n')
	}

	return strings.TrimSpace(str)
}