![<?echo $_SERVER['SERVER_NAME'];?>](/template/twentyseventeen/skin/images/header.jpg)
1 Introduction
The complete smart card application system consists of a background service program, a host or terminal application, and a smart card, wherein the background service program provides a service that supports the smart card. For example, in an electronic payment system, a background service program can provide access to credit card and account information; a host or terminal application typically exists in a desktop or terminal, an electronic payment terminal, a mobile phone, or a security subsystem, a terminal application To handle communication between users, smart cards, and background service programs; smart cards store some information about users.
Terminal applications need to access smart cards through a card reader. In a system, there are usually multiple vendors' card readers, so a unified card reader device driver interface is required.
With the wide application of smart cards, in order to solve the interoperability problem between computers and various card readers, the PC/SC (Personal Computer/Smart Card) specification has been proposed, and the PC/SC specification is used as a card reader and card. There is a standard interface between computers that enables interoperability between cards and readers from different manufacturers. The device-independent API allows application developers to avoid having to consider the differences between current implementations and future implementations. Software development costs are reduced by avoiding application changes due to basic hardware changes.
Microsoft implemented PC/SC in its Platform SDK as a standard model for connecting smart card readers to computers, providing a device-independent API and integrating with the Windows platform. Therefore, we can use the PC/SC interface to access the smart card.
2 PC/SC Overview
The PC/SC interface contains more than 30 Scard-prefixed functions. The prototypes of all functions are declared in winscard.h. The application needs to include winscard.lib. The normal return value of all functions is SCARD_S_SUCCESS. Among the more than 30 functions, there are only a few commonly used functions, which correspond to the access process of the smart card (Fig. 2). These commonly used functions will be described in detail below.
3 PC/SC use
3.1 Establish the context of the resource manager
The function ScardEstablishContext() is used to establish the resource manager context (scope) in which the device database operation will be performed.
Prototype: LONG SCardEstablishContext (DWORD dwScope, LPCVOID pvReserved1, LPCVOID pvReserved2, LPSCARDCONTEXT phContext);
The meaning of each parameter: (1) dwScope: input type; indicates the scope of the resource manager context, the value is: SCARD_SCOPE_USER (complete the device database operation in the user domain), SCARD_SCOPE_SYSTEM (complete the device database operation in the system domain). The application is required to have the appropriate operational permissions. (2) pvReserved1: input type; reserved, must be NULL. (3) pvReserved2: input type; reserved, must be NULL. (4) phContext: output type; the handle of the created resource manager context.
Here's the code to set up the resource manager context:
SCARDCONTEXT hSC;
LONG lReturn;
lReturn = SCardEstablishContext(SCARD_SCOPE_USER, NULL, NULL, &hSC);
If ( lReturn!=SCARD_S_SUCCESS )
Printf("Failed SCardEstablishContext");
3.2 Obtaining a list of readers installed in the system
The function ScardListReaders() lists the names of the readers installed in the system.
Prototype: LONG SCardListReaders (SCARDCONTEXT hContext, LPCTSTR mszGroups, LPTSTR mszReaders, LPDWORD pcchReaders);
The meaning of each parameter: (1) hContext: input type; the handle of the resource manager context established by ScardEstablishContext (), can not be NULL. (2) mszGroups: input type; card reader group name, when NULL, means that all readers are listed. (3) mszReaders: output type; the name of the card reader installed in the system, separated by '\0', and the last name is followed by two consecutive '\0'. (4) pcchReaders: input and output types; the length of mszReaders.
Multiple readers may be installed in the system, so the name of each reader needs to be saved in order to establish a connection with the desired reader later.
Here's the code to get a list of readers installed in the system:
Char mszReaders[1024];
LPTSTR pReader, pReaderName[2];
DWORD dwLen=sizeof(mzsReaders);
Int nReaders=0;
lReturn = SCardListReaders(hSC, NULL, (LPTSTR)mszReaders, &dwLen);
If ( lReturn==SCARD_S_SUCCESS )
{
pReader = (LPTSTR)pmszReaders;
While (*pReader !='\0' )
{
If ( nReaders<2 ) //Use the first 2 card readers in the system
pReaderName[nReaders++]=pReader;
Printf("Reader: %S", pReader );
//Next card reader name
pReader = pReader + strlen(pReader) + 1;
}
}
3.3 Connecting to a card reader (smart card)
The function ScardConnect() establishes a connection between the application and the smart card on the reader.
Prototype: LONG SCardConnect (SCARDCONTEXT hContext, LPCTSTR szReader, DWORD dwShareMode, DWORD dwPreferredProtocols, LPSCARDHANDLE phCard, LPDWORD pdwActiveProtocol);
The meaning of each parameter: (1) hContext: input type; handle of the resource manager context established by ScardEstablishContext (). (2) szReader: input type; the name of the reader containing the smart card (the name of the reader is given by ScardListReaders()). (3) dwShareMode: input type; application operation mode of smart card, SCARD_SHARE_SHARED (multiple applications share the same smart card), SCARD_SHARE_EXCLUSIVE (application exclusive smart card), SCARD_SHARE_DIRECT (application uses smart card as private use, directly manipulates smart card, does not allow other Application access smart card). (4) dwPreferredProtocols: input type; protocol used for connection, SCARD_PROTOCOL_T0 (using T=0 protocol), SCARD_PROTOCOL_T1 (using T=1 protocol). (5) phCard: output type; handle connected to the smart card. (6) PdwActiveProtocol: output type; the protocol actually used.
Here's the code to make a connection to the smart card:
SCARDHANDLE hCardHandle[2];
DWORD dwAP;
lReturn = SCardConnect( hContext, pReaderName[0], SCARD_SHARE_SHARED,
SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1, &hCardHandle[0], &dwAP );
If ( lReturn!=SCARD_S_SUCCESS )
{
Printf("Failed SCardConnect");
Exit(1);
}
Once the connection is established with the smart card, the smart card can be sent an instruction to exchange data with it.
3.4 Sending instructions to the smart card
The function ScardTransmit() sends an instruction to the smart card and accepts the returned data.
Prototype: LONG SCardTransmit (SCARDHANDLE hCard, LPCSCARD_I0_REQUEST pioSendPci, LPCBYTE pbSendBuffer, DWORD cbSendLength, LPSCARD_IO_REQUEST pioRecvPci, LPBYTE pbRecvBuffer, LPDWORD pcbRecvLength);
The meaning of each parameter: (1) hCard: input type; handle connected to the smart card. (2) pioSendPci: input type; pointer to the protocol header structure of the instruction, defined by the SCARD_IO_REQUEST structure. This is followed by the protocol control information for the protocol used. The system-defined structure is generally used, SCARD_PCI_T0 (T=0 protocol), SCARD_PCI_T1 (T=1 protocol), SCARD_PCI_RAW (original protocol). (3) pbSendBuffer: input type; pointer to the data to be sent to the smart card. (4) cbSendLength: input type; the number of bytes of pbSendBuffer. (5) pioRecvPci: input and output type; pointer to the instruction protocol header structure, followed by the protocol control information of the protocol used, if not returning the protocol control information, it can be NULL. (6) pbRecvBuffer: input and output type; pointer to the data returned from the smart card. (7) pcbRecvLength: input and output type; pbRecvBuffer size and actual size.
For the T=0 protocol, the usage of the send and receive buffer is as follows:
(a) Send data to the smart card: When sending n>0 bytes of data to the smart card, the first 4 bytes of pbSendBuffer are CLA, INS, P1, P2 of T=0, the 5th byte is n, followed by n words. Section data; cbSendLength value is n+5 (4 bytes header + 1 byte Lc + n bytes of data). PbRecvBuffer will receive SW1 and SW2 status codes; pcbRecvLength value will be at least 2 when called and 2 after return.
BYTE recvBuffer[260];
Int sendSize, recvSize;
BTYE sw1, sw2;
BYTE select_mf[]={0xC0, 0xA4, 0x00, 0x00, 0x02, 0x3F, 0x00};
sendSize=7;
recvSize=sizeof(recvBuffer);
lReturn = SCardTransmit(hCardHandle[0], SCARD_PCI_T0, select_mf, sendSize,
NULL, recvBuffer, &recvSize);
If ( lReturn != SCARD_S_SUCCESS )
{
Printf("Failed SCardTransmit");
Exit(1);
}
/ / returned data, recvSize = 2
Sw1=recvBuffer[recvSize-2];
Sw2=recvBuffer[recvSize-1];
(b) Receiving data from the smart card: In order to receive n>0 bytes of data from the smart card, the first 4 bytes of pbSendBuffer are CLA, INS, P1, P2 of T=0, and the 5th byte is n (ie Le), if When receiving 256 bytes from the smart card, the 5th byte is 0; the cbSendLength value is 5 (4 bytes header + 1 byte Le). PbRecvBuffer will receive the n bytes returned by the smart card, followed by the SW1, SW2 status code; the value of pcbRecvLength is at least n + 2 when called, and n + 2 after return.
BYTE get_challenge[]={0x00, 0x84, 0x00, 0x00, 0x08};
sendSize=5;
recvSize=sizeof(recvBuffer);
lReturn = SCardTransmit(hCardHandle[0], SCARD_PCI_T0, get_challenge,
sendSize, NULL, recvBuffer, &recvSize);
If ( lReturn != SCARD_S_SUCCESS )
{
Printf("Failed SCardTransmit");
Exit(1);
}
/ / returned data, recvSize = 10
Sw1=recvBuffer[recvSize-2];
Sw2=recvBuffer[recvSize-1];
//data=recvBuffer[0]----recvBuffer[7]
(c) Send a command without data exchange to the smart card: the application neither sends data to the smart card nor receives data from the smart card. The first 4 bytes of pbSendBuffer are CLA, INS, P1, P2 of T=0, respectively, and P3 is not sent. The cbSendLength value must be 4. The PbRecvBuffer receives the SW1 and SW2 status codes from the smart card; the pcbRecvLength value is at least 2 when called and 2 after returning.
BYTE set_flag[]={0x80, 0xFE, 0x00, 0x00};
sendSize=4;
recvSize=sizeof(recvBuffer);
lReturn = SCardTransmit(hCardHandle[0], SCARD_PCI_T0, set_flag, sendSize,
NULL, recvBuffer, &recvSize);
If ( lReturn != SCARD_S_SUCCESS )
{
Printf("Failed SCardTransmit");
Exit(1);
}
/ / returned data, recvSize = 2
Sw1=recvBuffer[recvSize-2];
Sw2=recvBuffer[recvSize-1];
(d) Sending a command with two-way data exchange to the smart card: In the T=0 protocol, the application cannot simultaneously transmit data to the smart card, and receives data from the smart card, that is, an instruction sent to the smart card, and cannot have both Lc and Le. This can only be achieved in two steps: sending data to the smart card, receiving the status code returned by the smart card, where SW2 is the number of data bytes that the smart card will return; receiving data from the smart card (instructions are 0x00, 0xC0, 0x00, 0x00, Le) .
BYTE get_response={0x00, 0xc0, 0x00, 0x00, 0x00};
BYTE internal_auth[]={0x00, 0x88, 0x00, 0x00, 0x08, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
sendSize=13;
recvSize=sizeof(recvBuffer);
lReturn = SCardTransmit(hCardHandle[0], SCARD_PCI_T0, internal_auth,
sendSize, NULL, recvBuffer, &recvSize);
If ( lReturn != SCARD_S_SUCCESS )
{
Printf("Failed SCardTransmit");
Exit(1);
}
/ / returned data, recvSize = 2
Sw1=recvBuffer[recvSize-2];
Sw2=recvBuffer[recvSize-1];
If ( sw1!=0x61 )
{
Printf("Failed Command");
Exit(1);
}
Get_response[4]=sw2;
sendSize=5;
recvSize=sizeof(recvBuffer);
lReturn = SCardTransmit(hCardHandle[0], SCARD_PCI_T0, get_response,
sendSize, NULL, recvBuffer, &recvSize);
If ( lReturn != SCARD_S_SUCCESS )
{
Printf("Failed SCardTransmit");
Exit(1);
}
/ / returned data, recvSize = 10
Sw1=recvBuffer[recvSize-2];
Sw2=recvBuffer[recvSize-1];
//data=recvBuffer[0]----recvBuffer[7]
3.5 Disconnecting from the card reader (smart card)
After the data exchange with the smart card is completed, the connection between the application and the smart card can be terminated using the function ScardDisconnect().
Prototype: LONG SCardDisconnect (SCARDHANDLE hCard, DWORD dwDisposition);
The meaning of each parameter: (1) hCard: input type; handle connected to the smart card. (2) dwDisposition: input type; when disconnecting, the operation of the smart card, SCARD_LEAVE_CARD (do nothing), SCARD_RESET_CARD (reset smart card), SCARD_UNPOWER_CARD (power down the smart card), SCARD_EJECT_CARD (eject smart card).
Here's the code to disconnect from the smart card:
lReturn = SCardDisconnect(hCardHandle[0], SCARD_LEAVE_CARD);
If ( lReturn != SCARD_S_SUCCESS )
{
Printf("Failed SCardDisconnect");
Exit(1);
}
3.6 Release the resource management context
The function ScardReleaseContext() should be called to release the context of the resource manager before the application terminates.
Prototype: LONG SCardReleaseContext(SCARDCONTEXT hContext);
The meaning of each parameter: (1) hContext: input type; the handle of the resource manager context established by ScardEstablishContext (), can not be NULL.
Here is the code to release the resource management context:
lReturn = SCardReleaseContext(hSC);
If ( lReturn!=SCARD_S_SUCCESS )
Printf("Failed SCardReleaseContext");
4 Summary
The process described above for operating a smart card via a PC/SC can be packaged in a single class. For example, we can design a class:
Class CSmartReader
{
Private:
SCARDCONTEXT hSC;
LONG lReturn;
Char mszReaders[1024];
LPTSTR pReader, pReaderName[2];
DWORD dwLen;
Int nReaders, nCurrentReader;
SCARDHANDLE hCardHandle[2];
DWORD dwAP;
Public:
CSmartReader (); / / establish context, take a list of readers
~CSmartReader(); //release context
Void SetCurrentReader(int currentReader);
Int GetReaders(); //Get the number of readers
Int ConnectReader (); / / establish a connection with the current reader
Int DisConnectReader(); //Disconnect from the current reader
Int SendCommand(BYTE command[], int commandLength, BYTE result[], int *resultLength); //Send a command to the reader and receive the returned data. The return value is sw
};
In this way, we can easily use the PC/SC interface.
Product description of dry weave Panty Liner:
1. Ultra thin 1mm, 210mm long, elegant look.
2. Extra large size is equal to mini pad in light flow days.
3. High tech and dry weave top sheet combined with cotton layer for maximum soft touch and quick absorption.
4. Breathable back keeps girls always fresh and comfortable.
5. Adhesive on the back sheet keeps pad sticked to the panty firmly.
6. Shaped and anatomic design provides perfect body fit.
FAQ
(1) Do you accept small order?
Yes,we do. We are having ready stock available now.
(2) Visit of factory?
Yes, warmly welcome a visit of our factory anytime.
(3) Free sample?
Yes, Free samples available.
(4) Other hot product
Now. our the most popular product have the Far-infrared Sanitary Pad, herbal medicine Sanitary Napkin, Fruit series santary towel and so on. if you want to know more popular product, please leave us a message.
Dry Weave Panty Liner
Dry Weave Panty Liner,Best Panty Liners,Panty Liner
Glory Power Hygiene Products Ltd. , https://www.hygienenapkin.com