ROOT logo
///////////////////////////////////////////////////////////////////////////////
//
//  Macro test authentication methods stand alone
//
//  See $ROOTSYS/README/README.AUTH for additional details
//
//   Syntax:
//
//  .x TestAuth.C(<port>,"<user>","<krb5_princ>","<globus_det>")
//
//     <port>          = rootd port (default 1094)
//     <user>          = login user name for the test
//                       (default from getpwuid)
//     <krb5_princ>    = Principal to be used for Krb5 authentication
//                       in the form user@THE.REA.LM
//                       ( default: <running_user@Default_Realm with
//                                  Default_realm taken from /etc/krb5.conf
//                                  or the $KRB5_CONFIG file )
//     <globus_det>    = details for the globus authentication
//                       ( default: ad:certificates cd:$HOME/.globus
//                                  cf:usercert.pem kf:userkey.pem )
//
//  MAKE SURE that rootd is running
//
//  Example of successful output:
//
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// +                                                                          +
// +                         TestAuth.C                                       +
// +                                                                          +
// +                Test of authentication methods                            +
// +                                                                          +
// +   Syntax:                                                                +
// +                                                                          +
// + .x TestAuth.C(<port>,"<user>","<krb5_princ>","<globus_det>")             +
// +                                                                          +
// +     <port>          = rootd port (default 1094)                          +
// +     <user>          = login user name for the test                       +
// +                      (default from getpwuid)                             +
// +     <krb5_princ>    = Principal to be used for Krb5 authentication       +
// +                       in the form user@THE.REA.LM                        +
// +                      ( default: <running_user@Default_Realm with         +
// +                                 Default_realm taken from /etc/krb5.conf  +
// +                                 or the $KRB5_CONFIG file )               +
// +     <globus_det>    = details for the globus authentication              +
// +                      ( default ad:certificates cd:$HOME/.globus          +
// +                                cf:usercert.pem kf:userkey.pem )          +
// +                                                                          +
// +                 >>> MAKE SURE that rootd is running <<<                  +
// +                                                                          +
// +             See $ROOTSYS/README/README.AUTH for additional details       +
// +                                                                          +
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// +                                                                          +
// +   Basic test parameters:                                                 +
// +                                                                          +
// +   Local User is          : ganis
// +   Authentication Details : pt:0 ru:1 us:ganis
// +   Current directory is   : /home/ganis/local/root/root/tutorials
// +   TFTP string            : root://localhost:1094
// +   Krb5 Details           : pt:0 ru:1 us:ganis@PCEPSFT43.CERN.CH
// +                                                                          +
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// +                                                                          +
// +   Testing UsrPwd ...                                                     +
// ganis@localhost password:
// +                                                                          +
// +   Testing SRP ...                                                        +
// ganis@localhost SRP password:
// +                                                                          +
// +   Testing Krb5 ...                                                       +
// Password for ganis@PCEPSFT43.CERN.CH:
// +                                                                          +
// +   Testing Globus ...                                                     +
// Local Globus Certificates (    )
// Enter <key>:<new value> to change:
// Your identity: /O=Grid/OU=GlobusTest/OU=simpleCA-arthux.cern.ch/OU=cern.ch/CN=ganis
// Enter GRID pass phrase for this identity:
// Creating proxy ............................ Done
// Your proxy is valid until: Fri Oct 31 09:33:04 2003
// +                                                                          +
// +   Testing SSH ...                                                        +
// ganis@localhost's password:
// +                                                                          +
// +   Testing UidGid ...                                                     +
// +                                                                          +
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// +                                                                          +
// +   Result of the tests:                                                   +
// +                                                                          +
// +   Method: 0 (UsrPwd): successful! (reuse: successful!)                   +
// +   Method: 1    (SRP): successful! (reuse: successful!)                   +
// +   Method: 2   (Krb5): successful! (reuse: successful!)                   +
// +   Method: 3 (Globus): successful! (reuse: successful!)                   +
// +   Method: 4    (SSH): successful! (reuse: successful!)                   +
// +   Method: 5 (UidGid): successful!                                        +
// +                                                                          +
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
///////////////////////////////////////////////////////////////////////////////
//
int TestAuth(int port = 1094, char *user = "", char *krb5  = "", char *globus  = "")
{
   //
   // This macro tests the authentication methods
   //
   gROOT->Reset();

// Getting debug flag
   Int_t lDebug = gEnv->GetValue("Root.Debug",0);

// Useful flags
   Bool_t HaveMeth[6] = {1,0,0,0,0,1};
   Int_t  TestMeth[6] = {0,0,0,0,0,0};
   Int_t TestReUse[6] = {3,3,3,3,3,3};


// Some Printout
   printf("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
   printf("+                                                                             +\n");
   printf("+                         TestAuth.C                                          +\n");
   printf("+                                                                             +\n");
   printf("+                Test of authentication methods                               +\n");
   printf("+                                                                             +\n");
   printf("+   Syntax:                                                                   +\n");
   printf("+                                                                             +\n");
   printf("+ .x TestAuth.C(<port>,\"<user>\",\"<krb5_princ>\",\"<globus_det>\")                +\n");
   printf("+                                                                             +\n");
   printf("+     <port>          = rootd port (default 1094)                             +\n");
   printf("+     <user>          = login user name for the test                          +\n");
   printf("+                      (default from getpwuid)                                +\n");
   printf("+     <krb5_princ>    = Principal to be used for Krb5 authentication          +\n");
   printf("+                       in the form user@THE.REA.LM                           +\n");
   printf("+                      ( default: <running_user@Default_Realm with            +\n");
   printf("+                                 Default_realm taken from /etc/krb5.conf     +\n");
   printf("+                                 or the $KRB5_CONFIG file )                  +\n");
   printf("+     <globus_det>    = details for the globus authentication                 +\n");
   printf("+                      ( default ad:certificates cd:$HOME/.globus             +\n");
   printf("+                                cf:usercert.pem kf:userkey.pem )             +\n");
   printf("+                                                                             +\n");
   printf("+                     >>> MAKE SURE that rootd is running <<<                 +\n");
   printf("+                                                                             +\n");
   printf("+             See $ROOTSYS/README/README.AUTH for additional details          +\n");
   printf("+                                                                             +\n");
   printf("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\n");

// Useful variables

// User
   TString User = user;
   if (User == "") {

      UserGroup_t *u = gSystem->GetUserInfo();
      if (!u) {
         printf("\n >>>> 'user' not defined: please enter a valid username:\n");
         char utmp[256] = {0};
         scanf("%s",utmp);
         if (strlen(utmp)) {
            User = utmp;
         } else {
            printf(">>>> no 'user' defined: return!\n");
            return 1;
         }
      } else {
         User = u->fUser;
      }

   }

// Host
   TString Host = "localhost";
   TString HostName = gSystem->HostName();

// File path string for TFTP
   //TString TFTPPath = TString("root://localhost:")+ port ;
   TString TFTPPath = TString("root://")+User+TString("@localhost:")+ port ;
   //TString TFTPPathKrb5 = TString("root://") + HostName + TString(":")+ port ;
   TString TFTPPathKrb5 = TString("root://") + User+ TString("@") +
                          HostName + TString(":")+ port ;

// Details
   TString Details = TString("pt:0 ru:1 us:") + User;

// Testing availibilities
   char *p;

//   TString HaveSRP = "@srpdir@";
   if ((p = gSystem->DynamicPathName("libSRPAuth", kTRUE))) {
      HaveMeth[1] = 1;
   }
   delete[] p;

// Check if Kerberos is available
   TString Krb5Details;
   TString Krb5Open;
   if ((p = gSystem->DynamicPathName("libKrb5Auth", kTRUE))) {
      HaveMeth[2] = 1;
      // Special details string for Kerberos
      if (strlen(krb5) > 0) {
         Krb5Details = TString("pt:0 ru:1 us:") + TString(krb5);
      } else {
         // Must determine a default ... look in config file
         TString Krb5Conf, Realm;
         if (gSystem->Getenv("KRB5_CONFIG")) {
            if (!gSystem->AccessPathName(gSystem->Getenv("KRB5_CONFIG"), kReadPermission)) {
               Krb5Conf = gSystem->Getenv("KRB5_CONFIG");
            }
         } else if (!gSystem->AccessPathName("/etc/krb5.conf", kReadPermission)) {
            Krb5Conf = "/etc/krb5.conf";
         } else {
            printf("\n >>>> Kerberos Principal undefined\n");
            printf("\n >>>> unable to localize Kerberos config file to build a default\n");
            printf("\n >>>> Switching off Kerberos\n");
            printf("\n >>>> Run again with giving the principal as 3rd argument\n");
            printf("\n >>>> or define the variable KRB5_CONFIG with the full path \n");
            printf("\n >>>> to the config file (usually /etc/krb5.conf)\n");
            HaveMeth[2] = 0;
         }
         if (HaveMeth[2] == 1) {
            FILE *fc = fopen(Krb5Conf.Data(),"r");
            if (fc) {
               char line[1024], fs1[1024], fs2[1024], fs3[1024];
               while (fgets(line, sizeof(line), fc) != 0) {
                  int nf = sscanf(line,"%s %s %s",fs1,fs2,fs3);
                  if (nf == 3 && !strcmp(fs1,"default_realm")) {
                     Realm = fs3;
                     break;
                  }
               }
               Krb5Details = TString("pt:0 ru:1 us:") + User + TString("@") + Realm;
//               Krb5Details = TString("pt:0 ru:1 us:") + User;
               fclose(fc);
            } else {
               HaveMeth[2] = 0;
            }
         }
      }
   }
   delete[] p;

// Check if Globus is available
   TString GlobusDetails;
   if ((p = gSystem->DynamicPathName("libGlobusAuth", kTRUE))) {
      HaveMeth[3] = 1;
      // Special details string for Globus
      GlobusDetails = TString("pt:0 ru:1 ") + TString(globus);
   }
   delete[] p;

// Check if SSH available
   if (gSystem->Which(gSystem->Getenv("PATH"), "ssh", kExecutePermission)) {
      HaveMeth[4] = 1;
   }

// Test parameter Printout
   printf("\n+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
   printf("+                                                                             +\n");
   printf("+   Basic test parameters:                                                    +\n");
   printf("+                                                                             +\n");
   printf("+   Local User is          : %s \n",User.Data());
   printf("+   Authentication Details : %s \n",Details.Data());
   printf("+   Current directory is   : %s \n",gSystem->WorkingDirectory());
   printf("+   TFTP string            : %s \n",TFTPPath.Data());
   if (HaveMeth[2]) {
      printf("+   Krb5 Details           : %s \n",Krb5Details.Data());
   }
   printf("+                                                                             +\n");
   printf("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");

// Read local <RootAuthrc> now to avoid to be later superseeded
   TAuthenticate::ReadRootAuthrc();
   if (lDebug > 0)
      TAuthenticate::Show();

   TFTP *t1 = 0;
// UsrPwd method
   printf("+                                                                             +\n");
   printf("+   Testing UsrPwd ...                                                        +\n");

   // Check if by any chance locally there is already an THostAuth matching
   // the one we want to use for testing
   THostAuth *hasv1 = 0;
   THostAuth *ha = TAuthenticate::HasHostAuth(Host.Data(),User.Data());
   if (ha) {
      // We need to save it to restore at the end
      hasv1 = new THostAuth(*ha);
      // We reset the existing one
      ha->Reset();
      // And update it with the info we want
      ha->AddMethod(0,Details.Data());
   } else {
      // We create directly a new THostAuth
      ha = new THostAuth(Host.Data(),User.Data(),0,Details.Data());
      // And add object to list so that TAuthenticate has
      // a chance to find it
      TAuthenticate::GetAuthInfo()->Add(ha);
   }

   // Print available host auth info
   if (lDebug > 0)
      ha->Print();

   {
   // First authentication attempt
   t1 = new TFTP(TFTPPath.Data(),2);
   if (t1->IsOpen()) {
      TestMeth[0] = 1;
   } else {
      printf(" >>>>>>>>>>>>>>>> Test of UsrPwd authentication failed \n");
   }}

   // Try ReUse
   if (TestMeth[0] == 1) {
      TIter next(ha->Established());
      TSecContext *ai;
      while ((ai = (TSecContext *) next())) {
         if (ai->GetMethod() == 0) {
            Int_t OffSet = ai->GetOffSet();
            TestReUse[0] = 0;
            if (OffSet > -1) {
               TestReUse[0] = 1;
            }
         }
      }
   }
   // Delete t1
   if (t1) delete t1;
   // remove method from available list
   ha->RemoveMethod(0);

// SRP method
   if ( HaveMeth[1] ) {
      printf("+                                                                             +\n");
      printf("+   Testing SRP ...                                                           +\n");

     // Add relevant info to HostAuth
      ha->AddFirst(1,Details.Data());
      if (lDebug > 0)
         ha->Print();

     // Authentication attempt
      t1 = new TFTP(TFTPPath.Data(),2);
      if (t1->IsOpen()) {
         TestMeth[1] = 1;
      } else {
         printf(" >>>>>>>>>>>>>>>> Test of SRP authentication failed \n");
      }

      // Try ReUse
      if (TestMeth[1] == 1) {
         TIter next(ha->Established());
         TSecContext *ai;
         while ((ai = (TSecContext *) next())) {
            if (ai->GetMethod() == 1) {
               Int_t OffSet = ai->GetOffSet();
               TestReUse[1] = 0;
               if (OffSet > -1) {
                  TestReUse[1] = 1;
               }
            }
         }
      }
      // Delete t1
      if (t1) delete t1;
      // remove method from available list
      ha->RemoveMethod(1);

   }

// Kerberos method
   THostAuth *hak = 0;
   THostAuth *hasv2 = 0;
   if ( HaveMeth[2] ) {
      printf("+                                                                             +\n");
      printf("+   Testing Krb5 ...                                                          +\n");


      // Check if by any chance locally there is already an THostAuth matching
      // the one we want to use for testing
      hak = TAuthenticate::HasHostAuth(HostName.Data(),User.Data());
      if (hak) {
         if (lDebug > 0)
            printf(" >>>>>>>>>>>>>>>> Krb5: existing THostAuth found \n");
         // We need to save it to restore at the end
         hasv2 = new THostAuth(*hak);
         // We reset the existing one
         hak->Reset();
         // And update it with the info we want
         hak->AddMethod(2,Krb5Details.Data());
      } else {
         // We create directly a new THostAuth
         hak = new THostAuth(HostName.Data(),User.Data(),2,Krb5Details.Data());
         // And add object to list so that TAuthenticate has
         // a chance to find it
         TAuthenticate::GetAuthInfo()->Add(hak);
      }
      if (lDebug > 0)
         hak->Print();

     // Authentication attempt
      t1 = new TFTP(TFTPPathKrb5.Data(),2);
      if (t1->IsOpen()) {
         TestMeth[2] = 1;
      } else {
         printf(" >>>>>>>>>>>>>>>> Test of Kerberos authentication failed \n");
         if (strlen(krb5) > 0) {
            printf(" >>>>>>>>>>>>>>>> details used: '%s' \n",krb5);
         }
      }

      // Try ReUse
      if (TestMeth[2] == 1) {
         TIter next(hak->Established());
         TSecContext *ai;
         while ((ai = (TSecContext *) next())) {
            if (ai->GetMethod() == 2) {
               Int_t OffSet = ai->GetOffSet();
               TestReUse[2] = 0;
               if (OffSet > -1) {
                  TestReUse[2] = 1;
               }
            }
         }
      }
      // Delete t1
      if (t1) delete t1;
      // remove method from available list
      hak->RemoveMethod(2);
   }

// Globus method
   if ( HaveMeth[3] ) {
      printf("+                                                                             +\n");
      printf("+   Testing Globus ...                                                        +\n");

     // Add relevant info to HostAuth
      ha->AddFirst(3,GlobusDetails.Data());
      if (lDebug > 0)
         ha->Print();

     // Authentication attempt
      t1 = new TFTP(TFTPPath.Data(),2);
      if (t1->IsOpen()) {
         TestMeth[3] = 1;
      } else {
         printf(" >>>>>>>>>>>>>>>> Test of Globus authentication failed \n");
         if (strlen(globus) > 0) {
            printf(" >>>>>>>>>>>>>>>> details used: '%s' \n",globus);
         } else {
            printf(" >>>>>>>>>>>>>>>> using default details: \n");
            printf(" >>>>>>>>>>>>>>>>   ad:/etc/grid-security/certificates");
            printf(" cd:$HOME/.globus cf:usercert.pem kf:userkey.pem\n");
         }
         UserGroup_t *u = gSystem->GetUserInfo();
         if (u) {
            if (u->fUid > 0) {
               printf(" >>>>>>>>>>>>>>>> You are not root,");
               printf(" you may not have the right privileges\n");
               printf(" >>>>>>>>>>>>>>>> Make sure that the used details are correct! \n");
            }
         }
      }

      // Try ReUse
      if (TestMeth[3] == 1) {
         TIter next(ha->Established());
         TSecContext *ai;
         while ((ai = (TSecContext *) next())) {
            if (ai->GetMethod() == 3) {
               Int_t OffSet = ai->GetOffSet();
               TestReUse[3] = 0;
               if (OffSet > -1) {
                  TestReUse[3] = 1;
               }
            }
         }
      }
      // Delete t1
      if (t1) delete t1;
      // remove method from available list
      ha->RemoveMethod(3);
   }

// SSH method

   if ( HaveMeth[4] ) {
      printf("+                                                                             +\n");
      printf("+   Testing SSH ...                                                           +\n");

     // Add relevant info to HostAuth
      ha->AddFirst(4,Details.Data());
      if (lDebug > 0)
         ha->Print();

     // Authentication attempt
      t1 = new TFTP(TFTPPath.Data(),2);
      if (t1->IsOpen()) {
         TestMeth[4] = 1;
      } else {
         printf(" >>>>>>>>>>>>>>>> Test of SSH authentication failed \n");
      }

      // Try ReUse
      if (TestMeth[4] == 1) {
         TIter next(ha->Established());
         TSecContext *ai;
         while ((ai = (TSecContext *) next())) {
            if (ai->GetMethod() == 4) {
               Int_t OffSet = ai->GetOffSet();
               TestReUse[4] = 0;
               if (OffSet > -1) {
                  TestReUse[4] = 1;
               }
            }
         }
      }
      // Delete t1
      if (t1) delete t1;
      // remove method from available list
      ha->RemoveMethod(4);
   }


// Rfio method
   printf("+                                                                             +\n");
   printf("+   Testing UidGid ...                                                        +\n");

   // Add relevant info to HostAuth
   ha->AddFirst(5,Details.Data());
   if (lDebug > 0)
      ha->Print();

   // Authentication attempt
   {
   t1 = new TFTP(TFTPPath.Data(),2);
   if (t1->IsOpen()) {
      TestMeth[5] = 1;
   } else {
      printf(" >>>>>>>>>>>>>>>> Test of UidGid authentication failed \n");
   }}

   // Delete t1
   if (t1) delete t1;

   // remove method from available list
   ha->RemoveMethod(5);

   printf("+                                                                             +\n");
   printf("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");

   // Print available host auth info
   if (lDebug > 0)
      TAuthenticate::Show();

// Now restore initial configuration
   if (hasv1) {
      ha->Reset();
      ha->Update(hasv1);
   } else {
      TAuthenticate::GetAuthInfo()->Remove(ha);
   }
   if (hasv2) {
      hak->Reset();
      hak->Update(hasv2);
   } else {
      TAuthenticate::GetAuthInfo()->Remove(hak);
   }

// Final Printout
   printf("\n+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
   printf("+                                                                             +\n");
   printf("+   Result of the tests:                                                      +\n");
   printf("+                                                                             +\n");
   char status[4][20] = {"failed!","successful!","not testable","not tested"};
   int i = 0;
   for( i=0; i<6; i++ ) {
     if (HaveMeth[i] && TestMeth[i] < 2) {
       if (i < 5) {
          printf("+   Method: %d %8s: %11s (reuse: %11s)                      +\n",i,
                         Form("(%s)",TAuthenticate::GetAuthMethod(i)),
                         status[TestMeth[i]],status[TestReUse[i]]);
       } else
          printf("+   Method: %d %8s: %11s                                           +\n",i,
                         Form("(%s)",TAuthenticate::GetAuthMethod(i)),
                         status[TestMeth[i]]);
     }
   }
   Bool_t NotPrinted = kTRUE;
   for( i=0; i<6; i++ ) {
     if (HaveMeth[i] && TestMeth[i] > 1) {
        if (NotPrinted) {
           printf("+                                                                             +\n");
           printf("+   Could not be tested:                                                      +\n");
           printf("+                                                                             +\n");
           NotPrinted = kFALSE;
        }
        printf("+   Method: %d %8s: %11s                      +\n",i,
                       Form("(%s)",TAuthenticate::GetAuthMethod(i)),
                       status[TestMeth[i]]);
     }
   }
   printf("+                                                                             +\n");
   printf("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");

}
 TestAuth.C:1
 TestAuth.C:2
 TestAuth.C:3
 TestAuth.C:4
 TestAuth.C:5
 TestAuth.C:6
 TestAuth.C:7
 TestAuth.C:8
 TestAuth.C:9
 TestAuth.C:10
 TestAuth.C:11
 TestAuth.C:12
 TestAuth.C:13
 TestAuth.C:14
 TestAuth.C:15
 TestAuth.C:16
 TestAuth.C:17
 TestAuth.C:18
 TestAuth.C:19
 TestAuth.C:20
 TestAuth.C:21
 TestAuth.C:22
 TestAuth.C:23
 TestAuth.C:24
 TestAuth.C:25
 TestAuth.C:26
 TestAuth.C:27
 TestAuth.C:28
 TestAuth.C:29
 TestAuth.C:30
 TestAuth.C:31
 TestAuth.C:32
 TestAuth.C:33
 TestAuth.C:34
 TestAuth.C:35
 TestAuth.C:36
 TestAuth.C:37
 TestAuth.C:38
 TestAuth.C:39
 TestAuth.C:40
 TestAuth.C:41
 TestAuth.C:42
 TestAuth.C:43
 TestAuth.C:44
 TestAuth.C:45
 TestAuth.C:46
 TestAuth.C:47
 TestAuth.C:48
 TestAuth.C:49
 TestAuth.C:50
 TestAuth.C:51
 TestAuth.C:52
 TestAuth.C:53
 TestAuth.C:54
 TestAuth.C:55
 TestAuth.C:56
 TestAuth.C:57
 TestAuth.C:58
 TestAuth.C:59
 TestAuth.C:60
 TestAuth.C:61
 TestAuth.C:62
 TestAuth.C:63
 TestAuth.C:64
 TestAuth.C:65
 TestAuth.C:66
 TestAuth.C:67
 TestAuth.C:68
 TestAuth.C:69
 TestAuth.C:70
 TestAuth.C:71
 TestAuth.C:72
 TestAuth.C:73
 TestAuth.C:74
 TestAuth.C:75
 TestAuth.C:76
 TestAuth.C:77
 TestAuth.C:78
 TestAuth.C:79
 TestAuth.C:80
 TestAuth.C:81
 TestAuth.C:82
 TestAuth.C:83
 TestAuth.C:84
 TestAuth.C:85
 TestAuth.C:86
 TestAuth.C:87
 TestAuth.C:88
 TestAuth.C:89
 TestAuth.C:90
 TestAuth.C:91
 TestAuth.C:92
 TestAuth.C:93
 TestAuth.C:94
 TestAuth.C:95
 TestAuth.C:96
 TestAuth.C:97
 TestAuth.C:98
 TestAuth.C:99
 TestAuth.C:100
 TestAuth.C:101
 TestAuth.C:102
 TestAuth.C:103
 TestAuth.C:104
 TestAuth.C:105
 TestAuth.C:106
 TestAuth.C:107
 TestAuth.C:108
 TestAuth.C:109
 TestAuth.C:110
 TestAuth.C:111
 TestAuth.C:112
 TestAuth.C:113
 TestAuth.C:114
 TestAuth.C:115
 TestAuth.C:116
 TestAuth.C:117
 TestAuth.C:118
 TestAuth.C:119
 TestAuth.C:120
 TestAuth.C:121
 TestAuth.C:122
 TestAuth.C:123
 TestAuth.C:124
 TestAuth.C:125
 TestAuth.C:126
 TestAuth.C:127
 TestAuth.C:128
 TestAuth.C:129
 TestAuth.C:130
 TestAuth.C:131
 TestAuth.C:132
 TestAuth.C:133
 TestAuth.C:134
 TestAuth.C:135
 TestAuth.C:136
 TestAuth.C:137
 TestAuth.C:138
 TestAuth.C:139
 TestAuth.C:140
 TestAuth.C:141
 TestAuth.C:142
 TestAuth.C:143
 TestAuth.C:144
 TestAuth.C:145
 TestAuth.C:146
 TestAuth.C:147
 TestAuth.C:148
 TestAuth.C:149
 TestAuth.C:150
 TestAuth.C:151
 TestAuth.C:152
 TestAuth.C:153
 TestAuth.C:154
 TestAuth.C:155
 TestAuth.C:156
 TestAuth.C:157
 TestAuth.C:158
 TestAuth.C:159
 TestAuth.C:160
 TestAuth.C:161
 TestAuth.C:162
 TestAuth.C:163
 TestAuth.C:164
 TestAuth.C:165
 TestAuth.C:166
 TestAuth.C:167
 TestAuth.C:168
 TestAuth.C:169
 TestAuth.C:170
 TestAuth.C:171
 TestAuth.C:172
 TestAuth.C:173
 TestAuth.C:174
 TestAuth.C:175
 TestAuth.C:176
 TestAuth.C:177
 TestAuth.C:178
 TestAuth.C:179
 TestAuth.C:180
 TestAuth.C:181
 TestAuth.C:182
 TestAuth.C:183
 TestAuth.C:184
 TestAuth.C:185
 TestAuth.C:186
 TestAuth.C:187
 TestAuth.C:188
 TestAuth.C:189
 TestAuth.C:190
 TestAuth.C:191
 TestAuth.C:192
 TestAuth.C:193
 TestAuth.C:194
 TestAuth.C:195
 TestAuth.C:196
 TestAuth.C:197
 TestAuth.C:198
 TestAuth.C:199
 TestAuth.C:200
 TestAuth.C:201
 TestAuth.C:202
 TestAuth.C:203
 TestAuth.C:204
 TestAuth.C:205
 TestAuth.C:206
 TestAuth.C:207
 TestAuth.C:208
 TestAuth.C:209
 TestAuth.C:210
 TestAuth.C:211
 TestAuth.C:212
 TestAuth.C:213
 TestAuth.C:214
 TestAuth.C:215
 TestAuth.C:216
 TestAuth.C:217
 TestAuth.C:218
 TestAuth.C:219
 TestAuth.C:220
 TestAuth.C:221
 TestAuth.C:222
 TestAuth.C:223
 TestAuth.C:224
 TestAuth.C:225
 TestAuth.C:226
 TestAuth.C:227
 TestAuth.C:228
 TestAuth.C:229
 TestAuth.C:230
 TestAuth.C:231
 TestAuth.C:232
 TestAuth.C:233
 TestAuth.C:234
 TestAuth.C:235
 TestAuth.C:236
 TestAuth.C:237
 TestAuth.C:238
 TestAuth.C:239
 TestAuth.C:240
 TestAuth.C:241
 TestAuth.C:242
 TestAuth.C:243
 TestAuth.C:244
 TestAuth.C:245
 TestAuth.C:246
 TestAuth.C:247
 TestAuth.C:248
 TestAuth.C:249
 TestAuth.C:250
 TestAuth.C:251
 TestAuth.C:252
 TestAuth.C:253
 TestAuth.C:254
 TestAuth.C:255
 TestAuth.C:256
 TestAuth.C:257
 TestAuth.C:258
 TestAuth.C:259
 TestAuth.C:260
 TestAuth.C:261
 TestAuth.C:262
 TestAuth.C:263
 TestAuth.C:264
 TestAuth.C:265
 TestAuth.C:266
 TestAuth.C:267
 TestAuth.C:268
 TestAuth.C:269
 TestAuth.C:270
 TestAuth.C:271
 TestAuth.C:272
 TestAuth.C:273
 TestAuth.C:274
 TestAuth.C:275
 TestAuth.C:276
 TestAuth.C:277
 TestAuth.C:278
 TestAuth.C:279
 TestAuth.C:280
 TestAuth.C:281
 TestAuth.C:282
 TestAuth.C:283
 TestAuth.C:284
 TestAuth.C:285
 TestAuth.C:286
 TestAuth.C:287
 TestAuth.C:288
 TestAuth.C:289
 TestAuth.C:290
 TestAuth.C:291
 TestAuth.C:292
 TestAuth.C:293
 TestAuth.C:294
 TestAuth.C:295
 TestAuth.C:296
 TestAuth.C:297
 TestAuth.C:298
 TestAuth.C:299
 TestAuth.C:300
 TestAuth.C:301
 TestAuth.C:302
 TestAuth.C:303
 TestAuth.C:304
 TestAuth.C:305
 TestAuth.C:306
 TestAuth.C:307
 TestAuth.C:308
 TestAuth.C:309
 TestAuth.C:310
 TestAuth.C:311
 TestAuth.C:312
 TestAuth.C:313
 TestAuth.C:314
 TestAuth.C:315
 TestAuth.C:316
 TestAuth.C:317
 TestAuth.C:318
 TestAuth.C:319
 TestAuth.C:320
 TestAuth.C:321
 TestAuth.C:322
 TestAuth.C:323
 TestAuth.C:324
 TestAuth.C:325
 TestAuth.C:326
 TestAuth.C:327
 TestAuth.C:328
 TestAuth.C:329
 TestAuth.C:330
 TestAuth.C:331
 TestAuth.C:332
 TestAuth.C:333
 TestAuth.C:334
 TestAuth.C:335
 TestAuth.C:336
 TestAuth.C:337
 TestAuth.C:338
 TestAuth.C:339
 TestAuth.C:340
 TestAuth.C:341
 TestAuth.C:342
 TestAuth.C:343
 TestAuth.C:344
 TestAuth.C:345
 TestAuth.C:346
 TestAuth.C:347
 TestAuth.C:348
 TestAuth.C:349
 TestAuth.C:350
 TestAuth.C:351
 TestAuth.C:352
 TestAuth.C:353
 TestAuth.C:354
 TestAuth.C:355
 TestAuth.C:356
 TestAuth.C:357
 TestAuth.C:358
 TestAuth.C:359
 TestAuth.C:360
 TestAuth.C:361
 TestAuth.C:362
 TestAuth.C:363
 TestAuth.C:364
 TestAuth.C:365
 TestAuth.C:366
 TestAuth.C:367
 TestAuth.C:368
 TestAuth.C:369
 TestAuth.C:370
 TestAuth.C:371
 TestAuth.C:372
 TestAuth.C:373
 TestAuth.C:374
 TestAuth.C:375
 TestAuth.C:376
 TestAuth.C:377
 TestAuth.C:378
 TestAuth.C:379
 TestAuth.C:380
 TestAuth.C:381
 TestAuth.C:382
 TestAuth.C:383
 TestAuth.C:384
 TestAuth.C:385
 TestAuth.C:386
 TestAuth.C:387
 TestAuth.C:388
 TestAuth.C:389
 TestAuth.C:390
 TestAuth.C:391
 TestAuth.C:392
 TestAuth.C:393
 TestAuth.C:394
 TestAuth.C:395
 TestAuth.C:396
 TestAuth.C:397
 TestAuth.C:398
 TestAuth.C:399
 TestAuth.C:400
 TestAuth.C:401
 TestAuth.C:402
 TestAuth.C:403
 TestAuth.C:404
 TestAuth.C:405
 TestAuth.C:406
 TestAuth.C:407
 TestAuth.C:408
 TestAuth.C:409
 TestAuth.C:410
 TestAuth.C:411
 TestAuth.C:412
 TestAuth.C:413
 TestAuth.C:414
 TestAuth.C:415
 TestAuth.C:416
 TestAuth.C:417
 TestAuth.C:418
 TestAuth.C:419
 TestAuth.C:420
 TestAuth.C:421
 TestAuth.C:422
 TestAuth.C:423
 TestAuth.C:424
 TestAuth.C:425
 TestAuth.C:426
 TestAuth.C:427
 TestAuth.C:428
 TestAuth.C:429
 TestAuth.C:430
 TestAuth.C:431
 TestAuth.C:432
 TestAuth.C:433
 TestAuth.C:434
 TestAuth.C:435
 TestAuth.C:436
 TestAuth.C:437
 TestAuth.C:438
 TestAuth.C:439
 TestAuth.C:440
 TestAuth.C:441
 TestAuth.C:442
 TestAuth.C:443
 TestAuth.C:444
 TestAuth.C:445
 TestAuth.C:446
 TestAuth.C:447
 TestAuth.C:448
 TestAuth.C:449
 TestAuth.C:450
 TestAuth.C:451
 TestAuth.C:452
 TestAuth.C:453
 TestAuth.C:454
 TestAuth.C:455
 TestAuth.C:456
 TestAuth.C:457
 TestAuth.C:458
 TestAuth.C:459
 TestAuth.C:460
 TestAuth.C:461
 TestAuth.C:462
 TestAuth.C:463
 TestAuth.C:464
 TestAuth.C:465
 TestAuth.C:466
 TestAuth.C:467
 TestAuth.C:468
 TestAuth.C:469
 TestAuth.C:470
 TestAuth.C:471
 TestAuth.C:472
 TestAuth.C:473
 TestAuth.C:474
 TestAuth.C:475
 TestAuth.C:476
 TestAuth.C:477
 TestAuth.C:478
 TestAuth.C:479
 TestAuth.C:480
 TestAuth.C:481
 TestAuth.C:482
 TestAuth.C:483
 TestAuth.C:484
 TestAuth.C:485
 TestAuth.C:486
 TestAuth.C:487
 TestAuth.C:488
 TestAuth.C:489
 TestAuth.C:490
 TestAuth.C:491
 TestAuth.C:492
 TestAuth.C:493
 TestAuth.C:494
 TestAuth.C:495
 TestAuth.C:496
 TestAuth.C:497
 TestAuth.C:498
 TestAuth.C:499
 TestAuth.C:500
 TestAuth.C:501
 TestAuth.C:502
 TestAuth.C:503
 TestAuth.C:504
 TestAuth.C:505
 TestAuth.C:506
 TestAuth.C:507
 TestAuth.C:508
 TestAuth.C:509
 TestAuth.C:510
 TestAuth.C:511
 TestAuth.C:512
 TestAuth.C:513
 TestAuth.C:514
 TestAuth.C:515
 TestAuth.C:516
 TestAuth.C:517
 TestAuth.C:518
 TestAuth.C:519
 TestAuth.C:520
 TestAuth.C:521
 TestAuth.C:522
 TestAuth.C:523
 TestAuth.C:524
 TestAuth.C:525
 TestAuth.C:526
 TestAuth.C:527
 TestAuth.C:528
 TestAuth.C:529
 TestAuth.C:530
 TestAuth.C:531
 TestAuth.C:532
 TestAuth.C:533
 TestAuth.C:534
 TestAuth.C:535
 TestAuth.C:536
 TestAuth.C:537
 TestAuth.C:538
 TestAuth.C:539
 TestAuth.C:540
 TestAuth.C:541
 TestAuth.C:542
 TestAuth.C:543
 TestAuth.C:544
 TestAuth.C:545
 TestAuth.C:546
 TestAuth.C:547
 TestAuth.C:548
 TestAuth.C:549
 TestAuth.C:550
 TestAuth.C:551
 TestAuth.C:552
 TestAuth.C:553
 TestAuth.C:554
 TestAuth.C:555
 TestAuth.C:556
 TestAuth.C:557
 TestAuth.C:558
 TestAuth.C:559
 TestAuth.C:560
 TestAuth.C:561
 TestAuth.C:562
 TestAuth.C:563
 TestAuth.C:564
 TestAuth.C:565
 TestAuth.C:566
 TestAuth.C:567
 TestAuth.C:568
 TestAuth.C:569
 TestAuth.C:570
 TestAuth.C:571
 TestAuth.C:572
 TestAuth.C:573
 TestAuth.C:574
 TestAuth.C:575
 TestAuth.C:576
 TestAuth.C:577
 TestAuth.C:578
 TestAuth.C:579
 TestAuth.C:580
 TestAuth.C:581
 TestAuth.C:582
 TestAuth.C:583
 TestAuth.C:584
 TestAuth.C:585
 TestAuth.C:586
 TestAuth.C:587
 TestAuth.C:588
 TestAuth.C:589
 TestAuth.C:590
 TestAuth.C:591
 TestAuth.C:592
 TestAuth.C:593
 TestAuth.C:594
 TestAuth.C:595
 TestAuth.C:596
 TestAuth.C:597
 TestAuth.C:598
 TestAuth.C:599
 TestAuth.C:600
 TestAuth.C:601
 TestAuth.C:602
 TestAuth.C:603
 TestAuth.C:604
 TestAuth.C:605
 TestAuth.C:606
 TestAuth.C:607
 TestAuth.C:608
 TestAuth.C:609
 TestAuth.C:610