1 // Copyright 2023 Google LLC 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 // 15 //////////////////////////////////////////////////////////////////////////////// 16 17 package com.google.crypto.tink.prf; 18 19 import static com.google.common.truth.Truth.assertThat; 20 import static java.nio.charset.StandardCharsets.UTF_8; 21 import static org.junit.Assert.assertThrows; 22 23 import com.google.crypto.tink.subtle.Hex; 24 import com.google.crypto.tink.util.Bytes; 25 import java.security.GeneralSecurityException; 26 import org.junit.Test; 27 import org.junit.experimental.theories.DataPoints; 28 import org.junit.experimental.theories.FromDataPoints; 29 import org.junit.experimental.theories.Theories; 30 import org.junit.experimental.theories.Theory; 31 import org.junit.runner.RunWith; 32 33 @RunWith(Theories.class) 34 public final class HkdfPrfParametersTest { 35 36 private static final Bytes SALT = Bytes.copyFrom(Hex.decode("2023af")); 37 38 @DataPoints("keySizes") 39 public static final int[] KEY_SIZES = new int[] {16, 32}; 40 41 @Theory buildWithSalt_succeeds(@romDataPoints"keySizes") int keySize)42 public void buildWithSalt_succeeds(@FromDataPoints("keySizes") int keySize) throws Exception { 43 HkdfPrfParameters parameters = 44 HkdfPrfParameters.builder() 45 .setKeySizeBytes(keySize) 46 .setHashType(HkdfPrfParameters.HashType.SHA256) 47 .setSalt(SALT) 48 .build(); 49 assertThat(parameters.getKeySizeBytes()).isEqualTo(keySize); 50 assertThat(parameters.getHashType()).isEqualTo(HkdfPrfParameters.HashType.SHA256); 51 assertThat(parameters.getSalt()).isEqualTo(SALT); 52 assertThat(parameters.hasIdRequirement()).isFalse(); 53 assertThat(parameters.toString()) 54 .isEqualTo( 55 "HKDF PRF Parameters (hashType: SHA256, salt: Bytes(2023af), and " 56 + keySize 57 + "-byte key)"); 58 } 59 60 @Test buildWithoutSettingSalt_succeeds()61 public void buildWithoutSettingSalt_succeeds() throws Exception { 62 HkdfPrfParameters parameters = 63 HkdfPrfParameters.builder() 64 .setKeySizeBytes(16) 65 .setHashType(HkdfPrfParameters.HashType.SHA256) 66 .build(); 67 assertThat(parameters.getSalt()).isNull(); 68 } 69 70 @Test buildWithEmptySalt_succeeds()71 public void buildWithEmptySalt_succeeds() throws Exception { 72 HkdfPrfParameters parameters = 73 HkdfPrfParameters.builder() 74 .setKeySizeBytes(16) 75 .setHashType(HkdfPrfParameters.HashType.SHA256) 76 .setSalt(Bytes.copyFrom("".getBytes(UTF_8))) 77 .build(); 78 assertThat(parameters.getSalt()).isNull(); 79 } 80 81 @Test clearSaltWithEmptyString_succeeds()82 public void clearSaltWithEmptyString_succeeds() throws Exception { 83 HkdfPrfParameters parameters = 84 HkdfPrfParameters.builder() 85 .setKeySizeBytes(16) 86 .setHashType(HkdfPrfParameters.HashType.SHA256) 87 .setSalt(Bytes.copyFrom("Some Salt".getBytes(UTF_8))) 88 .setSalt(Bytes.copyFrom("".getBytes(UTF_8))) 89 .build(); 90 assertThat(parameters.getSalt()).isNull(); 91 } 92 93 @Test buildWithoutSettingKeySize_fails()94 public void buildWithoutSettingKeySize_fails() throws Exception { 95 assertThrows( 96 GeneralSecurityException.class, 97 () -> 98 HkdfPrfParameters.builder() 99 .setHashType(HkdfPrfParameters.HashType.SHA256) 100 .setSalt(SALT) 101 .build()); 102 } 103 104 @Test buildWithUnsupportedKeySize_fails()105 public void buildWithUnsupportedKeySize_fails() throws Exception { 106 assertThrows( 107 GeneralSecurityException.class, 108 () -> 109 HkdfPrfParameters.builder() 110 .setKeySizeBytes(15) 111 .setHashType(HkdfPrfParameters.HashType.SHA256) 112 .setSalt(SALT) 113 .build()); 114 } 115 116 @Test buildWithoutSettingHashType_fails()117 public void buildWithoutSettingHashType_fails() throws Exception { 118 assertThrows( 119 GeneralSecurityException.class, 120 () -> HkdfPrfParameters.builder().setKeySizeBytes(16).setSalt(SALT).build()); 121 } 122 123 @Test equalsAndHashCode()124 public void equalsAndHashCode() throws Exception { 125 HkdfPrfParameters parameters = 126 HkdfPrfParameters.builder() 127 .setKeySizeBytes(16) 128 .setHashType(HkdfPrfParameters.HashType.SHA256) 129 .setSalt(SALT) 130 .build(); 131 HkdfPrfParameters sameParameters = 132 HkdfPrfParameters.builder() 133 .setKeySizeBytes(16) 134 .setHashType(HkdfPrfParameters.HashType.SHA256) 135 .setSalt(SALT) 136 .build(); 137 assertThat(sameParameters).isEqualTo(parameters); 138 assertThat(sameParameters.hashCode()).isEqualTo(parameters.hashCode()); 139 140 HkdfPrfParameters keySize32Parameters = 141 HkdfPrfParameters.builder() 142 .setKeySizeBytes(32) 143 .setHashType(parameters.getHashType()) 144 .setSalt(parameters.getSalt()) 145 .build(); 146 assertThat(keySize32Parameters).isNotEqualTo(parameters); 147 assertThat(keySize32Parameters.hashCode()).isNotEqualTo(parameters.hashCode()); 148 149 HkdfPrfParameters sha512Parameters = 150 HkdfPrfParameters.builder() 151 .setKeySizeBytes(parameters.getKeySizeBytes()) 152 .setHashType(HkdfPrfParameters.HashType.SHA512) 153 .setSalt(parameters.getSalt()) 154 .build(); 155 assertThat(sha512Parameters).isNotEqualTo(parameters); 156 assertThat(sha512Parameters.hashCode()).isNotEqualTo(parameters.hashCode()); 157 158 HkdfPrfParameters noSaltParameters = 159 HkdfPrfParameters.builder() 160 .setKeySizeBytes(parameters.getKeySizeBytes()) 161 .setHashType(parameters.getHashType()) 162 .build(); 163 HkdfPrfParameters sameNoSaltParameters = 164 HkdfPrfParameters.builder() 165 .setKeySizeBytes(parameters.getKeySizeBytes()) 166 .setHashType(parameters.getHashType()) 167 .build(); 168 assertThat(sameNoSaltParameters).isEqualTo(noSaltParameters); 169 assertThat(sameNoSaltParameters.hashCode()).isEqualTo(noSaltParameters.hashCode()); 170 assertThat(noSaltParameters).isNotEqualTo(parameters); 171 assertThat(noSaltParameters.hashCode()).isNotEqualTo(parameters.hashCode()); 172 } 173 } 174