1 #!/usr/bin/env perl
2 #
3 # Copyright (c) 2022 Omar Polo <op@omarpolo.com>
4 #
5 # Permission to use, copy, modify, and distribute this software for any
6 # purpose with or without fee is hereby granted, provided that the above
7 # copyright notice and this permission notice appear in all copies.
8 #
9 # THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 # OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 
17 use strict;
18 use warnings;
19 use v5.32;
20 
21 use open ":std", ":encoding(UTF-8)";
22 
23 use Getopt::Long qw(:config bundling require_order);
24 use Pod::Usage;
25 use File::Basename;
26 use File::Find;
27 
28 my $store = $ENV{'PLASS_STORE'} // $ENV{'HOME'}.'/.password-store';
29 
30 my $got = $ENV{'PLASS_GOT'} // 'got';
31 my $tog = $ENV{'PLASS_TOG'} // 'tog';
32 
33 my $gpg = $ENV{'PLASS_GPG'} // 'gpg2';
34 my @gpg_flags = qw(--quiet --compress-algo=none --no-encrypt-to);
35 
36 my $default_chars = $ENV{'PLASS_CHARS'} // '!-~';
37 my $default_length = $ENV{'PLASS_LENGTH'};
38 if (!defined($default_length) || $default_length lt 0) {
39 	$default_length = 32;
40 }
41 
42 GetOptions(
43 	"h|?" => sub { pod2usage(0) },
44     ) or pod2usage(1);
45 
46 my $cmd = shift or pod2usage(1);
47 
48 my %subcmd = (
49 	cat	=> [\&cmd_cat,		"entries..."],
50 	find	=> [\&cmd_find,		"[pattern]"],
51 	gen	=> [\&cmd_gen,		"[-nq] [-c chars] [-l length] entry"],
52 	got	=> [\&cmd_got,		"args ..."],
53 	mv	=> [\&cmd_mv,		"from to"],
54 	rm	=> [\&cmd_rm,		"entry"],
55 	tee	=> [\&cmd_tee,		"[-q] entry"],
56 	tog	=> [\&cmd_tog,		"args ..."],
57     );
58 pod2usage(1) unless defined $subcmd{$cmd};
59 my ($fn, $usage) = @{$subcmd{$cmd}};
60 chdir $store;
61 $fn->();
62 exit 0;
63 
64 
65 # utils
66 
67 sub usage {
68 	my $prog = basename $0;
69 	say STDERR "Usage: $prog $cmd $usage";
70 	exit 1;
71 }
72 
73 sub name2file {
74 	my $f = shift;
75 	$f .= ".gpg" unless $f =~ m,\.gpg$,;
76 	return $f;
77 }
78 
79 # tr -cd -- $chars < /dev/random | dd bs=$len count=1 status=none
80 sub gen {
81 	my ($chars, $length) = @_;
82 	my $pass = "";
83 
84 	open(my $fh, '<:raw', '/dev/random')
85 	    or die "can't open /dev/random: $!";
86 	my $l = $length;
87 	while ($l gt 0) {
88 		read($fh, my $t, $length * 4)
89 		    or die "failed to read /dev/random: $!";
90 		$t =~ s/[^$chars]//g;
91 		$l -= length($t);
92 		$pass .= $t;
93 	}
94 	close($fh);
95 
96 	return substr($pass, 0, $length);
97 }
98 
99 sub readpass {
100 	# todo some stty black magic to avoid echo
101 	print shift if -t;
102 	my $pass = <>;
103 	die "failed to read stdin: $!" unless defined($pass);
104 	chomp $pass;
105 	return $pass;
106 }
107 
108 sub mkdirs {
109 	my $dir = shift;
110 	my $parent = dirname $dir;
111 	mkdirs($parent) unless -d $parent || $parent eq '/';
112 	mkdir $dir or die "mkdir $dir: $!"
113 	    unless -d $dir;
114 }
115 
116 sub writepass {
117 	my ($file, $pass) = @_;
118 
119 	mkdirs(dirname $file);
120 
121 	my @args = ($gpg, @gpg_flags, '-e', '-r', recipient(),
122 	    '-o', $file);
123 	open my $fh, '|-', @args;
124 	say $fh "$pass";
125 	close($fh);
126 }
127 
128 sub recipient {
129 	open my $fh, '<', "$store/.gpg-id"
130 	    or die "can't open recipient file";
131 	my $r = <$fh>;
132 	chomp $r;
133 	close($fh);
134 	return $r;
135 }
136 
137 sub passfind {
138 	my $pattern = shift;
139 	my @entries;
140 
141 	find({
142 		wanted => sub {
143 			if (m,/.git$, || m,/.got$,) {
144 				$File::Find::prune = 1;
145 				return;
146 			}
147 
148 			return if defined($pattern) && ! m/$pattern/;
149 			return unless -f && m,.gpg$,;
150 
151 			s,^$store/*,,;
152 			s,.gpg$,,;
153 			push @entries, $_;
154 		},
155 		no_chdir => 1,
156 		follow_fast => 1,
157 	     }, ($store));
158 	return sort(@entries);
159 }
160 
161 sub got {
162 	# discard stdout
163 	open my $fh, '-|', ($got, @_);
164 	close($fh);
165 	return !$?;
166 }
167 
168 sub got_add {
169 	return got 'add', '-I', shift;
170 }
171 
172 sub got_rm {
173 	got 'remove', '-f', shift
174 	    or exit(1);
175 }
176 
177 sub got_ci {
178 	my $pid = fork;
179 	die "failed to fork: $!" unless defined $pid;
180 
181 	if ($pid ne 0) {
182 		wait;
183 		die "failed to commit changes" if $?;
184 		return;
185 	}
186 
187 	open (STDOUT, ">&", \*STDERR)
188 	    or die "can't redirect stdout to stderr";
189 	exec ($got, 'commit', '-m', shift)
190 	    or die "failed to exec $got: $!";
191 }
192 
193 
194 # cmds
195 
196 sub cmd_cat {
197 	GetOptions('h|?' => \&usage) or usage;
198 	usage unless @ARGV;
199 
200 	while (@ARGV) {
201 		my $file = name2file(shift @ARGV);
202 		system ($gpg, @gpg_flags, '-d', $file);
203 		die "failed to exec $gpg: $!" if $? == -1;
204 	}
205 }
206 
207 sub cmd_find {
208 	GetOptions('h|?' => \&usage) or usage;
209 	usage if @ARGV gt 1;
210 
211 	map { say $_ } passfind(shift @ARGV);
212 }
213 
214 sub cmd_gen {
215 	my $chars = $default_chars;
216 	my $length = $default_length;
217 	my $nop;
218 	my $q;
219 
220 	GetOptions(
221 		'c=s' => sub { $chars = $_[1] },
222 		'h|?' => \&usage,
223 		'l=i' => sub { $length = $_[1] },
224 		'n'   => \$nop,
225 		'q'   => \$q,
226 	    ) or usage;
227 	usage if @ARGV ne 1;
228 
229 	my $name = shift @ARGV;
230 	my $file = name2file $name;
231 	my $renamed = -f $file;
232 
233 	my $pass = gen($chars, $length);
234 
235 	unless ($nop) {
236 		writepass($file, $pass);
237 		got_add $file;
238 		got_ci($renamed ? "update $name" : "+$name");
239 	}
240 	say $pass unless $q;
241 }
242 
243 sub cmd_got {
244 	exec $got, @ARGV;
245 }
246 
247 # TODO: handle moving directories?
248 sub cmd_mv {
249 	GetOptions('h|?' => \&usage) or usage;
250 	usage if @ARGV ne 2;
251 
252 	my $a = shift @ARGV;
253 	my $b = shift @ARGV;
254 
255 	my $pa = name2file $a;
256 	my $pb = name2file $b;
257 
258 	die "source password doesn't exist" unless -f $pa;
259 	die "target password exists" if -f $pb;
260 
261 	rename $pa, $pb or die "can't rename $a to $b: $!";
262 
263 	got_rm $pa;
264 	got_add $pb or die "can't add $pb\n";
265 	got_ci "mv $a $b";
266 }
267 
268 sub cmd_rm {
269 	GetOptions('h|?' => \&usage) or usage;
270 	usage if @ARGV ne 1;
271 
272 	my $name = shift @ARGV;
273 	my $file = name2file $name;
274 
275 	got_rm $file;
276 	got_ci "-$name";
277 }
278 
279 sub cmd_tee {
280 	my $q;
281 	GetOptions(
282 		'h|?' => \&usage,
283 		'q'   => \$q,
284 	    ) or usage;
285 	usage if @ARGV ne 1;
286 
287 	my $name = shift @ARGV;
288 	my $file = name2file $name;
289 
290 	my $pass = readpass "Enter the password: ";
291 	writepass($file, $pass);
292 
293 	got_add $file;
294 	got_ci (-f $file ? "update $name" : "+$name");
295 	say $pass unless $q;
296 }
297 
298 sub cmd_tog {
299 	exec $tog, @ARGV;
300 }
301 
302 __END__
303 
304 =head1 NAME
305 
306 B<plass> - manage passwords
307 
308 =head1 SYNOPSIS
309 
310 B<plass> I<command> [-h] [arg ...]
311 
312 Valid subcommands are: cat, find, gen, got, mv, rm, tee, tog.
313 
314 =head1 DESCRIPTION
315 
316 B<plass> is a simple password manager.  It manages passwords stored in
317 a directory tree rooted at I<~/.password-store> (or I<$PLASS_STORE>),
318 where every password is a single file encrypted with gpg2(1).
319 
320 Passwords entries can be referenced using the path relative to the
321 store directory.  The extension ".gpg" is optional.
322 
323 The whole store is supposed to be managed by the got(1) version
324 control system.
325 
326 The commands for B<plass> are as follows:
327 
328 =over
329 
330 =item B<cat> I<entries ...>
331 
332 Decrypt and print the passwords of the given I<entries>.
333 
334 =item B<find> [I<pattern>]
335 
336 Print one per line all the entries of the store, optionally filtered
337 by the given I<pattern>.
338 
339 =item B<gen> [B<-nq>] [B<-c> I<chars>] [B<-l> I<length>] I<entry>
340 
341 Generate and persist a password for the given I<entry> in the store.
342 B<-c> can be used to control the characters allowed in the password
343 (by default I<!-~> i.e. all the printable ASCII character) and B<-l>
344 the length (32 by default.)
345 
346 Unless B<-q> is provided, plass prints the generated password.
347 
348 If the B<-n> option is given, plass won't persist the password.
349 
350 =item B<got> I<arguments ...>
351 
352 Execute got(1) in the password store directory with the given
353 I<arguments>.
354 
355 =item B<mv> I<from> I<to>
356 
357 Rename a password entry, doesn't work with directories.  I<from> must
358 exist and I<to> mustn't.
359 
360 =item B<rm> I<entry>
361 
362 Remove the password I<entry> from the store.
363 
364 =item B<tee> [B<-q>] I<entry>
365 
366 Prompt for a password, persist it in the store under the given
367 I<entry> name and then print it again to standard output.
368 
369 =item B<tog> I<arguments ...>
370 
371 Execute tog(1) in the password store directory with the given
372 I<arguments>.
373 
374 =back
375 
376 =head1 CREATING A PASSWORD STORE
377 
378 A password store is just a normal got(1) repository with a worktree
379 checked out in I<~/.password-store> (or I<$PLASS_STORE>).  The only
380 restriction is that a file called I<.gpg-id> must exist in the root of
381 the work tree for most B<plass> commands to work.
382 
383 For example, a got repository and password store can be created as
384 follows:
385 
386 	$ mkdir .password-store
387 	$ cd .password-store
388 	$ echo foo@example.com > .gpg-id
389 	$ cd ~/git
390 	$ got init pass.git
391 	$ got import -r pass.git -m 'initial import' ~/.password-store
392 	$ cd ~/.password-store
393 	$ got checkout -E ~/git/pass.git .
394 
395 See got(1) for more information.
396 
397 Otherwise, if a repository already exists, a password-store can be
398 checked out more simply as:
399 
400 	$ got checkout ~/git/pass.git ~/.password-store
401 
402 To migrate from pass(1), just delete I<~/.password-store> and checkout
403 it again using got(1).
404 
405 =head1 ENVIRONMENT
406 
407 =over
408 
409 =item PLASS_CHARS
410 
411 Default range of characters to use to generate passwords.
412 
413 =item PLASS_GOT
414 
415 Path to the got(1) executable.
416 
417 =item PLASS_GPG
418 
419 Path to the gpg2(1) executable.
420 
421 =item PLASS_LENGTH
422 
423 Default length for the passwords generated.
424 
425 =item PLASS_STORE
426 
427 Path to the password-store directory tree.  I<~/.password-store> by
428 default.
429 
430 =item PLASS_TOG
431 
432 Path to the tog(1) executable.
433 
434 =back
435 
436 =head1 FILES
437 
438 =over
439 
440 =item I<~/.password-store>
441 
442 Password store used by default.
443 
444 =item I<~/.password-store/.gpg-id>
445 
446 File containing the gpg recipient used to encrypt the passwords.
447 
448 =back
449 
450 =head1 ACKNOWLEDGEMENTS
451 
452 B<plass> was heavily influenced by pass(1) in the design, but it's a
453 complete different implementation with different tools involved.
454 
455 =head1 AUTHORS
456 
457 The B<plass> utility was written by Omar Polo <I<op@omarpolo.com>>.
458 
459 =head1 CAVEATS
460 
461 B<plass> B<find> output format isn't designed to handle files with
462 newlines in them.  Use find(1) B<-print0> or similar if it's a
463 concern.
464 
465 There isn't a B<init> sub-command, the store initialisation must be
466 performed manually.
467 
468 =cut