@FiloSottile

As another data point, Android P has introduced usage of RSA/ECB/OAEPWITHSHA-256ANDMGF1PADDING.

https://developer.android.com/reference/android/security/keystore/WrappedKeyEntry

the same issue.

Hi guys, I could help to implement the resolution for this issue, but I need your help to decide what's the best scenario for this.

Do you think the OEAPOptions is the best way?

Thank you

OAEP is one of those unfortunate standards with a million parameters, which the Go standard library intentionally culls to a reasonable subset. For example, there is no good reason I know of to use different hashes at different stages of the algorithm.

On balance, I'm mostly ok with adding a field to OEAPOptions for decryption, as it won't disturb common users. However, adding a whole new function would be more invasive, and I don't think it would be worth it.

Would having support for independent hashes only for decryption make sense for your use cases, or would it be useless without encryption? (It makes sense to me also because the library is already asymmetrical due to crypto.Decrypter not having an encryption counterpart, and decryption is more likely to be about compatibility with a third party.)

I got your point, but thinking in interoperability maybe is the deal here. I think that it could reduce the fricction along another implementations. As the use case that I exposed related to android.

I think that makes sense use for both encrypt/decrypt.

Well, this is my understood at reading RFC 3447, starting chapter "7. Encryption schemes" and keeping up beyond this section. But, looking to the implementation that we have at the golang, I think that is a gonna be just a decision to update of the usage context and allow the encryption besides the decryption.

Thanks

Update on this? Saw @sakjur commits but I couldn't find any PRs related

@vieiramanoel That was mostly an experiment that didn't lead anywhere and I later ended up not needing to complete 🙂 I'm not sure if whatever I have in my branch works at all, and it was mostly an accident that my WIP commits ended up being linked from here.

Any Update on this?

Still waiting for this feature,
I personally asked this on SO https://stackoverflow.com/questions/69286881/java-rsa-ecb-oaepwithsha-256andmgf1padding-migrate-to-go and pick a solution from there and it works https://play.golang.org/p/9Le_3GiQVUE
It's not so complicated change but it seems unattended.

Any updates on this? Me personally is not quite sure about the status of this issue. I'm more than open to implement it and file a PR, but I'm unsure whether such work is appropriate for the go standard library :D

Hello everyone! Long time user, first time contributor :-)

This is something we recently ran into while attempting to decrypt ciphertexts sent to us by a third-party. Unfortunately, we do not have the ability to change the parameters they use in this protocol. I am very interested (and motivated!) to work on upstreaming a change to resolve this.

It has been a while, but it sounds like the right direction was to add something to OEAPOptions. However, the challenge seems to be that everything flows the exported function:

DecryptOAEP(hash hash.Hash, random io.Reader, priv *PrivateKey, ciphertext []byte, label []byte) 

And it is desirable to not change the signature of this function. As a general approach, how would you feel about creating a new non-exported function (decryptOAEP), which is referenced by both the exported DecryptOAEP and the func (priv *PrivateKey) Decrypt(...) functions?

cc @FiloSottile

Change https://go.dev/cl/418874 mentions this issue: crypto: allow hash.Hash for OAEP and MGF1 to be specified independently

@FiloSottile I see you might be looking at my pull request. I expect we will want to add test coverage for any change. However, it looks like there is an existing set of hard-coded test vectors that are used for OAEP, and it wasn't clear to me how those are being generated.

I've rebased the PR on the latest code. It's been a while, but I'm still interested in discussing this change :-)

Throwing in proposal review bucket since this is an API change.

Thank you so much @ianlancetaylor and @andybons. Please let me know if there are any updates needed to the API change.

The proposed new API is to add MGFHash to rsa.OAEPOptions:

type OAEPOptions struct {
	// Hash is the hash function that will be used when generating the mask.
	Hash crypto.Hash

	// NEW: MGFHash is the hash function used for MGF1.
	// If zero, Hash is used instead.
	MGFHash crypto.Hash

	// Label is an arbitrary byte string that must be equal to the value
	// used when encrypting.
	Label []byte
}

(The CL uses *crypto.Hash but we can use the plain zero value for a presence check instead.)

Does anyone object to this API?

CC @golang/security

This proposal has been added to the active column of the proposals project
and will now be reviewed at the weekly proposal review meetings.
— rsc for the proposal review group

Does anyone object to adding OAEPOptions.MGFHash as in #19974 (comment)?

Based on the discussion above, this proposal seems like a likely accept.
— rsc for the proposal review group

No change in consensus, so accepted. 🎉
This issue now tracks the work of implementing the proposal.
— rsc for the proposal review group

I've updated the change to reflect the proposed API: https://go-review.googlesource.com/c/go/+/418874