plugins/enigma/lib/enigma_driver_gnupg.php

   1 <?php
   2 /*
   3  +-------------------------------------------------------------------------+
   4  | GnuPG (PGP) driver for the Enigma Plugin                                |
   5  |                                                                         |
   6  | This program is free software; you can redistribute it and/or modify    |
   7  | it under the terms of the GNU General Public License version 2          |
   8  | as published by the Free Software Foundation.                           |
   9  |                                                                         |
  10  | This program is distributed in the hope that it will be useful,         |
  11  | but WITHOUT ANY WARRANTY; without even the implied warranty of          |
  12  | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           |
  13  | GNU General Public License for more details.                            |
  14  |                                                                         |
  15  | You should have received a copy of the GNU General Public License along |
  16  | with this program; if not, write to the Free Software Foundation, Inc., |
  17  | 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.             |
  18  |                                                                         |
  19  +-------------------------------------------------------------------------+
  20  | Author: Aleksander Machniak <alec@alec.pl>                              |
  21  +-------------------------------------------------------------------------+
  22 */
  23
  24 require_once 'Crypt/GPG.php';
  25
  26 class enigma_driver_gnupg extends enigma_driver
  27 {
  28     private $rc;
  29     private $gpg;
  30     private $homedir;
  31     private $user;
  32
  33     function __construct($user)
  34     {
  35         $rcmail = rcmail::get_instance();
  36         $this->rc = $rcmail;
  37         $this->user = $user;
  38     }
  39
  40     /**
  41      * Driver initialization and environment checking.
  42      * Should only return critical errors.
  43      *
  44      * @return mixed NULL on success, enigma_error on failure
  45      */
  46     function init()
  47     {
  48         $homedir = $this->rc->config->get('enigma_pgp_homedir', INSTALL_PATH . '/plugins/enigma/home');
  49
  50         if (!$homedir)
  51             return new enigma_error(enigma_error::E_INTERNAL,
  52                 "Option 'enigma_pgp_homedir' not specified");
  53
  54         // check if homedir exists (create it if not) and is readable
  55         if (!file_exists($homedir))
  56             return new enigma_error(enigma_error::E_INTERNAL,
  57                 "Keys directory doesn't exists: $homedir");
  58         if (!is_writable($homedir))
  59             return new enigma_error(enigma_error::E_INTERNAL,
  60                 "Keys directory isn't writeable: $homedir");
  61
  62         $homedir = $homedir . '/' . $this->user;
  63
  64         // check if user's homedir exists (create it if not) and is readable
  65         if (!file_exists($homedir))
  66             mkdir($homedir, 0700);
  67
  68         if (!file_exists($homedir))
  69             return new enigma_error(enigma_error::E_INTERNAL,
  70                 "Unable to create keys directory: $homedir");
  71         if (!is_writable($homedir))
  72             return new enigma_error(enigma_error::E_INTERNAL,
  73                 "Unable to write to keys directory: $homedir");
  74
  75         $this->homedir = $homedir;
  76
  77         // Create Crypt_GPG object
  78         try {
  79                 $this->gpg = new Crypt_GPG(array(
  80                 'homedir'   => $this->homedir,
  81 //                'debug'     => true,
  82           ));
  83         }
  84         catch (Exception $e) {
  85             return $this->get_error_from_exception($e);
  86         }
  87     }
  88
  89     function encrypt($text, $keys)
  90     {
  91 /*
  92             foreach ($keys as $key) {
  93                     $this->gpg->addEncryptKey($key);
  94             }
  95             $enc = $this->gpg->encrypt($text);
  96             return $enc;
  97 */
  98     }
  99
 100     function decrypt($text, $key, $passwd)
 101     {
 102 //          $this->gpg->addDecryptKey($key, $passwd);
 103         try {
 104             $dec = $this->gpg->decrypt($text);
 105             return $dec;
 106         }
 107         catch (Exception $e) {
 108             return $this->get_error_from_exception($e);
 109         }
 110     }
 111
 112     function sign($text, $key, $passwd)
 113     {
 114 /*
 115             $this->gpg->addSignKey($key, $passwd);
 116             $signed = $this->gpg->sign($text, Crypt_GPG::SIGN_MODE_DETACHED);
 117             return $signed;
 118 */
 119     }
 120
 121     function verify($text, $signature)
 122     {
 123         try {
 124             $verified = $this->gpg->verify($text, $signature);
 125             return $this->parse_signature($verified[0]);
 126         }
 127         catch (Exception $e) {
 128             return $this->get_error_from_exception($e);
 129         }
 130     }
 131
 132     public function import($content, $isfile=false)
 133     {
 134         try {
 135             if ($isfile)
 136                 return $this->gpg->importKeyFile($content);
 137             else
 138                 return $this->gpg->importKey($content);
 139         }
 140         catch (Exception $e) {
 141             return $this->get_error_from_exception($e);
 142         }
 143     }
 144
 145     public function list_keys($pattern='')
 146     {
 147         try {
 148             $keys = $this->gpg->getKeys($pattern);
 149             $result = array();
 150 //print_r($keys);
 151             foreach ($keys as $idx => $key) {
 152                 $result[] = $this->parse_key($key);
 153                 unset($keys[$idx]);
 154             }
 155 //print_r($result);
 156             return $result;
 157         }
 158         catch (Exception $e) {
 159             return $this->get_error_from_exception($e);
 160         }
 161     }
 162
 163     public function get_key($keyid)
 164     {
 165         $list = $this->list_keys($keyid);
 166
 167         if (is_array($list))
 168             return array_shift($list);
 169
 170         // error
 171         return $list;
 172     }
 173
 174     public function gen_key($data)
 175     {
 176     }
 177
 178     public function del_key($keyid)
 179     {
 180 //        $this->get_key($keyid);
 181
 182
 183     }
 184
 185     public function del_privkey($keyid)
 186     {
 187         try {
 188             $this->gpg->deletePrivateKey($keyid);
 189             return true;
 190         }
 191         catch (Exception $e) {
 192             return $this->get_error_from_exception($e);
 193         }
 194     }
 195
 196     public function del_pubkey($keyid)
 197     {
 198         try {
 199             $this->gpg->deletePublicKey($keyid);
 200             return true;
 201         }
 202         catch (Exception $e) {
 203             return $this->get_error_from_exception($e);
 204         }
 205     }
 206
 207     /**
 208      * Converts Crypt_GPG exception into Enigma's error object
 209      *
 210      * @param mixed Exception object
 211      *
 212      * @return enigma_error Error object
 213      */
 214     private function get_error_from_exception($e)
 215     {
 216         $data = array();
 217
 218         if ($e instanceof Crypt_GPG_KeyNotFoundException) {
 219             $error = enigma_error::E_KEYNOTFOUND;
 220             $data['id'] = $e->getKeyId();
 221         }
 222         else if ($e instanceof Crypt_GPG_BadPassphraseException) {
 223             $error = enigma_error::E_BADPASS;
 224             $data['bad']     = $e->getBadPassphrases();
 225             $data['missing'] = $e->getMissingPassphrases();
 226         }
 227         else if ($e instanceof Crypt_GPG_NoDataException)
 228             $error = enigma_error::E_NODATA;
 229         else if ($e instanceof Crypt_GPG_DeletePrivateKeyException)
 230             $error = enigma_error::E_DELKEY;
 231         else
 232             $error = enigma_error::E_INTERNAL;
 233
 234         $msg = $e->getMessage();
 235
 236         return new enigma_error($error, $msg, $data);
 237     }
 238
 239     /**
 240      * Converts Crypt_GPG_Signature object into Enigma's signature object
 241      *
 242      * @param Crypt_GPG_Signature Signature object
 243      *
 244      * @return enigma_signature Signature object
 245      */
 246     private function parse_signature($sig)
 247     {
 248         $user = $sig->getUserId();
 249
 250         $data = new enigma_signature();
 251         $data->id          = $sig->getId();
 252         $data->valid       = $sig->isValid();
 253         $data->fingerprint = $sig->getKeyFingerprint();
 254         $data->created     = $sig->getCreationDate();
 255         $data->expires     = $sig->getExpirationDate();
 256         $data->name        = $user->getName();
 257         $data->comment     = $user->getComment();
 258         $data->email       = $user->getEmail();
 259
 260         return $data;
 261     }
 262
 263     /**
 264      * Converts Crypt_GPG_Key object into Enigma's key object
 265      *
 266      * @param Crypt_GPG_Key Key object
 267      *
 268      * @return enigma_key Key object
 269      */
 270     private function parse_key($key)
 271     {
 272         $ekey = new enigma_key();
 273
 274         foreach ($key->getUserIds() as $idx => $user) {
 275             $id = new enigma_userid();
 276             $id->name    = $user->getName();
 277             $id->comment = $user->getComment();
 278             $id->email   = $user->getEmail();
 279             $id->valid   = $user->isValid();
 280             $id->revoked = $user->isRevoked();
 281
 282             $ekey->users[$idx] = $id;
 283         }
 284
 285         $ekey->name = trim($ekey->users[0]->name . ' <' . $ekey->users[0]->email . '>');
 286
 287         foreach ($key->getSubKeys() as $idx => $subkey) {
 288                 $skey = new enigma_subkey();
 289                 $skey->id          = $subkey->getId();
 290                 $skey->revoked     = $subkey->isRevoked();
 291                 $skey->created     = $subkey->getCreationDate();
 292                 $skey->expires     = $subkey->getExpirationDate();
 293                 $skey->fingerprint = $subkey->getFingerprint();
 294                 $skey->has_private = $subkey->hasPrivate();
 295                 $skey->can_sign    = $subkey->canSign();
 296                 $skey->can_encrypt = $subkey->canEncrypt();
 297
 298                 $ekey->subkeys[$idx] = $skey;
 299         };
 300
 301         $ekey->id = $ekey->subkeys[0]->id;
 302
 303         return $ekey;
 304     }
 305 }