Skip to content
KitploitKITPLOIT
उपकरणब्लॉग
जमा करें
उपकरणब्लॉग
जमा करें

हैकिंग, पेनटेस्ट और साइबर सुरक्षा उपकरण आपके सुरक्षा शस्त्रागार के लिए!

Kitploit हैकिंग, साइबर सुरक्षा और पेंटेस्टिंग टूल्स की एक निर्देशिका है। कमजोरियों को खोजने, सिस्टम का विश्लेषण करने, परीक्षण को स्वचालित करने और अपनी सुरक्षा को मजबूत करने के लिए नवीनतम प्रोजेक्ट अपडेट खोजें।

··फ़ीड·संपर्क·गोपनीयता·© 2026 Kitploit

टूल निर्देशिका

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
CVE-2022-29464 — CVE-2022-29464 के लिए एक्सप्लॉइट, WSO2 सर्वर में एक बिना प्रमाणीकरण के मनमाना फ़ाइल अपलोड, जो दुर्भावनापूर्ण JSP अपलोड के माध्यम से रिमोट कोड निष्पादन सक्षम करता है। | Kitploit
उपकरण/GitHubGitHub/devengpk/cve-2022-29464
भेद्यता विश्लेषणशोषणवेब एप्लिकेशन शोषणपेनिट्रेशन टेस्टिंगरेड टीमिंगपेलोड डेवलपमेंट
GitHubdevengpk/cve-2022-29464

CVE-2022-29464

CVE-2022-29464 के लिए एक्सप्लॉइट, WSO2 सर्वर में एक बिना प्रमाणीकरण के मनमाना फ़ाइल अपलोड, जो दुर्भावनापूर्ण JSP अपलोड के माध्यम से रिमोट कोड निष्पादन सक्षम करता है।

रिपॉजिटरी देखें
13 साल पहलेअभी तक समीक्षित नहीं

सबसे लोकप्रिय

सभी देखें →

हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।

सभी उपकरण खोजें

हमारे उपकरणों का संग्रह ब्राउज़ करें

सभी उपकरण देखें →
साझा करें

WSO2 RCE (CVE-2022-29464) एक्सप्लॉइट और राइटअप।

विवरण

CVE-2022-29464 WSO2 में एक गंभीर खामी है। यह खामी एक अनधिकृत, बिना किसी प्रतिबंध के मनमाना फ़ाइल अपलोड है जो अनधिकृत उपयोगकर्ताओं को WSO2 सर्वर पर दुर्भावनापूर्ण JSP फ़ाइलें अपलोड करने और रिमोट कोड एक्ज़ीक्यूशन (RCE) प्राप्त करने में सक्षम बनाती है।

कमजोर अपलोड रूट /fileupload है, जिसे FileUploadServlet सर्वलेट द्वारा हैंडल किया जाता है। और यह IAM द्वारा असुरक्षित रूट है, जैसा कि हम indentity.xml कॉन्फ़िगरेशन फ़ाइल में देख सकते हैं:```xml

root@kitploit:~
'The handleSecurity ()' फ़ंक्शन WSO2 द्वारा प्रदान किए गए विभिन्न रूट्स की सुरक्षा के लिए ज़िम्मेदार है और प्राप्त HTTP अनुरोधों पर सुरक्षा जाँच करने के लिए एक तंत्र प्रदान करता है। 'handleSecurity()' 'CarbonUILoginUtil.handleLoginPageRequest()' को कॉल करेगा, और इसके रिटर्न मान के आधार पर, यह तय किया जाएगा कि अनुरोधित URI तक पहुँच प्रदान करनी है या अस्वीकार करनी है:```java
    public boolean handleSecurity(HttpServletRequest request, HttpServletResponse response)
            throws IOException {
	[snipped]
        if ((val = CarbonUILoginUtil.handleLoginPageRequest(requestedURI, request, response,
                authenticated, context, indexPageURL)) != CarbonUILoginUtil.CONTINUE) {
            if (val == CarbonUILoginUtil.RETURN_TRUE) {
                return true;
            } else {
                return false;
            }
        }
	[snipped]
    }

जब रूट /fileupload होता है, CarbonUILoginUtil.handleLoginPageRequest() CarbonUILoginUtil.RETURN_TRUE लौटाता है:```java protected static int handleLoginPageRequest(String requestedURI, HttpServletRequest request, HttpServletResponse response, boolean authenticated, String context, String indexPageURL) throws IOException { boolean isTryIt = requestedURI.indexOf("admin/jsp/WSRequestXSSproxy_ajaxprocessor.jsp") > -1; boolean isFileDownload = requestedURI.endsWith("/filedownload"); if ((requestedURI.indexOf("login.jsp") > -1 || requestedURI.indexOf("login_ajaxprocessor.jsp") > -1 || requestedURI.indexOf("admin/layout/template.jsp") > -1 || isFileDownload || requestedURI.endsWith("/fileupload") || requestedURI.indexOf("/fileupload/") > -1 || requestedURI.indexOf("login_action.jsp") > -1 || isTryIt || requestedURI.indexOf("tryit/JAXRSRequestXSSproxy_ajaxprocessor.jsp") > -1) && !requestedURI.contains(";")) {

root@kitploit:~
        if ((requestedURI.indexOf("login.jsp") > -1
                || requestedURI.indexOf("login_ajaxprocessor.jsp") > -1 || requestedURI
                .indexOf("login_action.jsp") > -1) && authenticated) {
            [snipped]
        } else if ((isTryIt || isFileDownload) && !authenticated) {
            [snipped]
        } else if (requestedURI.indexOf("login_action.jsp") > -1 && !authenticated) {
            [snipped]
        } else {
			if (log.isDebugEnabled()) {
				log.debug("Skipping security checks for " + requestedURI);
			}
            return RETURN_TRUE;
        }
    }

    return CONTINUE;
}
root@kitploit:~
जब `CarbonUILoginUtil.handleLoginPageRequest()` `CarbonUILoginUtil.RETURN_TRUE` लौटाता है, तो `handleSecurity()` `true` लौटाएगा और फिर बिना प्रमाणीकरण के `/fileupload` तक पहुंच प्रदान कर दी जाएगी।

`FileUploadServlet` सर्वलेट और [`init()`](https://github.com/wso2/carbon-kernel/blob/d47232dfb2b26c0ef18a74e2ef4aa503caa59697/core/org.wso2.carbon.ui/src/main/java/org/wso2/carbon/ui/transports/FileUploadServlet.java#L71) पर, विधि कॉलों की एक श्रृंखला के माध्यम से, अंततः `carbon.xml` कॉन्फ़िगरेशन फ़ाइल से कई अपलोड फ़ाइल प्रारूपों/क्रियाओं को उस ऑब्जेक्ट के साथ लोड करता है जो प्रत्येक प्रारूप को संभालता है।```java
    public void init(ServletConfig servletConfig) throws ServletException {
        this.servletConfig = servletConfig;
        try {
            fileUploadExecutorManager = new FileUploadExecutorManager(bundleContext, configContext, webContext);
            //Registering FileUploadExecutor Manager as an OSGi service
            bundleContext.registerService(FileUploadExecutorManager.class.getName(), fileUploadExecutorManager, null);
        } catch (CarbonException e) {
            log.error("Exception occurred while trying to initialize FileUploadServlet", e);
            throw new ServletException(e);
        }
    }

FileUploadExecutorManager क्लास का कंस्ट्रक्टर इस प्रकार है:```java public FileUploadExecutorManager(BundleContext bundleContext, ConfigurationContext configCtx, String webContext) throws CarbonException { this.bundleContext = bundleContext; this.configContext = configCtx; this.webContext = webContext; this.loadExecutorMap(); }

root@kitploit:~
कंस्ट्रक्टर निजी विधि [`loadExecutorMap()`](https://github.com/wso2/carbon-kernel/blob/d47232dfb2b26c0ef18a74e2ef4aa503caa59697/core/org.wso2.carbon.ui/src/main/java/org/wso2/carbon/ui/transports/fileupload/FileUploadExecutorManager.java#L131) को कॉल करता है, जहाँ कॉन्फ़िगरेशन लोडिंग की जाती है:```java
    private void loadExecutorMap() throws CarbonException {
        [snipped]
                try {
            documentElement = XMLUtils.toOM(serverConfiguration.getDocumentElement());
        } catch (Exception e) {
            String msg = "Unable to read Server Configuration.";
            log.error(msg);
            throw new CarbonException(msg, e);
        }
        [snipped]
        OMElement fileUploadConfigElement =
                documentElement.getFirstChildWithName(
                        new QName(ServerConstants.CARBON_SERVER_XML_NAMESPACE, "FileUploadConfig"));
        for (Iterator iterator = fileUploadConfigElement.getChildElements(); iterator.hasNext();) {
            OMElement mapppingElement = (OMElement) iterator.next();
            if (mapppingElement.getLocalName().equalsIgnoreCase("Mapping")) {
                OMElement actionsElement =
                        mapppingElement.getFirstChildWithName(
                                new QName(ServerConstants.CARBON_SERVER_XML_NAMESPACE, "Actions"));
                String confPath = System.getProperty(CarbonBaseConstants.CARBON_CONFIG_DIR_PATH);
        [snipped]

फ़ाइल अपलोड प्रारूप कॉन्फ़िगरेशन XML कॉन्फ़िगरेशन फ़ाइल में FileUploadConfig नेमस्पेस के भीतर है, यह डिफ़ॉल्ट कॉन्फ़िगरेशन है:```xml 100

root@kitploit:~
    <Mapping>
        <Actions>
            <Action>keystore</Action>
            <Action>certificate</Action>
            <Action>*</Action>
        </Actions>
        <Class>org.wso2.carbon.ui.transports.fileupload.AnyFileUploadExecutor</Class>
    </Mapping>

    <Mapping>
        <Actions>
            <Action>jarZip</Action>
        </Actions>
        <Class>org.wso2.carbon.ui.transports.fileupload.JarZipUploadExecutor</Class>
    </Mapping>
    <Mapping>
        <Actions>
            <Action>dbs</Action>
        </Actions>
        <Class>org.wso2.carbon.ui.transports.fileupload.DBSFileUploadExecutor</Class>
    </Mapping>
    <Mapping>
        <Actions>
            <Action>tools</Action>
        </Actions>
        <Class>org.wso2.carbon.ui.transports.fileupload.ToolsFileUploadExecutor</Class>
    </Mapping>
    <Mapping>
        <Actions>
            <Action>toolsAny</Action>
        </Actions>
        <Class>org.wso2.carbon.ui.transports.fileupload.ToolsAnyFileUploadExecutor</Class>
    </Mapping>
</FileUploadConfig>
root@kitploit:~
`loadExecutorMap()` विधि कॉन्फ़िग फ़ाइल से निकाले गए Actions और Classes के साथ `<Action, Class>` का एक `HashMap` बनाती और भरती है। जिसका उपयोग बाद में यह चुनने के लिए किया जाएगा कि किसी दिए गए प्रारूप/क्रिया को ठीक से संभालने के लिए किस क्लास का उपयोग किया जाए।

बाद में जब `/fileupload` रूट पर POST अनुरोध प्राप्त होता है, तो सर्वलेट की [`doPost()`](https://github.com/wso2/carbon-kernel/blob/d47232dfb2b26c0ef18a74e2ef4aa503caa59697/core/org.wso2.carbon.ui/src/main/java/org/wso2/carbon/ui/transports/FileUploadServlet.java#L53) विधि को कॉल किया जाएगा। यह विधि केवल अनुरोध और प्रतिक्रिया ऑब्जेक्ट को `fileUploadExecutorManager` की `execute()` विधि को अग्रेषित करती है, जिसे `init()` पर प्रारंभ किया गया था।```java
    protected void doPost(HttpServletRequest request,
                          HttpServletResponse response) throws ServletException, IOException {

        try {
            fileUploadExecutorManager.execute(request, response);
        } catch (Exception e) {
            String msg = "File upload failed ";
            log.error(msg, e);
            throw new ServletException(e);
        }
    }

the execute() विधि, अनुरोध URL को fileupload/ स्ट्रिंग के ठीक बाद विभाजित करती है, जिसका अर्थ है कि यह अनुरोध URL में /fileupload/ के बाद जो कुछ भी है उसे निकालती है और उसे actionString को सौंप देती है।```java public boolean execute(HttpServletRequest request, HttpServletResponse response) throws IOException {

root@kitploit:~
    HttpSession session = request.getSession();
    String cookie = (String) session.getAttribute(ServerConstants.ADMIN_SERVICE_COOKIE);
    request.setAttribute(CarbonConstants.ADMIN_SERVICE_COOKIE, cookie);
    request.setAttribute(CarbonConstants.WEB_CONTEXT, webContext);
    request.setAttribute(CarbonConstants.SERVER_URL,
                         CarbonUIUtil.getServerURL(request.getSession().getServletContext(),
                                                   request.getSession()));


    String requestURI = request.getRequestURI();

    //TODO - fileupload is hardcoded
    int indexToSplit = requestURI.indexOf("fileupload/") + "fileupload/".length();
    String actionString = requestURI.substring(indexToSplit);

    // Register execution handlers
    FileUploadExecutionHandlerManager execHandlerManager =
            new FileUploadExecutionHandlerManager();
    CarbonXmlFileUploadExecHandler carbonXmlExecHandler =
            new CarbonXmlFileUploadExecHandler(request, response, actionString);
    execHandlerManager.addExecHandler(carbonXmlExecHandler);
    OSGiFileUploadExecHandler osgiExecHandler =
            new OSGiFileUploadExecHandler(request, response);
    execHandlerManager.addExecHandler(osgiExecHandler);
    AnyFileUploadExecHandler anyFileExecHandler =
            new AnyFileUploadExecHandler(request, response);
    execHandlerManager.addExecHandler(anyFileExecHandler);
    execHandlerManager.startExec();
    return true;
}
root@kitploit:~
`actionString` को `request` और `response` के साथ `CarbonXmlFileUploadExecHandler` क्लास कंस्ट्रक्टर को पास किया जाता है:```java
        private CarbonXmlFileUploadExecHandler(HttpServletRequest request,
                                               HttpServletResponse response,
                                               String actionString) {
            this.request = request;
            this.response = response;
            this.actionString = actionString;
        }

कंस्ट्रक्टर उन्हें अपनी प्रॉपर्टीज़ में सहेज लेगा।

उसके बाद carbonXmlExecHandler ऑब्जेक्ट को अन्य ऑब्जेक्ट्स के साथ execHandlerManager में addExecHandler() विधि का उपयोग करके जोड़ा जाएगा।```java public void addExecHandler(FileUploadExecutionHandler handler) { if (prevHandler != null) { prevHandler.setNext(handler); } else { firstHandler = handler; } prevHandler = handler; }

root@kitploit:~
फिर `execHandlerManager.startExec()` कहा जाता है:```java
        public void startExec() throws IOException {
            firstHandler.execute();
        }

startExec() पहले जोड़े गए ऑब्जेक्ट के execute() को कॉल करता है जो CarbonXmlFileUploadExecHandler है:```java public void execute() throws IOException { boolean foundExecutor = false; for (String key : executorMap.keySet()) { if (key.equals(actionString)) { AbstractFileUploadExecutor obj = executorMap.get(key); foundExecutor = true; obj.executeGeneric(request, response, configContext); break; } } if (!foundExecutor) { next(); } }

root@kitploit:~
[`execute()`](https://github.com/wso2/carbon-kernel/blob/d47232dfb2b26c0ef18a74e2ef4aa503caa59697/core/org.wso2.carbon.ui/src/main/java/org/wso2/carbon/ui/transports/fileupload/FileUploadExecutorManager.java#L430) पहले बनाए गए `<Action, Class>` के `HashMap` में लूप करता है और उस Action (key) को खोजता है जो `actionString` के बराबर है; यदि मिल जाए, तो उस Action से जुड़े ऑब्जेक्ट का `executeGeneric()` मेथड कॉल किया जाएगा।

डिफ़ॉल्ट कॉन्फ़िगरेशन को संशोधित करने के लिए 7 एक्शन होते हैं, जो इस प्रकार हैं:
* `keystore`, `certificate`, `*` को `org.wso2.carbon.ui.transports.fileupload.AnyFileUploadExecutor` द्वारा संभाला जाता है।
* `jarZip` को `org.wso2.carbon.ui.transports.fileupload.JarZipUploadExecutor` द्वारा संभाला जाता है।
* `dbs` को `org.wso2.carbon.ui.transports.fileupload.DBSFileUploadExecutor` द्वारा संभाला जाता है।
* `tools` को `org.wso2.carbon.ui.transports.fileupload.ToolsFileUploadExecutor` द्वारा संभाला जाता है।
* `toolsAny` को `org.wso2.carbon.ui.transports.fileupload.ToolsAnyFileUploadExecutor` द्वारा संभाला जाता है।

इनमें से प्रत्येक ऑब्जेक्ट अपलोड को अलग तरीके से संभालता है; उनमें से कुछ विशिष्ट एक्सटेंशन स्वीकार करते हैं।

पहला जो मुझे arbitrary file write के प्रति संवेदनशील मिला, वह `toolsAny` था ([`ToolsAnyFileUploadExecutor`](https://github.com/wso2/carbon-kernel/blob/4.4.x/core/org.wso2.carbon.ui/src/main/java/org/wso2/carbon/ui/transports/fileupload/ToolsAnyFileUploadExecutor.java))।

`ToolsAnyFileUploadExecutor` में `executeGeneric()` मेथड नहीं है, लेकिन यह [`AbstractFileUploadExecutor`](https://github.com/wso2/carbon-kernel/blob/d47232dfb2b26c0ef18a74e2ef4aa503caa59697/core/org.wso2.carbon.ui/src/main/java/org/wso2/carbon/ui/transports/fileupload/AbstractFileUploadExecutor.java#L61) को एक्सटेंड करता है, जिसमें [`executeGeneric()`](https://github.com/wso2/carbon-kernel/blob/d47232dfb2b26c0ef18a74e2ef4aa503caa59697/core/org.wso2.carbon.ui/src/main/java/org/wso2/carbon/ui/transports/fileupload/AbstractFileUploadExecutor.java#L97) मेथड मौजूद है:```java
    boolean executeGeneric(HttpServletRequest request,
                           HttpServletResponse response,
                           ConfigurationContext configurationContext) throws IOException {//,
        //    CarbonException {
        this.configurationContext = configurationContext;
        try {
            parseRequest(request);
            return execute(request, response);
        } catch (FileUploadFailedException e) {
            sendErrorRedirect(request, response, e);
        } catch (FileSizeLimitExceededException e) {
            sendErrorRedirect(request, response, e);
        } catch (CarbonException e) {
            sendErrorRedirect(request, response, e);
        }
        return false;
    }

executeGeneric() सबसे पहले parseRequest() को कॉल करता है, जिसमें request ऑब्जेक्ट को पैरामीटर के रूप में पास किया जाता है:```java protected void parseRequest(HttpServletRequest request) throws FileUploadFailedException, FileSizeLimitExceededException { fileItemsMap.set(new HashMap<String, ArrayList>()); formFieldsMap.set(new HashMap<String, ArrayList>());

root@kitploit:~
    ServletRequestContext servletRequestContext = new ServletRequestContext(request);
    boolean isMultipart = ServletFileUpload.isMultipartContent(servletRequestContext);
    Long totalFileSize = 0L;

    if (isMultipart) {

        List items;
        try {
            items = parseRequest(servletRequestContext);
        } catch (FileUploadException e) {
            String msg = "File upload failed";
            log.error(msg, e);
            throw new FileUploadFailedException(msg, e);
        }
        boolean multiItems = false;
        if (items.size() > 1) {
            multiItems = true;
        }

        // Add the uploaded items to the corresponding maps.
        for (Iterator iter = items.iterator(); iter.hasNext();) {
            FileItem item = (FileItem) iter.next();
            String fieldName = item.getFieldName().trim();
            if (item.isFormField()) {
                if (formFieldsMap.get().get(fieldName) == null) {
                    formFieldsMap.get().put(fieldName, new ArrayList<String>());
                }
                try {
                    formFieldsMap.get().get(fieldName).add(new String(item.get(), "UTF-8"));
                } catch (UnsupportedEncodingException ignore) {
                }
            } else {
                String fileName = item.getName();
                if ((fileName == null || fileName.length() == 0) && multiItems) {
                    continue;
                }
                if (fileItemsMap.get().get(fieldName) == null) {
                    fileItemsMap.get().put(fieldName, new ArrayList<FileItemData>());
                }
                totalFileSize += item.getSize();
                if (totalFileSize < totalFileUploadSizeLimit) {
                    fileItemsMap.get().get(fieldName).add(new FileItemData(item));
                } else {
                    throw new FileSizeLimitExceededException(getFileSizeLimit() / 1024 / 1024);
                }
            }
        }
    }
}
root@kitploit:~
यह पहले सुनिश्चित करता है कि POST अनुरोध एक multipart POST अनुरोध है, और फिर अपलोड की गई फ़ाइलों को निकालता है, यह सुनिश्चित करता है कि POST अनुरोध में कम से कम एक अपलोड की गई फ़ाइल शामिल है और अधिकतम फ़ाइल आकार के विरुद्ध इसका सत्यापन करता है।

`parseRequest()` से लौटने के बाद, `executeGeneric()` अब `execute()` विधि को कॉल करेगा, जिसे `ToolsAnyFileUploadExecutor` द्वारा [override](https://github.com/wso2/carbon-kernel/blob/d47232dfb2b26c0ef18a74e2ef4aa503caa59697/core/org.wso2.carbon.ui/src/main/java/org/wso2/carbon/ui/transports/fileupload/ToolsAnyFileUploadExecutor.java#L36) किया गया है:```java
	@Override
	public boolean execute(HttpServletRequest request,
			HttpServletResponse response) throws CarbonException, IOException {
		PrintWriter out = response.getWriter();
        try {
        	Map fileResourceMap =
                (Map) configurationContext
                        .getProperty(ServerConstants.FILE_RESOURCE_MAP);
        	if (fileResourceMap == null) {
        		fileResourceMap = new TreeBidiMap();
        		configurationContext.setProperty(ServerConstants.FILE_RESOURCE_MAP,
                                             fileResourceMap);
        	}
            List<FileItemData> fileItems = getAllFileItems();
            //String filePaths = "";

            for (FileItemData fileItem : fileItems) {
                String uuid = String.valueOf(
                        System.currentTimeMillis() + Math.random());
                String serviceUploadDir =
                        configurationContext
                                .getProperty(ServerConstants.WORK_DIR) +
                                File.separator +
                                "extra" + File
                                .separator +
                                uuid + File.separator;
                File dir = new File(serviceUploadDir);
                if (!dir.exists()) {
                    dir.mkdirs();
                }
                File uploadedFile = new File(dir, fileItem.getFileItem().getFieldName());
                try (FileOutputStream fileOutStream = new FileOutputStream(uploadedFile)) {
                    fileItem.getDataHandler().writeTo(fileOutStream);
                    fileOutStream.flush();
                }
                response.setContentType("text/plain; charset=utf-8");
                //filePaths = filePaths + uploadedFile.getAbsolutePath() + ",";
                fileResourceMap.put(uuid, uploadedFile.getAbsolutePath());
                out.write(uuid);
            }
            //filePaths = filePaths.substring(0, filePaths.length() - 1);
            //out.write(filePaths);
            out.flush();
        } catch (Exception e) {
            log.error("File upload FAILED", e);
            out.write("<script type=\"text/javascript\">" +
                    "top.wso2.wsf.Util.alertWarning('File upload FAILED. File may be non-existent or invalid.');" +
                    "</script>");
        } finally {
            out.close();
        }
        return true;
	}

यहीं बग है, execute() विधि पाथ ट्रैवर्सल भेद्यता के प्रति संवेदनशील है क्योंकि यह POST अनुरोध में उपयोगकर्ता द्वारा दिए गए फ़ाइलनाम पर भरोसा करती है। पाथ ट्रैवर्सल के tmp निर्देशिका से बाहर निकले बिना फ़ाइल वास्तव में यहाँ सहेजी जाती है:``` ./tmp/work/extra/$uuid/$filename

root@kitploit:~
with `uuid` being returned in the response:

![image](https://assets.kitploit.com/production/public/readmes/24643/46ab2e31428a23ca42c93423c5c2a7508cb72c7e508d0a7e5405a35c27a4f619.png)

the file can be found in:

![image](https://assets.kitploit.com/production/public/readmes/24643/49f94872497ef3ce08545f18bf26a84e60729c3ad0faef81819d2af8adf44f1d.png)

Now we just need to escape the `tmp` directory and add our JSP shell to some location being served by the WSO2.

lets find the tomcat `appBase` directory:

![image](https://assets.kitploit.com/production/public/readmes/24643/3e23eb3dd832cc9284d45d0a0339a5bf7ba1ec1bf2f26eaae67f23869488d04b.png)

this directory is the location of the applications that are deployed on tomcat, it contains multiple already deployed WAR applications and also thier raw WAR files:```
./repository/deployment/server/webapps

image

उन अनुप्रयोगों में से एक authenticationendpoint (//host/authenticationendpoint) है, जो WSO2 के लिए प्रमाणीकरण संभालता है और इसका स्थान है:``` ./repository/deployment/server/webapps/authenticationendpoint

root@kitploit:~
![image](https://assets.kitploit.com/production/public/readmes/24643/bef03f1fdec5ff102076e81cf806e914bc733cadf836d8eb2fe7f80261ea70d7.png)

**नोट:** हम इस कमजोरी का उपयोग `appBase` निर्देशिका में अपनी खुद की नई निर्देशिका (कॉन्टेक्स्ट पाथ) बनाने के लिए भी कर सकते हैं और यह स्वतः तैनात हो जाएगी, लेकिन मैं बस एक ले लूँगा और `authenticationendpoint` का उपयोग करूँगा।
# PoC
* Burpsuite का उपयोग करके:

![image](https://assets.kitploit.com/production/public/readmes/24643/f18951e9acbdfdbd282f6c83037d849069b2225774598bd70d1a135ff83bdc1c.png)

![image](https://assets.kitploit.com/production/public/readmes/24643/b513180803a0562bebfc66ea9dca8572ea6f9f8bc63a898c4e32cb811b0c2ebc.png)

![image](https://assets.kitploit.com/production/public/readmes/24643/0d02bf7c174a316d5acbdc73c245cefc1a9ee00d54887a3306f6a897708474f5.png)

* exploiy.py का उपयोग करके:

> उपयोग: 
> ```
> python3 exploit.py https://host:9443/ ArbitraryShellName.jsp
> ```
![poc](https://assets.kitploit.com/production/public/readmes/24643/01a463e5871c7a232eca86d8d7afafecfc687621989f4033c7204965fb933a47.gif)
टूल डाउनलोड करें