guppy_basecaller: env/lib/python3.7/site-packages/boto/sts/connection.py comparison

comparison env/lib/python3.7/site-packages/boto/sts/connection.py @ 0:26e78fe6e8c4 draft

"planemo upload commit c699937486c35866861690329de38ec1a5d9f783"

author	shellac
date	Sat, 02 May 2020 07:14:21 -0400
parents
children

comparison

equal deleted inserted replaced

--1:000000000000
+:26e78fe6e8c4
+# Copyright (c) 2011 Mitch Garnaat http://garnaat.org/
+# Copyright (c) 2011, Eucalyptus Systems, Inc.
+# Copyright (c) 2013 Amazon.com, Inc. or its affiliates.  All Rights Reserved
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+from boto.connection import AWSQueryConnection
+from boto.provider import Provider, NO_CREDENTIALS_PROVIDED
+from boto.regioninfo import RegionInfo
+from boto.sts.credentials import Credentials, FederationToken, AssumedRole
+from boto.sts.credentials import DecodeAuthorizationMessage
+import boto
+import boto.utils
+import datetime
+import threading
+_session_token_cache = {}
+class STSConnection(AWSQueryConnection):
+"""
+AWS Security Token Service
+The AWS Security Token Service is a web service that enables you
+to request temporary, limited-privilege credentials for AWS
+Identity and Access Management (IAM) users or for users that you
+authenticate (federated users). This guide provides descriptions
+of the AWS Security Token Service API.
+For more detailed information about using this service, go to
+`Using Temporary Security Credentials`_.
+For information about setting up signatures and authorization
+through the API, go to `Signing AWS API Requests`_ in the AWS
+General Reference . For general information about the Query API,
+go to `Making Query Requests`_ in Using IAM . For information
+about using security tokens with other AWS products, go to `Using
+Temporary Security Credentials to Access AWS`_ in Using Temporary
+Security Credentials .
+If you're new to AWS and need additional technical information
+about a specific AWS product, you can find the product's technical
+documentation at `http://aws.amazon.com/documentation/`_.
+We will refer to Amazon Identity and Access Management using the
+abbreviated form IAM. All copyrights and legal protections still
+apply.
+"""
+DefaultRegionName = 'us-east-1'
+DefaultRegionEndpoint = 'sts.amazonaws.com'
+APIVersion = '2011-06-15'
+def __init__(self, aws_access_key_id=None, aws_secret_access_key=None,
+is_secure=True, port=None, proxy=None, proxy_port=None,
+proxy_user=None, proxy_pass=None, debug=0,
+https_connection_factory=None, region=None, path='/',
+converter=None, validate_certs=True, anon=False,
+security_token=None, profile_name=None):
+"""
+:type anon: boolean
+:param anon: If this parameter is True, the ``STSConnection`` object
+will make anonymous requests, and it will not use AWS
+Credentials or even search for AWS Credentials to make these
+requests.
+"""
+if not region:
+region = RegionInfo(self, self.DefaultRegionName,
+self.DefaultRegionEndpoint,
+connection_cls=STSConnection)
+self.region = region
+self.anon = anon
+self._mutex = threading.Semaphore()
+provider = 'aws'
+# If an anonymous request is sent, do not try to look for credentials.
+# So we pass in dummy values for the access key id, secret access
+# key, and session token. It does not matter that they are
+# not actual values because the request is anonymous.
+if self.anon:
+provider = Provider('aws', NO_CREDENTIALS_PROVIDED,
+NO_CREDENTIALS_PROVIDED,
+NO_CREDENTIALS_PROVIDED)
+super(STSConnection, self).__init__(aws_access_key_id,
+aws_secret_access_key,
+is_secure, port, proxy, proxy_port,
+proxy_user, proxy_pass,
+self.region.endpoint, debug,
+https_connection_factory, path,
+validate_certs=validate_certs,
+security_token=security_token,
+profile_name=profile_name,
+provider=provider)
+def _required_auth_capability(self):
+if self.anon:
+return ['sts-anon']
+else:
+return ['hmac-v4']
+def _check_token_cache(self, token_key, duration=None, window_seconds=60):
+token = _session_token_cache.get(token_key, None)
+if token:
+now = datetime.datetime.utcnow()
+expires = boto.utils.parse_ts(token.expiration)
+delta = expires - now
+if delta < datetime.timedelta(seconds=window_seconds):
+msg = 'Cached session token %s is expired' % token_key
+boto.log.debug(msg)
+token = None
+return token
+def _get_session_token(self, duration=None,
+mfa_serial_number=None, mfa_token=None):
+params = {}
+if duration:
+params['DurationSeconds'] = duration
+if mfa_serial_number:
+params['SerialNumber'] = mfa_serial_number
+if mfa_token:
+params['TokenCode'] = mfa_token
+return self.get_object('GetSessionToken', params,
+Credentials, verb='POST')
+def get_session_token(self, duration=None, force_new=False,
+mfa_serial_number=None, mfa_token=None):
+"""
+Return a valid session token.  Because retrieving new tokens
+from the Secure Token Service is a fairly heavyweight operation
+this module caches previously retrieved tokens and returns
+them when appropriate.  Each token is cached with a key
+consisting of the region name of the STS endpoint
+concatenated with the requesting user's access id.  If there
+is a token in the cache meeting with this key, the session
+expiration is checked to make sure it is still valid and if
+so, the cached token is returned.  Otherwise, a new session
+token is requested from STS and it is placed into the cache
+and returned.
+:type duration: int
+:param duration: The number of seconds the credentials should
+remain valid.
+:type force_new: bool
+:param force_new: If this parameter is True, a new session token
+will be retrieved from the Secure Token Service regardless
+of whether there is a valid cached token or not.
+:type mfa_serial_number: str
+:param mfa_serial_number: The serial number of an MFA device.
+If this is provided and if the mfa_passcode provided is
+valid, the temporary session token will be authorized with
+to perform operations requiring the MFA device authentication.
+:type mfa_token: str
+:param mfa_token: The 6 digit token associated with the
+MFA device.
+"""
+token_key = '%s:%s' % (self.region.name, self.provider.access_key)
+token = self._check_token_cache(token_key, duration)
+if force_new or not token:
+boto.log.debug('fetching a new token for %s' % token_key)
+try:
+self._mutex.acquire()
+token = self._get_session_token(duration,
+mfa_serial_number,
+mfa_token)
+_session_token_cache[token_key] = token
+finally:
+self._mutex.release()
+return token
+def get_federation_token(self, name, duration=None, policy=None):
+"""
+Returns a set of temporary security credentials (consisting of
+an access key ID, a secret access key, and a security token)
+for a federated user. A typical use is in a proxy application
+that is getting temporary security credentials on behalf of
+distributed applications inside a corporate network. Because
+you must call the `GetFederationToken` action using the long-
+term security credentials of an IAM user, this call is
+appropriate in contexts where those credentials can be safely
+stored, usually in a server-based application.
+**Note:** Do not use this call in mobile applications or
+client-based web applications that directly get temporary
+security credentials. For those types of applications, use
+`AssumeRoleWithWebIdentity`.
+The `GetFederationToken` action must be called by using the
+long-term AWS security credentials of the AWS account or an
+IAM user. Credentials that are created by IAM users are valid
+for the specified duration, between 900 seconds (15 minutes)
+and 129600 seconds (36 hours); credentials that are created by
+using account credentials have a maximum duration of 3600
+seconds (1 hour).
+The permissions that are granted to the federated user are the
+intersection of the policy that is passed with the
+`GetFederationToken` request and policies that are associated
+with of the entity making the `GetFederationToken` call.
+For more information about how permissions work, see
+`Controlling Permissions in Temporary Credentials`_ in Using
+Temporary Security Credentials . For information about using
+`GetFederationToken` to create temporary security credentials,
+see `Creating Temporary Credentials to Enable Access for
+Federated Users`_ in Using Temporary Security Credentials .
+:type name: string
+:param name: The name of the federated user. The name is used as an
+identifier for the temporary security credentials (such as `Bob`).
+For example, you can reference the federated user name in a
+resource-based policy, such as in an Amazon S3 bucket policy.
+:type policy: string
+:param policy: A policy that specifies the permissions that are granted
+to the federated user. By default, federated users have no
+permissions; they do not inherit any from the IAM user. When you
+specify a policy, the federated user's permissions are intersection
+of the specified policy and the IAM user's policy. If you don't
+specify a policy, federated users can only access AWS resources
+that explicitly allow those federated users in a resource policy,
+such as in an Amazon S3 bucket policy.
+:type duration: integer
+:param duration: The duration, in seconds, that the session
+should last. Acceptable durations for federation sessions range
+from 900 seconds (15 minutes) to 129600 seconds (36 hours), with
+43200 seconds (12 hours) as the default. Sessions for AWS account
+owners are restricted to a maximum of 3600 seconds (one hour). If
+the duration is longer than one hour, the session for AWS account
+owners defaults to one hour.
+"""
+params = {'Name': name}
+if duration:
+params['DurationSeconds'] = duration
+if policy:
+params['Policy'] = policy
+return self.get_object('GetFederationToken', params,
+FederationToken, verb='POST')
+def assume_role(self, role_arn, role_session_name, policy=None,
+duration_seconds=None, external_id=None,
+mfa_serial_number=None,
+mfa_token=None):
+"""
+Returns a set of temporary security credentials (consisting of
+an access key ID, a secret access key, and a security token)
+that you can use to access AWS resources that you might not
+normally have access to. Typically, you use `AssumeRole` for
+cross-account access or federation.
+For cross-account access, imagine that you own multiple
+accounts and need to access resources in each account. You
+could create long-term credentials in each account to access
+those resources. However, managing all those credentials and
+remembering which one can access which account can be time
+consuming. Instead, you can create one set of long-term
+credentials in one account and then use temporary security
+credentials to access all the other accounts by assuming roles
+in those accounts. For more information about roles, see
+`Roles`_ in Using IAM .
+For federation, you can, for example, grant single sign-on
+access to the AWS Management Console. If you already have an
+identity and authentication system in your corporate network,
+you don't have to recreate user identities in AWS in order to
+grant those user identities access to AWS. Instead, after a
+user has been authenticated, you call `AssumeRole` (and
+specify the role with the appropriate permissions) to get
+temporary security credentials for that user. With those
+temporary security credentials, you construct a sign-in URL
+that users can use to access the console. For more
+information, see `Scenarios for Granting Temporary Access`_ in
+AWS Security Token Service .
+The temporary security credentials are valid for the duration
+that you specified when calling `AssumeRole`, which can be
+from 900 seconds (15 minutes) to 3600 seconds (1 hour). The
+default is 1 hour.
+The temporary security credentials that are returned from the
+`AssumeRoleWithWebIdentity` response have the permissions that
+are associated with the access policy of the role being
+assumed and any policies that are associated with the AWS
+resource being accessed. You can further restrict the
+permissions of the temporary security credentials by passing a
+policy in the request. The resulting permissions are an
+intersection of the role's access policy and the policy that
+you passed. These policies and any applicable resource-based
+policies are evaluated when calls to AWS service APIs are made
+using the temporary security credentials.
+To assume a role, your AWS account must be trusted by the
+role. The trust relationship is defined in the role's trust
+policy when the IAM role is created. You must also have a
+policy that allows you to call `sts:AssumeRole`.
+**Important:** You cannot call `Assumerole` by using AWS
+account credentials; access will be denied. You must use IAM
+user credentials to call `AssumeRole`.
+:type role_arn: string
+:param role_arn: The Amazon Resource Name (ARN) of the role that the
+caller is assuming.
+:type role_session_name: string
+:param role_session_name: An identifier for the assumed role session.
+The session name is included as part of the `AssumedRoleUser`.
+:type policy: string
+:param policy: A supplemental policy that is associated with the
+temporary security credentials from the `AssumeRole` call. The
+resulting permissions of the temporary security credentials are an
+intersection of this policy and the access policy that is
+associated with the role. Use this policy to further restrict the
+permissions of the temporary security credentials.
+:type duration_seconds: integer
+:param duration_seconds: The duration, in seconds, of the role session.
+The value can range from 900 seconds (15 minutes) to 3600 seconds
+(1 hour). By default, the value is set to 3600 seconds.
+:type external_id: string
+:param external_id: A unique identifier that is used by third parties
+to assume a role in their customers' accounts. For each role that
+the third party can assume, they should instruct their customers to
+create a role with the external ID that the third party generated.
+Each time the third party assumes the role, they must pass the
+customer's external ID. The external ID is useful in order to help
+third parties bind a role to the customer who created it. For more
+information about the external ID, see `About the External ID`_ in
+Using Temporary Security Credentials .
+:type mfa_serial_number: string
+:param mfa_serial_number: The identification number of the MFA device that
+is associated with the user who is making the AssumeRole call.
+Specify this value if the trust policy of the role being assumed
+includes a condition that requires MFA authentication. The value is
+either the serial number for a hardware device (such as
+GAHT12345678) or an Amazon Resource Name (ARN) for a virtual device
+(such as arn:aws:iam::123456789012:mfa/user). Minimum length of 9.
+Maximum length of 256.
+:type mfa_token: string
+:param mfa_token: The value provided by the MFA device, if the trust
+policy of the role being assumed requires MFA (that is, if the
+policy includes a condition that tests for MFA). If the role being
+assumed requires MFA and if the TokenCode value is missing or
+expired, the AssumeRole call returns an "access denied" errror.
+Minimum length of 6. Maximum length of 6.
+"""
+params = {
+'RoleArn': role_arn,
+'RoleSessionName': role_session_name
+}
+if policy is not None:
+params['Policy'] = policy
+if duration_seconds is not None:
+params['DurationSeconds'] = duration_seconds
+if external_id is not None:
+params['ExternalId'] = external_id
+if mfa_serial_number is not None:
+params['SerialNumber'] = mfa_serial_number
+if mfa_token is not None:
+params['TokenCode'] = mfa_token
+return self.get_object('AssumeRole', params, AssumedRole, verb='POST')
+def assume_role_with_saml(self, role_arn, principal_arn, saml_assertion,
+policy=None, duration_seconds=None):
+"""
+Returns a set of temporary security credentials for users who
+have been authenticated via a SAML authentication response.
+This operation provides a mechanism for tying an enterprise
+identity store or directory to role-based AWS access without
+user-specific credentials or configuration.
+The temporary security credentials returned by this operation
+consist of an access key ID, a secret access key, and a
+security token. Applications can use these temporary security
+credentials to sign calls to AWS services. The credentials are
+valid for the duration that you specified when calling
+`AssumeRoleWithSAML`, which can be up to 3600 seconds (1 hour)
+or until the time specified in the SAML authentication
+response's `NotOnOrAfter` value, whichever is shorter.
+The maximum duration for a session is 1 hour, and the minimum
+duration is 15 minutes, even if values outside this range are
+specified.
+Optionally, you can pass an AWS IAM access policy to this
+operation. The temporary security credentials that are
+returned by the operation have the permissions that are
+associated with the access policy of the role being assumed,
+except for any permissions explicitly denied by the policy you
+pass. This gives you a way to further restrict the permissions
+for the federated user. These policies and any applicable
+resource-based policies are evaluated when calls to AWS are
+made using the temporary security credentials.
+Before your application can call `AssumeRoleWithSAML`, you
+must configure your SAML identity provider (IdP) to issue the
+claims required by AWS. Additionally, you must use AWS
+Identity and Access Management (AWS IAM) to create a SAML
+provider entity in your AWS account that represents your
+identity provider, and create an AWS IAM role that specifies
+this SAML provider in its trust policy.
+Calling `AssumeRoleWithSAML` does not require the use of AWS
+security credentials. The identity of the caller is validated
+by using keys in the metadata document that is uploaded for
+the SAML provider entity for your identity provider.
+For more information, see the following resources:
++ `Creating Temporary Security Credentials for SAML
+Federation`_ in the Using Temporary Security Credentials
+guide.
++ `SAML Providers`_ in the Using IAM guide.
++ `Configuring a Relying Party and Claims in the Using IAM
+guide. `_
++ `Creating a Role for SAML-Based Federation`_ in the Using
+IAM guide.
+:type role_arn: string
+:param role_arn: The Amazon Resource Name (ARN) of the role that the
+caller is assuming.
+:type principal_arn: string
+:param principal_arn: The Amazon Resource Name (ARN) of the SAML
+provider in AWS IAM that describes the IdP.
+:type saml_assertion: string
+:param saml_assertion: The base-64 encoded SAML authentication response
+provided by the IdP.
+For more information, see `Configuring a Relying Party and Adding
+Claims`_ in the Using IAM guide.
+:type policy: string
+:param policy:
+An AWS IAM policy in JSON format.
+The temporary security credentials that are returned by this operation
+have the permissions that are associated with the access policy of
+the role being assumed, except for any permissions explicitly
+denied by the policy you pass. These policies and any applicable
+resource-based policies are evaluated when calls to AWS are made
+using the temporary security credentials.
+The policy must be 2048 bytes or shorter, and its packed size must be
+less than 450 bytes.
+:type duration_seconds: integer
+:param duration_seconds:
+The duration, in seconds, of the role session. The value can range from
+900 seconds (15 minutes) to 3600 seconds (1 hour). By default, the
+value is set to 3600 seconds. An expiration can also be specified
+in the SAML authentication response's `NotOnOrAfter` value. The
+actual expiration time is whichever value is shorter.
+The maximum duration for a session is 1 hour, and the minimum duration
+is 15 minutes, even if values outside this range are specified.
+"""
+params = {
+'RoleArn': role_arn,
+'PrincipalArn': principal_arn,
+'SAMLAssertion': saml_assertion,
+}
+if policy is not None:
+params['Policy'] = policy
+if duration_seconds is not None:
+params['DurationSeconds'] = duration_seconds
+return self.get_object('AssumeRoleWithSAML', params, AssumedRole,
+verb='POST')
+def assume_role_with_web_identity(self, role_arn, role_session_name,
+web_identity_token, provider_id=None,
+policy=None, duration_seconds=None):
+"""
+Returns a set of temporary security credentials for users who
+have been authenticated in a mobile or web application with a
+web identity provider, such as Login with Amazon, Facebook, or
+Google. `AssumeRoleWithWebIdentity` is an API call that does
+not require the use of AWS security credentials. Therefore,
+you can distribute an application (for example, on mobile
+devices) that requests temporary security credentials without
+including long-term AWS credentials in the application or by
+deploying server-based proxy services that use long-term AWS
+credentials. For more information, see `Creating a Mobile
+Application with Third-Party Sign-In`_ in AWS Security Token
+Service .
+The temporary security credentials consist of an access key
+ID, a secret access key, and a security token. Applications
+can use these temporary security credentials to sign calls to
+AWS service APIs. The credentials are valid for the duration
+that you specified when calling `AssumeRoleWithWebIdentity`,
+which can be from 900 seconds (15 minutes) to 3600 seconds (1
+hour). By default, the temporary security credentials are
+valid for 1 hour.
+The temporary security credentials that are returned from the
+`AssumeRoleWithWebIdentity` response have the permissions that
+are associated with the access policy of the role being
+assumed. You can further restrict the permissions of the
+temporary security credentials by passing a policy in the
+request. The resulting permissions are an intersection of the
+role's access policy and the policy that you passed. These
+policies and any applicable resource-based policies are
+evaluated when calls to AWS service APIs are made using the
+temporary security credentials.
+Before your application can call `AssumeRoleWithWebIdentity`,
+you must have an identity token from a supported identity
+provider and create a role that the application can assume.
+The role that your application assumes must trust the identity
+provider that is associated with the identity token. In other
+words, the identity provider must be specified in the role's
+trust policy. For more information, see ` Creating Temporary
+Security Credentials for Mobile Apps Using Third-Party
+Identity Providers`_.
+:type role_arn: string
+:param role_arn: The Amazon Resource Name (ARN) of the role that the
+caller is assuming.
+:type role_session_name: string
+:param role_session_name: An identifier for the assumed role session.
+Typically, you pass the name or identifier that is associated with
+the user who is using your application. That way, the temporary
+security credentials that your application will use are associated
+with that user. This session name is included as part of the ARN
+and assumed role ID in the `AssumedRoleUser` response element.
+:type web_identity_token: string
+:param web_identity_token: The OAuth 2.0 access token or OpenID Connect
+ID token that is provided by the identity provider. Your
+application must get this token by authenticating the user who is
+using your application with a web identity provider before the
+application makes an `AssumeRoleWithWebIdentity` call.
+:type provider_id: string
+:param provider_id: Specify this value only for OAuth access tokens. Do
+not specify this value for OpenID Connect ID tokens, such as
+`accounts.google.com`. This is the fully-qualified host component
+of the domain name of the identity provider. Do not include URL
+schemes and port numbers. Currently, `www.amazon.com` and
+`graph.facebook.com` are supported.
+:type policy: string
+:param policy: A supplemental policy that is associated with the
+temporary security credentials from the `AssumeRoleWithWebIdentity`
+call. The resulting permissions of the temporary security
+credentials are an intersection of this policy and the access
+policy that is associated with the role. Use this policy to further
+restrict the permissions of the temporary security credentials.
+:type duration_seconds: integer
+:param duration_seconds: The duration, in seconds, of the role session.
+The value can range from 900 seconds (15 minutes) to 3600 seconds
+(1 hour). By default, the value is set to 3600 seconds.
+"""
+params = {
+'RoleArn': role_arn,
+'RoleSessionName': role_session_name,
+'WebIdentityToken': web_identity_token,
+}
+if provider_id is not None:
+params['ProviderId'] = provider_id
+if policy is not None:
+params['Policy'] = policy
+if duration_seconds is not None:
+params['DurationSeconds'] = duration_seconds
+return self.get_object(
+'AssumeRoleWithWebIdentity',
+params,
+AssumedRole,
+verb='POST'
+)
+def decode_authorization_message(self, encoded_message):
+"""
+Decodes additional information about the authorization status
+of a request from an encoded message returned in response to
+an AWS request.
+For example, if a user is not authorized to perform an action
+that he or she has requested, the request returns a
+`Client.UnauthorizedOperation` response (an HTTP 403
+response). Some AWS actions additionally return an encoded
+message that can provide details about this authorization
+failure.
+Only certain AWS actions return an encoded authorization
+message. The documentation for an individual action indicates
+whether that action returns an encoded message in addition to
+returning an HTTP code.
+The message is encoded because the details of the
+authorization status can constitute privileged information
+that the user who requested the action should not see. To
+decode an authorization status message, a user must be granted
+permissions via an IAM policy to request the
+`DecodeAuthorizationMessage` (
+`sts:DecodeAuthorizationMessage`) action.
+The decoded message includes the following type of
+information:
++ Whether the request was denied due to an explicit deny or
+due to the absence of an explicit allow. For more information,
+see `Determining Whether a Request is Allowed or Denied`_ in
+Using IAM .
++ The principal who made the request.
++ The requested action.
++ The requested resource.
++ The values of condition keys in the context of the user's
+request.
+:type encoded_message: string
+:param encoded_message: The encoded message that was returned with the
+response.
+"""
+params = {
+'EncodedMessage': encoded_message,
+}
+return self.get_object(
+'DecodeAuthorizationMessage',
+params,
+DecodeAuthorizationMessage,
+verb='POST'
+)

Mercurial > repos > shellac > guppy_basecaller

comparison env/lib/python3.7/site-packages/boto/sts/connection.py @ 0:26e78fe6e8c4 draft