2 #include "reader-common.h"
4 static uchar ISK
[0x40];
5 static uchar cwexp
[] = { 1, 0 , 1};
6 static BIGNUM exp
, ucpk
;
7 static int ucpk_valid
= 0;
9 extern uchar cta_cmd
[], cta_res
[];
14 void RotateBytes1(unsigned char *out
, unsigned char *in
, int n
)
16 // loop is executed atleast once, so it's not a good idea to
19 do { *(--out
)=*(in
++); } while(--n
);
22 void RotateBytes2(unsigned char *in
, int n
)
24 // loop is executed atleast once, so it's not a good idea to
26 unsigned char *e
=in
+n
-1;
29 unsigned char temp
=*in
;
35 int Input(BIGNUM
*d
, unsigned char *in
, int n
, int LE
)
40 RotateBytes1(tmp
,in
,n
);
41 return(BN_bin2bn(tmp
,n
,d
)!=0);
44 return(BN_bin2bn(in
,n
,d
)!=0);
47 int Output(unsigned char *out
, int n
, BIGNUM
*r
, int LE
)
49 int s
=BN_num_bytes(r
);
52 unsigned char buff
[s
];
53 cs_debug("rsa: RSA len %d > %d, truncating", s
, n
);
55 memcpy(out
,buff
+s
-n
,n
);
60 cs_debug("rsa: RSA len %d < %d, padding", s
, n
);
71 int RSA(unsigned char *out
, unsigned char *in
, int n
, BIGNUM
*exp
, BIGNUM
*mod
, int LE
)
81 if(BN_mod_exp(r
,d
,exp
,mod
,ctx
))
82 rc
=Output(out
,n
,r
,LE
);
84 cs_log("rsa: mod-exp failed");
92 int CheckSctLen(const uchar
*data
, int off
)
97 cs_debug("smartcard: section too long %d > %d", l
, MAX_LEN
-off
);
103 static int card_write(uchar
*cmd
, uchar
*data
, int wflag
)
107 memcpy(buf
, cmd
, CMD_LEN
);
108 l
=wflag
? cmd
[4] : 0;
110 memcpy(buf
+CMD_LEN
, data
, l
);
111 l
=reader_cmd2icc(buf
, CMD_LEN
+l
);
115 #define write_cmd(cmd, data) \
117 if (card_write(cmd, data, 1)) return(0); \
120 #define read_cmd(cmd, data) \
122 if (card_write(cmd, data, 0)) return(0); \
125 static char *chid_date(uchar
*ptr
, char *buf
, int l
)
129 snprintf(buf
, l
, "%04d/%02d/%02d",
130 1990+(ptr
[0]>>1), ((ptr
[0]&1)<<3)|(ptr
[1]>>5), ptr
[1]&0x1f);
135 static int select_file(uchar f1
, uchar f2
)
137 uchar insA4
[] = {0xA4, 0xA4, 0x00, 0x00, 0x02, 0x00, 0x00};
140 write_cmd(insA4
, insA4
+5); // select file
141 return((cta_res
[0]==0x9f)&&(cta_res
[1]==0x11));
144 static int read_record(uchar rec
)
146 uchar insA2
[] = {0xA4, 0xA2, 0x00, 0x00, 0x01, 0x00};
147 uchar insB2
[] = {0xA4, 0xB2, 0x00, 0x00, 0x00};
150 write_cmd(insA2
, insA2
+5); // select record
151 if (cta_res
[0]!=0x9f)
153 insB2
[4]=cta_res
[1]; // get len
154 read_cmd(insB2
, NULL
); // read record
155 if ((cta_res
[cta_lr
-2]!=0x90) || (cta_res
[cta_lr
-1]))
160 int cryptoworks_card_init(uchar
*atr
, int atrsize
)
163 unsigned int mfid
=0x3F20;
164 uchar insA4C
[]= {0xA4, 0xC0, 0x00, 0x00, 0x11};
165 uchar insB8
[] = {0xA4, 0xB8, 0x00, 0x00, 0x0c};
168 char *unknown
="unknown", *pin
=unknown
, ptxt
[CS_MAXPROV
<<2]={0};
170 if ((atr
[6]!=0xC4) || (atr
[9]!=0x8F) || (atr
[10]!=0xF1)) return(0);
172 reader
[ridx
].caid
[0]=0xD00;
173 reader
[ridx
].nprov
=0;
174 memset(reader
[ridx
].prid
, 0, sizeof(reader
[ridx
].prid
));
176 read_cmd(insA4C
, NULL
); // read masterfile-ID
177 if ((cta_res
[0]==0xDF) && (cta_res
[1]>=6))
178 mfid
=(cta_res
[6]<<8)|cta_res
[7];
180 select_file(0x3f, 0x20);
181 insB8
[2]=insB8
[3]=0; // first
182 for(cta_res
[0]=0xdf; cta_res
[0]==0xdf;)
184 read_cmd(insB8
, NULL
); // read provider id's
185 if (cta_res
[0]!=0xdf) break;
186 if (((cta_res
[4]&0x1f)==0x1f) && (reader
[ridx
].nprov
<CS_MAXPROV
))
188 sprintf(ptxt
+strlen(ptxt
), ",%02X", cta_res
[5]);
189 reader
[ridx
].prid
[reader
[ridx
].nprov
++][3]=cta_res
[5];
191 insB8
[2]=insB8
[3]=0xff; // next
193 for (i
=reader
[ridx
].nprov
; i
<CS_MAXPROV
; i
++)
194 memset(&reader
[ridx
].prid
[i
][0], 0xff, 4);
196 select_file(0x2f, 0x01); // read caid
197 if (read_record(0xD1)>=4)
198 reader
[ridx
].caid
[0]=(cta_res
[2]<<8)|cta_res
[3];
200 if (read_record(0x80)>=7) // read serial
201 memcpy(reader
[ridx
].hexserial
, cta_res
+2, 5);
202 cs_ri_log("type: cryptoworks, caid: %04X, serial: %llu",
203 reader
[ridx
].caid
[0], b2ll(5, reader
[ridx
].hexserial
));
205 if (read_record(0x9E)>=66) // read ISK
209 if (search_boxkey(reader
[ridx
].caid
[0], 0, keybuf
))
212 BN_bin2bn(cwexp
, sizeof(cwexp
), &exp
);
213 BN_bin2bn(keybuf
, 64, ipk
);
214 RSA(cta_res
+2, cta_res
+2, 0x40, &exp
, ipk
, 0);
216 if (ucpk_valid
=(cta_res
[2]==((mfid
& 0xFF)>>1)))
219 BN_bin2bn(cta_res
+2, 0x40, &ucpk
);
220 cs_ddump(cta_res
+2, 0x40, "IPK available -> session-key:");
224 if (ucpk_valid
=(keybuf
[0]==(((mfid
& 0xFF)>>1)|0x80)))
226 BN_bin2bn(keybuf
, 0x40, &ucpk
);
227 cs_ddump(keybuf
, 0x40, "session-key found:");
230 cs_log("invalid IPK or session-key for CAID %04X !", reader
[ridx
].caid
[0]);
234 if (read_record(0x9F)>=3)
236 if (read_record(0xC0)>=16)
238 strncpy(issuer
, cta_res
+2, sizeof(issuer
)-1);
242 strcpy(issuer
, unknown
);
244 select_file(0x3f, 0x20);
245 select_file(0x2f, 0x11); // read pin
246 if (read_record(atr
[8])>=7)
251 cs_ri_log("issuer: %s, id: %02X, bios: v%d, pin: %s, mfid: %04X", issuer
, issuerid
, atr
[7], pin
, mfid
);
252 cs_ri_log("providers: %d (%s)", reader
[ridx
].nprov
, ptxt
+1);
253 cs_log("ready for requests");
258 bool cSmartCardCryptoworks::Decode(const cEcmInfo
*ecm
, const unsigned char *data
, unsigned char *cw
)
260 static unsigned char ins4c
[] = { 0xA4,0x4C,0x00,0x00,0x00 };
262 unsigned char nanoD4
[10];
263 int l
=CheckSctLen(data
,-5+(ucpkValid
? sizeof(nanoD4
):0));
265 unsigned char buff
[MAX_LEN
];
270 for(unsigned int i
=2; i
<sizeof(nanoD4
); i
++) nanoD4
[i
]=rand();
271 memcpy(&buff
[l
],nanoD4
,sizeof(nanoD4
));
272 data
=buff
; l
+=sizeof(nanoD4
);
274 ins4c
[3]=ucpkValid
? 2 : 0;
276 if(IsoWrite(ins4c
,&data
[5]) && Status() &&
277 (l
=GetLen())>0 && ReadData(buff
,l
)==l
) {
279 for(int i
=0; i
<l
&& r
<2; ) {
283 de(printf("smartcardcryptoworks: nano 80 (serial)\n"))
286 de(printf("smartcardcryptoworks: nano D4 (rand)\n"))
287 if(n
<8 || memcmp(&buff
[i
],nanoD4
,sizeof(nanoD4
)))
288 di(printf("smartcardcryptoworks: random data check failed after decrypt\n"))
291 de(printf("smartcardcryptoworks: nano DB (cw)\n"))
293 memcpy(cw
,&buff
[i
+2],16);
297 case 0xDF: // signature
298 de(printf("smartcardcryptoworks: nano DF %02x (sig)\n",n
))
300 if((buff
[i
+2]&0x50)==0x50 && !(buff
[i
+3]&0x01) && (buff
[i
+5]&0x80))
303 else if(n
==0x40) { // camcrypt
305 RSA(&buff
[i
+2],&buff
[i
+2],n
,exp
,ucpk
,false);
306 de(printf("smartcardcryptoworks: after camcrypt "))
307 de(HexDump(&buff
[i
+2],n
))
311 di(printf("smartcardcryptoworks: valid UCPK needed for camcrypt!\n"))
317 de(printf("smartcardcryptoworks: nano %02x (unhandled)\n",buff
[i
]))
329 int cryptoworks_do_ecm(ECM_REQUEST
*er
)
333 static unsigned char ins4C
[] = { 0xA4,0x4C,0x00,0x00,0x00 };
334 static unsigned char insC0
[] = { 0xA4,0xC0,0x00,0x00,0x1C };
335 unsigned char nanoD4
[10];
336 int secLen
=CheckSctLen(er
->ecm
,-5+(ucpk_valid
? sizeof(nanoD4
):0));
346 memcpy(buff
,er
->ecm
,secLen
);
349 for (i
=2; i
<sizeof(nanoD4
); i
++)
351 memcpy(&buff
[secLen
], nanoD4
, sizeof(nanoD4
));
353 secLen
+=sizeof(nanoD4
);
356 ins4C
[3]=ucpk_valid
? 2 : 0;
358 write_cmd(ins4C
, ecm
+5);
359 if (cta_res
[cta_lr
-2]==0x9f)
361 insC0
[4]=cta_res
[cta_lr
-1];
362 read_cmd(insC0
, NULL
);
363 for(i
=0; i
<secLen
&& r
<2; )
369 cs_debug("cryptoworks: nano 80 (serial)");
372 cs_debug("smartcardcryptoworks: nano D4 (rand)");
373 if(n
<8 || memcmp(&cta_res
[i
],nanoD4
,sizeof(nanoD4
)))
374 cs_debug("cryptoworks: random data check failed after decrypt");
377 cs_debug("smartcardcryptoworks: nano DB (cw)");
380 memcpy(er
->cw
, &cta_res
[i
+2], 16);
384 case 0xDF: // signature
385 cs_debug("cryptoworks: nano DF %02x (sig)", n
);
388 if((cta_res
[i
+2]&0x50)==0x50 && !(cta_res
[i
+3]&0x01) && (cta_res
[i
+5]&0x80))
391 else if (n
==0x40) // camcrypt
395 RSA(&cta_res
[i
+2],&cta_res
[i
+2], n
, &exp
, &ucpk
, 0);
396 cs_debug("smartcardcryptoworks: after camcrypt ");
397 r
=0; secLen
=n
-4; n
=4;
401 cs_log("cryptoworks: valid UCPK needed for camcrypt!");
407 cs_debug("smartcardcryptoworks: nano %02x (unhandled)",cta_res
[i
]);
415 ########################################################################
416 if ((cta_res
[cta_lr
-2]==0x9f)&&(cta_res
[cta_lr
-1]==0x1c))
418 read_cmd(insC0
, NULL
);
419 if ((cta_lr
>26)&&(cta_res
[cta_lr
-2]==0x90)&&(cta_res
[cta_lr
-1]==0))
421 if (rc
=(((cta_res
[20]&0x50)==0x50) &&
422 (!(cta_res
[21]&0x01)) &&
424 memcpy(er
->cw
, cta_res
+2, 16);
429 // return(rc ? 1 : 0);
430 return((r
==3) ? 1 : 0);
433 int cryptoworks_do_emm(EMM_PACKET
*ep
)
438 if ((emm
[0]==0x8f) && (emm
[3]==0xa4)) // emm via camd3.5x
441 write_cmd(emm
+3, emm
+3+CMD_LEN
);
442 if ((cta_lr
==2) && (cta_res
[0]==0x90) && (cta_res
[1]==0))
448 int cryptoworks_card_info(void)
451 uchar insA21
[]= {0xA4, 0xA2, 0x01, 0x00, 0x05, 0x8C, 0x00, 0x00, 0x00, 0x00};
452 uchar insB2
[] = {0xA4, 0xB2, 0x00, 0x00, 0x00};
453 char l_name
[20+8]=", name: ";
455 for (i
=0; i
<reader
[ridx
].nprov
; i
++)
458 select_file(0x1f, reader
[ridx
].prid
[i
][3]); // select provider
459 select_file(0x0e, 0x11); // read provider name
460 if (read_record(0xD6)>=16)
462 strncpy(l_name
+8, cta_res
+2, sizeof(l_name
)-9);
463 l_name
[sizeof(l_name
)]=0;
466 l_name
[0]=(l_name
[8]) ? ',' : 0;
467 cs_ri_log("provider: %d, id: %02X%s", i
+1, reader
[ridx
].prid
[i
][3], l_name
);
468 select_file(0x0f, 0x20); // select provider class
469 write_cmd(insA21
, insA21
+5);
470 if (cta_res
[0]==0x9f)
473 for(insB2
[3]=0; (cta_res
[0]!=0x94)||(cta_res
[1]!=0x2); insB2
[3]=1)
475 read_cmd(insB2
, NULL
); // read chid
476 if (cta_res
[0]!=0x94)
479 chid_date(cta_res
+28, ds
, sizeof(ds
)-1);
480 chid_date(cta_res
+30, de
, sizeof(de
)-1);
481 cs_ri_log("chid: %02X%02X, date: %s - %s, name: %s",
482 cta_res
[6], cta_res
[7], ds
, de
, trim(cta_res
+10));