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 daead_test 18 19import ( 20 "bytes" 21 "fmt" 22 "strings" 23 "testing" 24 25 "github.com/google/go-cmp/cmp" 26 "github.com/google/go-cmp/cmp/cmpopts" 27 "github.com/google/tink/go/core/cryptofmt" 28 "github.com/google/tink/go/core/registry" 29 "github.com/google/tink/go/daead" 30 "github.com/google/tink/go/insecurecleartextkeyset" 31 "github.com/google/tink/go/internal/internalregistry" 32 "github.com/google/tink/go/internal/testing/stubkeymanager" 33 "github.com/google/tink/go/keyset" 34 "github.com/google/tink/go/monitoring" 35 "github.com/google/tink/go/signature" 36 "github.com/google/tink/go/subtle/random" 37 "github.com/google/tink/go/testing/fakemonitoring" 38 "github.com/google/tink/go/testkeyset" 39 "github.com/google/tink/go/testutil" 40 "github.com/google/tink/go/tink" 41 42 tinkpb "github.com/google/tink/go/proto/tink_go_proto" 43) 44 45func TestFactoryMultipleKeys(t *testing.T) { 46 // encrypt with non-raw key. 47 keyset := testutil.NewTestAESSIVKeyset(tinkpb.OutputPrefixType_TINK) 48 primaryKey := keyset.Key[0] 49 if primaryKey.OutputPrefixType == tinkpb.OutputPrefixType_RAW { 50 t.Errorf("expect a non-raw key") 51 } 52 keysetHandle, _ := testkeyset.NewHandle(keyset) 53 d, err := daead.New(keysetHandle) 54 if err != nil { 55 t.Errorf("daead.New failed: %s", err) 56 } 57 expectedPrefix, _ := cryptofmt.OutputPrefix(primaryKey) 58 if err := validateDAEADFactoryCipher(d, d, expectedPrefix); err != nil { 59 t.Errorf("invalid cipher: %s", err) 60 } 61 62 // encrypt with a non-primary RAW key in keyset and decrypt with the keyset. 63 { 64 rawKey := keyset.Key[1] 65 if rawKey.OutputPrefixType != tinkpb.OutputPrefixType_RAW { 66 t.Errorf("expect a raw key") 67 } 68 keyset2 := testutil.NewKeyset(rawKey.KeyId, []*tinkpb.Keyset_Key{rawKey}) 69 keysetHandle2, _ := testkeyset.NewHandle(keyset2) 70 d2, err := daead.New(keysetHandle2) 71 if err != nil { 72 t.Errorf("daead.New failed: %s", err) 73 } 74 if err := validateDAEADFactoryCipher(d2, d, cryptofmt.RawPrefix); err != nil { 75 t.Errorf("invalid cipher: %s", err) 76 } 77 } 78 79 // encrypt with a random key from a new keyset, decrypt with the original keyset should fail. 80 { 81 keyset2 := testutil.NewTestAESSIVKeyset(tinkpb.OutputPrefixType_TINK) 82 newPK := keyset2.Key[0] 83 if newPK.OutputPrefixType == tinkpb.OutputPrefixType_RAW { 84 t.Errorf("expect a non-raw key") 85 } 86 keysetHandle2, _ := testkeyset.NewHandle(keyset2) 87 d2, err := daead.New(keysetHandle2) 88 if err != nil { 89 t.Errorf("daead.New failed: %s", err) 90 } 91 expectedPrefix, _ = cryptofmt.OutputPrefix(newPK) 92 err = validateDAEADFactoryCipher(d2, d, expectedPrefix) 93 if err == nil || !strings.Contains(err.Error(), "decryption failed") { 94 t.Errorf("expect decryption to fail with random key: %s", err) 95 } 96 } 97} 98 99func TestFactoryRawKeyAsPrimary(t *testing.T) { 100 keyset := testutil.NewTestAESSIVKeyset(tinkpb.OutputPrefixType_RAW) 101 if keyset.Key[0].OutputPrefixType != tinkpb.OutputPrefixType_RAW { 102 t.Errorf("primary key is not a raw key") 103 } 104 keysetHandle, _ := testkeyset.NewHandle(keyset) 105 106 d, err := daead.New(keysetHandle) 107 if err != nil { 108 t.Errorf("cannot get primitive from keyset handle: %s", err) 109 } 110 if err := validateDAEADFactoryCipher(d, d, cryptofmt.RawPrefix); err != nil { 111 t.Errorf("invalid cipher: %s", err) 112 } 113} 114 115func validateDAEADFactoryCipher(encryptCipher, decryptCipher tink.DeterministicAEAD, expectedPrefix string) error { 116 prefixSize := len(expectedPrefix) 117 // regular plaintext. 118 pt := random.GetRandomBytes(20) 119 aad := random.GetRandomBytes(20) 120 ct, err := encryptCipher.EncryptDeterministically(pt, aad) 121 if err != nil { 122 return fmt.Errorf("encryption failed with regular plaintext: %s", err) 123 } 124 decrypted, err := decryptCipher.DecryptDeterministically(ct, aad) 125 if err != nil || !bytes.Equal(decrypted, pt) { 126 return fmt.Errorf("decryption failed with regular plaintext: err: %s, pt: %s, decrypted: %s", err, pt, decrypted) 127 } 128 if string(ct[:prefixSize]) != expectedPrefix { 129 return fmt.Errorf("incorrect prefix with regular plaintext") 130 } 131 132 // short plaintext. 133 pt = random.GetRandomBytes(1) 134 ct, err = encryptCipher.EncryptDeterministically(pt, aad) 135 if err != nil { 136 return fmt.Errorf("encryption failed with short plaintext: %s", err) 137 } 138 decrypted, err = decryptCipher.DecryptDeterministically(ct, aad) 139 if err != nil || !bytes.Equal(decrypted, pt) { 140 return fmt.Errorf("decryption failed with short plaintext: err: %s, pt: %s, decrypted: %s", 141 err, pt, decrypted) 142 } 143 if string(ct[:prefixSize]) != expectedPrefix { 144 return fmt.Errorf("incorrect prefix with short plaintext") 145 } 146 return nil 147} 148 149func TestFactoryWithInvalidPrimitiveSetType(t *testing.T) { 150 wrongKH, err := keyset.NewHandle(signature.ECDSAP256KeyTemplate()) 151 if err != nil { 152 t.Fatalf("failed to build *keyset.Handle: %s", err) 153 } 154 155 _, err = daead.New(wrongKH) 156 if err == nil { 157 t.Fatal("calling New() with wrong *keyset.Handle should fail") 158 } 159} 160 161func TestFactoryWithValidPrimitiveSetType(t *testing.T) { 162 goodKH, err := keyset.NewHandle(daead.AESSIVKeyTemplate()) 163 if err != nil { 164 t.Fatalf("failed to build *keyset.Handle: %s", err) 165 } 166 167 _, err = daead.New(goodKH) 168 if err != nil { 169 t.Fatalf("calling New() with good *keyset.Handle failed: %s", err) 170 } 171} 172 173func TestPrimitiveFactoryWithMonitoringAnnotationsLogsEncryptionDecryptionWithPrefix(t *testing.T) { 174 defer internalregistry.ClearMonitoringClient() 175 client := fakemonitoring.NewClient("fake-client") 176 if err := internalregistry.RegisterMonitoringClient(client); err != nil { 177 t.Fatalf("internalregistry.RegisterMonitoringClient() err = %v, want nil", err) 178 } 179 kh, err := keyset.NewHandle(daead.AESSIVKeyTemplate()) 180 if err != nil { 181 t.Fatalf("keyset.NewHandle() err = %v, want nil", err) 182 } 183 // Annotations are only supported throught the `insecurecleartextkeyset` API. 184 buff := &bytes.Buffer{} 185 if err := insecurecleartextkeyset.Write(kh, keyset.NewBinaryWriter(buff)); err != nil { 186 t.Fatalf("insecurecleartextkeyset.Write() err = %v, want nil", err) 187 } 188 annotations := map[string]string{"foo": "bar"} 189 mh, err := insecurecleartextkeyset.Read(keyset.NewBinaryReader(buff), keyset.WithAnnotations(annotations)) 190 if err != nil { 191 t.Fatalf("insecurecleartextkeyset.Read() err = %v, want nil", err) 192 } 193 p, err := daead.New(mh) 194 if err != nil { 195 t.Fatalf("daead.New() err = %v, want nil", err) 196 } 197 pt := []byte("HELLO_WORLD") 198 ct, err := p.EncryptDeterministically(pt, nil) 199 if err != nil { 200 t.Fatalf("p.EncryptDeterministically() err = %v, want nil", err) 201 } 202 if _, err := p.DecryptDeterministically(ct, nil); err != nil { 203 t.Fatalf("p.DecryptDeterministically() err = %v, want nil", err) 204 } 205 got := client.Events() 206 wantKeysetInfo := monitoring.NewKeysetInfo( 207 annotations, 208 kh.KeysetInfo().GetPrimaryKeyId(), 209 []*monitoring.Entry{ 210 { 211 Status: monitoring.Enabled, 212 KeyID: kh.KeysetInfo().GetPrimaryKeyId(), 213 KeyType: "tink.AesSivKey", 214 KeyPrefix: "TINK", 215 }, 216 }, 217 ) 218 want := []*fakemonitoring.LogEvent{ 219 { 220 KeyID: mh.KeysetInfo().GetPrimaryKeyId(), 221 NumBytes: len(pt), 222 Context: monitoring.NewContext("daead", "encrypt", wantKeysetInfo), 223 }, 224 { 225 KeyID: mh.KeysetInfo().GetPrimaryKeyId(), 226 // Ciphertext was encrypted with a key that has a TINK output prefix. This adds a 5-byte prefix 227 // to the ciphertext. This prefix is not included in `Log` call. 228 NumBytes: len(ct) - cryptofmt.NonRawPrefixSize, 229 Context: monitoring.NewContext("daead", "decrypt", wantKeysetInfo), 230 }, 231 } 232 if !cmp.Equal(got, want) { 233 t.Errorf("got = %v, want = %v, with diff: %v", got, want, cmp.Diff(got, want)) 234 } 235} 236 237func TestPrimitiveFactoryWithMonitoringAnnotationsLogsEncryptionDecryptionWithoutPrefix(t *testing.T) { 238 defer internalregistry.ClearMonitoringClient() 239 client := fakemonitoring.NewClient("fake-client") 240 if err := internalregistry.RegisterMonitoringClient(client); err != nil { 241 t.Fatalf("internalregistry.RegisterMonitoringClient() err = %v, want nil", err) 242 } 243 template := daead.AESSIVKeyTemplate() 244 // There's currently not a raw template in the public API, but 245 // we add a test by customizing the output prefix of an existing one. 246 template.OutputPrefixType = tinkpb.OutputPrefixType_RAW 247 kh, err := keyset.NewHandle(template) 248 if err != nil { 249 t.Fatalf("keyset.NewHandle() err = %v, want nil", err) 250 } 251 // Annotations are only supported throught the `insecurecleartextkeyset` API. 252 buff := &bytes.Buffer{} 253 if err := insecurecleartextkeyset.Write(kh, keyset.NewBinaryWriter(buff)); err != nil { 254 t.Fatalf("insecurecleartextkeyset.Write() err = %v, want nil", err) 255 } 256 annotations := map[string]string{"foo": "bar"} 257 mh, err := insecurecleartextkeyset.Read(keyset.NewBinaryReader(buff), keyset.WithAnnotations(annotations)) 258 if err != nil { 259 t.Fatalf("insecurecleartextkeyset.Read() err = %v, want nil", err) 260 } 261 p, err := daead.New(mh) 262 if err != nil { 263 t.Fatalf("daead.New() err = %v, want nil", err) 264 } 265 data := []byte("hello_world") 266 aad := []byte("_!") 267 ct, err := p.EncryptDeterministically(data, aad) 268 if err != nil { 269 t.Fatalf("p.EncryptDeterministically() err = %v, want nil", err) 270 } 271 if _, err := p.DecryptDeterministically(ct, aad); err != nil { 272 t.Fatalf("p.DecryptDeterministically() err = %v, want nil", err) 273 } 274 got := client.Events() 275 wantKeysetInfo := monitoring.NewKeysetInfo( 276 annotations, 277 kh.KeysetInfo().GetPrimaryKeyId(), 278 []*monitoring.Entry{ 279 { 280 Status: monitoring.Enabled, 281 KeyID: kh.KeysetInfo().GetPrimaryKeyId(), 282 KeyType: "tink.AesSivKey", 283 KeyPrefix: "RAW", 284 }, 285 }, 286 ) 287 want := []*fakemonitoring.LogEvent{ 288 { 289 Context: monitoring.NewContext("daead", "encrypt", wantKeysetInfo), 290 KeyID: wantKeysetInfo.PrimaryKeyID, 291 NumBytes: len(data), 292 }, 293 { 294 Context: monitoring.NewContext("daead", "decrypt", wantKeysetInfo), 295 KeyID: wantKeysetInfo.PrimaryKeyID, 296 NumBytes: len(ct), 297 }, 298 } 299 if !cmp.Equal(got, want) { 300 t.Errorf("got = %v, want = %v, with diff: %v", got, want, cmp.Diff(got, want)) 301 } 302} 303 304func TestFactoryWithMonitoringPrimitiveWithMultipleKeysLogsEncryptionDecryption(t *testing.T) { 305 defer internalregistry.ClearMonitoringClient() 306 client := fakemonitoring.NewClient("fake-client") 307 if err := internalregistry.RegisterMonitoringClient(client); err != nil { 308 t.Fatalf("internalregistry.RegisterMonitoringClient() err = %v, want nil", err) 309 } 310 manager := keyset.NewManager() 311 numKeys := 4 312 keyIDs := make([]uint32, numKeys, numKeys) 313 var err error 314 for i := 0; i < numKeys; i++ { 315 keyIDs[i], err = manager.Add(daead.AESSIVKeyTemplate()) 316 if err != nil { 317 t.Fatalf("manager.Add() err = %v, want nil", err) 318 } 319 } 320 if err := manager.SetPrimary(keyIDs[1]); err != nil { 321 t.Fatalf("manager.SetPrimary(%d) err = %v, want nil", keyIDs[1], err) 322 } 323 if err := manager.Disable(keyIDs[0]); err != nil { 324 t.Fatalf("manager.Disable(%d) err = %v, want nil", keyIDs[0], err) 325 } 326 kh, err := manager.Handle() 327 if err != nil { 328 t.Fatalf("manager.Handle() err = %v, want nil", err) 329 } 330 // Annotations are only supported throught the `insecurecleartextkeyset` API. 331 buff := &bytes.Buffer{} 332 if err := insecurecleartextkeyset.Write(kh, keyset.NewBinaryWriter(buff)); err != nil { 333 t.Fatalf("insecurecleartextkeyset.Write() err = %v, want nil", err) 334 } 335 annotations := map[string]string{"foo": "bar"} 336 mh, err := insecurecleartextkeyset.Read(keyset.NewBinaryReader(buff), keyset.WithAnnotations(annotations)) 337 if err != nil { 338 t.Fatalf("insecurecleartextkeyset.Read() err = %v, want nil", err) 339 } 340 p, err := daead.New(mh) 341 if err != nil { 342 t.Fatalf("daead.New() err = %v, want nil", err) 343 } 344 data := []byte("YELLOW_ORANGE") 345 ct, err := p.EncryptDeterministically(data, nil) 346 if err != nil { 347 t.Fatalf("p.EncryptDeterministically() err = %v, want nil", err) 348 } 349 if _, err := p.DecryptDeterministically(ct, nil); err != nil { 350 t.Fatalf("p.DecryptDeterministically() err = %v, want nil", err) 351 } 352 failures := len(client.Failures()) 353 if failures != 0 { 354 t.Errorf("len(client.Failures()) = %d, want 0", failures) 355 } 356 got := client.Events() 357 wantKeysetInfo := monitoring.NewKeysetInfo(annotations, kh.KeysetInfo().GetPrimaryKeyId(), []*monitoring.Entry{ 358 { 359 KeyID: kh.KeysetInfo().GetPrimaryKeyId(), 360 Status: monitoring.Enabled, 361 KeyType: "tink.AesSivKey", 362 KeyPrefix: "TINK", 363 }, 364 { 365 KeyID: keyIDs[2], 366 Status: monitoring.Enabled, 367 KeyType: "tink.AesSivKey", 368 KeyPrefix: "TINK", 369 }, 370 { 371 KeyID: keyIDs[3], 372 Status: monitoring.Enabled, 373 KeyType: "tink.AesSivKey", 374 KeyPrefix: "TINK", 375 }, 376 }) 377 want := []*fakemonitoring.LogEvent{ 378 { 379 KeyID: kh.KeysetInfo().GetPrimaryKeyId(), 380 NumBytes: len(data), 381 Context: monitoring.NewContext( 382 "daead", 383 "encrypt", 384 wantKeysetInfo, 385 ), 386 }, 387 { 388 KeyID: kh.KeysetInfo().GetPrimaryKeyId(), 389 NumBytes: len(ct) - cryptofmt.NonRawPrefixSize, 390 Context: monitoring.NewContext( 391 "daead", 392 "decrypt", 393 wantKeysetInfo, 394 ), 395 }, 396 } 397 // sort by keyID to avoid non deterministic order. 398 entryLessFunc := func(a, b *monitoring.Entry) bool { 399 return a.KeyID < b.KeyID 400 } 401 if !cmp.Equal(got, want, cmpopts.SortSlices(entryLessFunc)) { 402 t.Errorf("got = %v, want = %v, with diff: %v", got, want, cmp.Diff(got, want)) 403 } 404} 405 406func TestPrimitiveFactoryWithMonitoringAnnotationsEncryptionFailureIsLogged(t *testing.T) { 407 defer internalregistry.ClearMonitoringClient() 408 client := &fakemonitoring.Client{Name: ""} 409 if err := internalregistry.RegisterMonitoringClient(client); err != nil { 410 t.Fatalf("internalregistry.RegisterMonitoringClient() err = %v, want nil", err) 411 } 412 typeURL := "TestFactoryWithMonitoringPrimitiveEncryptionFailureIsLogged" 413 km := &stubkeymanager.StubKeyManager{ 414 URL: typeURL, 415 Prim: &testutil.AlwaysFailingDeterministicAead{Error: fmt.Errorf("failed")}, 416 KeyData: &tinkpb.KeyData{ 417 TypeUrl: typeURL, 418 Value: []byte("serialized_key"), 419 KeyMaterialType: tinkpb.KeyData_SYMMETRIC, 420 }, 421 } 422 if err := registry.RegisterKeyManager(km); err != nil { 423 t.Fatalf("registry.RegisterKeyManager() err = %v, want nil", err) 424 } 425 template := &tinkpb.KeyTemplate{ 426 TypeUrl: typeURL, 427 OutputPrefixType: tinkpb.OutputPrefixType_LEGACY, 428 } 429 kh, err := keyset.NewHandle(template) 430 if err != nil { 431 t.Fatalf("keyset.NewHandle() err = %v, want nil", err) 432 } 433 // Annotations are only supported throught the `insecurecleartextkeyset` API. 434 buff := &bytes.Buffer{} 435 if err := insecurecleartextkeyset.Write(kh, keyset.NewBinaryWriter(buff)); err != nil { 436 t.Fatalf("insecurecleartextkeyset.Write() err = %v, want nil", err) 437 } 438 annotations := map[string]string{"foo": "bar"} 439 mh, err := insecurecleartextkeyset.Read(keyset.NewBinaryReader(buff), keyset.WithAnnotations(annotations)) 440 if err != nil { 441 t.Fatalf("insecurecleartextkeyset.Read() err = %v, want nil", err) 442 } 443 p, err := daead.New(mh) 444 if err != nil { 445 t.Fatalf("daead.New() err = %v, want nil", err) 446 } 447 if _, err := p.EncryptDeterministically(nil, nil); err == nil { 448 t.Fatalf("EncryptDeterministically() err = nil, want error") 449 } 450 got := client.Failures() 451 want := []*fakemonitoring.LogFailure{ 452 { 453 Context: monitoring.NewContext( 454 "daead", 455 "encrypt", 456 monitoring.NewKeysetInfo( 457 annotations, 458 kh.KeysetInfo().GetPrimaryKeyId(), 459 []*monitoring.Entry{ 460 { 461 KeyID: kh.KeysetInfo().GetPrimaryKeyId(), 462 Status: monitoring.Enabled, 463 KeyType: typeURL, 464 KeyPrefix: "LEGACY", 465 }, 466 }, 467 ), 468 ), 469 }, 470 } 471 if !cmp.Equal(got, want) { 472 t.Errorf("got = %v, want = %v, with diff: %v", got, want, cmp.Diff(got, want)) 473 } 474} 475 476func TestPrimitiveFactoryWithMonitoringAnnotationsDecryptionFailureIsLogged(t *testing.T) { 477 defer internalregistry.ClearMonitoringClient() 478 client := &fakemonitoring.Client{Name: ""} 479 if err := internalregistry.RegisterMonitoringClient(client); err != nil { 480 t.Fatalf("internalregistry.RegisterMonitoringClient() err = %v, want nil", err) 481 } 482 kh, err := keyset.NewHandle(daead.AESSIVKeyTemplate()) 483 if err != nil { 484 t.Fatalf("keyset.NewHandle() err = %v, want nil", err) 485 } 486 // Annotations are only supported throught the `insecurecleartextkeyset` API. 487 buff := &bytes.Buffer{} 488 if err := insecurecleartextkeyset.Write(kh, keyset.NewBinaryWriter(buff)); err != nil { 489 t.Fatalf("insecurecleartextkeyset.Write() err = %v, want nil", err) 490 } 491 annotations := map[string]string{"foo": "bar"} 492 mh, err := insecurecleartextkeyset.Read(keyset.NewBinaryReader(buff), keyset.WithAnnotations(annotations)) 493 if err != nil { 494 t.Fatalf("insecurecleartextkeyset.Read() err = %v, want nil", err) 495 } 496 p, err := daead.New(mh) 497 if err != nil { 498 t.Fatalf("daead.New() err = %v, want nil", err) 499 } 500 if _, err := p.DecryptDeterministically([]byte("invalid_data"), nil); err == nil { 501 t.Fatalf("DecryptDeterministically() err = nil, want error") 502 } 503 got := client.Failures() 504 want := []*fakemonitoring.LogFailure{ 505 { 506 Context: monitoring.NewContext( 507 "daead", 508 "decrypt", 509 monitoring.NewKeysetInfo( 510 annotations, 511 kh.KeysetInfo().GetPrimaryKeyId(), 512 []*monitoring.Entry{ 513 { 514 KeyID: kh.KeysetInfo().GetPrimaryKeyId(), 515 Status: monitoring.Enabled, 516 KeyType: "tink.AesSivKey", 517 KeyPrefix: "TINK", 518 }, 519 }, 520 ), 521 ), 522 }, 523 } 524 if !cmp.Equal(got, want) { 525 t.Errorf("got = %v, want = %v, with diff: %v", got, want, cmp.Diff(got, want)) 526 } 527} 528 529func TestFactoryWithMonitoringMultiplePrimitivesLogOperations(t *testing.T) { 530 defer internalregistry.ClearMonitoringClient() 531 client := &fakemonitoring.Client{Name: ""} 532 if err := internalregistry.RegisterMonitoringClient(client); err != nil { 533 t.Fatalf("internalregistry.RegisterMonitoringClient() err = %v, want nil", err) 534 } 535 kh1, err := keyset.NewHandle(daead.AESSIVKeyTemplate()) 536 if err != nil { 537 t.Fatalf("keyset.NewHandle() err = %v, want nil", err) 538 } 539 // Annotations are only supported throught the `insecurecleartextkeyset` API. 540 buff := &bytes.Buffer{} 541 if err := insecurecleartextkeyset.Write(kh1, keyset.NewBinaryWriter(buff)); err != nil { 542 t.Fatalf("insecurecleartextkeyset.Write() err = %v, want nil", err) 543 } 544 annotations := map[string]string{"foo": "bar"} 545 mh1, err := insecurecleartextkeyset.Read(keyset.NewBinaryReader(buff), keyset.WithAnnotations(annotations)) 546 if err != nil { 547 t.Fatalf("insecurecleartextkeyset.Read() err = %v, want nil", err) 548 } 549 p1, err := daead.New(mh1) 550 if err != nil { 551 t.Fatalf("daead.New() err = %v, want nil", err) 552 } 553 kh2, err := keyset.NewHandle(daead.AESSIVKeyTemplate()) 554 if err != nil { 555 t.Fatalf("keyset.NewHandle() err = %v, want nil", err) 556 } 557 buff.Reset() 558 if err := insecurecleartextkeyset.Write(kh2, keyset.NewBinaryWriter(buff)); err != nil { 559 t.Fatalf("insecurecleartextkeyset.Write() err = %v, want nil", err) 560 } 561 mh2, err := insecurecleartextkeyset.Read(keyset.NewBinaryReader(buff), keyset.WithAnnotations(annotations)) 562 if err != nil { 563 t.Fatalf("insecurecleartextkeyset.Read() err = %v, want nil", err) 564 } 565 p2, err := daead.New(mh2) 566 if err != nil { 567 t.Fatalf("daead.New() err = %v, want nil", err) 568 } 569 d1 := []byte("YELLOW_ORANGE") 570 if _, err := p1.EncryptDeterministically(d1, nil); err != nil { 571 t.Fatalf("p1.EncryptDeterministically() err = %v, want nil", err) 572 } 573 d2 := []byte("ORANGE_BLUE") 574 if _, err := p2.EncryptDeterministically(d2, nil); err != nil { 575 t.Fatalf("p2.EncryptDeterministically() err = %v, want nil", err) 576 } 577 got := client.Events() 578 want := []*fakemonitoring.LogEvent{ 579 { 580 KeyID: kh1.KeysetInfo().GetPrimaryKeyId(), 581 NumBytes: len(d1), 582 Context: monitoring.NewContext( 583 "daead", 584 "encrypt", 585 monitoring.NewKeysetInfo( 586 annotations, 587 kh1.KeysetInfo().GetPrimaryKeyId(), 588 []*monitoring.Entry{ 589 { 590 KeyID: kh1.KeysetInfo().GetPrimaryKeyId(), 591 Status: monitoring.Enabled, 592 KeyType: "tink.AesSivKey", 593 KeyPrefix: "TINK", 594 }, 595 }, 596 ), 597 ), 598 }, 599 { 600 KeyID: kh2.KeysetInfo().GetPrimaryKeyId(), 601 NumBytes: len(d2), 602 Context: monitoring.NewContext( 603 "daead", 604 "encrypt", 605 monitoring.NewKeysetInfo( 606 annotations, 607 kh2.KeysetInfo().GetPrimaryKeyId(), 608 []*monitoring.Entry{ 609 { 610 KeyID: kh2.KeysetInfo().GetPrimaryKeyId(), 611 Status: monitoring.Enabled, 612 KeyType: "tink.AesSivKey", 613 KeyPrefix: "TINK", 614 }, 615 }, 616 ), 617 ), 618 }, 619 } 620 if !cmp.Equal(got, want) { 621 t.Errorf("got = %v, want = %v, with diff: %v", got, want, cmp.Diff(got, want)) 622 } 623} 624 625func TestPrimitiveFactoryEncryptDecryptWithoutAnnotationsDoesNotMonitor(t *testing.T) { 626 defer internalregistry.ClearMonitoringClient() 627 client := fakemonitoring.NewClient("fake-client") 628 if err := internalregistry.RegisterMonitoringClient(client); err != nil { 629 t.Fatalf("internalregistry.RegisterMonitoringClient() err = %v, want nil", err) 630 } 631 kh, err := keyset.NewHandle(daead.AESSIVKeyTemplate()) 632 if err != nil { 633 t.Fatalf("keyset.NewHandle() err = %v, want nil", err) 634 } 635 p, err := daead.New(kh) 636 if err != nil { 637 t.Fatalf("daead.New() err = %v, want nil", err) 638 } 639 data := []byte("hello_world") 640 ct, err := p.EncryptDeterministically(data, nil) 641 if err != nil { 642 t.Fatalf("p.EncryptDeterministically() err = %v, want nil", err) 643 } 644 if _, err := p.DecryptDeterministically(ct, nil); err != nil { 645 t.Fatalf("p.DecryptDeterministically() err = %v, want nil", err) 646 } 647 got := client.Events() 648 if len(got) != 0 { 649 t.Errorf("len(client.Events()) = %d, want 0", len(got)) 650 } 651} 652