| 1 | package Mail::GPG::Result; | ||
| 2 | |||
| 3 | # $Id: Result.pm,v 1.8 2006/04/14 11:05:03 joern Exp $ | ||
| 4 | |||
| 5 | use strict; | ||
| 6 | |||
| 7 | require Encode if $] >= 5.008; | ||
| 8 | |||
| 9 | sub get_mail_gpg { shift->{mail_gpg} } | ||
| 10 | |||
| 11 | sub get_is_encrypted { shift->{is_encrypted} } | ||
| 12 | sub get_enc_ok { shift->{enc_ok} } | ||
| 13 | sub get_enc_key_id { shift->{enc_key_id} } | ||
| 14 | sub get_enc_mail { shift->{enc_mail} } | ||
| 15 | sub get_enc_key_ids { shift->{enc_key_ids} } | ||
| 16 | sub get_enc_mails { shift->{enc_mails} } | ||
| 17 | sub get_is_signed { shift->{is_signed} } | ||
| 18 | sub get_sign_ok { shift->{sign_ok} } | ||
| 19 | sub get_sign_state { shift->{sign_state} } | ||
| 20 | sub get_sign_key_id { shift->{sign_key_id} } | ||
| 21 | sub get_sign_mail { shift->{sign_mail} } | ||
| 22 | sub get_sign_mail_aliases { shift->{sign_mail_aliases} } | ||
| 23 | sub get_sign_fingerprint { shift->{sign_fingerprint} } | ||
| 24 | |||
| 25 | sub set_is_encrypted { shift->{is_encrypted} = $_[1] } | ||
| 26 | sub set_enc_ok { shift->{enc_ok} = $_[1] } | ||
| 27 | sub set_enc_key_id { shift->{enc_key_id} = $_[1] } | ||
| 28 | sub set_enc_mail { shift->{enc_mail} = $_[1] } | ||
| 29 | sub set_enc_key_ids { shift->{enc_key_ids} = $_[1] } | ||
| 30 | sub set_enc_mails { shift->{enc_mails} = $_[1] } | ||
| 31 | sub set_is_signed { shift->{is_signed} = $_[1] } | ||
| 32 | sub set_sign_ok { shift->{sign_ok} = $_[1] } | ||
| 33 | sub set_sign_state { shift->{sign_state} = $_[1] } | ||
| 34 | sub set_sign_key_id { shift->{sign_key_id} = $_[1] } | ||
| 35 | sub set_sign_mail { shift->{sign_mail} = $_[1] } | ||
| 36 | sub set_sign_mail_aliases { shift->{sign_mail_aliases} = $_[1] } | ||
| 37 | sub set_sign_fingerprint { shift->{sign_fingerprint} = $_[1] } | ||
| 38 | |||
| 39 | sub get_gpg_stdout { shift->{gpg_stdout} } | ||
| 40 | sub get_gpg_stderr { shift->{gpg_stderr} } | ||
| 41 | sub get_gpg_status { shift->{gpg_status} } | ||
| 42 | sub get_gpg_rc { shift->{gpg_rc} } | ||
| 43 | |||
| 44 | sub new { | ||
| 45 | my $class = shift; | ||
| 46 | my %par = @_; | ||
| 47 | my ($mail_gpg, $gpg_stdout, $gpg_stderr, $gpg_status, $gpg_rc) = | ||
| 48 | @par{'mail_gpg','gpg_stdout','gpg_stderr','gpg_status','gpg_rc'}; | ||
| 49 | |||
| 50 | #-- initialize reference attributes to prevent | ||
| 51 | #-- dereferencing undef errors | ||
| 52 | $gpg_stdout = \"" if not defined $gpg_stdout; | ||
| 53 | $gpg_stderr = \"" if not defined $gpg_stderr; | ||
| 54 | $gpg_status = \"" if not defined $gpg_status; | ||
| 55 | |||
| 56 | my $self = bless { | ||
| 57 | mail_gpg => $mail_gpg, | ||
| 58 | gpg_stdout => $gpg_stdout, | ||
| 59 | gpg_stderr => $gpg_stderr, | ||
| 60 | gpg_status => $gpg_status, | ||
| 61 | gpg_rc => $gpg_rc, | ||
| 62 | }, $class; | ||
| 63 | |||
| 64 | $self->analyze_result; | ||
| 65 | |||
| 66 | return $self; | ||
| 67 | } | ||
| 68 | |||
| 69 | sub analyze_result { | ||
| 70 | my $self = shift; | ||
| 71 | |||
| 72 | my ($is_signed, $sign_ok, $sign_state, | ||
| 73 | $sign_key_id, $sign_mail, $sign_fingerprint, | ||
| 74 | @sign_mail_aliases, $is_encrypted, $enc_ok, | ||
| 75 | @enc_key_ids, @enc_mails | ||
| 76 | ); | ||
| 77 | |||
| 78 | my $gpg_status = $self->get_gpg_status; | ||
| 79 | my $gpg_stderr = $self->get_gpg_stderr; | ||
| 80 | |||
| 81 | while ( $$gpg_status && $$gpg_status =~ m{^\[GNUPG:\]\s+(.*)$}mg ) { | ||
| 82 | my $line = $1; | ||
| 83 | if ( $line =~ /^(GOOD|EXP|EXPKEY|REVKEY|BAD)SIG\s+([^\s]+)\s+(.*)/ ) { | ||
| 84 | my ( $state, $key_id, $mail ) = ( $1, $2, $3 ); | ||
| 85 | $is_signed = 1; | ||
| 86 | $sign_state = $state; | ||
| 87 | $sign_key_id = $key_id; | ||
| 88 | $sign_mail = decode($mail); | ||
| 89 | $sign_ok = $sign_state eq 'GOOD'; | ||
| 90 | } | ||
| 91 | elsif ( $line =~ /^ERRSIG\s+([^\s]+)/ ) { | ||
| 92 | $is_signed = 1; | ||
| 93 | $sign_key_id = $1; | ||
| 94 | } | ||
| 95 | elsif ( $line =~ /^VALIDSIG\s+([^\s]+)/ ) { | ||
| 96 | $sign_fingerprint = $1; | ||
| 97 | } | ||
| 98 | elsif ( $line =~ /^ENC_TO\s+([^\s]+)/ ) { | ||
| 99 | push @enc_key_ids, decode($1); | ||
| 100 | $enc_mails[ @enc_key_ids - 1 ] = ""; | ||
| 101 | } | ||
| 102 | elsif ( $line =~ /^USERID_HINT\s+([^\s]+)\s+(.*)/ ) { | ||
| 103 | my ( $hint_key_id, $hint_text ) = ( $1, $2 ); | ||
| 104 | my $i = 0; | ||
| 105 | foreach my $key_id (@enc_key_ids) { | ||
| 106 | if ( $key_id eq $hint_key_id ) { | ||
| 107 | $enc_mails[$i] = decode($hint_text); | ||
| 108 | } | ||
| 109 | ++$i; | ||
| 110 | } | ||
| 111 | } | ||
| 112 | elsif ( $line =~ /^BEGIN_DECRYPTION/ ) { | ||
| 113 | $is_encrypted = 1; | ||
| 114 | } | ||
| 115 | elsif ( $line =~ /^DECRYPTION_OKAY/ ) { | ||
| 116 | $enc_ok = 1; | ||
| 117 | } | ||
| 118 | } | ||
| 119 | |||
| 120 | @sign_mail_aliases = $$gpg_stderr =~ /^gpg:\s+aka\s+"(.*?)"/mg; | ||
| 121 | |||
| 122 | if ( !$self->get_mail_gpg->get_use_long_key_ids ) { | ||
| 123 | for ( $sign_key_id, @enc_key_ids ) { | ||
| 124 | $_ = substr( $_, -8, 8 ) if defined $_; | ||
| 125 | } | ||
| 126 | } | ||
| 127 | |||
| 128 | $self->set_is_signed( $is_signed || 0 ); | ||
| 129 | $self->set_sign_ok( $sign_ok || 0 ); | ||
| 130 | $self->set_sign_state( $sign_state || "" ); | ||
| 131 | $self->set_sign_key_id( $sign_key_id || "" ); | ||
| 132 | $self->set_sign_mail( $sign_mail || "" ); | ||
| 133 | $self->set_sign_fingerprint( $sign_fingerprint || "" ); | ||
| 134 | $self->set_sign_mail_aliases( \@sign_mail_aliases ); | ||
| 135 | $self->set_is_encrypted( $is_encrypted || '0' ); | ||
| 136 | |||
| 137 | $self->set_enc_ok( $enc_ok || 0 ); | ||
| 138 | $self->set_enc_key_ids( \@enc_key_ids ); | ||
| 139 | $self->set_enc_mails( \@enc_mails ); | ||
| 140 | $self->set_enc_key_id( $enc_key_ids[0] || "" ); | ||
| 141 | $self->set_enc_mail( $enc_mails[0] || "" ); | ||
| 142 | |||
| 143 | return $self; | ||
| 144 | } | ||
| 145 | |||
| 146 | sub decode { | ||
| 147 | my ($str) = @_; | ||
| 148 | return $str if not defined $str; | ||
| 149 | $str =~ s/\\x(..)/chr(hex($1))/eg; | ||
| 150 | eval { $str = Encode::decode("utf-8", $str, Encode::FB_CROAK) } | ||
| 151 | if $] >= 5.008; | ||
| 152 | return $str; | ||
| 153 | } | ||
| 154 | |||
| 155 | sub as_string { | ||
| 156 | my $self = shift; | ||
| 157 | my %par = @_; | ||
| 158 | my ($no_stdout) = $par{'no_stdout'}; | ||
| 159 | |||
| 160 | my ( $method, $string ); | ||
| 161 | foreach my $attr ( | ||
| 162 | qw (is_encrypted enc_ok enc_key_id enc_mail | ||
| 163 | enc_key_ids enc_mails | ||
| 164 | is_signed sign_ok sign_state sign_key_id | ||
| 165 | sign_fingerprint sign_mail sign_mail_aliases | ||
| 166 | sign_trust gpg_rc ) | ||
| 167 | ) { | ||
| 168 | if ( $attr eq 'sign_mail_aliases' ) { | ||
| 169 | foreach my $value ( @{ $self->get_sign_mail_aliases } ) { | ||
| 170 | $string | ||
| 171 | .= sprintf( "%-18s: %s\n", "sign_mail_alias", $value ); | ||
| 172 | } | ||
| 173 | } | ||
| 174 | elsif ( $attr eq 'enc_key_ids' ) { | ||
| 175 | foreach my $value ( @{ $self->get_enc_key_ids } ) { | ||
| 176 | $string .= sprintf( "%-18s: %s\n", "enc_key_ids", $value ); | ||
| 177 | } | ||
| 178 | } | ||
| 179 | elsif ( $attr eq 'enc_mails' ) { | ||
| 180 | foreach my $value ( @{ $self->get_enc_mails } ) { | ||
| 181 | $string .= sprintf( "%-18s: %s\n", "enc_mails", $value ); | ||
| 182 | } | ||
| 183 | } | ||
| 184 | else { | ||
| 185 | $method = "get_$attr"; | ||
| 186 | my $value = $self->$method; | ||
| 187 | $value = "" unless defined $value; | ||
| 188 | $string .= sprintf( "%-18s: %s\n", $attr, $value ); | ||
| 189 | } | ||
| 190 | } | ||
| 191 | |||
| 192 | my $stdout = ${ $self->get_gpg_stdout }; | ||
| 193 | my $stderr = ${ $self->get_gpg_stderr }; | ||
| 194 | my $status = ${ $self->get_gpg_status }; | ||
| 195 | |||
| 196 | for ( $stdout, $stderr, $status ) { | ||
| 197 | next unless $_; | ||
| 198 | s/\n/\n /g; | ||
| 199 | s/\s+$//; | ||
| 200 | } | ||
| 201 | |||
| 202 | $string .= sprintf( "%-18s: %s\n", "gpg_stdout", $stdout || '' ) | ||
| 203 | if not $no_stdout; | ||
| 204 | $string .= sprintf( "%-18s: %s\n", "gpg_stderr", $stderr || '' ); | ||
| 205 | $string .= sprintf( "%-18s: %s\n", "gpg_status", $status || '' ); | ||
| 206 | |||
| 207 | return $string; | ||
| 208 | } | ||
| 209 | |||
| 210 | sub as_short_string { | ||
| 211 | my $self = shift; | ||
| 212 | |||
| 213 | my $string; | ||
| 214 | |||
| 215 | if ( $self->get_is_encrypted ) { | ||
| 216 | $string .= "ENC(" | ||
| 217 | . $self->get_enc_mail . ", " | ||
| 218 | . $self->get_enc_key_id . ", " | ||
| 219 | . ( $self->get_enc_ok ? "OK" : "NOK" ) . ") - "; | ||
| 220 | } | ||
| 221 | else { | ||
| 222 | $string .= "NOENC - "; | ||
| 223 | } | ||
| 224 | |||
| 225 | if ( $self->get_is_signed ) { | ||
| 226 | $string .= "SIGN(" | ||
| 227 | . $self->get_sign_mail . ", " | ||
| 228 | . $self->get_sign_key_id . ", " | ||
| 229 | . $self->get_sign_state . ") - "; | ||
| 230 | } | ||
| 231 | else { | ||
| 232 | $string .= "NOSIGN - "; | ||
| 233 | } | ||
| 234 | |||
| 235 | $string =~ s/ - $//; | ||
| 236 | |||
| 237 | return $string; | ||
| 238 | } | ||
| 239 | |||
| 240 | sub get_sign_trust { | ||
| 241 | my $self = shift; | ||
| 242 | |||
| 243 | return $self->{sign_trust} if exists $self->{sign_trust}; | ||
| 244 | |||
| 245 | my $trust = $self->get_mail_gpg->get_key_trust( | ||
| 246 | key_id => $self->get_sign_key_id ); | ||
| 247 | |||
| 248 | return $self->{sign_trust} = $trust; | ||
| 249 | } | ||
| 250 | |||
| 251 | 1; | ||
| 252 | |||
| 253 | __END__ |