1/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16package com.android.internal.telephony.uicc;
17
18import static org.junit.Assert.assertEquals;
19import static org.junit.Assert.assertTrue;
20import static org.mockito.Matchers.any;
21import static org.mockito.Mockito.anyInt;
22import static org.mockito.Mockito.anyString;
23import static org.mockito.Mockito.doAnswer;
24
25import android.content.pm.Signature;
26import android.os.AsyncResult;
27import android.os.Handler;
28import android.os.HandlerThread;
29import android.os.Message;
30import android.test.suitebuilder.annotation.SmallTest;
31
32import com.android.internal.telephony.TelephonyTest;
33
34import org.junit.After;
35import org.junit.Before;
36import org.junit.Test;
37import org.mockito.Mock;
38import org.mockito.invocation.InvocationOnMock;
39import org.mockito.stubbing.Answer;
40
41public class UiccCarrierPrivilegeRulesTest extends TelephonyTest {
42    private UiccCarrierPrivilegeRules mUiccCarrierPrivilegeRules;
43    public UiccCarrierPrivilegeRulesTest() {
44        super();
45    }
46    private UiccCarrierPrivilegeRulesHandlerThread mTestHandlerThread;
47    private Handler mHandler;
48
49    private static final int EVENT_OPEN_LOGICAL_CHANNEL_DONE = 1;
50    private static final int EVENT_TEST_DONE = 2;
51
52    @Mock
53    private UiccCard mUiccCard;
54
55    private class UiccCarrierPrivilegeRulesHandlerThread extends HandlerThread {
56
57        private UiccCarrierPrivilegeRulesHandlerThread(String name) {
58            super(name);
59        }
60
61        @Override
62        public void onLooperPrepared() {
63            /* create a custom handler for the Handler Thread */
64            mHandler = new Handler(mTestHandlerThread.getLooper()) {
65                @Override
66                public void handleMessage(Message msg) {
67                    switch (msg.what) {
68                        case EVENT_OPEN_LOGICAL_CHANNEL_DONE:
69                            /* Upon handling this event, new CarrierPrivilegeRule
70                            will be created with the looper of HandlerThread */
71                            mUiccCarrierPrivilegeRules = new UiccCarrierPrivilegeRules(
72                                    mUiccCard, mHandler.obtainMessage(EVENT_TEST_DONE));
73                            break;
74                        case EVENT_TEST_DONE:
75                            setReady(true);
76                            break;
77                        default:
78                            logd("Unknown Event " + msg.what);
79                    }
80                }
81            };
82            setReady(true);
83        }
84    }
85
86    @Before
87    public void setUp() throws Exception {
88        super.setUp(getClass().getSimpleName());
89        mTestHandlerThread = new UiccCarrierPrivilegeRulesHandlerThread(TAG);
90        mTestHandlerThread.start();
91
92        waitUntilReady();
93    }
94
95    @After
96    public void tearDown() throws Exception {
97        mTestHandlerThread.quit();
98        super.tearDown();
99        mUiccCarrierPrivilegeRules = null;
100    }
101
102    private void testHelper(String hexString) {
103        doAnswer(new Answer<Void>() {
104            @Override
105            public Void answer(InvocationOnMock invocation) throws Throwable {
106                Message message = (Message) invocation.getArguments()[2];
107                AsyncResult ar = new AsyncResult(null, new int[]{0}, null);
108                message.obj = ar;
109                message.sendToTarget();
110                return null;
111            }
112        }).when(mUiccCard).iccOpenLogicalChannel(anyString(), anyInt(), any(Message.class));
113
114        doAnswer(new Answer<Void>() {
115            @Override
116            public Void answer(InvocationOnMock invocation) throws Throwable {
117                Message message = (Message) invocation.getArguments()[7];
118                IccIoResult iir = new IccIoResult(0x90, 0x00, IccUtils.hexStringToBytes(hexString));
119                AsyncResult ar = new AsyncResult(null, iir, null);
120                message.obj = ar;
121                message.sendToTarget();
122                return null;
123            }
124        }).when(mUiccCard).iccTransmitApduLogicalChannel(anyInt(), anyInt(), anyInt(), anyInt(),
125                anyInt(), anyInt(), anyString(), any(Message.class));
126
127
128        Message mCardOpenLogicalChannel = mHandler.obtainMessage(EVENT_OPEN_LOGICAL_CHANNEL_DONE);
129        setReady(false);
130        mCardOpenLogicalChannel.sendToTarget();
131        waitUntilReady();
132    }
133
134    @Test
135    @SmallTest
136    public void testHandleMessage_Normal() {
137        /**
138         * FF40 45
139         *   E2 43
140         *      E1 35
141         *         C1 14 ABCD92CBB156B280FA4E1429A6ECEEB6E5C1BFE4
142         *         CA 1D 636F6D2E676F6F676C652E616E64726F69642E617070732E6D79617070
143         *      E3 0A
144         *         DB 08 0000000000000001
145         */
146        final String hexString =
147                "FF4045E243E135C114ABCD92CBB156B280FA4E1429A6ECEEB6E5C1BFE4CA1D636F6D2E676F6F676"
148                        + "C652E616E64726F69642E617070732E6D79617070E30ADB080000000000000001";
149
150        testHelper(hexString);
151
152        assertTrue(mUiccCarrierPrivilegeRules.hasCarrierPrivilegeRules());
153        assertEquals(1, mUiccCarrierPrivilegeRules.getPackageNames().size());
154        assertEquals("com.google.android.apps.myapp",
155                mUiccCarrierPrivilegeRules.getPackageNames().get(0));
156        Signature signature = new Signature("abcd92cbb156b280fa4e1429a6eceeb6e5c1bfe4");
157        assertEquals(0, mUiccCarrierPrivilegeRules.getCarrierPrivilegeStatus(signature,
158                mUiccCarrierPrivilegeRules.getPackageNames().get(0)));
159    }
160
161    @Test
162    @SmallTest
163    public void testHandleMessage_With4FD0D1() {
164        /**
165         * FF40 34
166         *   E2 32
167         *      E1 1E
168         *         4F 06 FF FF FF FF FF FF
169         *         C1 14 B6 1B E3 4A D2 C2 0D 7A FE D8 49 3C 31 3A 13 7F 89 FA 27 65
170         *      E3 10
171         *         D0 01 01
172         *         D1 01 01
173         *         DB 08 00 00 00 00 00 00 00 01
174         */
175        final String hexString = "FF4034E232E11E4F06FFFFFFFFFFFFC114B61BE34AD2C20D7AFED84"
176                + "93C313A137F89FA2765E310D00101D10101DB080000000000000001";
177
178        testHelper(hexString);
179
180        assertTrue(mUiccCarrierPrivilegeRules.hasCarrierPrivilegeRules());
181        assertEquals(0, mUiccCarrierPrivilegeRules.getPackageNames().size());
182    }
183
184    @Test
185    @SmallTest
186    public void testHandleMessage_With4FD0() {
187        /**
188         * FF40 31
189         *   E2 2F
190         *      E1 1E
191         *         4F 06 FF FF FF FF FF FF
192         *         C1 14 B6 1B E3 4A D2 C2 0D 7A FE D8 49 3C 31 3A 13 7F 89 FA 27 65
193         *      E3 0D
194         *         D0 01 01
195         *         DB 08 00 00 00 00 00 00 00 01
196         */
197        final String hexString = "FF4031E22FE11E4F06FFFFFFFFFFFFC114B61BE34AD2C20D7AFED8493C313A"
198                + "137F89FA2765E30DD00101DB080000000000000001";
199
200        testHelper(hexString);
201
202        assertTrue(mUiccCarrierPrivilegeRules.hasCarrierPrivilegeRules());
203        assertEquals(0, mUiccCarrierPrivilegeRules.getPackageNames().size());
204    }
205
206    @Test
207    @SmallTest
208    public void testHandleMessage_TwoMessages() {
209        /**
210         * FF40 68
211         *   E2 39
212         *      E1 2B
213         *         4F 06 FFFFFFFFFFFF
214         *         C1 02 B61B
215         *         CA 1D 636F6D2E676F6F676C652E616E64726F69642E617070732E6D79617070
216         *      E3 0A
217         *         D0 01 01
218         *         D1 01 01
219         *         DB 02 0001
220         *   E2 2B
221         *      E1 23
222         *         C1 02 ABCD
223         *         CA 1D 636F6D2E676F6F676C652E616E64726F69642E617070732E6D79617070
224         *      E3 04
225         *         DB 02 0001
226         */
227        final String hexString =
228                "FF4068E239E12B4F06FFFFFFFFFFFFC102B61BCA1D636F6D2E676F6F676C652E616E64726F69642"
229                        + "E617070732E6D79617070E30AD00101D10101DB020001E22BE123C102ABCDCA1D636F"
230                        + "6D2E676F6F676C652E616E64726F69642E617070732E6D79617070E304DB020001";
231
232        testHelper(hexString);
233
234        assertTrue(mUiccCarrierPrivilegeRules.hasCarrierPrivilegeRules());
235        assertEquals(2, mUiccCarrierPrivilegeRules.getPackageNames().size());
236        assertEquals("com.google.android.apps.myapp",
237                mUiccCarrierPrivilegeRules.getPackageNames().get(0));
238        Signature signature1 = new Signature("b61b");
239        assertEquals(0, mUiccCarrierPrivilegeRules.getCarrierPrivilegeStatus(signature1,
240                mUiccCarrierPrivilegeRules.getPackageNames().get(0)));
241
242        assertEquals("com.google.android.apps.myapp",
243                mUiccCarrierPrivilegeRules.getPackageNames().get(1));
244        Signature signature2 = new Signature("abcd");
245        assertEquals(0, mUiccCarrierPrivilegeRules.getCarrierPrivilegeStatus(signature2,
246                mUiccCarrierPrivilegeRules.getPackageNames().get(0)));
247    }
248
249    @Test
250    @SmallTest
251    public void testHandleMessage_InvalidRulesWith4F00() {
252        /**
253         * FF40 24
254         *   E2 22
255         *      E1 18
256         *         4F 00
257         *         C1 14 75C073AFD219AEB221948E828F066E778ADFDF23
258         *      E3 06
259         *         D0 01 01
260         *         D1 01 01
261         */
262        final String hexString = "FF4024E222E1184F00C11475C073AFD219AEB221948E828F066E778ADFDF23"
263                + "E306D00101D10101";
264
265        testHelper(hexString);
266
267        assertTrue(!mUiccCarrierPrivilegeRules.hasCarrierPrivilegeRules());
268        assertEquals(0, mUiccCarrierPrivilegeRules.getPackageNames().size());
269    }
270
271    @Test
272    @SmallTest
273    public void testHandleMessage_InvalidRulesWithoutDB() {
274        /**
275         * FF40 2A
276         *   E2 28
277         *      E1 1E
278         *         4F 06 FF FF FF FF FF FF
279         *         C1 14 B6 1B E3 4A D2 C2 0D 7A FE D8 49 3C 31 3A 13 7F 89 FA 27 65
280         *      E3 06
281         *         D0 01 01
282         *         D1 01 01
283         */
284        final String hexString = "FF402AE228E11E4F06FFFFFFFFFFFFC114B61BE34AD2C20D7AFED8493C313A"
285                + "137F89FA2765E306D00101D10101";
286
287        testHelper(hexString);
288
289        assertTrue(!mUiccCarrierPrivilegeRules.hasCarrierPrivilegeRules());
290        assertEquals(0, mUiccCarrierPrivilegeRules.getPackageNames().size());
291    }
292}
293