* again with a different argument, it negates the effect * of this call. * * @param privateKey the private key of the identity whose signature * is going to be generated. * * @exception InvalidKeyException if the key is invalid. */ public final void initSign(PrivateKey privateKey) throws InvalidKeyException { engineInitSign(privateKey); state = SIGN; } /** * Initialize this object for signing. If this method is called * again with a different argument, it negates the effect * of this call. * * @param privateKey the private key of the identity whose signature * is going to be generated. * * @param random the source of randomness for this signature. * * @exception InvalidKeyException if the key is invalid. */ public final void initSign(PrivateKey privateKey, SecureRandom random) throws InvalidKeyException { engineInitSign(privateKey, random); state = SIGN; } /** * Returns the signature bytes of all the data updated. * The format of the signature depends on the underlying * signature scheme. * * <p>A call to this method resets this signature object to the state * it was in when previously initialized for signing via a * call to <code>initSign(PrivateKey)</code>. That is, the object is * reset and available to generate another signature from the same * signer, if desired, via new calls to <code>update</code> and * <code>sign</code>. * * @return the signature bytes of the signing operation's result. * * @exception SignatureException if this signature object is not * initialized properly or if this signature algorithm is unable to * process the input data provided. */ public final byte[] sign() throws SignatureException { if (state == SIGN) { return engineSign(); } throw new SignatureException("object not initialized for " + "signing"); } /** * Finishes the signature operation and stores the resulting signature * bytes in the provided buffer <code>outbuf</code>, starting at * <code>offset</code>. * The format of the signature depends on the underlying * signature scheme. * * <p>This signature object is reset to its initial state (the state it * was in after a call to one of the <code>initSign</code> methods) and * can be reused to generate further signatures with the same private key. * * @param outbuf buffer for the signature result. * * @param offset offset into <code>outbuf</code> where the signature is * stored. * * @param len number of bytes within <code>outbuf</code> allotted for the * signature. * * @return the number of bytes placed into <code>outbuf</code>. * * @exception SignatureException if this signature object is not * initialized properly, if this signature algorithm is unable to * process the input data provided, or if <code>len</code> is less * than the actual signature length. * * @since 1.2 */ public final int sign(byte[] outbuf, int offset, int len) throws SignatureException { if (outbuf == null) { throw new IllegalArgumentException("No output buffer given"); } if (outbuf.length - offset < len) { throw new IllegalArgumentException ("Output buffer too small for specified offset and length"); } if (state != SIGN) { throw new SignatureException("object not initialized for " + "signing"); } return engineSign(outbuf, offset, len); } /** * Verifies the passed-in signature. * * <p>A call to this method resets this signature object to the state * it was in when previously initialized for verification via a * call to <code>initVerify(PublicKey)</code>. That is, the object is * reset and available to verify another signature from the identity * whose public key was specified in the call to <code>initVerify</code>. * * @param signature the signature bytes to be verified. * * @return true if the signature was verified, false if not. * * @exception SignatureException if this signature object is not * initialized properly, the passed-in signature is improperly * encoded or of the wrong type, if this signature algorithm is unable to * process the input data provided, etc. */ public final boolean verify(byte[] signature) throws SignatureException { if (state == VERIFY) { return engineVerify(signature); } throw new SignatureException("object not initialized for " + "verification"); } /** * Verifies the passed-in signature in the specified array * of bytes, starting at the specified offset. * * <p>A call to this method resets this signature object to the state * it was in when previously initialized for verification via a * call to <code>initVerify(PublicKey)</code>. That is, the object is * reset and available to verify another signature from the identity * whose public key was specified in the call to <code>initVerify</code>. * * * @param signature the signature bytes to be verified. * @param offset the offset to start from in the array of bytes. * @param length the number of bytes to use, starting at offset. * * @return true if the signature was verified, false if not. * * @exception SignatureException if this signature object is not * initialized properly, the passed-in signature is improperly * encoded or of the wrong type, if this signature algorithm is unable to * process the input data provided, etc. * @exception IllegalArgumentException if the <code>signature</code> * byte array is null, or the <code>offset</code> or <code>length</code> * is less than 0, or the sum of the <code>offset</code> and * <code>length</code> is greater than the length of the * <code>signature</code> byte array. * @since 1.4 */ public final boolean verify(byte[] signature, int offset, int length) throws SignatureException { if (state == VERIFY) { if ((signature == null) || (offset < 0) || (length < 0) || (offset + length > signature.length)) { throw new IllegalArgumentException("Bad arguments"); } return engineVerify(signature, offset, length); } throw new SignatureException("object not initialized for " + "verification"); } /** * Updates the data to be signed or verified by a byte. * * @param b the byte to use for the update. * * @exception SignatureException if this signature object is not * initialized properly. */ public final void update(byte b) throws SignatureException { if (state == VERIFY || state == SIGN) { engineUpdate(b); } else { throw new SignatureException("object not initialized for " + "signature or verification"); } } /** * Updates the data to be signed or verified, using the specified * array of bytes. * * @param data the byte array to use for the update. * * @exception SignatureException if this signature object is not * initialized properly. */ public final void update(byte[] data) throws SignatureException { update(data, 0, data.length); } /** * Updates the data to be signed or verified, using the specified * array of bytes, starting at the specified offset. * * @param data the array of bytes. * @param off the offset to start from in the array of bytes. * @param len the number of bytes to use, starting at offset. * * @exception SignatureException if this signature object is not * initialized properly. */ public final void update(byte[] data, int off, int len) throws SignatureException { if (state == SIGN || state == VERIFY) { engineUpdate(data, off, len); } else { throw new SignatureException("object not initialized for " + "signature or verification"); } } /** * Updates the data to be signed or verified using the specified * ByteBuffer. Processes the <code>data.remaining()</code> bytes * starting at at <code>data.position()</code>. * Upon return, the buffer's position will be equal to its limit; * its limit will not have changed. * * @param data the ByteBuffer * * @exception SignatureException if this signature object is not * initialized properly. * @since 1.5 */ public final void update(ByteBuffer data) throws SignatureException { if ((state != SIGN) && (state != VERIFY)) { throw new SignatureException("object not initialized for " + "signature or verification"); } if (data == null) { throw new NullPointerException(); } engineUpdate(data); } /** * Returns the name of the algorithm for this signature object. * * @return the name of the algorithm for this signature object. */ public final String getAlgorithm() { return this.algorithm; } /** * Returns a string representation of this signature object, * providing information that includes the state of the object * and the name of the algorithm used. * * @return a string representation of this signature object. */ public String toString() { String initState = ""; switch (state) { case UNINITIALIZED: initState = "<not initialized>"; break; case VERIFY: initState = "<initialized for verifying>"; break; case SIGN: initState = "<initialized for signing>"; break; } return "Signature object: " + getAlgorithm() + initState; } /** * Sets the specified algorithm parameter to the specified value. * This method supplies a general-purpose mechanism through * which it is possible to set the various parameters of this object. * A parameter may be any settable parameter for the algorithm, such as * a parameter size, or a source of random bits for signature generation * (if appropriate), or an indication of whether or not to perform * a specific but optional computation. A uniform algorithm-specific * naming scheme for each parameter is desirable but left unspecified * at this time. * * @param param the string identifier of the parameter. * @param value the parameter value. * * @exception InvalidParameterException if <code>param</code> is an * invalid parameter for this signature algorithm engine, * the parameter is already set * and cannot be set again, a security exception occurs, and so on. * * @see #getParameter * * @deprecated Use * {@link #setParameter(java.security.spec.AlgorithmParameterSpec) * setParameter}. */ @Deprecated public final void setParameter(String param, Object value) throws InvalidParameterException { engineSetParameter(param, value); } /** * Initializes this signature engine with the specified parameter set. * * @param params the parameters * * @exception InvalidAlgorithmParameterException if the given parameters * are inappropriate for this signature engine * * @see #getParameters */ public final void setParameter(AlgorithmParameterSpec params) throws InvalidAlgorithmParameterException { engineSetParameter(params); } /** * Returns the parameters used with this signature object. * * <p>The returned parameters may be the same that were used to initialize * this signature, or may contain a combination of default and randomly * generated parameter values used by the underlying signature * implementation if this signature requires algorithm parameters but * was not initialized with any. * * @return the parameters used with this signature, or null if this * signature does not use any parameters. * * @see #setParameter(AlgorithmParameterSpec) * @since 1.4 */ public final AlgorithmParameters getParameters() { return engineGetParameters(); } /** * Gets the value of the specified algorithm parameter. This method * supplies a general-purpose mechanism through which it is possible to * get the various parameters of this object. A parameter may be any * settable parameter for the algorithm, such as a parameter size, or * a source of random bits for signature generation (if appropriate), * or an indication of whether or not to perform a specific but optional * computation. A uniform algorithm-specific naming scheme for each * parameter is desirable but left unspecified at this time. * * @param param the string name of the parameter. * * @return the object that represents the parameter value, or null if * there is none. * * @exception InvalidParameterException if <code>param</code> is an invalid * parameter for this engine, or another exception occurs while * trying to get this parameter. * * @see #setParameter(String, Object) * * @deprecated */ @Deprecated public final Object getParameter(String param) throws InvalidParameterException { return engineGetParameter(param); } /** * Returns a clone if the implementation is cloneable. * * @return a clone if the implementation is cloneable. * * @exception CloneNotSupportedException if this is called * on an implementation that does not support <code>Cloneable</code>. */ public Object clone() throws CloneNotSupportedException { if (this instanceof Cloneable) { return super.clone(); } else { throw new CloneNotSupportedException(); } } /* * The following class allows providers to extend from SignatureSpi * rather than from Signature. It represents a Signature with an * encapsulated, provider-supplied SPI object (of type SignatureSpi). * If the provider implementation is an instance of SignatureSpi, the * getInstance() methods above return an instance of this class, with * the SPI object encapsulated. * * Note: All SPI methods from the original Signature class have been * moved up the hierarchy into a new class (SignatureSpi), which has * been interposed in the hierarchy between the API (Signature) * and its original parent (Object). */ private static class Delegate extends Signature { // The provider implementation (delegate) // filled in once the provider is selected private SignatureSpi sigSpi; // lock for mutex during provider selection private final Object lock; // next service to try in provider selection // null once provider is selected private Service firstService; // remaining services to try in provider selection // null once provider is selected private Iterator<Service> serviceIterator; // constructor Delegate(SignatureSpi sigSpi, String algorithm) { super(algorithm); this.sigSpi = sigSpi; this.lock = null; // no lock needed } // used with delayed provider selection Delegate(Service service, Iterator<Service> iterator, String algorithm) { super(algorithm); this.firstService = service; this.serviceIterator = iterator; this.lock = new Object(); } /** * Returns a clone if the delegate is cloneable. * * @return a clone if the delegate is cloneable. * * @exception CloneNotSupportedException if this is called on a * delegate that does not support <code>Cloneable</code>. */ public Object clone() throws CloneNotSupportedException { chooseFirstProvider(); if (sigSpi instanceof Cloneable) { SignatureSpi sigSpiClone = (SignatureSpi)sigSpi.clone(); // Because 'algorithm' and 'provider' are private // members of our supertype, we must perform a cast to // access them. Signature that = new Delegate(sigSpiClone, ((Signature)this).algorithm); that.provider = ((Signature)this).provider; return that; } else { throw new CloneNotSupportedException(); } } private static SignatureSpi newInstance(Service s) throws NoSuchAlgorithmException { if (s.getType().equals("Cipher")) { // must be NONEwithRSA try { Cipher c = Cipher.getInstance(RSA_CIPHER, s.getProvider()); return new CipherAdapter(c); } catch (NoSuchPaddingException e) { throw new NoSuchAlgorithmException(e); } } else { Object o = s.newInstance(null); if (o instanceof SignatureSpi == false) { throw new NoSuchAlgorithmException ("Not a SignatureSpi: " + o.getClass().getName()); } return (SignatureSpi)o; } } // max number of debug warnings to print from chooseFirstProvider() private static int warnCount = 10; /** * Choose the Spi from the first provider available. Used if * delayed provider selection is not possible because initSign()/ * initVerify() is not the first method called. */ void chooseFirstProvider() { if (sigSpi != null) { return; } synchronized (lock) { if (sigSpi != null) { return; } if (debug != null) { int w = --warnCount; if (w >= 0) { debug.println("Signature.init() not first method " + "called, disabling delayed provider selection"); if (w == 0) {Lines 501–1000 of 1293. Previous lines Load more
* again with a different argument, it negates the effect * of this call. * * @param privateKey the private key of the identity whose signature * is going to be generated. * * @exception InvalidKeyException if the key is invalid. */ public final void initSign(PrivateKey privateKey) throws InvalidKeyException { engineInitSign(privateKey); state = SIGN; } /** * Initialize this object for signing. If this method is called * again with a different argument, it negates the effect * of this call. * * @param privateKey the private key of the identity whose signature * is going to be generated. * * @param random the source of randomness for this signature. * * @exception InvalidKeyException if the key is invalid. */ public final void initSign(PrivateKey privateKey, SecureRandom random) throws InvalidKeyException { engineInitSign(privateKey, random); state = SIGN; } /** * Returns the signature bytes of all the data updated. * The format of the signature depends on the underlying * signature scheme. * * <p>A call to this method resets this signature object to the state * it was in when previously initialized for signing via a * call to <code>initSign(PrivateKey)</code>. That is, the object is * reset and available to generate another signature from the same * signer, if desired, via new calls to <code>update</code> and * <code>sign</code>. * * @return the signature bytes of the signing operation's result. * * @exception SignatureException if this signature object is not * initialized properly or if this signature algorithm is unable to * process the input data provided. */ public final byte[] sign() throws SignatureException { if (state == SIGN) { return engineSign(); } throw new SignatureException("object not initialized for " + "signing"); } /** * Finishes the signature operation and stores the resulting signature * bytes in the provided buffer <code>outbuf</code>, starting at * <code>offset</code>. * The format of the signature depends on the underlying * signature scheme. * * <p>This signature object is reset to its initial state (the state it * was in after a call to one of the <code>initSign</code> methods) and * can be reused to generate further signatures with the same private key. * * @param outbuf buffer for the signature result. * * @param offset offset into <code>outbuf</code> where the signature is * stored. * * @param len number of bytes within <code>outbuf</code> allotted for the * signature. * * @return the number of bytes placed into <code>outbuf</code>. * * @exception SignatureException if this signature object is not * initialized properly, if this signature algorithm is unable to * process the input data provided, or if <code>len</code> is less * than the actual signature length. * * @since 1.2 */ public final int sign(byte[] outbuf, int offset, int len) throws SignatureException { if (outbuf == null) { throw new IllegalArgumentException("No output buffer given"); } if (outbuf.length - offset < len) { throw new IllegalArgumentException ("Output buffer too small for specified offset and length"); } if (state != SIGN) { throw new SignatureException("object not initialized for " + "signing"); } return engineSign(outbuf, offset, len); } /** * Verifies the passed-in signature. * * <p>A call to this method resets this signature object to the state * it was in when previously initialized for verification via a * call to <code>initVerify(PublicKey)</code>. That is, the object is * reset and available to verify another signature from the identity * whose public key was specified in the call to <code>initVerify</code>. * * @param signature the signature bytes to be verified. * * @return true if the signature was verified, false if not. * * @exception SignatureException if this signature object is not * initialized properly, the passed-in signature is improperly * encoded or of the wrong type, if this signature algorithm is unable to * process the input data provided, etc. */ public final boolean verify(byte[] signature) throws SignatureException { if (state == VERIFY) { return engineVerify(signature); } throw new SignatureException("object not initialized for " + "verification"); } /** * Verifies the passed-in signature in the specified array * of bytes, starting at the specified offset. * * <p>A call to this method resets this signature object to the state * it was in when previously initialized for verification via a * call to <code>initVerify(PublicKey)</code>. That is, the object is * reset and available to verify another signature from the identity * whose public key was specified in the call to <code>initVerify</code>. * * * @param signature the signature bytes to be verified. * @param offset the offset to start from in the array of bytes. * @param length the number of bytes to use, starting at offset. * * @return true if the signature was verified, false if not. * * @exception SignatureException if this signature object is not * initialized properly, the passed-in signature is improperly * encoded or of the wrong type, if this signature algorithm is unable to * process the input data provided, etc. * @exception IllegalArgumentException if the <code>signature</code> * byte array is null, or the <code>offset</code> or <code>length</code> * is less than 0, or the sum of the <code>offset</code> and * <code>length</code> is greater than the length of the * <code>signature</code> byte array. * @since 1.4 */ public final boolean verify(byte[] signature, int offset, int length) throws SignatureException { if (state == VERIFY) { if ((signature == null) || (offset < 0) || (length < 0) || (offset + length > signature.length)) { throw new IllegalArgumentException("Bad arguments"); } return engineVerify(signature, offset, length); } throw new SignatureException("object not initialized for " + "verification"); } /** * Updates the data to be signed or verified by a byte. * * @param b the byte to use for the update. * * @exception SignatureException if this signature object is not * initialized properly. */ public final void update(byte b) throws SignatureException { if (state == VERIFY || state == SIGN) { engineUpdate(b); } else { throw new SignatureException("object not initialized for " + "signature or verification"); } } /** * Updates the data to be signed or verified, using the specified * array of bytes. * * @param data the byte array to use for the update. * * @exception SignatureException if this signature object is not * initialized properly. */ public final void update(byte[] data) throws SignatureException { update(data, 0, data.length); } /** * Updates the data to be signed or verified, using the specified * array of bytes, starting at the specified offset. * * @param data the array of bytes. * @param off the offset to start from in the array of bytes. * @param len the number of bytes to use, starting at offset. * * @exception SignatureException if this signature object is not * initialized properly. */ public final void update(byte[] data, int off, int len) throws SignatureException { if (state == SIGN || state == VERIFY) { engineUpdate(data, off, len); } else { throw new SignatureException("object not initialized for " + "signature or verification"); } } /** * Updates the data to be signed or verified using the specified * ByteBuffer. Processes the <code>data.remaining()</code> bytes * starting at at <code>data.position()</code>. * Upon return, the buffer's position will be equal to its limit; * its limit will not have changed. * * @param data the ByteBuffer * * @exception SignatureException if this signature object is not * initialized properly. * @since 1.5 */ public final void update(ByteBuffer data) throws SignatureException { if ((state != SIGN) && (state != VERIFY)) { throw new SignatureException("object not initialized for " + "signature or verification"); } if (data == null) { throw new NullPointerException(); } engineUpdate(data); } /** * Returns the name of the algorithm for this signature object. * * @return the name of the algorithm for this signature object. */ public final String getAlgorithm() { return this.algorithm; } /** * Returns a string representation of this signature object, * providing information that includes the state of the object * and the name of the algorithm used. * * @return a string representation of this signature object. */ public String toString() { String initState = ""; switch (state) { case UNINITIALIZED: initState = "<not initialized>"; break; case VERIFY: initState = "<initialized for verifying>"; break; case SIGN: initState = "<initialized for signing>"; break; } return "Signature object: " + getAlgorithm() + initState; } /** * Sets the specified algorithm parameter to the specified value. * This method supplies a general-purpose mechanism through * which it is possible to set the various parameters of this object. * A parameter may be any settable parameter for the algorithm, such as * a parameter size, or a source of random bits for signature generation * (if appropriate), or an indication of whether or not to perform * a specific but optional computation. A uniform algorithm-specific * naming scheme for each parameter is desirable but left unspecified * at this time. * * @param param the string identifier of the parameter. * @param value the parameter value. * * @exception InvalidParameterException if <code>param</code> is an * invalid parameter for this signature algorithm engine, * the parameter is already set * and cannot be set again, a security exception occurs, and so on. * * @see #getParameter * * @deprecated Use * {@link #setParameter(java.security.spec.AlgorithmParameterSpec) * setParameter}. */ @Deprecated public final void setParameter(String param, Object value) throws InvalidParameterException { engineSetParameter(param, value); } /** * Initializes this signature engine with the specified parameter set. * * @param params the parameters * * @exception InvalidAlgorithmParameterException if the given parameters * are inappropriate for this signature engine * * @see #getParameters */ public final void setParameter(AlgorithmParameterSpec params) throws InvalidAlgorithmParameterException { engineSetParameter(params); } /** * Returns the parameters used with this signature object. * * <p>The returned parameters may be the same that were used to initialize * this signature, or may contain a combination of default and randomly * generated parameter values used by the underlying signature * implementation if this signature requires algorithm parameters but * was not initialized with any. * * @return the parameters used with this signature, or null if this * signature does not use any parameters. * * @see #setParameter(AlgorithmParameterSpec) * @since 1.4 */ public final AlgorithmParameters getParameters() { return engineGetParameters(); } /** * Gets the value of the specified algorithm parameter. This method * supplies a general-purpose mechanism through which it is possible to * get the various parameters of this object. A parameter may be any * settable parameter for the algorithm, such as a parameter size, or * a source of random bits for signature generation (if appropriate), * or an indication of whether or not to perform a specific but optional * computation. A uniform algorithm-specific naming scheme for each * parameter is desirable but left unspecified at this time. * * @param param the string name of the parameter. * * @return the object that represents the parameter value, or null if * there is none. * * @exception InvalidParameterException if <code>param</code> is an invalid * parameter for this engine, or another exception occurs while * trying to get this parameter. * * @see #setParameter(String, Object) * * @deprecated */ @Deprecated public final Object getParameter(String param) throws InvalidParameterException { return engineGetParameter(param); } /** * Returns a clone if the implementation is cloneable. * * @return a clone if the implementation is cloneable. * * @exception CloneNotSupportedException if this is called * on an implementation that does not support <code>Cloneable</code>. */ public Object clone() throws CloneNotSupportedException { if (this instanceof Cloneable) { return super.clone(); } else { throw new CloneNotSupportedException(); } } /* * The following class allows providers to extend from SignatureSpi * rather than from Signature. It represents a Signature with an * encapsulated, provider-supplied SPI object (of type SignatureSpi). * If the provider implementation is an instance of SignatureSpi, the * getInstance() methods above return an instance of this class, with * the SPI object encapsulated. * * Note: All SPI methods from the original Signature class have been * moved up the hierarchy into a new class (SignatureSpi), which has * been interposed in the hierarchy between the API (Signature) * and its original parent (Object). */ private static class Delegate extends Signature { // The provider implementation (delegate) // filled in once the provider is selected private SignatureSpi sigSpi; // lock for mutex during provider selection private final Object lock; // next service to try in provider selection // null once provider is selected private Service firstService; // remaining services to try in provider selection // null once provider is selected private Iterator<Service> serviceIterator; // constructor Delegate(SignatureSpi sigSpi, String algorithm) { super(algorithm); this.sigSpi = sigSpi; this.lock = null; // no lock needed } // used with delayed provider selection Delegate(Service service, Iterator<Service> iterator, String algorithm) { super(algorithm); this.firstService = service; this.serviceIterator = iterator; this.lock = new Object(); } /** * Returns a clone if the delegate is cloneable. * * @return a clone if the delegate is cloneable. * * @exception CloneNotSupportedException if this is called on a * delegate that does not support <code>Cloneable</code>. */ public Object clone() throws CloneNotSupportedException { chooseFirstProvider(); if (sigSpi instanceof Cloneable) { SignatureSpi sigSpiClone = (SignatureSpi)sigSpi.clone(); // Because 'algorithm' and 'provider' are private // members of our supertype, we must perform a cast to // access them. Signature that = new Delegate(sigSpiClone, ((Signature)this).algorithm); that.provider = ((Signature)this).provider; return that; } else { throw new CloneNotSupportedException(); } } private static SignatureSpi newInstance(Service s) throws NoSuchAlgorithmException { if (s.getType().equals("Cipher")) { // must be NONEwithRSA try { Cipher c = Cipher.getInstance(RSA_CIPHER, s.getProvider()); return new CipherAdapter(c); } catch (NoSuchPaddingException e) { throw new NoSuchAlgorithmException(e); } } else { Object o = s.newInstance(null); if (o instanceof SignatureSpi == false) { throw new NoSuchAlgorithmException ("Not a SignatureSpi: " + o.getClass().getName()); } return (SignatureSpi)o; } } // max number of debug warnings to print from chooseFirstProvider() private static int warnCount = 10; /** * Choose the Spi from the first provider available. Used if * delayed provider selection is not possible because initSign()/ * initVerify() is not the first method called. */ void chooseFirstProvider() { if (sigSpi != null) { return; } synchronized (lock) { if (sigSpi != null) { return; } if (debug != null) { int w = --warnCount; if (w >= 0) { debug.println("Signature.init() not first method " + "called, disabling delayed provider selection"); if (w == 0) {