jdk/src/java.base/share/classes/javax/crypto/Cipher.java
author vinnie
Thu, 25 Sep 2014 12:24:19 +0100
changeset 26736 5a93000b26cd
parent 25859 3317bb8137f4
child 26861 47dde7f5cf36
permissions -rw-r--r--
8056026: Debug security logging should print Provider used for each crypto operation Reviewed-by: mullan
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     1
/*
26736
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
     2
 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
90ce3da70b43 Initial load
duke
parents:
diff changeset
     4
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
90ce3da70b43 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 1692
diff changeset
     7
 * published by the Free Software Foundation.  Oracle designates this
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 1692
diff changeset
     9
 * by Oracle in the LICENSE file that accompanied this code.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    10
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    11
 * This code is distributed in the hope that it will be useful, but WITHOUT
90ce3da70b43 Initial load
duke
parents:
diff changeset
    12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
90ce3da70b43 Initial load
duke
parents:
diff changeset
    14
 * version 2 for more details (a copy is included in the LICENSE file that
90ce3da70b43 Initial load
duke
parents:
diff changeset
    15
 * accompanied this code).
90ce3da70b43 Initial load
duke
parents:
diff changeset
    16
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    17
 * You should have received a copy of the GNU General Public License version
90ce3da70b43 Initial load
duke
parents:
diff changeset
    18
 * 2 along with this work; if not, write to the Free Software Foundation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    20
 *
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 1692
diff changeset
    21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 1692
diff changeset
    22
 * or visit www.oracle.com if you need additional information or have any
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 1692
diff changeset
    23
 * questions.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    24
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    25
90ce3da70b43 Initial load
duke
parents:
diff changeset
    26
package javax.crypto;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    27
90ce3da70b43 Initial load
duke
parents:
diff changeset
    28
import java.util.*;
11671
60fdf1412864 7092825: javax.crypto.Cipher.Transform.patternCache is synchronizedMap and became scalability bottleneck.
valeriep
parents: 10336
diff changeset
    29
import java.util.concurrent.ConcurrentHashMap;
60fdf1412864 7092825: javax.crypto.Cipher.Transform.patternCache is synchronizedMap and became scalability bottleneck.
valeriep
parents: 10336
diff changeset
    30
import java.util.concurrent.ConcurrentMap;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    31
import java.util.regex.*;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    32
90ce3da70b43 Initial load
duke
parents:
diff changeset
    33
90ce3da70b43 Initial load
duke
parents:
diff changeset
    34
import java.security.*;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    35
import java.security.Provider.Service;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    36
import java.security.spec.AlgorithmParameterSpec;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    37
import java.security.spec.InvalidParameterSpecException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    38
import java.security.cert.Certificate;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    39
import java.security.cert.X509Certificate;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    40
90ce3da70b43 Initial load
duke
parents:
diff changeset
    41
import javax.crypto.spec.*;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    42
90ce3da70b43 Initial load
duke
parents:
diff changeset
    43
import java.nio.ByteBuffer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    44
import java.nio.ReadOnlyBufferException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    45
90ce3da70b43 Initial load
duke
parents:
diff changeset
    46
import sun.security.util.Debug;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    47
import sun.security.jca.*;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    48
90ce3da70b43 Initial load
duke
parents:
diff changeset
    49
/**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    50
 * This class provides the functionality of a cryptographic cipher for
90ce3da70b43 Initial load
duke
parents:
diff changeset
    51
 * encryption and decryption. It forms the core of the Java Cryptographic
90ce3da70b43 Initial load
duke
parents:
diff changeset
    52
 * Extension (JCE) framework.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    53
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    54
 * <p>In order to create a Cipher object, the application calls the
90ce3da70b43 Initial load
duke
parents:
diff changeset
    55
 * Cipher's <code>getInstance</code> method, and passes the name of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
    56
 * requested <i>transformation</i> to it. Optionally, the name of a provider
90ce3da70b43 Initial load
duke
parents:
diff changeset
    57
 * may be specified.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    58
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    59
 * <p>A <i>transformation</i> is a string that describes the operation (or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    60
 * set of operations) to be performed on the given input, to produce some
90ce3da70b43 Initial load
duke
parents:
diff changeset
    61
 * output. A transformation always includes the name of a cryptographic
90ce3da70b43 Initial load
duke
parents:
diff changeset
    62
 * algorithm (e.g., <i>DES</i>), and may be followed by a feedback mode and
90ce3da70b43 Initial load
duke
parents:
diff changeset
    63
 * padding scheme.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    64
 *
21955
abc02575919c 8029475: Fix more doclint issues in javax.security
darcy
parents: 18771
diff changeset
    65
 * <p> A transformation is of the form:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    66
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    67
 * <ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    68
 * <li>"<i>algorithm/mode/padding</i>" or
21955
abc02575919c 8029475: Fix more doclint issues in javax.security
darcy
parents: 18771
diff changeset
    69
 *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    70
 * <li>"<i>algorithm</i>"
90ce3da70b43 Initial load
duke
parents:
diff changeset
    71
 * </ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    72
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    73
 * <P> (in the latter case,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    74
 * provider-specific default values for the mode and padding scheme are used).
21955
abc02575919c 8029475: Fix more doclint issues in javax.security
darcy
parents: 18771
diff changeset
    75
 * For example, the following is a valid transformation:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    76
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    77
 * <pre>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    78
 *     Cipher c = Cipher.getInstance("<i>DES/CBC/PKCS5Padding</i>");
90ce3da70b43 Initial load
duke
parents:
diff changeset
    79
 * </pre>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    80
 *
8152
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
    81
 * Using modes such as <code>CFB</code> and <code>OFB</code>, block
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    82
 * ciphers can encrypt data in units smaller than the cipher's actual
90ce3da70b43 Initial load
duke
parents:
diff changeset
    83
 * block size.  When requesting such a mode, you may optionally specify
90ce3da70b43 Initial load
duke
parents:
diff changeset
    84
 * the number of bits to be processed at a time by appending this number
90ce3da70b43 Initial load
duke
parents:
diff changeset
    85
 * to the mode name as shown in the "<code>DES/CFB8/NoPadding</code>" and
90ce3da70b43 Initial load
duke
parents:
diff changeset
    86
 * "<code>DES/OFB32/PKCS5Padding</code>" transformations. If no such
90ce3da70b43 Initial load
duke
parents:
diff changeset
    87
 * number is specified, a provider-specific default is used. (For
90ce3da70b43 Initial load
duke
parents:
diff changeset
    88
 * example, the SunJCE provider uses a default of 64 bits for DES.)
90ce3da70b43 Initial load
duke
parents:
diff changeset
    89
 * Thus, block ciphers can be turned into byte-oriented stream ciphers by
90ce3da70b43 Initial load
duke
parents:
diff changeset
    90
 * using an 8 bit mode such as CFB8 or OFB8.
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
    91
 * <p>
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
    92
 * Modes such as Authenticated Encryption with Associated Data (AEAD)
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
    93
 * provide authenticity assurances for both confidential data and
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
    94
 * Additional Associated Data (AAD) that is not encrypted.  (Please see
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
    95
 * <a href="http://www.ietf.org/rfc/rfc5116.txt"> RFC 5116 </a> for more
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
    96
 * information on AEAD and AEAD algorithms such as GCM/CCM.) Both
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
    97
 * confidential and AAD data can be used when calculating the
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
    98
 * authentication tag (similar to a {@link Mac}).  This tag is appended
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
    99
 * to the ciphertext during encryption, and is verified on decryption.
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
   100
 * <p>
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
   101
 * AEAD modes such as GCM/CCM perform all AAD authenticity calculations
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
   102
 * before starting the ciphertext authenticity calculations.  To avoid
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
   103
 * implementations having to internally buffer ciphertext, all AAD data
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
   104
 * must be supplied to GCM/CCM implementations (via the {@code
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
   105
 * updateAAD} methods) <b>before</b> the ciphertext is processed (via
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
   106
 * the {@code update} and {@code doFinal} methods).
15008
6a494f8ba5b5 6996769: support AEAD cipher
valeriep
parents: 11671
diff changeset
   107
 * <p>
6a494f8ba5b5 6996769: support AEAD cipher
valeriep
parents: 11671
diff changeset
   108
 * Note that GCM mode has a uniqueness requirement on IVs used in
6a494f8ba5b5 6996769: support AEAD cipher
valeriep
parents: 11671
diff changeset
   109
 * encryption with a given key. When IVs are repeated for GCM
6a494f8ba5b5 6996769: support AEAD cipher
valeriep
parents: 11671
diff changeset
   110
 * encryption, such usages are subject to forgery attacks. Thus, after
6a494f8ba5b5 6996769: support AEAD cipher
valeriep
parents: 11671
diff changeset
   111
 * each encryption operation using GCM mode, callers should re-initialize
6a494f8ba5b5 6996769: support AEAD cipher
valeriep
parents: 11671
diff changeset
   112
 * the cipher objects with GCM parameters which has a different IV value.
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
   113
 * <pre>
15008
6a494f8ba5b5 6996769: support AEAD cipher
valeriep
parents: 11671
diff changeset
   114
 *     GCMParameterSpec s = ...;
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
   115
 *     cipher.init(..., s);
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
   116
 *
15008
6a494f8ba5b5 6996769: support AEAD cipher
valeriep
parents: 11671
diff changeset
   117
 *     // If the GCM parameters were generated by the provider, it can
6a494f8ba5b5 6996769: support AEAD cipher
valeriep
parents: 11671
diff changeset
   118
 *     // be retrieved by:
6a494f8ba5b5 6996769: support AEAD cipher
valeriep
parents: 11671
diff changeset
   119
 *     // cipher.getParameters().getParameterSpec(GCMParameterSpec.class);
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
   120
 *
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
   121
 *     cipher.updateAAD(...);  // AAD
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
   122
 *     cipher.update(...);     // Multi-part update
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
   123
 *     cipher.doFinal(...);    // conclusion of operation
15008
6a494f8ba5b5 6996769: support AEAD cipher
valeriep
parents: 11671
diff changeset
   124
 *
6a494f8ba5b5 6996769: support AEAD cipher
valeriep
parents: 11671
diff changeset
   125
 *     // Use a different IV value for every encryption
6a494f8ba5b5 6996769: support AEAD cipher
valeriep
parents: 11671
diff changeset
   126
 *     byte[] newIv = ...;
6a494f8ba5b5 6996769: support AEAD cipher
valeriep
parents: 11671
diff changeset
   127
 *     s = new GCMParameterSpec(s.getTLen(), newIv);
6a494f8ba5b5 6996769: support AEAD cipher
valeriep
parents: 11671
diff changeset
   128
 *     cipher.init(..., s);
6a494f8ba5b5 6996769: support AEAD cipher
valeriep
parents: 11671
diff changeset
   129
 *     ...
6a494f8ba5b5 6996769: support AEAD cipher
valeriep
parents: 11671
diff changeset
   130
 *
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
   131
 * </pre>
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
   132
 * Every implementation of the Java platform is required to support
8152
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   133
 * the following standard <code>Cipher</code> transformations with the keysizes
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   134
 * in parentheses:
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   135
 * <ul>
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   136
 * <li><tt>AES/CBC/NoPadding</tt> (128)</li>
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   137
 * <li><tt>AES/CBC/PKCS5Padding</tt> (128)</li>
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   138
 * <li><tt>AES/ECB/NoPadding</tt> (128)</li>
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   139
 * <li><tt>AES/ECB/PKCS5Padding</tt> (128)</li>
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   140
 * <li><tt>DES/CBC/NoPadding</tt> (56)</li>
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   141
 * <li><tt>DES/CBC/PKCS5Padding</tt> (56)</li>
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   142
 * <li><tt>DES/ECB/NoPadding</tt> (56)</li>
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   143
 * <li><tt>DES/ECB/PKCS5Padding</tt> (56)</li>
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   144
 * <li><tt>DESede/CBC/NoPadding</tt> (168)</li>
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   145
 * <li><tt>DESede/CBC/PKCS5Padding</tt> (168)</li>
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   146
 * <li><tt>DESede/ECB/NoPadding</tt> (168)</li>
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   147
 * <li><tt>DESede/ECB/PKCS5Padding</tt> (168)</li>
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   148
 * <li><tt>RSA/ECB/PKCS1Padding</tt> (1024, 2048)</li>
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   149
 * <li><tt>RSA/ECB/OAEPWithSHA-1AndMGF1Padding</tt> (1024, 2048)</li>
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   150
 * <li><tt>RSA/ECB/OAEPWithSHA-256AndMGF1Padding</tt> (1024, 2048)</li>
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   151
 * </ul>
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   152
 * These transformations are described in the
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   153
 * <a href="{@docRoot}/../technotes/guides/security/StandardNames.html#Cipher">
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   154
 * Cipher section</a> of the
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   155
 * Java Cryptography Architecture Standard Algorithm Name Documentation.
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   156
 * Consult the release documentation for your implementation to see if any
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   157
 * other transformations are supported.
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   158
 *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   159
 * @author Jan Luehe
90ce3da70b43 Initial load
duke
parents:
diff changeset
   160
 * @see KeyGenerator
90ce3da70b43 Initial load
duke
parents:
diff changeset
   161
 * @see SecretKey
90ce3da70b43 Initial load
duke
parents:
diff changeset
   162
 * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   163
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   164
90ce3da70b43 Initial load
duke
parents:
diff changeset
   165
public class Cipher {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   166
90ce3da70b43 Initial load
duke
parents:
diff changeset
   167
    private static final Debug debug =
90ce3da70b43 Initial load
duke
parents:
diff changeset
   168
                        Debug.getInstance("jca", "Cipher");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   169
26736
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
   170
    private static final Debug pdebug =
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
   171
                        Debug.getInstance("provider", "Provider");
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
   172
    private static final boolean skipDebug =
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
   173
        Debug.isOn("engine=") && !Debug.isOn("cipher");
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
   174
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   175
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   176
     * Constant used to initialize cipher to encryption mode.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   177
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   178
    public static final int ENCRYPT_MODE = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   179
90ce3da70b43 Initial load
duke
parents:
diff changeset
   180
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   181
     * Constant used to initialize cipher to decryption mode.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   182
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   183
    public static final int DECRYPT_MODE = 2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   184
90ce3da70b43 Initial load
duke
parents:
diff changeset
   185
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   186
     * Constant used to initialize cipher to key-wrapping mode.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   187
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   188
    public static final int WRAP_MODE = 3;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   189
90ce3da70b43 Initial load
duke
parents:
diff changeset
   190
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   191
     * Constant used to initialize cipher to key-unwrapping mode.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   192
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   193
    public static final int UNWRAP_MODE = 4;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   194
90ce3da70b43 Initial load
duke
parents:
diff changeset
   195
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   196
     * Constant used to indicate the to-be-unwrapped key is a "public key".
90ce3da70b43 Initial load
duke
parents:
diff changeset
   197
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   198
    public static final int PUBLIC_KEY = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   199
90ce3da70b43 Initial load
duke
parents:
diff changeset
   200
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   201
     * Constant used to indicate the to-be-unwrapped key is a "private key".
90ce3da70b43 Initial load
duke
parents:
diff changeset
   202
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   203
    public static final int PRIVATE_KEY = 2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   204
90ce3da70b43 Initial load
duke
parents:
diff changeset
   205
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   206
     * Constant used to indicate the to-be-unwrapped key is a "secret key".
90ce3da70b43 Initial load
duke
parents:
diff changeset
   207
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   208
    public static final int SECRET_KEY = 3;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   209
90ce3da70b43 Initial load
duke
parents:
diff changeset
   210
    // The provider
90ce3da70b43 Initial load
duke
parents:
diff changeset
   211
    private Provider provider;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   212
90ce3da70b43 Initial load
duke
parents:
diff changeset
   213
    // The provider implementation (delegate)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   214
    private CipherSpi spi;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   215
90ce3da70b43 Initial load
duke
parents:
diff changeset
   216
    // The transformation
90ce3da70b43 Initial load
duke
parents:
diff changeset
   217
    private String transformation;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   218
90ce3da70b43 Initial load
duke
parents:
diff changeset
   219
    // Crypto permission representing the maximum allowable cryptographic
90ce3da70b43 Initial load
duke
parents:
diff changeset
   220
    // strength that this Cipher object can be used for. (The cryptographic
90ce3da70b43 Initial load
duke
parents:
diff changeset
   221
    // strength is a function of the keysize and algorithm parameters encoded
90ce3da70b43 Initial load
duke
parents:
diff changeset
   222
    // in the crypto permission.)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   223
    private CryptoPermission cryptoPerm;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   224
90ce3da70b43 Initial load
duke
parents:
diff changeset
   225
    // The exemption mechanism that needs to be enforced
90ce3da70b43 Initial load
duke
parents:
diff changeset
   226
    private ExemptionMechanism exmech;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   227
90ce3da70b43 Initial load
duke
parents:
diff changeset
   228
    // Flag which indicates whether or not this cipher has been initialized
90ce3da70b43 Initial load
duke
parents:
diff changeset
   229
    private boolean initialized = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   230
90ce3da70b43 Initial load
duke
parents:
diff changeset
   231
    // The operation mode - store the operation mode after the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   232
    // cipher has been initialized.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   233
    private int opmode = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   234
90ce3da70b43 Initial load
duke
parents:
diff changeset
   235
    // The OID for the KeyUsage extension in an X.509 v3 certificate
90ce3da70b43 Initial load
duke
parents:
diff changeset
   236
    private static final String KEY_USAGE_EXTENSION_OID = "2.5.29.15";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   237
90ce3da70b43 Initial load
duke
parents:
diff changeset
   238
    // next SPI  to try in provider selection
90ce3da70b43 Initial load
duke
parents:
diff changeset
   239
    // null once provider is selected
90ce3da70b43 Initial load
duke
parents:
diff changeset
   240
    private CipherSpi firstSpi;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   241
90ce3da70b43 Initial load
duke
parents:
diff changeset
   242
    // next service to try in provider selection
90ce3da70b43 Initial load
duke
parents:
diff changeset
   243
    // null once provider is selected
90ce3da70b43 Initial load
duke
parents:
diff changeset
   244
    private Service firstService;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   245
90ce3da70b43 Initial load
duke
parents:
diff changeset
   246
    // remaining services to try in provider selection
90ce3da70b43 Initial load
duke
parents:
diff changeset
   247
    // null once provider is selected
10336
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
   248
    private Iterator<Service> serviceIterator;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   249
90ce3da70b43 Initial load
duke
parents:
diff changeset
   250
    // list of transform Strings to lookup in the provider
10336
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
   251
    private List<Transform> transforms;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   252
90ce3da70b43 Initial load
duke
parents:
diff changeset
   253
    private final Object lock;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   254
90ce3da70b43 Initial load
duke
parents:
diff changeset
   255
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   256
     * Creates a Cipher object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   257
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   258
     * @param cipherSpi the delegate
90ce3da70b43 Initial load
duke
parents:
diff changeset
   259
     * @param provider the provider
90ce3da70b43 Initial load
duke
parents:
diff changeset
   260
     * @param transformation the transformation
90ce3da70b43 Initial load
duke
parents:
diff changeset
   261
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   262
    protected Cipher(CipherSpi cipherSpi,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   263
                     Provider provider,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   264
                     String transformation) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   265
        // See bug 4341369 & 4334690 for more info.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   266
        // If the caller is trusted, then okey.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   267
        // Otherwise throw a NullPointerException.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   268
        if (!JceSecurityManager.INSTANCE.isCallerTrusted()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   269
            throw new NullPointerException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   270
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   271
        this.spi = cipherSpi;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   272
        this.provider = provider;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   273
        this.transformation = transformation;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   274
        this.cryptoPerm = CryptoAllPermission.INSTANCE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   275
        this.lock = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   276
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   277
90ce3da70b43 Initial load
duke
parents:
diff changeset
   278
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   279
     * Creates a Cipher object. Called internally and by NullCipher.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   280
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   281
     * @param cipherSpi the delegate
90ce3da70b43 Initial load
duke
parents:
diff changeset
   282
     * @param transformation the transformation
90ce3da70b43 Initial load
duke
parents:
diff changeset
   283
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   284
    Cipher(CipherSpi cipherSpi, String transformation) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   285
        this.spi = cipherSpi;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   286
        this.transformation = transformation;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   287
        this.cryptoPerm = CryptoAllPermission.INSTANCE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   288
        this.lock = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   289
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   290
90ce3da70b43 Initial load
duke
parents:
diff changeset
   291
    private Cipher(CipherSpi firstSpi, Service firstService,
10336
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
   292
            Iterator<Service> serviceIterator, String transformation,
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
   293
            List<Transform> transforms) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   294
        this.firstSpi = firstSpi;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   295
        this.firstService = firstService;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   296
        this.serviceIterator = serviceIterator;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   297
        this.transforms = transforms;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   298
        this.transformation = transformation;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   299
        this.lock = new Object();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   300
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   301
90ce3da70b43 Initial load
duke
parents:
diff changeset
   302
    private static String[] tokenizeTransformation(String transformation)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   303
            throws NoSuchAlgorithmException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   304
        if (transformation == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   305
            throw new NoSuchAlgorithmException("No transformation given");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   306
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   307
        /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   308
         * array containing the components of a Cipher transformation:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   309
         *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   310
         * index 0: algorithm component (e.g., DES)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   311
         * index 1: feedback component (e.g., CFB)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   312
         * index 2: padding component (e.g., PKCS5Padding)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   313
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   314
        String[] parts = new String[3];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   315
        int count = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   316
        StringTokenizer parser = new StringTokenizer(transformation, "/");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   317
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   318
            while (parser.hasMoreTokens() && count < 3) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   319
                parts[count++] = parser.nextToken().trim();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   320
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   321
            if (count == 0 || count == 2 || parser.hasMoreTokens()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   322
                throw new NoSuchAlgorithmException("Invalid transformation"
90ce3da70b43 Initial load
duke
parents:
diff changeset
   323
                                               + " format:" +
90ce3da70b43 Initial load
duke
parents:
diff changeset
   324
                                               transformation);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   325
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   326
        } catch (NoSuchElementException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   327
            throw new NoSuchAlgorithmException("Invalid transformation " +
90ce3da70b43 Initial load
duke
parents:
diff changeset
   328
                                           "format:" + transformation);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   329
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   330
        if ((parts[0] == null) || (parts[0].length() == 0)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   331
            throw new NoSuchAlgorithmException("Invalid transformation:" +
90ce3da70b43 Initial load
duke
parents:
diff changeset
   332
                                   "algorithm not specified-"
90ce3da70b43 Initial load
duke
parents:
diff changeset
   333
                                   + transformation);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   334
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   335
        return parts;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   336
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   337
90ce3da70b43 Initial load
duke
parents:
diff changeset
   338
    // Provider attribute name for supported chaining mode
90ce3da70b43 Initial load
duke
parents:
diff changeset
   339
    private final static String ATTR_MODE = "SupportedModes";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   340
    // Provider attribute name for supported padding names
90ce3da70b43 Initial load
duke
parents:
diff changeset
   341
    private final static String ATTR_PAD  = "SupportedPaddings";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   342
90ce3da70b43 Initial load
duke
parents:
diff changeset
   343
    // constants indicating whether the provider supports
90ce3da70b43 Initial load
duke
parents:
diff changeset
   344
    // a given mode or padding
90ce3da70b43 Initial load
duke
parents:
diff changeset
   345
    private final static int S_NO    = 0;       // does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
   346
    private final static int S_MAYBE = 1;       // unable to determine
90ce3da70b43 Initial load
duke
parents:
diff changeset
   347
    private final static int S_YES   = 2;       // does support
90ce3da70b43 Initial load
duke
parents:
diff changeset
   348
90ce3da70b43 Initial load
duke
parents:
diff changeset
   349
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   350
     * Nested class to deal with modes and paddings.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   351
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   352
    private static class Transform {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   353
        // transform string to lookup in the provider
90ce3da70b43 Initial load
duke
parents:
diff changeset
   354
        final String transform;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   355
        // the mode/padding suffix in upper case. for example, if the algorithm
90ce3da70b43 Initial load
duke
parents:
diff changeset
   356
        // to lookup is "DES/CBC/PKCS5Padding" suffix is "/CBC/PKCS5PADDING"
90ce3da70b43 Initial load
duke
parents:
diff changeset
   357
        // if loopup is "DES", suffix is the empty string
90ce3da70b43 Initial load
duke
parents:
diff changeset
   358
        // needed because aliases prevent straight transform.equals()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   359
        final String suffix;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   360
        // value to pass to setMode() or null if no such call required
90ce3da70b43 Initial load
duke
parents:
diff changeset
   361
        final String mode;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   362
        // value to pass to setPadding() or null if no such call required
90ce3da70b43 Initial load
duke
parents:
diff changeset
   363
        final String pad;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   364
        Transform(String alg, String suffix, String mode, String pad) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   365
            this.transform = alg + suffix;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   366
            this.suffix = suffix.toUpperCase(Locale.ENGLISH);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   367
            this.mode = mode;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   368
            this.pad = pad;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   369
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   370
        // set mode and padding for the given SPI
90ce3da70b43 Initial load
duke
parents:
diff changeset
   371
        void setModePadding(CipherSpi spi) throws NoSuchAlgorithmException,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   372
                NoSuchPaddingException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   373
            if (mode != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   374
                spi.engineSetMode(mode);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   375
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   376
            if (pad != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   377
                spi.engineSetPadding(pad);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   378
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   379
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   380
        // check whether the given services supports the mode and
90ce3da70b43 Initial load
duke
parents:
diff changeset
   381
        // padding described by this Transform
90ce3da70b43 Initial load
duke
parents:
diff changeset
   382
        int supportsModePadding(Service s) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   383
            int smode = supportsMode(s);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   384
            if (smode == S_NO) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   385
                return smode;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   386
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   387
            int spad = supportsPadding(s);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   388
            // our constants are defined so that Math.min() is a tri-valued AND
90ce3da70b43 Initial load
duke
parents:
diff changeset
   389
            return Math.min(smode, spad);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   390
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   391
90ce3da70b43 Initial load
duke
parents:
diff changeset
   392
        // separate methods for mode and padding
90ce3da70b43 Initial load
duke
parents:
diff changeset
   393
        // called directly by Cipher only to throw the correct exception
90ce3da70b43 Initial load
duke
parents:
diff changeset
   394
        int supportsMode(Service s) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   395
            return supports(s, ATTR_MODE, mode);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   396
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   397
        int supportsPadding(Service s) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   398
            return supports(s, ATTR_PAD, pad);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   399
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   400
90ce3da70b43 Initial load
duke
parents:
diff changeset
   401
        private static int supports(Service s, String attrName, String value) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   402
            if (value == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   403
                return S_YES;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   404
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   405
            String regexp = s.getAttribute(attrName);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   406
            if (regexp == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   407
                return S_MAYBE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   408
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   409
            return matches(regexp, value) ? S_YES : S_NO;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   410
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   411
11671
60fdf1412864 7092825: javax.crypto.Cipher.Transform.patternCache is synchronizedMap and became scalability bottleneck.
valeriep
parents: 10336
diff changeset
   412
        // ConcurrentMap<String,Pattern> for previously compiled patterns
60fdf1412864 7092825: javax.crypto.Cipher.Transform.patternCache is synchronizedMap and became scalability bottleneck.
valeriep
parents: 10336
diff changeset
   413
        private final static ConcurrentMap<String, Pattern> patternCache =
60fdf1412864 7092825: javax.crypto.Cipher.Transform.patternCache is synchronizedMap and became scalability bottleneck.
valeriep
parents: 10336
diff changeset
   414
            new ConcurrentHashMap<String, Pattern>();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   415
90ce3da70b43 Initial load
duke
parents:
diff changeset
   416
        private static boolean matches(String regexp, String str) {
10336
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
   417
            Pattern pattern = patternCache.get(regexp);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   418
            if (pattern == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   419
                pattern = Pattern.compile(regexp);
11671
60fdf1412864 7092825: javax.crypto.Cipher.Transform.patternCache is synchronizedMap and became scalability bottleneck.
valeriep
parents: 10336
diff changeset
   420
                patternCache.putIfAbsent(regexp, pattern);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   421
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   422
            return pattern.matcher(str.toUpperCase(Locale.ENGLISH)).matches();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   423
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   424
90ce3da70b43 Initial load
duke
parents:
diff changeset
   425
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   426
10336
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
   427
    private static List<Transform> getTransforms(String transformation)
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   428
            throws NoSuchAlgorithmException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   429
        String[] parts = tokenizeTransformation(transformation);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   430
90ce3da70b43 Initial load
duke
parents:
diff changeset
   431
        String alg = parts[0];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   432
        String mode = parts[1];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   433
        String pad = parts[2];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   434
        if ((mode != null) && (mode.length() == 0)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   435
            mode = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   436
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   437
        if ((pad != null) && (pad.length() == 0)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   438
            pad = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   439
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   440
90ce3da70b43 Initial load
duke
parents:
diff changeset
   441
        if ((mode == null) && (pad == null)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   442
            // DES
90ce3da70b43 Initial load
duke
parents:
diff changeset
   443
            Transform tr = new Transform(alg, "", null, null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   444
            return Collections.singletonList(tr);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   445
        } else { // if ((mode != null) && (pad != null)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   446
            // DES/CBC/PKCS5Padding
10336
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
   447
            List<Transform> list = new ArrayList<>(4);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   448
            list.add(new Transform(alg, "/" + mode + "/" + pad, null, null));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   449
            list.add(new Transform(alg, "/" + mode, null, pad));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   450
            list.add(new Transform(alg, "//" + pad, mode, null));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   451
            list.add(new Transform(alg, "", mode, pad));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   452
            return list;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   453
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   454
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   455
90ce3da70b43 Initial load
duke
parents:
diff changeset
   456
    // get the transform matching the specified service
10336
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
   457
    private static Transform getTransform(Service s,
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
   458
                                          List<Transform> transforms) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   459
        String alg = s.getAlgorithm().toUpperCase(Locale.ENGLISH);
10336
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
   460
        for (Transform tr : transforms) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   461
            if (alg.endsWith(tr.suffix)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   462
                return tr;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   463
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   464
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   465
        return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   466
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   467
90ce3da70b43 Initial load
duke
parents:
diff changeset
   468
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   469
     * Returns a <code>Cipher</code> object that implements the specified
90ce3da70b43 Initial load
duke
parents:
diff changeset
   470
     * transformation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   471
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   472
     * <p> This method traverses the list of registered security Providers,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   473
     * starting with the most preferred Provider.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   474
     * A new Cipher object encapsulating the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   475
     * CipherSpi implementation from the first
90ce3da70b43 Initial load
duke
parents:
diff changeset
   476
     * Provider that supports the specified algorithm is returned.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   477
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   478
     * <p> Note that the list of registered providers may be retrieved via
90ce3da70b43 Initial load
duke
parents:
diff changeset
   479
     * the {@link Security#getProviders() Security.getProviders()} method.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   480
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   481
     * @param transformation the name of the transformation, e.g.,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   482
     * <i>DES/CBC/PKCS5Padding</i>.
8152
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   483
     * See the Cipher section in the <a href=
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   484
     *   "{@docRoot}/../technotes/guides/security/StandardNames.html#Cipher">
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   485
     * Java Cryptography Architecture Standard Algorithm Name Documentation</a>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   486
     * for information about standard transformation names.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   487
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   488
     * @return a cipher that implements the requested transformation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   489
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   490
     * @exception NoSuchAlgorithmException if <code>transformation</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   491
     *          is null, empty, in an invalid format,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   492
     *          or if no Provider supports a CipherSpi implementation for the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   493
     *          specified algorithm.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   494
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   495
     * @exception NoSuchPaddingException if <code>transformation</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   496
     *          contains a padding scheme that is not available.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   497
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   498
     * @see java.security.Provider
90ce3da70b43 Initial load
duke
parents:
diff changeset
   499
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   500
    public static final Cipher getInstance(String transformation)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   501
            throws NoSuchAlgorithmException, NoSuchPaddingException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   502
    {
10336
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
   503
        List<Transform> transforms = getTransforms(transformation);
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
   504
        List<ServiceId> cipherServices = new ArrayList<>(transforms.size());
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
   505
        for (Transform transform : transforms) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   506
            cipherServices.add(new ServiceId("Cipher", transform.transform));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   507
        }
10336
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
   508
        List<Service> services = GetInstance.getServices(cipherServices);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   509
        // make sure there is at least one service from a signed provider
90ce3da70b43 Initial load
duke
parents:
diff changeset
   510
        // and that it can use the specified mode and padding
10336
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
   511
        Iterator<Service> t = services.iterator();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   512
        Exception failure = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   513
        while (t.hasNext()) {
10336
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
   514
            Service s = t.next();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   515
            if (JceSecurity.canUseProvider(s.getProvider()) == false) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   516
                continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   517
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   518
            Transform tr = getTransform(s, transforms);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   519
            if (tr == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   520
                // should never happen
90ce3da70b43 Initial load
duke
parents:
diff changeset
   521
                continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   522
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   523
            int canuse = tr.supportsModePadding(s);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   524
            if (canuse == S_NO) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   525
                // does not support mode or padding we need, ignore
90ce3da70b43 Initial load
duke
parents:
diff changeset
   526
                continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   527
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   528
            if (canuse == S_YES) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   529
                return new Cipher(null, s, t, transformation, transforms);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   530
            } else { // S_MAYBE, try out if it works
90ce3da70b43 Initial load
duke
parents:
diff changeset
   531
                try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   532
                    CipherSpi spi = (CipherSpi)s.newInstance(null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   533
                    tr.setModePadding(spi);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   534
                    return new Cipher(spi, s, t, transformation, transforms);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   535
                } catch (Exception e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   536
                    failure = e;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   537
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   538
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   539
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   540
        throw new NoSuchAlgorithmException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   541
            ("Cannot find any provider supporting " + transformation, failure);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   542
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   543
90ce3da70b43 Initial load
duke
parents:
diff changeset
   544
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   545
     * Returns a <code>Cipher</code> object that implements the specified
90ce3da70b43 Initial load
duke
parents:
diff changeset
   546
     * transformation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   547
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   548
     * <p> A new Cipher object encapsulating the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   549
     * CipherSpi implementation from the specified provider
90ce3da70b43 Initial load
duke
parents:
diff changeset
   550
     * is returned.  The specified provider must be registered
90ce3da70b43 Initial load
duke
parents:
diff changeset
   551
     * in the security provider list.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   552
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   553
     * <p> Note that the list of registered providers may be retrieved via
90ce3da70b43 Initial load
duke
parents:
diff changeset
   554
     * the {@link Security#getProviders() Security.getProviders()} method.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   555
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   556
     * @param transformation the name of the transformation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   557
     * e.g., <i>DES/CBC/PKCS5Padding</i>.
8152
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   558
     * See the Cipher section in the <a href=
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   559
     *   "{@docRoot}/../technotes/guides/security/StandardNames.html#Cipher">
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   560
     * Java Cryptography Architecture Standard Algorithm Name Documentation</a>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   561
     * for information about standard transformation names.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   562
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   563
     * @param provider the name of the provider.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   564
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   565
     * @return a cipher that implements the requested transformation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   566
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   567
     * @exception NoSuchAlgorithmException if <code>transformation</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   568
     *          is null, empty, in an invalid format,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   569
     *          or if a CipherSpi implementation for the specified algorithm
90ce3da70b43 Initial load
duke
parents:
diff changeset
   570
     *          is not available from the specified provider.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   571
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   572
     * @exception NoSuchProviderException if the specified provider is not
90ce3da70b43 Initial load
duke
parents:
diff changeset
   573
     *          registered in the security provider list.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   574
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   575
     * @exception NoSuchPaddingException if <code>transformation</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   576
     *          contains a padding scheme that is not available.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   577
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   578
     * @exception IllegalArgumentException if the <code>provider</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   579
     *          is null or empty.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   580
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   581
     * @see java.security.Provider
90ce3da70b43 Initial load
duke
parents:
diff changeset
   582
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   583
    public static final Cipher getInstance(String transformation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   584
                                           String provider)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   585
            throws NoSuchAlgorithmException, NoSuchProviderException,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   586
            NoSuchPaddingException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   587
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   588
        if ((provider == null) || (provider.length() == 0)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   589
            throw new IllegalArgumentException("Missing provider");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   590
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   591
        Provider p = Security.getProvider(provider);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   592
        if (p == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   593
            throw new NoSuchProviderException("No such provider: " +
90ce3da70b43 Initial load
duke
parents:
diff changeset
   594
                                              provider);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   595
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   596
        return getInstance(transformation, p);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   597
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   598
90ce3da70b43 Initial load
duke
parents:
diff changeset
   599
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   600
     * Returns a <code>Cipher</code> object that implements the specified
90ce3da70b43 Initial load
duke
parents:
diff changeset
   601
     * transformation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   602
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   603
     * <p> A new Cipher object encapsulating the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   604
     * CipherSpi implementation from the specified Provider
90ce3da70b43 Initial load
duke
parents:
diff changeset
   605
     * object is returned.  Note that the specified Provider object
90ce3da70b43 Initial load
duke
parents:
diff changeset
   606
     * does not have to be registered in the provider list.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   607
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   608
     * @param transformation the name of the transformation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   609
     * e.g., <i>DES/CBC/PKCS5Padding</i>.
8152
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   610
     * See the Cipher section in the <a href=
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   611
     *   "{@docRoot}/../technotes/guides/security/StandardNames.html#Cipher">
94e5966bdf22 5001004: Required Security Algorithms need to be defined
mullan
parents: 5506
diff changeset
   612
     * Java Cryptography Architecture Standard Algorithm Name Documentation</a>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   613
     * for information about standard transformation names.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   614
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   615
     * @param provider the provider.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   616
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   617
     * @return a cipher that implements the requested transformation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   618
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   619
     * @exception NoSuchAlgorithmException if <code>transformation</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   620
     *          is null, empty, in an invalid format,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   621
     *          or if a CipherSpi implementation for the specified algorithm
90ce3da70b43 Initial load
duke
parents:
diff changeset
   622
     *          is not available from the specified Provider object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   623
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   624
     * @exception NoSuchPaddingException if <code>transformation</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   625
     *          contains a padding scheme that is not available.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   626
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   627
     * @exception IllegalArgumentException if the <code>provider</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   628
     *          is null.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   629
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   630
     * @see java.security.Provider
90ce3da70b43 Initial load
duke
parents:
diff changeset
   631
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   632
    public static final Cipher getInstance(String transformation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   633
                                           Provider provider)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   634
            throws NoSuchAlgorithmException, NoSuchPaddingException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   635
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   636
        if (provider == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   637
            throw new IllegalArgumentException("Missing provider");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   638
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   639
        Exception failure = null;
10336
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
   640
        List<Transform> transforms = getTransforms(transformation);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   641
        boolean providerChecked = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   642
        String paddingError = null;
10336
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
   643
        for (Transform tr : transforms) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   644
            Service s = provider.getService("Cipher", tr.transform);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   645
            if (s == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   646
                continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   647
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   648
            if (providerChecked == false) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   649
                // for compatibility, first do the lookup and then verify
90ce3da70b43 Initial load
duke
parents:
diff changeset
   650
                // the provider. this makes the difference between a NSAE
90ce3da70b43 Initial load
duke
parents:
diff changeset
   651
                // and a SecurityException if the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   652
                // provider does not support the algorithm.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   653
                Exception ve = JceSecurity.getVerificationResult(provider);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   654
                if (ve != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   655
                    String msg = "JCE cannot authenticate the provider "
90ce3da70b43 Initial load
duke
parents:
diff changeset
   656
                        + provider.getName();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   657
                    throw new SecurityException(msg, ve);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   658
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   659
                providerChecked = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   660
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   661
            if (tr.supportsMode(s) == S_NO) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   662
                continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   663
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   664
            if (tr.supportsPadding(s) == S_NO) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   665
                paddingError = tr.pad;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   666
                continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   667
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   668
            try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   669
                CipherSpi spi = (CipherSpi)s.newInstance(null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   670
                tr.setModePadding(spi);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   671
                Cipher cipher = new Cipher(spi, transformation);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   672
                cipher.provider = s.getProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   673
                cipher.initCryptoPermission();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   674
                return cipher;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   675
            } catch (Exception e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   676
                failure = e;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   677
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   678
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   679
90ce3da70b43 Initial load
duke
parents:
diff changeset
   680
        // throw NoSuchPaddingException if the problem is with padding
90ce3da70b43 Initial load
duke
parents:
diff changeset
   681
        if (failure instanceof NoSuchPaddingException) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   682
            throw (NoSuchPaddingException)failure;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   683
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   684
        if (paddingError != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   685
            throw new NoSuchPaddingException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   686
                ("Padding not supported: " + paddingError);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   687
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   688
        throw new NoSuchAlgorithmException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   689
                ("No such algorithm: " + transformation, failure);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   690
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   691
90ce3da70b43 Initial load
duke
parents:
diff changeset
   692
    // If the requested crypto service is export-controlled,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   693
    // determine the maximum allowable keysize.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   694
    private void initCryptoPermission() throws NoSuchAlgorithmException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   695
        if (JceSecurity.isRestricted() == false) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   696
            cryptoPerm = CryptoAllPermission.INSTANCE;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   697
            exmech = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   698
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   699
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   700
        cryptoPerm = getConfiguredPermission(transformation);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   701
        // Instantiate the exemption mechanism (if required)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   702
        String exmechName = cryptoPerm.getExemptionMechanism();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   703
        if (exmechName != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   704
            exmech = ExemptionMechanism.getInstance(exmechName);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   705
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   706
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   707
90ce3da70b43 Initial load
duke
parents:
diff changeset
   708
    // max number of debug warnings to print from chooseFirstProvider()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   709
    private static int warnCount = 10;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   710
90ce3da70b43 Initial load
duke
parents:
diff changeset
   711
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   712
     * Choose the Spi from the first provider available. Used if
90ce3da70b43 Initial load
duke
parents:
diff changeset
   713
     * delayed provider selection is not possible because init()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   714
     * is not the first method called.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   715
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   716
    void chooseFirstProvider() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   717
        if (spi != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   718
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   719
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   720
        synchronized (lock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   721
            if (spi != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   722
                return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   723
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   724
            if (debug != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   725
                int w = --warnCount;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   726
                if (w >= 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   727
                    debug.println("Cipher.init() not first method "
90ce3da70b43 Initial load
duke
parents:
diff changeset
   728
                        + "called, disabling delayed provider selection");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   729
                    if (w == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   730
                        debug.println("Further warnings of this type will "
90ce3da70b43 Initial load
duke
parents:
diff changeset
   731
                            + "be suppressed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   732
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   733
                    new Exception("Call trace").printStackTrace();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   734
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   735
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   736
            Exception lastException = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   737
            while ((firstService != null) || serviceIterator.hasNext()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   738
                Service s;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   739
                CipherSpi thisSpi;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   740
                if (firstService != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   741
                    s = firstService;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   742
                    thisSpi = firstSpi;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   743
                    firstService = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   744
                    firstSpi = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   745
                } else {
10336
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
   746
                    s = serviceIterator.next();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   747
                    thisSpi = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   748
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   749
                if (JceSecurity.canUseProvider(s.getProvider()) == false) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   750
                    continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   751
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   752
                Transform tr = getTransform(s, transforms);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   753
                if (tr == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   754
                    // should never happen
90ce3da70b43 Initial load
duke
parents:
diff changeset
   755
                    continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   756
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   757
                if (tr.supportsModePadding(s) == S_NO) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   758
                    continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   759
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   760
                try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   761
                    if (thisSpi == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   762
                        Object obj = s.newInstance(null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   763
                        if (obj instanceof CipherSpi == false) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   764
                            continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   765
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   766
                        thisSpi = (CipherSpi)obj;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   767
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   768
                    tr.setModePadding(thisSpi);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   769
                    initCryptoPermission();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   770
                    spi = thisSpi;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   771
                    provider = s.getProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   772
                    // not needed any more
90ce3da70b43 Initial load
duke
parents:
diff changeset
   773
                    firstService = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   774
                    serviceIterator = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   775
                    transforms = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   776
                    return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   777
                } catch (Exception e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   778
                    lastException = e;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   779
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   780
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   781
            ProviderException e = new ProviderException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   782
                    ("Could not construct CipherSpi instance");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   783
            if (lastException != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   784
                e.initCause(lastException);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   785
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   786
            throw e;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   787
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   788
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   789
90ce3da70b43 Initial load
duke
parents:
diff changeset
   790
    private final static int I_KEY       = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   791
    private final static int I_PARAMSPEC = 2;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   792
    private final static int I_PARAMS    = 3;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   793
    private final static int I_CERT      = 4;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   794
90ce3da70b43 Initial load
duke
parents:
diff changeset
   795
    private void implInit(CipherSpi thisSpi, int type, int opmode, Key key,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   796
            AlgorithmParameterSpec paramSpec, AlgorithmParameters params,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   797
            SecureRandom random) throws InvalidKeyException,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   798
            InvalidAlgorithmParameterException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   799
        switch (type) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   800
        case I_KEY:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   801
            checkCryptoPerm(thisSpi, key);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   802
            thisSpi.engineInit(opmode, key, random);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   803
            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   804
        case I_PARAMSPEC:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   805
            checkCryptoPerm(thisSpi, key, paramSpec);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   806
            thisSpi.engineInit(opmode, key, paramSpec, random);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   807
            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   808
        case I_PARAMS:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   809
            checkCryptoPerm(thisSpi, key, params);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   810
            thisSpi.engineInit(opmode, key, params, random);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   811
            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   812
        case I_CERT:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   813
            checkCryptoPerm(thisSpi, key);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   814
            thisSpi.engineInit(opmode, key, random);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   815
            break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   816
        default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   817
            throw new AssertionError("Internal Cipher error: " + type);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   818
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   819
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   820
90ce3da70b43 Initial load
duke
parents:
diff changeset
   821
    private void chooseProvider(int initType, int opmode, Key key,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   822
            AlgorithmParameterSpec paramSpec,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   823
            AlgorithmParameters params, SecureRandom random)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   824
            throws InvalidKeyException, InvalidAlgorithmParameterException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   825
        synchronized (lock) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   826
            if (spi != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   827
                implInit(spi, initType, opmode, key, paramSpec, params, random);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   828
                return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   829
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   830
            Exception lastException = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   831
            while ((firstService != null) || serviceIterator.hasNext()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   832
                Service s;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   833
                CipherSpi thisSpi;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   834
                if (firstService != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   835
                    s = firstService;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   836
                    thisSpi = firstSpi;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   837
                    firstService = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   838
                    firstSpi = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   839
                } else {
10336
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
   840
                    s = serviceIterator.next();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   841
                    thisSpi = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   842
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   843
                // if provider says it does not support this key, ignore it
90ce3da70b43 Initial load
duke
parents:
diff changeset
   844
                if (s.supportsParameter(key) == false) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   845
                    continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   846
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   847
                if (JceSecurity.canUseProvider(s.getProvider()) == false) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   848
                    continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   849
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   850
                Transform tr = getTransform(s, transforms);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   851
                if (tr == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   852
                    // should never happen
90ce3da70b43 Initial load
duke
parents:
diff changeset
   853
                    continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   854
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   855
                if (tr.supportsModePadding(s) == S_NO) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   856
                    continue;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   857
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   858
                try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   859
                    if (thisSpi == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   860
                        thisSpi = (CipherSpi)s.newInstance(null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   861
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   862
                    tr.setModePadding(thisSpi);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   863
                    initCryptoPermission();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   864
                    implInit(thisSpi, initType, opmode, key, paramSpec,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   865
                                                        params, random);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   866
                    provider = s.getProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   867
                    this.spi = thisSpi;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   868
                    firstService = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   869
                    serviceIterator = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   870
                    transforms = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   871
                    return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   872
                } catch (Exception e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   873
                    // NoSuchAlgorithmException from newInstance()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   874
                    // InvalidKeyException from init()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   875
                    // RuntimeException (ProviderException) from init()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   876
                    // SecurityException from crypto permission check
90ce3da70b43 Initial load
duke
parents:
diff changeset
   877
                    if (lastException == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   878
                        lastException = e;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   879
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   880
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   881
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   882
            // no working provider found, fail
90ce3da70b43 Initial load
duke
parents:
diff changeset
   883
            if (lastException instanceof InvalidKeyException) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   884
                throw (InvalidKeyException)lastException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   885
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   886
            if (lastException instanceof InvalidAlgorithmParameterException) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   887
                throw (InvalidAlgorithmParameterException)lastException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   888
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   889
            if (lastException instanceof RuntimeException) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   890
                throw (RuntimeException)lastException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   891
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   892
            String kName = (key != null) ? key.getClass().getName() : "(null)";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   893
            throw new InvalidKeyException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   894
                ("No installed provider supports this key: "
90ce3da70b43 Initial load
duke
parents:
diff changeset
   895
                + kName, lastException);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   896
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   897
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   898
90ce3da70b43 Initial load
duke
parents:
diff changeset
   899
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   900
     * Returns the provider of this <code>Cipher</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   901
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   902
     * @return the provider of this <code>Cipher</code> object
90ce3da70b43 Initial load
duke
parents:
diff changeset
   903
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   904
    public final Provider getProvider() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   905
        chooseFirstProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   906
        return this.provider;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   907
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   908
90ce3da70b43 Initial load
duke
parents:
diff changeset
   909
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   910
     * Returns the algorithm name of this <code>Cipher</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   911
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   912
     * <p>This is the same name that was specified in one of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   913
     * <code>getInstance</code> calls that created this <code>Cipher</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   914
     * object..
90ce3da70b43 Initial load
duke
parents:
diff changeset
   915
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   916
     * @return the algorithm name of this <code>Cipher</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   917
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   918
    public final String getAlgorithm() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   919
        return this.transformation;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   920
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   921
90ce3da70b43 Initial load
duke
parents:
diff changeset
   922
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   923
     * Returns the block size (in bytes).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   924
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   925
     * @return the block size (in bytes), or 0 if the underlying algorithm is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   926
     * not a block cipher
90ce3da70b43 Initial load
duke
parents:
diff changeset
   927
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   928
    public final int getBlockSize() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   929
        chooseFirstProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   930
        return spi.engineGetBlockSize();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   931
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   932
90ce3da70b43 Initial load
duke
parents:
diff changeset
   933
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   934
     * Returns the length in bytes that an output buffer would need to be in
90ce3da70b43 Initial load
duke
parents:
diff changeset
   935
     * order to hold the result of the next <code>update</code> or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   936
     * <code>doFinal</code> operation, given the input length
90ce3da70b43 Initial load
duke
parents:
diff changeset
   937
     * <code>inputLen</code> (in bytes).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   938
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   939
     * <p>This call takes into account any unprocessed (buffered) data from a
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
   940
     * previous <code>update</code> call, padding, and AEAD tagging.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   941
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   942
     * <p>The actual output length of the next <code>update</code> or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   943
     * <code>doFinal</code> call may be smaller than the length returned by
90ce3da70b43 Initial load
duke
parents:
diff changeset
   944
     * this method.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   945
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   946
     * @param inputLen the input length (in bytes)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   947
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   948
     * @return the required output buffer size (in bytes)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   949
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   950
     * @exception IllegalStateException if this cipher is in a wrong state
90ce3da70b43 Initial load
duke
parents:
diff changeset
   951
     * (e.g., has not yet been initialized)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   952
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   953
    public final int getOutputSize(int inputLen) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   954
90ce3da70b43 Initial load
duke
parents:
diff changeset
   955
        if (!initialized && !(this instanceof NullCipher)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   956
            throw new IllegalStateException("Cipher not initialized");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   957
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   958
        if (inputLen < 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   959
            throw new IllegalArgumentException("Input size must be equal " +
90ce3da70b43 Initial load
duke
parents:
diff changeset
   960
                                               "to or greater than zero");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   961
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   962
        chooseFirstProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   963
        return spi.engineGetOutputSize(inputLen);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   964
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   965
90ce3da70b43 Initial load
duke
parents:
diff changeset
   966
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   967
     * Returns the initialization vector (IV) in a new buffer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   968
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   969
     * <p>This is useful in the case where a random IV was created,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   970
     * or in the context of password-based encryption or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   971
     * decryption, where the IV is derived from a user-supplied password.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   972
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   973
     * @return the initialization vector in a new buffer, or null if the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   974
     * underlying algorithm does not use an IV, or if the IV has not yet
90ce3da70b43 Initial load
duke
parents:
diff changeset
   975
     * been set.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   976
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   977
    public final byte[] getIV() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   978
        chooseFirstProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   979
        return spi.engineGetIV();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   980
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   981
90ce3da70b43 Initial load
duke
parents:
diff changeset
   982
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   983
     * Returns the parameters used with this cipher.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   984
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   985
     * <p>The returned parameters may be the same that were used to initialize
90ce3da70b43 Initial load
duke
parents:
diff changeset
   986
     * this cipher, or may contain a combination of default and random
90ce3da70b43 Initial load
duke
parents:
diff changeset
   987
     * parameter values used by the underlying cipher implementation if this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   988
     * cipher requires algorithm parameters but was not initialized with any.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   989
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   990
     * @return the parameters used with this cipher, or null if this cipher
90ce3da70b43 Initial load
duke
parents:
diff changeset
   991
     * does not use any parameters.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   992
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   993
    public final AlgorithmParameters getParameters() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   994
        chooseFirstProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   995
        return spi.engineGetParameters();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   996
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   997
90ce3da70b43 Initial load
duke
parents:
diff changeset
   998
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   999
     * Returns the exemption mechanism object used with this cipher.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1000
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1001
     * @return the exemption mechanism object used with this cipher, or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1002
     * null if this cipher does not use any exemption mechanism.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1003
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1004
    public final ExemptionMechanism getExemptionMechanism() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1005
        chooseFirstProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1006
        return exmech;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1007
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1008
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1009
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1010
    // Crypto permission check code below
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1011
    //
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1012
    private void checkCryptoPerm(CipherSpi checkSpi, Key key)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1013
            throws InvalidKeyException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1014
        if (cryptoPerm == CryptoAllPermission.INSTANCE) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1015
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1016
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1017
        // Check if key size and default parameters are within legal limits
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1018
        AlgorithmParameterSpec params;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1019
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1020
            params = getAlgorithmParameterSpec(checkSpi.engineGetParameters());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1021
        } catch (InvalidParameterSpecException ipse) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1022
            throw new InvalidKeyException
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1023
                ("Unsupported default algorithm parameters");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1024
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1025
        if (!passCryptoPermCheck(checkSpi, key, params)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1026
            throw new InvalidKeyException(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1027
                "Illegal key size or default parameters");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1028
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1029
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1030
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1031
    private void checkCryptoPerm(CipherSpi checkSpi, Key key,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1032
            AlgorithmParameterSpec params) throws InvalidKeyException,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1033
            InvalidAlgorithmParameterException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1034
        if (cryptoPerm == CryptoAllPermission.INSTANCE) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1035
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1036
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1037
        // Determine keysize and check if it is within legal limits
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1038
        if (!passCryptoPermCheck(checkSpi, key, null)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1039
            throw new InvalidKeyException("Illegal key size");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1040
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1041
        if ((params != null) && (!passCryptoPermCheck(checkSpi, key, params))) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1042
            throw new InvalidAlgorithmParameterException("Illegal parameters");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1043
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1044
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1045
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1046
    private void checkCryptoPerm(CipherSpi checkSpi, Key key,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1047
            AlgorithmParameters params)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1048
            throws InvalidKeyException, InvalidAlgorithmParameterException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1049
        if (cryptoPerm == CryptoAllPermission.INSTANCE) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1050
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1051
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1052
        // Convert the specified parameters into specs and then delegate.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1053
        AlgorithmParameterSpec pSpec;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1054
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1055
            pSpec = getAlgorithmParameterSpec(params);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1056
        } catch (InvalidParameterSpecException ipse) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1057
            throw new InvalidAlgorithmParameterException
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1058
                ("Failed to retrieve algorithm parameter specification");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1059
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1060
        checkCryptoPerm(checkSpi, key, pSpec);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1061
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1062
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1063
    private boolean passCryptoPermCheck(CipherSpi checkSpi, Key key,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1064
                                        AlgorithmParameterSpec params)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1065
            throws InvalidKeyException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1066
        String em = cryptoPerm.getExemptionMechanism();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1067
        int keySize = checkSpi.engineGetKeySize(key);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1068
        // Use the "algorithm" component of the cipher
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1069
        // transformation so that the perm check would
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1070
        // work when the key has the "aliased" algo.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1071
        String algComponent;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1072
        int index = transformation.indexOf('/');
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1073
        if (index != -1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1074
            algComponent = transformation.substring(0, index);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1075
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1076
            algComponent = transformation;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1077
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1078
        CryptoPermission checkPerm =
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1079
            new CryptoPermission(algComponent, keySize, params, em);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1080
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1081
        if (!cryptoPerm.implies(checkPerm)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1082
            if (debug != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1083
                debug.println("Crypto Permission check failed");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1084
                debug.println("granted: " + cryptoPerm);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1085
                debug.println("requesting: " + checkPerm);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1086
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1087
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1088
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1089
        if (exmech == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1090
            return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1091
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1092
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1093
            if (!exmech.isCryptoAllowed(key)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1094
                if (debug != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1095
                    debug.println(exmech.getName() + " isn't enforced");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1096
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1097
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1098
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1099
        } catch (ExemptionMechanismException eme) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1100
            if (debug != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1101
                debug.println("Cannot determine whether "+
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1102
                              exmech.getName() + " has been enforced");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1103
                eme.printStackTrace();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1104
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1105
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1106
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1107
        return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1108
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1109
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1110
    // check if opmode is one of the defined constants
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1111
    // throw InvalidParameterExeption if not
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1112
    private static void checkOpmode(int opmode) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1113
        if ((opmode < ENCRYPT_MODE) || (opmode > UNWRAP_MODE)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1114
            throw new InvalidParameterException("Invalid operation mode");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1115
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1116
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1117
26736
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1118
    private static String getOpmodeString(int opmode) {
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1119
        switch (opmode) {
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1120
            case ENCRYPT_MODE:
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1121
                return "encryption";
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1122
            case DECRYPT_MODE:
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1123
                return "decryption";
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1124
            case WRAP_MODE:
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1125
                return "key wrapping";
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1126
            case UNWRAP_MODE:
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1127
                return "key unwrapping";
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1128
            default:
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1129
                return "";
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1130
        }
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1131
    }
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1132
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1133
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1134
     * Initializes this cipher with a key.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1135
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1136
     * <p>The cipher is initialized for one of the following four operations:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1137
     * encryption, decryption, key wrapping or key unwrapping, depending
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1138
     * on the value of <code>opmode</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1139
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1140
     * <p>If this cipher requires any algorithm parameters that cannot be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1141
     * derived from the given <code>key</code>, the underlying cipher
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1142
     * implementation is supposed to generate the required parameters itself
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1143
     * (using provider-specific default or random values) if it is being
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1144
     * initialized for encryption or key wrapping, and raise an
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1145
     * <code>InvalidKeyException</code> if it is being
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1146
     * initialized for decryption or key unwrapping.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1147
     * The generated parameters can be retrieved using
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1148
     * {@link #getParameters() getParameters} or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1149
     * {@link #getIV() getIV} (if the parameter is an IV).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1150
     *
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1151
     * <p>If this cipher requires algorithm parameters that cannot be
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1152
     * derived from the input parameters, and there are no reasonable
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1153
     * provider-specific default values, initialization will
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1154
     * necessarily fail.
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1155
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1156
     * <p>If this cipher (including its underlying feedback or padding scheme)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1157
     * requires any random bytes (e.g., for parameter generation), it will get
18771
9dadb0719cea 8019772: Fix doclint issues in javax.crypto and javax.security subpackages
juh
parents: 17919
diff changeset
  1158
     * them using the {@link java.security.SecureRandom}
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1159
     * implementation of the highest-priority
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1160
     * installed provider as the source of randomness.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1161
     * (If none of the installed providers supply an implementation of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1162
     * SecureRandom, a system-provided source of randomness will be used.)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1163
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1164
     * <p>Note that when a Cipher object is initialized, it loses all
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1165
     * previously-acquired state. In other words, initializing a Cipher is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1166
     * equivalent to creating a new instance of that Cipher and initializing
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1167
     * it.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1168
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1169
     * @param opmode the operation mode of this cipher (this is one of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1170
     * the following:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1171
     * <code>ENCRYPT_MODE</code>, <code>DECRYPT_MODE</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1172
     * <code>WRAP_MODE</code> or <code>UNWRAP_MODE</code>)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1173
     * @param key the key
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1174
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1175
     * @exception InvalidKeyException if the given key is inappropriate for
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1176
     * initializing this cipher, or requires
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1177
     * algorithm parameters that cannot be
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1178
     * determined from the given key, or if the given key has a keysize that
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1179
     * exceeds the maximum allowable keysize (as determined from the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1180
     * configured jurisdiction policy files).
17919
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1181
     * @throws UnsupportedOperationException if (@code opmode} is
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1182
     * {@code WRAP_MODE} or {@code UNWRAP_MODE} but the mode is not implemented
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1183
     * by the underlying {@code CipherSpi}.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1184
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1185
    public final void init(int opmode, Key key) throws InvalidKeyException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1186
        init(opmode, key, JceSecurity.RANDOM);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1187
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1188
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1189
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1190
     * Initializes this cipher with a key and a source of randomness.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1191
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1192
     * <p>The cipher is initialized for one of the following four operations:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1193
     * encryption, decryption, key wrapping or  key unwrapping, depending
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1194
     * on the value of <code>opmode</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1195
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1196
     * <p>If this cipher requires any algorithm parameters that cannot be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1197
     * derived from the given <code>key</code>, the underlying cipher
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1198
     * implementation is supposed to generate the required parameters itself
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1199
     * (using provider-specific default or random values) if it is being
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1200
     * initialized for encryption or key wrapping, and raise an
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1201
     * <code>InvalidKeyException</code> if it is being
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1202
     * initialized for decryption or key unwrapping.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1203
     * The generated parameters can be retrieved using
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1204
     * {@link #getParameters() getParameters} or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1205
     * {@link #getIV() getIV} (if the parameter is an IV).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1206
     *
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1207
     * <p>If this cipher requires algorithm parameters that cannot be
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1208
     * derived from the input parameters, and there are no reasonable
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1209
     * provider-specific default values, initialization will
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1210
     * necessarily fail.
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1211
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1212
     * <p>If this cipher (including its underlying feedback or padding scheme)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1213
     * requires any random bytes (e.g., for parameter generation), it will get
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1214
     * them from <code>random</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1215
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1216
     * <p>Note that when a Cipher object is initialized, it loses all
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1217
     * previously-acquired state. In other words, initializing a Cipher is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1218
     * equivalent to creating a new instance of that Cipher and initializing
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1219
     * it.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1220
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1221
     * @param opmode the operation mode of this cipher (this is one of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1222
     * following:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1223
     * <code>ENCRYPT_MODE</code>, <code>DECRYPT_MODE</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1224
     * <code>WRAP_MODE</code> or <code>UNWRAP_MODE</code>)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1225
     * @param key the encryption key
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1226
     * @param random the source of randomness
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1227
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1228
     * @exception InvalidKeyException if the given key is inappropriate for
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1229
     * initializing this cipher, or requires
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1230
     * algorithm parameters that cannot be
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1231
     * determined from the given key, or if the given key has a keysize that
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1232
     * exceeds the maximum allowable keysize (as determined from the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1233
     * configured jurisdiction policy files).
17919
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1234
     * @throws UnsupportedOperationException if (@code opmode} is
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1235
     * {@code WRAP_MODE} or {@code UNWRAP_MODE} but the mode is not implemented
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1236
     * by the underlying {@code CipherSpi}.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1237
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1238
    public final void init(int opmode, Key key, SecureRandom random)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1239
            throws InvalidKeyException
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1240
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1241
        initialized = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1242
        checkOpmode(opmode);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1243
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1244
        if (spi != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1245
            checkCryptoPerm(spi, key);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1246
            spi.engineInit(opmode, key, random);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1247
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1248
            try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1249
                chooseProvider(I_KEY, opmode, key, null, null, random);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1250
            } catch (InvalidAlgorithmParameterException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1251
                // should never occur
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1252
                throw new InvalidKeyException(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1253
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1254
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1255
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1256
        initialized = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1257
        this.opmode = opmode;
26736
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1258
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1259
        if (!skipDebug && pdebug != null) {
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1260
            pdebug.println("Cipher." + transformation + " " +
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1261
                getOpmodeString(opmode) + " algorithm from: " +
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1262
                this.provider.getName());
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1263
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1264
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1265
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1266
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1267
     * Initializes this cipher with a key and a set of algorithm
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1268
     * parameters.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1269
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1270
     * <p>The cipher is initialized for one of the following four operations:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1271
     * encryption, decryption, key wrapping or  key unwrapping, depending
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1272
     * on the value of <code>opmode</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1273
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1274
     * <p>If this cipher requires any algorithm parameters and
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1275
     * <code>params</code> is null, the underlying cipher implementation is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1276
     * supposed to generate the required parameters itself (using
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1277
     * provider-specific default or random values) if it is being
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1278
     * initialized for encryption or key wrapping, and raise an
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1279
     * <code>InvalidAlgorithmParameterException</code> if it is being
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1280
     * initialized for decryption or key unwrapping.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1281
     * The generated parameters can be retrieved using
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1282
     * {@link #getParameters() getParameters} or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1283
     * {@link #getIV() getIV} (if the parameter is an IV).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1284
     *
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1285
     * <p>If this cipher requires algorithm parameters that cannot be
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1286
     * derived from the input parameters, and there are no reasonable
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1287
     * provider-specific default values, initialization will
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1288
     * necessarily fail.
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1289
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1290
     * <p>If this cipher (including its underlying feedback or padding scheme)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1291
     * requires any random bytes (e.g., for parameter generation), it will get
18771
9dadb0719cea 8019772: Fix doclint issues in javax.crypto and javax.security subpackages
juh
parents: 17919
diff changeset
  1292
     * them using the {@link java.security.SecureRandom}
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1293
     * implementation of the highest-priority
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1294
     * installed provider as the source of randomness.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1295
     * (If none of the installed providers supply an implementation of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1296
     * SecureRandom, a system-provided source of randomness will be used.)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1297
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1298
     * <p>Note that when a Cipher object is initialized, it loses all
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1299
     * previously-acquired state. In other words, initializing a Cipher is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1300
     * equivalent to creating a new instance of that Cipher and initializing
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1301
     * it.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1302
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1303
     * @param opmode the operation mode of this cipher (this is one of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1304
     * following:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1305
     * <code>ENCRYPT_MODE</code>, <code>DECRYPT_MODE</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1306
     * <code>WRAP_MODE</code> or <code>UNWRAP_MODE</code>)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1307
     * @param key the encryption key
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1308
     * @param params the algorithm parameters
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1309
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1310
     * @exception InvalidKeyException if the given key is inappropriate for
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1311
     * initializing this cipher, or its keysize exceeds the maximum allowable
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1312
     * keysize (as determined from the configured jurisdiction policy files).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1313
     * @exception InvalidAlgorithmParameterException if the given algorithm
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1314
     * parameters are inappropriate for this cipher,
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1315
     * or this cipher requires
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1316
     * algorithm parameters and <code>params</code> is null, or the given
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1317
     * algorithm parameters imply a cryptographic strength that would exceed
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1318
     * the legal limits (as determined from the configured jurisdiction
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1319
     * policy files).
17919
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1320
     * @throws UnsupportedOperationException if (@code opmode} is
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1321
     * {@code WRAP_MODE} or {@code UNWRAP_MODE} but the mode is not implemented
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1322
     * by the underlying {@code CipherSpi}.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1323
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1324
    public final void init(int opmode, Key key, AlgorithmParameterSpec params)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1325
            throws InvalidKeyException, InvalidAlgorithmParameterException
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1326
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1327
        init(opmode, key, params, JceSecurity.RANDOM);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1328
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1329
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1330
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1331
     * Initializes this cipher with a key, a set of algorithm
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1332
     * parameters, and a source of randomness.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1333
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1334
     * <p>The cipher is initialized for one of the following four operations:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1335
     * encryption, decryption, key wrapping or  key unwrapping, depending
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1336
     * on the value of <code>opmode</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1337
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1338
     * <p>If this cipher requires any algorithm parameters and
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1339
     * <code>params</code> is null, the underlying cipher implementation is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1340
     * supposed to generate the required parameters itself (using
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1341
     * provider-specific default or random values) if it is being
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1342
     * initialized for encryption or key wrapping, and raise an
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1343
     * <code>InvalidAlgorithmParameterException</code> if it is being
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1344
     * initialized for decryption or key unwrapping.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1345
     * The generated parameters can be retrieved using
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1346
     * {@link #getParameters() getParameters} or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1347
     * {@link #getIV() getIV} (if the parameter is an IV).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1348
     *
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1349
     * <p>If this cipher requires algorithm parameters that cannot be
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1350
     * derived from the input parameters, and there are no reasonable
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1351
     * provider-specific default values, initialization will
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1352
     * necessarily fail.
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1353
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1354
     * <p>If this cipher (including its underlying feedback or padding scheme)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1355
     * requires any random bytes (e.g., for parameter generation), it will get
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1356
     * them from <code>random</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1357
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1358
     * <p>Note that when a Cipher object is initialized, it loses all
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1359
     * previously-acquired state. In other words, initializing a Cipher is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1360
     * equivalent to creating a new instance of that Cipher and initializing
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1361
     * it.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1362
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1363
     * @param opmode the operation mode of this cipher (this is one of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1364
     * following:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1365
     * <code>ENCRYPT_MODE</code>, <code>DECRYPT_MODE</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1366
     * <code>WRAP_MODE</code> or <code>UNWRAP_MODE</code>)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1367
     * @param key the encryption key
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1368
     * @param params the algorithm parameters
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1369
     * @param random the source of randomness
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1370
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1371
     * @exception InvalidKeyException if the given key is inappropriate for
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1372
     * initializing this cipher, or its keysize exceeds the maximum allowable
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1373
     * keysize (as determined from the configured jurisdiction policy files).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1374
     * @exception InvalidAlgorithmParameterException if the given algorithm
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1375
     * parameters are inappropriate for this cipher,
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1376
     * or this cipher requires
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1377
     * algorithm parameters and <code>params</code> is null, or the given
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1378
     * algorithm parameters imply a cryptographic strength that would exceed
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1379
     * the legal limits (as determined from the configured jurisdiction
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1380
     * policy files).
17919
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1381
     * @throws UnsupportedOperationException if (@code opmode} is
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1382
     * {@code WRAP_MODE} or {@code UNWRAP_MODE} but the mode is not implemented
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1383
     * by the underlying {@code CipherSpi}.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1384
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1385
    public final void init(int opmode, Key key, AlgorithmParameterSpec params,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1386
                           SecureRandom random)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1387
            throws InvalidKeyException, InvalidAlgorithmParameterException
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1388
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1389
        initialized = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1390
        checkOpmode(opmode);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1391
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1392
        if (spi != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1393
            checkCryptoPerm(spi, key, params);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1394
            spi.engineInit(opmode, key, params, random);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1395
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1396
            chooseProvider(I_PARAMSPEC, opmode, key, params, null, random);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1397
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1398
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1399
        initialized = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1400
        this.opmode = opmode;
26736
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1401
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1402
        if (!skipDebug && pdebug != null) {
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1403
            pdebug.println("Cipher." + transformation + " " +
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1404
                getOpmodeString(opmode) + " algorithm from: " +
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1405
                this.provider.getName());
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1406
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1407
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1408
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1409
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1410
     * Initializes this cipher with a key and a set of algorithm
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1411
     * parameters.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1412
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1413
     * <p>The cipher is initialized for one of the following four operations:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1414
     * encryption, decryption, key wrapping or  key unwrapping, depending
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1415
     * on the value of <code>opmode</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1416
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1417
     * <p>If this cipher requires any algorithm parameters and
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1418
     * <code>params</code> is null, the underlying cipher implementation is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1419
     * supposed to generate the required parameters itself (using
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1420
     * provider-specific default or random values) if it is being
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1421
     * initialized for encryption or key wrapping, and raise an
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1422
     * <code>InvalidAlgorithmParameterException</code> if it is being
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1423
     * initialized for decryption or key unwrapping.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1424
     * The generated parameters can be retrieved using
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1425
     * {@link #getParameters() getParameters} or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1426
     * {@link #getIV() getIV} (if the parameter is an IV).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1427
     *
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1428
     * <p>If this cipher requires algorithm parameters that cannot be
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1429
     * derived from the input parameters, and there are no reasonable
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1430
     * provider-specific default values, initialization will
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1431
     * necessarily fail.
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1432
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1433
     * <p>If this cipher (including its underlying feedback or padding scheme)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1434
     * requires any random bytes (e.g., for parameter generation), it will get
18771
9dadb0719cea 8019772: Fix doclint issues in javax.crypto and javax.security subpackages
juh
parents: 17919
diff changeset
  1435
     * them using the {@link java.security.SecureRandom}
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1436
     * implementation of the highest-priority
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1437
     * installed provider as the source of randomness.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1438
     * (If none of the installed providers supply an implementation of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1439
     * SecureRandom, a system-provided source of randomness will be used.)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1440
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1441
     * <p>Note that when a Cipher object is initialized, it loses all
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1442
     * previously-acquired state. In other words, initializing a Cipher is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1443
     * equivalent to creating a new instance of that Cipher and initializing
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1444
     * it.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1445
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1446
     * @param opmode the operation mode of this cipher (this is one of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1447
     * following: <code>ENCRYPT_MODE</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1448
     * <code>DECRYPT_MODE</code>, <code>WRAP_MODE</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1449
     * or <code>UNWRAP_MODE</code>)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1450
     * @param key the encryption key
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1451
     * @param params the algorithm parameters
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1452
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1453
     * @exception InvalidKeyException if the given key is inappropriate for
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1454
     * initializing this cipher, or its keysize exceeds the maximum allowable
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1455
     * keysize (as determined from the configured jurisdiction policy files).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1456
     * @exception InvalidAlgorithmParameterException if the given algorithm
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1457
     * parameters are inappropriate for this cipher,
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1458
     * or this cipher requires
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1459
     * algorithm parameters and <code>params</code> is null, or the given
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1460
     * algorithm parameters imply a cryptographic strength that would exceed
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1461
     * the legal limits (as determined from the configured jurisdiction
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1462
     * policy files).
17919
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1463
     * @throws UnsupportedOperationException if (@code opmode} is
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1464
     * {@code WRAP_MODE} or {@code UNWRAP_MODE} but the mode is not implemented
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1465
     * by the underlying {@code CipherSpi}.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1466
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1467
    public final void init(int opmode, Key key, AlgorithmParameters params)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1468
            throws InvalidKeyException, InvalidAlgorithmParameterException
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1469
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1470
        init(opmode, key, params, JceSecurity.RANDOM);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1471
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1472
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1473
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1474
     * Initializes this cipher with a key, a set of algorithm
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1475
     * parameters, and a source of randomness.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1476
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1477
     * <p>The cipher is initialized for one of the following four operations:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1478
     * encryption, decryption, key wrapping or  key unwrapping, depending
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1479
     * on the value of <code>opmode</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1480
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1481
     * <p>If this cipher requires any algorithm parameters and
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1482
     * <code>params</code> is null, the underlying cipher implementation is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1483
     * supposed to generate the required parameters itself (using
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1484
     * provider-specific default or random values) if it is being
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1485
     * initialized for encryption or key wrapping, and raise an
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1486
     * <code>InvalidAlgorithmParameterException</code> if it is being
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1487
     * initialized for decryption or key unwrapping.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1488
     * The generated parameters can be retrieved using
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1489
     * {@link #getParameters() getParameters} or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1490
     * {@link #getIV() getIV} (if the parameter is an IV).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1491
     *
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1492
     * <p>If this cipher requires algorithm parameters that cannot be
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1493
     * derived from the input parameters, and there are no reasonable
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1494
     * provider-specific default values, initialization will
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1495
     * necessarily fail.
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1496
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1497
     * <p>If this cipher (including its underlying feedback or padding scheme)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1498
     * requires any random bytes (e.g., for parameter generation), it will get
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1499
     * them from <code>random</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1500
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1501
     * <p>Note that when a Cipher object is initialized, it loses all
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1502
     * previously-acquired state. In other words, initializing a Cipher is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1503
     * equivalent to creating a new instance of that Cipher and initializing
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1504
     * it.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1505
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1506
     * @param opmode the operation mode of this cipher (this is one of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1507
     * following: <code>ENCRYPT_MODE</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1508
     * <code>DECRYPT_MODE</code>, <code>WRAP_MODE</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1509
     * or <code>UNWRAP_MODE</code>)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1510
     * @param key the encryption key
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1511
     * @param params the algorithm parameters
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1512
     * @param random the source of randomness
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1513
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1514
     * @exception InvalidKeyException if the given key is inappropriate for
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1515
     * initializing this cipher, or its keysize exceeds the maximum allowable
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1516
     * keysize (as determined from the configured jurisdiction policy files).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1517
     * @exception InvalidAlgorithmParameterException if the given algorithm
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1518
     * parameters are inappropriate for this cipher,
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1519
     * or this cipher requires
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1520
     * algorithm parameters and <code>params</code> is null, or the given
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1521
     * algorithm parameters imply a cryptographic strength that would exceed
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1522
     * the legal limits (as determined from the configured jurisdiction
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1523
     * policy files).
17919
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1524
     * @throws UnsupportedOperationException if (@code opmode} is
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1525
     * {@code WRAP_MODE} or {@code UNWRAP_MODE} but the mode is not implemented
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1526
     * by the underlying {@code CipherSpi}.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1527
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1528
    public final void init(int opmode, Key key, AlgorithmParameters params,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1529
                           SecureRandom random)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1530
            throws InvalidKeyException, InvalidAlgorithmParameterException
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1531
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1532
        initialized = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1533
        checkOpmode(opmode);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1534
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1535
        if (spi != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1536
            checkCryptoPerm(spi, key, params);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1537
            spi.engineInit(opmode, key, params, random);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1538
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1539
            chooseProvider(I_PARAMS, opmode, key, null, params, random);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1540
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1541
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1542
        initialized = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1543
        this.opmode = opmode;
26736
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1544
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1545
        if (!skipDebug && pdebug != null) {
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1546
            pdebug.println("Cipher." + transformation + " " +
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1547
                getOpmodeString(opmode) + " algorithm from: " +
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1548
                this.provider.getName());
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1549
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1550
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1551
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1552
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1553
     * Initializes this cipher with the public key from the given certificate.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1554
     * <p> The cipher is initialized for one of the following four operations:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1555
     * encryption, decryption, key wrapping or  key unwrapping, depending
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1556
     * on the value of <code>opmode</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1557
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1558
     * <p>If the certificate is of type X.509 and has a <i>key usage</i>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1559
     * extension field marked as critical, and the value of the <i>key usage</i>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1560
     * extension field implies that the public key in
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1561
     * the certificate and its corresponding private key are not
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1562
     * supposed to be used for the operation represented by the value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1563
     * of <code>opmode</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1564
     * an <code>InvalidKeyException</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1565
     * is thrown.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1566
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1567
     * <p> If this cipher requires any algorithm parameters that cannot be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1568
     * derived from the public key in the given certificate, the underlying
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1569
     * cipher
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1570
     * implementation is supposed to generate the required parameters itself
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1571
     * (using provider-specific default or random values) if it is being
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1572
     * initialized for encryption or key wrapping, and raise an <code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1573
     * InvalidKeyException</code> if it is being initialized for decryption or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1574
     * key unwrapping.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1575
     * The generated parameters can be retrieved using
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1576
     * {@link #getParameters() getParameters} or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1577
     * {@link #getIV() getIV} (if the parameter is an IV).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1578
     *
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1579
     * <p>If this cipher requires algorithm parameters that cannot be
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1580
     * derived from the input parameters, and there are no reasonable
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1581
     * provider-specific default values, initialization will
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1582
     * necessarily fail.
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1583
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1584
     * <p>If this cipher (including its underlying feedback or padding scheme)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1585
     * requires any random bytes (e.g., for parameter generation), it will get
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1586
     * them using the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1587
     * <code>SecureRandom</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1588
     * implementation of the highest-priority
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1589
     * installed provider as the source of randomness.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1590
     * (If none of the installed providers supply an implementation of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1591
     * SecureRandom, a system-provided source of randomness will be used.)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1592
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1593
     * <p>Note that when a Cipher object is initialized, it loses all
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1594
     * previously-acquired state. In other words, initializing a Cipher is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1595
     * equivalent to creating a new instance of that Cipher and initializing
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1596
     * it.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1597
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1598
     * @param opmode the operation mode of this cipher (this is one of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1599
     * following:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1600
     * <code>ENCRYPT_MODE</code>, <code>DECRYPT_MODE</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1601
     * <code>WRAP_MODE</code> or <code>UNWRAP_MODE</code>)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1602
     * @param certificate the certificate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1603
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1604
     * @exception InvalidKeyException if the public key in the given
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1605
     * certificate is inappropriate for initializing this cipher, or this
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1606
     * cipher requires algorithm parameters that cannot be determined from the
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1607
     * public key in the given certificate, or the keysize of the public key
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1608
     * in the given certificate has a keysize that exceeds the maximum
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1609
     * allowable keysize (as determined by the configured jurisdiction policy
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1610
     * files).
17919
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1611
     * @throws UnsupportedOperationException if (@code opmode} is
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1612
     * {@code WRAP_MODE} or {@code UNWRAP_MODE} but the mode is not implemented
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1613
     * by the underlying {@code CipherSpi}.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1614
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1615
    public final void init(int opmode, Certificate certificate)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1616
            throws InvalidKeyException
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1617
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1618
        init(opmode, certificate, JceSecurity.RANDOM);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1619
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1620
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1621
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1622
     * Initializes this cipher with the public key from the given certificate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1623
     * and
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1624
     * a source of randomness.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1625
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1626
     * <p>The cipher is initialized for one of the following four operations:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1627
     * encryption, decryption, key wrapping
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1628
     * or key unwrapping, depending on
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1629
     * the value of <code>opmode</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1630
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1631
     * <p>If the certificate is of type X.509 and has a <i>key usage</i>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1632
     * extension field marked as critical, and the value of the <i>key usage</i>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1633
     * extension field implies that the public key in
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1634
     * the certificate and its corresponding private key are not
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1635
     * supposed to be used for the operation represented by the value of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1636
     * <code>opmode</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1637
     * an <code>InvalidKeyException</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1638
     * is thrown.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1639
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1640
     * <p>If this cipher requires any algorithm parameters that cannot be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1641
     * derived from the public key in the given <code>certificate</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1642
     * the underlying cipher
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1643
     * implementation is supposed to generate the required parameters itself
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1644
     * (using provider-specific default or random values) if it is being
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1645
     * initialized for encryption or key wrapping, and raise an
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1646
     * <code>InvalidKeyException</code> if it is being
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1647
     * initialized for decryption or key unwrapping.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1648
     * The generated parameters can be retrieved using
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1649
     * {@link #getParameters() getParameters} or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1650
     * {@link #getIV() getIV} (if the parameter is an IV).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1651
     *
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1652
     * <p>If this cipher requires algorithm parameters that cannot be
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1653
     * derived from the input parameters, and there are no reasonable
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1654
     * provider-specific default values, initialization will
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1655
     * necessarily fail.
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1656
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1657
     * <p>If this cipher (including its underlying feedback or padding scheme)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1658
     * requires any random bytes (e.g., for parameter generation), it will get
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1659
     * them from <code>random</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1660
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1661
     * <p>Note that when a Cipher object is initialized, it loses all
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1662
     * previously-acquired state. In other words, initializing a Cipher is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1663
     * equivalent to creating a new instance of that Cipher and initializing
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1664
     * it.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1665
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1666
     * @param opmode the operation mode of this cipher (this is one of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1667
     * following:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1668
     * <code>ENCRYPT_MODE</code>, <code>DECRYPT_MODE</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1669
     * <code>WRAP_MODE</code> or <code>UNWRAP_MODE</code>)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1670
     * @param certificate the certificate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1671
     * @param random the source of randomness
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1672
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1673
     * @exception InvalidKeyException if the public key in the given
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1674
     * certificate is inappropriate for initializing this cipher, or this
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  1675
     * cipher
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1676
     * requires algorithm parameters that cannot be determined from the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1677
     * public key in the given certificate, or the keysize of the public key
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1678
     * in the given certificate has a keysize that exceeds the maximum
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1679
     * allowable keysize (as determined by the configured jurisdiction policy
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1680
     * files).
17919
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1681
     * @throws UnsupportedOperationException if (@code opmode} is
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1682
     * {@code WRAP_MODE} or {@code UNWRAP_MODE} but the mode is not implemented
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  1683
     * by the underlying {@code CipherSpi}.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1684
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1685
    public final void init(int opmode, Certificate certificate,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1686
                           SecureRandom random)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1687
            throws InvalidKeyException
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1688
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1689
        initialized = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1690
        checkOpmode(opmode);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1691
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1692
        // Check key usage if the certificate is of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1693
        // type X.509.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1694
        if (certificate instanceof java.security.cert.X509Certificate) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1695
            // Check whether the cert has a key usage extension
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1696
            // marked as a critical extension.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1697
            X509Certificate cert = (X509Certificate)certificate;
10336
0bb1999251f8 7064075: Security libraries don't build with javac -Xlint:all,-deprecation -Werror
jjg
parents: 9275
diff changeset
  1698
            Set<String> critSet = cert.getCriticalExtensionOIDs();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1699
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1700
            if (critSet != null && !critSet.isEmpty()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1701
                && critSet.contains(KEY_USAGE_EXTENSION_OID)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1702
                boolean[] keyUsageInfo = cert.getKeyUsage();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1703
                // keyUsageInfo[2] is for keyEncipherment;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1704
                // keyUsageInfo[3] is for dataEncipherment.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1705
                if ((keyUsageInfo != null) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1706
                    (((opmode == Cipher.ENCRYPT_MODE) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1707
                      (keyUsageInfo.length > 3) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1708
                      (keyUsageInfo[3] == false)) ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1709
                     ((opmode == Cipher.WRAP_MODE) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1710
                      (keyUsageInfo.length > 2) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1711
                      (keyUsageInfo[2] == false)))) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1712
                    throw new InvalidKeyException("Wrong key usage");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1713
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1714
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1715
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1716
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1717
        PublicKey publicKey =
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1718
            (certificate==null? null:certificate.getPublicKey());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1719
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1720
        if (spi != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1721
            checkCryptoPerm(spi, publicKey);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1722
            spi.engineInit(opmode, publicKey, random);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1723
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1724
            try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1725
                chooseProvider(I_CERT, opmode, publicKey, null, null, random);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1726
            } catch (InvalidAlgorithmParameterException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1727
                // should never occur
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1728
                throw new InvalidKeyException(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1729
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1730
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1731
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1732
        initialized = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1733
        this.opmode = opmode;
26736
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1734
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1735
        if (!skipDebug && pdebug != null) {
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1736
            pdebug.println("Cipher." + transformation + " " +
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1737
                getOpmodeString(opmode) + " algorithm from: " +
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1738
                this.provider.getName());
5a93000b26cd 8056026: Debug security logging should print Provider used for each crypto operation
vinnie
parents: 25859
diff changeset
  1739
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1740
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1741
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1742
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1743
     * Ensures that Cipher is in a valid state for update() and doFinal()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1744
     * calls - should be initialized and in ENCRYPT_MODE or DECRYPT_MODE.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1745
     * @throws IllegalStateException if Cipher object is not in valid state.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1746
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1747
    private void checkCipherState() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1748
        if (!(this instanceof NullCipher)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1749
            if (!initialized) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1750
                throw new IllegalStateException("Cipher not initialized");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1751
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1752
            if ((opmode != Cipher.ENCRYPT_MODE) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1753
                (opmode != Cipher.DECRYPT_MODE)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1754
                throw new IllegalStateException("Cipher not initialized " +
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1755
                                                "for encryption/decryption");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1756
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1757
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1758
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1759
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1760
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1761
     * Continues a multiple-part encryption or decryption operation
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1762
     * (depending on how this cipher was initialized), processing another data
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1763
     * part.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1764
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1765
     * <p>The bytes in the <code>input</code> buffer are processed, and the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1766
     * result is stored in a new buffer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1767
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1768
     * <p>If <code>input</code> has a length of zero, this method returns
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1769
     * <code>null</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1770
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1771
     * @param input the input buffer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1772
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1773
     * @return the new buffer with the result, or null if the underlying
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1774
     * cipher is a block cipher and the input data is too short to result in a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1775
     * new block.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1776
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1777
     * @exception IllegalStateException if this cipher is in a wrong state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1778
     * (e.g., has not been initialized)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1779
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1780
    public final byte[] update(byte[] input) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1781
        checkCipherState();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1782
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1783
        // Input sanity check
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1784
        if (input == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1785
            throw new IllegalArgumentException("Null input buffer");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1786
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1787
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1788
        chooseFirstProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1789
        if (input.length == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1790
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1791
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1792
        return spi.engineUpdate(input, 0, input.length);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1793
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1794
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1795
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1796
     * Continues a multiple-part encryption or decryption operation
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1797
     * (depending on how this cipher was initialized), processing another data
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1798
     * part.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1799
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1800
     * <p>The first <code>inputLen</code> bytes in the <code>input</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1801
     * buffer, starting at <code>inputOffset</code> inclusive, are processed,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1802
     * and the result is stored in a new buffer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1803
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1804
     * <p>If <code>inputLen</code> is zero, this method returns
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1805
     * <code>null</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1806
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1807
     * @param input the input buffer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1808
     * @param inputOffset the offset in <code>input</code> where the input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1809
     * starts
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1810
     * @param inputLen the input length
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1811
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1812
     * @return the new buffer with the result, or null if the underlying
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1813
     * cipher is a block cipher and the input data is too short to result in a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1814
     * new block.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1815
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1816
     * @exception IllegalStateException if this cipher is in a wrong state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1817
     * (e.g., has not been initialized)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1818
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1819
    public final byte[] update(byte[] input, int inputOffset, int inputLen) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1820
        checkCipherState();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1821
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1822
        // Input sanity check
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1823
        if (input == null || inputOffset < 0
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1824
            || inputLen > (input.length - inputOffset) || inputLen < 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1825
            throw new IllegalArgumentException("Bad arguments");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1826
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1827
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1828
        chooseFirstProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1829
        if (inputLen == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1830
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1831
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1832
        return spi.engineUpdate(input, inputOffset, inputLen);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1833
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1834
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1835
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1836
     * Continues a multiple-part encryption or decryption operation
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1837
     * (depending on how this cipher was initialized), processing another data
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1838
     * part.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1839
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1840
     * <p>The first <code>inputLen</code> bytes in the <code>input</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1841
     * buffer, starting at <code>inputOffset</code> inclusive, are processed,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1842
     * and the result is stored in the <code>output</code> buffer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1843
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1844
     * <p>If the <code>output</code> buffer is too small to hold the result,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1845
     * a <code>ShortBufferException</code> is thrown. In this case, repeat this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1846
     * call with a larger output buffer. Use
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1847
     * {@link #getOutputSize(int) getOutputSize} to determine how big
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1848
     * the output buffer should be.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1849
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1850
     * <p>If <code>inputLen</code> is zero, this method returns
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1851
     * a length of zero.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1852
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1853
     * <p>Note: this method should be copy-safe, which means the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1854
     * <code>input</code> and <code>output</code> buffers can reference
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1855
     * the same byte array and no unprocessed input data is overwritten
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1856
     * when the result is copied into the output buffer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1857
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1858
     * @param input the input buffer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1859
     * @param inputOffset the offset in <code>input</code> where the input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1860
     * starts
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1861
     * @param inputLen the input length
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1862
     * @param output the buffer for the result
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1863
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1864
     * @return the number of bytes stored in <code>output</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1865
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1866
     * @exception IllegalStateException if this cipher is in a wrong state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1867
     * (e.g., has not been initialized)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1868
     * @exception ShortBufferException if the given output buffer is too small
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1869
     * to hold the result
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1870
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1871
    public final int update(byte[] input, int inputOffset, int inputLen,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1872
                            byte[] output)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1873
            throws ShortBufferException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1874
        checkCipherState();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1875
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1876
        // Input sanity check
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1877
        if (input == null || inputOffset < 0
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1878
            || inputLen > (input.length - inputOffset) || inputLen < 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1879
            throw new IllegalArgumentException("Bad arguments");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1880
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1881
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1882
        chooseFirstProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1883
        if (inputLen == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1884
            return 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1885
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1886
        return spi.engineUpdate(input, inputOffset, inputLen,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1887
                                      output, 0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1888
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1889
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1890
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1891
     * Continues a multiple-part encryption or decryption operation
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1892
     * (depending on how this cipher was initialized), processing another data
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1893
     * part.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1894
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1895
     * <p>The first <code>inputLen</code> bytes in the <code>input</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1896
     * buffer, starting at <code>inputOffset</code> inclusive, are processed,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1897
     * and the result is stored in the <code>output</code> buffer, starting at
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1898
     * <code>outputOffset</code> inclusive.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1899
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1900
     * <p>If the <code>output</code> buffer is too small to hold the result,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1901
     * a <code>ShortBufferException</code> is thrown. In this case, repeat this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1902
     * call with a larger output buffer. Use
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1903
     * {@link #getOutputSize(int) getOutputSize} to determine how big
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1904
     * the output buffer should be.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1905
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1906
     * <p>If <code>inputLen</code> is zero, this method returns
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1907
     * a length of zero.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1908
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1909
     * <p>Note: this method should be copy-safe, which means the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1910
     * <code>input</code> and <code>output</code> buffers can reference
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1911
     * the same byte array and no unprocessed input data is overwritten
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1912
     * when the result is copied into the output buffer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1913
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1914
     * @param input the input buffer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1915
     * @param inputOffset the offset in <code>input</code> where the input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1916
     * starts
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1917
     * @param inputLen the input length
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1918
     * @param output the buffer for the result
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1919
     * @param outputOffset the offset in <code>output</code> where the result
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1920
     * is stored
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1921
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1922
     * @return the number of bytes stored in <code>output</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1923
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1924
     * @exception IllegalStateException if this cipher is in a wrong state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1925
     * (e.g., has not been initialized)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1926
     * @exception ShortBufferException if the given output buffer is too small
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1927
     * to hold the result
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1928
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1929
    public final int update(byte[] input, int inputOffset, int inputLen,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1930
                            byte[] output, int outputOffset)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1931
            throws ShortBufferException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1932
        checkCipherState();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1933
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1934
        // Input sanity check
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1935
        if (input == null || inputOffset < 0
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1936
            || inputLen > (input.length - inputOffset) || inputLen < 0
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1937
            || outputOffset < 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1938
            throw new IllegalArgumentException("Bad arguments");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1939
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1940
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1941
        chooseFirstProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1942
        if (inputLen == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1943
            return 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1944
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1945
        return spi.engineUpdate(input, inputOffset, inputLen,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1946
                                      output, outputOffset);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1947
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1948
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1949
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1950
     * Continues a multiple-part encryption or decryption operation
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1951
     * (depending on how this cipher was initialized), processing another data
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1952
     * part.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1953
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1954
     * <p>All <code>input.remaining()</code> bytes starting at
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1955
     * <code>input.position()</code> are processed. The result is stored
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1956
     * in the output buffer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1957
     * Upon return, the input buffer's position will be equal
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1958
     * to its limit; its limit will not have changed. The output buffer's
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1959
     * position will have advanced by n, where n is the value returned
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1960
     * by this method; the output buffer's limit will not have changed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1961
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1962
     * <p>If <code>output.remaining()</code> bytes are insufficient to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1963
     * hold the result, a <code>ShortBufferException</code> is thrown.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1964
     * In this case, repeat this call with a larger output buffer. Use
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1965
     * {@link #getOutputSize(int) getOutputSize} to determine how big
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1966
     * the output buffer should be.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1967
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1968
     * <p>Note: this method should be copy-safe, which means the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1969
     * <code>input</code> and <code>output</code> buffers can reference
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1970
     * the same block of memory and no unprocessed input data is overwritten
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1971
     * when the result is copied into the output buffer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1972
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1973
     * @param input the input ByteBuffer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1974
     * @param output the output ByteByffer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1975
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1976
     * @return the number of bytes stored in <code>output</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1977
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1978
     * @exception IllegalStateException if this cipher is in a wrong state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1979
     * (e.g., has not been initialized)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1980
     * @exception IllegalArgumentException if input and output are the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1981
     *   same object
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1982
     * @exception ReadOnlyBufferException if the output buffer is read-only
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1983
     * @exception ShortBufferException if there is insufficient space in the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1984
     * output buffer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1985
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1986
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1987
    public final int update(ByteBuffer input, ByteBuffer output)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1988
            throws ShortBufferException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1989
        checkCipherState();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1990
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1991
        if ((input == null) || (output == null)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1992
            throw new IllegalArgumentException("Buffers must not be null");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1993
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1994
        if (input == output) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1995
            throw new IllegalArgumentException("Input and output buffers must "
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1996
                + "not be the same object, consider using buffer.duplicate()");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1997
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1998
        if (output.isReadOnly()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1999
            throw new ReadOnlyBufferException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2000
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2001
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2002
        chooseFirstProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2003
        return spi.engineUpdate(input, output);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2004
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2005
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2006
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2007
     * Finishes a multiple-part encryption or decryption operation, depending
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2008
     * on how this cipher was initialized.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2009
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2010
     * <p>Input data that may have been buffered during a previous
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2011
     * <code>update</code> operation is processed, with padding (if requested)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2012
     * being applied.
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2013
     * If an AEAD mode such as GCM/CCM is being used, the authentication
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2014
     * tag is appended in the case of encryption, or verified in the
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2015
     * case of decryption.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2016
     * The result is stored in a new buffer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2017
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2018
     * <p>Upon finishing, this method resets this cipher object to the state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2019
     * it was in when previously initialized via a call to <code>init</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2020
     * That is, the object is reset and available to encrypt or decrypt
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2021
     * (depending on the operation mode that was specified in the call to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2022
     * <code>init</code>) more data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2023
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2024
     * <p>Note: if any exception is thrown, this cipher object may need to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2025
     * be reset before it can be used again.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2026
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2027
     * @return the new buffer with the result
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2028
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2029
     * @exception IllegalStateException if this cipher is in a wrong state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2030
     * (e.g., has not been initialized)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2031
     * @exception IllegalBlockSizeException if this cipher is a block cipher,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2032
     * no padding has been requested (only in encryption mode), and the total
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2033
     * input length of the data processed by this cipher is not a multiple of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2034
     * block size; or if this encryption algorithm is unable to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2035
     * process the input data provided.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2036
     * @exception BadPaddingException if this cipher is in decryption mode,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2037
     * and (un)padding has been requested, but the decrypted data is not
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2038
     * bounded by the appropriate padding bytes
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2039
     * @exception AEADBadTagException if this cipher is decrypting in an
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2040
     * AEAD mode (such as GCM/CCM), and the received authentication tag
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2041
     * does not match the calculated value
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2042
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2043
    public final byte[] doFinal()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2044
            throws IllegalBlockSizeException, BadPaddingException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2045
        checkCipherState();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2046
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2047
        chooseFirstProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2048
        return spi.engineDoFinal(null, 0, 0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2049
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2050
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2051
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2052
     * Finishes a multiple-part encryption or decryption operation, depending
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2053
     * on how this cipher was initialized.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2054
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2055
     * <p>Input data that may have been buffered during a previous
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2056
     * <code>update</code> operation is processed, with padding (if requested)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2057
     * being applied.
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2058
     * If an AEAD mode such as GCM/CCM is being used, the authentication
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2059
     * tag is appended in the case of encryption, or verified in the
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2060
     * case of decryption.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2061
     * The result is stored in the <code>output</code> buffer, starting at
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2062
     * <code>outputOffset</code> inclusive.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2063
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2064
     * <p>If the <code>output</code> buffer is too small to hold the result,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2065
     * a <code>ShortBufferException</code> is thrown. In this case, repeat this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2066
     * call with a larger output buffer. Use
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2067
     * {@link #getOutputSize(int) getOutputSize} to determine how big
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2068
     * the output buffer should be.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2069
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2070
     * <p>Upon finishing, this method resets this cipher object to the state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2071
     * it was in when previously initialized via a call to <code>init</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2072
     * That is, the object is reset and available to encrypt or decrypt
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2073
     * (depending on the operation mode that was specified in the call to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2074
     * <code>init</code>) more data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2075
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2076
     * <p>Note: if any exception is thrown, this cipher object may need to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2077
     * be reset before it can be used again.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2078
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2079
     * @param output the buffer for the result
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2080
     * @param outputOffset the offset in <code>output</code> where the result
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2081
     * is stored
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2082
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2083
     * @return the number of bytes stored in <code>output</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2084
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2085
     * @exception IllegalStateException if this cipher is in a wrong state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2086
     * (e.g., has not been initialized)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2087
     * @exception IllegalBlockSizeException if this cipher is a block cipher,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2088
     * no padding has been requested (only in encryption mode), and the total
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2089
     * input length of the data processed by this cipher is not a multiple of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2090
     * block size; or if this encryption algorithm is unable to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2091
     * process the input data provided.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2092
     * @exception ShortBufferException if the given output buffer is too small
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2093
     * to hold the result
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2094
     * @exception BadPaddingException if this cipher is in decryption mode,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2095
     * and (un)padding has been requested, but the decrypted data is not
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2096
     * bounded by the appropriate padding bytes
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2097
     * @exception AEADBadTagException if this cipher is decrypting in an
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2098
     * AEAD mode (such as GCM/CCM), and the received authentication tag
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2099
     * does not match the calculated value
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2100
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2101
    public final int doFinal(byte[] output, int outputOffset)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2102
            throws IllegalBlockSizeException, ShortBufferException,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2103
               BadPaddingException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2104
        checkCipherState();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2105
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2106
        // Input sanity check
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2107
        if ((output == null) || (outputOffset < 0)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2108
            throw new IllegalArgumentException("Bad arguments");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2109
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2110
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2111
        chooseFirstProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2112
        return spi.engineDoFinal(null, 0, 0, output, outputOffset);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2113
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2114
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2115
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2116
     * Encrypts or decrypts data in a single-part operation, or finishes a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2117
     * multiple-part operation. The data is encrypted or decrypted,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2118
     * depending on how this cipher was initialized.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2119
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2120
     * <p>The bytes in the <code>input</code> buffer, and any input bytes that
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2121
     * may have been buffered during a previous <code>update</code> operation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2122
     * are processed, with padding (if requested) being applied.
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2123
     * If an AEAD mode such as GCM/CCM is being used, the authentication
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2124
     * tag is appended in the case of encryption, or verified in the
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2125
     * case of decryption.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2126
     * The result is stored in a new buffer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2127
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2128
     * <p>Upon finishing, this method resets this cipher object to the state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2129
     * it was in when previously initialized via a call to <code>init</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2130
     * That is, the object is reset and available to encrypt or decrypt
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2131
     * (depending on the operation mode that was specified in the call to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2132
     * <code>init</code>) more data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2133
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2134
     * <p>Note: if any exception is thrown, this cipher object may need to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2135
     * be reset before it can be used again.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2136
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2137
     * @param input the input buffer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2138
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2139
     * @return the new buffer with the result
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2140
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2141
     * @exception IllegalStateException if this cipher is in a wrong state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2142
     * (e.g., has not been initialized)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2143
     * @exception IllegalBlockSizeException if this cipher is a block cipher,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2144
     * no padding has been requested (only in encryption mode), and the total
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2145
     * input length of the data processed by this cipher is not a multiple of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2146
     * block size; or if this encryption algorithm is unable to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2147
     * process the input data provided.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2148
     * @exception BadPaddingException if this cipher is in decryption mode,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2149
     * and (un)padding has been requested, but the decrypted data is not
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2150
     * bounded by the appropriate padding bytes
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2151
     * @exception AEADBadTagException if this cipher is decrypting in an
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2152
     * AEAD mode (such as GCM/CCM), and the received authentication tag
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2153
     * does not match the calculated value
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2154
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2155
    public final byte[] doFinal(byte[] input)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2156
            throws IllegalBlockSizeException, BadPaddingException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2157
        checkCipherState();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2158
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2159
        // Input sanity check
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2160
        if (input == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2161
            throw new IllegalArgumentException("Null input buffer");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2162
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2163
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2164
        chooseFirstProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2165
        return spi.engineDoFinal(input, 0, input.length);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2166
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2167
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2168
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2169
     * Encrypts or decrypts data in a single-part operation, or finishes a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2170
     * multiple-part operation. The data is encrypted or decrypted,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2171
     * depending on how this cipher was initialized.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2172
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2173
     * <p>The first <code>inputLen</code> bytes in the <code>input</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2174
     * buffer, starting at <code>inputOffset</code> inclusive, and any input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2175
     * bytes that may have been buffered during a previous <code>update</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2176
     * operation, are processed, with padding (if requested) being applied.
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2177
     * If an AEAD mode such as GCM/CCM is being used, the authentication
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2178
     * tag is appended in the case of encryption, or verified in the
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2179
     * case of decryption.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2180
     * The result is stored in a new buffer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2181
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2182
     * <p>Upon finishing, this method resets this cipher object to the state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2183
     * it was in when previously initialized via a call to <code>init</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2184
     * That is, the object is reset and available to encrypt or decrypt
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2185
     * (depending on the operation mode that was specified in the call to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2186
     * <code>init</code>) more data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2187
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2188
     * <p>Note: if any exception is thrown, this cipher object may need to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2189
     * be reset before it can be used again.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2190
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2191
     * @param input the input buffer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2192
     * @param inputOffset the offset in <code>input</code> where the input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2193
     * starts
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2194
     * @param inputLen the input length
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2195
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2196
     * @return the new buffer with the result
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2197
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2198
     * @exception IllegalStateException if this cipher is in a wrong state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2199
     * (e.g., has not been initialized)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2200
     * @exception IllegalBlockSizeException if this cipher is a block cipher,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2201
     * no padding has been requested (only in encryption mode), and the total
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2202
     * input length of the data processed by this cipher is not a multiple of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2203
     * block size; or if this encryption algorithm is unable to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2204
     * process the input data provided.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2205
     * @exception BadPaddingException if this cipher is in decryption mode,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2206
     * and (un)padding has been requested, but the decrypted data is not
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2207
     * bounded by the appropriate padding bytes
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2208
     * @exception AEADBadTagException if this cipher is decrypting in an
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2209
     * AEAD mode (such as GCM/CCM), and the received authentication tag
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2210
     * does not match the calculated value
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2211
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2212
    public final byte[] doFinal(byte[] input, int inputOffset, int inputLen)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2213
            throws IllegalBlockSizeException, BadPaddingException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2214
        checkCipherState();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2215
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2216
        // Input sanity check
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2217
        if (input == null || inputOffset < 0
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2218
            || inputLen > (input.length - inputOffset) || inputLen < 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2219
            throw new IllegalArgumentException("Bad arguments");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2220
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2221
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2222
        chooseFirstProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2223
        return spi.engineDoFinal(input, inputOffset, inputLen);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2224
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2225
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2226
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2227
     * Encrypts or decrypts data in a single-part operation, or finishes a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2228
     * multiple-part operation. The data is encrypted or decrypted,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2229
     * depending on how this cipher was initialized.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2230
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2231
     * <p>The first <code>inputLen</code> bytes in the <code>input</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2232
     * buffer, starting at <code>inputOffset</code> inclusive, and any input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2233
     * bytes that may have been buffered during a previous <code>update</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2234
     * operation, are processed, with padding (if requested) being applied.
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2235
     * If an AEAD mode such as GCM/CCM is being used, the authentication
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2236
     * tag is appended in the case of encryption, or verified in the
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2237
     * case of decryption.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2238
     * The result is stored in the <code>output</code> buffer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2239
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2240
     * <p>If the <code>output</code> buffer is too small to hold the result,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2241
     * a <code>ShortBufferException</code> is thrown. In this case, repeat this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2242
     * call with a larger output buffer. Use
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2243
     * {@link #getOutputSize(int) getOutputSize} to determine how big
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2244
     * the output buffer should be.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2245
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2246
     * <p>Upon finishing, this method resets this cipher object to the state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2247
     * it was in when previously initialized via a call to <code>init</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2248
     * That is, the object is reset and available to encrypt or decrypt
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2249
     * (depending on the operation mode that was specified in the call to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2250
     * <code>init</code>) more data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2251
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2252
     * <p>Note: if any exception is thrown, this cipher object may need to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2253
     * be reset before it can be used again.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2254
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2255
     * <p>Note: this method should be copy-safe, which means the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2256
     * <code>input</code> and <code>output</code> buffers can reference
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2257
     * the same byte array and no unprocessed input data is overwritten
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2258
     * when the result is copied into the output buffer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2259
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2260
     * @param input the input buffer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2261
     * @param inputOffset the offset in <code>input</code> where the input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2262
     * starts
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2263
     * @param inputLen the input length
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2264
     * @param output the buffer for the result
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2265
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2266
     * @return the number of bytes stored in <code>output</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2267
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2268
     * @exception IllegalStateException if this cipher is in a wrong state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2269
     * (e.g., has not been initialized)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2270
     * @exception IllegalBlockSizeException if this cipher is a block cipher,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2271
     * no padding has been requested (only in encryption mode), and the total
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2272
     * input length of the data processed by this cipher is not a multiple of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2273
     * block size; or if this encryption algorithm is unable to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2274
     * process the input data provided.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2275
     * @exception ShortBufferException if the given output buffer is too small
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2276
     * to hold the result
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2277
     * @exception BadPaddingException if this cipher is in decryption mode,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2278
     * and (un)padding has been requested, but the decrypted data is not
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2279
     * bounded by the appropriate padding bytes
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2280
     * @exception AEADBadTagException if this cipher is decrypting in an
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2281
     * AEAD mode (such as GCM/CCM), and the received authentication tag
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2282
     * does not match the calculated value
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2283
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2284
    public final int doFinal(byte[] input, int inputOffset, int inputLen,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2285
                             byte[] output)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2286
            throws ShortBufferException, IllegalBlockSizeException,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2287
            BadPaddingException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2288
        checkCipherState();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2289
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2290
        // Input sanity check
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2291
        if (input == null || inputOffset < 0
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2292
            || inputLen > (input.length - inputOffset) || inputLen < 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2293
            throw new IllegalArgumentException("Bad arguments");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2294
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2295
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2296
        chooseFirstProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2297
        return spi.engineDoFinal(input, inputOffset, inputLen,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2298
                                       output, 0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2299
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2300
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2301
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2302
     * Encrypts or decrypts data in a single-part operation, or finishes a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2303
     * multiple-part operation. The data is encrypted or decrypted,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2304
     * depending on how this cipher was initialized.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2305
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2306
     * <p>The first <code>inputLen</code> bytes in the <code>input</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2307
     * buffer, starting at <code>inputOffset</code> inclusive, and any input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2308
     * bytes that may have been buffered during a previous
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2309
     * <code>update</code> operation, are processed, with padding
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2310
     * (if requested) being applied.
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2311
     * If an AEAD mode such as GCM/CCM is being used, the authentication
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2312
     * tag is appended in the case of encryption, or verified in the
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2313
     * case of decryption.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2314
     * The result is stored in the <code>output</code> buffer, starting at
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2315
     * <code>outputOffset</code> inclusive.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2316
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2317
     * <p>If the <code>output</code> buffer is too small to hold the result,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2318
     * a <code>ShortBufferException</code> is thrown. In this case, repeat this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2319
     * call with a larger output buffer. Use
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2320
     * {@link #getOutputSize(int) getOutputSize} to determine how big
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2321
     * the output buffer should be.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2322
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2323
     * <p>Upon finishing, this method resets this cipher object to the state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2324
     * it was in when previously initialized via a call to <code>init</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2325
     * That is, the object is reset and available to encrypt or decrypt
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2326
     * (depending on the operation mode that was specified in the call to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2327
     * <code>init</code>) more data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2328
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2329
     * <p>Note: if any exception is thrown, this cipher object may need to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2330
     * be reset before it can be used again.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2331
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2332
     * <p>Note: this method should be copy-safe, which means the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2333
     * <code>input</code> and <code>output</code> buffers can reference
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2334
     * the same byte array and no unprocessed input data is overwritten
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2335
     * when the result is copied into the output buffer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2336
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2337
     * @param input the input buffer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2338
     * @param inputOffset the offset in <code>input</code> where the input
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2339
     * starts
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2340
     * @param inputLen the input length
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2341
     * @param output the buffer for the result
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2342
     * @param outputOffset the offset in <code>output</code> where the result
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2343
     * is stored
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2344
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2345
     * @return the number of bytes stored in <code>output</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2346
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2347
     * @exception IllegalStateException if this cipher is in a wrong state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2348
     * (e.g., has not been initialized)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2349
     * @exception IllegalBlockSizeException if this cipher is a block cipher,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2350
     * no padding has been requested (only in encryption mode), and the total
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2351
     * input length of the data processed by this cipher is not a multiple of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2352
     * block size; or if this encryption algorithm is unable to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2353
     * process the input data provided.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2354
     * @exception ShortBufferException if the given output buffer is too small
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2355
     * to hold the result
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2356
     * @exception BadPaddingException if this cipher is in decryption mode,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2357
     * and (un)padding has been requested, but the decrypted data is not
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2358
     * bounded by the appropriate padding bytes
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2359
     * @exception AEADBadTagException if this cipher is decrypting in an
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2360
     * AEAD mode (such as GCM/CCM), and the received authentication tag
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2361
     * does not match the calculated value
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2362
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2363
    public final int doFinal(byte[] input, int inputOffset, int inputLen,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2364
                             byte[] output, int outputOffset)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2365
            throws ShortBufferException, IllegalBlockSizeException,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2366
            BadPaddingException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2367
        checkCipherState();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2368
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2369
        // Input sanity check
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2370
        if (input == null || inputOffset < 0
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2371
            || inputLen > (input.length - inputOffset) || inputLen < 0
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2372
            || outputOffset < 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2373
            throw new IllegalArgumentException("Bad arguments");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2374
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2375
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2376
        chooseFirstProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2377
        return spi.engineDoFinal(input, inputOffset, inputLen,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2378
                                       output, outputOffset);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2379
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2380
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2381
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2382
     * Encrypts or decrypts data in a single-part operation, or finishes a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2383
     * multiple-part operation. The data is encrypted or decrypted,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2384
     * depending on how this cipher was initialized.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2385
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2386
     * <p>All <code>input.remaining()</code> bytes starting at
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2387
     * <code>input.position()</code> are processed.
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2388
     * If an AEAD mode such as GCM/CCM is being used, the authentication
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2389
     * tag is appended in the case of encryption, or verified in the
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2390
     * case of decryption.
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2391
     * The result is stored in the output buffer.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2392
     * Upon return, the input buffer's position will be equal
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2393
     * to its limit; its limit will not have changed. The output buffer's
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2394
     * position will have advanced by n, where n is the value returned
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2395
     * by this method; the output buffer's limit will not have changed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2396
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2397
     * <p>If <code>output.remaining()</code> bytes are insufficient to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2398
     * hold the result, a <code>ShortBufferException</code> is thrown.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2399
     * In this case, repeat this call with a larger output buffer. Use
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2400
     * {@link #getOutputSize(int) getOutputSize} to determine how big
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2401
     * the output buffer should be.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2402
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2403
     * <p>Upon finishing, this method resets this cipher object to the state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2404
     * it was in when previously initialized via a call to <code>init</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2405
     * That is, the object is reset and available to encrypt or decrypt
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2406
     * (depending on the operation mode that was specified in the call to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2407
     * <code>init</code>) more data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2408
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2409
     * <p>Note: if any exception is thrown, this cipher object may need to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2410
     * be reset before it can be used again.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2411
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2412
     * <p>Note: this method should be copy-safe, which means the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2413
     * <code>input</code> and <code>output</code> buffers can reference
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2414
     * the same byte array and no unprocessed input data is overwritten
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2415
     * when the result is copied into the output buffer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2416
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2417
     * @param input the input ByteBuffer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2418
     * @param output the output ByteBuffer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2419
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2420
     * @return the number of bytes stored in <code>output</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2421
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2422
     * @exception IllegalStateException if this cipher is in a wrong state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2423
     * (e.g., has not been initialized)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2424
     * @exception IllegalArgumentException if input and output are the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2425
     *   same object
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2426
     * @exception ReadOnlyBufferException if the output buffer is read-only
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2427
     * @exception IllegalBlockSizeException if this cipher is a block cipher,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2428
     * no padding has been requested (only in encryption mode), and the total
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2429
     * input length of the data processed by this cipher is not a multiple of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2430
     * block size; or if this encryption algorithm is unable to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2431
     * process the input data provided.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2432
     * @exception ShortBufferException if there is insufficient space in the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2433
     * output buffer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2434
     * @exception BadPaddingException if this cipher is in decryption mode,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2435
     * and (un)padding has been requested, but the decrypted data is not
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2436
     * bounded by the appropriate padding bytes
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2437
     * @exception AEADBadTagException if this cipher is decrypting in an
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2438
     * AEAD mode (such as GCM/CCM), and the received authentication tag
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2439
     * does not match the calculated value
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2440
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2441
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2442
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2443
    public final int doFinal(ByteBuffer input, ByteBuffer output)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2444
            throws ShortBufferException, IllegalBlockSizeException,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2445
            BadPaddingException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2446
        checkCipherState();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2447
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2448
        if ((input == null) || (output == null)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2449
            throw new IllegalArgumentException("Buffers must not be null");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2450
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2451
        if (input == output) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2452
            throw new IllegalArgumentException("Input and output buffers must "
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2453
                + "not be the same object, consider using buffer.duplicate()");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2454
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2455
        if (output.isReadOnly()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2456
            throw new ReadOnlyBufferException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2457
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2458
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2459
        chooseFirstProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2460
        return spi.engineDoFinal(input, output);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2461
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2462
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2463
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2464
     * Wrap a key.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2465
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2466
     * @param key the key to be wrapped.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2467
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2468
     * @return the wrapped key.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2469
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2470
     * @exception IllegalStateException if this cipher is in a wrong
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2471
     * state (e.g., has not been initialized).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2472
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2473
     * @exception IllegalBlockSizeException if this cipher is a block
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2474
     * cipher, no padding has been requested, and the length of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2475
     * encoding of the key to be wrapped is not a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2476
     * multiple of the block size.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2477
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2478
     * @exception InvalidKeyException if it is impossible or unsafe to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2479
     * wrap the key with this cipher (e.g., a hardware protected key is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2480
     * being passed to a software-only cipher).
17919
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  2481
     *
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  2482
     * @throws UnsupportedOperationException if the corresponding method in the
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  2483
     * {@code CipherSpi} is not supported.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2484
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2485
    public final byte[] wrap(Key key)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2486
            throws IllegalBlockSizeException, InvalidKeyException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2487
        if (!(this instanceof NullCipher)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2488
            if (!initialized) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2489
                throw new IllegalStateException("Cipher not initialized");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2490
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2491
            if (opmode != Cipher.WRAP_MODE) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2492
                throw new IllegalStateException("Cipher not initialized " +
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2493
                                                "for wrapping keys");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2494
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2495
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2496
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2497
        chooseFirstProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2498
        return spi.engineWrap(key);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2499
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2500
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2501
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2502
     * Unwrap a previously wrapped key.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2503
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2504
     * @param wrappedKey the key to be unwrapped.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2505
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2506
     * @param wrappedKeyAlgorithm the algorithm associated with the wrapped
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2507
     * key.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2508
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2509
     * @param wrappedKeyType the type of the wrapped key. This must be one of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2510
     * <code>SECRET_KEY</code>, <code>PRIVATE_KEY</code>, or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2511
     * <code>PUBLIC_KEY</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2512
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2513
     * @return the unwrapped key.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2514
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2515
     * @exception IllegalStateException if this cipher is in a wrong state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2516
     * (e.g., has not been initialized).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2517
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2518
     * @exception NoSuchAlgorithmException if no installed providers
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2519
     * can create keys of type <code>wrappedKeyType</code> for the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2520
     * <code>wrappedKeyAlgorithm</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2521
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2522
     * @exception InvalidKeyException if <code>wrappedKey</code> does not
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2523
     * represent a wrapped key of type <code>wrappedKeyType</code> for
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2524
     * the <code>wrappedKeyAlgorithm</code>.
17919
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  2525
     *
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  2526
     * @throws UnsupportedOperationException if the corresponding method in the
b5c4ce8b74c5 6750584: Cipher.wrap/unwrap methods should define UnsupportedOperationException
ascarpino
parents: 15008
diff changeset
  2527
     * {@code CipherSpi} is not supported.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2528
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2529
    public final Key unwrap(byte[] wrappedKey,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2530
                            String wrappedKeyAlgorithm,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2531
                            int wrappedKeyType)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2532
            throws InvalidKeyException, NoSuchAlgorithmException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2533
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2534
        if (!(this instanceof NullCipher)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2535
            if (!initialized) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2536
                throw new IllegalStateException("Cipher not initialized");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2537
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2538
            if (opmode != Cipher.UNWRAP_MODE) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2539
                throw new IllegalStateException("Cipher not initialized " +
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2540
                                                "for unwrapping keys");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2541
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2542
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2543
        if ((wrappedKeyType != SECRET_KEY) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2544
            (wrappedKeyType != PRIVATE_KEY) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2545
            (wrappedKeyType != PUBLIC_KEY)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2546
            throw new InvalidParameterException("Invalid key type");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2547
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2548
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2549
        chooseFirstProvider();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2550
        return spi.engineUnwrap(wrappedKey,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2551
                                      wrappedKeyAlgorithm,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2552
                                      wrappedKeyType);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2553
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2554
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2555
    private AlgorithmParameterSpec getAlgorithmParameterSpec(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2556
                                      AlgorithmParameters params)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2557
            throws InvalidParameterSpecException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2558
        if (params == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2559
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2560
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2561
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2562
        String alg = params.getAlgorithm().toUpperCase(Locale.ENGLISH);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2563
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2564
        if (alg.equalsIgnoreCase("RC2")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2565
            return params.getParameterSpec(RC2ParameterSpec.class);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2566
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2567
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2568
        if (alg.equalsIgnoreCase("RC5")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2569
            return params.getParameterSpec(RC5ParameterSpec.class);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2570
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2571
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2572
        if (alg.startsWith("PBE")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2573
            return params.getParameterSpec(PBEParameterSpec.class);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2574
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2575
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2576
        if (alg.startsWith("DES")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2577
            return params.getParameterSpec(IvParameterSpec.class);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2578
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2579
        return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2580
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2581
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2582
    private static CryptoPermission getConfiguredPermission(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2583
            String transformation) throws NullPointerException,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2584
            NoSuchAlgorithmException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2585
        if (transformation == null) throw new NullPointerException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2586
        String[] parts = tokenizeTransformation(transformation);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2587
        return JceSecurityManager.INSTANCE.getCryptoPermission(parts[0]);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2588
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2589
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2590
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2591
     * Returns the maximum key length for the specified transformation
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2592
     * according to the installed JCE jurisdiction policy files. If
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2593
     * JCE unlimited strength jurisdiction policy files are installed,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2594
     * Integer.MAX_VALUE will be returned.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2595
     * For more information on default key size in JCE jurisdiction
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2596
     * policy files, please see Appendix E in the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2597
     * <a href=
1692
92165aa9df3e 6778613: Update javax.crypto.Cipher.getMaxAllowedKeyLength to point to proper Appendix after doc reorg
wetmore
parents: 2
diff changeset
  2598
     *   "{@docRoot}/../technotes/guides/security/crypto/CryptoSpec.html#AppC">
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2599
     * Java Cryptography Architecture Reference Guide</a>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2600
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2601
     * @param transformation the cipher transformation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2602
     * @return the maximum key length in bits or Integer.MAX_VALUE.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2603
     * @exception NullPointerException if <code>transformation</code> is null.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2604
     * @exception NoSuchAlgorithmException if <code>transformation</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2605
     * is not a valid transformation, i.e. in the form of "algorithm" or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2606
     * "algorithm/mode/padding".
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2607
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2608
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2609
    public static final int getMaxAllowedKeyLength(String transformation)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2610
            throws NoSuchAlgorithmException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2611
        CryptoPermission cp = getConfiguredPermission(transformation);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2612
        return cp.getMaxKeySize();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2613
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2614
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2615
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2616
     * Returns an AlgorithmParameterSpec object which contains
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2617
     * the maximum cipher parameter value according to the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2618
     * jurisdiction policy file. If JCE unlimited strength jurisdiction
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2619
     * policy files are installed or there is no maximum limit on the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2620
     * parameters for the specified transformation in the policy file,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2621
     * null will be returned.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2622
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2623
     * @param transformation the cipher transformation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2624
     * @return an AlgorithmParameterSpec which holds the maximum
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2625
     * value or null.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2626
     * @exception NullPointerException if <code>transformation</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2627
     * is null.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2628
     * @exception NoSuchAlgorithmException if <code>transformation</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2629
     * is not a valid transformation, i.e. in the form of "algorithm" or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2630
     * "algorithm/mode/padding".
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2631
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2632
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2633
    public static final AlgorithmParameterSpec getMaxAllowedParameterSpec(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2634
            String transformation) throws NoSuchAlgorithmException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2635
        CryptoPermission cp = getConfiguredPermission(transformation);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2636
        return cp.getAlgorithmParameterSpec();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2637
    }
9265
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2638
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2639
    /**
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2640
     * Continues a multi-part update of the Additional Authentication
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2641
     * Data (AAD).
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2642
     * <p>
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2643
     * Calls to this method provide AAD to the cipher when operating in
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2644
     * modes such as AEAD (GCM/CCM).  If this cipher is operating in
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2645
     * either GCM or CCM mode, all AAD must be supplied before beginning
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2646
     * operations on the ciphertext (via the {@code update} and {@code
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2647
     * doFinal} methods).
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2648
     *
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2649
     * @param src the buffer containing the Additional Authentication Data
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2650
     *
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2651
     * @throws IllegalArgumentException if the {@code src}
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2652
     * byte array is null
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2653
     * @throws IllegalStateException if this cipher is in a wrong state
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2654
     * (e.g., has not been initialized), does not accept AAD, or if
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2655
     * operating in either GCM or CCM mode and one of the {@code update}
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2656
     * methods has already been called for the active
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2657
     * encryption/decryption operation
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2658
     * @throws UnsupportedOperationException if the corresponding method
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2659
     * in the {@code CipherSpi} has not been overridden by an
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2660
     * implementation
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2661
     *
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2662
     * @since 1.7
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2663
     */
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2664
    public final void updateAAD(byte[] src) {
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2665
        if (src == null) {
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2666
            throw new IllegalArgumentException("src buffer is null");
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2667
        }
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2668
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2669
        updateAAD(src, 0, src.length);
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2670
    }
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2671
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2672
    /**
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2673
     * Continues a multi-part update of the Additional Authentication
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2674
     * Data (AAD), using a subset of the provided buffer.
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2675
     * <p>
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2676
     * Calls to this method provide AAD to the cipher when operating in
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2677
     * modes such as AEAD (GCM/CCM).  If this cipher is operating in
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2678
     * either GCM or CCM mode, all AAD must be supplied before beginning
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2679
     * operations on the ciphertext (via the {@code update} and {@code
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2680
     * doFinal} methods).
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2681
     *
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2682
     * @param src the buffer containing the AAD
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2683
     * @param offset the offset in {@code src} where the AAD input starts
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2684
     * @param len the number of AAD bytes
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2685
     *
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2686
     * @throws IllegalArgumentException if the {@code src}
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2687
     * byte array is null, or the {@code offset} or {@code length}
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2688
     * is less than 0, or the sum of the {@code offset} and
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2689
     * {@code len} is greater than the length of the
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2690
     * {@code src} byte array
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2691
     * @throws IllegalStateException if this cipher is in a wrong state
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2692
     * (e.g., has not been initialized), does not accept AAD, or if
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2693
     * operating in either GCM or CCM mode and one of the {@code update}
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2694
     * methods has already been called for the active
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2695
     * encryption/decryption operation
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2696
     * @throws UnsupportedOperationException if the corresponding method
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2697
     * in the {@code CipherSpi} has not been overridden by an
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2698
     * implementation
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2699
     *
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2700
     * @since 1.7
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2701
     */
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2702
    public final void updateAAD(byte[] src, int offset, int len) {
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2703
        checkCipherState();
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2704
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2705
        // Input sanity check
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2706
        if ((src == null) || (offset < 0) || (len < 0)
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2707
                || ((len + offset) > src.length)) {
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2708
            throw new IllegalArgumentException("Bad arguments");
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2709
        }
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2710
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2711
        chooseFirstProvider();
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2712
        if (len == 0) {
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2713
            return;
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2714
        }
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2715
        spi.engineUpdateAAD(src, offset, len);
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2716
    }
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2717
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2718
    /**
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2719
     * Continues a multi-part update of the Additional Authentication
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2720
     * Data (AAD).
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2721
     * <p>
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2722
     * Calls to this method provide AAD to the cipher when operating in
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2723
     * modes such as AEAD (GCM/CCM).  If this cipher is operating in
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2724
     * either GCM or CCM mode, all AAD must be supplied before beginning
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2725
     * operations on the ciphertext (via the {@code update} and {@code
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2726
     * doFinal} methods).
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2727
     * <p>
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2728
     * All {@code src.remaining()} bytes starting at
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2729
     * {@code src.position()} are processed.
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2730
     * Upon return, the input buffer's position will be equal
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2731
     * to its limit; its limit will not have changed.
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2732
     *
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2733
     * @param src the buffer containing the AAD
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2734
     *
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2735
     * @throws IllegalArgumentException if the {@code src ByteBuffer}
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2736
     * is null
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2737
     * @throws IllegalStateException if this cipher is in a wrong state
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2738
     * (e.g., has not been initialized), does not accept AAD, or if
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2739
     * operating in either GCM or CCM mode and one of the {@code update}
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2740
     * methods has already been called for the active
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2741
     * encryption/decryption operation
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2742
     * @throws UnsupportedOperationException if the corresponding method
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2743
     * in the {@code CipherSpi} has not been overridden by an
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2744
     * implementation
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2745
     *
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2746
     * @since 1.7
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2747
     */
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2748
    public final void updateAAD(ByteBuffer src) {
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2749
        checkCipherState();
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2750
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2751
        // Input sanity check
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2752
        if (src == null) {
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2753
            throw new IllegalArgumentException("src ByteBuffer is null");
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2754
        }
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2755
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2756
        chooseFirstProvider();
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2757
        if (src.remaining() == 0) {
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2758
            return;
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2759
        }
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2760
        spi.engineUpdateAAD(src);
62d885310f4d 7031343: Provide API changes to support future GCM AEAD ciphers
wetmore
parents: 8152
diff changeset
  2761
    }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2762
}