Replace Factory boilerplate with derive macros

Cargo.toml

@@ -13,6 +13,7 @@ bouncycastle-base64 = { path = "./crypto/base64" }
 bouncycastle-core = { path = "crypto/core" }
 bouncycastle-core-test-framework = { path = "./crypto/core-test-framework" }
 bouncycastle-factory = { path = "./crypto/factory" }
+bouncycastle-factory-macros = { path = "./crypto/factory-macros" }
 bouncycastle-hex = { path = "./crypto/hex" }
 bouncycastle-hkdf = { path = "./crypto/hkdf" }
 bouncycastle-hmac = { path = "./crypto/hmac" }

crypto/factory-macros/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "bouncycastle-factory-macros"
+version.workspace = true
+edition.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { version = "2", features = ["full"] }
+quote = "1"
+proc-macro2 = "1"

crypto/factory-macros/src/factory.rs

@@ -0,0 +1,130 @@
+//! Expansion for the `AlgorithmFactory` derive -- see the `AlgorithmFactory` entry point in the
+//! crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident, Path, Type};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `Default` and `crate::AlgorithmFactory` impls from the per-variant
+/// `#[factory(...)]` attributes.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let variants = parse_factory_variants(as_data_enum(input)?)?;
+
+ let default_128 = variants.iter().find(|v| v.is_default_128_bit);
+ let default_256 = variants.iter().find(|v| v.is_default_256_bit);
+ let (Some(default_128), Some(default_256)) = (default_128, default_256) else {
+ return Err(syn::Error::new_spanned(
+ input,
+ "exactly one variant needs `#[factory(default_128_bit)]` and one needs \
+ `#[factory(default_256_bit)]`",
+ ));
+ };
+ let default_128_ident = &default_128.ident;
+ let default_128_ty = &default_128.ty;
+ let default_256_ident = &default_256.ident;
+ let default_256_ty = &default_256.ty;
+
+ let idents: Vec<&Ident> = variants.iter().map(|v| &v.ident).collect();
+ let tys: Vec<&Type> = variants.iter().map(|v| &v.ty).collect();
+ let name_consts: Vec<&Path> = variants.iter().map(|v| &v.name_const).collect();
+
+ Ok(quote! {
+ impl ::std::default::Default for #enum_name {
+ fn default() -> #enum_name {
+ <#enum_name as crate::AlgorithmFactory>::default_128_bit()
+ }
+ }
+
+ impl crate::AlgorithmFactory for #enum_name {
+ fn default_128_bit() -> #enum_name {
+ Self::#default_128_ident(<#default_128_ty>::new())
+ }
+
+ fn default_256_bit() -> #enum_name {
+ Self::#default_256_ident(<#default_256_ty>::new())
+ }
+
+ fn new(alg_name: &str) -> Result<Self, crate::FactoryError> {
+ match alg_name {
+ crate::DEFAULT => Ok(<Self as ::std::default::Default>::default()),
+ crate::DEFAULT_128_BIT => {
+ Ok(<Self as crate::AlgorithmFactory>::default_128_bit())
+ }
+ crate::DEFAULT_256_BIT => {
+ Ok(<Self as crate::AlgorithmFactory>::default_256_bit())
+ }
+ #(#name_consts => Ok(Self::#idents(<#tys>::new())),)*
+ _ => Err(crate::FactoryError::UnsupportedAlgorithm(format!(
+ "The algorithm: \"{}\" is not a known {}",
+ alg_name,
+ stringify!(#enum_name),
+ ))),
+ }
+ }
+ }
+ })
+}
+
+/// One enum variant's worth of parsed `#[factory(...)]` configuration.
+struct FactoryVariant {
+ ident: Ident,
+ ty: Type,
+ name_const: Path,
+ is_default_128_bit: bool,
+ is_default_256_bit: bool,
+}
+
+/// Parses the `#[factory(...)]` helper attribute off every variant.
+fn parse_factory_variants(data: &DataEnum) -> syn::Result<Vec<FactoryVariant>> {
+ data.variants
+ .iter()
+ .map(|variant| {
+ let ty = single_field_type(variant)?.clone();
+
+ let mut name_const = None;
+ let mut is_default_128_bit = false;
+ let mut is_default_256_bit = false;
+
+ for attr in &variant.attrs {
+ if !attr.path().is_ident("factory") {
+ continue;
+ }
+ attr.parse_nested_meta(|meta| {
+ if meta.path.is_ident("name") {
+ name_const = Some(meta.value()?.parse::<Path>()?);
+ Ok(())
+ } else if meta.path.is_ident("default_128_bit") {
+ is_default_128_bit = true;
+ Ok(())
+ } else if meta.path.is_ident("default_256_bit") {
+ is_default_256_bit = true;
+ Ok(())
+ } else {
+ Err(meta.error(
+ "unrecognized `factory` attribute; expected `name`, \
+ `default_128_bit`, or `default_256_bit`",
+ ))
+ }
+ })?;
+ }
+
+ let name_const = name_const.ok_or_else(|| {
+ syn::Error::new_spanned(
+ variant,
+ "every variant needs `#[factory(name = ...)]` giving its algorithm-name constant",
+ )
+ })?;
+
+ Ok(FactoryVariant {
+ ident: variant.ident.clone(),
+ ty,
+ name_const,
+ is_default_128_bit,
+ is_default_256_bit,
+ })
+ })
+ .collect()
+}

crypto/factory-macros/src/hash.rs

@@ -0,0 +1,87 @@
+//! Expansion for the `Hash` derive -- see the `Hash` entry point in the crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `bouncycastle_core::traits::Hash` impl, forwarding every trait method to the
+/// wrapped value of whichever variant the enum currently holds.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let idents = single_field_variant_idents(as_data_enum(input)?)?;
+
+ Ok(quote! {
+ impl ::bouncycastle_core::traits::Hash for #enum_name {
+ fn block_bitlen(&self) -> usize {
+ match self { #(Self::#idents(h) => h.block_bitlen(),)* }
+ }
+
+ fn output_len(&self) -> usize {
+ match self { #(Self::#idents(h) => h.output_len(),)* }
+ }
+
+ fn hash(self, data: &[u8]) -> Vec<u8> {
+ match self { #(Self::#idents(h) => h.hash(data),)* }
+ }
+
+ fn hash_out(self, data: &[u8], output: &mut [u8]) -> usize {
+ output.fill(0);
+ match self { #(Self::#idents(h) => h.hash_out(data, output),)* }
+ }
+
+ fn do_update(&mut self, data: &[u8]) {
+ match self { #(Self::#idents(h) => h.do_update(data),)* }
+ }
+
+ fn do_final(self) -> Vec<u8> {
+ match self { #(Self::#idents(h) => h.do_final(),)* }
+ }
+
+ fn do_final_out(self, output: &mut [u8]) -> usize {
+ output.fill(0);
+ match self { #(Self::#idents(h) => h.do_final_out(output),)* }
+ }
+
+ fn do_final_partial_bits(
+ self,
+ partial_byte: u8,
+ num_partial_bits: usize,
+ ) -> Result<Vec<u8>, ::bouncycastle_core::errors::HashError> {
+ match self {
+ #(Self::#idents(h) => h.do_final_partial_bits(partial_byte, num_partial_bits),)*
+ }
+ }
+
+ fn do_final_partial_bits_out(
+ self,
+ partial_byte: u8,
+ num_partial_bits: usize,
+ output: &mut [u8],
+ ) -> Result<usize, ::bouncycastle_core::errors::HashError> {
+ match self {
+ #(Self::#idents(h) => {
+ h.do_final_partial_bits_out(partial_byte, num_partial_bits, output)
+ })*
+ }
+ }
+
+ fn max_security_strength(&self) -> ::bouncycastle_core::traits::SecurityStrength {
+ match self { #(Self::#idents(h) => h.max_security_strength(),)* }
+ }
+ }
+ })
+}
+
+/// Collects each variant's ident, rejecting any variant that isn't a single-field tuple since
+/// there would be no unambiguous value to forward the trait methods to.
+fn single_field_variant_idents(data: &DataEnum) -> syn::Result<Vec<Ident>> {
+ data.variants
+ .iter()
+ .map(|v| {
+ single_field_type(v)?;
+ Ok(v.ident.clone())
+ })
+ .collect()
+}

crypto/factory-macros/src/kdf.rs

@@ -0,0 +1,82 @@
+//! Expansion for the `KDF` derive -- see the `KDF` entry point in the crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `bouncycastle_core::traits::KDF` impl, forwarding every trait method to the
+/// wrapped value of whichever variant the enum currently holds.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let idents = single_field_variant_idents(as_data_enum(input)?)?;
+
+ Ok(quote! {
+ impl ::bouncycastle_core::traits::KDF for #enum_name {
+ fn derive_key(
+ self,
+ key: &impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ additional_input: &[u8],
+ ) -> Result<
+ ::std::boxed::Box<dyn ::bouncycastle_core::key_material::KeyMaterialTrait>,
+ ::bouncycastle_core::errors::KDFError,
+ > {
+ match self { #(Self::#idents(h) => h.derive_key(key, additional_input),)* }
+ }
+
+ fn derive_key_out(
+ self,
+ key: &impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ additional_input: &[u8],
+ output_key: &mut impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ ) -> Result<usize, ::bouncycastle_core::errors::KDFError> {
+ match self {
+ #(Self::#idents(h) => h.derive_key_out(key, additional_input, output_key),)*
+ }
+ }
+
+ fn derive_key_from_multiple(
+ self,
+ keys: &[&impl ::bouncycastle_core::key_material::KeyMaterialTrait],
+ additional_input: &[u8],
+ ) -> Result<
+ ::std::boxed::Box<dyn ::bouncycastle_core::key_material::KeyMaterialTrait>,
+ ::bouncycastle_core::errors::KDFError,
+ > {
+ match self {
+ #(Self::#idents(h) => h.derive_key_from_multiple(keys, additional_input),)*
+ }
+ }
+
+ fn derive_key_from_multiple_out(
+ self,
+ keys: &[&impl ::bouncycastle_core::key_material::KeyMaterialTrait],
+ additional_input: &[u8],
+ output_key: &mut impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ ) -> Result<usize, ::bouncycastle_core::errors::KDFError> {
+ match self {
+ #(Self::#idents(h) => {
+ h.derive_key_from_multiple_out(keys, additional_input, output_key)
+ })*
+ }
+ }
+
+ fn max_security_strength(&self) -> ::bouncycastle_core::traits::SecurityStrength {
+ match self { #(Self::#idents(h) => h.max_security_strength(),)* }
+ }
+ }
+ })
+}
+
+/// Collects each variant's ident, rejecting any variant that isn't a single-field tuple since
+/// there would be no unambiguous value to forward the trait methods to.
+fn single_field_variant_idents(data: &DataEnum) -> syn::Result<Vec<Ident>> {
+ data.variants
+ .iter()
+ .map(|v| {
+ single_field_type(v)?;
+ Ok(v.ident.clone())
+ })
+ .collect()
+}

Cargo.toml

@@ -13,6 +13,7 @@ bouncycastle-base64 = { path = "./crypto/base64" }
 bouncycastle-core = { path = "crypto/core" }
 bouncycastle-core-test-framework = { path = "./crypto/core-test-framework" }
 bouncycastle-factory = { path = "./crypto/factory" }
+bouncycastle-factory-macros = { path = "./crypto/factory-macros" }
 bouncycastle-hex = { path = "./crypto/hex" }
 bouncycastle-hkdf = { path = "./crypto/hkdf" }
 bouncycastle-hmac = { path = "./crypto/hmac" }

crypto/factory-macros/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "bouncycastle-factory-macros"
+version.workspace = true
+edition.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { version = "2", features = ["full"] }
+quote = "1"
+proc-macro2 = "1"

crypto/factory-macros/src/factory.rs

@@ -0,0 +1,130 @@
+//! Expansion for the `AlgorithmFactory` derive -- see the `AlgorithmFactory` entry point in the
+//! crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident, Path, Type};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `Default` and `crate::AlgorithmFactory` impls from the per-variant
+/// `#[factory(...)]` attributes.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let variants = parse_factory_variants(as_data_enum(input)?)?;
+
+ let default_128 = variants.iter().find(|v| v.is_default_128_bit);
+ let default_256 = variants.iter().find(|v| v.is_default_256_bit);
+ let (Some(default_128), Some(default_256)) = (default_128, default_256) else {
+ return Err(syn::Error::new_spanned(
+ input,
+ "exactly one variant needs `#[factory(default_128_bit)]` and one needs \
+ `#[factory(default_256_bit)]`",
+ ));
+ };
+ let default_128_ident = &default_128.ident;
+ let default_128_ty = &default_128.ty;
+ let default_256_ident = &default_256.ident;
+ let default_256_ty = &default_256.ty;
+
+ let idents: Vec<&Ident> = variants.iter().map(|v| &v.ident).collect();
+ let tys: Vec<&Type> = variants.iter().map(|v| &v.ty).collect();
+ let name_consts: Vec<&Path> = variants.iter().map(|v| &v.name_const).collect();
+
+ Ok(quote! {
+ impl ::std::default::Default for #enum_name {
+ fn default() -> #enum_name {
+ <#enum_name as crate::AlgorithmFactory>::default_128_bit()
+ }
+ }
+
+ impl crate::AlgorithmFactory for #enum_name {
+ fn default_128_bit() -> #enum_name {
+ Self::#default_128_ident(<#default_128_ty>::new())
+ }
+
+ fn default_256_bit() -> #enum_name {
+ Self::#default_256_ident(<#default_256_ty>::new())
+ }
+
+ fn new(alg_name: &str) -> Result<Self, crate::FactoryError> {
+ match alg_name {
+ crate::DEFAULT => Ok(<Self as ::std::default::Default>::default()),
+ crate::DEFAULT_128_BIT => {
+ Ok(<Self as crate::AlgorithmFactory>::default_128_bit())
+ }
+ crate::DEFAULT_256_BIT => {
+ Ok(<Self as crate::AlgorithmFactory>::default_256_bit())
+ }
+ #(#name_consts => Ok(Self::#idents(<#tys>::new())),)*
+ _ => Err(crate::FactoryError::UnsupportedAlgorithm(format!(
+ "The algorithm: \"{}\" is not a known {}",
+ alg_name,
+ stringify!(#enum_name),
+ ))),
+ }
+ }
+ }
+ })
+}
+
+/// One enum variant's worth of parsed `#[factory(...)]` configuration.
+struct FactoryVariant {
+ ident: Ident,
+ ty: Type,
+ name_const: Path,
+ is_default_128_bit: bool,
+ is_default_256_bit: bool,
+}
+
+/// Parses the `#[factory(...)]` helper attribute off every variant.
+fn parse_factory_variants(data: &DataEnum) -> syn::Result<Vec<FactoryVariant>> {
+ data.variants
+ .iter()
+ .map(|variant| {
+ let ty = single_field_type(variant)?.clone();
+
+ let mut name_const = None;
+ let mut is_default_128_bit = false;
+ let mut is_default_256_bit = false;
+
+ for attr in &variant.attrs {
+ if !attr.path().is_ident("factory") {
+ continue;
+ }
+ attr.parse_nested_meta(|meta| {
+ if meta.path.is_ident("name") {
+ name_const = Some(meta.value()?.parse::<Path>()?);
+ Ok(())
+ } else if meta.path.is_ident("default_128_bit") {
+ is_default_128_bit = true;
+ Ok(())
+ } else if meta.path.is_ident("default_256_bit") {
+ is_default_256_bit = true;
+ Ok(())
+ } else {
+ Err(meta.error(
+ "unrecognized `factory` attribute; expected `name`, \
+ `default_128_bit`, or `default_256_bit`",
+ ))
+ }
+ })?;
+ }
+
+ let name_const = name_const.ok_or_else(|| {
+ syn::Error::new_spanned(
+ variant,
+ "every variant needs `#[factory(name = ...)]` giving its algorithm-name constant",
+ )
+ })?;
+
+ Ok(FactoryVariant {
+ ident: variant.ident.clone(),
+ ty,
+ name_const,
+ is_default_128_bit,
+ is_default_256_bit,
+ })
+ })
+ .collect()
+}

crypto/factory-macros/src/hash.rs

@@ -0,0 +1,87 @@
+//! Expansion for the `Hash` derive -- see the `Hash` entry point in the crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `bouncycastle_core::traits::Hash` impl, forwarding every trait method to the
+/// wrapped value of whichever variant the enum currently holds.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let idents = single_field_variant_idents(as_data_enum(input)?)?;
+
+ Ok(quote! {
+ impl ::bouncycastle_core::traits::Hash for #enum_name {
+ fn block_bitlen(&self) -> usize {
+ match self { #(Self::#idents(h) => h.block_bitlen(),)* }
+ }
+
+ fn output_len(&self) -> usize {
+ match self { #(Self::#idents(h) => h.output_len(),)* }
+ }
+
+ fn hash(self, data: &[u8]) -> Vec<u8> {
+ match self { #(Self::#idents(h) => h.hash(data),)* }
+ }
+
+ fn hash_out(self, data: &[u8], output: &mut [u8]) -> usize {
+ output.fill(0);
+ match self { #(Self::#idents(h) => h.hash_out(data, output),)* }
+ }
+
+ fn do_update(&mut self, data: &[u8]) {
+ match self { #(Self::#idents(h) => h.do_update(data),)* }
+ }
+
+ fn do_final(self) -> Vec<u8> {
+ match self { #(Self::#idents(h) => h.do_final(),)* }
+ }
+
+ fn do_final_out(self, output: &mut [u8]) -> usize {
+ output.fill(0);
+ match self { #(Self::#idents(h) => h.do_final_out(output),)* }
+ }
+
+ fn do_final_partial_bits(
+ self,
+ partial_byte: u8,
+ num_partial_bits: usize,
+ ) -> Result<Vec<u8>, ::bouncycastle_core::errors::HashError> {
+ match self {
+ #(Self::#idents(h) => h.do_final_partial_bits(partial_byte, num_partial_bits),)*
+ }
+ }
+
+ fn do_final_partial_bits_out(
+ self,
+ partial_byte: u8,
+ num_partial_bits: usize,
+ output: &mut [u8],
+ ) -> Result<usize, ::bouncycastle_core::errors::HashError> {
+ match self {
+ #(Self::#idents(h) => {
+ h.do_final_partial_bits_out(partial_byte, num_partial_bits, output)
+ })*
+ }
+ }
+
+ fn max_security_strength(&self) -> ::bouncycastle_core::traits::SecurityStrength {
+ match self { #(Self::#idents(h) => h.max_security_strength(),)* }
+ }
+ }
+ })
+}
+
+/// Collects each variant's ident, rejecting any variant that isn't a single-field tuple since
+/// there would be no unambiguous value to forward the trait methods to.
+fn single_field_variant_idents(data: &DataEnum) -> syn::Result<Vec<Ident>> {
+ data.variants
+ .iter()
+ .map(|v| {
+ single_field_type(v)?;
+ Ok(v.ident.clone())
+ })
+ .collect()
+}

crypto/factory-macros/src/kdf.rs

@@ -0,0 +1,82 @@
+//! Expansion for the `KDF` derive -- see the `KDF` entry point in the crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `bouncycastle_core::traits::KDF` impl, forwarding every trait method to the
+/// wrapped value of whichever variant the enum currently holds.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let idents = single_field_variant_idents(as_data_enum(input)?)?;
+
+ Ok(quote! {
+ impl ::bouncycastle_core::traits::KDF for #enum_name {
+ fn derive_key(
+ self,
+ key: &impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ additional_input: &[u8],
+ ) -> Result<
+ ::std::boxed::Box<dyn ::bouncycastle_core::key_material::KeyMaterialTrait>,
+ ::bouncycastle_core::errors::KDFError,
+ > {
+ match self { #(Self::#idents(h) => h.derive_key(key, additional_input),)* }
+ }
+
+ fn derive_key_out(
+ self,
+ key: &impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ additional_input: &[u8],
+ output_key: &mut impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ ) -> Result<usize, ::bouncycastle_core::errors::KDFError> {
+ match self {
+ #(Self::#idents(h) => h.derive_key_out(key, additional_input, output_key),)*
+ }
+ }
+
+ fn derive_key_from_multiple(
+ self,
+ keys: &[&impl ::bouncycastle_core::key_material::KeyMaterialTrait],
+ additional_input: &[u8],
+ ) -> Result<
+ ::std::boxed::Box<dyn ::bouncycastle_core::key_material::KeyMaterialTrait>,
+ ::bouncycastle_core::errors::KDFError,
+ > {
+ match self {
+ #(Self::#idents(h) => h.derive_key_from_multiple(keys, additional_input),)*
+ }
+ }
+
+ fn derive_key_from_multiple_out(
+ self,
+ keys: &[&impl ::bouncycastle_core::key_material::KeyMaterialTrait],
+ additional_input: &[u8],
+ output_key: &mut impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ ) -> Result<usize, ::bouncycastle_core::errors::KDFError> {
+ match self {
+ #(Self::#idents(h) => {
+ h.derive_key_from_multiple_out(keys, additional_input, output_key)
+ })*
+ }
+ }
+
+ fn max_security_strength(&self) -> ::bouncycastle_core::traits::SecurityStrength {
+ match self { #(Self::#idents(h) => h.max_security_strength(),)* }
+ }
+ }
+ })
+}
+
+/// Collects each variant's ident, rejecting any variant that isn't a single-field tuple since
+/// there would be no unambiguous value to forward the trait methods to.
+fn single_field_variant_idents(data: &DataEnum) -> syn::Result<Vec<Ident>> {
+ data.variants
+ .iter()
+ .map(|v| {
+ single_field_type(v)?;
+ Ok(v.ident.clone())
+ })
+ .collect()
+}

Cargo.toml

@@ -13,6 +13,7 @@ bouncycastle-base64 = { path = "./crypto/base64" }
 bouncycastle-core = { path = "crypto/core" }
 bouncycastle-core-test-framework = { path = "./crypto/core-test-framework" }
 bouncycastle-factory = { path = "./crypto/factory" }
+bouncycastle-factory-macros = { path = "./crypto/factory-macros" }
 bouncycastle-hex = { path = "./crypto/hex" }
 bouncycastle-hkdf = { path = "./crypto/hkdf" }
 bouncycastle-hmac = { path = "./crypto/hmac" }

crypto/factory-macros/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "bouncycastle-factory-macros"
+version.workspace = true
+edition.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { version = "2", features = ["full"] }
+quote = "1"
+proc-macro2 = "1"

crypto/factory-macros/src/factory.rs

@@ -0,0 +1,130 @@
+//! Expansion for the `AlgorithmFactory` derive -- see the `AlgorithmFactory` entry point in the
+//! crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident, Path, Type};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `Default` and `crate::AlgorithmFactory` impls from the per-variant
+/// `#[factory(...)]` attributes.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let variants = parse_factory_variants(as_data_enum(input)?)?;
+
+ let default_128 = variants.iter().find(|v| v.is_default_128_bit);
+ let default_256 = variants.iter().find(|v| v.is_default_256_bit);
+ let (Some(default_128), Some(default_256)) = (default_128, default_256) else {
+ return Err(syn::Error::new_spanned(
+ input,
+ "exactly one variant needs `#[factory(default_128_bit)]` and one needs \
+ `#[factory(default_256_bit)]`",
+ ));
+ };
+ let default_128_ident = &default_128.ident;
+ let default_128_ty = &default_128.ty;
+ let default_256_ident = &default_256.ident;
+ let default_256_ty = &default_256.ty;
+
+ let idents: Vec<&Ident> = variants.iter().map(|v| &v.ident).collect();
+ let tys: Vec<&Type> = variants.iter().map(|v| &v.ty).collect();
+ let name_consts: Vec<&Path> = variants.iter().map(|v| &v.name_const).collect();
+
+ Ok(quote! {
+ impl ::std::default::Default for #enum_name {
+ fn default() -> #enum_name {
+ <#enum_name as crate::AlgorithmFactory>::default_128_bit()
+ }
+ }
+
+ impl crate::AlgorithmFactory for #enum_name {
+ fn default_128_bit() -> #enum_name {
+ Self::#default_128_ident(<#default_128_ty>::new())
+ }
+
+ fn default_256_bit() -> #enum_name {
+ Self::#default_256_ident(<#default_256_ty>::new())
+ }
+
+ fn new(alg_name: &str) -> Result<Self, crate::FactoryError> {
+ match alg_name {
+ crate::DEFAULT => Ok(<Self as ::std::default::Default>::default()),
+ crate::DEFAULT_128_BIT => {
+ Ok(<Self as crate::AlgorithmFactory>::default_128_bit())
+ }
+ crate::DEFAULT_256_BIT => {
+ Ok(<Self as crate::AlgorithmFactory>::default_256_bit())
+ }
+ #(#name_consts => Ok(Self::#idents(<#tys>::new())),)*
+ _ => Err(crate::FactoryError::UnsupportedAlgorithm(format!(
+ "The algorithm: \"{}\" is not a known {}",
+ alg_name,
+ stringify!(#enum_name),
+ ))),
+ }
+ }
+ }
+ })
+}
+
+/// One enum variant's worth of parsed `#[factory(...)]` configuration.
+struct FactoryVariant {
+ ident: Ident,
+ ty: Type,
+ name_const: Path,
+ is_default_128_bit: bool,
+ is_default_256_bit: bool,
+}
+
+/// Parses the `#[factory(...)]` helper attribute off every variant.
+fn parse_factory_variants(data: &DataEnum) -> syn::Result<Vec<FactoryVariant>> {
+ data.variants
+ .iter()
+ .map(|variant| {
+ let ty = single_field_type(variant)?.clone();
+
+ let mut name_const = None;
+ let mut is_default_128_bit = false;
+ let mut is_default_256_bit = false;
+
+ for attr in &variant.attrs {
+ if !attr.path().is_ident("factory") {
+ continue;
+ }
+ attr.parse_nested_meta(|meta| {
+ if meta.path.is_ident("name") {
+ name_const = Some(meta.value()?.parse::<Path>()?);
+ Ok(())
+ } else if meta.path.is_ident("default_128_bit") {
+ is_default_128_bit = true;
+ Ok(())
+ } else if meta.path.is_ident("default_256_bit") {
+ is_default_256_bit = true;
+ Ok(())
+ } else {
+ Err(meta.error(
+ "unrecognized `factory` attribute; expected `name`, \
+ `default_128_bit`, or `default_256_bit`",
+ ))
+ }
+ })?;
+ }
+
+ let name_const = name_const.ok_or_else(|| {
+ syn::Error::new_spanned(
+ variant,
+ "every variant needs `#[factory(name = ...)]` giving its algorithm-name constant",
+ )
+ })?;
+
+ Ok(FactoryVariant {
+ ident: variant.ident.clone(),
+ ty,
+ name_const,
+ is_default_128_bit,
+ is_default_256_bit,
+ })
+ })
+ .collect()
+}

crypto/factory-macros/src/hash.rs

@@ -0,0 +1,87 @@
+//! Expansion for the `Hash` derive -- see the `Hash` entry point in the crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `bouncycastle_core::traits::Hash` impl, forwarding every trait method to the
+/// wrapped value of whichever variant the enum currently holds.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let idents = single_field_variant_idents(as_data_enum(input)?)?;
+
+ Ok(quote! {
+ impl ::bouncycastle_core::traits::Hash for #enum_name {
+ fn block_bitlen(&self) -> usize {
+ match self { #(Self::#idents(h) => h.block_bitlen(),)* }
+ }
+
+ fn output_len(&self) -> usize {
+ match self { #(Self::#idents(h) => h.output_len(),)* }
+ }
+
+ fn hash(self, data: &[u8]) -> Vec<u8> {
+ match self { #(Self::#idents(h) => h.hash(data),)* }
+ }
+
+ fn hash_out(self, data: &[u8], output: &mut [u8]) -> usize {
+ output.fill(0);
+ match self { #(Self::#idents(h) => h.hash_out(data, output),)* }
+ }
+
+ fn do_update(&mut self, data: &[u8]) {
+ match self { #(Self::#idents(h) => h.do_update(data),)* }
+ }
+
+ fn do_final(self) -> Vec<u8> {
+ match self { #(Self::#idents(h) => h.do_final(),)* }
+ }
+
+ fn do_final_out(self, output: &mut [u8]) -> usize {
+ output.fill(0);
+ match self { #(Self::#idents(h) => h.do_final_out(output),)* }
+ }
+
+ fn do_final_partial_bits(
+ self,
+ partial_byte: u8,
+ num_partial_bits: usize,
+ ) -> Result<Vec<u8>, ::bouncycastle_core::errors::HashError> {
+ match self {
+ #(Self::#idents(h) => h.do_final_partial_bits(partial_byte, num_partial_bits),)*
+ }
+ }
+
+ fn do_final_partial_bits_out(
+ self,
+ partial_byte: u8,
+ num_partial_bits: usize,
+ output: &mut [u8],
+ ) -> Result<usize, ::bouncycastle_core::errors::HashError> {
+ match self {
+ #(Self::#idents(h) => {
+ h.do_final_partial_bits_out(partial_byte, num_partial_bits, output)
+ })*
+ }
+ }
+
+ fn max_security_strength(&self) -> ::bouncycastle_core::traits::SecurityStrength {
+ match self { #(Self::#idents(h) => h.max_security_strength(),)* }
+ }
+ }
+ })
+}
+
+/// Collects each variant's ident, rejecting any variant that isn't a single-field tuple since
+/// there would be no unambiguous value to forward the trait methods to.
+fn single_field_variant_idents(data: &DataEnum) -> syn::Result<Vec<Ident>> {
+ data.variants
+ .iter()
+ .map(|v| {
+ single_field_type(v)?;
+ Ok(v.ident.clone())
+ })
+ .collect()
+}

crypto/factory-macros/src/kdf.rs

@@ -0,0 +1,82 @@
+//! Expansion for the `KDF` derive -- see the `KDF` entry point in the crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `bouncycastle_core::traits::KDF` impl, forwarding every trait method to the
+/// wrapped value of whichever variant the enum currently holds.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let idents = single_field_variant_idents(as_data_enum(input)?)?;
+
+ Ok(quote! {
+ impl ::bouncycastle_core::traits::KDF for #enum_name {
+ fn derive_key(
+ self,
+ key: &impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ additional_input: &[u8],
+ ) -> Result<
+ ::std::boxed::Box<dyn ::bouncycastle_core::key_material::KeyMaterialTrait>,
+ ::bouncycastle_core::errors::KDFError,
+ > {
+ match self { #(Self::#idents(h) => h.derive_key(key, additional_input),)* }
+ }
+
+ fn derive_key_out(
+ self,
+ key: &impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ additional_input: &[u8],
+ output_key: &mut impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ ) -> Result<usize, ::bouncycastle_core::errors::KDFError> {
+ match self {
+ #(Self::#idents(h) => h.derive_key_out(key, additional_input, output_key),)*
+ }
+ }
+
+ fn derive_key_from_multiple(
+ self,
+ keys: &[&impl ::bouncycastle_core::key_material::KeyMaterialTrait],
+ additional_input: &[u8],
+ ) -> Result<
+ ::std::boxed::Box<dyn ::bouncycastle_core::key_material::KeyMaterialTrait>,
+ ::bouncycastle_core::errors::KDFError,
+ > {
+ match self {
+ #(Self::#idents(h) => h.derive_key_from_multiple(keys, additional_input),)*
+ }
+ }
+
+ fn derive_key_from_multiple_out(
+ self,
+ keys: &[&impl ::bouncycastle_core::key_material::KeyMaterialTrait],
+ additional_input: &[u8],
+ output_key: &mut impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ ) -> Result<usize, ::bouncycastle_core::errors::KDFError> {
+ match self {
+ #(Self::#idents(h) => {
+ h.derive_key_from_multiple_out(keys, additional_input, output_key)
+ })*
+ }
+ }
+
+ fn max_security_strength(&self) -> ::bouncycastle_core::traits::SecurityStrength {
+ match self { #(Self::#idents(h) => h.max_security_strength(),)* }
+ }
+ }
+ })
+}
+
+/// Collects each variant's ident, rejecting any variant that isn't a single-field tuple since
+/// there would be no unambiguous value to forward the trait methods to.
+fn single_field_variant_idents(data: &DataEnum) -> syn::Result<Vec<Ident>> {
+ data.variants
+ .iter()
+ .map(|v| {
+ single_field_type(v)?;
+ Ok(v.ident.clone())
+ })
+ .collect()
+}

Cargo.toml

@@ -13,6 +13,7 @@ bouncycastle-base64 = { path = "./crypto/base64" }
 bouncycastle-core = { path = "crypto/core" }
 bouncycastle-core-test-framework = { path = "./crypto/core-test-framework" }
 bouncycastle-factory = { path = "./crypto/factory" }
+bouncycastle-factory-macros = { path = "./crypto/factory-macros" }
 bouncycastle-hex = { path = "./crypto/hex" }
 bouncycastle-hkdf = { path = "./crypto/hkdf" }
 bouncycastle-hmac = { path = "./crypto/hmac" }

crypto/factory-macros/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "bouncycastle-factory-macros"
+version.workspace = true
+edition.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { version = "2", features = ["full"] }
+quote = "1"
+proc-macro2 = "1"

crypto/factory-macros/src/factory.rs

@@ -0,0 +1,130 @@
+//! Expansion for the `AlgorithmFactory` derive -- see the `AlgorithmFactory` entry point in the
+//! crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident, Path, Type};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `Default` and `crate::AlgorithmFactory` impls from the per-variant
+/// `#[factory(...)]` attributes.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let variants = parse_factory_variants(as_data_enum(input)?)?;
+
+ let default_128 = variants.iter().find(|v| v.is_default_128_bit);
+ let default_256 = variants.iter().find(|v| v.is_default_256_bit);
+ let (Some(default_128), Some(default_256)) = (default_128, default_256) else {
+ return Err(syn::Error::new_spanned(
+ input,
+ "exactly one variant needs `#[factory(default_128_bit)]` and one needs \
+ `#[factory(default_256_bit)]`",
+ ));
+ };
+ let default_128_ident = &default_128.ident;
+ let default_128_ty = &default_128.ty;
+ let default_256_ident = &default_256.ident;
+ let default_256_ty = &default_256.ty;
+
+ let idents: Vec<&Ident> = variants.iter().map(|v| &v.ident).collect();
+ let tys: Vec<&Type> = variants.iter().map(|v| &v.ty).collect();
+ let name_consts: Vec<&Path> = variants.iter().map(|v| &v.name_const).collect();
+
+ Ok(quote! {
+ impl ::std::default::Default for #enum_name {
+ fn default() -> #enum_name {
+ <#enum_name as crate::AlgorithmFactory>::default_128_bit()
+ }
+ }
+
+ impl crate::AlgorithmFactory for #enum_name {
+ fn default_128_bit() -> #enum_name {
+ Self::#default_128_ident(<#default_128_ty>::new())
+ }
+
+ fn default_256_bit() -> #enum_name {
+ Self::#default_256_ident(<#default_256_ty>::new())
+ }
+
+ fn new(alg_name: &str) -> Result<Self, crate::FactoryError> {
+ match alg_name {
+ crate::DEFAULT => Ok(<Self as ::std::default::Default>::default()),
+ crate::DEFAULT_128_BIT => {
+ Ok(<Self as crate::AlgorithmFactory>::default_128_bit())
+ }
+ crate::DEFAULT_256_BIT => {
+ Ok(<Self as crate::AlgorithmFactory>::default_256_bit())
+ }
+ #(#name_consts => Ok(Self::#idents(<#tys>::new())),)*
+ _ => Err(crate::FactoryError::UnsupportedAlgorithm(format!(
+ "The algorithm: \"{}\" is not a known {}",
+ alg_name,
+ stringify!(#enum_name),
+ ))),
+ }
+ }
+ }
+ })
+}
+
+/// One enum variant's worth of parsed `#[factory(...)]` configuration.
+struct FactoryVariant {
+ ident: Ident,
+ ty: Type,
+ name_const: Path,
+ is_default_128_bit: bool,
+ is_default_256_bit: bool,
+}
+
+/// Parses the `#[factory(...)]` helper attribute off every variant.
+fn parse_factory_variants(data: &DataEnum) -> syn::Result<Vec<FactoryVariant>> {
+ data.variants
+ .iter()
+ .map(|variant| {
+ let ty = single_field_type(variant)?.clone();
+
+ let mut name_const = None;
+ let mut is_default_128_bit = false;
+ let mut is_default_256_bit = false;
+
+ for attr in &variant.attrs {
+ if !attr.path().is_ident("factory") {
+ continue;
+ }
+ attr.parse_nested_meta(|meta| {
+ if meta.path.is_ident("name") {
+ name_const = Some(meta.value()?.parse::<Path>()?);
+ Ok(())
+ } else if meta.path.is_ident("default_128_bit") {
+ is_default_128_bit = true;
+ Ok(())
+ } else if meta.path.is_ident("default_256_bit") {
+ is_default_256_bit = true;
+ Ok(())
+ } else {
+ Err(meta.error(
+ "unrecognized `factory` attribute; expected `name`, \
+ `default_128_bit`, or `default_256_bit`",
+ ))
+ }
+ })?;
+ }
+
+ let name_const = name_const.ok_or_else(|| {
+ syn::Error::new_spanned(
+ variant,
+ "every variant needs `#[factory(name = ...)]` giving its algorithm-name constant",
+ )
+ })?;
+
+ Ok(FactoryVariant {
+ ident: variant.ident.clone(),
+ ty,
+ name_const,
+ is_default_128_bit,
+ is_default_256_bit,
+ })
+ })
+ .collect()
+}

crypto/factory-macros/src/hash.rs

@@ -0,0 +1,87 @@
+//! Expansion for the `Hash` derive -- see the `Hash` entry point in the crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `bouncycastle_core::traits::Hash` impl, forwarding every trait method to the
+/// wrapped value of whichever variant the enum currently holds.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let idents = single_field_variant_idents(as_data_enum(input)?)?;
+
+ Ok(quote! {
+ impl ::bouncycastle_core::traits::Hash for #enum_name {
+ fn block_bitlen(&self) -> usize {
+ match self { #(Self::#idents(h) => h.block_bitlen(),)* }
+ }
+
+ fn output_len(&self) -> usize {
+ match self { #(Self::#idents(h) => h.output_len(),)* }
+ }
+
+ fn hash(self, data: &[u8]) -> Vec<u8> {
+ match self { #(Self::#idents(h) => h.hash(data),)* }
+ }
+
+ fn hash_out(self, data: &[u8], output: &mut [u8]) -> usize {
+ output.fill(0);
+ match self { #(Self::#idents(h) => h.hash_out(data, output),)* }
+ }
+
+ fn do_update(&mut self, data: &[u8]) {
+ match self { #(Self::#idents(h) => h.do_update(data),)* }
+ }
+
+ fn do_final(self) -> Vec<u8> {
+ match self { #(Self::#idents(h) => h.do_final(),)* }
+ }
+
+ fn do_final_out(self, output: &mut [u8]) -> usize {
+ output.fill(0);
+ match self { #(Self::#idents(h) => h.do_final_out(output),)* }
+ }
+
+ fn do_final_partial_bits(
+ self,
+ partial_byte: u8,
+ num_partial_bits: usize,
+ ) -> Result<Vec<u8>, ::bouncycastle_core::errors::HashError> {
+ match self {
+ #(Self::#idents(h) => h.do_final_partial_bits(partial_byte, num_partial_bits),)*
+ }
+ }
+
+ fn do_final_partial_bits_out(
+ self,
+ partial_byte: u8,
+ num_partial_bits: usize,
+ output: &mut [u8],
+ ) -> Result<usize, ::bouncycastle_core::errors::HashError> {
+ match self {
+ #(Self::#idents(h) => {
+ h.do_final_partial_bits_out(partial_byte, num_partial_bits, output)
+ })*
+ }
+ }
+
+ fn max_security_strength(&self) -> ::bouncycastle_core::traits::SecurityStrength {
+ match self { #(Self::#idents(h) => h.max_security_strength(),)* }
+ }
+ }
+ })
+}
+
+/// Collects each variant's ident, rejecting any variant that isn't a single-field tuple since
+/// there would be no unambiguous value to forward the trait methods to.
+fn single_field_variant_idents(data: &DataEnum) -> syn::Result<Vec<Ident>> {
+ data.variants
+ .iter()
+ .map(|v| {
+ single_field_type(v)?;
+ Ok(v.ident.clone())
+ })
+ .collect()
+}

crypto/factory-macros/src/kdf.rs

@@ -0,0 +1,82 @@
+//! Expansion for the `KDF` derive -- see the `KDF` entry point in the crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `bouncycastle_core::traits::KDF` impl, forwarding every trait method to the
+/// wrapped value of whichever variant the enum currently holds.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let idents = single_field_variant_idents(as_data_enum(input)?)?;
+
+ Ok(quote! {
+ impl ::bouncycastle_core::traits::KDF for #enum_name {
+ fn derive_key(
+ self,
+ key: &impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ additional_input: &[u8],
+ ) -> Result<
+ ::std::boxed::Box<dyn ::bouncycastle_core::key_material::KeyMaterialTrait>,
+ ::bouncycastle_core::errors::KDFError,
+ > {
+ match self { #(Self::#idents(h) => h.derive_key(key, additional_input),)* }
+ }
+
+ fn derive_key_out(
+ self,
+ key: &impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ additional_input: &[u8],
+ output_key: &mut impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ ) -> Result<usize, ::bouncycastle_core::errors::KDFError> {
+ match self {
+ #(Self::#idents(h) => h.derive_key_out(key, additional_input, output_key),)*
+ }
+ }
+
+ fn derive_key_from_multiple(
+ self,
+ keys: &[&impl ::bouncycastle_core::key_material::KeyMaterialTrait],
+ additional_input: &[u8],
+ ) -> Result<
+ ::std::boxed::Box<dyn ::bouncycastle_core::key_material::KeyMaterialTrait>,
+ ::bouncycastle_core::errors::KDFError,
+ > {
+ match self {
+ #(Self::#idents(h) => h.derive_key_from_multiple(keys, additional_input),)*
+ }
+ }
+
+ fn derive_key_from_multiple_out(
+ self,
+ keys: &[&impl ::bouncycastle_core::key_material::KeyMaterialTrait],
+ additional_input: &[u8],
+ output_key: &mut impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ ) -> Result<usize, ::bouncycastle_core::errors::KDFError> {
+ match self {
+ #(Self::#idents(h) => {
+ h.derive_key_from_multiple_out(keys, additional_input, output_key)
+ })*
+ }
+ }
+
+ fn max_security_strength(&self) -> ::bouncycastle_core::traits::SecurityStrength {
+ match self { #(Self::#idents(h) => h.max_security_strength(),)* }
+ }
+ }
+ })
+}
+
+/// Collects each variant's ident, rejecting any variant that isn't a single-field tuple since
+/// there would be no unambiguous value to forward the trait methods to.
+fn single_field_variant_idents(data: &DataEnum) -> syn::Result<Vec<Ident>> {
+ data.variants
+ .iter()
+ .map(|v| {
+ single_field_type(v)?;
+ Ok(v.ident.clone())
+ })
+ .collect()
+}

Cargo.toml

@@ -13,6 +13,7 @@ bouncycastle-base64 = { path = "./crypto/base64" }
 bouncycastle-core = { path = "crypto/core" }
 bouncycastle-core-test-framework = { path = "./crypto/core-test-framework" }
 bouncycastle-factory = { path = "./crypto/factory" }
+bouncycastle-factory-macros = { path = "./crypto/factory-macros" }
 bouncycastle-hex = { path = "./crypto/hex" }
 bouncycastle-hkdf = { path = "./crypto/hkdf" }
 bouncycastle-hmac = { path = "./crypto/hmac" }

crypto/factory-macros/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "bouncycastle-factory-macros"
+version.workspace = true
+edition.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { version = "2", features = ["full"] }
+quote = "1"
+proc-macro2 = "1"

crypto/factory-macros/src/factory.rs

@@ -0,0 +1,130 @@
+//! Expansion for the `AlgorithmFactory` derive -- see the `AlgorithmFactory` entry point in the
+//! crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident, Path, Type};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `Default` and `crate::AlgorithmFactory` impls from the per-variant
+/// `#[factory(...)]` attributes.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let variants = parse_factory_variants(as_data_enum(input)?)?;
+
+ let default_128 = variants.iter().find(|v| v.is_default_128_bit);
+ let default_256 = variants.iter().find(|v| v.is_default_256_bit);
+ let (Some(default_128), Some(default_256)) = (default_128, default_256) else {
+ return Err(syn::Error::new_spanned(
+ input,
+ "exactly one variant needs `#[factory(default_128_bit)]` and one needs \
+ `#[factory(default_256_bit)]`",
+ ));
+ };
+ let default_128_ident = &default_128.ident;
+ let default_128_ty = &default_128.ty;
+ let default_256_ident = &default_256.ident;
+ let default_256_ty = &default_256.ty;
+
+ let idents: Vec<&Ident> = variants.iter().map(|v| &v.ident).collect();
+ let tys: Vec<&Type> = variants.iter().map(|v| &v.ty).collect();
+ let name_consts: Vec<&Path> = variants.iter().map(|v| &v.name_const).collect();
+
+ Ok(quote! {
+ impl ::std::default::Default for #enum_name {
+ fn default() -> #enum_name {
+ <#enum_name as crate::AlgorithmFactory>::default_128_bit()
+ }
+ }
+
+ impl crate::AlgorithmFactory for #enum_name {
+ fn default_128_bit() -> #enum_name {
+ Self::#default_128_ident(<#default_128_ty>::new())
+ }
+
+ fn default_256_bit() -> #enum_name {
+ Self::#default_256_ident(<#default_256_ty>::new())
+ }
+
+ fn new(alg_name: &str) -> Result<Self, crate::FactoryError> {
+ match alg_name {
+ crate::DEFAULT => Ok(<Self as ::std::default::Default>::default()),
+ crate::DEFAULT_128_BIT => {
+ Ok(<Self as crate::AlgorithmFactory>::default_128_bit())
+ }
+ crate::DEFAULT_256_BIT => {
+ Ok(<Self as crate::AlgorithmFactory>::default_256_bit())
+ }
+ #(#name_consts => Ok(Self::#idents(<#tys>::new())),)*
+ _ => Err(crate::FactoryError::UnsupportedAlgorithm(format!(
+ "The algorithm: \"{}\" is not a known {}",
+ alg_name,
+ stringify!(#enum_name),
+ ))),
+ }
+ }
+ }
+ })
+}
+
+/// One enum variant's worth of parsed `#[factory(...)]` configuration.
+struct FactoryVariant {
+ ident: Ident,
+ ty: Type,
+ name_const: Path,
+ is_default_128_bit: bool,
+ is_default_256_bit: bool,
+}
+
+/// Parses the `#[factory(...)]` helper attribute off every variant.
+fn parse_factory_variants(data: &DataEnum) -> syn::Result<Vec<FactoryVariant>> {
+ data.variants
+ .iter()
+ .map(|variant| {
+ let ty = single_field_type(variant)?.clone();
+
+ let mut name_const = None;
+ let mut is_default_128_bit = false;
+ let mut is_default_256_bit = false;
+
+ for attr in &variant.attrs {
+ if !attr.path().is_ident("factory") {
+ continue;
+ }
+ attr.parse_nested_meta(|meta| {
+ if meta.path.is_ident("name") {
+ name_const = Some(meta.value()?.parse::<Path>()?);
+ Ok(())
+ } else if meta.path.is_ident("default_128_bit") {
+ is_default_128_bit = true;
+ Ok(())
+ } else if meta.path.is_ident("default_256_bit") {
+ is_default_256_bit = true;
+ Ok(())
+ } else {
+ Err(meta.error(
+ "unrecognized `factory` attribute; expected `name`, \
+ `default_128_bit`, or `default_256_bit`",
+ ))
+ }
+ })?;
+ }
+
+ let name_const = name_const.ok_or_else(|| {
+ syn::Error::new_spanned(
+ variant,
+ "every variant needs `#[factory(name = ...)]` giving its algorithm-name constant",
+ )
+ })?;
+
+ Ok(FactoryVariant {
+ ident: variant.ident.clone(),
+ ty,
+ name_const,
+ is_default_128_bit,
+ is_default_256_bit,
+ })
+ })
+ .collect()
+}

crypto/factory-macros/src/hash.rs

@@ -0,0 +1,87 @@
+//! Expansion for the `Hash` derive -- see the `Hash` entry point in the crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `bouncycastle_core::traits::Hash` impl, forwarding every trait method to the
+/// wrapped value of whichever variant the enum currently holds.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let idents = single_field_variant_idents(as_data_enum(input)?)?;
+
+ Ok(quote! {
+ impl ::bouncycastle_core::traits::Hash for #enum_name {
+ fn block_bitlen(&self) -> usize {
+ match self { #(Self::#idents(h) => h.block_bitlen(),)* }
+ }
+
+ fn output_len(&self) -> usize {
+ match self { #(Self::#idents(h) => h.output_len(),)* }
+ }
+
+ fn hash(self, data: &[u8]) -> Vec<u8> {
+ match self { #(Self::#idents(h) => h.hash(data),)* }
+ }
+
+ fn hash_out(self, data: &[u8], output: &mut [u8]) -> usize {
+ output.fill(0);
+ match self { #(Self::#idents(h) => h.hash_out(data, output),)* }
+ }
+
+ fn do_update(&mut self, data: &[u8]) {
+ match self { #(Self::#idents(h) => h.do_update(data),)* }
+ }
+
+ fn do_final(self) -> Vec<u8> {
+ match self { #(Self::#idents(h) => h.do_final(),)* }
+ }
+
+ fn do_final_out(self, output: &mut [u8]) -> usize {
+ output.fill(0);
+ match self { #(Self::#idents(h) => h.do_final_out(output),)* }
+ }
+
+ fn do_final_partial_bits(
+ self,
+ partial_byte: u8,
+ num_partial_bits: usize,
+ ) -> Result<Vec<u8>, ::bouncycastle_core::errors::HashError> {
+ match self {
+ #(Self::#idents(h) => h.do_final_partial_bits(partial_byte, num_partial_bits),)*
+ }
+ }
+
+ fn do_final_partial_bits_out(
+ self,
+ partial_byte: u8,
+ num_partial_bits: usize,
+ output: &mut [u8],
+ ) -> Result<usize, ::bouncycastle_core::errors::HashError> {
+ match self {
+ #(Self::#idents(h) => {
+ h.do_final_partial_bits_out(partial_byte, num_partial_bits, output)
+ })*
+ }
+ }
+
+ fn max_security_strength(&self) -> ::bouncycastle_core::traits::SecurityStrength {
+ match self { #(Self::#idents(h) => h.max_security_strength(),)* }
+ }
+ }
+ })
+}
+
+/// Collects each variant's ident, rejecting any variant that isn't a single-field tuple since
+/// there would be no unambiguous value to forward the trait methods to.
+fn single_field_variant_idents(data: &DataEnum) -> syn::Result<Vec<Ident>> {
+ data.variants
+ .iter()
+ .map(|v| {
+ single_field_type(v)?;
+ Ok(v.ident.clone())
+ })
+ .collect()
+}

crypto/factory-macros/src/kdf.rs

@@ -0,0 +1,82 @@
+//! Expansion for the `KDF` derive -- see the `KDF` entry point in the crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `bouncycastle_core::traits::KDF` impl, forwarding every trait method to the
+/// wrapped value of whichever variant the enum currently holds.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let idents = single_field_variant_idents(as_data_enum(input)?)?;
+
+ Ok(quote! {
+ impl ::bouncycastle_core::traits::KDF for #enum_name {
+ fn derive_key(
+ self,
+ key: &impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ additional_input: &[u8],
+ ) -> Result<
+ ::std::boxed::Box<dyn ::bouncycastle_core::key_material::KeyMaterialTrait>,
+ ::bouncycastle_core::errors::KDFError,
+ > {
+ match self { #(Self::#idents(h) => h.derive_key(key, additional_input),)* }
+ }
+
+ fn derive_key_out(
+ self,
+ key: &impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ additional_input: &[u8],
+ output_key: &mut impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ ) -> Result<usize, ::bouncycastle_core::errors::KDFError> {
+ match self {
+ #(Self::#idents(h) => h.derive_key_out(key, additional_input, output_key),)*
+ }
+ }
+
+ fn derive_key_from_multiple(
+ self,
+ keys: &[&impl ::bouncycastle_core::key_material::KeyMaterialTrait],
+ additional_input: &[u8],
+ ) -> Result<
+ ::std::boxed::Box<dyn ::bouncycastle_core::key_material::KeyMaterialTrait>,
+ ::bouncycastle_core::errors::KDFError,
+ > {
+ match self {
+ #(Self::#idents(h) => h.derive_key_from_multiple(keys, additional_input),)*
+ }
+ }
+
+ fn derive_key_from_multiple_out(
+ self,
+ keys: &[&impl ::bouncycastle_core::key_material::KeyMaterialTrait],
+ additional_input: &[u8],
+ output_key: &mut impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ ) -> Result<usize, ::bouncycastle_core::errors::KDFError> {
+ match self {
+ #(Self::#idents(h) => {
+ h.derive_key_from_multiple_out(keys, additional_input, output_key)
+ })*
+ }
+ }
+
+ fn max_security_strength(&self) -> ::bouncycastle_core::traits::SecurityStrength {
+ match self { #(Self::#idents(h) => h.max_security_strength(),)* }
+ }
+ }
+ })
+}
+
+/// Collects each variant's ident, rejecting any variant that isn't a single-field tuple since
+/// there would be no unambiguous value to forward the trait methods to.
+fn single_field_variant_idents(data: &DataEnum) -> syn::Result<Vec<Ident>> {
+ data.variants
+ .iter()
+ .map(|v| {
+ single_field_type(v)?;
+ Ok(v.ident.clone())
+ })
+ .collect()
+}

Cargo.toml

@@ -13,6 +13,7 @@ bouncycastle-base64 = { path = "./crypto/base64" }
 bouncycastle-core = { path = "crypto/core" }
 bouncycastle-core-test-framework = { path = "./crypto/core-test-framework" }
 bouncycastle-factory = { path = "./crypto/factory" }
+bouncycastle-factory-macros = { path = "./crypto/factory-macros" }
 bouncycastle-hex = { path = "./crypto/hex" }
 bouncycastle-hkdf = { path = "./crypto/hkdf" }
 bouncycastle-hmac = { path = "./crypto/hmac" }

crypto/factory-macros/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "bouncycastle-factory-macros"
+version.workspace = true
+edition.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { version = "2", features = ["full"] }
+quote = "1"
+proc-macro2 = "1"

crypto/factory-macros/src/factory.rs

@@ -0,0 +1,130 @@
+//! Expansion for the `AlgorithmFactory` derive -- see the `AlgorithmFactory` entry point in the
+//! crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident, Path, Type};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `Default` and `crate::AlgorithmFactory` impls from the per-variant
+/// `#[factory(...)]` attributes.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let variants = parse_factory_variants(as_data_enum(input)?)?;
+
+ let default_128 = variants.iter().find(|v| v.is_default_128_bit);
+ let default_256 = variants.iter().find(|v| v.is_default_256_bit);
+ let (Some(default_128), Some(default_256)) = (default_128, default_256) else {
+ return Err(syn::Error::new_spanned(
+ input,
+ "exactly one variant needs `#[factory(default_128_bit)]` and one needs \
+ `#[factory(default_256_bit)]`",
+ ));
+ };
+ let default_128_ident = &default_128.ident;
+ let default_128_ty = &default_128.ty;
+ let default_256_ident = &default_256.ident;
+ let default_256_ty = &default_256.ty;
+
+ let idents: Vec<&Ident> = variants.iter().map(|v| &v.ident).collect();
+ let tys: Vec<&Type> = variants.iter().map(|v| &v.ty).collect();
+ let name_consts: Vec<&Path> = variants.iter().map(|v| &v.name_const).collect();
+
+ Ok(quote! {
+ impl ::std::default::Default for #enum_name {
+ fn default() -> #enum_name {
+ <#enum_name as crate::AlgorithmFactory>::default_128_bit()
+ }
+ }
+
+ impl crate::AlgorithmFactory for #enum_name {
+ fn default_128_bit() -> #enum_name {
+ Self::#default_128_ident(<#default_128_ty>::new())
+ }
+
+ fn default_256_bit() -> #enum_name {
+ Self::#default_256_ident(<#default_256_ty>::new())
+ }
+
+ fn new(alg_name: &str) -> Result<Self, crate::FactoryError> {
+ match alg_name {
+ crate::DEFAULT => Ok(<Self as ::std::default::Default>::default()),
+ crate::DEFAULT_128_BIT => {
+ Ok(<Self as crate::AlgorithmFactory>::default_128_bit())
+ }
+ crate::DEFAULT_256_BIT => {
+ Ok(<Self as crate::AlgorithmFactory>::default_256_bit())
+ }
+ #(#name_consts => Ok(Self::#idents(<#tys>::new())),)*
+ _ => Err(crate::FactoryError::UnsupportedAlgorithm(format!(
+ "The algorithm: \"{}\" is not a known {}",
+ alg_name,
+ stringify!(#enum_name),
+ ))),
+ }
+ }
+ }
+ })
+}
+
+/// One enum variant's worth of parsed `#[factory(...)]` configuration.
+struct FactoryVariant {
+ ident: Ident,
+ ty: Type,
+ name_const: Path,
+ is_default_128_bit: bool,
+ is_default_256_bit: bool,
+}
+
+/// Parses the `#[factory(...)]` helper attribute off every variant.
+fn parse_factory_variants(data: &DataEnum) -> syn::Result<Vec<FactoryVariant>> {
+ data.variants
+ .iter()
+ .map(|variant| {
+ let ty = single_field_type(variant)?.clone();
+
+ let mut name_const = None;
+ let mut is_default_128_bit = false;
+ let mut is_default_256_bit = false;
+
+ for attr in &variant.attrs {
+ if !attr.path().is_ident("factory") {
+ continue;
+ }
+ attr.parse_nested_meta(|meta| {
+ if meta.path.is_ident("name") {
+ name_const = Some(meta.value()?.parse::<Path>()?);
+ Ok(())
+ } else if meta.path.is_ident("default_128_bit") {
+ is_default_128_bit = true;
+ Ok(())
+ } else if meta.path.is_ident("default_256_bit") {
+ is_default_256_bit = true;
+ Ok(())
+ } else {
+ Err(meta.error(
+ "unrecognized `factory` attribute; expected `name`, \
+ `default_128_bit`, or `default_256_bit`",
+ ))
+ }
+ })?;
+ }
+
+ let name_const = name_const.ok_or_else(|| {
+ syn::Error::new_spanned(
+ variant,
+ "every variant needs `#[factory(name = ...)]` giving its algorithm-name constant",
+ )
+ })?;
+
+ Ok(FactoryVariant {
+ ident: variant.ident.clone(),
+ ty,
+ name_const,
+ is_default_128_bit,
+ is_default_256_bit,
+ })
+ })
+ .collect()
+}

crypto/factory-macros/src/hash.rs

@@ -0,0 +1,87 @@
+//! Expansion for the `Hash` derive -- see the `Hash` entry point in the crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `bouncycastle_core::traits::Hash` impl, forwarding every trait method to the
+/// wrapped value of whichever variant the enum currently holds.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let idents = single_field_variant_idents(as_data_enum(input)?)?;
+
+ Ok(quote! {
+ impl ::bouncycastle_core::traits::Hash for #enum_name {
+ fn block_bitlen(&self) -> usize {
+ match self { #(Self::#idents(h) => h.block_bitlen(),)* }
+ }
+
+ fn output_len(&self) -> usize {
+ match self { #(Self::#idents(h) => h.output_len(),)* }
+ }
+
+ fn hash(self, data: &[u8]) -> Vec<u8> {
+ match self { #(Self::#idents(h) => h.hash(data),)* }
+ }
+
+ fn hash_out(self, data: &[u8], output: &mut [u8]) -> usize {
+ output.fill(0);
+ match self { #(Self::#idents(h) => h.hash_out(data, output),)* }
+ }
+
+ fn do_update(&mut self, data: &[u8]) {
+ match self { #(Self::#idents(h) => h.do_update(data),)* }
+ }
+
+ fn do_final(self) -> Vec<u8> {
+ match self { #(Self::#idents(h) => h.do_final(),)* }
+ }
+
+ fn do_final_out(self, output: &mut [u8]) -> usize {
+ output.fill(0);
+ match self { #(Self::#idents(h) => h.do_final_out(output),)* }
+ }
+
+ fn do_final_partial_bits(
+ self,
+ partial_byte: u8,
+ num_partial_bits: usize,
+ ) -> Result<Vec<u8>, ::bouncycastle_core::errors::HashError> {
+ match self {
+ #(Self::#idents(h) => h.do_final_partial_bits(partial_byte, num_partial_bits),)*
+ }
+ }
+
+ fn do_final_partial_bits_out(
+ self,
+ partial_byte: u8,
+ num_partial_bits: usize,
+ output: &mut [u8],
+ ) -> Result<usize, ::bouncycastle_core::errors::HashError> {
+ match self {
+ #(Self::#idents(h) => {
+ h.do_final_partial_bits_out(partial_byte, num_partial_bits, output)
+ })*
+ }
+ }
+
+ fn max_security_strength(&self) -> ::bouncycastle_core::traits::SecurityStrength {
+ match self { #(Self::#idents(h) => h.max_security_strength(),)* }
+ }
+ }
+ })
+}
+
+/// Collects each variant's ident, rejecting any variant that isn't a single-field tuple since
+/// there would be no unambiguous value to forward the trait methods to.
+fn single_field_variant_idents(data: &DataEnum) -> syn::Result<Vec<Ident>> {
+ data.variants
+ .iter()
+ .map(|v| {
+ single_field_type(v)?;
+ Ok(v.ident.clone())
+ })
+ .collect()
+}

crypto/factory-macros/src/kdf.rs

@@ -0,0 +1,82 @@
+//! Expansion for the `KDF` derive -- see the `KDF` entry point in the crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `bouncycastle_core::traits::KDF` impl, forwarding every trait method to the
+/// wrapped value of whichever variant the enum currently holds.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let idents = single_field_variant_idents(as_data_enum(input)?)?;
+
+ Ok(quote! {
+ impl ::bouncycastle_core::traits::KDF for #enum_name {
+ fn derive_key(
+ self,
+ key: &impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ additional_input: &[u8],
+ ) -> Result<
+ ::std::boxed::Box<dyn ::bouncycastle_core::key_material::KeyMaterialTrait>,
+ ::bouncycastle_core::errors::KDFError,
+ > {
+ match self { #(Self::#idents(h) => h.derive_key(key, additional_input),)* }
+ }
+
+ fn derive_key_out(
+ self,
+ key: &impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ additional_input: &[u8],
+ output_key: &mut impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ ) -> Result<usize, ::bouncycastle_core::errors::KDFError> {
+ match self {
+ #(Self::#idents(h) => h.derive_key_out(key, additional_input, output_key),)*
+ }
+ }
+
+ fn derive_key_from_multiple(
+ self,
+ keys: &[&impl ::bouncycastle_core::key_material::KeyMaterialTrait],
+ additional_input: &[u8],
+ ) -> Result<
+ ::std::boxed::Box<dyn ::bouncycastle_core::key_material::KeyMaterialTrait>,
+ ::bouncycastle_core::errors::KDFError,
+ > {
+ match self {
+ #(Self::#idents(h) => h.derive_key_from_multiple(keys, additional_input),)*
+ }
+ }
+
+ fn derive_key_from_multiple_out(
+ self,
+ keys: &[&impl ::bouncycastle_core::key_material::KeyMaterialTrait],
+ additional_input: &[u8],
+ output_key: &mut impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ ) -> Result<usize, ::bouncycastle_core::errors::KDFError> {
+ match self {
+ #(Self::#idents(h) => {
+ h.derive_key_from_multiple_out(keys, additional_input, output_key)
+ })*
+ }
+ }
+
+ fn max_security_strength(&self) -> ::bouncycastle_core::traits::SecurityStrength {
+ match self { #(Self::#idents(h) => h.max_security_strength(),)* }
+ }
+ }
+ })
+}
+
+/// Collects each variant's ident, rejecting any variant that isn't a single-field tuple since
+/// there would be no unambiguous value to forward the trait methods to.
+fn single_field_variant_idents(data: &DataEnum) -> syn::Result<Vec<Ident>> {
+ data.variants
+ .iter()
+ .map(|v| {
+ single_field_type(v)?;
+ Ok(v.ident.clone())
+ })
+ .collect()
+}

Cargo.toml

@@ -13,6 +13,7 @@ bouncycastle-base64 = { path = "./crypto/base64" }
 bouncycastle-core = { path = "crypto/core" }
 bouncycastle-core-test-framework = { path = "./crypto/core-test-framework" }
 bouncycastle-factory = { path = "./crypto/factory" }
+bouncycastle-factory-macros = { path = "./crypto/factory-macros" }
 bouncycastle-hex = { path = "./crypto/hex" }
 bouncycastle-hkdf = { path = "./crypto/hkdf" }
 bouncycastle-hmac = { path = "./crypto/hmac" }

crypto/factory-macros/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "bouncycastle-factory-macros"
+version.workspace = true
+edition.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { version = "2", features = ["full"] }
+quote = "1"
+proc-macro2 = "1"

crypto/factory-macros/src/factory.rs

@@ -0,0 +1,130 @@
+//! Expansion for the `AlgorithmFactory` derive -- see the `AlgorithmFactory` entry point in the
+//! crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident, Path, Type};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `Default` and `crate::AlgorithmFactory` impls from the per-variant
+/// `#[factory(...)]` attributes.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let variants = parse_factory_variants(as_data_enum(input)?)?;
+
+ let default_128 = variants.iter().find(|v| v.is_default_128_bit);
+ let default_256 = variants.iter().find(|v| v.is_default_256_bit);
+ let (Some(default_128), Some(default_256)) = (default_128, default_256) else {
+ return Err(syn::Error::new_spanned(
+ input,
+ "exactly one variant needs `#[factory(default_128_bit)]` and one needs \
+ `#[factory(default_256_bit)]`",
+ ));
+ };
+ let default_128_ident = &default_128.ident;
+ let default_128_ty = &default_128.ty;
+ let default_256_ident = &default_256.ident;
+ let default_256_ty = &default_256.ty;
+
+ let idents: Vec<&Ident> = variants.iter().map(|v| &v.ident).collect();
+ let tys: Vec<&Type> = variants.iter().map(|v| &v.ty).collect();
+ let name_consts: Vec<&Path> = variants.iter().map(|v| &v.name_const).collect();
+
+ Ok(quote! {
+ impl ::std::default::Default for #enum_name {
+ fn default() -> #enum_name {
+ <#enum_name as crate::AlgorithmFactory>::default_128_bit()
+ }
+ }
+
+ impl crate::AlgorithmFactory for #enum_name {
+ fn default_128_bit() -> #enum_name {
+ Self::#default_128_ident(<#default_128_ty>::new())
+ }
+
+ fn default_256_bit() -> #enum_name {
+ Self::#default_256_ident(<#default_256_ty>::new())
+ }
+
+ fn new(alg_name: &str) -> Result<Self, crate::FactoryError> {
+ match alg_name {
+ crate::DEFAULT => Ok(<Self as ::std::default::Default>::default()),
+ crate::DEFAULT_128_BIT => {
+ Ok(<Self as crate::AlgorithmFactory>::default_128_bit())
+ }
+ crate::DEFAULT_256_BIT => {
+ Ok(<Self as crate::AlgorithmFactory>::default_256_bit())
+ }
+ #(#name_consts => Ok(Self::#idents(<#tys>::new())),)*
+ _ => Err(crate::FactoryError::UnsupportedAlgorithm(format!(
+ "The algorithm: \"{}\" is not a known {}",
+ alg_name,
+ stringify!(#enum_name),
+ ))),
+ }
+ }
+ }
+ })
+}
+
+/// One enum variant's worth of parsed `#[factory(...)]` configuration.
+struct FactoryVariant {
+ ident: Ident,
+ ty: Type,
+ name_const: Path,
+ is_default_128_bit: bool,
+ is_default_256_bit: bool,
+}
+
+/// Parses the `#[factory(...)]` helper attribute off every variant.
+fn parse_factory_variants(data: &DataEnum) -> syn::Result<Vec<FactoryVariant>> {
+ data.variants
+ .iter()
+ .map(|variant| {
+ let ty = single_field_type(variant)?.clone();
+
+ let mut name_const = None;
+ let mut is_default_128_bit = false;
+ let mut is_default_256_bit = false;
+
+ for attr in &variant.attrs {
+ if !attr.path().is_ident("factory") {
+ continue;
+ }
+ attr.parse_nested_meta(|meta| {
+ if meta.path.is_ident("name") {
+ name_const = Some(meta.value()?.parse::<Path>()?);
+ Ok(())
+ } else if meta.path.is_ident("default_128_bit") {
+ is_default_128_bit = true;
+ Ok(())
+ } else if meta.path.is_ident("default_256_bit") {
+ is_default_256_bit = true;
+ Ok(())
+ } else {
+ Err(meta.error(
+ "unrecognized `factory` attribute; expected `name`, \
+ `default_128_bit`, or `default_256_bit`",
+ ))
+ }
+ })?;
+ }
+
+ let name_const = name_const.ok_or_else(|| {
+ syn::Error::new_spanned(
+ variant,
+ "every variant needs `#[factory(name = ...)]` giving its algorithm-name constant",
+ )
+ })?;
+
+ Ok(FactoryVariant {
+ ident: variant.ident.clone(),
+ ty,
+ name_const,
+ is_default_128_bit,
+ is_default_256_bit,
+ })
+ })
+ .collect()
+}

crypto/factory-macros/src/hash.rs

@@ -0,0 +1,87 @@
+//! Expansion for the `Hash` derive -- see the `Hash` entry point in the crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `bouncycastle_core::traits::Hash` impl, forwarding every trait method to the
+/// wrapped value of whichever variant the enum currently holds.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let idents = single_field_variant_idents(as_data_enum(input)?)?;
+
+ Ok(quote! {
+ impl ::bouncycastle_core::traits::Hash for #enum_name {
+ fn block_bitlen(&self) -> usize {
+ match self { #(Self::#idents(h) => h.block_bitlen(),)* }
+ }
+
+ fn output_len(&self) -> usize {
+ match self { #(Self::#idents(h) => h.output_len(),)* }
+ }
+
+ fn hash(self, data: &[u8]) -> Vec<u8> {
+ match self { #(Self::#idents(h) => h.hash(data),)* }
+ }
+
+ fn hash_out(self, data: &[u8], output: &mut [u8]) -> usize {
+ output.fill(0);
+ match self { #(Self::#idents(h) => h.hash_out(data, output),)* }
+ }
+
+ fn do_update(&mut self, data: &[u8]) {
+ match self { #(Self::#idents(h) => h.do_update(data),)* }
+ }
+
+ fn do_final(self) -> Vec<u8> {
+ match self { #(Self::#idents(h) => h.do_final(),)* }
+ }
+
+ fn do_final_out(self, output: &mut [u8]) -> usize {
+ output.fill(0);
+ match self { #(Self::#idents(h) => h.do_final_out(output),)* }
+ }
+
+ fn do_final_partial_bits(
+ self,
+ partial_byte: u8,
+ num_partial_bits: usize,
+ ) -> Result<Vec<u8>, ::bouncycastle_core::errors::HashError> {
+ match self {
+ #(Self::#idents(h) => h.do_final_partial_bits(partial_byte, num_partial_bits),)*
+ }
+ }
+
+ fn do_final_partial_bits_out(
+ self,
+ partial_byte: u8,
+ num_partial_bits: usize,
+ output: &mut [u8],
+ ) -> Result<usize, ::bouncycastle_core::errors::HashError> {
+ match self {
+ #(Self::#idents(h) => {
+ h.do_final_partial_bits_out(partial_byte, num_partial_bits, output)
+ })*
+ }
+ }
+
+ fn max_security_strength(&self) -> ::bouncycastle_core::traits::SecurityStrength {
+ match self { #(Self::#idents(h) => h.max_security_strength(),)* }
+ }
+ }
+ })
+}
+
+/// Collects each variant's ident, rejecting any variant that isn't a single-field tuple since
+/// there would be no unambiguous value to forward the trait methods to.
+fn single_field_variant_idents(data: &DataEnum) -> syn::Result<Vec<Ident>> {
+ data.variants
+ .iter()
+ .map(|v| {
+ single_field_type(v)?;
+ Ok(v.ident.clone())
+ })
+ .collect()
+}

crypto/factory-macros/src/kdf.rs

@@ -0,0 +1,82 @@
+//! Expansion for the `KDF` derive -- see the `KDF` entry point in the crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `bouncycastle_core::traits::KDF` impl, forwarding every trait method to the
+/// wrapped value of whichever variant the enum currently holds.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let idents = single_field_variant_idents(as_data_enum(input)?)?;
+
+ Ok(quote! {
+ impl ::bouncycastle_core::traits::KDF for #enum_name {
+ fn derive_key(
+ self,
+ key: &impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ additional_input: &[u8],
+ ) -> Result<
+ ::std::boxed::Box<dyn ::bouncycastle_core::key_material::KeyMaterialTrait>,
+ ::bouncycastle_core::errors::KDFError,
+ > {
+ match self { #(Self::#idents(h) => h.derive_key(key, additional_input),)* }
+ }
+
+ fn derive_key_out(
+ self,
+ key: &impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ additional_input: &[u8],
+ output_key: &mut impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ ) -> Result<usize, ::bouncycastle_core::errors::KDFError> {
+ match self {
+ #(Self::#idents(h) => h.derive_key_out(key, additional_input, output_key),)*
+ }
+ }
+
+ fn derive_key_from_multiple(
+ self,
+ keys: &[&impl ::bouncycastle_core::key_material::KeyMaterialTrait],
+ additional_input: &[u8],
+ ) -> Result<
+ ::std::boxed::Box<dyn ::bouncycastle_core::key_material::KeyMaterialTrait>,
+ ::bouncycastle_core::errors::KDFError,
+ > {
+ match self {
+ #(Self::#idents(h) => h.derive_key_from_multiple(keys, additional_input),)*
+ }
+ }
+
+ fn derive_key_from_multiple_out(
+ self,
+ keys: &[&impl ::bouncycastle_core::key_material::KeyMaterialTrait],
+ additional_input: &[u8],
+ output_key: &mut impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ ) -> Result<usize, ::bouncycastle_core::errors::KDFError> {
+ match self {
+ #(Self::#idents(h) => {
+ h.derive_key_from_multiple_out(keys, additional_input, output_key)
+ })*
+ }
+ }
+
+ fn max_security_strength(&self) -> ::bouncycastle_core::traits::SecurityStrength {
+ match self { #(Self::#idents(h) => h.max_security_strength(),)* }
+ }
+ }
+ })
+}
+
+/// Collects each variant's ident, rejecting any variant that isn't a single-field tuple since
+/// there would be no unambiguous value to forward the trait methods to.
+fn single_field_variant_idents(data: &DataEnum) -> syn::Result<Vec<Ident>> {
+ data.variants
+ .iter()
+ .map(|v| {
+ single_field_type(v)?;
+ Ok(v.ident.clone())
+ })
+ .collect()
+}

Cargo.toml

@@ -13,6 +13,7 @@ bouncycastle-base64 = { path = "./crypto/base64" }
 bouncycastle-core = { path = "crypto/core" }
 bouncycastle-core-test-framework = { path = "./crypto/core-test-framework" }
 bouncycastle-factory = { path = "./crypto/factory" }
+bouncycastle-factory-macros = { path = "./crypto/factory-macros" }
 bouncycastle-hex = { path = "./crypto/hex" }
 bouncycastle-hkdf = { path = "./crypto/hkdf" }
 bouncycastle-hmac = { path = "./crypto/hmac" }

crypto/factory-macros/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "bouncycastle-factory-macros"
+version.workspace = true
+edition.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { version = "2", features = ["full"] }
+quote = "1"
+proc-macro2 = "1"

crypto/factory-macros/src/factory.rs

@@ -0,0 +1,130 @@
+//! Expansion for the `AlgorithmFactory` derive -- see the `AlgorithmFactory` entry point in the
+//! crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident, Path, Type};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `Default` and `crate::AlgorithmFactory` impls from the per-variant
+/// `#[factory(...)]` attributes.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let variants = parse_factory_variants(as_data_enum(input)?)?;
+
+ let default_128 = variants.iter().find(|v| v.is_default_128_bit);
+ let default_256 = variants.iter().find(|v| v.is_default_256_bit);
+ let (Some(default_128), Some(default_256)) = (default_128, default_256) else {
+ return Err(syn::Error::new_spanned(
+ input,
+ "exactly one variant needs `#[factory(default_128_bit)]` and one needs \
+ `#[factory(default_256_bit)]`",
+ ));
+ };
+ let default_128_ident = &default_128.ident;
+ let default_128_ty = &default_128.ty;
+ let default_256_ident = &default_256.ident;
+ let default_256_ty = &default_256.ty;
+
+ let idents: Vec<&Ident> = variants.iter().map(|v| &v.ident).collect();
+ let tys: Vec<&Type> = variants.iter().map(|v| &v.ty).collect();
+ let name_consts: Vec<&Path> = variants.iter().map(|v| &v.name_const).collect();
+
+ Ok(quote! {
+ impl ::std::default::Default for #enum_name {
+ fn default() -> #enum_name {
+ <#enum_name as crate::AlgorithmFactory>::default_128_bit()
+ }
+ }
+
+ impl crate::AlgorithmFactory for #enum_name {
+ fn default_128_bit() -> #enum_name {
+ Self::#default_128_ident(<#default_128_ty>::new())
+ }
+
+ fn default_256_bit() -> #enum_name {
+ Self::#default_256_ident(<#default_256_ty>::new())
+ }
+
+ fn new(alg_name: &str) -> Result<Self, crate::FactoryError> {
+ match alg_name {
+ crate::DEFAULT => Ok(<Self as ::std::default::Default>::default()),
+ crate::DEFAULT_128_BIT => {
+ Ok(<Self as crate::AlgorithmFactory>::default_128_bit())
+ }
+ crate::DEFAULT_256_BIT => {
+ Ok(<Self as crate::AlgorithmFactory>::default_256_bit())
+ }
+ #(#name_consts => Ok(Self::#idents(<#tys>::new())),)*
+ _ => Err(crate::FactoryError::UnsupportedAlgorithm(format!(
+ "The algorithm: \"{}\" is not a known {}",
+ alg_name,
+ stringify!(#enum_name),
+ ))),
+ }
+ }
+ }
+ })
+}
+
+/// One enum variant's worth of parsed `#[factory(...)]` configuration.
+struct FactoryVariant {
+ ident: Ident,
+ ty: Type,
+ name_const: Path,
+ is_default_128_bit: bool,
+ is_default_256_bit: bool,
+}
+
+/// Parses the `#[factory(...)]` helper attribute off every variant.
+fn parse_factory_variants(data: &DataEnum) -> syn::Result<Vec<FactoryVariant>> {
+ data.variants
+ .iter()
+ .map(|variant| {
+ let ty = single_field_type(variant)?.clone();
+
+ let mut name_const = None;
+ let mut is_default_128_bit = false;
+ let mut is_default_256_bit = false;
+
+ for attr in &variant.attrs {
+ if !attr.path().is_ident("factory") {
+ continue;
+ }
+ attr.parse_nested_meta(|meta| {
+ if meta.path.is_ident("name") {
+ name_const = Some(meta.value()?.parse::<Path>()?);
+ Ok(())
+ } else if meta.path.is_ident("default_128_bit") {
+ is_default_128_bit = true;
+ Ok(())
+ } else if meta.path.is_ident("default_256_bit") {
+ is_default_256_bit = true;
+ Ok(())
+ } else {
+ Err(meta.error(
+ "unrecognized `factory` attribute; expected `name`, \
+ `default_128_bit`, or `default_256_bit`",
+ ))
+ }
+ })?;
+ }
+
+ let name_const = name_const.ok_or_else(|| {
+ syn::Error::new_spanned(
+ variant,
+ "every variant needs `#[factory(name = ...)]` giving its algorithm-name constant",
+ )
+ })?;
+
+ Ok(FactoryVariant {
+ ident: variant.ident.clone(),
+ ty,
+ name_const,
+ is_default_128_bit,
+ is_default_256_bit,
+ })
+ })
+ .collect()
+}

crypto/factory-macros/src/hash.rs

@@ -0,0 +1,87 @@
+//! Expansion for the `Hash` derive -- see the `Hash` entry point in the crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `bouncycastle_core::traits::Hash` impl, forwarding every trait method to the
+/// wrapped value of whichever variant the enum currently holds.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let idents = single_field_variant_idents(as_data_enum(input)?)?;
+
+ Ok(quote! {
+ impl ::bouncycastle_core::traits::Hash for #enum_name {
+ fn block_bitlen(&self) -> usize {
+ match self { #(Self::#idents(h) => h.block_bitlen(),)* }
+ }
+
+ fn output_len(&self) -> usize {
+ match self { #(Self::#idents(h) => h.output_len(),)* }
+ }
+
+ fn hash(self, data: &[u8]) -> Vec<u8> {
+ match self { #(Self::#idents(h) => h.hash(data),)* }
+ }
+
+ fn hash_out(self, data: &[u8], output: &mut [u8]) -> usize {
+ output.fill(0);
+ match self { #(Self::#idents(h) => h.hash_out(data, output),)* }
+ }
+
+ fn do_update(&mut self, data: &[u8]) {
+ match self { #(Self::#idents(h) => h.do_update(data),)* }
+ }
+
+ fn do_final(self) -> Vec<u8> {
+ match self { #(Self::#idents(h) => h.do_final(),)* }
+ }
+
+ fn do_final_out(self, output: &mut [u8]) -> usize {
+ output.fill(0);
+ match self { #(Self::#idents(h) => h.do_final_out(output),)* }
+ }
+
+ fn do_final_partial_bits(
+ self,
+ partial_byte: u8,
+ num_partial_bits: usize,
+ ) -> Result<Vec<u8>, ::bouncycastle_core::errors::HashError> {
+ match self {
+ #(Self::#idents(h) => h.do_final_partial_bits(partial_byte, num_partial_bits),)*
+ }
+ }
+
+ fn do_final_partial_bits_out(
+ self,
+ partial_byte: u8,
+ num_partial_bits: usize,
+ output: &mut [u8],
+ ) -> Result<usize, ::bouncycastle_core::errors::HashError> {
+ match self {
+ #(Self::#idents(h) => {
+ h.do_final_partial_bits_out(partial_byte, num_partial_bits, output)
+ })*
+ }
+ }
+
+ fn max_security_strength(&self) -> ::bouncycastle_core::traits::SecurityStrength {
+ match self { #(Self::#idents(h) => h.max_security_strength(),)* }
+ }
+ }
+ })
+}
+
+/// Collects each variant's ident, rejecting any variant that isn't a single-field tuple since
+/// there would be no unambiguous value to forward the trait methods to.
+fn single_field_variant_idents(data: &DataEnum) -> syn::Result<Vec<Ident>> {
+ data.variants
+ .iter()
+ .map(|v| {
+ single_field_type(v)?;
+ Ok(v.ident.clone())
+ })
+ .collect()
+}

crypto/factory-macros/src/kdf.rs

@@ -0,0 +1,82 @@
+//! Expansion for the `KDF` derive -- see the `KDF` entry point in the crate root.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DataEnum, DeriveInput, Ident};
+
+use crate::{as_data_enum, single_field_type};
+
+/// Generates the `bouncycastle_core::traits::KDF` impl, forwarding every trait method to the
+/// wrapped value of whichever variant the enum currently holds.
+pub(crate) fn expand(input: &DeriveInput) -> syn::Result<TokenStream> {
+ let enum_name = &input.ident;
+ let idents = single_field_variant_idents(as_data_enum(input)?)?;
+
+ Ok(quote! {
+ impl ::bouncycastle_core::traits::KDF for #enum_name {
+ fn derive_key(
+ self,
+ key: &impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ additional_input: &[u8],
+ ) -> Result<
+ ::std::boxed::Box<dyn ::bouncycastle_core::key_material::KeyMaterialTrait>,
+ ::bouncycastle_core::errors::KDFError,
+ > {
+ match self { #(Self::#idents(h) => h.derive_key(key, additional_input),)* }
+ }
+
+ fn derive_key_out(
+ self,
+ key: &impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ additional_input: &[u8],
+ output_key: &mut impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ ) -> Result<usize, ::bouncycastle_core::errors::KDFError> {
+ match self {
+ #(Self::#idents(h) => h.derive_key_out(key, additional_input, output_key),)*
+ }
+ }
+
+ fn derive_key_from_multiple(
+ self,
+ keys: &[&impl ::bouncycastle_core::key_material::KeyMaterialTrait],
+ additional_input: &[u8],
+ ) -> Result<
+ ::std::boxed::Box<dyn ::bouncycastle_core::key_material::KeyMaterialTrait>,
+ ::bouncycastle_core::errors::KDFError,
+ > {
+ match self {
+ #(Self::#idents(h) => h.derive_key_from_multiple(keys, additional_input),)*
+ }
+ }
+
+ fn derive_key_from_multiple_out(
+ self,
+ keys: &[&impl ::bouncycastle_core::key_material::KeyMaterialTrait],
+ additional_input: &[u8],
+ output_key: &mut impl ::bouncycastle_core::key_material::KeyMaterialTrait,
+ ) -> Result<usize, ::bouncycastle_core::errors::KDFError> {
+ match self {
+ #(Self::#idents(h) => {
+ h.derive_key_from_multiple_out(keys, additional_input, output_key)
+ })*
+ }
+ }
+
+ fn max_security_strength(&self) -> ::bouncycastle_core::traits::SecurityStrength {
+ match self { #(Self::#idents(h) => h.max_security_strength(),)* }
+ }
+ }
+ })
+}
+
+/// Collects each variant's ident, rejecting any variant that isn't a single-field tuple since
+/// there would be no unambiguous value to forward the trait methods to.
+fn single_field_variant_idents(data: &DataEnum) -> syn::Result<Vec<Ident>> {
+ data.variants
+ .iter()
+ .map(|v| {
+ single_field_type(v)?;
+ Ok(v.ident.clone())
+ })
+ .collect()
+}