Merge ~mirespace/ubuntu/+source/libmail-dkim-perl:reverting-upstream-debian-ed25519-noble-proposed into ubuntu/+source/libmail-dkim-perl:ubuntu/devel

[Miriam España Acebal]

Hi team,

I'm dropping lybcriptx-perl support (dependencies and related upstream commits) to avoid a component mismatched situation temporarily while packaging New libcrypt-openssl-ed25519-perl package [1]. I'll update the Releases Notes for Noble once this change is accepted.

The patches correspond to this PR in upstream:

https://github.com/fastmail/mail-dkim/pull/18/commits

but, looking into the complete history, you can find these commits where added to a branch created by the maintainer and called "ed25519" which includes two more commits:

https://github.com/fastmail/mail-dkim/commits/ed25519/

The 0006-Revert-*.patch is for undoing the changes related to ed25519 (only those) added by Debian when upgrading the package to version 1.20230630 ( commit message New upstream version 1.20230630) :

https://salsa.debian.org/perl-team/modules/packages/libmail-dkim-perl/-/commit/876974a2c45f2d3ac1c71a4b43b70055fba66f4f

The changes in the code are only adding the use of ed25519, not affecting the use from other third packages of the existing rsa-sha256 algorithm, making a distinction between 'rsa' or 'ed25519' for selecting the correct algorithm.

PPA for this is:

ppa:mirespace/libmail-dkim-perl-no-libcryptx-perl
https://launchpad.net/~mirespace/+archive/ubuntu/libmail-dkim-perl-no-libcryptx-perl

Test passed locally:
autopkgtest [13:55:19]: @@@@@@@@@@@@@@@@@@@@ summary
autodep8-perl-build-deps PASS
autodep8-perl PASS (superficial)
autodep8-perl-recommends PASS (superficial)

Also, they ran in the infra with good results (i386 not passing is known):

https://autopkgtest.ubuntu.com/results/autopkgtest-noble-mirespace-libmail-dkim-perl-no-libcryptx-perl/?format=plain

 ✅ libmail-dkim-perl on noble for amd64 @ 19.02.24 08:59:17
      • Log: https://autopkgtest.ubuntu.com/results/autopkgtest-noble-mirespace-libmail-dkim-perl-no-libcryptx-perl/noble/amd64/libm/libmail-dkim-perl/20240219_085917_d304c@/log.gz

 ✅ libmail-dkim-perl on noble for arm64 @ 19.02.24 09:35:18
      • Log: https://autopkgtest.ubuntu.com/results/autopkgtest-noble-mirespace-libmail-dkim-perl-no-libcryptx-perl/noble/arm64/libm/libmail-dkim-perl/20240219_093518_1a71a@/log.gz

 ✅ libmail-dkim-perl on noble for armhf @ 19.02.24 09:04:19
      • Log: https://autopkgtest.ubuntu.com/results/autopkgtest-noble-mirespace-libmail-dkim-perl-no-libcryptx-perl/noble/armhf/libm/libmail-dkim-perl/20240219_090419_1fb9a@/log.gz

✅ libmail-dkim-perl on noble for ppc64el @ 19.02.24 09:01:02
      • Log: https://autopkgtest.ubuntu.com/results/autopkgtest-noble-mirespace-libmail-dkim-perl-no-libcryptx-perl/noble/ppc64el/libm/libmail-dkim-perl/20240219_090102_81f0d@/log.gz

✅ libmail-dkim-perl on noble for s390x @ 19.02.24 09:19:56
      • Log: https://autopkgtest.ubuntu.com/results/autopkgtest-noble-mirespace-libmail-dkim-perl-no-libcryptx-perl/noble/s390x/libm/libmail-dkim-perl/20240219_091956_7991c@/log.gz

And all building tests passed:

All tests successful.
Files=19, Tests=455, 2 wallclock secs ( 0.08 usr 0.05 sys + 1.43 cusr 0.40 csys = 1.96 CPU)
Result: PASS

Checking spamassassin's tests again this libmail-dkim-perl was also OK:

$ autopkgtest -U -s --add-apt-source="deb [trusted=yes] https://ppa.launchpadcontent.net/mirespace/libmail-dkim-perl-no-libcryptx-perl/ubuntu noble main" spamassassin -- qemu /media/miriam/extension/Images/autopkgtest-noble-amd64.img

[...]
autopkgtest [16:51:09]: @@@@@@@@@@@@@@@@@@@@ summary
spamassassin.nospam PASS
spamassassin.spam PASS
daemon PASS

And looking into the building tests of spamassassin, the dkim test is disabled because it could be flaky due to network issues. But, I manually disabled the net verification (commenting line 19 in t/dkim.t) and I launched the test with the libmail-dkim-perl package proposed here:

All tests successful.
Files=1, Tests=258, 16 wallclock secs ( 0.03 usr 0.02 sys + 3.82 cusr 0.15 csys = 4.02 CPU)
Result: PASS

Complete log at https://pastebin.ubuntu.com/p/gjGdCrB9hF/

Package installed :

root@Nspamassasin-dkim-no-cryptx:~/spamassassin# dpkg -l libmail-dkim-perl | grep dkim
ii libmail-dkim-perl 1.20240124-1ubuntu1+ppa1 all module to cryptographically identify the sender of email

without libcryptx-perl:

root@Nspamassasin-dkim-no-cryptx:~/spamassassin# apt-cache policy libcryptx-perl
libcryptx-perl:
  Installed: (none)
  Candidate: 0.080-2build1
  Version table:
     0.080-2build1 500
        500 http://archive.ubuntu.com/ubuntu noble/universe amd64 Packages

Please, review and sponsor if LGTY. Thanks in advance (also, for your time reviewing this)!

[1] https://bugs.launchpad.net/ubuntu/+source/libcryptx-perl/+bug/2046154/comments/6

[Andreas Hasenack (ahasenack)]

I still have to go over this in more detail, but my first question (and sorry if I missed the answer somewhere), is about the reverse dependencies of libmail-dkim-perl:
$ apt-cache rdepends libmail-dkim-perl
libmail-dkim-perl
Reverse Depends:
  sympa
  amavisd-new
  libmail-dmarc-perl
  spamassassin

What about sympa and amavisd-new, do they indirectly rely on libcryptx-perl, or specifically, on the ed25519 code? Did you also rebuild these reverse dependencies, and their tests?

[Miriam España Acebal (mirespace)]

Hi Andreas!

> I still have to go over this in more detail, but my first question (and sorry
> if I missed the answer somewhere)

Nothing to be sorry about... Maybe I missed this question in the standup :$.

> What about sympa and amavisd-new, do they indirectly rely on libcryptx-perl,
> or specifically, on the ed25519 code? Did you also rebuild these reverse
> dependencies, and their tests?

Good point (as ever) ! I'm on it with the tests and checking the code of those reverse dependencies to look for Mail::Dkim inclusions and calls to any removed code in this MP.

I'll go back to you with the conclusions... thanks Andreas!

[Miriam España Acebal (mirespace)]

TL;DR: Checking that amavisd-new or sympa still work ok when dropping this change: OK

All tested against the package in the ppa.

A. Code Insights: No one of the packages calls directly or indirectly the added (and removed here) code.

In both cases, an 'ack ed25519' search doesn't return anything.

Files modified by these MP are

lib/Mail/DKIM/Signature.pm
lib/Mail/DKIM/Verifier.pm
 -- > Modified functions
       _check_and_verify_signature → private, called by finish_body
lib/Mail/DKIM/PublicKey.pm
lib/Mail/DKIM/Algorithm/ed25519_sha256.pm

A.1. Sympa:

sympa
-------------
❯ ack Mail::DKIM::Signature
❯ ack Mail::DKIM::PublicKey
❯ ack Mail::DKIM::Verifier
cpanfile
182:recommends 'Mail::DKIM::Verifier', '>= 0.37';
272:feature 'Mail::DKIM::Verifier', 'Required in order to use DKIM features (both for signature verification and signature insertion).' => sub {
273: requires 'Mail::DKIM::Verifier', '>= 0.37';

src/lib/Sympa/Message.pm
648: eval 'use Mail::DKIM::Verifier';
655: return unless $Mail::DKIM::Verifier::VERSION;
668: unless ($dkim = Mail::DKIM::Verifier->new()) {
669: $log->syslog('err', 'Could not create Mail::DKIM::Verifier');

Checking Algorithm used is rsa:

❯ ack -C2 Algorithm
src/lib/Sympa/Message.pm
502- # create a signer object
503- my $dkim = Mail::DKIM::Signer->new(
504: Algorithm => "rsa-sha256",
505- Method => "relaxed",
506- Domain => $dkim_d,
--
600- # create a signer object
601- my $arc = Mail::DKIM::ARC::Signer->new(
602: Algorithm => "rsa-sha256",
603- Chain => $arc_cv,
604- SrvId => $arc_srvid,

A.2. amavisd-new:

amavisd-new
-------------------

❯ ack Mail::DKIM::Signature
lib/Amavis/Tools.pm
116: $dkim->add_signature( Mail::DKIM::Signature->new(

lib/Amavis/DKIM.pm
27:use Mail::DKIM::Signature;
336:# returning them as a list of Mail::DKIM::Signature objects
694: $dkim->add_signature( Mail::DKIM::Signature->new(
838: # map a Mail::DKIM::Signature result into an RFC 7601 result value
❯ ack Mail::DKIM::PublicKey
❯ ack Mail::DKIM::Verifier
lib/Amavis.pm
900: Net::Patricia Net::LDAP Mail::SpamAssassin Mail::DKIM::Verifier
6221: if (!defined $dns_resolver && Mail::DKIM::Verifier->VERSION >= 0.40) {
6223: # of Mail::DKIM::Verifier; this avoids repeating initializations
6254: $dkim_verifier = Mail::DKIM::Verifier->new;

lib/Amavis/SpamControl/SpamAssassin.pm
123: push(@modules, qw(Mail::DKIM Mail::DKIM::Verifier Net::DNS::Resolver))

lib/Amavis/Tools.pm
139: my $dkim_verifier = Mail::DKIM::Verifier->new;
140: $dkim_verifier or die "Could not create a Mail::DKIM::Verifier object";

lib/Amavis/DKIM.pm
24:use Mail::DKIM::Verifier 0.31;

Checking Algorithm used is rsa:

❯ ack -C2 Algorithm
lib/Amavis/Tools.pm
116- $dkim->add_signature( Mail::DKIM::Signature->new(
117- Selector => $selector_ace, Domain => $domain_ace,
118: Method => 'simple/simple', Algorithm => 'rsa-sha256',
119- Timestamp => int($now), Expiration => int($now)+24*3600, Key => $key,
120- )); under;

lib/Amavis/DKIM.pm
299-
300-# a CustomSigner callback routine passed to Mail::DKIM in place of a key;
301:# the ro...

[Andreas Hasenack (ahasenack)]

So I'm looking at this, and here are my concerns:

a) complex delta
These patches look like they will be hard to carry forward. Even though we are unlikely to see big changes in noble SRUs, and there they should be more maintainable, this is delta that will be hard to maintain post-noble.

b) we are making a big change to a package
Ed25519 was announced by upstream as part of the 1.20230630 release. Except, in Ubuntu, it's not. configure-like and other version checks might be assuming that after this version, Ed25519 support is there for granted. But not in Ubuntu. In other words, we are deviating quite harshly from upstream and removing a feature they added more than a year ago. Granted, most good such checks will look for the actual feature being present, and not just a version number, but still.

c) there is no guarantee that we will benefit from this work
For this to be complete, we still need the MIR LP: #2023971 to be complete. It's currently in the security review queue, and it might come out from there as a +1 or a -1.

We currently have these versions in noble:

 libmail-dkim-perl | 1.20230212-1 | noble | source
 libmail-dkim-perl | 1.20240124-1 | noble-proposed | source

The upstream change that added Ed25519 support is in 1.20230630, which mean it's *NOT* in noble release at the moment, only noble-proposed.

I propose that we kick out 1.20240124-1 from noble-proposed, and keep the one in noble-release. We can either add this package to the sync-blocklist[1], or upload a no-change rebuild with an ubuntu suffix to block it from syncing that way. I seem to remember there was a discussion on a suitable suffix for such changes, something like adding "maysync" or similar. We can find that, I think it was used recently in an MP in the server team even, for dns root data?

Yes:

 dns-root-data | 2023112702~willsync1 | noble | source, all

But maybe for now, just before FF, we should add a block to it, just to be safe. Although, if we do nothing, it will just stay in proposed without migrating...

Now, if there is something in newer libmail-dkim-perl that we want, maybe the plan above doesn't work so well. Or we could cherry-pick what we want that is in newer versions only.

So, what do you think?

1. https://code.launchpad.net/~ubuntu-archive/+git/sync-blocklist

review: Needs Information

[Miriam España Acebal (mirespace)]

Thanks Andreas!

It makes perfect sense for a user to trust that a new package version will come with all the features announced upstream.... thanks for bringing up this point.

I checked spamassassin versions and we are in 4.0.0 since Mantic, so new features that can come in -proposed libmail-dkim-perl version are not in use yet:

 spamassassin | 3.4.6-1ubuntu0.22.04.1 | jammy-updates | source, all
 spamassassin | 4.0.0-7ubuntu1 | mantic | source, all
 spamassassin | 4.0.0-8ubuntu1 | noble | source, all

for libmail-dmar-perl is the same case:

 libmail-dmarc-perl | 1.20230215-1 | mantic/universe | source, all
 libmail-dmarc-perl | 1.20230215-1 | noble/universe | source, all

Only for the records, the changes that come with the dkim -proposed version are:

1.20240124 2024-01-24 UTC
  * ARC: Return fail for any ARC set with an instance number greater than 50.
    This brings ARC verification in line with DKIM verification limits.

1.20230911 2023-09-11 UTC
  * Option to add custom tags to generated ARC signatures and seals

1.20230630 2023-06-30 UTC
  * Add support for Ed25519 signature types
    Thanks to Matthäus Wander @mwander
  * Option to add custom tags to generated signatures

So I'm okay with adding libmail-dkim-perl to the sync-blocklist.

[Andreas Hasenack (ahasenack)]

Ok, the "maysync" or "willsync" ideas don't apply here, because the version in noble is way lower then debian unstable:

1.20230212-1 vs 1.20240124-1

Also, the sync blocklist is meant for more permanent blocks, and I don't think we will want to block this package forever.

So my suggestion is, if we all agree on this plan, to:

- remove libmail-dkim-perl 1.20240124-1 from noble-proposed
- prepare and upload libmail-dkim-perl 1.20230212-1ubuntu1 with no changes. The "ubuntu1" suffix will block it from syncing

[Miriam España Acebal (mirespace)]

MP for blocking is here: https://code.launchpad.net/~mirespace/+git/sync-blocklist/+merge/461273
(I didn't say anything in #ubuntu-release yet; I am waiting for comments from Christian)

[Christian Ehrhardt  (paelzer)]

Thanks Andreas, this really is a much more maintainable approach to this.
The current version as it is not too old but would get the rest of the stack resolved.
I'd be ok on either sync-blockist or delta to avoid a sync.

I'm already +0.99 on this, but let me ask one crucial question though...

The intent originally was to add back Ed25519 once we managed to create a wrapper we'd trust.
But if we now hold back 1.20240124-1, we'd have a much bigger change to "later add Ed25519".
As we'd then need to go to "at least 1.20230630 for the general infrastructure and then adopt it to use the alternative library for that encryption.

So we'd buy an easier current time, for a more complex future.

Yet OTOH the success, acceptance and all that of the to be created wrapper isn't entirely certain.
We are not taking away anything, it is already without Ed25519, no loss on upgrade. We'd just have that feature later.

And while intention is well meant - there still is the chance we need to decide later, "yeah Ed25519 will only be added in 24.10 but not backported".

With that in mind I'm adding another +0.01 for not spending effort now which might end up being totally different than we thought.

Objections after I forced that thought to be present in your mind?

[Miriam España Acebal (mirespace)]

Hi Andreas, Christian:

Adding here the third scenario (blocking by suffix):

https://code.launchpad.net/~mirespace/ubuntu/+source/libmail-dkim-perl/+git/libmail-dkim-perl/+merge/461344

As the sync-blocklist MP.

Both are in WIP, but ready. If I'm OOO after the decision on this is taken, feel free to mark Needs Review and Approve/Reject depending on the taken decision.

About the complexity in the long-term: how feasible would it be to upgrade to a new version of this package with new features in noble as LTS? It sounds like we would need a SRU exception for only once... Oh, I forgot Robie's comment (https://bugs.launchpad.net/ubuntu/+source/libcryptx-perl/+bug/2046154/comments/7)... so, at the end, What will the way more compatible to do the SRU to noble later?

1- This MP, removing all the patches and restoring the dependency in d/control as SRU?
2- removing the package from sync-blocklist, and doing a "sync-SRU"?
3- removing the suffix as SRU-change, and sync automatically in MM and "SRU-sync" to noble?

I don't know if a sync to a GA LTS can be done, hence my questions.

[Andreas Hasenack (ahasenack)]

> About the complexity in the long-term: how feasible would it be to upgrade to a new version of this
> package with new features

We don't have to upgrade, we can patch the ed25519 support in. Basically the revert of you patches here.

It's still a new feature, of course, and one could argue it's a delta as complicated as the one here dropping the patches. So updating the version might be less risky. Both scenarios, however, will require an FFe for noble. Personally, I would prefer upgrading to 1.20240124-1 when the time comes.

So let's think about the scenarios:

a) Proceed as planned with this MP, which means:
- remove Ed25519 support from src:libmail-dkim-perl now, and upload
- that will make src:libmail-dkim-perl migrate
- feature freeze happens without Ed25519 support

Then:
- fingers crossed that security ACKs MIR LP: #2023971 for src:libmail-dmarc-perl
- the Ed25519 perl+openssl wrapper happens, passes NEW review, goes into noble
- we restore Ed25519 support in src:libmail-dkim-perl by dropping these patches, get an FFe, upload to noble
- change src:spamassassin to again recommend (instead of suggest) bin:libmail-dmarc-perl (its MIR was supposedly accepted above)

b) Revert to src:libmail-dkim-perl 1.20230212 in noble, without Ed25519 support
- remove src:libmail-dkim-perl 1.20240124-1 from noble-proposed
- upload src:libmail-dkim-perl 1.20230212-1ubuntu to block syncs
- feature freeze happens without Ed25519 support

Then:
- fingers crossed that security ACKs MIR LP: #2023971 for src:libmail-dmarc-perl
- the Ed25519 perl+openssl wrapper happens, passes NEW review, goes into noble
- we restore Ed25519 support in src:libmail-dkim-perl. Either updating to 1.20240124, or patching Ed25519 in taken from the 1.20230630 version. FFe required
- change src:spamassassin to again recommend (instead of suggest) bin:libmail-dmarc-perl (its MIR was supposedly accepted above)

So.

If all goes to plan, in *both* cases we will need a FFe for src:libmail-dkim-perl with the Ed25519 feature put back, either via a patch, or a version bump to at least 1.20230630, or preferably (just because it's the sync from debian) 1.20240124-1.

If something fails along the way (MIR is not granted for src:libmail-dmarc-perl, or the new openssl ed25519 perl wrapper doesn't happen in time, or is not reviewed in NEW in time, etc), then we have differences.

In the failed (a) case, we will have in noble a src:libmail-dkim-perl package with Ed25519 patched out. That delta is unlikely to apply cleanly on version upgrades, but that shouldn't happen in noble SRUs. This has the "unexpected" feeling (to me) of a newer version of a package with a feature dropped by us as a delta. If we manage to unfail things after noble was released, an SRU would just remove that patch, and by that, add a new feature.

In the failed (b) case, we will have in noble a normal src:libmail-dkim-perl package, just behind debian, without Ed25519. After we "unfail" this, the SRU would be to add a feature by either adding ed25519 via patches, or bumping the version. This might be psychological, but personally I feel that removing patches has less risk than adding them, or bumping the version.

If we...

[Andreas Hasenack (ahasenack)]

Let's take a look at the patches, while we are at it (inline).

[Andreas Hasenack (ahasenack)]

Oh, and after looking more closely at the reverts, and I think I haven't mentioned this before: there is risk in us missing something in these reverts, or later, miss something if we decide to patch ed25519 back in (instead of bumping the version).

[Miriam España Acebal (mirespace)]

I understand completely that the patches way could be more risky and are ugly/tedious/horrible/madness to inspection.

(ofi) I did the patches 1-5 with git format-patch -5 HEAD from marcbrashaw/ed25519 (upstream/ed25519) branch, I didn't do it manually

[Andreas Hasenack (ahasenack)]

We decided to go with (b) and drop[1] libmail-dkim-perl 1.20240124-1 from noble-proposed.

1. https://bugs.launchpad.net/ubuntu/+source/libmail-dkim-perl/+bug/2055198

[Andreas Hasenack (ahasenack)]

review: Disapprove

Unmerged commits

4844d33... by Miriam España Acebal on 2024-02-16

changelog

e23ee2c... by Miriam España Acebal on 2024-02-16

update-maintainer

9b1b276... by Miriam España Acebal on 2024-02-16

d/control: Dropping libcryptc-perl dependency.

f5552de... by Miriam España Acebal on 2024-02-16

d/p/0006-Revert-*.patch: Reverting changes applied by debian to support ed25519

959e0c1... by Miriam España Acebal on 2024-02-16

d/patches/*-Revert-*.patch: Dropping ed25519 support while replacing
    using of libcryptx-perl as dependency. Reverting upstream changes.

diff --git a/debian/changelog b/debian/changelog
index 4a792c5..edafb42 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,12 @@
+libmail-dkim-perl (1.20240124-1ubuntu1) noble; urgency=medium
+
+  * d/patches/*-Revert-*.patch: Drop ed25519 support while replacing
+    the use of libcryptx-perl as dependency. Revert upstream and debian
+    changes due to that (LP: #2046154).
+  * d/control: Drop libcryptx-perl dependency.
+
+ -- Miriam España Acebal <[e-mail]>  Fri, 16 Feb 2024 13:20:59 +0100
+
 libmail-dkim-perl (1.20240124-1) unstable; urgency=medium
 
   * Team upload.
diff --git a/debian/control b/debian/control
index 9c1240c..9bf4a65 100644
--- a/debian/control
+++ b/debian/control
@@ -1,12 +1,12 @@
 Source: libmail-dkim-perl
-Maintainer: Debian Perl Group <[e-mail]>
+Maintainer: Ubuntu Developers <[e-mail]>
+XSBC-Original-Maintainer: Debian Perl Group <[e-mail]>
 Uploaders: Magnus Holmgren <[e-mail]>
 Section: perl
 Testsuite: autopkgtest-pkg-perl
 Priority: optional
 Build-Depends: debhelper-compat (= 13)
 Build-Depends-Indep: libcrypt-openssl-rsa-perl <!nocheck>,
-                     libcryptx-perl <!nocheck>,
                      libdigest-sha-perl <!nocheck>,
                      liberror-perl <!nocheck>,
                      libmail-authenticationresults-perl <!nocheck>,
@@ -27,7 +27,6 @@ Architecture: all
 Depends: ${misc:Depends},
          ${perl:Depends},
          libcrypt-openssl-rsa-perl,
-         libcryptx-perl,
          libdigest-sha-perl,
          liberror-perl,
          libgetopt-long-descriptive-perl,
diff --git a/debian/patches/0001-Revert-Ed25519-Add-test-for-missing-public-key.patch b/debian/patches/0001-Revert-Ed25519-Add-test-for-missing-public-key.patch
 new file mode 100644
index 0000000..71b97c9
--- /dev/null
+++ b/debian/patches/0001-Revert-Ed25519-Add-test-for-missing-public-key.patch
@@ -0,0 +1,94 @@
+From d7cd937e612f44d8862999f4a8894384ac8eb8c1 Mon Sep 17 00:00:00 2001
+From: Miriam Espana Acebal <[e-mail]>
+Date: Fri, 16 Feb 2024 13:11:48 +0100
+Subject: [PATCH 1/5] Revert "Ed25519: Add test for missing public key"
+
+This reverts commit 1d37a260ec2090aaccb3bbe6bb668d7ca1569836.
+---
+ t/FAKE_DNS.dat               |  1 -
+ t/corpus/badkey4_ed25519.txt | 16 ----------------
+ t/corpus/badkey5_ed25519.txt | 16 ----------------
+ t/verifier.t                 |  4 +---
+ 4 files changed, 1 insertion(+), 36 deletions(-)
+ delete mode 100644 t/corpus/badkey4_ed25519.txt
+ delete mode 100644 t/corpus/badkey5_ed25519.txt
+
+diff --git a/t/FAKE_DNS.dat b/t/FAKE_DNS.dat
+index 602c13b..22e24da 100644
+--- a/t/FAKE_DNS.dat
++++ b/t/FAKE_DNS.dat
+@@ -25,5 +25,4 @@ nonexistent._domainkey.messiah.edu NXDOMAIN
+ test3._domainkey.blackhole.messiah.edu ~~Query timed out~~
+ test3._domainkey.blackhole2.messiah.edu ~~SERVFAIL~~
+ 2023-05-ed25519._domainkey.wander.science  v=DKIM1; k=ed25519; p=pP+YUyRjAvKha4Oc49KAY703oLUS1NLMEuGD3IHMKww=
+-2023-05-ed25519-empty._domainkey.wander.science  ""
+ invalid._domainkey.wander.science  v=DKIM1; k=ed25519; p=MCowBQYDK2VwAyEA3SUqa9UbfciWkk7tlcJ9P1VD5pXAasg0JUn/OgjVbKE=
+diff --git a/t/corpus/badkey4_ed25519.txt b/t/corpus/badkey4_ed25519.txt
+deleted file mode 100644
+index 4693bc2..0000000
+--- a/t/corpus/badkey4_ed25519.txt
++++ /dev/null
+@@ -1,16 +0,0 @@
+-DKIM-Signature: v=1; a=ed25519-sha256; q=dns/txt; c=relaxed/relaxed;
+-	d=wander.science; s=2023-05-ed25519-does-not-exist; h=Subject:Content-Transfer-Encoding:
+-	Content-Type:From:To:MIME-Version:Date:Message-ID:In-Reply-To:Cc:References:
+-	Sender:Reply-To; bh=P//FppzGgSSJDjYgpnZ255T9+DxXvu14MiedTEyE5UY=; b=85mI8hH/s
+-	TYf2w8vAF3BKeRs/7EMD8yGrrekJNcoZ8LxDd3RnpejvsG43I6vryFIx6xFmVSx65+zmxXu9/kvDg
+-	==;
+-Message-ID: <[e-mail]>
+-Date: Wed, 10 May 2023 21:54:21 +0200
+-MIME-Version: 1.0
+-To: [e-mail]
+-From: [e-mail]
+-Content-Type: text/plain; charset=UTF-8; format=flowed
+-Content-Transfer-Encoding: 7bit
+-Subject: Test ed25519
+-
+-This is an elliptic test, with a missing key.
+diff --git a/t/corpus/badkey5_ed25519.txt b/t/corpus/badkey5_ed25519.txt
+deleted file mode 100644
+index f60f504..0000000
+--- a/t/corpus/badkey5_ed25519.txt
++++ /dev/null
+@@ -1,16 +0,0 @@
+-DKIM-Signature: v=1; a=ed25519-sha256; q=dns/txt; c=relaxed/relaxed;
+-	d=wander.science; s=2023-05-ed25519-empty; h=Subject:Content-Transfer-Encoding:
+-	Content-Type:From:To:MIME-Version:Date:Message-ID:In-Reply-To:Cc:References:
+-	Sender:Reply-To; bh=P//FppzGgSSJDjYgpnZ255T9+DxXvu14MiedTEyE5UY=; b=85mI8hH/s
+-	TYf2w8vAF3BKeRs/7EMD8yGrrekJNcoZ8LxDd3RnpejvsG43I6vryFIx6xFmVSx65+zmxXu9/kvDg
+-	==;
+-Message-ID: <[e-mail]>
+-Date: Wed, 10 May 2023 21:54:21 +0200
+-MIME-Version: 1.0
+-To: [e-mail]
+-From: [e-mail]
+-Content-Type: text/plain; charset=UTF-8; format=flowed
+-Content-Transfer-Encoding: 7bit
+-Subject: Test ed25519
+-
+-This is an elliptic test, with a missing key.
+diff --git a/t/verifier.t b/t/verifier.t
+index 3f802c9..90320d4 100755
+--- a/t/verifier.t
++++ b/t/verifier.t
+@@ -2,7 +2,7 @@
+ 
+ use strict;
+ use warnings;
+-use Test::More tests => 111;
++use Test::More tests => 109;
+ 
+ use Mail::DKIM::Verifier;
+ 
+@@ -167,8 +167,6 @@ test_email( "goodkey_ed25519.txt", "pass" );
+ test_email( "badkey1_ed25519.txt", "invalid" ); # key has invalid length
+ test_email( "badkey2_ed25519.txt", "fail" ); # header modified
+ test_email( "badkey3_ed25519.txt", "fail" ); # body modified
+-test_email( "badkey4_ed25519.txt", "invalid" ); # missing key
+-test_email( "badkey5_ed25519.txt", "invalid" ); # empty key
+ 
+ sub read_file {
+     my $srcfile = shift;
+-- 
+2.40.1
+
diff --git a/debian/patches/0002-Revert-Refactor-and-cleanup-some-ed25519-code.patch b/debian/patches/0002-Revert-Refactor-and-cleanup-some-ed25519-code.patch
 new file mode 100644
index 0000000..10aeb9d
--- /dev/null
+++ b/debian/patches/0002-Revert-Refactor-and-cleanup-some-ed25519-code.patch
@@ -0,0 +1,496 @@
+From 3d65013b6cc172343354bfa33e59330b9b44ee57 Mon Sep 17 00:00:00 2001
+From: Miriam Espana Acebal <[e-mail]>
+Date: Fri, 16 Feb 2024 13:15:07 +0100
+Subject: [PATCH 2/5] Revert "Refactor and cleanup some ed25519 code"
+
+This reverts commit 86f65f4e6d7b99e759de2ea23c56e16b5e76ab15.
+---
+ Changes                                   |   2 -
+ lib/Mail/DKIM/Algorithm/ed25519_sha256.pm |   4 +-
+ lib/Mail/DKIM/PrivateKey.pm               | 161 ++++++++++----------
+ lib/Mail/DKIM/PublicKey.pm                | 175 ++++++++++------------
+ 4 files changed, 163 insertions(+), 179 deletions(-)
+
+diff --git a/Changes b/Changes
+index f898dc5..39b645a 100644
+--- a/Changes
++++ b/Changes
+@@ -8,8 +8,6 @@ This file summarizes what's changed between releases of Mail-DKIM.
+   * Option to add custom tags to generated ARC signatures and seals
+ 
+ 1.20230630 2023-06-30 UTC
+-  * Add support for Ed25519 signature types
+-    Thanks to  Matthäus Wander @mwander
+   * Option to add custom tags to generated signatures
+ 
+ 1.20230212 2023-02-12 UTC
+diff --git a/lib/Mail/DKIM/Algorithm/ed25519_sha256.pm b/lib/Mail/DKIM/Algorithm/ed25519_sha256.pm
+index 9a4a2f3..d97deeb 100644
+--- a/lib/Mail/DKIM/Algorithm/ed25519_sha256.pm
++++ b/lib/Mail/DKIM/Algorithm/ed25519_sha256.pm
+@@ -1,8 +1,8 @@
+ package Mail::DKIM::Algorithm::ed25519_sha256;
+ use strict;
+ use warnings;
+-our $VERSION = '1.20240124'; # VERSION
+-# ABSTRACT: ed25519 sha256 algorithm class
++# VERSION
++# ABSTRACT: edd2519 sha256 algorithm class
+ 
+ # Copyright 2005-2006 Messiah College. All rights reserved.
+ # Jason Long <[e-mail]>
+diff --git a/lib/Mail/DKIM/PrivateKey.pm b/lib/Mail/DKIM/PrivateKey.pm
+index af08573..1a9526d 100644
+--- a/lib/Mail/DKIM/PrivateKey.pm
++++ b/lib/Mail/DKIM/PrivateKey.pm
+@@ -15,8 +15,6 @@ our $VERSION = '1.20240124'; # VERSION
+ use base 'Mail::DKIM::Key';
+ use Carp;
+ *calculate_EM = \&Mail::DKIM::Key::calculate_EM;
+-use Crypt::OpenSSL::RSA;
+-use Crypt::PK::Ed25519;
+ 
+ 
+ sub load {
+@@ -53,86 +51,88 @@ sub load {
+ }
+ 
+ 
+-sub _convert_rsa {
++sub convert {
+     my $self = shift;
+ 
+-    # have to PKCS1ify the privkey because openssl is too finicky...
+-    my $pkcs = "-----BEGIN RSA PRIVATE KEY-----\n";
+-
+-    for ( my $i = 0 ; $i < length $self->data ; $i += 64 ) {
+-        $pkcs .= substr $self->data, $i, 64;
+-        $pkcs .= "\n";
++    # Use different libs subject to key type.
++    if ( $self->{'TYPE'} eq 'rsa' ) {
++        use Crypt::OpenSSL::RSA;
++    }
++    elsif ( $self->{'TYPE'} eq 'ed25519' ) {
++        use Crypt::PK::Ed25519;
+     }
+ 
+-    $pkcs .= "-----END RSA PRIVATE KEY-----\n";
++    $self->data
++      or return;
++
++    if ( $self->{'TYPE'} eq 'rsa' ) {
++
++        # have to PKCS1ify the privkey because openssl is too finicky...
++        my $pkcs = "-----BEGIN RSA PRIVATE KEY-----\n";
++
++        for ( my $i = 0 ; $i < length $self->data ; $i += 64 ) {
++            $pkcs .= substr $self->data, $i, 64;
++            $pkcs .= "\n";
++        }
++
++        $pkcs .= "-----END RSA PRIVATE KEY-----\n";
+ 
+-    my $cork;
++        my $cork;
+ 
+-    eval {
+-        local $SIG{__DIE__};
+-        $cork = new_private_key Crypt::OpenSSL::RSA($pkcs);
+-    1
+-    } || do {
++        eval {
++            local $SIG{__DIE__};
++            $cork = new_private_key Crypt::OpenSSL::RSA($pkcs);
++        1
++        } || do {
+         $self->errorstr($@);
+         return;
+-    };
++        };
+ 
+-    $cork
+-      or return;
++        $cork
++          or return;
+ 
+-    # segfaults on my machine
+-    #	$cork->check_key or
+-    #		return;
++        # segfaults on my machine
++        #	$cork->check_key or
++        #		return;
+ 
+-    $self->cork($cork);
+-    return 1;
+-}
++        $self->cork($cork);
+ 
+-sub _convert_ed25519 {
+-    my $self = shift;
+-    my $cork;
++    }
++    elsif ( $self->{'TYPE'} eq 'ed25519' ) {
++        my $cork;
+ 
+-    eval {
+-        local $SIG{__DIE__};
+-        $cork = new Crypt::PK::Ed25519;
++        eval {
++            local $SIG{__DIE__};
++            $cork = new Crypt::PK::Ed25519;
+ 
+-        # Prepend/append with PEM boilerplate
+-        my $pem = "-----BEGIN ED25519 PRIVATE KEY-----\n";
+-        $pem .= $self->data;
+-        $pem .= "\n";
+-        $pem .= "-----END ED25519 PRIVATE KEY-----\n";
++            # Prepend/append with PEM boilerplate
++            my $pem = "-----BEGIN ED25519 PRIVATE KEY-----\n";
++            $pem .= $self->data;
++            $pem .= "\n";
++            $pem .= "-----END ED25519 PRIVATE KEY-----\n";
+ 
+-        # Pass PEM text buffer
+-        $cork->import_key(\$pem)
+-            or die 'failed to load Ed25519 private key';
++            # Pass PEM text buffer
++            $cork->import_key(\$pem)
++                or die 'failed to load Ed25519 private key';
+ 
+-        # Alternatively, import_raw_key() could be used,
+-        # but requires the 32-byte key, which must be extracted
+-        # from the ASN.1 structure first.
++            # Alternatively, import_raw_key() could be used,
++            # but requires the 32-byte key, which must be extracted
++            # from the ASN.1 structure first.
+ 
+-    1
+-    } || do {
+-        $self->errorstr($@);
+-        return;
+-    };
++        1
++        } || do {
++            $self->errorstr($@);
++            return;
++        };
+ 
+-    $cork
+-      or return;
++        $cork
++          or return;
+ 
+-    $self->cork($cork);
+-    return 1;
+-}
++        $self->cork($cork);
+ 
+-sub convert {
+-    my $self = shift;
+-
+-    $self->data
+-      or return;
++    }
+ 
+-    return $self->_convert_rsa if $self->{TYPE} eq 'rsa';
+-    return $self->_convert_ed25519 if $self->{TYPE} eq 'ed25519';
+-    self->errorstr('unsupported key type');
+-    return;
++    return 1;
+ }
+ 
+ #deprecated
+@@ -151,36 +151,31 @@ sub sign_sha1_digest {
+ }
+ 
+ 
+-sub _sign_digest_rsa {
++sub sign_digest {
+     my $self = shift;
+     my ( $digest_algorithm, $digest ) = @_;
+ 
+-    my $rsa_priv = $self->cork;
+-    $rsa_priv->use_no_padding;
+-    my $k = $rsa_priv->size;
+-    my $EM = calculate_EM( $digest_algorithm, $digest, $k );
+-    return $rsa_priv->decrypt($EM);
+-}
++    if ( $self->{'TYPE'} eq 'rsa') {
+ 
+-sub _sign_digest_ed25519 {
+-    my $self = shift;
+-    my ( $digest_algorithm, $digest ) = @_;
++        my $rsa_priv = $self->cork;
++        $rsa_priv->use_no_padding;
++
++        my $k = $rsa_priv->size;
++        my $EM = calculate_EM( $digest_algorithm, $digest, $k );
++        return $rsa_priv->decrypt($EM);
+ 
+-    my $ed = $self->cork;
+-    if ( !$ed ) {
+-        $@ = $@ ne '' ? "Ed25519 failed: $@" : 'Ed25519 unknown problem';
+-        die;
+     }
+-    return $ed->sign_message($digest);
+-}
++    elsif ( $self->{'TYPE'} eq 'ed25519' ) {
+ 
+-sub sign_digest {
+-    my $self = shift;
+-    my ( $digest_algorithm, $digest ) = @_;
++        my $ed = $self->cork;
++        if ( !$ed ) {
++            $@ = $@ ne '' ? "Ed25519 failed: $@" : 'Ed25519 unknown problem';
++            die;
++        }
+ 
+-    return $self->_sign_digest_rsa($digest_algorithm, $digest) if $self->{TYPE} eq 'rsa';
+-    return $self->_sign_digest_ed25519($digest_algorithm, $digest) if $self->{TYPE} eq 'ed25519';
+-    die 'unsupported key type';
++        return $ed->sign_message($digest);
++
++    }
+ }
+ 
+ __END__
+diff --git a/lib/Mail/DKIM/PublicKey.pm b/lib/Mail/DKIM/PublicKey.pm
+index bbae0e7..bd45aeb 100644
+--- a/lib/Mail/DKIM/PublicKey.pm
++++ b/lib/Mail/DKIM/PublicKey.pm
+@@ -14,9 +14,6 @@ our $VERSION = '1.20240124'; # VERSION
+ use base ( 'Mail::DKIM::KeyValueList', 'Mail::DKIM::Key' );
+ *calculate_EM = \&Mail::DKIM::Key::calculate_EM;
+ 
+-use Crypt::OpenSSL::RSA;
+-use Crypt::PK::Ed25519;
+-use MIME::Base64;
+ use Mail::DKIM::DNS;
+ 
+ sub new {
+@@ -102,7 +99,7 @@ sub fetch_async {
+         my $self = $class->parse($strn);
+         $self->{Selector} = $prms{'Selector'};
+         $self->{Domain}   = $prms{'Domain'};
+-        $self->{TYPE}     = $self->get_tag('k') || 'rsa';
++        $self->{TYPE}     = ( $self->get_tag('k') or 'rsa' );
+         $self->check;
+ 
+         return $on_success->($self);
+@@ -284,54 +281,57 @@ sub check_hash_algorithm {
+ # Create an OpenSSL public key object from the Base64-encoded data
+ # found in this public key's DNS record. The OpenSSL object is saved
+ # in the "cork" property.
+-sub _convert_rsa {
++sub convert {
+     my $self = shift;
+-    # have to PKCS1ify the pubkey because openssl is too finicky...
+-    my $cert = "-----BEGIN PUBLIC KEY-----\n";
+ 
+-    for ( my $i = 0 ; $i < length $self->data ; $i += 64 ) {
+-        $cert .= substr $self->data, $i, 64;
+-        $cert .= "\n";
++    # Use different libs subject to k= tag.
++    # Without k= tag, default to RSA to maintain prior behavior
++    my $k = ( $self->get_tag('k') or 'rsa' );
++    if ( $k eq 'rsa' ) {
++        use Crypt::OpenSSL::RSA;
++    }
++    elsif ( $k eq 'ed25519' ) {
++        use Crypt::PK::Ed25519;
++        use MIME::Base64;
+     }
+ 
+-    $cert .= "-----END PUBLIC KEY-----\n";
++    $self->data
++      or return;
+ 
+-    my $cork = Crypt::OpenSSL::RSA->new_public_key($cert)
+-      or die 'unable to generate public key object';
++    if ( $k eq 'rsa' ) {
++        # have to PKCS1ify the pubkey because openssl is too finicky...
++        my $cert = "-----BEGIN PUBLIC KEY-----\n";
+ 
+-    # segfaults on my machine
+-    #	$cork->check_key or
+-    #		return;
++        for ( my $i = 0 ; $i < length $self->data ; $i += 64 ) {
++            $cert .= substr $self->data, $i, 64;
++            $cert .= "\n";
++        }
+ 
+-    $self->cork($cork);
+-    return 1;
+-}
++        $cert .= "-----END PUBLIC KEY-----\n";
+ 
+-sub _convert_ed25519 {
+-    my $self = shift;
+-    my $cork = Crypt::PK::Ed25519->new
+-      or die 'unable to generate Ed25519 public key object';
++        my $cork = Crypt::OpenSSL::RSA->new_public_key($cert)
++          or die 'unable to generate public key object';
+ 
+-    my $keybin = decode_base64($self->data);
+-    $cork->import_key_raw($keybin, 'public')
+-      or die 'failed to load Ed25519 public key';
++        # segfaults on my machine
++        #	$cork->check_key or
++        #		return;
+ 
+-    $self->cork($cork);
+-    return 1;
+-}
++        $self->cork($cork);
+ 
+-sub convert {
+-    my $self = shift;
++    }
++    elsif ( $k eq 'ed25519' ) {
++        my $cork = Crypt::PK::Ed25519->new
++          or die 'unable to generate Ed25519 public key object';
+ 
+-    my $k_tag = $self->get_tag('k');
+-    $k_tag = 'rsa' unless defined $k_tag;
++        my $keybin = decode_base64($self->data);
++        $cork->import_key_raw($keybin, 'public')
++          or die 'failed to load Ed25519 public key';
+ 
+-    $self->data
+-      or return;
++        $self->cork($cork);
++
++    }
+ 
+-    return $self->_convert_rsa if $k_tag eq 'rsa';
+-    return $self->_convert_ed25519 if $k_tag eq 'ed25519';
+-    die 'unsupported key type';
++    return 1;
+ }
+ 
+ sub verify {
+@@ -436,76 +436,67 @@ sub verify_sha1_digest {
+     return $self->verify_digest( 'SHA-1', $digest, $signature );
+ }
+ 
+-sub _verify_digest_rsa {
++# verify_digest() - returns true if the digest verifies, false otherwise
++#
++# if false, $@ is set to a description of the problem
++#
++sub verify_digest {
+     my $self = shift;
+     my ( $digest_algorithm, $digest, $signature ) = @_;
+ 
+-    my $rsa_pub = $self->cork;
+-    if ( !$rsa_pub ) {
+-        $@ = $@ ne '' ? "RSA failed: $@" : 'RSA unknown problem';
+-        $@ .= ", s=$self->{Selector} d=$self->{Domain}";
+-        return;
+-    }
+-
+-    $rsa_pub->use_no_padding;
+-    my $verify_result = $rsa_pub->encrypt($signature);
++    my $k_tag = $self->get_tag('k') || 'rsa';
+ 
+-    my $k = $rsa_pub->size;
+-    my $expected = calculate_EM( $digest_algorithm, $digest, $k );
+-    return 1 if ( $verify_result eq $expected );
++    if ($k_tag eq 'rsa') {
++        my $rsa_pub = $self->cork;
++        if ( !$rsa_pub ) {
++            $@ = $@ ne '' ? "RSA failed: $@" : 'RSA unknown problem';
++            $@ .= ", s=$self->{Selector} d=$self->{Domain}";
++            return;
++        }
+ 
+-    # well, the RSA verification failed; I wonder if the RSA signing
+-    # was performed on a different digest value? I think we can check...
++        $rsa_pub->use_no_padding;
++        my $verify_result = $rsa_pub->encrypt($signature);
+ 
+-    # basically, if the $verify_result has the same prefix as $expected,
+-    # then only the digest was different
++        my $k = $rsa_pub->size;
++        my $expected = calculate_EM( $digest_algorithm, $digest, $k );
++        return 1 if ( $verify_result eq $expected );
+ 
+-    my $digest_len = length $digest;
+-    my $prefix_len = length($expected) - $digest_len;
+-    if (
+-        substr( $verify_result, 0, $prefix_len ) eq
+-        substr( $expected,      0, $prefix_len ) )
+-    {
+-        $@ = 'message has been altered';
+-        return;
+-    }
++        # well, the RSA verification failed; I wonder if the RSA signing
++        # was performed on a different digest value? I think we can check...
+ 
+-    $@ = 'bad RSA signature';
+-    return;
+-}
++        # basically, if the $verify_result has the same prefix as $expected,
++        # then only the digest was different
+ 
+-sub _verify_digest_ed25519 {
+-    my $self = shift;
+-    my ( $digest_algorithm, $digest, $signature ) = @_;
++        my $digest_len = length $digest;
++        my $prefix_len = length($expected) - $digest_len;
++        if (
++            substr( $verify_result, 0, $prefix_len ) eq
++            substr( $expected,      0, $prefix_len ) )
++        {
++            $@ = 'message has been altered';
++            return;
++        }
+ 
+-    my $ed = $self->cork;
+-    if ( !$ed ) {
+-        $@ = $@ ne '' ? "Ed25519 failed: $@" : 'Ed25519 unknown problem';
+-        $@ .= ", s=$self->{Selector} d=$self->{Domain}";
++        $@ = 'bad RSA signature';
+         return;
+-    }
+ 
+-    my $verify_result = $ed->verify_message($signature, $digest);
+-    return $verify_result if ($verify_result == 1);
++    } elsif ($k_tag eq 'ed25519') {
+ 
+-    $@ = 'bad Ed25519 signature';
+-    return;
+-}
++        my $ed = $self->cork;
++        if ( !$ed ) {
++            $@ = $@ ne '' ? "Ed25519 failed: $@" : 'Ed25519 unknown problem';
++            $@ .= ", s=$self->{Selector} d=$self->{Domain}";
++            return;
++        }
+ 
+-# verify_digest() - returns true if the digest verifies, false otherwise
+-#
+-# if false, $@ is set to a description of the problem
+-#
+-sub verify_digest {
+-    my $self = shift;
+-    my ( $digest_algorithm, $digest, $signature ) = @_;
++        my $verify_result = $ed->verify_message($signature, $digest);
++        return $verify_result if ($verify_result == 1);
+ 
+-    my $k_tag = $self->get_tag('k') || 'rsa';
++        $@ = 'bad Ed25519 signature';
++        return;
++
++    }
+ 
+-    return $self->_verify_digest_rsa($digest_algorithm, $digest, $signature) if $k_tag eq 'rsa';
+-    return $self->_verify_digest_ed25519($digest_algorithm, $digest, $signature) if $k_tag eq 'ed25519';
+-    $@ = 'unsupported key type';
+-    return;
+ }
+ 
+ 1;
+-- 
+2.40.1
+
diff --git a/debian/patches/0003-Revert-set-rsa-ed25519-type.patch b/debian/patches/0003-Revert-set-rsa-ed25519-type.patch
 new file mode 100644
index 0000000..8e8ded8
--- /dev/null
+++ b/debian/patches/0003-Revert-set-rsa-ed25519-type.patch
@@ -0,0 +1,84 @@
+From 7f8a91d1c8643967907843e45ee75ca0ae5a2157 Mon Sep 17 00:00:00 2001
+From: Miriam Espana Acebal <[e-mail]>
+Date: Fri, 16 Feb 2024 13:15:15 +0100
+Subject: [PATCH 3/5] Revert "set rsa/ed25519 type"
+
+This reverts commit d146356d5f0ec41f796cc40f0db76ba400efe12a.
+---
+ lib/Mail/DKIM/PrivateKey.pm | 2 +-
+ lib/Mail/DKIM/PublicKey.pm  | 6 ++----
+ lib/Mail/DKIM/Signer.pm     | 6 +-----
+ 3 files changed, 4 insertions(+), 10 deletions(-)
+
+diff --git a/lib/Mail/DKIM/PrivateKey.pm b/lib/Mail/DKIM/PrivateKey.pm
+index 1a9526d..ad98dd2 100644
+--- a/lib/Mail/DKIM/PrivateKey.pm
++++ b/lib/Mail/DKIM/PrivateKey.pm
+@@ -165,7 +165,7 @@ sub sign_digest {
+         return $rsa_priv->decrypt($EM);
+ 
+     }
+-    elsif ( $self->{'TYPE'} eq 'ed25519' ) {
++    elsif ( $self->{'TYPE'} eq 'ed25519') {
+ 
+         my $ed = $self->cork;
+         if ( !$ed ) {
+diff --git a/lib/Mail/DKIM/PublicKey.pm b/lib/Mail/DKIM/PublicKey.pm
+index bd45aeb..dce1736 100644
+--- a/lib/Mail/DKIM/PublicKey.pm
++++ b/lib/Mail/DKIM/PublicKey.pm
+@@ -25,7 +25,7 @@ sub new {
+     $self->{'GRAN'} = $prms{'Granularity'};
+     $self->{'NOTE'} = $prms{'Note'};
+     $self->{'TEST'} = $prms{'Testing'};
+-    $self->{'TYPE'} = ( $prms{'Type'} or 'rsa' );
++    #$self->{'TYPE'} = ( $prms{'Type'} or 'rsa' ); # unused
+     $self->{'DATA'} = $prms{'Data'};
+ 
+     bless $self, $type;
+@@ -99,9 +99,7 @@ sub fetch_async {
+         my $self = $class->parse($strn);
+         $self->{Selector} = $prms{'Selector'};
+         $self->{Domain}   = $prms{'Domain'};
+-        $self->{TYPE}     = ( $self->get_tag('k') or 'rsa' );
+         $self->check;
+-
+         return $on_success->($self);
+     };
+ 
+@@ -286,7 +284,7 @@ sub convert {
+ 
+     # Use different libs subject to k= tag.
+     # Without k= tag, default to RSA to maintain prior behavior
+-    my $k = ( $self->get_tag('k') or 'rsa' );
++    my $k = $self->get_tag('k') || 'rsa';
+     if ( $k eq 'rsa' ) {
+         use Crypt::OpenSSL::RSA;
+     }
+diff --git a/lib/Mail/DKIM/Signer.pm b/lib/Mail/DKIM/Signer.pm
+index 7aebced..24b5285 100644
+--- a/lib/Mail/DKIM/Signer.pm
++++ b/lib/Mail/DKIM/Signer.pm
+@@ -185,9 +185,6 @@ sub finish_body {
+         # finished canonicalizing
+         $algorithm->finish_body;
+ 
+-        my $type = 'rsa'; # default
+-        $type = 'ed25519' if ( $self->{'Algorithm'} =~ /^ed25519/ );
+-
+         # load the private key file if necessary
+         my $signature = $algorithm->signature;
+         my $key =
+@@ -196,8 +193,7 @@ sub finish_body {
+           || $self->{Key}
+           || $self->{KeyFile};
+         if ( defined($key) && !ref($key) ) {
+-            $key = Mail::DKIM::PrivateKey->load( File => $key,
+-                Type => $type );
++            $key = Mail::DKIM::PrivateKey->load( File => $key );
+         }
+         $key
+           or die "no key available to sign with\n";
+-- 
+2.40.1
+
diff --git a/debian/patches/0004-Revert-added-ed25519-signing-support.patch b/debian/patches/0004-Revert-added-ed25519-signing-support.patch
 new file mode 100644
index 0000000..7966790
--- /dev/null
+++ b/debian/patches/0004-Revert-added-ed25519-signing-support.patch
@@ -0,0 +1,327 @@
+From 74064a137e63c028a815eb24dcd8b52c616a08bc Mon Sep 17 00:00:00 2001
+From: Miriam Espana Acebal <[e-mail]>
+Date: Fri, 16 Feb 2024 13:15:23 +0100
+Subject: [PATCH 4/5] Revert "added ed25519 signing support."
+
+This reverts commit edd9897ee9208f41035f311d5b8443a5513a6037.
+---
+ lib/Mail/DKIM/PrivateKey.pm | 114 +++++++++---------------------------
+ lib/Mail/DKIM/PublicKey.pm  |  12 ++--
+ lib/Mail/DKIM/Signer.pm     |  16 ++---
+ t/signer.t                  |  54 +----------------
+ t/test.ed.key               |   3 -
+ 5 files changed, 38 insertions(+), 161 deletions(-)
+ delete mode 100644 t/test.ed.key
+
+diff --git a/lib/Mail/DKIM/PrivateKey.pm b/lib/Mail/DKIM/PrivateKey.pm
+index ad98dd2..261f866 100644
+--- a/lib/Mail/DKIM/PrivateKey.pm
++++ b/lib/Mail/DKIM/PrivateKey.pm
+@@ -52,85 +52,42 @@ sub load {
+ 
+ 
+ sub convert {
+-    my $self = shift;
++    use Crypt::OpenSSL::RSA;
+ 
+-    # Use different libs subject to key type.
+-    if ( $self->{'TYPE'} eq 'rsa' ) {
+-        use Crypt::OpenSSL::RSA;
+-    }
+-    elsif ( $self->{'TYPE'} eq 'ed25519' ) {
+-        use Crypt::PK::Ed25519;
+-    }
++    my $self = shift;
+ 
+     $self->data
+       or return;
+ 
+-    if ( $self->{'TYPE'} eq 'rsa' ) {
+-
+-        # have to PKCS1ify the privkey because openssl is too finicky...
+-        my $pkcs = "-----BEGIN RSA PRIVATE KEY-----\n";
+-
+-        for ( my $i = 0 ; $i < length $self->data ; $i += 64 ) {
+-            $pkcs .= substr $self->data, $i, 64;
+-            $pkcs .= "\n";
+-        }
+-
+-        $pkcs .= "-----END RSA PRIVATE KEY-----\n";
+-
+-        my $cork;
+-
+-        eval {
+-            local $SIG{__DIE__};
+-            $cork = new_private_key Crypt::OpenSSL::RSA($pkcs);
+-        1
+-        } || do {
+-        $self->errorstr($@);
+-        return;
+-        };
+-
+-        $cork
+-          or return;
+-
+-        # segfaults on my machine
+-        #	$cork->check_key or
+-        #		return;
+-
+-        $self->cork($cork);
++    # have to PKCS1ify the privkey because openssl is too finicky...
++    my $pkcs = "-----BEGIN RSA PRIVATE KEY-----\n";
+ 
++    for ( my $i = 0 ; $i < length $self->data ; $i += 64 ) {
++        $pkcs .= substr $self->data, $i, 64;
++        $pkcs .= "\n";
+     }
+-    elsif ( $self->{'TYPE'} eq 'ed25519' ) {
+-        my $cork;
+ 
+-        eval {
+-            local $SIG{__DIE__};
+-            $cork = new Crypt::PK::Ed25519;
++    $pkcs .= "-----END RSA PRIVATE KEY-----\n";
+ 
+-            # Prepend/append with PEM boilerplate
+-            my $pem = "-----BEGIN ED25519 PRIVATE KEY-----\n";
+-            $pem .= $self->data;
+-            $pem .= "\n";
+-            $pem .= "-----END ED25519 PRIVATE KEY-----\n";
++    my $cork;
+ 
+-            # Pass PEM text buffer
+-            $cork->import_key(\$pem)
+-                or die 'failed to load Ed25519 private key';
++    eval {
++        local $SIG{__DIE__};
++        $cork = new_private_key Crypt::OpenSSL::RSA($pkcs);
++	1
++    } || do {
++	$self->errorstr($@);
++	return;
++    };
+ 
+-            # Alternatively, import_raw_key() could be used,
+-            # but requires the 32-byte key, which must be extracted
+-            # from the ASN.1 structure first.
+-
+-        1
+-        } || do {
+-            $self->errorstr($@);
+-            return;
+-        };
+-
+-        $cork
+-          or return;
++    $cork
++      or return;
+ 
+-        $self->cork($cork);
++    # segfaults on my machine
++    #	$cork->check_key or
++    #		return;
+ 
+-    }
++    $self->cork($cork);
+ 
+     return 1;
+ }
+@@ -155,27 +112,12 @@ sub sign_digest {
+     my $self = shift;
+     my ( $digest_algorithm, $digest ) = @_;
+ 
+-    if ( $self->{'TYPE'} eq 'rsa') {
+-
+-        my $rsa_priv = $self->cork;
+-        $rsa_priv->use_no_padding;
+-
+-        my $k = $rsa_priv->size;
+-        my $EM = calculate_EM( $digest_algorithm, $digest, $k );
+-        return $rsa_priv->decrypt($EM);
++    my $rsa_priv = $self->cork;
++    $rsa_priv->use_no_padding;
+ 
+-    }
+-    elsif ( $self->{'TYPE'} eq 'ed25519') {
+-
+-        my $ed = $self->cork;
+-        if ( !$ed ) {
+-            $@ = $@ ne '' ? "Ed25519 failed: $@" : 'Ed25519 unknown problem';
+-            die;
+-        }
+-
+-        return $ed->sign_message($digest);
+-
+-    }
++    my $k = $rsa_priv->size;
++    my $EM = calculate_EM( $digest_algorithm, $digest, $k );
++    return $rsa_priv->decrypt($EM);
+ }
+ 
+ __END__
+diff --git a/lib/Mail/DKIM/PublicKey.pm b/lib/Mail/DKIM/PublicKey.pm
+index dce1736..b7b2a49 100644
+--- a/lib/Mail/DKIM/PublicKey.pm
++++ b/lib/Mail/DKIM/PublicKey.pm
+@@ -285,10 +285,9 @@ sub convert {
+     # Use different libs subject to k= tag.
+     # Without k= tag, default to RSA to maintain prior behavior
+     my $k = $self->get_tag('k') || 'rsa';
+-    if ( $k eq 'rsa' ) {
++    if ($k eq 'rsa') {
+         use Crypt::OpenSSL::RSA;
+-    }
+-    elsif ( $k eq 'ed25519' ) {
++    } elsif ($k eq 'ed25519') {
+         use Crypt::PK::Ed25519;
+         use MIME::Base64;
+     }
+@@ -296,7 +295,7 @@ sub convert {
+     $self->data
+       or return;
+ 
+-    if ( $k eq 'rsa' ) {
++    if ($k eq 'rsa') {
+         # have to PKCS1ify the pubkey because openssl is too finicky...
+         my $cert = "-----BEGIN PUBLIC KEY-----\n";
+ 
+@@ -316,8 +315,7 @@ sub convert {
+ 
+         $self->cork($cork);
+ 
+-    }
+-    elsif ( $k eq 'ed25519' ) {
++    } elsif ($k eq 'ed25519') {
+         my $cork = Crypt::PK::Ed25519->new
+           or die 'unable to generate Ed25519 public key object';
+ 
+@@ -492,9 +490,7 @@ sub verify_digest {
+ 
+         $@ = 'bad Ed25519 signature';
+         return;
+-
+     }
+-
+ }
+ 
+ 1;
+diff --git a/lib/Mail/DKIM/Signer.pm b/lib/Mail/DKIM/Signer.pm
+index 24b5285..b1d751a 100644
+--- a/lib/Mail/DKIM/Signer.pm
++++ b/lib/Mail/DKIM/Signer.pm
+@@ -61,21 +61,16 @@ sub init {
+     my $self = shift;
+     $self->SUPER::init;
+ 
++    if ( defined $self->{KeyFile} ) {
++        $self->{Key} ||=
++          Mail::DKIM::PrivateKey->load( File => $self->{KeyFile} );
++    }
++
+     unless ( $self->{'Algorithm'} ) {
+ 
+         # use default algorithm
+         $self->{'Algorithm'} = 'rsa-sha1';
+     }
+-
+-    my $type = 'rsa'; # default
+-    $type = 'ed25519' if ( $self->{'Algorithm'} =~ /^ed25519/ );
+-
+-    if ( defined $self->{KeyFile} ) {
+-        $self->{Key} ||=
+-          Mail::DKIM::PrivateKey->load( File => $self->{KeyFile},
+-            Type => $type );
+-    }
+-
+     unless ( $self->{'Method'} ) {
+ 
+         # use default canonicalization method
+@@ -91,7 +86,6 @@ sub init {
+         # use default selector
+         $self->{'Selector'} = 'unknown';
+     }
+-
+ }
+ 
+ sub finish_header {
+diff --git a/t/signer.t b/t/signer.t
+index 7cc4738..203a671 100755
+--- a/t/signer.t
++++ b/t/signer.t
+@@ -2,7 +2,7 @@
+ 
+ use strict;
+ use warnings;
+-use Test::Simple tests => 35;
++use Test::Simple tests => 31;
+ 
+ use Mail::DKIM::Signer;
+ 
+@@ -238,55 +238,3 @@ END_OF_SAMPLE
+     ok( $sigstr =~ /subject/i, "subject was signed" );
+     ok( $sigstr =~ /from/i,    "from was signed" );
+ }
+-
+-{
+-    my $EXPECTED_RE = qr/4goHxydMueA3ev5toKlGLc7sUrwPG/;
+-
+-    my $tdir    = -f "t/test.ed.key" ? "t" : ".";
+-    my $keyfile = "$tdir/test.ed.key";
+-    my $dkim    = Mail::DKIM::Signer->new(
+-        Algorithm => "ed25519-sha256",
+-        Method    => "relaxed",
+-        Domain    => "example.org",
+-        Selector  => "test",
+-        KeyFile   => $keyfile
+-    );
+-    ok( $dkim, "new() works" );
+-
+-    my $sample_email = <<END_OF_SAMPLE;
+-From: alice <alice\@example.org>
+-Date: Wed, 12 May 2023 14:00:00 +0200
+-Subject: ed25519
+-
+-this is an elliptic test.
+-END_OF_SAMPLE
+-    $sample_email =~ s/\n/\015\012/gs;
+-
+-    $dkim->PRINT($sample_email);
+-    $dkim->CLOSE;
+-
+-    my $signature = $dkim->signature;
+-    ok( $signature, "signature() works" );
+-
+-    print "# signature=" . $signature->as_string . "\n";
+-    ok( $signature->as_string =~ /$EXPECTED_RE/, "got expected signature value" );
+-
+-    # Modify sample email and sign again
+-
+-    $sample_email =~ s/Wed, 12/Tue, 11/;
+-    $dkim    = Mail::DKIM::Signer->new(
+-        Algorithm => "ed25519-sha256",
+-        Method    => "relaxed",
+-        Domain    => "example.org",
+-        Selector  => "test",
+-        KeyFile   => $keyfile
+-    );
+-    $dkim->PRINT($sample_email);
+-    $dkim->CLOSE;
+-
+-    $signature = $dkim->signature;
+-
+-    print "# signature=" . $signature->as_string . "\n";
+-    ok( $signature->as_string !~ /$EXPECTED_RE/, "got expected signature mismatch" );
+-
+-}
+diff --git a/t/test.ed.key b/t/test.ed.key
+deleted file mode 100644
+index 8e3a9d3..0000000
+--- a/t/test.ed.key
++++ /dev/null
+@@ -1,3 +0,0 @@
+------BEGIN PRIVATE KEY-----
+-MC4CAQAwBQYDK2VwBCIEIBNq8eB74GQ0uhob9AKDiQFK2vPZy3Rpqw6ec66p3A+m
+------END PRIVATE KEY-----
+-- 
+2.40.1
+
diff --git a/debian/patches/0005-Revert-added-support-for-verifying-Ed25519-signature.patch b/debian/patches/0005-Revert-added-support-for-verifying-Ed25519-signature.patch
 new file mode 100644
index 0000000..5f2b978
--- /dev/null
+++ b/debian/patches/0005-Revert-added-support-for-verifying-Ed25519-signature.patch
@@ -0,0 +1,578 @@
+From 007bf781b0efd2f9f41cd6c259ad02fb488337c6 Mon Sep 17 00:00:00 2001
+From: Miriam Espana Acebal <[e-mail]>
+Date: Fri, 16 Feb 2024 13:17:00 +0100
+Subject: [PATCH 5/5] Revert "added support for *verifying* Ed25519 signatures
+ (depends on Crypt::PK::Ed25519)."
+
+This reverts commit 3aa592be9bff03672e229a7e70abef0a5b302ce7.
+---
+ HACKING.DKIM                              |   9 +-
+ README.md                                 |   1 -
+ lib/Mail/DKIM/Algorithm/ed25519_sha256.pm | 121 ---------------------
+ lib/Mail/DKIM/PublicKey.pm                | 127 +++++++---------------
+ lib/Mail/DKIM/Signature.pm                |  11 +-
+ lib/Mail/DKIM/Verifier.pm                 |  17 +--
+ t/FAKE_DNS.dat                            |   2 -
+ t/corpus/badkey1_ed25519.txt              |  16 ---
+ t/corpus/badkey2_ed25519.txt              |  16 ---
+ t/corpus/badkey3_ed25519.txt              |  16 ---
+ t/corpus/goodkey_ed25519.txt              |  16 ---
+ t/verifier.t                              |   8 +-
+ 12 files changed, 57 insertions(+), 303 deletions(-)
+ delete mode 100644 lib/Mail/DKIM/Algorithm/ed25519_sha256.pm
+ delete mode 100644 t/corpus/badkey1_ed25519.txt
+ delete mode 100644 t/corpus/badkey2_ed25519.txt
+ delete mode 100644 t/corpus/badkey3_ed25519.txt
+ delete mode 100644 t/corpus/goodkey_ed25519.txt
+
+diff --git a/HACKING.DKIM b/HACKING.DKIM
+index 9d8354a..e21ab49 100644
+--- a/HACKING.DKIM
++++ b/HACKING.DKIM
+@@ -30,18 +30,11 @@ New version - update version numbers in these files:
+ New algorithm:
+   create new algorithm class by copying and editing
+     lib/Mail/DKIM/Algorithm/rsa_sha1.pm
+-  edit lib/Mail/DKIM/Signature.pm:
++  edit lib/Mail/DKIM/Common.pm:
+     get_algorithm_class() - add a check for your new algorithm and return
+       the name of your new algorithm class
+     add a "use" line at the top of this file so that your algorithm class
+       gets imported
+-  if the new algorithm uses a different key type (k=), also edit
+-    lib/Mail/DKIM/PublicKey.pm:
+-      check()
+-      convert()
+-      verify_digest()
+-    lib/Mail/DKIM/Verifier.pm:
+-      _check_and_verify_signature()
+ 
+ --
+ 
+diff --git a/README.md b/README.md
+index 5b937a9..cf1dd52 100644
+--- a/README.md
++++ b/README.md
+@@ -30,7 +30,6 @@ DEPENDENCIES
+ This module requires these other modules and libraries:
+ 
+   Crypt::OpenSSL::RSA
+-  Crypt::PK::Ed25519
+   Digest::SHA
+   Mail::Address (part of the MailTools package)
+   MIME::Base64
+diff --git a/lib/Mail/DKIM/Algorithm/ed25519_sha256.pm b/lib/Mail/DKIM/Algorithm/ed25519_sha256.pm
+deleted file mode 100644
+index d97deeb..0000000
+--- a/lib/Mail/DKIM/Algorithm/ed25519_sha256.pm
++++ /dev/null
+@@ -1,121 +0,0 @@
+-package Mail::DKIM::Algorithm::ed25519_sha256;
+-use strict;
+-use warnings;
+-# VERSION
+-# ABSTRACT: edd2519 sha256 algorithm class
+-
+-# Copyright 2005-2006 Messiah College. All rights reserved.
+-# Jason Long <[e-mail]>
+-
+-# Copyright (c) 2004 Anthony D. Urso. All rights reserved.
+-# This program is free software; you can redistribute it and/or
+-# modify it under the same terms as Perl itself.
+-
+-use base 'Mail::DKIM::Algorithm::Base';
+-use Carp;
+-use MIME::Base64;
+-use Digest::SHA;
+-
+-sub init_digests {
+-    my $self = shift;
+-
+-    # initialize a SHA-256 Digest
+-    $self->{header_digest} = new Digest::SHA(256);
+-    $self->{body_digest}   = new Digest::SHA(256);
+-}
+-
+-sub sign {
+-    my $self = shift;
+-    croak 'wrong number of arguments' unless ( @_ == 1 );
+-    my ($private_key) = @_;
+-
+-    my $digest = $self->{header_digest}->digest;
+-    my $signature = $private_key->sign_digest( 'SHA-256', $digest );
+-
+-    return encode_base64( $signature, '' );
+-}
+-
+-sub verify {
+-    my $self = shift;
+-    croak 'wrong number of arguments' unless ( @_ == 0 );
+-
+-    my $base64     = $self->signature->data;
+-    my $public_key = $self->signature->get_public_key;
+-
+-    my $digest = $self->{header_digest}->digest;
+-    my $sig    = decode_base64($base64);
+-
+-    return unless $public_key->verify_digest( 'SHA-256', $digest, $sig );
+-    return $self->check_body_hash;
+-}
+-
+-sub wants_pre_signature_headers {
+-    return 1;
+-}
+-
+-1;
+-
+-__END__
+-
+-=pod
+-
+-=encoding UTF-8
+-
+-=head1 NAME
+-
+-Mail::DKIM::Algorithm::ed25519_sha256 - ed25519 sha256 algorithm class
+-
+-=head1 VERSION
+-
+-version 1.20240124
+-
+-=head1 AUTHORS
+-
+-=over 4
+-
+-=item *
+-
+-Jason Long <[e-mail]>
+-
+-=item *
+-
+-Marc Bradshaw <[e-mail]>
+-
+-=item *
+-
+-Bron Gondwana <[e-mail]> (ARC)
+-
+-=back
+-
+-=head1 THANKS
+-
+-Work on ensuring that this module passes the ARC test suite was
+-generously sponsored by Valimail (https://www.valimail.com/)
+-
+-=head1 COPYRIGHT AND LICENSE
+-
+-=over 4
+-
+-=item *
+-
+-Copyright (C) 2013 by Messiah College
+-
+-=item *
+-
+-Copyright (C) 2010 by Jason Long
+-
+-=item *
+-
+-Copyright (C) 2017 by Standcore LLC
+-
+-=item *
+-
+-Copyright (C) 2020 by FastMail Pty Ltd
+-
+-=back
+-
+-This library is free software; you can redistribute it and/or modify
+-it under the same terms as Perl itself, either Perl version 5.8.6 or,
+-at your option, any later version of Perl 5 you may have available.
+-
+-=cut
+diff --git a/lib/Mail/DKIM/PublicKey.pm b/lib/Mail/DKIM/PublicKey.pm
+index b7b2a49..0080c67 100644
+--- a/lib/Mail/DKIM/PublicKey.pm
++++ b/lib/Mail/DKIM/PublicKey.pm
+@@ -25,7 +25,7 @@ sub new {
+     $self->{'GRAN'} = $prms{'Granularity'};
+     $self->{'NOTE'} = $prms{'Note'};
+     $self->{'TEST'} = $prms{'Testing'};
+-    #$self->{'TYPE'} = ( $prms{'Type'} or 'rsa' ); # unused
++    $self->{'TYPE'} = ( $prms{'Type'} or 'rsa' );
+     $self->{'DATA'} = $prms{'Data'};
+ 
+     bless $self, $type;
+@@ -130,7 +130,7 @@ sub check {
+ 
+     # check key type
+     if ( my $k = $self->get_tag('k') ) {
+-        unless ( $k eq 'rsa' || $k eq 'ed25519' ) {
++        unless ( $k eq 'rsa' ) {
+             die "unsupported key type\n";
+         }
+     }
+@@ -162,9 +162,6 @@ sub check {
+         elsif ( $E =~ /^(panic:.*?) at / ) {
+             $E = "OpenSSL $1";
+         }
+-        elsif ( $E =~ /^FATAL: (.*) at / ) {
+-            $E = "Ed25519 $1";
+-        }
+         die "$E\n";
+     };
+ 
+@@ -280,52 +277,31 @@ sub check_hash_algorithm {
+ # found in this public key's DNS record. The OpenSSL object is saved
+ # in the "cork" property.
+ sub convert {
+-    my $self = shift;
++    use Crypt::OpenSSL::RSA;
+ 
+-    # Use different libs subject to k= tag.
+-    # Without k= tag, default to RSA to maintain prior behavior
+-    my $k = $self->get_tag('k') || 'rsa';
+-    if ($k eq 'rsa') {
+-        use Crypt::OpenSSL::RSA;
+-    } elsif ($k eq 'ed25519') {
+-        use Crypt::PK::Ed25519;
+-        use MIME::Base64;
+-    }
++    my $self = shift;
+ 
+     $self->data
+       or return;
+ 
+-    if ($k eq 'rsa') {
+-        # have to PKCS1ify the pubkey because openssl is too finicky...
+-        my $cert = "-----BEGIN PUBLIC KEY-----\n";
+-
+-        for ( my $i = 0 ; $i < length $self->data ; $i += 64 ) {
+-            $cert .= substr $self->data, $i, 64;
+-            $cert .= "\n";
+-        }
+-
+-        $cert .= "-----END PUBLIC KEY-----\n";
+-
+-        my $cork = Crypt::OpenSSL::RSA->new_public_key($cert)
+-          or die 'unable to generate public key object';
++    # have to PKCS1ify the pubkey because openssl is too finicky...
++    my $cert = "-----BEGIN PUBLIC KEY-----\n";
+ 
+-        # segfaults on my machine
+-        #	$cork->check_key or
+-        #		return;
+-
+-        $self->cork($cork);
++    for ( my $i = 0 ; $i < length $self->data ; $i += 64 ) {
++        $cert .= substr $self->data, $i, 64;
++        $cert .= "\n";
++    }
+ 
+-    } elsif ($k eq 'ed25519') {
+-        my $cork = Crypt::PK::Ed25519->new
+-          or die 'unable to generate Ed25519 public key object';
++    $cert .= "-----END PUBLIC KEY-----\n";
+ 
+-        my $keybin = decode_base64($self->data);
+-        $cork->import_key_raw($keybin, 'public')
+-          or die 'failed to load Ed25519 public key';
++    my $cork = Crypt::OpenSSL::RSA->new_public_key($cert)
++      or die 'unable to generate public key object';
+ 
+-        $self->cork($cork);
++    # segfaults on my machine
++    #	$cork->check_key or
++    #		return;
+ 
+-    }
++    $self->cork($cork);
+ 
+     return 1;
+ }
+@@ -440,57 +416,38 @@ sub verify_digest {
+     my $self = shift;
+     my ( $digest_algorithm, $digest, $signature ) = @_;
+ 
+-    my $k_tag = $self->get_tag('k') || 'rsa';
+-
+-    if ($k_tag eq 'rsa') {
+-        my $rsa_pub = $self->cork;
+-        if ( !$rsa_pub ) {
+-            $@ = $@ ne '' ? "RSA failed: $@" : 'RSA unknown problem';
+-            $@ .= ", s=$self->{Selector} d=$self->{Domain}";
+-            return;
+-        }
+-
+-        $rsa_pub->use_no_padding;
+-        my $verify_result = $rsa_pub->encrypt($signature);
+-
+-        my $k = $rsa_pub->size;
+-        my $expected = calculate_EM( $digest_algorithm, $digest, $k );
+-        return 1 if ( $verify_result eq $expected );
+-
+-        # well, the RSA verification failed; I wonder if the RSA signing
+-        # was performed on a different digest value? I think we can check...
+-
+-        # basically, if the $verify_result has the same prefix as $expected,
+-        # then only the digest was different
+-
+-        my $digest_len = length $digest;
+-        my $prefix_len = length($expected) - $digest_len;
+-        if (
+-            substr( $verify_result, 0, $prefix_len ) eq
+-            substr( $expected,      0, $prefix_len ) )
+-        {
+-            $@ = 'message has been altered';
+-            return;
+-        }
+-
+-        $@ = 'bad RSA signature';
++    my $rsa_pub = $self->cork;
++    if ( !$rsa_pub ) {
++        $@ = $@ ne '' ? "RSA failed: $@" : 'RSA unknown problem';
++        $@ .= ", s=$self->{Selector} d=$self->{Domain}";
+         return;
++    }
+ 
+-    } elsif ($k_tag eq 'ed25519') {
++    $rsa_pub->use_no_padding;
++    my $verify_result = $rsa_pub->encrypt($signature);
+ 
+-        my $ed = $self->cork;
+-        if ( !$ed ) {
+-            $@ = $@ ne '' ? "Ed25519 failed: $@" : 'Ed25519 unknown problem';
+-            $@ .= ", s=$self->{Selector} d=$self->{Domain}";
+-            return;
+-        }
++    my $k = $rsa_pub->size;
++    my $expected = calculate_EM( $digest_algorithm, $digest, $k );
++    return 1 if ( $verify_result eq $expected );
+ 
+-        my $verify_result = $ed->verify_message($signature, $digest);
+-        return $verify_result if ($verify_result == 1);
++    # well, the RSA verification failed; I wonder if the RSA signing
++    # was performed on a different digest value? I think we can check...
+ 
+-        $@ = 'bad Ed25519 signature';
++    # basically, if the $verify_result has the same prefix as $expected,
++    # then only the digest was different
++
++    my $digest_len = length $digest;
++    my $prefix_len = length($expected) - $digest_len;
++    if (
++        substr( $verify_result, 0, $prefix_len ) eq
++        substr( $expected,      0, $prefix_len ) )
++    {
++        $@ = 'message has been altered';
+         return;
+     }
++
++    $@ = 'bad RSA signature';
++    return;
+ }
+ 
+ 1;
+diff --git a/lib/Mail/DKIM/Signature.pm b/lib/Mail/DKIM/Signature.pm
+index 7beb5e9..0504329 100644
+--- a/lib/Mail/DKIM/Signature.pm
++++ b/lib/Mail/DKIM/Signature.pm
+@@ -14,7 +14,6 @@ our $VERSION = '1.20240124'; # VERSION
+ use Mail::DKIM::PublicKey;
+ use Mail::DKIM::Algorithm::rsa_sha1;
+ use Mail::DKIM::Algorithm::rsa_sha256;
+-use Mail::DKIM::Algorithm::ed25519_sha256;
+ 
+ use base 'Mail::DKIM::KeyValueList';
+ use Carp;
+@@ -83,6 +82,14 @@ sub wantheader {
+     return;
+ }
+ 
++=head2 algorithm() - get or set the algorithm (a=) field
++
++The algorithm used to generate the signature. Should be either "rsa-sha1",
++an RSA-signed SHA-1 digest, or "rsa-sha256", an RSA-signed SHA-256 digest.
++
++See also hash_algorithm().
++
++=cut
+ 
+ sub algorithm {
+     my $self = shift;
+@@ -343,7 +350,6 @@ sub get_algorithm_class {
+     my $class =
+         $algorithm eq 'rsa-sha1'   ? 'Mail::DKIM::Algorithm::rsa_sha1'
+       : $algorithm eq 'rsa-sha256' ? 'Mail::DKIM::Algorithm::rsa_sha256'
+-      : $algorithm eq 'ed25519-sha256' ? 'Mail::DKIM::Algorithm::ed25519_sha256'
+       :                              undef;
+     return $class;
+ }
+@@ -426,7 +432,6 @@ sub hash_algorithm {
+     return
+         $algorithm eq 'rsa-sha1'   ? 'sha1'
+       : $algorithm eq 'rsa-sha256' ? 'sha256'
+-      : $algorithm eq 'ed25519-sha256' ? 'sha256'
+       :                              undef;
+ }
+ 
+diff --git a/lib/Mail/DKIM/Verifier.pm b/lib/Mail/DKIM/Verifier.pm
+index 8dfa65b..c1ca743 100644
+--- a/lib/Mail/DKIM/Verifier.pm
++++ b/lib/Mail/DKIM/Verifier.pm
+@@ -348,15 +348,11 @@ sub _check_and_verify_signature {
+         return ( 'invalid', $self->{signature_reject_reason} );
+     }
+ 
+-    # special handling for RSA signatures
+-    my $k = $pkey->get_tag('k') || 'rsa';
+-    if ($k eq 'rsa') {
+-        # make sure key is big enough
+-        my $keysize = $pkey->cork->size * 8;    # in bits
+-        if ( $keysize < 1024 && $self->{Strict} ) {
+-            $self->{signature_reject_reason} = "Key length $keysize too short";
+-            return ( 'fail', $self->{signature_reject_reason} );
+-        }
++    # make sure key is big enough
++    my $keysize = $pkey->cork->size * 8;    # in bits
++    if ( $keysize < 1024 && $self->{Strict} ) {
++        $self->{signature_reject_reason} = "Key length $keysize too short";
++        return ( 'fail', $self->{signature_reject_reason} );
+     }
+ 
+     # verify signature
+@@ -377,9 +373,6 @@ sub _check_and_verify_signature {
+         elsif ( $E =~ /^(panic:.*?) at / ) {
+             $E = "OpenSSL $1";
+         }
+-        elsif ( $E =~ /^FATAL: (.*) at / ) {
+-            $E = "Ed25519 $1";
+-        }
+         $result  = 'fail';
+         $details = $E;
+     };
+diff --git a/t/FAKE_DNS.dat b/t/FAKE_DNS.dat
+index 22e24da..e1683da 100644
+--- a/t/FAKE_DNS.dat
++++ b/t/FAKE_DNS.dat
+@@ -24,5 +24,3 @@ foo._domainkey.vmt2.cis.att.net  v=DKIM1; k=rsa; n=send%20comments%20to%20tony%4
+ nonexistent._domainkey.messiah.edu NXDOMAIN
+ test3._domainkey.blackhole.messiah.edu ~~Query timed out~~
+ test3._domainkey.blackhole2.messiah.edu ~~SERVFAIL~~
+-2023-05-ed25519._domainkey.wander.science  v=DKIM1; k=ed25519; p=pP+YUyRjAvKha4Oc49KAY703oLUS1NLMEuGD3IHMKww=
+-invalid._domainkey.wander.science  v=DKIM1; k=ed25519; p=MCowBQYDK2VwAyEA3SUqa9UbfciWkk7tlcJ9P1VD5pXAasg0JUn/OgjVbKE=
+diff --git a/t/corpus/badkey1_ed25519.txt b/t/corpus/badkey1_ed25519.txt
+deleted file mode 100644
+index 48dca6c..0000000
+--- a/t/corpus/badkey1_ed25519.txt
++++ /dev/null
+@@ -1,16 +0,0 @@
+-DKIM-Signature: v=1; a=ed25519-sha256; q=dns/txt; c=relaxed/relaxed;
+-	d=wander.science; s=invalid; h=Subject:Content-Transfer-Encoding:
+-	Content-Type:From:To:MIME-Version:Date:Message-ID:In-Reply-To:Cc:References:
+-	Sender:Reply-To; bh=P//FppzGgSSJDjYgpnZ255T9+DxXvu14MiedTEyE5UY=; b=85mI8hH/s
+-	TYf2w8vAF3BKeRs/7EMD8yGrrekJNcoZ8LxDd3RnpejvsG43I6vryFIx6xFmVSx65+zmxXu9/kvDg
+-	==;
+-Message-ID: <[e-mail]>
+-Date: Wed, 10 May 2023 21:54:21 +0200
+-MIME-Version: 1.0
+-To: [e-mail]
+-From: [e-mail]
+-Content-Type: text/plain; charset=UTF-8; format=flowed
+-Content-Transfer-Encoding: 7bit
+-Subject: Test ed25519
+-
+-The public key is invalid (wrong key length).
+diff --git a/t/corpus/badkey2_ed25519.txt b/t/corpus/badkey2_ed25519.txt
+deleted file mode 100644
+index bbb0d6b..0000000
+--- a/t/corpus/badkey2_ed25519.txt
++++ /dev/null
+@@ -1,16 +0,0 @@
+-DKIM-Signature: v=1; a=ed25519-sha256; q=dns/txt; c=relaxed/relaxed;
+-	d=wander.science; s=2023-05-ed25519; h=Subject:Content-Transfer-Encoding:
+-	Content-Type:From:To:MIME-Version:Date:Message-ID:In-Reply-To:Cc:References:
+-	Sender:Reply-To; bh=P//FppzGgSSJDjYgpnZ255T9+DxXvu14MiedTEyE5UY=; b=85mI8hH/s
+-	TYf2w8vAF3BKeRs/7EMD8yGrrekJNcoZ8LxDd3RnpejvsG43I6vryFIx6xFmVSx65+zmxXu9/kvDg
+-	==;
+-Message-ID: <[e-mail]>
+-Date: Wed, 10 May 2023 21:54:21 +0200
+-MIME-Version: 1.0
+-To: [e-mail]
+-From: [e-mail]
+-Content-Type: text/plain; charset=UTF-8; format=flowed
+-Content-Transfer-Encoding: 7bit
+-Subject: Test ed25519 wrong signature - subject modified
+-
+-This is an elliptic test.
+diff --git a/t/corpus/badkey3_ed25519.txt b/t/corpus/badkey3_ed25519.txt
+deleted file mode 100644
+index 02ea252..0000000
+--- a/t/corpus/badkey3_ed25519.txt
++++ /dev/null
+@@ -1,16 +0,0 @@
+-DKIM-Signature: v=1; a=ed25519-sha256; q=dns/txt; c=relaxed/relaxed;
+-	d=wander.science; s=2023-05-ed25519; h=Subject:Content-Transfer-Encoding:
+-	Content-Type:From:To:MIME-Version:Date:Message-ID:In-Reply-To:Cc:References:
+-	Sender:Reply-To; bh=P//FppzGgSSJDjYgpnZ255T9+DxXvu14MiedTEyE5UY=; b=85mI8hH/s
+-	TYf2w8vAF3BKeRs/7EMD8yGrrekJNcoZ8LxDd3RnpejvsG43I6vryFIx6xFmVSx65+zmxXu9/kvDg
+-	==;
+-Message-ID: <[e-mail]>
+-Date: Wed, 10 May 2023 21:54:21 +0200
+-MIME-Version: 1.0
+-To: [e-mail]
+-From: [e-mail]
+-Content-Type: text/plain; charset=UTF-8; format=flowed
+-Content-Transfer-Encoding: 7bit
+-Subject: Test ed25519
+-
+-Signature invalid - body modified.
+diff --git a/t/corpus/goodkey_ed25519.txt b/t/corpus/goodkey_ed25519.txt
+deleted file mode 100644
+index 42c2eb3..0000000
+--- a/t/corpus/goodkey_ed25519.txt
++++ /dev/null
+@@ -1,16 +0,0 @@
+-DKIM-Signature: v=1; a=ed25519-sha256; q=dns/txt; c=relaxed/relaxed;
+-	d=wander.science; s=2023-05-ed25519; h=Subject:Content-Transfer-Encoding:
+-	Content-Type:From:To:MIME-Version:Date:Message-ID:In-Reply-To:Cc:References:
+-	Sender:Reply-To; bh=P//FppzGgSSJDjYgpnZ255T9+DxXvu14MiedTEyE5UY=; b=85mI8hH/s
+-	TYf2w8vAF3BKeRs/7EMD8yGrrekJNcoZ8LxDd3RnpejvsG43I6vryFIx6xFmVSx65+zmxXu9/kvDg
+-	==;
+-Message-ID: <[e-mail]>
+-Date: Wed, 10 May 2023 21:54:21 +0200
+-MIME-Version: 1.0
+-To: [e-mail]
+-From: [e-mail]
+-Content-Type: text/plain; charset=UTF-8; format=flowed
+-Content-Transfer-Encoding: 7bit
+-Subject: Test ed25519
+-
+-This is an elliptic test.
+diff --git a/t/verifier.t b/t/verifier.t
+index 90320d4..b1b1e28 100755
+--- a/t/verifier.t
++++ b/t/verifier.t
+@@ -2,7 +2,7 @@
+ 
+ use strict;
+ use warnings;
+-use Test::More tests => 109;
++use Test::More tests => 105;
+ 
+ use Mail::DKIM::Verifier;
+ 
+@@ -162,12 +162,6 @@ test_email( "badkey_15.txt", "invalid" );    # dns error (SERVFAIL)
+ ok( $dkim->result_detail =~ /public key/,     "detail mentions public key" );
+ ok( $dkim->result_detail =~ /dns.*SERVFAIL/i, "type of dns failure" );
+ 
+-# test ed25519
+-test_email( "goodkey_ed25519.txt", "pass" );
+-test_email( "badkey1_ed25519.txt", "invalid" ); # key has invalid length
+-test_email( "badkey2_ed25519.txt", "fail" ); # header modified
+-test_email( "badkey3_ed25519.txt", "fail" ); # body modified
+-
+ sub read_file {
+     my $srcfile = shift;
+     open my $fh, "<", $srcfile
+-- 
+2.40.1
+
diff --git a/debian/patches/0006-Revert-Debian-support-for-ed25519.patch b/debian/patches/0006-Revert-Debian-support-for-ed25519.patch
 new file mode 100644
index 0000000..1ae3d6d
--- /dev/null
+++ b/debian/patches/0006-Revert-Debian-support-for-ed25519.patch
@@ -0,0 +1,93 @@
+From 2ff36de8102d340f4b2f25fc538891049af1692b Mon Sep 17 00:00:00 2001
+From: Miriam Espana Acebal <[e-mail]>
+Date: Thu, 15 Feb 2024 16:50:10 +0100
+Subject: [PATCH] Revert-Debian-support-for-ed25519
+
+Reverting partially commit b0358e44077951cabd3f27ad99473ef3bd778e67 from Debian,
+just removing perl dependencies and files related to ed25519 in 1.20230630-1.
+---
+ MANIFEST    | 7 -------
+ META.json   | 1 -
+ META.yml    | 1 -
+ Makefile.PL | 2 --
+ 4 files changed, 11 deletions(-)
+
+diff --git a/MANIFEST b/MANIFEST
+index edf3b5f..067c052 100644
+--- a/MANIFEST
++++ b/MANIFEST
+@@ -23,7 +23,6 @@ lib/Mail/DKIM/ARC/Signer.pm
+ lib/Mail/DKIM/ARC/Verifier.pm
+ lib/Mail/DKIM/Algorithm/Base.pm
+ lib/Mail/DKIM/Algorithm/dk_rsa_sha1.pm
+-lib/Mail/DKIM/Algorithm/ed25519_sha256.pm
+ lib/Mail/DKIM/Algorithm/rsa_sha1.pm
+ lib/Mail/DKIM/Algorithm/rsa_sha256.pm
+ lib/Mail/DKIM/AuthorDomainPolicy.pm
+@@ -83,11 +82,6 @@ t/corpus/bad_dk_5.txt
+ t/corpus/bad_ietf01_1.txt
+ t/corpus/bad_ietf01_2.txt
+ t/corpus/bad_ietf01_3.txt
+-t/corpus/badkey1_ed25519.txt
+-t/corpus/badkey2_ed25519.txt
+-t/corpus/badkey3_ed25519.txt
+-t/corpus/badkey4_ed25519.txt
+-t/corpus/badkey5_ed25519.txt
+ t/corpus/badkey_1.txt
+ t/corpus/badkey_10.txt
+ t/corpus/badkey_11.txt
+@@ -133,7 +127,6 @@ t/corpus/goodkey_1.txt
+ t/corpus/goodkey_2.txt
+ t/corpus/goodkey_3.txt
+ t/corpus/goodkey_4.txt
+-t/corpus/goodkey_ed25519.txt
+ t/corpus/ignore_1.txt
+ t/corpus/ignore_2.txt
+ t/corpus/ignore_3.txt
+diff --git a/META.json b/META.json
+index 0491f11..557b36e 100644
+--- a/META.json
++++ b/META.json
+@@ -31,7 +31,6 @@
+          "requires" : {
+             "Carp" : "0",
+             "Crypt::OpenSSL::RSA" : "0",
+-            "Crypt::PK::Ed25519" : "0",
+             "Digest::SHA" : "0",
+             "MIME::Base64" : "0",
+             "Mail::Address" : "0",
+diff --git a/META.yml b/META.yml
+index 9a226c5..240ba76 100644
+--- a/META.yml
++++ b/META.yml
+@@ -24,7 +24,6 @@ name: Mail-DKIM
+ requires:
+   Carp: '0'
+   Crypt::OpenSSL::RSA: '0'
+-  Crypt::PK::Ed25519: '0'
+   Digest::SHA: '0'
+   MIME::Base64: '0'
+   Mail::Address: '0'
+diff --git a/Makefile.PL b/Makefile.PL
+index d36be4e..43ab54e 100644
+--- a/Makefile.PL
++++ b/Makefile.PL
+@@ -19,7 +19,6 @@ my %WriteMakefileArgs = (
+   "PREREQ_PM" => {
+     "Carp" => 0,
+     "Crypt::OpenSSL::RSA" => 0,
+-    "Crypt::PK::Ed25519" => 0,
+     "Digest::SHA" => 0,
+     "MIME::Base64" => 0,
+     "Mail::Address" => 0,
+@@ -50,7 +49,6 @@ my %WriteMakefileArgs = (
+ my %FallbackPrereqs = (
+   "Carp" => 0,
+   "Crypt::OpenSSL::RSA" => 0,
+-  "Crypt::PK::Ed25519" => 0,
+   "Data::Dumper" => 0,
+   "Digest::SHA" => 0,
+   "MIME::Base64" => 0,
+-- 
+2.40.1
+
diff --git a/debian/patches/series b/debian/patches/series
 new file mode 100644
index 0000000..6e5e0f9
--- /dev/null
+++ b/debian/patches/series
@@ -0,0 +1,6 @@
+0001-Revert-Ed25519-Add-test-for-missing-public-key.patch
+0002-Revert-Refactor-and-cleanup-some-ed25519-code.patch
+0003-Revert-set-rsa-ed25519-type.patch
+0004-Revert-added-ed25519-signing-support.patch
+0005-Revert-added-support-for-verifying-Ed25519-signature.patch
+0006-Revert-Debian-support-for-ed25519.patch