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

Source for file Signature.php

Documentation is available at Signature.php

  1. <?php
  2.  
  3. /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
  4.  
  5. /**
  6.  * A class representing GPG signatures
  7.  *
  8.  * This file contains a data class representing a GPG signature.
  9.  *
  10.  * PHP version 5
  11.  *
  12.  * LICENSE:
  13.  *
  14.  * This library is free software; you can redistribute it and/or modify
  15.  * it under the terms of the GNU Lesser General Public License as
  16.  * published by the Free Software Foundation; either version 2.1 of the
  17.  * License, or (at your option) any later version.
  18.  *
  19.  * This library is distributed in the hope that it will be useful,
  20.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  22.  * Lesser General Public License for more details.
  23.  *
  24.  * You should have received a copy of the GNU Lesser General Public
  25.  * License along with this library; if not, write to the Free Software
  26.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  27.  *
  28.  * @category  Encryption
  29.  * @package   Crypt_GPG
  30.  * @author    Nathan Fredrickson <nathan@silverorange.com>
  31.  * @author    Michael Gauthier <mike@silverorange.com>
  32.  * @copyright 2005-2013 silverorange
  33.  * @license   http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
  34.  * @version   CVS: $Id$
  35.  * @link      http://pear.php.net/package/Crypt_GPG
  36.  */
  37.  
  38. /**
  39.  * User id class definition
  40.  */
  41. require_once 'Crypt/GPG/UserId.php';
  42.  
  43. // {{{ class Crypt_GPG_Signature
  44.  
  45. /**
  46.  * A class for GPG signature information
  47.  *
  48.  * This class is used to store the results of the Crypt_GPG::verify() method.
  49.  *
  50.  * @category  Encryption
  51.  * @package   Crypt_GPG
  52.  * @author    Nathan Fredrickson <nathan@silverorange.com>
  53.  * @author    Michael Gauthier <mike@silverorange.com>
  54.  * @copyright 2005-2013 silverorange
  55.  * @license   http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
  56.  * @link      http://pear.php.net/package/Crypt_GPG
  57.  * @see       Crypt_GPG::verify()
  58.  */
  59. {
  60.     // {{{ class properties
  61.  
  62.     /**
  63.      * A base64-encoded string containing a unique id for this signature if
  64.      * this signature has been verified as ok
  65.      *
  66.      * This id is used to prevent replay attacks and is not present for all
  67.      * types of signatures.
  68.      *
  69.      * @var string 
  70.      */
  71.     private $_id '';
  72.  
  73.     /**
  74.      * The fingerprint of the key used to create the signature
  75.      *
  76.      * @var string 
  77.      */
  78.     private $_keyFingerprint '';
  79.  
  80.     /**
  81.      * The id of the key used to create the signature
  82.      *
  83.      * @var string 
  84.      */
  85.     private $_keyId '';
  86.  
  87.     /**
  88.      * The creation date of this signature
  89.      *
  90.      * This is a Unix timestamp.
  91.      *
  92.      * @var integer 
  93.      */
  94.     private $_creationDate = 0;
  95.  
  96.     /**
  97.      * The expiration date of the signature
  98.      *
  99.      * This is a Unix timestamp. If this signature does not expire, this will
  100.      * be zero.
  101.      *
  102.      * @var integer 
  103.      */
  104.     private $_expirationDate = 0;
  105.  
  106.     /**
  107.      * The user id associated with this signature
  108.      *
  109.      * @var Crypt_GPG_UserId 
  110.      */
  111.     private $_userId = null;
  112.  
  113.     /**
  114.      * Whether or not this signature is valid
  115.      *
  116.      * @var boolean 
  117.      */
  118.     private $_isValid = false;
  119.  
  120.     // }}}
  121.     // {{{ __construct()
  122.  
  123.     /**
  124.      * Creates a new signature
  125.      *
  126.      * Signatures can be initialized from an array of named values. Available
  127.      * names are:
  128.      *
  129.      * - <kbd>string  id</kbd>          - the unique id of this signature.
  130.      * - <kbd>string  fingerprint</kbd> - the fingerprint of the key used to
  131.      *                                    create the signature. The fingerprint
  132.      *                                    should not contain formatting
  133.      *                                    characters.
  134.      * - <kbd>string  keyId</kbd>       - the id of the key used to create the
  135.      *                                    the signature.
  136.      * - <kbd>integer creation</kbd>    - the date the signature was created.
  137.      *                                    This is a UNIX timestamp.
  138.      * - <kbd>integer expiration</kbd>  - the date the signature expired. This
  139.      *                                    is a UNIX timestamp. If the signature
  140.      *                                    does not expire, use 0.
  141.      * - <kbd>boolean valid</kbd>       - whether or not the signature is valid.
  142.      * - <kbd>string  userId</kbd>      - the user id associated with the
  143.      *                                    signature. This may also be a
  144.      *                                    {@link Crypt_GPG_UserId} object.
  145.      *
  146.      * @param Crypt_GPG_Signature|array$signature optional. Either an existing
  147.      *         signature object, which is copied; or an array of initial values.
  148.      */
  149.     public function __construct($signature = null)
  150.     {
  151.         // copy from object
  152.         if ($signature instanceof Crypt_GPG_Signature{
  153.             $this->_id             $signature->_id;
  154.             $this->_keyFingerprint $signature->_keyFingerprint;
  155.             $this->_keyId          $signature->_keyId;
  156.             $this->_creationDate   $signature->_creationDate;
  157.             $this->_expirationDate $signature->_expirationDate;
  158.             $this->_isValid        $signature->_isValid;
  159.  
  160.             if ($signature->_userId instanceof Crypt_GPG_UserId{
  161.                 $this->_userId = clone $signature->_userId;
  162.             }
  163.         }
  164.  
  165.         // initialize from array
  166.         if (is_array($signature)) {
  167.             if (array_key_exists('id'$signature)) {
  168.                 $this->setId($signature['id']);
  169.             }
  170.  
  171.             if (array_key_exists('fingerprint'$signature)) {
  172.                 $this->setKeyFingerprint($signature['fingerprint']);
  173.             }
  174.  
  175.             if (array_key_exists('keyId'$signature)) {
  176.                 $this->setKeyId($signature['keyId']);
  177.             }
  178.  
  179.             if (array_key_exists('creation'$signature)) {
  180.                 $this->setCreationDate($signature['creation']);
  181.             }
  182.  
  183.             if (array_key_exists('expiration'$signature)) {
  184.                 $this->setExpirationDate($signature['expiration']);
  185.             }
  186.  
  187.             if (array_key_exists('valid'$signature)) {
  188.                 $this->setValid($signature['valid']);
  189.             }
  190.  
  191.             if (array_key_exists('userId'$signature)) {
  192.                 $userId = new Crypt_GPG_UserId($signature['userId']);
  193.                 $this->setUserId($userId);
  194.             }
  195.         }
  196.     }
  197.  
  198.     // }}}
  199.     // {{{ getId()
  200.  
  201.     /**
  202.      * Gets the id of this signature
  203.      *
  204.      * @return string a base64-encoded string containing a unique id for this
  205.      *                 signature. This id is used to prevent replay attacks and
  206.      *                 is not present for all types of signatures.
  207.      */
  208.     public function getId()
  209.     {
  210.         return $this->_id;
  211.     }
  212.  
  213.     // }}}
  214.     // {{{ getKeyFingerprint()
  215.  
  216.     /**
  217.      * Gets the fingerprint of the key used to create this signature
  218.      *
  219.      * @return string the fingerprint of the key used to create this signature.
  220.      */
  221.     public function getKeyFingerprint()
  222.     {
  223.         return $this->_keyFingerprint;
  224.     }
  225.  
  226.     // }}}
  227.     // {{{ getKeyId()
  228.  
  229.     /**
  230.      * Gets the id of the key used to create this signature
  231.      *
  232.      * Whereas the fingerprint of the signing key may not always be available
  233.      * (for example if the signature is bad), the id should always be
  234.      * available.
  235.      *
  236.      * @return string the id of the key used to create this signature.
  237.      */
  238.     public function getKeyId()
  239.     {
  240.         return $this->_keyId;
  241.     }
  242.  
  243.     // }}}
  244.     // {{{ getCreationDate()
  245.  
  246.     /**
  247.      * Gets the creation date of this signature
  248.      *
  249.      * @return integer the creation date of this signature. This is a Unix
  250.      *                  timestamp.
  251.      */
  252.     public function getCreationDate()
  253.     {
  254.         return $this->_creationDate;
  255.     }
  256.  
  257.     // }}}
  258.     // {{{ getExpirationDate()
  259.  
  260.     /**
  261.      * Gets the expiration date of the signature
  262.      *
  263.      * @return integer the expiration date of this signature. This is a Unix
  264.      *                  timestamp. If this signature does not expire, this will
  265.      *                  be zero.
  266.      */
  267.     public function getExpirationDate()
  268.     {
  269.         return $this->_expirationDate;
  270.     }
  271.  
  272.     // }}}
  273.     // {{{ getUserId()
  274.  
  275.     /**
  276.      * Gets the user id associated with this signature
  277.      *
  278.      * @return Crypt_GPG_UserId the user id associated with this signature.
  279.      */
  280.     public function getUserId()
  281.     {
  282.         return $this->_userId;
  283.     }
  284.  
  285.     // }}}
  286.     // {{{ isValid()
  287.  
  288.     /**
  289.      * Gets whether or no this signature is valid
  290.      *
  291.      * @return boolean true if this signature is valid and false if it is not.
  292.      */
  293.     public function isValid()
  294.     {
  295.         return $this->_isValid;
  296.     }
  297.  
  298.     // }}}
  299.     // {{{ setId()
  300.  
  301.     /**
  302.      * Sets the id of this signature
  303.      *
  304.      * @param string $id a base64-encoded string containing a unique id for
  305.      *                    this signature.
  306.      *
  307.      * @return Crypt_GPG_Signature the current object, for fluent interface.
  308.      *
  309.      * @see Crypt_GPG_Signature::getId()
  310.      */
  311.     public function setId($id)
  312.     {
  313.         $this->_id strval($id);
  314.         return $this;
  315.     }
  316.  
  317.     // }}}
  318.     // {{{ setKeyFingerprint()
  319.  
  320.     /**
  321.      * Sets the key fingerprint of this signature
  322.      *
  323.      * @param string $fingerprint the key fingerprint of this signature. This
  324.      *                             is the fingerprint of the primary key used to
  325.      *                             create this signature.
  326.      *
  327.      * @return Crypt_GPG_Signature the current object, for fluent interface.
  328.      */
  329.     public function setKeyFingerprint($fingerprint)
  330.     {
  331.         $this->_keyFingerprint strval($fingerprint);
  332.         return $this;
  333.     }
  334.  
  335.     // }}}
  336.     // {{{ setKeyId()
  337.  
  338.     /**
  339.      * Sets the key id of this signature
  340.      *
  341.      * @param string $id the key id of this signature. This is the id of the
  342.      *                    primary key used to create this signature.
  343.      *
  344.      * @return Crypt_GPG_Signature the current object, for fluent interface.
  345.      */
  346.     public function setKeyId($id)
  347.     {
  348.         $this->_keyId strval($id);
  349.         return $this;
  350.     }
  351.  
  352.     // }}}
  353.     // {{{ setCreationDate()
  354.  
  355.     /**
  356.      * Sets the creation date of this signature
  357.      *
  358.      * @param integer $creationDate the creation date of this signature. This
  359.      *                               is a Unix timestamp.
  360.      *
  361.      * @return Crypt_GPG_Signature the current object, for fluent interface.
  362.      */
  363.     public function setCreationDate($creationDate)
  364.     {
  365.         $this->_creationDate intval($creationDate);
  366.         return $this;
  367.     }
  368.  
  369.     // }}}
  370.     // {{{ setExpirationDate()
  371.  
  372.     /**
  373.      * Sets the expiration date of this signature
  374.      *
  375.      * @param integer $expirationDate the expiration date of this signature.
  376.      *                                 This is a Unix timestamp. Specify zero if
  377.      *                                 this signature does not expire.
  378.      *
  379.      * @return Crypt_GPG_Signature the current object, for fluent interface.
  380.      */
  381.     public function setExpirationDate($expirationDate)
  382.     {
  383.         $this->_expirationDate intval($expirationDate);
  384.         return $this;
  385.     }
  386.  
  387.     // }}}
  388.     // {{{ setUserId()
  389.  
  390.     /**
  391.      * Sets the user id associated with this signature
  392.      *
  393.      * @param Crypt_GPG_UserId $userId the user id associated with this
  394.      *                                  signature.
  395.      *
  396.      * @return Crypt_GPG_Signature the current object, for fluent interface.
  397.      */
  398.     public function setUserId(Crypt_GPG_UserId $userId)
  399.     {
  400.         $this->_userId $userId;
  401.         return $this;
  402.     }
  403.  
  404.     // }}}
  405.     // {{{ setValid()
  406.  
  407.     /**
  408.      * Sets whether or not this signature is valid
  409.      *
  410.      * @param boolean $isValid true if this signature is valid and false if it
  411.      *                          is not.
  412.      *
  413.      * @return Crypt_GPG_Signature the current object, for fluent interface.
  414.      */
  415.     public function setValid($isValid)
  416.     {
  417.         $this->_isValid ($isValid? true : false;
  418.         return $this;
  419.     }
  420.  
  421.     // }}}
  422. }
  423.  
  424. // }}}
  425.  
  426. ?>

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