精华内容
下载资源
问答
  • JAVA在Windows平台上生成机器码
  • CPU序列号: ... import java.io.IOException;  import java.util.Scanner;    public class CPUTest {     /**   * @param args   * @throws IOException   */   ...

    CPU序列号:

     

    1. package test;  
    2.   
    3. import java.io.IOException;  
    4. import java.util.Scanner;  
    5.   
    6. public class CPUTest {  
    7.   
    8.     /** 
    9.      * @param args 
    10.      * @throws IOException  
    11.      */  
    12.     public static void main(String[] args) throws IOException {  
    13.         // TODO Auto-generated method stub  
    14.         long start = System.currentTimeMillis();  
    15.         Process process = Runtime.getRuntime().exec(  
    16.                 new String[] { "wmic""cpu""get""ProcessorId" });  
    17.         process.getOutputStream().close();  
    18.         Scanner sc = new Scanner(process.getInputStream());  
    19.         String property = sc.next();  
    20.         String serial = sc.next();  
    21.         System.out.println(property + ": " + serial);  
    22.            
    23.         System.out.println("time:" + (System.currentTimeMillis() - start));  
    24.   
    25.     }  
    26.   
    27. }  

      结果输出是这样的   

              其实就是用Runtime.getRuntime().exec 执行一个指令而已。。

          想知道结果是否是准确的 , 可以在DOS下面测试  首先windows键+R键 打开运行框 ,然后输入cmd 打开DOS 。然后输入   wmic cpu get ProcessorId   

          这次的结果任然是    

     

          Runtime.getRuntime().exec 真的很强大啊,直接可以取得当前JVM的运行时环境,然后通过exec执行传入的命令参数,Runtime.exec还可以做其他的事情,比如说直接打开一个文件。。不过在这里我就不在做了,有兴趣的小伙伴可以自己去试试看。。。

    转载自:https://blog.csdn.net/y353027520dx/article/details/42494721

     

    java获取mac和机器码,注册码的实现

    package util;
    import java.net.NetworkInterface;
    import java.util.Enumeration;
    import java.util.HashSet;
    import java.util.Properties;
    import java.util.Set;
    import org.hyperic.sigar.NetFlags;
    import org.hyperic.sigar.NetInterfaceConfig;
    import org.hyperic.sigar.Sigar;
    import org.hyperic.sigar.SigarException;
    import org.springframework.security.authentication.encoding.Md5PasswordEncoder;
    
    /**
     * java获取mac和机器码,注册码的实现
     * 
     */
    public class AuthorizationUtils {
    	private static final int SPLITLENGTH = 4;
    	private static final String SALT = "yunshouhu";
    
    	public static void main(String args[]) throws Exception {
    		String code = getMachineCode();
    
    		System.out.println("code:" + code);
    
    		String authCode = auth(code);
    		System.out.println("机器码:" + code);
    		System.out.println("注册码:" + authCode);
    
    		// System.out.println("mac:"+getMac());
    		// System.out.println("mac2:"+getMac2());
    
    	}
    
    	private static String getMachineCode() {
    		Set<String> result = new HashSet<>();
    		String mac = getMac();
    		System.out.println("mac:" + getMac());
    		result.add(mac);
    		Properties props = System.getProperties();
    		String javaVersion = props.getProperty("java.version");
    		result.add(javaVersion);
    		// System.out.println("Java的运行环境版本:    " + javaVersion);
    		String javaVMVersion = props.getProperty("java.vm.version");
    		result.add(javaVMVersion);
    		// System.out.println("Java的虚拟机实现版本:    " +
    		// props.getProperty("java.vm.version"));
    		String osVersion = props.getProperty("os.version");
    		result.add(osVersion);
    		// System.out.println("操作系统的版本:    " + props.getProperty("os.version"));
    
    		String code = new Md5PasswordEncoder().encodePassword(
    				result.toString(), SALT);
    		return getSplitString(code, "-", 4);
    
    	}
    
    	// 使用hyperic-sigar获取mac
    	private static String getMac2() throws SigarException {
    		Sigar sigar = new Sigar();
    		String[] ifaces = sigar.getNetInterfaceList();
    		for (String iface : ifaces) {
    			NetInterfaceConfig cfg = sigar.getNetInterfaceConfig(iface);
    			if (NetFlags.LOOPBACK_ADDRESS.equals(cfg.getAddress())
    					|| (cfg.getFlags() & NetFlags.IFF_LOOPBACK) != 0
    					|| NetFlags.NULL_HWADDR.equals(cfg.getHwaddr())) {
    				continue;
    			}
    			String mac = cfg.getHwaddr();
    			return mac;
    		}
    		return null;
    
    	}
    
    	public static String auth(String machineCode) {
    		String newCode = "(yunshouhuxxx@gmail.com)["
    				+ machineCode.toUpperCase() + "](xxx应用级产品开发平台)";
    		String code = new Md5PasswordEncoder().encodePassword(newCode, SALT)
    				.toUpperCase() + machineCode.length();
    		return getSplitString(code);
    	}
    
    	private static String getSplitString(String str) {
    		return getSplitString(str, "-", SPLITLENGTH);
    	}
    
    	private static String getSplitString(String str, String split, int length) {
    		int len = str.length();
    		StringBuilder temp = new StringBuilder();
    		for (int i = 0; i < len; i++) {
    			if (i % length == 0 && i > 0) {
    				temp.append(split);
    			}
    			temp.append(str.charAt(i));
    		}
    		String[] attrs = temp.toString().split(split);
    		StringBuilder finalMachineCode = new StringBuilder();
    		for (String attr : attrs) {
    			if (attr.length() == length) {
    				finalMachineCode.append(attr).append(split);
    			}
    		}
    		String result = finalMachineCode.toString().substring(0,
    				finalMachineCode.toString().length() - 1);
    		return result;
    	}
    
    	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();
    	}
    
    	// ‎00-24-7E-0A-22-93
    	private static String getMac() {
    		try {
    			Enumeration<NetworkInterface> el = NetworkInterface
    					.getNetworkInterfaces();
    			while (el.hasMoreElements()) {
    				byte[] mac = el.nextElement().getHardwareAddress();
    				if (mac == null)
    					continue;
    
    				String hexstr = bytesToHexString(mac);
    				return getSplitString(hexstr, "-", 2).toUpperCase();
    
    			}
    		} catch (Exception exception) {
    			exception.printStackTrace();
    		}
    		return null;
    	}
    }

    转自:https://blog.csdn.net/earbao/article/details/41484691

    展开全文
  • 机器码获取,并加密

    2012-04-01 10:06:48
    写的一个Demo供大家分享,用到DES加密,解密。获取机器码
  • java生成系统机器码(linux和windows)

    千次阅读 2020-05-23 10:48:07
    if (property.contains("windows")) { // 获取cpu序列号 cpuSerialNumber = GenerateRegistCode.getCPUSerialNumber(); // 获取 硬盘号 hardDiskSerialNumber = GenerateRegistCode.getHardDiskSerialNumber(); } ...
    /**
     * 生成序列号的main方法
     * @param args
     */
    public static void main(String[] args) {
        String property = System.getProperty("os.name").toLowerCase();
        String cpuSerialNumber = "";
        String hardDiskSerialNumber = "";
        String md5Result = "";
        if (property.contains("windows")) {
            // 获取cpu序列号
            cpuSerialNumber = GenerateRegistCode.getCPUSerialNumber();
            // 获取 硬盘号
            hardDiskSerialNumber = GenerateRegistCode.getHardDiskSerialNumber();
        } else if (property.contains("linux")) {
            // 获取cpu序列号
            cpuSerialNumber = GenerateRegistCode.getUUID();
            // 获取 硬盘号
            hardDiskSerialNumber = GenerateRegistCode.getBoisVersion();
        }
        // 获取到cpu序列号和硬盘号  
           System.out.println("key:" + cpuSerialNumber + hardDiskSerialNumber);
    }
    /**
     * 获取CPU序列号(Windows)
     *
     * @return
     * @throws IOException
     */
    public static String getCPUSerialNumber() {
        String serial;
        try {
            Process process = Runtime.getRuntime().exec(new String[]{"wmic", "cpu", "get", "ProcessorId"});
            process.getOutputStream().close();
            Scanner sc = new Scanner(process.getInputStream());
            serial = sc.next();
        } catch (IOException e) {
            throw new RuntimeException("获取CPU序列号失败");
        }
        return serial;
    }
    /**
     * 获取 硬盘序列号(Windows)
     *
     * @return
     * @throws IOException
     * @throws InterruptedException
     */
    public static String getHardDiskSerialNumber() {
        String serial;
        try {
            Process process = Runtime.getRuntime().exec(new String[]{"wmic", "path", "win32_physicalmedia", "get", "serialnumber"});
            process.getOutputStream().close();
            Scanner sc = new Scanner(process.getInputStream());
            serial = sc.next();
        } catch (IOException e) {
            throw new RuntimeException("获取硬盘序列号失败");
        }
        return serial;
    }
    /**
    * 注:liunx上 如果想获取的话  需要root用户来执行 ;如果使用普通用户 执行的话  需要输入当前用户的密码(普通用户不支持dmidecode命令 因为没权限)
    */
    
    /**
     * bois版本号(linux)
     *
     * @return
     */
    public static String getBoisVersion() {
        String result = "";
        Process p;
        try {
            p = Runtime.getRuntime().exec("sudo dmidecode -s bios-version");// 管道
            BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream()));
            String line;
            while ((line = br.readLine()) != null) {
                result += line;
                break;
            }
            br.close();
        } catch (IOException e) {
            System.out.println("获取主板信息错误");
        }
        return result;
    }
    
    
    /**
     * 获取系统序列号(linux)
     *
     * @return
     */
    public static String getUUID() {
        String result = "";
        try {
            Process process = Runtime.getRuntime().exec("sudo dmidecode -s system-uuid");
            InputStream in;
            BufferedReader br;
            in = process.getInputStream();
            br = new BufferedReader(new InputStreamReader(in));
            while (in.read() != -1) {
                result = br.readLine();
            }
            br.close();
            in.close();
            process.destroy();
            // System.out.println("获取序列号:"+result);
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return result;
    }
    展开全文
  • (转)JAVA获得机器码的实现

    千次阅读 2014-02-10 14:19:42
    首先,定义了一个统一的接口,以支持不同操作系统不同实现的透明切换: ... *生成机器码的接口,不同平台有不同实现 * @author 杨尚川 */ public interface SequenceService { /** ...
    http://yangshangchuan.iteye.com/blog/2012401
    

    首先,定义了一个统一的接口,以支持不同操作系统不同实现的透明切换:

    Java代码 收藏代码
    /**
    *生成机器码的接口,不同平台有不同实现
    * @author 杨尚川
    */
    public interface SequenceService {
    /**
    * 获取机器码
    * @return 机器码
    */
    public String getSequence();
    }


    其次,定义了一个抽象类,实现了一些通用的功能,如生成MD5摘要、将很长的字符串以固定的位数分割开,以便于人类阅读(如将机器码 71F5DA7F495E7F706D47F3E63DC6349A 每4个一组,以-分割为71F5-DA7F-495E-7F70-6D47-F3E6-3DC6-349A)、利用sigar来生成机器码。这里需要在pom.xml中加入sigar依赖。

    Xml代码 收藏代码
    <dependency>
    <groupId>org.fusesource</groupId>
    <artifactId>sigar</artifactId>
    <version>1.6.4</version>
    <exclusions>
    <exclusion>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    </exclusion>
    </exclusions>
    </dependency>


    Java代码 收藏代码
    import org.apdplat.module.system.service.PropertyHolder;
    import org.apdplat.platform.log.APDPlatLogger;
    import org.apdplat.platform.util.ConvertUtils;
    import org.apdplat.platform.util.FileUtils;
    import java.io.File;
    import java.io.UnsupportedEncodingException;
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    import java.util.HashSet;
    import java.util.Properties;
    import java.util.Set;
    import org.apdplat.platform.log.APDPlatLoggerFactory;
    import org.hyperic.sigar.Mem;
    import org.hyperic.sigar.NetFlags;
    import org.hyperic.sigar.NetInterfaceConfig;
    import org.hyperic.sigar.Sigar;

    /**
    *机器码生成的通用服务
    * @author 杨尚川
    */
    public abstract class AbstractSequenceService implements SequenceService{
    protected final APDPlatLogger LOG = APDPlatLoggerFactory.getAPDPlatLogger(getClass());
    /**
    * 对一段String生成MD5摘要信息
    * @param message 要摘要的String
    * @return 生成的MD5摘要信息
    */
    protected String getMD5(String message) {
    message += "{apdplat}";
    try {
    MessageDigest md = MessageDigest.getInstance("MD5");
    LOG.debug("MD5摘要长度:" + md.getDigestLength());
    byte[] b = md.digest(message.getBytes("utf-8"));
    String md5 = ConvertUtils.byte2HexString(b)+message.length();
    return getSplitString(md5);
    } catch (NoSuchAlgorithmException | UnsupportedEncodingException e) {
    LOG.error("MD5摘要失败",e);
    }
    return null;
    }
    /**
    * 将很长的字符串以固定的位数分割开,以便于人类阅读
    * @param str
    * @return
    */
    protected String getSplitString(String str){
    return getSplitString(str, "-", 4);
    }
    /**
    * 将很长的字符串以固定的位数分割开,以便于人类阅读
    * 如将
    * 71F5DA7F495E7F706D47F3E63DC6349A
    * 以-,每4个一组,则分割为
    * 71F5-DA7F-495E-7F70-6D47-F3E6-3DC6-349A
    * @param str 字符串
    * @param split 分隔符
    * @param length 长度
    * @return
    */
    protected String getSplitString(String str, String split, int length){
    int len=str.length();
    StringBuilder temp=new StringBuilder();
    for(int i=0;i<len;i++){
    if(i%length==0 && i>0){
    temp.append(split);
    }
    temp.append(str.charAt(i));
    }
    String[] attrs=temp.toString().split(split);
    StringBuilder finalMachineCode=new StringBuilder();
    for(String attr : attrs){
    if(attr.length()==length){
    finalMachineCode.append(attr).append(split);
    }
    }
    String result=finalMachineCode.toString().substring(0, finalMachineCode.toString().length()-1);
    return result;
    }
    /**
    * 利用sigar来生成机器码,当然这个实现不是很好,无法获得CPU ID,希望有兴趣的朋友来改进这个实现
    * @param osName 操作系统类型
    * @return 机器码
    */
    protected String getSigarSequence(String osName) {
    try {
    File libFile = new File(FileUtils.getAbsolutePath("/WEB-INF/lib/"+PropertyHolder.getProperty("libsigar."+osName)));
    LOG.debug("libsigar."+osName+" : "+libFile.getAbsolutePath());

    System.load(libFile.getAbsolutePath());
    Set<String> result = new HashSet<>();
    Sigar sigar = new Sigar();
    String[] ifaces = sigar.getNetInterfaceList();
    for (String iface : ifaces) {
    NetInterfaceConfig cfg = sigar.getNetInterfaceConfig(iface); if (NetFlags.LOOPBACK_ADDRESS.equals(cfg.getAddress()) || (cfg.getFlags() & NetFlags.IFF_LOOPBACK) != 0
    || NetFlags.NULL_HWADDR.equals(cfg.getHwaddr())) {
    continue;
    }
    String mac = cfg.getHwaddr();
    result.add(mac);
    LOG.debug("mac: " + mac);
    }
    if(result.size()<1){
    return null;
    }
    Properties props = System.getProperties();
    String javaVersion = props.getProperty("java.version");
    result.add(javaVersion);
    LOG.debug("Java的运行环境版本: " + javaVersion);
    String javaVMVersion = props.getProperty("java.vm.version");
    result.add(javaVMVersion);
    LOG.debug("Java的虚拟机实现版本: " + props.getProperty("java.vm.version"));
    String osVersion = props.getProperty("os.version");
    result.add(osVersion);
    LOG.debug("操作系统的版本: " + props.getProperty("os.version"));

    Mem mem = sigar.getMem();
    // 内存总量
    String totalMem = mem.getTotal() / 1024L + "K av";
    LOG.debug("内存总量: " + totalMem);
    result.add(totalMem);

    LOG.debug("result: " + result);
    String machineCode = getMD5(result.toString());

    return machineCode;
    } catch (Throwable ex) {
    LOG.error("生成 "+osName+" 平台下的机器码失败", ex);
    }
    return null;
    }
    }


    最后,我们分别看看不同平台的实现。

    Windows:

    Java代码 收藏代码
    /**
    *在Windows平台上生成机器码
    * @author 杨尚川
    */
    public final class WindowsSequenceService extends AbstractSequenceService{
    @Override
    public String getSequence() {
    String cpuID=getCPUSerial();
    String hdID=getHDSerial("C");
    if(cpuID==null || hdID==null){
    return null;
    }
    String machineCode = getMD5(cpuID+hdID);

    return machineCode;
    }

    /**
    *
    * @param drive 硬盘驱动器分区 如C,D
    * @return 该分区的卷标
    */
    private String getHDSerial(String drive) {
    StringBuilder result = new StringBuilder();
    try {
    File file = File.createTempFile("tmp", ".vbs");
    file.deleteOnExit();
    try (FileWriter fw = new java.io.FileWriter(file)) {
    String vbs = "Set objFSO = CreateObject(\"Scripting.FileSystemObject\")\n"
    + "Set colDrives = objFSO.Drives\n" + "Set objDrive = colDrives.item(\"" + drive + "\")\n"
    + "Wscript.Echo objDrive.SerialNumber";
    fw.write(vbs);
    }
    Process p = Runtime.getRuntime().exec("cscript //NoLogo " + file.getPath());
    try (BufferedReader input = new BufferedReader(new InputStreamReader(p.getInputStream()))) {
    String line;
    while ((line = input.readLine()) != null) {
    result.append(line);
    }
    }
    file.delete();
    } catch (Throwable e) {
    LOG.error("生成HDSerial失败", e);
    }
    if (result.length() < 1) {
    LOG.info("无磁盘ID被读取");
    }

    return result.toString();
    }

    /**
    * 获取CPU号,多CPU时,只取第一个
    * @return
    */
    private String getCPUSerial() {
    StringBuilder result = new StringBuilder();
    try {
    File file = File.createTempFile("tmp", ".vbs");
    file.deleteOnExit();
    try (FileWriter fw = new FileWriter(file)) {
    String vbs = "On Error Resume Next \r\n\r\n" + "strComputer = \".\" \r\n"
    + "Set objWMIService = GetObject(\"winmgmts:\" _ \r\n"
    + " & \"{impersonationLevel=impersonate}!\\\\\" & strComputer & \"\\root\\cimv2\") \r\n"
    + "Set colItems = objWMIService.ExecQuery(\"Select * from Win32_Processor\") \r\n "
    + "For Each objItem in colItems\r\n " + " Wscript.Echo objItem.ProcessorId \r\n "
    + " exit for ' do the first cpu only! \r\n" + "Next ";

    fw.write(vbs);
    }
    Process p = Runtime.getRuntime().exec("cscript //NoLogo " + file.getPath());
    try (BufferedReader input = new BufferedReader(new InputStreamReader(p.getInputStream()))) {
    String line;
    while ((line = input.readLine()) != null) {
    result.append(line);
    }
    }
    file.delete();
    } catch (Throwable e) {
    LOG.error("生成CPUSerial失败", e);
    }
    if (result.length() < 1) {
    LOG.info("无CPU_ID被读取");
    }
    return result.toString();
    }

    public static void main(String[] args) {
    SequenceService s = new WindowsSequenceService();
    String seq = s.getSequence();
    System.out.println(seq);
    }
    }


    Linux:

    Java代码 收藏代码
    /**
    *在Linux平台上生成机器码
    * @author 杨尚川
    */
    public class LinuxSequenceService extends AbstractSequenceService{
    @Override
    public String getSequence() {
    return getSigarSequence("linux");
    }

    public static void main(String[] args) {
    SequenceService s = new LinuxSequenceService();
    String seq = s.getSequence();
    System.out.println(seq);
    }
    }


    Mac OS X:

    Java代码 收藏代码
    /**
    *在Mac OS X平台上生成机器码
    * @author 杨尚川
    */
    public class MacSequenceService extends AbstractSequenceService{
    @Override
    public String getSequence() {
    return getSigarSequence("mac");
    }

    public static void main(String[] args) {
    SequenceService s = new MacSequenceService();
    String seq = s.getSequence();
    System.out.println(seq);
    }
    }


    Solaris:

    Java代码 收藏代码
    /**
    *在Solaris平台上生成机器码
    * @author 杨尚川
    */
    public class SolarisSequenceService extends AbstractSequenceService{
    @Override
    public String getSequence() {
    return getSigarSequence("solaris");
    }

    public static void main(String[] args) {
    SequenceService s = new SolarisSequenceService();
    String seq = s.getSequence();
    System.out.println(seq);
    }
    }
    展开全文
  • java RSA加密生成license,用CPU序列号生成机器码 license里就是一些注册信息,键值对组成的字符串 对称加密: DES,AES,加密解密都用一个秘钥,速度快 非对称机密 RSA,可以私钥加密公钥解密,也可以公钥机密私钥...

    java RSA加密生成license,用CPU序列号生成机器码

    • license里就是一些注册信息,键值对组成的字符串

      对称加密:

      DES,AES,加密解密都用一个秘钥,速度快

      非对称机密

      RSA,可以私钥加密公钥解密,也可以公钥机密私钥解密,速度慢

      注意:
      RSA加密明文最大长度117字节,解密要求密文最大长度为128字节,所以在加密和解密的过程中需要分块进行。
      RSA加密对明文的长度是有限制的,如果加密数据过大会抛出异常:

    • 常见加密算法

    1. DES
      DES是Data Encryption Standard(数据加密标准)的缩写,DES算法为密码体制中的对称密码体制。它是由IBM公司研制的一种加密算法,美国国家标准局于1977年公布把它作为非机要部门使用的数据加密标准,二十年来,它一直活跃在国际保密通信的舞台上,扮演了十分重要的角色。
      DES是一个分组加密算法,他以64位为分组对数据加密。同时DES也是一个对称算法:加密和解密用的是同一个算法。它的密匙长度是56位(因为每个第8位都用作奇偶校验),密匙可以是任意的56位的数,而且可以任意时候改变。其中有极少量的数被认为是弱密匙,但是很容易避开他们。所以保密性依赖于密钥。
      特点:分组比较短、密钥太短、密码生命周期短、运算速度较慢。
        DES算法具有极高安全性,到目前为止,除了用穷举搜索法对DES算法进行攻击外,还没有发现更有效的办法。而56位长的密钥的穷举空间为256,这意味着如果一台计算机的速度是每一秒种检测一百万个密钥,则它搜索完全部密钥就需要将近2285年的时间。

      DES现在已经不视为一种安全的加密算法,因为它使用的56位秘钥过短,以现代计算能力,24小时内即可能被破解。也有一些分析报告提出了该算法的理论上的弱点,虽然实际情况未必出现。该标准在最近已经被高级加密标准(AES)所取代。

    2. AES
      高级加密标准(Advanced Encryption Standard,AES),又称Rijndael加密法,是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES,已经被多方分析且广为全世界所使用。经过五年的甄选流程,高级加密标准由美国国家标准与技术研究院(NIST)于2001年11月26日发布于FIPS PUB 197,并在2002年5月26日成为有效的标准。2006年,高级加密标准已然成为对称密钥加密中最流行的算法之一。

      AES的区块长度固定为128 位元,密钥长度则可以是128,192或256位元。

    3. RAS
      RSA加密算法是一种非对称加密算法。在公钥加密标准和电子商业中RSA被广泛使用。RSA是1977年由罗纳德·李维斯特(Ron Rivest)、阿迪·萨莫尔(Adi Shamir)和伦纳德·阿德曼(Leonard Adleman)一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。

      RSA算法的可靠性基于分解极大的整数是很困难的。假如有人找到一种很快的分解因子的算法的话,那么用RSA加密的信息的可靠性就肯定会极度下降。但找到这样的算法的可能性是非常小的。今天只有短的RSA钥匙才可能被强力方式解破。到2008年为止,世界上还没有任何可靠的攻击RSA算法的方式。只要其钥匙的长度足够长,用RSA加密的信息实际上是不能被解破的。

      RSA算法利用两个很大的质数相乘所产生的乘积来加密。这两个质数无论哪一个先与原文件编码相乘,对文件加密,均可由另一个质数再相乘来解密。但要用一个质数来求出另一个质数,则是十分困难的。因此将这一对质数称为密钥对(Key Pair)。在加密应用时,某个用户总是将一个密钥公开,让需发信的人员将信息用其公共密钥加密后发给该用户,而一旦信息加密后,只有用该用户一个人知道的私用密钥才能解密。具有数字凭证身份的人员的公共密钥可在网上查到,亦可在请对方发信息时主动将公共密钥传给对方,这样保证在Internet上传输信息的保密和安全。

      本文采用RSA加密算法加密license信息,可以运行RSATester.java生成公钥和私钥。
      RSAUtils.java

     * Created by User on 2019/5/23.
     */
    import java.io.ByteArrayOutputStream;
    import java.security.Key;
    import java.security.KeyFactory;
    import java.security.KeyPair;
    import java.security.KeyPairGenerator;
    import java.security.PrivateKey;
    import java.security.PublicKey;
    import java.security.Signature;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.HashMap;
    import java.util.Map;
    
    import javax.crypto.Cipher;
    
    /** *//**
     * <p>
     * RSA公钥/私钥/签名工具包
     * </p>
     * <p>
     * 罗纳德·李维斯特(Ron [R]ivest)、阿迪·萨莫尔(Adi [S]hamir)和伦纳德·阿德曼(Leonard [A]dleman)
     * </p>
     * <p>
     * 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式<br/>
     * 由于非对称加密速度极其缓慢,一般文件不使用它来加密而是使用对称加密,<br/>
     * 非对称加密算法可以用来对对称加密的密钥加密,这样保证密钥的安全也就保证了数据的安全
     * </p>
     *
     * @author IceWee
     * @date 2012-4-26
     * @version 1.0
     */
    public class RSAUtils {
    
        /** *//**
         * 加密算法RSA
         */
        public static final String KEY_ALGORITHM = "RSA";
    
        /** *//**
         * 签名算法
         */
        public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
    
        /** *//**
         * 获取公钥的key
         */
        private static final String PUBLIC_KEY = "RSAPublicKey";
    
        /** *//**
         * 获取私钥的key
         */
        private static final String PRIVATE_KEY = "RSAPrivateKey";
    
        /** *//**
         * RSA最大加密明文大小
         */
        private static final int MAX_ENCRYPT_BLOCK = 117;
    
        /** *//**
         * RSA最大解密密文大小
         */
        private static final int MAX_DECRYPT_BLOCK = 128;
    
        /** *//**
         * <p>
         * 生成密钥对(公钥和私钥)
         * </p>
         *
         * @return
         * @throws Exception
         */
        public static Map<String, Object> genKeyPair() throws Exception {
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
            keyPairGen.initialize(1024);
            KeyPair keyPair = keyPairGen.generateKeyPair();
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            Map<String, Object> keyMap = new HashMap<String, Object>(2);
            keyMap.put(PUBLIC_KEY, publicKey);
            keyMap.put(PRIVATE_KEY, privateKey);
            return keyMap;
        }
    
        /** *//**
         * <p>
         * 用私钥对信息生成数字签名
         * </p>
         *
         * @param data 已加密数据
         * @param privateKey 私钥(BASE64编码)
         *
         * @return
         * @throws Exception
         */
        public static String sign(byte[] data, String privateKey) throws Exception {
            byte[] keyBytes = Base64Utils.decode(privateKey);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            signature.initSign(privateK);
            signature.update(data);
            return Base64Utils.encode(signature.sign());
        }
    
        /** *//**
         * <p>
         * 校验数字签名
         * </p>
         *
         * @param data 已加密数据
         * @param publicKey 公钥(BASE64编码)
         * @param sign 数字签名
         *
         * @return
         * @throws Exception
         *
         */
        public static boolean verify(byte[] data, String publicKey, String sign)
                throws Exception {
            byte[] keyBytes = Base64Utils.decode(publicKey);
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            PublicKey publicK = keyFactory.generatePublic(keySpec);
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            signature.initVerify(publicK);
            signature.update(data);
            return signature.verify(Base64Utils.decode(sign));
        }
    
        /** *//**
         * <P>
         * 私钥解密
         * </p>
         *
         * @param encryptedData 已加密数据
         * @param privateKey 私钥(BASE64编码)
         * @return
         * @throws Exception
         */
        public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)
                throws Exception {
            byte[] keyBytes = Base64Utils.decode(privateKey);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, privateK);
            int inputLen = encryptedData.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段解密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                    cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_DECRYPT_BLOCK;
            }
            byte[] decryptedData = out.toByteArray();
            out.close();
            return decryptedData;
        }
    
        /** *//**
         * <p>
         * 公钥解密
         * </p>
         *
         * @param encryptedData 已加密数据
         * @param publicKey 公钥(BASE64编码)
         * @return
         * @throws Exception
         */
        public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)
                throws Exception {
            byte[] keyBytes = Base64Utils.decode(publicKey);
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key publicK = keyFactory.generatePublic(x509KeySpec);
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, publicK);
            int inputLen = encryptedData.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段解密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                    cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_DECRYPT_BLOCK;
            }
            byte[] decryptedData = out.toByteArray();
            out.close();
            return decryptedData;
        }
    
        /** *//**
         * <p>
         * 公钥加密
         * </p>
         *
         * @param data 源数据
         * @param publicKey 公钥(BASE64编码)
         * @return
         * @throws Exception
         */
        public static byte[] encryptByPublicKey(byte[] data, String publicKey)
                throws Exception {
            byte[] keyBytes = Base64Utils.decode(publicKey);
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key publicK = keyFactory.generatePublic(x509KeySpec);
            // 对数据加密
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, publicK);
            int inputLen = data.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段加密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                    cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(data, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_ENCRYPT_BLOCK;
            }
            byte[] encryptedData = out.toByteArray();
            out.close();
            return encryptedData;
        }
    
        /** *//**
         * <p>
         * 私钥加密
         * </p>
         *
         * @param data 源数据
         * @param privateKey 私钥(BASE64编码)
         * @return
         * @throws Exception
         */
        public static byte[] encryptByPrivateKey(byte[] data, String privateKey)
                throws Exception {
            byte[] keyBytes = Base64Utils.decode(privateKey);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, privateK);
            int inputLen = data.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段加密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                    cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(data, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_ENCRYPT_BLOCK;
            }
            byte[] encryptedData = out.toByteArray();
            out.close();
            return encryptedData;
        }
    
        /** *//**
         * <p>
         * 获取私钥
         * </p>
         *
         * @param keyMap 密钥对
         * @return
         * @throws Exception
         */
        public static String getPrivateKey(Map<String, Object> keyMap)
                throws Exception {
            Key key = (Key) keyMap.get(PRIVATE_KEY);
            return Base64Utils.encode(key.getEncoded());
        }
    
        /** *//**
         * <p>
         * 获取公钥
         * </p>
         *
         * @param keyMap 密钥对
         * @return
         * @throws Exception
         */
        public static String getPublicKey(Map<String, Object> keyMap)
                throws Exception {
            Key key = (Key) keyMap.get(PUBLIC_KEY);
            return Base64Utils.encode(key.getEncoded());
        }
    
    }
    

    Base64Utils.java

     * Created by User on 2019/5/23.
     */
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.InputStream;
    import java.io.OutputStream;
    
    //import it.sauronsoftware.base64.Base64;
    import sun.misc.BASE64Decoder;
    import sun.misc.BASE64Encoder;
    //若报错,编译路径移除jdk,再添加jdk
    
    /** *//**
     * <p>
     * BASE64编码解码工具包
     * </p>
     * <p>
     * 依赖javabase64-1.3.1.jar 或 common-codec
     * </p>
     *
     * @author IceWee
     * @date 2012-5-19
     * @version 1.0
     */
    public class Base64Utils {
    
        /** *//**
         * 文件读取缓冲区大小
         */
        private static final int CACHE_SIZE = 1024;
    
        /** *//**
         * <p>
         * BASE64字符串解码为二进制数据
         * </p>
         *
         * @param base64
         * @return
         * @throws Exception
         */
        public static byte[] decode(String base64) throws Exception {
            //return Base64.decode(base64.getBytes());
            return new BASE64Decoder().decodeBuffer(base64);
        }
    
        /** *//**
         * <p>
         * 二进制数据编码为BASE64字符串
         * </p>
         *
         * @param bytes
         * @return
         * @throws Exception
         */
        public static String encode(byte[] bytes) throws Exception {
            //return new String(Base64.encode(bytes));
            return new BASE64Encoder().encode(bytes);
        }
    
        /** *//**
         * <p>
         * 将文件编码为BASE64字符串
         * </p>
         * <p>
         * 大文件慎用,可能会导致内存溢出
         * </p>
         *
         * @param filePath 文件绝对路径
         * @return
         * @throws Exception
         */
        public static String encodeFile(String filePath) throws Exception {
            byte[] bytes = fileToByte(filePath);
            return encode(bytes);
        }
    
        /** *//**
         * <p>
         * BASE64字符串转回文件
         * </p>
         *
         * @param filePath 文件绝对路径
         * @param base64 编码字符串
         * @throws Exception
         */
        public static void decodeToFile(String filePath, String base64) throws Exception {
            byte[] bytes = decode(base64);
            byteArrayToFile(bytes, filePath);
        }
    
        /** *//**
         * <p>
         * 文件转换为二进制数组
         * </p>
         *
         * @param filePath 文件路径
         * @return
         * @throws Exception
         */
        public static byte[] fileToByte(String filePath) throws Exception {
            byte[] data = new byte[0];
            File file = new File(filePath);
            if (file.exists()) {
                FileInputStream in = new FileInputStream(file);
                ByteArrayOutputStream out = new ByteArrayOutputStream(2048);
                byte[] cache = new byte[CACHE_SIZE];
                int nRead = 0;
                while ((nRead = in.read(cache)) != -1) {
                    out.write(cache, 0, nRead);
                    out.flush();
                }
                out.close();
                in.close();
                data = out.toByteArray();
            }
            return data;
        }
    
        /** *//**
         * <p>
         * 二进制数据写文件
         * </p>
         *
         * @param bytes 二进制数据
         * @param filePath 文件生成目录
         */
        public static void byteArrayToFile(byte[] bytes, String filePath) throws Exception {
            InputStream in = new ByteArrayInputStream(bytes);
            File destFile = new File(filePath);
    //        if (!destFile.getParentFile().exists()) {
    //            destFile.getParentFile().mkdirs();
    //        }
            destFile.createNewFile();
            OutputStream out = new FileOutputStream(destFile);
            byte[] cache = new byte[CACHE_SIZE];
            int nRead = 0;
            while ((nRead = in.read(cache)) != -1) {
                out.write(cache, 0, nRead);
                out.flush();
            }
            out.close();
            in.close();
        }
    
    
    }
    

    RSATester.java

     * Created by User on 2019/5/23.
     */
    import java.util.Map;
    
    public class RSATester {
    
        static String publicKey;
        static String privateKey;
    
        static {
            try {
                Map<String, Object> keyMap = RSAUtils.genKeyPair();
                publicKey = RSAUtils.getPublicKey(keyMap);
                privateKey = RSAUtils.getPrivateKey(keyMap);
                System.err.println("公钥: \n\r" + publicKey);
                System.err.println("私钥: \n\r" + privateKey);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        public static void main(String[] args) throws Exception {
            test();
            testSign();
        }
    
        static void test() throws Exception {
            System.err.println("公钥加密——私钥解密");
            String source = "这是一行没有任何意义的文字,你看完了等于没看,不是吗?";
            System.out.println("\r加密前文字:\r\n" + source);
            byte[] data = source.getBytes();
            byte[] encodedData = RSAUtils.encryptByPublicKey(data, publicKey);
            System.out.println("加密后文字:\r\n" + new String(encodedData));
            byte[] decodedData = RSAUtils.decryptByPrivateKey(encodedData, privateKey);
            String target = new String(decodedData);
            System.out.println("解密后文字: \r\n" + target);
        }
    
        static void testSign() throws Exception {
            System.err.println("私钥加密——公钥解密");
            String source = "这是一行测试RSA数字签名的无意义文字";
            System.out.println("原文字:\r\n" + source);
            byte[] data = source.getBytes();
            byte[] encodedData = RSAUtils.encryptByPrivateKey(data, privateKey);
            System.out.println("加密后:\r\n" + new String(encodedData));
            byte[] decodedData = RSAUtils.decryptByPublicKey(encodedData, publicKey);
            String target = new String(decodedData);
            System.out.println("解密后: \r\n" + target);
            System.err.println("私钥签名——公钥验证签名");
            String sign = RSAUtils.sign(encodedData, privateKey);
            System.err.println("签名:\r" + sign);
            boolean status = RSAUtils.verify(encodedData, publicKey, sign);
            System.err.println("验证结果:\r" + status);
        }
    
    }
    

    运行此类生成license

    LicenseGenerator.java

     * Created by User on 2019/5/23.
     */
    import java.io.File;
    
    /**
     * 生成license
     * @author happyqing
     * 2014.6.15
     */
    public class LicenseGenerator {
    
        /**
         * serial:由客户提供
         * timeEnd:过期时间
         */
        private static String licensestatic = "serial=568b8fa5cdfd8a2623bda1d8ab7b7b34;" +
                "timeEnd=1404057600000";
    
        private static final String publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCaa8y9g+ioR2OSs8njT5uCGWm0YmOA1elSu/P5\n"
                + "D3XYPCHsUPab74V5Og+NEZeTk9/LtG+jPSpKekTWm67gS2lQYWoygTwnoWsr4woaqNXmWw7L8Ty0\n"
                + "LQFTojZgyynvu2RSIJp4c76z6SV/khiP/ireGtt8uzXPswPO5uaPU38tQQIDAQAB";
    
        /**
         * RSA算法
         * 公钥和私钥是一对,此处只用私钥加密
         */
        public static final String privateKey = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAJprzL2D6KhHY5KzyeNPm4IZabRi\n"
                + "Y4DV6VK78/kPddg8IexQ9pvvhXk6D40Rl5OT38u0b6M9Kkp6RNabruBLaVBhajKBPCehayvjChqo\n"
                + "1eZbDsvxPLQtAVOiNmDLKe+7ZFIgmnhzvrPpJX+SGI/+Kt4a23y7Nc+zA87m5o9Tfy1BAgMBAAEC\n"
                + "gYAVnlfohEoTHQN0q1TtTNzRhutEhK23gLsMiSGr0Z1G64w4QFF2HT9LbHR25GqbD426QAWNDegY\n"
                + "yytN/DesUQJqNXx8vuEuqs7+MQDgKgJqpAx+Fg3Iwsk/SVjq7meaSVGCgPKhtWHJk5oXoRMpsrlT\n"
                + "AwUjpdpAZXIIKW3mrqkW0QJBANq4INw6lZlqRFtxT4uzYQYtzmB/nxMnCbL2SQ4ZQ/4CWlQpOnR/\n"
                + "mH2JxIBCVtTADFlPM0DWF4aoqykYs9tu2X0CQQC0vgEk8DpkQbh1kgIyBGWCqYSKISTSXia0rbYo\n"
                + "FPnzdldgtZVirNGNmiJGL8RPz0YKpZNOg9FLHq/oYXSNFI4VAkAJ4OcbC0pWc4ZC2wtMs/1d2hPI\n"
                + "J/t3UfwOKTGDgYCgqFqMEpChUmIAyYgmgtiJI2NrZThbZVAKtPOGF6eH8anBAkAbxkL4wS3H8E1/\n"
                + "S7OoqgJLZO9oJpW4+hzqkPM4D5klb58Xzm+pXTNKllAEBx0cwpZZ1n3fh+Qmrg2MIUW+1FTNAkBt\n"
                + "WECowLUqW014M96WsFpiof7kjteOBNOjFyxhIbx2eT7//bnrADfq2Xu1/mSedUKrjGr/O+FRi7PO\n"
                + "u7WhF6C9";
    
        public static void generator() throws Exception {
            System.err.println("私钥加密——公钥解密");
            //String source = "568b8fa5cdfd8a2623bda1d8ab7b7b34";
            System.out.println("原文字:\r\n" + licensestatic);
            byte[] data = licensestatic.getBytes();
            byte[] encodedData = RSAUtils.encryptByPrivateKey(data, privateKey);
            System.out.println("加密后:\r\n" + new String(encodedData)); //加密后乱码是正常的
    
            Base64Utils.byteArrayToFile(encodedData, FileUtil.getBasePath()+File.separator+"license.dat");
            System.out.println("license.dat:\r\n" + FileUtil.getBasePath()+File.separator+"license.dat");
    
            //解密
            byte[] decodedData = RSAUtils.decryptByPublicKey(encodedData, publicKey);
            String target = new String(decodedData);
            System.out.println("解密后: \r\n" + target);
        }
    
        public static void main(String[] args) throws Exception {
            generator();
        }
    }
    

    这里把解密逻辑也放这里了,实际上,公钥和解密逻辑应该放在软件运行的地方。

    FileUtil.java

     * Created by User on 2019/5/23.
     */
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.UnsupportedEncodingException;
    import java.net.URLDecoder;
    import java.util.logging.Level;
    import java.util.logging.Logger;
    
    /**
     * 文件工具类
     * @author happyqing
     */
    public class FileUtil {
    
        /**
         * 获得类的基路径,打成jar包也可以正确获得路径
         * @return
         */
        public static String getBasePath(){
            /*
            /D:/zhao/Documents/NetBeansProjects/docCompare/build/classes/
            /D:/zhao/Documents/NetBeansProjects/docCompare/dist/bundles/docCompare/app/docCompare.jar
            */
            String filePath = FileUtil.class.getProtectionDomain().getCodeSource().getLocation().getFile();
    
    
            if (filePath.endsWith(".jar")){
                filePath = filePath.substring(0, filePath.lastIndexOf("/"));
                try {
                    filePath = URLDecoder.decode(filePath, "UTF-8"); //解决路径中有空格%20的问题
                } catch (UnsupportedEncodingException ex) {
    
                }
    
            }
            File file = new File(filePath);
            filePath = file.getAbsolutePath();
            return filePath;
        }
    
        public static void main(String[] args) throws Exception {
            System.out.println(getBasePath());
        }
    }
    

    serial是软件运行的地方提供的,

    纯java获取CPU序列号,生成机器码

    http://happyqing.iteye.com/blog/2080402

    参考

    http://www.blogjava.net/icewee/archive/2012/05/19/378570.html

    一个简单的RSA加密类

    http://yuncode.net/code/c_5049f78253ad762

    RSAEncrypt.java

     * Created by User on 2019/5/23.
     */
    import java.security.KeyPair;
    import java.security.KeyPairGenerator;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import javax.crypto.Cipher;
    
    /**
     * RSA加密类
     */
    public class RSAEncrypt {
        public static void main(String[] args) {
            try {
                RSAEncrypt encrypt = new RSAEncrypt();
                String encryptText = "12345678";
                KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
                keyPairGen.initialize(1024);
                KeyPair keyPair = keyPairGen.generateKeyPair();
    
                // Generate keys
                RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate(); // 私钥
                RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic(); // 公钥
                byte[] e = encrypt.encrypt(publicKey, encryptText.getBytes());
                byte[] de = encrypt.decrypt(privateKey, e);
                System.out.println(encrypt.bytesToString(e));
                System.out.println();
                System.out.println(encrypt.bytesToString(de));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * byte数组转为string
         * @param encrytpByte
         * @return
         */
        protected String bytesToString(byte[] encrytpByte) {
            String result = "";
            for (Byte bytes : encrytpByte) {
                result += (char) bytes.intValue();
            }
            return result;
        }
    
        /**
         * 加密方法
         * @param publicKey
         * @param obj
         * @return
         */
        protected byte[] encrypt(RSAPublicKey publicKey, byte[] obj) {
            if (publicKey != null) {
                try {
                    Cipher cipher = Cipher.getInstance("RSA");
                    cipher.init(Cipher.ENCRYPT_MODE, publicKey);
                    return cipher.doFinal(obj);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return null;
        }
    
        /**
         * 解密方法
         * @param privateKey
         * @param obj
         * @return
         */
        protected byte[] decrypt(RSAPrivateKey privateKey, byte[] obj) {
            if (privateKey != null) {
                try {
                    Cipher cipher = Cipher.getInstance("RSA");
                    cipher.init(Cipher.DECRYPT_MODE, privateKey);
                    return cipher.doFinal(obj);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return null;
        }
    }
    

    说明:

    公钥私钥要自己生成,别拷别人的

    展开全文
  • java获取CPU序列号,生成机器码

    千次阅读 2019-01-18 14:17:32
    java获取CPU序列号,生成机器码
  • java获取mac和机器码,注册码的实现

    万次阅读 2014-11-25 17:01:32
    * java获取mac和机器码,注册码的实现 * */ public class AuthorizationUtils { private static final int SPLITLENGTH = 4; private static final String SALT = "yunshouhu"; public static void main...
  • JAVA通过JNI获取机器码

    2010-10-25 23:02:44
    谁能提供一下获取机器码(CPU序列号,MAC地址,硬盘序列号)的DLL动态链接库啊!谢谢 邮箱:291144929@qq.com
  • 使用前端编译期(javac、eclipse)将.java源代码编译成.class字节码文件,运行时JVM加载.class字节码文件交给解释器解释成相应平台的机器码执行 早期的JVM就是以这种方式运行java程序,由解释器一行行的将字节码解释...
  • 在很久很久以前(几十年),软件就是直接开发在硬件设备上的,用纸带有无孔标识二进制位,此时的开发语言是机器码,软件直接对接硬件设备;后来很不方便,尤其不方便复用,然后,有了汇编,有了简单的编译环境,然后...
  • 运行时把Class文件字节码编译成本地机器码 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 在《Java三种编译方式:前端编译 JIT编译 AOT编译》中了解到了它们各有什么优点和缺点,以及...
  • (1)软件生成一个机器码,交给开发者,开发者提供一个注册码。 (2)把用户名交给开发者,开发者提供一个注册码。 (3)直接向开发者索取一个注册码。 在算法上,这几种情况并无太大区别。如果我们有一个原始的...
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    原理是什么Java语言有哪些特点什么是字节?采用字节的最大好处是什么什么是Java程序的主类?应用程序和小程序的主类有何不同?Java应用程序与小程序之间有那些差别?Java和C++的区别Oracle JDK 和 OpenJDK 的...
  • 如果Java直接编译成机器码,这样岂不解决了Java运行缓慢的问题,进而淘汰或者取代C语言。(这里,不是说就此取消Java的JVM解释型运行的机制,我的意思这两种方式并存。)衍生问题:C语言为什么不设计一个C语言虚拟机...
  • java程序编写获取枪扫程序,并将扫枪扫有数据库MySQL数据进行对比预警,解决相关行业使用扫枪进行出货重复使用相关商品问题。该程序连接MySQL数据库,可同时部署到多台机器上进行设备比对。底层也实现...
  • public class SerialNumberUtil { private static String SerialNumber; /** * 获取主板序列号 * * @return */ public static String getMotherboardSN() { String result = ...
  • 做应用时很多时候都得获取到每个设备的机器码 Secure.getString(getContext().getContentResolver(), Secure.ANDROID_ID) 复制代码 或者 所有的设备都可以返回一个TelephonyManager.getDeviceId()所有的...
  • 下面详细了解JIT编译;从官方JDK中的HotSpot虚拟机的JIT编译器入手,先介绍解释器与JIT编译器是如何配合工作的,认识JIT编译器C1/C2;再看看JIT编译的是什么,以及触发条件是什么;...最后对比Java与C/C++的编译器。
  • 目录class字节示例字节整体结构魔数(Magic Number)版本(Version)常量池(Constant Pool)例如总结Mytest1常量池对应的内容访问标志(Access Flags)当前Class名(This Class Name )父类名(super Class)...
  • 跟随本篇文章深入研究JVM内部结构和java字节,你将会知道如何分解你的文件进行深入检查。 对于一个经验丰富的开发人员阅读java字节也是非常枯燥的事情。首先我们要弄清楚我们为什么需要知道如此底层的东西?...
  • 得到机器的MAC,硬盘序列序列号和IP地址 public static void main(String[] args) ...{ String osName = System.getProperty("os.name"); StringBuffer systemPathBuff = new StringBuffer(""); if (osName.index...
  • Java获取本地机器MAC地址

    千次阅读 2016-07-22 11:56:18
    import java.net.NetworkInterface; import java.net.SocketException; import java.util.Enumeration; /** ... * 获取客户端MAC地址 * * */ public class MacAddress { public static Strin
  • 我们把C代码编译成java字节,这样我们的C语言便具备了可跨品台属性。通过把C语言编译成java字节,我们不但能够继续学习和掌握编译原理相关的算法技术,于此同时,还能深入理解java虚拟机的基本原理,此乃...
  • 文章目录前言从AOP说起静态代理动态代理JavaProxyCGLIB字节增强实现AOPASMJavaAssist运行时类加载Instrumentation接口JavaAgentPremainClass随JVM进程启动AgentClass以Attach方法注入Agent总结 前言 在上篇文章...
  • Snowflake ID组成结构:正数位(占1比特)+ 时间戳(占41比特)+ 机器ID(占5比特)+ 数据中心(占5比特)+ 自增值(占12比特),总共64比特组成的一个Long类型。 其实我们通过图片可以看出来,我们如果保证单机唯一...
  • java.utils.UUID获取唯一识别

    千次阅读 2019-05-23 14:28:22
    UUID (Universally Unique Identifier)缩写,即通用唯一识别,也是被开源软件基金会 (Open Software Foundation, OSF)的组织应用在分布式计算环境 (Distributed Computing Environment, DCE) 领域的一部分。...
  • JAVA获取硬件唯一标识,CPU+MAC

    千次阅读 2020-08-17 10:47:47
    初衷 结合上一篇博文,我需要拿到一台主机的唯一标识,并且这个标识是不可修改的,经查阅发现...毕竟是Java代码,要考虑多个平台的问题,而且linux和windows系统的命令又不同,所以分出处理。不多说,直接上代码: /**
  • 获取机器识别

    千次阅读 2016-12-08 15:31:37
    systeminfo.deviceuniqueidentifier()

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 127,921
精华内容 51,168
关键字:

java机器码获取

java 订阅