cadi/core/src/test/java/org/onap/aaf/cadi/test/JU_CmdLine.java

   1 /*******************************************************************************
   2  * ============LICENSE_START====================================================
   3  * * org.onap.aaf
   4  * * ===========================================================================
   5  * * Copyright © 2017 AT&T Intellectual Property. All rights reserved.
   6  * * ===========================================================================
   7  * * Licensed under the Apache License, Version 2.0 (the "License");
   8  * * you may not use this file except in compliance with the License.
   9  * * You may obtain a copy of the License at
  10  * *
  11  *  *      http://www.apache.org/licenses/LICENSE-2.0
  12  * *
  13  *  * Unless required by applicable law or agreed to in writing, software
  14  * * distributed under the License is distributed on an "AS IS" BASIS,
  15  * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * * See the License for the specific language governing permissions and
  17  * * limitations under the License.
  18  * * ============LICENSE_END====================================================
  19  * *
  20  * *
  21  ******************************************************************************/
  22 package org.onap.aaf.cadi.test;
  23
  24 import static org.hamcrest.CoreMatchers.is;
  25 import static org.hamcrest.CoreMatchers.not;
  26 import static org.junit.Assert.assertFalse;
  27 import static org.junit.Assert.assertThat;
  28 import static org.junit.Assert.assertTrue;
  29
  30 import java.io.ByteArrayInputStream;
  31 import java.io.ByteArrayOutputStream;
  32 import java.io.File;
  33 import java.io.FileInputStream;
  34 import java.io.IOException;
  35 import java.io.OutputStream;
  36 import java.io.PrintStream;
  37 import java.nio.file.Files;
  38 import java.nio.file.Paths;
  39 import java.util.Properties;
  40
  41 import org.junit.After;
  42 import org.junit.Before;
  43 import org.junit.Test;
  44 import org.mockito.Mock;
  45 import org.mockito.MockitoAnnotations;
  46 import org.onap.aaf.cadi.CmdLine;
  47 import org.onap.aaf.cadi.Symm;
  48
  49 public class JU_CmdLine {
  50
  51         @Mock
  52         private OutputStream thrower;
  53
  54         private final ByteArrayOutputStream outContent = new ByteArrayOutputStream();
  55
  56         private String password;
  57         private String keyfile;
  58         private String quickBrownFoxPlain = "The quick brown fox jumps over the lazy dog";
  59         private String quickBrownFoxMD5 = "0x9e107d9d372bb6826bd81d3542a419d6";
  60         private String quickBrownFoxSHA256 = "0xd7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592";
  61         private Symm symm;
  62
  63         @Before
  64         public void setup() throws Exception {
  65                 MockitoAnnotations.initMocks(this);
  66
  67                 System.setOut(new PrintStream(outContent));
  68
  69                 Properties p = new Properties();
  70                 p.setProperty("force_exit", "false");
  71
  72                 CmdLine.setSystemExit(false);
  73                 keyfile = "src/test/resources/keyfile";
  74                 password = "password";
  75
  76                 File keyF = new File("src/test/resources", "keyfile");
  77                 FileInputStream fis = new FileInputStream(keyF);
  78                 try {
  79                         symm = Symm.obtain(fis);
  80                 } finally {
  81                         fis.close();
  82                 }
  83         }
  84
  85         @After
  86         public void restoreStreams() throws IOException {
  87                 System.setOut(System.out);
  88                 System.setIn(System.in);
  89         }
  90
  91         @Test
  92         public void digestTest() throws Exception {
  93                 CmdLine.main(new String[]{"digest", password, keyfile});
  94                 String decrypted = symm.depass(outContent.toString());
  95                 assertThat(decrypted, is(password));
  96
  97                 System.setIn(new ByteArrayInputStream(password.getBytes()));
  98                 CmdLine.main(new String[]{"digest", "-i", keyfile});
  99                 decrypted = symm.depass(outContent.toString());
 100                 assertThat(decrypted, is(password));
 101         }
 102
 103         @Test
 104         public void encode64Test() throws Exception {
 105                 CmdLine.main(new String[]{"encode64", password});
 106                 String decrypted = Symm.base64.decode(outContent.toString());
 107                 assertThat(decrypted, is(password));
 108         }
 109
 110         @Test
 111         public void decode64Test() throws Exception {
 112                 String encrypted = Symm.base64.encode(password);
 113                 CmdLine.main(new String[]{"decode64", encrypted});
 114                 assertThat(outContent.toString(), is(password + "\n"));
 115         }
 116
 117         @Test
 118         public void encode64urlTest() throws Exception {
 119                 CmdLine.main(new String[]{"encode64url", password});
 120                 String decrypted = Symm.base64url.decode(outContent.toString());
 121                 assertThat(decrypted, is(password));
 122         }
 123
 124         @Test
 125         public void decode64urlTest() throws Exception {
 126                 String encrypted = Symm.base64url.encode(password);
 127                 CmdLine.main(new String[]{"decode64url", encrypted});
 128                 assertThat(outContent.toString(), is(password + "\n"));
 129         }
 130
 131         @Test
 132         public void md5Test() throws Exception {
 133                 CmdLine.main(new String[]{"md5", quickBrownFoxPlain});
 134                 assertThat(outContent.toString(), is(quickBrownFoxMD5 + "\n"));
 135         }
 136
 137         @Test
 138         public void sha256Test() throws Exception {
 139                 CmdLine.main(new String[]{"sha256", quickBrownFoxPlain});
 140                 assertThat(outContent.toString(), is(quickBrownFoxSHA256 + "\n"));
 141
 142                 outContent.reset();
 143                 CmdLine.main(new String[]{"sha256", quickBrownFoxPlain, "10"});
 144                 String hash1 = outContent.toString();
 145
 146                 outContent.reset();
 147                 CmdLine.main(new String[]{"sha256", quickBrownFoxPlain, "10"});
 148                 String hash2 = outContent.toString();
 149
 150                 outContent.reset();
 151                 CmdLine.main(new String[]{"sha256", quickBrownFoxPlain, "11"});
 152                 String hash3 = outContent.toString();
 153
 154                 assertThat(hash1, is(hash2));
 155                 assertThat(hash1, is(not(hash3)));
 156         }
 157
 158         @Test
 159         public void keygenTest() throws Exception {
 160                 CmdLine.main(new String[]{"keygen"});
 161                 assertThat(outContent.toString().length(), is(2074));
 162
 163                 String filePath = "test/output_key";
 164                 File testDir = new File("test");
 165                 if(!testDir.exists()) {
 166                         testDir.mkdirs();
 167                 }
 168                 CmdLine.main(new String[]{"keygen", filePath});
 169                 File keyfile = new File(filePath);
 170                 assertTrue(Files.isReadable(Paths.get(filePath)));
 171                 assertFalse(Files.isWritable(Paths.get(filePath)));
 172                 assertFalse(Files.isExecutable(Paths.get(filePath)));
 173                 keyfile.delete();
 174         }
 175
 176         @Test
 177         public void passgenTest() throws Exception {
 178                 CmdLine.main(new String[]{"passgen"});
 179                 String output = outContent.toString().trim();
 180                 assertThat(output.length(), is(24));
 181                 assertTrue(containsAny(output, "+!@#$%^&*(){}[]?:;,."));
 182                 assertTrue(containsAny(output, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"));
 183                 assertTrue(containsAny(output, "abcdefghijklmnopqrstuvwxyz"));
 184                 assertTrue(containsAny(output, "0123456789"));
 185
 186                 int length = 10;
 187                 outContent.reset();
 188                 CmdLine.main(new String[]{"passgen", String.valueOf(length)});
 189                 output = outContent.toString().trim();
 190                 assertThat(output.length(), is(length));
 191
 192                 length = 5;
 193                 outContent.reset();
 194                 CmdLine.main(new String[]{"passgen", String.valueOf(length)});
 195                 output = outContent.toString().trim();
 196                 assertThat(output.length(), is(8));
 197
 198                 // Check that the custom hasRepeats method works
 199                 assertTrue(hasRepeats("aa"));
 200                 assertTrue(hasRepeats("baa"));
 201                 assertTrue(hasRepeats("aab"));
 202                 assertTrue(hasRepeats("baab"));
 203                 assertFalse(hasRepeats("abc"));
 204                 assertFalse(hasRepeats("aba"));
 205
 206                 // Run this a bunch of times for coverage
 207                 for (int i = 0; i < 1000; i++) {
 208                         outContent.reset();
 209                         CmdLine.main(new String[]{"passgen"});
 210                         output = outContent.toString().trim();
 211                         assertFalse(hasRepeats(output));
 212                 }
 213         }
 214
 215         @Test
 216         public void urlgenTest() throws Exception {
 217                 CmdLine.main(new String[]{"urlgen"});
 218                 String output = outContent.toString().trim();
 219                 assertThat(output.length(), is(24));
 220
 221                 int length = 5;
 222                 outContent.reset();
 223                 CmdLine.main(new String[]{"urlgen", String.valueOf(length)});
 224                 output = outContent.toString().trim();
 225                 assertThat(output.length(), is(5));
 226         }
 227
 228         @Test
 229         public void showHelpTest() {
 230                 String expected =
 231                         "Usage: java -jar <this jar> ...\n" +
 232                         "  keygen [<keyfile>]                     (Generates Key on file, or Std Out)\n" +
 233                         "  digest [<passwd>|-i|] <keyfile>        (Encrypts Password with \"keyfile\"\n" +
 234                         "                                          if passwd = -i, will read StdIn\n" +
 235                         "                                          if passwd is blank, will ask securely)\n" +
 236                         "  passgen <digits>                       (Generate Password of given size)\n" +
 237                         "  urlgen <digits>                        (Generate URL field of given size)\n" +
 238                         "  encode64 <your text>                   (Encodes to Base64)\n" +
 239                         "  decode64 <base64 encoded text>         (Decodes from Base64)\n" +
 240                         "  encode64url <your text>                (Encodes to Base64 URL charset)\n" +
 241                         "  decode64url <base64url encoded text>   (Decodes from Base64 URL charset)\n" +
 242                         "  sha256 <text> <salts(s)>               (Digest String into SHA256 Hash)\n" +
 243                         "  md5 <text>                             (Digest String into MD5 Hash)\n"
 244                         ;
 245
 246                 CmdLine.main(new String[]{});
 247
 248                 assertThat(outContent.toString(), is(expected));
 249         }
 250
 251         private boolean containsAny(String str, String searchChars) {
 252                 for (char c : searchChars.toCharArray()) {
 253                         if (str.indexOf(c) >= 0) {
 254                                 return true;
 255                         }
 256                 }
 257                 return false;
 258         }
 259
 260         private boolean hasRepeats(String str) {
 261                 int c = -1;
 262                 int last;
 263                 for (int i = 0; i < str.length(); i++) {
 264                         last = c;
 265                         c = str.charAt(i);
 266                         if (c == last) {
 267                                 return true;
 268                         }
 269                 }
 270                 return false;
 271         }
 272
 273 }