use aws_smithy_runtime_api::client::identity::Identity;
use bytes::{BufMut, BytesMut};
use crypto_bigint::{CheckedAdd, CheckedSub, Encoding, U256};
use ecdsa::hazmat::sign_prehashed_rfc6979;
use hmac::{digest::FixedOutput, Hmac, KeyInit, Mac};
use p256::{NistP256, NonZeroScalar};
use sha2::{Digest as _, Sha256};
use std::io::Write;
use std::sync::LazyLock;
use std::time::SystemTime;
use zeroize::Zeroizing;
const ALGORITHM: &[u8] = b"AWS4-ECDSA-P256-SHA256";
const P256_PRIVATE_KEY_SIZE: usize = 32;
const P256_PRIVATE_KEY_MIN_SIZE: usize = 24;
static BIG_N_MINUS_2: LazyLock<U256> = LazyLock::new(|| {
const ORDER: U256 =
U256::from_be_hex("ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551");
ORDER.checked_sub(&U256::from(2u32)).unwrap()
});
pub fn calculate_signature(signing_key: impl AsRef<[u8]>, string_to_sign: &[u8]) -> String {
let signing_key = signing_key.as_ref();
assert!(
(P256_PRIVATE_KEY_MIN_SIZE..=P256_PRIVATE_KEY_SIZE).contains(&signing_key.len()),
"a P-256 private scalar is {P256_PRIVATE_KEY_MIN_SIZE} to {P256_PRIVATE_KEY_SIZE} bytes, got {}",
signing_key.len()
);
let mut repr = Zeroizing::new([0u8; P256_PRIVATE_KEY_SIZE]);
repr[P256_PRIVATE_KEY_SIZE - signing_key.len()..].copy_from_slice(signing_key);
let scalar = Zeroizing::new(
Option::<NonZeroScalar>::from(NonZeroScalar::from_repr((*repr).into()))
.expect("signing key is a valid P-256 private scalar"),
);
let z = Sha256::digest(string_to_sign);
let (signature, _recovery_id) = sign_prehashed_rfc6979::<NistP256, Sha256>(&scalar, &z, &[]);
hex::encode(signature.to_der().as_bytes())
}
pub fn generate_signing_key(access_key: &str, secret_access_key: &str) -> impl AsRef<[u8]> {
let mut input_key = Zeroizing::new(Vec::with_capacity(secret_access_key.len() + 5));
write!(input_key, "AWS4A{secret_access_key}").unwrap();
let mut kdf_context = Zeroizing::new(Vec::with_capacity(access_key.len() + 1));
let mut counter = Zeroizing::new(1u8);
let key = loop {
write!(kdf_context, "{access_key}").unwrap();
kdf_context.push(*counter);
let mut fis = ALGORITHM.to_vec();
fis.push(0);
fis.append(&mut kdf_context);
fis.put_i32(256);
let mut mac =
Hmac::<Sha256>::new_from_slice(&input_key).expect("HMAC can take key of any size");
let mut buf = BytesMut::new();
buf.put_i32(1);
buf.put_slice(&fis);
mac.update(&buf);
let k0 = U256::from_be_bytes(mac.finalize_fixed().into());
if k0 <= *BIG_N_MINUS_2 {
let pk = k0
.checked_add(&U256::ONE)
.expect("k0 is always less than U256::MAX");
break Zeroizing::new(pk.to_be_bytes());
}
*counter = counter
.checked_add(1)
.expect("counter will never get to 255");
};
key
}
#[derive(Debug)]
#[non_exhaustive]
pub struct SigningParams<'a, S> {
pub(crate) identity: &'a Identity,
pub(crate) region_set: &'a str,
pub(crate) name: &'a str,
pub(crate) time: SystemTime,
pub(crate) settings: S,
}
pub(crate) const ECDSA_256: &str = "AWS4-ECDSA-P256-SHA256";
impl<S> SigningParams<'_, S> {
pub fn region_set(&self) -> &str {
self.region_set
}
pub fn name(&self) -> &str {
self.name
}
pub fn algorithm(&self) -> &'static str {
ECDSA_256
}
}
impl<'a, S: Default> SigningParams<'a, S> {
pub fn builder() -> signing_params::Builder<'a, S> {
Default::default()
}
}
pub mod signing_params {
use super::SigningParams;
use aws_smithy_runtime_api::client::identity::Identity;
use std::error::Error;
use std::fmt;
use std::time::SystemTime;
#[derive(Debug)]
pub struct BuildError {
reason: &'static str,
}
impl BuildError {
fn new(reason: &'static str) -> Self {
Self { reason }
}
}
impl fmt::Display for BuildError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.reason)
}
}
impl Error for BuildError {}
#[derive(Debug, Default)]
pub struct Builder<'a, S> {
identity: Option<&'a Identity>,
region_set: Option<&'a str>,
name: Option<&'a str>,
time: Option<SystemTime>,
settings: Option<S>,
}
impl<'a, S> Builder<'a, S> {
builder_methods!(
set_identity,
identity,
&'a Identity,
"Sets the identity (required)",
set_region_set,
region_set,
&'a str,
"Sets the region set (required)",
set_name,
name,
&'a str,
"Sets the name (required)",
set_time,
time,
SystemTime,
"Sets the time to be used in the signature (required)",
set_settings,
settings,
S,
"Sets additional signing settings (required)"
);
pub fn build(self) -> Result<SigningParams<'a, S>, BuildError> {
Ok(SigningParams {
identity: self
.identity
.ok_or_else(|| BuildError::new("identity is required"))?,
region_set: self
.region_set
.ok_or_else(|| BuildError::new("region_set is required"))?,
name: self
.name
.ok_or_else(|| BuildError::new("name is required"))?,
time: self
.time
.ok_or_else(|| BuildError::new("time is required"))?,
settings: self
.settings
.ok_or_else(|| BuildError::new("settings are required"))?,
})
}
}
}
#[cfg(test)]
mod tests {
use super::{
calculate_signature, generate_signing_key, P256_PRIVATE_KEY_MIN_SIZE, P256_PRIVATE_KEY_SIZE,
};
use p256::ecdsa::signature::Signer;
use p256::ecdsa::{DerSignature, SigningKey};
use p256::elliptic_curve::sec1::ToSec1Point;
#[test]
fn the_accepted_length_range_matches_secret_key() {
let key = generate_signing_key("AKIDEXAMPLE", "wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY");
let full = key.as_ref();
assert!(
SigningKey::from_slice(&full[..P256_PRIVATE_KEY_MIN_SIZE]).is_ok(),
"{P256_PRIVATE_KEY_MIN_SIZE} bytes should be the shortest accepted key"
);
assert!(
SigningKey::from_slice(&full[..P256_PRIVATE_KEY_MIN_SIZE - 1]).is_err(),
"one byte below {P256_PRIVATE_KEY_MIN_SIZE} should be refused"
);
let too_long = [full, full].concat();
assert!(
SigningKey::from_slice(&too_long[..P256_PRIVATE_KEY_SIZE + 1]).is_err(),
"one byte above {P256_PRIVATE_KEY_SIZE} should be refused"
);
}
#[test]
fn short_keys_match_the_signing_key_path() {
let key = generate_signing_key("AKIDEXAMPLE", "wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY");
let string_to_sign = b"AWS4-ECDSA-P256-SHA256\n20260101T000000Z";
for len in P256_PRIVATE_KEY_MIN_SIZE..=P256_PRIVATE_KEY_SIZE {
let short = &key.as_ref()[..len];
let expected: DerSignature = SigningKey::from_slice(short)
.expect("a left-padded short key is a valid P-256 private key")
.sign(string_to_sign);
assert_eq!(
hex::encode(expected.as_bytes()),
calculate_signature(short, string_to_sign),
"signature diverged for a {len}-byte key"
);
}
}
const CREDENTIALS: &[(&str, &str)] = &[
(
"AKIAIOSFODNN7EXAMPLE",
"wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
),
("AKIDEXAMPLE", "wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY"),
(
"AKIAIOSFODNN7EXAMPLF",
"je7MtGbClwBF/2Zp9Utk/h3yCo8nvbEXAMPLEKEY",
),
];
const STRINGS_TO_SIGN: &[&[u8]] = &[
b"",
b"AWS4-ECDSA-P256-SHA256\n20260101T000000Z\n20260101/lambda/aws4_request\n\
a1b2c3d4e5f60718293a4b5c6d7e8f90a1b2c3d4e5f60718293a4b5c6d7e8f90",
&[0xff; 64],
];
#[test]
fn signature_matches_the_signing_key_path() {
for (access_key, secret_key) in CREDENTIALS {
let key = generate_signing_key(access_key, secret_key);
for string_to_sign in STRINGS_TO_SIGN {
let expected: DerSignature = SigningKey::from_slice(key.as_ref())
.expect("derived key is a valid P-256 private key")
.sign(string_to_sign);
assert_eq!(
hex::encode(expected.as_bytes()),
calculate_signature(&key, string_to_sign),
"signature diverged for access key {access_key}"
);
}
}
}
#[test]
fn derived_key_matches_the_published_test_vector() {
let key = generate_signing_key("AKIDEXAMPLE", "wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY");
assert_eq!(
"7efc8c0e65a324242818c5a50c891c6060b6a00717b7ba3cbe3c5d765be9259c",
hex::encode(key.as_ref()),
"the derived signing key changed"
);
let point = SigningKey::from_slice(key.as_ref())
.expect("derived key is a valid P-256 private key")
.verifying_key()
.as_affine()
.to_sec1_point(false);
assert_eq!(
"b6618f6a65740a99e650b33b6b4b5bd0d43b176d721a3edfea7e7d2d56d936b1",
hex::encode(point.x().expect("uncompressed point has an x coordinate")),
"public key no longer matches the test suite's public-key.json"
);
assert_eq!(
"865ed22a7eadc9c5cb9d2cbaca1b3699139fedc5043dc6661864218330c8e518",
hex::encode(point.y().expect("uncompressed point has a y coordinate")),
"public key no longer matches the test suite's public-key.json"
);
}
}