1/*
2 * Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.  Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26package sun.security.smartcardio;
27
28import java.nio.*;
29import java.security.AccessController;
30import java.security.PrivilegedAction;
31
32import javax.smartcardio.*;
33
34import static sun.security.smartcardio.PCSC.*;
35
36/**
37 * CardChannel implementation.
38 *
39 * @since   1.6
40 * @author  Andreas Sterbenz
41 */
42final class ChannelImpl extends CardChannel {
43
44    // the card this channel is associated with
45    private final CardImpl card;
46
47    // the channel number, 0 for the basic logical channel
48    private final int channel;
49
50    // whether this channel has been closed. only logical channels can be closed
51    private volatile boolean isClosed;
52
53    ChannelImpl(CardImpl card, int channel) {
54        this.card = card;
55        this.channel = channel;
56    }
57
58    void checkClosed() {
59        card.checkState();
60        if (isClosed) {
61            throw new IllegalStateException("Logical channel has been closed");
62        }
63    }
64
65    public Card getCard() {
66        return card;
67    }
68
69    public int getChannelNumber() {
70        checkClosed();
71        return channel;
72    }
73
74    private static void checkManageChannel(byte[] b) {
75        if (b.length < 4) {
76            throw new IllegalArgumentException
77                ("Command APDU must be at least 4 bytes long");
78        }
79        if ((b[0] >= 0) && (b[1] == 0x70)) {
80            throw new IllegalArgumentException
81                ("Manage channel command not allowed, use openLogicalChannel()");
82        }
83    }
84
85    public ResponseAPDU transmit(CommandAPDU command) throws CardException {
86        checkClosed();
87        card.checkExclusive();
88        byte[] commandBytes = command.getBytes();
89        byte[] responseBytes = doTransmit(commandBytes);
90        return new ResponseAPDU(responseBytes);
91    }
92
93    public int transmit(ByteBuffer command, ByteBuffer response) throws CardException {
94        checkClosed();
95        card.checkExclusive();
96        if ((command == null) || (response == null)) {
97            throw new NullPointerException();
98        }
99        if (response.isReadOnly()) {
100            throw new ReadOnlyBufferException();
101        }
102        if (command == response) {
103            throw new IllegalArgumentException
104                    ("command and response must not be the same object");
105        }
106        if (response.remaining() < 258) {
107            throw new IllegalArgumentException
108                    ("Insufficient space in response buffer");
109        }
110        byte[] commandBytes = new byte[command.remaining()];
111        command.get(commandBytes);
112        byte[] responseBytes = doTransmit(commandBytes);
113        response.put(responseBytes);
114        return responseBytes.length;
115    }
116
117    private final static boolean t0GetResponse =
118        getBooleanProperty("sun.security.smartcardio.t0GetResponse", true);
119
120    private final static boolean t1GetResponse =
121        getBooleanProperty("sun.security.smartcardio.t1GetResponse", true);
122
123    private final static boolean t1StripLe =
124        getBooleanProperty("sun.security.smartcardio.t1StripLe", false);
125
126    private static boolean getBooleanProperty(String name, boolean def) {
127        String val = AccessController.doPrivileged(
128            (PrivilegedAction<String>) () -> System.getProperty(name));
129        if (val == null) {
130            return def;
131        }
132        if (val.equalsIgnoreCase("true")) {
133            return true;
134        } else if (val.equalsIgnoreCase("false")) {
135            return false;
136        } else {
137            throw new IllegalArgumentException
138                (name + " must be either 'true' or 'false'");
139        }
140    }
141
142    private byte[] concat(byte[] b1, byte[] b2, int n2) {
143        int n1 = b1.length;
144        if ((n1 == 0) && (n2 == b2.length)) {
145            return b2;
146        }
147        byte[] res = new byte[n1 + n2];
148        System.arraycopy(b1, 0, res, 0, n1);
149        System.arraycopy(b2, 0, res, n1, n2);
150        return res;
151    }
152
153    private final static byte[] B0 = new byte[0];
154
155    private byte[] doTransmit(byte[] command) throws CardException {
156        // note that we modify the 'command' array in some cases, so it must
157        // be a copy of the application provided data.
158        try {
159            checkManageChannel(command);
160            setChannel(command);
161            int n = command.length;
162            boolean t0 = card.protocol == SCARD_PROTOCOL_T0;
163            boolean t1 = card.protocol == SCARD_PROTOCOL_T1;
164            if (t0 && (n >= 7) && (command[4] == 0)) {
165                throw new CardException
166                        ("Extended length forms not supported for T=0");
167            }
168            if ((t0 || (t1 && t1StripLe)) && (n >= 7)) {
169                int lc = command[4] & 0xff;
170                if (lc != 0) {
171                    if (n == lc + 6) {
172                        n--;
173                    }
174                } else {
175                    lc = ((command[5] & 0xff) << 8) | (command[6] & 0xff);
176                    if (n == lc + 9) {
177                        n -= 2;
178                    }
179                }
180            }
181            boolean getresponse = (t0 && t0GetResponse) || (t1 && t1GetResponse);
182            int k = 0;
183            byte[] result = B0;
184            while (true) {
185                if (++k >= 32) {
186                    throw new CardException("Could not obtain response");
187                }
188                byte[] response = SCardTransmit
189                    (card.cardId, card.protocol, command, 0, n);
190                int rn = response.length;
191                if (getresponse && (rn >= 2)) {
192                    // see ISO 7816/2005, 5.1.3
193                    if ((rn == 2) && (response[0] == 0x6c)) {
194                        // Resend command using SW2 as short Le field
195                        command[n - 1] = response[1];
196                        continue;
197                    }
198                    if (response[rn - 2] == 0x61) {
199                        // Issue a GET RESPONSE command with the same CLA
200                        // using SW2 as short Le field
201                        if (rn > 2) {
202                            result = concat(result, response, rn - 2);
203                        }
204                        command[1] = (byte)0xC0;
205                        command[2] = 0;
206                        command[3] = 0;
207                        command[4] = response[rn - 1];
208                        n = 5;
209                        continue;
210                    }
211
212                }
213                result = concat(result, response, rn);
214                break;
215            }
216            return result;
217        } catch (PCSCException e) {
218            card.handleError(e);
219            throw new CardException(e);
220        }
221    }
222
223    private static int getSW(byte[] res) throws CardException {
224        if (res.length < 2) {
225            throw new CardException("Invalid response length: " + res.length);
226        }
227        int sw1 = res[res.length - 2] & 0xff;
228        int sw2 = res[res.length - 1] & 0xff;
229        return (sw1 << 8) | sw2;
230    }
231
232    private static boolean isOK(byte[] res) throws CardException {
233        return (res.length == 2) && (getSW(res) == 0x9000);
234    }
235
236    private void setChannel(byte[] com) {
237        int cla = com[0];
238        if (cla < 0) {
239            // proprietary class format, cannot set or check logical channel
240            // for now, just return
241            return;
242        }
243        // classes 001x xxxx is reserved for future use in ISO, ignore
244        if ((cla & 0xe0) == 0x20) {
245            return;
246        }
247        // see ISO 7816/2005, table 2 and 3
248        if (channel <= 3) {
249            // mask of bits 7, 1, 0 (channel number)
250            // 0xbc == 1011 1100
251            com[0] &= 0xbc;
252            com[0] |= channel;
253        } else if (channel <= 19) {
254            // mask of bits 7, 3, 2, 1, 0 (channel number)
255            // 0xbc == 1011 0000
256            com[0] &= 0xb0;
257            com[0] |= 0x40;
258            com[0] |= (channel - 4);
259        } else {
260            throw new RuntimeException("Unsupported channel number: " + channel);
261        }
262    }
263
264    public void close() throws CardException {
265        if (getChannelNumber() == 0) {
266            throw new IllegalStateException("Cannot close basic logical channel");
267        }
268        if (isClosed) {
269            return;
270        }
271        card.checkExclusive();
272        try {
273            byte[] com = new byte[] {0x00, 0x70, (byte)0x80, 0};
274            com[3] = (byte)getChannelNumber();
275            setChannel(com);
276            byte[] res = SCardTransmit(card.cardId, card.protocol, com, 0, com.length);
277            if (isOK(res) == false) {
278                throw new CardException("close() failed: " + PCSC.toString(res));
279            }
280        } catch (PCSCException e) {
281            card.handleError(e);
282            throw new CardException("Could not close channel", e);
283        } finally {
284            isClosed = true;
285        }
286    }
287
288    public String toString() {
289        return "PC/SC channel " + channel;
290    }
291
292}
293