Package Instance

Avo has a XSS vulnerability on `return_to` param
## Description

A reflected cross-site scripting (XSS) vulnerability exists in
the `return_to` query parameter used in the avo interface.

An attacker can craft a malicious URL that injects arbitrary
JavaScript, which is executed when he clicks a dynamically
generated navigation button.

## Impact

This vulnerability may allow execution of arbitrary JavaScript
in the context of the application.

Impact varies depending on deployment:
- In unauthenticated setups: exploitable via crafted links sent to users.
- In authenticated setups: limited to authenticated users and
  requires interaction.

Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Avo is a framework to create admin panels for Ruby on Rails apps. In Avo 3 pre12 any HTML inside text that is passed to `error` or `succeed` in an `Avo::BaseAction` subclass will be rendered directly without sanitization in the toast/notification that appears in the UI on Action completion. A malicious user could exploit this vulnerability to trigger a cross site scripting attack on an unsuspecting user. This issue has been addressed in the 3.0.0 release of Avo. Users are advised to upgrade.

Broken Access Control Through Unauthorized Execution of Arbitrary Action Classes Across Resources
### Summary

A critical Broken Access Control vulnerability was identified in the
`ActionsController` of the Avo framework (v3.x). Due to insecure
action lookup logic, an authenticated user can execute any Action
class (descendants of `Avo::BaseAction`) on any resource, even if
the action is not registered for that specific resource. This leads
to Privilege Escalation and unauthorized data manipulation across
the entire application.

### Details

The vulnerability exists in the `action_class` method within
`app/controllers/avo/actions_controller.rb`.

#### Vulnerable Code

```ruby
def action_class
  # It searches through ALL descendants of BaseAction without
  #    resource validation.
  Avo::BaseAction.descendants.find do |action|
    action.to_s == params[:action_id]
  end
end
```

The controller identifies the action class to execute solely based
on the `params[:action_id]` by searching through all `BaseAction`
descendants. It fails to verify whether the requested action is
actually permitted or registered for the resource context specified
in the request URL (e.g., `/admin/resources/posts/actions`).

Consequently, an attacker can invoke sensitive actions (e.g.,
`Avo::Actions::ToggleAdmin`) through an unrelated resource endpoint
(e.g., `Post`), bypassing the intended resource-action mapping.

### Impact

This flaw results in significant security risks:

- **Privilege Escalation:** An authenticated user with low privileges
  can execute administrative actions (like toggling admin roles) to
  escalate their own or others' permissions.
- **Unauthorized Operations:** Actions designed for restricted
  resources can be triggered against any record ID in the database.
- **Data Integrity Compromise:** Attackers can perform unauthorized
  destructive operations (e.g., Delete, Archive, or Update) on records
  they should not have access to.

### CREDIT

Illunight

Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Avo is a framework to create admin panels for Ruby on Rails apps. A stored cross-site scripting (XSS) vulnerability was found in the key_value field of Avo v3.2.3. This vulnerability could allow an attacker to execute arbitrary JavaScript code in the victim's browser. The value of the key_value is inserted directly into the HTML code. In the current version of Avo (possibly also older versions), the value is not properly sanitized before it is inserted into the HTML code. This vulnerability could be used to steal sensitive information from victims that could be used to hijack victims' accounts or redirect them to malicious websites. Avo 3.2.4 includes a fix for this issue. Users are advised to upgrade.