Package com.icodici.crypto.rsaoaep

Class RSAOAEPPublicKey

java.lang.Object

com.icodici.crypto.AbstractKey

com.icodici.crypto.AbstractAsymmetricKey

com.icodici.crypto.AbstractPublicKey

com.icodici.crypto.rsaoaep.RSAOAEPPublicKey

All Implemented Interfaces:

KeyMatcher, net.sergeych.tools.Bindable, net.sergeych.tools.Hashable

public class RSAOAEPPublicKey
extends AbstractPublicKey

The Public Key for RSA asymmetric algorithm used together with OAEP padding. All key information is private, until increasing its visibility is really needed. Default hash and MGF1 hash are SHA-256.

Created by amyodov on 16.04.16.

Nested Class Summary

Nested classes/interfaces inherited from interface net.sergeych.tools.Hashable

net.sergeych.tools.Hashable.Error

Field Summary

Fields

Modifier and Type	Field	Description
static HashType	DEFAULT_MGF1_HASH	The default MGF1 hash algorithm.
static HashType	DEFAULT_OAEP_HASH	The default hash algorithm for OAEP.

Fields inherited from class com.icodici.crypto.AbstractAsymmetricKey

MAX_SALT_LENGTH

Fields inherited from class com.icodici.crypto.AbstractKey

FINGERPRINT_SHA256, FINGERPRINT_SHA384, keyInfo, TYPE_PRIVATE, TYPE_PRIVATE_PASSWORD, TYPE_PRIVATE_PASSWORD_V2, TYPE_PUBLIC

Constructor Summary

Constructors

Constructor	Description
RSAOAEPPublicKey()	Empty constructor.

Method Summary

Modifier and Type	Method	Description
@NonNull java.lang.String	algorithmTag()	Any encryption type has an unique tag.
boolean	canEncrypt()	Check that this key instance is suitable for encryption too (some keys can provide checkSignature only functionality).
@org.checkerframework.checker.nullness.qual.NonNull boolean	checkSignature(java.io.InputStream input, byte[] signature, HashType hashType, int saltLength)	Check the digital signature.
@org.checkerframework.checker.nullness.qual.NonNull byte[]	encrypt(byte[] plaintext)	Public-key encryption of the block.
int	getBitStrength()
boolean	isInitialized()	True if the key is properly initialized
@NonNull java.util.Map<java.lang.String,java.lang.Object>	toHash()
java.lang.String	toString()
void	updateFromHash(java.util.Map<java.lang.String,java.lang.Object> hash)

Methods inherited from class com.icodici.crypto.AbstractPublicKey

checkSignature, checkSignature, checkSignature, checkSignature, encrypt

Methods inherited from class com.icodici.crypto.AbstractAsymmetricKey

getMaxSaltLength

Methods inherited from class com.icodici.crypto.AbstractKey

address, asKeySource, canSign, createAnonymousId, decrypt, fingerprint, fromBinder, getLongAddress, getPublicKey, getShortAddress, info, isMatchingKey, isMatchingKeyAddress, isPrivate, isPublic, matchAnonymousId, matchTag, matchType, pack, packedInfo, packToBase64String, setTag, setTag, sign, sign, toBinder, unpack, updateDigestWithKeyComponents, updateFrom, verify, verify, verify

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

DEFAULT_OAEP_HASH

public static final HashType DEFAULT_OAEP_HASH

The default hash algorithm for OAEP.

DEFAULT_MGF1_HASH

public static final HashType DEFAULT_MGF1_HASH

The default MGF1 hash algorithm.

Constructor Detail

RSAOAEPPublicKey

public RSAOAEPPublicKey()

Empty constructor.

Method Detail

toString

public java.lang.String toString()

Overrides:

toString in class AbstractKey

canEncrypt

public boolean canEncrypt()

Check that this key instance is suitable for encryption too (some keys can provide checkSignature only functionality).

Specified by:

canEncrypt in class AbstractPublicKey

Returns:

true if this key can encrypt.

getBitStrength

public int getBitStrength()
                   throws java.lang.IllegalStateException

Specified by:

getBitStrength in class AbstractPublicKey

Returns:

bit strength of the key, e.g. 2048 ro RSA.

Throws:

java.lang.IllegalStateException

isInitialized

public boolean isInitialized()

True if the key is properly initialized

Specified by:

isInitialized in class AbstractPublicKey

encrypt

public @org.checkerframework.checker.nullness.qual.NonNull byte[] encrypt(byte[] plaintext)
                                                                   throws EncryptionError,
                                                                          java.lang.IllegalStateException

Public-key encryption of the block.

Specified by:

encrypt in class AbstractPublicKey

Parameters:

plaintext - data to encrypt.

Throws:

EncryptionError - if the key can't encrypt, data too large for the key or any other error that prevents data to be encrypted.

java.lang.IllegalStateException

checkSignature

public @org.checkerframework.checker.nullness.qual.NonNull boolean checkSignature(java.io.InputStream input,
                                                                                  byte[] signature,
                                                                                  HashType hashType,
                                                                                  int saltLength)
                                                                           throws java.lang.IllegalStateException,
                                                                                  java.io.IOException

Check the digital signature. As very large documents can be signed, we represent them as streams. The document can be way too large to load the whole into memory, so implementations should calculate the signature by reading portions of it from the stream.

The method must not throw exception if the signature is bad. e.g. improper, has wrong structure and so on. Instead, it must return false.

Specified by:

checkSignature in class AbstractPublicKey

Parameters:

input - source data

signature - signature to check

Returns:

true if the signature is valid, false if not.

Throws:

java.io.IOException - failed to read the input stream (including empty stream, EOF at start)

java.lang.IllegalStateException

algorithmTag

public @NonNull java.lang.String algorithmTag()

Any encryption type has an unique tag. For RSAES-OAEP the tag is r1. For elliptic curve variant used in bitcoin, "e1" and so on. The tag is not intended to be human readable, it is used to properly select decryption method and not waste package space.

Specified by:

algorithmTag in class AbstractPublicKey

Returns:

encryption method tag

toHash

public @NonNull java.util.Map<java.lang.String,java.lang.Object> toHash()
                                                                       throws java.lang.IllegalStateException

Throws:

java.lang.IllegalStateException

updateFromHash

public void updateFromHash(java.util.Map<java.lang.String,java.lang.Object> hash)
                    throws net.sergeych.tools.Hashable.Error

Throws:

net.sergeych.tools.Hashable.Error