Awsviz.dev simplifying AWS IAM policies

https://www.awsviz.dev/

by bscript • 2 years ago

177 143 2 years ago

bscript9• 2 years ago

Sometimes, reading AWS IAM policies can be tough for me. I prefer visuals, so I often use the IAM Policy Simulator. To make things even easier, I built a small tool that turns IAM policies into simple graphs. awsviz.dev is a good tool designed to help users visualize, analyze, and improve their AWS IAM policies.

More details: https://medium.com/@Bohr/introducing-awsviz-dev-simplifying-...

kaladin-jasnah• 2 years ago

Should this be a "Show HN" post?

bscript9• 2 years ago

First time here, did not know about Show NH

lhousa• 2 years ago

Just skimmed through the post but how is it different from a plain json visualiser like https://jsoncrack.com?

l3x4ur1n• 2 years ago

First thing that came to me after reading the url https://en.m.wikipedia.org/wiki/Auschwitz_concentration_camp

bdcravens• 2 years ago

Perhaps it would make sense to link to the repo on the page? As best I can tell, you can easily self-host your tool (would need to update the redirects in the index.html).

https://github.com/BourAbdelhadi/awsviz

zarzavat2• 2 years ago

This is a very bad name for a product.

bscript9• 2 years ago

You might be right. My focus wasn't on the name; I just wanted to create something useful for my day-to-day job and share it with others. The goal was never to commercialize the product … so maybe that’s why the name was bad!

sclangdon• 2 years ago

He may be referring to the fact that it could be pronounced Auschwitz. I must admit, my immediate thought on reading the name was "why would someone name their app after a concentration camp?"

linkgoron• 2 years ago

yes, I immediately thought that the pronunciation was Auschwitz...

cyberax4• 2 years ago

IAM policies can be so complex, that become close to unusable.

Use multiple AWS accounts, and keep your policies simple. One account for DB, one for the backend servers, etc. Each environment (prod, staging, dev) also gets its own set of accounts.

This way, a misconfigured policy won't give admin access to everything.

potamic• 2 years ago

Wouldn't that lead to cross account policies, which appear to be even more quirky?

devonkim• 2 years ago

Yeah, error messages start to become more opaque as well which makes debugging even tougher, which is kind of the opposite of the point of using multiple accounts. But really, AWS not having proper namespaces in its constructs that’s ubiquitously supported (IAM paths were attempted. Attempted) hampers a lot of things

cyberax4• 2 years ago

In my practice? Not really.

For resources like databases, you don't need cross-account access if you're using internal DB authentication systems. For IAM-based DB authentication, you can simply write policies to trust the target accounts.

Occasionally, you'll need to create a cross-account trust (via AssumeRole), but it's not at all that frequent.

My personal wish is for AWS to allow account _names_ instead of ID numbers in policies.

laurent_du• 2 years ago

I honestly can't imagine a situation where this would be a good advice. Can you give an example of such an IAM policy?

cyberax4• 2 years ago

For example, if you want your CI/CD to deploy to CloudFormation and allow it to generate IAM resources, then it's essentially root-level access. Because you can simply create an IAM role that gives admin permissions to you.

Or even without that, there are plenty of footguns. AWS has a good blog post: https://aws.amazon.com/blogs/security/protect-sensitive-data...

Hikikomori3• 2 years ago

One account per system and environment with shared vpcs is great.

shakiXBT2• 2 years ago

Having one account per database/backend/frontend is not only overkill, but actually a bad practice. You're going to have to expose your DB to the internet instead of having everything inside a single VPC.

What you should do instead is have one account per environment (as you said).

kroolik• 2 years ago

You can peer-connect vpcs cross-account

tenplusfive• 2 years ago

I've recently stumbled upon the possibility to share a VPC and use one VPC with multiple accounts: https://docs.aws.amazon.com/whitepapers/latest/building-scal...

I'm honestly not sure if thats a great idea, but this might be a possible way to do one account per DB/backend/frontend in a somewhat sane way.

Hikikomori3• 2 years ago

You'll find that a plan like this is not overkill once you outgrow single accounts. Though I would do one account per system with Shared VPCs instead.

chippiewill• 2 years ago

We use peered VPCs at work. We have a central account per environment that has the VPC that's shared to all the other accounts in that environment for databases etc.

To be honest, I'd probably prefer a single account per environment. But managing the IAM for that would be much more work.

cyberax4• 2 years ago

Having one account per database/backend/frontend is not only overkill, but actually a bad practice.

That's how AWS works internally. A team can easily have several hundred accounts: one for each region, and for each env.

You absolutely need tools to manage them, and AWS is not great in this regard. IAM Identity Center is a good first step, but its usability sucks compared to the AWS internal tool (called "Isengard").

You're going to have to expose your DB to the internet instead of having everything inside a single VPC.

There are several ways to NOT do this. The easiest one is to use IPv6 with your own block (you can get it from ARIN for around $100). Then split it into "public" and "private" subnets, and install a network ACL prohibiting external connections into the private subnet.

timendum• 2 years ago

I think Policy Details card should have a scrollbar, but it is set to "overflow: hidden".

bscript9• 2 years ago

Good point. Thanks

egorfine16• 2 years ago

Okay, so I have no idea what to do with that web. I copied one of the complicated policy JSONs from AWS, now where do I paste it? What's there to upload? In zip?

bscript9• 2 years ago

paste it to the IAM Policy JSON input or zip your json files and upload the zip.

egorfine16• 2 years ago

Ah, I can see you added JSON input. Tried it.

It looks like the "The user is allowed to:" part is the most important one and should be on top. The graph visualization does not make any sense on my random JSON policy I have just pasted.

egorfine16• 2 years ago

I have been discussing IAM with a couple of AWS engineers from that team a few years ago. I have tried to convince them to implement something actually sane non-corporate developers, because IAM is complicated way beyond a point of being usable. I have seen so many people just slam the root credentials into config in order to never touch IAM. And yes, me included, and yes, it's a shameful practice, don't do that. Take a day off, go on a hike, watch the sunset, meditate and embrace the inevitable: yes IAM is incredibly bad and there is no way around.

(I was heavily using AWS since inception, way before IAM was invented).

My speech fell on deaf ears, because IAM is clear as sky to its inventors and they fail to see what's the problem in it and corporate customers are happy to employ one or two people solely dedicated to learning and managing IAM.

Anyways. There is no way around IAM. And just like with systemd you better embrace it and learn it and it turns not that terrible.

JackSlateur5• 2 years ago

I find IAM to be a great product. I cannot imagine how we could make it different, without removing some of its capabilities: after all, this is nothing but a list of <who, what, on which> permissions

MrBuddyCasino• 2 years ago

I cannot imagine how we could make it different

This seems almost bait.

nprateem• 2 years ago

Well, for a start, you could have a recorder that actually shows all the relevant permissions for a particular API call so users can work out what they should set permissions on (including interactions with SCPs and anything else that could affect a decision).

egorfine16• 2 years ago

I tend to agree with you that the idea of a list of "who, what, which" is straightforward and probably is the right way of doing things. I agree that permissions is inherently a hard problem.

I disagree that IAM specifically is a great product. It's great if you learn it, but learning permissions system never adds anything to the bottom line. It's an evergrowing technical debt at best. People interested in learning permissions system are typically people interested in developing one. Users are never happy with permissions systems because more often than not it's a nuisance.

In my view IAM is an incredibly overengineered list of who, what, which, suitable for corporate granularity but then too complex to be used by a startup or a project.

myaccountonhn• 2 years ago

I don’t think the language is bad, but maybe improve the policy simulator, make it easier to understand what policies are require and also make it easier to find and reference different arns.

whs• 2 years ago

I wish it is a list of <who, what, which>. Right now you can't even get a comprehensive list of people who can access this S3 object. Add assume roles, conditional access, cross account, per-service object level policy into the mix I don't think it's even actually possible for AWS to implement that.

I found GCP's access control to be much simpler but more limited than AWS. They're adding complexity though with conditional access. In GCP the "who" in most case is an email (Google Account, Google Groups, service account)

tyingq5• 2 years ago

The way it evolved makes it complicated. That you have normal policy, resource attached policy, SCP, Assumed roles, etc, etc.

That spreads out the actual end resulting policy into a bunch of disparate corners that's hard to unravel.

There's tools to see "can this specific user/role/service get to this thing". But because of the above, there's no one place to see "who can/cannot get to this thing".

randomtoast• 2 years ago

AWS is good at building abstractions on top of their already existing features, e.g. AWS App Runner. Maybe there could be an abstraction on top of IAM that does not allow for all the fine-grained permissions settings and options that IAM has, but has much simpler predefined roles which are very well suited for a small startup.

icedchai4• 2 years ago

The main problem is it's a huge time suck. When writing IAC like Terraform, you'll probably spend more time configuring IAM roles and permissions than you do the actual infrastructure. Also, in my experience, nobody reviewing your code will check if it's correct, least privilege, etc. And when you get it wrong (too restrictive), the error messages can be difficult to diagnose, depending on the service. So most people will err on the side of more permissions than needed.

dopylitty• 2 years ago

It’s a little more complicated than that. I’ve run into many instances where a particular Action involves many different Resources.

If you’re trying to do fine grained permissions you have to know every resource that might end up in the request context and then have an entry in a Resource section of a policy for that Resource type. For instance just creating an EC2 (RunInstances) might involve Subnet, Security Group, EBS, image, volume, snapshot, and a few other resource types.

This gets even more complicated when you’re using Condition operators because the conditions are checked against every resource in the request context but each resource type has different valid conditions (eg some resources have tags and some don’t) so you have to split up the policy into numerous statements specific to each resource type.

All of that would be fine if there was any way to actually reliably get the context of a request so you can see exactly what was denied. Sometimes you can get the context via the encoded authorization message in a failed API call but this is usually truncated in CloudTrail or if you’re using IaC tools like Cloudformation.

They’ve done a lot in the past few years to explain why a particular call was denied but none of it beats seeing the context and seeing exactly which part of the policy did or didn’t apply.

wetpaste• 2 years ago

I think it gets hard when an emergent chain of complex trust relationships need to be built and understood. Things like IAM identity center, workload identity, IRSA on EKS, service principals vs roles for accessing other services from a service, resource policies vs principle-level policies and when to use each. Not necessarily intuitive all the time. I don't think it's THAT hard and I understand why some of these things were built this way, but it's a huge complicated ecosystem of services and I understand why it can get confusing to some. Gotta be disciplined about it.

danielheath2• 2 years ago

“Record mode”, where for 24h all permissions are automatically granted on first use, would be an obvious improvement.

The ability to measure what permissions you need and record them automatically would improve the onboarding experience immeasurably.

lijok4• 2 years ago

Cedar, the new language by AWS that's currently used by Verified Access, is looking good; https://www.cedarpolicy.com

egorfine16• 2 years ago

Their mere description on that page makes me shiver.

rirze2• 2 years ago

this is application side, correct?

nerdjon5• 2 years ago

I disagree. IAM does what it’s supposed too when you need to run an organization with very fine gained controls.

People being able to see and interact with certain services but not everything related to those services. Same with services since it’s the same system.

To me the problem isn’t IAM itself but the nested API calls. Which also itself isn’t a problem but we need a better UI to diagnose when something goes wrong.

Cloudtrail isn’t really suitable for this task. A “simple” UI of looking at a role and seeing a “failed calls” would go a long way.

captrb• 2 years ago

There is a pretty simple way to query cloudtrail logs with Athena and its a huge improvement over the normal UI.

jjice• 2 years ago

I have seen so many people just slam the root credentials into config in order to never touch IAM

Anecdotally, at a startup I worked for, our devops and security engineers pulled me into a call once because they needed my help finding where the root credentials were being used in our code. I logged into our dev, staging, and production servers, but they were nowhere to be seen in any place you'd expect AWS creds (like ~/.aws).

Then it hit me. I pulled up our git repo and pulled up a function that handled file upload to s3 for something incredibly unimportant. Right there, in plain text, checked into git. The git blame read something like "4 years ago".

Creds weren't even needed since the AWS SDK does whatever magic to know the creds based on the EC2 instances role. I immediately put up PR just removing the creds as the empty constructor for our SDK used the EC2 role (this pattern was used in multiple other parts of the code base).

The CEO (the author of the code) didn't want to merge it in case it stopped working, despite me demoing in our staging environment and the feature using this code was only used like twice a week.

Thankfully, we convinced him, got it removed from the codebase, and either cycled or deleted the root creds, I don't recall how that worked at the moment.

I wasn't familiar with root creds at the time either, but damn is it scary to think that anyone of the engineers had access to root creds for a company of the size that we were.

And the CEO wrote it like that originally because he didn't want to mess with IAM. I can see why he did it, but man was that a bad idea.

Aperocky• 2 years ago

Not a good sign...

egorfine16• 2 years ago

And the CEO wrote it like that originally because he didn't want to mess with IAM. I can see why he did it, but man was that a bad idea.

This is a very common case. It's okay in the very early development (rarely we start projects with a definition of IAM policies), but then it gets shoved into backlog forever.

js22• 2 years ago

IAM is conceptually straightforward, but it's combinatorial difficult with all the different ways that AWS services interact with it. Support for IAM is also inconsistent across services. I'll give a recent example.

I have EC2 Mac instances in an autoscaling group that are running untrusted code. I've "sandboxed" that code by running it as its own user and blocking that user from reaching the IMDS endpoint with a packet filter on the instance so that the untrusted code, in theory, cannot get instance policy credentials. Nonetheless, I'd like to limit the blast radius should the code somehow escape that sandbox. So I want the instance policy as restricted as possible.

One of the things the instances need to do is set tags on themselves. For this, you can use an IAM condition on the ec2 CreateTags action to say "this instance can call CreateTags, but the instance ID has to be the instance itself". This prevents an instance from setting tags on a different instance in the same autoscaling group.

The instances also need to make a few autoscaling API calls, to complete lifecycle actions (CompleteLifecycleAction), and to enable and disable scaling protection (SetInstanceProtection). Here again, I'd like each instance to only be able to make these calls against itself. Unfortunately, there is no condition you can use with the autoscaling API to similarly limit the calls as you can with the ec2 API. The same condition that works with the ec2 API doesn't do anything with the autoscaling API.

Not helping matters, the documentation is very spread about. Just in the use case I describe above, you need to read at least all of these:

https://docs.aws.amazon.com/service-authorization/latest/ref...

https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-au...

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-poli...

https://docs.aws.amazon.com/autoscaling/ec2/userguide/contro...

js22• 2 years ago

BTW, there's no reason I can see that the condition couldn't work in both cases, but apparently this is up to the API/service to implement. The condition for CreateTags is:

  Condition:
    StringLike:
      aws:userid: "*:${ec2:InstanceID}"

Documented (sorta) across four(!) pages:

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_p...

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-poli...

https://docs.aws.amazon.com/service-authorization/latest/ref...

rirze2• 2 years ago

In my experience, it's fine. I just wish it supported more condition keys across all services. Nothing sucks more than to write a policy with a explicit condition only to bash your head trying to figure out why and then finally realize that restricting for a specific tag for a specific resource+action is not supported.

Aeolun5• 2 years ago

I feel like IAM is not actually that complicated? Most services have permissions that are in direct correspondence with the API calls you want to make. Of course a few of them decided to do mad shit (looking at you API Gateway), and a few others require you to have nearly all permissions to do some of their most common API calls (S3 needs like 15 permissions to set all possible properies on an S3 object).

It’d be nice if AWS could fix the madness and standardize on one List/Update/Create/Delete call per resource, since most services are already like that.

Fire-Dragon-DoL• 2 years ago

Don't they have a table that states api call -> IAM permissions necessary?

That would go a long way into solving the problem

ak217• 2 years ago

I'm not sure how IAM is any more difficult or harder to comprehend than any alternative. I've been using AWS since 2010 and frankly IAM has never been an issue. Can you give some examples?

In any case, IAM and its essential features are not some optional thing; it's actually the prerequisite for AWS existing in its current form. IAM is the most universal AWS service - every other AWS service must use it. It's a loosely coupled symbolic policy computation engine for federated identity and service permissions. The "federated" part is doing A LOT of heavy lifting here: without federation, it's impossible to decouple teams and achieve the organizational velocity that AWS has.

Other cloud providers have ended up re-inventing AWS IAM, sometimes poorly. Although I have to give GCP credit for recently greatly improving their IAM console and permissions error usability.

bfLives• 2 years ago

I think IAM would be a lot easier to interact with from a dev perspective if the error messages were more clear. I suspect that they are sometimes intentionally vague (or misleading) as a kind of security-through-obscurity. For example, S3 returns “file does not exist” errors when the real problem is that the caller doesn’t have permission to access the bucket/prefix.

mauflows• 2 years ago

It's funny, because AWS devs are also a bit guilty of slamming admin credentials and calling it a day.

I was testing out sagemaker studio. I just did the quick setup wizard and the default managed execution role was insanely permissive. I believe read/write to all of the accounts S3 buckets and broad List* for account resources. There are multiple parts of the documentation that also recommended you use this role. It seemed especially wild for a product with so many ways to access. we have good account hygiene but still

vladvasiliu• 2 years ago

the default managed execution role was insanely permissive.

I find this is often the case.

Dowwie• 2 years ago

Is this a claude artifact?

nerdjon5• 2 years ago

Is there somewhere that outlines what is done with the uploads or is this all client side?

I am reluctant to just upload an IAM Policy when that could include bucket names, databases, account names, etc. Things that could expose more information than I would like (both security and product related)

bscript9• 2 years ago

Client side only, you can check the github repo

nerdjon5• 2 years ago

Ahh thank you, I did not realize this was open source. I might recommend putting a link to the github repo at the top or something, unless I am just looking right past it I don't see that anywhere (the most I see is the github script to copy)

ckozlowski2• 2 years ago

Very cool.

What are you using to rate severity in the security scan? Is there a full list of checks being performed?

I recommend having both resources in your documentation. If you're referencing another document, link to it. That way there's some context to the results as to why a policy author should change it. Just something to add to the improvement list.

Looks good overall! Thanks for sharing!

koromak• 2 years ago

The best part of any new stack: Spending 4 days repeatedly destroying and creating it while you figure out a single god damn policy to add to the project at a time

Aeolun5• 2 years ago

Still better than just giving it all permissions to be done with it? At least it made me feel a little bit happy when I did this the first time.

klysm• 2 years ago

I've gotten a lot better at it by being boneheaded about not giving up. By bashing my head into IAM, I've gotten pretty good at figuring out the right set of permissions, roles, etc for cross account stuff to work. It's definitely still a mess a shitty, slow feedback loop, but it's better to have security by default.

rafaelturk• 2 years ago

This like this is what made us leave the cloud and go back to our own private cloud.

JustAnotherJeff• 2 years ago

You just made me want to stop lurking and register to say Thank You. I have a bunch of users that keep producing blatantly wrong IAM policies, I hope such visualisation will help putting some sense in what they write.

Very good and straightforward - thanks a lot for providing the GitHub repo as well as I would never tell them to paste policies on a random website.

tobilg3• 2 years ago

I publish a daily updated AWS IAM dataset at https://github.com/tobilg/aws-iam-data as well as historized managed IAM policies at https://github.com/tobilg/aws-iam-managed-policies

There's also https://www.awsiamdata.com/ which analyzes the AWS IAM data and also contains a changelog. Maybe this helps some people.

You can also query the data from your browser: https://tobilg.com/chat-with-a-duck#heading-explore-aws-iam-...

redeux2• 2 years ago

Thanks for sharing this! Very useful data. The contrast on your dashboard at https://www.awsiamdata.com/ makes it almost impossible to read. You may want to take a look at that.

tobilg3• 2 years ago

Thanks for the feedback, are you using dark mode eventually?

otteromkram• 2 years ago

This is interesting. Is it just a reference package for npm? As in, you can't set/update policies with it or do other IAM ops with it, correct?

tobilg3• 2 years ago

Exactly, it's "just" extracting the AWS IAM data from the publicly available documentation, stores it in multiple formats and publishes a NPM package containing the data with some wrappers/accessors, so that people can theoretically leverage it to build their own tools.

playingalong• 2 years ago

You might consider adding git-scraping label to your repo.

glzone1• 2 years ago

Isn't there a way to basically give your project root in a separate account, then use cloudtrail to figure out what policies it actually needs? I've not been able to get that going myself but it seems like a more efficient approach potentially.

turtlebits2• 2 years ago

You can use Access advisor to see which service your IAM role/user has accessed and when. You can then prune permissions which haven't been recently used.

twosdai• 2 years ago

Let me know when policy updates are no longer eventually consistent. It's the worst experience in the world.

Update you policy, wait for some period of ykme, hopefully test it.

Doesn't work?

Maybe you didn't wait long ebougb, maybe you're dumb. Who knows!? Not me.

Awsviz.dev simplifying AWS IAM policies

Related Stories