1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 package javax.crypto; 19 20 import java.nio.ByteBuffer; 21 import java.security.InvalidAlgorithmParameterException; 22 import java.security.InvalidKeyException; 23 import java.security.Key; 24 import java.security.spec.AlgorithmParameterSpec; 25 26 /** 27 * The <i>Service-Provider Interface</i> (<b>SPI</b>) definition for the {@code 28 * Mac} class. 29 * 30 * @see Mac 31 */ 32 public abstract class MacSpi { 33 34 /** 35 * Creates a new {@code MacSpi} instance. 36 */ MacSpi()37 public MacSpi() { 38 } 39 40 /** 41 * Returns the length of this MAC (in bytes). 42 * 43 * @return the length of this MAC (in bytes). 44 */ engineGetMacLength()45 protected abstract int engineGetMacLength(); 46 47 /** 48 * Initializes this {@code MacSpi} instance with the specified key and 49 * algorithm parameters. 50 * 51 * @param key 52 * the key to initialize this algorithm. 53 * @param params 54 * the parameters for this algorithm. 55 * @throws InvalidKeyException 56 * if the specified key cannot be used to initialize this 57 * algorithm, or it is {@code null}. 58 * @throws InvalidAlgorithmParameterException 59 * if the specified parameters cannot be used to initialize this 60 * algorithm. 61 */ engineInit(Key key, AlgorithmParameterSpec params)62 protected abstract void engineInit(Key key, AlgorithmParameterSpec params) 63 throws InvalidKeyException, InvalidAlgorithmParameterException; 64 65 /** 66 * Updates this {@code MacSpi} instance with the specified byte. 67 * 68 * @param input 69 * the byte. 70 */ engineUpdate(byte input)71 protected abstract void engineUpdate(byte input); 72 73 /** 74 * Updates this {@code MacSpi} instance with the data from the specified 75 * buffer {@code input} from the specified {@code offset} and length {@code 76 * len}. 77 * 78 * @param input 79 * the buffer. 80 * @param offset 81 * the offset in the buffer. 82 * @param len 83 * the length of the data in the buffer. 84 */ engineUpdate(byte[] input, int offset, int len)85 protected abstract void engineUpdate(byte[] input, int offset, int len); 86 87 /** 88 * Updates this {@code MacSpi} instance with the data from the specified 89 * buffer, starting at {@link ByteBuffer#position()}, including the next 90 * {@link ByteBuffer#remaining()} bytes. 91 * 92 * @param input 93 * the buffer. 94 */ engineUpdate(ByteBuffer input)95 protected void engineUpdate(ByteBuffer input) { 96 if (!input.hasRemaining()) { 97 return; 98 } 99 byte[] bInput; 100 if (input.hasArray()) { 101 bInput = input.array(); 102 int offset = input.arrayOffset(); 103 int position = input.position(); 104 int limit = input.limit(); 105 engineUpdate(bInput, offset + position, limit - position); 106 input.position(limit); 107 } else { 108 bInput = new byte[input.limit() - input.position()]; 109 input.get(bInput); 110 engineUpdate(bInput, 0, bInput.length); 111 } 112 } 113 114 /** 115 * Computes the digest of this MAC based on the data previously specified in 116 * {@link #engineUpdate} calls. 117 * <p> 118 * This {@code MacSpi} instance is reverted to its initial state and 119 * can be used to start the next MAC computation with the same parameters or 120 * initialized with different parameters. 121 * 122 * @return the generated digest. 123 */ engineDoFinal()124 protected abstract byte[] engineDoFinal(); 125 126 /** 127 * Resets this {@code MacSpi} instance to its initial state. 128 * <p> 129 * This {@code MacSpi} instance is reverted to its initial state and can be 130 * used to start the next MAC computation with the same parameters or 131 * initialized with different parameters. 132 */ engineReset()133 protected abstract void engineReset(); 134 135 /** 136 * Clones this {@code MacSpi} instance. 137 * 138 * @return the cloned instance. 139 * @throws CloneNotSupportedException 140 * if cloning is not supported. 141 */ 142 @Override clone()143 public Object clone() throws CloneNotSupportedException { 144 return super.clone(); 145 } 146 } 147