Java 签名（SHA1WithRSA、SHA256WithRSA、SHA256withECDSA）

RSA1、RSA256 签名

  public static String MakeSign(String Data) {

     try {
       byte[] data = Data.getBytes();
       byte[] keyBytes = base64String2Byte(PrivateKey);

       PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

       KeyFactory keyFactory = KeyFactory.getInstance("RSA");

       PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
 　　　　
       Signature signature = Signature.getInstance("SHA256withRSA");//这个根据需求填充SHA1WithRSA或SHA256WithRSA
       signature.initSign(priKey);
       signature.update(data);

       return byte2Base64String(signature.sign());
     } catch (Exception e) {
       return "";
     }
   }

 // base64字符串转字节数组
   public static byte[] base64String2Byte(String base64Str) {
     return Base64.decodeBase64(base64Str);
   }

RSA1、RSA256 验签

     public static boolean VeriSign(String Data_ori, String Singnature) {
     　　try {
       　　byte[] signed = base64String2Byte(Singnature);

       　　X509EncodedKeySpec keySpec = new X509EncodedKeySpec(base64String2Byte(PublicKey));
       　　KeyFactory keyFactory = null;
       　　keyFactory = KeyFactory.getInstance("RSA");
       　　PublicKey publicKey = keyFactory.generatePublic(keySpec);

       　　Signature signature2 = Signature.getInstance("Sha256WithRSA");//这个根据需求填充SHA1WithRSA或SHA256WithRSA
       　　signature2.initVerify(publicKey);
       　　signature2.update(Data_ori.getBytes("UTF-8"));
       　　boolean verify = signature2.verify(signed);
       　　return verify;
     　　} catch (Exception e) {
       　　return false;
     　　}
   }

SHA256withECDSA验签

  public static boolean verifySign(String _data, String _key, String _sign) {

         try {
             java.security.spec.X509EncodedKeySpec bobPubKeySpec = new java.security.spec.X509EncodedKeySpec(
                     new BASE64Decoder().decodeBuffer(_key));
             KeyFactory keyf = KeyFactory.getInstance("EC"); //ECC 可根据需求更改
             PublicKey publicKey = keyf.generatePublic(bobPubKeySpec);

             byte[] data = hexStringToBytes(_data);
             byte[] sig = hexStringToBytes(_sign);

             Signature signer = Signature.getInstance("SHA256withECDSA");
             signer.initVerify(publicKey);
             signer.update(data);
             return (signer.verify(sig));
         }
         catch(Exception ex)
         {
             System.out.println(ex.getMessage());
             return false;
         }

  public static String bytesToHexString(byte[] src) {
         StringBuilder stringBuilder = new StringBuilder("");
         if (src == null || src.length <= 0) {
             return null;
         }
         for (int i = 0; i < src.length; i++) {
             int v = src[i] & 0xFF;
             String hv = Integer.toHexString(v);
             if (hv.length() < 2) {
                 stringBuilder.append(0);
             }
             stringBuilder.append(hv);
         }
         return stringBuilder.toString();
     }

     public static byte[] hexStringToBytes(String hexString) {
         if (hexString == null || hexString.equals("")) {
             return new byte[0];
         }
         hexString = hexString.toUpperCase();
         int length = hexString.length() / 2;
         char[] hexChars = hexString.toCharArray();
         byte[] d = new byte[length];
         for (int i = 0; i < length; i++) {
             int pos = i * 2;
             d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
         }
         return d;
     }

     public static byte charToByte(char c) {
         return (byte) "0123456789ABCDEF".indexOf(c);
     }

HEX和Byte[]互转