Crypt_GPG
[ class tree: Crypt_GPG ] [ index: Crypt_GPG ] [ all elements ]

Source for file SubKey.php

Documentation is available at SubKey.php

  1. <?php
  2.  
  3. /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
  4.  
  5. /**
  6.  * Contains a class representing GPG sub-keys and constants for GPG algorithms
  7.  *
  8.  * PHP version 5
  9.  *
  10.  * LICENSE:
  11.  *
  12.  * This library is free software; you can redistribute it and/or modify
  13.  * it under the terms of the GNU Lesser General Public License as
  14.  * published by the Free Software Foundation; either version 2.1 of the
  15.  * License, or (at your option) any later version.
  16.  *
  17.  * This library is distributed in the hope that it will be useful,
  18.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  20.  * Lesser General Public License for more details.
  21.  *
  22.  * You should have received a copy of the GNU Lesser General Public
  23.  * License along with this library; if not, write to the Free Software
  24.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  25.  *
  26.  * @category  Encryption
  27.  * @package   Crypt_GPG
  28.  * @author    Michael Gauthier <mike@silverorange.com>
  29.  * @author    Nathan Fredrickson <nathan@silverorange.com>
  30.  * @copyright 2005-2010 silverorange
  31.  * @license   http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
  32.  * @version   CVS: $Id$
  33.  * @link      http://pear.php.net/package/Crypt_GPG
  34.  */
  35.  
  36. // {{{ class Crypt_GPG_SubKey
  37.  
  38. /**
  39.  * A class for GPG sub-key information
  40.  *
  41.  * This class is used to store the results of the {@link Crypt_GPG::getKeys()}
  42.  * method. Sub-key objects are members of a {@link Crypt_GPG_Key} object.
  43.  *
  44.  * @category  Encryption
  45.  * @package   Crypt_GPG
  46.  * @author    Michael Gauthier <mike@silverorange.com>
  47.  * @author    Nathan Fredrickson <nathan@silverorange.com>
  48.  * @copyright 2005-2010 silverorange
  49.  * @license   http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
  50.  * @link      http://pear.php.net/package/Crypt_GPG
  51.  * @see       Crypt_GPG::getKeys()
  52.  * @see       Crypt_GPG_Key::getSubKeys()
  53.  */
  54. {
  55.     // {{{ algorithm class constants
  56.  
  57.     /**
  58.      * RSA encryption algorithm.
  59.      */
  60.     const ALGORITHM_RSA = 1;
  61.  
  62.     /**
  63.      * Elgamal encryption algorithm (encryption only).
  64.      */
  65.     const ALGORITHM_ELGAMAL_ENC = 16;
  66.  
  67.     /**
  68.      * DSA encryption algorithm (sometimes called DH, sign only).
  69.      */
  70.     const ALGORITHM_DSA = 17;
  71.  
  72.     /**
  73.      * Elgamal encryption algorithm (signage and encryption - should not be
  74.      * used).
  75.      */
  76.     const ALGORITHM_ELGAMAL_ENC_SGN = 20;
  77.  
  78.     // }}}
  79.     // {{{ usage class constants
  80.  
  81.     /**
  82.      * Key can be used to encrypt
  83.      */
  84.     const USAGE_ENCRYPT = 1;
  85.  
  86.     /**
  87.      * Key can be used to sign
  88.      */
  89.     const USAGE_SIGN = 2;
  90.  
  91.     /**
  92.      * Key can be used to certify other keys
  93.      */
  94.     const USAGE_CERTIFY = 4;
  95.  
  96.     /**
  97.      * Key can be used for authentication
  98.      */
  99.     const USAGE_AUTHENTICATION = 8;
  100.  
  101.     // }}}
  102.     // {{{ class properties
  103.  
  104.     /**
  105.      * The id of this sub-key
  106.      *
  107.      * @var string 
  108.      */
  109.     private $_id '';
  110.  
  111.     /**
  112.      * The algorithm used to create this sub-key
  113.      *
  114.      * The value is one of the Crypt_GPG_SubKey::ALGORITHM_* constants.
  115.      *
  116.      * @var integer 
  117.      */
  118.     private $_algorithm = 0;
  119.  
  120.     /**
  121.      * The fingerprint of this sub-key
  122.      *
  123.      * @var string 
  124.      */
  125.     private $_fingerprint '';
  126.  
  127.     /**
  128.      * Length of this sub-key in bits
  129.      *
  130.      * @var integer 
  131.      */
  132.     private $_length = 0;
  133.  
  134.     /**
  135.      * Date this sub-key was created
  136.      *
  137.      * This is a Unix timestamp.
  138.      *
  139.      * @var integer 
  140.      */
  141.     private $_creationDate = 0;
  142.  
  143.     /**
  144.      * Date this sub-key expires
  145.      *
  146.      * This is a Unix timestamp. If this sub-key does not expire, this will be
  147.      * zero.
  148.      *
  149.      * @var integer 
  150.      */
  151.     private $_expirationDate = 0;
  152.  
  153.     /**
  154.      * Whether or not this sub-key can sign data
  155.      *
  156.      * @var boolean 
  157.      */
  158.     private $_canSign = false;
  159.  
  160.     /**
  161.      * Whether or not this sub-key can encrypt data
  162.      *
  163.      * @var boolean 
  164.      */
  165.     private $_canEncrypt = false;
  166.  
  167.     /**
  168.      * Whether or not the private key for this sub-key exists in the keyring
  169.      *
  170.      * @var boolean 
  171.      */
  172.     private $_hasPrivate = false;
  173.  
  174.     /**
  175.      * Whether or not this sub-key is revoked
  176.      *
  177.      * @var boolean 
  178.      */
  179.     private $_isRevoked = false;
  180.  
  181.     // }}}
  182.     // {{{ __construct()
  183.  
  184.     /**
  185.      * Creates a new sub-key object
  186.      *
  187.      * Sub-keys can be initialized from an array of named values. Available
  188.      * names are:
  189.      *
  190.      * - <kbd>string  id</kbd>          - the key id of the sub-key.
  191.      * - <kbd>integer algorithm</kbd>   - the encryption algorithm of the
  192.      *                                    sub-key.
  193.      * - <kbd>string  fingerprint</kbd> - the fingerprint of the sub-key. The
  194.      *                                    fingerprint should not contain
  195.      *                                    formatting characters.
  196.      * - <kbd>integer length</kbd>      - the length of the sub-key in bits.
  197.      * - <kbd>integer creation</kbd>    - the date the sub-key was created.
  198.      *                                    This is a UNIX timestamp.
  199.      * - <kbd>integer expiration</kbd>  - the date the sub-key expires. This
  200.      *                                    is a UNIX timestamp. If the sub-key
  201.      *                                    does not expire, use 0.
  202.      * - <kbd>boolean canSign</kbd>     - whether or not the sub-key can be
  203.      *                                    used to sign data.
  204.      * - <kbd>boolean canEncrypt</kbd>  - whether or not the sub-key can be
  205.      *                                    used to encrypt data.
  206.      * - <kbd>boolean hasPrivate</kbd>  - whether or not the private key for
  207.      *                                    the sub-key exists in the keyring.
  208.      * - <kbd>boolean isRevoked</kbd>   - whether or not this sub-key is
  209.      *                                    revoked.
  210.      *
  211.      * @param Crypt_GPG_SubKey|string|array$key optional. Either an existing
  212.      *         sub-key object, which is copied; a sub-key string, which is
  213.      *         parsed; or an array of initial values.
  214.      */
  215.     public function __construct($key = null)
  216.     {
  217.         // parse from string
  218.         if (is_string($key)) {
  219.             $key = self::parse($key);
  220.         }
  221.  
  222.         // copy from object
  223.         if ($key instanceof Crypt_GPG_SubKey{
  224.             $this->_id             $key->_id;
  225.             $this->_algorithm      $key->_algorithm;
  226.             $this->_fingerprint    $key->_fingerprint;
  227.             $this->_length         $key->_length;
  228.             $this->_creationDate   $key->_creationDate;
  229.             $this->_expirationDate $key->_expirationDate;
  230.             $this->_canSign        $key->_canSign;
  231.             $this->_canEncrypt     $key->_canEncrypt;
  232.             $this->_hasPrivate     $key->_hasPrivate;
  233.             $this->_isRevoked      $key->_isRevoked;
  234.         }
  235.  
  236.         // initialize from array
  237.         if (is_array($key)) {
  238.             if (array_key_exists('id'$key)) {
  239.                 $this->setId($key['id']);
  240.             }
  241.  
  242.             if (array_key_exists('algorithm'$key)) {
  243.                 $this->setAlgorithm($key['algorithm']);
  244.             }
  245.  
  246.             if (array_key_exists('fingerprint'$key)) {
  247.                 $this->setFingerprint($key['fingerprint']);
  248.             }
  249.  
  250.             if (array_key_exists('length'$key)) {
  251.                 $this->setLength($key['length']);
  252.             }
  253.  
  254.             if (array_key_exists('creation'$key)) {
  255.                 $this->setCreationDate($key['creation']);
  256.             }
  257.  
  258.             if (array_key_exists('expiration'$key)) {
  259.                 $this->setExpirationDate($key['expiration']);
  260.             }
  261.  
  262.             if (array_key_exists('canSign'$key)) {
  263.                 $this->setCanSign($key['canSign']);
  264.             }
  265.  
  266.             if (array_key_exists('canEncrypt'$key)) {
  267.                 $this->setCanEncrypt($key['canEncrypt']);
  268.             }
  269.  
  270.             if (array_key_exists('hasPrivate'$key)) {
  271.                 $this->setHasPrivate($key['hasPrivate']);
  272.             }
  273.  
  274.             if (array_key_exists('isRevoked'$key)) {
  275.                 $this->setRevoked($key['isRevoked']);
  276.             }
  277.         }
  278.     }
  279.  
  280.     // }}}
  281.     // {{{ getId()
  282.  
  283.     /**
  284.      * Gets the id of this sub-key
  285.      *
  286.      * @return string the id of this sub-key.
  287.      */
  288.     public function getId()
  289.     {
  290.         return $this->_id;
  291.     }
  292.  
  293.     // }}}
  294.     // {{{ getAlgorithm()
  295.  
  296.     /**
  297.      * Gets the algorithm used by this sub-key
  298.      *
  299.      * The algorithm should be one of the Crypt_GPG_SubKey::ALGORITHM_*
  300.      * constants.
  301.      *
  302.      * @return integer the algorithm used by this sub-key.
  303.      */
  304.     public function getAlgorithm()
  305.     {
  306.         return $this->_algorithm;
  307.     }
  308.  
  309.     // }}}
  310.     // {{{ getCreationDate()
  311.  
  312.     /**
  313.      * Gets the creation date of this sub-key
  314.      *
  315.      * This is a Unix timestamp.
  316.      *
  317.      * @return integer the creation date of this sub-key.
  318.      */
  319.     public function getCreationDate()
  320.     {
  321.         return $this->_creationDate;
  322.     }
  323.  
  324.     // }}}
  325.     // {{{ getExpirationDate()
  326.  
  327.     /**
  328.      * Gets the date this sub-key expires
  329.      *
  330.      * This is a Unix timestamp. If this sub-key does not expire, this will be
  331.      * zero.
  332.      *
  333.      * @return integer the date this sub-key expires.
  334.      */
  335.     public function getExpirationDate()
  336.     {
  337.         return $this->_expirationDate;
  338.     }
  339.  
  340.     // }}}
  341.     // {{{ getFingerprint()
  342.  
  343.     /**
  344.      * Gets the fingerprint of this sub-key
  345.      *
  346.      * @return string the fingerprint of this sub-key.
  347.      */
  348.     public function getFingerprint()
  349.     {
  350.         return $this->_fingerprint;
  351.     }
  352.  
  353.     // }}}
  354.     // {{{ getLength()
  355.  
  356.     /**
  357.      * Gets the length of this sub-key in bits
  358.      *
  359.      * @return integer the length of this sub-key in bits.
  360.      */
  361.     public function getLength()
  362.     {
  363.         return $this->_length;
  364.     }
  365.  
  366.     // }}}
  367.     // {{{ canSign()
  368.  
  369.     /**
  370.      * Gets whether or not this sub-key can sign data
  371.      *
  372.      * @return boolean true if this sub-key can sign data and false if this
  373.      *                  sub-key can not sign data.
  374.      */
  375.     public function canSign()
  376.     {
  377.         return $this->_canSign;
  378.     }
  379.  
  380.     // }}}
  381.     // {{{ canEncrypt()
  382.  
  383.     /**
  384.      * Gets whether or not this sub-key can encrypt data
  385.      *
  386.      * @return boolean true if this sub-key can encrypt data and false if this
  387.      *                  sub-key can not encrypt data.
  388.      */
  389.     public function canEncrypt()
  390.     {
  391.         return $this->_canEncrypt;
  392.     }
  393.  
  394.     // }}}
  395.     // {{{ hasPrivate()
  396.  
  397.     /**
  398.      * Gets whether or not the private key for this sub-key exists in the
  399.      * keyring
  400.      *
  401.      * @return boolean true the private key for this sub-key exists in the
  402.      *                  keyring and false if it does not.
  403.      */
  404.     public function hasPrivate()
  405.     {
  406.         return $this->_hasPrivate;
  407.     }
  408.  
  409.     // }}}
  410.     // {{{ isRevoked()
  411.  
  412.     /**
  413.      * Gets whether or not this sub-key is revoked
  414.      *
  415.      * @return boolean true if this sub-key is revoked and false if it is not.
  416.      */
  417.     public function isRevoked()
  418.     {
  419.         return $this->_isRevoked;
  420.     }
  421.  
  422.     // }}}
  423.     // {{{ setCreationDate()
  424.  
  425.     /**
  426.      * Sets the creation date of this sub-key
  427.      *
  428.      * The creation date is a Unix timestamp.
  429.      *
  430.      * @param integer $creationDate the creation date of this sub-key.
  431.      *
  432.      * @return Crypt_GPG_SubKey the current object, for fluent interface.
  433.      */
  434.     public function setCreationDate($creationDate)
  435.     {
  436.         $this->_creationDate intval($creationDate);
  437.         return $this;
  438.     }
  439.  
  440.     // }}}
  441.     // {{{ setExpirationDate()
  442.  
  443.     /**
  444.      * Sets the expiration date of this sub-key
  445.      *
  446.      * The expiration date is a Unix timestamp. Specify zero if this sub-key
  447.      * does not expire.
  448.      *
  449.      * @param integer $expirationDate the expiration date of this sub-key.
  450.      *
  451.      * @return Crypt_GPG_SubKey the current object, for fluent interface.
  452.      */
  453.     public function setExpirationDate($expirationDate)
  454.     {
  455.         $this->_expirationDate intval($expirationDate);
  456.         return $this;
  457.     }
  458.  
  459.     // }}}
  460.     // {{{ setId()
  461.  
  462.     /**
  463.      * Sets the id of this sub-key
  464.      *
  465.      * @param string $id the id of this sub-key.
  466.      *
  467.      * @return Crypt_GPG_SubKey the current object, for fluent interface.
  468.      */
  469.     public function setId($id)
  470.     {
  471.         $this->_id strval($id);
  472.         return $this;
  473.     }
  474.  
  475.     // }}}
  476.     // {{{ setAlgorithm()
  477.  
  478.     /**
  479.      * Sets the algorithm used by this sub-key
  480.      *
  481.      * @param integer $algorithm the algorithm used by this sub-key.
  482.      *
  483.      * @return Crypt_GPG_SubKey the current object, for fluent interface.
  484.      */
  485.     public function setAlgorithm($algorithm)
  486.     {
  487.         $this->_algorithm intval($algorithm);
  488.         return $this;
  489.     }
  490.  
  491.     // }}}
  492.     // {{{ setFingerprint()
  493.  
  494.     /**
  495.      * Sets the fingerprint of this sub-key
  496.      *
  497.      * @param string $fingerprint the fingerprint of this sub-key.
  498.      *
  499.      * @return Crypt_GPG_SubKey the current object, for fluent interface.
  500.      */
  501.     public function setFingerprint($fingerprint)
  502.     {
  503.         $this->_fingerprint strval($fingerprint);
  504.         return $this;
  505.     }
  506.  
  507.     // }}}
  508.     // {{{ setLength()
  509.  
  510.     /**
  511.      * Sets the length of this sub-key in bits
  512.      *
  513.      * @param integer $length the length of this sub-key in bits.
  514.      *
  515.      * @return Crypt_GPG_SubKey the current object, for fluent interface.
  516.      */
  517.     public function setLength($length)
  518.     {
  519.         $this->_length intval($length);
  520.         return $this;
  521.     }
  522.  
  523.     // }}}
  524.     // {{{ setCanSign()
  525.  
  526.     /**
  527.      * Sets whether of not this sub-key can sign data
  528.      *
  529.      * @param boolean $canSign true if this sub-key can sign data and false if
  530.      *                          it can not.
  531.      *
  532.      * @return Crypt_GPG_SubKey the current object, for fluent interface.
  533.      */
  534.     public function setCanSign($canSign)
  535.     {
  536.         $this->_canSign ($canSign? true : false;
  537.         return $this;
  538.     }
  539.  
  540.     // }}}
  541.     // {{{ setCanEncrypt()
  542.  
  543.     /**
  544.      * Sets whether of not this sub-key can encrypt data
  545.      *
  546.      * @param boolean $canEncrypt true if this sub-key can encrypt data and
  547.      *                             false if it can not.
  548.      *
  549.      * @return Crypt_GPG_SubKey the current object, for fluent interface.
  550.      */
  551.     public function setCanEncrypt($canEncrypt)
  552.     {
  553.         $this->_canEncrypt ($canEncrypt? true : false;
  554.         return $this;
  555.     }
  556.  
  557.     // }}}
  558.     // {{{ setHasPrivate()
  559.  
  560.     /**
  561.      * Sets whether of not the private key for this sub-key exists in the
  562.      * keyring
  563.      *
  564.      * @param boolean $hasPrivate true if the private key for this sub-key
  565.      *                             exists in the keyring and false if it does
  566.      *                             not.
  567.      *
  568.      * @return Crypt_GPG_SubKey the current object, for fluent interface.
  569.      */
  570.     public function setHasPrivate($hasPrivate)
  571.     {
  572.         $this->_hasPrivate ($hasPrivate? true : false;
  573.         return $this;
  574.     }
  575.  
  576.     // }}}
  577.     // {{{ setRevoked()
  578.  
  579.     /**
  580.      * Sets whether or not this sub-key is revoked
  581.      *
  582.      * @param boolean $isRevoked whether or not this sub-key is revoked.
  583.      *
  584.      * @return Crypt_GPG_SubKey the current object, for fluent interface.
  585.      */
  586.     public function setRevoked($isRevoked)
  587.     {
  588.         $this->_isRevoked ($isRevoked? true : false;
  589.         return $this;
  590.     }
  591.  
  592.     // }}}
  593.     // {{{ parse()
  594.  
  595.     /**
  596.      * Parses a sub-key object from a sub-key string
  597.      *
  598.      * See <b>doc/DETAILS</b> in the
  599.      * {@link http://www.gnupg.org/download/ GPG distribution} for information
  600.      * on how the sub-key string is parsed.
  601.      *
  602.      * @param string $string the string containing the sub-key.
  603.      *
  604.      * @return Crypt_GPG_SubKey the sub-key object parsed from the string.
  605.      */
  606.     public static function parse($string)
  607.     {
  608.         $tokens explode(':'$string);
  609.  
  610.         $subKey = new Crypt_GPG_SubKey();
  611.  
  612.         $subKey->setId($tokens[4]);
  613.         $subKey->setLength($tokens[2]);
  614.         $subKey->setAlgorithm($tokens[3]);
  615.         $subKey->setCreationDate(self::_parseDate($tokens[5]));
  616.         $subKey->setExpirationDate(self::_parseDate($tokens[6]));
  617.  
  618.         if ($tokens[1== 'r'{
  619.             $subKey->setRevoked(true);
  620.         }
  621.  
  622.         if (strpos($tokens[11]'s'!== false{
  623.             $subKey->setCanSign(true);
  624.         }
  625.  
  626.         if (strpos($tokens[11]'e'!== false{
  627.             $subKey->setCanEncrypt(true);
  628.         }
  629.  
  630.         return $subKey;
  631.     }
  632.  
  633.     // }}}
  634.     // {{{ _parseDate()
  635.  
  636.     /**
  637.      * Parses a date string as provided by GPG into a UNIX timestamp
  638.      *
  639.      * @param string $string the date string.
  640.      *
  641.      * @return integer the UNIX timestamp corresponding to the provided date
  642.      *                  string.
  643.      */
  644.     private static function _parseDate($string)
  645.     {
  646.         if ($string == ''{
  647.             $timestamp = 0;
  648.         else {
  649.             // all times are in UTC according to GPG documentation
  650.             $timeZone = new DateTimeZone('UTC');
  651.  
  652.             if (strpos($string'T'=== false{
  653.                 // interpret as UNIX timestamp
  654.                 $string '@' $string;
  655.             }
  656.  
  657.             $date = new DateTime($string$timeZone);
  658.  
  659.             // convert to UNIX timestamp
  660.             $timestamp intval($date->format('U'));
  661.         }
  662.  
  663.         return $timestamp;
  664.     }
  665.  
  666.     // }}}
  667. }
  668.  
  669. // }}}
  670.  
  671. ?>

Documentation generated on Wed, 13 Mar 2013 18:30:12 +0000 by phpDocumentor 1.4.3. PEAR Logo Copyright © PHP Group 2004.