1// Copyright 2022 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 signature_test 18 19import ( 20 "math/big" 21 "testing" 22 23 "github.com/google/go-cmp/cmp" 24 "google.golang.org/protobuf/proto" 25 "google.golang.org/protobuf/testing/protocmp" 26 "github.com/google/tink/go/core/registry" 27 "github.com/google/tink/go/subtle/random" 28 "github.com/google/tink/go/tink" 29 cpb "github.com/google/tink/go/proto/common_go_proto" 30 rsppb "github.com/google/tink/go/proto/rsa_ssa_pss_go_proto" 31 tpb "github.com/google/tink/go/proto/tink_go_proto" 32) 33 34const ( 35 rsaPSSTestPrivateKeyTypeURL = "type.googleapis.com/google.crypto.tink.RsaSsaPssPrivateKey" 36 rsaPSSTestPrivateKeyVersion = 0 37) 38 39func TestRSASSAPSSSignerKeyManagerDoesSupport(t *testing.T) { 40 skm, err := registry.GetKeyManager(rsaPSSTestPrivateKeyTypeURL) 41 if err != nil { 42 t.Fatalf("registry.GetKeyManager(%q) err = %v, want nil", err, rsaPSSTestPrivateKeyTypeURL) 43 } 44 if !skm.DoesSupport(rsaPSSTestPrivateKeyTypeURL) { 45 t.Errorf("DoesSupport(%q) err = false, want true", rsaPSSTestPrivateKeyTypeURL) 46 } 47 if skm.DoesSupport("fake.type.url") { 48 t.Errorf("DoesSupport(%q) err = true, want false", "fake.type.url") 49 } 50} 51 52func TestRSASSAPSSSignerKeyManagerTypeURL(t *testing.T) { 53 skm, err := registry.GetKeyManager(rsaPSSTestPrivateKeyTypeURL) 54 if err != nil { 55 t.Fatalf("registry.GetKeyManager(%q) err = %v, want nil", err, rsaPSSTestPrivateKeyTypeURL) 56 } 57 if skm.TypeURL() != rsaPSSTestPrivateKeyTypeURL { 58 t.Errorf("TypeURL() = %q, want %q", skm.TypeURL(), rsaPSSTestPrivateKeyTypeURL) 59 } 60} 61 62func TestRSASSAPSSSignerGetPrimitive(t *testing.T) { 63 skm, err := registry.GetKeyManager(rsaPSSTestPrivateKeyTypeURL) 64 if err != nil { 65 t.Fatalf("registry.GetKeyManager(%q) err = %v, want nil", err, rsaPSSTestPrivateKeyTypeURL) 66 } 67 privKey, err := makeValidRSAPSSKey() 68 if err != nil { 69 t.Fatalf("makeValidRSAPSSKey() err = %v, want nil", err) 70 } 71 serializedPrivate, err := proto.Marshal(privKey) 72 if err != nil { 73 t.Fatalf("proto.Marshal() err = %v, want nil", err) 74 } 75 p, err := skm.Primitive(serializedPrivate) 76 if err != nil { 77 t.Fatalf("Primitive() err = %v, want nil", err) 78 } 79 signer := p.(tink.Signer) 80 vkm, err := registry.GetKeyManager(rsaPSSTestPublicKeyTypeURL) 81 if err != nil { 82 t.Fatalf("registry.GetKeyManager(%q) err = %v, want nil", err, rsaPSSTestPublicKeyTypeURL) 83 } 84 serializedPublic, err := proto.Marshal(privKey.GetPublicKey()) 85 if err != nil { 86 t.Fatalf("proto.Marshal() err = %v, want nil", err) 87 } 88 p, err = vkm.Primitive(serializedPublic) 89 if err != nil { 90 t.Fatalf("Primitive() err = %v, want nil", err) 91 } 92 verifier := p.(tink.Verifier) 93 data := random.GetRandomBytes(80) 94 signature, err := signer.Sign(data) 95 if err != nil { 96 t.Fatalf("Sign() err = %v, want nil", err) 97 } 98 if err := verifier.Verify(signature, data); err != nil { 99 t.Fatalf("Verify() err = %v, want nil", err) 100 } 101} 102 103func mergePrivPub(priv *rsppb.RsaSsaPssPrivateKey, pub *rsppb.RsaSsaPssPublicKey) *rsppb.RsaSsaPssPrivateKey { 104 return &rsppb.RsaSsaPssPrivateKey{ 105 Version: priv.GetVersion(), 106 PublicKey: pub, 107 D: priv.GetD(), 108 P: priv.GetP(), 109 Q: priv.GetQ(), 110 Dp: priv.GetDp(), 111 Dq: priv.GetDq(), 112 Crt: priv.GetCrt(), 113 } 114} 115 116func TestRSASSAPSSSignerGetPrimitiveWithInvalidInput(t *testing.T) { 117 type testCase struct { 118 tag string 119 privKey *rsppb.RsaSsaPssPrivateKey 120 } 121 skm, err := registry.GetKeyManager(rsaPSSTestPrivateKeyTypeURL) 122 if err != nil { 123 t.Fatalf("registry.GetKeyManager(%q) err = %v, want nil", err, rsaPSSTestPrivateKeyTypeURL) 124 } 125 validPrivKey, err := makeValidRSAPSSKey() 126 if err != nil { 127 t.Fatalf("makeValidRSAPSSKey() err = %v, want nil", err) 128 } 129 for _, tc := range []testCase{ 130 { 131 tag: "empty private key", 132 privKey: &rsppb.RsaSsaPssPrivateKey{}, 133 }, 134 { 135 tag: "invalid private key version", 136 privKey: &rsppb.RsaSsaPssPrivateKey{ 137 Version: validPrivKey.GetVersion() + 1, 138 PublicKey: validPrivKey.GetPublicKey(), 139 D: validPrivKey.GetD(), 140 P: validPrivKey.GetP(), 141 Q: validPrivKey.GetQ(), 142 Dp: validPrivKey.GetDp(), 143 Dq: validPrivKey.GetDq(), 144 Crt: validPrivKey.GetCrt(), 145 }, 146 }, 147 { 148 tag: "invalid private key D", 149 privKey: &rsppb.RsaSsaPssPrivateKey{ 150 Version: validPrivKey.GetVersion(), 151 PublicKey: validPrivKey.GetPublicKey(), 152 D: nil, 153 P: validPrivKey.GetP(), 154 Q: validPrivKey.GetQ(), 155 Dp: validPrivKey.GetDp(), 156 Dq: validPrivKey.GetDq(), 157 Crt: validPrivKey.GetCrt(), 158 }, 159 }, 160 { 161 tag: "invalid private key P", 162 privKey: &rsppb.RsaSsaPssPrivateKey{ 163 Version: validPrivKey.GetVersion(), 164 PublicKey: validPrivKey.GetPublicKey(), 165 D: validPrivKey.GetD(), 166 P: nil, 167 Q: validPrivKey.GetQ(), 168 Dp: validPrivKey.GetDp(), 169 Dq: validPrivKey.GetDq(), 170 Crt: validPrivKey.GetCrt(), 171 }, 172 }, 173 { 174 tag: "invalid private key Q", 175 privKey: &rsppb.RsaSsaPssPrivateKey{ 176 Version: validPrivKey.GetVersion(), 177 PublicKey: validPrivKey.GetPublicKey(), 178 D: validPrivKey.GetD(), 179 P: validPrivKey.GetP(), 180 Q: nil, 181 Dp: validPrivKey.GetDp(), 182 Dq: validPrivKey.GetDq(), 183 Crt: validPrivKey.GetCrt(), 184 }, 185 }, 186 { 187 tag: "invalid private key Dp", 188 privKey: &rsppb.RsaSsaPssPrivateKey{ 189 Version: validPrivKey.GetVersion(), 190 PublicKey: validPrivKey.GetPublicKey(), 191 D: validPrivKey.GetD(), 192 P: validPrivKey.GetP(), 193 Q: validPrivKey.GetQ(), 194 Dp: nil, 195 Dq: validPrivKey.GetDq(), 196 Crt: validPrivKey.GetCrt(), 197 }, 198 }, 199 { 200 tag: "invalid private key Dq", 201 privKey: &rsppb.RsaSsaPssPrivateKey{ 202 Version: validPrivKey.GetVersion(), 203 PublicKey: validPrivKey.GetPublicKey(), 204 D: validPrivKey.GetD(), 205 P: validPrivKey.GetP(), 206 Q: validPrivKey.GetQ(), 207 Dp: validPrivKey.GetDp(), 208 Dq: nil, 209 Crt: validPrivKey.GetCrt(), 210 }, 211 }, 212 { 213 tag: "invalid private key Crt", 214 privKey: &rsppb.RsaSsaPssPrivateKey{ 215 Version: validPrivKey.GetVersion(), 216 PublicKey: validPrivKey.GetPublicKey(), 217 D: validPrivKey.GetD(), 218 P: validPrivKey.GetP(), 219 Q: validPrivKey.GetQ(), 220 Dp: validPrivKey.GetDp(), 221 Dq: validPrivKey.GetDq(), 222 Crt: nil, 223 }, 224 }, 225 { 226 tag: "empty public key", 227 privKey: mergePrivPub(validPrivKey, &rsppb.RsaSsaPssPublicKey{}), 228 }, 229 { 230 tag: "invalid public key version", 231 privKey: mergePrivPub( 232 validPrivKey, 233 &rsppb.RsaSsaPssPublicKey{ 234 Version: validPrivKey.GetPublicKey().GetVersion() + 1, 235 Params: validPrivKey.GetPublicKey().GetParams(), 236 N: validPrivKey.GetPublicKey().GetN(), 237 E: validPrivKey.GetPublicKey().GetE(), 238 }), 239 }, 240 { 241 tag: "different sig and mgf1 hash functions", 242 privKey: mergePrivPub( 243 validPrivKey, 244 &rsppb.RsaSsaPssPublicKey{ 245 Version: validPrivKey.GetPublicKey().GetVersion(), 246 Params: &rsppb.RsaSsaPssParams{ 247 SigHash: cpb.HashType_SHA256, 248 Mgf1Hash: cpb.HashType_SHA384, 249 SaltLength: validPrivKey.GetPublicKey().GetParams().GetSaltLength(), 250 }, 251 N: validPrivKey.GetPublicKey().GetN(), 252 E: validPrivKey.GetPublicKey().GetE(), 253 }), 254 }, 255 { 256 tag: "negative salt length", 257 privKey: mergePrivPub( 258 validPrivKey, 259 &rsppb.RsaSsaPssPublicKey{ 260 Version: validPrivKey.GetPublicKey().GetVersion(), 261 Params: &rsppb.RsaSsaPssParams{ 262 SigHash: validPrivKey.GetPublicKey().GetParams().GetSigHash(), 263 Mgf1Hash: validPrivKey.GetPublicKey().GetParams().GetMgf1Hash(), 264 SaltLength: -1, 265 }, 266 N: validPrivKey.GetPublicKey().GetN(), 267 E: validPrivKey.GetPublicKey().GetE(), 268 }), 269 }, 270 { 271 tag: "invalid hash function", 272 privKey: mergePrivPub( 273 validPrivKey, 274 &rsppb.RsaSsaPssPublicKey{ 275 Version: validPrivKey.GetPublicKey().GetVersion(), 276 Params: &rsppb.RsaSsaPssParams{ 277 SigHash: cpb.HashType_UNKNOWN_HASH, 278 Mgf1Hash: cpb.HashType_UNKNOWN_HASH, 279 SaltLength: validPrivKey.GetPublicKey().GetParams().GetSaltLength(), 280 }, 281 N: validPrivKey.GetPublicKey().GetN(), 282 E: validPrivKey.GetPublicKey().GetE(), 283 }), 284 }, 285 { 286 tag: "unsafe hash function", 287 privKey: mergePrivPub( 288 validPrivKey, 289 &rsppb.RsaSsaPssPublicKey{ 290 Version: validPrivKey.GetPublicKey().GetVersion(), 291 Params: &rsppb.RsaSsaPssParams{ 292 SigHash: cpb.HashType_SHA1, 293 Mgf1Hash: cpb.HashType_SHA1, 294 SaltLength: validPrivKey.GetPublicKey().GetParams().GetSaltLength(), 295 }, 296 N: validPrivKey.GetPublicKey().GetN(), 297 E: validPrivKey.GetPublicKey().GetE(), 298 }), 299 }, 300 { 301 tag: "invalid modulus", 302 privKey: mergePrivPub( 303 validPrivKey, 304 &rsppb.RsaSsaPssPublicKey{ 305 Version: validPrivKey.GetPublicKey().GetVersion(), 306 Params: validPrivKey.GetPublicKey().GetParams(), 307 N: []byte{0x00}, 308 E: validPrivKey.GetPublicKey().GetE(), 309 }), 310 }, 311 { 312 tag: "invalid exponent", 313 privKey: mergePrivPub( 314 validPrivKey, 315 &rsppb.RsaSsaPssPublicKey{ 316 Version: validPrivKey.GetPublicKey().GetVersion(), 317 Params: validPrivKey.GetPublicKey().GetParams(), 318 N: validPrivKey.GetPublicKey().GetN(), 319 E: []byte{0x01}, 320 }), 321 }, 322 { 323 tag: "exponent larger than 64 bits", 324 privKey: mergePrivPub( 325 validPrivKey, 326 &rsppb.RsaSsaPssPublicKey{ 327 Version: validPrivKey.GetPublicKey().GetVersion(), 328 Params: validPrivKey.GetPublicKey().GetParams(), 329 N: validPrivKey.GetPublicKey().GetN(), 330 E: random.GetRandomBytes(32), 331 }), 332 }, 333 } { 334 t.Run(tc.tag, func(t *testing.T) { 335 serializedPrivKey, err := proto.Marshal(tc.privKey) 336 if err != nil { 337 t.Fatalf("proto.Marshal() err = %v, want nil", err) 338 } 339 if _, err := skm.Primitive(serializedPrivKey); err == nil { 340 t.Errorf("Primitive() err = nil, want error") 341 } 342 if _, err := skm.(registry.PrivateKeyManager).PublicKeyData(serializedPrivKey); err == nil { 343 t.Errorf("PublicKeyData() err = nil, want error") 344 } 345 }) 346 } 347} 348 349func TestRSASSAPSSSignerGetPrimitiveWithCorruptedPrivateKey(t *testing.T) { 350 skm, err := registry.GetKeyManager(rsaPSSTestPrivateKeyTypeURL) 351 if err != nil { 352 t.Fatalf("registry.GetKeyManager(%q) err = %v, want nil", err, rsaPSSTestPrivateKeyTypeURL) 353 } 354 validPrivKey, err := makeValidRSAPSSKey() 355 if err != nil { 356 t.Fatalf("makeValidRSAPSSKey() err = %v, want nil", err) 357 } 358 corruptedPrivKey := validPrivKey 359 corruptedPrivKey.P[5] <<= 1 360 corruptedPrivKey.P[20] <<= 1 361 serializedPrivKey, err := proto.Marshal(corruptedPrivKey) 362 if err != nil { 363 t.Fatalf("proto.Marshal() err = %v, want nil", err) 364 } 365 if _, err := skm.Primitive(serializedPrivKey); err == nil { 366 t.Errorf("Primitive() err = nil, want error") 367 } 368} 369 370func TestRSASSAPSSSignerNewKey(t *testing.T) { 371 keyFormat := &rsppb.RsaSsaPssKeyFormat{ 372 Params: &rsppb.RsaSsaPssParams{ 373 SigHash: cpb.HashType_SHA256, 374 Mgf1Hash: cpb.HashType_SHA256, 375 SaltLength: 32, 376 }, 377 ModulusSizeInBits: 3072, 378 PublicExponent: []byte{0x01, 0x00, 0x01}, 379 } 380 serializedKeyFormat, err := proto.Marshal(keyFormat) 381 if err != nil { 382 t.Fatalf("proto.Marshal() err = %v, want nil", err) 383 } 384 skm, err := registry.GetKeyManager(rsaPSSTestPrivateKeyTypeURL) 385 if err != nil { 386 t.Fatalf("registry.GetKeyManager(%q) err = %v, want nil", err, rsaPSSTestPrivateKeyTypeURL) 387 } 388 key, err := skm.NewKey(serializedKeyFormat) 389 if err != nil { 390 t.Fatalf("NewKey() err = %v, want nil", err) 391 } 392 privKey, ok := key.(*rsppb.RsaSsaPssPrivateKey) 393 if !ok { 394 t.Fatalf("key isn't a *rsppb.RsaSsaPssPrivateKey") 395 } 396 if privKey.GetVersion() != rsaPSSTestPrivateKeyVersion { 397 t.Errorf("privKey.GetVersion() = %d, want %d", privKey.GetVersion(), rsaPSSTestPrivateKeyVersion) 398 } 399 if privKey.GetD() == nil { 400 t.Error("GetD() == nil, want []byte{}") 401 } 402 if privKey.GetP() == nil { 403 t.Error("GetP() == nil, want []byte{}") 404 } 405 if privKey.GetQ() == nil { 406 t.Error("GetQ() == nil, want []byte{}") 407 } 408 if privKey.GetDp() == nil { 409 t.Error("GetDp() == nil, want []byte{}") 410 } 411 if privKey.GetDq() == nil { 412 t.Error("GetDq() == nil, want []byte{}") 413 } 414 if privKey.GetCrt() == nil { 415 t.Error("GetCrt() == nil, want []byte{}") 416 } 417 pubKey := privKey.GetPublicKey() 418 if !cmp.Equal(pubKey.GetE(), keyFormat.GetPublicExponent()) { 419 t.Errorf("GetE() = %v, want %v", pubKey.GetE(), keyFormat.GetPublicExponent()) 420 } 421 n := uint32(new(big.Int).SetBytes(pubKey.GetN()).BitLen()) 422 if !cmp.Equal(n, keyFormat.GetModulusSizeInBits()) { 423 t.Errorf("Modulus size in bits = %q, want %q", n, keyFormat.GetModulusSizeInBits()) 424 } 425 if !cmp.Equal(pubKey.GetParams(), keyFormat.GetParams(), protocmp.Transform()) { 426 t.Errorf("GetParams() = %v, want %v", pubKey.GetParams(), keyFormat.GetParams()) 427 } 428} 429 430func TestRSASSAPSSSignerNewKeyData(t *testing.T) { 431 keyFormat := &rsppb.RsaSsaPssKeyFormat{ 432 Params: &rsppb.RsaSsaPssParams{ 433 SigHash: cpb.HashType_SHA256, 434 Mgf1Hash: cpb.HashType_SHA256, 435 SaltLength: 32, 436 }, 437 ModulusSizeInBits: 3072, 438 PublicExponent: []byte{0x01, 0x00, 0x01}, 439 } 440 serializedKeyFormat, err := proto.Marshal(keyFormat) 441 if err != nil { 442 t.Fatalf("proto.Marshal() err = %v, want nil", err) 443 } 444 skm, err := registry.GetKeyManager(rsaPSSTestPrivateKeyTypeURL) 445 if err != nil { 446 t.Fatalf("registry.GetKeyManager(%q) err = %v, want nil", err, rsaPSSTestPrivateKeyTypeURL) 447 } 448 vkm, err := registry.GetKeyManager(rsaPSSTestPublicKeyTypeURL) 449 if err != nil { 450 t.Fatalf("registry.GetKeyManager(%q) err = %v, want nil", err, rsaPSSTestPublicKeyTypeURL) 451 } 452 keyData, err := skm.NewKeyData(serializedKeyFormat) 453 if err != nil { 454 t.Fatalf("skm.NewKeyData() err = %v, want nil", err) 455 } 456 if keyData.GetKeyMaterialType() != tpb.KeyData_ASYMMETRIC_PRIVATE { 457 t.Errorf("keyData.GetKeyMaterialType() = %v, want %v", keyData.GetKeyMaterialType(), tpb.KeyData_ASYMMETRIC_PRIVATE) 458 } 459 if keyData.GetTypeUrl() != rsaPSSTestPrivateKeyTypeURL { 460 t.Errorf("keyData.GetTypeUrl() = %q, want %q", keyData.GetTypeUrl(), rsaPSSTestPrivateKeyTypeURL) 461 } 462 // Creating a primitive does a self key test which signs and verifies data. 463 s, err := skm.Primitive(keyData.GetValue()) 464 if err != nil { 465 t.Fatalf("Primitive() err = %v, want nil", err) 466 } 467 signer, ok := s.(tink.Signer) 468 if !ok { 469 t.Fatal("Primitive() return type isn't a tink.Signer") 470 } 471 data := random.GetRandomBytes(50) 472 sig, err := signer.Sign(data) 473 if err != nil { 474 t.Fatalf("signer.Sign() err = %v, want nil", err) 475 } 476 pubKeyData, err := skm.(registry.PrivateKeyManager).PublicKeyData(keyData.GetValue()) 477 if err != nil { 478 t.Fatalf("PublicKeyData() err = %v, want nil", err) 479 } 480 v, err := vkm.Primitive(pubKeyData.GetValue()) 481 if err != nil { 482 t.Fatalf("Primitive() err = %v, want nil", err) 483 } 484 verifier, ok := v.(tink.Verifier) 485 if !ok { 486 t.Fatal("Primitive() return type isn't a tink.Verifier") 487 } 488 if err := verifier.Verify(sig, data); err != nil { 489 t.Fatalf("verifier.Verify() err = %v, want nil", err) 490 } 491} 492 493func TestRSASSAPSSSignerNewKeyFailsWithInvalidFormat(t *testing.T) { 494 type testCase struct { 495 tag string 496 keyFormat *rsppb.RsaSsaPssKeyFormat 497 } 498 skm, err := registry.GetKeyManager(rsaPSSTestPrivateKeyTypeURL) 499 if err != nil { 500 t.Fatalf("registry.GetKeyManager(%q) err = %v, want nil", err, rsaPSSTestPrivateKeyTypeURL) 501 } 502 validKeyFormat := &rsppb.RsaSsaPssKeyFormat{ 503 Params: &rsppb.RsaSsaPssParams{ 504 SigHash: cpb.HashType_SHA256, 505 Mgf1Hash: cpb.HashType_SHA256, 506 SaltLength: 32, 507 }, 508 ModulusSizeInBits: 3072, 509 PublicExponent: []byte{0x01, 0x00, 0x01}, 510 } 511 serializedKeyFormat, err := proto.Marshal(validKeyFormat) 512 if err != nil { 513 t.Fatalf("proto.Marshal() err = %v, want nil", err) 514 } 515 if _, err := skm.NewKeyData(serializedKeyFormat); err != nil { 516 t.Fatalf("NewKeyData() err = %v, want nil", err) 517 } 518 for _, tc := range []testCase{ 519 { 520 tag: "unsafe hash function", 521 keyFormat: &rsppb.RsaSsaPssKeyFormat{ 522 Params: &rsppb.RsaSsaPssParams{ 523 SigHash: cpb.HashType_SHA224, 524 Mgf1Hash: cpb.HashType_SHA224, 525 SaltLength: validKeyFormat.GetParams().GetSaltLength(), 526 }, 527 ModulusSizeInBits: validKeyFormat.GetModulusSizeInBits(), 528 PublicExponent: validKeyFormat.GetPublicExponent(), 529 }, 530 }, 531 { 532 tag: "different signature and mgf1 hash function", 533 keyFormat: &rsppb.RsaSsaPssKeyFormat{ 534 Params: &rsppb.RsaSsaPssParams{ 535 SigHash: cpb.HashType_SHA384, 536 Mgf1Hash: cpb.HashType_SHA512, 537 SaltLength: validKeyFormat.GetParams().GetSaltLength(), 538 }, 539 ModulusSizeInBits: validKeyFormat.GetModulusSizeInBits(), 540 PublicExponent: validKeyFormat.GetPublicExponent(), 541 }, 542 }, 543 { 544 tag: "negative salt length", 545 keyFormat: &rsppb.RsaSsaPssKeyFormat{ 546 Params: &rsppb.RsaSsaPssParams{ 547 SigHash: validKeyFormat.GetParams().GetSigHash(), 548 Mgf1Hash: validKeyFormat.GetParams().GetMgf1Hash(), 549 SaltLength: -1, 550 }, 551 ModulusSizeInBits: validKeyFormat.GetModulusSizeInBits(), 552 PublicExponent: validKeyFormat.GetPublicExponent(), 553 }, 554 }, 555 { 556 tag: "insecure modulus size", 557 keyFormat: &rsppb.RsaSsaPssKeyFormat{ 558 Params: validKeyFormat.GetParams(), 559 ModulusSizeInBits: 2047, 560 PublicExponent: validKeyFormat.GetPublicExponent(), 561 }, 562 }, 563 { 564 tag: "invalid public exponent", 565 keyFormat: &rsppb.RsaSsaPssKeyFormat{ 566 Params: validKeyFormat.GetParams(), 567 ModulusSizeInBits: validKeyFormat.GetModulusSizeInBits(), 568 PublicExponent: []byte{0x00, 0x00, 0x03}, 569 }, 570 }, 571 } { 572 t.Run(tc.tag, func(t *testing.T) { 573 serializedKeyFormat, err := proto.Marshal(tc.keyFormat) 574 if err != nil { 575 t.Fatalf("proto.Marshal() err = %v, want nil", err) 576 } 577 if _, err := skm.NewKey(serializedKeyFormat); err == nil { 578 t.Fatalf("NewKey() err = nil, want error") 579 } 580 if _, err := skm.NewKeyData(serializedKeyFormat); err == nil { 581 t.Fatalf("NewKeyData() err = nil, want error") 582 } 583 }) 584 } 585} 586 587func TestRSASSAPSSSignerPublicKeyData(t *testing.T) { 588 skm, err := registry.GetKeyManager(rsaPSSTestPrivateKeyTypeURL) 589 if err != nil { 590 t.Fatalf("registry.GetKeyManager(%q) err = %v, want nil", err, rsaPSSTestPrivateKeyTypeURL) 591 } 592 vkm, err := registry.GetKeyManager(rsaPSSTestPublicKeyTypeURL) 593 if err != nil { 594 t.Fatalf("registry.GetKeyManager(%q) err = %v, want nil", err, rsaPSSTestPublicKeyTypeURL) 595 } 596 validPrivKey, err := makeValidRSAPSSKey() 597 if err != nil { 598 t.Fatalf("makeValidRSAPSSKey() err = %v, want nil", err) 599 } 600 serializedPrivKey, err := proto.Marshal(validPrivKey) 601 if err != nil { 602 t.Fatalf("proto.Marshal() err = %v, want nil", err) 603 } 604 pubKeyData, err := skm.(registry.PrivateKeyManager).PublicKeyData(serializedPrivKey) 605 if err != nil { 606 t.Fatalf("PublicKeyData() err = %v, want nil", err) 607 } 608 if pubKeyData.GetKeyMaterialType() != tpb.KeyData_ASYMMETRIC_PUBLIC { 609 t.Errorf("GetKeyMaterialType() = %v, want %v", pubKeyData.GetKeyMaterialType(), tpb.KeyData_ASYMMETRIC_PUBLIC) 610 } 611 if pubKeyData.GetTypeUrl() != rsaPSSTestPublicKeyTypeURL { 612 t.Errorf("GetTypeUrl() = %q, want %q", pubKeyData.GetTypeUrl(), rsaPSSTestPublicKeyTypeURL) 613 } 614 if _, err := vkm.Primitive(pubKeyData.GetValue()); err != nil { 615 t.Fatalf("vkm.Primitive() err = %v, want nil", err) 616 } 617} 618