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

src/pkg/crypto/openpgp/elgamal/elgamal.go

 // Copyright 2011 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 elgamal implements ElGamal encryption, suitable for OpenPGP,
 // as specified in "A Public-Key Cryptosystem and a Signature Scheme Based on
 // Discrete Logarithms," IEEE Transactions on Information Theory, v. IT-31,
 // n. 4, 1985, pp. 469-472.
 //
 // This form of ElGamal embeds PKCS#1 v1.5 padding, which may make it
@@ skipping 19 matching lines @@
         PublicKey
         X *big.Int
 }
 
 // Encrypt encrypts the given message to the given public key. The result is a
 // pair of integers. Errors can result from reading random, or because msg is
 // too large to be encrypted to the public key.
 func Encrypt(random io.Reader, pub *PublicKey, msg []byte) (c1, c2 *big.Int, err os.Error) {
         pLen := (pub.P.BitLen() + 7) / 8
         if len(msg) > pLen-11 {
-                err = os.ErrorString("elgamal: message too long")
+                err = os.NewError("elgamal: message too long")
                 return
         }
 
         // EM = 0x02 || PS || 0x00 || M
         em := make([]byte, pLen-1)
         em[0] = 2
         ps, mm := em[1:len(em)-len(msg)-1], em[len(em)-len(msg):]
         err = nonZeroRandomBytes(ps, random)
         if err != nil {
                 return
@@ skipping 39 matching lines @@
         var lookingForIndex, index int
         lookingForIndex = 1
 
         for i := 1; i < len(em); i++ {
                 equals0 := subtle.ConstantTimeByteEq(em[i], 0)
                 index = subtle.ConstantTimeSelect(lookingForIndex&equals0, i, index)
                 lookingForIndex = subtle.ConstantTimeSelect(equals0, 0, lookingForIndex)
         }
 
         if firstByteIsTwo != 1 || lookingForIndex != 0 || index < 9 {
-                return nil, os.ErrorString("elgamal: decryption error")
+                return nil, os.NewError("elgamal: decryption error")
         }
         return em[index+1:], nil
 }
 
 // nonZeroRandomBytes fills the given slice with non-zero random octets.
 func nonZeroRandomBytes(s []byte, rand io.Reader) (err os.Error) {
         _, err = io.ReadFull(rand, s)
         if err != nil {
                 return
         }
 
         for i := 0; i < len(s); i++ {
                 for s[i] == 0 {
                         _, err = io.ReadFull(rand, s[i:i+1])
                         if err != nil {
                                 return
                         }
                 }
         }
 
         return
 }