[BACK]Return to Lond.pm CVS log [TXT] [DIR] Up to [LON-CAPA] / loncom

Diff for /loncom/Lond.pm between versions 1.8.2.3.2.3 and 1.17

version 1.8.2.3.2.3, 2022/02/20 21:06:30 version 1.17, 2022/01/19 16:02:59
Line 37  use lib '/home/httpd/lib/perl/'; Line 37  use lib '/home/httpd/lib/perl/';
 use LONCAPA;  use LONCAPA;
 use Apache::lonnet;  use Apache::lonnet;
 use GDBM_File;  use GDBM_File;
 use Net::OAuth;  use MIME::Base64;
 use Crypt::CBC;  use Crypt::OpenSSL::X509;
   use Crypt::X509::CRL;
   use Crypt::PKCS10;
   
 sub dump_with_regexp {  sub dump_with_regexp {
     my ( $tail, $clientversion ) = @_;      my ( $tail, $clientversion ) = @_;
Line 812  sub is_course { Line 814  sub is_course {
     return $iscourse;      return $iscourse;
 }  }
   
   sub server_certs {
       my ($perlvar,$lonhost,$hostname) = @_;
       my %pemfiles = (
                        key      => 'lonnetPrivateKey',
                        host     => 'lonnetCertificate',
                        hostname => 'lonnetHostnameCertificate',
                        ca       => 'lonnetCertificateAuthority',
                        crl      => 'lonnetCertRevocationList',
                      );
       my (%md5hash,%expected_cn,%expired,%revoked,%wrongcn,%info,$crlfile,$cafile,
           %rvkcerts,$numrvk);
       %info = (
                   key => {},
                   ca  => {},
                   host => {},
                   hostname => {},
                   crl => {},
               );
       my @ordered = ('crl','key','ca','host','hostname');
       if (ref($perlvar) eq 'HASH') {
           $expected_cn{'host'} = $Apache::lonnet::serverhomeIDs{$hostname};
           $expected_cn{'hostname'} = 'internal-'.$hostname;
           my $certsdir = $perlvar->{'lonCertificateDirectory'};
           if (-d $certsdir) {
               $crlfile = $certsdir.'/'.$perlvar->{$pemfiles{'crl'}};
               $cafile = $certsdir.'/'.$perlvar->{$pemfiles{'ca'}};
               foreach my $key (@ordered) {
                   if ($perlvar->{$pemfiles{$key}}) {
                       my $file = $certsdir.'/'.$perlvar->{$pemfiles{$key}};
                       if (-e $file) {
                           if ($key eq 'crl') {
                                if ((-e $crlfile) && (-e $cafile)) {
                                    if (open(PIPE,"openssl crl -in $crlfile -inform pem -CAfile $cafile -noout 2>&1 |")) {
                                        my $crlstatus = <PIPE>;
                                        close(PIPE);
                                        chomp($crlstatus);
                                        if ($crlstatus =~ /OK/) {
                                            $info{$key}{'status'} = 'ok';
                                            $info{$key}{'details'} = 'CRL valid for CA';
                                        }
                                    }
                                }
                                if (open(my $fh,'<',$crlfile)) {
                                    my $pem_crl = '';
                                    while (my $line=<$fh>) {
                                        chomp($line);
                                        next if ($line eq '-----BEGIN X509 CRL-----');
                                        next if ($line eq '-----END X509 CRL-----');
                                        $pem_crl .= $line;
                                    }
                                    close($fh);
                                    my $der_crl = MIME::Base64::decode_base64($pem_crl);
                                    if ($der_crl ne '') {
                                        my $decoded = Crypt::X509::CRL->new( crl => $der_crl );
                                        if ($decoded->error) {
                                            $info{$key}{'status'} = 'error';
                                        } elsif (ref($decoded)) {
                                            $info{$key}{'start'} = $decoded->this_update;
                                            $info{$key}{'end'} = $decoded->next_update;
                                            $info{$key}{'alg'} = $decoded->SigEncAlg.' '.$decoded->SigHashAlg;
                                            $info{$key}{'cn'} = $decoded->issuer_cn;
                                            $info{$key}{'email'} = $decoded->issuer_email;
                                            $info{$key}{'size'} = $decoded->signature_length;
                                            my $rlref = $decoded->revocation_list;
                                            if (ref($rlref) eq 'HASH') {
                                                foreach my $key (keys(%{$rlref})) {
                                                    my $hkey = sprintf("%X",$key);
                                                    $rvkcerts{$hkey} = 1;
                                                }
                                                $numrvk = scalar(keys(%{$rlref}));
                                                if ($numrvk) {
                                                    $info{$key}{'details'} .= " ($numrvk revoked)"; 
                                                }
                                            }
                                        }
                                    }
                               }
                           } elsif ($key eq 'key') {
                               if (open(PIPE,"openssl rsa -noout -in $file -check |")) {
                                   my $check = <PIPE>;
                                   close(PIPE);
                                   chomp($check);
                                   $info{$key}{'status'} = $check;
                               }
                               if (open(PIPE,"openssl rsa -noout -modulus -in $file | openssl md5 |")) {
                                   $md5hash{$key} = <PIPE>;
                                   close(PIPE);
                                   chomp($md5hash{$key});
                               }
                           } else {
                               if ($key eq 'ca') {
                                   if (open(PIPE,"openssl verify -CAfile $file $file |")) {
                                       my $check = <PIPE>;
                                       close(PIPE);
                                       chomp($check);
                                       if ($check eq "$file: OK") {
                                           $info{$key}{'status'} = 'ok';
                                       } else {
                                           $check =~ s/^\Q$file\E\:?\s*//;
                                           $info{$key}{'status'} = $check;
                                       }
                                   }
                               } else {
                                   if (open(PIPE,"openssl x509 -noout -modulus -in $file | openssl md5 |")) {
                                       $md5hash{$key} = <PIPE>;
                                       close(PIPE);
                                       chomp($md5hash{$key});
                                   }
                               }
                               my $x509 = Crypt::OpenSSL::X509->new_from_file($file);
                               my @items = split(/,\s+/,$x509->subject());
                               foreach my $item (@items) {
                                   my ($name,$value) = split(/=/,$item);
                                   if ($name eq 'CN') {
                                       $info{$key}{'cn'} = $value;
                                   }
                               }
                               $info{$key}{'start'} = $x509->notBefore();
                               $info{$key}{'end'} = $x509->notAfter();
                               $info{$key}{'alg'} = $x509->sig_alg_name();
                               $info{$key}{'size'} = $x509->bit_length();
                               $info{$key}{'email'} = $x509->email();
                               $info{$key}{'serial'} = uc($x509->serial());
                               $info{$key}{'issuerhash'} = $x509->issuer_hash();
                               if ($x509->checkend(0)) {
                                   $expired{$key} = 1;
                               }
                               if (($key eq 'host') || ($key eq 'hostname')) {
                                   if ($info{$key}{'cn'} ne $expected_cn{$key}) {
                                       $wrongcn{$key} = 1;
                                   }
                                   if (($numrvk) && ($info{$key}{'serial'})) {
                                       if ($rvkcerts{$info{$key}{'serial'}}) {
                                           $revoked{$key} = 1;
                                       }
                                   }
                               }
                           }
                       }
                       if (($key eq 'host') || ($key eq 'hostname')) {
                           my $csrfile = $file;
                           $csrfile =~ s/\.pem$/.csr/;
                           if (-e $csrfile) {
                               if (open(PIPE,"openssl req -noout -modulus -in $csrfile |openssl md5 |")) {
                                   my $csrhash = <PIPE>;
                                   close(PIPE);
                                   chomp($csrhash);
                                   if ((!-e $file) || ($csrhash ne $md5hash{$key}) || ($expired{$key}) ||
                                       ($wrongcn{$key}) || ($revoked{$key})) {
                                       Crypt::PKCS10->setAPIversion(1);
                                       my $decoded = Crypt::PKCS10->new( $csrfile,(PEMonly => 1, readFile => 1));
                                       if (ref($decoded)) {
                                           if ($decoded->commonName() eq $expected_cn{$key}) {
                                               $info{$key.'-csr'}{'cn'} = $decoded->commonName();
                                               $info{$key.'-csr'}{'alg'} = $decoded->pkAlgorithm();
                                               $info{$key.'-csr'}{'email'} = $decoded->emailAddress();
                                               my $params = $decoded->subjectPublicKeyParams();
                                               if (ref($params) eq 'HASH') {
                                                   $info{$key.'-csr'}{'size'} = $params->{keylen};
                                               }
                                               $md5hash{$key.'-csr'} = $csrhash;
                                           }
                                       }
                                   }
                               }
                           }
                       }
                   }
               }
           }
       }
       foreach my $key ('host','hostname') {
           if ($md5hash{$key}) {
               if ($md5hash{$key} eq $md5hash{'key'}) {
                   if ($revoked{$key}) {
                       $info{$key}{'status'} = 'revoked';
                   } elsif ($expired{$key}) {
                       $info{$key}{'status'} = 'expired';
                   } elsif ($wrongcn{$key}) {
                       $info{$key}{'status'} = 'wrongcn';
                   } elsif ((exists($info{'ca'}{'issuerhash'})) &&
                            ($info{'ca'}{'issuerhash'} ne $info{$key}{'issuerhash'})) {
                       $info{$key}{'status'} = 'mismatch';
                   } else {
                       $info{$key}{'status'} = 'ok';
                   }
               } elsif ($info{'key'}{'status'} =~ /ok/) {
                   $info{$key}{'status'} = 'otherkey';
               } else {
                   $info{$key}{'status'} = 'nokey';
               }
           }
           if ($md5hash{$key.'-csr'}) {
               if ($md5hash{$key.'-csr'} eq $md5hash{'key'}) {
                   $info{$key.'-csr'}{'status'} = 'ok';
               } elsif ($info{'key'}{'status'} =~ /ok/) {
                   $info{$key.'-csr'}{'status'} = 'otherkey';
               } else {
                   $info{$key.'-csr'}{'status'} = 'nokey';
               }
           }
       }
       my $result;
       foreach my $key (keys(%info)) {
           $result .= &escape($key).'='.&Apache::lonnet::freeze_escape($info{$key}).'&';
       }
       $result =~ s/\&$//;
       return $result;
   }
   
 sub get_dom {  sub get_dom {
     my ($userinput) = @_;      my ($userinput) = @_;
     my ($cmd,$udom,$namespace,$what) =split(/:/,$userinput,4);      my ($cmd,$udom,$namespace,$what) =split(/:/,$userinput,4); 
     my $hashref = &tie_domain_hash($udom,$namespace,&GDBM_READER()) or      my $hashref = &tie_domain_hash($udom,$namespace,&GDBM_READER()) or
         return "error: ".($!+0)." tie(GDBM) Failed while attempting $cmd";          return "error: ".($!+0)." tie(GDBM) Failed while attempting $cmd";
     my $qresult='';      my $qresult='';
Line 831  sub get_dom { Line 1043  sub get_dom {
     return $qresult;      return $qresult;
 }  }
   
 sub store_dom {  
     my ($userinput) = @_;  
     my ($cmd,$dom,$namespace,$rid,$what) =split(/:/,$userinput);  
     my $hashref  = &tie_domain_hash($dom,$namespace,&GDBM_WRCREAT(),"S","$rid:$what") or  
         return "error: ".($!+0)." tie(GDBM) Failed while attempting $cmd";  
     $hashref->{"version:$rid"}++;  
     my $version=$hashref->{"version:$rid"};  
     my $allkeys='';  
     my @pairs=split(/\&/,$what);  
     foreach my $pair (@pairs) {  
         my ($key,$value)=split(/=/,$pair);  
         $allkeys.=$key.':';  
         $hashref->{"$version:$rid:$key"}=$value;  
     }  
     my $now = time;  
     $hashref->{"$version:$rid:timestamp"}=$now;  
     $allkeys.='timestamp';  
     $hashref->{"$version:keys:$rid"}=$allkeys;  
     &untie_user_hash($hashref) or  
         return "error: ".($!+0)." untie(GDBM) Failed while attempting $cmd";  
     return 'ok';  
 }  
   
 sub restore_dom {  
     my ($userinput) = @_;  
     my ($cmd,$dom,$namespace,$rid) = split(/:/,$userinput);  
     my $hashref = &tie_domain_hash($dom,$namespace,&GDBM_READER()) or  
         return "error: ".($!+0)." tie(GDBM) Failed while attempting $cmd";  
     my $qresult='';  
     if (ref($hashref)) {  
         chomp($rid);  
         my $version=$hashref->{"version:$rid"};  
         $qresult.="version=$version&";  
         my $scope;  
         for ($scope=1;$scope<=$version;$scope++) {  
             my $vkeys=$hashref->{"$scope:keys:$rid"};  
             my @keys=split(/:/,$vkeys);  
             my $key;  
             $qresult.="$scope:keys=$vkeys&";  
             foreach $key (@keys) {  
                 $qresult.="$scope:$key=".$hashref->{"$scope:$rid:$key"}."&";  
             }  
         }  
         $qresult=~s/\&$//;  
     }  
     &untie_user_hash($hashref) or  
         return "error: ".($!+0)." untie(GDBM) Failed while attempting $cmd";  
     return $qresult;  
 }  
   
 sub crslti_itemid {  
     my ($cdom,$cnum,$url,$method,$params,$loncaparev) = @_;  
     unless (ref($params) eq 'HASH') {  
         return;  
     }  
     if (($cdom eq '') || ($cnum eq '')) {  
         return;  
     }  
     my ($itemid,$consumer_key,$secret);  
   
     if (exists($params->{'oauth_callback'})) {  
         $Net::OAuth::PROTOCOL_VERSION = Net::OAuth::PROTOCOL_VERSION_1_0A;  
     } else {  
         $Net::OAuth::PROTOCOL_VERSION = Net::OAuth::PROTOCOL_VERSION_1_0;  
     }  
   
     my $consumer_key = $params->{'oauth_consumer_key'};  
     return if ($consumer_key eq '');  
   
     my (%crslti,%crslti_by_key);  
     my $hashid=$cdom.'_'.$cnum;  
     my ($result,$cached)=&Apache::lonnet::is_cached_new('courseltienc',$hashid);  
     if (defined($cached)) {  
         if (ref($result) eq 'HASH') {  
             %crslti = %{$result};  
         }  
     } else {  
         my $reply = &dump_with_regexp(join(":",($cdom,$cnum,'nohist_ltienc','','')),$loncaparev);  
         %crslti = %{&Apache::lonnet::unserialize($reply)};  
         my $cachetime = 24*60*60;  
         &Apache::lonnet::do_cache_new('courseltienc',$hashid,\%crslti,$cachetime);  
     }  
   
     return if (!keys(%crslti));  
   
     foreach my $id (keys(%crslti)) {  
         if (ref($crslti{$id}) eq 'HASH') {  
             my $key = $crslti{$id}{'key'};  
             if (($key ne '') && ($crslti{$id}{'secret'} ne '')) {  
                 push(@{$crslti_by_key{$key}},$id);  
             }  
         }  
     }  
   
     return if (!keys(%crslti_by_key));  
   
     my %courselti = &Apache::lonnet::get_course_lti($cnum,$cdom,'provider');  
   
     if (ref($crslti_by_key{$consumer_key}) eq 'ARRAY') {  
         foreach my $id (@{$crslti_by_key{$consumer_key}}) {  
             my $secret = $crslti{$id}{'secret'};  
             if (ref($courselti{$id}) eq 'HASH') {  
                 if ((exists($courselti{$id}{'cipher'})) &&  
                     ($courselti{$id}{'cipher'} =~ /^\d+$/)) {  
                     my $keynum = $courselti{$id}{'cipher'};  
                     my $privkey = &get_dom("getdom:$cdom:private:$keynum:lti:key");  
                     if ($privkey ne '') {  
                         my $cipher = new Crypt::CBC($privkey);  
                         $secret = $cipher->decrypt_hex($secret);  
                     }  
                 }  
             }  
             my $request = Net::OAuth->request('request token')->from_hash($params,  
                                               request_url => $url,  
                                               request_method => $method,  
                                               consumer_secret => $secret,);  
             if ($request->verify()) {  
                 $itemid = $id;  
                 last;  
             }  
         }  
     }  
     return $itemid;  
 }  
   
 sub domlti_itemid {  
     my ($dom,$context,$url,$method,$params,$loncaparev) = @_;  
     unless (ref($params) eq 'HASH') {  
         return;  
     }  
     if ($dom eq '') {  
         return;  
     }  
     my ($itemid,$consumer_key,$secret);  
   
     if (exists($params->{'oauth_callback'})) {  
         $Net::OAuth::PROTOCOL_VERSION = Net::OAuth::PROTOCOL_VERSION_1_0A;  
     } else {  
         $Net::OAuth::PROTOCOL_VERSION = Net::OAuth::PROTOCOL_VERSION_1_0;  
     }  
   
     my $consumer_key = $params->{'oauth_consumer_key'};  
     return if ($consumer_key eq '');  
   
     my ($name,$cachename);  
     if ($context eq 'linkprot') {  
         $name = $context;  
     } else {  
         $name = 'lti';  
     }  
     $cachename = $name.'enc';  
     my %ltienc;  
     my ($encresult,$enccached)=&Apache::lonnet::is_cached_new($cachename,$dom);  
     if (defined($enccached)) {  
         if (ref($encresult) eq 'HASH') {  
             %ltienc = %{$encresult};  
         }  
     } else {  
         my $reply = &get_dom("getdom:$dom:encconfig:$name");  
         my $ltiencref = &Apache::lonnet::thaw_unescape($reply);  
         if (ref($ltiencref) eq 'HASH') {  
             %ltienc = %{$ltiencref};  
         }  
         my $cachetime = 24*60*60;  
         &Apache::lonnet::do_cache_new($cachename,$dom,\%ltienc,$cachetime);  
     }  
   
     return if (!keys(%ltienc));  
   
     my %lti_by_key;  
     foreach my $id (keys(%ltienc)) {  
         if (ref($ltienc{$id}) eq 'HASH') {  
             my $key = $ltienc{$id}{'key'};  
             if (($key ne '') && ($ltienc{$id}{'secret'} ne '')) {  
                 push(@{$lti_by_key{$key}},$id);  
             }  
         }  
     }  
     return if (!keys(%lti_by_key));  
   
     my %lti = &Apache::lonnet::get_domain_lti($dom,$context);  
   
     if (ref($lti_by_key{$consumer_key}) eq 'ARRAY') {  
         foreach my $id (@{$lti_by_key{$consumer_key}}) {  
             my $secret = $ltienc{$id}{'secret'};  
             if (ref($lti{$id}) eq 'HASH') {  
                 if ((exists($lti{$id}{'cipher'})) &&  
                     ($lti{$id}{'cipher'} =~ /^\d+$/)) {  
                     my $keynum = $lti{$id}{'cipher'};  
                     my $privkey = &get_dom("getdom:$dom:private:$keynum:lti:key");  
                     if ($privkey ne '') {  
                         my $cipher = new Crypt::CBC($privkey);  
                         $secret = $cipher->decrypt_hex($secret);  
                     }  
                 }  
             }  
             my $request = Net::OAuth->request('request token')->from_hash($params,  
                                               request_url => $url,  
                                               request_method => $method,  
                                               consumer_secret => $secret,);  
             if ($request->verify()) {  
                 $itemid = $id;  
                 last;  
             }  
         }  
     }  
     return $itemid;  
 }  
   
 1;  1;
   
 __END__  __END__
Line 1169  in /home/httpd/lonUsers/$dom on the prim Line 1172  in /home/httpd/lonUsers/$dom on the prim
 The single argument passed is the string: $cmd:$udom:$namespace:$what  The single argument passed is the string: $cmd:$udom:$namespace:$what
 where $cmd is the command historically passed to lond - i.e., getdom  where $cmd is the command historically passed to lond - i.e., getdom
 or egetdom, $udom is the domain, $namespace is the name of the GDBM file  or egetdom, $udom is the domain, $namespace is the name of the GDBM file
 (encconfig or configuration), and $what is a string containing names of  (encconfig or configuration), and $what is a string containing names of 
 items to retrieve from the db file (each item name is escaped and separated  items to retrieve from the db file (each item name is escaped and separated
 from the next item name with an ampersand). The return value is either:  from the next item name with an ampersand). The return value is either:
 error: followed by an error message, or a string containing the value (escaped)  error: followed by an error message, or a string containing the value (escaped)
Removed from v.1.8.2.3.2.3  
changed lines
  Added in v.1.17

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>