Show spam aliases #
This commit is contained in:
andryyy
@@ -0,0 +1,134 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
+-------------------------------------------------------------------------+
|
||||
| Abstract driver for the Enigma Plugin |
|
||||
| |
|
||||
| Copyright (C) 2010-2015 The Roundcube Dev Team |
|
||||
| |
|
||||
| Licensed under the GNU General Public License version 3 or |
|
||||
| any later version with exceptions for skins & plugins. |
|
||||
| See the README file for a full license statement. |
|
||||
| |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Author: Aleksander Machniak <alec@alec.pl> |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
abstract class enigma_driver
|
||||
{
|
||||
/**
|
||||
* Class constructor.
|
||||
*
|
||||
* @param string User name (email address)
|
||||
*/
|
||||
abstract function __construct($user);
|
||||
|
||||
/**
|
||||
* Driver initialization.
|
||||
*
|
||||
* @return mixed NULL on success, enigma_error on failure
|
||||
*/
|
||||
abstract function init();
|
||||
|
||||
/**
|
||||
* Encryption (and optional signing).
|
||||
*
|
||||
* @param string Message body
|
||||
* @param array List of keys (enigma_key objects)
|
||||
* @param enigma_key Optional signing Key ID
|
||||
*
|
||||
* @return mixed Encrypted message or enigma_error on failure
|
||||
*/
|
||||
abstract function encrypt($text, $keys, $sign_key = null);
|
||||
|
||||
/**
|
||||
* Decryption (and sig verification if sig exists).
|
||||
*
|
||||
* @param string Encrypted message
|
||||
* @param array List of key-password
|
||||
* @param enigma_signature Signature information (if available)
|
||||
*
|
||||
* @return mixed Decrypted message or enigma_error on failure
|
||||
*/
|
||||
abstract function decrypt($text, $keys = array(), &$signature = null);
|
||||
|
||||
/**
|
||||
* Signing.
|
||||
*
|
||||
* @param string Message body
|
||||
* @param enigma_key The signing key
|
||||
* @param int Signing mode (enigma_engine::SIGN_*)
|
||||
*
|
||||
* @return mixed True on success or enigma_error on failure
|
||||
*/
|
||||
abstract function sign($text, $key, $mode = null);
|
||||
|
||||
/**
|
||||
* Signature verification.
|
||||
*
|
||||
* @param string Message body
|
||||
* @param string Signature, if message is of type PGP/MIME and body doesn't contain it
|
||||
*
|
||||
* @return mixed Signature information (enigma_signature) or enigma_error
|
||||
*/
|
||||
abstract function verify($text, $signature);
|
||||
|
||||
/**
|
||||
* Key/Cert file import.
|
||||
*
|
||||
* @param string File name or file content
|
||||
* @param bolean True if first argument is a filename
|
||||
* @param array Optional key => password map
|
||||
*
|
||||
* @return mixed Import status array or enigma_error
|
||||
*/
|
||||
abstract function import($content, $isfile = false, $passwords = array());
|
||||
|
||||
/**
|
||||
* Key/Cert export.
|
||||
*
|
||||
* @param string Key ID
|
||||
* @param bool Include private key
|
||||
* @param array Optional key => password map
|
||||
*
|
||||
* @return mixed Key content or enigma_error
|
||||
*/
|
||||
abstract function export($key, $with_private = false, $passwords = array());
|
||||
|
||||
/**
|
||||
* Keys listing.
|
||||
*
|
||||
* @param string Optional pattern for key ID, user ID or fingerprint
|
||||
*
|
||||
* @return mixed Array of enigma_key objects or enigma_error
|
||||
*/
|
||||
abstract function list_keys($pattern = '');
|
||||
|
||||
/**
|
||||
* Single key information.
|
||||
*
|
||||
* @param string Key ID, user ID or fingerprint
|
||||
*
|
||||
* @return mixed Key (enigma_key) object or enigma_error
|
||||
*/
|
||||
abstract function get_key($keyid);
|
||||
|
||||
/**
|
||||
* Key pair generation.
|
||||
*
|
||||
* @param array Key/User data (name, email, password, size)
|
||||
*
|
||||
* @return mixed Key (enigma_key) object or enigma_error
|
||||
*/
|
||||
abstract function gen_key($data);
|
||||
|
||||
/**
|
||||
* Key deletion.
|
||||
*
|
||||
* @param string Key ID
|
||||
*
|
||||
* @return mixed True on success or enigma_error
|
||||
*/
|
||||
abstract function delete_key($keyid);
|
||||
}
|
||||
@@ -0,0 +1,512 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
+-------------------------------------------------------------------------+
|
||||
| GnuPG (PGP) driver for the Enigma Plugin |
|
||||
| |
|
||||
| Copyright (C) 2010-2015 The Roundcube Dev Team |
|
||||
| |
|
||||
| Licensed under the GNU General Public License version 3 or |
|
||||
| any later version with exceptions for skins & plugins. |
|
||||
| See the README file for a full license statement. |
|
||||
| |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Author: Aleksander Machniak <alec@alec.pl> |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
require_once 'Crypt/GPG.php';
|
||||
|
||||
class enigma_driver_gnupg extends enigma_driver
|
||||
{
|
||||
protected $rc;
|
||||
protected $gpg;
|
||||
protected $homedir;
|
||||
protected $user;
|
||||
|
||||
|
||||
function __construct($user)
|
||||
{
|
||||
$this->rc = rcmail::get_instance();
|
||||
$this->user = $user;
|
||||
}
|
||||
|
||||
/**
|
||||
* Driver initialization and environment checking.
|
||||
* Should only return critical errors.
|
||||
*
|
||||
* @return mixed NULL on success, enigma_error on failure
|
||||
*/
|
||||
function init()
|
||||
{
|
||||
$homedir = $this->rc->config->get('enigma_pgp_homedir', INSTALL_PATH . 'plugins/enigma/home');
|
||||
$debug = $this->rc->config->get('enigma_debug');
|
||||
$binary = $this->rc->config->get('enigma_pgp_binary');
|
||||
$agent = $this->rc->config->get('enigma_pgp_agent');
|
||||
$gpgconf = $this->rc->config->get('enigma_pgp_gpgconf');
|
||||
|
||||
if (!$homedir) {
|
||||
return new enigma_error(enigma_error::INTERNAL,
|
||||
"Option 'enigma_pgp_homedir' not specified");
|
||||
}
|
||||
|
||||
// check if homedir exists (create it if not) and is readable
|
||||
if (!file_exists($homedir)) {
|
||||
return new enigma_error(enigma_error::INTERNAL,
|
||||
"Keys directory doesn't exists: $homedir");
|
||||
}
|
||||
if (!is_writable($homedir)) {
|
||||
return new enigma_error(enigma_error::INTERNAL,
|
||||
"Keys directory isn't writeable: $homedir");
|
||||
}
|
||||
|
||||
$homedir = $homedir . '/' . $this->user;
|
||||
|
||||
// check if user's homedir exists (create it if not) and is readable
|
||||
if (!file_exists($homedir)) {
|
||||
mkdir($homedir, 0700);
|
||||
}
|
||||
|
||||
if (!file_exists($homedir)) {
|
||||
return new enigma_error(enigma_error::INTERNAL,
|
||||
"Unable to create keys directory: $homedir");
|
||||
}
|
||||
if (!is_writable($homedir)) {
|
||||
return new enigma_error(enigma_error::INTERNAL,
|
||||
"Unable to write to keys directory: $homedir");
|
||||
}
|
||||
|
||||
$this->homedir = $homedir;
|
||||
|
||||
$options = array('homedir' => $this->homedir);
|
||||
|
||||
if ($debug) {
|
||||
$options['debug'] = array($this, 'debug');
|
||||
}
|
||||
if ($binary) {
|
||||
$options['binary'] = $binary;
|
||||
}
|
||||
if ($agent) {
|
||||
$options['agent'] = $agent;
|
||||
}
|
||||
if ($gpgconf) {
|
||||
$options['gpgconf'] = $gpgconf;
|
||||
}
|
||||
|
||||
// Create Crypt_GPG object
|
||||
try {
|
||||
$this->gpg = new Crypt_GPG($options);
|
||||
}
|
||||
catch (Exception $e) {
|
||||
return $this->get_error_from_exception($e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Encryption (and optional signing).
|
||||
*
|
||||
* @param string Message body
|
||||
* @param array List of keys (enigma_key objects)
|
||||
* @param enigma_key Optional signing Key ID
|
||||
*
|
||||
* @return mixed Encrypted message or enigma_error on failure
|
||||
*/
|
||||
function encrypt($text, $keys, $sign_key = null)
|
||||
{
|
||||
try {
|
||||
foreach ($keys as $key) {
|
||||
$this->gpg->addEncryptKey($key->reference);
|
||||
}
|
||||
|
||||
if ($sign_key) {
|
||||
$this->gpg->addSignKey($sign_key->reference, $sign_key->password);
|
||||
return $this->gpg->encryptAndSign($text, true);
|
||||
}
|
||||
|
||||
return $this->gpg->encrypt($text, true);
|
||||
}
|
||||
catch (Exception $e) {
|
||||
return $this->get_error_from_exception($e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Decrypt a message (and verify if signature found)
|
||||
*
|
||||
* @param string Encrypted message
|
||||
* @param array List of key-password mapping
|
||||
* @param enigma_signature Signature information (if available)
|
||||
*
|
||||
* @return mixed Decrypted message or enigma_error on failure
|
||||
*/
|
||||
function decrypt($text, $keys = array(), &$signature = null)
|
||||
{
|
||||
try {
|
||||
foreach ($keys as $key => $password) {
|
||||
$this->gpg->addDecryptKey($key, $password);
|
||||
}
|
||||
|
||||
$result = $this->gpg->decryptAndVerify($text);
|
||||
|
||||
if (!empty($result['signatures'])) {
|
||||
$signature = $this->parse_signature($result['signatures'][0]);
|
||||
}
|
||||
|
||||
return $result['data'];
|
||||
}
|
||||
catch (Exception $e) {
|
||||
return $this->get_error_from_exception($e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Signing.
|
||||
*
|
||||
* @param string Message body
|
||||
* @param enigma_key The key
|
||||
* @param int Signing mode (enigma_engine::SIGN_*)
|
||||
*
|
||||
* @return mixed True on success or enigma_error on failure
|
||||
*/
|
||||
function sign($text, $key, $mode = null)
|
||||
{
|
||||
try {
|
||||
$this->gpg->addSignKey($key->reference, $key->password);
|
||||
return $this->gpg->sign($text, $mode, CRYPT_GPG::ARMOR_ASCII, true);
|
||||
}
|
||||
catch (Exception $e) {
|
||||
return $this->get_error_from_exception($e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Signature verification.
|
||||
*
|
||||
* @param string Message body
|
||||
* @param string Signature, if message is of type PGP/MIME and body doesn't contain it
|
||||
*
|
||||
* @return mixed Signature information (enigma_signature) or enigma_error
|
||||
*/
|
||||
function verify($text, $signature)
|
||||
{
|
||||
try {
|
||||
$verified = $this->gpg->verify($text, $signature);
|
||||
return $this->parse_signature($verified[0]);
|
||||
}
|
||||
catch (Exception $e) {
|
||||
return $this->get_error_from_exception($e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Key file import.
|
||||
*
|
||||
* @param string File name or file content
|
||||
* @param bolean True if first argument is a filename
|
||||
* @param array Optional key => password map
|
||||
*
|
||||
* @return mixed Import status array or enigma_error
|
||||
*/
|
||||
public function import($content, $isfile = false, $passwords = array())
|
||||
{
|
||||
try {
|
||||
// GnuPG 2.1 requires secret key passphrases on import
|
||||
foreach ($passwords as $keyid => $pass) {
|
||||
$this->gpg->addPassphrase($keyid, $pass);
|
||||
}
|
||||
|
||||
if ($isfile)
|
||||
return $this->gpg->importKeyFile($content);
|
||||
else
|
||||
return $this->gpg->importKey($content);
|
||||
}
|
||||
catch (Exception $e) {
|
||||
return $this->get_error_from_exception($e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Key export.
|
||||
*
|
||||
* @param string Key ID
|
||||
* @param bool Include private key
|
||||
* @param array Optional key => password map
|
||||
*
|
||||
* @return mixed Key content or enigma_error
|
||||
*/
|
||||
public function export($keyid, $with_private = false, $passwords = array())
|
||||
{
|
||||
try {
|
||||
$key = $this->gpg->exportPublicKey($keyid, true);
|
||||
|
||||
if ($with_private) {
|
||||
// GnuPG 2.1 requires secret key passphrases on export
|
||||
foreach ($passwords as $_keyid => $pass) {
|
||||
$this->gpg->addPassphrase($_keyid, $pass);
|
||||
}
|
||||
|
||||
$priv = $this->gpg->exportPrivateKey($keyid, true);
|
||||
$key .= $priv;
|
||||
}
|
||||
|
||||
return $key;
|
||||
}
|
||||
catch (Exception $e) {
|
||||
return $this->get_error_from_exception($e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Keys listing.
|
||||
*
|
||||
* @param string Optional pattern for key ID, user ID or fingerprint
|
||||
*
|
||||
* @return mixed Array of enigma_key objects or enigma_error
|
||||
*/
|
||||
public function list_keys($pattern = '')
|
||||
{
|
||||
try {
|
||||
$keys = $this->gpg->getKeys($pattern);
|
||||
$result = array();
|
||||
|
||||
foreach ($keys as $idx => $key) {
|
||||
$result[] = $this->parse_key($key);
|
||||
unset($keys[$idx]);
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
catch (Exception $e) {
|
||||
return $this->get_error_from_exception($e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Single key information.
|
||||
*
|
||||
* @param string Key ID, user ID or fingerprint
|
||||
*
|
||||
* @return mixed Key (enigma_key) object or enigma_error
|
||||
*/
|
||||
public function get_key($keyid)
|
||||
{
|
||||
$list = $this->list_keys($keyid);
|
||||
|
||||
if (is_array($list)) {
|
||||
return $list[key($list)];
|
||||
}
|
||||
|
||||
// error
|
||||
return $list;
|
||||
}
|
||||
|
||||
/**
|
||||
* Key pair generation.
|
||||
*
|
||||
* @param array Key/User data (user, email, password, size)
|
||||
*
|
||||
* @return mixed Key (enigma_key) object or enigma_error
|
||||
*/
|
||||
public function gen_key($data)
|
||||
{
|
||||
try {
|
||||
$debug = $this->rc->config->get('enigma_debug');
|
||||
$keygen = new Crypt_GPG_KeyGenerator(array(
|
||||
'homedir' => $this->homedir,
|
||||
// 'binary' => '/usr/bin/gpg2',
|
||||
'debug' => $debug ? array($this, 'debug') : false,
|
||||
));
|
||||
|
||||
$key = $keygen
|
||||
->setExpirationDate(0)
|
||||
->setPassphrase($data['password'])
|
||||
->generateKey($data['user'], $data['email']);
|
||||
|
||||
return $this->parse_key($key);
|
||||
}
|
||||
catch (Exception $e) {
|
||||
return $this->get_error_from_exception($e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Key deletion.
|
||||
*
|
||||
* @param string Key ID
|
||||
*
|
||||
* @return mixed True on success or enigma_error
|
||||
*/
|
||||
public function delete_key($keyid)
|
||||
{
|
||||
// delete public key
|
||||
$result = $this->delete_pubkey($keyid);
|
||||
|
||||
// error handling
|
||||
if ($result !== true) {
|
||||
$code = $result->getCode();
|
||||
|
||||
// if not found, delete private key
|
||||
if ($code == enigma_error::KEYNOTFOUND) {
|
||||
$result = $this->delete_privkey($keyid);
|
||||
}
|
||||
// need to delete private key first
|
||||
else if ($code == enigma_error::DELKEY) {
|
||||
$key = $this->get_key($keyid);
|
||||
for ($i = count($key->subkeys) - 1; $i >= 0; $i--) {
|
||||
$type = ($key->subkeys[$i]->usage & enigma_key::CAN_ENCRYPT) ? 'priv' : 'pub';
|
||||
$result = $this->{'delete_' . $type . 'key'}($key->subkeys[$i]->id);
|
||||
if ($result !== true) {
|
||||
return $result;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Private key deletion.
|
||||
*/
|
||||
protected function delete_privkey($keyid)
|
||||
{
|
||||
try {
|
||||
$this->gpg->deletePrivateKey($keyid);
|
||||
return true;
|
||||
}
|
||||
catch (Exception $e) {
|
||||
return $this->get_error_from_exception($e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Public key deletion.
|
||||
*/
|
||||
protected function delete_pubkey($keyid)
|
||||
{
|
||||
try {
|
||||
$this->gpg->deletePublicKey($keyid);
|
||||
return true;
|
||||
}
|
||||
catch (Exception $e) {
|
||||
return $this->get_error_from_exception($e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts Crypt_GPG exception into Enigma's error object
|
||||
*
|
||||
* @param mixed Exception object
|
||||
*
|
||||
* @return enigma_error Error object
|
||||
*/
|
||||
protected function get_error_from_exception($e)
|
||||
{
|
||||
$data = array();
|
||||
|
||||
if ($e instanceof Crypt_GPG_KeyNotFoundException) {
|
||||
$error = enigma_error::KEYNOTFOUND;
|
||||
$data['id'] = $e->getKeyId();
|
||||
}
|
||||
else if ($e instanceof Crypt_GPG_BadPassphraseException) {
|
||||
$error = enigma_error::BADPASS;
|
||||
$data['bad'] = $e->getBadPassphrases();
|
||||
$data['missing'] = $e->getMissingPassphrases();
|
||||
}
|
||||
else if ($e instanceof Crypt_GPG_NoDataException) {
|
||||
$error = enigma_error::NODATA;
|
||||
}
|
||||
else if ($e instanceof Crypt_GPG_DeletePrivateKeyException) {
|
||||
$error = enigma_error::DELKEY;
|
||||
}
|
||||
else {
|
||||
$error = enigma_error::INTERNAL;
|
||||
}
|
||||
|
||||
$msg = $e->getMessage();
|
||||
|
||||
return new enigma_error($error, $msg, $data);
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts Crypt_GPG_Signature object into Enigma's signature object
|
||||
*
|
||||
* @param Crypt_GPG_Signature Signature object
|
||||
*
|
||||
* @return enigma_signature Signature object
|
||||
*/
|
||||
protected function parse_signature($sig)
|
||||
{
|
||||
$data = new enigma_signature();
|
||||
|
||||
$data->id = $sig->getId();
|
||||
$data->valid = $sig->isValid();
|
||||
$data->fingerprint = $sig->getKeyFingerprint();
|
||||
$data->created = $sig->getCreationDate();
|
||||
$data->expires = $sig->getExpirationDate();
|
||||
|
||||
// In case of ERRSIG user may not be set
|
||||
if ($user = $sig->getUserId()) {
|
||||
$data->name = $user->getName();
|
||||
$data->comment = $user->getComment();
|
||||
$data->email = $user->getEmail();
|
||||
}
|
||||
|
||||
return $data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts Crypt_GPG_Key object into Enigma's key object
|
||||
*
|
||||
* @param Crypt_GPG_Key Key object
|
||||
*
|
||||
* @return enigma_key Key object
|
||||
*/
|
||||
protected function parse_key($key)
|
||||
{
|
||||
$ekey = new enigma_key();
|
||||
|
||||
foreach ($key->getUserIds() as $idx => $user) {
|
||||
$id = new enigma_userid();
|
||||
$id->name = $user->getName();
|
||||
$id->comment = $user->getComment();
|
||||
$id->email = $user->getEmail();
|
||||
$id->valid = $user->isValid();
|
||||
$id->revoked = $user->isRevoked();
|
||||
|
||||
$ekey->users[$idx] = $id;
|
||||
}
|
||||
|
||||
$ekey->name = trim($ekey->users[0]->name . ' <' . $ekey->users[0]->email . '>');
|
||||
|
||||
// keep reference to Crypt_GPG's key for performance reasons
|
||||
$ekey->reference = $key;
|
||||
|
||||
foreach ($key->getSubKeys() as $idx => $subkey) {
|
||||
$skey = new enigma_subkey();
|
||||
$skey->id = $subkey->getId();
|
||||
$skey->revoked = $subkey->isRevoked();
|
||||
$skey->created = $subkey->getCreationDate();
|
||||
$skey->expires = $subkey->getExpirationDate();
|
||||
$skey->fingerprint = $subkey->getFingerprint();
|
||||
$skey->has_private = $subkey->hasPrivate();
|
||||
$skey->algorithm = $subkey->getAlgorithm();
|
||||
$skey->length = $subkey->getLength();
|
||||
$skey->usage = $subkey->usage();
|
||||
|
||||
$ekey->subkeys[$idx] = $skey;
|
||||
};
|
||||
|
||||
$ekey->id = $ekey->subkeys[0]->id;
|
||||
|
||||
return $ekey;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write debug info from Crypt_GPG to logs/enigma
|
||||
*/
|
||||
public function debug($line)
|
||||
{
|
||||
rcube::write_log('enigma', 'GPG: ' . $line);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,224 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
+-------------------------------------------------------------------------+
|
||||
| S/MIME driver for the Enigma Plugin |
|
||||
| |
|
||||
| Copyright (C) 2010-2015 The Roundcube Dev Team |
|
||||
| |
|
||||
| Licensed under the GNU General Public License version 3 or |
|
||||
| any later version with exceptions for skins & plugins. |
|
||||
| See the README file for a full license statement. |
|
||||
| |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Author: Aleksander Machniak <alec@alec.pl> |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
class enigma_driver_phpssl extends enigma_driver
|
||||
{
|
||||
private $rc;
|
||||
private $homedir;
|
||||
private $user;
|
||||
|
||||
function __construct($user)
|
||||
{
|
||||
$rcmail = rcmail::get_instance();
|
||||
$this->rc = $rcmail;
|
||||
$this->user = $user;
|
||||
}
|
||||
|
||||
/**
|
||||
* Driver initialization and environment checking.
|
||||
* Should only return critical errors.
|
||||
*
|
||||
* @return mixed NULL on success, enigma_error on failure
|
||||
*/
|
||||
function init()
|
||||
{
|
||||
$homedir = $this->rc->config->get('enigma_smime_homedir', INSTALL_PATH . '/plugins/enigma/home');
|
||||
|
||||
if (!$homedir)
|
||||
return new enigma_error(enigma_error::INTERNAL,
|
||||
"Option 'enigma_smime_homedir' not specified");
|
||||
|
||||
// check if homedir exists (create it if not) and is readable
|
||||
if (!file_exists($homedir))
|
||||
return new enigma_error(enigma_error::INTERNAL,
|
||||
"Keys directory doesn't exists: $homedir");
|
||||
if (!is_writable($homedir))
|
||||
return new enigma_error(enigma_error::INTERNAL,
|
||||
"Keys directory isn't writeable: $homedir");
|
||||
|
||||
$homedir = $homedir . '/' . $this->user;
|
||||
|
||||
// check if user's homedir exists (create it if not) and is readable
|
||||
if (!file_exists($homedir))
|
||||
mkdir($homedir, 0700);
|
||||
|
||||
if (!file_exists($homedir))
|
||||
return new enigma_error(enigma_error::INTERNAL,
|
||||
"Unable to create keys directory: $homedir");
|
||||
if (!is_writable($homedir))
|
||||
return new enigma_error(enigma_error::INTERNAL,
|
||||
"Unable to write to keys directory: $homedir");
|
||||
|
||||
$this->homedir = $homedir;
|
||||
|
||||
}
|
||||
|
||||
function encrypt($text, $keys, $sign_key = null)
|
||||
{
|
||||
}
|
||||
|
||||
function decrypt($text, $keys = array(), &$signature = null)
|
||||
{
|
||||
}
|
||||
|
||||
function sign($text, $key, $mode = null)
|
||||
{
|
||||
}
|
||||
|
||||
function verify($struct, $message)
|
||||
{
|
||||
// use common temp dir
|
||||
$temp_dir = $this->rc->config->get('temp_dir');
|
||||
$msg_file = tempnam($temp_dir, 'rcmMsg');
|
||||
$cert_file = tempnam($temp_dir, 'rcmCert');
|
||||
|
||||
$fh = fopen($msg_file, "w");
|
||||
if ($struct->mime_id) {
|
||||
$message->get_part_body($struct->mime_id, false, 0, $fh);
|
||||
}
|
||||
else {
|
||||
$this->rc->storage->get_raw_body($message->uid, $fh);
|
||||
}
|
||||
fclose($fh);
|
||||
|
||||
// @TODO: use stored certificates
|
||||
|
||||
// try with certificate verification
|
||||
$sig = openssl_pkcs7_verify($msg_file, 0, $cert_file);
|
||||
$validity = true;
|
||||
|
||||
if ($sig !== true) {
|
||||
// try without certificate verification
|
||||
$sig = openssl_pkcs7_verify($msg_file, PKCS7_NOVERIFY, $cert_file);
|
||||
$validity = enigma_error::UNVERIFIED;
|
||||
}
|
||||
|
||||
if ($sig === true) {
|
||||
$sig = $this->parse_sig_cert($cert_file, $validity);
|
||||
}
|
||||
else {
|
||||
$errorstr = $this->get_openssl_error();
|
||||
$sig = new enigma_error(enigma_error::INTERNAL, $errorstr);
|
||||
}
|
||||
|
||||
// remove temp files
|
||||
@unlink($msg_file);
|
||||
@unlink($cert_file);
|
||||
|
||||
return $sig;
|
||||
}
|
||||
|
||||
public function import($content, $isfile = false, $passwords = array())
|
||||
{
|
||||
}
|
||||
|
||||
public function export($key, $with_private = false, $passwords = array())
|
||||
{
|
||||
}
|
||||
|
||||
public function list_keys($pattern='')
|
||||
{
|
||||
}
|
||||
|
||||
public function get_key($keyid)
|
||||
{
|
||||
}
|
||||
|
||||
public function gen_key($data)
|
||||
{
|
||||
}
|
||||
|
||||
public function delete_key($keyid)
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts Crypt_GPG_Key object into Enigma's key object
|
||||
*
|
||||
* @param Crypt_GPG_Key Key object
|
||||
*
|
||||
* @return enigma_key Key object
|
||||
*/
|
||||
private function parse_key($key)
|
||||
{
|
||||
/*
|
||||
$ekey = new enigma_key();
|
||||
|
||||
foreach ($key->getUserIds() as $idx => $user) {
|
||||
$id = new enigma_userid();
|
||||
$id->name = $user->getName();
|
||||
$id->comment = $user->getComment();
|
||||
$id->email = $user->getEmail();
|
||||
$id->valid = $user->isValid();
|
||||
$id->revoked = $user->isRevoked();
|
||||
|
||||
$ekey->users[$idx] = $id;
|
||||
}
|
||||
|
||||
$ekey->name = trim($ekey->users[0]->name . ' <' . $ekey->users[0]->email . '>');
|
||||
|
||||
foreach ($key->getSubKeys() as $idx => $subkey) {
|
||||
$skey = new enigma_subkey();
|
||||
$skey->id = $subkey->getId();
|
||||
$skey->revoked = $subkey->isRevoked();
|
||||
$skey->created = $subkey->getCreationDate();
|
||||
$skey->expires = $subkey->getExpirationDate();
|
||||
$skey->fingerprint = $subkey->getFingerprint();
|
||||
$skey->has_private = $subkey->hasPrivate();
|
||||
|
||||
$ekey->subkeys[$idx] = $skey;
|
||||
};
|
||||
|
||||
$ekey->id = $ekey->subkeys[0]->id;
|
||||
|
||||
return $ekey;
|
||||
*/
|
||||
}
|
||||
|
||||
private function get_openssl_error()
|
||||
{
|
||||
$tmp = array();
|
||||
while ($errorstr = openssl_error_string()) {
|
||||
$tmp[] = $errorstr;
|
||||
}
|
||||
|
||||
return join("\n", array_values($tmp));
|
||||
}
|
||||
|
||||
private function parse_sig_cert($file, $validity)
|
||||
{
|
||||
$cert = openssl_x509_parse(file_get_contents($file));
|
||||
|
||||
if (empty($cert) || empty($cert['subject'])) {
|
||||
$errorstr = $this->get_openssl_error();
|
||||
return new enigma_error(enigma_error::INTERNAL, $errorstr);
|
||||
}
|
||||
|
||||
$data = new enigma_signature();
|
||||
|
||||
$data->id = $cert['hash']; //?
|
||||
$data->valid = $validity;
|
||||
$data->fingerprint = $cert['serialNumber'];
|
||||
$data->created = $cert['validFrom_time_t'];
|
||||
$data->expires = $cert['validTo_time_t'];
|
||||
$data->name = $cert['subject']['CN'];
|
||||
// $data->comment = '';
|
||||
$data->email = $cert['subject']['emailAddress'];
|
||||
|
||||
return $data;
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,56 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
+-------------------------------------------------------------------------+
|
||||
| Error class for the Enigma Plugin |
|
||||
| |
|
||||
| Copyright (C) 2010-2015 The Roundcube Dev Team |
|
||||
| |
|
||||
| Licensed under the GNU General Public License version 3 or |
|
||||
| any later version with exceptions for skins & plugins. |
|
||||
| See the README file for a full license statement. |
|
||||
| |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Author: Aleksander Machniak <alec@alec.pl> |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
class enigma_error
|
||||
{
|
||||
private $code;
|
||||
private $message;
|
||||
private $data = array();
|
||||
|
||||
// error codes
|
||||
const OK = 0;
|
||||
const INTERNAL = 1;
|
||||
const NODATA = 2;
|
||||
const KEYNOTFOUND = 3;
|
||||
const DELKEY = 4;
|
||||
const BADPASS = 5;
|
||||
const EXPIRED = 6;
|
||||
const UNVERIFIED = 7;
|
||||
|
||||
|
||||
function __construct($code = null, $message = '', $data = array())
|
||||
{
|
||||
$this->code = $code;
|
||||
$this->message = $message;
|
||||
$this->data = $data;
|
||||
}
|
||||
|
||||
function getCode()
|
||||
{
|
||||
return $this->code;
|
||||
}
|
||||
|
||||
function getMessage()
|
||||
{
|
||||
return $this->message;
|
||||
}
|
||||
|
||||
function getData($name)
|
||||
{
|
||||
return $name ? $this->data[$name] : $this->data;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,167 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
+-------------------------------------------------------------------------+
|
||||
| Key class for the Enigma Plugin |
|
||||
| |
|
||||
| Copyright (C) 2010-2015 The Roundcube Dev Team |
|
||||
| |
|
||||
| Licensed under the GNU General Public License version 3 or |
|
||||
| any later version with exceptions for skins & plugins. |
|
||||
| See the README file for a full license statement. |
|
||||
| |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Author: Aleksander Machniak <alec@alec.pl> |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
class enigma_key
|
||||
{
|
||||
public $id;
|
||||
public $name;
|
||||
public $users = array();
|
||||
public $subkeys = array();
|
||||
public $reference;
|
||||
public $password;
|
||||
|
||||
const TYPE_UNKNOWN = 0;
|
||||
const TYPE_KEYPAIR = 1;
|
||||
const TYPE_PUBLIC = 2;
|
||||
|
||||
const CAN_ENCRYPT = 1;
|
||||
const CAN_SIGN = 2;
|
||||
const CAN_CERTIFY = 4;
|
||||
const CAN_AUTHENTICATE = 8;
|
||||
|
||||
|
||||
/**
|
||||
* Keys list sorting callback for usort()
|
||||
*/
|
||||
static function cmp($a, $b)
|
||||
{
|
||||
return strcmp($a->name, $b->name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns key type
|
||||
*/
|
||||
function get_type()
|
||||
{
|
||||
if ($this->subkeys[0]->has_private)
|
||||
return enigma_key::TYPE_KEYPAIR;
|
||||
else if (!empty($this->subkeys[0]))
|
||||
return enigma_key::TYPE_PUBLIC;
|
||||
|
||||
return enigma_key::TYPE_UNKNOWN;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if all user IDs are revoked
|
||||
*/
|
||||
function is_revoked()
|
||||
{
|
||||
foreach ($this->subkeys as $subkey)
|
||||
if (!$subkey->revoked)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if any user ID is valid
|
||||
*/
|
||||
function is_valid()
|
||||
{
|
||||
foreach ($this->users as $user)
|
||||
if ($user->valid)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if any of subkeys is not expired
|
||||
*/
|
||||
function is_expired()
|
||||
{
|
||||
$now = time();
|
||||
|
||||
foreach ($this->subkeys as $subkey)
|
||||
if (!$subkey->expires || $subkey->expires > $now)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if any of subkeys is a private key
|
||||
*/
|
||||
function is_private()
|
||||
{
|
||||
$now = time();
|
||||
|
||||
foreach ($this->subkeys as $subkey)
|
||||
if ($subkey->has_private)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get key ID by user email
|
||||
*/
|
||||
function find_subkey($email, $mode)
|
||||
{
|
||||
$now = time();
|
||||
|
||||
foreach ($this->users as $user) {
|
||||
if (strcasecmp($user->email, $email) === 0 && $user->valid && !$user->revoked) {
|
||||
foreach ($this->subkeys as $subkey) {
|
||||
if (!$subkey->revoked && (!$subkey->expires || $subkey->expires > $now)) {
|
||||
if ($subkey->usage & $mode) {
|
||||
return $subkey;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts long ID or Fingerprint to short ID
|
||||
* Crypt_GPG uses internal, but e.g. Thunderbird's Enigmail displays short ID
|
||||
*
|
||||
* @param string Key ID or fingerprint
|
||||
* @return string Key short ID
|
||||
*/
|
||||
static function format_id($id)
|
||||
{
|
||||
// E.g. 04622F2089E037A5 => 89E037A5
|
||||
|
||||
return substr($id, -8);
|
||||
}
|
||||
|
||||
/**
|
||||
* Formats fingerprint string
|
||||
*
|
||||
* @param string Key fingerprint
|
||||
*
|
||||
* @return string Formatted fingerprint (with spaces)
|
||||
*/
|
||||
static function format_fingerprint($fingerprint)
|
||||
{
|
||||
if (!$fingerprint) {
|
||||
return '';
|
||||
}
|
||||
|
||||
$result = '';
|
||||
for ($i=0; $i<40; $i++) {
|
||||
if ($i % 4 == 0) {
|
||||
$result .= ' ';
|
||||
}
|
||||
$result .= $fingerprint[$i];
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,294 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
+-------------------------------------------------------------------------+
|
||||
| Mail_mime wrapper for the Enigma Plugin |
|
||||
| |
|
||||
| Copyright (C) 2010-2015 The Roundcube Dev Team |
|
||||
| |
|
||||
| Licensed under the GNU General Public License version 3 or |
|
||||
| any later version with exceptions for skins & plugins. |
|
||||
| See the README file for a full license statement. |
|
||||
| |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Author: Aleksander Machniak <alec@alec.pl> |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
class enigma_mime_message extends Mail_mime
|
||||
{
|
||||
const PGP_SIGNED = 1;
|
||||
const PGP_ENCRYPTED = 2;
|
||||
|
||||
protected $type;
|
||||
protected $message;
|
||||
protected $body;
|
||||
protected $signature;
|
||||
protected $encrypted;
|
||||
|
||||
|
||||
/**
|
||||
* Object constructor
|
||||
*
|
||||
* @param Mail_mime Original message
|
||||
* @param int Output message type
|
||||
*/
|
||||
function __construct($message, $type)
|
||||
{
|
||||
$this->message = $message;
|
||||
$this->type = $type;
|
||||
|
||||
// clone parameters
|
||||
foreach (array_keys($this->build_params) as $param) {
|
||||
$this->build_params[$param] = $message->getParam($param);
|
||||
}
|
||||
|
||||
// clone headers
|
||||
$this->headers = $message->headers();
|
||||
|
||||
// \r\n is must-have here
|
||||
$this->body = $message->get() . "\r\n";
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if the message is multipart (requires PGP/MIME)
|
||||
*
|
||||
* @return bool True if it is multipart, otherwise False
|
||||
*/
|
||||
public function isMultipart()
|
||||
{
|
||||
return $this->message instanceof enigma_mime_message
|
||||
|| $this->message->isMultipart() || $this->message->getHTMLBody();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get e-mail address of message sender
|
||||
*
|
||||
* @return string Sender address
|
||||
*/
|
||||
public function getFromAddress()
|
||||
{
|
||||
// get sender address
|
||||
$headers = $this->message->headers();
|
||||
$from = rcube_mime::decode_address_list($headers['From'], 1, false, null, true);
|
||||
$from = $from[1];
|
||||
|
||||
return $from;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get recipients' e-mail addresses
|
||||
*
|
||||
* @return array Recipients' addresses
|
||||
*/
|
||||
public function getRecipients()
|
||||
{
|
||||
// get sender address
|
||||
$headers = $this->message->headers();
|
||||
$to = rcube_mime::decode_address_list($headers['To'], null, false, null, true);
|
||||
$cc = rcube_mime::decode_address_list($headers['Cc'], null, false, null, true);
|
||||
$bcc = rcube_mime::decode_address_list($headers['Bcc'], null, false, null, true);
|
||||
|
||||
$recipients = array_unique(array_merge($to, $cc, $bcc));
|
||||
$recipients = array_diff($recipients, array('undisclosed-recipients:'));
|
||||
|
||||
return $recipients;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get original message body, to be encrypted/signed
|
||||
*
|
||||
* @return string Message body
|
||||
*/
|
||||
public function getOrigBody()
|
||||
{
|
||||
$_headers = $this->message->headers();
|
||||
$headers = array();
|
||||
|
||||
if ($_headers['Content-Transfer-Encoding']
|
||||
&& stripos($_headers['Content-Type'], 'multipart') === false
|
||||
) {
|
||||
$headers[] = 'Content-Transfer-Encoding: ' . $_headers['Content-Transfer-Encoding'];
|
||||
}
|
||||
$headers[] = 'Content-Type: ' . $_headers['Content-Type'];
|
||||
|
||||
return implode("\r\n", $headers) . "\r\n\r\n" . $this->body;
|
||||
}
|
||||
|
||||
/**
|
||||
* Register signature attachment
|
||||
*
|
||||
* @param string Signature body
|
||||
*/
|
||||
public function addPGPSignature($body)
|
||||
{
|
||||
$this->signature = $body;
|
||||
|
||||
// Reset Content-Type to be overwritten with valid boundary
|
||||
unset($this->headers['Content-Type']);
|
||||
unset($this->headers['Content-Transfer-Encoding']);
|
||||
}
|
||||
|
||||
/**
|
||||
* Register encrypted body
|
||||
*
|
||||
* @param string Encrypted body
|
||||
*/
|
||||
public function setPGPEncryptedBody($body)
|
||||
{
|
||||
$this->encrypted = $body;
|
||||
|
||||
// Reset Content-Type to be overwritten with valid boundary
|
||||
unset($this->headers['Content-Type']);
|
||||
unset($this->headers['Content-Transfer-Encoding']);
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds the multipart message.
|
||||
*
|
||||
* @param array $params Build parameters that change the way the email
|
||||
* is built. Should be associative. See $_build_params.
|
||||
* @param resource $filename Output file where to save the message instead of
|
||||
* returning it
|
||||
* @param boolean $skip_head True if you want to return/save only the message
|
||||
* without headers
|
||||
*
|
||||
* @return mixed The MIME message content string, null or PEAR error object
|
||||
*/
|
||||
public function get($params = null, $filename = null, $skip_head = false)
|
||||
{
|
||||
if (isset($params)) {
|
||||
while (list($key, $value) = each($params)) {
|
||||
$this->build_params[$key] = $value;
|
||||
}
|
||||
}
|
||||
|
||||
$this->checkParams();
|
||||
|
||||
if ($this->type == self::PGP_SIGNED) {
|
||||
$params = array(
|
||||
'preamble' => "This is an OpenPGP/MIME signed message (RFC 4880 and 3156)",
|
||||
'content_type' => "multipart/signed; micalg=pgp-sha1; protocol=\"application/pgp-signature\"",
|
||||
'eol' => $this->build_params['eol'],
|
||||
);
|
||||
|
||||
$message = new Mail_mimePart('', $params);
|
||||
|
||||
if (!empty($this->body)) {
|
||||
$headers = $this->message->headers();
|
||||
$params = array('content_type' => $headers['Content-Type']);
|
||||
|
||||
if ($headers['Content-Transfer-Encoding']
|
||||
&& stripos($headers['Content-Type'], 'multipart') === false
|
||||
) {
|
||||
$params['encoding'] = $headers['Content-Transfer-Encoding'];
|
||||
}
|
||||
|
||||
$message->addSubpart($this->body, $params);
|
||||
}
|
||||
|
||||
if (!empty($this->signature)) {
|
||||
$message->addSubpart($this->signature, array(
|
||||
'filename' => 'signature.asc',
|
||||
'content_type' => 'application/pgp-signature',
|
||||
'disposition' => 'attachment',
|
||||
'description' => 'OpenPGP digital signature',
|
||||
));
|
||||
}
|
||||
}
|
||||
else if ($this->type == self::PGP_ENCRYPTED) {
|
||||
$params = array(
|
||||
'preamble' => "This is an OpenPGP/MIME encrypted message (RFC 4880 and 3156)",
|
||||
'content_type' => "multipart/encrypted; protocol=\"application/pgp-encrypted\"",
|
||||
'eol' => $this->build_params['eol'],
|
||||
);
|
||||
|
||||
$message = new Mail_mimePart('', $params);
|
||||
|
||||
$message->addSubpart('Version: 1', array(
|
||||
'content_type' => 'application/pgp-encrypted',
|
||||
'description' => 'PGP/MIME version identification',
|
||||
));
|
||||
|
||||
$message->addSubpart($this->encrypted, array(
|
||||
'content_type' => 'application/octet-stream',
|
||||
'description' => 'PGP/MIME encrypted message',
|
||||
'disposition' => 'inline',
|
||||
'filename' => 'encrypted.asc',
|
||||
));
|
||||
}
|
||||
|
||||
// Use saved boundary
|
||||
if (!empty($this->build_params['boundary'])) {
|
||||
$boundary = $this->build_params['boundary'];
|
||||
}
|
||||
else {
|
||||
$boundary = null;
|
||||
}
|
||||
|
||||
// Write output to file
|
||||
if ($filename) {
|
||||
// Append mimePart message headers and body into file
|
||||
$headers = $message->encodeToFile($filename, $boundary, $skip_head);
|
||||
|
||||
if ($this->isError($headers)) {
|
||||
return $headers;
|
||||
}
|
||||
|
||||
$this->headers = array_merge($this->headers, $headers);
|
||||
|
||||
return;
|
||||
}
|
||||
else {
|
||||
$output = $message->encode($boundary, $skip_head);
|
||||
|
||||
if ($this->isError($output)) {
|
||||
return $output;
|
||||
}
|
||||
|
||||
$this->headers = array_merge($this->headers, $output['headers']);
|
||||
|
||||
return $output['body'];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Content-Type and Content-Transfer-Encoding headers of the message
|
||||
*
|
||||
* @return array Headers array
|
||||
*/
|
||||
protected function contentHeaders()
|
||||
{
|
||||
$this->checkParams();
|
||||
|
||||
$eol = $this->build_params['eol'] ?: "\r\n";
|
||||
|
||||
// multipart message: and boundary
|
||||
if (!empty($this->build_params['boundary'])) {
|
||||
$boundary = $this->build_params['boundary'];
|
||||
}
|
||||
else if (!empty($this->headers['Content-Type'])
|
||||
&& preg_match('/boundary="([^"]+)"/', $this->headers['Content-Type'], $m)
|
||||
) {
|
||||
$boundary = $m[1];
|
||||
}
|
||||
else {
|
||||
$boundary = '=_' . md5(rand() . microtime());
|
||||
}
|
||||
|
||||
$this->build_params['boundary'] = $boundary;
|
||||
|
||||
if ($this->type == self::PGP_SIGNED) {
|
||||
$headers['Content-Type'] = "multipart/signed; micalg=pgp-sha1;$eol"
|
||||
." protocol=\"application/pgp-signature\";$eol"
|
||||
." boundary=\"$boundary\"";
|
||||
}
|
||||
else if ($this->type == self::PGP_ENCRYPTED) {
|
||||
$headers['Content-Type'] = "multipart/encrypted;$eol"
|
||||
." protocol=\"application/pgp-encrypted\";$eol"
|
||||
." boundary=\"$boundary\"";
|
||||
}
|
||||
|
||||
return $headers;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
+-------------------------------------------------------------------------+
|
||||
| Signature class for the Enigma Plugin |
|
||||
| |
|
||||
| Copyright (C) 2010-2015 The Roundcube Dev Team |
|
||||
| |
|
||||
| Licensed under the GNU General Public License version 3 or |
|
||||
| any later version with exceptions for skins & plugins. |
|
||||
| See the README file for a full license statement. |
|
||||
| |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Author: Aleksander Machniak <alec@alec.pl> |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
class enigma_signature
|
||||
{
|
||||
public $id;
|
||||
public $valid;
|
||||
public $fingerprint;
|
||||
public $created;
|
||||
public $expires;
|
||||
public $name;
|
||||
public $comment;
|
||||
public $email;
|
||||
|
||||
// Set it to true if signature is valid, but part of the message
|
||||
// was out of the signed block
|
||||
public $partial;
|
||||
}
|
||||
@@ -0,0 +1,79 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
+-------------------------------------------------------------------------+
|
||||
| SubKey class for the Enigma Plugin |
|
||||
| |
|
||||
| Copyright (C) 2010-2015 The Roundcube Dev Team |
|
||||
| |
|
||||
| Licensed under the GNU General Public License version 3 or |
|
||||
| any later version with exceptions for skins & plugins. |
|
||||
| See the README file for a full license statement. |
|
||||
| |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Author: Aleksander Machniak <alec@alec.pl> |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
class enigma_subkey
|
||||
{
|
||||
public $id;
|
||||
public $fingerprint;
|
||||
public $expires;
|
||||
public $created;
|
||||
public $revoked;
|
||||
public $has_private;
|
||||
public $algorithm;
|
||||
public $length;
|
||||
public $usage;
|
||||
|
||||
|
||||
/**
|
||||
* Converts internal ID to short ID
|
||||
* Crypt_GPG uses internal, but e.g. Thunderbird's Enigmail displays short ID
|
||||
*
|
||||
* @return string Key ID
|
||||
*/
|
||||
function get_short_id()
|
||||
{
|
||||
// E.g. 04622F2089E037A5 => 89E037A5
|
||||
return enigma_key::format_id($this->id);
|
||||
}
|
||||
|
||||
/**
|
||||
* Getter for formatted fingerprint
|
||||
*
|
||||
* @return string Formatted fingerprint
|
||||
*/
|
||||
function get_fingerprint()
|
||||
{
|
||||
return enigma_key::format_fingerprint($this->fingerprint);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns human-readable name of the key's algorithm
|
||||
*
|
||||
* @return string Algorithm name
|
||||
*/
|
||||
function get_algorithm()
|
||||
{
|
||||
// http://tools.ietf.org/html/rfc4880#section-9.1
|
||||
switch ($this->algorithm) {
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
return 'RSA';
|
||||
case 16:
|
||||
case 20:
|
||||
return 'Elgamal';
|
||||
case 17:
|
||||
return 'DSA';
|
||||
case 18:
|
||||
return 'Elliptic Curve';
|
||||
case 19:
|
||||
return 'ECDSA';
|
||||
case 21:
|
||||
return 'Diffie-Hellman';
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,25 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
+-------------------------------------------------------------------------+
|
||||
| User ID class for the Enigma Plugin |
|
||||
| |
|
||||
| Copyright (C) 2010-2015 The Roundcube Dev Team |
|
||||
| |
|
||||
| Licensed under the GNU General Public License version 3 or |
|
||||
| any later version with exceptions for skins & plugins. |
|
||||
| See the README file for a full license statement. |
|
||||
| |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Author: Aleksander Machniak <alec@alec.pl> |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
class enigma_userid
|
||||
{
|
||||
public $revoked;
|
||||
public $valid;
|
||||
public $name;
|
||||
public $comment;
|
||||
public $email;
|
||||
}
|
||||
Reference in New Issue
Block a user