libgo/go/crypto/rsa/pkcs1v15_test.go

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package rsa
   6
   7 import (
   8         "big"
   9         "bytes"
  10         "crypto/rand"
  11         "crypto/sha1"
  12         "encoding/base64"
  13         "encoding/hex"
  14         "io"
  15         "testing"
  16         "testing/quick"
  17 )
  18
  19 func decodeBase64(in string) []byte {
  20         out := make([]byte, base64.StdEncoding.DecodedLen(len(in)))
  21         n, err := base64.StdEncoding.Decode(out, []byte(in))
  22         if err != nil {
  23                 return nil
  24         }
  25         return out[0:n]
  26 }
  27
  28 type DecryptPKCS1v15Test struct {
  29         in, out string
  30 }
  31
  32 // These test vectors were generated with `openssl rsautl -pkcs -encrypt`
  33 var decryptPKCS1v15Tests = []DecryptPKCS1v15Test{
  34         {
  35                 "gIcUIoVkD6ATMBk/u/nlCZCCWRKdkfjCgFdo35VpRXLduiKXhNz1XupLLzTXAybEq15juc+EgY5o0DHv/nt3yg==",
  36                 "x",
  37         },
  38         {
  39                 "Y7TOCSqofGhkRb+jaVRLzK8xw2cSo1IVES19utzv6hwvx+M8kFsoWQm5DzBeJCZTCVDPkTpavUuEbgp8hnUGDw==",
  40                 "testing.",
  41         },
  42         {
  43                 "arReP9DJtEVyV2Dg3dDp4c/PSk1O6lxkoJ8HcFupoRorBZG+7+1fDAwT1olNddFnQMjmkb8vxwmNMoTAT/BFjQ==",
  44                 "testing.\n",
  45         },
  46         {
  47                 "WtaBXIoGC54+vH0NH0CHHE+dRDOsMc/6BrfFu2lEqcKL9+uDuWaf+Xj9mrbQCjjZcpQuX733zyok/jsnqe/Ftw==",
  48                 "01234567890123456789012345678901234567890123456789012",
  49         },
  50 }
  51
  52 func TestDecryptPKCS1v15(t *testing.T) {
  53         for i, test := range decryptPKCS1v15Tests {
  54                 out, err := DecryptPKCS1v15(nil, rsaPrivateKey, decodeBase64(test.in))
  55                 if err != nil {
  56                         t.Errorf("#%d error decrypting", i)
  57                 }
  58                 want := []byte(test.out)
  59                 if bytes.Compare(out, want) != 0 {
  60                         t.Errorf("#%d got:%#v want:%#v", i, out, want)
  61                 }
  62         }
  63 }
  64
  65 func TestEncryptPKCS1v15(t *testing.T) {
  66         random := rand.Reader
  67         k := (rsaPrivateKey.N.BitLen() + 7) / 8
  68
  69         tryEncryptDecrypt := func(in []byte, blind bool) bool {
  70                 if len(in) > k-11 {
  71                         in = in[0 : k-11]
  72                 }
  73
  74                 ciphertext, err := EncryptPKCS1v15(random, &rsaPrivateKey.PublicKey, in)
  75                 if err != nil {
  76                         t.Errorf("error encrypting: %s", err)
  77                         return false
  78                 }
  79
  80                 var rand io.Reader
  81                 if !blind {
  82                         rand = nil
  83                 } else {
  84                         rand = random
  85                 }
  86                 plaintext, err := DecryptPKCS1v15(rand, rsaPrivateKey, ciphertext)
  87                 if err != nil {
  88                         t.Errorf("error decrypting: %s", err)
  89                         return false
  90                 }
  91
  92                 if bytes.Compare(plaintext, in) != 0 {
  93                         t.Errorf("output mismatch: %#v %#v", plaintext, in)
  94                         return false
  95                 }
  96                 return true
  97         }
  98
  99         quick.Check(tryEncryptDecrypt, nil)
 100 }
 101
 102 // These test vectors were generated with `openssl rsautl -pkcs -encrypt`
 103 var decryptPKCS1v15SessionKeyTests = []DecryptPKCS1v15Test{
 104         {
 105                 "e6ukkae6Gykq0fKzYwULpZehX+UPXYzMoB5mHQUDEiclRbOTqas4Y0E6nwns1BBpdvEJcilhl5zsox/6DtGsYg==",
 106                 "1234",
 107         },
 108         {
 109                 "Dtis4uk/q/LQGGqGk97P59K03hkCIVFMEFZRgVWOAAhxgYpCRG0MX2adptt92l67IqMki6iVQyyt0TtX3IdtEw==",
 110                 "FAIL",
 111         },
 112         {
 113                 "LIyFyCYCptPxrvTxpol8F3M7ZivlMsf53zs0vHRAv+rDIh2YsHS69ePMoPMe3TkOMZ3NupiL3takPxIs1sK+dw==",
 114                 "abcd",
 115         },
 116         {
 117                 "bafnobel46bKy76JzqU/RIVOH0uAYvzUtauKmIidKgM0sMlvobYVAVQPeUQ/oTGjbIZ1v/6Gyi5AO4DtHruGdw==",
 118                 "FAIL",
 119         },
 120 }
 121
 122 func TestEncryptPKCS1v15SessionKey(t *testing.T) {
 123         for i, test := range decryptPKCS1v15SessionKeyTests {
 124                 key := []byte("FAIL")
 125                 err := DecryptPKCS1v15SessionKey(nil, rsaPrivateKey, decodeBase64(test.in), key)
 126                 if err != nil {
 127                         t.Errorf("#%d error decrypting", i)
 128                 }
 129                 want := []byte(test.out)
 130                 if bytes.Compare(key, want) != 0 {
 131                         t.Errorf("#%d got:%#v want:%#v", i, key, want)
 132                 }
 133         }
 134 }
 135
 136 func TestNonZeroRandomBytes(t *testing.T) {
 137         random := rand.Reader
 138
 139         b := make([]byte, 512)
 140         err := nonZeroRandomBytes(b, random)
 141         if err != nil {
 142                 t.Errorf("returned error: %s", err)
 143         }
 144         for _, b := range b {
 145                 if b == 0 {
 146                         t.Errorf("Zero octet found")
 147                         return
 148                 }
 149         }
 150 }
 151
 152 type signPKCS1v15Test struct {
 153         in, out string
 154 }
 155
 156 // These vectors have been tested with
 157 //   `openssl rsautl -verify -inkey pk -in signature | hexdump -C`
 158 var signPKCS1v15Tests = []signPKCS1v15Test{
 159         {"Test.\n", "a4f3fa6ea93bcdd0c57be020c1193ecbfd6f200a3d95c409769b029578fa0e336ad9a347600e40d3ae823b8c7e6bad88cc07c1d54c3a1523cbbb6d58efc362ae"},
 160 }
 161
 162 func TestSignPKCS1v15(t *testing.T) {
 163         for i, test := range signPKCS1v15Tests {
 164                 h := sha1.New()
 165                 h.Write([]byte(test.in))
 166                 digest := h.Sum()
 167
 168                 s, err := SignPKCS1v15(nil, rsaPrivateKey, HashSHA1, digest)
 169                 if err != nil {
 170                         t.Errorf("#%d %s", i, err)
 171                 }
 172
 173                 expected, _ := hex.DecodeString(test.out)
 174                 if bytes.Compare(s, expected) != 0 {
 175                         t.Errorf("#%d got: %x want: %x", i, s, expected)
 176                 }
 177         }
 178 }
 179
 180 func TestVerifyPKCS1v15(t *testing.T) {
 181         for i, test := range signPKCS1v15Tests {
 182                 h := sha1.New()
 183                 h.Write([]byte(test.in))
 184                 digest := h.Sum()
 185
 186                 sig, _ := hex.DecodeString(test.out)
 187
 188                 err := VerifyPKCS1v15(&rsaPrivateKey.PublicKey, HashSHA1, digest, sig)
 189                 if err != nil {
 190                         t.Errorf("#%d %s", i, err)
 191                 }
 192         }
 193 }
 194
 195 func bigFromString(s string) *big.Int {
 196         ret := new(big.Int)
 197         ret.SetString(s, 10)
 198         return ret
 199 }
 200
 201 // In order to generate new test vectors you'll need the PEM form of this key:
 202 // -----BEGIN RSA PRIVATE KEY-----
 203 // MIIBOgIBAAJBALKZD0nEffqM1ACuak0bijtqE2QrI/KLADv7l3kK3ppMyCuLKoF0
 204 // fd7Ai2KW5ToIwzFofvJcS/STa6HA5gQenRUCAwEAAQJBAIq9amn00aS0h/CrjXqu
 205 // /ThglAXJmZhOMPVn4eiu7/ROixi9sex436MaVeMqSNf7Ex9a8fRNfWss7Sqd9eWu
 206 // RTUCIQDasvGASLqmjeffBNLTXV2A5g4t+kLVCpsEIZAycV5GswIhANEPLmax0ME/
 207 // EO+ZJ79TJKN5yiGBRsv5yvx5UiHxajEXAiAhAol5N4EUyq6I9w1rYdhPMGpLfk7A
 208 // IU2snfRJ6Nq2CQIgFrPsWRCkV+gOYcajD17rEqmuLrdIRexpg8N1DOSXoJ8CIGlS
 209 // tAboUGBxTDq3ZroNism3DaMIbKPyYrAqhKov1h5V
 210 // -----END RSA PRIVATE KEY-----
 211
 212 var rsaPrivateKey = &PrivateKey{
 213         PublicKey: PublicKey{
 214                 N: bigFromString("9353930466774385905609975137998169297361893554149986716853295022578535724979677252958524466350471210367835187480748268864277464700638583474144061408845077"),
 215                 E: 65537,
 216         },
 217         D: bigFromString("7266398431328116344057699379749222532279343923819063639497049039389899328538543087657733766554155839834519529439851673014800261285757759040931985506583861"),
 218         P: bigFromString("98920366548084643601728869055592650835572950932266967461790948584315647051443"),
 219         Q: bigFromString("94560208308847015747498523884063394671606671904944666360068158221458669711639"),
 220 }