Appearance
Security Notes
This page collects the security-relevant behaviour of GET Mobile 5.1.20 and of the GETServices API it talks to. It is written for people building against the API, and for anyone reviewing a GET Mobile deployment.
WARNING
Everything here is a point-in-time observation of a client that anyone can download and decompile. None of it is a finding against a specific institution's configuration. CBORD can change any of it without notice.
How this was derived
Two sources, kept separate throughout this page:
- Client-verified — read directly out of the shipped app bundle (
Payload/GET_Mobile.app/public/*.jsandcapacitor.config.json). Deterministic: if the app ships it, it is true of the app. - Live-verified — observed against the demo sandbox (
services.get.demo.cbord.com) on 2026-11-20, using the app's own public system credentials and unauthenticated calls only. Nothing was sent to production, and no patron data was accessed.
Anything that depends on server-side authorisation is marked Unverified — it describes what the client sends, and what the server does with it needs its own test.
Threat model in one paragraph
The security boundary is the session ID. It is a bare string (a UUID) held in the WebView's @ionic/storage vault and sent in the request body. The four-digit PIN is a local convenience lock in front of that vault, not a credential the server checks. Anything that can read or execute inside the WebView — a debugging attachment, a malicious page, a device backup, a compromised plugin — is equivalent to full account access. The server's job is therefore to bind every userId/photoId/accountId it receives to the session that sent it. The client cannot do that for you.
Summary
| # | Finding | Severity | Basis |
|---|---|---|---|
| 1 | WebView remote debugging enabled in the shipped build | High | Client-verified |
| 2 | PIN is an unsalted client-side SHA-256 with no persistent lockout | High | Client-verified |
| 3 | No auth throttling on the demo environment | High | Live-verified |
| 4 | userId is taken from the request, not the session, in guest deposit flows | High | Client-verified (impact Unverified) |
| 5 | Photo endpoints take bare photoId/userId (government-ID photos) | High | Client-verified (impact Unverified) |
| 6 | Access-Control-Allow-Origin: * with preflight allowed | Medium | Live-verified |
| 7 | Deep-link handling accepts any URL containing cbord.com | Medium | Client-verified |
| 8 | Profile/order/transaction writes trust client-supplied identifiers and totals | Medium | Client-verified (impact Unverified) |
| 9 | Card PAN and CVV sent as plain JSON fields | Medium | Client-verified |
| 10 | Barcodes are forgeable: a captured barcode + institution key yields the patron key | High | Client-verified |
| 11 | Destructive actions (delete account, report card lost) need only a session | Medium | Client-verified |
| 12 | Client-side validation is advisory only | Low | Client-verified |
| 13 | Environment override survives logout; sandbox card injection off-prod | Low | Client-verified |
| 16 | Unauthenticated callers can mint unlimited system sessions | Low | Live-verified |
| 14 | Generic error handling leaks nothing | Info (good) | Live-verified |
1. WebView remote debugging enabled in the shipped build
High — client-verified.
capacitor.config.json in the .ipa:
json
{
"server": { "androidScheme": "http" },
"android": {
"appendUserAgent": "android:application",
"webContentsDebuggingEnabled": true
},
"ios": {
"appendUserAgent": "ios:application",
"webContentsDebuggingEnabled": true,
"scheme": "Debug"
}
}Capacitor maps the iOS flag to WKWebView.setInspectable:. The symbol is present in the shipped Frameworks/Capacitor.framework/Capacitor binary, along with the warning string isWebDebuggable only functions as intended on iOS 16.4 and above.
Consequence: on a shipping App Store / Play build, Safari Web Inspector or chrome://inspect can attach to the app and execute JavaScript in the app origin. From there, get_sessionId, get_user, jwt_token and the whole Ionic storage vault are readable. This bypasses the PIN entirely (see #2).
webContentsDebuggingEnabled is meant to be false (or omitted) for release builds.
Two related config notes:
server.androidSchemeis"http", not Capacitor's default"https". The WebView origin becomeshttp://localhostrather thanhttps://localhost, which removes the secure-context assumption from anything that relies on it.ios.schemesays"Debug", butInfo.plistactually registersgetmobile(andcapacitor). The config value is stale and unused.
There is no NSAppTransportSecurity dictionary in Info.plist, so the app is subject to default ATS (TLS 1.2+, forward secrecy on the CBORD hosts) — that part is fine.
2. The PIN is a local unsalted SHA-256 with no persistent lockout
High — client-verified.
The PIN manager (chunk-4DBESXXF.js) stores auth_pin_hash in Capacitor Preferences:
js
storePin(pin) { hashPin(pin) → Preferences.set({ key: "auth_pin_hash", value }) }
checkPin(pin) { return (await hashPin(pin)) === await get("auth_pin_hash") }hashPin is a plain SHA-256 of the PIN — no salt, no iteration count, no server involvement. A four-digit PIN has 10,000 candidates, so the stored hash is a 10,000-guess offline problem.
The verification path is worse than the storage. In the PIN modal:
js
if (await pinManager.isPinStored()) {
if (await pinManager.checkPin(pin)) {
this.authenticator?.authenticate(pin).catch(() => {}); // result discarded
this.modalController.dismiss(this.pin, LOGIN_SUCCESS);
} else {
this.handleWrongPin();
}
}When a hash is stored, the backend call's result is thrown away — the local hash is the only gate. There is also no re-authentication on resume; the session in the vault is reused as-is.
The attempt counter (currentLoginAttempts vs get.login.pin_max_failed, default 5) is a field on the modal component, initialised to 0 in the constructor. Closing and re-opening the modal, or restarting the app, resets it. Nothing is persisted, so the lockout is cosmetic.
A legacy path still exists: auth_pin / auth_pin_date hold the server's encodePin(pin, date) output, and checkPin upgrades a match to the SHA-256 form. Either way it is local data.
Practical takeaway: treat the PIN as a shoulder-surfing deterrent, not as authentication. Do not build anything that relies on it. Screenshot/backup protection and vault encryption matter far more than the PIN.
3. No auth throttling observed
High — live-verified on demo.
Twelve consecutive failed authenticateSystem calls completed in ~1.1 s total, every one HTTP 200, every response ~90 ms, with no 429, no lockout, no delay growth. Nothing in the response headers indicates quota tracking. The same run showed no difference between an unknown service consumer and a correct consumer with a wrong password:
json
{ "response": null, "exception": "9504|Given service consumer does not exist, or the password was invalid." }The combined message is the right design — it prevents consumer enumeration. But without per-IP or per-account throttling, an attacker gets unlimited guesses against authenticateUser and authenticatePIN. authenticatePIN is the interesting target: the client sends { systemCredentials, deviceId, pin }, and the server's only observed defence is device binding.
Unknown or unbound device on authenticatePIN:
json
{ "response": null, "exception": "9510|Device marked as lost or user logged on to another device" }NOTE
Absence of throttling on the demo environment does not prove production behaves the same. Edge proxies (Cloudflare/WAF) are common in front of production but not demo. This is worth confirming on your own environment before drawing conclusions.
4. userId comes from the request, not the session (guest deposits)
High — client-verified; server impact Unverified.
The guest deposit flow deliberately uses the system session to look a recipient up, then passes a caller-supplied userId to commerce methods:
js
// chunk-STI56G4X.js
retrieveAndSaveRecipientByCashlessFields(recipient, lookupFields) {
this.authFacadeService.getAuthSessionToken$() // ← system session
.pipe(switchMap(([token, institution]) =>
this.userApiService.retrieveUserIdByCashlessFields(institution.id, token, lookupFields)))
.pipe(switchMap(({ id }) => ...save { nickname, id }))
}
// chunk-D3AODLWA.js
retrieveAccountsByUser(userId) // { userId }, useSessionId, !useInstitutionId
retrieveDepositAccountsByUser(userId) // { userId }, useSessionId, !useInstitutionId
depositForUserFromAnyAccount // { userId, fromAccountId, fromAccountCvv, toAccountId, amount }Three things follow from the shape alone:
retrieveUserIdByCashlessFieldsis an unauthenticated-ish lookup oracle: it takesinstitutionId, a session, and arbitrarycashlessData.lookupFields, and returns auserId. It is there so a guest can find who to send money to, so it must answer lookups it should not otherwise answer. Check what fields are accepted and whether the response is limited to an ID.retrieveAccountsByUser/retrieveDepositAccountsByUsertakeuserIdwith only a session interest. If the server does not verify that the session owns thatuserId, they enumerate anyone's accounts.depositForUserFromAnyAccounttakesfromAccountIdalongsideuserId. The name says what it is for — a guest charging a card they have on file — but ifuserIdandfromAccountIdare not cross-checked against the session, it is an arbitrary debit.
The client cannot enforce any of this. Test on your own environment: authenticate as one patron, then call each method with a second patron's userId and observe.
5. Photo endpoints take bare identifiers
High — client-verified; server impact Unverified.
js
getUserPhoto(photoId) // retrieveUserPhoto { photoId }
getPhotoListByUserId(userId) // retrieveUserPhotoList { userId }
getFullPhotoListByUserId(userId) // retrieveFullUserPhotoList { userId }
retrievePendingOrRejectedUserPhoto // { userId }
addUserPhoto(userId, photo) // { userId, photo }
updateUserPhotoStatus(photoId, ...)All of these carry a session interest but no derived identity — the identifiers are plain request parameters. That matters more than usual here because the photo model includes GOVT_ID_FRONT / GOVT_ID_BACK (government ID scans, status ACCEPTED), and because retrieveFullUserPhotoList is the "full" variant.
If any of these resolves photoId/userId without comparing it to the session's user, the result is disclosure of identity documents. This is the single highest-impact thing to test on a real deployment.
Also note the client-side upload cap: get.photo_upload.max_upload_size is checked against the decoded base64 length (len * 3 / 4) in JavaScript only. A direct RPC call skips it, so the server must enforce its own limit or accept arbitrary payload sizes.
6. Access-Control-Allow-Origin: *
Medium — live-verified on demo.
http
HTTP/2 200
server: nginx
access-control-allow-origin: *
access-control-allow-methods: POST, GET
access-control-allow-headers: Origin, X-Requested-With, Content-Type, Accept
strict-transport-security: max-age=86400Preflight is answered too, so a browser page on any origin can POST to the API. Because the session travels in the body (not a cookie), this is not classic CSRF — an attacker page cannot read a victim's session. What it does enable:
- Credential stuffing / PIN guessing straight from a malicious web page, with the victim's own browser as the source IP (see #3 — no throttling).
- Relay phishing: a look-alike page that asks for GET credentials and forwards them, with no CORS error anywhere.
- Browser-only third-party clients, which is why it is probably
*in the first place.
If you control a deployment, restrict the origin list to the hosts you actually serve.
Note the mismatch: preflight advertises GET, but OPTIONS returns allow: POST, OPTIONS, and GET with a body returned Unexpected Error. Only POST is real.
7. Deep-link validation is a substring test
Medium — client-verified.
js
getAppUrlOpenEvent$.subscribe(({ url }) => {
if (url && url.includes("cbord.com")) {
this._deepLinkPath = new URL(url).pathname.split("/").filter(Boolean);
}
});https://evil.example/cbord.com/patron/settings satisfies includes("cbord.com"). The path segments are then used to navigate after login. The guest dashboard applies an allowlist; the patron dashboard does not — it navigates whatever segments it was given through the normal router.
By itself this is a route-hijack / phishing primitive. It becomes more serious if any route consumes path or query parameters and acts on them (e.g. an order ID or a merchant ID). Any custom scheme or universal link reaching appUrlOpen — including getmobile:// — can trigger it.
The fix on the client side is an allowlist plus an exact-host check; on the server side it is to keep every deep-linkable route parameterised by the session and not by the URL.
The login validator uses the same test
The external login flow applies the same substring check to the session handoff:
js
if (!url.includes("mobileapp_login_validator.php")) return;
sessionId = url.split("?")[1].split("=")[1];There is no host check on url, and the value is assigned straight to get_sessionId. If an attacker can get any page in the login chain to navigate to https://anything/mobileapp_login_validator.php?<attacker-session>, the app adopts that session. That is session fixation, not theft: the attacker still needs a valid session id of their own, and a page in the chain to influence (a compromised or malicious institution login page, a loose IdP redirect, or an open redirect on the hosted site). It is not triggerable by an arbitrary third-party deep link the way #7 is, so treat it as a hardening item: verify the host and parse the query string properly.
8. Client-supplied identifiers and totals are trusted
Medium — client-verified; server impact Unverified.
Several writes carry the acting user's identity as data rather than deriving it:
| Call | What the client sends |
|---|---|
update | { user: { id: ... }, forceOverwrite: true } |
submitOrder | { order: { userId, tax, tip, subTotal, total, discount, ... }, accountId, cvv } |
retrieveOrderList | { userId, merchantId, institutionId, startDate, endDate, orderStatuses, maxReturn } |
retrieveTransactionHistory | { paymentSystemType, queryCriteria } (accounts by ID) |
retrieveUserAddressList | { userId, addressId } |
forceOverwrite: true on update is worth calling out on its own: any stale copy of the profile the client holds will overwrite whatever the server has, including changes made in another session or on the web.
The ordering totals are the other one. submitOrder receives tax, tip, subTotal, total and discount as ordinary fields. If the server does not recompute them from the menu, a caller can name their own price. The app does re-validate (validateOrder, validateOrderItems, validateOrderAddOns) before submitting, which suggests the server is meant to be the authority — but "meant to" is not "verified".
9. Card data as plain JSON
Medium — client-verified.
createAccount (chunk-QGVHKECN.js):
json
{
"accountDisplayName": "My Visa",
"nameOnMedia": "J DOE",
"paymentSystemType": null,
"accountTender": "4",
"mediaValue": "4111111111111111",
"mediaEntryMethod": 1,
"mediaSecurityCode": "123",
"expirationMonth": "09",
"expirationYear": "29",
"usePatronEmail": false,
"billingAddress": { "address1": "...", "city": "", "state": "", "postalcode": "..." },
"externalAccountToken": null,
"externalTransactionToken": null
}The PAN is mediaValue and the CVV is mediaSecurityCode, in cleartext JSON over TLS. No tokenisation is applied on this path (the USAePay hosted-page path exists separately, see Payments). city and state are always sent empty; only address1 and postalcode are collected.
Brand detection is Visa (^4) and MasterCard only; Amex, Discover and JCB fall through to "", which is then coerced to tender "3". That is likely to matter for merchants.
There is no Luhn check on the card form. Luhn exists in the bundle but is used only for the SOA barcode check digit. Client validation on the form is:
| Field | Rule |
|---|---|
| card number | required, pattern("[0-9 ]+") |
| expiry | required, minLength(7) |
| CVV | required, minLength(3), pattern("[0-9.-]*") |
| name | required |
| billing address | required |
| ZIP | required, pattern("[0-9.-]*") |
Both patterns are unanchored, so 12x34 passes. If you are handling cards, the server is the only validator.
10. Barcodes are forgeable from the patron key, and the key is recoverable
High — client-verified.
This section originally said "barcode security reduces to PIN security". That was wrong: the value fed into the barcode generator is the patron key (Settings.CASHLESS_KEY), not the login PIN. The correction makes the finding stronger, not weaker.
soa.general.key is fetched at runtime with getSetting and used locally to generate patron barcodes, together with the user setting CashlessKey:
js
combineLatest(
this.getUserSetting(Settings.CASHLESS_KEY), // patron key
this.getSetting(Setting.SOA_KEY) // institution key
).pipe(map(([cashlessKey, soaKey]) => barcodeService.generateBarcode(cashlessKey, soaKey, i)))The transform (beginBarcodeGeneration) is:
plaintext
garble = base64("NTBGQ0RGM0ZFNDIyQTBBNDY5RkU=") = hex 50FCDF3FE422A0A469FE
xorKey = garble XOR soa.general.key
counter = floor(Date.now() / 1000)
totp = HMAC-SHA256(xorKey, counter) mod 1e9, zero-padded to 9
patron = XOR(first4LE(patronKey), last8LE(totp))
barcode = counter(10) + "1" + patron(10) + luhnDigit(patronKey)Two consequences follow from the shape alone:
- The timestamp is plaintext.
counteris the first 10 digits of the barcode, andpatronKeyis nullable to 4 bytes because it is a numeric patron identifier (the function that packs it is literally namedpatronKeyToByteArray). A barcode is therefore an obfuscated patron ID with a timestamp prefix, not a credential. - The transform is reversible.
BarcodeService.reverseBarcodeDecryption(barcode, key)exists and is the exact inverse: parse the timestamp, regenerate the TOTP, XOR the middle 10 digits, and you get the patron key back as a decimal string. It is dead code in the client, which suggests it is the server-side path used to identify a patron from a scan.
So the attack shape is: Capture one barcode (a photo at a door reader, a shared screenshot, a compromised terminal), recover the patron key, mint barcodes forever — because the only moving part is a public timestamp. The 22-digit string is time-boxed, but the ability to generate one never expires.
Note that the ID: label printed under the barcode on screen is a different value, returned by commerce.retrieveCashlessPatronMobileDisplayMediaValue (institution-configured, often a student/staff number). Decoding the barcode gives the patron key regardless of what that label says — which is also why the label is not a useful integrity check.
The remaining bar is knowing soa.general.key. That is a per-institution key fetched by every client of that institution, so any authenticated patron of the same school/company has it. It is not per-user, and it is not a secret from the user population.
Compare with the barcode's own purpose: a door reader has to accept it offline, so the design must be deterministic and client-derivable. The patron key is CBORD-internal rather than printed on the screen — the ID: label there is the institution's student ID, a different number — which raises the bar slightly, since you cannot read the key off the screen. It does not change the outcome: the key is embedded in every barcode, and one capture plus the institution key is enough to extract it. Revocation (reissue the patron key, rotate the institution key) is the control, not secrecy.
NOTE
The client's own authenticatePinTotp$ — which would have run the PIN through this same encoder before sending it — is dead code in 5.1.20. The PIN screen sends the raw PIN. That is a separate issue (see #2); it does not change the barcode analysis above.
11. Destructive actions need only a session
Medium — client-verified.
js
deleteAccount$() { new Qt("updateUserStatus", {}, true) } // empty params
reportCard$(lost) { new Qt(lost ? "reportCardLost" : "reportCardFound", {}, true) }No password, no PIN, no confirmation token — the session is the only factor. Combined with #1 (a debugging attachment gives you the session), account deletion is one call away.
12. Client-side validation is advisory
Low — client-verified.
Angular validators used by the app:
js
b6 = /^[^\s@]+@[^\s@]+\.[^\s@]+$/ // email
w6 = /^\s*(?=.*[1-9])\d*(?:\.\d{1,2})?\s*$/ // money: ≤2 dp, at least one non-zero digit
A6 = /(?:\s|^)\d+(?=\s|$)/ // phone
Vu = /^(0+)/ // "no leading zeros"Every one of these is bypassed by calling the RPC directly, which is exactly what a custom client does. Password complexity is not enforced in the client at all — the rules come from server-supplied content strings (patron-ui.passwordValidation), which are copy, not controls. changePassword { oldPassword, newPassword } therefore accepts whatever the server accepts.
Deposit amounts are bounded by settings and UI state (quick_amount, tender configuration), and the client does not pre-check the source balance — it relies on the server returning 6112 INSUFFICIENT_FUNDS.
13. Environment override and sandbox cards
Low — client-verified.
overrided_environment is persisted in storage and is not cleared by the logout path. When it is set, the app points at demo / develop / feature1 instead of production, and a sandbox card injector (addUSAePayCreditSandboxCard, PAN 4000100211112222) becomes active whenever the environment is not production.
This is a normal developer affordance leaking into a production binary. It is not a vulnerability by itself, but it does mean a user can be talked into moving their session onto a non-production host, where the same credentials are accepted by a different backend.
14. Error handling leaks nothing (this part is good)
Info — live-verified.
| Case | Response |
|---|---|
| Unknown method | {"response":null,"exception":"Unexpected Error"} |
| Missing session | {"response":null,"exception":"Unexpected Error"} |
| Malformed JSON | {"response":null,"exception":"Unexpected Error"} |
| Invalid session | {"response":null,"exception":"4001|Session not found"} |
| System session used as a user session | {"response":null,"exception":"4002|No user associated with this session"} |
| Bad service consumer | {"response":null,"exception":"9504|Given service consumer does not exist, or the password was invalid."} |
| Unbound device (PIN) | {"response":null,"exception":"9510|Device marked as lost or user logged on to another device"} |
Exceptions are "<code>|<message>" strings. Unknown methods and missing sessions both collapse to Unexpected Error, so there is no method-enumeration oracle and no stack trace disclosure. The one detail worth knowing: 4001 is distinguishable from Unexpected Error, so a caller can tell "your session is dead" from "you did something wrong" — which is necessary for the client's re-auth flow.
Status codes are inconsistent
The HTTP status tells you almost nothing about what happened:
| Failure | Status | Body |
|---|---|---|
| Unknown method, bad params, missing session | 200 | JSON {"response":null,"exception":"..."} |
| Invalid session | 200 | JSON, exception: "4001|Session not found" |
Unknown service path (/json/nope) | 404 | HTML No service was found. |
Missing path segment (/json) | 404 | HTML No service was found. |
So the JSON dispatcher answers 200 for errors, while Spring's own handler answers 404 with text/html;charset=ISO-8859-1. Do not drive retry or error handling off the status code — parse exception, and treat a non-JSON body as a wrong-URL bug.
The HTML error page is static and does not reflect the requested service name (/json/%3Cscript%3E... returns the same fixed string), and the session ID is not echoed back in exception messages. Both are correct behaviour.
15. Service inventory
Nine service paths exist under /json/. All of them answer the same JSON envelope, and an unknown method gives Unexpected Error rather than 404 — so the set below is exhaustive:
plaintext
/json/authentication /json/user /json/userNotification
/json/commerce /json/merchant /json/ordering
/json/institution /json/configuration /json/contentEvery environment is reachable, and GETServices/metrics/ping (a GET, no auth) returns 200 on all seven:
| Host | Ping |
|---|---|
services.get.cbord.com | 200 |
services.get.demo.cbord.com | 200 |
services.get.uk.demo.cbord.com | 200 |
services.get.ca.cbord.com | 200 |
services.get.uk.cbord.com | 200 |
services.get.dev.cbord.com | 200 |
services.get.feature1.cbord.com | 200 |
Since ping needs no credentials, it is the cheapest way to confirm an environment is up without touching any patron data.
16. Session lifecycle observations
Low–Medium — live-verified on demo.
authenticateSystem needs nothing but the public get_mobile credential, and every call mints a new, distinct session. Four consecutive calls returned four different UUIDs, and no limit was hit. Since sessions live server-side for at least several minutes (one minted at the start of this session was still valid four minutes later), unauthenticated callers can accumulate sessions without bound. That is a resource-exhaustion consideration for the session store and a log-volume one for monitoring — not an access-control problem on its own.
The same guidance applies to authenticateUser: until #3 is addressed, every attempt that fails still occupies whatever work the server does before rejecting it.
Error granularity varies by method
A valid-vs-invalid session check is only observable on some methods:
| Call | Bogus session | Valid system session |
|---|---|---|
/json/user retrieve | 4001|Session not found | 4002|No user associated with this session |
/json/commerce retrieveAccounts | 4001|Session not found | — |
/json/institution retrieve | Unexpected Error | Unexpected Error |
institution.retrieve collapses both cases into Unexpected Error, so it is not a session oracle. The user and commerce methods are. That inconsistency is worth knowing when you are debugging a 401-equivalent: a generic Unexpected Error does not mean your session is bad, and 4002 does not mean it expired — it means you sent a system session to a patron method.
What the distinction is actually worth: one bit — "this token is alive, but it is not a patron's". That is only useful to someone who already holds a session ID, and anyone who holds one can already call a method and watch for 4001. It reveals nothing about whose session it is, does not help guess one (122-bit UUID), and cannot be turned into access by itself. Its practical value is confirming server-side session typing for documentation — which is what this page used it for.
The one scenario where it matters is a leaked session id (crash reports, proxy logs, analytics, the WebView debugging hole in #1): the oracle lets an attacker validate a stolen token silently, without triggering a login event. That makes it an amplifier for a session leak, not a vulnerability on its own. The control for that is revocation and short lifetimes — not hiding the error message.
Note also that the inconsistency cuts the other way for clients. Collapsing everything into Unexpected Error (as institution.retrieve does) is safer against the oracle but leaves you unable to tell "session dead" from "you called it wrong". A uniform, documented code is the better trade — CBORD already has the codes, they just are not applied consistently.
A system session surviving several minutes is also informative: sessions are not short-lived, so a stolen session is worth keeping. Design for revocation, not for expiry.
Notes for API consumers
If you are building a client on this API, the client-verified findings above are constraints you inherit:
- Sessions are bearer tokens in the body. Store them in the platform keystore, not
localStorage, and expect them to be readable by anyone who can attach a debugger. - Never trust a
userIdyou received fromretrieveUserIdByCashlessFieldsfor anything other than a display name. It is a lookup result, not an authorisation. - Server-side pricing is the only pricing. Send your totals, but expect them to be ignored — and if they are not, that is a finding on the server, not a feature.
forceOverwrite: truemeans you must re-read the profile before writing it.- Deep links must be allowlisted client-side; the URL is not trustworthy.
- The PIN is not authentication. If you need real authentication, use the password or the platform biometric APIs, and keep the session's lifetime as short as the UX allows.
Reporting
These are observations about a vendor's shipped client. If you need to report a specific issue, send it to the institution running the deployment and to CBORD, with the build number (5.1.20, bundle com.cbord.getmobile) and the reproduction steps. Do not test against production instances you do not operate.