rt/lib/RT/Interface/Email/Auth/GnuPG.pm

   1 # BEGIN BPS TAGGED BLOCK {{{
   2 #
   3 # COPYRIGHT:
   4 #
   5 # This software is Copyright (c) 1996-2009 Best Practical Solutions, LLC
   6 #                                          <jesse@bestpractical.com>
   7 #
   8 # (Except where explicitly superseded by other copyright notices)
   9 #
  10 #
  11 # LICENSE:
  12 #
  13 # This work is made available to you under the terms of Version 2 of
  14 # the GNU General Public License. A copy of that license should have
  15 # been provided with this software, but in any event can be snarfed
  16 # from www.gnu.org.
  17 #
  18 # This work is distributed in the hope that it will be useful, but
  19 # WITHOUT ANY WARRANTY; without even the implied warranty of
  20 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21 # General Public License for more details.
  22 #
  23 # You should have received a copy of the GNU General Public License
  24 # along with this program; if not, write to the Free Software
  25 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  26 # 02110-1301 or visit their web page on the internet at
  27 # http://www.gnu.org/licenses/old-licenses/gpl-2.0.html.
  28 #
  29 #
  30 # CONTRIBUTION SUBMISSION POLICY:
  31 #
  32 # (The following paragraph is not intended to limit the rights granted
  33 # to you to modify and distribute this software under the terms of
  34 # the GNU General Public License and is only of importance to you if
  35 # you choose to contribute your changes and enhancements to the
  36 # community by submitting them to Best Practical Solutions, LLC.)
  37 #
  38 # By intentionally submitting any modifications, corrections or
  39 # derivatives to this work, or any other work intended for use with
  40 # Request Tracker, to Best Practical Solutions, LLC, you confirm that
  41 # you are the copyright holder for those contributions and you grant
  42 # Best Practical Solutions,  LLC a nonexclusive, worldwide, irrevocable,
  43 # royalty-free, perpetual, license to use, copy, create derivative
  44 # works based on those contributions, and sublicense and distribute
  45 # those contributions and any derivatives thereof.
  46 #
  47 # END BPS TAGGED BLOCK }}}
  48
  49 package RT::Interface::Email::Auth::GnuPG;
  50
  51 use strict;
  52 use warnings;
  53
  54 =head2 GetCurrentUser
  55
  56 To use the gnupg-secured mail gateway, you need to do the following:
  57
  58 Set up a GnuPG key directory with a pubring containing only the keys
  59 you care about and specify the following in your SiteConfig.pm
  60
  61     Set(%GnuPGOptions, homedir => '/opt/rt3/var/data/GnuPG');
  62     Set(@MailPlugins, 'Auth::MailFrom', 'Auth::GnuPG', ...other filter...);
  63
  64 =cut
  65
  66 sub ApplyBeforeDecode { return 1 }
  67
  68 use RT::Crypt::GnuPG;
  69 use RT::EmailParser ();
  70
  71 sub GetCurrentUser {
  72     my %args = (
  73         Message       => undef,
  74         RawMessageRef => undef,
  75         @_
  76     );
  77
  78     $args{'Message'}->head->delete($_)
  79         for qw(X-RT-GnuPG-Status X-RT-Incoming-Encrypton
  80                X-RT-Incoming-Signature X-RT-Privacy);
  81
  82     my $msg = $args{'Message'}->dup;
  83
  84     my ($status, @res) = VerifyDecrypt( Entity => $args{'Message'} );
  85     if ( $status && !@res ) {
  86         $args{'Message'}->head->add(
  87             'X-RT-Incoming-Encryption' => 'Not encrypted'
  88         );
  89
  90         return 1;
  91     }
  92
  93     # FIXME: Check if the message is encrypted to the address of
  94     # _this_ queue. send rejecting mail otherwise.
  95
  96     unless ( $status ) {
  97         $RT::Logger->error("Had a problem during decrypting and verifying");
  98         my $reject = HandleErrors( Message => $args{'Message'}, Result => \@res );
  99         return (0, 'rejected because of problems during decrypting and verifying')
 100             if $reject;
 101     }
 102
 103     # attach the original encrypted message
 104     $args{'Message'}->attach(
 105         Type        => 'application/x-rt-original-message',
 106         Disposition => 'inline',
 107         Data        => ${ $args{'RawMessageRef'} },
 108     );
 109
 110     $args{'Message'}->head->add( 'X-RT-Privacy' => 'PGP' );
 111
 112     foreach my $part ( $args{'Message'}->parts_DFS ) {
 113         my $decrypted;
 114
 115         my $status = $part->head->get( 'X-RT-GnuPG-Status' );
 116         if ( $status ) {
 117             for ( RT::Crypt::GnuPG::ParseStatus( $status ) ) {
 118                 if ( $_->{Operation} eq 'Decrypt' && $_->{Status} eq 'DONE' ) {
 119                     $decrypted = 1;
 120                 }
 121                 if ( $_->{Operation} eq 'Verify' && $_->{Status} eq 'DONE' ) {
 122                     $part->head->add(
 123                         'X-RT-Incoming-Signature' => $_->{UserString}
 124                     );
 125                 }
 126             }
 127         }
 128
 129         $part->head->add(
 130             'X-RT-Incoming-Encryption' =>
 131                 $decrypted ? 'Success' : 'Not encrypted'
 132         );
 133     }
 134
 135     return 1;
 136 }
 137
 138 sub HandleErrors {
 139     my %args = (
 140         Message => undef,
 141         Result => [],
 142         @_
 143     );
 144
 145     my $reject = 0;
 146
 147     my %sent_once = ();
 148     foreach my $run ( @{ $args{'Result'} } ) {
 149         my @status = RT::Crypt::GnuPG::ParseStatus( $run->{'status'} );
 150         unless ( $sent_once{'NoPrivateKey'} ) {
 151             unless ( CheckNoPrivateKey( Message => $args{'Message'}, Status => \@status ) ) {
 152                 $sent_once{'NoPrivateKey'}++;
 153                 $reject = 1 if RT->Config->Get('GnuPG')->{'RejectOnMissingPrivateKey'};
 154             }
 155         }
 156         unless ( $sent_once{'BadData'} ) {
 157             unless ( CheckBadData( Message => $args{'Message'}, Status => \@status ) ) {
 158                 $sent_once{'BadData'}++;
 159                 $reject = 1 if RT->Config->Get('GnuPG')->{'RejectOnBadData'};
 160             }
 161         }
 162     }
 163     return $reject;
 164 }
 165
 166 sub CheckNoPrivateKey {
 167     my %args = (Message => undef, Status => [], @_ );
 168     my @status = @{ $args{'Status'} };
 169
 170     my @decrypts = grep $_->{'Operation'} eq 'Decrypt', @status;
 171     return 1 unless @decrypts;
 172     foreach my $action ( @decrypts ) {
 173         # if at least one secrete key exist then it's another error
 174         return 1 if
 175             grep !$_->{'User'}{'SecretKeyMissing'},
 176                 @{ $action->{'EncryptedTo'} };
 177     }
 178
 179     $RT::Logger->error("Couldn't decrypt a message: have no private key");
 180
 181     my $address = (RT::Interface::Email::ParseSenderAddressFromHead( $args{'Message'}->head ))[0];
 182     my ($status) = RT::Interface::Email::SendEmailUsingTemplate(
 183         To        => $address,
 184         Template  => 'Error: no private key',
 185         Arguments => {
 186             Message   => $args{'Message'},
 187             TicketObj => $args{'Ticket'},
 188         },
 189         InReplyTo => $args{'Message'},
 190     );
 191     unless ( $status ) {
 192         $RT::Logger->error("Couldn't send 'Error: no private key'");
 193     }
 194     return 0;
 195 }
 196
 197 sub CheckBadData {
 198     my %args = (Message => undef, Status => [], @_ );
 199     my @bad_data_messages =
 200         map $_->{'Message'},
 201         grep $_->{'Status'} ne 'DONE' && $_->{'Operation'} eq 'Data',
 202         @{ $args{'Status'} };
 203     return 1 unless @bad_data_messages;
 204
 205     $RT::Logger->error("Couldn't process a message: ". join ', ', @bad_data_messages );
 206
 207     my $address = (RT::Interface::Email::ParseSenderAddressFromHead( $args{'Message'}->head ))[0];
 208     my ($status) = RT::Interface::Email::SendEmailUsingTemplate(
 209         To        => $address,
 210         Template  => 'Error: bad GnuPG data',
 211         Arguments => {
 212             Messages  => [ @bad_data_messages ],
 213             TicketObj => $args{'Ticket'},
 214         },
 215         InReplyTo => $args{'Message'},
 216     );
 217     unless ( $status ) {
 218         $RT::Logger->error("Couldn't send 'Error: bad GnuPG data'");
 219     }
 220     return 0;
 221 }
 222
 223 sub VerifyDecrypt {
 224     my %args = (
 225         Entity => undef,
 226         @_
 227     );
 228
 229     my @res = RT::Crypt::GnuPG::VerifyDecrypt( %args );
 230     unless ( @res ) {
 231         $RT::Logger->debug("No more encrypted/signed parts");
 232         return 1;
 233     }
 234
 235     $RT::Logger->debug('Found GnuPG protected parts');
 236
 237     # return on any error
 238     if ( grep $_->{'exit_code'}, @res ) {
 239         $RT::Logger->debug("Error during verify/decrypt operation");
 240         return (0, @res);
 241     }
 242
 243     # nesting
 244     my ($status, @nested) = VerifyDecrypt( %args );
 245     return $status, @res, @nested;
 246 }
 247
 248 eval "require RT::Interface::Email::Auth::GnuPG_Vendor";
 249 die $@
 250   if ( $@
 251     && $@ !~ qr{^Can't locate RT/Interface/Email/Auth/GnuPG_Vendor.pm} );
 252 eval "require RT::Interface::Email::Auth::GnuPG_Local";
 253 die $@
 254   if ( $@
 255     && $@ !~ qr{^Can't locate RT/Interface/Email/Auth/GnuPG_Local.pm} );
 256
 257 1;
 258