code review 4607052: os.Error API: don't export os.ErrorString, use os.NewEr...

src/pkg/crypto/rsa/rsa.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Package rsa implements RSA encryption as specified in PKCS#1.
 package rsa
 
 // TODO(agl): Add support for PSS padding.
 
 import (
@@ skipping 46 matching lines @@
 // Validate performs basic sanity checks on the key.
 // It returns nil if the key is valid, or else an os.Error describing a problem.
 
 func (priv *PrivateKey) Validate() os.Error {
         // Check that the prime factors are actually prime. Note that this is
         // just a sanity check. Since the random witnesses chosen by
         // ProbablyPrime are deterministic, given the candidate number, it's
         // easy for an attack to generate composites that pass this test.
         for _, prime := range priv.Primes {
                 if !big.ProbablyPrime(prime, 20) {
-                        return os.ErrorString("prime factor is composite")
+                        return os.NewError("prime factor is composite")
                 }
         }
 
         // Check that Πprimes == n.
         modulus := new(big.Int).Set(bigOne)
         for _, prime := range priv.Primes {
                 modulus.Mul(modulus, prime)
         }
         if modulus.Cmp(priv.N) != 0 {
-                return os.ErrorString("invalid modulus")
+                return os.NewError("invalid modulus")
         }
         // Check that e and totient(Πprimes) are coprime.
         totient := new(big.Int).Set(bigOne)
         for _, prime := range priv.Primes {
                 pminus1 := new(big.Int).Sub(prime, bigOne)
                 totient.Mul(totient, pminus1)
         }
         e := big.NewInt(int64(priv.E))
         gcd := new(big.Int)
         x := new(big.Int)
         y := new(big.Int)
         big.GcdInt(gcd, x, y, totient, e)
         if gcd.Cmp(bigOne) != 0 {
-                return os.ErrorString("invalid public exponent E")
+                return os.NewError("invalid public exponent E")
         }
         // Check that de ≡ 1 (mod totient(Πprimes))
         de := new(big.Int).Mul(priv.D, e)
         de.Mod(de, totient)
         if de.Cmp(bigOne) != 0 {
-                return os.ErrorString("invalid private exponent D")
+                return os.NewError("invalid private exponent D")
         }
         return nil
 }
 
 // GenerateKey generates an RSA keypair of the given bit size.
 func GenerateKey(random io.Reader, bits int) (priv *PrivateKey, err os.Error) {
         return GenerateMultiPrimeKey(random, 2, bits)
 }
 
 // GenerateMultiPrimeKey generates a multi-prime RSA keypair of the given bit
@@ skipping 12 matching lines @@
         // operations. Since the exponent must be coprime to
         // (p-1)(q-1), the smallest possible value is 3. Some have
         // suggested that a larger exponent (often 2**16+1) be used
         // since previous implementation bugs[1] were avoided when this
         // was the case. However, there are no current reasons not to use
         // small exponents.
         // [1] http://marc.info/?l=cryptography&m=115694833312008&w=2
         priv.E = 3
 
         if nprimes < 2 {
-                return nil, os.ErrorString("rsa.GenerateMultiPrimeKey: nprimes must be >= 2")
+                return nil, os.NewError("rsa.GenerateMultiPrimeKey: nprimes must be >= 2")
         }
 
         primes := make([]*big.Int, nprimes)
 
 NextSetOfPrimes:
         for {
                 todo := bits
                 for i := 0; i < nprimes; i++ {
                         primes[i], err = rand.Prime(random, todo/(nprimes-i))
                         if err != nil {
@@ skipping 352 matching lines @@
 // aligned in the new slice.
 func leftPad(input []byte, size int) (out []byte) {
         n := len(input)
         if n > size {
                 n = size
         }
         out = make([]byte, size)
         copy(out[len(out)-n:], input)
         return
 }