7 ms·
Launch HN: Slauth (YC S22) – auto-generate secure IAM policies for AWS and GCP
Hi HN, We're Daniel and Bruno and working on https://slauth.io/ https://slauth.io/. Slauth.io is a CLI to auto-generate secure IAM policies for AWS, and GCP (Azure in the next few days!). We enable development teams to speed up creating secure policies and reduce over-permissive policies being deployed to the cloud.
Check out the video or give our open-source CLI a try with one of the sample repo's on https://github.com/slauth-io/slauth-cli https://github.com/slauth-io/slauth-cli
https://www.loom.com/share/bd02211659eb4c7f9b335e34094b57cb?sid=f5e84cb2-6939-4d7f-9ed8-90521c90f6de https://www.loom.com/share/bd02211659eb4c7f9b335e34094b57cb?...
We got into the cloud access market by coincidence and were amazed by the amount of money spent on IAM. Current tooling such as http://Ermetic.com http://Ermetic.com and http://wiz.io/ http://wiz.io/ visualize IAM misconfigurations post deployment but don't actually change engineering behavior, leaving organizations in a constant loop of engineers deploying over-permissive policies ⇒ security engineers/CISO's getting alerts ⇒ Jira tickets created begging developers to remediate ⇒ New over-permissive policies being deployed again.
We interviewed hundreds of developers and DevOps engineers and discovered two key pain points:
1. *IAM is a Hassle:* Developers despise dealing with IAM intricacies.
2. *Speed vs. Security:* IAM was slowing them down in deploying quality code swiftly.
So the objective is automate policy creation so that developers don't have to deal with it, and harden IAM security pre-deployment.
We employ Large Language Models (currently OpenAI GPT-4) to scan code in any language. Through a series of prompts, we identify service calls and the actions required. The resource name receives a placeholder unless its embedded in the code. We aim in the future to create a static code analyzer in order to not send any source code to LLM's but for now using LLM's is the fastest way to market and somewhat accepted by the industry through the use of Github Copilot etc.
You can use the CLI in the terminal or actually integrate it in your CI/CD and have it become a part of your development team workflow.
Three main questions we receive
1. *Security Concerns:* How can I trust [Slauth.io](http://slauth.io/ http://slauth.io/) to access my source code?
2. *Policy Accuracy:* How can I trust [Slauth.io](http://slauth.io/ http://slauth.io/) creates the right policies?
3. *Differentiation:* How are you different from IAMLive, IAMBic AccessAnalyzer or Policy Sentry?
To address the first concern, we don't access your code directly. Instead, we offer a CLI that integrates into your CI/CD pipeline, allowing local code scanning. http://slauth.io/ http://slauth.io/ uses your OpenAI key to convert the code into a secure policy, with the option to output results to *`stdout`* or a file for artifact upload and download. That does mean OpenAI has access to the source code located in the path you set to be scanned as we need to know which SDK calls are performed to generate the policies.
We have extensively tested it on AWS , Typescript and GPT 4 with very good results (>95% accuracy). We do know these accuracies drop when using GPT 3.5 so if possible, use GPT 4 as we are improving the prompts. GCP and Azure have been tested less but the results when using GPT 4 seem equally high. We also have experienced some hallucinations but they have not effected the outcome of a secure policy but merely the structure of how the policy is generated. That is not to say that it is 100% reliable hence we aim to provide toolings to double check policies through policy simulators and other means.
Compared to competitors, we focus mainly on generating secure policies pre-deployment and automating as much as possible. We were inspired by IAMLive but it wasn't as scalable to use across development teams. Policy Sentry is great for templates but with http://Slauth.io http://Slauth.io you actually get a granular least privilege policy. Lastly, access analyzer is used to harden security policies which have already been deployed which is similar to other cloud scanning tools and creates a strange reactive process to security. The new access-analyzer feature checks policy diffs in your CDK but again doesn't actually generate the policy pre-deployment.
We recognise some engineers are very capable of creating secure policies but similar to using Checkov and TFscan in the context of IaC deployment, we believe using Slauth.io will become a necessity in your CI/CD when deploying service permissions to make sure no IAM misconfiguration appear in the cloud.
Would love to get your feedback and feel free to interact on our Github repo and join our Slack community.
- verdverm 3y agoRepost: https://news.ycombinator.com/item?id=34038663 https://news.ycombinator.com/item?id=34038663 (11 months ago) > We employ Large Language Models (currently OpenAI GPT-4) For IAM, this seems like a disaster waiting to happen. Combining hallucination problems with security settings is not a path I would consider
- DanielSlauth 3y agoDo you think humans are doing a better job? Research shows that 95% of the permissions granted to users aren't used which creates huge problems and is a reason for spending millions in security tools. Why not use Slauth and other checks such as policy simulators to get tightened policies pre-deployed
- verdverm 3y agoI'm not your target user, I don't feel the priority on this problem even though our permissions are more permissive than we'd like. Thing is, to rein them in typically requires application changes. You cannot just sprinkle magic LLM dust on IAM and make things better. My concern is for those who blindly trust LLMs. Security posturing is not the place to be an early adopter of AI tools. You have to understand both IAM and system architecture to know if what the LLM is saying is correct, so where does that leave us? I think they can be an extra pair of eyes, but not the driver. Still, there is a signal to noise problem that remains, due to the inherent hallucinations.
- thehucklecat 3y agowhat kind of application changes are you thinking it would equire? my policies are definitely too broad, but feels like I should be able to tighten them up without changing code. (just potentially breaking things if I get it wrong and go too tight).
- verdverm 3y agoSome scenarios 1. The application has to start using credentials for the first time, or consume them a different way. For example, stop consuming an environment variable and rely on a service account. 2. You have to change ops to support new workflows. Often you have to put approval workflows in place because fewer people can do things and you want only the machines touching production 3. You have to change human behaviors and habits (this is the real hard one). I've had to revert changes because the increased security blocked developers and they don't have time to adapt for the next deadline. 4. Getting parity in local development workflows is also challenging. How and where do you match vs except from IAM parity? 5. Should I give the current server access to a particular cloud service/resource or break out that particular function into a lambda and minimize the permissions there? You have to think through the implications of a breach and how/where you want to limit the blast radius. 6. This is probably obvious, but implementing application level controls, like API endpoint permissioning. IAM is not limited to cloud infra