eletrotupi

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179


---
title: "Senhas"
date: 2020-08-03
tags: ["tecnologia", "organizacao", "pass"]
---

Senhas. Um problema, uma confusão. Perder uma senha hoje é um inferno,
considerando que praticamente dependemos de dezenas de serviços onlines,
das quais praticamente guardam e conhecem a nossa vida, até melhor que
nós mesmos. Nesse cenário, gerenciar, guardar e ter em sincronia essas
senhas é uma tarefa chata e complexa. Podemos tornar isso menos
complexo, se utilizarmos um gerenciador de senhas.

Existem diversos, eu já passei por alguns, comecei com
o [1Password](https://1password.com), [LastPass](https://lastpass.com),
[Buttercup](https://buttercup.pw) e finalmente aterrisei no
[Pass](https://passwordstore.org).

## Usando o Pass

Tecnicamente falando, o Pass não tem bancos de dados, não tem cadastros,
nem nada complexo. Na verdade ele só conecta arquivos de textos com
o GnuPG, ou um gerenciador de chaves digitais, o que eu acredito ser
o tipo de ferramenta ideal, afinal além de mínimo (44kb), não ser intrusivo,
ele se utiliza de outras ferramentas sólidas e maduras. Justamente por
ser arquivos de texto normais, te oferece uma liberdade extra de você
organizar da forma que você julgar mais apropriado. Inclusive, não
precisa ser necessariamente senhas, podendo ser qualquer coisa que você
quiser, como dados de cartão, documentos sensíveis, configuração de
acesso, etc. Para informações mais aprofundadas, consulte o site do
[Pass](https://passwordstore.org), e o [Guia de mão do
GnuPG (em inglês)](https://www.gnupg.org/gph/en/manual.html).

### Iniciando

Primeiramente, instale o `pass` de acordo com o seu sistema operacional,
ou seja, através do seu gerenciador de pacotes nas distribuições Linux
ou o `brew` no macOS e instale também o `gpg`.

Se você não está familiarizado com PGP, recomendo novamente dar uma lida
no [Guia de mão do GnuPG (em inglês)](https://www.gnupg.org/gph/en/manual.html).
Basicamente o PGP funciona gerando um par de chaves, uma pública e uma
privada, e com essas chaves você pode criptografar e descriptografar
arquivos. Quando você gera uma chave, você ganha um fingerprint
(digital) da qual representa essa chave.

Para gerar uma chave nova, é bem simples.

```shell
$ gpg --gen-key
$ gpg --list-keys
```

Aproveite e faça backup das duas e mantenha em um lugar seguro, como um
pen-drive, um HD externo, etc:

```shell
$ gpg --export-secret-keys --armor <fingerprint> > privkey.asc
$ gpg --export --armor <fingerprint> > pubkey.asc
```

### Usando o `pass`

Bom, agora que você já fez backup, vamos usar essa chave para
inicializar o pass e informar que você quer criptografar as suas senhas
usando essa chave em específico.

```shell
$ pass init <fingerprint>
```

Relembrando, cada entrada no teu banco de senhas é um próprio arquivo,
e você pode armazenar quaisquer informação de texto nesses arquivos,
nomes de usuário, senhas, emails, respostas para informações secretas,
etc. Novamente, dê uma olhada no manual do pass. Além de uma ótima
documentação ([e ser offline](https://porcellis.com/primeiramente-man)),
ele oferece também alguns exemplos de como organizar melhor suas senhas,
exemplos, etc.

```shell
$ man pass
```

Uma funcionalidade que eu gosto muito, é de transformar seu banco de
senhas em um repositório git, podendo assim sincronizar em qualquer
lugar.

### Transformando esse banco em repositório git

Para inicio, é bom se familiarizar com os termos e como funciona o git.
Deixo de recomendação, a [própria documentação do
Git](https://git-scm.com/book/pt-br/v2). Feito isso, você vai precisar
de um repositório `bare` ou como eu gosto de chamar, um "repositório
backend". Aqui existem duas opções, dependendo de onde você pretende
guardar essas informações. Auto-hospedando em um servidor próprio, ou
usando um serviço como o Github/Gitlab e derivados.

Se você, assim como eu, prefere colocar isso num servidor próprio,
afinal estamos falando de senhas e informações sensíveis, basta seguir
aqui o seguinte passo no seu servidor para criar um repositório `bare`:

```shell
$ git init --bare ~/.password-store
```

Diga para o `pass` que você quer que seu banco de senhas seja um
repositório git e indique para qual repositório bare o git deve mandar
os dados, seja aqui no seu servidor ou no Github/Gitlab.

```shell
$ pass git init
$ pass git remote add origin user@serve
$ pass git push
```

_Se você criou um repositório no Github/GitLab/etc basta apontar para
`git@github.com:user
a documentação do serviço que você usa._

Pronto, agora para usar o seu repositório em uma máquina diferente
é simples, basta importar as chaves, e clonar o repositório.

Importando as chaves:

```shell
$ gpg --import pubkey.asc
$ gpg --allow-secret-key-import --import privkey.asc
```

Talvez seja necessário
[Confiar (em inglês)](https://www.gnupg.org/gph/en/manual.html#AEN346) as novas
chaves.

```shell
$ gpg --edit-key <fingerprint>
```

Clone o repositório diretamente na pasta padrão que o `pass` procura.

```shell
$ git clone user@serve
```

Feito, agora basta sincronizar os dois hospedeiros usando `pass git
push` e `pass git pull`. Se você precisar remover, basta apagar a pasta
com `rm -rf ~/.password-store` e voilá.

## Certo, e no celular?

No celular é relativamente simples. Usando o F-Droid[^f-droid], basta
instalar
o [openKeychain](https://f-droid.org/en/packages/org.sufficientlysecure.keychain/)
e o [PasswordStore](https://github.com/android-password-store/Android-Password-Store).
Dê uma olhada com calma na documentação dos dois aplicativos. Marquei os
links para algumas referências no rodapé.

### Importando sua chave digital

O primeiro passo é de importar a sua chave digital no
`openKeychain`[^open-key-chain]. No
meu caso, eu transferi elas para o meu celular e fiz o passo manual de
importar elas através do aplicativo (é bem auto-explicativo).

### Configurar o Password Store

Já no `PasswordStore`[^password-store], nas configurações primeiro você deve indicar qual
chave digital quer utilizar (ele automáticamente busca primeiro no
`openKeychain`).

Depois, na seção de Repository, idealmente você deve gerar uma chave SSH
e importá-la no seu servidor ou na sua conta do Github/Gitlab.

E basta configurar os dados como login e senha de acesso ao seu
servidor, e qual URL buscar e enviar as senhas.

[^f-droid]: https://f-droid.org
[^open-key-chain]: https://www.openkeychain.org/
[^password-store]: https://github.com/android-password-store/Android-Password-Store/wiki/First-time-setup