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 // 'find';
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 If no I<command> is given, B<find> is assumed.
315 
316 =head1 DESCRIPTION
317 
318 B<plass> is a simple password manager.  It manages passwords stored in
319 a directory tree rooted at I<~/.password-store> (or I<$PLASS_STORE>),
320 where every password is a single file encrypted with gpg2(1).
321 
322 Passwords entries can be referenced using the path relative to the
323 store directory.  The extension ".gpg" is optional.
324 
325 The whole store is supposed to be managed by the got(1) version
326 control system.
327 
328 The commands for B<plass> are as follows:
329 
330 =over
331 
332 =item B<cat> I<entries ...>
333 
334 Decrypt and print the passwords of the given I<entries>.
335 
336 =item B<find> [I<pattern>]
337 
338 Print one per line all the entries of the store, optionally filtered
339 by the given I<pattern>.
340 
341 =item B<gen> [B<-nq>] [B<-c> I<chars>] [B<-l> I<length>] I<entry>
342 
343 Generate and persist a password for the given I<entry> in the store.
344 B<-c> can be used to control the characters allowed in the password
345 (by default I<!-~> i.e. all the printable ASCII character) and B<-l>
346 the length (32 by default.)
347 
348 Unless B<-q> is provided, plass prints the generated password.
349 
350 If the B<-n> option is given, plass won't persist the password.
351 
352 =item B<got> I<arguments ...>
353 
354 Execute got(1) in the password store directory with the given
355 I<arguments>.
356 
357 =item B<mv> I<from> I<to>
358 
359 Rename a password entry, doesn't work with directories.  I<from> must
360 exist and I<to> mustn't.
361 
362 =item B<rm> I<entry>
363 
364 Remove the password I<entry> from the store.
365 
366 =item B<tee> [B<-q>] I<entry>
367 
368 Prompt for a password, persist it in the store under the given
369 I<entry> name and then print it again to standard output.
370 
371 =item B<tog> I<arguments ...>
372 
373 Execute tog(1) in the password store directory with the given
374 I<arguments>.
375 
376 =back
377 
378 =head1 CREATING A PASSWORD STORE
379 
380 A password store is just a normal got(1) repository with a worktree
381 checked out in I<~/.password-store> (or I<$PLASS_STORE>).  The only
382 restriction is that a file called I<.gpg-id> must exist in the root of
383 the work tree for most B<plass> commands to work.
384 
385 For example, a got repository and password store can be created as
386 follows:
387 
388 	$ mkdir .password-store
389 	$ cd .password-store
390 	$ echo foo@example.com > .gpg-id
391 	$ cd ~/git
392 	$ got init pass.git
393 	$ got import -r pass.git -m 'initial import' ~/.password-store
394 	$ cd ~/.password-store
395 	$ got checkout -E ~/git/pass.git .
396 
397 See got(1) for more information.
398 
399 Otherwise, if a repository already exists, a password-store can be
400 checked out more simply as:
401 
402 	$ got checkout ~/git/pass.git ~/.password-store
403 
404 To migrate from pass(1), just delete I<~/.password-store> and checkout
405 it again using got(1).
406 
407 =head1 ENVIRONMENT
408 
409 =over
410 
411 =item PLASS_CHARS
412 
413 Default range of characters to use to generate passwords.
414 
415 =item PLASS_GOT
416 
417 Path to the got(1) executable.
418 
419 =item PLASS_GPG
420 
421 Path to the gpg2(1) executable.
422 
423 =item PLASS_LENGTH
424 
425 Default length for the passwords generated.
426 
427 =item PLASS_STORE
428 
429 Path to the password-store directory tree.  I<~/.password-store> by
430 default.
431 
432 =item PLASS_TOG
433 
434 Path to the tog(1) executable.
435 
436 =back
437 
438 =head1 FILES
439 
440 =over
441 
442 =item I<~/.password-store>
443 
444 Password store used by default.
445 
446 =item I<~/.password-store/.gpg-id>
447 
448 File containing the gpg recipient used to encrypt the passwords.
449 
450 =back
451 
452 =head1 ACKNOWLEDGEMENTS
453 
454 B<plass> was heavily influenced by pass(1) in the design, but it's a
455 complete different implementation with different tools involved.
456 
457 =head1 AUTHORS
458 
459 The B<plass> utility was written by Omar Polo <I<op@omarpolo.com>>.
460 
461 =head1 CAVEATS
462 
463 B<plass> B<find> output format isn't designed to handle files with
464 newlines in them.  Use find(1) B<-print0> or similar if it's a
465 concern.
466 
467 There isn't a B<init> sub-command, the store initialisation must be
468 performed manually.
469 
470 =cut