Ministack: Free, open-source local AWS emulator - 60+ services, Terraform compatible, real databases. Free forever. MIT licensed.
Python awsaws-emulatoraws-localaws-sdkdevtoolsdockerdynamodbec2emulatorlambdalocalstacklocalstack-alternativeministackmock-awsopen-sourcepythons3sqsterraform
"""EC2 Verified Access control plane: the calls the Terraform aws_verifiedaccess_* resources make.
Expected codes, messages and orders are AWS's answers in us-east-1; each test names the
capture keys it follows (A/B/C/D/E/F: reads, W: writes, X/Y: load-balancer endpoints,
V: device providers, groups, logging and a network-interface endpoint, Z: check orders).
"""
import uuid
import boto3
import pytest
from botocore.config import Config
from botocore.exceptions import ClientError
from conftest import ENDPOINT, make_client
_POLICY = 'permit(principal, action, resource) when { context.idp.email like "*@example.com" };'
_OIDC = {
"Issuer": "https://login.example.com",
"AuthorizationEndpoint": "https://login.example.com/authorize",
"TokenEndpoint": "https://login.example.com/token",
"UserInfoEndpoint": "https://login.example.com/userinfo",
"ClientId": "client",
"ClientSecret": "secret",
"Scope": "openid email",
}
_MISSING = {"Instance": "vai-0000000000000000a", "TrustProvider": "vatp-0000000000000000a",
"Group": "vagr-0000000000000000a", "Endpoint": "vae-0000000000000000a"}
def _client(region="us-east-1", account_id="test", service="ec2", validate=True):
return boto3.client(
service, endpoint_url=ENDPOINT, region_name=region,
aws_access_key_id=account_id, aws_secret_access_key="test",
config=Config(region_name=region, retries={"total_max_attempts": 1}, parameter_validation=validate),
)
@pytest.fixture
def raw():
"""An EC2 client that sends requests botocore would refuse to build."""
return _client(validate=False)
def _oidc_provider(ec2, ref="idp", **extra):
return ec2.create_verified_access_trust_provider(
TrustProviderType="user", UserTrustProviderType="oidc", PolicyReferenceName=ref,
OidcOptions=dict(_OIDC), **extra)["VerifiedAccessTrustProvider"]
def _device_provider(ec2, device_type="jamf", **options):
return ec2.create_verified_access_trust_provider(
TrustProviderType="device", DeviceTrustProviderType=device_type, PolicyReferenceName=device_type,
DeviceOptions={"TenantId": "tenant-1", **options})["VerifiedAccessTrustProvider"]
def _instance(ec2, **extra):
return ec2.create_verified_access_instance(**extra)["VerifiedAccessInstance"]["VerifiedAccessInstanceId"]
def _attach(ec2, inst_id, tp_id):
ec2.attach_verified_access_trust_provider(VerifiedAccessInstanceId=inst_id, VerifiedAccessTrustProviderId=tp_id)
def _instance_with_provider(ec2):
"""An instance with an OIDC provider attached: AWS refuses groups on an instance without one."""
inst_id = _instance(ec2)
tp_id = _oidc_provider(ec2)["VerifiedAccessTrustProviderId"]
_attach(ec2, inst_id, tp_id)
return inst_id, tp_id
def _group(ec2, inst_id, **extra):
return ec2.create_verified_access_group(
VerifiedAccessInstanceId=inst_id, **extra)["VerifiedAccessGroup"]["VerifiedAccessGroupId"]
def _error(exc):
err = exc.value.response["Error"]
return err["Code"], err["Message"]
def _status(exc):
return exc.value.response["ResponseMetadata"]["HTTPStatusCode"]
def _provider_ids(ec2, inst_id):
inst = ec2.describe_verified_access_instances(VerifiedAccessInstanceIds=[inst_id])["VerifiedAccessInstances"][0]
return [p["VerifiedAccessTrustProviderId"] for p in inst["VerifiedAccessTrustProviders"]]
def _cleanup(ec2, groups=(), instances=(), providers=()):
for group_id in groups:
ec2.delete_verified_access_group(VerifiedAccessGroupId=group_id)
for inst_id in instances:
for tp_id in _provider_ids(ec2, inst_id):
ec2.detach_verified_access_trust_provider(VerifiedAccessInstanceId=inst_id, VerifiedAccessTrustProviderId=tp_id)
ec2.delete_verified_access_instance(VerifiedAccessInstanceId=inst_id)
for tp_id in providers:
ec2.delete_verified_access_trust_provider(VerifiedAccessTrustProviderId=tp_id)
# ── Trust providers ────────────────────────────────────────
def test_verified_access_oidc_trust_provider_lifecycle(ec2):
"""W2:create:oidc-idp, W2:describe:oidc-idp, W2:modify:oidc-scope-only, V6:delete:tp, V6:describe:tp-after-delete."""
tp = _oidc_provider(ec2, Description="corp idp", TagSpecifications=[
{"ResourceType": "verified-access-trust-provider", "Tags": [{"Key": "team", "Value": "platform"}]}])
tp_id = tp["VerifiedAccessTrustProviderId"]
assert tp_id.startswith("vatp-") and len(tp_id) == 22
assert (tp["TrustProviderType"], tp["UserTrustProviderType"], tp["Description"]) == ("user", "oidc", "corp idp")
assert tp["OidcOptions"] == {**_OIDC, "ClientSecret": "REDACTED"}
assert tp["SseSpecification"] == {"CustomerManagedKeyEnabled": False}
assert tp["Tags"] == [{"Key": "team", "Value": "platform"}]
described = ec2.describe_verified_access_trust_providers(
VerifiedAccessTrustProviderIds=[tp_id])["VerifiedAccessTrustProviders"][0]
assert described["PolicyReferenceName"] == "idp"
assert described["OidcOptions"]["ClientSecret"] == "REDACTED"
modified = ec2.modify_verified_access_trust_provider(
VerifiedAccessTrustProviderId=tp_id, Description="renamed", OidcOptions={"Scope": "openid"},
)["VerifiedAccessTrustProvider"]
assert modified["Description"] == "renamed"
assert modified["OidcOptions"] == {**_OIDC, "Scope": "openid", "ClientSecret": "REDACTED"}
assert "Tags" not in modified
deleted = ec2.delete_verified_access_trust_provider(VerifiedAccessTrustProviderId=tp_id)["VerifiedAccessTrustProvider"]
assert deleted["VerifiedAccessTrustProviderId"] == tp_id
with pytest.raises(ClientError) as exc:
ec2.describe_verified_access_trust_providers(VerifiedAccessTrustProviderIds=[tp_id])
assert _error(exc) == ("InvalidVerifiedAccessTrustProviderId.NotFound", f"VerifiedAccessTrustProvider {tp_id} does not exist")
with pytest.raises(ClientError) as exc:
ec2.delete_verified_access_trust_provider(VerifiedAccessTrustProviderId=tp_id)
assert _error(exc) == ("InvalidVerifiedAccessTrustProviderId.NotFound", f"VerifiedAccessTrustProvider {tp_id} does not exist")
def test_verified_access_device_trust_providers(ec2, raw):
"""V1:create:jamf, V1:create:crowdstrike, W2:create:jumpcloud, W2:create:jumpcloud:tenant-only, W2:modify:device-url-only, V1:modify:url-on-jamf,
V1:create:crowdstrike-url, W2:create:jamf."""
jamf = _device_provider(ec2, "jamf")
assert jamf["DeviceOptions"] == {"TenantId": "tenant-1"}
assert "UserTrustProviderType" not in jamf and jamf["Description"] == ""
crowdstrike = _device_provider(ec2, "crowdstrike")
assert crowdstrike["DeviceOptions"] == {
"TenantId": "tenant-1", "PublicSigningKeyUrl": "https://assets-public.falcon.crowdstrike.com/zta/jwk.json"}
# W2:create:jumpcloud:tenant-only: AWS fills jumpcloud's key URL in too.
default_jc = _device_provider(ec2, "jumpcloud")
assert default_jc["DeviceOptions"] == {"TenantId": "tenant-1",
"PublicSigningKeyUrl": "https://go.jumpcloud.com/.well-known/jwks.json"}
ec2.delete_verified_access_trust_provider(VerifiedAccessTrustProviderId=default_jc["VerifiedAccessTrustProviderId"])
jumpcloud = _device_provider(ec2, "jumpcloud", PublicSigningKeyUrl="https://keys.example.com")
modified = ec2.modify_verified_access_trust_provider(
VerifiedAccessTrustProviderId=jumpcloud["VerifiedAccessTrustProviderId"],
DeviceOptions={"PublicSigningKeyUrl": "https://keys2.example.com"})["VerifiedAccessTrustProvider"]
assert modified["DeviceOptions"] == {"TenantId": "tenant-1", "PublicSigningKeyUrl": "https://keys2.example.com"}
with pytest.raises(ClientError) as exc:
ec2.modify_verified_access_trust_provider(
VerifiedAccessTrustProviderId=jamf["VerifiedAccessTrustProviderId"],
DeviceOptions={"PublicSigningKeyUrl": "https://keys2.example.com"})
assert _error(exc) == ("InvalidParameterValue", "Parameter DeviceOptions is not allowed when DeviceTrustProviderType is jamf")
for device_type in ("jamf", "crowdstrike"):
with pytest.raises(ClientError) as exc:
_device_provider(ec2, device_type, PublicSigningKeyUrl="https://keys.example.com")
assert _error(exc) == ("InvalidParameterValue",
f"Parameter PublicSigningKeyUrl is not allowed when DeviceTrustProviderType is {device_type}")
_cleanup(ec2, providers=[p["VerifiedAccessTrustProviderId"] for p in (jamf, crowdstrike, jumpcloud)])
_TP_CREATE_ERRORS = [
# (capture key, request, code, message)
("E1:CreateVerifiedAccessTrustProvider:no-params", {}, "MissingParameter",
"The request must include the following parameters: PolicyReferenceName, TrustProviderType. "
"Add the required parameters and retry the request."),
("W2:invalid:type=robot", {"TrustProviderType": "robot"}, "InvalidParameterValue",
"The value of trustProviderType you provided is not valid"),
("W2:invalid:policy-ref=bad-chars", {"TrustProviderType": "device", "DeviceTrustProviderType": "jamf",
"PolicyReferenceName": "Bad Name!"}, "InvalidParameterValue",
"Value of parameter PolicyReferenceName must match regular expression [a-zA-Z_][a-zA-Z0-9_]*"),
("W2:invalid:user+DeviceTrustProviderType", {"TrustProviderType": "user", "DeviceTrustProviderType": "jamf"},
"MissingParameter", "Missing UserTrustProviderType parameter required when TrustProviderType is user"),
("W2:invalid:user-type=bogus", {"TrustProviderType": "user", "UserTrustProviderType": "bogus"},
"InvalidParameterValue", "The value of userTrustProviderType you provided is not valid"),
("W2:invalid:user+both-types", {"TrustProviderType": "user", "UserTrustProviderType": "oidc",
"DeviceTrustProviderType": "jamf", "OidcOptions": _OIDC},
"InvalidParameterCombination", "Parameter DeviceTrustProviderType is not allowed when TrustProviderType is user"),
("W2:invalid:oidc+DeviceOptions", {"TrustProviderType": "user", "UserTrustProviderType": "oidc", "OidcOptions": _OIDC,
"DeviceOptions": {"TenantId": "t"}},
"InvalidParameterCombination", "Parameter DeviceOptions is not allowed when TrustProviderType is user"),
("W2:invalid:oidc-without-OidcOptions", {"TrustProviderType": "user", "UserTrustProviderType": "oidc"},
"MissingParameter",
"Missing OidcOptions or NativeApplicationOidcOptions parameter required when UserTrustProviderType is oidc"),
("W2:create:iam-identity-center", {"TrustProviderType": "user", "UserTrustProviderType": "iam-identity-center"},
"InvalidParameterValue", "IAM Identity Center is not enabled on your organization"),
("V1:create:oidc-without-ClientSecret", {"TrustProviderType": "user", "UserTrustProviderType": "oidc",
"OidcOptions": {k: v for k, v in _OIDC.items() if k != "ClientSecret"}},
"MissingParameter", "Missing required parameter ClientSecret in OidcOptions"),
("W2:create:oidc-partial-options", {"TrustProviderType": "user", "UserTrustProviderType": "oidc",
"OidcOptions": {"Issuer": "https://login.example.com"}},
"MissingParameter", "Missing required parameter AuthorizationEndpoint in OidcOptions"),
("W2:create:oidc-http-issuer", {"TrustProviderType": "user", "UserTrustProviderType": "oidc",
"OidcOptions": {**_OIDC, "Issuer": "http://login.example.com"}},
"InvalidParameterValue", "Parameter Issuer in OidcOptions must be a valid HTTPS URL"),
("V1:create:oidc-not-url", {"TrustProviderType": "user", "UserTrustProviderType": "oidc",
"OidcOptions": {**_OIDC, "TokenEndpoint": "token"}},
"InvalidParameterValue", "Parameter TokenEndpoint in OidcOptions must be a valid HTTPS URL"),
("W2:invalid:device+UserTrustProviderType", {"TrustProviderType": "device", "UserTrustProviderType": "oidc"},
"InvalidParameterCombination", "Parameter UserTrustProviderType is not allowed when TrustProviderType is device"),
("W2:invalid:device-without-device-type", {"TrustProviderType": "device"}, "MissingParameter",
"Missing DeviceTrustProviderType parameter required when TrustProviderType is device"),
("W2:invalid:device-type=bogus", {"TrustProviderType": "device", "DeviceTrustProviderType": "bogus"},
"InvalidParameterValue", "The value of deviceTrustProviderType you provided is not valid"),
("W2:invalid:device+OidcOptions", {"TrustProviderType": "device", "DeviceTrustProviderType": "jamf", "OidcOptions": _OIDC},
"InvalidParameterCombination", "Parameter OidcOptions is not allowed when TrustProviderType is device"),
("W2:create:jamf:no-options", {"TrustProviderType": "device", "DeviceTrustProviderType": "jamf"}, "MissingParameter",
"Missing DeviceOptions parameter required when TrustProviderType is device"),
("W2:create:jamf:url-only", {"TrustProviderType": "device", "DeviceTrustProviderType": "jamf",
"DeviceOptions": {"PublicSigningKeyUrl": "https://keys.example.com"}},
"MissingParameter", "Missing required parameter TenantId in DeviceOptions"),
("Z1:tp:type-bad+ref-bad", {"TrustProviderType": "robot", "PolicyReferenceName": "Bad Name!"}, "InvalidParameterValue",
"The value of trustProviderType you provided is not valid"),
("Z1:tp:ref-too-long", {"TrustProviderType": "device", "DeviceTrustProviderType": "jamf", "DeviceOptions": {"TenantId": "t"},
"PolicyReferenceName": "a" * 33}, "InvalidParameterValue",
"Length of parameter PolicyReferenceName must be between 1 and 32"),
("Z1:tp:oidc-no-options+device-type", {"TrustProviderType": "user", "UserTrustProviderType": "oidc",
"DeviceTrustProviderType": "jamf"}, "MissingParameter",
"Missing OidcOptions or NativeApplicationOidcOptions parameter required when UserTrustProviderType is oidc"),
("Z1:tp:iic+oidc-options", {"TrustProviderType": "user", "UserTrustProviderType": "iam-identity-center",
"OidcOptions": _OIDC}, "InvalidParameterCombination",
"Parameter OidcOptions is not allowed when UserTrustProviderType is iam-identity-center"),
("Z1:tp:iic+device-options", {"TrustProviderType": "user", "UserTrustProviderType": "iam-identity-center",
"DeviceOptions": {"TenantId": "t"}}, "InvalidParameterValue",
"IAM Identity Center is not enabled on your organization"),
("Z1:tp:oidc-missing-field+http-issuer", {"TrustProviderType": "user", "UserTrustProviderType": "oidc", "OidcOptions": {
k: v for k, v in {**_OIDC, "Issuer": "http://a.example.com"}.items() if k != "Scope"}},
"InvalidParameterValue", "Parameter Issuer in OidcOptions must be a valid HTTPS URL"),
("Z1:tp:oidc-http-userinfo", {"TrustProviderType": "user", "UserTrustProviderType": "oidc",
"OidcOptions": {**_OIDC, "UserInfoEndpoint": "http://login.example.com/userinfo"}},
"InvalidParameterValue", "Parameter UserInfoEndpoint in OidcOptions must be a valid HTTPS URL"),
("Z1:tp:oidc-issuer-upper-scheme", {"TrustProviderType": "user", "UserTrustProviderType": "oidc",
"OidcOptions": {**_OIDC, "Issuer": "HTTPS://login.example.com"}},
"InvalidParameterValue", "Parameter Issuer in OidcOptions must be a valid HTTPS URL"),
("Z1:tp:oidc-long-scope", {"TrustProviderType": "user", "UserTrustProviderType": "oidc",
"OidcOptions": {**_OIDC, "Scope": "s" * 257}},
"InvalidParameterValue", "Length of parameter Scope in OidcOptions must be between 1 and 256"),
("Z1:tp:device-type-missing+oidc", {"TrustProviderType": "device", "OidcOptions": _OIDC}, "InvalidParameterCombination",
"Parameter OidcOptions is not allowed when TrustProviderType is device"),
("Z1:tp:device-type-bad+oidc", {"TrustProviderType": "device", "DeviceTrustProviderType": "bogus", "OidcOptions": _OIDC},
"InvalidParameterValue", "The value of deviceTrustProviderType you provided is not valid"),
("Z1:tp:jumpcloud-http-url", {"TrustProviderType": "device", "DeviceTrustProviderType": "jumpcloud",
"DeviceOptions": {"TenantId": "t", "PublicSigningKeyUrl": "http://k.example.com"}},
"InvalidParameterValue", "Parameter PublicSigningKeyUrl must be a valid HTTPS URL"),
("Z1:tp:jamf-url+sse-fake-key", {"TrustProviderType": "device", "DeviceTrustProviderType": "jamf",
"DeviceOptions": {"TenantId": "t", "PublicSigningKeyUrl": "https://k.example.com"},
"SseSpecification": {"CustomerManagedKeyEnabled": True, "KmsKeyArn":
"arn:aws:kms:us-east-1:000000000000:key/00000000-0000-0000-0000-000000000000"}},
"InvalidParameterValue", "Parameter PublicSigningKeyUrl is not allowed when DeviceTrustProviderType is jamf"),
("Z1:tp:device-sse-enabled-no-key", {"TrustProviderType": "device", "DeviceTrustProviderType": "jamf",
"DeviceOptions": {"TenantId": "t"}, "SseSpecification": {"CustomerManagedKeyEnabled": True}},
"MissingParameter", "Invalid value for parameter KmsKeyArn"),
]
@pytest.mark.parametrize("key, request_params, code, message", _TP_CREATE_ERRORS, ids=[c[0] for c in _TP_CREATE_ERRORS])
def test_verified_access_trust_provider_create_errors(raw, key, request_params, code, message):
params = dict(request_params)
if key != "E1:CreateVerifiedAccessTrustProvider:no-params":
params.setdefault("PolicyReferenceName", "x")
before = len(raw.describe_verified_access_trust_providers()["VerifiedAccessTrustProviders"])
with pytest.raises(ClientError) as exc:
raw.create_verified_access_trust_provider(**params)
assert (_status(exc), *_error(exc)) == (400, code, message)
assert len(raw.describe_verified_access_trust_providers()["VerifiedAccessTrustProviders"]) == before
def test_verified_access_trust_provider_modify_errors(ec2):
"""W2:modify:device-options-on-oidc, V1:modify:oidc-options-on-device, V1:modify:oidc-http-issuer."""
oidc = _oidc_provider(ec2)["VerifiedAccessTrustProviderId"]
device = _device_provider(ec2, "jumpcloud")["VerifiedAccessTrustProviderId"]
for tp_id, kwargs, message in (
(oidc, {"DeviceOptions": {"PublicSigningKeyUrl": "https://k.example.com"}},
"Parameter DeviceOptions is not allowed when TrustProviderType is user"),
(device, {"OidcOptions": {"Scope": "openid"}}, "Parameter OidcOptions is not allowed when TrustProviderType is device"),
(oidc, {"OidcOptions": {"Issuer": "http://x.example.com"}}, "Parameter Issuer in OidcOptions must be a valid HTTPS URL"),
):
with pytest.raises(ClientError) as exc:
ec2.modify_verified_access_trust_provider(VerifiedAccessTrustProviderId=tp_id, **kwargs)
assert _error(exc) == ("InvalidParameterValue", message)
assert ec2.describe_verified_access_trust_providers(
VerifiedAccessTrustProviderIds=[oidc])["VerifiedAccessTrustProviders"][0]["OidcOptions"]["Issuer"] == _OIDC["Issuer"]
_cleanup(ec2, providers=[oidc, device])
# ── Instances and attachments ──────────────────────────────
def test_verified_access_instance_attach_detach(ec2):
"""V1:attach:jamf-to-second-instance and W3:attach:oidc-to-second-instance name the requested instance; W3:create:instance, V1:attach:*, V1:describe:after-attaches, W3:attach:oidc (response), V1:detach:crowdstrike,
V1:detach:crowdstrike-again, V1:attach:jamf-to-second-instance, W3:attach:second-oidc, V1:delete-tp:attached-device,
V1:delete:instance-with-provider-no-group, W8:delete:instance."""
inst_id = _instance(ec2, Description="platform", TagSpecifications=[
{"ResourceType": "verified-access-instance", "Tags": [{"Key": "Name", "Value": "va"}]}])
created = ec2.describe_verified_access_instances(VerifiedAccessInstanceIds=[inst_id])["VerifiedAccessInstances"][0]
assert inst_id.startswith("vai-") and len(inst_id) == 21
assert (created["FipsEnabled"], created["VerifiedAccessTrustProviders"]) == (False, [])
jamf = _device_provider(ec2, "jamf")["VerifiedAccessTrustProviderId"]
oidc = _oidc_provider(ec2, Description="corp")["VerifiedAccessTrustProviderId"]
crowdstrike = _device_provider(ec2, "crowdstrike")["VerifiedAccessTrustProviderId"]
second_oidc = _oidc_provider(ec2, ref="idp2")["VerifiedAccessTrustProviderId"]
for tp_id in (jamf, oidc, crowdstrike):
attached = ec2.attach_verified_access_trust_provider(
VerifiedAccessInstanceId=inst_id, VerifiedAccessTrustProviderId=tp_id)
assert attached["VerifiedAccessTrustProvider"]["VerifiedAccessTrustProviderId"] == crowdstrike
# The attach response lists the providers without their descriptions; Describe lists them.
assert [p.get("Description") for p in attached["VerifiedAccessInstance"]["VerifiedAccessTrustProviders"]] == [None] * 3
described = ec2.describe_verified_access_instances(VerifiedAccessInstanceIds=[inst_id])["VerifiedAccessInstances"][0]
assert [(p["VerifiedAccessTrustProviderId"], p.get("Description")) for p in described["VerifiedAccessTrustProviders"]] == [
(jamf, None), (oidc, "corp"), (crowdstrike, None)]
other = _instance(ec2)
with pytest.raises(ClientError) as exc:
_attach(ec2, other, jamf)
assert _error(exc) == ("VerifiedAccessTrustProviderAttachmentLimitExceeded",
f"VerifiedAccessTrustProvider {jamf} is already attached to VerifiedAccessInstance {other}")
with pytest.raises(ClientError) as exc:
_attach(ec2, inst_id, second_oidc)
assert _error(exc) == ("VerifiedAccessTrustProviderAttachmentLimitExceeded",
"Cannot have more than 1 VerifiedAccessTrustProvider with TrustProviderType user "
"attached to a VerifiedAccessInstance")
with pytest.raises(ClientError) as exc:
ec2.delete_verified_access_trust_provider(VerifiedAccessTrustProviderId=jamf)
assert _error(exc) == ("InvalidParameterValue", "VerifiedAccessTrustProvider has existing attachments. "
"Please remove all VerifiedAccessTrustProvider attachments before deleting.")
with pytest.raises(ClientError) as exc:
ec2.delete_verified_access_instance(VerifiedAccessInstanceId=inst_id)
assert _error(exc) == ("InvalidParameterValue", f"{inst_id} has existing attachments. "
"Remove all VerifiedAccessTrustProvider attachments before deleting.")
ec2.detach_verified_access_trust_provider(VerifiedAccessInstanceId=inst_id, VerifiedAccessTrustProviderId=oidc)
assert _provider_ids(ec2, inst_id) == [jamf, crowdstrike]
with pytest.raises(ClientError) as exc:
ec2.detach_verified_access_trust_provider(VerifiedAccessInstanceId=inst_id, VerifiedAccessTrustProviderId=oidc)
assert _error(exc) == ("InvalidParameterValue", f"Trust provider {oidc} is not attached to instance {inst_id}")
ec2.modify_verified_access_instance(VerifiedAccessInstanceId=inst_id, Description="changed")
assert ec2.describe_verified_access_instances(
VerifiedAccessInstanceIds=[inst_id])["VerifiedAccessInstances"][0]["Description"] == "changed"
_cleanup(ec2, instances=[inst_id, other], providers=[jamf, oidc, crowdstrike, second_oidc])
with pytest.raises(ClientError) as exc:
ec2.delete_verified_access_instance(VerifiedAccessInstanceId=inst_id)
assert _error(exc) == ("InvalidVerifiedAccessInstanceId.NotFound", f"The verified-access-instance ID '{inst_id}' does not exist")
def test_verified_access_attachment_id_checks(ec2):
"""W1:attach_*, W1:detach_*, V1:attach:malformed-*, V1:detach:malformed-*, W3:attach:*-missing-*, W3:detach:*-missing-*:
a well-formed id is looked up (instance first); a malformed one is reported only when no lookup failed."""
inst_id, tp_id = _instance_with_provider(ec2)
a, d = ec2.attach_verified_access_trust_provider, ec2.detach_verified_access_trust_provider
for call, inst, tp, code, message in (
(a, _MISSING["Instance"], _MISSING["TrustProvider"], "InvalidVerifiedAccessInstanceId.NotFound",
f"The verified-access-instance ID '{_MISSING['Instance']}' does not exist"),
(a, "abc", _MISSING["TrustProvider"], "InvalidVerifiedAccessTrustProviderId.NotFound",
f"The verified-access-trust-provider ID '{_MISSING['TrustProvider']}' does not exist"),
(a, "abc", tp_id, "InvalidParameterValue", "Length of parameter VerifiedAccessInstanceId must be between 5 and 21"),
(a, inst_id, "abc", "InvalidParameterValue", "Length of parameter VerifiedAccessTrustProviderId must be between 6 and 22"),
(d, "abc", _MISSING["TrustProvider"], "InvalidVerifiedAccessTrustProviderId.NotFound",
f"VerifiedAccessTrustProvider {_MISSING['TrustProvider']} does not exist"),
(d, _MISSING["Instance"], tp_id, "InvalidVerifiedAccessInstanceId.NotFound",
f"The verified-access-instance ID '{_MISSING['Instance']}' does not exist"),
):
with pytest.raises(ClientError) as exc:
call(VerifiedAccessInstanceId=inst, VerifiedAccessTrustProviderId=tp)
assert _error(exc) == (code, message)
_cleanup(ec2, instances=[inst_id], providers=[tp_id])
def test_verified_access_user_provider_is_locked_while_groups_exist(ec2):
"""V3:detach:with-group, V3:detach:device-with-group, W5:create:group-no-policy, V3:delete-instance:with-groups."""
inst_id, oidc = _instance_with_provider(ec2)
jumpcloud = _device_provider(ec2, "jumpcloud")["VerifiedAccessTrustProviderId"]
_attach(ec2, inst_id, jumpcloud)
group_id = _group(ec2, inst_id)
with pytest.raises(ClientError) as exc:
ec2.detach_verified_access_trust_provider(VerifiedAccessInstanceId=inst_id, VerifiedAccessTrustProviderId=oidc)
assert _error(exc) == ("VerifiedAccessGroupAttachmentExists",
f"VerifiedAccessInstance {inst_id} is not empty. Please remove all VerifiedAccessGroups "
"before attaching or detaching a VerifiedAccessTrustProvider with TrustProviderType user")
ec2.detach_verified_access_trust_provider(VerifiedAccessInstanceId=inst_id, VerifiedAccessTrustProviderId=jumpcloud)
with pytest.raises(ClientError) as exc:
ec2.delete_verified_access_instance(VerifiedAccessInstanceId=inst_id)
assert _error(exc)[1] == (f"{inst_id} has existing attachments. "
"Remove all VerifiedAccessTrustProvider attachments before deleting.")
bare = _instance(ec2)
with pytest.raises(ClientError) as exc:
_group(ec2, bare)
assert _error(exc) == ("InvalidParameterValue", f"Must attach a TrustProvider to Instance {bare} before you can create a Group")
_cleanup(ec2, groups=[group_id], instances=[inst_id, bare], providers=[oidc, jumpcloud])
def test_verified_access_round6_check_orders(ec2):
"""Z2:create:group, Z2:attach:tp-inner-upper, Z2:attach:tp-upper-prefix, Z2:detach:tp-inner-upper, Z2:attach:both-malformed,
Z2:modify-group:group-abc+instance-fake, -group-fake+instance-abc, -group-abc+instance-real, Z2:modify-tp:oidc-device-options+bad-issuer,
Z2:create-group:no-provider+sse-fake."""
fake_key = "arn:aws:kms:us-east-1:000000000000:key/00000000-0000-0000-0000-000000000000"
device_only = _instance(ec2)
jamf = _device_provider(ec2, "jamf")["VerifiedAccessTrustProviderId"]
_attach(ec2, device_only, jamf)
with pytest.raises(ClientError) as exc:
_group(ec2, device_only)
assert _error(exc) == ("InvalidParameterValue",
f"Must attach a 'user' TrustProvider to Instance {device_only} before you can create a Group")
bare = _instance(ec2)
with pytest.raises(ClientError) as exc:
_group(ec2, bare, SseSpecification={"CustomerManagedKeyEnabled": True, "KmsKeyArn": fake_key})
assert _error(exc) == ("InvalidParameterValue", f"Could not find the following key: {fake_key}")
inst_id, oidc = _instance_with_provider(ec2)
group_id = _group(ec2, inst_id)
a, d = ec2.attach_verified_access_trust_provider, ec2.detach_verified_access_trust_provider
for call, tp, error in (
(a, "vatp-0000000A000000000", ("InvalidVerifiedAccessTrustProviderId.NotFound",
"The verified-access-trust-provider ID 'vatp-0000000A000000000' does not exist")),
(a, "VATP-00000000000000000", ("InvalidParameterValue",
"Value of parameter VerifiedAccessTrustProviderId must match regular expression [a-z0-9-]+")),
(d, "vatp-0000000A000000000", ("InvalidParameterValue",
"Value of parameter VerifiedAccessTrustProviderId must match regular expression [a-z0-9-]+")),
):
with pytest.raises(ClientError) as exc:
call(VerifiedAccessInstanceId=inst_id, VerifiedAccessTrustProviderId=tp)
assert _error(exc) == error
with pytest.raises(ClientError) as exc:
a(VerifiedAccessInstanceId="abc", VerifiedAccessTrustProviderId="abc")
assert _error(exc)[1] == "Length of parameter VerifiedAccessTrustProviderId must be between 6 and 22"
other_oidc = _oidc_provider(ec2, ref="idp2")["VerifiedAccessTrustProviderId"]
mg = ec2.modify_verified_access_group
for group, inst, error in (
("abc", _MISSING["Instance"], ("InvalidVerifiedAccessInstanceId.NotFound",
f"The verified-access-instance ID '{_MISSING['Instance']}' does not exist")),
(_MISSING["Group"], "abc", ("InvalidVerifiedAccessGroupId.NotFound",
f"The verified-access-group ID '{_MISSING['Group']}' does not exist")),
("abc", inst_id, ("InvalidParameterValue", "Length of parameter VerifiedAccessGroupId must be between 6 and 22")),
):
with pytest.raises(ClientError) as exc:
mg(VerifiedAccessGroupId=group, VerifiedAccessInstanceId=inst)
assert _error(exc) == error
with pytest.raises(ClientError) as exc:
ec2.modify_verified_access_trust_provider(VerifiedAccessTrustProviderId=oidc, OidcOptions={"Issuer": "http://x.example.com"},
DeviceOptions={"PublicSigningKeyUrl": "https://k.example.com"})
assert _error(exc) == ("InvalidParameterValue", "Parameter Issuer in OidcOptions must be a valid HTTPS URL")
_cleanup(ec2, groups=[group_id], instances=[device_only, bare, inst_id], providers=[jamf, oidc, other_oidc])
def test_verified_access_round8_orders_and_orphans(ec2, raw):
"""R1:*, R2:*, R3:* (round 8)."""
inst_id, oidc = _instance_with_provider(ec2)
group_id = _group(ec2, inst_id)
other, other_oidc = _instance_with_provider(ec2)
spare = _oidc_provider(ec2, ref="idp3")["VerifiedAccessTrustProviderId"]
locked = ("VerifiedAccessGroupAttachmentExists",
f"VerifiedAccessInstance {inst_id} is not empty. Please remove all VerifiedAccessGroups before attaching "
"or detaching a VerifiedAccessTrustProvider with TrustProviderType user")
for call, tp in ((ec2.attach_verified_access_trust_provider, other_oidc),
(ec2.attach_verified_access_trust_provider, spare),
(ec2.detach_verified_access_trust_provider, spare)):
with pytest.raises(ClientError) as exc:
call(VerifiedAccessInstanceId=inst_id, VerifiedAccessTrustProviderId=tp)
assert _error(exc) == locked
with pytest.raises(ClientError) as exc:
ec2.detach_verified_access_trust_provider(VerifiedAccessInstanceId="abc", VerifiedAccessTrustProviderId="abc")
assert _error(exc)[1] == "Length of parameter VerifiedAccessTrustProviderId must be between 6 and 22"
for group, inst, message in (
(group_id, "abc", "Length of parameter VerifiedAccessInstanceId must be between 5 and 21"),
(group_id, "VAI-00000000000000000", "Value of parameter VerifiedAccessInstanceId must match regular expression [a-z0-9-]+"),
("abc", "abc", "Length of parameter VerifiedAccessGroupId must be between 6 and 22"),
):
with pytest.raises(ClientError) as exc:
ec2.modify_verified_access_group(VerifiedAccessGroupId=group, VerifiedAccessInstanceId=inst)
assert _error(exc) == ("InvalidParameterValue", message)
for op, member, value in (("describe_verified_access_groups", "VerifiedAccessInstanceId", "vai-0000000A000000000"),
("describe_verified_access_endpoints", "VerifiedAccessGroupId", "vagr-0000000A000000000")):
with pytest.raises(ClientError) as exc:
getattr(ec2, op)(**{member: value})
assert _error(exc)[1] == f"Value of parameter {member} must match regular expression [a-z0-9-]+"
# An instance holding a moved-in group and no provider can be deleted; the group stays.
bare = _instance(ec2)
ec2.modify_verified_access_group(VerifiedAccessGroupId=group_id, VerifiedAccessInstanceId=bare)
ec2.delete_verified_access_instance(VerifiedAccessInstanceId=bare)
orphan = ec2.describe_verified_access_groups(VerifiedAccessGroupIds=[group_id])["VerifiedAccessGroups"][0]
assert orphan["VerifiedAccessInstanceId"] == bare
with pytest.raises(ClientError) as exc:
raw.create_verified_access_trust_provider(TrustProviderType="device", UserTrustProviderType="oidc",
DeviceTrustProviderType="bogus", PolicyReferenceName="x")
assert _error(exc)[1] == "The value of deviceTrustProviderType you provided is not valid"
jumpcloud = _device_provider(ec2, "jumpcloud", PublicSigningKeyUrl="https://k.example.com")["VerifiedAccessTrustProviderId"]
with pytest.raises(ClientError) as exc:
ec2.modify_verified_access_trust_provider(VerifiedAccessTrustProviderId=jumpcloud, DeviceOptions={"PublicSigningKeyUrl": "keys"})
assert _error(exc) == ("InvalidParameterValue", "Parameter PublicSigningKeyUrl must be a valid HTTPS URL")
key = make_client("kms").create_key()["KeyMetadata"]
make_client("kms").create_alias(AliasName=f"alias/va-{uuid.uuid4().hex[:8]}", TargetKeyId=key["KeyId"])
sse = {"CustomerManagedKeyEnabled": True, "KmsKeyArn": key["Arn"]}
keyed = ec2.modify_verified_access_trust_provider(VerifiedAccessTrustProviderId=jumpcloud, SseSpecification=sse)
assert keyed["VerifiedAccessTrustProvider"]["SseSpecification"] == sse
keyed_group = _group(ec2, other, SseSpecification=sse)
for arn, error in (
("arn:aws:kms:us-east-1:000000000000:alias/x", ("InvalidParameterValue", "Invalid value for parameter KmsKeyArn")),
(key["Arn"].replace("000000000000", "123456789012"),
("UnauthorizedOperation", "User does not have permission to invoke required action: kms:DescribeKey")),
(key["Arn"].replace("us-east-1", "us-west-2"),
("InvalidParameterValue", f"Could not find the following key: {key['Arn'].replace('us-east-1', 'us-west-2')}")),
):
with pytest.raises(ClientError) as exc:
ec2.modify_verified_access_group_policy(VerifiedAccessGroupId=keyed_group,
SseSpecification={"CustomerManagedKeyEnabled": True, "KmsKeyArn": arn})
assert _error(exc) == error
before = ec2.describe_verified_access_instances(VerifiedAccessInstanceIds=[other])["VerifiedAccessInstances"][0]["LastUpdatedTime"]
import time
time.sleep(1.1)
ec2.modify_verified_access_instance_logging_configuration(VerifiedAccessInstanceId=other, AccessLogs={"IncludeTrustContext": True})
after = ec2.describe_verified_access_instances(VerifiedAccessInstanceIds=[other])["VerifiedAccessInstances"][0]["LastUpdatedTime"]
assert after > before
_cleanup(ec2, groups=[group_id, keyed_group], instances=[inst_id, other],
providers=[oidc, other_oidc, spare, jumpcloud])
def test_verified_access_response_times_and_ids(ec2):
"""V3:move:to-instance-without-provider, V3:describe:after-move, W5:modify:description, W2:modify:oidc-scope-only,
Q3:create:wild-one-level and Q5:create:same-domain-while-deleting (ids start with 0)."""
import time
inst_id, tp_id = _instance_with_provider(ec2)
assert inst_id[4] == "0" and tp_id[5] == "0"
group_id = _group(ec2, inst_id)
created = ec2.describe_verified_access_groups(VerifiedAccessGroupIds=[group_id])["VerifiedAccessGroups"][0]["LastUpdatedTime"]
time.sleep(1.1)
target = _instance(ec2)
moved = ec2.modify_verified_access_group(VerifiedAccessGroupId=group_id, VerifiedAccessInstanceId=target)["VerifiedAccessGroup"]
assert moved["LastUpdatedTime"] == created
after = ec2.describe_verified_access_groups(VerifiedAccessGroupIds=[group_id])["VerifiedAccessGroups"][0]["LastUpdatedTime"]
assert after > created
time.sleep(1.1)
renamed = ec2.modify_verified_access_group(VerifiedAccessGroupId=group_id, Description="x")["VerifiedAccessGroup"]
assert renamed["LastUpdatedTime"] > after
tp_before = ec2.describe_verified_access_trust_providers(
VerifiedAccessTrustProviderIds=[tp_id])["VerifiedAccessTrustProviders"][0]["LastUpdatedTime"]
time.sleep(1.1)
modified = ec2.modify_verified_access_trust_provider(VerifiedAccessTrustProviderId=tp_id, Description="y")
assert modified["VerifiedAccessTrustProvider"]["LastUpdatedTime"] == tp_before
_cleanup(ec2, groups=[group_id], instances=[inst_id, target], providers=[tp_id])
def test_verified_access_round9_kms_and_orders(ec2):
"""S1:*, S2:* (round 9): KMS key state and region, SSE first on a provider modify."""
kms, kms_west = make_client("kms"), _client("us-west-2", service="kms")
inst_id, oidc = _instance_with_provider(ec2)
group_id = _group(ec2, inst_id)
disabled = kms.create_key()["KeyMetadata"]["Arn"]
kms.disable_key(KeyId=disabled)
pending = kms.create_key()["KeyMetadata"]["Arn"]
kms.schedule_key_deletion(KeyId=pending, PendingWindowInDays=7)
west = kms_west.create_key()["KeyMetadata"]["Arn"]
for arn, error in ((disabled, ("InvalidParameterValue", f"The provided KMS key {disabled} is disabled")),
(pending, ("InvalidParameterValue", f"The provided KMS key {pending} is disabled")),
(west, ("InvalidParameterValue", f"Could not find the following key: {west}")),
("arn:aws:kms:us-east-1:123456789012:alias/x",
("UnauthorizedOperation", "User does not have permission to invoke required action: kms:DescribeKey"))):
with pytest.raises(ClientError) as exc:
ec2.modify_verified_access_group_policy(VerifiedAccessGroupId=group_id,
SseSpecification={"CustomerManagedKeyEnabled": True, "KmsKeyArn": arn})
assert _error(exc) == error
fake_key = "arn:aws:kms:us-east-1:000000000000:key/00000000-0000-0000-0000-000000000000"
jumpcloud = _device_provider(ec2, "jumpcloud", PublicSigningKeyUrl="https://k.example.com")["VerifiedAccessTrustProviderId"]
for tp_id, kwargs in ((jumpcloud, {"DeviceOptions": {"PublicSigningKeyUrl": "http://k.example.com"}}),
(oidc, {"OidcOptions": {"Issuer": "http://x.example.com"}})):
with pytest.raises(ClientError) as exc:
ec2.modify_verified_access_trust_provider(VerifiedAccessTrustProviderId=tp_id, **kwargs,
SseSpecification={"CustomerManagedKeyEnabled": True, "KmsKeyArn": fake_key})
assert _error(exc) == ("InvalidParameterValue", f"Could not find the following key: {fake_key}")
_cleanup(ec2, groups=[group_id], instances=[inst_id], providers=[oidc, jumpcloud])
def test_verified_access_instance_refuses_cidr_subdomain(ec2):
"""MiniStack scope: cidr endpoints are not emulated, so the custom subdomain is refused and nothing is stored."""
before = len(ec2.describe_verified_access_instances()["VerifiedAccessInstances"])
with pytest.raises(ClientError) as exc:
ec2.create_verified_access_instance(CidrEndpointsCustomSubDomain="corp.example.com")
assert _error(exc)[0] == "UnsupportedOperation"
assert len(ec2.describe_verified_access_instances()["VerifiedAccessInstances"]) == before
# ── Logging ────────────────────────────────────────────────
def test_verified_access_logging_describe_lists_next_token_first(ec2):
"""V4:logging:all-MaxResults-1 (round 4): the response lists nextToken before loggingConfigurationSet."""
import urllib.request
instances = [_instance(ec2), _instance(ec2)]
req = urllib.request.Request(
ENDPOINT, data=b"Action=DescribeVerifiedAccessInstanceLoggingConfigurations&Version=2016-11-15&MaxResults=1",
method="POST", headers={"Content-Type": "application/x-www-form-urlencoded; charset=utf-8",
"Authorization": "AWS4-HMAC-SHA256 Credential=test/20260101/us-east-1/ec2/aws4_request"})
with urllib.request.urlopen(req) as resp:
body = resp.read().decode()
assert -1 < body.index("<nextToken>") < body.index("<loggingConfigurationSet>")
_cleanup(ec2, instances=instances)
def test_verified_access_logging_configuration(ec2):
"""W4:describe:default, W4:log-version:*, W4:include-trust-context, V2:log:*, W4:s3+cw-enabled, W4:s3-only-in-request,
W4:s3-missing-bucket, W4:cw-missing-group, W4:firehose-missing, R3:logging:*."""
inst_id = _instance(ec2)
modify = ec2.modify_verified_access_instance_logging_configuration
default = ec2.describe_verified_access_instance_logging_configurations(
VerifiedAccessInstanceIds=[inst_id])["LoggingConfigurations"][0]
assert default == {"VerifiedAccessInstanceId": inst_id, "AccessLogs": {
"S3": {"Enabled": False}, "CloudWatchLogs": {"Enabled": False}, "KinesisDataFirehose": {"Enabled": False},
"LogVersion": "ocsf-1.0.0-rc.2", "IncludeTrustContext": False}}
logs = modify(VerifiedAccessInstanceId=inst_id, AccessLogs={"LogVersion": "OCSF-0.1"})["LoggingConfiguration"]["AccessLogs"]
assert logs["LogVersion"] == "ocsf-0.1"
# A request without LogVersion sets it back to the default.
logs = modify(VerifiedAccessInstanceId=inst_id, AccessLogs={"IncludeTrustContext": True})["LoggingConfiguration"]["AccessLogs"]
assert (logs["LogVersion"], logs["IncludeTrustContext"]) == ("ocsf-1.0.0-rc.2", True)
for access_logs, code, message in (
({"LogVersion": "ocsf-1.0.0"}, "InvalidParameterValue", "Invalid value for parameter LogVersion"),
({"LogVersion": "ocsf-0.1", "IncludeTrustContext": True}, "InvalidParameterCombination",
"The LogVersion ocsf-0.1 is not compatible with IncludeTrustContext true"),
({"S3": {"Enabled": False, "BucketName": "b"}}, "InvalidParameterCombination",
"The parameter AccessLogs.S3.BucketName cannot be used when AccessLogs.S3.Enabled is false"),
({"CloudWatchLogs": {"Enabled": False, "LogGroup": "/x"}}, "InvalidParameterCombination",
"The parameter AccessLogs.CloudWatchLogs.LogGroup cannot be used when AccessLogs.CloudWatchLogs.Enabled is false"),
({"S3": {"Enabled": True}, "LogVersion": "ocsf-9"}, "MissingParameter", "Missing required parameter AccessLogs.S3.BucketName"),
({"KinesisDataFirehose": {"Enabled": True}}, "MissingParameter",
"Missing required parameter AccessLogs.KinesisDataFirehose.DeliveryStream"),
({"S3": {"Enabled": True, "BucketName": f"missing-{uuid.uuid4().hex[:8]}"},
"CloudWatchLogs": {"Enabled": True, "LogGroup": "/missing"}},
"LogDestinationNotFound", "Log destination resource identified by AccessLogs.S3.BucketName was not found"),
({"CloudWatchLogs": {"Enabled": True, "LogGroup": "/missing"}}, "LogDestinationNotFound",
"Log destination resource identified by AccessLogs.CloudWatchLogs.LogGroup was not found"),
):
with pytest.raises(ClientError) as exc:
modify(VerifiedAccessInstanceId=inst_id, AccessLogs=access_logs)
assert _error(exc) == (code, message), access_logs
bucket, group = f"va-logs-{uuid.uuid4().hex[:8]}", f"/va/{uuid.uuid4().hex[:8]}"
make_client("s3").create_bucket(Bucket=bucket)
make_client("logs").create_log_group(logGroupName=group)
logs = modify(VerifiedAccessInstanceId=inst_id, AccessLogs={
"S3": {"Enabled": True, "BucketName": bucket, "Prefix": "va"},
"CloudWatchLogs": {"Enabled": True, "LogGroup": group}})["LoggingConfiguration"]["AccessLogs"]
assert logs["S3"] == {"Enabled": True, "BucketName": bucket, "Prefix": "va", "BucketOwner": "000000000000",
"DeliveryStatus": {"Code": "success"}}
assert logs["CloudWatchLogs"] == {"Enabled": True, "LogGroup": group, "DeliveryStatus": {"Code": "success"}}
# Destinations a request leaves out are kept.
logs = modify(VerifiedAccessInstanceId=inst_id, AccessLogs={"S3": {"Enabled": False}})["LoggingConfiguration"]["AccessLogs"]
assert logs["S3"] == {"Enabled": False}
assert logs["CloudWatchLogs"]["Enabled"] is True
modify(VerifiedAccessInstanceId=inst_id, AccessLogs={"CloudWatchLogs": {"Enabled": False}})
# R3:logging:firehose, R3:logging:describe-firehose.
stream = f"va-{uuid.uuid4().hex[:8]}"
make_client("firehose").create_delivery_stream(
DeliveryStreamName=stream, DeliveryStreamType="DirectPut",
S3DestinationConfiguration={"RoleARN": "arn:aws:iam::000000000000:role/fh", "BucketARN": f"arn:aws:s3:::{bucket}"})
logs = modify(VerifiedAccessInstanceId=inst_id, AccessLogs={
"KinesisDataFirehose": {"Enabled": True, "DeliveryStream": stream}})["LoggingConfiguration"]["AccessLogs"]
assert logs["KinesisDataFirehose"] == {"Enabled": True, "DeliveryStream": stream, "DeliveryStatus": {"Code": "success"}}
modify(VerifiedAccessInstanceId=inst_id, AccessLogs={"KinesisDataFirehose": {"Enabled": False}})
ec2.delete_verified_access_instance(VerifiedAccessInstanceId=inst_id)
# ── Groups and policies ────────────────────────────────────
def test_verified_access_group_lifecycle(ec2):
"""W5:create:group, W5:describe:by-instance, W5:get-policy:new, V3:get-policy:none, W5:modify:description,
V3:move:to-instance-without-provider, V6:delete:group, V6:describe:group-after-delete, V6:delete:group-again."""
inst_id, tp_id = _instance_with_provider(ec2)
group = ec2.create_verified_access_group(VerifiedAccessInstanceId=inst_id, Description="apps", PolicyDocument=_POLICY,
TagSpecifications=[{"ResourceType": "verified-access-group",
"Tags": [{"Key": "team", "Value": "a"}]}])["VerifiedAccessGroup"]
group_id = group["VerifiedAccessGroupId"]
assert group_id.startswith("vagr-") and len(group_id) == 22
assert group["VerifiedAccessGroupArn"] == f"arn:aws:ec2:us-east-1:000000000000:verified-access-group/{group_id}"
assert (group["Owner"], group["SseSpecification"]) == ("000000000000", {"CustomerManagedKeyEnabled": False})
assert ec2.get_verified_access_group_policy(VerifiedAccessGroupId=group_id) | {"ResponseMetadata": None} == {
"PolicyEnabled": True, "PolicyDocument": _POLICY, "ResponseMetadata": None}
listed = ec2.describe_verified_access_groups(VerifiedAccessInstanceId=inst_id)["VerifiedAccessGroups"]
assert [(g["VerifiedAccessGroupId"], g["Tags"]) for g in listed] == [(group_id, [{"Key": "team", "Value": "a"}])]
bare_group = _group(ec2, inst_id)
policy = ec2.get_verified_access_group_policy(VerifiedAccessGroupId=bare_group)
assert (policy["PolicyEnabled"], "PolicyDocument" in policy) == (False, False)
modified = ec2.modify_verified_access_group(VerifiedAccessGroupId=bare_group, Description="renamed")["VerifiedAccessGroup"]
assert modified["Description"] == "renamed" and "Tags" not in modified
# A group can move to an instance without a trust provider.
target = _instance(ec2)
moved = ec2.modify_verified_access_group(VerifiedAccessGroupId=bare_group, VerifiedAccessInstanceId=target)
assert moved["VerifiedAccessGroup"]["VerifiedAccessInstanceId"] == target
deleted = ec2.delete_verified_access_group(VerifiedAccessGroupId=group_id)["VerifiedAccessGroup"]
assert deleted["DeletionTime"] and "Tags" not in deleted
with pytest.raises(ClientError) as exc:
ec2.describe_verified_access_groups(VerifiedAccessGroupIds=[group_id])
assert _error(exc) == ("InvalidVerifiedAccessGroupId.NotFound", f"VerifiedAccessGroup {group_id} does not exist")
with pytest.raises(ClientError) as exc:
ec2.delete_verified_access_group(VerifiedAccessGroupId=group_id)
assert _error(exc) == ("InvalidVerifiedAccessGroupId.NotFound", f"The verified-access-group ID '{group_id}' does not exist")
_cleanup(ec2, groups=[bare_group], instances=[inst_id, target], providers=[tp_id])
def test_verified_access_group_policy_rules(ec2):
"""W5:policy:*, V3:policy:*, W5:policy:sse-fake-key, W5:policy:sse-real-key, V3:policy:sse-key-not-enabled,
V3:create:group-sse-enabled-no-key, V3:create:group-sse-fake-key."""
inst_id, tp_id = _instance_with_provider(ec2)
group_id = _group(ec2, inst_id, PolicyDocument=_POLICY)
modify = ec2.modify_verified_access_group_policy
for kwargs, code, message in (
({"PolicyEnabled": True}, "MissingParameter", "Policy Document must be provided when Policy Enabled is true"),
({"PolicyDocument": _POLICY}, "InvalidParameterValue", "Policy Document cannot be provided when Policy Enabled is false or missing"),
({"PolicyEnabled": False, "PolicyDocument": _POLICY}, "InvalidParameterValue",
"Policy Document cannot be provided when Policy Enabled is false or missing"),
):
with pytest.raises(ClientError) as exc:
modify(VerifiedAccessGroupId=group_id, **kwargs)
assert _error(exc) == (code, message)
unchanged = modify(VerifiedAccessGroupId=group_id)
assert (unchanged["PolicyEnabled"], unchanged["PolicyDocument"]) == (True, _POLICY)
fake_key = "arn:aws:kms:us-east-1:000000000000:key/00000000-0000-0000-0000-000000000000"
with pytest.raises(ClientError) as exc:
modify(VerifiedAccessGroupId=group_id, SseSpecification={"CustomerManagedKeyEnabled": True, "KmsKeyArn": fake_key})
assert _error(exc) == ("InvalidParameterValue", f"Could not find the following key: {fake_key}")
with pytest.raises(ClientError) as exc:
_group(ec2, inst_id, SseSpecification={"CustomerManagedKeyEnabled": True})
assert _error(exc) == ("MissingParameter", "Invalid value for parameter KmsKeyArn")
key_arn = make_client("kms").create_key()["KeyMetadata"]["Arn"]
with_key = modify(VerifiedAccessGroupId=group_id, SseSpecification={"CustomerManagedKeyEnabled": True, "KmsKeyArn": key_arn})
assert with_key["SseSpecification"] == {"CustomerManagedKeyEnabled": True, "KmsKeyArn": key_arn}
assert (with_key["PolicyEnabled"], with_key["PolicyDocument"]) == (True, _POLICY)
off = modify(VerifiedAccessGroupId=group_id, SseSpecification={"CustomerManagedKeyEnabled": False, "KmsKeyArn": key_arn})
assert off["SseSpecification"] == {"CustomerManagedKeyEnabled": False}
disabled = modify(VerifiedAccessGroupId=group_id, PolicyEnabled=False)
assert (disabled["PolicyEnabled"], "PolicyDocument" in disabled) == (False, False)
policy = ec2.get_verified_access_group_policy(VerifiedAccessGroupId=group_id)
assert (policy["PolicyEnabled"], "PolicyDocument" in policy) == (False, False)
_cleanup(ec2, groups=[group_id], instances=[inst_id], providers=[tp_id])
# ── Describe and id checks ─────────────────────────────────
_DESCRIBES = {
"instances": ("describe_verified_access_instances", "VerifiedAccessInstanceIds", "Instance", 5, 200),
"trust_providers": ("describe_verified_access_trust_providers", "VerifiedAccessTrustProviderIds", "TrustProvider", 5, 1000),
"groups": ("describe_verified_access_groups", "VerifiedAccessGroupIds", "Group", 5, 200),
"endpoints": ("describe_verified_access_endpoints", "VerifiedAccessEndpointIds", "Endpoint", 5, 200),
"logging": ("describe_verified_access_instance_logging_configurations", "VerifiedAccessInstanceIds", "Instance", 1, 10),
}
@pytest.mark.parametrize("name", list(_DESCRIBES))
def test_verified_access_describe_checks(raw, name):
"""A1:*, A12:*, B1:*, B12:*, C1:*, D1:* for each Describe call."""
op, member, kind, low, high = _DESCRIBES[name]
call = getattr(raw, op)
singular = member[:-1]
lengths = {"Instance": (5, 21), "TrustProvider": (6, 22), "Group": (6, 22), "Endpoint": (5, 21)}[kind]
missing = _MISSING[kind]
cases = [
({member: [missing]}, f"InvalidVerifiedAccess{kind}Id.NotFound", f"VerifiedAccess{kind} {missing} does not exist"),
({member: ["abc"]}, "InvalidParameterValue", f"Length of parameter {singular} must be between {lengths[0]} and {lengths[1]}"),
({member: [missing[:4] + "_" + missing[5:]]}, "InvalidParameterValue",
f"Value of parameter {singular} must match regular expression [a-z0-9-]+"),
({member: [missing, "abc"]}, "InvalidParameterValue",
f"Length of parameter {singular} must be between {lengths[0]} and {lengths[1]}"),
({member: ["abc"], "MaxResults": low}, "InvalidParameterCombination",
f"The parameters {member} and MaxResults cannot be used together"),
({member: [missing], "MaxResults": low, "NextToken": "x"}, "InvalidParameterCombination",
f"The parameters {member} and NextToken cannot be used together"),
({"MaxResults": low - 1}, "InvalidParameterValue", f"The parameter MaxResults must be between {low} and {high}"),
({"MaxResults": high + 1}, "InvalidParameterValue", f"The parameter MaxResults must be between {low} and {high}"),
({"MaxResults": low - 1, "NextToken": "x"}, "InvalidParameterValue", f"The parameter MaxResults must be between {low} and {high}"),
({"MaxResults": "abc"}, "InvalidParameterValue", "Invalid integer value abc"),
({"NextToken": "not-a-token"}, "InvalidParameterValue", "Next token is invalid"),
]
for params, code, message in cases:
with pytest.raises(ClientError) as exc:
call(**params)
assert (_status(exc), *_error(exc)) == (400, code, message), params
call(MaxResults=low)
call(MaxResults=high)
# Filter names AWS does not know are ignored.
call(Filters=[{"Name": "bogus", "Values": ["x"]}])
def test_verified_access_describe_member_checks(raw):
"""B1:groups:instance-missing+group-missing, C1:groups:*, C1:endpoints:*, D1:endpoints:*, D1:groups:*."""
vai, vagr, vae = _MISSING["Instance"], _MISSING["Group"], _MISSING["Endpoint"]
for op, params, code, message in (
("describe_verified_access_groups", {"VerifiedAccessInstanceId": vai, "VerifiedAccessGroupIds": [vagr]},
"InvalidVerifiedAccessGroupId.NotFound", f"VerifiedAccessGroup {vagr} does not exist"),
("describe_verified_access_groups", {"VerifiedAccessInstanceId": "abc", "VerifiedAccessGroupIds": [vagr]},
"InvalidParameterValue", "Length of parameter VerifiedAccessInstanceId must be between 5 and 21"),
("describe_verified_access_groups", {"VerifiedAccessInstanceId": vai, "MaxResults": 0},
"InvalidParameterValue", "The parameter MaxResults must be between 5 and 200"),
("describe_verified_access_groups", {"VerifiedAccessInstanceId": vai, "NextToken": "x"},
"InvalidParameterValue", "Next token is invalid"),
("describe_verified_access_groups", {"VerifiedAccessInstanceId": vai},
"InvalidVerifiedAccessInstanceId.NotFound", f"VerifiedAccessInstance {vai} does not exist"),
("describe_verified_access_endpoints", {"VerifiedAccessInstanceId": vai, "VerifiedAccessGroupId": vagr},
"InvalidParameterCombination", "The parameters VerifiedAccessInstanceId and VerifiedAccessGroupId cannot be used together"),
("describe_verified_access_endpoints", {"VerifiedAccessInstanceId": "abc", "VerifiedAccessGroupId": "abc"},
"InvalidParameterValue", "Length of parameter VerifiedAccessInstanceId must be between 5 and 21"),
("describe_verified_access_endpoints", {"VerifiedAccessInstanceId": vai, "VerifiedAccessGroupId": vagr, "MaxResults": 0},
"InvalidParameterValue", "The parameter MaxResults must be between 5 and 200"),
("describe_verified_access_endpoints", {"VerifiedAccessInstanceId": vai, "VerifiedAccessEndpointIds": [vae]},
"InvalidVerifiedAccessEndpointId.NotFound", f"VerifiedAccessEndpoint {vae} does not exist"),
("describe_verified_access_endpoints", {"VerifiedAccessGroupId": vagr},
"InvalidVerifiedAccessGroupId.NotFound", f"VerifiedAccessGroup {vagr} does not exist"),
):
with pytest.raises(ClientError) as exc:
getattr(raw, op)(**params)
assert _error(exc) == (code, message), params
_REQUIRED = [
("delete_verified_access_instance", "VerifiedAccessInstanceId"),
("modify_verified_access_instance", "VerifiedAccessInstanceId"),
("delete_verified_access_trust_provider", "VerifiedAccessTrustProviderId"),
("modify_verified_access_trust_provider", "VerifiedAccessTrustProviderId"),
("create_verified_access_group", "VerifiedAccessInstanceId"),
("modify_verified_access_group", "VerifiedAccessGroupId"),
("delete_verified_access_group", "VerifiedAccessGroupId"),
("get_verified_access_group_policy", "VerifiedAccessGroupId"),
("modify_verified_access_group_policy", "VerifiedAccessGroupId"),
("modify_verified_access_endpoint", "VerifiedAccessEndpointId"),
("delete_verified_access_endpoint", "VerifiedAccessEndpointId"),
("get_verified_access_endpoint_policy", "VerifiedAccessEndpointId"),
("modify_verified_access_endpoint_policy", "VerifiedAccessEndpointId"),
]
@pytest.mark.parametrize("op, member", _REQUIRED)
def test_verified_access_missing_parameter(raw, op, member):
"""E1:<Operation>:no-params."""
with pytest.raises(ClientError) as exc:
getattr(raw, op)()
assert _error(exc) == ("MissingParameter", f"The request must include the {member} parameter. "
"Add the required parameter and retry the request.")
def test_verified_access_missing_parameters_listed(raw):
"""E1:AttachVerifiedAccessTrustProvider:*, E1:DetachVerifiedAccessTrustProvider:*, E1:ModifyVerifiedAccessInstanceLoggingConfiguration:*,
W1:create_verified_access_endpoint:no-params."""
for call in (raw.attach_verified_access_trust_provider, raw.detach_verified_access_trust_provider):
with pytest.raises(ClientError) as exc:
call()
assert _error(exc)[1] == ("The request must include the following parameters: VerifiedAccessInstanceId, "
"VerifiedAccessTrustProviderId. Add the required parameters and retry the request.")
with pytest.raises(ClientError) as exc:
call(VerifiedAccessInstanceId=_MISSING["Instance"])
assert _error(exc)[1] == ("The request must include the VerifiedAccessTrustProviderId parameter. "
"Add the required parameter and retry the request.")
with pytest.raises(ClientError) as exc:
raw.modify_verified_access_instance_logging_configuration()
assert _error(exc)[1] == ("The request must include the following parameters: AccessLogs, VerifiedAccessInstanceId. "
"Add the required parameters and retry the request.")
with pytest.raises(ClientError) as exc:
raw.create_verified_access_endpoint(EndpointType="load-balancer")
assert _error(exc) == ("MissingParameter", "Missing required parameter VerifiedAccessGroupId")
_WRITE_ID_CHECKS = [
# (operation, member, kind, extra request members, NotFound wording)
("modify_verified_access_instance", "VerifiedAccessInstanceId", "Instance", {}, "single"),
("delete_verified_access_instance", "VerifiedAccessInstanceId", "Instance", {}, "single"),
("modify_verified_access_instance_logging_configuration", "VerifiedAccessInstanceId", "Instance",
{"AccessLogs": {"IncludeTrustContext": False}}, "single"),
("create_verified_access_group", "VerifiedAccessInstanceId", "Instance", {}, "single"),
("modify_verified_access_trust_provider", "VerifiedAccessTrustProviderId", "TrustProvider", {}, "listed"),
("delete_verified_access_trust_provider", "VerifiedAccessTrustProviderId", "TrustProvider", {}, "listed"),
("modify_verified_access_group", "VerifiedAccessGroupId", "Group", {}, "single"),
("delete_verified_access_group", "VerifiedAccessGroupId", "Group", {}, "single"),
("modify_verified_access_group_policy", "VerifiedAccessGroupId", "Group", {}, "single"),
("get_verified_access_group_policy", "VerifiedAccessGroupId", "Group", {}, "single"),
("create_verified_access_endpoint", "VerifiedAccessGroupId", "Group",
{"EndpointType": "network-interface", "AttachmentType": "vpc"}, "single"),
("modify_verified_access_endpoint", "VerifiedAccessEndpointId", "Endpoint", {}, "single"),
("delete_verified_access_endpoint", "VerifiedAccessEndpointId", "Endpoint", {}, "single"),
("modify_verified_access_endpoint_policy", "VerifiedAccessEndpointId", "Endpoint", {}, "single"),
("get_verified_access_endpoint_policy", "VerifiedAccessEndpointId", "Endpoint", {}, "single"),
]
@pytest.mark.parametrize("op, member, kind, extra, wording", _WRITE_ID_CHECKS, ids=[c[0] for c in _WRITE_ID_CHECKS])
def test_verified_access_id_checks_on_single_resource_calls(raw, op, member, kind, extra, wording):
"""W1:<op>:missing/abc/upper/inner-upper/underscore, F1:get_verified_access_*_policy:*: trust provider calls
hold the whole id to the pattern; the other calls only the part before the first hyphen."""
missing = _MISSING[kind]
prefix, _, rest = missing.partition("-")
inner_upper = f"{prefix}-{rest[:7]}A{rest[8:]}"
pattern_error = ("InvalidParameterValue", f"Value of parameter {member} must match regular expression [a-z0-9-]+")
rtype = {"Instance": "instance", "TrustProvider": "trust-provider", "Group": "group", "Endpoint": "endpoint"}[kind]
def not_found(value):
if wording == "listed":
return f"InvalidVerifiedAccess{kind}Id.NotFound", f"VerifiedAccess{kind} {value} does not exist"
return f"InvalidVerifiedAccess{kind}Id.NotFound", f"The verified-access-{rtype} ID '{value}' does not exist"
lengths = {"Instance": (5, 21), "TrustProvider": (6, 22), "Group": (6, 22), "Endpoint": (5, 21)}[kind]
expected = {
missing: not_found(missing),
"abc": ("InvalidParameterValue", f"Length of parameter {member} must be between {lengths[0]} and {lengths[1]}"),
f"{prefix.upper()}-{rest}": pattern_error,
f"{prefix}_{rest}": pattern_error,
inner_upper: pattern_error if kind == "TrustProvider" else not_found(inner_upper),
}
for value, error in expected.items():
with pytest.raises(ClientError) as exc:
getattr(raw, op)(**{member: value}, **extra)
assert _error(exc) == error, value
def test_verified_access_resources_are_regional_and_per_account(ec2):
"""W6:region:instance, W6:region:tp, V3:region:group, V3:region:group-policy, W6:region:modify-instance."""
west, other = _client("us-west-2"), _client(account_id="123456789012")
inst_id, tp_id = _instance_with_provider(ec2)
group_id = _group(ec2, inst_id)
for client in (west, other):
for call, kwargs, error in (
(client.describe_verified_access_instances, {"VerifiedAccessInstanceIds": [inst_id]},
("InvalidVerifiedAccessInstanceId.NotFound", f"VerifiedAccessInstance {inst_id} does not exist")),
(client.describe_verified_access_trust_providers, {"VerifiedAccessTrustProviderIds": [tp_id]},
("InvalidVerifiedAccessTrustProviderId.NotFound", f"VerifiedAccessTrustProvider {tp_id} does not exist")),
(client.describe_verified_access_groups, {"VerifiedAccessGroupIds": [group_id]},
("InvalidVerifiedAccessGroupId.NotFound", f"VerifiedAccessGroup {group_id} does not exist")),
(client.get_verified_access_group_policy, {"VerifiedAccessGroupId": group_id},
("InvalidVerifiedAccessGroupId.NotFound", f"The verified-access-group ID '{group_id}' does not exist")),
(client.modify_verified_access_instance, {"VerifiedAccessInstanceId": inst_id, "Description": "x"},
("InvalidVerifiedAccessInstanceId.NotFound", f"The verified-access-instance ID '{inst_id}' does not exist")),
):
with pytest.raises(ClientError) as exc:
call(**kwargs)
assert _error(exc) == error
_cleanup(ec2, groups=[group_id], instances=[inst_id], providers=[tp_id])
def test_verified_access_tags_and_filters(ec2):
"""V4:tags:describe-tags, V4:tags:delete-all, V4:tags:describe-untagged-group, W6:filter:*, V4:filter:*, V4:page:*."""
marker = uuid.uuid4().hex
tagged = [ec2.create_verified_access_trust_provider(
TrustProviderType="device", DeviceTrustProviderType="jumpcloud", PolicyReferenceName="j",
DeviceOptions={"TenantId": "t"}, TagSpecifications=[{"ResourceType": "verified-access-trust-provider",
"Tags": [{"Key": "run", "Value": marker}]}],
)["VerifiedAccessTrustProvider"]["VerifiedAccessTrustProviderId"] for _ in range(7)]
describe = ec2.describe_verified_access_trust_providers
by_tag = {tp["VerifiedAccessTrustProviderId"] for tp in describe(Filters=[{"Name": "tag:run", "Values": [marker]}])["VerifiedAccessTrustProviders"]}
assert by_tag == set(tagged)
assert describe(Filters=[{"Name": "tag:run", "Values": [marker]}, {"Name": "tag:Owner", "Values": ["nobody"]}])[
"VerifiedAccessTrustProviders"] == []
ignored = describe(Filters=[{"Name": "tag:run", "Values": [marker]}, {"Name": "bogus", "Values": ["x"]}])
assert len(ignored["VerifiedAccessTrustProviders"]) == 7
paged = [tp["VerifiedAccessTrustProviderId"]
for page in ec2.get_paginator("describe_verified_access_trust_providers").paginate(
Filters=[{"Name": "tag:run", "Values": [marker]}], PaginationConfig={"PageSize": 5})
for tp in page["VerifiedAccessTrustProviders"]]
assert sorted(paged) == sorted(tagged)
inst_id = _instance(ec2)
ec2.create_tags(Resources=[inst_id, tagged[0]], Tags=[{"Key": "env", "Value": "dev"}])
tags = ec2.describe_tags(Filters=[{"Name": "resource-id", "Values": [inst_id, tagged[0]]}, {"Name": "key", "Values": ["env"]}])["Tags"]
assert {(t["ResourceId"], t["ResourceType"]) for t in tags} == {
(inst_id, "verified-access-instance"), (tagged[0], "verified-access-trust-provider")}
ec2.delete_tags(Resources=[inst_id], Tags=[{"Key": "env"}])
assert ec2.describe_verified_access_instances(VerifiedAccessInstanceIds=[inst_id])["VerifiedAccessInstances"][0]["Tags"] == []
_cleanup(ec2, instances=[inst_id], providers=tagged)
# ── Endpoints ──────────────────────────────────────────────
@pytest.fixture
def endpoint_fixture(ec2):
"""An instance with a provider, a group, an internal ALB, an ENI and an issued certificate."""
subnets = [s["SubnetId"] for s in ec2.describe_subnets()["Subnets"]][:2]
lb_arn = make_client("elbv2").create_load_balancer(
Name=f"va-{uuid.uuid4().hex[:10]}", Subnets=subnets, Scheme="internal", Type="application",
)["LoadBalancers"][0]["LoadBalancerArn"]
eni = ec2.create_network_interface(SubnetId=subnets[0])["NetworkInterface"]["NetworkInterfaceId"]
vpc_id = ec2.describe_subnets(SubnetIds=subnets[:1])["Subnets"][0]["VpcId"]
sg = ec2.create_security_group(GroupName=f"va-{uuid.uuid4().hex[:8]}", Description="va", VpcId=vpc_id)["GroupId"]
cert = make_client("acm").request_certificate(
DomainName="app.example.com", SubjectAlternativeNames=["app.example.com", "eni.example.com"])["CertificateArn"]
inst_id, tp_id = _instance_with_provider(ec2)
group_id = _group(ec2, inst_id)
fixture = {"lb": lb_arn, "eni": eni, "sg": sg, "cert": cert, "subnets": subnets, "instance": inst_id, "provider": tp_id,
"group": group_id}
yield fixture
for ep in ec2.describe_verified_access_endpoints(VerifiedAccessInstanceId=inst_id)["VerifiedAccessEndpoints"]:
if ep["Status"]["Code"] != "deleting":
ec2.delete_verified_access_endpoint(VerifiedAccessEndpointId=ep["VerifiedAccessEndpointId"])
groups = [g["VerifiedAccessGroupId"] for g in ec2.describe_verified_access_groups()["VerifiedAccessGroups"]
if g["VerifiedAccessInstanceId"] == inst_id]
_cleanup(ec2, groups=groups, instances=[inst_id], providers=[tp_id])
def _lb_endpoint_params(fx, **over):
params = dict(VerifiedAccessGroupId=fx["group"], EndpointType="load-balancer", AttachmentType="vpc",
DomainCertificateArn=fx["cert"], ApplicationDomain="app.example.com", EndpointDomainPrefix="app",
SecurityGroupIds=[fx["sg"]],
LoadBalancerOptions={"Protocol": "https", "Port": 443, "LoadBalancerArn": fx["lb"], "SubnetIds": fx["subnets"]})
params.update(over)
return {k: v for k, v in params.items() if v is not None}
def test_verified_access_endpoint_create_errors(raw, endpoint_fixture):
"""X1:invalid:*, V5:invalid:*, Y1:invalid:*, W1:create_verified_access_endpoint:*."""
fx = endpoint_fixture
lb = {"Protocol": "https", "Port": 443, "LoadBalancerArn": fx["lb"], "SubnetIds": fx["subnets"]}
eni = {"NetworkInterfaceId": fx["eni"], "Protocol": "https", "Port": 443}
cases = [
({"EndpointType": None}, "MissingParameter", "Required parameter EndpointType was empty or null in the request"),
({"EndpointType": None, "AttachmentType": None}, "MissingParameter",
"Required parameter EndpointType was empty or null in the request"),
({"AttachmentType": None}, "MissingParameter", "Required parameter AttachmentType was empty or null in the request"),
({"SecurityGroupIds": ["sg-00000000000000000"]}, "InvalidParameterValue", "The Security Group Ids are invalid"),
({"LoadBalancerOptions": {**lb, "SubnetIds": ["subnet-00000000000000000"]}}, "InvalidParameterValue",
"Invalid value for parameter SubnetIds"),
({"VerifiedAccessGroupId": _MISSING["Group"], "EndpointType": "bogus"}, "InvalidVerifiedAccessGroupId.NotFound",
f"The verified-access-group ID '{_MISSING['Group']}' does not exist"),
({"EndpointType": "bogus"}, "InvalidParameterValue", "The value of endpointType you provided is not valid"),
({"AttachmentType": "bogus"}, "InvalidParameterValue", "The value of attachmentType you provided is not valid"),
({"EndpointType": "rds", "LoadBalancerOptions": None}, "MissingParameter", "Missing required parameter RdsOptions"),
({"EndpointType": "cidr", "LoadBalancerOptions": None}, "MissingParameter", "Missing required parameter CidrOptions"),
({"LoadBalancerOptions": None, "DomainCertificateArn": "arn:c"}, "MissingParameter",
"LoadBalancerOptions must be provided if endpoint type load-balancer is specified"),
({"LoadBalancerOptions": None, "NetworkInterfaceOptions": eni}, "MissingParameter",
"LoadBalancerOptions must be provided if endpoint type load-balancer is specified"),
({"LoadBalancerOptions": {k: v for k, v in lb.items() if k != "LoadBalancerArn"}}, "MissingParameter",
"LoadBalancerArn must be provided in LoadBalancerOptions"),
({"NetworkInterfaceOptions": eni}, "InvalidParameterCombination",
"NetworkInterfaceOptions cannot be provided if endpoint type load-balancer is specified"),
({"LoadBalancerOptions": {**lb, "PortRanges": [{"FromPort": 443, "ToPort": 443}]}}, "InvalidParameterValue",
"Parameter PortRanges is not currently supported for the operation"),
({"DomainCertificateArn": None}, "MissingParameter", "Missing required parameter DomainCertificateArn"),
({"ApplicationDomain": None}, "MissingParameter", "Missing required parameter ApplicationDomain"),
({"EndpointDomainPrefix": None}, "MissingParameter", "Missing required parameter EndpointDomainPrefix"),
({"LoadBalancerOptions": {**lb, "LoadBalancerArn": fx["lb"][:-16] + "0" * 16}}, "InvalidParameterValue",
"The LoadBalancerArn is invalid"),
({"DomainCertificateArn": fx["cert"][:-12] + "0" * 12}, "InvalidParameterValue", "The CertificateArn is invalid"),
({"ApplicationDomain": "other.example.com"}, "InvalidParameterValue",
"The ApplicationDomain provided is not present in the DomainCertificateArn provided in the request."),
({"EndpointType": "network-interface", "LoadBalancerOptions": None}, "MissingParameter",
"NetworkInterfaceOptions must be provided if endpoint type network-interface is specified"),
({"EndpointType": "network-interface", "NetworkInterfaceOptions": eni}, "InvalidParameterCombination",
"LoadBalancerOptions cannot be provided if endpoint type network-interface is specified"),
({"EndpointType": "network-interface", "LoadBalancerOptions": None,
"NetworkInterfaceOptions": {"Protocol": "https", "Port": 443}}, "MissingParameter",
"Missing required parameter NetworkInterfaceId"),
({"EndpointType": "network-interface", "LoadBalancerOptions": None,
"NetworkInterfaceOptions": {**eni, "NetworkInterfaceId": "eni-00000000000000000"}}, "InvalidParameterValue",
"NetworkInterfaceId is invalid"),
]
for over, code, message in cases:
with pytest.raises(ClientError) as exc:
raw.create_verified_access_endpoint(**_lb_endpoint_params(fx, **over))
assert (_status(exc), *_error(exc)) == (400, code, message), over
assert raw.describe_verified_access_endpoints(VerifiedAccessGroupId=fx["group"])["VerifiedAccessEndpoints"] == []
def test_verified_access_endpoint_create_check_order(raw, endpoint_fixture):
"""Z4:invalid:*, Q3:invalid:*, R4:invalid:*, R5:*, S4:invalid:* (two faults per request: the one AWS reports)."""
fx = endpoint_fixture
lb = {"Protocol": "https", "Port": 443, "LoadBalancerArn": fx["lb"], "SubnetIds": fx["subnets"]}
bad_lb = {**lb, "LoadBalancerArn": fx["lb"][:-16] + "0" * 16}
bad_cert = fx["cert"][:-12] + "0" * 12
cases = [
({"EndpointType": None, "AttachmentType": "bogus"}, "InvalidParameterValue",
"The value of attachmentType you provided is not valid"),
({"EndpointType": "bogus", "AttachmentType": "bogus"}, "InvalidParameterValue",
"The value of endpointType you provided is not valid; The value of attachmentType you provided is not valid"),
({"EndpointType": "bogus", "AttachmentType": None}, "InvalidParameterValue", "The value of endpointType you provided is not valid"),
({"AttachmentType": None, "LoadBalancerOptions": None}, "MissingParameter",
"Required parameter AttachmentType was empty or null in the request"),
({"LoadBalancerOptions": {k: v for k, v in lb.items() if k != "Protocol"}}, "MissingParameter",
"Missing required parameter protocol in EniOptions"),
({"LoadBalancerOptions": {"Port": 443, "PortRanges": [{"FromPort": 1, "ToPort": 2}]}}, "MissingParameter",
"Missing required parameter protocol in EniOptions"),
({"LoadBalancerOptions": {k: v for k, v in lb.items() if k != "Port"}}, "MissingParameter",
"Port must be provided in LoadBalancerOptions"),
({"LoadBalancerOptions": {k: v for k, v in lb.items() if k != "SubnetIds"}}, "MissingParameter",
"SubnetIds must be provided in LoadBalancerOptions"),
({"LoadBalancerOptions": {**lb, "Protocol": "ftp"}}, "InvalidParameterValue",
"The value of loadBalancerOptions.protocol you provided is not valid"),
({"LoadBalancerOptions": {**lb, "Port": 0}}, "InvalidParameterValue", "The value of loadBalancerOptions.port you provided is not valid"),
({"EndpointType": "network-interface", "LoadBalancerOptions": None,
"NetworkInterfaceOptions": {"NetworkInterfaceId": fx["eni"], "Port": 443}}, "MissingParameter",
"Missing required parameter protocol in EniOptions"),
({"SecurityGroupIds": None, "LoadBalancerOptions": {**lb, "SubnetIds": ["subnet-00000000000000000"]}},
"InvalidParameterValue", "Invalid value for parameter SubnetIds"),
({"LoadBalancerOptions": {**lb, "SubnetIds": ["subnet-00000000000000000"]}, "DomainCertificateArn": bad_cert},
"InvalidParameterValue", "Invalid value for parameter SubnetIds"),
({"SecurityGroupIds": ["sg-00000000000000000"], "LoadBalancerOptions": bad_lb}, "InvalidParameterValue",
"The LoadBalancerArn is invalid"),
({"ApplicationDomain": None, "LoadBalancerOptions": bad_lb}, "InvalidParameterValue", "The LoadBalancerArn is invalid"),
({"EndpointDomainPrefix": "a.b", "LoadBalancerOptions": bad_lb}, "InvalidParameterValue", "The LoadBalancerArn is invalid"),
({"DomainCertificateArn": None, "ApplicationDomain": None, "EndpointDomainPrefix": None}, "MissingParameter",
"Missing required parameter DomainCertificateArn"),
({"ApplicationDomain": None, "EndpointDomainPrefix": None}, "MissingParameter", "Missing required parameter ApplicationDomain"),
({"EndpointDomainPrefix": None, "DomainCertificateArn": bad_cert}, "MissingParameter",
"Missing required parameter EndpointDomainPrefix"),
({"SecurityGroupIds": None, "DomainCertificateArn": None}, "MissingParameter", "Missing required parameter DomainCertificateArn"),
({"ApplicationDomain": None, "EndpointDomainPrefix": "a.b"}, "MissingParameter", "Missing required parameter ApplicationDomain"),
({"SecurityGroupIds": ["sg-00000000000000000"], "EndpointDomainPrefix": "a.b"}, "InvalidParameterValue",
"The Security Group Ids are invalid"),
({"SecurityGroupIds": ["sg-00000000000000000"], "ApplicationDomain": "x.other.com"}, "InvalidParameterValue",
"The Security Group Ids are invalid"),
({"SecurityGroupIds": None, "EndpointDomainPrefix": "a.b"}, "InvalidParameterValue",
"The EndpointDomainPrefix provided in the request contains unsupported characters"),
({"EndpointDomainPrefix": "a.b", "DomainCertificateArn": bad_cert}, "InvalidParameterValue",
"The EndpointDomainPrefix provided in the request contains unsupported characters"),
({"EndpointDomainPrefix": "-ab"}, "InvalidParameterValue", "The EndpointDomainPrefix provided in the request contains unsupported characters"),
({"EndpointDomainPrefix": "ab-"}, "InvalidParameterValue", "The EndpointDomainPrefix provided in the request contains unsupported characters"),
({"EndpointDomainPrefix": "a.bbbbbbbbbbbbbbbbbbb"}, "InvalidParameterValue",
"The EndpointDomainPrefix provided in the request contains unsupported characters"),
({"EndpointDomainPrefix": "a" * 21}, "InvalidParameterValue", "Provided EndpointDomainPrefix exceeds max character limit of 20 characters"),
({"SecurityGroupIds": None}, "MissingParameter", "Security Group Ids must be provided if attachment type vpc is selected"),
({"SecurityGroupIds": None, "DomainCertificateArn": bad_cert}, "InvalidParameterValue", "The CertificateArn is invalid"),
({"LoadBalancerOptions": {**lb, "Protocol": "tcp"}}, "InvalidParameterValue",
"Parameter port in LoadBalancerOptions is not supported with 'tcp' protocol"),
({"LoadBalancerOptions": {k: v for k, v in {**lb, "Protocol": "tcp"}.items() if k != "Port"}}, "MissingParameter",
"PortRanges must be provided in LoadBalancerOptions"),
({"EndpointType": "network-interface", "LoadBalancerOptions": None,
"NetworkInterfaceOptions": {"NetworkInterfaceId": fx["eni"], "Protocol": "tcp", "Port": 443}}, "InvalidParameterValue",
"Parameter port in EniOptions is not supported with 'tcp' protocol"),
({"LoadBalancerOptions": {k: v for k, v in {**lb, "Port": 0}.items() if k != "SubnetIds"}}, "InvalidParameterValue",
"The value of loadBalancerOptions.port you provided is not valid"),
({"EndpointType": "network-interface", "LoadBalancerOptions": None,
"NetworkInterfaceOptions": {"Protocol": "https", "Port": 0}}, "InvalidParameterValue",
"The value of networkInterfaceOptions.port you provided is not valid"),
({"DomainCertificateArn": None, "SecurityGroupIds": ["sg-00000000000000000"]}, "InvalidParameterValue",
"The Security Group Ids are invalid"),
({"LoadBalancerOptions": {**lb, "Port": 65536}}, "InvalidParameterValue", "The value of loadBalancerOptions.port you provided is not valid"),
({"ApplicationDomain": "APP.example.com"}, "InvalidParameterValue",
"The ApplicationDomain provided is not present in the DomainCertificateArn provided in the request."),
({"EndpointDomainPrefix": "_a-bcdefghijklmnopqr", "DomainCertificateArn": bad_cert}, "InvalidParameterValue",
"The CertificateArn is invalid"),
({"LoadBalancerOptions": {"Protocol": "ftp", "SubnetIds": fx["subnets"], "LoadBalancerArn": fx["lb"]}},
"InvalidParameterValue", "The value of loadBalancerOptions.protocol you provided is not valid"),
({"LoadBalancerOptions": {"Protocol": "https", "LoadBalancerArn": fx["lb"]}}, "MissingParameter",
"Port must be provided in LoadBalancerOptions"),
({"LoadBalancerOptions": {"Protocol": "https", "Port": 443}}, "MissingParameter", "SubnetIds must be provided in LoadBalancerOptions"),
({"LoadBalancerOptions": {**lb, "Port": 0, "PortRanges": [{"FromPort": 1, "ToPort": 2}]}}, "InvalidParameterValue",
"The value of loadBalancerOptions.port you provided is not valid"),
({"LoadBalancerOptions": {**bad_lb, "SubnetIds": ["subnet-00000000000000000"]}}, "InvalidParameterValue",
"Invalid value for parameter SubnetIds"),
({"EndpointType": "network-interface", "LoadBalancerOptions": None, "NetworkInterfaceOptions": {"Port": 443}},
"MissingParameter", "Missing required parameter protocol in EniOptions"),
({"EndpointType": "network-interface", "LoadBalancerOptions": None,
"NetworkInterfaceOptions": {"NetworkInterfaceId": fx["eni"], "Protocol": "https", "Port": 0}},
"InvalidParameterValue", "The value of networkInterfaceOptions.port you provided is not valid"),
({"EndpointType": "network-interface", "LoadBalancerOptions": None,
"NetworkInterfaceOptions": {"NetworkInterfaceId": fx["eni"], "Protocol": "ftp", "Port": 443}},
"InvalidParameterValue", "The value of networkInterfaceOptions.protocol you provided is not valid"),
({"DomainCertificateArn": bad_cert, "ApplicationDomain": "x.other.com"}, "InvalidParameterValue", "The CertificateArn is invalid"),
]
for over, code, message in cases:
with pytest.raises(ClientError) as exc:
raw.create_verified_access_endpoint(**_lb_endpoint_params(fx, **over))
assert _error(exc) == (code, message), over
assert raw.describe_verified_access_endpoints(VerifiedAccessGroupId=fx["group"])["VerifiedAccessEndpoints"] == []
def test_verified_access_endpoint_prefix_wildcard_and_device_domain(ec2, endpoint_fixture):
"""Z4:invalid:prefix-upper, Z4:invalid:prefix-underscore, Z4:invalid:wild-cert-*, Q3:create:wild-one-level, Q3:invalid:wild-apex,
X2:create:lb (no device provider), Q3:create:wild-one-level (with one), Q5:create:same-domain-while-deleting."""
fx = endpoint_fixture
wild = make_client("acm").request_certificate(DomainName="*.example.com")["CertificateArn"]
for domain in ("example.com", "a.b.example.com"):
with pytest.raises(ClientError) as exc:
ec2.create_verified_access_endpoint(**_lb_endpoint_params(fx, DomainCertificateArn=wild, ApplicationDomain=domain))
assert _error(exc) == ("InvalidParameterValue", "The ApplicationDomain provided is not present in the "
"DomainCertificateArn provided in the request.")
plain = ec2.create_verified_access_endpoint(**_lb_endpoint_params(
fx, DomainCertificateArn=wild, ApplicationDomain="web.example.com", EndpointDomainPrefix="App_1"))["VerifiedAccessEndpoint"]
assert plain["EndpointDomain"].startswith("App_1.edge-")
assert "DeviceValidationDomain" not in plain
ec2.delete_verified_access_endpoint(VerifiedAccessEndpointId=plain["VerifiedAccessEndpointId"])
jamf = _device_provider(ec2, "jamf")["VerifiedAccessTrustProviderId"]
_attach(ec2, fx["instance"], jamf)
# R5:describe:after-device: the domain shows once the instance has a device provider.
assert ec2.describe_verified_access_endpoints(
VerifiedAccessEndpointIds=[plain["VerifiedAccessEndpointId"]])["VerifiedAccessEndpoints"][0]["DeviceValidationDomain"]
# The domain of an endpoint that is being deleted is free again.
with_device = ec2.create_verified_access_endpoint(**_lb_endpoint_params(
fx, DomainCertificateArn=wild, ApplicationDomain="web.example.com", EndpointDomainPrefix="web"))["VerifiedAccessEndpoint"]
edge = with_device["EndpointDomain"].split(".")[1]
validation = with_device["DeviceValidationDomain"]
assert validation.startswith(f"{edge}.vld-") and validation.endswith(".vld.prod.verified-access.us-east-1.amazonaws.com")
# One vld id per instance (Q3:create:wild-one-level and Q5:create:same-domain-while-deleting share it).
second = ec2.create_verified_access_endpoint(**_lb_endpoint_params(
fx, DomainCertificateArn=wild, ApplicationDomain="web2.example.com", EndpointDomainPrefix="web2"))["VerifiedAccessEndpoint"]
assert second["DeviceValidationDomain"].split(".")[1] == validation.split(".")[1]
assert second["EndpointDomain"].split(".")[1] != edge
ec2.delete_verified_access_endpoint(VerifiedAccessEndpointId=second["VerifiedAccessEndpointId"])
ec2.delete_verified_access_endpoint(VerifiedAccessEndpointId=with_device["VerifiedAccessEndpointId"])
ec2.describe_verified_access_endpoints(VerifiedAccessInstanceId=fx["instance"])
ec2.detach_verified_access_trust_provider(VerifiedAccessInstanceId=fx["instance"], VerifiedAccessTrustProviderId=jamf)
ec2.delete_verified_access_trust_provider(VerifiedAccessTrustProviderId=jamf)
def test_verified_access_round10_endpoints(ec2, raw, endpoint_fixture):
"""T1:*, T3:*, T4:*, T5:* (round 10): tcp, network-interface values and protocol changes on modify,
the group checked first on modify, the device validation domain after a detach."""
fx = endpoint_fixture
lb = {"Protocol": "https", "Port": 443, "LoadBalancerArn": fx["lb"], "SubnetIds": fx["subnets"]}
native = ("InvalidParameterValue", "TCP based endpoints require a TrustProvider with NativeApplicationOidcOptions to be "
"attached to the instance.")
for over, error in (
({"ApplicationDomain": "x.other.com", "SecurityGroupIds": None},
("InvalidParameterValue", "The ApplicationDomain provided is not present in the DomainCertificateArn provided in the request.")),
({"LoadBalancerOptions": {**{k: v for k, v in lb.items() if k != "Port"}, "Protocol": "tcp",
"PortRanges": [{"FromPort": 443, "ToPort": 443}]}}, native),
({"EndpointType": "network-interface", "LoadBalancerOptions": None,
"NetworkInterfaceOptions": {"NetworkInterfaceId": fx["eni"], "Protocol": "tcp"}},
("MissingParameter", "Missing required parameter PortRanges")),
({"EndpointType": "network-interface", "LoadBalancerOptions": None,
"NetworkInterfaceOptions": {"NetworkInterfaceId": fx["eni"], "Protocol": "tcp", "PortRanges": [{"FromPort": 443, "ToPort": 443}]}},
native),
):
with pytest.raises(ClientError) as exc:
raw.create_verified_access_endpoint(**_lb_endpoint_params(fx, **over))
assert _error(exc) == error, over
jamf = _device_provider(ec2, "jamf")["VerifiedAccessTrustProviderId"]
_attach(ec2, fx["instance"], jamf)
lb_ep = ec2.create_verified_access_endpoint(**_lb_endpoint_params(fx))["VerifiedAccessEndpoint"]
with pytest.raises(ClientError) as exc:
ec2.create_verified_access_endpoint(**_lb_endpoint_params(fx, EndpointDomainPrefix="w2", SecurityGroupIds=None))
assert _error(exc) == ("MissingParameter", "Security Group Ids must be provided if attachment type vpc is selected")
eni_ep = ec2.create_verified_access_endpoint(**_lb_endpoint_params(
fx, EndpointType="network-interface", LoadBalancerOptions=None, ApplicationDomain="eni.example.com",
EndpointDomainPrefix="eni", NetworkInterfaceOptions={"NetworkInterfaceId": fx["eni"], "Protocol": "https", "Port": 443},
))["VerifiedAccessEndpoint"]
me = raw.modify_verified_access_endpoint
for ep_id, kwargs, error in (
(eni_ep["VerifiedAccessEndpointId"], {"NetworkInterfaceOptions": {"Port": 0}},
("InvalidParameterValue", "The value of networkInterfaceOptions.port you provided is not valid")),
(eni_ep["VerifiedAccessEndpointId"], {"NetworkInterfaceOptions": {"Protocol": "ftp"}},
("InvalidParameterValue", "The value of networkInterfaceOptions.protocol you provided is not valid")),
(eni_ep["VerifiedAccessEndpointId"], {"NetworkInterfaceOptions": {"Protocol": "tcp", "Port": 443}},
("InvalidParameterValue", "Protocol cannot be modified between HTTP/HTTPS and TCP")),
(lb_ep["VerifiedAccessEndpointId"], {"LoadBalancerOptions": {"Protocol": "tcp"}},
("InvalidParameterValue", "Protocol cannot be modified between HTTP/HTTPS and TCP")),
(lb_ep["VerifiedAccessEndpointId"], {"VerifiedAccessGroupId": _MISSING["Group"], "NetworkInterfaceOptions": {"Port": 80}},
("InvalidVerifiedAccessGroupId.NotFound", f"The verified-access-group ID '{_MISSING['Group']}' does not exist")),
(lb_ep["VerifiedAccessEndpointId"], {"VerifiedAccessGroupId": _MISSING["Group"], "LoadBalancerOptions": {"Port": 0}},
("InvalidVerifiedAccessGroupId.NotFound", f"The verified-access-group ID '{_MISSING['Group']}' does not exist")),
):
with pytest.raises(ClientError) as exc:
me(VerifiedAccessEndpointId=ep_id, **kwargs)
assert _error(exc) == error, kwargs
ec2.detach_verified_access_trust_provider(VerifiedAccessInstanceId=fx["instance"], VerifiedAccessTrustProviderId=jamf)
after = ec2.describe_verified_access_endpoints(VerifiedAccessEndpointIds=[lb_ep["VerifiedAccessEndpointId"]])
assert after["VerifiedAccessEndpoints"][0]["DeviceValidationDomain"] == lb_ep["DeviceValidationDomain"]
for ep in (lb_ep, eni_ep):
ec2.delete_verified_access_endpoint(VerifiedAccessEndpointId=ep["VerifiedAccessEndpointId"])
ec2.delete_verified_access_trust_provider(VerifiedAccessTrustProviderId=jamf)
def test_verified_access_round11_endpoints(ec2, raw, endpoint_fixture):
"""U1:*, U3:logging:*, U4:*, U5:*, U7:* (round 11): the tcp check order on create and modify, another
account as the log bucket owner, the device domain without a read, and an endpoint in an orphaned group."""
fx = endpoint_fixture
lb = {"Protocol": "https", "Port": 443, "LoadBalancerArn": fx["lb"], "SubnetIds": fx["subnets"]}
ranges = [{"FromPort": 443, "ToPort": 443}]
tcp_lb = {"Protocol": "tcp", "LoadBalancerArn": fx["lb"], "SubnetIds": fx["subnets"], "PortRanges": ranges}
native = ("InvalidParameterValue", "TCP based endpoints require a TrustProvider with NativeApplicationOidcOptions to be "
"attached to the instance.")
eni = {"EndpointType": "network-interface", "LoadBalancerOptions": None}
for over, error in (
({"LoadBalancerOptions": {**tcp_lb, "Port": 443}},
("InvalidParameterValue", "Parameter port in LoadBalancerOptions is not supported with 'tcp' protocol")),
({"LoadBalancerOptions": {**lb, "Protocol": "tcp", "Port": 0}},
("InvalidParameterValue", "The value of loadBalancerOptions.port you provided is not valid")),
({"LoadBalancerOptions": {k: v for k, v in tcp_lb.items() if k != "LoadBalancerArn"}},
("MissingParameter", "LoadBalancerArn must be provided in LoadBalancerOptions")),
({"LoadBalancerOptions": {k: v for k, v in tcp_lb.items() if k != "SubnetIds"}}, native),
({"LoadBalancerOptions": {**tcp_lb, "SubnetIds": ["subnet-00000000000000000"]}},
("InvalidParameterValue", "Invalid value for parameter SubnetIds")),
({"LoadBalancerOptions": {**tcp_lb, "LoadBalancerArn": fx["lb"][:-16] + "0" * 16}},
("InvalidParameterValue", "The LoadBalancerArn is invalid")),
({"LoadBalancerOptions": tcp_lb, "SecurityGroupIds": None},
("MissingParameter", "Security Group Ids must be provided if attachment type vpc is selected")),
({"LoadBalancerOptions": tcp_lb, "DomainCertificateArn": fx["cert"][:-12] + "0" * 12}, native),
({**eni, "NetworkInterfaceOptions": {"NetworkInterfaceId": "eni-00000000000000000", "Protocol": "tcp", "PortRanges": ranges}},
("InvalidParameterValue", "NetworkInterfaceId is invalid")),
({**eni, "NetworkInterfaceOptions": {"Protocol": "tcp", "PortRanges": ranges}},
("MissingParameter", "Missing required parameter NetworkInterfaceId")),
):
with pytest.raises(ClientError) as exc:
raw.create_verified_access_endpoint(**_lb_endpoint_params(fx, **over))
assert _error(exc) == error, over
bucket = f"va-owner-{uuid.uuid4().hex[:8]}"
make_client("s3").create_bucket(Bucket=bucket)
lm = ec2.modify_verified_access_instance_logging_configuration
with pytest.raises(ClientError) as exc:
lm(VerifiedAccessInstanceId=fx["instance"],
AccessLogs={"S3": {"Enabled": True, "BucketName": bucket, "BucketOwner": "123456789012"}})
assert _error(exc) == ("LogDestinationPermissionIssue", "User does not have permission to configure log destination "
"resource identified by AccessLogs.S3.BucketName for log delivery")
assert _status(exc) == 400
account = make_client("sts").get_caller_identity()["Account"]
logs = lm(VerifiedAccessInstanceId=fx["instance"],
AccessLogs={"S3": {"Enabled": True, "BucketName": bucket, "BucketOwner": account}})["LoggingConfiguration"]
assert logs["AccessLogs"]["S3"]["BucketOwner"] == account
lm(VerifiedAccessInstanceId=fx["instance"], AccessLogs={"S3": {"Enabled": False}})
# An attach and a detach with no read between them still leave the endpoint a device validation domain.
jamf = _device_provider(ec2, "jamf")["VerifiedAccessTrustProviderId"]
_attach(ec2, fx["instance"], jamf)
ec2.detach_verified_access_trust_provider(VerifiedAccessInstanceId=fx["instance"], VerifiedAccessTrustProviderId=jamf)
ep = ec2.create_verified_access_endpoint(**_lb_endpoint_params(fx))["VerifiedAccessEndpoint"]
assert ep["DeviceValidationDomain"]
ep_id = ep["VerifiedAccessEndpointId"]
for opts, error in (
({"Port": 0, "PortRanges": [{"FromPort": 1, "ToPort": 2}]},
"The value of loadBalancerOptions.port you provided is not valid"),
({"Protocol": "tcp", "PortRanges": [{"FromPort": 1, "ToPort": 2}]}, "Protocol cannot be modified between HTTP/HTTPS and TCP"),
({"Protocol": "tcp", "SubnetIds": ["subnet-00000000000000000"]}, "Protocol cannot be modified between HTTP/HTTPS and TCP"),
({"Protocol": "tcp", "Port": 0}, "The value of loadBalancerOptions.port you provided is not valid"),
({"Protocol": "ftp", "PortRanges": [{"FromPort": 1, "ToPort": 2}]},
"The value of loadBalancerOptions.protocol you provided is not valid"),
):
with pytest.raises(ClientError) as exc:
raw.modify_verified_access_endpoint(VerifiedAccessEndpointId=ep_id, LoadBalancerOptions=opts)
assert _error(exc) == ("InvalidParameterValue", error), opts
ec2.delete_verified_access_endpoint(VerifiedAccessEndpointId=ep_id)
ec2.delete_verified_access_trust_provider(VerifiedAccessTrustProviderId=jamf)
# A group moved to a bare instance that is then deleted takes no HTTP/HTTPS endpoint.
orphan = _group(ec2, fx["instance"])
bare = _instance(ec2)
ec2.modify_verified_access_group(VerifiedAccessGroupId=orphan, VerifiedAccessInstanceId=bare)
ec2.delete_verified_access_instance(VerifiedAccessInstanceId=bare)
with pytest.raises(ClientError) as exc:
ec2.create_verified_access_endpoint(**_lb_endpoint_params(fx, VerifiedAccessGroupId=orphan))
assert _error(exc) == ("InvalidParameterValue",
"HTTP/HTTPS based endpoints require a TrustProvider with OidcOptions to be attached to the instance.")
ec2.delete_verified_access_group(VerifiedAccessGroupId=orphan)
def test_verified_access_round12_check_orders(ec2, raw, endpoint_fixture):
"""V1:invalid:*, V3:logging:*, V4:modify:*, V5:invalid:* (round 12), W1:invalid:* (round 13): the remaining pairs of two faults."""
fx = endpoint_fixture
ranges = [{"FromPort": 443, "ToPort": 443}]
tcp_lb = {"Protocol": "tcp", "LoadBalancerArn": fx["lb"], "SubnetIds": fx["subnets"], "PortRanges": ranges}
native = ("InvalidParameterValue", "TCP based endpoints require a TrustProvider with NativeApplicationOidcOptions to be "
"attached to the instance.")
oidc = ("InvalidParameterValue", "HTTP/HTTPS based endpoints require a TrustProvider with OidcOptions to be attached to the instance.")
fake_sg, fake_eni = "sg-00000000000000000", "eni-00000000000000000"
eni = {"EndpointType": "network-interface", "LoadBalancerOptions": None}
for over, error in (
({"LoadBalancerOptions": {"Protocol": "tcp", "SubnetIds": fx["subnets"]}},
("MissingParameter", "PortRanges must be provided in LoadBalancerOptions")),
({**eni, "NetworkInterfaceOptions": {"Protocol": "tcp"}}, ("MissingParameter", "Missing required parameter NetworkInterfaceId")),
({"LoadBalancerOptions": {"Protocol": "tcp", "Port": 443, "SubnetIds": fx["subnets"], "PortRanges": ranges}},
("InvalidParameterValue", "Parameter port in LoadBalancerOptions is not supported with 'tcp' protocol")),
({**eni, "NetworkInterfaceOptions": {"Protocol": "tcp", "Port": 443, "PortRanges": ranges}},
("InvalidParameterValue", "Parameter port in EniOptions is not supported with 'tcp' protocol")),
({"LoadBalancerOptions": tcp_lb, "SecurityGroupIds": [fake_sg]}, ("InvalidParameterValue", "The Security Group Ids are invalid")),
({"LoadBalancerOptions": tcp_lb, "DomainCertificateArn": None}, native),
({"LoadBalancerOptions": tcp_lb, "ApplicationDomain": None}, native),
({"LoadBalancerOptions": tcp_lb, "EndpointDomainPrefix": None}, native),
({**eni, "SecurityGroupIds": [fake_sg], "NetworkInterfaceOptions": {
"NetworkInterfaceId": fake_eni, "Protocol": "tcp", "PortRanges": ranges}}, ("InvalidParameterValue", "NetworkInterfaceId is invalid")),
({**eni, "SecurityGroupIds": [fake_sg], "NetworkInterfaceOptions": {
"NetworkInterfaceId": fake_eni, "Protocol": "https", "Port": 443}}, ("InvalidParameterValue", "NetworkInterfaceId is invalid")),
):
with pytest.raises(ClientError) as exc:
raw.create_verified_access_endpoint(**_lb_endpoint_params(fx, **over))
assert _error(exc) == error, over
bucket = f"va-pairs-{uuid.uuid4().hex[:8]}"
make_client("s3").create_bucket(Bucket=bucket)
other = {"Enabled": True, "BucketName": bucket, "BucketOwner": "123456789012"}
for missing in ({"CloudWatchLogs": {"Enabled": True, "LogGroup": "/va/missing"}},
{"KinesisDataFirehose": {"Enabled": True, "DeliveryStream": "va-missing"}}):
with pytest.raises(ClientError) as exc:
ec2.modify_verified_access_instance_logging_configuration(
VerifiedAccessInstanceId=fx["instance"], AccessLogs={"S3": other, **missing})
assert _error(exc)[0] == "LogDestinationPermissionIssue", missing
ep_id = ec2.create_verified_access_endpoint(**_lb_endpoint_params(fx))["VerifiedAccessEndpoint"]["VerifiedAccessEndpointId"]
for kwargs, error in (
({"NetworkInterfaceOptions": {"Port": 80}, "LoadBalancerOptions": {"Port": 0}},
("InvalidParameterValue", "The value of loadBalancerOptions.port you provided is not valid")),
({"NetworkInterfaceOptions": {"Port": 80}, "LoadBalancerOptions": {"Protocol": "ftp"}},
("InvalidParameterValue", "The value of loadBalancerOptions.protocol you provided is not valid")),
({"LoadBalancerOptions": {"PortRanges": ranges, "SubnetIds": ["subnet-00000000000000000"]}},
("InvalidParameterValue", "Parameter PortRanges is not currently supported for the operation")),
):
with pytest.raises(ClientError) as exc:
raw.modify_verified_access_endpoint(VerifiedAccessEndpointId=ep_id, **kwargs)
assert _error(exc) == error, kwargs
ec2.delete_verified_access_endpoint(VerifiedAccessEndpointId=ep_id)
# A group on an instance with no provider, then on one that was deleted, answers alike.
group = _group(ec2, fx["instance"])
bare = _instance(ec2)
ec2.modify_verified_access_group(VerifiedAccessGroupId=group, VerifiedAccessInstanceId=bare)
fake_key = "arn:aws:kms:us-east-1:000000000000:key/00000000-0000-0000-0000-000000000000"
pairs = (
({}, oidc),
({"SecurityGroupIds": None}, ("MissingParameter", "Security Group Ids must be provided if attachment type vpc is selected")),
({"SecurityGroupIds": [fake_sg]}, ("InvalidParameterValue", "The Security Group Ids are invalid")),
({"DomainCertificateArn": None}, ("MissingParameter", "Missing required parameter DomainCertificateArn")),
({"ApplicationDomain": "x.other.com"},
("InvalidParameterValue", "The ApplicationDomain provided is not present in the DomainCertificateArn provided in the request.")),
({"SseSpecification": {"CustomerManagedKeyEnabled": True, "KmsKeyArn": fake_key}}, oidc),
)
for deleted in (False, True):
if deleted:
ec2.delete_verified_access_instance(VerifiedAccessInstanceId=bare)
for over, error in pairs:
with pytest.raises(ClientError) as exc:
raw.create_verified_access_endpoint(**_lb_endpoint_params(
fx, VerifiedAccessGroupId=group, EndpointDomainPrefix="orphan", **over))
assert _error(exc) == error, (deleted, over)
ec2.delete_verified_access_group(VerifiedAccessGroupId=group)
def test_verified_access_round14_check_orders(ec2, raw, endpoint_fixture):
"""X1:tp:*, X2:invalid:*, X3:*, X4:logging:*, X6:modify:*, X7:* (round 14): the pairs the final audit found uncaptured."""
oidc = {"Issuer": "https://idp.example.com", "AuthorizationEndpoint": "https://idp.example.com/auth",
"TokenEndpoint": "https://idp.example.com/token", "UserInfoEndpoint": "https://idp.example.com/userinfo",
"ClientId": "client", "ClientSecret": "secret", "Scope": "openid"}
user = dict(TrustProviderType="user", UserTrustProviderType="oidc", PolicyReferenceName="idp")
for kwargs, error in (
({"OidcOptions": {k: v for k, v in oidc.items() if k not in ("Issuer", "AuthorizationEndpoint")}},
("MissingParameter", "Missing required parameter Issuer in OidcOptions")),
({"OidcOptions": {k: v for k, v in oidc.items() if k not in ("TokenEndpoint", "UserInfoEndpoint")}},
("MissingParameter", "Missing required parameter TokenEndpoint in OidcOptions")),
({"OidcOptions": {k: v for k, v in oidc.items() if k not in ("UserInfoEndpoint", "ClientId")}},
("MissingParameter", "Missing required parameter UserInfoEndpoint in OidcOptions")),
({"OidcOptions": {k: v for k, v in oidc.items() if k not in ("ClientId", "ClientSecret")}},
("MissingParameter", "Missing required parameter ClientId in OidcOptions")),
({"OidcOptions": {k: v for k, v in oidc.items() if k not in ("ClientSecret", "Scope")}},
("MissingParameter", "Missing required parameter ClientSecret in OidcOptions")),
({"OidcOptions": {k: v for k, v in oidc.items() if k != "Issuer"}, "DeviceOptions": {"TenantId": "t"}},
("MissingParameter", "Missing required parameter Issuer in OidcOptions")),
({"OidcOptions": {**oidc, "Issuer": "http://idp.example.com"}, "DeviceTrustProviderType": "jamf"},
("InvalidParameterValue", "Parameter Issuer in OidcOptions must be a valid HTTPS URL")),
({"OidcOptions": oidc, "PolicyReferenceName": "a!" * 20},
("InvalidParameterValue", "Length of parameter PolicyReferenceName must be between 1 and 32")),
):
with pytest.raises(ClientError) as exc:
raw.create_verified_access_trust_provider(**{**user, **kwargs})
assert _error(exc) == error, kwargs
fx = endpoint_fixture
lb = {"Protocol": "https", "Port": 443, "LoadBalancerArn": fx["lb"], "SubnetIds": fx["subnets"]}
ranges = [{"FromPort": 443, "ToPort": 443}]
refused = ("InvalidParameterValue", "Parameter PortRanges is not currently supported for the operation")
eni = {"EndpointType": "network-interface", "LoadBalancerOptions": None}
for over, error in (
({"LoadBalancerOptions": {**lb, "Protocol": "ftp", "Port": 0}},
("InvalidParameterValue", "The value of loadBalancerOptions.protocol you provided is not valid; "
"The value of loadBalancerOptions.port you provided is not valid")),
({"LoadBalancerOptions": {k: v for k, v in {**lb, "PortRanges": ranges}.items() if k != "Port"}}, refused),
({"LoadBalancerOptions": {k: v for k, v in {**lb, "PortRanges": ranges}.items() if k != "SubnetIds"}}, refused),
({"LoadBalancerOptions": {k: v for k, v in {**lb, "PortRanges": ranges}.items() if k != "LoadBalancerArn"}}, refused),
({"LoadBalancerOptions": {**lb, "SubnetIds": ["subnet-00000000000000000"], "PortRanges": ranges}}, refused),
({"SecurityGroupIds": ["sg-00000000000000000"], "LoadBalancerOptions": {**lb, "PortRanges": ranges}}, refused),
({**eni, "NetworkInterfaceOptions": {"Protocol": "https", "Port": 443, "PortRanges": ranges}}, refused),
({**eni, "NetworkInterfaceOptions": {"NetworkInterfaceId": "eni-00000000000000000", "Protocol": "https", "Port": 443,
"PortRanges": ranges}}, refused),
):
with pytest.raises(ClientError) as exc:
raw.create_verified_access_endpoint(**_lb_endpoint_params(fx, **over))
assert _error(exc) == error, over
for call, kwargs, error in (
(raw.describe_verified_access_groups, {"VerifiedAccessInstanceId": "abc", "MaxResults": 1},
("InvalidParameterValue", "The parameter MaxResults must be between 5 and 200")),
(raw.describe_verified_access_groups, {"VerifiedAccessInstanceId": "abc", "NextToken": "bad"},
("InvalidParameterValue", "Length of parameter VerifiedAccessInstanceId must be between 5 and 21")),
(raw.describe_verified_access_endpoints, {"VerifiedAccessInstanceId": fx["instance"], "VerifiedAccessGroupId": fx["group"],
"NextToken": "bad"},
("InvalidParameterCombination", "The parameters VerifiedAccessInstanceId and VerifiedAccessGroupId cannot be used together")),
(raw.describe_verified_access_instances, {"VerifiedAccessInstanceIds": [fx["instance"]], "MaxResults": "abc", "NextToken": "bad"},
("InvalidParameterValue", "Invalid integer value abc")),
):
with pytest.raises(ClientError) as exc:
call(**kwargs)
assert _error(exc) == error, kwargs
for logs in ({"CloudWatchLogs": {"Enabled": True}, "KinesisDataFirehose": {"Enabled": True}},
{"CloudWatchLogs": {"Enabled": True}, "KinesisDataFirehose": {"Enabled": False, "DeliveryStream": "x"}}):
with pytest.raises(ClientError) as exc:
ec2.modify_verified_access_instance_logging_configuration(VerifiedAccessInstanceId=fx["instance"], AccessLogs=logs)
assert _error(exc) == ("MissingParameter", "Missing required parameter AccessLogs.CloudWatchLogs.LogGroup"), logs
ep_id = ec2.create_verified_access_endpoint(**_lb_endpoint_params(fx))["VerifiedAccessEndpoint"]["VerifiedAccessEndpointId"]
combination = ("InvalidParameterCombination",
"NetworkInterfaceOptions may only be specified for Verified Access Endpoints with network-interface type")
for opts in ({"Protocol": "tcp"}, {"PortRanges": ranges}, {"SubnetIds": ["subnet-00000000000000000"]}):
with pytest.raises(ClientError) as exc:
raw.modify_verified_access_endpoint(VerifiedAccessEndpointId=ep_id, NetworkInterfaceOptions={"Port": 80},
LoadBalancerOptions=opts)
assert _error(exc) == combination, opts
# A deleting endpoint doesn't block the instance delete; the attached provider does.
ec2.delete_verified_access_endpoint(VerifiedAccessEndpointId=ep_id)
with pytest.raises(ClientError) as exc:
ec2.delete_verified_access_instance(VerifiedAccessInstanceId=fx["instance"])
assert _error(exc)[1].endswith("has existing attachments. Remove all VerifiedAccessTrustProvider attachments before deleting.")
def test_verified_access_round15_pages_and_pairs(ec2, raw, endpoint_fixture):
"""Y1:tp:long-scope+device-options, Y3:endpoints:page-5, Y4:modify:* (round 15)."""
import urllib.request
with pytest.raises(ClientError) as exc:
raw.create_verified_access_trust_provider(
TrustProviderType="user", UserTrustProviderType="oidc", PolicyReferenceName="idp", DeviceOptions={"TenantId": "t"},
OidcOptions={"Issuer": "https://idp.example.com", "AuthorizationEndpoint": "https://idp.example.com/auth",
"TokenEndpoint": "https://idp.example.com/token", "UserInfoEndpoint": "https://idp.example.com/userinfo",
"ClientId": "client", "ClientSecret": "secret", "Scope": "s" * 300})
assert _error(exc) == ("InvalidParameterValue", "Length of parameter Scope in OidcOptions must be between 1 and 256")
fx = endpoint_fixture
names = [f"app{n}.example.com" for n in range(1, 7)]
cert = make_client("acm").request_certificate(DomainName=names[0], SubjectAlternativeNames=names)["CertificateArn"]
eps = [ec2.create_verified_access_endpoint(**_lb_endpoint_params(
fx, DomainCertificateArn=cert, ApplicationDomain=name, EndpointDomainPrefix=name.split(".")[0],
))["VerifiedAccessEndpoint"]["VerifiedAccessEndpointId"] for name in names]
body = f"Action=DescribeVerifiedAccessEndpoints&Version=2016-11-15&VerifiedAccessInstanceId={fx['instance']}&MaxResults=5"
req = urllib.request.Request(ENDPOINT, data=body.encode(), method="POST", headers={
"Content-Type": "application/x-www-form-urlencoded; charset=utf-8",
"Authorization": "AWS4-HMAC-SHA256 Credential=test/20260101/us-east-1/ec2/aws4_request"})
with urllib.request.urlopen(req) as resp:
text = resp.read().decode()
assert -1 < text.index("<verifiedAccessEndpointSet>") < text.index("<nextToken>")
for port in (0, 70000):
with pytest.raises(ClientError) as exc:
raw.modify_verified_access_endpoint(VerifiedAccessEndpointId=eps[0],
LoadBalancerOptions={"Protocol": "ftp", "Port": port})
assert _error(exc) == ("InvalidParameterValue", "The value of loadBalancerOptions.protocol you provided is not valid; "
"The value of loadBalancerOptions.port you provided is not valid"), port
for ep_id in eps:
ec2.delete_verified_access_endpoint(VerifiedAccessEndpointId=ep_id)
def test_verified_access_round16_check_orders(ec2, raw, endpoint_fixture):
"""Z1:tp:*, Z2:*, Z3:invalid:* (round 16): the pairs the audit of 08b05ab5 found uncaptured."""
oidc = {"Issuer": "https://idp.example.com", "AuthorizationEndpoint": "https://idp.example.com/auth",
"TokenEndpoint": "https://idp.example.com/token", "UserInfoEndpoint": "https://idp.example.com/userinfo",
"ClientId": "client", "ClientSecret": "secret", "Scope": "openid"}
https = ("InvalidParameterValue", "Parameter Issuer in OidcOptions must be a valid HTTPS URL")
for opts, extra, error in (
({k: v for k, v in oidc.items() if k != "ClientId"}, {"DeviceTrustProviderType": "jamf"},
("MissingParameter", "Missing required parameter ClientId in OidcOptions")),
({**oidc, "Scope": "s" * 300}, {"DeviceTrustProviderType": "jamf"},
("InvalidParameterValue", "Length of parameter Scope in OidcOptions must be between 1 and 256")),
({**oidc, "Issuer": "http://idp.example.com"}, {"DeviceOptions": {"TenantId": "t"}}, https),
({**{k: v for k, v in oidc.items() if k != "Issuer"}, "TokenEndpoint": "http://idp.example.com/token"}, {},
("MissingParameter", "Missing required parameter Issuer in OidcOptions")),
({**oidc, "Issuer": "http://idp.example.com", "Scope": "s" * 300}, {}, https),
):
with pytest.raises(ClientError) as exc:
raw.create_verified_access_trust_provider(TrustProviderType="user", UserTrustProviderType="oidc",
PolicyReferenceName="idp", OidcOptions=opts, **extra)
assert _error(exc) == error, (opts, extra)
fake_key = "arn:aws:kms:us-east-1:000000000000:key/00000000-0000-0000-0000-000000000000"
sse = {"CustomerManagedKeyEnabled": True, "KmsKeyArn": fake_key}
for call, kwargs, code in (
(raw.modify_verified_access_trust_provider, {"VerifiedAccessTrustProviderId": _MISSING["TrustProvider"],
"OidcOptions": {"Issuer": "http://idp.example.com"}}, "TrustProvider"),
(raw.modify_verified_access_trust_provider, {"VerifiedAccessTrustProviderId": _MISSING["TrustProvider"],
"SseSpecification": sse}, "TrustProvider"),
(raw.modify_verified_access_instance_logging_configuration, {"VerifiedAccessInstanceId": _MISSING["Instance"],
"AccessLogs": {"S3": {"Enabled": True}}}, "Instance"),
(raw.create_verified_access_group, {"VerifiedAccessInstanceId": _MISSING["Instance"], "SseSpecification": sse}, "Instance"),
(raw.modify_verified_access_group, {"VerifiedAccessGroupId": _MISSING["Group"], "VerifiedAccessInstanceId": "abc"}, "Group"),
(raw.modify_verified_access_group_policy, {"VerifiedAccessGroupId": _MISSING["Group"], "PolicyEnabled": True}, "Group"),
(raw.modify_verified_access_endpoint_policy, {"VerifiedAccessEndpointId": _MISSING["Endpoint"], "PolicyEnabled": True}, "Endpoint"),
):
with pytest.raises(ClientError) as exc:
call(**kwargs)
assert _error(exc)[0] == f"InvalidVerifiedAccess{code}Id.NotFound", kwargs
fx = endpoint_fixture
refused = ("InvalidParameterValue", "Parameter PortRanges is not currently supported for the operation")
ranges = [{"FromPort": 443, "ToPort": 443}]
eni = {"EndpointType": "network-interface", "LoadBalancerOptions": None}
for over, error in (
({**eni, "NetworkInterfaceOptions": {"NetworkInterfaceId": "eni-00000000000000000", "Protocol": "ftp", "Port": 0}},
("InvalidParameterValue", "The value of networkInterfaceOptions.protocol you provided is not valid; "
"The value of networkInterfaceOptions.port you provided is not valid")),
({"LoadBalancerOptions": {"Protocol": "http", "LoadBalancerArn": fx["lb"], "SubnetIds": fx["subnets"], "PortRanges": ranges}},
refused),
({**eni, "NetworkInterfaceOptions": {"Protocol": "http", "Port": 80, "PortRanges": ranges}}, refused),
):
with pytest.raises(ClientError) as exc:
raw.create_verified_access_endpoint(**_lb_endpoint_params(fx, **over))
assert _error(exc) == error, over
def test_verified_access_deleting_endpoint_keeps_page_offsets(ec2, endpoint_fixture):
"""MiniStack: a deleting endpoint is listed once more; pages of that listing keep their offsets."""
fx = endpoint_fixture
wild = make_client("acm").request_certificate(DomainName="*.example.com")["CertificateArn"]
ids = [ec2.create_verified_access_endpoint(**_lb_endpoint_params(
fx, DomainCertificateArn=wild, ApplicationDomain=f"e{n}.example.com", EndpointDomainPrefix=f"e{n}",
))["VerifiedAccessEndpoint"]["VerifiedAccessEndpointId"] for n in range(6)]
ec2.delete_verified_access_endpoint(VerifiedAccessEndpointId=ids[0])
first = ec2.describe_verified_access_endpoints(VerifiedAccessGroupId=fx["group"], MaxResults=5)
second = ec2.describe_verified_access_endpoints(VerifiedAccessGroupId=fx["group"], MaxResults=5,
NextToken=first["NextToken"])
listed = [e["VerifiedAccessEndpointId"] for e in first["VerifiedAccessEndpoints"] + second["VerifiedAccessEndpoints"]]
assert sorted(listed) == sorted(ids)
fresh = ec2.describe_verified_access_endpoints(VerifiedAccessGroupId=fx["group"])["VerifiedAccessEndpoints"]
assert sorted(e["VerifiedAccessEndpointId"] for e in fresh) == sorted(ids[1:])
def test_verified_access_endpoint_modify_check_order(ec2, endpoint_fixture):
"""Q4:modify:*, Q4:move-group:*."""
fx = endpoint_fixture
ep_id = ec2.create_verified_access_endpoint(**_lb_endpoint_params(fx))["VerifiedAccessEndpoint"]["VerifiedAccessEndpointId"]
other_inst, other_tp = _instance_with_provider(ec2)
other = _group(ec2, other_inst)
move = ec2.modify_verified_access_endpoint
for kwargs, code, message in (
({"VerifiedAccessGroupId": _MISSING["Group"], "LoadBalancerOptions": {"SubnetIds": ["subnet-00000000000000000"]}},
"InvalidVerifiedAccessGroupId.NotFound", f"The verified-access-group ID '{_MISSING['Group']}' does not exist"),
({"VerifiedAccessGroupId": other, "LoadBalancerOptions": {"PortRanges": [{"FromPort": 1, "ToPort": 2}]}},
"InvalidParameterValue", "Parameter PortRanges is not currently supported for the operation"),
({"VerifiedAccessGroupId": other, "NetworkInterfaceOptions": {"Port": 80}}, "InvalidParameterCombination",
"NetworkInterfaceOptions may only be specified for Verified Access Endpoints with network-interface type"),
({"VerifiedAccessGroupId": other, "LoadBalancerOptions": {"SubnetIds": ["subnet-00000000000000000"]}},
"InvalidParameterValue", "Invalid value for parameter SubnetIds"),
({"LoadBalancerOptions": {"Protocol": "ftp"}}, "InvalidParameterValue",
"The value of loadBalancerOptions.protocol you provided is not valid"),
):
with pytest.raises(ClientError) as exc:
move(VerifiedAccessEndpointId=ep_id, **kwargs)
assert _error(exc) == (code, message), kwargs
same = ec2.modify_verified_access_group(VerifiedAccessGroupId=fx["group"], VerifiedAccessInstanceId=fx["instance"])
assert same["VerifiedAccessGroup"]["VerifiedAccessInstanceId"] == fx["instance"]
with pytest.raises(ClientError) as exc:
ec2.modify_verified_access_group(VerifiedAccessGroupId=fx["group"], VerifiedAccessInstanceId=_MISSING["Instance"])
assert _error(exc)[0] == "InvalidVerifiedAccessInstanceId.NotFound"
ec2.delete_verified_access_endpoint(VerifiedAccessEndpointId=ep_id)
_cleanup(ec2, groups=[other], instances=[other_inst], providers=[other_tp])
def test_verified_access_user_provider_attach_is_locked_by_groups(ec2):
"""Q2:move-group:to-bare-instance, Q2:attach:user-while-group, Q2:attach:device-while-group, Q2:create-group:device-only."""
inst_id, tp_id = _instance_with_provider(ec2)
group_id = _group(ec2, inst_id)
bare = _instance(ec2)
ec2.modify_verified_access_group(VerifiedAccessGroupId=group_id, VerifiedAccessInstanceId=bare)
user = _oidc_provider(ec2, ref="idp3")["VerifiedAccessTrustProviderId"]
with pytest.raises(ClientError) as exc:
_attach(ec2, bare, user)
assert _error(exc) == ("VerifiedAccessGroupAttachmentExists",
f"VerifiedAccessInstance {bare} is not empty. Please remove all VerifiedAccessGroups before "
"attaching or detaching a VerifiedAccessTrustProvider with TrustProviderType user")
jamf = _device_provider(ec2, "jamf")["VerifiedAccessTrustProviderId"]
_attach(ec2, bare, jamf)
_cleanup(ec2, groups=[group_id], instances=[inst_id, bare], providers=[tp_id, user, jamf])
def test_verified_access_load_balancer_endpoint_lifecycle(ec2, endpoint_fixture):
"""X2:create:lb, X2:describe:active, X2:modify:while-pending, X2:delete-group:endpoint-pending,
X2:delete-instance:with-groups-and-endpoints, X3:*, X4:modify:*-options-on-lb, V5:delete:eni-endpoint, V5:poll:delete."""
fx = endpoint_fixture
ep = ec2.create_verified_access_endpoint(**_lb_endpoint_params(fx, Description="web", PolicyDocument=_POLICY, TagSpecifications=[
{"ResourceType": "verified-access-endpoint", "Tags": [{"Key": "site", "Value": "app"}]}]))["VerifiedAccessEndpoint"]
ep_id = ep["VerifiedAccessEndpointId"]
assert ep_id.startswith("vae-") and len(ep_id) == 21
assert ep["Status"] == {"Code": "pending"}
domain = ep["EndpointDomain"]
assert domain.startswith("app.edge-") and domain.endswith(f".{fx['instance']}.prod.verified-access.us-east-1.amazonaws.com")
assert ep["LoadBalancerOptions"] == {"LoadBalancerArn": fx["lb"], "Port": 443, "Protocol": "https", "SubnetIds": fx["subnets"]}
assert "NetworkInterfaceOptions" not in ep
assert (ep["Tags"], ep["SseSpecification"]) == ([{"Key": "site", "Value": "app"}], {"CustomerManagedKeyEnabled": False})
described = ec2.describe_verified_access_endpoints(VerifiedAccessEndpointIds=[ep_id])["VerifiedAccessEndpoints"][0]
assert described["Status"] == {"Code": "active"}
modified = ec2.modify_verified_access_endpoint(
VerifiedAccessEndpointId=ep_id, Description="renamed", LoadBalancerOptions={"Port": 8443})["VerifiedAccessEndpoint"]
assert (modified["Status"], modified["Description"]) == ({"Code": "updating"}, "renamed")
assert modified["LoadBalancerOptions"]["Port"] == 8443 and modified["LoadBalancerOptions"]["LoadBalancerArn"] == fx["lb"]
assert "Tags" not in modified
for kwargs, message in (
({"NetworkInterfaceOptions": {"Port": 80}}, "NetworkInterfaceOptions may only be specified for Verified Access "
"Endpoints with network-interface type"),
({"RdsOptions": {"Port": 5432}}, "RdsOptions may only be specified for Verified Access Endpoints with rds type"),
):
with pytest.raises(ClientError) as exc:
ec2.modify_verified_access_endpoint(VerifiedAccessEndpointId=ep_id, **kwargs)
assert _error(exc) == ("InvalidParameterCombination", message)
with pytest.raises(ClientError) as exc:
ec2.delete_verified_access_group(VerifiedAccessGroupId=fx["group"])
assert _error(exc) == ("InvalidParameterValue", f"VerifiedAccessGroup {fx['group']} is not empty. "
"Please remove all VerifiedAccessEndpoints before deleting.")
with pytest.raises(ClientError) as exc:
ec2.delete_verified_access_instance(VerifiedAccessInstanceId=fx["instance"])
assert _error(exc) == ("InvalidParameterValue", f"VerifiedAccessInstance {fx['instance']} is not empty. "
"Please remove all VerifiedAccessEndpoints before deleting.")
with pytest.raises(ClientError) as exc:
ec2.create_verified_access_endpoint(**_lb_endpoint_params(fx))
assert _error(exc) == ("InvalidParameterValue", f"ApplicationDomain provided is already in use by another endpoint in "
f"VerifiedAccessInstance {fx['instance']}. ApplicationDomain must be unique within a Verified Access Instance.")
policy = ec2.get_verified_access_endpoint_policy(VerifiedAccessEndpointId=ep_id)
assert (policy["PolicyEnabled"], policy["PolicyDocument"]) == (True, _POLICY)
ec2.modify_verified_access_endpoint_policy(VerifiedAccessEndpointId=ep_id, PolicyEnabled=False)
policy = ec2.get_verified_access_endpoint_policy(VerifiedAccessEndpointId=ep_id)
assert (policy["PolicyEnabled"], "PolicyDocument" in policy) == (False, False)
deleted = ec2.delete_verified_access_endpoint(VerifiedAccessEndpointId=ep_id)["VerifiedAccessEndpoint"]
assert deleted["Status"] == {"Code": "deleting"} and "Tags" not in deleted
# Y5:*: a deleting endpoint answers NotFound to every call but Describe, and its group can go.
for call in (lambda: ec2.delete_verified_access_endpoint(VerifiedAccessEndpointId=ep_id),
lambda: ec2.modify_verified_access_endpoint(VerifiedAccessEndpointId=ep_id, Description="late"),
lambda: ec2.get_verified_access_endpoint_policy(VerifiedAccessEndpointId=ep_id)):
with pytest.raises(ClientError) as exc:
call()
assert _error(exc) == ("InvalidVerifiedAccessEndpointId.NotFound",
f"The verified-access-endpoint ID '{ep_id}' does not exist")
assert ec2.describe_verified_access_endpoints(
VerifiedAccessEndpointIds=[ep_id])["VerifiedAccessEndpoints"][0]["Status"] == {"Code": "deleting"}
with pytest.raises(ClientError) as exc:
ec2.describe_verified_access_endpoints(VerifiedAccessEndpointIds=[ep_id])
assert _error(exc) == ("InvalidVerifiedAccessEndpointId.NotFound", f"VerifiedAccessEndpoint {ep_id} does not exist")
def test_verified_access_endpoint_and_group_moves(ec2, endpoint_fixture):
"""Y4:move:missing-group, Y4:move:same-instance, Y4:move:other-instance, Y4:move:group-with-endpoint,
Y4:detach:provider-with-endpoints, Y5:delete-group:*-while-endpoint-deleting."""
fx = endpoint_fixture
ep_id = ec2.create_verified_access_endpoint(**_lb_endpoint_params(fx))["VerifiedAccessEndpoint"]["VerifiedAccessEndpointId"]
same = _group(ec2, fx["instance"])
other_inst, other_tp = _instance_with_provider(ec2)
other = _group(ec2, other_inst)
move = ec2.modify_verified_access_endpoint
with pytest.raises(ClientError) as exc:
move(VerifiedAccessEndpointId=ep_id, VerifiedAccessGroupId=_MISSING["Group"])
assert _error(exc) == ("InvalidVerifiedAccessGroupId.NotFound", f"The verified-access-group ID '{_MISSING['Group']}' does not exist")
with pytest.raises(ClientError) as exc:
move(VerifiedAccessEndpointId=ep_id, VerifiedAccessGroupId=other)
assert _error(exc) == ("InvalidParameterValue", "Cannot move a VerifiedAccessEndpoint to a VerifiedAccessGroup that "
"belongs to a different VerifiedAccessInstance.")
moved = move(VerifiedAccessEndpointId=ep_id, VerifiedAccessGroupId=same)["VerifiedAccessEndpoint"]
assert (moved["VerifiedAccessGroupId"], moved["Status"]) == (same, {"Code": "updating"})
with pytest.raises(ClientError) as exc:
ec2.modify_verified_access_group(VerifiedAccessGroupId=same, VerifiedAccessInstanceId=other_inst)
assert _error(exc) == ("InvalidParameterValue", f"VerifiedAccessGroup {same} is not empty. "
"Please remove all VerifiedAccessEndpoints before changing VerifiedAccessInstanceId.")
with pytest.raises(ClientError) as exc:
ec2.detach_verified_access_trust_provider(VerifiedAccessInstanceId=fx["instance"],
VerifiedAccessTrustProviderId=fx["provider"])
assert _error(exc)[0] == "VerifiedAccessGroupAttachmentExists"
ec2.delete_verified_access_endpoint(VerifiedAccessEndpointId=ep_id)
ec2.delete_verified_access_group(VerifiedAccessGroupId=same)
_cleanup(ec2, groups=[other], instances=[other_inst], providers=[other_tp])
def test_verified_access_network_interface_endpoint(ec2, endpoint_fixture):
"""V5:create:eni, V5:modify:port, V5:modify:protocol-http, V5:modify:lb-options-on-eni, V5:modify:port-ranges, V5:get-policy:none."""
fx = endpoint_fixture
ep = ec2.create_verified_access_endpoint(**_lb_endpoint_params(
fx, EndpointType="network-interface", LoadBalancerOptions=None, ApplicationDomain="eni.example.com",
EndpointDomainPrefix="eni", NetworkInterfaceOptions={"NetworkInterfaceId": fx["eni"], "Protocol": "https", "Port": 443},
))["VerifiedAccessEndpoint"]
ep_id = ep["VerifiedAccessEndpointId"]
assert ep["NetworkInterfaceOptions"] == {"NetworkInterfaceId": fx["eni"], "Port": 443, "Protocol": "https"}
assert "LoadBalancerOptions" not in ep
policy = ec2.get_verified_access_endpoint_policy(VerifiedAccessEndpointId=ep_id)
assert (policy["PolicyEnabled"], "PolicyDocument" in policy) == (False, False)
modified = ec2.modify_verified_access_endpoint(
VerifiedAccessEndpointId=ep_id, NetworkInterfaceOptions={"Port": 8443, "Protocol": "http"})["VerifiedAccessEndpoint"]
assert modified["NetworkInterfaceOptions"] == {"NetworkInterfaceId": fx["eni"], "Port": 8443, "Protocol": "http"}
with pytest.raises(ClientError) as exc:
ec2.modify_verified_access_endpoint(VerifiedAccessEndpointId=ep_id, LoadBalancerOptions={"Port": 443})
assert _error(exc) == ("InvalidParameterCombination",
"LoadBalancerOptions may only be specified for Verified Access Endpoints with load-balancer type")
with pytest.raises(ClientError) as exc:
ec2.modify_verified_access_endpoint(VerifiedAccessEndpointId=ep_id,
NetworkInterfaceOptions={"PortRanges": [{"FromPort": 443, "ToPort": 443}]})
assert _error(exc) == ("InvalidParameterValue", "Parameter PortRanges is not currently supported for the operation")
# ── IAM ────────────────────────────────────────────────────
def test_verified_access_iam_resource_arns():
"""A14:*, E1:*, W7:deny:*, V3:deny:*, Z5:deny:*: the resource AWS names when it denies each call, the
id's ARN for a resource that exists and <type>/* for one that does not."""
from ministack.core.iam_actions import extract_resource_arn
from ministack.services import ec2 as mod
account, region = "123456789012", "us-east-1"
for store, key in ((mod._va_instances, "vai-00000000000000001"), (mod._va_trust_providers, "vatp-00000000000000001"),
(mod._va_groups, "vagr-00000000000000001"), (mod._va_endpoints, "vae-00000000000000001"),
(mod._subnets, "subnet-00000001"), (mod._security_groups, "sg-00000001"),
(mod._network_interfaces, "eni-00000001")):
store.set_scoped(account, region, key, {})
mod._va_endpoints.set_scoped(account, region, "vae-00000000000000002", {"Status": "deleting"})
def arn(params):
query = {k: [v] for k, v in params.items()}
return extract_resource_arn("ec2", "POST", "/", {}, b"", query, region, account)
prefix = f"arn:aws:ec2:{region}:{account}:"
vai, vatp, vagr, vae = "vai-00000000000000001", "vatp-00000000000000001", "vagr-00000000000000001", "vae-00000000000000001"
try:
for params, expected in (
({"Action": "CreateVerifiedAccessInstance"}, "verified-access-instance/*"),
({"Action": "CreateVerifiedAccessTrustProvider", "TrustProviderType": "user"}, "verified-access-trust-provider/*"),
({"Action": "DeleteVerifiedAccessInstance", "VerifiedAccessInstanceId": vai}, f"verified-access-instance/{vai}"),
({"Action": "DeleteVerifiedAccessInstance", "VerifiedAccessInstanceId": "vai-0000000000000000f"},
"verified-access-instance/*"),
({"Action": "ModifyVerifiedAccessInstance", "VerifiedAccessInstanceId": "abc"}, "verified-access-instance/*"),
({"Action": "ModifyVerifiedAccessTrustProvider", "VerifiedAccessTrustProviderId": vatp},
f"verified-access-trust-provider/{vatp}"),
({"Action": "AttachVerifiedAccessTrustProvider", "VerifiedAccessInstanceId": vai,
"VerifiedAccessTrustProviderId": vatp}, f"verified-access-instance/{vai}"),
({"Action": "AttachVerifiedAccessTrustProvider", "VerifiedAccessInstanceId": "abc",
"VerifiedAccessTrustProviderId": "vatp-0000000000000000f"}, "verified-access-trust-provider/*"),
({"Action": "CreateVerifiedAccessGroup", "VerifiedAccessInstanceId": vai}, f"verified-access-instance/{vai}"),
({"Action": "ModifyVerifiedAccessGroup", "VerifiedAccessGroupId": vagr}, f"verified-access-group/{vagr}"),
({"Action": "ModifyVerifiedAccessGroup", "VerifiedAccessGroupId": vagr, "VerifiedAccessInstanceId": vai},
f"verified-access-instance/{vai}"),
({"Action": "GetVerifiedAccessGroupPolicy", "VerifiedAccessGroupId": vagr}, f"verified-access-group/{vagr}"),
({"Action": "ModifyVerifiedAccessEndpoint", "VerifiedAccessEndpointId": "vae-0000000000000000f",
"VerifiedAccessGroupId": vagr}, "verified-access-endpoint/*"),
({"Action": "GetVerifiedAccessEndpointPolicy", "VerifiedAccessEndpointId": vae}, f"verified-access-endpoint/{vae}"),
({"Action": "CreateVerifiedAccessEndpoint", "VerifiedAccessGroupId": vagr, "SecurityGroupId.1": "sg-1",
"LoadBalancerOptions.SubnetId.1": "subnet-00000001"}, "subnet/subnet-00000001"),
({"Action": "CreateVerifiedAccessEndpoint", "VerifiedAccessGroupId": vagr,
"LoadBalancerOptions.SubnetId.1": "subnet-0000000f"}, f"verified-access-group/{vagr}"),
({"Action": "CreateVerifiedAccessEndpoint", "VerifiedAccessGroupId": "vagr-0000000000000000f"},
"verified-access-group/*"),
({"Action": "CreateVerifiedAccessEndpoint", "VerifiedAccessGroupId": vagr, "SecurityGroupId.1": "sg-00000001"},
"security-group/sg-00000001"),
({"Action": "ModifyVerifiedAccessGroup", "VerifiedAccessGroupId": vagr, "VerifiedAccessInstanceId": "abc"},
f"verified-access-group/{vagr}"),
({"Action": "CreateVerifiedAccessEndpoint"}, "verified-access-endpoint/*"),
# U2:deny:* (round 11), V2:deny:* (round 12): every subnet is scanned, then every security group.
({"Action": "CreateVerifiedAccessEndpoint", "VerifiedAccessGroupId": vagr, "SecurityGroupId.1": "sg-00000001",
"LoadBalancerOptions.SubnetId.1": "subnet-0000000f", "LoadBalancerOptions.SubnetId.2": "subnet-00000001"},
"subnet/subnet-00000001"),
({"Action": "CreateVerifiedAccessEndpoint", "VerifiedAccessGroupId": vagr, "SecurityGroupId.1": "sg-0000000f",
"SecurityGroupId.2": "sg-00000001", "LoadBalancerOptions.SubnetId.1": "subnet-0000000f"},
"security-group/sg-00000001"),
# V2:deny:* (round 12): the first known security group at any index; with none known, the group.
({"Action": "CreateVerifiedAccessEndpoint", "VerifiedAccessGroupId": vagr, "SecurityGroupId.1": "sg-00000001",
"SecurityGroupId.2": "sg-0000000f", "LoadBalancerOptions.SubnetId.1": "subnet-0000000f"},
"security-group/sg-00000001"),
({"Action": "CreateVerifiedAccessEndpoint", "VerifiedAccessGroupId": vagr, "SecurityGroupId.1": "sg-0000000f",
"LoadBalancerOptions.SubnetId.1": "subnet-0000000f"}, f"verified-access-group/{vagr}"),
# X5:deny:eni-real+fake-sg-only (round 14): a known ENI with no known security group.
({"Action": "CreateVerifiedAccessEndpoint", "VerifiedAccessGroupId": vagr, "SecurityGroupId.1": "sg-0000000f",
"NetworkInterfaceOptions.NetworkInterfaceId": "eni-00000001"}, "network-interface/eni-00000001"),
({"Action": "CreateVerifiedAccessEndpoint", "VerifiedAccessGroupId": vagr, "SecurityGroupId.1": "sg-00000001",
"NetworkInterfaceOptions.NetworkInterfaceId": "eni-00000001"}, "security-group/sg-00000001"),
# Z4:deny:lb-subnet+known-eni (round 16): a known subnet before a known ENI.
({"Action": "CreateVerifiedAccessEndpoint", "VerifiedAccessGroupId": vagr, "LoadBalancerOptions.SubnetId.1": "subnet-00000001",
"NetworkInterfaceOptions.NetworkInterfaceId": "eni-00000001"}, "subnet/subnet-00000001"),
# U6:deny:* (round 11): a deleting endpoint is named like a missing one.
({"Action": "ModifyVerifiedAccessEndpoint", "VerifiedAccessEndpointId": "vae-00000000000000002"},
"verified-access-endpoint/*"),
({"Action": "DeleteVerifiedAccessEndpoint", "VerifiedAccessEndpointId": "vae-00000000000000002"},
"verified-access-endpoint/*"),
):
assert arn(params) == prefix + expected, params
assert arn({"Action": "DescribeVerifiedAccessGroups", "VerifiedAccessInstanceId": vai}) == "*"
finally:
for store, key in ((mod._va_instances, vai), (mod._va_trust_providers, vatp), (mod._va_groups, vagr),
(mod._va_endpoints, vae), (mod._va_endpoints, "vae-00000000000000002"),
(mod._subnets, "subnet-00000001"), (mod._security_groups, "sg-00000001"),
(mod._network_interfaces, "eni-00000001")):
store.pop_scoped(account, region, key, None)
@pytest.mark.auth_contract
@pytest.mark.parametrize("permission", ["none", "allow", "other-resource", "explicit-deny"])
def test_verified_access_modify_permission_contract(auth_enabled, iam_user, permission):
"""W7:deny:modify-instance: ModifyVerifiedAccessInstance is authorized on the instance ARN."""
admin = make_client("ec2")
inst_id = _instance(admin, Description="before")
resource = f"arn:aws:ec2:us-east-1:000000000000:verified-access-instance/{inst_id}"
statements = []
if permission != "none":
target = resource.replace(inst_id, "vai-00000000000000000") if permission == "other-resource" else resource
statements.append({"Effect": "Allow", "Action": "ec2:ModifyVerifiedAccessInstance", "Resource": target})
if permission == "explicit-deny":
statements.append({"Effect": "Deny", "Action": "ec2:ModifyVerifiedAccessInstance", "Resource": resource})
policy = {"Version": "2012-10-17", "Statement": statements} if statements else None
client = iam_user(policy=policy).client("ec2")
try:
if auth_enabled and permission != "allow":
with pytest.raises(ClientError) as exc:
client.modify_verified_access_instance(VerifiedAccessInstanceId=inst_id, Description="after")
assert _error(exc)[0] == "UnauthorizedOperation"
assert _status(exc) == 403
expected = "before"
else:
client.modify_verified_access_instance(VerifiedAccessInstanceId=inst_id, Description="after")
expected = "after"
assert admin.describe_verified_access_instances(
VerifiedAccessInstanceIds=[inst_id])["VerifiedAccessInstances"][0]["Description"] == expected
finally:
admin.delete_verified_access_instance(VerifiedAccessInstanceId=inst_id)
@pytest.mark.auth_contract
def test_verified_access_create_permission_contract(auth_enabled, iam_user):
"""V3:deny:create-instance: CreateVerifiedAccessInstance is authorized on verified-access-instance/*."""
resource = "arn:aws:ec2:us-east-1:000000000000:verified-access-instance/*"
allowed = iam_user(policy={"Version": "2012-10-17", "Statement": [
{"Effect": "Allow", "Action": "ec2:CreateVerifiedAccessInstance", "Resource": resource},
{"Effect": "Allow", "Action": "ec2:DeleteVerifiedAccessInstance", "Resource": "*"}]}).client("ec2")
denied = iam_user().client("ec2")
inst_id = _instance(allowed)
allowed.delete_verified_access_instance(VerifiedAccessInstanceId=inst_id)
if auth_enabled:
with pytest.raises(ClientError) as exc:
denied.create_verified_access_instance()
assert (_status(exc), _error(exc)[0]) == (403, "UnauthorizedOperation")
else:
inst_id = _instance(denied)
denied.delete_verified_access_instance(VerifiedAccessInstanceId=inst_id)
@pytest.mark.auth_contract
def test_verified_access_deny_on_each_authorized_resource_holds(auth_enabled, iam_user):
"""AWS authorizes a group move on the group and the instance, and a detach on the instance and the provider."""
admin = make_client("ec2")
inst_id, oidc_id = _instance_with_provider(admin)
device_id = _device_provider(admin)["VerifiedAccessTrustProviderId"]
_attach(admin, inst_id, device_id)
group_id = _group(admin, inst_id, Description="before")
prefix = "arn:aws:ec2:us-east-1:000000000000:"
client = iam_user(policy={"Version": "2012-10-17", "Statement": [
{"Effect": "Allow", "Action": "ec2:*", "Resource": "*"},
{"Effect": "Deny", "Action": "ec2:ModifyVerifiedAccessGroup", "Resource": f"{prefix}verified-access-group/{group_id}"},
{"Effect": "Deny", "Action": "ec2:DetachVerifiedAccessTrustProvider",
"Resource": f"{prefix}verified-access-trust-provider/{device_id}"},
]}).client("ec2")
try:
calls = (
lambda: client.modify_verified_access_group(VerifiedAccessGroupId=group_id, VerifiedAccessInstanceId=inst_id,
Description="after"),
lambda: client.detach_verified_access_trust_provider(VerifiedAccessInstanceId=inst_id,
VerifiedAccessTrustProviderId=device_id),
)
for call in calls:
if auth_enabled:
with pytest.raises(ClientError) as exc:
call()
assert (_status(exc), _error(exc)[0]) == (403, "UnauthorizedOperation")
else:
call()
group = admin.describe_verified_access_groups(VerifiedAccessGroupIds=[group_id])["VerifiedAccessGroups"][0]
assert group["Description"] == ("before" if auth_enabled else "after")
assert (device_id in _provider_ids(admin, inst_id)) is auth_enabled
finally:
_cleanup(admin, groups=[group_id], instances=[inst_id], providers=[oidc_id, device_id])
def test_verified_access_resource_arns_cover_every_authorized_resource():
from ministack.core.iam_actions import verified_access_resource_arns
prefix = "arn:aws:ec2:us-east-1:000000000000:"
params = {"Action": "CreateVerifiedAccessEndpoint", "VerifiedAccessGroupId": "vagr-00000000000000009",
"LoadBalancerOptions.SubnetId.1": "subnet-a", "LoadBalancerOptions.SubnetId.2": "subnet-b",
"SecurityGroupId.1": "sg-a"}
arns = verified_access_resource_arns(params, "us-east-1", "000000000000")
assert set(arns) == {prefix + r for r in ("security-group/sg-a", "subnet/subnet-a", "subnet/subnet-b",
"verified-access-endpoint/*", "verified-access-group/*")}
assert verified_access_resource_arns({"Action": "CreateVerifiedAccessGroup", "VerifiedAccessInstanceId": "vai-00000000000000009"},
"us-east-1", "000000000000") == [
prefix + "verified-access-instance/*", prefix + "verified-access-group/*"]
assert verified_access_resource_arns({"Action": "DescribeVerifiedAccessGroups"}, "us-east-1", "000000000000") == []