Showing posts with label EBS R12. Show all posts
Showing posts with label EBS R12. Show all posts

Tuesday, May 19, 2026

CVE-2025-61882 — what the EBS zero-day exploit means for your patching strategy

CVE-2025-61882 — What the Oracle EBS Zero-Day Means for Your Patching Strategy | punitoracledba

CVE-2025-61882 — What the Oracle EBS Zero-Day Means for Your Patching Strategy

Every EBS DBA knows that CPU patching is important. Most treat it as routine maintenance — something to schedule, plan, execute, and document. CVE-2025-61882 changed that conversation permanently.

In August 2025, the Cl0p ransomware group began silently exploiting a zero-day vulnerability in Oracle E-Business Suite. For weeks, they moved through unpatched EBS environments, exfiltrating payroll files, vendor contracts, and financial transaction data — without triggering a single alert. By the time Oracle published an emergency patch on October 4, 2025, many organizations had already lost significant data and received extortion demands.

This post covers what CVE-2025-61882 was, how the attack worked, what the April 2026 CPU addresses in its aftermath, and — most importantly — what it means for how you manage EBS patching going forward.

What Is CVE-2025-61882

CVE-2025-61882 is a critical unauthenticated remote code execution (RCE) vulnerability in Oracle E-Business Suite. It carries a CVSS base score of 9.8 out of 10 — the highest severity rating in practice.

Detail Value
CVE ID CVE-2025-61882
CVSS Base Score 9.8 Critical
Attack Vector Network — remotely exploitable via HTTP
Authentication Required None — pre-authentication, no credentials needed
Component Affected Oracle Concurrent Processing — BI Publisher Integration, UiServlet
Versions Affected Oracle EBS 12.2.3 through 12.2.14
Impact Full remote code execution — complete system compromise
Patch Released October 4, 2025 — out-of-band emergency patch
Added to CISA KEV October 6, 2025 — confirmed ransomware use

The vulnerability is not a single flaw. According to WatchTowr, the exploit chain involves five separate bugs to achieve pre-authentication remote code execution, including some that were patched by Oracle in its July 2025 Critical Patch Update. This means organizations that were behind on their quarterly CPU patching were exposed to components of this exploit chain months before the zero-day was even disclosed.

How the Attack Worked — The Five-Stage Exploit Chain

CVE-2025-61882 is a chained exploit — five separate vulnerabilities combined in sequence to achieve full remote code execution. Understanding the chain helps you understand why patching every quarterly CPU matters, not just the most recent one.

Stage 1 — Server-Side Request Forgery via UiServlet

The attack begins by exploiting a Server-Side Request Forgery (SSRF) vulnerability in the UiServlet component. By sending a specially crafted XML document through the getUiType parameter, an attacker can coerce the backend server into making arbitrary HTTP requests. No authentication is required for this initial step.

Stage 2 — Internal service access via port 7201

The exploit specifically targets an internal HTTP service running on port 7201, which is the core Oracle EBS application server. This technique allows reaching internal services that would otherwise be protected from direct internet access, significantly expanding the attack surface.

Stage 3 — Authentication bypass via path traversal

With access to the internal service, the attacker bypasses authentication filters using a classic path traversal technique with the /help/ prefix. The /help/ endpoint is publicly accessible and does not require authentication. By combining it with path traversal sequences, the filter logic fails to enforce authentication requirements.

Stage 4 — Malicious template upload via BI Publisher

To achieve code execution, the adversary targeted Oracle's XML Publisher Template Manager by issuing GET and POST requests to /OA_HTML/RF.jsp and /OA_HTML/OA.jsp to upload and execute a malicious XSLT template.

Stage 5 — Remote code execution and persistence

Web shells are invoked via filter chains in EBS endpoints, allowing attackers to execute commands in memory without leaving obvious traces on disk. Outbound HTTPS and TCP connections from Oracle Java processes to attacker-controlled infrastructure were used to fetch loaders and backdoors.

The sophistication of this chain is significant. It requires deep knowledge of EBS internals — the servlet architecture, BI Publisher integration, and internal port layout. This was not opportunistic scanning by script kiddies. It was targeted research by a well-resourced threat actor over months before exploitation began.

Timeline of the CVE-2025-61882 Campaign

July 10, 2025 Suspicious activity targeting EBS customer environments begins — approximately three months before the vulnerability is publicly disclosed. Cl0p was already inside environments at this stage.
August 9, 2025 The first confirmed exploitation occurs on August 9, 2025. Cl0p begins actively exploiting the zero-day in the wild. Throughout August, they quietly gain access to vulnerable EBS servers and harvest sensitive data without detection.
Late September 2025 After weeks of data theft, affected organizations begin receiving Cl0p extortion emails. The emails are sent to company executives, claiming the actor had breached their Oracle EBS application and exfiltrated documents — providing legitimate file listings from victim environments as proof.
October 2, 2025 Google Threat Intelligence Group and Mandiant publish their analysis of the campaign. CrowdStrike publishes independently. The scale of the exploitation becomes publicly known. Pressure mounts on Oracle to respond.
October 4, 2025 Oracle releases an emergency out-of-band patch for CVE-2025-61882 — outside the usual quarterly CPU schedule. The advisory confirms CVSS 9.8, pre-auth RCE, and includes Indicators of Compromise from observed exploitation.
October 6, 2025 CVE-2025-61882 is added to the US Cybersecurity and Infrastructure Security Agency (CISA) Known Exploited Vulnerabilities list, confirming its use in a ransomware campaign.
October 7–9, 2025 Exploit code for CVE-2025-61882 surfaces on public forums via a Telegram channel. Security researchers confirm the PoC can reliably compromise unpatched systems, turning the zero-day into a one-day exploit accessible to any threat actor — not just Cl0p.
April 21, 2026 Oracle releases the April 2026 CPU — the first regular quarterly CPU after the CVE-2025-61882 incident. It includes 18 new security patches for EBS with a highest CVSS score of 9.8. Security researchers note elevated attacker interest in EBS remains.

What Data Was Taken and Who Was at Risk

The fallout from the campaign was extensive. Cl0p gained access to sensitive ERP data such as payroll files, vendor contracts, and financial transactions. Oracle EBS is the financial and operational backbone of many large organizations. When it is compromised, the attacker has access to everything that runs through it.

Any organization that had Oracle E-Business Suite exposed to the internet was at risk. Given that mass exploitation attempts had been ongoing for more than a month before public disclosure, organizations faced a real possibility that the vulnerability had already been exploited before they were aware of it.

The affected versions were Oracle EBS 12.2.3 through 12.2.14 — which covers virtually every organization running EBS R12.2.

If your EBS is internet-facing and was not fully patched through the July 2025 CPU before October 2025, you were exposed for the duration of the campaign. If you have not already done so, conduct a threat hunting exercise using the IOCs published by Oracle and Mandiant to determine if your environment was accessed.

What the April 2026 CPU Addresses in This Context

The April 2026 CPU is the first regular quarterly CPU released after CVE-2025-61882. It is not a direct fix for that specific vulnerability — that was the October 2025 emergency patch. However, the April 2026 CPU matters significantly in the post-CVE-2025-61882 landscape for several reasons.

18 new security patches for EBS

The April 2026 CPU includes 18 new security patches for Oracle EBS, with 8 remotely exploitable and the highest CVSS score at 9.8. Given that the CVE-2025-61882 exploit chain incorporated vulnerabilities from previous CPUs that organizations had not applied, every patch in the April 2026 CPU must be treated as a potential component of a future exploit chain — not as an optional update.

Attacker interest in EBS remains elevated

GTIG assesses that Cl0p-affiliated actors almost certainly perceive mass exploitation campaigns as successful, given that they have employed this approach since at least late 2020 and will continue to dedicate resources to acquiring zero-day exploits for similar applications for at least the near term. EBS is now a confirmed high-value target. That does not go away after one patch.

Proof-of-concept code is publicly available

The CVE-2025-61882 proof-of-concept exploit code is publicly available on underground forums. Any organization still running an unpatched EBS instance — whether the October 2025 emergency patch was missed, or earlier CPUs were skipped — is now trivially exploitable. The April 2026 CPU must be applied on top of a fully patched baseline, not a partially patched one.

Indicators of Compromise — What to Look For

If you have not yet checked your environment for signs of compromise from the CVE-2025-61882 campaign, do so before applying the April 2026 CPU. Patching over an already-compromised environment does not remove a backdoor that is already installed.

Suspicious HTTP endpoints to monitor in logs

Suspicious URL patterns — search access logs for these
# Search your EBS web tier and OHS access logs for these patterns
# Any hits on these endpoints warrant immediate investigation

grep -i "UiServlet" /u01/oracle/R122/fs1/FMW_Home/webtier/instances/*/diagnostics/logs/OHS/*/access_log*
grep -i "SyncServlet" /u01/oracle/R122/fs1/FMW_Home/webtier/instances/*/diagnostics/logs/OHS/*/access_log*
grep -i "help/\.\." /u01/oracle/R122/fs1/FMW_Home/webtier/instances/*/diagnostics/logs/OHS/*/access_log*
grep -i "ieshostedsurvey" /u01/oracle/R122/fs1/FMW_Home/webtier/instances/*/diagnostics/logs/OHS/*/access_log*
grep -i "RF\.jsp" /u01/oracle/R122/fs1/FMW_Home/webtier/instances/*/diagnostics/logs/OHS/*/access_log*

Suspicious database activity

Check for unusual BI Publisher templates — run as APPS sqlplus apps/<apps_password> <<EOF -- Check for unusual or recently added XDO templates -- External URLs or unknown XSLT payloads are suspicious SELECT template_code, template_name, default_output_type, last_update_date, last_updated_by FROM xdo_templates_vl WHERE last_update_date > TO_DATE('2025-07-01','YYYY-MM-DD') ORDER BY last_update_date DESC; -- Check for unexpected administrative accounts created recently SELECT user_name, start_date, end_date, last_logon_date, created_by FROM fnd_user WHERE start_date > TO_DATE('2025-07-01','YYYY-MM-DD') ORDER BY start_date DESC; EOF

Other indicators to check

  • Unexpected Java files on the application server — particularly files with names like Log4jConfigQpgsubFilter.java or other unusual Java class files
  • Outbound HTTPS or TCP connections from Oracle Java processes to unknown external IP addresses — check firewall logs for the period July to October 2025
  • Unusual activity in /OA_HTML/ directories — unexpected JSP or class files added outside of patch cycles
  • Extortion emails received by your executives referencing EBS data — if received, treat the environment as compromised and engage incident response immediately

What CVE-2025-61882 Means for Your Patching Strategy

The CVE-2025-61882 incident forced a reckoning that many EBS teams needed. The comfortable assumption that EBS patching can be deferred, deprioritised, or spread across many months is no longer defensible. Here is what this incident means for how you manage patching going forward.

1. Missing one CPU creates compounding risk

The CVE-2025-61882 exploit chain incorporated vulnerabilities that were already patched in the July 2025 CPU. Organizations that had applied the July 2025 CPU reduced their exposure to components of the exploit chain. Organizations that had not applied it were fully exposed. Each missed CPU is not just one missed quarter — it is a cumulative increase in attack surface that compounds with each passing month.

2. Internet-facing EBS requires an accelerated patching SLA

If your EBS environment is accessible from the internet — whether directly or via a DMZ — the standard quarterly patching timeline is no longer adequate on its own. You need a defined SLA for how quickly you apply security patches after release. For internet-facing EBS, the target should be within 30 days of the CPU release. For critical out-of-band patches like the October 2025 emergency fix, the target should be days, not weeks.

3. Out-of-band patches cannot wait for the next quarterly window

Oracle released the emergency patch on October 4 for CVE-2025-61882. GTIG and Mandiant recommend applying Oracle EBS patches released on October 4, 2025 immediately as the highest priority action. Many organizations that held the emergency patch for their next scheduled maintenance window allowed weeks of additional exposure. Out-of-band patches with CVSS scores above 9.0 must bypass the normal change calendar.

4. Your July 2025 CPU status was your first line of defence

This is the most critical lesson. The exploit chain used bugs that Oracle had already patched in July 2025. Organizations fully patched through July 2025 had significantly reduced exposure compared to those running older patch levels. Being current on quarterly CPUs is not just compliance — it is your primary defence against the next zero-day exploit chain.

5. Threat hunting after a public campaign is not optional

The timeline shows that Cl0p was inside EBS environments for six to eight weeks before public disclosure. If your environment was internet-facing and unpatched, and you have not yet conducted a threat hunting exercise, do it now. Applying the April 2026 CPU does not remove a backdoor already installed. Patching and incident response are separate activities.

Hardening Recommendations Beyond Patching

The April 2026 CPU and the October 2025 emergency patch address the known vulnerabilities. These additional measures reduce the attack surface for vulnerabilities that have not yet been disclosed.

Recommendation Why It Matters
Restrict internet exposure of EBS Place EBS behind a WAF, reverse proxy, or VPN. CVE-2025-61882 required network access via HTTP — limiting who can reach EBS at all reduces the attack surface for all future vulnerabilities
Enforce MFA on all EBS login paths In cases where an organization reacts, Cl0p sometimes falls back to secondary access paths — using local EBS login endpoints that bypass SSO and do not enforce MFA, creating a survival route. Close these paths
Monitor access logs for suspicious URL patterns The IOCs published by Oracle and Mandiant include specific URL patterns. Set up alerting on these. Early detection limits the dwell time attackers have before discovery
Restrict outbound connections from EBS servers The CVE-2025-61882 exploit required outbound connections from EBS Java processes to attacker servers. Egress filtering from application servers limits the ability to establish command-and-control channels
Apply AD_PATCH.IS_PATCH_APPLIED checks after every CPU Confirm that every patch listed in ECPUC is genuinely applied — not just attempted. Verify using the function rather than AD_BUGS alone
Keep OPatch and Java homes current The exploit chain used Java-level vulnerabilities. EJCPUC identifies missing Java CPU patches. Keep every Java home current every quarter

The New Standard for EBS Patching After CVE-2025-61882

Before October 2025 it was possible to treat EBS CPU patching as a routine operational task with flexible timelines. That position is no longer defensible to management, auditors, or — if a breach occurs — legal teams. The standard that the CVE-2025-61882 incident has established is this:

  • Quarterly CPUs — applied within 30 to 60 days of release for all environments, within 30 days for internet-facing environments
  • Out-of-band emergency patches with CVSS 9.0 or above — applied within 7 days for internet-facing environments, within 14 days for internal-only environments
  • ECPUC and EJCPUC — run before and after every CPU cycle to confirm zero remaining recommended patches
  • Threat hunting — conducted within 30 days of any public EBS security campaign using published IOCs
  • Patch status reporting — current CPU level documented and reported to management quarterly

If your organization is struggling to justify the resources for quarterly EBS patching, the CVE-2025-61882 campaign provides the argument. The cost of applying the July 2025 CPU on schedule was a maintenance window. The cost of not applying it was potentially six to eight weeks of undetected attacker access to payroll files, vendor contracts, and financial data.

Summary

  • CVE-2025-61882 is a CVSS 9.8 pre-authentication RCE vulnerability in Oracle EBS Concurrent Processing — exploited by Cl0p as a zero-day from August 2025, patched by Oracle on October 4, 2025
  • The exploit chain chains five vulnerabilities — including some already patched in the July 2025 CPU — meaning organizations current on quarterly CPUs had reduced exposure
  • Cl0p operated silently inside EBS environments for six to eight weeks before public disclosure, exfiltrating ERP data including payroll and financial records
  • The April 2026 CPU includes 18 new EBS security patches — each one a potential component of a future exploit chain if left unpatched
  • Internet-facing EBS environments require an accelerated patching SLA — emergency patches with CVSS 9.0 or above cannot wait for the next quarterly window
  • Patching does not replace threat hunting — if your environment was exposed during the campaign period, investigate using published IOCs before assuming you are clean
  • The hardening measures — WAF, MFA enforcement, egress filtering, log monitoring — reduce attack surface for vulnerabilities not yet disclosed

OPatch vs ADOP — which patches use which tool in EBS R12.2

OPatch vs ADOP — Which Patches Use Which Tool in Oracle EBS R12.2 | punitoracledba

OPatch vs ADOP — Which Patches Use Which Tool in Oracle EBS R12.2

One of the most common questions from DBAs who are new to Oracle EBS R12.2 — and one that comes up regularly in interviews — is this: when do I use OPatch and when do I use ADOP?

The answer is straightforward once you understand that an EBS R12.2 environment is not a single layer. It has three distinct tiers — the database tier, the Fusion Middleware and WebLogic tier, and the EBS application tier — and each tier has its own patching tool. Using the wrong tool on the wrong tier does not just fail — it can leave your environment in an inconsistent state.

This post maps every patch type to the correct tool, explains why each tool is used where it is, provides the exact commands for each, and gives you a decision tree you can refer to during any patching session.

One rule to remember before reading further: adpatch is not used on R12.2. It was the patching tool for R12.1 and earlier. On R12.2, EBS application tier patches always use ADOP. This is non-negotiable — adpatch does not understand the dual-filesystem architecture of R12.2.

The Two Patching Tools — What They Are

OPatch

OPatch is Oracle's universal patching utility for Oracle software installations. It patches Oracle homes — the database home, the Oracle Fusion Middleware homes, and WebLogic homes. It works by modifying files inside a specific $ORACLE_HOME directory. OPatch knows nothing about EBS editions, dual filesystems, or ADOP sessions. It simply modifies the files in the Oracle home you point it to.

ADOP

ADOP — AD Online Patching — is the EBS-specific patching utility for the application tier. It understands the dual-filesystem architecture, the database edition model, and the five-phase patching cycle. It manages the entire online patching process from prepare through cleanup. ADOP is only used for EBS application tier patches — not for database or FMW patches.

Tool What It Patches Aware of EBS Editions Requires Services Down
OPatch Oracle homes — DB, FMW, WebLogic, OHS, Forms, Reports No Usually yes — DB must be shut down for DB patches
ADOP EBS application tier — PL/SQL, Forms, Reports, Java, seed data Yes — uses patch edition and dual filesystem No — except for brief cutover window

Which Patch Type Uses Which Tool

Patch Type Tool OS User Services During Apply
Oracle Database CPU (DB home) OPatch oracle DB must be shut down
Oracle JVM / OJVM patch (inside DB) OPatch + datapatch oracle DB shut down for OPatch, then DB up for datapatch
Oracle WebLogic Server (WLS) OPatch applmgr WebLogic Admin and Managed Servers must be down
Oracle Fusion Middleware (FMW) OPatch applmgr FMW services must be down
Oracle HTTP Server (OHS / Web Tier) OPatch applmgr OHS must be down
Oracle Forms and Reports home OPatch applmgr Forms and Reports services must be down
EBS Application Tier (CPU, one-off, RUP) ADOP applmgr Services stay up — brief cutover only
EBS NLS / Language patches ADOP applmgr Services stay up — brief cutover only
EBS AD and TXK codelevel patches ADOP applmgr Services stay up — brief cutover only
Java CPU patches (JDK in FMW homes) OPatch applmgr FMW services must be down for each Java home

Important for CPU patching: A full quarterly CPU cycle in EBS R12.2 uses both tools. OPatch is applied first to the DB home and all FMW homes. ADOP is applied after to the EBS application tier. Both are required — neither replaces the other.

Decision Tree — Which Tool to Use

Use this decision tree every time you have a patch to apply. Start at the top and follow the questions down.

Is this an EBS application tier patch? (one-off, CPU app tier, RUP, NLS, AD/TXK) | YES ────────────────────────> Use ADOP | adop phase=apply patches=<number> | NO | v Is this a Database home patch? (DB CPU, OJVM, PSU, one-off DB fix) | YES ────────────────────────> Use OPatch on $ORACLE_HOME (DB) | Shut down DB first | Run datapatch after for OJVM patches NO | v Is this a WebLogic Server patch? | YES ────────────────────────> Use OPatch on $WLS_ORACLE_HOME | Stop Admin and Managed Servers first | NO | v Is this an Oracle HTTP Server or Web Tier (OHS) patch? | YES ────────────────────────> Use OPatch on $OHS_ORACLE_HOME | Stop OHS first | NO | v Is this a Java / JDK CPU patch for an FMW Java home? | YES ────────────────────────> Use OPatch on each Java home | Run EJCPUC first to identify homes | NO | v Is this a Forms or Reports home patch? | YES ────────────────────────> Use OPatch on $FORMS_ORACLE_HOME Stop Forms and Reports services first

OPatch — Commands by Component

Database tier — DB CPU patch

Apply DB CPU using OPatch — run as oracle OS user
# Set DB Oracle home
export ORACLE_HOME=/u01/oracle/product/19.0.0/dbhome_1
export PATH=$ORACLE_HOME/OPatch:$PATH

# Check OPatch version — confirm it meets minimum requirement
opatch version

# Check for conflicts before applying
cd /stage/<db_patch_number>
opatch prereq CheckConflictAgainstOHWithDetail -ph ./

# Shut down the database and listener
sqlplus / as sysdba
SQL> shutdown immediate;
SQL> exit
lsnrctl stop

# Apply the DB CPU patch
opatch apply

# Start the database
sqlplus / as sysdba
SQL> startup;
SQL> exit
lsnrctl start

# Run datapatch to apply SQL changes (required for OJVM patches)
$ORACLE_HOME/OPatch/datapatch -verbose

# Verify patch applied
opatch lsinventory | grep <patch_number>

WebLogic Server — FMW patch

Apply FMW / WebLogic patch using OPatch — run as applmgr # Stop WebLogic Admin and Managed Servers source /u01/oracle/R122/EBSapps.env run $ADMIN_SCRIPTS_HOME/adstopWLS.sh # Set FMW Oracle home — check your environment for the correct path export ORACLE_HOME=/u01/oracle/R122/fs1/FMW_Home/Oracle_EBS-app1 export PATH=$ORACLE_HOME/OPatch:$PATH # Apply FMW patch cd /stage/<fmw_patch_number> opatch apply # Repeat for each FMW home that requires patching # Check MOS CPU note for list of homes to patch # Restart WebLogic $ADMIN_SCRIPTS_HOME/adstartWLS.sh # Verify opatch lsinventory | grep <patch_number>

Oracle HTTP Server — Web tier patch

Apply OHS patch using OPatch — run as applmgr # Stop Oracle HTTP Server $ADMIN_SCRIPTS_HOME/adopmnctl.sh stop # Set OHS Oracle home export ORACLE_HOME=/u01/oracle/R122/fs1/FMW_Home/webtier export PATH=$ORACLE_HOME/OPatch:$PATH # Apply OHS patch cd /stage/<ohs_patch_number> opatch apply # Restart OHS $ADMIN_SCRIPTS_HOME/adopmnctl.sh start # Verify opatch lsinventory | grep <patch_number>

Java CPU — per Java home

Apply Java CPU patch to each Java home using OPatch # Run EJCPUC first to identify which Java homes need patching cd /stage/ejcpuc ./ejcpuc.sh # For each Java home listed in the EJCPUC report: export JAVA_HOME=/u01/oracle/R122/fs1/FMW_Home/jdk export PATH=$JAVA_HOME/bin:$PATH # Stop services that use this Java home before patching # Then apply the Java CPU patch cd /stage/<java_cpu_patch> $JAVA_HOME/../OPatch/opatch apply # Verify $JAVA_HOME/../OPatch/opatch lsinventory | grep <patch_number> # Repeat for every Java home in the EJCPUC report

ADOP — Commands for EBS Application Tier Patches

Standard ADOP patching cycle — run as applmgr on primary node # Source run environment — always first source /u01/oracle/R122/EBSapps.env run # Dryrun before every real apply adop phase=apply patches=<patch_number> apply_mode=dryrun # Full online patching cycle adop phase=prepare adop phase=apply patches=<patch_number> workers=8 adop phase=finalize adop phase=cutover adop phase=cleanup # Check status at any point adop phase=status # Verify patch registered in AD tables sqlplus apps/<apps_password> <<EOF SELECT bug_number, last_update_date FROM ad_bugs WHERE bug_number = '<patch_number>'; EOF

ADOP commands are always run from the primary application tier node only. In a multi-node environment, ADOP automatically uses SSH to execute the required actions on all secondary nodes. You do not run ADOP on secondary nodes separately.

An Important Consideration — OPatch and the Dual Filesystem

When you apply an OPatch to an FMW home on the run filesystem, the patch filesystem is not updated automatically. This creates a discrepancy between the run and patch filesystems. If you then start an ADOP cycle, the prepare phase will detect the discrepancy and attempt to synchronise the patch filesystem.

The safest approach — and the one Oracle recommends — is to apply OPatch changes to FMW homes on both the run and patch filesystems, or to run adop phase=fs_clone after applying OPatch changes to the run filesystem. This ensures both filesystems are in sync before the next prepare phase.

Apply OPatch to both run and patch filesystem FMW homes # Apply to run filesystem FMW home first export ORACLE_HOME=/u01/oracle/R122/fs1/FMW_Home/Oracle_EBS-app1 opatch apply # Then apply to patch filesystem FMW home export ORACLE_HOME=/u01/oracle/R122/fs2/FMW_Home/Oracle_EBS-app1 opatch apply # Alternative — run fs_clone to sync patch FS from run FS # Use this only when documented by Oracle or when specifically needed adop phase=fs_clone

Verifying That Patches Are Applied

Verifying OPatch patches

Check OPatch inventory for a specific patch # List all applied patches in the Oracle home opatch lsinventory # Search for a specific patch number opatch lsinventory | grep <patch_number> # Detailed listing of a specific patch opatch lsinventory -detail | grep -A5 <patch_number>

Verifying ADOP patches

Check AD tables for EBS application tier patches sqlplus apps/<apps_password> <<EOF -- Check if patch is registered SELECT bug_number, last_update_date FROM ad_bugs WHERE bug_number = '<patch_number>'; -- More reliable check using AD_PATCH function SELECT ad_patch.is_patch_applied('R12', -1, <patch_number>) FROM dual; -- Returns: EXPLICIT = applied -- Returns: NOT APPLIED = not applied or aborted -- Check patch history for a session SELECT adop_session_id, bug_number, status, end_date FROM ad_adop_session_patches WHERE bug_number = '<patch_number>' ORDER BY end_date DESC; EOF

Use AD_PATCH.IS_PATCH_APPLIED over AD_BUGS for verification. The AD_BUGS table can contain entries for patches that were applied during a cycle that was subsequently aborted. The AD_PATCH.IS_PATCH_APPLIED function checks the actual successful application status and is therefore more reliable for confirming a patch is truly in place.

Complete CPU April 2026 Patching Sequence — Tool by Tool

This is the correct sequence for applying a full quarterly CPU in EBS R12.2. Each step uses the correct tool for that component. Do not reorder these steps.

Step Component Tool Services Required Down
1 Run ECPUC and EJCPUC — identify all required patches ECPUC / EJCPUC scripts None
2 Oracle Database home — DB CPU patch OPatch Database and listener
3 Run datapatch after DB OPatch (for OJVM patches) datapatch DB up, no user connections
4 WebLogic Server and FMW Oracle homes OPatch WebLogic Admin and Managed Servers
5 Oracle HTTP Server (OHS) home OPatch OHS / web tier services
6 Java CPU — all Java homes on app tier and DB tier OPatch (per Java home) Services using each Java home
7 EBS application tier — CPU patches from ECPUC list ADOP None — brief cutover only
8 Run ECPUC and EJCPUC again — confirm zero remaining patches ECPUC / EJCPUC scripts None

Common Mistakes — Tool Confusion in Practice

Mistake Consequence Correct Approach
Using adpatch instead of ADOP on R12.2 Patch applies to run filesystem only — does not use dual filesystem or editions — leaves system inconsistent Always use ADOP for EBS application tier patches on R12.2
Applying DB CPU with ADOP ADOP does not patch Oracle database homes — patch will not apply Use OPatch on $ORACLE_HOME (DB) with the DB shut down
Applying FMW patches with ADOP FMW homes are not part of the ADOP patching cycle — patch will not apply Use OPatch on each FMW Oracle home
Applying OPatch to run FS only and not syncing patch FS Next ADOP prepare will detect discrepancy and may fail or run fs_clone unexpectedly Apply OPatch to both filesystems or run fs_clone after
Using AD_BUGS alone to verify patch application AD_BUGS may show patches from aborted cycles as applied when they are not Use AD_PATCH.IS_PATCH_APPLIED for reliable verification
Forgetting datapatch after DB OPatch Database SQL changes from the patch are not applied — partial patch state Always run datapatch after applying DB and OJVM OPatches

Quick Reference — Tool and Command Summary

Component Tool Key Command
Oracle DB home OPatch opatch apply (DB shut down)
Oracle JVM / OJVM OPatch + datapatch opatch apply then datapatch -verbose
WebLogic / FMW homes OPatch opatch apply (WLS services down)
Oracle HTTP Server OPatch opatch apply (OHS down)
Java CPU (per home) OPatch opatch apply (services using that home down)
EBS application tier ADOP adop phase=apply patches=<number>
Verify OPatch patch OPatch opatch lsinventory | grep <patch>
Verify ADOP patch SQL AD_PATCH.IS_PATCH_APPLIED('R12',-1,<patch>)

How to Apply Multiple EBS Patches in One ADOP Cycle — The Right Way

How to Apply Multiple EBS Patches in One ADOP Cycle the Right Way | punitoracledba

How to Apply Multiple EBS Patches in One ADOP Cycle — The Right Way

Every quarterly CPU cycle involves multiple patches — application tier patches, one-off fixes, prerequisite patches, and sometimes NLS patches on top. Running a separate ADOP cycle for each one is the most common mistake DBAs make. It means multiple prepare phases, multiple cutover windows, and hours of unnecessary downtime.

The right approach is to consolidate everything into a single ADOP cycle. One prepare. One cutover. One cleanup. The total downtime is the same regardless of how many patches you apply — so applying ten patches in one cycle costs the same cutover time as applying one.

This post covers two methods for applying multiple patches in one ADOP cycle — the comma-separated method and the admrgpch merge method — and explains when to use each one, how to handle conflicts, and what to watch out for.

Key principle: The cutover window in ADOP is fixed — it is the time needed to bounce services and switch filesystems. It does not grow significantly with the number of patches applied. Consolidating patches saves real downtime every quarter.

Two Methods for Applying Multiple Patches

ADOP gives you two ways to apply multiple patches in a single cycle. Understanding the difference helps you choose the right approach for each situation.

Method How It Works Best For
Comma-separated patches List all patch numbers in one apply command separated by commas. ADOP handles the merge automatically during apply. Most CPU patching scenarios — fast, simple, no pre-work needed
admrgpch pre-merge Merge patches manually before the ADOP cycle using the admrgpch utility. Apply the single merged patch via ADOP. Large upgrade patches, release update packs, or when you want to pre-validate merge conflicts before the maintenance window

For quarterly CPU patching, the comma-separated method is what you should use in almost every case. It is simpler, faster to set up, and fully supported by Oracle. The admrgpch method is covered later in this post for situations where it is specifically needed.

Method 1 — Comma-Separated Patches in One Apply Command

This is the standard approach for CPU patching. All patch numbers are listed in a single adop phase=apply command separated by commas. ADOP automatically merges the unified driver files during the apply phase and applies all patches in one pass.

Step 1 — Stage all patches

Download and unzip every patch into the $PATCH_TOP directory before starting the ADOP cycle. Each patch must be in its own numbered subdirectory.

Stage all patches in PATCH_TOP
# Confirm PATCH_TOP location
echo $PATCH_TOP
# Default: $NE_BASE/EBSapps/patch

# Unzip each patch into its own directory
unzip p36478206_R12_GENERIC.zip -d $PATCH_TOP
unzip p35987654_R12_GENERIC.zip -d $PATCH_TOP
unzip p36112233_R12_GENERIC.zip -d $PATCH_TOP

# Verify each patch directory exists
ls -la $PATCH_TOP/
# Should show: 36478206/  35987654/  36112233/

# On multi-node environments — patches only need to be staged
# on the PRIMARY node when using a shared filesystem

Step 2 — Run the ADOP cycle with all patches in one command

Full ADOP cycle — all patches consolidated # Source the run environment source /u01/oracle/R122/EBSapps.env run # Always dryrun first — no exceptions adop phase=apply \ patches=36478206,35987654,36112233 \ apply_mode=dryrun # Step 1 — Prepare adop phase=prepare # Step 2 — Apply all patches in one command adop phase=apply \ patches=36478206,35987654,36112233 \ workers=8 # Step 3 — Finalize adop phase=finalize # Step 4 — Cutover (only downtime window) adop phase=cutover # Step 5 — Cleanup adop phase=cleanup

When you list multiple patches with commas, ADOP automatically uses merge=yes internally. You do not need to specify it. The patches are merged on the fly during the apply phase and applied together in a single pass.

Applying patches in multiple apply commands within one cycle

You can also run multiple adop phase=apply commands within the same patching cycle without running cutover in between. This is useful when patches must be applied in a specific order — for example when one patch is a prerequisite for another.

Multiple apply commands — same cycle, no cutover between them # Start the cycle adop phase=prepare # Apply prerequisite patches first adop phase=apply patches=35987654 workers=8 # Then apply the main CPU patches adop phase=apply patches=36478206,36112233 workers=8 # Continue the cycle as normal adop phase=finalize adop phase=cutover adop phase=cleanup

You do not need to run finalize between multiple apply commands in the same cycle. Run finalize once after all apply commands are complete. This saves significant time in a large patching session.

Choosing the Right Number of Workers

The workers parameter controls how many parallel processes ADOP uses to apply patch jobs. More workers means faster apply — up to a point. Too many workers can exhaust database connections and cause the apply to fail.

Environment Size Recommended Workers Notes
Small — 4 CPU cores, 16 GB RAM 4 Default is usually adequate for small environments
Medium — 8 CPU cores, 32 GB RAM 6 to 8 Good balance of speed and stability
Large — 16+ CPU cores, 64+ GB RAM 8 to 16 Test in non-production first — monitor DB connections
Check DB processes limit before setting workers sqlplus / as sysdba <<EOF -- Confirm processes parameter can support your worker count SHOW PARAMETER processes; -- Each worker needs approximately 3 DB connections -- workers=8 needs ~24 connections available above current usage -- Check current active sessions SELECT COUNT(*) FROM v$session WHERE status = 'ACTIVE'; EOF

Method 2 — Pre-Merging Patches with admrgpch

The admrgpch utility allows you to merge multiple patches into a single merged patch before the ADOP cycle begins. The main advantage is that conflicts between patches are identified and resolved before your maintenance window opens — not during it.

This method is particularly useful for large release update packs, upgrade patches, or situations where you are applying a large number of patches and want to validate compatibility upfront.

Step 1 — Stage all patches in PATCH_TOP

Stage individual patches ready for merging # Unzip all patches into PATCH_TOP cd $PATCH_TOP unzip /downloads/p36478206_R12_GENERIC.zip unzip /downloads/p35987654_R12_GENERIC.zip unzip /downloads/p36112233_R12_GENERIC.zip # Confirm patch directories are present ls -la $PATCH_TOP # 36478206/ 35987654/ 36112233/

Step 2 — Create a destination directory for the merged patch

Create the merge destination directory # Create a destination directory under PATCH_TOP mkdir -p $PATCH_TOP/merged_cpu_apr2026 # Confirm it is empty ls -la $PATCH_TOP/merged_cpu_apr2026/

Step 3 — Run admrgpch to merge the patches

Run admrgpch to create the merged patch # Source the run environment source /u01/oracle/R122/EBSapps.env run # Run admrgpch # -s = source directory containing individual patches # -d = destination directory for the merged result admrgpch \ -s $PATCH_TOP \ -d $PATCH_TOP/merged_cpu_apr2026 # Review the output — look for conflicts or warnings # A merged driver file is created in the destination directory ls -la $PATCH_TOP/merged_cpu_apr2026/ # Should contain: fnd u_merged.drv (and others)

Step 4 — Move individual patch directories into the merged directory

This is the step most DBAs miss. ADOP looks for the individual patch directories inside the merged patch directory during the next prepare phase. If they are not there, the next prepare will fail.

Move individual patch directories under the merged directory # Move each individual patch directory into the merged destination mv $PATCH_TOP/36478206 $PATCH_TOP/merged_cpu_apr2026/ mv $PATCH_TOP/35987654 $PATCH_TOP/merged_cpu_apr2026/ mv $PATCH_TOP/36112233 $PATCH_TOP/merged_cpu_apr2026/ # Verify the merged directory structure ls -la $PATCH_TOP/merged_cpu_apr2026/ # Should now contain: # 36478206/ 35987654/ 36112233/ fnd u_merged.drv

Why this step is mandatory: During the next prepare phase after cutover, ADOP synchronises the patch filesystem and looks for the individual patch directories that were part of the previous cycle. If they are not inside the merged patch directory, prepare will fail with a missing patch directory error.

Step 5 — Apply the merged patch using ADOP

Apply the merged patch in the ADOP cycle # Prepare adop phase=prepare # Apply using the merged patch directory # Specify the patchtop pointing to the merged directory adop phase=apply \ patches=merged_cpu_apr2026 \ patchtop=$PATCH_TOP/merged_cpu_apr2026 \ workers=8 # Continue normally adop phase=finalize adop phase=cutover adop phase=cleanup

Handling Merge Conflicts

A conflict occurs when two patches modify the same file or database object in incompatible ways. Both the comma-separated method and admrgpch will detect conflicts — they just do it at different times.

  • Comma-separated method — conflict detected during the apply phase inside the maintenance window
  • admrgpch method — conflict detected before the maintenance window when you run admrgpch

What a conflict looks like

Typical conflict message in the apply log WARNING: Conflict detected for file: $FND_TOP/patch/115/import/US/fndscsgn.ldt Modified by patches: 36478206, 35987654 Resolution: Patch 36478206 will take precedence (higher patch number)

How ADOP resolves conflicts automatically

For most conflicts, ADOP and admrgpch resolve them automatically using the following rules:

  1. The patch with the higher patch number takes precedence for file conflicts
  2. For database object conflicts, the last patch in the list wins
  3. Conflicts that cannot be resolved automatically are flagged as errors and must be resolved manually

When to involve Oracle Support

If admrgpch or the apply phase reports an unresolvable conflict — meaning it cannot determine which patch should win — raise a Service Request with Oracle Support before proceeding. Applying patches with unresolved conflicts can leave the application in an inconsistent state.

Review conflict details in the merge log # For admrgpch — review the merge log immediately after running cat $PATCH_TOP/merged_cpu_apr2026/admrgpch.log | grep -i "conflict\|error\|warning" # For comma-separated — review the apply log during or after apply grep -i "conflict\|warning" \ $APPL_TOP_NE/admin/log/adop/<session_id>/<timestamp>/adop.log

Patch Ordering — Does Sequence Matter?

In most cases the order of patches in the comma-separated list does not matter because ADOP handles dependencies internally. However there are two situations where ordering is important.

Situation 1 — Prerequisite patches

If Patch B requires Patch A to be applied first, apply them in separate apply commands within the same cycle — not in the same comma-separated list. ADOP does not enforce prerequisite ordering within a single apply command.

Correct ordering when one patch is a prerequisite of another # Apply the prerequisite patch first adop phase=apply patches=35987654 workers=8 # Then apply the patch that depends on it adop phase=apply patches=36478206 workers=8 # Both are within the same cycle — no cutover between them

Situation 2 — NLS patches

NLS (language) patches must always be applied after the base US English patch in a separate apply command. Do not combine US and NLS patches in the same comma-separated list.

Correct approach for US and NLS patches # Apply the US base patch first adop phase=apply patches=36478206 workers=8 # Then apply NLS patches separately in the same cycle adop phase=apply patches=36478206_AR,36478206_FR workers=4 # Or use hotpatch mode if the NLS README approves it # One finalize and cutover covers everything adop phase=finalize adop phase=cutover adop phase=cleanup

Using an Input File for Large Patch Lists

When applying many patches, a long comma-separated list on the command line can become difficult to manage and prone to typing errors. ADOP supports an input file that lists all parameters cleanly.

Create the input file # Create the input file — one parameter per line cat > /stage/cpu_apr2026_input.txt << EOF patches=36478206,35987654,36112233,36001122,35778899 workers=8 apply_mode=online EOF
Run apply using the input file # Reference the input file in the apply command adop phase=apply input_file=/stage/cpu_apr2026_input.txt # The input file approach also works for dryrun adop phase=apply input_file=/stage/cpu_apr2026_input.txt \ apply_mode=dryrun

Common Mistakes When Applying Multiple Patches

Mistake Consequence Correct Approach
Running a separate ADOP cycle for each patch Multiple cutover windows — hours of unnecessary downtime per quarter Consolidate all patches into one cycle with comma-separated list
Running finalize between multiple apply commands Wastes time — finalize compiles everything, not just the last patch Run finalize once after all apply commands are complete
Using admrgpch and not moving patch directories into merged folder Next prepare phase fails looking for missing patch directories Always move individual patch directories inside the merged destination
Mixing US and NLS patches in one comma-separated list NLS patch may fail or apply in wrong order Apply US patch first, NLS patches in a separate apply command
Not reading README files before consolidating Miss a patch that requires downtime mode — wrong apply_mode used Read every README before staging — note any mode requirements
Setting too many workers DB processes limit exceeded — workers fail to connect Check processes parameter and active sessions before setting workers
Not running dryrun before apply Conflicts and mode issues discovered mid-apply in the maintenance window Always run dryrun before every real apply — catches issues early

Complete Example — CPU April 2026 Multi-Patch Cycle

This is a complete example of a quarterly CPU patching session applying five patches in one ADOP cycle using the comma-separated method.

Complete CPU April 2026 — five patches in one cycle # Environment setup source /u01/oracle/R122/EBSapps.env run # Stage all patches cd $PATCH_TOP unzip /downloads/p36478206_R12_GENERIC.zip unzip /downloads/p35987654_R12_GENERIC.zip unzip /downloads/p36112233_R12_GENERIC.zip unzip /downloads/p36001122_R12_GENERIC.zip unzip /downloads/p35778899_R12_GENERIC.zip # Dryrun first — validate before committing adop phase=apply \ patches=36478206,35987654,36112233,36001122,35778899 \ apply_mode=dryrun # Review dryrun log — confirm no errors or mode conflicts tail -50 $APPL_TOP_NE/admin/log/adop/<session_id>/<timestamp>/adop.log # Prepare — starts the patching cycle adop phase=prepare # Apply all patches in one command adop phase=apply \ patches=36478206,35987654,36112233,36001122,35778899 \ workers=8 # Monitor apply progress adop phase=status # Finalize — compile, generate, merge seed data adop phase=finalize # Cutover — notify users first, then run # This is the only step that requires a maintenance window adop phase=cutover # Verify patches registered in AD tables sqlplus apps/<apps_pwd> <<EOF SELECT bug_number, last_update_date FROM ad_bugs WHERE bug_number IN ( '36478206','35987654','36112233','36001122','35778899' ) ORDER BY bug_number; EOF # Cleanup — run after confirming system is stable adop phase=cleanup

Summary

  • Always consolidate multiple patches into one ADOP cycle — one cutover regardless of patch count
  • For CPU patching use the comma-separated method — it is simple, fast, and fully supported
  • Use admrgpch when you want to pre-validate conflicts before the maintenance window
  • If using admrgpch, always move individual patch directories into the merged destination folder
  • Apply prerequisite patches in a separate apply command before the patches that depend on them
  • Apply NLS patches in a separate apply command after the US base patch
  • Run finalize only once — after all apply commands in the cycle are complete
  • Always dryrun before every real apply — every time, no exceptions

Friday, May 15, 2026

Oracle EBS R12: Create User & Assign Responsibility — Step-by-Step DBA Guide with SQL Verification

Oracle EBS R12: Create User & Assign Responsibility — Step-by-Step DBA Guide with SQL Verification

This guide explains how to create a user in Oracle E-Business Suite R12, assign a responsibility, and verify the setup using SQL queries.


1. Business Requirement

As an Oracle Apps DBA, you may receive a request to create a new EBS application user and assign required responsibilities.

Example Requirement:

Create EBS user       : MAHILANIA
Assign Responsibility : System Administrator
Application          : System Administration

2. Important Tables Used

Table Name Purpose
FND_USER Stores EBS application user details
FND_RESPONSIBILITY Stores responsibility details
FND_RESPONSIBILITY_TL Stores translated responsibility names
FND_APPLICATION Stores application details
FND_USER_RESP_GROUPS_DIRECT Stores direct user responsibility assignments

3. Source the EBS Environment

Login to the application tier as the application OS user and source the environment file.

cd $INST_TOP/ora/10.1.2
. <CONTEXT_NAME>.env

Or source the main EBS environment file:

. /u01/oracle/EBSapps.env run

4. Connect to SQL*Plus as APPS

sqlplus apps/<apps_password>

5. Create EBS User Using FND_USER_PKG

Use the standard Oracle seeded API FND_USER_PKG.CREATEUSER to create an application user.

BEGIN
  FND_USER_PKG.CREATEUSER(
    x_user_name              => 'MAHILANIA',
    x_owner                  => 'CUST',
    x_unencrypted_password   => 'Welcome123',
    x_start_date             => SYSDATE,
    x_end_date               => NULL,
    x_password_date          => SYSDATE,
    x_email_address          => 'mahilania@example.com'
  );

  COMMIT;
END;
/

Note: Replace the password and email address as per your organization policy.


6. Verify User Creation

SELECT user_id,
       user_name,
       start_date,
       end_date,
       email_address,
       creation_date
FROM   fnd_user
WHERE  user_name = 'MAHILANIA';

7. Find Responsibility Details

Before assigning a responsibility, find the correct responsibility name, responsibility ID, application ID, and security group ID.

SELECT fr.responsibility_id,
       fr.application_id,
       frt.responsibility_name,
       fa.application_short_name
FROM   fnd_responsibility fr,
       fnd_responsibility_tl frt,
       fnd_application fa
WHERE  fr.responsibility_id = frt.responsibility_id
AND    fr.application_id = frt.application_id
AND    fr.application_id = fa.application_id
AND    frt.language = USERENV('LANG')
AND    frt.responsibility_name LIKE 'System Administrator';

8. Assign Responsibility to User

Use FND_USER_PKG.ADDRESP to assign responsibility to the EBS user.

BEGIN
  FND_USER_PKG.ADDRESP(
    username       => 'MAHILANIA',
    resp_app       => 'SYSADMIN',
    resp_key       => 'SYSTEM_ADMINISTRATOR',
    security_group => 'STANDARD',
    description    => 'System Administrator responsibility assigned by Apps DBA',
    start_date     => SYSDATE,
    end_date       => NULL
  );

  COMMIT;
END;
/

9. Verify Responsibility Assignment

SELECT fu.user_name,
       frt.responsibility_name,
       fa.application_short_name,
       furg.start_date,
       furg.end_date
FROM   fnd_user fu,
       fnd_user_resp_groups_direct furg,
       fnd_responsibility_tl frt,
       fnd_responsibility fr,
       fnd_application fa
WHERE  fu.user_id = furg.user_id
AND    furg.responsibility_id = fr.responsibility_id
AND    furg.responsibility_application_id = fr.application_id
AND    fr.responsibility_id = frt.responsibility_id
AND    fr.application_id = frt.application_id
AND    fr.application_id = fa.application_id
AND    frt.language = USERENV('LANG')
AND    fu.user_name = 'MAHILANIA';

10. Check User Login Status

SELECT user_name,
       start_date,
       end_date,
       password_date,
       password_lifespan_days,
       password_accesses_left
FROM   fnd_user
WHERE  user_name = 'MAHILANIA';

11. End Date a Responsibility

If you need to remove access, do not delete records directly. End-date the responsibility using Oracle API.

BEGIN
  FND_USER_PKG.DELRESP(
    username       => 'MAHILANIA',
    resp_app       => 'SYSADMIN',
    resp_key       => 'SYSTEM_ADMINISTRATOR',
    security_group => 'STANDARD'
  );

  COMMIT;
END;
/

12. End Date an EBS User

UPDATE fnd_user
SET    end_date = SYSDATE
WHERE  user_name = 'MAHILANIA';

COMMIT;

13. Common Issues

Issue Possible Cause Action
User not visible in EBS User not committed or wrong username Verify in FND_USER
Responsibility not visible after login Incorrect responsibility key or application short name Verify responsibility details using SQL
Password issue Password policy restriction Reset password from System Administrator responsibility
Responsibility expired End date is already set Check FND_USER_RESP_GROUPS_DIRECT

14. Best Practices for Apps DBA

  • Always use Oracle seeded APIs where possible.
  • Do not directly insert records into FND tables.
  • Take approval before granting powerful responsibilities.
  • Use strong password policies.
  • Validate user and responsibility assignment using SQL.
  • End-date users when access is no longer required.
  • Keep audit details for production access changes.

15. Quick Validation Script

SET LINES 200
COL user_name FORMAT A20
COL responsibility_name FORMAT A40
COL application_short_name FORMAT A20

SELECT fu.user_name,
       frt.responsibility_name,
       fa.application_short_name,
       furg.start_date,
       furg.end_date
FROM   fnd_user fu,
       fnd_user_resp_groups_direct furg,
       fnd_responsibility_tl frt,
       fnd_responsibility fr,
       fnd_application fa
WHERE  fu.user_id = furg.user_id
AND    furg.responsibility_id = fr.responsibility_id
AND    furg.responsibility_application_id = fr.application_id
AND    fr.responsibility_id = frt.responsibility_id
AND    fr.application_id = frt.application_id
AND    fr.application_id = fa.application_id
AND    frt.language = USERENV('LANG')
AND    fu.user_name = UPPER('&USER_NAME');

Conclusion

Creating an Oracle EBS R12 user and assigning responsibility is a common Apps DBA activity. The safest approach is to use Oracle seeded APIs such as FND_USER_PKG.CREATEUSER and FND_USER_PKG.ADDRESP. Always verify the user and responsibility assignment from backend tables before confirming access to the business team.

Author: Punit Kumar
Role: Oracle Apps DBA / Oracle DBA Specialist

Tuesday, February 24, 2026

WebLogic Admin Console access issue: Connection rejected, filter blocked Socket, weblogic.security.net.FilterException: [Security:090220] rule 2 (Oracle EBS 12.2)

Fixing WebLogic FilterException [Security:090220] rule 2 in Oracle EBS 12.2

Fixing WebLogic Admin Console Access Error in Oracle EBS 12.2

Error Message

The Server is not able to service this request:
[Socket:000445] Connection rejected, filter blocked Socket
weblogic.security.net.FilterException: [Security:090220] rule 2

Root Cause

In Oracle E-Business Suite 12.2, WebLogic connection filtering is enabled as part of security hardening. If your client IP is not allow-listed, WebLogic blocks the request using a deny rule.

Typical deny rule inside config.xml:

<connection-filter-rule>0.0.0.0/0 * * deny</connection-filter-rule>

If your IP does not match an allow rule, WebLogic applies the deny rule (often rule 2), which results in the error:

[Security:090220] rule 2

Quick Verification Steps

  1. Check AdminServer log:
    cd $EBS_DOMAIN_HOME/servers/AdminServer/logs
    tail -200 AdminServer.log
    
  2. Identify the blocked client IP address.
  3. Verify whether your IP exists in the trusted host configuration.

Emergency Recovery (If Completely Locked Out)

Important: This should be used only temporarily to regain access.

Step 1 – Stop Application Tier

adstpall.sh apps/APPS_PASSWORD

Step 2 – Backup and Edit config.xml

cd $EBS_DOMAIN_HOME/config
cp -p config.xml config.xml.bak
vi config.xml

Locate this line:

<connection-filter-rule>0.0.0.0/0 * * deny</connection-filter-rule>

Add allow to it:

<connection-filter-rule>0.0.0.0/0 * * allow</connection-filter-rule>

Temporarily comment or remove it:

<!-- <connection-filter-rule>0.0.0.0/0 * * deny</connection-filter-rule> -->

Step 3 – Start Application Tier

adstrtal.sh apps/APPS_PASSWORD

Now try accessing the WebLogic Admin Console again.


Permanent Fix (Recommended Solution)

  1. Update the EBS context variable for trusted admin nodes (for example: s_wls_admin_console_access_nodes).
  2. Add only approved IP addresses (such as bastion host or corporate VPN egress IP).
  3. Run AutoConfig:
    adautocfg.sh
    
  4. Restart services:
    adstpall.sh apps/APPS_PASSWORD
    adstrtal.sh apps/APPS_PASSWORD
    

Best Practice

  • Use a Bastion or Jump Host with a fixed IP.
  • Allow only trusted admin IPs.
  • Keep the global deny rule enabled.
  • Avoid permanent manual edits in config.xml.

Conclusion

The error "[Security:090220] rule 2" is not a WebLogic failure. It is a security configuration blocking unauthorized access. Properly maintaining trusted host configuration ensures both security and availability.

Monday, February 2, 2026

ADOP Prepare Phase Failure in EBS R12.2 (ORA-20008 Solution)

 Issue in Oracle EBS R12.2 Online Patching – ORA-20008

While working on my first Oracle E-Business Suite R12.2 upgrade, I encountered an interesting issue during online patching. I’m documenting this here so it can help others who face the same problem during early R12.2 upgrade phases.


Upgrade Scenario

  • Oracle E-Business Suite upgrade from R12.2.0 to R12.2.2

  • As part of the upgrade, AD and TXK patches for 12.2.2 were being applied

  • Online patching cycle was initiated using ADOP

During the patching cycle, while running:

adop phase=prepare

The process failed with the following error:

ERROR at line 1: ORA-20008: No Concurrent Manager is defined that can run concurrent program ADZDPATCH ORA-06512: at "APPS.AD_ZD_ADOP", line 240

Understanding the Issue

This error occurs when the ADZDPATCH concurrent program definition is missing or not properly loaded in the system.
Since ADOP relies heavily on concurrent managers, the absence of this definition causes the prepare phase to fail.

This is a known issue, especially in fresh or early-stage R12.2 environments.


Solution

Important Prerequisite

Ensure you are sourced on the RUN filesystem environment, not the PATCH filesystem.

Resolution Command

Run the following command to reload the concurrent program definition:

FNDLOAD apps/apps 0 Y UPLOAD \ $FND_TOP/patch/115/import/afcpprog.lct \ $AD_TOP/patch/115/import/US/adzdpatch.ldt \ CUSTOM_MODE=FORCE

Post Fix Validation

  • Re-run the adop phase=prepare

  • The phase should complete successfully

  • Online patching cycle can then proceed normally


Oracle Reference

This issue is documented by Oracle in the following support note:

ORA-20008 When Running "adop phase=prepare"
Doc ID: 1587419.1