476 lines
17 KiB
PHP
476 lines
17 KiB
PHP
<?php
|
|
// This file is part of the Studyplan plugin for Moodle
|
|
//
|
|
// Moodle is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Moodle is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Moodle. If not, see <https://www.gnu.org/licenses/>.
|
|
/**
|
|
* Determine premium status
|
|
* @package local_treestudyplan
|
|
* @copyright 2023 P.M. Kuipers
|
|
* @license https://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
namespace local_treestudyplan;
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
require_once($CFG->libdir.'/externallib.php');
|
|
|
|
/**
|
|
* Handle badge information in the same style as the other classes
|
|
*/
|
|
class premium extends \external_api {
|
|
|
|
/**
|
|
* Toggle the variable below to enable support for premium stuff.
|
|
* If set to false, all premium features will be enabled and no premium settings panel will be visible.
|
|
* @var bool
|
|
*/
|
|
private static $premiumsupported = true;
|
|
|
|
/**
|
|
* Certficate code
|
|
* @var string
|
|
*/
|
|
private static $premiumcrt = "-----BEGIN CERTIFICATE-----
|
|
MIIDSzCCAjMCFFlyhmKf1fN7U5lQL/dtlsyP24AQMA0GCSqGSIb3DQEBCwUAMGEx
|
|
CzAJBgNVBAYTAk5MMRYwFAYDVQQIDA1Ob29yZC1Ib2xsYW5kMRowGAYDVQQKDBFN
|
|
aXFyYSBFbmdpbmVlcmluZzEeMBwGA1UEAwwVVHJlZVN0dWR5cGxhbiBQcmVtaXVt
|
|
MCAXDTI0MDIxMDE2MDQwM1oYDzIxMjQwMTE3MTYwNDAzWjBhMQswCQYDVQQGEwJO
|
|
TDEWMBQGA1UECAwNTm9vcmQtSG9sbGFuZDEaMBgGA1UECgwRTWlxcmEgRW5naW5l
|
|
ZXJpbmcxHjAcBgNVBAMMFVRyZWVTdHVkeXBsYW4gUHJlbWl1bTCCASIwDQYJKoZI
|
|
hvcNAQEBBQADggEPADCCAQoCggEBAOD7+Nf5UBYGmIadI+kRM7vSPGA12F6cyZuZ
|
|
O/JsdCWzZx3cCgVYt29DxHRvFVGrhGGLsoaMY9iXc9LdeO02jKqL3RoPo2kc5moT
|
|
SNarsKZcGZXgqo5NATmdMLqQpKAy41H0ybgXZDLq5XKs9YIRlkwSpzQTNeP49mOl
|
|
48giVX3icbpMw1TdQotalKXAtcs62o+guQJNANpjBRxPXssrmDoNXrJcAtUjNOjx
|
|
8M+8tCmwkKwBoK8F3wWxIo04kZ9KILtybMmn4VJJ6SwLEf4StphTIoru8zS7XUt8
|
|
3HbV3PsiyYErPlwIcobfcjwZJpub23bzetvxRvhpeIpLhrTGrPMCAwEAATANBgkq
|
|
hkiG9w0BAQsFAAOCAQEAQwkbP6m3sdQgXEK3mYYZvvs6R/FI9QPu/9ICA+dgfj4y
|
|
7wvL0toYYR5oXdhO9At3MYmS+0bFUmqoTS+cxsC4COpEKFbRBWwbJ3NXAw14Hx2U
|
|
ELLqMZGJNOwNV+3ZdhADrwA++AjUqu144ObrcNUqo4+A4h9R8qj+o0J50Gvwja9R
|
|
Uh67LsF4Ls8fUtqzpqct94bUl6MPMHlH4qpZlgndmQdgOwLWeQEmM8X3WtSJH90S
|
|
n8FqBInMBhGu1uz0Qeo09ke0RHRnghP9EXfig/veMegASZeEhFqmS2Bdiy6gqeZ5
|
|
Klc5I28bGbvxIV5pnL6ZSjHEDp2WreM8HB0XFJwU+Q==
|
|
-----END CERTIFICATE-----";
|
|
|
|
/**
|
|
* Cached status
|
|
* @var object
|
|
*/
|
|
private static $cachedpremiumstatus = null;
|
|
|
|
/**
|
|
* Check if premium is supported
|
|
* @return bool
|
|
*/
|
|
public static function supported() {
|
|
return self::$premiumsupported;
|
|
}
|
|
|
|
/**
|
|
* Decrypt encrypted data
|
|
* @param string $encrypted Encrypted data
|
|
*/
|
|
private static function decrypt($encrypted) {
|
|
// Get the public key.
|
|
$key = \openssl_get_publickey(self::$premiumcrt);
|
|
if ($key === false) {
|
|
throw new \ParseError("Error parsing public key data)");
|
|
}
|
|
// Determine the key size.
|
|
$keysize = \openssl_pkey_get_details($key)["bits"];
|
|
$blocksize = ($keysize / 8); // Bits / 8. Whether padded or not.
|
|
|
|
// Decode data in.
|
|
$b64 = \base64_decode($encrypted);
|
|
if ($b64 === false) {
|
|
throw new \ParseError("Error in base64 decoding");
|
|
}
|
|
|
|
$data = \str_split($b64, $blocksize);
|
|
$decrypted = "";
|
|
$i = 0;
|
|
foreach ($data as $chunk) {
|
|
if (\openssl_public_decrypt($chunk, $dchunk, $key, \OPENSSL_PKCS1_PADDING)) {
|
|
$decrypted .= $dchunk;
|
|
} else {
|
|
throw new \ParseError("Error decrypting chunk $i ({$blocksize} bytes)");
|
|
}
|
|
$i++;
|
|
}
|
|
|
|
// Deprecated in PHP 8.0 and up, but included to be compatible with 7.4.
|
|
if (\PHP_MAJOR_VERSION < 8) {
|
|
\openssl_pkey_free($key);
|
|
}
|
|
|
|
return $decrypted;
|
|
}
|
|
|
|
/**
|
|
* Trim headers from key data
|
|
* @param string $data the key dat with headers
|
|
* @return string Key without headers
|
|
*/
|
|
private static function trim_headers($data) {
|
|
// Headers are repeated in this function for easier testing and copy-pasting into other projects.
|
|
$startheader = "----- BEGIN ACTIVATION KEY -----";
|
|
$endheader = "----- END ACTIVATION KEY -----";
|
|
|
|
$parts = preg_split("/\r?\n/", \trim($data));
|
|
if (count($parts) > 2) {
|
|
$start = -1;
|
|
$end = -1;
|
|
for ($i = 0; $i < count($parts); $i++) {
|
|
// Make sure all unicode spaces are converted to normal spaces before comparing.
|
|
$p = trim(preg_replace('/\s+/u', ' ', $parts[$i]));
|
|
|
|
if ($p == $startheader) {
|
|
$start = $i + 1;
|
|
}
|
|
if ($start > 0 && $p == $endheader) {
|
|
$end = $i;
|
|
}
|
|
}
|
|
|
|
if ($start < 0 || $end < 0 || $end - $start <= 0) {
|
|
throw new \ParseError("Invalid activation key wrappers");
|
|
} else {
|
|
$keyslice = array_slice($parts, $start, $end - $start);
|
|
return implode("\n", $keyslice);
|
|
}
|
|
} else {
|
|
throw new \ParseError("Invalid activation key");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check if premium status is enabled
|
|
* @return bool
|
|
*/
|
|
public static function enabled() {
|
|
if (self::$premiumsupported) {
|
|
$status = self::premiumstatus();
|
|
return $status->enabled;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check if the premium key includes a specific intent in addition to the treestudyplan.
|
|
* @param string $intent The intent to search for
|
|
* @return bool
|
|
*/
|
|
public static function has_intent($intent) {
|
|
$status = self::premiumstatus();
|
|
if ($status->enabled) {
|
|
return \in_array(\strtolower($intent), $status->intents);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generate debug info.
|
|
*/
|
|
public static function debuginfo() {
|
|
$s = "<pre>";
|
|
try {
|
|
$activationkey = \get_config("local_treestudyplan", "premium_key");
|
|
if (strlen($activationkey) > 0) {
|
|
$keydata = self::trim_headers($activationkey);
|
|
$json = self::decrypt($keydata);
|
|
$s .= "Decoded key data:\n----\n";
|
|
$s .= $json . "\n----\n";
|
|
$decoded = \json_decode($json, false);
|
|
$s .= "Read as object:\n----\n";
|
|
$s .= \json_encode($decoded, \JSON_PRETTY_PRINT) ."\n----\n";
|
|
$status = self::premiumstatus();
|
|
$s .= "Parsed premium status block:\n----\n";
|
|
$s .= \json_encode($status, \JSON_PRETTY_PRINT) ."\n----\n";
|
|
$s .= "Message: " . self::statusdescription() . "\n";
|
|
} else {
|
|
$s .= "Premium key empty";
|
|
}
|
|
} catch (\Throwable $x) {
|
|
$s .= "!!! " . get_class($x) . ": " . $x->getCode() . " | " . $x->getMessage(). "\n";
|
|
$stack = explode("\n", $x->getTraceAsString());
|
|
foreach ($stack as $l) {
|
|
$s .= " " . trim($l) ."\n";
|
|
}
|
|
}
|
|
|
|
$s .= "</pre>";
|
|
return $s;
|
|
}
|
|
|
|
/**
|
|
* Determine, cache and retrieve premium status
|
|
* @return object
|
|
*/
|
|
protected static function premiumstatus() {
|
|
if (!isset(self::$cachedpremiumstatus)) {
|
|
|
|
// Initialize default object.
|
|
$o = new \stdClass;
|
|
$o->enabled = false;
|
|
$o->intents = [];
|
|
$o->name = "";
|
|
$o->website = "";
|
|
$o->expires = "";
|
|
$o->expired = false;
|
|
$o->issued = "";
|
|
try {
|
|
$activationkey = \get_config("local_treestudyplan", "premium_key");
|
|
if (strlen($activationkey) > 0) {
|
|
|
|
$keydata = self::trim_headers($activationkey);
|
|
$json = self::decrypt($keydata);
|
|
$decoded = \json_decode($json, false);
|
|
|
|
if (is_object($decoded)) {
|
|
|
|
// Copy basic data/.
|
|
$keys = ["name", "website", "expires", "issued"];
|
|
foreach ($keys as $k) {
|
|
if (isset($decoded->$k)) {
|
|
$o->$k = $decoded->$k;
|
|
}
|
|
}
|
|
|
|
if (!empty($decoded->intent)) {
|
|
$o->intents = explode(",", $decoded->intent);
|
|
}
|
|
|
|
// Convert dates to DateTime for.
|
|
$now = new \DateTime();
|
|
$issuedate = new \DateTime($o->issued);
|
|
if ($o->expires == 'never') {
|
|
// If expiry date == never.
|
|
$expirydate = new \DateTime(); // Default to now and add a year.
|
|
$expirydate->add(new \DateInterval("P1Y"));
|
|
} else {
|
|
try {
|
|
$expirydate = new \DateTime($o->expires);
|
|
} catch (\Exception $x) {
|
|
$expirydate = new \DateTime(); // Default to now.
|
|
}
|
|
}
|
|
|
|
if (\in_array('treestudyplan', $o->intents)
|
|
&& !empty($o->issued)
|
|
&& self::website_match($o->website)
|
|
) {
|
|
if ($expirydate > $now) {
|
|
$o->enabled = true;
|
|
$o->expired = false;
|
|
} else {
|
|
$o->expired = true;
|
|
$o->enabled = false;
|
|
}
|
|
// Format dates localized.
|
|
$o->issued = \userdate($issuedate->getTimestamp(), \get_string('strftimedate', 'langconfig'));
|
|
if ($o->expires == "never") {
|
|
$o->expires = \get_string("premium:never", 'local_treestudyplan');
|
|
} else {
|
|
$o->expires = \userdate($expirydate->getTimestamp(), \get_string('strftimedate', 'langconfig'));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch (\ParseError $x) {
|
|
$o->status = \get_string("premium:invalidactivationcontent", "local_treestudyplan");
|
|
}
|
|
self::$cachedpremiumstatus = $o;
|
|
|
|
}
|
|
return self::$cachedpremiumstatus;
|
|
}
|
|
|
|
/**
|
|
* Check if the current site matches the provided key
|
|
* @param string $key Website pattern to match against
|
|
*/
|
|
private static function website_match($key) {
|
|
global $CFG;
|
|
$site = $CFG->wwwroot;
|
|
|
|
// Add double slashes to key and site if no scheme is set.
|
|
// Basically: if no double slashes present before any dots, slashes or @s.
|
|
if (!\preg_match_all('#^[^./@]*?//#', $key)) {
|
|
$key = "//".$key;
|
|
}
|
|
if (!\preg_match_all('#^[^./@]*?//#', $site)) {
|
|
$site = "//".$site;
|
|
}
|
|
// Use parse_url() to split path and host.
|
|
$keyurl = (object)\parse_url($key);
|
|
$siteurl = (object)\parse_url($site);
|
|
|
|
// No match if host is empty on key or site.
|
|
if (empty($keyurl->host) || empty($siteurl->host)) {
|
|
return false;
|
|
}
|
|
|
|
if ($keyurl->host == "*") {
|
|
// Value * matches all.
|
|
return true;
|
|
}
|
|
|
|
// First match the host part.
|
|
$keyparts = \array_reverse(\explode(".", $keyurl->host));
|
|
$siteparts = \array_reverse(\explode(".", $siteurl->host));
|
|
|
|
// Trim starting www from both parts, since site.domain and www.site.domain should be treated as the same.
|
|
if (($x = \array_pop($keyparts)) != "www") {
|
|
\array_push($keyparts, $x);
|
|
}
|
|
if (($x = \array_pop($siteparts)) != "www") {
|
|
\array_push($siteparts, $x);
|
|
}
|
|
|
|
for ($i = 0; $i < count($keyparts); $i++) {
|
|
// No match if the site does not have a part, but the key does. Unless the key part is .
|
|
if (!isset($siteparts[$i])) {
|
|
if ($keyparts[$i] != "*") {
|
|
return false;
|
|
} else {
|
|
$i++; // Increment $i by one before break, to make sure the comparison following this loop holds.
|
|
break; // Stop comparison. Host part matches.
|
|
}
|
|
}
|
|
|
|
// Now do a proper case insensitive check for matching.
|
|
// Uses fnmatch to easily handle shell type wildcards.
|
|
if (! \fnmatch($keyparts[$i], $siteparts[$i], \FNM_CASEFOLD)) {
|
|
return false;
|
|
}
|
|
}
|
|
// Fail if the site has a deeper subdomain than the key, unless the deepest key subdomain is .
|
|
if ($keyparts[$i - 1] != '*' && count($siteparts) > ($i)) {
|
|
return false;
|
|
}
|
|
|
|
// If we made it here then the host part matches. Now check the path.
|
|
// If path is /*, matches all subpaths including /.
|
|
$keypath = empty($keyurl->path) ? "/" : $keyurl->path;
|
|
$sitepath = empty($siteurl->path) ? "/" : $siteurl->path;
|
|
|
|
// Trim trailing / from both paths before comparison.
|
|
if (\strlen($sitepath) > 1) {
|
|
$sitepath = \rtrim($sitepath, "/");
|
|
}
|
|
if (\strlen($keypath) > 1) {
|
|
$keypath = \rtrim($keypath, "/");
|
|
}
|
|
|
|
// Do a case insensitive fnmatch on the site so wildcards are matched too.
|
|
return \fnmatch($keypath, $sitepath, \FNM_CASEFOLD);
|
|
}
|
|
|
|
/**
|
|
* Parameter description for webservice function get_premiumstatus
|
|
*/
|
|
public static function get_premiumstatus_parameters(): \external_function_parameters {
|
|
return new \external_function_parameters([]);
|
|
}
|
|
|
|
/**
|
|
* Return value description for webservice function get_premiumstatus
|
|
*/
|
|
public static function get_premiumstatus_returns(): \external_description {
|
|
return new \external_single_structure([
|
|
"enabled" => new \external_value(PARAM_BOOL, 'premium status enabled'),
|
|
"website" => new \external_value(PARAM_TEXT, 'premium registration website'),
|
|
"name" => new \external_value(PARAM_TEXT, 'premium registration name'),
|
|
"expires" => new \external_value(PARAM_TEXT, 'premium registration expiry date'),
|
|
"expired" => new \external_value(PARAM_BOOL, 'premium status expired'),
|
|
"intents" => new \external_multiple_structure(
|
|
new \external_value(PARAM_TEXT), 'additional intents included in the license'
|
|
),
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Get premium status information for webservice
|
|
* @return object
|
|
*/
|
|
public static function get_premiumstatus() {
|
|
if (self::$premiumsupported) {
|
|
$status = self::premiumstatus();
|
|
$keys = [
|
|
"enabled",
|
|
"website",
|
|
"name",
|
|
"expires",
|
|
"expired",
|
|
"intents",
|
|
];
|
|
|
|
$result = [];
|
|
foreach ($keys as $param) {
|
|
$result[$param] = $status->$param;
|
|
}
|
|
return $result;
|
|
} else {
|
|
return [
|
|
"enabled" => true,
|
|
"website" => '*',
|
|
"name" => '*',
|
|
"expires" => '',
|
|
"expired" => false,
|
|
"intents" => [],
|
|
];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get a descriptive text of the current premium status
|
|
* @return string HTML description of premium status.
|
|
*/
|
|
public static function statusdescription() {
|
|
$status = self::premiumstatus();
|
|
|
|
$msg = new \stdClass;
|
|
$msg->name = $status->name;
|
|
$msg->issued = $status->issued;
|
|
$msg->expires = $status->expires;
|
|
if ($status->website != "*") {
|
|
$msg->sitestatus = \get_string("premium:onsite", 'local_treestudyplan', $status);
|
|
} else {
|
|
$msg->sitestatus = \get_string("premium:anywhere", 'local_treestudyplan');
|
|
}
|
|
|
|
if ($status->enabled) {
|
|
return \get_string("premium:active", 'local_treestudyplan', $msg);
|
|
} else if ($status->expired) {
|
|
return \get_string("premium:expired", 'local_treestudyplan', $msg);
|
|
} else if (!self::website_match($status->website)) {
|
|
return \get_string("premium:siteinvalid", 'local_treestudyplan', $status->website);
|
|
} else {
|
|
return \get_string("premium:notregistered", 'local_treestudyplan', $msg);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Throw an error if premium status is not enabled
|
|
* @param string $message Message translation key to use in exception
|
|
*/
|
|
public static function require_premium($message="premiumfeature:warning") {
|
|
if (! self::enabled()) {
|
|
throw new \moodle_exception($message, "local_treestudyplan");
|
|
}
|
|
}
|
|
|
|
}
|