Golang gopass.GetPasswdMasked函數代碼示例

func setup() {
	var dir string
	var username string
	var password []byte

	fmt.Println("Setup")
	fmt.Println("--------------------")
	fmt.Println("Bitte gib deine CampusOffice daten ein.")
	fmt.Println("Deine Zugangsdaten werden verschlüsselt auf deinem Computer abgelegt.")

	fmt.Printf("MatrNr: ")
	fmt.Scanln(&username)
	fmt.Printf("Passwort: ")
	password = gopass.GetPasswdMasked()

	for !login(string(username), string(password)) {
		fmt.Println("Falche MatrNr oder falsches Passwort!")

		fmt.Printf("MatrNr: ")
		fmt.Scanln(&username)
		fmt.Printf("Passwort: ")
		password = gopass.GetPasswdMasked()
	}

	fmt.Println("Erfolgreich eingeloggt")
	db.set_encrypted_setting(e, "username", username)
	db.set_encrypted_setting(e, "password", string(password))

	fmt.Println("Bitte gib den Speicherort an, an dem deine iCal exportiert werden soll.")
	fmt.Println("Beispiele:")
	fmt.Println("Windows: C:\\Users\\Benutzer\\Dropbox")
	fmt.Println("Linux: /home/Benutzer/Dropbox")

	fmt.Printf("Speicherort: ")
	fmt.Scanln(&dir)

	_, err := os.Stat(dir)
	for err != nil {
		if os.IsNotExist(err) {
			log.Print(err)
			fmt.Printf("Der Speicherort %s existiert nicht.\n", dir)
			fmt.Println("Bitte gibt einen gültigen Speicherort an")
		} else {
			fmt.Println("Es ist ein Fehler aufgetreten.")
			fmt.Println("Bist du sicher, dass du Zugriffsberechtigungn auf diesen Ordner hast?")
		}
		fmt.Printf("Speicherort: ")
		fmt.Scanln(&dir)
		_, err = os.Stat(dir)
	}
	db.set_setting("dir", dir)

	db.set_setting("setup", "1")
	fmt.Println("Setup abgeschlossen")
}

func Login(args []string, opts map[string]interface{}) {
	user := &userInfo{CurDir: "/"}
	if len(args) == 3 {
		user.Bucket = args[0]
		user.Username = args[1]
		user.Password = args[2]
	} else {
		fmt.Printf("ServiceName: ")
		fmt.Scanf("%s\n", &user.Bucket)
		fmt.Printf("Operator: ")
		fmt.Scanf("%s\n", &user.Username)
		fmt.Printf("Password: ")
		b, err := gopass.GetPasswdMasked()
		if err == nil {
			user.Password = string(b)
		}
	}

	if _, err := NewFsDriver(user.Bucket, user.Username,
		user.Password, user.CurDir, 10, nil); err != nil {
		fmt.Fprintf(os.Stderr, "failed to log in. %v\n", err)
		os.Exit(-1)
	}

	// save
	conf.UpdateUserInfo(user)
	conf.Save(confname)
}

func getAndVerifyMaster(master string) string {
	// prompt for a master password if necessary
	if len(master) == 0 {
		// get master password from environment, or from keyboard
		if s := os.Getenv("LETMEIN_MASTER"); s != "" {
			master = s
		} else {
			fmt.Printf("Master password: ")
			master = string(gopass.GetPasswdMasked())
			if len(master) == 0 {
				fmt.Fprintf(os.Stderr, "master password is required")
				os.Exit(1)
			}
		}
	}

	// validate the master password
	if len(master) < minMasterLength || len(master) > maxMasterLength {
		fmt.Fprintf(os.Stderr, "master password must be between %d and %d characters\n", minMasterLength, maxMasterLength)
		os.Exit(1)
	}
	for _, r := range master {
		if r < minChar || r > maxChar {
			fmt.Fprintf(os.Stderr, "master password contains an illegal character\n")
			os.Exit(1)
		}
	}

	return master
}

// SetupDb creates a new database or opens an existing one at a given directory.
// This will prompt the user to set a password if the database is being created.
func SetupDb(path string) (*Db, error) {
	imageDb, err := imagedb.NewDb(path)
	if err != nil {
		return nil, err
	}

	res := Db{imageDb, sync.RWMutex{}, filepath.Join(path, "config.json"), Config{}}
	saveConfig := false

	if res.loadConfig() != nil {
		saveConfig = true
	}
	if res.config.PasswordHash == "" {
		fmt.Print("Setup new password: ")
		pass := gopass.GetPasswdMasked()
		res.config.PasswordHash = HashPassword(string(pass))
		saveConfig = true
	}
	if res.config.MaxFileSize == 0 {
		res.config.MaxFileSize = DefaultMaxFileSize
		saveConfig = true
	}
	if res.config.MaxUploadsPerHour == 0 {
		res.config.MaxUploadsPerHour = DefaultMaxCountPerHour
		saveConfig = true
	}

	if saveConfig {
		if err := res.saveConfig(); err != nil {
			return nil, err
		}
	}

	return &res, nil
}

// ReadPassword reads password from standard input without echoing the characters.
// If mask is true, each chracter will be represented with astericks '*'. Note that
// this only works as expected when the standard input is a terminal.
func (s *Shell) ReadPassword(mask bool) string {
	fmt.Fprint(s.writer, s.prompt)
	if mask {
		return string(gopass.GetPasswdMasked())
	}
	return string(gopass.GetPasswd())
}

func (adc *ADC) AskCredentials() {
	fmt.Print("ADC username: ")
	fmt.Scanf("%s\n", &adc.username)

	fmt.Print("ADC password: ")
	adc.password = string(gopass.GetPasswdMasked())
}

func GetPasswd() string {
	fmt.Printf("Password: ")
	p, err := gopass.GetPasswdMasked()
	if err != nil {
		log.Fatal(err)
	}
	return string(p)
}

// Password prompt with mask.
func PasswordMasked(prompt string, args ...interface{}) string {
	fmt.Printf(prompt+": ", args...)
	var buf, err = gopass.GetPasswdMasked()
	if err != nil {
		return ""
	}
	s := string(buf[0:])
	return s
}

// ReadPassword reads password from standard input without echoing the characters.
// If mask is true, each character will be represented with asterisks '*'. Note that
// this only works as expected when the standard input is a terminal.
func (s *Shell) ReadPassword(mask bool) string {
	if s.showPrompt {
		s.Print(s.prompt)
	}
	if mask {
		return string(gopass.GetPasswdMasked())
	}
	return string(gopass.GetPasswd())
}

func getPassword() []byte {
	passFromEnv := os.Getenv("SCONSIFY_PASSWORD")
	if passFromEnv != "" {
		fmt.Println("Reading password from environment variable SCONSIFY_PASSWORD.")
		return []byte(passFromEnv)
	}
	fmt.Print("Password: ")
	return gopass.GetPasswdMasked()
}

func (this *MergeAccount) input_SrcSeed() string {
	fmt.Printf(this.infoStrings[this.languageIndex][MA_INFO_INPUT_SOURCE_SEED])

	input := gopass.GetPasswdMasked()
	if publicdefine.VerifySAddress(string(input)) == nil {
		return string(input)
	}
	return ""
}

func (this *AccountInfoPayment) input_SrcSeed() string {
	fmt.Printf(this.infoStrings[this.languageIndex][AIP_INFO_INPUT_PRIVATE_SEED])

	input := gopass.GetPasswdMasked()
	if publicdefine.VerifySAddress(string(input)) == nil {
		return string(input)
	}
	return ""
}

// PasswordMasked prompt with mask.
func PasswordMasked(prompt string, args ...interface{}) string {
	fmt.Printf(prompt, args...)

	b, err := gopass.GetPasswdMasked()
	if err != nil {
		panic(err)
	}

	return string(b)
}

func main() {
	fmt.Print("Email/username: ")
	user := readLine()
	fmt.Print("Password: ")
	pass, err := gopass.GetPasswdMasked()
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}

	fmt.Println()
	fmt.Println("Authenticating...")

	sess, err := fbmsgr.Auth(user, string(pass))
	if err != nil {
		fmt.Fprintln(os.Stderr, "Failed to login:", err)
		os.Exit(1)
	}

	fbid := promptChat(sess)

	fmt.Print("Destination filename: ")
	file := readLine()

	fmt.Println("Downloading messages...")
	var actions []map[string]interface{}

	actionChan, errChan := sess.FullActionLog(fbid, nil)
	for action := range actionChan {
		actions = append(actions, action.RawFields())
		fmt.Printf("\rGot %d actions...", len(actions))
	}
	fmt.Printf("\rTotal of %d actions...\n", len(actions))

	if err := <-errChan; err != nil {
		fmt.Fprintln(os.Stderr, "Fetch error:", err)
	}

	// Sort the actions chronologically.
	for i := 0; i < len(actions)/2; i++ {
		actions[i], actions[len(actions)-(i+1)] = actions[len(actions)-(i+1)], actions[i]
	}

	encoded, err := json.MarshalIndent(actions, "", "  ")
	if err != nil {
		fmt.Fprintln(os.Stderr, "Serialization failed:", err)
		os.Exit(1)
	}

	if err := ioutil.WriteFile(file, encoded, 0755); err != nil {
		fmt.Fprintln(os.Stderr, "Failed to write file:", err)
		os.Exit(1)
	}
}

func promptForString(field string, r io.Reader, show bool) (result string, err error) {
	fmt.Printf("Please enter %s: ", field)
	if show {
		_, err = fmt.Fscan(r, &result)
	} else {
		var data []byte
		data, err = gopass.GetPasswdMasked()
		result = string(data)
	}
	return result, err
}