标签: public-key-encryption

我想使用 RSA 来保护应用程序中的许可证文件。想法如下：

1. 创建许可证文件（纯文本）。
2. 创建 RSA 密钥对。
3. 使用公钥对许可证文件进行加密。
4. 将私钥放入应用程序的二进制文件中。
5. 然后应用程序可以解码许可证文件并开始运行。

问题是我必须将私钥与我的应用程序一起发送。如果我对公钥保密会有问题吗？

如果没有，还有哪些其他好的（足够的）方案来创建许可证文件系统？

在 TLS hanshake 消息中，客户端向服务器发送预主密钥。

双方生成一个主密钥并使用它来导出 TLS 的会话密钥。我的问题是为什么他们不只是将主密钥作为用于加密通信的对称密钥？为什么他们需要从中导出主密钥？

谢谢，

根据这里：

数字证书包含：

• 序列号：用于唯一标识证书。

• 主题：被识别的人或实体。

• 签名算法：用于创建签名的算法。

• 签名：验证它来自发行人的实际签名。

• 颁发者：验证信息并颁发证书的实体。

• Valid-From：证书第一次生效的日期。

• Valid-To：到期日期。

• Key-Usage：公钥的用途（例如加密、签名、证书签名...）。

• 公钥：公钥。

• 指纹算法：用于散列公钥证书的算法。

• 指纹（也称为指纹）：哈希本身，用作公钥证书的缩写形式。

我的问题是，签名是怎么来的？我认为它用于确保数字证书由受信任的颁发者颁发。所以发行者使用其私钥对某物进行签名以产生签名，那么证书的验证者必须具有发行者的相应公钥来解密签名并验证该东西是真实的。

如果我是对的，那么这个东西也必须存储在证书中，以便验证者将解密的签名与之进行比较。那这是什么东西？它可能是公钥的指纹（哈希）吗？

libsodium 提供了一个 API 来创建或打开这里记录的密封盒https://download.libsodium.org/doc/public-key_cryptography/sealed_boxes.html

如何在纯 Java 中实现相同的功能，以便我可以打开一个由 libsodium 创建的盒子或创建一个 libsodium 可以打开的盒子？

我一直在尝试将下面的 java 代码转换为其等效的 python 代码：

加密.java

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PublicKey;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Arrays;
import org.apache.commons.codec.binary.Base64;
//import org.jose4j.base64url.Base64;

public class Encrypt {

    public static void main(String[] args)
            throws InvalidKeySpecException, NoSuchAlgorithmException, UnsupportedEncodingException, CertificateException, FileNotFoundException {
        PublicKey pubKey; 
        Object localObject1 = new
         String("MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA76y3+1w4Ld9Q4WvHQkCkg6qjwq2wWOYMV9nAthX6ugatNlShRb2gBmy"
         +
         "qvh7tOYHhjAhkG9Z33jCVinPuhgb0ioa5/sFAgP5LDdo5SBk4b4n/wRUbdMhfFFcTT0As2OsmdBc2iONUaG4g3WjgRODxy6LLahms6YgTnG+AqeDo8LpXxsiFXe"
         +
         "iqGUyKQU1l16BPc2xyG+tDitFbKHx9pDL12e/w5b4G4Zg4yJgbNlZrGc3Udz5EbDREnAwirjAA3F6x2DF3j746vETb1g2y6+P5sS4lvG3XmaB1JBlhNh5qpqADRqmE"
         + "MWeiYhrRcK9KjS1URSUizGPo96d8R82DmXvYKQIDAQAB");

         //localObject1 = new X509EncodedKeySpec(Base64.decode(((String)localObject1).getBytes("utf-8")));
         localObject1 = new X509EncodedKeySpec(Base64.decodeBase64(((String)localObject1).getBytes("utf-8")));
         localObject1 …

我有 publicKey.key，我想将其导入 rsa 加密

这是我的代码：

using (RSA rsa = RSA.Create())
{
    var key = Encoding.UTF8.GetBytes("012345678901234567890");

    byte[] publicKey = File.ReadAllBytes("text/publicKey.key");

    var result = rsa.Encrypt(key, RSAEncryptionPadding.Pkcs1);
}

我最近在我的计算机科学课程中学习了公钥/私钥加密，以及它在数据加密/解密方面的工作原理。我们还介绍了如何将其用于数字签名。但是，我们没有详细介绍实际密钥是如何自己生成的。

我知道它以一个非常大的数字开头，然后通过某种密钥生成算法传递，该算法返回两个不同的密钥，其中一个是私有的，另一个是公共的。这些算法是已知的还是黑盒系统？一个用户是否总是拥有与他们相关联的同一对密钥，或者他们是否曾在任何时候发生变化？

这似乎是一个非常数学的问题，因为键是相互关联的，但不能从另一个推导出来。

因此，我需要使用 ECC spec256k1 从相应的 256 位数字中获取公钥。

因此，假设我从任何密码短语中使用 sha256 获取私钥，如下所示：

>>> import hashlib
>>> private_key = hashlib.sha3_256(b"Led Zeppelin - No Quarter").hexdigest()
>>> private_key
'c0b279f18074de51d075b152c8ce78b7bddb284e8cfde19896162abec0a0acce'

如何从该私钥获取公钥？我需要将公钥打印为字符串。

import 'package:encrypt/encrypt.dart';
import 'package:encrypt/encrypt_io.dart';
import 'dart:io';
import 'package:pointycastle/asymmetric/api.dart';
import 'dart:async';
import 'package:flutter/services.dart' show rootBundle;

class Encrypt {
  Future<String> loadPrivateKey() async {
    return await rootBundle.loadString('assets/private_key.pem');
  }

  Future<String> loadPublicKey() async {
    return await rootBundle.loadString('assets/public_key.pem');
  }

  encryptString() async {
    print(loadPublicKey().toString());
    final publicKey =
        await parseKeyFromFile<RSAPublicKey>('${loadPublicKey()}');
    final privateKey =
        await parseKeyFromFile<RSAPrivateKey>('${loadPrivateKey()}');

    final plainText = 'James Bond';
    final encrypter =
        Encrypter(RSA(publicKey: publicKey, privateKey: privateKey));

    final encrypted = encrypter.encrypt(plainText);
    final decrypted = encrypter.decrypt(encrypted);

    print(decrypted);
    print(encrypted.base64);
  }
}

错误：正在执行热重载...正在将文件同步到 IA 模拟器上的设备 AOSP...在 1,021 毫秒内重新加载了 707 个库中的 8 …

我有这个用于加密和解密的java代码，我想将其更改/转换为Ruby代码。我在 OpenSSL gem 中查找，但没有找到可用于 ruby​​ 的“RSA/ECB/OAEPWithSHA-256AndMGF1Padding”组合。我该如何实施？

public class EncryptDecryptService {
    
    public String encryptRequestObject(RequestObject requestObject) throws UnsupportedEncodingException, FileNotFoundException, CertificateException, InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
        PublicKey publicKey = getPublicKey(requestObject.getKeyFilename());
        byte[] message = requestObject.getString().getBytes("UTF-8");
        byte[] secret = encrypt(publicKey, message);
        return Base64.encodeBase64String(secret);
    }
    
    public String decryptRequestObject(RequestObject requestObject) throws UnrecoverableKeyException, KeyStoreException, NoSuchAlgorithmException, CertificateException, IOException, InvalidKeyException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
        PrivateKey privateKey = getPrivateKey(requestObject.getKeyFilename(), requestObject.getKeyPassword());
        byte[] cipherText = Base64.decodeBase64(requestObject.getString());
        byte[] decrypted = decrypt(privateKey, cipherText);
        return new String(decrypted, "UTF-8");
    }
    
    private PublicKey getPublicKey(String filename) throws FileNotFoundException, …