iotjava/iotruntime/master/RouterConfig.java

   1 package iotruntime.master;
   2
   3 import java.io.InputStream;
   4 import java.io.InputStreamReader;
   5 import java.io.BufferedReader;
   6 import java.io.BufferedWriter;
   7 import java.io.FileWriter;
   8 import java.io.PrintWriter;
   9 import java.io.IOException;
  10 import java.nio.file.Files;
  11 import java.nio.file.Paths;
  12 import java.nio.charset.StandardCharsets;
  13 import java.util.HashMap;
  14 import java.util.Map;
  15
  16 /** Class RouterConfig is a class that configures the router
  17  *  in our compute node network with the relevant netfilter
  18  *  policies;
  19  *  it uses ssh to contact the router and writes policy into it
  20  *  <p>
  21  *  To make the implementation faster, we use "iptables-restore"
  22  *  that doesn't require "iptables" command to be invoked many
  23  *  times - each invocation of "iptables" will load the existing
  24  *  table from the kernel space before appending the new rule.
  25  *  <p>
  26  *  We write the core policy repeatedly for each benchmark, while
  27  *  the header "*filter" and tail (a bunch of closing rules and
  28  *  REJECT rules) are written into a different file.
  29  *  They are merged and deployed for every benchmark bootstrapped
  30  *  in the main loop.
  31  *
  32  * @author      Rahmadi Trimananda <rahmadi.trimananda @ uci.edu>
  33  * @version     2.0
  34  * @since       2016-06-21
  35  */
  36 public final class RouterConfig {
  37
  38         /**
  39          * RouterConfig constants
  40          */
  41         private static final String STR_SSH_USERNAME_ROUTER = "root";
  42         private static final String STR_SSH_USERNAME_RASPBERRYPI = "pi";
  43         private static final String STR_SSH_USERNAME_HOST   = "iotuser";
  44         private static final String STR_POLICY_FILE_ALL         = "_all";
  45         private static final String STR_POLICY_FILE_EXT         = ".policy";
  46         private static final String STR_INCOMPLETE              = "(incomplete)";
  47
  48         /**
  49          * RouterConfig properties
  50          */
  51         private Map<String, PrintWriter> mapHostToFile;
  52         private Map<String, PrintWriter> mapHostToMainFile;
  53         private Map<String, String> mapMACtoIPAdd;
  54
  55         /**
  56          * Constructor
  57          */
  58         public RouterConfig() {
  59                 // This maps hostname to file PrintWriter
  60                 mapHostToFile = null;
  61                 mapMACtoIPAdd = new HashMap<String, String>();
  62         }
  63
  64         /**
  65          * renewPrintWriter() renews the mapHostToFile object that lists all PrintWriters
  66          *
  67          * @return  void
  68          */
  69         public void renewPrintWriter() {
  70
  71                 mapHostToFile = new HashMap<String, PrintWriter>();
  72         }
  73
  74         /**
  75          * renewMainPrintWriter() renews the mapHostToMainFile object that lists all main PrintWriters
  76          *
  77          * @return  void
  78          */
  79         public void renewMainPrintWriter() {
  80
  81                 mapHostToMainFile = new HashMap<String, PrintWriter>();
  82         }
  83
  84         /**
  85          * initMainPolicy() initializes the main PrintWriter object to print the entire policies
  86          *
  87          * @param   strConfigHost   String hostname to be configured
  88          * @return  void
  89          */
  90         public void initMainPolicy(String strConfigHost) {
  91
  92             PrintWriter pwConfig = getMainPrintWriter(strConfigHost);
  93             pwConfig.println("*filter");        // Print header for iptables-restore
  94         }
  95
  96         /**
  97          * getMainPrintWriter() gets the main PrintWriter object to print the entire policies
  98          *
  99          * @param   strHost       String hostname to be configured
 100          * @return  PrintWriter
 101          */
 102         private PrintWriter getMainPrintWriter(String strHost) {
 103
 104         String strConfigHost = strHost + STR_POLICY_FILE_ALL;
 105                 // Return object if existing
 106                 if (mapHostToMainFile.containsKey(strConfigHost)) {
 107                         return mapHostToMainFile.get(strConfigHost);
 108                 } else {
 109                 // Simply create a new one if it doesn't exist
 110                         FileWriter fw = null;
 111                         try {
 112                                 fw = new FileWriter(strConfigHost + STR_POLICY_FILE_EXT);
 113                         } catch (IOException ex) {
 114                                 ex.printStackTrace();
 115                         }
 116                         PrintWriter pwConfig = new PrintWriter(new BufferedWriter(fw));
 117                         mapHostToMainFile.put(strConfigHost, pwConfig);
 118                         return pwConfig;
 119                 }
 120         }
 121
 122         /**
 123          * getPrintWriter() gets the right PrintWriter object to print policies to the right file
 124          *
 125          * @param   strConfigHost       String hostname to be configured
 126          * @return  PrintWriter
 127          */
 128         private PrintWriter getPrintWriter(String strConfigHost) {
 129
 130                 // Return object if existing
 131                 if (mapHostToFile.containsKey(strConfigHost)) {
 132                         return mapHostToFile.get(strConfigHost);
 133                 } else {
 134                 // Simply create a new one if it doesn't exist
 135                         FileWriter fw = null;
 136                         try {
 137                                 fw = new FileWriter(strConfigHost + STR_POLICY_FILE_EXT);
 138                         } catch (IOException ex) {
 139                                 ex.printStackTrace();
 140                         }
 141                         PrintWriter pwConfig = new PrintWriter(new BufferedWriter(fw));
 142                         //pwConfig.println("*filter");  // Print header for iptables-restore
 143                         mapHostToFile.put(strConfigHost, pwConfig);
 144                         return pwConfig;
 145                 }
 146         }
 147
 148         /**
 149          * readFile() read the entire file and return a string
 150          *
 151          * @return  String  String that contains the content of the file
 152          */
 153         public String readFile(String filePath) {
 154
 155                 String retStr = null;
 156                 try {
 157                         retStr = new String(Files.readAllBytes(Paths.get(filePath)), StandardCharsets.UTF_8);
 158                 } catch (IOException ex) {
 159                         ex.printStackTrace();
 160                 }
 161                 return retStr;
 162         }
 163
 164         /**
 165          * combineRouterPolicies() method combines the core router policies into the main file
 166          *
 167          * @param   strConfigHost                       String hostname to be configured
 168          * @return  void
 169          */
 170         public void combineRouterPolicies(String strConfigHost) {
 171
 172                 PrintWriter pwConfigAll = getMainPrintWriter(strConfigHost);
 173                 PrintWriter pwConfig = getPrintWriter(strConfigHost);
 174                 pwConfig.flush();
 175                 String strPolicyList = readFile(strConfigHost + STR_POLICY_FILE_EXT);
 176                 pwConfigAll.print(strPolicyList);
 177         }
 178
 179         /**
 180          * closeMain() closes all main PrintWriter objects
 181          *
 182          * @return  void
 183          */
 184         public void closeMain() {
 185
 186                 for(PrintWriter pwConfig: mapHostToMainFile.values()) {
 187                         pwConfig.println("COMMIT");             // Add "COMMIT" statement to end the list for iptables-restore
 188                         pwConfig.close();
 189                 }
 190         }
 191
 192         /**
 193          * close() closes all PrintWriter objects
 194          *
 195          * @return  void
 196          */
 197         public void close() {
 198
 199                 for(PrintWriter pwConfig: mapHostToFile.values()) {
 200                         pwConfig.close();
 201                 }
 202         }
 203
 204         /**
 205          * sendRouterPolicies() deploys policies on router
 206          *
 207          * @param   strConfigHost String hostname to be configured
 208          * @return  void
 209          */
 210         public void sendRouterPolicies(String strConfigHost) {
 211
 212                 String strCmdSend = "scp " + strConfigHost + STR_POLICY_FILE_ALL + STR_POLICY_FILE_EXT + " " +
 213                         STR_SSH_USERNAME_ROUTER + "@" + strConfigHost + ":~;";
 214                 //System.out.println(strCmdSend);
 215                 deployPolicies(strCmdSend);
 216                 String strCmdDeploy = "ssh " + STR_SSH_USERNAME_ROUTER + "@" + strConfigHost +
 217                         " iptables-restore < ~/" + strConfigHost + STR_POLICY_FILE_ALL + STR_POLICY_FILE_EXT + "; rm ~/" + strConfigHost +
 218                         STR_POLICY_FILE_ALL + STR_POLICY_FILE_EXT + "; ";// +
 219                         // TODO: delete these later when we apply tight initial conditions (reject everything but SSH commands)
 220                         //"iptables -F startup_filter_tcp; iptables -F startup_filter_udp; " +
 221                         //"iptables -t filter -D FORWARD -j startup_filter_tcp; iptables -t filter -D FORWARD -j startup_filter_udp;";
 222                 //System.out.println(strCmdDeploy);
 223                 deployPolicies(strCmdDeploy);
 224         }
 225
 226         /**
 227          * sendHostPolicies() deploys policies on host
 228          *
 229          * @param   strConfigHost String hostname to be configured
 230          * @return  void
 231          */
 232         public void sendHostPolicies(String strConfigHost) {
 233
 234                 String strCmdSend = "scp " + strConfigHost + STR_POLICY_FILE_ALL + STR_POLICY_FILE_EXT + " " +
 235                         STR_SSH_USERNAME_HOST + "@" + strConfigHost + ":~;";
 236                 System.out.println(strCmdSend);
 237                 deployPolicies(strCmdSend);
 238                 String strCmdDeploy = "ssh " + STR_SSH_USERNAME_HOST + "@" + strConfigHost +
 239                         " sudo iptables-restore < ~/" + strConfigHost + STR_POLICY_FILE_ALL + STR_POLICY_FILE_EXT + "; rm ~/" + strConfigHost +
 240                         STR_POLICY_FILE_ALL + STR_POLICY_FILE_EXT + ";";
 241                 System.out.println(strCmdDeploy);
 242                 deployPolicies(strCmdDeploy);
 243         }
 244
 245         /**
 246          * deployPolicies() method configures the policies
 247          *
 248          * @param   strCommand  String that contains command line
 249          * @return  void
 250          */
 251         private void deployPolicies(String strCommand) {
 252
 253                 try {
 254                         Runtime runtime = Runtime.getRuntime();
 255                         Process process = runtime.exec(strCommand);
 256                         process.waitFor();
 257                 } catch (IOException ex) {
 258                         System.out.println("RouterConfig: IOException: " + ex.getMessage());
 259                         ex.printStackTrace();
 260                 } catch (InterruptedException ex) {
 261                         System.out.println("RouterConfig: InterruptException: " + ex.getMessage());
 262                         ex.printStackTrace();
 263                 }
 264         }
 265
 266         /**
 267          * getAddressListObject() method returns the map from this class
 268          * <p>
 269          * This method is useful for MAC policy class so that it doesn't have
 270          * to query the router again
 271          */
 272         public Map<String, String> getAddressListObject() {
 273
 274                 return mapMACtoIPAdd;
 275         }
 276
 277         /**
 278          * getAddressListTmp() method gets list of IP addresses from /tmp/dhcp.leases
 279          * <p>
 280          * This method sends an inquiry to the router to look for
 281          * the list of DHCP leased addresses and their mapping to MAC
 282          * addresses
 283          *
 284          * @param  strRouterAddress  String that contains address of router
 285          */
 286         public void getAddressListTmp(String strRouterAddress) {
 287
 288                 //HashMap<String,String> hmMACToIPAdd = new HashMap<String,String>();
 289                 try {
 290                         // We can replace "cat /tmp/dhcp.leases" with "cat /proc/net/arp"
 291                         String cmd = "ssh " + STR_SSH_USERNAME_ROUTER + "@" + strRouterAddress +
 292                          " cat /tmp/dhcp.leases";
 293                         Runtime runtime = Runtime.getRuntime();
 294                         Process process = runtime.exec(cmd);
 295
 296                         InputStream inStream = process.getInputStream();
 297                         InputStreamReader isReader = new InputStreamReader(inStream);
 298                         BufferedReader bReader = new BufferedReader(isReader);
 299                         String strRead = null;
 300                         while((strRead = bReader.readLine()) != null){
 301                                 String[] str = strRead.split(" ");
 302                                 mapMACtoIPAdd.put(str[1], str[2]);
 303                         }
 304                 } catch (IOException ex) {
 305                         System.out.println("RouterConfig: IOException: " + ex.getMessage());
 306                         ex.printStackTrace();
 307                 }
 308         }
 309
 310         /**
 311          * getAddressListArp() method gets list of IP addresses from arp command
 312          * <p>
 313          * This method sends an inquiry to the router to look for
 314          * the list of DHCP leased addresses and their mapping to MAC
 315          * addresses
 316          *
 317          * @param  strRouterAddress  String that contains address of router
 318          */
 319         public void getAddressListArp(String strRouterAddress) {
 320
 321                 //HashMap<String,String> hmMACToIPAdd = new HashMap<String,String>();
 322                 try {
 323                         // We replace with "cat /usr/sbin/arp"
 324                         String cmd = "ssh " + STR_SSH_USERNAME_RASPBERRYPI + "@" + strRouterAddress +
 325                          " /usr/sbin/arp";
 326                         Runtime runtime = Runtime.getRuntime();
 327                         Process process = runtime.exec(cmd);
 328
 329                         InputStream inStream = process.getInputStream();
 330                         InputStreamReader isReader = new InputStreamReader(inStream);
 331                         BufferedReader bReader = new BufferedReader(isReader);
 332                         String strRead = null;
 333                         while((strRead = bReader.readLine()) != null){
 334                                 String[] str = strRead.split("\\s+");
 335                                 // Skip if "(incomplete)" is seen!
 336                                 if (str[1].equals(STR_INCOMPLETE))
 337                                         continue;
 338                                 mapMACtoIPAdd.put(str[2], str[0]);
 339                         }
 340                 } catch (IOException ex) {
 341                         System.out.println("RouterConfig: IOException: " + ex.getMessage());
 342                         ex.printStackTrace();
 343                 }
 344         }
 345
 346         /**
 347          * getIPFromMACAddress() method gets IP from MAC address
 348          *
 349          * @return  String  String that contains IP address from the MAC-IP mapping
 350          */
 351         public String getIPFromMACAddress(String strMACAddress) {
 352
 353                 String strIPAddress = mapMACtoIPAdd.get(strMACAddress);
 354                 if (strIPAddress == null) {
 355                         throw new Error("RouterConfig: MAC address " + strMACAddress + " not found on the list! Please check if device is present in /tmp/dhcp.leases!");
 356                 }
 357                 return strIPAddress;
 358         }
 359
 360         /**
 361          * configureRouterMainPolicies() method configures the router
 362          * <p>
 363          * This method configures the router's main policies
 364          * This method creates a command line using 'ssh' and 'iptables'
 365          * to access the router and create Netfilter statements
 366          *
 367          * @param   strConfigHost        String hostname to be configured
 368          * @param   strFirstHost     String first host
 369          * @param   strSecondHost    String second host
 370          * @param   strProtocol      String protocol TCP/UDP
 371          * @param   iSrcPort         Integer source port number
 372          * @param   iDstPort         Integer destination port number
 373          * @return  void
 374          */
 375         public void configureRouterMainPolicies(String strConfigHost, String strFirstHost,
 376                 String strSecondHost, String strProtocol, int iSrcPort, int iDstPort) {
 377
 378                 PrintWriter pwConfig = getPrintWriter(strConfigHost);
 379                 pwConfig.println("-I FORWARD -j ACCEPT -s " + strFirstHost + " -d " +
 380                         strSecondHost + " -p " + strProtocol + " --dport " + iDstPort);
 381                 pwConfig.println("-I FORWARD -j ACCEPT -s " + strFirstHost + " -d " +
 382                         strSecondHost + " -p " + strProtocol + " --sport " + iSrcPort);
 383                 pwConfig.println("-I FORWARD -j ACCEPT -s " + strSecondHost + " -d " +
 384                         strFirstHost + " -p " + strProtocol + " --sport " + iDstPort);
 385                 pwConfig.println("-I FORWARD -j ACCEPT -s " + strSecondHost + " -d " +
 386                         strFirstHost + " -p " + strProtocol + " --dport " + iSrcPort);
 387         }
 388
 389         /**
 390          * configureRouterMainPolicies() method configures the router
 391          * <p>
 392          * This method configures the router's main policies
 393          * This method creates a command line using 'ssh' and 'iptables'
 394          * to access the router and create Netfilter statements
 395          *
 396          * @param   strConfigHost        String hostname to be configured
 397          * @param   strFirstHost     String first host
 398          * @param   strSecondHost    String second host
 399          * @param   strProtocol      String protocol TCP/UDP
 400          * @param   iPort            Integer port number
 401          * @return  void
 402          */
 403         public void configureRouterMainPolicies(String strConfigHost, String strFirstHost,
 404                 String strSecondHost, String strProtocol, int iPort) {
 405
 406                 PrintWriter pwConfig = getPrintWriter(strConfigHost);
 407                 pwConfig.println("-I FORWARD -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 408                         " -p " + strProtocol + " --dport " + iPort);
 409                 pwConfig.println("-I FORWARD -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 410                         " -p " + strProtocol + " --sport " + iPort);
 411                 pwConfig.println("-I FORWARD -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 412                         " -p " + strProtocol + " --dport " + iPort);
 413                 pwConfig.println("-I FORWARD -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 414                         " -p " + strProtocol + " --sport " + iPort);
 415         }
 416
 417         /**
 418          * configureRouterMainPolicies() method configures the router
 419          * <p>
 420          * This method is the same as the first configureRouterMainPolicies(),
 421          * but it doesn't specify a certain port for the communication
 422          *
 423          * @param   strConfigHost        String hostname to be configured
 424          * @param   strFirstHost     String first host
 425          * @param   strSecondHost    String second host
 426          * @param   strProtocol      String protocol TCP/UDP
 427          * @return  void
 428          */
 429         public void configureRouterMainPolicies(String strConfigHost, String strFirstHost,
 430                 String strSecondHost, String strProtocol) {
 431
 432                 PrintWriter pwConfig = getPrintWriter(strConfigHost);
 433                 pwConfig.println("-I FORWARD -j ACCEPT -s " + strFirstHost +
 434                         " -d " + strSecondHost + " -p " + strProtocol);
 435                 pwConfig.println("-I FORWARD -j ACCEPT -s " + strSecondHost +
 436                         " -d " + strFirstHost + " -p " + strProtocol);
 437
 438         }
 439
 440         /**
 441          * configureRouterMainPolicies() method configures the router
 442          * <p>
 443          * This method is the same as the first configureRouterMainPolicies(),
 444          * but it doesn't specify a certain port and protocol for the communication
 445          *
 446          * @param   strConfigHost        String hostname to be configured
 447          * @param   strFirstHost     String first host
 448          * @param   strSecondHost    String second host
 449          * @return  void
 450          */
 451         public void configureRouterMainPolicies(String strConfigHost, String strFirstHost, String strSecondHost) {
 452
 453                 PrintWriter pwConfig = getPrintWriter(strConfigHost);
 454                 pwConfig.println("-I FORWARD -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost);
 455                 pwConfig.println("-I FORWARD -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost);
 456
 457         }
 458
 459         /**
 460          * configureHostMainPolicies() method configures the host
 461          * <p>
 462          * This method configures the host with router's policies
 463          *
 464          * @param   strConfigHost        String hostname to be configured
 465          * @param   strFirstHost     String first host
 466          * @param   strSecondHost    String second host
 467          * @param   strProtocol      String protocol TCP/UDP
 468          * @param   iSrcPort         Integer source port number
 469          * @param   iDstPort         Integer destination port number
 470          * @return  void
 471          */
 472         public void configureHostMainPolicies(String strConfigHost, String strFirstHost,
 473                 String strSecondHost, String strProtocol, int iSrcPort, int iDstPort) {
 474
 475                 PrintWriter pwConfig = getPrintWriter(strConfigHost);
 476                 pwConfig.println("-I INPUT -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 477                         " -p " + strProtocol + " --dport " + iDstPort);
 478                 pwConfig.println("-I INPUT -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 479                         " -p " + strProtocol + " --sport " + iSrcPort);
 480                 pwConfig.println("-I INPUT -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 481                         " -p " + strProtocol + " --sport " + iDstPort);
 482                 pwConfig.println("-I INPUT -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 483                         " -p " + strProtocol + " --dport " + iSrcPort);
 484                 pwConfig.println("-I OUTPUT -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 485                         " -p " + strProtocol + " --dport " + iDstPort);
 486                 pwConfig.println("-I OUTPUT -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 487                         " -p " + strProtocol + " --sport " + iSrcPort);
 488                 pwConfig.println("-I OUTPUT -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 489                         " -p " + strProtocol + " --sport " + iDstPort);
 490                 pwConfig.println("-I OUTPUT -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 491                         " -p " + strProtocol + " --dport " + iSrcPort);
 492
 493         }
 494
 495         /**
 496          * configureHostMainPolicies() method configures the host
 497          * <p>
 498          * This method configures the host with router's policies
 499          *
 500          * @param   strConfigHost        String hostname to be configured
 501          * @param   strFirstHost     String first host
 502          * @param   strSecondHost    String second host
 503          * @param   strProtocol      String protocol TCP/UDP
 504          * @param   iPort            Integer port number
 505          * @return  void
 506          */
 507         public void configureHostMainPolicies(String strConfigHost, String strFirstHost,
 508                 String strSecondHost, String strProtocol, int iPort) {
 509
 510                 PrintWriter pwConfig = getPrintWriter(strConfigHost);
 511                 pwConfig.println("-I INPUT -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 512                         " -p " + strProtocol + " --dport " + iPort);
 513                 pwConfig.println("-I INPUT -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 514                         " -p " + strProtocol + " --sport " + iPort);
 515                 pwConfig.println("-I INPUT -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 516                         " -p " + strProtocol + " --dport " + iPort);
 517                 pwConfig.println("-I INPUT -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 518                         " -p " + strProtocol + " --sport " + iPort);
 519                 pwConfig.println("-I OUTPUT -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 520                         " -p " + strProtocol + " --dport " + iPort);
 521                 pwConfig.println("-I OUTPUT -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 522                         " -p " + strProtocol + " --sport " + iPort);
 523                 pwConfig.println("-I OUTPUT -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 524                         " -p " + strProtocol + " --dport " + iPort);
 525                 pwConfig.println("-I OUTPUT -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 526                         " -p " + strProtocol + " --sport " + iPort);
 527         }
 528
 529         /**
 530          * configureHostMainPolicies() method configures the host
 531          * <p>
 532          * This method is the same as the first configureHostMainPolicies(),
 533          * but it doesn't specify a certain port for the communication
 534          *
 535          * @param   strConfigHost        String hostname to be configured
 536          * @param   strFirstHost     String first host
 537          * @param   strSecondHost    String second host
 538          * @param   strProtocol      String protocol TCP/UDP
 539          * @return  void
 540          */
 541         public void configureHostMainPolicies(String strConfigHost, String strFirstHost,
 542                 String strSecondHost, String strProtocol) {
 543
 544                 PrintWriter pwConfig = getPrintWriter(strConfigHost);
 545                 pwConfig.println("-I INPUT -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 546                         " -p " + strProtocol);
 547                 pwConfig.println("-I INPUT -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 548                         " -p " + strProtocol);
 549                 pwConfig.println("-I OUTPUT -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 550                         " -p " + strProtocol);
 551                 pwConfig.println("-I OUTPUT -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 552                         " -p " + strProtocol);
 553         }
 554
 555         /**
 556          * configureHostMainPolicies() method configures the host
 557          * <p>
 558          * This method is the same as the first configureHostMainPolicies(),
 559          * but it doesn't specify a certain port and protocol for the communication
 560          *
 561          * @param   strConfigHost        String hostname to be configured
 562          * @param   strFirstHost     String first host
 563          * @param   strSecondHost    String second host
 564          * @return  void
 565          */
 566         public void configureHostMainPolicies(String strConfigHost, String strFirstHost, String strSecondHost) {
 567
 568                 PrintWriter pwConfig = getPrintWriter(strConfigHost);
 569                 pwConfig.println("-I INPUT -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost);
 570                 pwConfig.println("-I INPUT -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost);
 571                 pwConfig.println("-I OUTPUT -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost);
 572                 pwConfig.println("-I OUTPUT -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost);
 573         }
 574
 575
 576         /**
 577          * configureRouterHTTPPolicies() method configures the router
 578          * <p>
 579          * This method configures the router's basic policies
 580          * This method creates a command line using 'ssh' and 'iptables'
 581          * to access the router and create Netfilter statements
 582          *
 583          * @param   strConfigHost        String hostname to be configured
 584          * @param   strFirstHost  String first host address (source)
 585          * @param   strSecondHost   String second host address (destination)
 586          * @return  void
 587          */
 588         public void configureRouterHTTPPolicies(String strConfigHost, String strFirstHost, String strSecondHost) {
 589
 590                 PrintWriter pwConfig = getPrintWriter(strConfigHost);
 591                 // Allow HTTP
 592                 pwConfig.println("-I FORWARD -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 593                         " -p tcp --dport http");
 594                 pwConfig.println("-I FORWARD -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 595                         " -p tcp --sport http");
 596                 pwConfig.println("-I FORWARD -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 597                         " -p tcp --dport http");
 598                 pwConfig.println("-I FORWARD -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 599                         " -p tcp --sport http");
 600                 // Allow HTTPS
 601                 pwConfig.println("-I FORWARD -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 602                         " -p tcp --dport https");
 603                 pwConfig.println("-I FORWARD -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 604                         " -p tcp --sport https");
 605                 pwConfig.println("-I FORWARD -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 606                         " -p tcp --dport https");
 607                 pwConfig.println("-I FORWARD -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 608                         " -p tcp --sport https");
 609         }
 610
 611
 612
 613         /**
 614          * configureRouterICMPPolicies() method configures the router
 615          * <p>
 616          * This method configures the router's basic policies
 617          * This method creates a command line using 'ssh' and 'iptables'
 618          * to access the router and create Netfilter statements
 619          *
 620          * @param   strConfigHost        String hostname to be configured
 621          * @return  void
 622          */
 623         public void configureRouterICMPPolicies(String strConfigHost) {
 624
 625                 PrintWriter pwConfig = getMainPrintWriter(strConfigHost);
 626                 // Allow ICMP
 627                 pwConfig.println("-A FORWARD -j ACCEPT -p icmp");
 628                 pwConfig.println("-A INPUT -j ACCEPT -p icmp");
 629                 pwConfig.println("-A OUTPUT -j ACCEPT -p icmp");
 630         }
 631
 632         /**
 633          * configureRouterICMPPolicies() method configures the router
 634          * <p>
 635          * This method configures the router's basic policies
 636          * This method creates a command line using 'ssh' and 'iptables'
 637          * to access the router and create Netfilter statements
 638          *
 639          * @param   strConfigHost               String hostname to be configured
 640          * @param   strMonitorHost              String monitor address
 641          * @return  void
 642          */
 643         public void configureRouterICMPPolicies(String strConfigHost, String strMonitorHost) {
 644
 645                 PrintWriter pwConfig = getMainPrintWriter(strConfigHost);
 646                 // Allow ICMP
 647                 pwConfig.println("-A FORWARD -j ACCEPT -p icmp");
 648                 pwConfig.println("-A INPUT -j ACCEPT -s " + strMonitorHost +
 649                         " -d " + strConfigHost + " -p icmp");
 650                 pwConfig.println("-A INPUT -j ACCEPT -s " + strConfigHost +
 651                         " -d " + strMonitorHost + " -p icmp");
 652                 pwConfig.println("-A OUTPUT -j ACCEPT -s " + strMonitorHost +
 653                         " -d " + strConfigHost + " -p icmp");
 654                 pwConfig.println("-A OUTPUT -j ACCEPT -s " + strConfigHost +
 655                         " -d " + strMonitorHost + " -p icmp");
 656         }
 657
 658         /**
 659          * configureRouterSSHPolicies() method configures the router
 660          * <p>
 661          * This method configures the router's basic policies
 662          * This method creates a command line using 'ssh' and 'iptables'
 663          * to access the router and create Netfilter statements
 664          *
 665          * @param   strConfigHost               String hostname to be configured
 666          * @param   strMonitorHost              String monitor address
 667          * @return  void
 668          */
 669         public void configureRouterSSHPolicies(String strConfigHost, String strMonitorHost) {
 670
 671                 PrintWriter pwConfig = getMainPrintWriter(strConfigHost);
 672                 // Allow SSH - port 22 (only from monitor host)
 673                 pwConfig.println("-A INPUT -j ACCEPT -s " +
 674                         strMonitorHost + " -d " + strConfigHost + " -p tcp --dport ssh");
 675                 pwConfig.println("-A INPUT -j ACCEPT -s " +
 676                         strMonitorHost + " -d " + strConfigHost + " -p tcp --sport ssh");
 677                 pwConfig.println("-A INPUT -j ACCEPT -s " +
 678                         strConfigHost + " -d " + strMonitorHost + " -p tcp --dport ssh");
 679                 pwConfig.println("-A INPUT -j ACCEPT -s " +
 680                         strConfigHost + " -d " + strMonitorHost + " -p tcp --sport ssh");
 681                 pwConfig.println("-A OUTPUT -j ACCEPT -s " +
 682                         strMonitorHost + " -d " + strConfigHost + " -p tcp --dport ssh");
 683                 pwConfig.println("-A OUTPUT -j ACCEPT -s " +
 684                         strMonitorHost + " -d " + strConfigHost + " -p tcp --sport ssh");
 685                 pwConfig.println("-A OUTPUT -j ACCEPT -s " +
 686                         strConfigHost + " -d " + strMonitorHost + " -p tcp --dport ssh");
 687                 pwConfig.println("-A OUTPUT -j ACCEPT -s " +
 688                         strConfigHost + " -d " + strMonitorHost + " -p tcp --sport ssh");
 689                 //pwConfig.println("-A FORWARD -j ACCEPT -p tcp --dport ssh");
 690                 //pwConfig.println("-A FORWARD -j ACCEPT -p tcp --sport ssh");
 691
 692         }
 693
 694         /**
 695          * configureRouterDHCPPolicies() method configures the router
 696          * <p>
 697          * This method configures the router's basic policies
 698          * This method creates a command line using 'ssh' and 'iptables'
 699          * to access the router and create Netfilter statements
 700          *
 701          * @param   strConfigHost               String hostname to be configured
 702          * @return  void
 703          */
 704         public void configureRouterDHCPPolicies(String strConfigHost) {
 705
 706                 PrintWriter pwConfig = getMainPrintWriter(strConfigHost);
 707                 // Allow DHCP renew - BOOTP Client port 68 / BOOTP Server port 67
 708                 pwConfig.println("-A INPUT -j ACCEPT -p udp --dport bootpc");
 709                 pwConfig.println("-A INPUT -j ACCEPT -p udp --sport bootpc");
 710                 pwConfig.println("-A OUTPUT -j ACCEPT -p udp --dport bootps");
 711                 pwConfig.println("-A OUTPUT -j ACCEPT -p udp --sport bootps");
 712         }
 713
 714         /**
 715          * configureRouterDNSPolicies() method configures the router
 716          * <p>
 717          * This method configures the router's basic policies
 718          * This method creates a command line using 'ssh' and 'iptables'
 719          * to access the router and create Netfilter statements
 720          *
 721          * @param   strConfigHost               String hostname to be configured
 722          * @return  void
 723          */
 724         public void configureRouterDNSPolicies(String strConfigHost) {
 725
 726                 PrintWriter pwConfig = getMainPrintWriter(strConfigHost);
 727                 // Allow DNS UDP and TCP port 53
 728                 pwConfig.println("-A INPUT -j ACCEPT -p tcp --dport domain");
 729                 pwConfig.println("-A INPUT -j ACCEPT -p tcp --sport domain");
 730                 pwConfig.println("-A OUTPUT -j ACCEPT -p tcp --dport domain");
 731                 pwConfig.println("-A OUTPUT -j ACCEPT -p tcp --sport domain");
 732                 pwConfig.println("-A INPUT -j ACCEPT -p udp --dport domain");
 733                 pwConfig.println("-A INPUT -j ACCEPT -p udp --sport domain");
 734                 pwConfig.println("-A OUTPUT -j ACCEPT -p udp --dport domain");
 735                 pwConfig.println("-A OUTPUT -j ACCEPT -p udp --sport domain");
 736         }
 737
 738         /**
 739          * configureRejectPolicies() method configures the router
 740          * <p>
 741          * This method configures the router's basic policies
 742          * This method creates a command line using 'ssh' and 'iptables'
 743          * to access the router and create Netfilter statements
 744          *
 745          * @param   strConfigHost               String hostname to be configured
 746          * @return  void
 747          */
 748         public void configureRejectPolicies(String strConfigHost) {
 749
 750                 PrintWriter pwConfig = getMainPrintWriter(strConfigHost);
 751                 // Reject every other thing
 752                 pwConfig.println("-A FORWARD -j REJECT");
 753                 pwConfig.println("-A INPUT -j REJECT");
 754                 pwConfig.println("-A OUTPUT -j REJECT");
 755         }
 756
 757         /**
 758          * configureRouterNATPolicy() method configures the router
 759          * <p>
 760          * This method configures the NAT policy separately.
 761          * Somehow SSH in Java is not able to combine other commands for
 762          * iptables rules configuration and NAT configuration.
 763          *
 764          * @param   strConfigHost               String hostname to be configured
 765          * @return  void
 766          */
 767         public void configureRouterNATPolicy(String strConfigHost) {
 768
 769                 PrintWriter pwConfig = getMainPrintWriter(strConfigHost);
 770                 // Configure NAT
 771                 pwConfig.println("-t nat -A POSTROUTING -o eth0 -j MASQUERADE");
 772                 // Add the following 2 lines
 773                 pwConfig.println("-A FORWARD -i eth0 -o wlan0 -m state --state RELATED,ESTABLISHED -j ACCEPT");
 774                 pwConfig.println("-A FORWARD -i wlan0 -o eth0 -j ACCEPT");
 775         }
 776
 777         /**
 778          * configureHostHTTPPolicies() method configures the host
 779          * <p>
 780          * This method configures the host with HTTP policies
 781          *
 782          * @param   strConfigHost       String hostname to be configured
 783          * @param   strFirstHost        String first host address (source)
 784          * @param   strSecondHost       String second host address (destination)
 785          * @return  void
 786          */
 787         public void configureHostHTTPPolicies(String strConfigHost, String strFirstHost, String strSecondHost) {
 788
 789                 PrintWriter pwConfig = getPrintWriter(strConfigHost);
 790                 // Allow HTTP
 791                 pwConfig.println("-I INPUT -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 792                         " -p tcp --dport http");
 793                 pwConfig.println("-I INPUT -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 794                         " -p tcp --sport http");
 795                 pwConfig.println("-I INPUT -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 796                         " -p tcp --dport http");
 797                 pwConfig.println("-I INPUT -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 798                         " -p tcp --sport http");
 799                 pwConfig.println("-I OUTPUT -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 800                         " -p tcp --dport http");
 801                 pwConfig.println("-I OUTPUT -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 802                         " -p tcp --sport http");
 803                 pwConfig.println("-I OUTPUT -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 804                         " -p tcp --dport http");
 805                 pwConfig.println("-I OUTPUT -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 806                         " -p tcp --sport http");
 807                 // Allow HTTPS
 808                 pwConfig.println("-I INPUT -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 809                         " -p tcp --dport https");
 810                 pwConfig.println("-I INPUT -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 811                         " -p tcp --sport https");
 812                 pwConfig.println("-I INPUT -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 813                         " -p tcp --dport https");
 814                 pwConfig.println("-I INPUT -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 815                         " -p tcp --sport https");
 816                 pwConfig.println("-I OUTPUT -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 817                         " -p tcp --dport https");
 818                 pwConfig.println("-I OUTPUT -j ACCEPT -s " + strFirstHost + " -d " + strSecondHost +
 819                         " -p tcp --sport https");
 820                 pwConfig.println("-I OUTPUT -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 821                         " -p tcp --dport https");
 822                 pwConfig.println("-I OUTPUT -j ACCEPT -s " + strSecondHost + " -d " + strFirstHost +
 823                         " -p tcp --sport https");
 824         }
 825
 826         /**
 827          * configureHostICMPPolicies() method configures the host
 828          * <p>
 829          * This method configures the host with router's policies
 830          *
 831          * @param   strConfigHost               String hostname to be configured
 832          * @return  void
 833          */
 834         public void configureHostICMPPolicies(String strConfigHost) {
 835
 836                 PrintWriter pwConfig = getMainPrintWriter(strConfigHost);
 837                 // Allow ICMP
 838                 pwConfig.println("-A INPUT -j ACCEPT -p icmp");
 839                 pwConfig.println("-A OUTPUT -j ACCEPT -p icmp");
 840         }
 841
 842         /**
 843          * configureHostSQLPolicies() method configures the host
 844          * <p>
 845          * This method configures the host with router's policies
 846          *
 847          * @param   strConfigHost               String hostname to be configured
 848          * @return  void
 849          */
 850         public void configureHostSQLPolicies(String strConfigHost) {
 851
 852                 PrintWriter pwConfig = getMainPrintWriter(strConfigHost);
 853                 // Allow ICMP
 854                 pwConfig.println("-A INPUT -j ACCEPT -p tcp --dport mysql");
 855                 pwConfig.println("-A INPUT -j ACCEPT -p tcp --sport mysql");
 856                 pwConfig.println("-A OUTPUT -j ACCEPT -p tcp --dport mysql");
 857                 pwConfig.println("-A OUTPUT -j ACCEPT -p tcp --sport mysql");
 858         }
 859
 860         /**
 861          * configureHostICMPPolicies() method configures the host
 862          * <p>
 863          * This method configures the host with router's policies
 864          *
 865          * @param   strConfigHost               String hostname to be configured
 866          * @param   strMonitorHost              String monitor address
 867          * @return  void
 868          */
 869         public void configureHostICMPPolicies(String strConfigHost, String strMonitorHost) {
 870
 871                 PrintWriter pwConfig = getMainPrintWriter(strConfigHost);
 872                 // Allow ICMP
 873                 pwConfig.println("-A INPUT -j ACCEPT -s " + strMonitorHost +
 874                         " -d " + strConfigHost + " -p icmp");
 875                 pwConfig.println("-A INPUT -j ACCEPT -s " + strConfigHost +
 876                         " -d " + strMonitorHost + " -p icmp");
 877                 pwConfig.println("-A OUTPUT -j ACCEPT -s " + strMonitorHost +
 878                         " -d " + strConfigHost + " -p icmp");
 879                 pwConfig.println("-A OUTPUT -j ACCEPT -s " + strConfigHost +
 880                         " -d " + strMonitorHost + " -p icmp");
 881         }
 882
 883
 884         /**
 885          * configureHostSSHPolicies() method configures the host
 886          * <p>
 887          * This method configures the host with router's policies
 888          *
 889          * @param   strConfigHost               String hostname to be configured
 890          * @return  void
 891          */
 892         public void configureHostSSHPolicies(String strConfigHost) {
 893
 894                 PrintWriter pwConfig = getMainPrintWriter(strConfigHost);
 895                 // Allow SSH - port 22
 896                 pwConfig.println("-A INPUT -j ACCEPT -p tcp --dport ssh");
 897                 pwConfig.println("-A INPUT -j ACCEPT -p tcp --sport ssh");
 898                 pwConfig.println("-A OUTPUT -j ACCEPT -p tcp --dport ssh");
 899                 pwConfig.println("-A OUTPUT -j ACCEPT -p tcp --sport ssh");
 900                 pwConfig.println("-A FORWARD -j ACCEPT -p tcp --dport ssh");
 901                 pwConfig.println("-A FORWARD -j ACCEPT -p tcp --sport ssh");
 902         }
 903
 904
 905         /**
 906          * configureHostSSHPolicies() method configures the host
 907          * <p>
 908          * This method configures the host with router's policies
 909          *
 910          * @param   strConfigHost               String hostname to be configured
 911          * @param   strMonitorHost              String monitor address
 912          * @return  void
 913          */
 914         public void configureHostSSHPolicies(String strConfigHost, String strMonitorHost) {
 915
 916                 PrintWriter pwConfig = getMainPrintWriter(strConfigHost);
 917                 // Allow SSH - port 22
 918                 pwConfig.println("-A INPUT -j ACCEPT -s " +
 919                         strMonitorHost + " -d " + strConfigHost + " -p tcp --dport ssh");
 920                 pwConfig.println("-A INPUT -j ACCEPT -s " +
 921                         strMonitorHost + " -d " + strConfigHost + " -p tcp --sport ssh");
 922                 pwConfig.println("-A INPUT -j ACCEPT -s " +
 923                         strConfigHost + " -d " + strMonitorHost + " -p tcp --dport ssh");
 924                 pwConfig.println("-A INPUT -j ACCEPT -s " +
 925                         strConfigHost + " -d " + strMonitorHost + " -p tcp --sport ssh");
 926                 pwConfig.println("-A OUTPUT -j ACCEPT -s " +
 927                         strMonitorHost + " -d " + strConfigHost + " -p tcp --dport ssh");
 928                 pwConfig.println("-A OUTPUT -j ACCEPT -s " +
 929                         strMonitorHost + " -d " + strConfigHost + " -p tcp --sport ssh");
 930                 pwConfig.println("-A OUTPUT -j ACCEPT -s " +
 931                         strConfigHost + " -d " + strMonitorHost + " -p tcp --dport ssh");
 932                 pwConfig.println("-A OUTPUT -j ACCEPT -s " +
 933                         strConfigHost + " -d " + strMonitorHost + " -p tcp --sport ssh");
 934         }
 935
 936
 937         /**
 938          * configureHostDHCPPolicies() method configures the host
 939          * <p>
 940          * This method configures the host with router's policies
 941          *
 942          * @param   strConfigHost               String hostname to be configured
 943          * @return  void
 944          */
 945         public void configureHostDHCPPolicies(String strConfigHost) {
 946
 947                 PrintWriter pwConfig = getMainPrintWriter(strConfigHost);
 948                 // Allow DHCP renew - BOOTP Client port 68 / BOOTP Server port 67
 949                 pwConfig.println("-A INPUT -j ACCEPT -p udp --dport bootpc");
 950                 pwConfig.println("-A INPUT -j ACCEPT -p udp --sport bootpc");
 951                 pwConfig.println("-A OUTPUT -j ACCEPT -p udp --dport bootps");
 952                 pwConfig.println("-A OUTPUT -j ACCEPT -p udp --sport bootps");
 953         }
 954
 955
 956         /**
 957          * configureHostDNSPolicies() method configures the host
 958          * <p>
 959          * This method configures the host with router's policies
 960          *
 961          * @param   strConfigHost               String hostname to be configured
 962          * @return  void
 963          */
 964         public void configureHostDNSPolicies(String strConfigHost) {
 965
 966                 PrintWriter pwConfig = getMainPrintWriter(strConfigHost);
 967                 // Allow DNS UDP and TCP port 53
 968                 pwConfig.println("-A INPUT -j ACCEPT -p tcp --dport domain");
 969                 pwConfig.println("-A INPUT -j ACCEPT -p tcp --sport domain");
 970                 pwConfig.println("-A OUTPUT -j ACCEPT -p tcp --dport domain");
 971                 pwConfig.println("-A OUTPUT -j ACCEPT -p tcp --sport domain");
 972                 pwConfig.println("-A INPUT -j ACCEPT -p udp --dport domain");
 973                 pwConfig.println("-A INPUT -j ACCEPT -p udp --sport domain");
 974                 pwConfig.println("-A OUTPUT -j ACCEPT -p udp --dport domain");
 975                 pwConfig.println("-A OUTPUT -j ACCEPT -p udp --sport domain");
 976
 977         }
 978 }