Call from ec2 instance to 169.254.169.254 for security credentials returns invalid credentials

amazon ec2amazon-web-servicesauthenticationcredentials

So in theory, if a person needs valid credentials for an Amazon server, instead of hardcoding in their access key/password, one can call out to 169.254.169.254 for credentials to access certain resources like so:

   js = ''
   open('http://169.254.169.254/latest/meta-data/iam/security-credentials/<role>') { |f|
       f.each_line {|line| js += line}
   }
   credentials = JSON.load(js)

   ndnode[:s3_access_key_id] = credentials['AccessKeyId']
   ndnode[:s3_secret_access_key] = credentials['SecretAccessKey']

and then using the access stuff here:

   conn = AWS::EC2::Base.new(:access_key_id => ndnode[:s3_access_key_id],
       :secret_access_key => ndnode[:s3_secret_access_key])
   # THIS ALWAYS FAILS
   result = conn.describe_instances(:instance_id => instance_id)

I dislike the idea of hardcoding my access key and password into the source, and I'd like a workaround.

1) Am I and my boss correct that this is a way to do that workaround?
2) If yes to 1, what is the correct way of doing it? If no to 1, is there a way to avoid checking credentials into the source (either here or in a config file) and what is it?
3) In response to @Edwin's response, where in the AWS gem API do I put the security token? Boto has been reported to let me connect with the credentials that I'm given, which means forking off a process, and setting some environment variables, so that Ruby can use the Boto connection's asking for information.

Best Answer

Many of the AWS SDKs have support for IAM Roles in EC2 Profiles built in. With .Net, you use a parameterless constructor to use them. Make sure you're using a recent version of the SDK.

Here's Amazon's page on how to use the Ruby SDK with IAM Roles.

Update

Mike Pope has published a nice article about Granting Permission to Launch EC2 Instances with IAM Roles (PassRole Permission) on the AWS Security Blog, which explains the subject matter from an AWS point of view.

Initial Answer

Skaperen's answer is partially correct (+1), but slightly imprecise/misleading as follows (the explanation seems a bit too complex for a comment, hence this separate answer):

To launch an EC2 instance with an IAM role requires administrative access to the IAM facility.

This is correct as such and points towards the underlying problem, but the required administrative permissions are rather limited, so the following conclusion ...

Because IAM roles grant permissions, there is clearly a security issue to be addressed. You would not want IAM roles being a means to allow permission escalation.

... is a bit misleading, insofar the potential security issue can be properly addressed. The subject matter is addressed in Granting Applications that Run on Amazon EC2 Instances Access to AWS Resources:

You can use IAM roles to manage credentials for applications that run on Amazon EC2 instances. When you use roles, you don't have to distribute AWS credentials to Amazon EC2 instances. Instead, you can create a role with the permissions that applications will need when they run on Amazon EC2 and make calls to other AWS resources. When developers launch an Amazon EC2 instance, they can specify the role you created to associate with the instance. Applications that run on the instance can then use the role credentials to sign requests.

Now, within the use case at hand the mentioned developers [that] launch an Amazon EC2 instance are in fact EC2 instances themselves, which appears to yield the catch 22 security issue Skaperen outlined. That's not really the case though as illustrated by the sample policy in section Permissions Required for Using Roles with Amazon EC2 :

{
   "Version": "2012-10-17",
   "Statement": [{
      "Effect":"Allow",
      "Action":"iam:PassRole",
      "Resource":"*"
    },
    {
      "Effect":"Allow",
      "Action":"iam:ListInstanceProfiles",
      "Resource":"*"
    },
    {
      "Effect":"Allow",
      "Action":"ec2:*",
      "Resource":"*"
    }]
}

So iam:PassRole is in fact the only IAM permission required, and while technically of administrative nature, this isn't that far reaching - of course, the sample policy above would still allow to escalate permissions by means of listing and in turn passing any available role, but this can be prevented by specifying only those roles that are desired/safe to pass for the use case at hand - this is outlined in section Restricting Which Roles Can Be Passed to Amazon EC2 Instances (Using PassRole):

You can use the PassRole permission to prevent users from passing a role to Amazon EC2 that has more permissions than the user has already been granted, and then running applications under the elevated privileges for that role. In the role policy, allow the PassRole action and specify a resource (such as arn:aws:iam::111122223333:role/ec2Roles/*) to indicate that only a specific role or set of roles can be passed to an Amazon EC2 instance.

The respective sample policy illustrates exactly matches the use case at hand, i.e. grants permission to launch an instance with a role by using the Amazon EC2 API:

{
  "Version": "2012-10-17",
  "Statement": [{
      "Effect":"Allow",
      "Action":"ec2:RunInstances",
      "Resource":"*"
    },
    {
      "Effect":"Allow",
      "Action":"iam:PassRole",
      "Resource":"arn:aws:iam::123456789012:role/Get-pics"
    }]
}

Best Answer

Related Solutions

Can windows credentials be stored for ‘All Users’

How to Specify an IAM Role for an Amazon EC2 Instance via AWS CLI

Update

Initial Answer

Related Topic