Source for gnu.java.security.sig.dss.DSSSignatureRawCodec

   1: /* DSSSignatureRawCodec.java --
   2:    Copyright (C) 2001, 2002, 2003, 2006 Free Software Foundation, Inc.
   3: 
   4: This file is a part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2 of the License, or (at
   9: your option) any later version.
  10: 
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; if not, write to the Free Software
  18: Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
  19: USA
  20: 
  21: Linking this library statically or dynamically with other modules is
  22: making a combined work based on this library.  Thus, the terms and
  23: conditions of the GNU General Public License cover the whole
  24: combination.
  25: 
  26: As a special exception, the copyright holders of this library give you
  27: permission to link this library with independent modules to produce an
  28: executable, regardless of the license terms of these independent
  29: modules, and to copy and distribute the resulting executable under
  30: terms of your choice, provided that you also meet, for each linked
  31: independent module, the terms and conditions of the license of that
  32: module.  An independent module is a module which is not derived from
  33: or based on this library.  If you modify this library, you may extend
  34: this exception to your version of the library, but you are not
  35: obligated to do so.  If you do not wish to do so, delete this
  36: exception statement from your version.  */
  37: 
  38: 
  39: package gnu.java.security.sig.dss;
  40: 
  41: import gnu.java.security.Registry;
  42: import gnu.java.security.sig.ISignatureCodec;
  43: 
  44: import java.io.ByteArrayOutputStream;
  45: import java.math.BigInteger;
  46: 
  47: /**
  48:  * An object that implements the {@link ISignatureCodec} operations for the
  49:  * <i>Raw</i> format to use with DSS signatures.
  50:  */
  51: public class DSSSignatureRawCodec
  52:     implements ISignatureCodec
  53: {
  54:   public int getFormatID()
  55:   {
  56:     return RAW_FORMAT;
  57:   }
  58: 
  59:   /**
  60:    * Returns the encoded form of the designated DSS (Digital Signature Standard)
  61:    * signature object according to the <i>Raw</i> format supported by this
  62:    * library.
  63:    * <p>
  64:    * The <i>Raw</i> format for a DSA signature, in this implementation, is a
  65:    * byte sequence consisting of the following:
  66:    * <ol>
  67:    * <li>4-byte magic consisting of the value of the literal
  68:    * {@link Registry#MAGIC_RAW_DSS_SIGNATURE},</li>
  69:    * <li>1-byte version consisting of the constant: 0x01,</li>
  70:    * <li>4-byte count of following bytes representing the DSS parameter
  71:    * <code>r</code> in internet order,</li>
  72:    * <li>n-bytes representation of a {@link BigInteger} obtained by invoking
  73:    * the <code>toByteArray()</code> method on the DSS parameter <code>r</code>,
  74:    * </li>
  75:    * <li>4-byte count of following bytes representing the DSS parameter
  76:    * <code>s</code>,</li>
  77:    * <li>n-bytes representation of a {@link BigInteger} obtained by invoking
  78:    * the <code>toByteArray()</code> method on the DSS parameter <code>s</code>.
  79:    * </li>
  80:    * </ol>
  81:    *
  82:    * @param signature the signature to encode, consisting of the two DSS
  83:    *          parameters <code>r</code> and <code>s</code> as a
  84:    *          {@link BigInteger} array.
  85:    * @return the <i>Raw</i> format encoding of the designated signature.
  86:    * @exception IllegalArgumentException if the designated signature is not a
  87:    *              DSS (Digital Signature Standard) one.
  88:    */
  89:   public byte[] encodeSignature(Object signature)
  90:   {
  91:     BigInteger r, s;
  92:     try
  93:       {
  94:         BigInteger[] sig = (BigInteger[]) signature;
  95:         r = sig[0];
  96:         s = sig[1];
  97:       }
  98:     catch (Exception x)
  99:       {
 100:         throw new IllegalArgumentException("signature");
 101:       }
 102:     ByteArrayOutputStream baos = new ByteArrayOutputStream();
 103:     // magic
 104:     baos.write(Registry.MAGIC_RAW_DSS_SIGNATURE[0]);
 105:     baos.write(Registry.MAGIC_RAW_DSS_SIGNATURE[1]);
 106:     baos.write(Registry.MAGIC_RAW_DSS_SIGNATURE[2]);
 107:     baos.write(Registry.MAGIC_RAW_DSS_SIGNATURE[3]);
 108:     // version
 109:     baos.write(0x01);
 110:     // r
 111:     byte[] buffer = r.toByteArray();
 112:     int length = buffer.length;
 113:     baos.write( length >>> 24);
 114:     baos.write((length >>> 16) & 0xFF);
 115:     baos.write((length >>> 8) & 0xFF);
 116:     baos.write(length & 0xFF);
 117:     baos.write(buffer, 0, length);
 118:     // s
 119:     buffer = s.toByteArray();
 120:     length = buffer.length;
 121:     baos.write( length >>> 24);
 122:     baos.write((length >>> 16) & 0xFF);
 123:     baos.write((length >>> 8) & 0xFF);
 124:     baos.write(length & 0xFF);
 125:     baos.write(buffer, 0, length);
 126:     return baos.toByteArray();
 127:   }
 128: 
 129:   public Object decodeSignature(byte[] k)
 130:   {
 131:     // magic
 132:     if (k[0] != Registry.MAGIC_RAW_DSS_SIGNATURE[0]
 133:         || k[1] != Registry.MAGIC_RAW_DSS_SIGNATURE[1]
 134:         || k[2] != Registry.MAGIC_RAW_DSS_SIGNATURE[2]
 135:         || k[3] != Registry.MAGIC_RAW_DSS_SIGNATURE[3])
 136:       throw new IllegalArgumentException("magic");
 137:     // version
 138:     if (k[4] != 0x01)
 139:       throw new IllegalArgumentException("version");
 140: 
 141:     int i = 5;
 142:     int l;
 143:     byte[] buffer;
 144:     // r
 145:     l =  k[i++]         << 24
 146:       | (k[i++] & 0xFF) << 16
 147:       | (k[i++] & 0xFF) << 8
 148:       | (k[i++] & 0xFF);
 149:     buffer = new byte[l];
 150:     System.arraycopy(k, i, buffer, 0, l);
 151:     i += l;
 152:     BigInteger r = new BigInteger(1, buffer);
 153:     // s
 154:     l =  k[i++]         << 24
 155:       | (k[i++] & 0xFF) << 16
 156:       | (k[i++] & 0xFF) << 8
 157:       | (k[i++] & 0xFF);
 158:     buffer = new byte[l];
 159:     System.arraycopy(k, i, buffer, 0, l);
 160:     i += l;
 161:     BigInteger s = new BigInteger(1, buffer);
 162:     return new BigInteger[] { r, s };
 163:   }
 164: }