You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
341 lines
8.8 KiB
341 lines
8.8 KiB
// ACard.cpp: implementation of the CAbstractCard 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 "NoWarning.h"
|
|
|
|
#include <functional>
|
|
|
|
|
|
#include "ACard.h"
|
|
#include "V1Card.h"
|
|
#include "V2Card.h"
|
|
#include "TransactionWrap.h"
|
|
|
|
using namespace std;
|
|
using namespace iop;
|
|
using namespace cci;
|
|
using namespace scu;
|
|
|
|
/////////////////////////// LOCAL/HELPER /////////////////////////////////
|
|
|
|
namespace
|
|
{
|
|
// Like std::mem_fun1_t but for constant member functions
|
|
template<class R, class T, class A>
|
|
class ConstMemFun1Type
|
|
: public binary_function<T const *, A, R>
|
|
{
|
|
public:
|
|
explicit ConstMemFun1Type(R (T::*Pm)(A) const)
|
|
: m_Ptr(Pm)
|
|
{}
|
|
|
|
R operator()(T const *P, A Arg) const
|
|
{
|
|
return ((P->*m_Ptr)(Arg));
|
|
}
|
|
|
|
private:
|
|
R (T::*m_Ptr)(A) const;
|
|
};
|
|
|
|
// Like std::mem_fun1 but for constant member functions
|
|
template<class R, class T, class A> inline
|
|
ConstMemFun1Type<R, T, A>
|
|
ConstMemFun1(R (T::*Pm)(A) const)
|
|
{
|
|
return (ConstMemFun1Type<R, T, A>(Pm));
|
|
}
|
|
|
|
|
|
template<class R>
|
|
ConstMemFun1Type<vector<R>, CAbstractCard const, ObjectAccess> const
|
|
PriviledgedEnumFun(vector<R> (CAbstractCard::*pmf)(ObjectAccess) const)
|
|
{
|
|
return ConstMemFun1Type<vector<R>, CAbstractCard const, ObjectAccess>(pmf);
|
|
}
|
|
|
|
template<class T, class Op>
|
|
vector<T>
|
|
EnumAll(Op Enumerator)
|
|
{
|
|
vector<T> vResult = Enumerator(oaPublicAccess);
|
|
vector<T> vPriv = Enumerator(oaPrivateAccess);
|
|
|
|
vResult.reserve(vResult.size() + vPriv.size());
|
|
vResult.insert(vResult.end(), vPriv.begin(), vPriv.end());
|
|
|
|
return vResult;
|
|
};
|
|
|
|
} // namespace
|
|
|
|
|
|
/////////////////////////// PUBLIC /////////////////////////////////
|
|
|
|
// Types
|
|
// C'tors/D'tors
|
|
|
|
CAbstractCard::~CAbstractCard()
|
|
{}
|
|
|
|
|
|
// Operators
|
|
bool
|
|
CAbstractCard::operator==(CAbstractCard const &rhs) const
|
|
{
|
|
CTransactionWrap wrap(this);
|
|
CTransactionWrap rhswrap(rhs); // will throw if the card is pulled.
|
|
|
|
return m_strReaderName == rhs.m_strReaderName;
|
|
}
|
|
|
|
|
|
bool
|
|
CAbstractCard::operator!=(CAbstractCard const &rhs) const
|
|
{
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
|
|
// Operations
|
|
void
|
|
CAbstractCard::AuthenticateUser(SecureArray<BYTE> const &rstrBuffer)
|
|
{
|
|
m_apSmartCard->VerifyCHV(1, rstrBuffer.data());
|
|
}
|
|
|
|
void
|
|
CAbstractCard::ChangePIN(SecureArray<BYTE> const &rstrOldPIN,
|
|
SecureArray<BYTE> const &rstrNewPIN)
|
|
{
|
|
if ((rstrOldPIN.size() != 0x08) || (rstrNewPIN.size() != 0x08))
|
|
throw Exception(ccBadPinLength);
|
|
|
|
m_apSmartCard->ChangeCHV(1,
|
|
rstrOldPIN.data(),
|
|
rstrNewPIN.data());
|
|
|
|
|
|
}
|
|
|
|
void
|
|
CAbstractCard::Logout()
|
|
{
|
|
m_apSmartCard->LogoutAll();
|
|
}
|
|
|
|
CAbstractCard *
|
|
CAbstractCard::Make(string const &rstrReader)
|
|
{
|
|
auto_ptr<CIOP> apiop(new CIOP());
|
|
auto_ptr<CSmartCard>
|
|
apSmartCard(apiop->Connect(rstrReader.c_str()));
|
|
|
|
typedef auto_ptr<CAbstractCard>(*PCardMakerFun)(string const &rstrReader,
|
|
auto_ptr<CIOP> &rapiop,
|
|
auto_ptr<CSmartCard> &rapSmartCard);
|
|
static PCardMakerFun aCardMakers[] =
|
|
{
|
|
CV2Card::DoMake,
|
|
CV1Card::DoMake,
|
|
0
|
|
};
|
|
|
|
auto_ptr<CAbstractCard> apCard;
|
|
for (PCardMakerFun *ppcmf = aCardMakers;
|
|
(*ppcmf && !apCard.get()); ++ppcmf)
|
|
apCard = auto_ptr<CAbstractCard>((*ppcmf)(rstrReader,
|
|
apiop,
|
|
apSmartCard));
|
|
|
|
if (!apCard.get())
|
|
throw Exception(ccNotPersonalized);
|
|
|
|
apCard->Setup();
|
|
|
|
return apCard.release(); // caller given ownership
|
|
}
|
|
|
|
void
|
|
CAbstractCard::SetUserPIN(string const &rstrPin)
|
|
{
|
|
if (rstrPin.size() != 8)
|
|
throw Exception(ccBadPinLength);
|
|
|
|
m_apSmartCard->ChangeCHV(1, reinterpret_cast<BYTE const *>(rstrPin.data()));
|
|
}
|
|
|
|
void
|
|
CAbstractCard::VerifyKey(string const &rstrKey,
|
|
BYTE bKeyNum)
|
|
{
|
|
m_apSmartCard->VerifyKey(bKeyNum,
|
|
static_cast<WORD>(rstrKey.size()),
|
|
reinterpret_cast<BYTE const *>(rstrKey.data()));
|
|
}
|
|
|
|
void
|
|
CAbstractCard::VerifyTransportKey(string const &rstrKey)
|
|
{
|
|
m_apSmartCard->VerifyTransportKey(reinterpret_cast<BYTE const *>(rstrKey.data()));
|
|
}
|
|
|
|
void
|
|
CAbstractCard::GenRandom(DWORD dwNumBytes, BYTE *bpRand)
|
|
{
|
|
m_apSmartCard->GetChallenge(dwNumBytes, bpRand);
|
|
}
|
|
// Access
|
|
|
|
SCardType
|
|
CAbstractCard::CardType()
|
|
{
|
|
char const *szCardName = m_apSmartCard->getCardName();
|
|
|
|
// TO DO: Kludge Alert--a better type interface is needed in the
|
|
// IOP to determine the card type rather than keying on the name.
|
|
// For now, the Cryptoflex8K type is interpreted to mean it's a
|
|
// Cryptoflex card and Access16K means it's an Access card. Thus
|
|
// any "Cryptoflex" will map to Cryptoflex8K (including 4K) and
|
|
// any "Cyberflex" will map to Access16K. The folded mapping was
|
|
// to minimize impact to PKCS with the impending release.
|
|
//
|
|
// All of this should be revisited with the IOP.
|
|
SCardType sct = UnknownCard;
|
|
|
|
if (strstr(szCardName, "Cryptoflex"))
|
|
sct = Cryptoflex8K;
|
|
if (strstr(szCardName, "Cyberflex"))
|
|
sct = Access16K;
|
|
|
|
return sct;
|
|
|
|
}
|
|
|
|
vector<CCertificate>
|
|
CAbstractCard::EnumCertificates() const
|
|
{
|
|
CTransactionWrap wrap(this);
|
|
|
|
return
|
|
EnumAll<CCertificate>(bind1st(PriviledgedEnumFun<CCertificate>(EnumCertificates), this));
|
|
}
|
|
|
|
vector<CDataObject>
|
|
CAbstractCard::EnumDataObjects() const
|
|
{
|
|
CTransactionWrap wrap(this);
|
|
|
|
return
|
|
EnumAll<CDataObject>(bind1st(PriviledgedEnumFun<CDataObject>(EnumDataObjects), this));
|
|
}
|
|
|
|
vector <CPrivateKey>
|
|
CAbstractCard::EnumPrivateKeys() const
|
|
{
|
|
CTransactionWrap wrap(this);
|
|
|
|
return
|
|
EnumAll<CPrivateKey>(bind1st(PriviledgedEnumFun<CPrivateKey>(EnumPrivateKeys), this));
|
|
}
|
|
|
|
vector<CPublicKey>
|
|
CAbstractCard::EnumPublicKeys() const
|
|
{
|
|
CTransactionWrap wrap(this);
|
|
|
|
return
|
|
EnumAll<CPublicKey>(bind1st(PriviledgedEnumFun<CPublicKey>(EnumPublicKeys), this));
|
|
|
|
}
|
|
|
|
string
|
|
CAbstractCard::ReaderName() const
|
|
{
|
|
return m_strReaderName;
|
|
}
|
|
|
|
CSmartCard &
|
|
CAbstractCard::SmartCard() const
|
|
{
|
|
return *m_apSmartCard;
|
|
}
|
|
|
|
// Predicates
|
|
|
|
// Card is connected and available (e.g. in the reader)
|
|
bool
|
|
CAbstractCard::IsAvailable() const
|
|
{
|
|
bool fIsAvailable = false;
|
|
|
|
try
|
|
{
|
|
CTransactionWrap wrap(this);
|
|
|
|
DWORD dwState;
|
|
DWORD dwProtocol;
|
|
|
|
m_apSmartCard->GetState(dwState, dwProtocol);
|
|
fIsAvailable = (SCARD_SPECIFIC == dwState);
|
|
}
|
|
|
|
catch (...)
|
|
{
|
|
}
|
|
|
|
return fIsAvailable;
|
|
}
|
|
|
|
|
|
// Static Variables
|
|
|
|
/////////////////////////// PROTECTED /////////////////////////////////
|
|
|
|
// C'tors/D'tors
|
|
|
|
CAbstractCard::CAbstractCard(string const &rstrReaderName,
|
|
auto_ptr<iop::CIOP> &rapiop,
|
|
auto_ptr<CSmartCard> &rapSmartCard)
|
|
: CCryptFactory(),
|
|
slbRefCnt::RCObject(),
|
|
m_strReaderName(rstrReaderName),
|
|
m_apiop(rapiop),
|
|
m_apSmartCard(rapSmartCard)
|
|
{}
|
|
|
|
// Operators
|
|
// Operations
|
|
void
|
|
CAbstractCard::DoSetup()
|
|
{}
|
|
|
|
// Access
|
|
// Predicates
|
|
// Static Variables
|
|
|
|
|
|
/////////////////////////// PRIVATE /////////////////////////////////
|
|
|
|
// C'tors/D'tors
|
|
// Operators
|
|
// Operations
|
|
|
|
void
|
|
CAbstractCard::Setup()
|
|
{
|
|
CTransactionWrap wrap(this);
|
|
|
|
DoSetup();
|
|
}
|
|
|
|
// Access
|
|
// Predicates
|
|
// Static Variables
|
|
|