Skip to content

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/*.js and capacitor.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 ​

#FindingSeverityBasis
1WebView remote debugging enabled in the shipped buildHighClient-verified
2PIN is an unsalted client-side SHA-256 with no persistent lockoutHighClient-verified
3No auth throttling on the demo environmentHighLive-verified
4userId is taken from the request, not the session, in guest deposit flowsHighClient-verified (impact Unverified)
5Photo endpoints take bare photoId/userId (government-ID photos)HighClient-verified (impact Unverified)
6Access-Control-Allow-Origin: * with preflight allowedMediumLive-verified
7Deep-link handling accepts any URL containing cbord.comMediumClient-verified
8Profile/order/transaction writes trust client-supplied identifiers and totalsMediumClient-verified (impact Unverified)
9Card PAN and CVV sent as plain JSON fieldsMediumClient-verified
10Barcodes are forgeable: a captured barcode + institution key yields the patron keyHighClient-verified
11Destructive actions (delete account, report card lost) need only a sessionMediumClient-verified
12Client-side validation is advisory onlyLowClient-verified
13Environment override survives logout; sandbox card injection off-prodLowClient-verified
16Unauthenticated callers can mint unlimited system sessionsLowLive-verified
14Generic error handling leaks nothingInfo (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.androidScheme is "http", not Capacitor's default "https". The WebView origin becomes http://localhost rather than https://localhost, which removes the secure-context assumption from anything that relies on it.
  • ios.scheme says "Debug", but Info.plist actually registers getmobile (and capacitor). 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:

  1. retrieveUserIdByCashlessFields is an unauthenticated-ish lookup oracle: it takes institutionId, a session, and arbitrary cashlessData.lookupFields, and returns a userId. 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.
  2. retrieveAccountsByUser / retrieveDepositAccountsByUser take userId with only a session interest. If the server does not verify that the session owns that userId, they enumerate anyone's accounts.
  3. depositForUserFromAnyAccount takes fromAccountId alongside userId. The name says what it is for — a guest charging a card they have on file — but if userId and fromAccountId are 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=86400

Preflight 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.

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:

CallWhat 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:

FieldRule
card numberrequired, pattern("[0-9 ]+")
expiryrequired, minLength(7)
CVVrequired, minLength(3), pattern("[0-9.-]*")
namerequired
billing addressrequired
ZIPrequired, 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:

  1. The timestamp is plaintext. counter is the first 10 digits of the barcode, and patronKey is nullable to 4 bytes because it is a numeric patron identifier (the function that packs it is literally named patronKeyToByteArray). A barcode is therefore an obfuscated patron ID with a timestamp prefix, not a credential.
  2. 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.

CaseResponse
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:

FailureStatusBody
Unknown method, bad params, missing session200JSON {"response":null,"exception":"..."}
Invalid session200JSON, exception: "4001|Session not found"
Unknown service path (/json/nope)404HTML No service was found.
Missing path segment (/json)404HTML 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/content

Every environment is reachable, and GETServices/metrics/ping (a GET, no auth) returns 200 on all seven:

HostPing
services.get.cbord.com200
services.get.demo.cbord.com200
services.get.uk.demo.cbord.com200
services.get.ca.cbord.com200
services.get.uk.cbord.com200
services.get.dev.cbord.com200
services.get.feature1.cbord.com200

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:

CallBogus sessionValid system session
/json/user retrieve4001|Session not found4002|No user associated with this session
/json/commerce retrieveAccounts4001|Session not found—
/json/institution retrieveUnexpected ErrorUnexpected 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 userId you received from retrieveUserIdByCashlessFields for 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: true means 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.