func returnPw(pwch chan string) { var pwd string select { case pw := <-pwch: pwd = pw case <-time.After(750 * time.Millisecond): say("Generating...") pwd = <-pwch } if *noTerminal { fmt.Print(pwd) return } before, err := clipboard.ReadAll() clipboard.WriteAll(pwd) say("\nPassword copied to clipboard! ") time.Sleep(5 * time.Second) say("Cleaning clipboard in 5 seconds...") time.Sleep(5 * time.Second) if err != nil { clipboard.WriteAll("") } else { clipboard.WriteAll(before) } say("\n...again? or CTRL+C\n") }
func writeToClipboard(buffer *bytes.Buffer) { clipboardOutput := buffer.String() if clipboardOutput != "" { clipboard.WriteAll(clipboardOutput) fmt.Printf("nw: wrote \"%s\" to clipboard\n", clipboardOutput) } }
func (app *App) runAdd(login, realm, note string, copyPassword bool) { db := app.openStore() defer db.Close() if login == "" { login = readInput("Login: "******"Password") if realm == "" { realm = readInput("Realm: ") } if note == "" { note = readInput("Note: ") } db.AddCredential(&store.Credential{ Login: login, Password: password, Realm: realm, Note: note, }) printSuccess("Credential added. ") if copyPassword { clipboard.WriteAll(password) fmt.Println("Password copied to the clipboard.") } else { fmt.Println() } }
func (yt *YouTube) generateOauthURLAndExit() { // Redirect user to Google's consent page to ask for permission // for the scopes specified above. url := yt.config.AuthCodeURL("state", oauth2.AccessTypeOffline, oauth2.ApprovalForce) clipboard.WriteAll(url) log.Fatalln("Visit the following URL to generate an auth code, then rerun with -auth=<code> (It has also been copied to your clipboard):\n%s", url) }
func add(name string, password []byte) error { clipboard.WriteAll(string(password)) p := Password{} p.Salt = randBytes(8) key = pbkdf2.Key(key, p.Salt, 4096, 32, sha1.New) session, err := aes.NewCipher(key) if err != nil { return err } password = pad(password) pass_ciphered := make([]byte, aes.BlockSize+len(password)) iv := pass_ciphered[:aes.BlockSize] if _, err := io.ReadFull(rand.Reader, iv); err != nil { return err } mode := cipher.NewCBCEncrypter(session, iv) mode.CryptBlocks(pass_ciphered[aes.BlockSize:], password) p.Pass = pass_ciphered logins[name] = p return nil }
func processClipboard() { val, _ := clipboard.ReadAll() if lastClipboardValue != val { lastClipboardValue = val found := false for _, urlPattern := range urls { m, _ := regexp.MatchString( "\\A"+strings.Replace(urlPattern, "*", "(.*)", -1)+"\\z", val) if m { found = true break } } if found { go func() { min := minify(val) if len(min) > 0 { clipboard.WriteAll(min) lastClipboardValue = min } }() } } }
func Example() { clipboard.WriteAll("日本語") text, _ := clipboard.ReadAll() fmt.Println(text) // Output: // 日本語 }
func writeClipBoard() { shortened := <-shortenChan err := clipboard.WriteAll(shortened) if err != nil { log.Fatal(err) } writerChan <- "wrote " + shortened + " to the clipboard\n" }
// Copy the selection to the system clipboard func (v *View) Copy() { if v.cursor.HasSelection() { if !clipboard.Unsupported { clipboard.WriteAll(v.cursor.GetSelection()) } else { messenger.Error("Clipboard is not supported on your system") } } }
func action(context *cli.Context) { text := readClipboard() res := httpGet(text) json := unmarshal(res) if json.Errormessage != "" { fmt.Fprintln(os.Stderr, json.Errormessage) os.Exit(1) } clipboard.WriteAll(json.Shorturl) fmt.Println("Write the value to clipboard: " + json.Shorturl) }
func main() { out, err := ioutil.ReadAll(os.Stdin) if err != nil { panic(err) } if err := clipboard.WriteAll(string(out)); err != nil { panic(err) } }
func (b *BrowserCode) CopyToClipboard() error { encoded, err := b.Encode() if err != nil { return err } err = clipboard.WriteAll(encoded) if err != nil { return err } return nil }
func KeyFuncClearBefore(this *Buffer) Result { var killbuf bytes.Buffer for i := 0; i < this.Cursor; i++ { killbuf.WriteRune(this.Buffer[i]) } clipboard.WriteAll(killbuf.String()) keta := this.Delete(0, this.Cursor) Backspace(keta) this.Cursor = 0 this.Repaint(0, keta) return CONTINUE }
func copyPass(siteName string) { decrypted, _ := getDecryptedData() value, ok := decrypted[siteName] if ok { err := clipboard.WriteAll(value) check(err) fmt.Println("The password has been copied to the clipboard") } else { fmt.Println("Not found") os.Exit(1) } }
func (app *App) runGen(login, realm, note string, copyPassword bool, generator *passgen.Generator) { passwordChan := make(chan *passwordResult) go func() { password, err := generator.Generate() passwordChan <- &passwordResult{password: password, err: err} }() db := app.openStore() defer db.Close() if login == "" { login = readInput("Login: "******"" { realm = readInput("Realm: ") } if note == "" { note = readInput("Note: ") } var result *passwordResult select { case result = <-passwordChan: fmt.Println("Password: (generated)") default: fmt.Println("Password: (generating)") result = <-passwordChan } if result.err != nil { printError("%s\n", result.err) return } db.AddCredential(&store.Credential{ Login: login, Password: result.password, Realm: realm, Note: note, }) printSuccess("Credential added. ") if copyPassword { clipboard.WriteAll(result.password) fmt.Println("Generated password copied to the clipboard.") } else { fmt.Println() } }
func main() { r := regexp.MustCompile(`^“([^“”]+)”[^“”]+Excerpt From:[^“”]+“[^“”]+” iBooks.`) for true { clipContent, _ := clipboard.ReadAll() matchedGroups := r.FindStringSubmatch(clipContent) if len(matchedGroups) > 0 { stripped := matchedGroups[1] clipboard.WriteAll(stripped) fmt.Println("\n\n" + stripped) } time.Sleep(50) } }
func copyThenClear(text string, d time.Duration) error { signals := make(chan os.Signal, 1) signal.Notify(signals, os.Interrupt, os.Kill) defer signal.Stop(signals) original, err := clipboard.ReadAll() if err != nil { return err } err = clipboard.WriteAll(text) if err != nil { return err } select { case <-signals: case <-time.After(d): } current, _ := clipboard.ReadAll() if current == text { return clipboard.WriteAll(original) } return nil }
func main() { var domain, salt, master, note string = "", "", "", "" var pass_length int = 14 if len(os.Args) == 1 { fmt.Printf("Usage: %s domain [password-length]\n", os.Args[0]) os.Exit(1) } if len(os.Args) > 1 { // We do have domain domain = strings.TrimSpace(os.Args[1]) display_notes(domain) } if len(os.Args) > 2 { // We do have password length p_length, err := strconv.Atoi(os.Args[2]) if err != nil { fmt.Printf("Password Length should be a number\n") os.Exit(1) } pass_length = p_length } reader := bufio.NewReader(os.Stdin) fmt.Printf("Enter salt. Hit enter to leave it blank: ") salt, _ = reader.ReadString('\n') salt = strings.TrimRight(salt, "\n") fmt.Printf("Enter note to save. Hit enter to leave it blank: ") note, _ = reader.ReadString('\n') note = strings.TrimRight(note, "\n") if len(note) > 0 { add_note(domain, note) } fmt.Printf("Enter Master password. Hit enter to abort: ") master = string(gopass.GetPasswdMasked()[:]) if len(master) == 0 { os.Exit(1) } password := gen_pwd(domain+salt, master)[:pass_length] clipboard.WriteAll(password) fmt.Println(password, "copied to your clipboard") }
func cp(args []string) { if len(args) != 1 { fmt.Fprintln(os.Stderr, "Usage: passman cp <service>") return } services, err := loadServices(getPasswd()) gobro.CheckErr(err, "Password invalid") service := services.Get(args[0]) if service.Name != "" { clipboard.WriteAll(service.Password) } else { fmt.Printf("'%s' not found\n", args[0]) } }
func (app *App) runCopy(query []string) { db := app.openStore() defer db.Close() credential := findCredential(db, query) if credential == nil { return } clipboard.WriteAll(credential.Password) identifier := formatCredential(credential) printSuccess("Password for %s copied to the clipboard.\n", identifier) }
//Execute runs the current command. func (c *CopyCommand) Execute(w io.Writer, s Storage) { for _, list := range s.Lists { for key, entries := range list { if key == c.List || c.List == "" { for _, entry := range entries { for key, value := range entry { if key == c.Entry { clipboard.WriteAll(value) } } } } } } }
func (c *listCommand) Execute(args []string) (err error) { masker := func(x string) string { if c.Unmask { return x } if c.Clipboard { if err := clipboard.WriteAll(x); err != nil { fmt.Fprintf(os.Stderr, "error copying to clipboard: %s", err) } } return strings.Repeat("*", len(x)) } db, err := v3.Open(c.Path, makePassphraseFn(c.Passphrase, nil)) if err != nil { return err } var re *regexp.Regexp if c.Filter != "" { re, err = regexp.Compile(c.Filter) if err != nil { return err } } for _, record := range db.Records() { if re != nil && !re.MatchString(record.Group()) && !re.MatchString(record.Title()) { continue } fmt.Println("[", record.UUID(), "]") printFields([]fieldDescription{ {"Title", record.Title()}, {"Username", record.Username()}, {"Password", masker(record.Password())}, {"Notes", record.Notes()}, {"Group", record.Group()}, {"URL", record.URL()}, {"Ctime", record.Ctime()}, {"Atime", record.Atime()}, {"Mtime", record.Mtime()}, }) fmt.Println() } return nil }
func addPass(siteName string, generatePass bool) { decrypted, auth := getDecryptedData() var sitePass string if generatePass { sitePass = generateRandomString(32)[:32] err := clipboard.WriteAll(sitePass) check(err) fmt.Println("The password has been copied to the clipboard") } else { fmt.Printf("Password for %s:", siteName) sitePass = string(gopass.GetPasswd()) } decrypted[siteName] = sitePass encrypted := encryptStorage(auth, decrypted) writeFile(cfg.storageFile, encrypted) }
func main() { if len(os.Args) != 2 { fmt.Fprintf(os.Stderr, "Usage: %s <site_address>\n", os.Args[0]) os.Exit(1) } passwd := "" for passwd == "" { if passwd, err := gopass.GetPass(os.Args[1] + " password: "******"" { clipboard.WriteAll(generate(passwd, os.Args[1])) break } } else { panic(err) } } }
func copyCmd(cmd *cobra.Command, args []string) error { selectors := strings.Split(strings.Join(args, " "), "/") entry, err := readEntry(selectors, &db.Content.Root.Groups[0]) if err != nil { return err } if err := clipboard.WriteAll(entry.GetPassword()); err != nil { return err } markAsAccessed(entry) fmt.Printf("UserName: %s\n", entry.GetContent("UserName")) return nil }
func main() { text, err := clipboard.ReadAll() if err != nil { fmt.Fprintln(os.Stderr, err) os.Exit(1) } re := regexp.MustCompile(`\r?\n`) line := re.ReplaceAllString(text, "") if err := clipboard.WriteAll(line); err != nil { fmt.Fprintln(os.Stderr, err) os.Exit(1) } fmt.Print(line) os.Exit(0) }
func KeyFuncWordRubout(this *Buffer) Result { org_cursor := this.Cursor for this.Cursor > 0 && unicode.IsSpace(this.Buffer[this.Cursor-1]) { this.Cursor-- } i := this.CurrentWordTop() var killbuf bytes.Buffer for j := i; j < org_cursor; j++ { killbuf.WriteRune(this.Buffer[j]) } clipboard.WriteAll(killbuf.String()) keta := this.Delete(i, org_cursor-i) if i >= this.ViewStart { Backspace(keta) } else { Backspace(this.GetWidthBetween(this.ViewStart, org_cursor)) } this.Cursor = i this.Repaint(i, keta) return CONTINUE }
func printBrowseOrCopy(args *Args, msg string, openBrowser bool, performCopy bool) { if performCopy { if err := clipboard.WriteAll(msg); err != nil { ui.Errorf("Error copying %s to clipboard:\n%s\n", msg, err.Error()) } } if openBrowser { launcher, err := utils.BrowserLauncher() utils.Check(err) args.Replace(launcher[0], "", launcher[1:]...) args.AppendParams(msg) } if !openBrowser && !performCopy { args.AfterFn(func() error { ui.Println(msg) return nil }) } }
func KeyFuncClearAfter(this *Buffer) Result { w := this.GetWidthBetween(this.ViewStart, this.Cursor) i := this.Cursor bs := 0 var killbuf bytes.Buffer for j := this.Cursor; j < this.Length; j++ { killbuf.WriteRune(this.Buffer[j]) } clipboard.WriteAll(killbuf.String()) for i < this.Length && w < this.ViewWidth { w1 := GetCharWidth(this.Buffer[i]) PutRunes(' ', w1) i++ w += w1 bs += w1 } Backspace(bs) this.Length = this.Cursor return CONTINUE }
func read(name string) error { p, ok := logins[name] if !ok { return fmt.Errorf("no such key") } key = pbkdf2.Key(key, p.Salt, 4096, 32, sha1.New) session, err := aes.NewCipher(key) if err != nil { return err } pass_ciphered := p.Pass iv := pass_ciphered[:aes.BlockSize] pass_ciphered = pass_ciphered[aes.BlockSize:] pass_plain := make([]byte, len(pass_ciphered)) mode := cipher.NewCBCDecrypter(session, iv) mode.CryptBlocks(pass_plain, pass_ciphered) clipboard.WriteAll(string(pass_plain)) return nil }