Sample code for 30+ languages & platforms
Rust

Amazon SES v2: Check an address on the account suppression list

See more Amazon SES Examples

Look up one address in the sending Region with ses:GetSuppressedDestination. The record distinguishes a bounce from a complaint. An absent record tells you only that this account suppression lookup found no entry. The example signs the exact encoded mailbox path and also works with temporary credentials.

GetSuppressedDestination

Chilkat Rust Downloads

Rust

// Assumes Chilkat is unlocked. See Global Unlock Sample.
let _ = false;

// Look up the address exactly as stored, including any plus tag.
let address = "avery+orders@example.com".to_string();
let region = "us-west-2".to_string();
let access_key = "AWS_ACCESS_KEY_ID".to_string();
let secret_key = "AWS_SECRET_ACCESS_KEY".to_string();
let session_token = String::new();
let host = chilkat::StringBuilder::new();
let _ = host.append("email.");
let _ = host.append(&region);
let _ = host.append(".amazonaws.com");
let mailbox = chilkat::StringBuilder::new();
let _ = mailbox.append(&address);
let path = chilkat::StringBuilder::new();
let _ = path.append("/v2/email/suppression/addresses/");
let _ = path.append(&mailbox.get_encoded("url_rfc3986", "utf-8").unwrap_or_default());

// SigV4 for SES encodes the wire path a second time in the canonical request.
// Only the canonical copy escapes the percent signs. Send the original path over HTTPS.
let canonical_path = chilkat::StringBuilder::new();
let _ = canonical_path.append(&path.get_as_string().unwrap_or_default());
let mut replaced = canonical_path.replace("%", "%25");
let clock = chilkat::DateTime::new();
let _ = clock.set_from_current_system_time();
let stamp = chilkat::StringBuilder::new();
let _ = stamp.append(&clock.get_as_timestamp(false).unwrap_or_default());
replaced = stamp.replace("-", "");
replaced = stamp.replace(":", "");
let date = stamp.get_range(0, 8, false).unwrap_or_default();
let rest = chilkat::Rest::new();
let _ = rest.add_header("Host", &host.get_as_string().unwrap_or_default());
let _ = rest.add_header("x-amz-date", &stamp.get_as_string().unwrap_or_default());
let headers = chilkat::StringBuilder::new();
let _ = headers.append("host:");
let _ = headers.append(&host.get_as_string().unwrap_or_default());
let _ = headers.append("\nx-amz-date:");
let _ = headers.append(&stamp.get_as_string().unwrap_or_default());
let _ = headers.append("\n");
let mut signed_headers = "host;x-amz-date".to_string();
if session_token != "" {
    let _ = rest.add_header("x-amz-security-token", &session_token);
    let _ = headers.append("x-amz-security-token:");
    let _ = headers.append(&session_token);
    let _ = headers.append("\n");
    signed_headers = "host;x-amz-date;x-amz-security-token".to_string();
}

let crypto = chilkat::Crypt2::new();
crypto.set_hash_algorithm("sha256");
crypto.set_mac_algorithm("hmac");
crypto.set_encoding_mode("hexlower");
crypto.set_charset("utf-8");
let canonical = chilkat::StringBuilder::new();
let _ = canonical.append("GET\n");
let _ = canonical.append(&canonical_path.get_as_string().unwrap_or_default());
let _ = canonical.append("\n\n");
let _ = canonical.append(&headers.get_as_string().unwrap_or_default());
let _ = canonical.append("\n");
let _ = canonical.append(&signed_headers);
let _ = canonical.append("\n");
let _ = canonical.append(&crypto.hash_string_enc("").unwrap_or_default());
let scope = chilkat::StringBuilder::new();
let _ = scope.append(&date);
let _ = scope.append("/");
let _ = scope.append(&region);
let _ = scope.append("/ses/aws4_request");
let to_sign = chilkat::StringBuilder::new();
let _ = to_sign.append("AWS4-HMAC-SHA256\n");
let _ = to_sign.append(&stamp.get_as_string().unwrap_or_default());
let _ = to_sign.append("\n");
let _ = to_sign.append(&scope.get_as_string().unwrap_or_default());
let _ = to_sign.append("\n");
let _ = to_sign.append(&crypto.hash_string_enc(&canonical.get_as_string().unwrap_or_default()).unwrap_or_default());

// Derive the signing key one HMAC at a time. Decode each intermediate key from hex.
let seed = chilkat::StringBuilder::new();
let _ = seed.append("AWS4");
let _ = seed.append(&secret_key);
let _ = crypto.set_mac_key_string(&seed.get_as_string().unwrap_or_default());
let mut key = crypto.mac_string_enc(&date).unwrap_or_default();
let _ = crypto.set_mac_key_encoded(&key, "hex");
key = crypto.mac_string_enc(&region).unwrap_or_default();
let _ = crypto.set_mac_key_encoded(&key, "hex");
key = crypto.mac_string_enc("ses").unwrap_or_default();
let _ = crypto.set_mac_key_encoded(&key, "hex");
key = crypto.mac_string_enc("aws4_request").unwrap_or_default();
let _ = crypto.set_mac_key_encoded(&key, "hex");
let signature = crypto.mac_string_enc(&to_sign.get_as_string().unwrap_or_default()).unwrap_or_default();
let authorization = chilkat::StringBuilder::new();
let _ = authorization.append("AWS4-HMAC-SHA256 Credential=");
let _ = authorization.append(&access_key);
let _ = authorization.append("/");
let _ = authorization.append(&scope.get_as_string().unwrap_or_default());
let _ = authorization.append(", SignedHeaders=");
let _ = authorization.append(&signed_headers);
let _ = authorization.append(", Signature=");
let _ = authorization.append(&signature);
let _ = rest.add_header("Authorization", &authorization.get_as_string().unwrap_or_default());
let connection = chilkat::Socket::new();
connection.set_require_ssl_cert_verify(true);
if connection.connect(&host.get_as_string().unwrap_or_default(), 443, true, 10000).is_err() {
    println!("{}", connection.last_error_text());
    return;
}

if rest.use_connection(&connection, false).is_err() {
    println!("{}", rest.last_error_text());
    return;
}

let Ok(response_text) = rest.full_request_no_body("GET", &path.get_as_string().unwrap_or_default()) else {
    println!("{}", rest.last_error_text());
    return;
};

if rest.response_status_code() == 404 {
    println!("No account suppression entry for this address in this Region.");
    return;
}

if rest.response_status_code() != 200 {
    println!("SES returned HTTP {} {}", rest.response_status_code(), response_text);
    return;
}

let response = chilkat::JsonObject::new();
if response.load(&response_text).is_err() {
    println!("{}", response.last_error_text());
    return;
}

println!("{}", response.string_of("SuppressedDestination.EmailAddress").unwrap_or_default());
println!("Reason: {}", response.string_of("SuppressedDestination.Reason").unwrap_or_default());
println!("Last updated (Unix seconds): {}", response.string_of("SuppressedDestination.LastUpdateTime").unwrap_or_default());