标签: sha256

我需要使用 SAML 2.0 标准化算法 (RSAwithSHA256) 对 XML SAML 消息进行签名。但我的 saml 插件（passport-saml）似乎只支持 sha1 和 sha256。SHA256 听起来与 RSAwithSHA256 非常接近，但可能不是同一件事？有什么区别，如何使用 RSAwithSHA256 代替？我可能需要编辑 Passport-saml 库，以允许使用 RSAwithSHA256 算法？

对于 CRC32，可以组合两个哈希，这样给定两个流 A 和 B，我们只需知道 CRC(A)、CRC(B) 和 length(B) 就可以找到 CRC(A+B)。（此处提供了实现，以及 Mark Adler对其工作原理的解释）。

例如，这使我们能够并行计算单个流上的哈希值，或者仅在其包含介质上使用前向查找来计算大型（如“不适合内存”） 、严重碎片化的流上的哈希值（这为非常慢的媒体提供了巨大的加速潜力）。

似乎没有可用于其他更复杂的哈希算法（例如 MD5）的此类行为的实现。MD5 根本不可能实现这种行为吗？难道这件事太难做到了，以至于没有人愿意去尝试吗？更复杂的算法（例如 SHA1 或 SHA256）怎么样？我很想听听对此的任何见解。

我正在开发一个 Solidity 项目，其中我将字符串编码为 SHA256 哈希值，现在我想解码 SHA256 哈希值并检索实际数据。请帮助锄头做这件事。

下面是我用来散列字符串的代码。

pragma solidity ^0.4.26;

contract TestShaAlgo {
  function getSha256(string str) public view returns (bytes32) {
  bytes32 hash = sha256(abi.encodePacked(str));
  return hash;
  }
}

我编写了一个方法，将 JWT 作为请求并检查签名是否有效。

这是单元测试：

@Test
public void isValid() {
    final JwtValidator jwtValidator = JwtValidator.getInstance();
    final boolean valid = jwtValidator.isValid("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c");
    Assert.isTrue(valid);
}

这是代码：

@SneakyThrows
public boolean isValid(String extractedToken) {
    final String[] tokenParts = extractedToken.split(Pattern.quote("."));
    String header = tokenParts[0];
    String payload = tokenParts[1];
    String signature = tokenParts[2];

    final byte[] calcHmacSha256 = HMAC.calcHmacSha256("your-256-bit-secret".getBytes(), (header+"."+payload).getBytes());

    final String s = Base64.getEncoder().encodeToString(calcHmacSha256);

    System.out.println("'" + signature + "'.equals('"+s+"')");
    return signature.equals(s);
}

日志打印两个字符串，仅相差 2 个字符，所以我觉得我已经接近“但不完全”使其工作：

'SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c'.equals('SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV/adQssw5c=')

当然存在硬编码值，因为实现尚未完成，但我现在使用https://jwt.io/中的示例值以便于使用。

谢谢！

编辑1：

public class JwtValidatorTest {

    @Test
    public void …

在BlackBerry应用程序中,我使用此代码以从密码获取哈希:

        SHA256Digest sha256d = new SHA256Digest();
        byte[] passwordData = null;

        try {
            passwordData = password.getBytes("UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        DigestOutputStream outputStream = new DigestOutputStream(sha256d, null);
        try {
            outputStream.write(passwordData);
        } catch (IOException e) {
            e.printStackTrace();
        }

        byte[] hashedValue = sha256d.getDigest();
        tempSHA256Password = new String(hashedValue);
        System.out.println(tempSHA256Password);

在这个代码块的末尾,tempSHA256Password它将是这样的东西:ëÇ#ÎiGê8óq =ßÝ÷<rê¨_FR»ã...所以绝不是我所期待的.我期待一个看起来像这样的字符串:ebc723ce6947ea38f371a03d0cdfddf73c840f7215eaa85f031446529bbb16e3

我究竟做错了什么？

我正在使用crypto ++库进行一些练习.我期待与从shell调用的sha256sum工具相同的输出.

// typedef unsigned char byte;
byte out[CryptoPP::SHA256::DIGESTSIZE];
byte in=65;  // 'A'
CryptoPP::SHA256().CalculateDigest(out, &in, 1);
for(int i=0; i < CryptoPP::SHA256::DIGESTSIZE; i++)
    std::cout << std::hex << (int)out[i];
std::cout << std::endl;

559aead08264d5795d399718cdd5abd49572e84fe55590eef31a88a08fdffd

$ echo A | sha256sum

06f961b802bc46ee168555f066d28f4f0e9afdf3f88174c1ee6f9de004fc30a0

为什么两者不相等？

我有一个对象集合,我希望从这个对象集合中生成一个哈希值(使用SHA256).

这些散列这些对象的过程是零知识证明系统的一部分,其中证明者生成证明,该证明稍后由验证者验证.这个证明实际上是哈希函数的输出.

这些对象都包含3或4个大的BigInteger值(大小为2048位).对象的数量是可变的,但它将在4到10之间.

我编写了以下方法,用于从可变数量的对象生成哈希值:

public byte[] buildHashFromHashcodes(final Object... listOfObjects) {

    for (Object obj : listOfObjects) {

        if (obj == null) {
            throw new Exception(
                "Input objects cannot be null");
        }

        _md.update(intToBytes(obj.hashCode()));
    }

    return _md.digest();
}

private byte[] intToBytes(final int intValue) {
    return new byte[] {(byte) (intValue >> 24),
            (byte) (intValue >> 16), (byte) (intValue >> 8),
            (byte) intValue };
}

我的问题与在此代码中使用hashCode方法有关.具体来说,我试图确定hashCode方法的使用是否会削弱系统的安全性,因为它只生成一个32位数,因此只在每次迭代期间使用32位信息更新散列.因此,我不确定此过程中此信息的丢失是否真的会削弱系统.

这些对象的hashCode方法的实现使用大的BigInteger值来生成它们的哈希码,但是在返回之前该数字被截断为int.

我担心的部分原因是,某些对象的哈希码之间可能存在冲突.但话说回来,哈希在循环内部被多次更新,因此单个冲突不会是一个大问题.

让我们假设对象集合中有4个对象.在循环的第一次迭代中,将使用32位来更新散列,在第二次迭代中,将使用另外32位来更新散列,等等.

据我所知,在调用update方法之后执行散列算法.不是128位(4个对象)将存储在缓冲区中,然后使用这128位作为输入执行散列算法.

因此,我们可以说在最终更新之后哈希所处的状态总数将是(2 ^ 32)*(2 ^ 32)*(2 ^ 32)*(2 ^ 32)？(在实践中,这当然不会发生,因为它会在某些时候被截断).

我相信使用hashCode是一种安全的方法,因为在每次迭代期间都会调用update方法.

为了避免对象之间发生冲突的风险,另一种方法是使用每个对象的toString()方法,该方法返回一个包含每个对象的全部熵的String(大BigInteger数字的值包含在字符串).这意味着在循环的每次迭代期间使用更多信息更新散列,但我不确定是否有必要.

所以,我的问题是,在这段代码中使用hashCode方法会削弱系统的强度吗？

我创建了一个注册表格,处理如下:

function register_user() {
   global $conn;
   $name      = sanitize($_POST['name']);
   $email     = sanitize($_POST['email']);
   $password = sanitize($_POST['password']);
   $salt      = bin2hex(mcrypt_create_iv(32, MCRYPT_DEV_URANDOM));

   $saltedPW = $password . $salt;
   $hashedPW = hash('sha256', $saltedPW);

   mysqli_query($conn, "INSERT INTO users (name, email, password, salt) VALUES ('$name', '$email', '$hashedPW', '$salt')");

然后按如下方式处理登录表单:

    function login($email, $password) {
    global $conn;
    $user_id = user_id_from_username($email);
    $query   = mysqli_query($conn, "SELECT salt FROM users WHERE email = '$email'");
    $row1    = mysqli_fetch_assoc($query);
    $salt    = $row1['salt'];

    $saltedPW = $password . $salt;
    $hashedPW = hash('sha256', $saltedPW);

    $result = mysqli_query($conn, …

我正在用Java浏览Java中的密码Hashing.

password = Hashing
        .sha256()
        .hashString(input, StandardCharsets.UTF_8)
        .toString();

当我将任何文本传递给该行时,它会散列并以小写字符输出所有内容,例如,如果我传递"foo",则值password变为:

2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae

但是,如果我使用此站点来散列"foo",它输出的值是

2C26B46B68FFC68FF99B453C1D30413413422D706483BFA0F98A5E886266E7AE

据我所知,这只是完全相同的密码,除了大写字母而不是小写字母.

导致那些输出不同值的原因是什么,以及如何使用大写字母输出番石榴(不需要调用toUpperCase,除非这是唯一的方法)

我有一个文件的md5和sha256哈希,我想从哈希值计算文件的大小.

有没有办法让我们可以获得该文件的md5或sha256哈希文件的大小？