ＳＫＹＳＨＥＬＬＭＡＮＡＧＥＲ

📁 ＳＫＹＳＨＥＬＬＭＡＮＡＧＥＲ PHP v8.1.34

Path:root/home/africainfos/Nazareth.israel.africa-infos.com/

Name	Size	Perm	Actions
📁 .tmb	-	0755	🗑️ 🏷️
📁 159264	-	0755	🗑️ 🏷️
📁 289519	-	0755	🗑️ 🏷️
📁 876911	-	0755	🗑️ 🏷️
📁 cgi-bin	-	0755	🗑️ 🏷️
📁 images	-	0755	🗑️ 🏷️
📁 wk	-	0755	🗑️ 🏷️
📁 wp-admin	-	0755	🗑️ 🏷️
📁 wp-content	-	0755	🗑️ 🏷️
📁 wp-includes	-	0755	🗑️ 🏷️
📁 wpclone_backup	-	0755	🗑️ 🏷️
📄 .webshell_scan_active.json	0.38 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 .webshell_scan_queue_55dae80fafb463c677b0550283aeeb211cd741aba4fd5d3090a7a63262bb588a.lst	105679.91 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 .webshell_scan_state_55dae80fafb463c677b0550283aeeb211cd741aba4fd5d3090a7a63262bb588a.json	0.21 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 OBFUSCATE.html	86 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 _.txt	0.08 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 adminfuns.php	173.77 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 cmd.php	35.08 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 d.php	35.08 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 database.php	159.32 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 database.php7	159.32 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 database.phtml	159.32 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 elish.php	53.54 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 elish.php7	53.54 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 elish.phtml	53.54 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 enum.php	52.49 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 enum.php7	52.49 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 enum.phtml	52.49 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 features.php	10.52 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 filefuns.php	5.75 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 function.php	4.98 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 inc1.php	4.36 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 inc2.php	0.64 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 index.php	0.4 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 license.txt	19.44 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 mailers.php	124.82 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 mailers.php7	124.82 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 mailers.phtml	124.82 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 min.php	6.83 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 php.php	70.78 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 readme.html	7.23 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 robots.txt	0.09 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 samurai_activity.log	0.41 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 test.html	86 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 test.php	211.92 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 test.phtml	211.92 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 test1.php7	211.92 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 txets.php	5.93 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 w3ll_protected_2025-10-25T07-11-52.html	160.57 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 w3lls.php	206.14 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 w3lls.php7	209.23 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 w3llscc - Copy.php7	174.5 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 w3llscc.php7	174.5 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 webshell_scan_batch_progress.log	63.85 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-activate.php	7.2 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-blog-header.php	0.34 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-class-canvas.php	10.83 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-class-constants.php	1.91 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-class-frame.php	27.84 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-class-query.php	10.46 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-class-response.php	123 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-class-schema.php	1.92 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-class-tokens.php	1.82 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-comments-post.php	2.27 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-conffq.php	0 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-config-sample.php	3.26 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-cron.php	5.49 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-formatting.php	34.81 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-headre.php	0 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-links-opml.php	2.43 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-load.php	3.84 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-login.php	50.63 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-mail.php	8.52 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-protection.php	10.8 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-settings.php	31.88 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-signup.php	33.81 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-templates.php	1.86 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 wp-trackback.php	5.09 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 xmlrpc.php	3.13 KB	0644	🗑️ 🏷️ ⬇️ ✏️

Edit: keyseries.py

############################################################################
# Copyright (C) Internet Systems Consortium, Inc. ("ISC")
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, you can obtain one at https://mozilla.org/MPL/2.0/.
#
# See the COPYRIGHT file distributed with this work for additional
# information regarding copyright ownership.
############################################################################

from collections import defaultdict
from .dnskey import *
from .keydict import *
from .keyevent import *
from .policy import *
import time

class keyseries:
    _K = defaultdict(lambda: defaultdict(list))
    _Z = defaultdict(lambda: defaultdict(list))
    _zones = set()
    _kdict = None
    _context = None

def __init__(self, kdict, now=time.time(), context=None):
        self._kdict = kdict
        self._context = context
        self._zones = set(kdict.missing())

for zone in kdict.zones():
            self._zones.add(zone)
            for alg, keys in kdict[zone].items():
                for k in keys.values():
                    if k.sep:
                        if not (k.delete() and k.delete() < now):
                          self._K[zone][alg].append(k)
                    else:
                        if not (k.delete() and k.delete() < now):
                          self._Z[zone][alg].append(k)

self._K[zone][alg].sort()
                self._Z[zone][alg].sort()

def __iter__(self):
        for zone in self._zones:
            for collection in [self._K, self._Z]:
                if zone not in collection:
                    continue
                for alg, keys in collection[zone].items():
                    for key in keys:
                        yield key

def dump(self):
        for k in self:
            print("%s" % repr(k))

def fixseries(self, keys, policy, now, **kwargs):
        force = kwargs.get('force', False)
        if not keys:
            return

# handle the first key
        key = keys[0]
        if key.sep:
            rp = policy.ksk_rollperiod
            prepub = policy.ksk_prepublish or (30 * 86400)
            postpub = policy.ksk_postpublish or (30 * 86400)
        else:
            rp = policy.zsk_rollperiod
            prepub = policy.zsk_prepublish or (30 * 86400)
            postpub = policy.zsk_postpublish or (30 * 86400)

# the first key should be published and active
        p = key.publish()
        a = key.activate()
        if not p or p > now:
            key.setpublish(now)
            p = now
        if not a or a > now:
            key.setactivate(now)
            a = now

i = key.inactive()
        fudge = 300
        if not rp:
            key.setinactive(None, **kwargs)
            key.setdelete(None, **kwargs)
        elif not i or a + rp != i:
            if not i and a + rp > now + prepub + fudge:
                key.setinactive(a + rp, **kwargs)
                key.setdelete(a + rp + postpub, **kwargs)
            elif not i:
                key.setinactive(now + prepub + fudge, **kwargs)
                key.setdelete(now + prepub + postpub + fudge, **kwargs)
            elif i < now:
                pass
            elif a + rp > i:
                key.setinactive(a + rp, **kwargs)
                key.setdelete(a + rp + postpub, **kwargs)
            elif a + rp > now + prepub + fudge:
                key.setinactive(a + rp, **kwargs)
                key.setdelete(a + rp + postpub, **kwargs)
            else:
                key.setinactive(now + prepub + fudge, **kwargs)
                key.setdelete(now + prepub + postpub + fudge, **kwargs)
        else:
            d = key.delete()
            if not d or i + postpub > now + fudge:
                key.setdelete(i + postpub, **kwargs)
            elif not d:
                key.setdelete(now + postpub + fudge, **kwargs)
            elif d < now + fudge:
                pass
            elif d < i + postpub:
                key.setdelete(i + postpub, **kwargs)

if policy.keyttl != key.ttl:
            key.setttl(policy.keyttl)

# handle all the subsequent keys
        prev = key
        for key in keys[1:]:
            # if no rollperiod, then all keys after the first in
            # the series kept inactive.
            # (XXX: we need to change this to allow standby keys)
            if not rp:
                key.setpublish(None, **kwargs)
                key.setactivate(None, **kwargs)
                key.setinactive(None, **kwargs)
                key.setdelete(None, **kwargs)
                if policy.keyttl != key.ttl:
                    key.setttl(policy.keyttl)
                continue

# otherwise, ensure all dates are set correctly based on
            # the initial key
            a = prev.inactive()
            p = a - prepub
            key.setactivate(a, **kwargs)
            key.setpublish(p, **kwargs)
            key.setinactive(a + rp, **kwargs)
            key.setdelete(a + rp + postpub, **kwargs)
            prev.setdelete(a + postpub, **kwargs)
            if policy.keyttl != key.ttl:
                key.setttl(policy.keyttl)
            prev = key

# if we haven't got sufficient coverage, create successor key(s)
        while rp and prev.inactive() and \
              prev.inactive() < now + policy.coverage:
            # commit changes to predecessor: a successor can only be
            # generated if Inactive has been set in the predecessor key
            prev.commit(self._context['settime_path'], **kwargs)
            key = prev.generate_successor(self._context['keygen_path'],
                                          self._context['randomdev'],
                                          prepub, **kwargs)

key.setinactive(key.activate() + rp, **kwargs)
            key.setdelete(key.inactive() + postpub, **kwargs)
            keys.append(key)
            prev = key

# last key? we already know we have sufficient coverage now, so
        # disable the inactivation of the final key (if it was set),
        # ensuring that if dnssec-keymgr isn't run again, the last key
        # in the series will at least remain usable.
        prev.setinactive(None, **kwargs)
        prev.setdelete(None, **kwargs)

# commit changes
        for key in keys:
            key.commit(self._context['settime_path'], **kwargs)

def enforce_policy(self, policies, now=time.time(), **kwargs):
        # If zones is provided as a parameter, use that list.
        # If not, use what we have in this object
        zones = kwargs.get('zones', self._zones)
        keys_dir = kwargs.get('dir', self._context.get('keys_path', None))
        force = kwargs.get('force', False)

for zone in zones:
            collections = []
            policy = policies.policy(zone)
            keys_dir = keys_dir or policy.directory or '.'
            alg = policy.algorithm
            algnum = dnskey.algnum(alg)
            if 'ksk' not in kwargs or not kwargs['ksk']:
                if len(self._Z[zone][algnum]) == 0:
                    k = dnskey.generate(self._context['keygen_path'],
                                        self._context['randomdev'],
                                        keys_dir, zone, alg,
                                        policy.zsk_keysize, False,
                                        policy.keyttl or 3600,
                                        **kwargs)
                    self._Z[zone][algnum].append(k)
                collections.append(self._Z[zone])

if 'zsk' not in kwargs or not kwargs['zsk']:
                if len(self._K[zone][algnum]) == 0:
                    k = dnskey.generate(self._context['keygen_path'],
                                        self._context['randomdev'],
                                        keys_dir, zone, alg,
                                        policy.ksk_keysize, True,
                                        policy.keyttl or 3600,
                                        **kwargs)
                    self._K[zone][algnum].append(k)
                collections.append(self._K[zone])

for collection in collections:
                for algorithm, keys in collection.items():
                    if algorithm != algnum:
                        continue
                    try:
                        self.fixseries(keys, policy, now, **kwargs)
                    except Exception as e:
                        raise Exception('%s/%s: %s' %
                                        (zone, dnskey.algstr(algnum), str(e)))

📁 ＳＫＹＳＨＥＬＬ ＭＡＮＡＧＥＲ PHP v8.1.34

Edit: keyseries.py

📁 ＳＫＹＳＨＥＬＬＭＡＮＡＧＥＲ PHP v8.1.34