CODEWITHSUNDEEP
apirest
Marlon
Marlon

Reputation: 20312

REST API responses based on authentication, best practices?

I have an API with endpoint GET /users/{id} which returns a User object. The User object can contain sensitive fields such as cardLast4, cardBrand, etc.

{
    firstName: ...,
    lastName: ...,
    cardLast4: ...,
    cardBrand: ...
}

If the user calls that endpoint with their own ID, all fields should be visible. However, if it is someone elses ID then cardLast4 and cardBrand should be hidden.

I want to know what are the best practices here for designing my response. I see three options:

Option 1. Two DTOs, one with all fields and one without the hidden fields:

// OtherUserDTO
{
    firstName: ...,
    lastName: ...,  // cardLast4 and cardBrand hidden
}

I can see this becoming out of hand with DTOs based on role, what if now I have UserDTOForAdminRole, UserDTOForAccountingRole, etc... It looks like it quickly gets out of hand with the number of potential DTOs.

Option 2. One response object being the User, but null out the values that the user should not be able to see.

{
    firstName: ...,
    lastName: ...,
    cardLast4: null, // hidden
    cardBrand: null  // hidden
}

Option 3. Create another endpoint such as /payment-methods?userId={userId} even though PaymentMethod is not an entity in my database. This will now require 2 api calls to get all the data. If the userId is not their own, it will return 403 forbidden.

{
    cardLast4: ...,
    cardBrand: ...
}

What are the best practices here?

Upvotes: 2

Views: 1607

Answers (2)

VoiceOfUnreason
VoiceOfUnreason

Reputation: 57249

I have an API with endpoint GET /users/{id} which returns a User object.

In general, it may help to reframe your thinking -- resources in REST are generalizations of documents (think "web pages"), not generalizations of objects. "HTTP is an application protocol whose application domain is the transfer of documents over a network" -- Jim Webber, 2011

If the user calls that endpoint with their own ID, all fields should be visible. However, if it is someone elses ID then cardLast4 and cardBrand should be hidden.

Big picture view: in HTTP, you've got a bit of tension between privacy (only show documents with sensitive information to people allowed access) and caching (save bandwidth and server pressure by using copies of documents to satisfy more than one request).

Cache is an important architectural constraint in the REST architectural style; that's the bit that puts the "web scale" in the world wide web.

OK, good news first -- HTTP has special rules for caching web requests with Authorization headers. Unless you deliberately opt-in to allowing the responses to be re-used, you don't have to worry the caching.

Treating the two different views as two different documents, with different identifiers, makes almost everything easier -- the public documents are available to the public, the sensitive documents are locked down, operators looking at traffic in the log can distinguish the two different views because the logged identifier is different, and so on.

The thing that isn't easier: the case where someone is editing (POST/PUT/PATCH) one document and expecting to see the changes appear in the other. Cache-invalidation is one of the two hard problems in computer science. HTTP doesn't have a general purpose mechanism that allows the origin server to mark arbitrary documents for invalidation - successful unsafe requests will invalidate the effective-target-uri, the Location, the Content-Location, and that's it... and all three of those values have other important uses, making them more challenging to game.

Documents with different absolute-uri are different documents, and those documents, once copied from the origin server, can get out of sync.

This is the option I would normally choose - a client looking at cached copies of a document isn't seeing changes made by the server

OK, you decide that you don't like those trade offs. Can we do it with just one resource identifier? You immediately lose some clarity in your general purpose logs, but perhaps a bespoke logging system will get you past that.

You probably also have to dump public caching at this point. The only general purpose header that changes between the user allowed to look at the sensitive information and the user who isn't? That's the authorization header, and there's no "Vary" mechanism on authorization.

You've also got something of a challenge for the user who is making changes to the sensitive copy, but wants to now review the public copy (to make sure nothing leaked? or to make sure that the publicly visible changes took hold?)

There's no general purpose header for "show me the public version", so either you need to use a non standard header (which general purpose components will ignore), or you need to try standardizing something and then driving adoption by the implementors of general purpose components. It's doable (PATCH happened, after all) but it's a lot of work.

The other trick you can try is to play games with Content-Type and the Accept header -- perhaps clients use something normal for the public version (ex application/json), and a specialized type for the sensitive version (application/prs.example-sensitive+json).

That would allow the origin server to use the Vary header to indicate that the response is only suitable if the same accept headers are used.

Once again, general purpose components aren't going to know about your bespoke content-type, and are never going to ask for it.

The standardization route really isn't going to help you here, because the thing you really need is that clients discriminate between the two modes, where general purpose components today are trying to use that channel to advertise all of the standardized representations that they can handle.

I don't think this actually gets you anywhere that you can't fake more easily with a bespoke header.

REST leans heavily into the idea of using readily standardizable forms; if you think this is a general problem that could potentially apply to all resources in the world, then a header is the right way to go. So a reasonable approach would be to try a custom header, and get a bunch of experience with it, then try writing something up and getting everybody to buy in.

If you want something that just works with the out of the box web that we have today, use two different URI and move on to solving important problems.

Upvotes: 1

Evert
Evert

Reputation: 99533

You're gonna get different opinions about this, but I feel that doing a GET request on some endpoint, and getting a different shape of data depending on the authorization status can be confusing.

So I would be tempted, if it's reasonable to do this, to expose the privileged data via a secondary endpoint. Either by just exposing the private properties there, or by having 2 distinct endpoints, one with the unprivileged data and a second that repeats the data + the new private properties.

I tend to go for option 1 here, because an API endpoint is not just a means to get data. The URI is an identity, so I would want /users/123 to mean the same thing everywhere, and have a second /users/123/secret-properties

Upvotes: 1

Related Questions