OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [classpath/] [javax/] [crypto/] [KeyAgreementSpi.java] - Blame information for rev 772

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 772 jeremybenn
/* KeyAgreementSpi.java -- The key agreement service provider interface.
2
   Copyright (C) 2004  Free Software Foundation, Inc.
3
 
4
This file is part of GNU Classpath.
5
 
6
GNU Classpath is free software; you can redistribute it and/or modify
7
it under the terms of the GNU General Public License as published by
8
the Free Software Foundation; either version 2, or (at your option)
9
any later version.
10
 
11
GNU Classpath is distributed in the hope that it will be useful, but
12
WITHOUT ANY WARRANTY; without even the implied warranty of
13
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
General Public License for more details.
15
 
16
You should have received a copy of the GNU General Public License
17
along with GNU Classpath; see the file COPYING.  If not, write to the
18
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19
02110-1301 USA.
20
 
21
Linking this library statically or dynamically with other modules is
22
making a combined work based on this library.  Thus, the terms and
23
conditions of the GNU General Public License cover the whole
24
combination.
25
 
26
As a special exception, the copyright holders of this library give you
27
permission to link this library with independent modules to produce an
28
executable, regardless of the license terms of these independent
29
modules, and to copy and distribute the resulting executable under
30
terms of your choice, provided that you also meet, for each linked
31
independent module, the terms and conditions of the license of that
32
module.  An independent module is a module which is not derived from
33
or based on this library.  If you modify this library, you may extend
34
this exception to your version of the library, but you are not
35
obligated to do so.  If you do not wish to do so, delete this
36
exception statement from your version. */
37
 
38
 
39
package javax.crypto;
40
 
41
import java.security.InvalidAlgorithmParameterException;
42
import java.security.InvalidKeyException;
43
import java.security.Key;
44
import java.security.NoSuchAlgorithmException;
45
import java.security.SecureRandom;
46
import java.security.spec.AlgorithmParameterSpec;
47
 
48
/**
49
 * This is the <i>Service Provider Interface</i> (<b>SPI</b>) for the
50
 * {@link javax.crypto.KeyAgreement} class.
51
 *
52
 * <p>Providers wishing to implement a key agreement algorithm must
53
 * subclass this and provide an appropriate implementation for all the
54
 * abstract methods below, and provide an appropriate entry in the
55
 * master {@link java.security.Provider} class (the service name for key
56
 * agreement algorithms is <code>"KeyAgreement"</code>).
57
 *
58
 * @author Casey Marshall (csm@gnu.org)
59
 * @since 1.4
60
 * @see KeyAgreement
61
 * @see SecretKey
62
 */
63
public abstract class KeyAgreementSpi
64
{
65
 
66
  // Constructor.
67
  // ------------------------------------------------------------------------
68
 
69
  /**
70
   * Create a new KeyAgreementSpi instance.
71
   */
72
  public KeyAgreementSpi()
73
  {
74
  }
75
 
76
  // Abstract instance methods.
77
  // ------------------------------------------------------------------------
78
 
79
  /**
80
   * Do a phase in the key agreement.
81
   *
82
   * @param key The key to use for this phase.
83
   * @param lastPhase <code>true</code> if this call should be the last
84
   *        phase.
85
   * @return The intermediate result, or <code>null</code> if there is
86
   *         no intermediate result.
87
   * @throws java.lang.IllegalStateException If this instance has not
88
   *         been initialized.
89
   * @throws java.security.InvalidKeyException If the supplied key is
90
   *         not appropriate.
91
   */
92
  protected abstract Key engineDoPhase(Key key, boolean lastPhase)
93
    throws IllegalStateException, InvalidKeyException;
94
 
95
  /**
96
   * Generate the shared secret in a new byte array.
97
   *
98
   * @return The shared secret in a new byte array.
99
   * @throws java.lang.IllegalStateException If this key agreement is
100
   *         not ready to generate the secret.
101
   */
102
  protected abstract byte[] engineGenerateSecret()
103
    throws IllegalStateException;
104
 
105
  /**
106
   * Generate the shared secret, storing it into the specified array.
107
   *
108
   * @param sharedSecret The byte array in which to store the secret.
109
   * @param offset       The offset into the byte array to start.
110
   * @return The size of the shared secret.
111
   * @throws java.lang.IllegalStateException If this key agreement is
112
   *         not ready to generate the secret.
113
   * @throws javax.crypto.ShortBufferException If there is not enough
114
   *         space in the supplied array for the shared secret.
115
   */
116
  protected abstract int engineGenerateSecret(byte[] sharedSecret, int offset)
117
    throws IllegalStateException, ShortBufferException;
118
 
119
  /**
120
   * Generate the shared secret and return it as a {@link SecretKey}.
121
   *
122
   * @param algorithm The algorithm with which to generate the secret key.
123
   * @return The shared secret as a secret key.
124
   * @throws java.lang.IllegalStateException If this key agreement is
125
   *         not ready to generate the secret.
126
   * @throws java.security.InvalidKeyException If the shared secret
127
   *         cannot be made into a {@link SecretKey}.
128
   * @throws java.security.NoSuchAlgorithmException If
129
   *         <code>algorithm</code> cannot be found.
130
   */
131
  protected abstract SecretKey engineGenerateSecret(String algorithm)
132
    throws IllegalStateException, InvalidKeyException, NoSuchAlgorithmException;
133
 
134
  /**
135
   * Initialize this key agreement with a key, parameters, and source of
136
   * randomness.
137
   *
138
   * @param key    The key to initialize with, usually a private key.
139
   * @param params The parameters to initialize with.
140
   * @param random The source of randomness to use.
141
   * @throws java.security.InvalidAlgorithmParameterException If the
142
   *         supplied parameters are inappropriate.
143
   * @throws java.security.InvalidKeyException If the supplied key is
144
   *         inappropriate.
145
   */
146
  protected abstract void engineInit(Key key, AlgorithmParameterSpec params,
147
                                     SecureRandom random)
148
    throws InvalidAlgorithmParameterException, InvalidKeyException;
149
 
150
  /**
151
   * Initialize this key agreement with a key and source of randomness.
152
   *
153
   * @param key    The key to initialize with, usually a private key.
154
   * @param random The source of randomness to use.
155
   * @throws java.security.InvalidKeyException If the supplied key is
156
   *         inappropriate.
157
   */
158
  protected abstract void engineInit(Key key, SecureRandom random)
159
    throws InvalidKeyException;
160
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.