Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "s", "*", "Store", ")", "Path", "(", ")", "string", "{", "if", "s", ".", "url", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "s", ".", "url", ".", "Path", "\n", "}" ]

[ "Path", "returns", "the", "value", "of", "path" ]

[ "func", "ListPrivateKeys", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "if", "err", ":=", "initCrypto", "(", ")", ";", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUnknown", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "kl", ",", "err", ":=", "crypto", ".", "ListPrivateKeyIDs", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUnknown", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "out", ".", "Print", "(", "ctx", ",", "\"", "\"", ")", "\n", "for", "_", ",", "key", ":=", "range", "kl", "{", "out", ".", "Print", "(", "ctx", ",", "\"", "\"", ",", "key", ",", "crypto", ".", "FormatKey", "(", "ctx", ",", "key", ")", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "ListPrivateKeys", "list", "the", "XC", "private", "keys" ]

[ "func", "GenerateKeypair", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "if", "err", ":=", "initCrypto", "(", ")", ";", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUnknown", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "name", ":=", "c", ".", "String", "(", "\"", "\"", ")", "\n", "email", ":=", "c", ".", "String", "(", "\"", "\"", ")", "\n", "pw", ":=", "c", ".", "String", "(", "\"", "\"", ")", "\n\n", "if", "name", "==", "\"", "\"", "{", "var", "err", "error", "\n", "name", ",", "err", "=", "termio", ".", "AskForString", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "||", "name", "==", "\"", "\"", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitNoName", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "if", "email", "==", "\"", "\"", "{", "var", "err", "error", "\n", "email", ",", "err", "=", "termio", ".", "AskForString", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "||", "email", "==", "\"", "\"", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitNoName", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "if", "pw", "==", "\"", "\"", "{", "var", "err", "error", "\n", "pw", ",", "err", "=", "termio", ".", "AskForPassword", "(", "ctx", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "||", "pw", "==", "\"", "\"", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitIO", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "crypto", ".", "CreatePrivateKeyBatch", "(", "ctx", ",", "name", ",", "email", ",", "pw", ")", ";", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUnknown", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GenerateKeypair", "generates", "a", "new", "XC", "keypair" ]

[ "func", "ExportPrivateKey", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "if", "err", ":=", "initCrypto", "(", ")", ";", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUnknown", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "id", ":=", "c", ".", "String", "(", "\"", "\"", ")", "\n", "file", ":=", "c", ".", "String", "(", "\"", "\"", ")", "\n\n", "if", "id", "==", "\"", "\"", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUsage", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "file", "==", "\"", "\"", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUsage", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "fsutil", ".", "IsFile", "(", "file", ")", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUnknown", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n\n", "pk", ",", "err", ":=", "crypto", ".", "ExportPrivateKey", "(", "ctx", ",", "id", ")", "\n", "if", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUnknown", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "ioutil", ".", "WriteFile", "(", "file", ",", "pk", ",", "0600", ")", ";", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitIO", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ExportPrivateKey", "exports", "an", "XC", "key" ]

[ "func", "ImportPrivateKey", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "if", "err", ":=", "initCrypto", "(", ")", ";", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUnknown", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "file", ":=", "c", ".", "String", "(", "\"", "\"", ")", "\n\n", "if", "file", "==", "\"", "\"", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUsage", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "!", "fsutil", ".", "IsFile", "(", "file", ")", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitNotFound", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n\n", "buf", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "file", ")", "\n", "if", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitIO", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "crypto", ".", "ImportPrivateKey", "(", "ctx", ",", "buf", ")", "\n", "}" ]

[ "ImportPrivateKey", "imports", "an", "XC", "key" ]

[ "func", "EncryptFile", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "if", "err", ":=", "initCrypto", "(", ")", ";", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUnknown", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "c", ".", "Bool", "(", "\"", "\"", ")", "{", "return", "EncryptFileStream", "(", "ctx", ",", "c", ")", "\n", "}", "\n\n", "inFile", ":=", "c", ".", "String", "(", "\"", "\"", ")", "\n", "if", "inFile", "==", "\"", "\"", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUsage", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n\n", "recipients", ":=", "c", ".", "StringSlice", "(", "\"", "\"", ")", "\n", "outFile", ":=", "inFile", "+", "\"", "\"", "\n\n", "if", "!", "fsutil", ".", "IsFile", "(", "inFile", ")", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitNotFound", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "fsutil", ".", "IsFile", "(", "outFile", ")", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitIO", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n\n", "plaintext", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "inFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitIO", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "ciphertext", ",", "err", ":=", "crypto", ".", "Encrypt", "(", "ctx", ",", "plaintext", ",", "recipients", ")", "\n", "if", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUnknown", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "err", ":=", "ioutil", ".", "WriteFile", "(", "outFile", ",", "ciphertext", ",", "0600", ")", ";", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUnknown", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "EncryptFile", "encrypts", "a", "single", "file" ]

[ "func", "DecryptFile", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "if", "err", ":=", "initCrypto", "(", ")", ";", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUnknown", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "c", ".", "Bool", "(", "\"", "\"", ")", "{", "return", "DecryptFileStream", "(", "ctx", ",", "c", ")", "\n", "}", "\n\n", "inFile", ":=", "c", ".", "String", "(", "\"", "\"", ")", "\n", "if", "inFile", "==", "\"", "\"", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUsage", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "!", "strings", ".", "HasSuffix", "(", "inFile", ",", "\"", "\"", ")", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUsage", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n", "outFile", ":=", "strings", ".", "TrimSuffix", "(", "inFile", ",", "\"", "\"", ")", "\n\n", "if", "!", "fsutil", ".", "IsFile", "(", "inFile", ")", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitNotFound", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "fsutil", ".", "IsFile", "(", "outFile", ")", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitIO", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n\n", "ciphertext", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "inFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitIO", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "plaintext", ",", "err", ":=", "crypto", ".", "Decrypt", "(", "ctx", ",", "ciphertext", ")", "\n", "if", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUnknown", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "ioutil", ".", "WriteFile", "(", "outFile", ",", "plaintext", ",", "0600", ")", ";", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUnknown", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "DecryptFile", "decrypts", "a", "single", "file" ]

[ "func", "EncryptFileStream", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "if", "err", ":=", "initCrypto", "(", ")", ";", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUnknown", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "inFile", ":=", "c", ".", "String", "(", "\"", "\"", ")", "\n", "if", "inFile", "==", "\"", "\"", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUsage", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n\n", "recipients", ":=", "c", ".", "StringSlice", "(", "\"", "\"", ")", "\n\n", "outFile", ":=", "inFile", "+", "\"", "\"", "\n\n", "if", "!", "fsutil", ".", "IsFile", "(", "inFile", ")", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitNotFound", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "fsutil", ".", "IsFile", "(", "outFile", ")", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitIO", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n\n", "plaintext", ",", "err", ":=", "os", ".", "Open", "(", "inFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitIO", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "func", "(", ")", "{", "_", "=", "plaintext", ".", "Close", "(", ")", "}", "(", ")", "\n\n", "ciphertext", ",", "err", ":=", "os", ".", "OpenFile", "(", "outFile", ",", "os", ".", "O_CREATE", "|", "os", ".", "O_WRONLY", ",", "0600", ")", "\n", "if", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitIO", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "func", "(", ")", "{", "_", "=", "ciphertext", ".", "Close", "(", ")", "}", "(", ")", "\n\n", "if", "err", ":=", "crypto", ".", "EncryptStream", "(", "ctx", ",", "plaintext", ",", "recipients", ",", "ciphertext", ")", ";", "err", "!=", "nil", "{", "_", "=", "os", ".", "Remove", "(", "outFile", ")", "\n", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUnknown", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "EncryptFileStream", "encrypts", "a", "single", "file" ]

[ "func", "DecryptFileStream", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "if", "err", ":=", "initCrypto", "(", ")", ";", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUnknown", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "inFile", ":=", "c", ".", "String", "(", "\"", "\"", ")", "\n", "if", "inFile", "==", "\"", "\"", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUsage", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "!", "strings", ".", "HasSuffix", "(", "inFile", ",", "\"", "\"", ")", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUsage", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n", "outFile", ":=", "strings", ".", "TrimSuffix", "(", "inFile", ",", "\"", "\"", ")", "\n\n", "if", "!", "fsutil", ".", "IsFile", "(", "inFile", ")", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitNotFound", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "fsutil", ".", "IsFile", "(", "outFile", ")", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitIO", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n\n", "ciphertext", ",", "err", ":=", "os", ".", "Open", "(", "inFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitIO", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "func", "(", ")", "{", "_", "=", "ciphertext", ".", "Close", "(", ")", "}", "(", ")", "\n\n", "plaintext", ",", "err", ":=", "os", ".", "OpenFile", "(", "outFile", ",", "os", ".", "O_CREATE", "|", "os", ".", "O_WRONLY", ",", "0600", ")", "\n", "if", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitIO", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "func", "(", ")", "{", "_", "=", "plaintext", ".", "Close", "(", ")", "}", "(", ")", "\n\n", "if", "err", ":=", "crypto", ".", "DecryptStream", "(", "ctx", ",", "ciphertext", ",", "plaintext", ")", ";", "err", "!=", "nil", "{", "_", "=", "os", ".", "Remove", "(", "outFile", ")", "\n", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUnknown", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "DecryptFileStream", "decrypts", "a", "single", "file" ]

[ "func", "(", "c", "*", "gitCredentials", ")", "WriteTo", "(", "w", "io", ".", "Writer", ")", "(", "int64", ",", "error", ")", "{", "var", "n", "int64", "\n", "if", "c", ".", "Protocol", "!=", "\"", "\"", "{", "i", ",", "err", ":=", "io", ".", "WriteString", "(", "w", ",", "\"", "\"", "+", "c", ".", "Protocol", "+", "\"", "\\n", "\"", ")", "\n", "n", "+=", "int64", "(", "i", ")", "\n", "if", "err", "!=", "nil", "{", "return", "n", ",", "err", "\n", "}", "\n", "}", "\n", "if", "c", ".", "Host", "!=", "\"", "\"", "{", "i", ",", "err", ":=", "io", ".", "WriteString", "(", "w", ",", "\"", "\"", "+", "c", ".", "Host", "+", "\"", "\\n", "\"", ")", "\n", "n", "+=", "int64", "(", "i", ")", "\n", "if", "err", "!=", "nil", "{", "return", "n", ",", "err", "\n", "}", "\n", "}", "\n", "if", "c", ".", "Path", "!=", "\"", "\"", "{", "i", ",", "err", ":=", "io", ".", "WriteString", "(", "w", ",", "\"", "\"", "+", "c", ".", "Path", "+", "\"", "\\n", "\"", ")", "\n", "n", "+=", "int64", "(", "i", ")", "\n", "if", "err", "!=", "nil", "{", "return", "n", ",", "err", "\n", "}", "\n", "}", "\n", "if", "c", ".", "Username", "!=", "\"", "\"", "{", "i", ",", "err", ":=", "io", ".", "WriteString", "(", "w", ",", "\"", "\"", "+", "c", ".", "Username", "+", "\"", "\\n", "\"", ")", "\n", "n", "+=", "int64", "(", "i", ")", "\n", "if", "err", "!=", "nil", "{", "return", "n", ",", "err", "\n", "}", "\n", "}", "\n", "if", "c", ".", "Password", "!=", "\"", "\"", "{", "i", ",", "err", ":=", "io", ".", "WriteString", "(", "w", ",", "\"", "\"", "+", "c", ".", "Password", "+", "\"", "\\n", "\"", ")", "\n", "n", "+=", "int64", "(", "i", ")", "\n", "if", "err", "!=", "nil", "{", "return", "n", ",", "err", "\n", "}", "\n", "}", "\n", "return", "n", ",", "nil", "\n", "}" ]

[ "WriteTo", "writes", "the", "given", "credentials", "to", "the", "given", "io", ".", "Writer", "in", "the", "git", "-", "credential", "format" ]

[ "func", "(", "s", "*", "Action", ")", "GitCredentialBefore", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "err", ":=", "s", ".", "Initialized", "(", "ctx", ",", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "ctxutil", ".", "IsStdin", "(", "ctx", ")", "{", "return", "ExitError", "(", "ctx", ",", "ExitUsage", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GitCredentialBefore", "is", "executed", "before", "another", "git", "-", "credential", "command" ]

[ "func", "(", "s", "*", "Action", ")", "GitCredentialGet", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "ctx", "=", "sub", ".", "WithAutoSync", "(", "ctx", ",", "false", ")", "\n", "cred", ",", "err", ":=", "parseGitCredentials", "(", "termio", ".", "Stdin", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ExitError", "(", "ctx", ",", "ExitUnsupported", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "// try git/host/username... If username is empty, simply try git/host", "path", ":=", "\"", "\"", "+", "fsutil", ".", "CleanFilename", "(", "cred", ".", "Host", ")", "+", "\"", "\"", "+", "fsutil", ".", "CleanFilename", "(", "cred", ".", "Username", ")", "\n", "if", "!", "s", ".", "Store", ".", "Exists", "(", "ctx", ",", "path", ")", "{", "// if the looked up path is a directory with only one entry (e.g. one user per host), take the subentry instead", "if", "!", "s", ".", "Store", ".", "IsDir", "(", "ctx", ",", "path", ")", "{", "return", "nil", "\n", "}", "\n", "tree", ",", "err", ":=", "s", ".", "Store", ".", "Tree", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ExitError", "(", "ctx", ",", "ExitDecrypt", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "sub", ",", "err", ":=", "tree", ".", "FindFolder", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "// no entry found... this is not an error", "return", "nil", "\n", "}", "\n", "entries", ":=", "sub", ".", "List", "(", "0", ")", "\n", "if", "len", "(", "entries", ")", "!=", "1", "{", "fmt", ".", "Fprintln", "(", "os", ".", "Stderr", ",", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n", "path", "=", "\"", "\"", "+", "entries", "[", "0", "]", "\n", "}", "\n", "secret", ",", "err", ":=", "s", ".", "Store", ".", "Get", "(", "ctx", ",", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ExitError", "(", "ctx", ",", "ExitDecrypt", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "cred", ".", "Password", "=", "secret", ".", "Password", "(", ")", "\n", "username", ",", "err", ":=", "secret", ".", "Value", "(", "\"", "\"", ")", "\n", "if", "err", "==", "nil", "{", "// leave the username as is otherwise", "cred", ".", "Username", "=", "username", "\n", "}", "\n\n", "_", ",", "err", "=", "cred", ".", "WriteTo", "(", "out", ".", "Stdout", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ExitError", "(", "ctx", ",", "ExitIO", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GitCredentialGet", "returns", "a", "credential", "to", "git" ]

[ "func", "(", "s", "*", "Action", ")", "GitCredentialStore", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "cred", ",", "err", ":=", "parseGitCredentials", "(", "termio", ".", "Stdin", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ExitError", "(", "ctx", ",", "ExitUnsupported", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "path", ":=", "\"", "\"", "+", "fsutil", ".", "CleanFilename", "(", "cred", ".", "Host", ")", "+", "\"", "\"", "+", "fsutil", ".", "CleanFilename", "(", "cred", ".", "Username", ")", "\n", "// This should never really be an issue because git automatically removes invalid credentials first", "if", "s", ".", "Store", ".", "Exists", "(", "ctx", ",", "path", ")", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\"", "+", "\"", "\\\"", "\\\"", "\"", "+", "\"", "\"", "+", "\"", "\\\"", "\\\"", "\\n", "\"", ",", "path", ",", "path", ",", ")", "\n", "return", "nil", "\n", "}", "\n", "secret", ":=", "secret", ".", "New", "(", "cred", ".", "Password", ",", "\"", "\"", ")", "\n", "if", "cred", ".", "Username", "!=", "\"", "\"", "{", "_", "=", "secret", ".", "SetValue", "(", "\"", "\"", ",", "cred", ".", "Username", ")", "\n", "}", "\n", "err", "=", "s", ".", "Store", ".", "Set", "(", "ctx", ",", "path", ",", "secret", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GitCredentialStore", "stores", "a", "credential", "got", "from", "git" ]

[ "func", "(", "s", "*", "Action", ")", "GitCredentialErase", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "cred", ",", "err", ":=", "parseGitCredentials", "(", "termio", ".", "Stdin", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ExitError", "(", "ctx", ",", "ExitUnsupported", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "path", ":=", "\"", "\"", "+", "fsutil", ".", "CleanFilename", "(", "cred", ".", "Host", ")", "+", "\"", "\"", "+", "fsutil", ".", "CleanFilename", "(", "cred", ".", "Username", ")", "\n", "err", "=", "s", ".", "Store", ".", "Delete", "(", "ctx", ",", "path", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintln", "(", "os", ".", "Stderr", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GitCredentialErase", "removes", "a", "credential", "got", "from", "git" ]

[ "func", "(", "s", "*", "Action", ")", "GitCredentialConfigure", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "flags", ":=", "0", "\n", "flag", ":=", "\"", "\"", "\n", "if", "c", ".", "Bool", "(", "\"", "\"", ")", "{", "flag", "=", "\"", "\"", "\n", "flags", "++", "\n", "}", "\n", "if", "c", ".", "Bool", "(", "\"", "\"", ")", "{", "flag", "=", "\"", "\"", "\n", "flags", "++", "\n", "}", "\n", "if", "c", ".", "Bool", "(", "\"", "\"", ")", "{", "flag", "=", "\"", "\"", "\n", "flags", "++", "\n", "}", "\n", "if", "flags", ">=", "2", "{", "return", "ExitError", "(", "ctx", ",", "ExitUnsupported", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "flags", "==", "0", "{", "log", ".", "Println", "(", "\"", "\"", ")", "\n", "}", "\n", "cmd", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "\"", "\"", ",", "flag", ",", "\"", "\"", ",", "`\"!gopass git-credential $@\"`", ")", "\n", "cmd", ".", "Stdout", "=", "os", ".", "Stdout", "\n", "cmd", ".", "Stderr", "=", "os", ".", "Stderr", "\n", "return", "cmd", ".", "Run", "(", ")", "\n", "}" ]

[ "GitCredentialConfigure", "configures", "gopass", "as", "git", "s", "credential", ".", "helper" ]

[ "func", "(", "f", "File", ")", "format", "(", "prefix", "string", ",", "last", "bool", ",", "_", ",", "_", "int", ")", "string", "{", "sym", ":=", "symBranch", "\n", "if", "last", "{", "sym", "=", "symLeaf", "\n", "}", "\n", "ft", ":=", "\"", "\"", "\n", "if", "f", ".", "Metadata", "!=", "nil", "{", "switch", "f", ".", "Metadata", "[", "\"", "\"", "]", "{", "case", "\"", "\"", ":", "ft", "=", "\"", "\"", "+", "colBin", "(", "\"", "\"", ")", "\n", "case", "\"", "\"", ":", "ft", "=", "\"", "\"", "+", "colYaml", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "prefix", "+", "sym", "+", "f", ".", "Name", "+", "ft", "+", "\"", "\\n", "\"", "\n", "}" ]

[ "format", "will", "format", "this", "leaf", "node", "for", "pretty", "printing" ]

[ "func", "(", "ca", "Actions", ")", "Selection", "(", ")", "[", "]", "string", "{", "keys", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "ca", ")", ")", "\n", "for", "_", ",", "a", ":=", "range", "ca", "{", "keys", "=", "append", "(", "keys", ",", "a", ".", "Name", ")", "\n", "}", "\n", "return", "keys", "\n", "}" ]

[ "Selection", "return", "the", "list", "of", "actions" ]

[ "func", "(", "ca", "Actions", ")", "Run", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ",", "i", "int", ")", "error", "{", "if", "len", "(", "ca", ")", "<", "i", "||", "i", ">=", "len", "(", "ca", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "ca", "[", "i", "]", ".", "Fn", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "ca", "[", "i", "]", ".", "Fn", "(", "ctx", ",", "c", ")", "\n", "}" ]

[ "Run", "executes", "the", "selected", "action" ]

[ "func", "New", "(", "dumps", "...", "string", ")", "(", "*", "Scanner", ",", "error", ")", "{", "ok", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "dumps", ")", ")", "\n", "for", "_", ",", "dump", ":=", "range", "dumps", "{", "if", "!", "fsutil", ".", "IsFile", "(", "dump", ")", "{", "continue", "\n", "}", "\n", "ok", "=", "append", "(", "ok", ",", "dump", ")", "\n", "}", "\n", "if", "len", "(", "ok", ")", "<", "1", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "&", "Scanner", "{", "dumps", ":", "ok", ",", "}", ",", "nil", "\n", "}" ]

[ "New", "creates", "a", "new", "scanner" ]

[ "func", "(", "s", "*", "Scanner", ")", "LookupBatch", "(", "ctx", "context", ".", "Context", ",", "in", "[", "]", "string", ")", "[", "]", "string", "{", "if", "len", "(", "in", ")", "<", "1", "{", "return", "nil", "\n", "}", "\n\n", "sort", ".", "Strings", "(", "in", ")", "\n", "for", "i", ",", "hash", ":=", "range", "in", "{", "in", "[", "i", "]", "=", "strings", ".", "ToUpper", "(", "hash", ")", "\n", "}", "\n\n", "out", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "in", ")", ")", "\n", "results", ":=", "make", "(", "chan", "string", ",", "len", "(", "in", ")", ")", "\n", "done", ":=", "make", "(", "chan", "struct", "{", "}", ",", "len", "(", "s", ".", "dumps", ")", ")", "\n\n", "for", "_", ",", "fn", ":=", "range", "s", ".", "dumps", "{", "go", "s", ".", "scanFile", "(", "ctx", ",", "fn", ",", "in", ",", "results", ",", "done", ")", "\n", "}", "\n", "go", "func", "(", ")", "{", "for", "result", ":=", "range", "results", "{", "out", "=", "append", "(", "out", ",", "result", ")", "\n", "}", "\n", "done", "<-", "struct", "{", "}", "{", "}", "\n", "}", "(", ")", "\n", "for", "range", "s", ".", "dumps", "{", "<-", "done", "\n", "}", "\n", "close", "(", "results", ")", "\n", "<-", "done", "\n\n", "return", "out", "\n", "}" ]

[ "LookupBatch", "takes", "a", "slice", "SHA1", "hashes", "and", "matches", "them", "against", "the", "provided", "dumps" ]

[ "func", "(", "g", "*", "Noop", ")", "Add", "(", "ctx", "context", ".", "Context", ",", "args", "...", "string", ")", "error", "{", "return", "nil", "\n", "}" ]

[ "Add", "does", "nothing" ]

[ "func", "(", "g", "*", "Noop", ")", "Commit", "(", "ctx", "context", ".", "Context", ",", "msg", "string", ")", "error", "{", "return", "nil", "\n", "}" ]

[ "Commit", "does", "nothing" ]

[ "func", "(", "g", "*", "Noop", ")", "Push", "(", "ctx", "context", ".", "Context", ",", "origin", ",", "branch", "string", ")", "error", "{", "return", "nil", "\n", "}" ]

[ "Push", "does", "nothing" ]

[ "func", "(", "g", "*", "Noop", ")", "Cmd", "(", "ctx", "context", ".", "Context", ",", "name", "string", ",", "args", "...", "string", ")", "error", "{", "return", "nil", "\n", "}" ]

[ "Cmd", "does", "nothing" ]

[ "func", "(", "g", "*", "Noop", ")", "AddRemote", "(", "ctx", "context", ".", "Context", ",", "remote", ",", "url", "string", ")", "error", "{", "return", "nil", "\n", "}" ]

[ "AddRemote", "does", "nothing" ]

[ "func", "(", "g", "*", "Noop", ")", "RemoveRemote", "(", "ctx", "context", ".", "Context", ",", "remote", "string", ")", "error", "{", "return", "nil", "\n", "}" ]

[ "RemoveRemote", "does", "nothing" ]

[ "func", "(", "g", "*", "Noop", ")", "Revisions", "(", "context", ".", "Context", ",", "string", ")", "(", "[", "]", "backend", ".", "Revision", ",", "error", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "g", ".", "Name", "(", ")", ")", "\n", "}" ]

[ "Revisions", "is", "not", "implemented" ]

[ "func", "WithPassPromptFunc", "(", "ctx", "context", ".", "Context", ",", "ppf", "PassPromptFunc", ")", "context", ".", "Context", "{", "return", "context", ".", "WithValue", "(", "ctx", ",", "ctxKeyPassPromptFunc", ",", "ppf", ")", "\n", "}" ]

[ "WithPassPromptFunc", "returns", "a", "context", "with", "the", "password", "prompt", "function", "set" ]

[ "func", "HasPassPromptFunc", "(", "ctx", "context", ".", "Context", ")", "bool", "{", "ppf", ",", "ok", ":=", "ctx", ".", "Value", "(", "ctxKeyPassPromptFunc", ")", ".", "(", "PassPromptFunc", ")", "\n", "return", "ok", "&&", "ppf", "!=", "nil", "\n", "}" ]

[ "HasPassPromptFunc", "returns", "true", "if", "a", "value", "for", "the", "pass", "prompt", "func", "has", "been", "set", "in", "this", "context" ]

[ "func", "(", "s", "*", "Store", ")", "ListTemplates", "(", "ctx", "context", ".", "Context", ",", "prefix", "string", ")", "[", "]", "string", "{", "lst", ",", "err", ":=", "s", ".", "storage", ".", "List", "(", "ctx", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "nil", "\n", "}", "\n", "tpls", ":=", "make", "(", "map", "[", "string", "]", "struct", "{", "}", ",", "len", "(", "lst", ")", ")", "\n", "for", "_", ",", "path", ":=", "range", "lst", "{", "if", "!", "strings", ".", "HasSuffix", "(", "path", ",", "TemplateFile", ")", "{", "continue", "\n", "}", "\n", "path", "=", "strings", ".", "TrimSuffix", "(", "path", ",", "sep", "+", "TemplateFile", ")", "\n", "if", "prefix", "!=", "\"", "\"", "{", "path", "=", "prefix", "+", "sep", "+", "path", "\n", "}", "\n", "tpls", "[", "path", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "out", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "tpls", ")", ")", "\n", "for", "k", ":=", "range", "tpls", "{", "out", "=", "append", "(", "out", ",", "k", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "ListTemplates", "will", "list", "all", "templates", "in", "this", "store" ]

[ "func", "(", "s", "*", "Store", ")", "templatefile", "(", "name", "string", ")", "string", "{", "return", "strings", ".", "TrimPrefix", "(", "filepath", ".", "Join", "(", "name", ",", "TemplateFile", ")", ",", "string", "(", "filepath", ".", "Separator", ")", ")", "\n", "}" ]

[ "templatefile", "returns", "the", "name", "of", "the", "given", "template", "on", "disk" ]

[ "func", "(", "s", "*", "Store", ")", "HasTemplate", "(", "ctx", "context", ".", "Context", ",", "name", "string", ")", "bool", "{", "return", "s", ".", "storage", ".", "Exists", "(", "ctx", ",", "s", ".", "templatefile", "(", "name", ")", ")", "\n", "}" ]

[ "HasTemplate", "returns", "true", "if", "the", "template", "exists" ]

[ "func", "(", "s", "*", "Store", ")", "GetTemplate", "(", "ctx", "context", ".", "Context", ",", "name", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "s", ".", "storage", ".", "Get", "(", "ctx", ",", "s", ".", "templatefile", "(", "name", ")", ")", "\n", "}" ]

[ "GetTemplate", "will", "return", "the", "content", "of", "the", "named", "template" ]

[ "func", "ParseURL", "(", "us", "string", ")", "(", "*", "URL", ",", "error", ")", "{", "// if it's no URL build file URL and parse that", "nu", ",", "err", ":=", "url", ".", "Parse", "(", "us", ")", "\n", "if", "err", "!=", "nil", "{", "nu", ",", "err", "=", "url", ".", "Parse", "(", "\"", "\"", "+", "us", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "u", ":=", "&", "URL", "{", "url", ":", "nu", ",", "}", "\n", "if", "err", ":=", "u", ".", "parseScheme", "(", ")", ";", "err", "!=", "nil", "{", "return", "u", ",", "err", "\n", "}", "\n", "u", ".", "Path", "=", "nu", ".", "Path", "\n", "if", "nu", ".", "User", "!=", "nil", "{", "u", ".", "Username", "=", "nu", ".", "User", ".", "Username", "(", ")", "\n", "u", ".", "Password", ",", "_", "=", "nu", ".", "User", ".", "Password", "(", ")", "\n", "}", "\n", "if", "nu", ".", "Host", "==", "\"", "\"", "{", "hd", ",", "err", ":=", "homedir", ".", "Dir", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "u", ",", "err", "\n", "}", "\n", "u", ".", "Path", "=", "filepath", ".", "Join", "(", "hd", ",", "u", ".", "Path", ")", "\n", "nu", ".", "Host", "=", "\"", "\"", "\n", "}", "\n", "u", ".", "Query", "=", "nu", ".", "Query", "(", ")", "\n", "if", "nu", ".", "Host", "!=", "\"", "\"", "{", "h", ",", "p", ",", "err", ":=", "net", ".", "SplitHostPort", "(", "nu", ".", "Host", ")", "\n", "if", "err", "==", "nil", "{", "u", ".", "Host", "=", "h", "\n", "u", ".", "Port", "=", "p", "\n", "}", "\n", "}", "else", "if", "runtime", ".", "GOOS", "==", "\"", "\"", "{", "// only trim if this is a local path, e. g. file:///C:/Users/...", "// (specified in https://blogs.msdn.microsoft.com/ie/2006/12/06/file-uris-in-windows/)", "// In that case, u.Path will contain a leading slash.", "// (correctly, as per RFC 3986, see https://github.com/golang/go/issues/6027)", "u", ".", "Path", "=", "strings", ".", "TrimPrefix", "(", "u", ".", "Path", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "u", ",", "nil", "\n", "}" ]

[ "ParseURL", "attempts", "to", "parse", "an", "backend", "URL" ]

[ "func", "(", "u", "*", "URL", ")", "UnmarshalYAML", "(", "umf", "func", "(", "interface", "{", "}", ")", "error", ")", "error", "{", "path", ":=", "\"", "\"", "\n", "if", "err", ":=", "umf", "(", "&", "path", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "um", ",", "err", ":=", "ParseURL", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "*", "u", "=", "*", "um", "\n", "return", "nil", "\n", "}" ]

[ "UnmarshalYAML", "implements", "yaml", ".", "Unmarshaler" ]

[ "func", "(", "s", "*", "Store", ")", "GitInit", "(", "ctx", "context", ".", "Context", ",", "un", ",", "ue", "string", ")", "error", "{", "rcs", ",", "err", ":=", "backend", ".", "InitRCS", "(", "ctx", ",", "backend", ".", "GetRCSBackend", "(", "ctx", ")", ",", "s", ".", "url", ".", "Path", ",", "un", ",", "ue", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "s", ".", "rcs", "=", "rcs", "\n", "return", "nil", "\n", "}" ]

[ "GitInit", "initializes", "the", "the", "git", "repo", "in", "the", "store" ]

[ "func", "(", "s", "*", "Store", ")", "ListRevisions", "(", "ctx", "context", ".", "Context", ",", "name", "string", ")", "(", "[", "]", "backend", ".", "Revision", ",", "error", ")", "{", "p", ":=", "s", ".", "passfile", "(", "name", ")", "\n", "return", "s", ".", "rcs", ".", "Revisions", "(", "ctx", ",", "p", ")", "\n", "}" ]

[ "ListRevisions", "will", "list", "all", "revisions", "for", "a", "secret" ]

[ "func", "(", "s", "*", "Store", ")", "GetRevision", "(", "ctx", "context", ".", "Context", ",", "name", ",", "revision", "string", ")", "(", "store", ".", "Secret", ",", "error", ")", "{", "p", ":=", "s", ".", "passfile", "(", "name", ")", "\n", "ciphertext", ",", "err", ":=", "s", ".", "rcs", ".", "GetRevision", "(", "ctx", ",", "p", ",", "revision", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "name", ",", "revision", ")", "\n", "}", "\n\n", "content", ",", "err", ":=", "s", ".", "crypto", ".", "Decrypt", "(", "ctx", ",", "ciphertext", ")", "\n", "if", "err", "!=", "nil", "{", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "nil", ",", "store", ".", "ErrDecrypt", "\n", "}", "\n\n", "sec", ",", "err", ":=", "secret", ".", "Parse", "(", "content", ")", "\n", "if", "err", "!=", "nil", "{", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "sec", ",", "nil", "\n", "}" ]

[ "GetRevision", "will", "retrieve", "a", "single", "revision", "from", "the", "backend" ]

[ "func", "(", "k", "Key", ")", "IsUseable", "(", ")", "bool", "{", "if", "!", "k", ".", "ExpirationDate", ".", "IsZero", "(", ")", "&&", "k", ".", "ExpirationDate", ".", "Before", "(", "time", ".", "Now", "(", ")", ")", "{", "return", "false", "\n", "}", "\n", "switch", "k", ".", "Validity", "{", "case", "\"", "\"", ":", "return", "true", "\n", "case", "\"", "\"", ":", "return", "true", "\n", "case", "\"", "\"", ":", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "IsUseable", "returns", "true", "if", "GPG", "would", "assume", "this", "key", "is", "useable", "for", "encryption" ]

[ "func", "(", "k", "Key", ")", "String", "(", ")", "string", "{", "fp", ":=", "\"", "\"", "\n", "if", "len", "(", "k", ".", "Fingerprint", ")", ">", "24", "{", "fp", "=", "k", ".", "Fingerprint", "[", "24", ":", "]", "\n", "}", "\n", "out", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "k", ".", "KeyType", ",", "k", ".", "KeyLength", ",", "fp", ",", "k", ".", "CreationDate", ".", "Format", "(", "\"", "\"", ")", ")", "\n", "if", "!", "k", ".", "ExpirationDate", ".", "IsZero", "(", ")", "{", "out", "+=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "k", ".", "ExpirationDate", ".", "Format", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "out", "+=", "\"", "\\n", "\"", "+", "k", ".", "Fingerprint", "\n", "for", "_", ",", "id", ":=", "range", "k", ".", "Identities", "{", "out", "+=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", "+", "id", ".", "String", "(", ")", ")", "\n", "}", "\n", "return", "out", "\n", "}" ]

[ "String", "implement", "fmt", ".", "Stringer", ".", "This", "method", "produces", "output", "that", "is", "close", "to", "but", "not", "exactly", "the", "same", "as", "the", "output", "form", "GPG", "itself" ]

[ "func", "(", "k", "Key", ")", "Identity", "(", ")", "Identity", "{", "ids", ":=", "make", "(", "[", "]", "Identity", ",", "0", ",", "len", "(", "k", ".", "Identities", ")", ")", "\n", "for", "_", ",", "i", ":=", "range", "k", ".", "Identities", "{", "ids", "=", "append", "(", "ids", ",", "i", ")", "\n", "}", "\n", "sort", ".", "Slice", "(", "ids", ",", "func", "(", "i", ",", "j", "int", ")", "bool", "{", "return", "ids", "[", "i", "]", ".", "CreationDate", ".", "After", "(", "ids", "[", "j", "]", ".", "CreationDate", ")", "\n", "}", ")", "\n", "for", "_", ",", "i", ":=", "range", "ids", "{", "return", "i", "\n", "}", "\n", "return", "Identity", "{", "}", "\n", "}" ]

[ "Identity", "returns", "the", "first", "identity" ]

[ "func", "(", "k", "Key", ")", "ID", "(", ")", "string", "{", "if", "len", "(", "k", ".", "Fingerprint", ")", "<", "25", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "k", ".", "Fingerprint", "[", "24", ":", "]", ")", "\n", "}" ]

[ "ID", "returns", "the", "short", "fingerprint" ]

[ "func", "(", "s", "*", "Action", ")", "Clone", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "if", "c", ".", "IsSet", "(", "\"", "\"", ")", "{", "ctx", "=", "backend", ".", "WithCryptoBackendString", "(", "ctx", ",", "c", ".", "String", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "if", "c", ".", "IsSet", "(", "\"", "\"", ")", "{", "ctx", "=", "backend", ".", "WithRCSBackendString", "(", "ctx", ",", "c", ".", "String", "(", "\"", "\"", ")", ")", "\n", "}", "\n\n", "if", "len", "(", "c", ".", "Args", "(", ")", ")", "<", "1", "{", "return", "ExitError", "(", "ctx", ",", "ExitUsage", ",", "nil", ",", "\"", "\"", ",", "s", ".", "Name", ")", "\n", "}", "\n\n", "repo", ":=", "c", ".", "Args", "(", ")", "[", "0", "]", "\n", "mount", ":=", "\"", "\"", "\n", "if", "len", "(", "c", ".", "Args", "(", ")", ")", ">", "1", "{", "mount", "=", "c", ".", "Args", "(", ")", "[", "1", "]", "\n", "}", "\n\n", "path", ":=", "c", ".", "String", "(", "\"", "\"", ")", "\n\n", "return", "s", ".", "clone", "(", "ctx", ",", "repo", ",", "mount", ",", "path", ")", "\n", "}" ]

[ "Clone", "will", "fetch", "and", "mount", "a", "new", "password", "store", "from", "a", "git", "repo" ]

[ "func", "(", "kl", "KeyList", ")", "Recipients", "(", ")", "[", "]", "string", "{", "l", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "kl", ")", ")", "\n", "for", "_", ",", "k", ":=", "range", "kl", "{", "l", "=", "append", "(", "l", ",", "k", ".", "ID", "(", ")", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "l", ")", "\n", "return", "l", "\n", "}" ]

[ "Recipients", "returns", "the", "KeyList", "formatted", "as", "a", "recipient", "list" ]

[ "func", "(", "kl", "KeyList", ")", "FindKey", "(", "id", "string", ")", "(", "Key", ",", "error", ")", "{", "id", "=", "strings", ".", "TrimPrefix", "(", "id", ",", "\"", "\"", ")", "\n", "for", "_", ",", "k", ":=", "range", "kl", "{", "if", "k", ".", "Fingerprint", "==", "id", "{", "return", "k", ",", "nil", "\n", "}", "\n", "if", "strings", ".", "HasSuffix", "(", "k", ".", "Fingerprint", ",", "id", ")", "{", "return", "k", ",", "nil", "\n", "}", "\n", "for", "_", ",", "ident", ":=", "range", "k", ".", "Identities", "{", "if", "ident", ".", "Name", "==", "id", "{", "return", "k", ",", "nil", "\n", "}", "\n", "if", "ident", ".", "Email", "==", "id", "{", "return", "k", ",", "nil", "\n", "}", "\n", "}", "\n", "for", "sk", ":=", "range", "k", ".", "SubKeys", "{", "if", "strings", ".", "HasSuffix", "(", "sk", ",", "id", ")", "{", "return", "k", ",", "nil", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "Key", "{", "}", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}" ]

[ "FindKey", "will", "try", "to", "find", "the", "requested", "key" ]

[ "func", "(", "x", "*", "XC", ")", "EncryptStream", "(", "ctx", "context", ".", "Context", ",", "plaintext", "io", ".", "Reader", ",", "recipients", "[", "]", "string", ",", "ciphertext", "io", ".", "Writer", ")", "error", "{", "privKeyIDs", ":=", "x", ".", "secring", ".", "KeyIDs", "(", ")", "\n", "if", "len", "(", "privKeyIDs", ")", "<", "1", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "privKey", ":=", "x", ".", "secring", ".", "Get", "(", "privKeyIDs", "[", "0", "]", ")", "\n\n", "// generate session / encryption key", "var", "sessionKey", "[", "32", "]", "byte", "\n", "if", "_", ",", "err", ":=", "crypto_rand", ".", "Read", "(", "sessionKey", "[", ":", "]", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// encrypt the session key per recipient", "header", ",", "err", ":=", "x", ".", "encryptHeader", "(", "ctx", ",", "privKey", ",", "sessionKey", "[", ":", "]", ",", "recipients", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// create the encoder", "enc", ":=", "binary", ".", "NewEncoder", "(", "ciphertext", ")", "\n\n", "// write verion", "if", "err", ":=", "enc", ".", "Encode", "(", "0x1", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// write header", "if", "err", ":=", "enc", ".", "Encode", "(", "header", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// write body", "num", ":=", "0", "\n", "buf", ":=", "make", "(", "[", "]", "byte", ",", "chunkSizeMax", ")", "\n", "encbuf", ":=", "make", "(", "[", "]", "byte", ",", "8", ")", "\n", "for", "{", "n", ",", "err", ":=", "plaintext", ".", "Read", "(", "buf", ")", "\n", "if", "err", ":=", "x", ".", "encryptChunk", "(", "sessionKey", ",", "num", ",", "buf", "[", ":", "n", "]", ",", "encbuf", ",", "ciphertext", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "if", "err", "==", "io", ".", "EOF", "{", "return", "nil", "\n", "}", "\n", "return", "err", "\n", "}", "\n", "num", "++", "\n", "}", "\n", "}" ]

[ "EncryptStream", "encrypts", "the", "plaintext", "using", "a", "slightly", "modified", "on", "disk", "-", "format", "suitable", "for", "streaming" ]

[ "func", "(", "x", "*", "XC", ")", "DecryptStream", "(", "ctx", "context", ".", "Context", ",", "ciphertext", "io", ".", "Reader", ",", "plaintext", "io", ".", "Writer", ")", "error", "{", "dec", ":=", "binary", ".", "NewDecoder", "(", "ciphertext", ")", "\n\n", "// read version", "ver", ":=", "0", "\n", "if", "err", ":=", "dec", ".", "Decode", "(", "&", "ver", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "ver", "!=", "0x1", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "// read header", "header", ":=", "&", "xcpb", ".", "Header", "{", "}", "\n", "if", "err", ":=", "dec", ".", "Decode", "(", "header", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// try to find a suiteable decryption key in the header", "sk", ",", "err", ":=", "x", ".", "decryptSessionKey", "(", "ctx", ",", "header", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "var", "secretKey", "[", "32", "]", "byte", "\n", "copy", "(", "secretKey", "[", ":", "]", ",", "sk", ")", "\n\n", "// read body", "num", ":=", "0", "\n", "var", "buf", "[", "]", "byte", "\n", "br", ":=", "&", "byteReader", "{", "ciphertext", "}", "\n", "for", "{", "l", ",", "err", ":=", "stdbin", ".", "ReadUvarint", "(", "br", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "==", "io", ".", "EOF", "{", "return", "nil", "\n", "}", "\n", "return", "err", "\n", "}", "\n", "buf", "=", "make", "(", "[", "]", "byte", ",", "l", ")", "\n", "n", ",", "err", ":=", "br", ".", "Read", "(", "buf", ")", "\n", "if", "err", ":=", "x", ".", "decryptChunk", "(", "secretKey", ",", "num", ",", "buf", "[", ":", "n", "]", ",", "plaintext", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "if", "err", "==", "io", ".", "EOF", "{", "return", "nil", "\n", "}", "\n", "return", "err", "\n", "}", "\n", "num", "++", "\n", "}", "\n", "}" ]

[ "DecryptStream", "decrypts", "an", "stream", "encrypted", "with", "EncryptStream" ]

[ "func", "ExitError", "(", "ctx", "context", ".", "Context", ",", "exitCode", "int", ",", "err", "error", ",", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "error", "{", "if", "err", "!=", "nil", "{", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "cli", ".", "NewExitError", "(", "fmt", ".", "Sprintf", "(", "format", ",", "args", "...", ")", ",", "exitCode", ")", "\n", "}" ]

[ "ExitError", "returns", "a", "user", "friendly", "CLI", "error" ]

[ "func", "(", "s", "*", "Store", ")", "Set", "(", "ctx", "context", ".", "Context", ",", "name", "string", ",", "sec", "store", ".", "Secret", ")", "error", "{", "if", "strings", ".", "Contains", "(", "name", ",", "\"", "\"", ")", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n\n", "p", ":=", "s", ".", "passfile", "(", "name", ")", "\n\n", "if", "s", ".", "IsDir", "(", "ctx", ",", "name", ")", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n\n", "recipients", ",", "err", ":=", "s", ".", "useableKeys", "(", "ctx", ",", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "p", ")", "\n", "}", "\n\n", "// confirm recipients", "newRecipients", ",", "err", ":=", "GetRecipientFunc", "(", "ctx", ")", "(", "ctx", ",", "name", ",", "recipients", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "recipients", "=", "newRecipients", "\n\n", "// make sure the encryptor can decrypt later", "recipients", "=", "s", ".", "ensureOurKeyID", "(", "ctx", ",", "recipients", ")", "\n\n", "buf", ",", "err", ":=", "sec", ".", "Bytes", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "ciphertext", ",", "err", ":=", "s", ".", "crypto", ".", "Encrypt", "(", "ctx", ",", "buf", ",", "recipients", ")", "\n", "if", "err", "!=", "nil", "{", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "return", "store", ".", "ErrEncrypt", "\n", "}", "\n\n", "if", "err", ":=", "s", ".", "storage", ".", "Set", "(", "ctx", ",", "p", ",", "ciphertext", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// It is not possible to perform concurrent git add and git commit commands", "// so we need to skip this step when using concurrency and perform them", "// at the end of the batch processing.", "if", "ctxutil", ".", "HasConcurrency", "(", "ctx", ")", "{", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "p", ")", "\n", "return", "nil", "\n", "}", "\n\n", "if", "err", ":=", "s", ".", "rcs", ".", "Add", "(", "ctx", ",", "p", ")", ";", "err", "!=", "nil", "{", "if", "errors", ".", "Cause", "(", "err", ")", "==", "store", ".", "ErrGitNotInit", "{", "return", "nil", "\n", "}", "\n", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "p", ")", "\n", "}", "\n\n", "if", "!", "ctxutil", ".", "IsGitCommit", "(", "ctx", ")", "{", "return", "nil", "\n", "}", "\n\n", "return", "s", ".", "gitCommitAndPush", "(", "ctx", ",", "name", ")", "\n", "}" ]

[ "Set", "encodes", "and", "writes", "the", "cipertext", "of", "one", "entry", "to", "disk" ]

[ "func", "(", "s", "*", "Store", ")", "Move", "(", "ctx", "context", ".", "Context", ",", "from", ",", "to", "string", ")", "error", "{", "// recursive move?", "if", "s", ".", "IsDir", "(", "ctx", ",", "from", ")", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "content", ",", "err", ":=", "s", ".", "Get", "(", "ctx", ",", "from", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "from", ")", "\n", "}", "\n", "if", "err", ":=", "s", ".", "Set", "(", "WithReason", "(", "ctx", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "from", ",", "to", ")", ")", ",", "to", ",", "content", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "to", ")", "\n", "}", "\n", "if", "err", ":=", "s", ".", "Delete", "(", "ctx", ",", "from", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "from", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Move", "will", "move", "one", "entry", "from", "one", "location", "to", "another", ".", "Moving", "an", "entry", "will", "decode", "it", "from", "the", "old", "location", "encode", "it", "for", "the", "destination", "store", "with", "the", "right", "set", "of", "recipients", "and", "remove", "it", "from", "the", "old", "location", "afterwards", "." ]

[ "func", "(", "s", "*", "Store", ")", "delete", "(", "ctx", "context", ".", "Context", ",", "name", "string", ",", "recurse", "bool", ")", "error", "{", "path", ":=", "s", ".", "passfile", "(", "name", ")", "\n\n", "if", "recurse", "{", "if", "err", ":=", "s", ".", "deleteRecurse", "(", "ctx", ",", "name", ",", "path", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "if", "err", ":=", "s", ".", "deleteSingle", "(", "ctx", ",", "path", ")", ";", "err", "!=", "nil", "{", "if", "!", "recurse", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "if", "!", "ctxutil", ".", "IsGitCommit", "(", "ctx", ")", "{", "return", "nil", "\n", "}", "\n\n", "if", "err", ":=", "s", ".", "rcs", ".", "Commit", "(", "ctx", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", ")", ";", "err", "!=", "nil", "{", "if", "errors", ".", "Cause", "(", "err", ")", "==", "store", ".", "ErrGitNotInit", "{", "return", "nil", "\n", "}", "\n", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// abort if auto sync is not set", "if", "!", "IsAutoSync", "(", "ctx", ")", "{", "return", "nil", "\n", "}", "\n\n", "if", "err", ":=", "s", ".", "rcs", ".", "Push", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "if", "errors", ".", "Cause", "(", "err", ")", "==", "store", ".", "ErrGitNotInit", "||", "errors", ".", "Cause", "(", "err", ")", "==", "store", ".", "ErrGitNoRemote", "{", "return", "nil", "\n", "}", "\n", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "delete", "will", "either", "delete", "one", "file", "or", "an", "directory", "tree", "depending", "on", "the", "recurse", "flag" ]

[ "func", "New", "(", "ctx", "context", ".", "Context", ",", "cfg", "*", "config", ".", "Config", ",", "sv", "semver", ".", "Version", ")", "(", "*", "Action", ",", "error", ")", "{", "return", "newAction", "(", "ctx", ",", "cfg", ",", "sv", ")", "\n", "}" ]

[ "New", "returns", "a", "new", "Action", "wrapper" ]

[ "func", "(", "g", "*", "GPG", ")", "CreatePrivateKeyBatch", "(", "ctx", "context", ".", "Context", ",", "name", ",", "email", ",", "passphrase", "string", ")", "error", "{", "buf", ":=", "&", "bytes", ".", "Buffer", "{", "}", "\n", "// https://git.gnupg.org/cgi-bin/gitweb.cgi?p=gnupg.git;a=blob;f=doc/DETAILS;h=de0f21ccba60c3037c2a155156202df1cd098507;hb=refs/heads/STABLE-BRANCH-1-4#l716", "_", ",", "_", "=", "buf", ".", "WriteString", "(", "`%echo Generating a RSA/RSA key pair\nKey-Type: RSA\nKey-Length: 2048\nSubkey-Type: RSA\nSubkey-Length: 2048\nExpire-Date: 0\n`", ")", "\n", "_", ",", "_", "=", "buf", ".", "WriteString", "(", "\"", "\"", "+", "name", "+", "\"", "\\n", "\"", ")", "\n", "_", ",", "_", "=", "buf", ".", "WriteString", "(", "\"", "\"", "+", "email", "+", "\"", "\\n", "\"", ")", "\n", "_", ",", "_", "=", "buf", ".", "WriteString", "(", "\"", "\"", "+", "passphrase", "+", "\"", "\\n", "\"", ")", "\n\n", "args", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", "}", "\n", "cmd", ":=", "exec", ".", "CommandContext", "(", "ctx", ",", "g", ".", "binary", ",", "args", "...", ")", "\n", "cmd", ".", "Stdin", "=", "bytes", ".", "NewReader", "(", "buf", ".", "Bytes", "(", ")", ")", "\n", "cmd", ".", "Stdout", "=", "nil", "\n", "cmd", ".", "Stderr", "=", "nil", "\n\n", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "cmd", ".", "Path", ",", "cmd", ".", "Args", ")", "\n", "if", "err", ":=", "cmd", ".", "Run", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "cmd", ".", "Path", ",", "cmd", ".", "Args", ")", "\n", "}", "\n", "g", ".", "privKeys", "=", "nil", "\n", "g", ".", "pubKeys", "=", "nil", "\n", "return", "nil", "\n", "}" ]

[ "CreatePrivateKeyBatch", "will", "create", "a", "new", "GPG", "keypair", "in", "batch", "mode" ]

[ "func", "(", "g", "*", "GPG", ")", "CreatePrivateKey", "(", "ctx", "context", ".", "Context", ")", "error", "{", "args", ":=", "[", "]", "string", "{", "\"", "\"", "}", "\n", "cmd", ":=", "exec", ".", "CommandContext", "(", "ctx", ",", "g", ".", "binary", ",", "args", "...", ")", "\n", "cmd", ".", "Stdin", "=", "os", ".", "Stdin", "\n", "cmd", ".", "Stdout", "=", "os", ".", "Stdout", "\n", "cmd", ".", "Stderr", "=", "os", ".", "Stderr", "\n\n", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "cmd", ".", "Path", ",", "cmd", ".", "Args", ")", "\n", "if", "err", ":=", "cmd", ".", "Run", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "cmd", ".", "Path", ",", "cmd", ".", "Args", ")", "\n", "}", "\n\n", "g", ".", "privKeys", "=", "nil", "\n", "g", ".", "pubKeys", "=", "nil", "\n", "return", "nil", "\n", "}" ]

[ "CreatePrivateKey", "will", "create", "a", "new", "GPG", "key", "in", "interactive", "mode" ]

[ "func", "(", "g", "*", "Git", ")", "InitConfig", "(", "ctx", "context", ".", "Context", ",", "userName", ",", "userEmail", "string", ")", "error", "{", "if", "userName", "==", "\"", "\"", "||", "userEmail", "==", "\"", "\"", "||", "!", "strings", ".", "Contains", "(", "userEmail", ",", "\"", "\"", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "// set commit identity", "if", "err", ":=", "g", ".", "ConfigSet", "(", "ctx", ",", "\"", "\"", ",", "userName", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "g", ".", "ConfigSet", "(", "ctx", ",", "\"", "\"", ",", "userEmail", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// ensure sane git config", "if", "err", ":=", "g", ".", "fixConfig", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", ":=", "ioutil", ".", "WriteFile", "(", "filepath", ".", "Join", "(", "g", ".", "path", ",", "\"", "\"", ")", ",", "[", "]", "byte", "(", "\"", "\\n", "\"", ")", ",", "fileMode", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "err", ":=", "g", ".", "Add", "(", "ctx", ",", "g", ".", "path", "+", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "out", ".", "Yellow", "(", "ctx", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "g", ".", "Commit", "(", "ctx", ",", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "out", ".", "Yellow", "(", "ctx", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "InitConfig", "initialized", "and", "preparse", "the", "git", "config" ]

[ "func", "(", "g", "*", "Git", ")", "ConfigSet", "(", "ctx", "context", ".", "Context", ",", "key", ",", "value", "string", ")", "error", "{", "return", "g", ".", "Cmd", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "key", ",", "value", ")", "\n", "}" ]

[ "ConfigSet", "sets", "a", "local", "config", "value" ]

[ "func", "(", "g", "*", "Git", ")", "ConfigGet", "(", "ctx", "context", ".", "Context", ",", "key", "string", ")", "(", "string", ",", "error", ")", "{", "if", "!", "g", ".", "IsInitialized", "(", ")", "{", "return", "\"", "\"", ",", "store", ".", "ErrGitNotInit", "\n", "}", "\n\n", "buf", ":=", "&", "strings", ".", "Builder", "{", "}", "\n\n", "cmd", ":=", "exec", ".", "CommandContext", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "key", ")", "\n", "cmd", ".", "Dir", "=", "g", ".", "path", "\n", "cmd", ".", "Stdout", "=", "buf", "\n", "cmd", ".", "Stderr", "=", "os", ".", "Stderr", "\n\n", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "cmd", ".", "Path", ",", "cmd", ".", "Args", ")", "\n", "if", "err", ":=", "cmd", ".", "Run", "(", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "strings", ".", "TrimSpace", "(", "buf", ".", "String", "(", ")", ")", ",", "nil", "\n", "}" ]

[ "ConfigGet", "returns", "a", "given", "config", "value" ]

[ "func", "(", "g", "*", "Git", ")", "ConfigList", "(", "ctx", "context", ".", "Context", ")", "(", "map", "[", "string", "]", "string", ",", "error", ")", "{", "if", "!", "g", ".", "IsInitialized", "(", ")", "{", "return", "nil", ",", "store", ".", "ErrGitNotInit", "\n", "}", "\n\n", "buf", ":=", "&", "strings", ".", "Builder", "{", "}", "\n\n", "cmd", ":=", "exec", ".", "CommandContext", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "cmd", ".", "Dir", "=", "g", ".", "path", "\n", "cmd", ".", "Stdout", "=", "buf", "\n", "cmd", ".", "Stderr", "=", "os", ".", "Stderr", "\n\n", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "cmd", ".", "Path", ",", "cmd", ".", "Args", ")", "\n", "if", "err", ":=", "cmd", ".", "Run", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "lines", ":=", "strings", ".", "Split", "(", "buf", ".", "String", "(", ")", ",", "\"", "\\n", "\"", ")", "\n", "kv", ":=", "make", "(", "map", "[", "string", "]", "string", ",", "len", "(", "lines", ")", ")", "\n", "for", "_", ",", "line", ":=", "range", "lines", "{", "line", "=", "strings", ".", "TrimSpace", "(", "line", ")", "\n", "p", ":=", "strings", ".", "SplitN", "(", "line", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "p", ")", "<", "2", "{", "continue", "\n", "}", "\n", "kv", "[", "p", "[", "0", "]", "]", "=", "p", "[", "1", "]", "\n", "}", "\n", "return", "kv", ",", "nil", "\n", "}" ]

[ "ConfigList", "returns", "all", "git", "config", "settings" ]

[ "func", "(", "s", "*", "Action", ")", "RecipientsPrint", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "out", ".", "Cyan", "(", "ctx", ",", "\"", "\"", ")", "\n\n", "tree", ",", "err", ":=", "s", ".", "Store", ".", "RecipientsTree", "(", "ctx", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ExitError", "(", "ctx", ",", "ExitList", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "fmt", ".", "Fprintln", "(", "stdout", ",", "tree", ".", "Format", "(", "0", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "RecipientsPrint", "prints", "all", "recipients", "per", "store" ]

[ "func", "(", "s", "*", "Action", ")", "RecipientsComplete", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "{", "tree", ",", "err", ":=", "s", ".", "Store", ".", "RecipientsTree", "(", "out", ".", "WithHidden", "(", "ctx", ",", "true", ")", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintln", "(", "stdout", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "for", "_", ",", "v", ":=", "range", "tree", ".", "List", "(", "0", ")", "{", "fmt", ".", "Fprintln", "(", "stdout", ",", "v", ")", "\n", "}", "\n", "}" ]

[ "RecipientsComplete", "will", "print", "a", "list", "of", "recipients", "for", "bash", "completion" ]

[ "func", "(", "s", "*", "Action", ")", "RecipientsAdd", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "store", ":=", "c", ".", "String", "(", "\"", "\"", ")", "\n", "force", ":=", "c", ".", "Bool", "(", "\"", "\"", ")", "\n", "added", ":=", "0", "\n\n", "// select store", "if", "store", "==", "\"", "\"", "{", "store", "=", "cui", ".", "AskForStore", "(", "ctx", ",", "s", ".", "Store", ")", "\n", "}", "\n\n", "crypto", ":=", "s", ".", "Store", ".", "Crypto", "(", "ctx", ",", "store", ")", "\n\n", "// select recipient", "recipients", ":=", "[", "]", "string", "(", "c", ".", "Args", "(", ")", ")", "\n", "if", "len", "(", "recipients", ")", "<", "1", "{", "r", ",", "err", ":=", "s", ".", "recipientsSelectForAdd", "(", "ctx", ",", "store", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "recipients", "=", "r", "\n", "}", "\n\n", "for", "_", ",", "r", ":=", "range", "recipients", "{", "keys", ",", "err", ":=", "crypto", ".", "FindPublicKeys", "(", "ctx", ",", "r", ")", "\n", "if", "err", "!=", "nil", "{", "out", ".", "Cyan", "(", "ctx", ",", "\"", "\"", ",", "r", ",", "err", ")", "\n", "if", "!", "force", "{", "continue", "\n", "}", "\n", "keys", "=", "[", "]", "string", "{", "r", "}", "\n", "}", "\n", "if", "len", "(", "keys", ")", "<", "1", "&&", "!", "force", "{", "out", ".", "Cyan", "(", "ctx", ",", "\"", "\"", ")", "\n", "out", ".", "Cyan", "(", "ctx", ",", "\"", "\"", ",", "r", ")", "\n", "out", ".", "Cyan", "(", "ctx", ",", "\"", "\"", ",", "r", ")", "\n", "out", ".", "Cyan", "(", "ctx", ",", "\"", "\"", ")", "\n", "continue", "\n", "}", "\n\n", "recp", ":=", "r", "\n", "if", "len", "(", "keys", ")", ">", "0", "{", "recp", "=", "crypto", ".", "Fingerprint", "(", "ctx", ",", "keys", "[", "0", "]", ")", "\n", "}", "\n\n", "if", "!", "termio", ".", "AskForConfirmation", "(", "ctx", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "crypto", ".", "FormatKey", "(", "ctx", ",", "recp", ")", ",", "store", ")", ")", "{", "continue", "\n", "}", "\n\n", "if", "err", ":=", "s", ".", "Store", ".", "AddRecipient", "(", "ctxutil", ".", "WithNoConfirm", "(", "ctx", ",", "true", ")", ",", "store", ",", "recp", ")", ";", "err", "!=", "nil", "{", "return", "ExitError", "(", "ctx", ",", "ExitRecipients", ",", "err", ",", "\"", "\"", ",", "r", ",", "err", ")", "\n", "}", "\n", "added", "++", "\n", "}", "\n", "if", "added", "<", "1", "{", "return", "ExitError", "(", "ctx", ",", "ExitUnknown", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n\n", "out", ".", "Green", "(", "ctx", ",", "\"", "\\n", "\"", ",", "added", ")", "\n", "out", ".", "Cyan", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "nil", "\n", "}" ]

[ "RecipientsAdd", "adds", "new", "recipients" ]

[ "func", "(", "s", "*", "Action", ")", "RecipientsRemove", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "store", ":=", "c", ".", "String", "(", "\"", "\"", ")", "\n", "force", ":=", "c", ".", "Bool", "(", "\"", "\"", ")", "\n", "removed", ":=", "0", "\n\n", "// select store", "if", "store", "==", "\"", "\"", "{", "store", "=", "cui", ".", "AskForStore", "(", "ctx", ",", "s", ".", "Store", ")", "\n", "}", "\n\n", "crypto", ":=", "s", ".", "Store", ".", "Crypto", "(", "ctx", ",", "store", ")", "\n\n", "// select recipient", "recipients", ":=", "[", "]", "string", "(", "c", ".", "Args", "(", ")", ")", "\n", "if", "len", "(", "recipients", ")", "<", "1", "{", "rs", ",", "err", ":=", "s", ".", "recipientsSelectForRemoval", "(", "ctx", ",", "store", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "recipients", "=", "rs", "\n", "}", "\n\n", "for", "_", ",", "r", ":=", "range", "recipients", "{", "kl", ",", "err", ":=", "crypto", ".", "FindPrivateKeys", "(", "ctx", ",", "r", ")", "\n", "if", "err", "==", "nil", "{", "if", "len", "(", "kl", ")", ">", "0", "{", "if", "!", "termio", ".", "AskForConfirmation", "(", "ctx", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "r", ")", ")", "{", "continue", "\n", "}", "\n", "}", "\n", "}", "\n\n", "keys", ",", "err", ":=", "crypto", ".", "FindPublicKeys", "(", "ctx", ",", "r", ")", "\n", "if", "err", "!=", "nil", "{", "out", ".", "Cyan", "(", "ctx", ",", "\"", "\"", ",", "r", ",", "err", ")", "\n", "if", "!", "force", "{", "continue", "\n", "}", "\n", "keys", "=", "[", "]", "string", "{", "r", "}", "\n", "}", "\n", "if", "len", "(", "keys", ")", "<", "1", "&&", "!", "force", "{", "out", ".", "Cyan", "(", "ctx", ",", "\"", "\"", ")", "\n", "out", ".", "Cyan", "(", "ctx", ",", "\"", "\"", ",", "r", ")", "\n", "out", ".", "Cyan", "(", "ctx", ",", "\"", "\"", ",", "r", ")", "\n", "out", ".", "Cyan", "(", "ctx", ",", "\"", "\"", ")", "\n", "continue", "\n", "}", "\n\n", "recp", ":=", "r", "\n", "if", "len", "(", "keys", ")", ">", "0", "{", "recp", "=", "crypto", ".", "Fingerprint", "(", "ctx", ",", "keys", "[", "0", "]", ")", "\n", "}", "\n\n", "if", "err", ":=", "s", ".", "Store", ".", "RemoveRecipient", "(", "ctxutil", ".", "WithNoConfirm", "(", "ctx", ",", "true", ")", ",", "store", ",", "recp", ")", ";", "err", "!=", "nil", "{", "return", "ExitError", "(", "ctx", ",", "ExitRecipients", ",", "err", ",", "\"", "\"", ",", "recp", ",", "err", ")", "\n", "}", "\n", "fmt", ".", "Fprintf", "(", "stdout", ",", "removalWarning", ",", "r", ")", "\n", "removed", "++", "\n", "}", "\n", "if", "removed", "<", "1", "{", "return", "ExitError", "(", "ctx", ",", "ExitUnknown", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n\n", "out", ".", "Green", "(", "ctx", ",", "\"", "\\n", "\"", ",", "removed", ")", "\n", "out", ".", "Cyan", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "nil", "\n", "}" ]

[ "RecipientsRemove", "removes", "recipients" ]

[ "func", "(", "s", "*", "Action", ")", "RecipientsUpdate", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "changed", ":=", "0", "\n\n", "mps", ":=", "s", ".", "Store", ".", "MountPoints", "(", ")", "\n", "sort", ".", "Sort", "(", "store", ".", "ByPathLen", "(", "mps", ")", ")", "\n", "for", "_", ",", "alias", ":=", "range", "append", "(", "mps", ",", "\"", "\"", ")", "{", "subs", ",", "err", ":=", "s", ".", "Store", ".", "GetSubStore", "(", "alias", ")", "\n", "if", "err", "!=", "nil", "||", "subs", "==", "nil", "{", "continue", "\n", "}", "\n", "recp", ",", "err", ":=", "subs", ".", "GetRecipients", "(", "ctx", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "!=", "sub", ".", "ErrRecipientChecksumChanged", "{", "return", "err", "\n", "}", "\n", "}", "\n", "if", "err", "==", "nil", "&&", "s", ".", "cfg", ".", "GetRecipientHash", "(", "alias", ",", "subs", ".", "Crypto", "(", ")", ".", "IDFile", "(", ")", ")", "!=", "\"", "\"", "{", "continue", "\n", "}", "\n", "if", "alias", "==", "\"", "\"", "{", "alias", "=", "\"", "\"", "\n", "}", "\n", "out", ".", "Cyan", "(", "ctx", ",", "\"", "\"", ",", "alias", ")", "\n", "for", "_", ",", "r", ":=", "range", "recp", "{", "out", ".", "Print", "(", "ctx", ",", "\"", "\"", ",", "subs", ".", "Crypto", "(", ")", ".", "FormatKey", "(", "ctx", ",", "r", ")", ")", "\n", "}", "\n", "if", "!", "termio", ".", "AskForConfirmation", "(", "ctx", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "alias", ")", ")", "{", "continue", "\n", "}", "\n", "if", "err", ":=", "subs", ".", "SetRecipients", "(", "ctx", ",", "recp", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "out", ".", "Print", "(", "ctx", ",", "\"", "\"", ")", "\n", "changed", "++", "\n", "}", "\n\n", "if", "changed", ">", "0", "{", "out", ".", "Green", "(", "ctx", ",", "\"", "\"", ",", "changed", ")", "\n", "}", "else", "{", "out", ".", "Green", "(", "ctx", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "RecipientsUpdate", "will", "recompute", "and", "update", "any", "changed", "recipients", "list", "checksums" ]

[ "func", "(", "s", "*", "Action", ")", "OTP", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "name", ":=", "c", ".", "Args", "(", ")", ".", "First", "(", ")", "\n", "if", "name", "==", "\"", "\"", "{", "return", "ExitError", "(", "ctx", ",", "ExitUsage", ",", "nil", ",", "\"", "\"", ",", "s", ".", "Name", ")", "\n", "}", "\n\n", "qrf", ":=", "c", ".", "String", "(", "\"", "\"", ")", "\n", "clip", ":=", "c", ".", "Bool", "(", "\"", "\"", ")", "\n\n", "return", "s", ".", "otp", "(", "ctx", ",", "c", ",", "name", ",", "qrf", ",", "clip", ",", "true", ")", "\n", "}" ]

[ "OTP", "implements", "OTP", "token", "handling", "for", "TOTP", "and", "HOTP" ]

[ "func", "(", "x", "*", "XC", ")", "Decrypt", "(", "ctx", "context", ".", "Context", ",", "buf", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "// unmarshal the protobuf message, the header and body are still encrypted", "// afterwards (parts of the header are plaintext!)", "msg", ":=", "&", "xcpb", ".", "Message", "{", "}", "\n", "if", "err", ":=", "proto", ".", "Unmarshal", "(", "buf", ",", "msg", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// try to find a suiteable decryption key in the header", "sk", ",", "err", ":=", "x", ".", "decryptSessionKey", "(", "ctx", ",", "msg", ".", "Header", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "secretKey", "[", "32", "]", "byte", "\n", "copy", "(", "secretKey", "[", ":", "]", ",", "sk", ")", "\n\n", "plainBuf", ":=", "&", "bytes", ".", "Buffer", "{", "}", "\n\n", "for", "i", ",", "chunk", ":=", "range", "msg", ".", "Chunks", "{", "// reconstruct nonce from chunk number", "// in case chunks have been reordered by some adversary", "// decryption will fail", "var", "nonce", "[", "24", "]", "byte", "\n", "binary", ".", "BigEndian", ".", "PutUint64", "(", "nonce", "[", ":", "]", ",", "uint64", "(", "i", ")", ")", "\n\n", "// decrypt and verify the ciphertext", "//plaintext, err := cp.Open(nil, nonce, chunk.Body, nil)", "plaintext", ",", "ok", ":=", "secretbox", ".", "Open", "(", "nil", ",", "chunk", ".", "Body", ",", "&", "nonce", ",", "&", "secretKey", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "plainBuf", ".", "Write", "(", "plaintext", ")", "\n", "}", "\n\n", "if", "!", "msg", ".", "Compressed", "{", "return", "plainBuf", ".", "Bytes", "(", ")", ",", "nil", "\n", "}", "\n\n", "return", "decompress", "(", "plainBuf", ".", "Bytes", "(", ")", ")", "\n", "}" ]

[ "Decrypt", "tries", "to", "decrypt", "the", "given", "ciphertext", "and", "returns", "the", "plaintext" ]

[ "func", "(", "x", "*", "XC", ")", "findDecryptionKey", "(", "hdr", "*", "xcpb", ".", "Header", ")", "(", "*", "keyring", ".", "PrivateKey", ",", "error", ")", "{", "for", "_", ",", "pk", ":=", "range", "x", ".", "secring", ".", "KeyIDs", "(", ")", "{", "if", "_", ",", "found", ":=", "hdr", ".", "Recipients", "[", "pk", "]", ";", "found", "{", "return", "x", ".", "secring", ".", "Get", "(", "pk", ")", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "hdr", ".", "Recipients", ")", "\n", "}" ]

[ "findDecryptionKey", "tries", "to", "find", "a", "suiteable", "decryption", "key", "from", "the", "available", "decryption", "keys", "and", "the", "recipients" ]

[ "func", "(", "x", "*", "XC", ")", "findPublicKey", "(", "needle", "string", ")", "(", "*", "keyring", ".", "PublicKey", ",", "error", ")", "{", "for", "_", ",", "id", ":=", "range", "x", ".", "pubring", ".", "KeyIDs", "(", ")", "{", "if", "id", "==", "needle", "{", "return", "x", ".", "pubring", ".", "Get", "(", "id", ")", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "needle", ")", "\n", "}" ]

[ "findPublicKey", "tries", "to", "find", "a", "given", "public", "key", "in", "the", "keyring" ]

[ "func", "(", "x", "*", "XC", ")", "decryptPrivateKey", "(", "ctx", "context", ".", "Context", ",", "recp", "*", "keyring", ".", "PrivateKey", ")", "error", "{", "fp", ":=", "recp", ".", "Fingerprint", "(", ")", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "maxUnlockAttempts", ";", "i", "++", "{", "// retry asking for key in case it's wrong", "passphrase", ",", "err", ":=", "x", ".", "client", ".", "Passphrase", "(", "ctx", ",", "fp", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "recp", ".", "Fingerprint", "(", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "err", "=", "recp", ".", "Decrypt", "(", "passphrase", ")", ";", "err", "==", "nil", "{", "// passphrase is correct, the key should now be decrypted", "return", "nil", "\n", "}", "\n\n", "// decryption failed, clear cache and wait a moment before trying again", "if", "err", ":=", "x", ".", "client", ".", "Remove", "(", "ctx", ",", "fp", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "time", ".", "Sleep", "(", "10", "*", "time", ".", "Millisecond", ")", "\n", "}", "\n\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "fp", ",", "maxUnlockAttempts", ")", "\n", "}" ]

[ "decryptPrivateKey", "will", "ask", "the", "agent", "to", "unlock", "the", "private", "key" ]

[ "func", "(", "x", "*", "XC", ")", "decryptSessionKey", "(", "ctx", "context", ".", "Context", ",", "hdr", "*", "xcpb", ".", "Header", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "// find a suiteable decryption key, i.e. a recipient entry which was encrypted", "// for one of our private keys", "recp", ",", "err", ":=", "x", ".", "findDecryptionKey", "(", "hdr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// we need the senders public key to decrypt/verify the message, since the", "// box algorithm ties successful decryption to successful verification", "sender", ",", "err", ":=", "x", ".", "findPublicKey", "(", "hdr", ".", "Sender", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "hdr", ".", "Sender", ")", "\n", "}", "\n\n", "// unlock recipient key", "if", "err", ":=", "x", ".", "decryptPrivateKey", "(", "ctx", ",", "recp", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// this is the per recipient ciphertext, we need to decrypt it to extract", "// the session key", "ciphertext", ":=", "hdr", ".", "Recipients", "[", "recp", ".", "Fingerprint", "(", ")", "]", "\n\n", "// since box works with byte arrays (or: pointers thereof) we need to copy", "// the slice to fixed arrays", "var", "nonce", "[", "24", "]", "byte", "\n", "copy", "(", "nonce", "[", ":", "]", ",", "ciphertext", "[", ":", "24", "]", ")", "\n\n", "var", "privKey", "[", "32", "]", "byte", "\n", "pk", ":=", "recp", ".", "PrivateKey", "(", ")", "\n", "copy", "(", "privKey", "[", ":", "]", ",", "pk", "[", ":", "]", ")", "\n\n", "// now we can try to decrypt/verify the ciphertext. unfortunately box doesn't give", "// us any diagnostic information in case it fails, i.e. we can't discern between", "// a failed decryption and a failed verification", "decrypted", ",", "ok", ":=", "box", ".", "Open", "(", "nil", ",", "ciphertext", "[", "24", ":", "]", ",", "&", "nonce", ",", "&", "sender", ".", "PublicKey", ",", "&", "privKey", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "decrypted", ",", "nil", "\n", "}" ]

[ "decryptSessionKey", "will", "attempt", "to", "find", "a", "readable", "recipient", "entry", "in", "the", "header", "and", "decrypt", "it", "s", "session", "key" ]

[ "func", "(", "s", "*", "Action", ")", "MountRemove", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "if", "len", "(", "c", ".", "Args", "(", ")", ")", "!=", "1", "{", "return", "ExitError", "(", "ctx", ",", "ExitUsage", ",", "nil", ",", "\"", "\"", ",", "s", ".", "Name", ")", "\n", "}", "\n\n", "if", "err", ":=", "s", ".", "Store", ".", "RemoveMount", "(", "ctx", ",", "c", ".", "Args", "(", ")", "[", "0", "]", ")", ";", "err", "!=", "nil", "{", "out", ".", "Error", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "s", ".", "cfg", ".", "Save", "(", ")", ";", "err", "!=", "nil", "{", "return", "ExitError", "(", "ctx", ",", "ExitConfig", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "out", ".", "Green", "(", "ctx", ",", "\"", "\"", ",", "c", ".", "Args", "(", ")", "[", "0", "]", ")", "\n", "return", "nil", "\n", "}" ]

[ "MountRemove", "removes", "an", "existing", "mount" ]

[ "func", "(", "s", "*", "Action", ")", "MountsPrint", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "if", "len", "(", "s", ".", "Store", ".", "Mounts", "(", ")", ")", "<", "1", "{", "out", ".", "Cyan", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n\n", "root", ":=", "simple", ".", "New", "(", "color", ".", "GreenString", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "s", ".", "Store", ".", "Path", "(", ")", ")", ")", ")", "\n", "mounts", ":=", "s", ".", "Store", ".", "Mounts", "(", ")", "\n", "mps", ":=", "s", ".", "Store", ".", "MountPoints", "(", ")", "\n", "sort", ".", "Sort", "(", "store", ".", "ByPathLen", "(", "mps", ")", ")", "\n", "for", "_", ",", "alias", ":=", "range", "mps", "{", "path", ":=", "mounts", "[", "alias", "]", "\n", "if", "err", ":=", "root", ".", "AddMount", "(", "alias", ",", "path", ")", ";", "err", "!=", "nil", "{", "out", ".", "Error", "(", "ctx", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "fmt", ".", "Fprintln", "(", "stdout", ",", "root", ".", "Format", "(", "0", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "MountsPrint", "prints", "all", "existing", "mounts" ]

[ "func", "(", "s", "*", "Action", ")", "MountsComplete", "(", "*", "cli", ".", "Context", ")", "{", "for", "alias", ":=", "range", "s", ".", "Store", ".", "Mounts", "(", ")", "{", "fmt", ".", "Fprintln", "(", "stdout", ",", "alias", ")", "\n", "}", "\n", "}" ]

[ "MountsComplete", "will", "print", "a", "list", "of", "existings", "mount", "points", "for", "bash", "completion" ]

[ "func", "(", "s", "*", "Action", ")", "MountAdd", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "alias", ":=", "c", ".", "Args", "(", ")", ".", "Get", "(", "0", ")", "\n", "localPath", ":=", "c", ".", "Args", "(", ")", ".", "Get", "(", "1", ")", "\n", "if", "alias", "==", "\"", "\"", "{", "return", "ExitError", "(", "ctx", ",", "ExitUsage", ",", "nil", ",", "\"", "\"", ",", "s", ".", "Name", ")", "\n", "}", "\n\n", "if", "localPath", "==", "\"", "\"", "{", "localPath", "=", "config", ".", "PwStoreDir", "(", "alias", ")", "\n", "}", "\n\n", "keys", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "1", ")", "\n", "if", "k", ":=", "c", ".", "String", "(", "\"", "\"", ")", ";", "k", "!=", "\"", "\"", "{", "keys", "=", "append", "(", "keys", ",", "k", ")", "\n", "}", "\n\n", "if", "s", ".", "Store", ".", "Exists", "(", "ctx", ",", "alias", ")", "{", "out", ".", "Yellow", "(", "ctx", ",", "\"", "\"", ",", "alias", ")", "\n", "}", "\n\n", "if", "err", ":=", "s", ".", "Store", ".", "AddMount", "(", "ctx", ",", "alias", ",", "localPath", ",", "keys", "...", ")", ";", "err", "!=", "nil", "{", "switch", "e", ":=", "errors", ".", "Cause", "(", "err", ")", ".", "(", "type", ")", "{", "case", "root", ".", "AlreadyMountedError", ":", "out", ".", "Print", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "nil", "\n", "case", "root", ".", "NotInitializedError", ":", "out", ".", "Print", "(", "ctx", ",", "\"", "\"", ",", "e", ".", "Alias", "(", ")", ")", "\n", "if", "err", ":=", "s", ".", "init", "(", "ctx", ",", "e", ".", "Alias", "(", ")", ",", "e", ".", "Path", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "ExitError", "(", "ctx", ",", "ExitUnknown", ",", "err", ",", "\"", "\"", ",", "e", ".", "Alias", "(", ")", ",", "err", ")", "\n", "}", "\n", "default", ":", "return", "ExitError", "(", "ctx", ",", "ExitMount", ",", "err", ",", "\"", "\"", ",", "alias", ",", "localPath", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "s", ".", "cfg", ".", "Save", "(", ")", ";", "err", "!=", "nil", "{", "return", "ExitError", "(", "ctx", ",", "ExitConfig", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "out", ".", "Green", "(", "ctx", ",", "\"", "\"", ",", "alias", ",", "localPath", ")", "\n", "return", "nil", "\n", "}" ]

[ "MountAdd", "adds", "a", "new", "mount" ]

[ "func", "(", "m", "*", "Mocker", ")", "FindPublicKeys", "(", "ctx", "context", ".", "Context", ",", "keys", "...", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "rs", ":=", "staticPrivateKeyList", ".", "Recipients", "(", ")", "\n", "res", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "rs", ")", ")", "\n", "for", "_", ",", "r", ":=", "range", "rs", "{", "for", "_", ",", "needle", ":=", "range", "keys", "{", "if", "strings", ".", "HasSuffix", "(", "r", ",", "needle", ")", "{", "res", "=", "append", "(", "res", ",", "r", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "FindPublicKeys", "does", "nothing" ]

[ "func", "(", "m", "*", "Mocker", ")", "RecipientIDs", "(", "context", ".", "Context", ",", "[", "]", "byte", ")", "(", "[", "]", "string", ",", "error", ")", "{", "return", "staticPrivateKeyList", ".", "Recipients", "(", ")", ",", "nil", "\n", "}" ]

[ "RecipientIDs", "does", "nothing" ]

[ "func", "(", "m", "*", "Mocker", ")", "Encrypt", "(", "ctx", "context", ".", "Context", ",", "content", "[", "]", "byte", ",", "recipients", "[", "]", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "content", ",", "nil", "\n", "}" ]

[ "Encrypt", "writes", "the", "input", "to", "disk", "unaltered" ]

[ "func", "(", "m", "*", "Mocker", ")", "Decrypt", "(", "ctx", "context", ".", "Context", ",", "ciphertext", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "ciphertext", ",", "nil", "\n", "}" ]

[ "Decrypt", "read", "the", "file", "from", "disk", "unaltered" ]

[ "func", "(", "m", "*", "Mocker", ")", "Sign", "(", "ctx", "context", ".", "Context", ",", "in", "string", ",", "sigf", "string", ")", "error", "{", "buf", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "in", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "sum", ":=", "sha256", ".", "New", "(", ")", "\n", "_", ",", "_", "=", "sum", ".", "Write", "(", "buf", ")", "\n", "hexsum", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "sum", ".", "Sum", "(", "nil", ")", ")", "\n", "return", "ioutil", ".", "WriteFile", "(", "sigf", ",", "[", "]", "byte", "(", "hexsum", ")", ",", "0644", ")", "\n", "}" ]

[ "Sign", "writes", "the", "hashsum", "to", "the", "given", "file" ]

[ "func", "(", "m", "*", "Mocker", ")", "Verify", "(", "ctx", "context", ".", "Context", ",", "sigf", "string", ",", "in", "string", ")", "error", "{", "sigb", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "sigf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "buf", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "in", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "sum", ":=", "sha256", ".", "New", "(", ")", "\n", "_", ",", "_", "=", "sum", ".", "Write", "(", "buf", ")", "\n", "hexsum", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "sum", ".", "Sum", "(", "nil", ")", ")", "\n\n", "if", "string", "(", "sigb", ")", "!=", "hexsum", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Verify", "does", "a", "pseudo", "-", "verification" ]

[ "func", "(", "m", "*", "Mocker", ")", "ReadNamesFromKey", "(", "ctx", "context", ".", "Context", ",", "buf", "[", "]", "byte", ")", "(", "[", "]", "string", ",", "error", ")", "{", "return", "[", "]", "string", "{", "\"", "\"", "}", ",", "nil", "\n", "}" ]

[ "ReadNamesFromKey", "does", "nothing" ]

[ "func", "(", "l", "loader", ")", "Clone", "(", "ctx", "context", ".", "Context", ",", "repo", ",", "path", "string", ")", "(", "backend", ".", "RCS", ",", "error", ")", "{", "return", "Clone", "(", "ctx", ",", "repo", ",", "path", ")", "\n", "}" ]

[ "Clone", "implements", "backend", ".", "RCSLoader" ]

[ "func", "(", "g", "*", "GPG", ")", "ImportPublicKey", "(", "ctx", "context", ".", "Context", ",", "buf", "[", "]", "byte", ")", "error", "{", "if", "len", "(", "buf", ")", "<", "1", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "args", ":=", "append", "(", "g", ".", "args", ",", "\"", "\"", ")", "\n", "cmd", ":=", "exec", ".", "CommandContext", "(", "ctx", ",", "g", ".", "binary", ",", "args", "...", ")", "\n", "cmd", ".", "Stdin", "=", "bytes", ".", "NewReader", "(", "buf", ")", "\n", "cmd", ".", "Stdout", "=", "os", ".", "Stdout", "\n", "cmd", ".", "Stderr", "=", "os", ".", "Stderr", "\n\n", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "cmd", ".", "Path", ",", "cmd", ".", "Args", ")", "\n", "if", "err", ":=", "cmd", ".", "Run", "(", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "cmd", ".", "Path", ",", "cmd", ".", "Args", ")", "\n", "}", "\n\n", "// clear key cache", "g", ".", "privKeys", "=", "nil", "\n", "g", ".", "pubKeys", "=", "nil", "\n", "return", "nil", "\n", "}" ]

[ "ImportPublicKey", "will", "import", "a", "key", "from", "the", "given", "location" ]

[ "func", "Copy", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ",", "store", "storer", ")", "error", "{", "from", ":=", "c", ".", "Args", "(", ")", ".", "Get", "(", "0", ")", "\n", "to", ":=", "c", ".", "Args", "(", ")", ".", "Get", "(", "1", ")", "\n\n", "// argument checking is in s.binaryCopy", "if", "err", ":=", "binaryCopy", "(", "ctx", ",", "c", ",", "from", ",", "to", ",", "false", ",", "store", ")", ";", "err", "!=", "nil", "{", "return", "action", ".", "ExitError", "(", "ctx", ",", "action", ".", "ExitUnknown", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Copy", "copies", "either", "from", "the", "filesystem", "to", "the", "store", "or", "from", "the", "store", "to", "the", "filesystem" ]

[ "func", "(", "s", "*", "Action", ")", "Fsck", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "out", ".", "Print", "(", "ctx", ",", "\"", "\"", ")", "\n", "// make sure config is in the right place", "// we may have loaded it from one of the fallback locations", "if", "err", ":=", "s", ".", "cfg", ".", "Save", "(", ")", ";", "err", "!=", "nil", "{", "return", "ExitError", "(", "ctx", ",", "ExitConfig", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// clean up any previous config locations", "oldCfg", ":=", "filepath", ".", "Join", "(", "config", ".", "Homedir", "(", ")", ",", "\"", "\"", ")", "\n", "if", "fsutil", ".", "IsFile", "(", "oldCfg", ")", "{", "if", "err", ":=", "os", ".", "Remove", "(", "oldCfg", ")", ";", "err", "!=", "nil", "{", "out", ".", "Error", "(", "ctx", ",", "\"", "\"", ",", "oldCfg", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "// display progress bar", "t", ",", "err", ":=", "s", ".", "Store", ".", "Tree", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "ExitError", "(", "ctx", ",", "ExitUnknown", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "pwList", ":=", "t", ".", "List", "(", "0", ")", "\n\n", "bar", ":=", "&", "goprogressbar", ".", "ProgressBar", "{", "Total", ":", "int64", "(", "len", "(", "pwList", ")", "*", "2", ")", ",", "Width", ":", "120", ",", "}", "\n", "if", "out", ".", "IsHidden", "(", "ctx", ")", "{", "old", ":=", "goprogressbar", ".", "Stdout", "\n", "goprogressbar", ".", "Stdout", "=", "ioutil", ".", "Discard", "\n", "defer", "func", "(", ")", "{", "goprogressbar", ".", "Stdout", "=", "old", "\n", "}", "(", ")", "\n", "}", "\n\n", "ctx", "=", "ctxutil", ".", "WithProgressCallback", "(", "ctx", ",", "func", "(", ")", "{", "bar", ".", "Current", "++", "\n", "bar", ".", "Text", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "bar", ".", "Current", ",", "bar", ".", "Total", ")", "\n", "bar", ".", "LazyPrint", "(", ")", "\n", "}", ")", "\n", "ctx", "=", "out", ".", "AddPrefix", "(", "ctx", ",", "\"", "\\n", "\"", ")", "\n\n", "// the main work in done by the sub stores", "if", "err", ":=", "s", ".", "Store", ".", "Fsck", "(", "ctx", ",", "c", ".", "Args", "(", ")", ".", "Get", "(", "0", ")", ")", ";", "err", "!=", "nil", "{", "return", "ExitError", "(", "ctx", ",", "ExitFsck", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Fsck", "checks", "the", "store", "integrity" ]

[ "func", "Notify", "(", "ctx", "context", ".", "Context", ",", "subj", ",", "msg", "string", ")", "error", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "runtime", ".", "GOOS", ")", "\n", "}" ]

[ "Notify", "is", "not", "yet", "implemented", "on", "this", "platform" ]

[ "func", "(", "g", "*", "GPG", ")", "ExportPublicKey", "(", "ctx", "context", ".", "Context", ",", "id", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "id", "==", "\"", "\"", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "args", ":=", "append", "(", "g", ".", "args", ",", "\"", "\"", ",", "\"", "\"", ",", "id", ")", "\n", "cmd", ":=", "exec", ".", "CommandContext", "(", "ctx", ",", "g", ".", "binary", ",", "args", "...", ")", "\n\n", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "cmd", ".", "Path", ",", "cmd", ".", "Args", ")", "\n", "out", ",", "err", ":=", "cmd", ".", "Output", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "cmd", ".", "Path", ",", "cmd", ".", "Args", ")", "\n", "}", "\n\n", "if", "len", "(", "out", ")", "<", "1", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "out", ",", "nil", "\n", "}" ]

[ "ExportPublicKey", "will", "export", "the", "named", "public", "key", "to", "the", "location", "given" ]

[ "func", "parseTS", "(", "str", "string", ")", "time", ".", "Time", "{", "t", ":=", "time", ".", "Time", "{", "}", "\n\n", "if", "sec", ",", "err", ":=", "strconv", ".", "ParseInt", "(", "str", ",", "10", ",", "64", ")", ";", "err", "==", "nil", "{", "t", "=", "time", ".", "Unix", "(", "sec", ",", "0", ")", "\n", "}", "\n\n", "return", "t", "\n", "}" ]

[ "parseTS", "parses", "the", "passed", "string", "as", "an", "Epoch", "int", "and", "returns", "the", "time", "struct", "or", "the", "zero", "time", "struct" ]

[ "func", "parseInt", "(", "str", "string", ")", "int", "{", "i", ":=", "0", "\n\n", "if", "iv", ",", "err", ":=", "strconv", ".", "ParseInt", "(", "str", ",", "10", ",", "32", ")", ";", "err", "==", "nil", "{", "i", "=", "int", "(", "iv", ")", "\n", "}", "\n\n", "return", "i", "\n", "}" ]

[ "parseInt", "parses", "the", "passed", "string", "as", "an", "int", "and", "returns", "it", "or", "0", "on", "errors" ]

[ "func", "GPGOpts", "(", ")", "[", "]", "string", "{", "for", "_", ",", "en", ":=", "range", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", "}", "{", "if", "opts", ":=", "os", ".", "Getenv", "(", "en", ")", ";", "opts", "!=", "\"", "\"", "{", "return", "strings", ".", "Fields", "(", "opts", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GPGOpts", "parses", "extra", "GPG", "options", "from", "the", "environment" ]

[ "func", "(", "s", "*", "Store", ")", "Exists", "(", "ctx", "context", ".", "Context", ",", "name", "string", ")", "bool", "{", "_", ",", "err", ":=", "s", ".", "Get", "(", "ctx", ",", "name", ")", "\n", "return", "err", "==", "nil", "\n", "}" ]

[ "Exists", "checks", "if", "a", "given", "secret", "exists" ]

[ "func", "(", "s", "*", "Store", ")", "Get", "(", "ctx", "context", ".", "Context", ",", "name", "string", ")", "(", "store", ".", "Secret", ",", "error", ")", "{", "key", ":=", "path", ".", "Join", "(", "s", ".", "path", ",", "name", ")", "\n", "out", ".", "Debug", "(", "ctx", ",", "\"", "\"", ",", "name", ",", "key", ")", "\n", "sec", ",", "err", ":=", "s", ".", "api", ".", "Logical", "(", ")", ".", "Read", "(", "key", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "sec", "==", "nil", "||", "sec", ".", "Data", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "&", "Secret", "{", "d", ":", "sec", ".", "Data", "}", ",", "nil", "\n", "}" ]

[ "Get", "returns", "a", "secret" ]

[ "func", "(", "s", "*", "Store", ")", "Initialized", "(", "ctx", "context", ".", "Context", ")", "bool", "{", "_", ",", "err", ":=", "s", ".", "List", "(", "ctx", ",", "\"", "\"", ")", "\n", "return", "err", "==", "nil", "\n", "}" ]

[ "Initialized", "returns", "true", "if", "the", "backend", "can", "communicate", "with", "Vault" ]

[ "func", "(", "s", "*", "Store", ")", "IsDir", "(", "ctx", "context", ".", "Context", ",", "name", "string", ")", "bool", "{", "ls", ",", "err", ":=", "s", ".", "List", "(", "ctx", ",", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "return", "len", "(", "ls", ")", ">", "1", "\n", "}" ]

[ "IsDir", "returns", "true", "if", "the", "given", "name", "is", "a", "dir" ]

[ "func", "(", "s", "*", "Store", ")", "List", "(", "ctx", "context", ".", "Context", ",", "prefix", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "keys", ",", "err", ":=", "s", ".", "list", "(", "ctx", ",", "prefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "i", ",", "e", ":=", "range", "keys", "{", "keys", "[", "i", "]", "=", "path", ".", "Join", "(", "s", ".", "alias", ",", "e", ")", "\n", "}", "\n", "return", "keys", ",", "nil", "\n", "}" ]

[ "List", "returns", "a", "list", "of", "entries", "with", "the", "given", "prefix" ]

[ "func", "(", "s", "*", "Store", ")", "Move", "(", "ctx", "context", ".", "Context", ",", "from", "string", ",", "to", "string", ")", "error", "{", "// recursive move?", "if", "s", ".", "IsDir", "(", "ctx", ",", "from", ")", "{", "if", "s", ".", "Exists", "(", "ctx", ",", "to", ")", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "sf", ",", "err", ":=", "s", ".", "List", "(", "ctx", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "destPrefix", ":=", "to", "\n", "if", "s", ".", "IsDir", "(", "ctx", ",", "to", ")", "{", "destPrefix", "=", "filepath", ".", "Join", "(", "to", ",", "filepath", ".", "Base", "(", "from", ")", ")", "\n", "}", "\n", "for", "_", ",", "e", ":=", "range", "sf", "{", "if", "!", "strings", ".", "HasPrefix", "(", "e", ",", "strings", ".", "TrimSuffix", "(", "from", ",", "\"", "\"", ")", "+", "\"", "\"", ")", "{", "continue", "\n", "}", "\n", "et", ":=", "filepath", ".", "Join", "(", "destPrefix", ",", "strings", ".", "TrimPrefix", "(", "e", ",", "from", ")", ")", "\n", "if", "err", ":=", "s", ".", "Move", "(", "ctx", ",", "e", ",", "et", ")", ";", "err", "!=", "nil", "{", "out", ".", "Error", "(", "ctx", ",", "\"", "\"", ",", "e", ",", "et", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "content", ",", "err", ":=", "s", ".", "Get", "(", "ctx", ",", "from", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "from", ")", "\n", "}", "\n", "if", "err", ":=", "s", ".", "Set", "(", "ctx", ",", "to", ",", "content", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "to", ")", "\n", "}", "\n", "if", "err", ":=", "s", ".", "Delete", "(", "ctx", ",", "from", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "from", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Move", "moves", "one", "or", "many", "secrets" ]

[ "func", "(", "s", "*", "Store", ")", "Set", "(", "ctx", "context", ".", "Context", ",", "name", "string", ",", "sec", "store", ".", "Secret", ")", "error", "{", "d", ":=", "sec", ".", "Data", "(", ")", "\n", "if", "d", "==", "nil", "{", "d", "=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "1", ")", "\n", "}", "\n", "d", "[", "passwordKey", "]", "=", "sec", ".", "Password", "(", ")", "\n", "_", ",", "err", ":=", "s", ".", "api", ".", "Logical", "(", ")", ".", "Write", "(", "path", ".", "Join", "(", "s", ".", "path", ",", "name", ")", ",", "d", ")", "\n", "return", "err", "\n", "}" ]

[ "Set", "writes", "a", "secret" ]

[ "func", "(", "s", "*", "Store", ")", "Prune", "(", "ctx", "context", ".", "Context", ",", "name", "string", ")", "error", "{", "ls", ",", "err", ":=", "s", ".", "List", "(", "ctx", ",", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "_", ",", "e", ":=", "range", "ls", "{", "if", "err", ":=", "s", ".", "Delete", "(", "ctx", ",", "e", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Prune", "removes", "a", "directory", "tree" ]

[ "func", "AskForInt", "(", "ctx", "context", ".", "Context", ",", "text", "string", ",", "def", "int", ")", "(", "int", ",", "error", ")", "{", "if", "ctxutil", ".", "IsAlwaysYes", "(", "ctx", ")", "{", "return", "def", ",", "nil", "\n", "}", "\n\n", "str", ",", "err", ":=", "AskForString", "(", "ctx", ",", "text", ",", "strconv", ".", "Itoa", "(", "def", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "if", "str", "==", "\"", "\"", "{", "return", "0", ",", "ErrAborted", "\n", "}", "\n", "intVal", ",", "err", ":=", "strconv", ".", "Atoi", "(", "str", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "intVal", ",", "nil", "\n", "}" ]

[ "AskForInt", "asks", "for", "an", "valid", "interger", "once", ".", "If", "the", "input", "can", "not", "be", "converted", "to", "an", "int", "it", "returns", "an", "error" ]

[ "func", "AskForKeyImport", "(", "ctx", "context", ".", "Context", ",", "key", "string", ",", "names", "[", "]", "string", ")", "bool", "{", "if", "ctxutil", ".", "IsAlwaysYes", "(", "ctx", ")", "{", "return", "true", "\n", "}", "\n", "if", "!", "ctxutil", ".", "IsInteractive", "(", "ctx", ")", "{", "return", "false", "\n", "}", "\n\n", "ok", ",", "err", ":=", "AskForBool", "(", "ctx", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "key", ",", "names", ")", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n\n", "return", "ok", "\n", "}" ]

[ "AskForKeyImport", "asks", "for", "permissions", "to", "import", "the", "named", "key" ]

[ "func", "AskForPassword", "(", "ctx", "context", ".", "Context", ",", "name", "string", ")", "(", "string", ",", "error", ")", "{", "if", "ctxutil", ".", "IsAlwaysYes", "(", "ctx", ")", "{", "return", "\"", "\"", ",", "nil", "\n", "}", "\n\n", "askFn", ":=", "GetPassPromptFunc", "(", "ctx", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "maxTries", ";", "i", "++", "{", "// check for context cancelation", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "\"", "\"", ",", "ErrAborted", "\n", "default", ":", "}", "\n\n", "pass", ",", "err", ":=", "askFn", "(", "ctx", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "passAgain", ",", "err", ":=", "askFn", "(", "ctx", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "if", "pass", "==", "passAgain", "||", "pass", "==", "\"", "\"", "{", "return", "pass", ",", "nil", "\n", "}", "\n\n", "out", ".", "Error", "(", "ctx", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "AskForPassword", "prompts", "for", "a", "password", "twice", "until", "both", "match" ]