+sub import {
+ hook(type => "getsetup", id => "passwordauth", "call" => \&getsetup);
+ hook(type => "formbuilder_setup", id => "passwordauth", call => \&formbuilder_setup);
+ hook(type => "formbuilder", id => "passwordauth", call => \&formbuilder);
+ hook(type => "sessioncgi", id => "passwordauth", call => \&sessioncgi);
+ hook(type => "auth", id => "passwordauth", call => \&auth);
+}
+
+sub getsetup () {
+ return
+ plugin => {
+ safe => 1,
+ rebuild => 0,
+ section => "auth",
+ },
+ account_creation_password => {
+ type => "string",
+ example => "s3cr1t",
+ description => "a password that must be entered when signing up for an account",
+ safe => 1,
+ rebuild => 0,
+ },
+ password_cost => {
+ type => "integer",
+ example => 8,
+ description => "cost of generating a password using Authen::Passphrase::BlowfishCrypt",
+ safe => 1,
+ rebuild => 0,
+ },
+}
+
+# Checks if a string matches a user's password, and returns true or false.
+sub checkpassword ($$;$) {
+ my $user=shift;
+ my $password=shift;
+ my $field=shift || "password";
+
+ # It's very important that the user not be allowed to log in with
+ # an empty password!
+ if (! length $password) {
+ return 0;
+ }
+
+ my $userinfo=IkiWiki::userinfo_retrieve();
+ if (! length $user || ! defined $userinfo ||
+ ! exists $userinfo->{$user} || ! ref $userinfo->{$user}) {
+ return 0;
+ }
+
+ my $ret=0;
+ if (exists $userinfo->{$user}->{"crypt".$field}) {
+ eval q{use Authen::Passphrase};
+ error $@ if $@;
+ my $p = Authen::Passphrase->from_crypt($userinfo->{$user}->{"crypt".$field});
+ $ret=$p->match($password);
+ }
+ elsif (exists $userinfo->{$user}->{$field}) {
+ $ret=$password eq $userinfo->{$user}->{$field};
+ }
+
+ if ($ret &&
+ (exists $userinfo->{$user}->{resettoken} ||
+ exists $userinfo->{$user}->{cryptresettoken})) {
+ # Clear reset token since the user has successfully logged in.
+ delete $userinfo->{$user}->{resettoken};
+ delete $userinfo->{$user}->{cryptresettoken};
+ IkiWiki::userinfo_store($userinfo);
+ }
+
+ return $ret;
+}
+
+sub setpassword ($$;$) {
+ my $user=shift;
+ my $password=shift;
+ my $field=shift || "password";
+
+ eval q{use Authen::Passphrase::BlowfishCrypt};
+ if (! $@) {
+ my $p = Authen::Passphrase::BlowfishCrypt->new(
+ cost => $config{password_cost} || 8,
+ salt_random => 1,
+ passphrase => $password,
+ );
+ IkiWiki::userinfo_set($user, "crypt$field", $p->as_crypt);
+ IkiWiki::userinfo_set($user, $field, "");
+ }
+ else {
+ IkiWiki::userinfo_set($user, $field, $password);
+ }
+
+ # Setting the password clears any passwordless login token.
+ if ($field ne 'passwordless') {
+ IkiWiki::userinfo_set($user, "passwordless", "");
+ }
+}
+
+# Generates a token that can be used to log the user in.
+# This needs to be hard to guess. Generating a cgi session id will
+# make it as hard to guess as any cgi session.
+sub gentoken ($$;$) {
+ my $user=shift;
+ my $tokenfield=shift;
+ my $reversable=shift;
+
+ eval q{use CGI::Session};
+ error($@) if $@;
+ my $token = CGI::Session->new->id;
+ if (! $reversable) {
+ setpassword($user, $token, $tokenfield);
+ }
+ else {
+ IkiWiki::userinfo_set($user, $tokenfield, $token);
+ }
+ return $token;
+}
+
+# An anonymous user has no normal password, only a passwordless login
+# token. Given an email address, this sets up such a user for that email,
+# unless one already exists, and returns the username.
+sub anonuser ($) {
+ my $email=shift;
+
+ # Want a username for this email that won't overlap with any other.
+ my $user=$email;
+ $user=~s/@/_/g;
+
+ my $userinfo=IkiWiki::userinfo_retrieve();
+ if (! exists $userinfo->{$user} || ! ref $userinfo->{$user}) {
+ if (IkiWiki::userinfo_setall($user, {
+ 'email' => $email,
+ 'regdate' => time})) {
+ gentoken($user, "passwordless", 1);
+ return $user;
+ }
+ else {
+ error(gettext("Error creating account."));
+ }
+ }
+ elsif (defined anonusertoken($userinfo->{$user})) {
+ return $user;
+ }
+ else {
+ return undef;
+ }
+}
+
+sub anonusertoken ($) {
+ my $userhash=shift;
+ if (exists $userhash->{passwordless} &&
+ length $userhash->{passwordless}) {
+ return $userhash->{passwordless};
+ }
+ else {
+ return undef;
+ }
+}