Introdução ao GoPass

O gopass é um poderoso gerenciador de senhas que você pode usar via terminal ou mesmo utilizar alguma aplicação gráfica, também está diponível para Android e iOS. Com ele você pode criar e armazenar as senhas de modo seguro.

A documentação usa bastante o termo password store para se referir ao local onde ficam as senhas, aqui vou chamar de cofre para facilitar.

Para este tutorial vou usar um cenário com 3 usuários (Alice, Bob e Jhon), ambos tendo acesso a mesma máquina (onde roda o Gopass), o backend de criptografia será sempre GPG. Vou demonstrar como usar o cofre tanto local como remoto, além de tentar dar algumas dicas.

Backends

O Gopass usa uma suíte de Backends, ou seja, são mecanismos que rodam em segundo plano fazendo com que seja possível usar diferentes métodos para armazenar as senhas e criptograr elas.

Armazenamento

O Armazenamento é o método que vamos usar para guardar as senhas, o gopass trabalha com três sistemas para armazenamento de senhas, sendo um deles experimental, então não falarei dele.

FS
É um método usado para armazenar senhas no File System, funciona como um sistema de armazenamento local e não possui compatibilidade com cofre remoto. Para acessar o cofre é necessário ter acesso a máquina onde o cofre se encontra.
A documentação informa ser mais usado para teste.

GITFS
É o método padrão de armazenamento, aqui podemos usar localmente (é necessário ter acesso a máquina para acessar o cofre).

O outro método é usar o GITFS como um armazenamento remoto, nesse caso vamos usar em conjunto com GIT (hub ou lab) para armazenar nosso cofre.
Assim como no FS, aqui os dados encriptados ficam armazenados diretamente no File System, com o benefício de usar o GIT para recursos de histórico e operações remotas de sincronização.

Criptografia

Para o método de encriptar as senhas existem três método também, sendo que um deles quase não é usado em produção, então não falarei dele.

GPGCLI
É o método de criptografia padrão, usa o GPG para encriptar as senhas (precisa ter o gnupg instalado e chaves para uso).

PLAIN
Esse método não usa criptografia, ou seja, as senhas ficam em texto puro, é usado mais para testes.

Recipients

O comando gopass possui um argumento que chama recipients, com ele vamos trabalhar em cima dos acessos (chaves GPG), permitindo que outras pessoas possam encriptar e decriptar as senhas do cofre. Vale lembrar que para adicionar uma chave GPG ela deve ter sido importada na sua conta.

# Listando as chaves GPG de todos os cofres:
$ gopass recipients 
Hint: run 'gopass sync' to import any missing public keys
gopass
├── 0xE09CFC975D39E4B4 - bob Tester <bob@foo.bar>
└── iduna (/usr/local/access/passwords)
    ├── 0xC709C8066BA395C6 - jhon Tester <jhon@foo.bar>
    ├── 0xD267A8A806C988EE - alice Tester <alice@foo.bar>
    └── 0xE09CFC975D39E4B4 - bob Tester <bob@foo.bar>

# Removendo uma chave no cofre teste:
$ gopass recipients rm --store teste joao

Em algumas versões do Gopass existe um bug ao remover uma chave, ao tentar remover é informado que a chave não está no repositório desejado, para isso, deve-se entrar na pasta do cofre e editar o aquivo .gpg-id e remover a chave manualmente, depois disso rode gopass sync.

Cofres

Existem dois tipos de cofres que podemos usar, um deles é o cofre compartilhado, onde outras pessoas terão acesso e requer uma configuração um pouco diferente dependendo do tipo de armazenamento e se vai ser somente local ou remoto.

O outro tipo é um cofre particular que usa GITFS e GPG, esse cofre é configurado quando rodamos o comando gopass setup, é então criado um cofre na home do usuário que somente ele terá acesso, até tem como adicionar outras pessoas mas isso envolve permissões então acaba sendo mais complicado (veremos isso na configuração de cofre local).

Instalação via pacote

Vamos fazer a instalação dos requisitos para uso do gopass e depois vamos baixar o pacote do gopass e fazer a instalação:

# Instalando dependências para o uso do Gopass:
sudo apt install git gnupg2 rng-tools

# Baixando pacote .deb do gopass:
wget https://github.com/gopasspw/gopass/releases/download/v1.14.0/gopass_1.14.0_linux_amd64.deb

# Instalando o gopass:
sudo dpkg -i gopass_1.14.0_linux_amd64.deb

Sempre faça a instalação via pacote.deb, pois o pacote no repositório não se trata desse mesmo gopass, segue mensagem dos próprios devs do Gopass:

WARNING: The official Debian repositories (and derived distributions) contain a package named gopass that is not related to this project in any way. It's a similar tool with a completely independent implementation and feature set. We are aware of this issue but can not do anything about it.

Instalação manual

Vamos ver como compilar o gopass:

# Instale o Go:
$ sudo apt update && sudo apt install golang-go golang -y

### Vamos atualizar o Go.

# Baixe a última versão:
$ wget https://go.dev/dl/go1.19.linux-amd64.tar.gz

# Descompacte:
$ sudo tar -xzf go1.19.linux-amd64.tar.gz

# Mova a pasta para o local correto:
$ sudo mv go /usr/lib/go-1.19

# Corrija o link para binário do Go:
$ sudo ln -sf /usr/lib/go-1.19/bin/go /usr/bin/go

# Crie um link chamado Go apontando para a pasta mais recente:
$ cd /usr/lib/ && sudo rm go && sudo ln -sf go-1.19 go

Agora vamos pegar o binário do Gopass compilando-o no processo:

# Mude como o Go vai importar os pacotes:
$ GO111MODULE='on'
$ export GO111MODULE='on'

# Altere o GOPATH para alocar o binário no '/tmp/bin/':
$ GOPATH=/tmp
$ export GOPATH=/tmp

# Obtenha o pacote usando o Gopass:
$ go install github.com/gopasspw/gopass@v1.9.0
go: downloading github.com/gopasspw/gopass v1.9.0
go: downloading github.com/blang/semver v0.0.0-20190414182527-1a9109f8c4a1
go: downloading github.com/fatih/color v1.9.0
go: downloading github.com/mattn/go-colorable v0.1.6
go: downloading github.com/urfave/cli/v2 v2.2.0
go: downloading golang.org/x/crypto v0.0.0-20200423211502-4bdfaf469ed5
go: downloading github.com/mattn/go-isatty v0.0.12
go: downloading github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51
go: downloading github.com/muesli/goprogressbar v0.0.0-20190807022807-e540249d2ac1
go: downloading github.com/pkg/errors v0.9.1
go: downloading github.com/schollz/closestmatch v0.0.0-20190308193919-1fbe626be92e
go: downloading github.com/martinhoefling/goxkcdpwgen v0.0.0-20190331205820-7dc3d102eca3
go: downloading github.com/mitchellh/go-homedir v1.1.0
go: downloading gopkg.in/yaml.v2 v2.2.8
go: downloading github.com/cpuguy83/go-md2man/v2 v2.0.0
go: downloading golang.org/x/sys v0.0.0-20200420163511-1957bb5e6d1f
go: downloading github.com/muesli/crunchy v0.4.0
go: downloading github.com/alecthomas/binary v0.0.0-20190922233330-fb1b1d9c299c
go: downloading google.golang.org/protobuf v1.21.0
go: downloading github.com/atotto/clipboard v0.1.2
go: downloading github.com/godbus/dbus v0.0.0-20190623212516-8a1682060722
go: downloading github.com/mitchellh/go-ps v1.0.0
go: downloading github.com/doronbehar/gocui v0.4.2
go: downloading github.com/cenkalti/backoff v2.2.1+incompatible
go: downloading golang.org/x/net v0.0.0-20200421231249-e086a090c8fd
go: downloading github.com/gokyle/twofactor v1.0.1
go: downloading github.com/skip2/go-qrcode v0.0.0-20191027152451-9434209cb086
go: downloading github.com/hashicorp/go-multierror v1.1.0
go: downloading github.com/jsimonetti/pwscheme v0.0.0-20160922125227-76804708ecad
go: downloading github.com/dominikschulz/github-releases v0.0.2
go: downloading github.com/hashicorp/golang-lru v0.5.4
go: downloading github.com/russross/blackfriday/v2 v2.0.1
go: downloading github.com/xrash/smetrics v0.0.0-20170218160415-a3153f7040e9
go: downloading github.com/golang/protobuf v1.4.0
go: downloading github.com/gdamore/tcell v1.3.0
go: downloading github.com/mattn/go-runewidth v0.0.9
go: downloading github.com/doronbehar/termbox-go v0.0.0-20191006141301-8c9470559e05
go: downloading rsc.io/qr v0.2.0
go: downloading github.com/hashicorp/errwrap v1.0.0
go: downloading github.com/shurcooL/sanitized_anchor_name v1.0.0
go: downloading github.com/gdamore/encoding v1.0.0
go: downloading github.com/lucasb-eyer/go-colorful v1.0.3
go: downloading golang.org/x/text v0.3.2

# Crie a pasta para alocar o binário do Gopass:
$ sudo mkdir -p /usr/local/bin/

# Mova o binário para a pasta recém criada:
$ sudo mv /tmp/bin/gopass /usr/local/bin/

Chave GPG

Vamos começar criando nossa chave gpg, lembrando que todos que forem usar o cofre também vão precisar de uma. As opções para a criação da chave vão ser:

1
Vamos usar o formato RSA and RSA
2048
O tamanho em bits da chave, irei escolher 2048.
0
A chave nunca vai expirar. Se for usar em produção recomendo uma data de expiração para a chave.
y
As informações acima estão corretas. Após isso deverá ser fornecido uma nome e um email para a chave (o comentário irei deixar em branco).
o
Por fim de ok para finalizar tudo e forneça a senha para sua chave.

Veja abaixo como ficou o processo de criação da minha chave:

# Criando uma chave GPG:
gpg2 --full-generate-key
gpg (GnuPG) 2.2.20; Copyright (C) 2020 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Please select what kind of key you want:
   (1) RSA and RSA (default)
   (2) DSA and Elgamal
   (3) DSA (sign only)
   (4) RSA (sign only)
  (14) Existing key from card
Your selection? 1
RSA keys may be between 1024 and 4096 bits long.
What keysize do you want? (3072) 2048
Requested keysize is 2048 bits
Please specify how long the key should be valid.
         0 = key does not expire
      <n>  = key expires in n days
      <n>w = key expires in n weeks
      <n>m = key expires in n months
      <n>y = key expires in n years
Key is valid for? (0) 0
Key does not expire at all
Is this correct? (y/N) y

GnuPG needs to construct a user ID to identify your key.

Real name: alice Tester
Email address: alice@foo.bar
Comment: 
You selected this USER-ID:
    "alice Tester <alice@foo.bar>"

Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? o
We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.
We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.
gpg: key 3C8BBC2617E4D437 marked as ultimately trusted
gpg: directory '/home/alice/.gnupg/openpgp-revocs.d' created
gpg: revocation certificate stored as '/home/alice/.gnupg/openpgp-revocs.d/3C8BBC2617E4D437F2607FBBD267A8A806C988EE.rev'
public and secret key created and signed.

pub   rsa1024 2022-10-07 [SCEA]
      3C8BBC2617E4D437F2607FBBD267A8A806C988EE
uid           [ultimate] alice Tester <alice@foo.bar>
sub   rsa1024 2022-10-07 [SEA]

Primeiros passos

Agora vamos ver os primeiros passos para termos um cofre funcional, vamos ver três maneiras possíveis de configurar um cofre, sendo:

Local usando o método FS
Local usando o método GITFS
Remoto usando o método GITFS com GITHUB ou GITLAB.

Criando um cofre local usando o File System - FS (não recomendado)

Vamos começar preparando o ambiente e tnão vamos inicializar o cofre e por fim adicionar os usuários para usar o cofre.

O único problema desse tipo de cofre é ficar gerenciando as permissões dos arquivos, tentei setar uma ACL mas não funcionou, mesmo assim vou demonstrar como fazer.

Os usuários já estão criados e já possuem suas chaves GPG criadas.

Preparando o ambiente para o Cofre

Vamos começar preparando o ambiente para o cofre, depois disso vamos podemos inicializar o cofre, todo o processo de preparação do ambiente e inicialização do cofre será feito com o usuário Jhon, vamos supor que ele seja responsavél pela administração deste cofre.

##
### Com o Jhon
##

# Criando a pasta onde vamos manter nosso cofre:
$ sudo mkdir -p /usr/local/access/passwords

# Criando qualquer coisa dentro da pasta sempre com mesmo grupo:
$ sudo chmod g+rwxs -R /usr/local/access/passwords

# Remova a permissão de outros:
$ sudo chmod o=- -R /usr/local/access

# Criar um grupo para que apenas as pessoas do grupo possam pertencer ao cofre:
$ sudo groupadd users-gopass

# Adicione os usuários ao grupo que criamos:
$ sudo gpasswd -a alice users-gopass
$ sudo gpasswd -a bob users-gopass
$ sudo gpasswd -a jhon users-gopass

# Verifique os usuários que estão dentro desse grupo:
$ getent group users-gopass
users-gopass:x:1004:alice,bob,jhon

# Mude o usuário e grupo do cofre:
$ sudo chown nobody.users-gopass -R /usr/local/access

Inicializando o Cofre

O local para manter nosso cofre está criado, agora precisamos inicializar ele, vamos usar o GPG como criptografia e o File System como backend de armazenamento.

##
### Com o Jhon
##

# Inicializando o cofre:
$ gopass init --store iduna --crypto gpgcli --path /usr/local/access/passwords --storage fs
🍭 Initializing a new password store ...
🔑 Searching for usable private Keys ...
⚠ Hint: Use 'gopass init <subkey> to use subkeys!'
❌ Failed to git commit: git is not initialized
❌ Failed to export missing public keys: some keys failed
✅ Wrote recipients to .gpg-id
🏁 Password store /usr/local/access/passwords initialized for:
📩 0xC709C8066BA395C6 - jhon Tester <jhon@foo.bar>

# Verifique a configuração do gopass:
$ gopass config
autoclip: false
autoimport: false
cliptimeout: 45
exportkeys: true
keychain: false
nopager: false
notifications: true
parsing: true
path: /home/jhon/.local/share/gopass/stores/root
safecontent: false
mount "iduna" => "/usr/local/access/passwords"

# Por causa do problema de permissão, temos que alterar novamente:
$ chmod g=rw /usr/local/access/passwords/.gpg-id
$ chmod g=rwxs -R /usr/local/access/passwords/.public-keys

# Configure o cofre para o jhon usar:
$ gopass --yes setup --remote file:///usr/local/access/passwords --alias iduna --storage fs

Adicionando outros usuários ao Cofre

Com o cofre já criado, vamos adicionar o restante dos usuários, começando com a Alice.

##
### Com a Alice
##

## Antes de tudo, certifique-se de que o usuário faz parte do grupo que criamos!

# Fazendo a configuração inicial e configurando para usar o cofre:
$ gopass --yes setup --remote file:///usr/local/access/passwords --alias iduna --storage fs
   __     _    _ _      _ _   ___   ___
 /'_ '\ /'_'\ ( '_'\  /'_' )/',__)/',__)
( (_) |( (_) )| (_) )( (_| |\__, \\__, \
'\__  |'\___/'| ,__/''\__,_)(____/(____/
( )_) |       | |
 \___/'       (_)

🌟 Welcome to gopass!
🌟 Initializing a new password store ...
Joining existing team ...
🌟 Configuring your password store ...
✅ Configuration written to /home/alice/.local/share/gopass/stores/root
[iduna]Configuring git remote ...
[iduna]Cloning from the git remote ...
2022/10/07 15:42:56 failed to clone repo: failed to clone repo "file:///usr/local/access/passwords" to "/home/alice/.local/share/gopass/stores/iduna": exit status 128: Cloning into '/home/alice/.local/share/gopass/stores/iduna'...
fatal: '/usr/local/access/passwords' does not appear to be a git repository
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.


# Agora precisamos montar o Cofre:
$ gopass mounts add iduna /usr/local/access/passwords
🚥 Syncing with all remotes ...
[<root>] 
   fs pull and push ... Skipped (no Git repo) (no changes)
   importing missing keys ... OK
   exporting missing keys ... nothing to do
   done
✅ All done
Mounted iduna as /usr/local/access/passwords


# Agora rode um sync para importar a chave de Jhon:
$ gopass sync
🚥 Syncing with all remotes ...
[<root>] 
   fs pull and push ... Skipped (no Git repo) (no changes)
   importing missing keys ... OK
   exporting missing keys ... nothing to do
   done
[iduna] 
   fs pull and push ... Skipped (no Git repo) (no changes)
   importing missing keys ... Do you want to import the public key "0xC709C8066BA395C6" (Names: [jhon Tester <jhon@foo.bar>]) into your keyring? [y/N/q]: y
[iduna] Imported public key for 0xC709C8066BA395C6 into KeyringOK
   exporting missing keys ... nothing to do
   done
✅ All done


# Faça com que Alice adicione sua chave (outra pessoa pode fazer isso também):
$ gopass recipients add --store iduna alice
Do you want to add "0xD267A8A806C988EE - alice Tester <alice@foo.bar>" (key "alice") as a recipient to the store "iduna"? [y/N/q]: y
❌ Failed to git commit: git is not initialized
❌ Failed to export missing public keys: some keys failed
Reencrypting existing secrets. This may take some time ...
Starting reencrypt


Added 1 recipients
You need to run 'gopass sync' to push these changes

# Acerte as permissões:
$ chmod g=rwxs -R /usr/local/access/passwords/.public-keys
chmod: changing permissions of '/usr/local/access/passwords/.public-keys': Operation not permitted
chmod: changing permissions of '/usr/local/access/passwords/.public-keys/0xC9A0A708C8AB27FE': Operation not permitted

Agora vamos adicionar o Bob ao cofre.

##
### Com o Bob
##

## Antes de tudo, certifique-se de que o usuário faz parte do grupo que criamos!

# Fazendo a configuração inicial e configurando para usar o cofre:
$ gopass --yes setup --remote file:///usr/local/access/passwords --alias iduna --storage fs
   __     _    _ _      _ _   ___   ___
 /'_ '\ /'_'\ ( '_'\  /'_' )/',__)/',__)
( (_) |( (_) )| (_) )( (_| |\__, \\__, \
'\__  |'\___/'| ,__/''\__,_)(____/(____/
( )_) |       | |
 \___/'       (_)

🌟 Welcome to gopass!
🌟 Initializing a new password store ...
Joining existing team ...
🌟 Configuring your password store ...
✅ Configuration written to /home/bob/.local/share/gopass/stores/root
[iduna]Configuring git remote ...
[iduna]Cloning from the git remote ...
2022/10/07 15:45:13 failed to clone repo: failed to clone repo "file:///usr/local/access/passwords" to "/home/bob/.local/share/gopass/stores/iduna": exit status 128: Cloning into '/home/bob/.local/share/gopass/stores/iduna'...
fatal: '/usr/local/access/passwords' does not appear to be a git repository
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

# Agora precisamos montar o Cofre:
$ gopass mounts add iduna /usr/local/access/passwords
🚥 Syncing with all remotes ...
[<root>] 
   fs pull and push ... Skipped (no Git repo) (no changes)
   importing missing keys ... OK
   exporting missing keys ... nothing to do
   done
✅ All done
Mounted iduna as /usr/local/access/passwords

# Agora rode um sync para importar a chave de Jhon e Alice:
$ gopass sync

# Faça com que Bob adicione sua chave (outra pessoa pode fazer isso também):
$ gopass recipients add --store iduna bob
Do you want to add "0xE09CFC975D39E4B4 - bob Tester <bob@foo.bar>" (key "bob") as a recipient to the store "iduna"? [y/N/q]: y
❌ Failed to git commit: git is not initialized
❌ Failed to export missing public keys: some keys failed
Reencrypting existing secrets. This may take some time ...
Starting reencrypt


Added 1 recipients
You need to run 'gopass sync' to push these changes

# Acerte as permissões:
$ chmod g=rwxs -R /usr/local/access/passwords/.public-keys
chmod: changing permissions of '/usr/local/access/passwords/.public-keys': Operation not permitted
chmod: changing permissions of '/usr/local/access/passwords/.public-keys/0xC9A0A708C8AB27FE': Operation not permitted
chmod: changing permissions of '/usr/local/access/passwords/.public-keys/alice': Operation not permitted

Adicionando uma senha

Vamos adicionar uma senha com a Bob e tentar ver essa senha com a Alice, como mencionei o problema no permissão, sempre que adicionar uma senha é necessário rodar o comando abaixo para acertar a permissão correta. Com o uso do backend FS não é preciso executar gopass sync porque todos acessam o diretório diretamente.

# Crie uma senha com Bob:
$ gopass insert iduna/web/apache/ivar
Enter password for iduna/web/apache/ivar: 
Retype password for iduna/web/apache/ivar:

# Acerte as permissões:
$ chmod g=rwxs -R /usr/local/access/passwords/
chmod: changing permissions of '/usr/local/access/passwords/': Operation not permitted
chmod: changing permissions of '/usr/local/access/passwords/.gpg-id': Operation not permitted
chmod: changing permissions of '/usr/local/access/passwords/.public-keys': Operation not permitted
chmod: changing permissions of '/usr/local/access/passwords/.public-keys/0xC9A0A708C8AB27FE': Operation not permitted
chmod: changing permissions of '/usr/local/access/passwords/.public-keys/alice': Operation not permitted


# Com Alice, tente abrir o arquivo (vai pedir senha):
$ gopass iduna/web/apache/ivar
⚠ Parsing is enabled. Use -n to disable.
Secret: iduna/web/apache/ivar

Y+E?;6%4qm),H:-:5o3Pl+@9Z

Criando um cofre local usando GIT File System - GITFS

Vamos começar preparando o ambiente e então vamos inicializar o cofre e por fim adicionar os usuários para usar o cofre.

Os usuários já estão criados e já possuem suas chaves GPG criadas.

Preparando o ambiente para o Cofre

##
### Com o Jhon
##

# Criando a pasta onde vamos manter nosso cofre:
$ sudo mkdir -p /usr/local/access/passwords

# Criar um grupo para que apenas as pessoas do grupo possam pertencer ao cofre:
$ sudo groupadd users-gopass

# Adicionar os usuários ao grupo:
$ sudo gpasswd -a alice users-gopass && sudo gpasswd -a jhon users-gopass && sudo gpasswd -a bob users-gopass

# De permissão apenas para o usuário e grupo:
$ sudo chmod 2770 -R /usr/local/access

# Mude o usuário e grupo do cofre:
$ sudo chown .users-gopass -R /usr/local/access

Inicializando o Cofre

O local para manter nosso cofre está criado, agora precisamos inicializar ele, vamos usar o GPG como criptografia e o File System como backend de armazenamento.

##
### Com o Jhon
##

# Configurando parametros do git:
$ git config --global user.email "jhon@foo.bar"
$ git config --global user.name "jhon"
$ git config --global --add safe.directory /usr/local/access/passwords
# A conf abaixo configura um repositório do Git para ser compartilhado por um grupo UNIX:
$ git config --global core.sharedRepository group

# Inicializando o cofre compartilhado (apenas enter, sem precisar responder nada):
$ gopass init --crypto gpgcli --path /usr/local/access/passwords --storage gitfs --store iduna 
🍭 Initializing a new password store ...
❌ Store is already initialized!
🔑 Searching for usable private Keys ...
⚠ Hint: Use 'gopass init <subkey> to use subkeys!'
✅ Wrote recipients to .gpg-id
Please enter an email address for password store git config []: jhon@gmail.com
git initialized at /usr/local/access/passwords
git configured at /usr/local/access/passwords
Initialized gitfs repository (gitfs) for jhon / ...
🏁 Password store /usr/local/access/passwords initialized for:
📩 0x4F5FA464EDCA48F2 - jhon Tester <jhon@gmail.com>

# Acesse o diretório e rode o comando para que o Git permita 'push' no repositório vazio:
$ cd /usr/local/access/passwords && git config receive.denyCurrentBranch ignore

## Jhon está acessando o cofre diretamente, isso significa que qualquer mudança
## será imediatamente aplicada, o que pode ser prejudicial, o ideal é
## que ele acesse não diretamente, através de um diretório em sua home.

# Para corrigir o problema acima, zere a configuração do gopass do Jhon:
$ yes | rm -r ~/.local/share/gopass/ ; yes|rm -r ~/.config/gopass ; yes|rm -r ~/.cache

# Agora configure o gopass para que jhon possa acessar o cofre recém criado,
# Para a pergunta 'Do you want to add a git remote?' responda NÃO:
$ gopass setup --remote file:///usr/local/access/passwords --alias iduna
🌟 Welcome to gopass!
🌟 Initializing a new password store ...
Joining existing team ...
🌟 Configuring your password store ...
Please enter an email address for password store git config []: jhon@foo.bar
❓ Do you want to add a git remote? [y/N/q]: n
✅ Configuration written to /home/jhon/.local/share/gopass/stores/root
Please enter the name of your team (may contain slashes) [iduna]: 
[iduna]Configuring git remote ...
[iduna]Please enter the git remote for your shared store [file:///usr/local/access/passwords]: 
[iduna]Cloning from the git remote ...
🚶 What is your name? [jhon]: 
📧 What is your email? []: jhon@foo.bar
[iduna]✅ Done. Joined Team "iduna"
[iduna]⚠ You still need to request access to decrypt secrets!


# Faça a sincronização:
$ gopass sync
🚥 Syncing with all remotes ...
[<root>] 
   git pull and push ... Skipped (no remote)[iduna] 
   git pull and push ... OK (no changes)
   importing missing keys ... OK
   exporting missing keys ... nothing to do
   done
✅ All done

Adicionando outros usuários ao Cofre

Com o cofre já criado, vamos adicionar o restante dos usuários, para que eles consigam acessar. A maneira correta de fazer isso é com o usuário administrador do Gopass (pessoa que criou o cofre), ele precisa adicionar a chave de cada um que precisa ter acesso, isso acontece porque o Gopass remove a permissão de escrita do arquivo .gpg-id para o Grupo e remove também da pasta .public-keys.

Antes de começar arrume a permissão desses arquivos com o usuário Jhon (dificilmente essas permissões vão ser sobrescritas novamente):

$ chmod g=rw /usr/local/access/passwords/.gpg-id
$ chmod g=rw /usr/local/access/passwords/.gitattributes
$ chmod g=rwx /usr/local/access/passwords/.public-keys
$ chmod g=rw /usr/local/access/passwords/.public-keys/*

Fizemos isso para que o próprio usuário consiga adicionar uma outra chave dele mesmo ou até adicionar um novo colaborador futuramente, lembrando que para ter acesso precisa estar no grupo e ter sua chave.

Não recomendo que cada um adicione sua chave inicialmente, como o cofre pode e normalmente tera senhas, o novo colaborador não conseguirá decriptar e encriptar elas, por isso quem faz esse processo já deve ter acesso.

Com o usuário Jhon, vamos importar as chaves públicas de Alice e Bob:

# Exporte a chave pública de Bob e Alice (Altere a pasta de destino /gpg):
$ gpg --output /gpg/bob-pgp.key --armor --export bob
$ gpg --output /gpg/alice-pgp.key --armor --export alice

# Agora com o usuário jhon, importe as chaves:
$ gpg --import /gpg/bob-pgp.key
gpg: key 9B0D0946659EECD6: public key "bob Tester <bob@gmail.com>" imported
gpg: Total number processed: 1
gpg:               imported: 1

$ gpg --import /gpg/alice-pgp.key
gpg: key 30493AAAA6EF8C15: public key "alice Tester <alice@gmail.com>" imported
gpg: Total number processed: 1
gpg:               imported: 1



# Agora adicione Alice como colaboradora do cofre:
$ gopass recipients add --store iduna alice
Do you want to add "0x30493AAAA6EF8C15 - alice Tester <alice@gmail.com>" (key "alice") as a recipient to the store "iduna"? [y/N/q]: y
Reencrypting existing secrets. This may take some time ...
Starting reencrypt


Added 1 recipients
You need to run 'gopass sync' to push these changes



# Agora adicione Bob como colaboradora do cofre:
$ gopass recipients add --store iduna bob
Do you want to add "0x9B0D0946659EECD6 - bob Tester <bob@gmail.com>" (key "bob") as a recipient to the store "iduna"? [y/N/q]: y
Reencrypting existing secrets. This may take some time ...
Starting reencrypt


Added 1 recipients
You need to run 'gopass sync' to push these changes


# Rode um sync para commitar a mudança:
$ gopass sync
🚥 Syncing with all remotes ...
[<root>] 
   git pull and push ... Skipped (no remote)[iduna] 
   git pull and push ... OK (no changes)
   importing missing keys ... OK
   exporting missing keys ... nothing to do
   done
✅ All done


# Liste os colaboradores:
$ gopass recipients
Hint: run 'gopass sync' to import any missing public keys
gopass
├── 0x4F5FA464EDCA48F2 - jhon Tester <jhon@gmail.com>
└── iduna (/home/jhon/.local/share/gopass/stores/iduna)
    ├── 0x30493AAAA6EF8C15 - alice Tester <alice@gmail.com>
    ├── 0x4F5FA464EDCA48F2 - jhon Tester <jhon@gmail.com>
    └── 0x9B0D0946659EECD6 - bob Tester <bob@gmail.com>

Agora adicione a Alice ao cofre.

##
### Com a Alice
##

# Configurando parametros do git:
$ git config --global user.email "alice@foo.bar"
$ git config --global user.name "alice"
$ git config --global --add safe.directory /usr/local/access/passwords
# A conf abaixo configura um repositório do Git para ser compartilhado por um grupo UNIX:
$ git config --global core.sharedRepository group

# Agora configure o gopass para que Alice possa acessar o cofre recém criado,
# Para a pergunta 'Do you want to add a git remote?' responda NÃO:
$ gopass setup --remote file:///usr/local/access/passwords --alias iduna
🌟 Welcome to gopass!
🌟 Initializing a new password store ...
Joining existing team ...
🌟 Configuring your password store ...
Please enter an email address for password store git config []: alice@foo.bar
❓ Do you want to add a git remote? [y/N/q]: n
✅ Configuration written to /home/alice/.local/share/gopass/stores/root
Please enter the name of your team (may contain slashes) [iduna]: 
[iduna]Configuring git remote ...
[iduna]Please enter the git remote for your shared store [file:///usr/local/access/passwords]: 
[iduna]Cloning from the git remote ...
🚶 What is your name? [alice]: 
📧 What is your email? []: alice@foo.bar
[iduna]✅ Done. Joined Team "iduna"
[iduna]⚠ You still need to request access to decrypt secrets!


# Faça a sincronização (vai pedir para importar a pub de todos que alice ainda
# não tem!):
$ gopass sync
🚥 Syncing with all remotes ...
[<root>] 
   git pull and push ... Skipped (no remote)[iduna] 
   git pull and push ... OK (no changes)
   importing missing keys ... Do you want to import the public key "0x4F5FA464EDCA48F2" (Names: [jhon Tester <jhon@gmail.com>]) into your keyring? [y/N/q]: y
[iduna] Imported public key for 0x4F5FA464EDCA48F2 into KeyringDo you want to import the public key "bob" (Names: [bob Tester <bob@gmail.com>]) into your keyring? [y/N/q]: y
[iduna] Imported public key for bob into KeyringOK
   exporting missing keys ... nothing to do
   done
✅ All done

Agora vamos adicionar o Bob ao cofre.

##
### Com o Bob
##

# Configurando parametros do git:
$ git config --global user.email "bob@foo.bar"
$ git config --global user.name "bob"
$ git config --global --add safe.directory /usr/local/access/passwords
# A conf abaixo configura um repositório do Git para ser compartilhado por um grupo UNIX:
$ git config --global core.sharedRepository group

# Agora configure o gopass para que bob possa acessar o cofre recém criado,
# Para a pergunta 'Do you want to add a git remote?' responda NÃO:
$ gopass setup --remote file:///usr/local/access/passwords --alias iduna
🌟 Welcome to gopass!
🌟 Initializing a new password store ...
Joining existing team ...
🌟 Configuring your password store ...
Please enter an email address for password store git config []: bob@foo.bar
❓ Do you want to add a git remote? [y/N/q]: n
✅ Configuration written to /home/bob/.local/share/gopass/stores/root
Please enter the name of your team (may contain slashes) [iduna]: 
[iduna]Configuring git remote ...
[iduna]Please enter the git remote for your shared store [file:///usr/local/access/passwords]: 
[iduna]Cloning from the git remote ...
🚶 What is your name? [bob]: 
📧 What is your email? []: bob@foo.bar
[iduna]✅ Done. Joined Team "iduna"
[iduna]⚠ You still need to request access to decrypt secrets!


# Faça a sincronização (vai pedir para importar a pub de todos que alice ainda
# não tem!):
$ gopass sync
🚥 Syncing with all remotes ...
[<root>] 
   git pull and push ... Skipped (no remote)[iduna] 
   git pull and push ... OK (no changes)
   importing missing keys ... Do you want to import the public key "0x4F5FA464EDCA48F2" (Names: [jhon Tester <jhon@gmail.com>]) into your keyring? [y/N/q]: y
[iduna] Imported public key for 0x4F5FA464EDCA48F2 into KeyringDo you want to import the public key "alice" (Names: [alice Tester <alice@gmail.com>]) into your keyring? [y/N/q]: y
[iduna] Imported public key for alice into KeyringOK
   exporting missing keys ... nothing to do
   done
✅ All done

Adicionando uma senha

Vamos adicionar uma senha com a Bob e tentar ver essa senha com a Alice. Com o uso do backend GITFS é sempre obrigatório executar gopass sync se quiser que todos tenham acesso as mudanças nas senhas.

# Crie uma senha com Bob:
$ gopass insert iduna/web/apache/ivar
Enter password for iduna/web/apache/ivar: 
Retype password for iduna/web/apache/ivar:
Warning: Password is too short

# Com o Bob, veja a senha:
$ gopass ls
gopass
└── iduna (/home/bob/.local/share/gopass/stores/iduna)
    └── web/
        └── apache/
            └── ivar

# Com a Alice, veja se ela consegue ver a senha:
$ gopass ls
gopass
└── iduna (/home/alice/.local/share/gopass/stores/iduna)


# Com o Bob, faça o sync:
$ gopass sync
🚥 Syncing with all remotes ...
[<root>] 
   git pull and push ... Skipped (no remote)[iduna] 
   git pull and push ... OK (no changes)
   importing missing keys ... OK
   exporting missing keys ... nothing to do
   done
✅ All done


# Com a Alice, veja se ela consegue ver a senha:
$ gopass ls
gopass
└── iduna (/home/alice/.local/share/gopass/stores/iduna)

# Ainda com a Alice, faça o sync e depois liste novamente:
$ gopass sync
🚥 Syncing with all remotes ...
[<root>] 
   git pull and push ... Skipped (no remote)[iduna] 
   git pull and push ... OK (Added 1 entries)
   importing missing keys ... OK
   exporting missing keys ... nothing to do
   done
✅ All done

# Agora liste:
$ gopass ls
gopass
└── iduna (/home/alice/.local/share/gopass/stores/iduna)
    └── web/
        └── apache/
            └── ivar

# Com Alice, tente abrir o arquivo (vai pedir senha):
$ gopass iduna/web/apache/ivar
⚠ Parsing is enabled. Use -n to disable.
Secret: iduna/web/apache/ivar

1234

Criando um cofre remoto usando o GIT

Vamos começar preparando o ambiente e então vamos inicializar o cofre e por fim adicionar os usuários para usar o cofre.

Preparando o ambiente para o Cofre

Novamente Jhon será o administrador do cofre. Não se esqueça de no GIT adicionar todos os integrantes que deverão ter acesso ao cofre como mantenedor (GitLab), já no GitHub não precisou de nada, apenas adicionar ao repositório. O usuário Jhon já tem um cofre (criado acima) e vai inicializar mais um no Git.

Os usuários já estão criados e já possuem suas chaves GPG criadas.

##########################################
############# Criando no GIT #############
##########################################

# Configurações iniciais do Git caso não tenha feito (coloque informações verdadeiras):
$ git config --global user.email "jhon@foo.bar"
$ git config --global user.name "jhon"
$ git config --global core.sharedRepository group

# Como já temos o outro cofre, basta clonar:
$ gopass clone https://gitlab.com/BRVN01/gopass.git iduna-remote
🌟 Welcome to gopass!
🌟 Cloning an existing password store from "https://gitlab.com/BRVN01/gopass.git" ...
⚠ Cloning gitfs repository "https://gitlab.com/BRVN01/gopass.git" to "/home/jhon/.local/share/gopass/stores/iduna-remote" ...
Username for 'https://gitlab.com': jhon
Password for 'https://jhon@gitlab.com': 
Git Email not set
⚠ Failed to commit .gitattributes to git
git configured at /home/jhon/.local/share/gopass/stores/iduna-remote

Error: Failed to add mount: failed to add mount: failed to init sub store "iduna-remote" at "/home/jhon/.local/share/gopass/stores/iduna-remote": password store iduna-remote is not initialized. Try gopass init --store iduna-remote --path /home/jhon/.local/share/gopass/stores/iduna-remote


# Inicialize o cofre agora:
$ gopass init --store iduna-remote --path /home/jhon/.local/share/gopass/stores/iduna-remote
🍭 Initializing a new password store ...
❌ Store is already initialized!
🔑 Searching for usable private Keys ...
⚠ Hint: Use 'gopass init <subkey> to use subkeys!'
Username for 'https://gitlab.com': jhon
Password for 'https://jhon@gitlab.com': 
Username for 'https://gitlab.com': jhon
Password for 'https://jhon@gitlab.com': 
✅ Wrote recipients to .gpg-id
Please enter an email address for password store git config []: jhon@foo.bar
⚠ Failed to commit .gitattributes to git
git configured at /home/jhon/.local/share/gopass/stores/iduna-remote
Initialized gitfs repository (gitfs) for jhon / ...
🏁 Password store /home/jhon/.local/share/gopass/stores/iduna-remote initialized for:
📩 0x4F5FA464EDCA48F2 - jhon Tester <jhon@gmail.com>



# Rode um sync:
$ gopass sync
🚥 Syncing with all remotes ...
[<root>] 
   git pull and push ... Skipped (no remote)[iduna] 
   git pull and push ... OK (no changes)
   importing missing keys ... OK
   exporting missing keys ... nothing to do
   done
[iduna-remote] 
   git pull and push ... Username for 'https://gitlab.com': jhon
Password for 'https://jhon@gitlab.com': 
Username for 'https://gitlab.com': jhon
Password for 'https://jhon@gitlab.com': 
OK (no changes)
   importing missing keys ... OK
   exporting missing keys ... nothing to do
   done
✅ All done


## Agora só cadastrar as senhas!

###########################################################
############# Caso não tenha outro cofre mapeado ##########
###########################################################

# Configurações iniciais do Git:
$ git config --global user.email "alice@foo.bar"
$ git config --global user.name "alice"
$ git config --global core.sharedRepository group

# Configurando o repositorio remoto:
$ gopass --yes setup --remote https://gitlab.com/BRVN01/gopass.git --alias iduna-remote
🌟 Welcome to gopass!
🌟 Initializing a new password store ...
Joining existing team ...
🌟 Configuring your password store ...
✅ Configuration written to /home/alice/.local/share/gopass/stores/root
[iduna-remote]Configuring git remote ...
[iduna-remote]Cloning from the git remote ...
Username for 'https://gitlab.com': sysnetbrofficial
Password for 'https://sysnetbrofficial@gitlab.com': 
[iduna-remote]✅ Done. Joined Team "iduna-remote"
[iduna-remote]⚠ You still need to request access to decrypt secrets!

# Faça o sync:
$ gopass sync
🚥 Syncing with all remotes ...
[<root>] 
   git pull and push ... Skipped (no remote)[iduna-remote] 
   git pull and push ... Username for 'https://gitlab.com': alice
Password for 'https://alice@gitlab.com': 
Username for 'https://gitlab.com': alice
Password for 'https://alice@gitlab.com': 
OK (no changes)
   importing missing keys ... OK
   exporting missing keys ... nothing to do
   done
✅ All done

Atualizando o Gopass usando pacote

Vamos instalar uma versão antiga do Gopass para depois atualizar ele.

##
### Com o Jhon
##

# Para teste de update do gopass começamos instalando a versão 1.9
$ wget https://github.com/gopasspw/gopass/releases/download/v1.9.0/gopass_1.9.0_linux_amd64.deb

# Instale o pacote:
$ sudo dpkg -i gopass_1.9.0_linux_amd64.deb

# Configure o git para o Jhon:
git config --global user.email "jhon@foo.bar"
git config --global user.name "jhon"
git config --global --add safe.directory /usr/local/access/passwords
git config --global core.sharedRepository group


# Inicialize o cofre:
$ gopass init --crypto gpgcli --path /usr/local/access/passwords --rcs gitcli --store iduna
[init] Initializing a new password store ...
Please select a private key for encrypting secrets:
[0] gpg - 0x4F5FA464EDCA48F2 - jhon Tester <jhon@gmail.com>
Please enter the number of a key (0-0, [q]uit) [0]: 
[init] Initializing git repository (gitcli) ...
Use jhon Tester (jhon@gmail.com) for password store git config? [Y/n/q]: y
[init] git initialized at /usr/local/access/passwords
[init] git configured at /usr/local/access/passwords
[init] Git initialized
[init] Password store /usr/local/access/passwords initialized for:
[init]   0x4F5FA464EDCA48F2 - jhon Tester <jhon@gmail.com>

# Faça o git aceitar commit sem arquivo:
$ cd /usr/local/access/passwords && git config receive.denyCurrentBranch ignore

# Apague as confs atuais do gopass:
$ yes | rm -r ~/.local/share/gopass/ ; yes|rm -r ~/.config/gopass ; yes|rm -r ~/.cache

# Configure o primeiro cofre para o jhon:
$ gopass setup --remote file:///usr/local/access/passwords --alias iduna
[init] Joining existing team ...
[init] [local] Initializing your local store ...
Please select a private key for encrypting secrets:
[0] gpg - 0x4F5FA464EDCA48F2 - jhon Tester <jhon@gmail.com>
Please enter the number of a key (0-0, [q]uit) [0]: 
Use jhon Tester (jhon@gmail.com) for password store git config? [Y/n/q]: y
[init] [local]  -> OK
[init] [local] Configuring your local store ...
[init] [local] Do you want to add a git remote? [y/N/q]: n
[init] [local] Do you want to always confirm recipients when encrypting? [y/N/q]: n
[init] [local]  -> OK
[init] Please enter the name of your team (may contain slashes) [iduna]: 
[init] [iduna]Configuring git remote ...
[init] [iduna]Please enter the git remote for your shared store [file:///usr/local/access/passwords]: 
[init] [iduna]Cloning from the git remote ...
Use jhon Tester (jhon@gmail.com) for password store git config? [Y/n/q]: y
[init] [iduna] -> OK
[init] [iduna]Joined Team 'iduna'
[init] [iduna]Note: You still need to request access to decrypt any secret!

# Acerte as permissões:
$ chmod g=rw /usr/local/access/passwords/.gpg-id
$ chmod g=rw /usr/local/access/passwords/.gitattributes
$ chmod g=rwx /usr/local/access/passwords/.public-keys
$ chmod g=rw /usr/local/access/passwords/.public-keys/*

## Faça o mesmo com a Alice!!

# Baixe e instale a versão mais nova:
$ wget https://github.com/gopasspw/gopass/releases/download/v1.14.0/gopass_1.14.0_linux_amd64.deb

# Instale a versão mais nova:
$ sudo dpkg -i gopass_1.14.0_linux_amd64.deb

Pronto, atualização realizada, agora reinicie ou deslogue todos os usuários, o path do gopass mudou, isso é necessário para que consigam acessar o binário no lugar correto.

Atualizando o Gopass usando Go

Vamos compilar o Gopass para a nova versão.

# Mude como o Go vai importar os pacotes:
$ GO111MODULE='on'
$ export GO111MODULE='on'

# Altere o GOPATH para alocar o binário no '/tmp/bin/':
$ GOPATH=/tmp
$ export GOPATH=/tmp

# Obtenha o pacote usando o Gopass:
$ go install github.com/gopasspw/gopass@v1.14.0

# Mova o binário para a pasta recém criada:
$ sudo mv /tmp/bin/gopass /usr/local/bin/

Outra forma de atualizar é:

# Entre como Root:
$ sudo su

# Mude como o Go vai importar os pacotes:
GO111MODULE='on'
export GO111MODULE='on'

# Altere o GOPATH para alocar o binário no '/tmp/bin/':
GOPATH=/tmp
export GOPATH=/tmp

# Atualize o Gopass:
gopass update
⚒ Checking for available updates ...
] 5844666 / 5844666 [Goooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooopass] 100.00% 
✅ gopass is up to date

Usando o Gopass

Vamos ver alguns comandos para usar o Gopass, aqui serão mostrados comandos que você irá usar no dia a dia.

gopass ls

Listar as senhas existentes, neste caso será de todos os cofres que temos:

$ gopass ls
gopass
├── cofre2 (/home/sysnetbr/.local/share/gopass/stores/cofre2)
│   ├── new/
│   │   ├── admin
│   │   └── root
│   ├── novo/
│   │   └── root
│   ├── teste
│   └── teste2
└── teste (/home/sysnetbr/.local/share/gopass/stores/teste)
    ├── vm1/
    │   ├── admin
    │   └── root
    └── vm2/

Listar as senhas existentes de apenas um cofre:

$ gopass ls cofre2
cofre2/
├── new/
│   ├── admin
│   └── root
├── novo/
│   └── root
├── teste
└── teste2

# Podemos ver uma árvore de diretório dentro de um cofre também:
$ gopass ls cofre2/new
cofre2/new/
├── admin
└── root

gopass find ou gopass search

Para procurar por uma senha, você pode usar os argumentos find ou search, eles são sinônimo (usar aspas não é necessário, coloquei apenas para dar um destaque em qual senha queremos procurar):

$ gopass find "root"
cofre2/new/root
cofre2/novo/root
teste/vm1/root
teste/vm2/root

Decriptar senhas

Agora vamos decriptar uma senha (ver a senha):

$ gopass teste/vm2/root
⚠ Parsing is enabled. Use -n to disable.
Secret: teste/vm2/root

123

Também podemos usar o argumento show, ele é útil em casos onde temos um diretório e um arquivo de senhas com o mesmo nome.

gopass insert

Agora vamos inserir uma senha nova no cofre, abaixo da árvore cofre2/novo:

$ gopass insert cofre2/novo/vm-google/root
Enter password for cofre2/novo/vm-google/root: 
Retype password for cofre2/novo/vm-google/root: 
Warning: Password is too short

# Faça a sincronização:
$ gopass sync
🚥 Syncing with all remotes ...
[<root>] 
   git pull and push ... Skipped (no remote)
[cofre2] 
   git pull and push ... OK (no changes)
   importing missing keys ... OK
   exporting missing keys ... nothing to do
   done
[teste] 
   git pull and push ... OK (no changes)
   importing missing keys ... OK
   exporting missing keys ... nothing to do
   done
✅ All done

No meu caso não pede senha porque adicionei minha chave ao ssh-agent, isso será mostrado mais adiante, outro detalhe é que nessa versão, ao adicionar uma senha ele automaticamente faz o sync, poupando tempo, caso não queira que isso ocorra, quando ele pedir a senha dê um Ctrl+c.

gopass edit

Vamos editar uma senha:

$ gopass edit cofre2/novo/root

# Faça o 'sync':
$ gopass sync

Inserindo strings dentro da senha, isso é útil caso queira adicionar por exemplo:

 admin = 123
 root = 321

gopass insert (com argumentos)

O comando é semelhante ao insert mas no final colocamos a string que queremos adicionar, veja os exemplos:

# Adicionando uma senha para a vm5 com o usuário chamado 'fulano':
$ gopass insert cofre2/vm5 fulano
cofre2/vm5:fulano []: 123

# Agora adicione o usuário admin:
$ gopass insert cofre2/vm5 admin
cofre2/vm5:admin []: 321

# Agora decripte a senha:
$ gopass cofre2/vm5
⚠ Parsing is enabled. Use -n to disable.
Secret: cofre2/vm5


admin: 321
fulano: 123

Você pode fazer isso usando o argumento edit também, alias a edição fica mais simplificada, mas essa forma é válida também.

gopass mv

Usado para mover uma senha ou renomear uma senha, inclusive move senhas entre cofres diferentes:

# Verificando como está:
$ gopass ls
gopass
├── cofre2 (/home/sysnetbr/.local/share/gopass/stores/cofre2)
│   ├── new/
│   │   ├── admin
│   │   └── root
│   ├── novo/
│   │   ├── github
│   │   ├── root
│   │   └── vm-google/
│   │       └── root
│   ├── teste
│   ├── teste2
│   └── vm5
└── teste (/home/sysnetbr/.local/share/gopass/stores/teste)
    ├── vm1/
    │   ├── admin
    │   └── root
    └── vm2/
        └── root


# Movendo a senha de cofre:
$ gopass mv cofre2/novo/github teste/vm2/


# Verificando se moveu:
$ gopass ls
gopass
├── cofre2 (/home/sysnetbr/.local/share/gopass/stores/cofre2)
│   ├── new/
│   │   ├── admin
│   │   └── root
│   ├── novo/
│   │   ├── root
│   │   └── vm-google/
│   │       └── root
│   ├── teste
│   ├── teste2
│   └── vm5
└── teste (/home/sysnetbr/.local/share/gopass/stores/teste)
    ├── vm1/
    │   ├── admin
    │   └── root
    └── vm2/
        ├── github
        └── root

Agora vamos renomer a senha:

$ gopass mv teste/vm2/github teste/vm2/github-new

# Verifique se mudou:
$ gopass ls teste/
teste/
├── vm1/
│   ├── admin
│   └── root
└── vm2/
    ├── github-new
    └── root

gopass rm

Usado para apagar uma senha:

$ gopass rm teste/vm2/github-new
☠ Are you sure you would like to delete teste/vm2/github-new? [y/N/q]: y


# Verifique se apagou:
$ gopass ls teste/
teste/
├── vm1/
│   ├── admin
│   └── root
└── vm2/
    └── root

gopass pwgen

Esse argumento gera senhas pseudo randomicas, é como um gerador de senhas:

$ gopass pwgen 
3BDWiqShBTgw XZul90Fd9qum qYwoP4UW6vM4 0YVBxdthRGGi 0kVPqjSMM05x 4BuLZQ0o315J 1dILS48CUApm cH5aHaU8tj60 9WM4yAwFs1S7 IB3xyRGPeLkn EDfXtRXmQUGv 4KSB2iNSr25t RkKU8yMUkA0g iUOMCTYqZ43T 
4kwO3QcLQ0df Qz0YeZnrax1s F03KiaNmsFTv jkYWHMDvUIAw uVom9nYzCmrd EJz3BTvcwBHb prPgBBvZkoAA WC7p4VJQEXyK RcVmDpTaRqZy 05UX6ELf2GM4 wftQCvsGdSvo vSyytcrSEKtq 7p9JTYdjR2JJ MKsLgUOZNHZd 
TkobKMIvvOKC bZ1iLnR3JTI8 Jk4oxLpxnp75 CttVSmLflSk7 20Qh20Yue60F PI4tmmfJL2RU SJHwVS0f3Gux iFYFYiU96Aey HiKTRJ6QD3Sz kSKdT3whfK5h osSr5tNM4A1x 0XQdwM90QQQK TnwtOoxixEKi 9WlKp8CmfWAD 
BlwQFMTZYDlO 55Rj5W9waBMR vYgoivOrMlfX M99Eddyq36dR ehecpt1Gg3KH LEAZfQYCCAFL Auo84FTerGfq GywzgoBQYXri rqex5hF8iPig daKOfZ90x90D iwq8jWlNrQqy PLO8MvhCxvGm IcOMmytMC1sr 1YuVetxZ0IbC 
LA8sVVjgicL0 2Alyu7WwnGCH fLShGA4wzc0m dnGHNw4KMyxq lzdYKKcGBe3T XFFobLCVrAdB G8grk6sj7ULu FzYKeiJna2N8 nxOPMlZuyE0T IrrW8nwYrQd7 kbIjwW7nHFGJ 1Z0koXau1ZnH 7nH0SJgqthxn 5UjCPwPXUUtw 
imIbnsW3qqb7 sNhLJb8CR5si tmnKZNWlNRHz 6a3fnOmVSg88 Lm9AXRabQIbF PBdchwJo6lDN 1oVOXuXhOxLw shZvFajgKLmJ D54bhhYUiCtK uepthizOI0sO 8qVJZfWVIzQj IAsVhmdcrqUv 0gVRLj7YDsjU T4SrYmcfyU7R 
HZ2YwOX6Di2o bRWuezEjhCyd ISvVQCv2AudC tSsZemcMMz0e d0pcOhmb3qCN rtYz4H7jijaF EnjG0fuYy2LZ hsu8KGQqrQAJ jNulLS6OEmHQ RCaILkQEcEwo kIu6l761MG6o 1vXuNuOpg0hz xosqW0ObXFAX lVmx3aK7Mn2C 
rdkPEqJjYcng opiyL2waUKKc cz8hPMW68atL EhpXQ8BD68Lz 8aDxoyvsxBan wj57jXNZCAAH eOOpt55kMACJ xww0ZFSCjgxy BTPz2MkMm4Wo VC8NreGSOgOC pISZQ6As4048 aPaP3nLULztY NA8hiqTTttqR dznIoA3JD98l 
abI8HdBCpGcf f8Ez2Sb5gEtD 5kOqaQsp8Zti f1e9LbEwC4sj VBOFoAYlOS3L eqzvZvgi617f 1FpwW3LxMeCG cRcLphYHwCmC JdzSK8FIi0Cu kS1n20ft3BjU 5DRMcXZJSPXa diyCIeH5H2jA DesnmuzjfQLo 0rRdRATu1Pb8 
X6qnNXHmYjVp G7IcotqUPxy6 5Hzr4YpeiaIV KLUSLQGMZg64 HOmHltJvlx6M VVYVY3gMyJMd fRn5PNmRAZk5 xmqPCOueDH38 HTOBqJVNIRR8 mNIfSNlZcwZ9 o77jjKKrYR1u QaeXKtxUM7kh ZZicheqWLAJT onacR4F3jsYN 

gopass generate

Usado para criar uma senha no cofre e já adicionar a senha (nesse caso não vamos ter que nós mesmo adicionar a senha):

# Gerando uma senha de 20 caracteres:
$ gopass generate cofre2/novo/github
How long should the password be? (q to abort) [24]: 20
✅ Password for entry "cofre2/novo/github" generated
Not printing secrets by default. Use 'gopass show cofre2/novo/github' to display the password.


# Exiba a senha:
$ gopass cofre2/novo/github
⚠ Parsing is enabled. Use -n to disable.
Secret: cofre2/novo/github

kxWSBfXOy1J1QPWOw5Si

gopass cp

Usado para copiar senhas de um local para outro local:

# Gerando uma senha de 20 caracteres:
$ gopass generate cofre2/novo/senha-grande
How long should the password be? (q to abort) [24]: 20
✅ Password for entry "cofre2/novo/senha-grande" generated
Not printing secrets by default. Use 'gopass show cofre2/novo/senha-grande' to display the password.


# Veja a senha:
$ gopass cofre2/novo/senha-grande
⚠ Parsing is enabled. Use -n to disable.
Secret: cofre2/novo/senha-grande

HVt0Z5T5Jg6TmcpVyX4W


# Copiando a senha para outro repo (com outro nome):
$ gopass cp cofre2/novo/senha-grande teste/big/senha1


# Veja a senha:
$ gopass teste/big/senha1
⚠ Parsing is enabled. Use -n to disable.
Secret: teste/big/senha1

HVt0Z5T5Jg6TmcpVyX4W

gopass audit

Usado para verificar a força das senhas e possíveis senhas duplicadas:

$ gopass audit 
Auditing passwords for common flaws ...
Checking 11 secrets. This may take some time ...

] 11 / 11 [Gooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooopass] 100.00% 
Detected a shared secret for:
    - cofre2/teste
    - teste/vm1/admin
    - teste/vm1/root
    - teste/vm2/root
Password is too short:
    - cofre2/new/admin
    - cofre2/new/root
    - cofre2/novo/vm-google/root
    - cofre2/teste
    - cofre2/teste2
    - teste/vm1/admin
    - teste/vm1/root
    - teste/vm2/root
weak password (0 / 4):
    - cofre2/new/admin
    - cofre2/new/root
    - cofre2/novo/vm-google/root
    - cofre2/teste
    - cofre2/teste2
    - teste/vm1/admin
    - teste/vm1/root
    - teste/vm2/root
weak password (2 / 4):
    - cofre2/novo/root
2022/02/03 16:36:22 found weak passwords or duplicates

gopass history

Usado para mostrar o histórico da senha:

$ gopass history teste/novo/senha-grande
0cef4dcdfddf00cf70119347215b7a3e74f8b7ba - sysnetbr <sysnetbr@gmail.com> - 2022-02-03T19:28:47Z - Move from cofre2/novo to teste/

Comandos extras

Zerar tada a configuração do gopass:

yes | rm -r ~/.local/share/gopass/ ; yes|rm -r ~/.config/gopass ; yes|rm -r ~/.cache

Habilitar o ssh-agent:

# Iniciar o SSH Agent:
eval "$(ssh-agent -s)"

# Adicionar a chave no SSH Agent:
ssh-add ~/.ssh/id_ed25519

Habilitar o auto complete:

# Habilitar o auto complete no Bash:
echo "source <(gopass completion bash)" >> ~/.bashrc
source ~/.bashrc

Mais detalhes ver em https://github.com/gopasspw/gopass/blob/master/docs/setup.md

Mapear um segundo cofre (gopass já instalado e o comando gopass setup foi executado):

# Certifique-se de que a configuração básica do Git foi feita:
git config --global user.email "joao@gmail.com"
git config --global user.name "joao"
git config --global core.sharedRepository group

# No git:
gopass clone git@github.com:joao/gopasstest2.git cofre2

# Local:
gopass clone file:///usr/local/access/cofre/ cofre

Ainda não tem nenhuma configuração e precisa mapear um cofre (apenas instalou o gopass):

# Configuração básica do Git:
git config --global user.email "joao@gmail.com"
git config --global user.name "joao"
git config --global core.sharedRepository group

# Configurando o repositorio remoto:
gopass setup --yes --remote git@github.com:joao/gopasstest2.git --alias ghost

## ou

# Configurando o repositorio local:
gopass setup --yes --remote file:///usr/local/access/passwords --alias ghost

Deixar chave GPG confiável
Em alguns casos, pode ser que você tenha exportado sua chave de outra máquina, e ao importar na nova máquina essa chave ficará como desconhecida, para usar ela no Gopass você terá que "confiar" na chave, siga o passo a passo abaixo mudando o email/identificação da sua chave:
```
gpg --edit-key joao@gmail.com
trust
5
save
```

Inicializando um segundo Cofre

O usuário Jhon já tem um cofre mapeado (na verdade possui dois), vamos inicializar um terceiro cofre para ele. Faça a parte de preparo do ambiente para um cofre local.

##
### Com o Jhon
##

## Preparando o ambiente:
$ sudo mkdir /usr/local/access/devs
$ sudo chmod 2770 -R /usr/local/access/devs
$ sudo chown .users-gopass -R /usr/local/access/devs


# Adicione ao git:
$ git config --global --add safe.directory /usr/local/access/devs

# Inicializando o cofre compartilhado (apenas enter, sem precisar responder nada):
$ gopass init --crypto gpgcli --path /usr/local/access/devs --storage gitfs --store devvault 
🍭 Initializing a new password store ...
❌ Store is already initialized!
🔑 Searching for usable private Keys ...
⚠ Hint: Use 'gopass init <subkey> to use subkeys!'
✅ Wrote recipients to .gpg-id
Please enter an email address for password store git config []: jhon@foo.bar
git initialized at /usr/local/access/devs
git configured at /usr/local/access/devs
Initialized gitfs repository (gitfs) for jhon / ...
🏁 Password store /usr/local/access/devs initialized for:
📩 0x4F5FA464EDCA48F2 - jhon Tester <jhon@gmail.com>

# Acesse o diretório e rode o comando para que o Git permita 'push' no repositório vazio:
$ cd /usr/local/access/devs && git config receive.denyCurrentBranch ignore

## Jhon está acessando o cofre diretamente, isso significa que qualquer mudança
## será imediatamente aplicada, o que pode ser prejudicial, o ideal é
## que ele acesse não diretamente, através de um diretório em sua home.

# Para corrigir o problema acima, zere apenas a configuração referente ao novo cofre:
$ gopass mounts remove devvault
Password Store devvault umounted


# Agora configure o gopass para que jhon possa acessar o cofre recém criado,
# Como ele já possui outros cofrer o comando 'gopass setup' não vai funcionar,
# então 'clone' o cofre:
$ gopass clone file:///usr/local/access/devs devvault
🌟 Welcome to gopass!
🌟 Cloning an existing password store from "file:///usr/local/access/devs" ...
⚠ Cloning gitfs repository "file:///usr/local/access/devs" to "/home/jhon/.local/share/gopass/stores/devvault" ...
Git Email not set
⚠ Failed to commit .gitattributes to git
git configured at /home/jhon/.local/share/gopass/stores/devvault
Mounted password store /home/jhon/.local/share/gopass/stores/devvault at mount point `devvault` ...
⚠ Configuring gitfs repository ...
🎩 Gathering information for the git repository ...
🚶 What is your name? [jhon]: 
📧 What is your email? []: jhon@foo.bar
⚠ Failed to commit .gitattributes to git
Your password store is ready to use! Have a look around: `gopass list devvault`

⚠ Found valid decryption keys. You can now decrypt your passwords.


# Faça a sincronização:
$ gopass sync -s devvault
🚥 Syncing with all remotes ...
[devvault] 
   git pull and push ... OK (no changes)
   importing missing keys ... OK
   exporting missing keys ... nothing to do
   done
✅ All done


#########################################################################

# Adicione Bob ao devvault:
$ gopass recipients add --store devvault bob
Do you want to add "0x9B0D0946659EECD6 - bob Tester <bob@gmail.com>" (key "bob") as a recipient to the store "devvault"? [y/N/q]: y
Reencrypting existing secrets. This may take some time ...
Starting reencrypt


Added 1 recipients
You need to run 'gopass sync' to push these changes


# Adicione o cofre com o usuário Bob:
$ gopass clone file:///usr/local/access/devs devvault
🌟 Welcome to gopass!
🌟 Cloning an existing password store from "file:///usr/local/access/devs" ...
⚠ Cloning gitfs repository "file:///usr/local/access/devs" to "/home/bob/.local/share/gopass/stores/devvault" ...
Git Email not set
⚠ Failed to commit .gitattributes to git
git configured at /home/bob/.local/share/gopass/stores/devvault
Mounted password store /home/bob/.local/share/gopass/stores/devvault at mount point `devvault` ...
⚠ Configuring gitfs repository ...
🎩 Gathering information for the git repository ...
🚶 What is your name? [bob]: 
📧 What is your email? []: bob@gmail.com
⚠ Failed to commit .gitattributes to git
Your password store is ready to use! Have a look around: `gopass list devvault`

⚠ Please ask the owner of the password store to add one of your keys: 0x9B0D0946659EECD6
⚠ The missing keys were exported to the password store. Run `gopass sync` to push them.

Fontes

https://woile.github.io/gopass-cheat-sheet/

https://www.gopass.pw/

https://blog.codecentric.de/2019/02/gopass-passwoerter-verwalten-team/

https://github.com/gopasspw/gopass/blob/master/docs/features.md

https://woile.github.io/gopass-presentation/

https://github.com/gopasspw/gopass/releases

https://github.com/BRVN01/vagrant/tree/main/gopass_lab

Backends​

Armazenamento​

Criptografia​

Recipients​

Cofres​

Instalação via pacote​

Instalação manual​

Chave GPG​

Primeiros passos​

Criando um cofre local usando o File System - FS (não recomendado)​

Preparando o ambiente para o Cofre​

Inicializando o Cofre​

Adicionando outros usuários ao Cofre​

Adicionando uma senha​

Criando um cofre local usando GIT File System - GITFS​

Preparando o ambiente para o Cofre​

Inicializando o Cofre​

Adicionando outros usuários ao Cofre​

Adicionando uma senha​

Criando um cofre remoto usando o GIT​

Preparando o ambiente para o Cofre​

Atualizando o Gopass usando pacote​

Atualizando o Gopass usando Go​

Usando o Gopass​

gopass ls​

gopass find ou gopass search​

Decriptar senhas​

gopass insert​

gopass edit​

gopass insert (com argumentos)​

gopass mv​

gopass rm​

gopass pwgen​

gopass generate​

gopass cp​

gopass audit​

gopass history​

Comandos extras​

Inicializando um segundo Cofre​

Fontes​

Backends

Armazenamento

Criptografia

Recipients

Cofres

Instalação via pacote

Instalação manual

Chave GPG

Primeiros passos

Criando um cofre local usando o File System - FS (não recomendado)

Preparando o ambiente para o Cofre

Inicializando o Cofre

Adicionando outros usuários ao Cofre

Adicionando uma senha

Criando um cofre local usando GIT File System - GITFS

Preparando o ambiente para o Cofre

Inicializando o Cofre

Adicionando outros usuários ao Cofre

Adicionando uma senha

Criando um cofre remoto usando o GIT

Preparando o ambiente para o Cofre

Atualizando o Gopass usando pacote

Atualizando o Gopass usando Go

Usando o Gopass

gopass ls

gopass find ou gopass search

Decriptar senhas

gopass insert

gopass edit

gopass insert (com argumentos)

gopass mv

gopass rm

gopass pwgen

gopass generate

gopass cp

gopass audit

gopass history

Comandos extras

Inicializando um segundo Cofre

Fontes