text: // V2PubKey.cpp: implementation of the CV2PubKey class.
  //
  // (c) Copyright Schlumberger Technology Corp., unpublished work, created
  // 1999. This computer program includes Confidential, Proprietary
  // Information and is a Trade Secret of Schlumberger Technology Corp. All
  // use, disclosure, and/or reproduction is prohibited unless authorized
  // in writing.  All Rights Reserved.
  //////////////////////////////////////////////////////////////////////
  
  #include <scuCast.h>
  
  #include "cciCard.h"
  #include "TransactionWrap.h"
  
  #include "V2PubKey.h"
  #include "PubKeyInfoRecord.h"
  
  using namespace std;
  using namespace cci;
  
  /////////////////////////// LOCAL/HELPER  /////////////////////////////////
  
  ///////////////////////////    PUBLIC     /////////////////////////////////
  
                                                    // Types
                                                    // C'tors/D'tors
  CV2PublicKey::CV2PublicKey(CV2Card const &rv2card,
                             ObjectAccess oa)
      : CAbstractPublicKey(rv2card, oa),
        m_sidHandle(0),
        m_apcir()
  {
  
      m_sidHandle =
          rv2card.ObjectInfoFile(m_oa).AddObject(otPublicKeyObject,
                                                 PublInfoRecordSize);
  
      Setup(rv2card);
  
      // write new public key object into info file
      m_apcir->Clear();
      m_apcir->Write();
  }
  
  CV2PublicKey::CV2PublicKey(CV2Card const &rv2card,
                             SymbolID sidHandle,
                             ObjectAccess oa)
      : CAbstractPublicKey(rv2card, oa),
        m_sidHandle(sidHandle),
        m_apcir()
  {
      Setup(rv2card);
  }
  
  CV2PublicKey::~CV2PublicKey()
  {}
  
  
                                                    // Operators
                                                    // Operations
  void
  CV2PublicKey::CKInvisible(bool flag)
  {
      m_apcir->Flag(PublCKInvisibleFlag, flag);
  }
  
  void
  CV2PublicKey::CredentialID(string const &rstrID)
  {
      m_apcir->Symbol(&m_apcir->m_bCredentialID, rstrID);
  }
  
  void
  CV2PublicKey::Derive(bool flag)
  {
      m_apcir->Flag(PublDeriveFlag, flag);
  }
  
  void
  CV2PublicKey::ID(string const &rstrID)
  {
      m_apcir->Symbol(&m_apcir->m_bID, rstrID);
  }
  
  void
  CV2PublicKey::EndDate(Date const &rdtEnd)
  {
      CTransactionWrap wrap(m_hcard);
      m_apcir->Read();
      m_apcir->m_dtEnd = rdtEnd;
      m_apcir->Write();
  }
  
  bool
  CV2PublicKey::Encrypt()
  {
      return m_apcir->Flag(PublEncryptFlag);
  }
  
  void
  CV2PublicKey::Exponent(string const &rstrExp)
  {
      m_apcir->Symbol(&m_apcir->m_bPublExponent, rstrExp);
  }
  
  void
  CV2PublicKey::Label(string const &rstrLabel)
  {
      m_apcir->Symbol(&m_apcir->m_bLabel, rstrLabel);
  }
  
  void
  CV2PublicKey::Local(bool flag)
  {
      m_apcir->Flag(PublLocalFlag, flag);
  }
  
  CV2PublicKey *
  CV2PublicKey::Make(CV2Card const &rv2card,
                     SymbolID sidHandle,
                     ObjectAccess oa)
  {
      return new CV2PublicKey(rv2card, sidHandle, oa);
  }
  
  void
  CV2PublicKey::Modifiable(bool flag)
  {
      m_apcir->Flag(PublModifiableFlag, flag);
  }
  
  void
  CV2PublicKey::Modulus(string const &rstrMod)
  {
      CTransactionWrap wrap(m_hcard);
  
      m_apcir->Read();
  
      m_apcir->Symbol(&m_apcir->m_bModulus, rstrMod);
  
      if (rstrMod.size() == 0x80)
          m_apcir->m_bKeyType = CardKeyTypeRSA1024;
      else if (rstrMod.size() == 0x60)
          m_apcir->m_bKeyType = CardKeyTypeRSA768;
      else if (rstrMod.size() == 0x40)
          m_apcir->m_bKeyType = CardKeyTypeRSA512;
      else
          m_apcir->m_bKeyType = CardKeyTypeNone;
  
      m_apcir->Write();
  
  }
  
  void
  CV2PublicKey::StartDate(Date const &rdtStart)
  {
      CTransactionWrap wrap(m_hcard);
      m_apcir->Read();
      m_apcir->m_dtStart = rdtStart;
      m_apcir->Write();
  
  }
  
  void
  CV2PublicKey::Subject(string const &rstrSubject)
  {
      m_apcir->Symbol(&m_apcir->m_bSubject, rstrSubject);
  }
  
  void
  CV2PublicKey::Verify(bool flag)
  {
      m_apcir->Flag(PublVerifyFlag, flag);
  }
  
  void
  CV2PublicKey::VerifyRecover(bool flag)
  {
      m_apcir->Flag(PublVerifyRecoverFlag, flag);
  }
  
  void
  CV2PublicKey::Wrap(bool flag)
  {
      m_apcir->Flag(PublWrapFlag, flag);
  }
  
                                                    // Access
  bool
  CV2PublicKey::CKInvisible()
  {
      return m_apcir->Flag(PublCKInvisibleFlag);
  }
  
  string
  CV2PublicKey::CredentialID()
  {
      return m_apcir->Symbol(&m_apcir->m_bCredentialID);
  }
  
  bool
  CV2PublicKey::Derive()
  {
      return m_apcir->Flag(PublDeriveFlag);
  }
  
  void
  CV2PublicKey::Encrypt(bool flag)
  {
      m_apcir->Flag(PublEncryptFlag, flag);
  }
  
  Date
  CV2PublicKey::EndDate()
  {
      CTransactionWrap wrap(m_hcard);
      m_apcir->Read();
      return m_apcir->m_dtEnd;
  }
  
  string
  CV2PublicKey::Exponent()
  {
      return m_apcir->Symbol(&m_apcir->m_bPublExponent);
  }
  
  SymbolID
  CV2PublicKey::Handle() const
  {
      return m_sidHandle;
  }
  
  string
  CV2PublicKey::ID()
  {
      return m_apcir->Symbol(&m_apcir->m_bID);
  }
  
  string
  CV2PublicKey::Label()
  {
      return m_apcir->Symbol(&m_apcir->m_bLabel);
  }
  
  bool
  CV2PublicKey::Local()
  {
      return m_apcir->Flag(PublLocalFlag);
  }
  
  bool
  CV2PublicKey::Modifiable()
  {
      return m_apcir->Flag(PublModifiableFlag);
  }
  
  string
  CV2PublicKey::Modulus()
  {
      return m_apcir->Symbol(&m_apcir->m_bModulus);
  }
  
  bool
  CV2PublicKey::Private()
  {
      return m_apcir->Private();
  }
  
  Date
  CV2PublicKey::StartDate()
  {
      CTransactionWrap wrap(m_hcard);
      m_apcir->Read();
      return m_apcir->m_dtStart;
  }
  
  string
  CV2PublicKey::Subject()
  {
      return m_apcir->Symbol(&m_apcir->m_bSubject);
  }
  
  bool
  CV2PublicKey::Verify()
  {
      return m_apcir->Flag(PublVerifyFlag);
  }
  
  bool
  CV2PublicKey::VerifyRecover()
  {
      return m_apcir->Flag(PublVerifyRecoverFlag);
  }
  
  bool
  CV2PublicKey::Wrap()
  {
      return m_apcir->Flag(PublWrapFlag);
  }
  
  
                                                    // Predicates
                                                    // Static Variables
  
  ///////////////////////////   PROTECTED   /////////////////////////////////
  
                                                    // C'tors/D'tors
                                                    // Operators
                                                    // Operations
  void
  CV2PublicKey::DoDelete()
  {
      CV2Card &rv2card = scu::DownCast<CV2Card &, CAbstractCard &>(*m_hcard);
  
      CObjectInfoFile &roif = rv2card.ObjectInfoFile(m_oa);
  
      m_apcir->Read();
  
      // Remove allocation of entry in private key file
  
      if (m_apcir->m_bLabel)
          roif.RemoveSymbol(m_apcir->m_bLabel);
      if (m_apcir->m_bID)
          roif.RemoveSymbol(m_apcir->m_bID);
      if (m_apcir->m_bCredentialID)
          roif.RemoveSymbol(m_apcir->m_bCredentialID);
      if (m_apcir->m_bSubject)
          roif.RemoveSymbol(m_apcir->m_bSubject);
      if (m_apcir->m_bModulus)
          roif.RemoveSymbol(m_apcir->m_bModulus);
      if (m_apcir->m_bPublExponent)
          roif.RemoveSymbol(m_apcir->m_bPublExponent);
  
      // Delete info record
  
      roif.RemoveObject(otPublicKeyObject, m_sidHandle);
  
  }
  
                                                    // Access
                                                    // Predicates
  bool
  CV2PublicKey::DoEquals(CAbstractPublicKey const &rhs) const
  {
      CV2PublicKey const &rv2rhs =
          scu::DownCast<CV2PublicKey const &, CAbstractPublicKey const &>(rhs);
  
      return (rv2rhs.m_sidHandle == m_sidHandle);
  }
  
                                                    // Static Variables
  
  
  ///////////////////////////    PRIVATE    /////////////////////////////////
  
                                                    // C'tors/D'tors
                                                    // Operators
                                                    // Operations
  void
  CV2PublicKey::Setup(CV2Card const &rv2card)
  {
  
      m_apcir =
          auto_ptr<CPubKeyInfoRecord>(new CPubKeyInfoRecord(rv2card,
                                                            m_sidHandle,
                                                            m_oa));
  }
  
                                                    // Access
                                                    // Predicates
                                                    // Static Variables
  