Akaunting’s OfflinePayments confirmation trusted accounting fields supplied by a guest holding a valid signed invoice link. The caller could choose the amount, currency, exchange rate, account, category, and payment method that Akaunting recorded. In our local test, a transaction for 0.01 EUR marked an invoice for 239.21 USD paid because the request supplied an exchange rate of 0.00004180.
No money moved. Akaunting recorded a payment and marked the invoice paid. The caller’s control of the accounting fields compromised the integrity of the invoice balance and transaction record.
We reproduced the behavior on Akaunting 3.2.4 with OfflinePayments 3.0.4, then reproduced it again on Akaunting 3.3.1. All testing used local Docker environments and invoices that we controlled.
We also found a separate installer access-control error in Akaunting 3.2.4. When the installation flag existed only in .env and Laravel’s configuration cache was enabled, the public installer could rewrite the database settings and migrate a second database. Akaunting changed the installer check in 3.3.0, and the same requests were blocked on 3.3.1. The payment issue remained reproducible.
Where this started
During Fenko’s open-source research, we identified the payment confirmation path. We traced the request through transaction creation and reproduced the accounting changes locally.
The affected payment path belongs to Akaunting’s OfflinePayments module. Both tested releases declare akaunting/module-offline-payments as a required Composer dependency, so the module code ships with the core application. Exploitation still requires the merchant to configure an OfflinePayments method and make it available to customers.
The module lets a customer confirm an offline payment such as cash or bank transfer. For a customer using a shared invoice link, Akaunting generates a signed confirmation URL and renders a form with two hidden fields:
<x-form id="redirect-form" method="POST" :url="$confirm_url">
<x-form.input.hidden name="payment_method" :value="$setting['code']" />
<x-form.input.hidden name="type" value="income" />
</x-form>
The browser normally sends only the fields in that form. The server cannot treat that as a security boundary. A caller can add other fields to an HTTP request even when the page does not display them.
What the signature protects
The module creates the confirmation URL through Akaunting’s shared payment controller:
public function getModuleUrl($invoice, $suffix)
{
return request()->isPortal($invoice->company_id)
? route('portal.' . $this->alias . '.invoices.' . $suffix, $invoice->id)
: URL::signedRoute(
'signed.' . $this->alias . '.invoices.' . $suffix,
[$invoice->id]
);
}
Laravel signs the URL, including its path and signed query parameters. It does not sign the later POST body. That is normal behavior for a signed URL. The application still has to decide which submitted fields the guest may control.
Exploitation requires a valid link for the target invoice and a configured OfflinePayments method available to customers. Changing one character in the signature produced HTTP 403 on both tested versions. The signature binds access to that invoice; the flaw is the server’s handling of the submitted accounting fields.
The problem appears after that check. The OfflinePayments controller passes the full request into the payment event:
public function confirm(Document $invoice, Request $request)
{
try {
event(new PaymentReceived($invoice, $request));
$message = trans('messages.success.added', [
'type' => trans_choice('general.payments', 1),
]);
// response construction omitted
} catch (\Exception $e) {
// error response omitted
}
}
The base payment controller’s dispatchPaidEvent() helper sets the company, account, amount, and payment method from server-side data before dispatching the same event. This excerpt shows those assignments:
public function dispatchPaidEvent($invoice, $request)
{
$request['company_id'] = $invoice->company_id;
$request['account_id'] = setting(
$this->alias . '.account_id',
setting('default.account')
);
$request['amount'] = $invoice->amount;
$request['payment_method'] = $this->alias;
// Reference and transaction type assignments omitted.
event(new PaymentReceived($invoice, $request));
}
OfflinePayments did not use that helper. Downstream transaction creation accepted the submitted accounting fields, including currency_code and currency_rate. Akaunting’s overpayment check compared the converted value with the invoice balance. A fabricated exchange rate made a very small foreign-currency transaction convert to the full USD balance.
What we reproduced
We created a 239.21 USD invoice and opened its normal signed customer link. From a fresh browser context, we obtained the page’s CSRF token and submitted the confirmation request with altered payment fields. Database queries confirmed the result:
Invoice total: 239.2100 USD
Stored transaction: 0.0100 EUR
Stored rate: 0.00004180
Invoice status: paid
The transaction also stored the account, category, and payment method selected in the request.
We repeated the test on the 3.2.4 release source and the official 3.3.1 image. Both accepted the altered fields and marked the invoice paid.
We also tested the boundaries:
- A modified signature returned HTTP 403.
- Reusing a valid link for two partial submissions created two 10.00 USD transactions while the invoice still had a balance.
- Reusing the link after full settlement did not create another transaction because the overpayment guard stopped it.
- A link with no
expiresparameter still worked after an application restart.
The tested link had no expiry parameter and remained usable after a restart. Signing-key rotation can invalidate signed links.
The separate installer issue
Akaunting 3.2.4 protected its installer with this check:
if (env('APP_INSTALLED', false) == false) {
return $next($request);
}
return redirect()->route('login');
After php artisan config:cache, Laravel reads the cached configuration without loading .env. If APP_INSTALLED=true exists only in that file, the raw env() call returns its fallback and the installer becomes reachable. A true value exported in the process environment preserves the guard. Application code should read this flag through config('app.installed').
The unauthenticated wizard accepted database settings, rewrote .env, and migrated 46 tables into a second local MariaDB database. The original database still held its user and invoice records. The second database contained the schema but no users or documents.
The database settings persisted in .env, while the existing configuration cache continued to select the original database. After we rebuilt that cache with config:cache, the CLI configuration selected the second database. The confirmed impact is an unauthenticated rewrite of the database configuration and migration into an attacker-selected, reachable database. Using the rewritten settings requires a later configuration-cache rebuild.
Akaunting changed the installer check from env('APP_INSTALLED') to config('app.installed') in commit c2c1b6f, included in the 3.3.0 line. With configuration cached on 3.3.1, installer GET and POST requests redirected to login, .env did not change, and the second database stayed empty.
Version status
| Version | Signed-link payment fields | Config-cached installer |
|---|---|---|
| 3.2.4 | Vulnerable in our test | Vulnerable in our test |
| 3.3.1 | Vulnerable in our test | Requests blocked |
The payment analysis used OfflinePayments 3.0.4 at commit 9e444c2e and Akaunting releases 3.2.4 and 3.3.1. Our 3.3.1 source review used commit 946e4260.
As of our November 12 verification, the payment issue remained reproducible on 3.3.1. Administrators should check the Akaunting release and OfflinePayments module version they run. The installer change does not address the payment path.
What maintainers should change
The confirmation controller should build a payment command from server-side values. It should derive the invoice balance, company, account, category, currency, exchange rate, and allowed payment method from the invoice and module configuration. A guest request should not supply those fields.
Offline payment confirmation should follow the merchant’s intended approval policy. If a customer is reporting a bank transfer or cash payment, the application can record it as pending until a trusted user confirms receipt. Signed links should have an expiry and a clear revocation mechanism. Those link controls supplement server-side validation of the accounting fields.
For the installer issue, users should run a release containing the config('app.installed') change. A separate installation marker outside mutable request data would add another check before any public installer route can rewrite connection settings.
Until a payment fix is available, administrators can reduce exposure by disabling customer-facing OfflinePayments confirmation and avoiding signed invoice links for that flow. A reverse proxy rule can block the signed OfflinePayments confirmation route, but it may also remove the intended customer feature.
Disclosure timeline
- September 23, 2026: Reported the findings through Akaunting’s published security email address with a 45-day disclosure window.
- November 7, 2026: The 45-day window ended. We had not received a reply.
- November 12, 2026: Tested the latest release, Akaunting 3.3.1, published the previous day. The signed-link payment issue remained present, while the installer flow was blocked.
- November 14, 2026: No vendor reply had been received as of publication.
We have not published the standalone reproduction scripts or full HTTP transcripts. Maintainers can contact Fenko for reproduction code and supporting evidence, or to coordinate a fix or advisory.
