Пример #1
0
  protected byte[] enginesign() throws signatureexception {
    byte[] hash = new byte[digest.getdigestsize()];

    digest.dofinal(hash, 0);

    try {
      byte[] sigbytes = new byte[64];
      biginteger[] sig = signer.generatesignature(hash);
      byte[] r = sig[0].tobytearray();
      byte[] s = sig[1].tobytearray();

      if (s[0] != 0) {
        system.arraycopy(s, 0, sigbytes, 32 - s.length, s.length);
      } else {
        system.arraycopy(s, 1, sigbytes, 32 - (s.length - 1), s.length - 1);
      }

      if (r[0] != 0) {
        system.arraycopy(r, 0, sigbytes, 64 - r.length, r.length);
      } else {
        system.arraycopy(r, 1, sigbytes, 64 - (r.length - 1), r.length - 1);
      }

      return sigbytes;
    } catch (exception e) {
      throw new signatureexception(e.tostring());
    }
  }
  // public constructors
  public digestrandomgenerator(digest digest) {
    this.digest = digest;

    this.seed = new byte[digest.getdigestsize()];
    this.seedcounter = 1;

    this.state = new byte[digest.getdigestsize()];
    this.statecounter = 1;
  }
Пример #3
0
  protected void engineinitverify(publickey publickey) throws invalidkeyexception {
    cipherparameters param;

    if (publickey instanceof ecpublickey) {
      param = ecutil.generatepublickeyparameter(publickey);
    } else if (publickey instanceof gost3410key) {
      param = gost3410util.generatepublickeyparameter(publickey);
    } else {
      try {
        byte[] bytes = publickey.getencoded();

        publickey = bouncycastleprovider.getpublickey(subjectpublickeyinfo.getinstance(bytes));

        if (publickey instanceof ecpublickey) {
          param = ecutil.generatepublickeyparameter(publickey);
        } else {
          throw new invalidkeyexception("can't recognise key type in dsa based signer");
        }
      } catch (exception e) {
        throw new invalidkeyexception("can't recognise key type in dsa based signer");
      }
    }

    digest.reset();
    signer.init(false, param);
  }
Пример #4
0
  protected boolean engineverify(byte[] sigbytes) throws signatureexception {
    byte[] hash = new byte[digest.getdigestsize()];

    digest.dofinal(hash, 0);

    biginteger[] sig;

    try {
      byte[] r = new byte[32];
      byte[] s = new byte[32];

      system.arraycopy(sigbytes, 0, s, 0, 32);

      system.arraycopy(sigbytes, 32, r, 0, 32);

      sig = new biginteger[2];
      sig[0] = new biginteger(1, r);
      sig[1] = new biginteger(1, s);
    } catch (exception e) {
      throw new signatureexception("error decoding signature bytes.");
    }

    return signer.verifysignature(hash, sig[0], sig[1]);
  }
Пример #5
0
  protected void engineinitsign(privatekey privatekey) throws invalidkeyexception {
    cipherparameters param;

    if (privatekey instanceof eckey) {
      param = ecutil.generateprivatekeyparameter(privatekey);
    } else {
      param = gost3410util.generateprivatekeyparameter(privatekey);
    }

    digest.reset();

    if (random != null) {
      signer.init(true, new parameterswithrandom(param, random));
    } else {
      signer.init(true, param);
    }
  }
 private void digestdofinal(byte[] result) {
   digest.dofinal(result, 0);
 }
 private void digestupdate(byte[] inseed) {
   digest.update(inseed, 0, inseed.length);
 }
 private void digestaddcounter(long seed) {
   for (int i = 0; i != 8; i++) {
     digest.update((byte) seed);
     seed >>>= 8;
   }
 }
Пример #9
0
 protected void engineupdate(byte[] b, int off, int len) throws signatureexception {
   digest.update(b, off, len);
 }
Пример #10
0
 protected void engineupdate(byte b) throws signatureexception {
   digest.update(b);
 }
Пример #11
0
 private static byte[] dofinal(digest d) {
   byte[] bs = new byte[d.getdigestsize()];
   d.dofinal(bs, 0);
   return bs;
 }