1// Copyright 2019 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 17package keyset_test 18 19import ( 20 "bytes" 21 "testing" 22 23 "google.golang.org/protobuf/proto" 24 "github.com/google/tink/go/aead" 25 "github.com/google/tink/go/keyset" 26 "github.com/google/tink/go/mac" 27 "github.com/google/tink/go/signature" 28 "github.com/google/tink/go/testkeyset" 29 "github.com/google/tink/go/testutil" 30 tinkpb "github.com/google/tink/go/proto/tink_go_proto" 31) 32 33func TestNewHandle(t *testing.T) { 34 template := mac.HMACSHA256Tag128KeyTemplate() 35 handle, err := keyset.NewHandle(template) 36 if err != nil { 37 t.Errorf("keyset.NewHandle(template) = %v, want nil", err) 38 } 39 ks := testkeyset.KeysetMaterial(handle) 40 if len(ks.Key) != 1 { 41 t.Errorf("len(ks.Key) = %d, want 1", len(ks.Key)) 42 } 43 key := ks.Key[0] 44 if ks.PrimaryKeyId != key.KeyId { 45 t.Errorf("ks.PrimaryKeyId = %d, want %d", ks.PrimaryKeyId, key.KeyId) 46 } 47 if key.KeyData.TypeUrl != template.TypeUrl { 48 t.Errorf("key.KeyData.TypeUrl = %v, want %v", key.KeyData.TypeUrl, template.TypeUrl) 49 } 50 if _, err = mac.New(handle); err != nil { 51 t.Errorf("mac.New(handle) err = %v, want nil", err) 52 } 53} 54 55func TestNewHandleWithInvalidTypeURLFails(t *testing.T) { 56 // template with unknown TypeURL 57 invalidTemplate := mac.HMACSHA256Tag128KeyTemplate() 58 invalidTemplate.TypeUrl = "some unknown TypeURL" 59 if _, err := keyset.NewHandle(invalidTemplate); err == nil { 60 t.Errorf("keyset.NewHandle(invalidTemplate) err = nil, want error") 61 } 62} 63 64func TestNewHandleWithNilTemplateFails(t *testing.T) { 65 if _, err := keyset.NewHandle(nil); err == nil { 66 t.Error("keyset.NewHandle(nil) err = nil, want error") 67 } 68} 69 70func TestWriteAndReadInBinary(t *testing.T) { 71 keysetEncryptionHandle, err := keyset.NewHandle(aead.AES128GCMKeyTemplate()) 72 if err != nil { 73 t.Errorf("keyset.NewHandle(aead.AES128GCMKeyTemplate()) err = %v, want nil", err) 74 } 75 keysetEncryptionAead, err := aead.New(keysetEncryptionHandle) 76 if err != nil { 77 t.Errorf("aead.New(keysetEncryptionHandle) err = %v, want nil", err) 78 } 79 80 handle, err := keyset.NewHandle(mac.HMACSHA256Tag128KeyTemplate()) 81 if err != nil { 82 t.Fatalf("keyset.NewHandle(mac.HMACSHA256Tag128KeyTemplate()) err = %v, want nil", err) 83 } 84 85 buff := &bytes.Buffer{} 86 err = handle.Write(keyset.NewBinaryWriter(buff), keysetEncryptionAead) 87 if err != nil { 88 t.Fatalf("handle.Write(keyset.NewBinaryWriter(buff), keysetEncryptionAead) err = %v, want nil", err) 89 } 90 encrypted := buff.Bytes() 91 92 gotHandle, err := keyset.Read(keyset.NewBinaryReader(bytes.NewBuffer(encrypted)), keysetEncryptionAead) 93 if err != nil { 94 t.Fatalf("keyset.Read() err = %v, want nil", err) 95 } 96 97 if !proto.Equal(testkeyset.KeysetMaterial(gotHandle), testkeyset.KeysetMaterial(handle)) { 98 t.Fatalf("keyset.Read() = %v, want %v", gotHandle, handle) 99 } 100} 101 102func TestWriteAndReadInJSON(t *testing.T) { 103 keysetEncryptionHandle, err := keyset.NewHandle(aead.AES128GCMKeyTemplate()) 104 if err != nil { 105 t.Errorf("keyset.NewHandle(aead.AES128GCMKeyTemplate()) err = %v, want nil", err) 106 } 107 keysetEncryptionAead, err := aead.New(keysetEncryptionHandle) 108 if err != nil { 109 t.Errorf("aead.New(keysetEncryptionHandle) err = %v, want nil", err) 110 } 111 112 handle, err := keyset.NewHandle(mac.HMACSHA256Tag128KeyTemplate()) 113 if err != nil { 114 t.Fatalf("keyset.NewHandle(mac.HMACSHA256Tag128KeyTemplate()) err = %v, want nil", err) 115 } 116 117 buff := &bytes.Buffer{} 118 err = handle.Write(keyset.NewJSONWriter(buff), keysetEncryptionAead) 119 if err != nil { 120 t.Fatalf("h.Write(keyset.NewJSONWriter(buff), keysetEncryptionAead) err = %v, want nil", err) 121 } 122 encrypted := buff.Bytes() 123 124 gotHandle, err := keyset.Read(keyset.NewJSONReader(bytes.NewBuffer(encrypted)), keysetEncryptionAead) 125 if err != nil { 126 t.Fatalf("keyset.Read() err = %v, want nil", err) 127 } 128 129 if !proto.Equal(testkeyset.KeysetMaterial(gotHandle), testkeyset.KeysetMaterial(handle)) { 130 t.Fatalf("keyset.Read() = %v, want %v", gotHandle, handle) 131 } 132} 133 134func TestWriteAndReadWithAssociatedData(t *testing.T) { 135 keysetEncryptionHandle, err := keyset.NewHandle(aead.AES128GCMKeyTemplate()) 136 if err != nil { 137 t.Errorf("keyset.NewHandle(aead.AES128GCMKeyTemplate()) err = %v, want nil", err) 138 } 139 keysetEncryptionAead, err := aead.New(keysetEncryptionHandle) 140 if err != nil { 141 t.Errorf("aead.New(keysetEncryptionHandle) err = %v, want nil", err) 142 } 143 144 handle, err := keyset.NewHandle(mac.HMACSHA256Tag128KeyTemplate()) 145 if err != nil { 146 t.Fatalf("keyset.NewHandle(mac.HMACSHA256Tag128KeyTemplate()) err = %v, want nil", err) 147 } 148 associatedData := []byte{0x01, 0x02} 149 150 buff := &bytes.Buffer{} 151 err = handle.WriteWithAssociatedData(keyset.NewBinaryWriter(buff), keysetEncryptionAead, associatedData) 152 if err != nil { 153 t.Fatalf("handle.WriteWithAssociatedData() err = %v, want nil", err) 154 } 155 encrypted := buff.Bytes() 156 157 handle2, err := keyset.ReadWithAssociatedData(keyset.NewBinaryReader(bytes.NewBuffer(encrypted)), keysetEncryptionAead, associatedData) 158 if err != nil { 159 t.Fatalf("keyset.ReadWithAssociatedData() err = %v, want nil", err) 160 } 161 162 if !proto.Equal(testkeyset.KeysetMaterial(handle), testkeyset.KeysetMaterial(handle2)) { 163 t.Errorf("keyset.ReadWithAssociatedData() = %v, want %v", handle2, handle) 164 } 165} 166 167func TestReadWithMismatchedAssociatedData(t *testing.T) { 168 keysetEncryptionHandle, err := keyset.NewHandle(aead.AES128GCMKeyTemplate()) 169 if err != nil { 170 t.Errorf("keyset.NewHandle(aead.AES128GCMKeyTemplate()) err = %v, want nil", err) 171 } 172 keysetEncryptionAead, err := aead.New(keysetEncryptionHandle) 173 if err != nil { 174 t.Errorf("aead.New(keysetEncryptionHandle) err = %v, want nil", err) 175 } 176 177 handle, err := keyset.NewHandle(mac.HMACSHA256Tag128KeyTemplate()) 178 if err != nil { 179 t.Fatalf("keyset.NewHandle(mac.HMACSHA256Tag128KeyTemplate()) err = %v, want nil", err) 180 } 181 associatedData := []byte{0x01, 0x02} 182 183 buff := &bytes.Buffer{} 184 err = handle.WriteWithAssociatedData(keyset.NewBinaryWriter(buff), keysetEncryptionAead, associatedData) 185 if err != nil { 186 t.Fatalf("handle.WriteWithAssociatedData() err = %v, want nil", err) 187 } 188 encrypted := buff.Bytes() 189 190 invalidAssociatedData := []byte{0x01, 0x03} 191 _, err = keyset.ReadWithAssociatedData(keyset.NewBinaryReader(bytes.NewBuffer(encrypted)), keysetEncryptionAead, invalidAssociatedData) 192 if err == nil { 193 t.Errorf("keyset.ReadWithAssociatedData() err = nil, want err") 194 } 195} 196 197func TestWriteAndReadWithNoSecrets(t *testing.T) { 198 // Create a keyset that contains a public key. 199 privateHandle, err := keyset.NewHandle(signature.ECDSAP256KeyTemplate()) 200 if err != nil { 201 t.Fatalf("keyset.NewHandle(signature.ECDSAP256KeyTemplate()) err = %v, want nil", err) 202 } 203 handle, err := privateHandle.Public() 204 if err != nil { 205 t.Fatalf("privateHandle.Public() err = %v, want nil", err) 206 } 207 208 buff := &bytes.Buffer{} 209 err = handle.WriteWithNoSecrets(keyset.NewBinaryWriter(buff)) 210 if err != nil { 211 t.Fatalf("handle.WriteWithAssociatedData(keyset.NewBinaryWriter(buff), masterKey, associatedData) err = %v, want nil", err) 212 } 213 serialized := buff.Bytes() 214 215 handle2, err := keyset.ReadWithNoSecrets(keyset.NewBinaryReader(bytes.NewBuffer(serialized))) 216 if err != nil { 217 t.Fatalf("keyset.ReadWithNoSecrets() err = %v, want nil", err) 218 } 219 220 if !proto.Equal(testkeyset.KeysetMaterial(handle), testkeyset.KeysetMaterial(handle2)) { 221 t.Fatalf("keyset.ReadWithNoSecrets() = %v, want %v", handle2, handle) 222 } 223} 224 225func TestWriteWithNoSecretsFailsWithSymmetricSecretKey(t *testing.T) { 226 // Create a keyset that contains a symmetric secret key. 227 handle, err := keyset.NewHandle(mac.HMACSHA256Tag128KeyTemplate()) 228 if err != nil { 229 t.Fatalf("keyset.NewHandle(aead.AES256GCMKeyTemplate()) err = %v, want nil", err) 230 } 231 232 buff := &bytes.Buffer{} 233 err = handle.WriteWithNoSecrets(keyset.NewBinaryWriter(buff)) 234 if err == nil { 235 t.Error("handle.WriteWithNoSecrets() = nil, want error") 236 } 237} 238 239func TestReadWithNoSecretsFailsWithSymmetricSecretKey(t *testing.T) { 240 // Create a keyset that contains a symmetric secret key. 241 handle, err := keyset.NewHandle(mac.HMACSHA256Tag128KeyTemplate()) 242 if err != nil { 243 t.Fatalf("keyset.NewHandle(aead.AES256GCMKeyTemplate()) err = %v, want nil", err) 244 } 245 buff := &bytes.Buffer{} 246 err = testkeyset.Write(handle, keyset.NewBinaryWriter(buff)) 247 if err != nil { 248 t.Fatalf("insecurecleartextkeyset.Write(handle, keyset.NewBinaryWriter(buff)) err = %v, want nil", err) 249 } 250 serialized := buff.Bytes() 251 252 _, err = keyset.ReadWithNoSecrets(keyset.NewBinaryReader(bytes.NewBuffer(serialized))) 253 if err == nil { 254 t.Error("keyset.ReadWithNoSecrets() = nil, want error") 255 } 256} 257 258func TestWriteWithNoSecretsFailsWithPrivateKey(t *testing.T) { 259 // Create a keyset that contains a private key. 260 handle, err := keyset.NewHandle(signature.ECDSAP256KeyTemplate()) 261 if err != nil { 262 t.Fatalf("keyset.NewHandle(signature.ECDSAP256KeyTemplate()) err = %v, want nil", err) 263 } 264 265 buff := &bytes.Buffer{} 266 if err := handle.WriteWithNoSecrets(keyset.NewBinaryWriter(buff)); err == nil { 267 t.Error("handle.WriteWithNoSecrets() = nil, want error") 268 } 269} 270 271func TestReadWithNoSecretsFailsWithPrivateKey(t *testing.T) { 272 // Create a keyset that contains a private key. 273 handle, err := keyset.NewHandle(signature.ECDSAP256KeyTemplate()) 274 if err != nil { 275 t.Fatalf("keyset.NewHandle(signature.ECDSAP256KeyTemplate()) err = %v, want nil", err) 276 } 277 buff := &bytes.Buffer{} 278 err = testkeyset.Write(handle, keyset.NewBinaryWriter(buff)) 279 if err != nil { 280 t.Fatalf("insecurecleartextkeyset.Write(handle, keyset.NewBinaryWriter(buff)) err = %v, want nil", err) 281 } 282 serialized := buff.Bytes() 283 284 _, err = keyset.ReadWithNoSecrets(keyset.NewBinaryReader(bytes.NewBuffer(serialized))) 285 if err == nil { 286 t.Error("keyset.ReadWithNoSecrets() = nil, want error") 287 } 288} 289 290func TestWriteAndReadWithNoSecretsFailsWithUnknownKeyMaterial(t *testing.T) { 291 // Create a keyset that contains unknown key material. 292 keyData := testutil.NewKeyData("some type url", []byte{0}, tinkpb.KeyData_UNKNOWN_KEYMATERIAL) 293 key := testutil.NewKey(keyData, tinkpb.KeyStatusType_ENABLED, 1, tinkpb.OutputPrefixType_TINK) 294 ks := testutil.NewKeyset(1, []*tinkpb.Keyset_Key{key}) 295 handle, err := testkeyset.NewHandle(ks) 296 if err != nil { 297 t.Fatal(err) 298 } 299 serialized, err := proto.Marshal(ks) 300 if err != nil { 301 t.Fatal(err) 302 } 303 304 buff := &bytes.Buffer{} 305 err = handle.WriteWithNoSecrets(keyset.NewBinaryWriter(buff)) 306 if err == nil { 307 t.Error("handle.WriteWithNoSecrets() = nil, want error") 308 } 309 310 _, err = keyset.ReadWithNoSecrets(keyset.NewBinaryReader(bytes.NewBuffer(serialized))) 311 if err == nil { 312 t.Error("handle.ReadWithNoSecrets() = nil, want error") 313 } 314} 315 316func TestKeysetInfo(t *testing.T) { 317 kt := mac.HMACSHA256Tag128KeyTemplate() 318 kh, err := keyset.NewHandle(kt) 319 if err != nil { 320 t.Errorf("unexpected error: %s", err) 321 } 322 info := kh.KeysetInfo() 323 if info.PrimaryKeyId != info.KeyInfo[0].KeyId { 324 t.Errorf("Expected primary key id: %d, but got: %d", info.KeyInfo[0].KeyId, info.PrimaryKeyId) 325 } 326} 327