001/**
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements.  See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership.  The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the
007 * "License"); you may not use this file except in compliance
008 * with the License.  You may obtain a copy of the License at
009 *
010 *     http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing, software
013 * distributed under the License is distributed on an "AS IS" BASIS,
014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015 * See the License for the specific language governing permissions and
016 * limitations under the License.
017 */
018package org.apache.hadoop.hbase.security.visibility;
019
020import static org.apache.hadoop.hbase.security.visibility.VisibilityConstants.LABELS_TABLE_NAME;
021import static org.junit.Assert.assertFalse;
022import static org.junit.Assert.assertTrue;
023
024import java.io.IOException;
025import java.security.PrivilegedExceptionAction;
026import org.apache.hadoop.conf.Configuration;
027import org.apache.hadoop.hbase.Cell;
028import org.apache.hadoop.hbase.CellScanner;
029import org.apache.hadoop.hbase.HBaseClassTestRule;
030import org.apache.hadoop.hbase.HBaseTestingUtil;
031import org.apache.hadoop.hbase.HConstants;
032import org.apache.hadoop.hbase.TableName;
033import org.apache.hadoop.hbase.client.Connection;
034import org.apache.hadoop.hbase.client.ConnectionFactory;
035import org.apache.hadoop.hbase.client.Put;
036import org.apache.hadoop.hbase.client.Result;
037import org.apache.hadoop.hbase.client.ResultScanner;
038import org.apache.hadoop.hbase.client.Scan;
039import org.apache.hadoop.hbase.client.Table;
040import org.apache.hadoop.hbase.security.User;
041import org.apache.hadoop.hbase.testclassification.MediumTests;
042import org.apache.hadoop.hbase.testclassification.SecurityTests;
043import org.apache.hadoop.hbase.util.Bytes;
044import org.junit.AfterClass;
045import org.junit.BeforeClass;
046import org.junit.ClassRule;
047import org.junit.Rule;
048import org.junit.Test;
049import org.junit.experimental.categories.Category;
050import org.junit.rules.TestName;
051
052@Category({SecurityTests.class, MediumTests.class})
053public class TestDefaultScanLabelGeneratorStack {
054
055  @ClassRule
056  public static final HBaseClassTestRule CLASS_RULE =
057      HBaseClassTestRule.forClass(TestDefaultScanLabelGeneratorStack.class);
058
059  public static final String CONFIDENTIAL = "confidential";
060  private static final String SECRET = "secret";
061  public static final HBaseTestingUtil TEST_UTIL = new HBaseTestingUtil();
062  private static final byte[] ROW_1 = Bytes.toBytes("row1");
063  private final static byte[] CF = Bytes.toBytes("f");
064  private final static byte[] Q1 = Bytes.toBytes("q1");
065  private final static byte[] Q2 = Bytes.toBytes("q2");
066  private final static byte[] Q3 = Bytes.toBytes("q3");
067  private final static byte[] value1 = Bytes.toBytes("value1");
068  private final static byte[] value2 = Bytes.toBytes("value2");
069  private final static byte[] value3 = Bytes.toBytes("value3");
070  public static Configuration conf;
071
072  @Rule
073  public final TestName TEST_NAME = new TestName();
074  public static User SUPERUSER;
075  public static User TESTUSER;
076
077  @BeforeClass
078  public static void setupBeforeClass() throws Exception {
079    // setup configuration
080    conf = TEST_UTIL.getConfiguration();
081    VisibilityTestUtil.enableVisiblityLabels(conf);
082    // Not setting any SLG class. This means to use the default behavior.
083    conf.set("hbase.superuser", "admin");
084    TEST_UTIL.startMiniCluster(1);
085    SUPERUSER = User.createUserForTesting(conf, "admin", new String[] { "supergroup" });
086    TESTUSER = User.createUserForTesting(conf, "test", new String[] { });
087
088    // Wait for the labels table to become available
089    TEST_UTIL.waitTableEnabled(LABELS_TABLE_NAME.getName(), 50000);
090
091    // Set up for the test
092    SUPERUSER.runAs(new PrivilegedExceptionAction<Void>() {
093      @Override
094      public Void run() throws Exception {
095        try (Connection conn = ConnectionFactory.createConnection(conf)) {
096          VisibilityClient.addLabels(conn, new String[] { SECRET, CONFIDENTIAL });
097          VisibilityClient.setAuths(conn, new String[] { CONFIDENTIAL }, TESTUSER.getShortName());
098        } catch (Throwable t) {
099          throw new IOException(t);
100        }
101        return null;
102      }
103    });
104  }
105
106  @Test
107  public void testDefaultScanLabelGeneratorStack() throws Exception {
108    final TableName tableName = TableName.valueOf(TEST_NAME.getMethodName());
109
110    SUPERUSER.runAs(new PrivilegedExceptionAction<Void>() {
111      @Override
112      public Void run() throws Exception {
113        try (Connection connection = ConnectionFactory.createConnection(conf);
114             Table table = TEST_UTIL.createTable(tableName, CF)) {
115          Put put = new Put(ROW_1);
116          put.addColumn(CF, Q1, HConstants.LATEST_TIMESTAMP, value1);
117          put.setCellVisibility(new CellVisibility(SECRET));
118          table.put(put);
119          put = new Put(ROW_1);
120          put.addColumn(CF, Q2, HConstants.LATEST_TIMESTAMP, value2);
121          put.setCellVisibility(new CellVisibility(CONFIDENTIAL));
122          table.put(put);
123          put = new Put(ROW_1);
124          put.addColumn(CF, Q3, HConstants.LATEST_TIMESTAMP, value3);
125          table.put(put);
126          return null;
127        }
128      }
129    });
130
131    // Test that super user can see all the cells.
132    SUPERUSER.runAs(new PrivilegedExceptionAction<Void>() {
133      @Override
134      public Void run() throws Exception {
135        try (Connection connection = ConnectionFactory.createConnection(conf);
136             Table table = connection.getTable(tableName)) {
137          Result[] next = getResult(table, new Scan());
138
139          // Test that super user can see all the cells.
140          CellScanner cellScanner = next[0].cellScanner();
141          cellScanner.advance();
142          Cell current = cellScanner.current();
143          assertTrue(Bytes.equals(current.getRowArray(), current.getRowOffset(),
144              current.getRowLength(), ROW_1, 0, ROW_1.length));
145          assertTrue(Bytes.equals(current.getQualifierArray(), current.getQualifierOffset(),
146            current.getQualifierLength(), Q1, 0, Q1.length));
147          assertTrue(Bytes.equals(current.getValueArray(), current.getValueOffset(),
148            current.getValueLength(), value1, 0, value1.length));
149          cellScanner.advance();
150          current = cellScanner.current();
151          assertTrue(Bytes.equals(current.getRowArray(), current.getRowOffset(),
152            current.getRowLength(), ROW_1, 0, ROW_1.length));
153          assertTrue(Bytes.equals(current.getQualifierArray(), current.getQualifierOffset(),
154            current.getQualifierLength(), Q2, 0, Q2.length));
155          assertTrue(Bytes.equals(current.getValueArray(), current.getValueOffset(),
156            current.getValueLength(), value2, 0, value2.length));
157          cellScanner.advance();
158          current = cellScanner.current();
159          assertTrue(Bytes.equals(current.getRowArray(), current.getRowOffset(),
160            current.getRowLength(), ROW_1, 0, ROW_1.length));
161          assertTrue(Bytes.equals(current.getQualifierArray(), current.getQualifierOffset(),
162            current.getQualifierLength(), Q3, 0, Q3.length));
163          assertTrue(Bytes.equals(current.getValueArray(), current.getValueOffset(),
164            current.getValueLength(), value3, 0, value3.length));
165
166          return null;
167        }
168      }
169    });
170
171    TESTUSER.runAs(new PrivilegedExceptionAction<Void>() {
172      @Override
173      public Void run() throws Exception {
174        try (Connection connection = ConnectionFactory.createConnection(conf);
175             Table table = connection.getTable(tableName)) {
176          // Test scan with no auth attribute
177          Result[] next = getResult(table, new Scan());
178          CellScanner cellScanner = next[0].cellScanner();
179          cellScanner.advance();
180          Cell current = cellScanner.current();
181          // test user can see value2 (CONFIDENTIAL) and value3 (no label)
182          assertTrue(Bytes.equals(current.getRowArray(), current.getRowOffset(),
183              current.getRowLength(), ROW_1, 0, ROW_1.length));
184          assertTrue(Bytes.equals(current.getQualifierArray(), current.getQualifierOffset(),
185            current.getQualifierLength(), Q2, 0, Q2.length));
186          assertTrue(Bytes.equals(current.getValueArray(), current.getValueOffset(),
187            current.getValueLength(), value2, 0, value2.length));
188          cellScanner.advance();
189          current = cellScanner.current();
190          // test user can see value2 (CONFIDENTIAL) and value3 (no label)
191          assertTrue(Bytes.equals(current.getRowArray(), current.getRowOffset(),
192              current.getRowLength(), ROW_1, 0, ROW_1.length));
193          assertTrue(Bytes.equals(current.getQualifierArray(), current.getQualifierOffset(),
194            current.getQualifierLength(), Q3, 0, Q3.length));
195          assertTrue(Bytes.equals(current.getValueArray(), current.getValueOffset(),
196            current.getValueLength(), value3, 0, value3.length));
197
198          // Test scan with correct auth attribute for test user
199          Scan s1 = new Scan();
200          // test user is entitled to 'CONFIDENTIAL'.
201          // If we set both labels in the scan, 'SECRET' will be dropped by the SLGs.
202          s1.setAuthorizations(new Authorizations(new String[] { SECRET, CONFIDENTIAL }));
203          ResultScanner scanner1 = table.getScanner(s1);
204          Result[] next1 = scanner1.next(1);
205
206          assertTrue(next1.length == 1);
207          CellScanner cellScanner1 = next1[0].cellScanner();
208          cellScanner1.advance();
209          Cell current1 = cellScanner1.current();
210          // test user can see value2 (CONFIDENTIAL) and value3 (no label)
211          assertTrue(Bytes.equals(current1.getRowArray(), current1.getRowOffset(),
212            current1.getRowLength(), ROW_1, 0, ROW_1.length));
213          assertTrue(Bytes.equals(current1.getQualifierArray(), current1.getQualifierOffset(),
214            current1.getQualifierLength(), Q2, 0, Q2.length));
215          assertTrue(Bytes.equals(current1.getValueArray(), current1.getValueOffset(),
216            current1.getValueLength(), value2, 0, value2.length));
217          cellScanner1.advance();
218          current1 = cellScanner1.current();
219          // test user can see value2 (CONFIDENTIAL) and value3 (no label)
220          assertTrue(Bytes.equals(current1.getRowArray(), current1.getRowOffset(),
221            current1.getRowLength(), ROW_1, 0, ROW_1.length));
222          assertTrue(Bytes.equals(current1.getQualifierArray(), current1.getQualifierOffset(),
223            current1.getQualifierLength(), Q3, 0, Q3.length));
224          assertTrue(Bytes.equals(current1.getValueArray(), current1.getValueOffset(),
225            current1.getValueLength(), value3, 0, value3.length));
226
227          // Test scan with incorrect auth attribute for test user
228          Scan s2 = new Scan();
229          // test user is entitled to 'CONFIDENTIAL'.
230          // If we set 'SECRET', it will be dropped by the SLGs.
231          s2.setAuthorizations(new Authorizations(new String[] { SECRET }));
232          ResultScanner scanner2 = table.getScanner(s2);
233          Result next2 = scanner2.next();
234          CellScanner cellScanner2 = next2.cellScanner();
235          cellScanner2.advance();
236          Cell current2 = cellScanner2.current();
237          // This scan will only see value3 (no label)
238          assertTrue(Bytes.equals(current2.getRowArray(), current2.getRowOffset(),
239            current2.getRowLength(), ROW_1, 0, ROW_1.length));
240          assertTrue(Bytes.equals(current2.getQualifierArray(), current2.getQualifierOffset(),
241            current2.getQualifierLength(), Q3, 0, Q3.length));
242          assertTrue(Bytes.equals(current2.getValueArray(), current2.getValueOffset(),
243            current2.getValueLength(), value3, 0, value3.length));
244
245          assertFalse(cellScanner2.advance());
246
247          return null;
248        }
249      }
250    });
251
252  }
253
254  private static Result [] getResult(Table table, Scan scan) throws IOException {
255    ResultScanner scanner = table.getScanner(scan);
256    Result[] next = scanner.next(1);
257    assertTrue(next.length == 1);
258    return next;
259  }
260
261  @AfterClass
262  public static void tearDownAfterClass() throws Exception {
263    TEST_UTIL.shutdownMiniCluster();
264  }
265}